Get a Lookup object (which communicates with the remote geocoding API)
 appropriate to the Query text.
422566
def lookup
      if !options[:street_address] and (options[:ip_address] or ip_address?)
        name = options[:ip_lookup] || Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
      else
        name = options[:lookup] || Configuration.lookup || Geocoder::Lookup.street_services.first
      end
      Lookup.get(name)
    end
1268678
def get(method, hmc, uri, uri_parms, logon_required):
        """"""
        query_str = uri_parms[0]
        try:
            console = hmc.consoles.lookup_by_oid(None)
        except KeyError:
            raise InvalidResourceError(method, uri)
        result_password_rules = []
        filter_args = parse_query_parms(method, uri, query_str)
        for password_rule in console.password_rules.list(filter_args):
            result_password_rule = {}
            for prop in password_rule.properties:
                if prop in ('element-uri', 'name', 'type'):
                    result_password_rule[prop] = password_rule.properties[prop]
            result_password_rules.append(result_password_rule)
        return {'password-rules': result_password_rules}
778261
function lookupParameterOnReq(name, index, length) {
    return (req, res) => {
        if(req[name]) return req[name]
        if(req.query && req.query[name]) return req.query[name]
        if(req.body && req.body[name]) return req.body[name]
        if(res.locals && res.locals[name]) return res.locals[name]
        if(req.app.locals && req.app.locals[name]) return req.app.locals[name]
        /**
         * In this case there is not a matching property in Request object for
         * the given parameter name. 
         * We just accept it, if that is the last parameter of the method, in which 
         * case it should correspond to a callback.
         */
        if(index != (length - 1))
            throw new Error('Parameter ' + name + ' not found in Request object!!!' )

        return null
    }
}
426247
def get(self, uri, query=None, **kwargs):
        """"""
        return self.fetch('get', uri, query, **kwargs)
872862
def geocode(self, string, bounds=None, region=None,
                language=None, sensor=False):
        '''
        '''
        if isinstance(string, unicode):
            string = string.encode('utf-8')

        params = {
            'address': self.format_string % string,
            'sensor': str(sensor).lower()
        }

        
        if bounds:
            params['bounds'] = bounds
            
        if region:
            params['region'] = region
            
        if language:
            params['language'] = language
            

        if not self.premier:
            url = self.get_url(params)
        else:
            url = self.get_signed_url(params)

        return self.GetService_url(url)
76488
public T lookup(String text)
	{
		if (text == null)
			return null;
		
		for (Entry<String,T> entry :lookupMap.entrySet())
		{
			if (Text.matches(text, entry.getKey()))
				return lookupMap.get(entry.getKey());
			
		}

		return null;

	}
915671
def _get(self, ip):
        
        # Geoloc updated up to once a week:
        # http://ipinfo.io/developers/data#geolocation-data
        retries = 10
        for retry in range(retries):
            try:
                response = requests.get('http://ipinfo.io/%s/json' % ip,
                                        verify=False, timeout=1)  # nosec
                if response.status_code == 429:
                    raise RateExceededError
                return response.json()
            except (requests.ReadTimeout, requests.ConnectTimeout):
                pass
        return {}
9177
public final Object handleGetObject(String key) {
        // lazily load the lookup hashtable.
        if (lookup == null) {
            loadLookup();
        }
        if (key == null) {
            throw new NullPointerException();
        }
        return lookup.get(key); // this class ignores locales
    }
981031
def query_to_map(text):
    '''
    '''
    dict_obj = {}

    for key, value in split_query(text, True):
        if key not in dict_obj:
            dict_obj[key] = []

        if value:
            dict_obj[key].append(value.replace('+', ' '))
        else:
            dict_obj[key].append('')

    return query_to_map(text)
944855
def _get_code(data, position, obj_end, opts, element_name):
    """"""
    code, position = _get_string(data, position, obj_end, opts, element_name)
    return Code(code), position
497516
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return CountryInstance(self._version, payload, iso_code=self._solution['iso_code'], )
475845
function goGet(api, key, requestor, params) {
  /*jshint validthis: true */

  var query  = {};
  var opt;

  // extract query options
  for (opt in this.options) {
    query[opt] = this.options[opt];
  }

  // unexpected params are ignored,
  // so we don't need to filter the query options from the params object
  var opts   = api.request(key, params, query);
  var duplex = requestor.newDuplex(opts);

  return duplex;
}
1177877
def get(self, param=None, must=[APIKEY]):
        '''
        '''
        param = {} if param is None else param
        r = self.verify_param(param, must)
        if not r.is_succ():
            return r
        handle = CommonResultHandler(lambda rsp: {VERSION_V1:rsp.get(USER), VERSION_V2:rsp}[self.version()])
        return self.path('get.json').post(param, handle, r)
292911
def retrieve(self, *args, **kwargs):
        

        lookup, key = self._lookup(*args, **kwargs)

        return lookup[key]
1268333
def reverse_geocode
      do_lookup(true) do |o,rs|
        if r = rs.first
          unless r.address.nil?
            o.__send__ "#{self.class.geocoder_options[:fetched_address]}=", r.address
          end
          r.address
        end
      end
    end
1298027
def geocode
      do_lookup(false) do |o,rs|
        if r = rs.first
          unless r.coordinates.nil?
            o.__send__ "#{self.class.geocoder_options[:coordinates]}=", r.coordinates.reverse
          end
          r.coordinates
        end
      end
    end
190719
def get(self, **params):
        '''
        
        '''
        return self.client.get('/v1/reference-data/locations/{0}'
                               .format(self.location_id), **params)