The GET command.
167208
def do_GET(self):
        '''
	'''
        if self.path.lower().endswith("?wsdl"):
            service_path = self.path[:-5]
            service = self.server.getNode(service_path)
            if hasattr(service, "_wsdl"):
                wsdl = service._wsdl
                # update the soap:location tag in the wsdl to the actual server
                #   location
                # - default to 'http' as protocol, or use server-specified protocol
                proto = 'http'
                if hasattr(self.server,'proto'):
                    proto = self.server.proto
                serviceUrl = '%s://%s:%d%s' % (proto,
                                                self.server.server_name,
                                                self.server.server_port,
                                                service_path)
                soapAddress = '<soap:address location="%s"/>' % serviceUrl
                wsdlre = re.compile('\<soap:address[^\>]*>',re.IGNORECASE)
                wsdl = re.sub(wsdlre,soapAddress,wsdl)
                self.send_xml(wsdl)
            else:
                self.send_error(404, "WSDL not available for that service [%s]." % self.path)
        else:
            self.send_error(404, "Service not found [%s]." % self.path)
1137928
def get_command(self, version=2):
        """"""
        try:
            options = _C['options']
            options_str = " -o ".join(options)
            if options_str:
                options_str = "-o " + options_str + " "
        except KeyError:
            options_str = ""

        if self.username:
            # Not supported on SunOS
            # "-o ConnectTimeout={}
            command = "ssh {}" \
                      "-{} " \
                      "-p {} {}@{}".format(options_str, version, self.port, self.username, self.hostname)
        else:
            command = "ssh {} " \
                      "-{} " \
                      "-p {} {}".format(options_str, version, self.port, self.hostname)
        return command
72124
def get(self, *args, **kwargs):
        """"""
        if 'convert' in kwargs:
            conversion = kwargs.pop('convert')
        else:
            conversion = True
        kwargs = self._get_keywords(**kwargs)
        url = self._create_path(*args)
        request = self.session.get(url, params=kwargs)
        content = request.content
        self._request = request
        return self.convert(content, conversion)
12397
def command(cmd):
    """"""
    message = create(protobuf.SEND_COMMAND_MESSAGE)
    send_command = message.inner()
    send_command.command = cmd
    return message
356294
def get(self, key, **kwargs):
        '''
        
        '''
        return self._get('/'.join([self._endpoint, key]), payload=kwargs)
1008354
def hmget(key, *fields, **options):
    '''
    
    '''
    host = options.get('host', None)
    port = options.get('port', None)
    database = options.get('db', None)
    password = options.get('password', None)
    server = _connect(host, port, database, password)
    return server.hmget(key, *fields)
596757
def get_direct_command(self, command_url):
        """"""
        self.logger.info("get_direct_command: %s", command_url)
        req = requests.get(command_url, timeout=self.timeout,
                           auth=requests.auth.HTTPBasicAuth(self.username,
                                                            self.password))
        self.http_code = req.status_code
        req.raise_for_status()
        return req
426247
def get(self, uri, query=None, **kwargs):
        """"""
        return self.fetch('get', uri, query, **kwargs)
866
def fetch_command(self, subcommand):
        
        # Get commands outside of try block to prevent swallowing exceptions
        commands = get_commands()
        try:
            app_name = commands[subcommand]
        except KeyError:
            # This might trigger ImproperlyConfigured (masked in get_commands)
            settings.INSTALLED_APPS
            sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" %
                (subcommand, self.prog_name))
            sys.exit(1)
        if isinstance(app_name, BaseCommand):
            # If the command is already loaded, use it directly.
            klass = app_name
        else:
            klass = load_command_class(app_name, subcommand)
        return klass
830560
def get_command(self, mode, txt=''):
        
        if mode == 'COMMAND':
            self.prompt = '> '
        elif mode == 'ADD':
            self.prompt = 'ADD > '
        elif mode == 'QUERY':
            self.prompt = '?? > '
        if txt == '':
            txt = input(self.prompt)
        return txt
220884
def get(self, key, recursive=False, sorted=False, quorum=False,
            timeout=None):
        """"""
        return self.adapter.get(key, recursive=recursive, sorted=sorted,
                                quorum=quorum, timeout=timeout)
866645
function get(command) {
        var commandID;
        if (!command) {
            console.error("Attempting to get a Sort method with a missing required parameter: command");
            return;
        }

        if (typeof command === "string") {
            commandID = command;
        } else {
            commandID = command.getID();
        }
        return _sorts[commandID];
    }
969838
def get(self, name, default=None):
        """"""
        value = self.params.get(name, default)
        if isinstance(value, str):
            value = os.path.expandvars(value)
        return value
1049245
def get(self, timeout=None):
        """"""
        if timeout:
            # Todo: Consider locking the poll/recv block.
            # Otherwise, this method is not thread safe.
            if self._conn1.poll(timeout):
                return (True, self._conn1.recv())
            else:
                return (False, None)
        return self._conn1.recv()
943439
def help(self, command=None):
        
        cmd = 'help'
        if command: cmd += ' %s' % command
        return self.fetch(cmd)[1]
151090
def get(self, key, failobj=None, exact=0):

        """"""

        if not exact:
            try:
                key = self.getfullkey(key)
            except KeyError:
                return failobj
        return self.data.get(key,failobj)
304891
def get(self, params=None):
        
        return self._call('get', url=self.endpoint, params=params)