def search_text(self, query=None, category=None, limit=None, start=None):
"""Fulltext search for places."""
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint('search_text'),
'GET', data=kwargs))
def search(self, lat, lon, radius=None, query=None, category=None, num=None):
"""Search for places near a lat/lon, within a radius (in kilometers)."""
_assert_valid_lat(lat)
_assert_valid_lon(lon)
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (num and not is_numeric(num)):
raise ValueError("Num parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if num:
kwargs['num'] = num
endpoint = self._endpoint('search', lat=lat, lon=lon)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_bbox(self, lat_sw, lon_sw, lat_ne, lon_ne, query=None,
category=None, limit=None, start=None):
"""Return places inside a box of (lat_sw, lon_sw), (lat_ne, lon_ne)."""
_assert_valid_lat(lat_sw)
_assert_valid_lat(lat_ne)
_assert_valid_lon(lon_sw)
_assert_valid_lon(lon_ne)
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint(
'search_bbox', lat_sw=lat_sw, lon_sw=lon_sw,
lat_ne=lat_ne, lon_ne=lon_ne), 'GET', data=kwargs))
def search_by_ip(self, ipaddr, radius=None, query=None, category=None):
"""
Search for places near an IP address, within a radius (in
kilometers).
The server uses guesses the latitude and longitude from the
ipaddr and then does the same thing as search(), using that
guessed latitude and longitude.
"""
precondition(is_valid_ip(ipaddr), ipaddr)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring), category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_ip', ipaddr=ipaddr)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_ip(self, ipaddr, radius=None, query=None, category=None):
"""
Search for places near an IP address, within a radius (in
kilometers).
The server uses guesses the latitude and longitude from the
ipaddr and then does the same thing as search(), using that
guessed latitude and longitude.
"""
precondition(is_valid_ip(ipaddr), ipaddr)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring),
category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = {}
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_ip', ipaddr=ipaddr)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search(self, lat, lon, radius=None, query=None, category=None):
"""Search for places near a lat/lon, within a radius (in kilometers)."""
precondition(is_valid_lat(lat), lat)
precondition(is_valid_lon(lon), lon)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring), category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search', lat=lat, lon=lon)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_my_ip(self, radius=None, query=None, category=None):
"""
Search for places near your IP address, within a radius (in
kilometers).
The server gets the IP address from the HTTP connection (this
may be the IP address of your device or of a firewall, NAT, or
HTTP proxy device between you and the server), and then does
the same thing as search_by_ip(), using that IP address.
"""
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring), category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_my_ip')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_my_ip(self, radius=None, query=None, category=None):
"""
Search for places near your IP address, within a radius (in
kilometers).
The server gets the IP address from the HTTP connection (this
may be the IP address of your device or of a firewall, NAT, or
HTTP proxy device between you and the server), and then does
the same thing as search_by_ip(), using that IP address.
"""
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring),
category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = {}
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_my_ip')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search(self, lat, lon, radius=None, query=None, category=None):
"""Search for places near a lat/lon, within a radius (in kilometers)."""
precondition(is_valid_lat(lat), lat)
precondition(is_valid_lon(lon), lon)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring),
category)
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = {}
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search', lat=lat, lon=lon)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_address(self, address, radius=None, query=None,
category=None, limit=None, start=None):
"""
Search for places near the given address, within a radius (in
kilometers).
The server figures out the latitude and longitude from the
street address and then does the same thing as search(), using
that deduced latitude and longitude.
"""
if not isinstance(address, basestring) or not address.strip():
raise ValueError("Address must be a non-empty string.")
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if isinstance(address, unicode):
address = address.encode('utf-8')
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
kwargs = { 'address': address }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint(
'search_by_address'), 'GET', data=kwargs))
def search_by_address(self, address, radius=None, query=None, category=None, num=None):
"""
Search for places near the given address, within a radius (in
kilometers).
The server figures out the latitude and longitude from the
street address and then does the same thing as search(), using
that deduced latitude and longitude.
"""
if not isinstance(address, basestring) or not address.strip():
raise ValueError("Address must be a non-empty string.")
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (num and not is_numeric(num)):
raise ValueError("Num parameter must be numeric.")
if isinstance(address, unicode):
address = address.encode('utf-8')
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { 'address': address }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if num:
kwargs['num'] = num
endpoint = self._endpoint('search_by_address')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_ip(self, ipaddr, radius=None, query=None,
category=None, limit=None, start=None):
"""
Search for places near an IP address, within a radius (in
kilometers).
The server uses guesses the latitude and longitude from the
ipaddr and then does the same thing as search(), using that
guessed latitude and longitude.
"""
if not is_valid_ip(ipaddr):
raise ValueError("Address %s is not a valid IP" % ipaddr)
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint(
'search_by_ip', ipaddr=ipaddr), 'GET', data=kwargs))
def search_by_ip(self, ipaddr, radius=None, query=None, category=None, num=None):
"""
Search for places near an IP address, within a radius (in
kilometers).
The server uses guesses the latitude and longitude from the
ipaddr and then does the same thing as search(), using that
guessed latitude and longitude.
"""
if not is_valid_ip(ipaddr):
raise ValueError("Address %s is not a valid IP" % ipaddr)
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (num and not is_numeric(num)):
raise ValueError("Num parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if num:
kwargs['num'] = num
endpoint = self._endpoint('search_by_ip', ipaddr=ipaddr)
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_my_ip(self, radius=None, query=None, category=None,
limit=None, start=None):
"""
Search for places near your IP address, within a radius (in
kilometers).
The server gets the IP address from the HTTP connection (this
may be the IP address of your device or of a firewall, NAT, or
HTTP proxy device between you and the server), and then does
the same thing as search_by_ip(), using that IP address.
"""
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint(
'search_by_my_ip'), 'GET', data=kwargs))
def search_by_my_ip(self, radius=None, query=None, category=None, num=None):
"""
Search for places near your IP address, within a radius (in
kilometers).
The server gets the IP address from the HTTP connection (this
may be the IP address of your device or of a firewall, NAT, or
HTTP proxy device between you and the server), and then does
the same thing as search_by_ip(), using that IP address.
"""
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (num and not is_numeric(num)):
raise ValueError("Num parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if num:
kwargs['num'] = num
endpoint = self._endpoint('search_by_my_ip')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search(self, lat, lon, radius=None, query=None, category=None,
limit=None, start=None):
"""Search for places near a lat/lon, within a radius (in kilometers)."""
_assert_valid_lat(lat)
_assert_valid_lon(lon)
if (radius and not is_numeric(radius)):
raise ValueError("Radius must be numeric.")
if (query and not isinstance(query, basestring)):
raise ValueError("Query must be a string.")
if (category and not isinstance(category, basestring)):
raise ValueError("Category must be a string.")
if (limit and not is_numeric(limit)):
raise ValueError("Limit parameter must be numeric.")
if (start and not is_numeric(start)):
raise ValueError("Start parameter must be numeric.")
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
if limit:
kwargs['limit'] = limit
if start:
kwargs['start'] = start
return self._respond(*self._request(self._endpoint(
'search', lat=lat, lon=lon),
'GET', data=kwargs))
def search_by_address(self,
address,
radius=None,
query=None,
category=None):
"""
Search for places near the given address, within a radius (in
kilometers).
The server figures out the latitude and longitude from the
street address and then does the same thing as search(), using
that deduced latitude and longitude.
"""
precondition(isinstance(address, basestring), address)
precondition(address != '', address)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring),
category)
if isinstance(address, unicode):
address = address.encode('utf-8')
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = {'address': address}
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_address')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
def search_by_address(self, address, radius=None, query=None, category=None):
"""
Search for places near the given address, within a radius (in
kilometers).
The server figures out the latitude and longitude from the
street address and then does the same thing as search(), using
that deduced latitude and longitude.
"""
precondition(isinstance(address, basestring), address)
precondition(address != '', address)
precondition(radius is None or is_numeric(radius), radius)
precondition(query is None or isinstance(query, basestring), query)
precondition(category is None or isinstance(category, basestring), category)
if isinstance(address, unicode):
address = address.encode('utf-8')
if isinstance(query, unicode):
query = query.encode('utf-8')
if isinstance(category, unicode):
category = category.encode('utf-8')
kwargs = { 'address': address }
if radius:
kwargs['radius'] = radius
if query:
kwargs['q'] = query
if category:
kwargs['category'] = category
endpoint = self._endpoint('search_by_address')
result = self._request(endpoint, 'GET', data=kwargs)[1]
fc = json_decode(result)
return [Feature.from_dict(f) for f in fc['features']]
