def _autocomplete(client, url_part, input_text, offset=None, location=None,
radius=None, language=None, types=None, components=None,
strict_bounds=False):
"""
Internal handler for ``autocomplete`` and ``autocomplete_query``.
See each method's docs for arg details.
"""
params = {"input": input_text}
if offset:
params["offset"] = offset
if location:
params["location"] = convert.latlng(location)
if radius:
params["radius"] = radius
if language:
params["language"] = language
if types:
params["types"] = types
if components:
if len(components) != 1 or list(components.keys())[0] != "country":
raise ValueError("Only country components are supported")
params["components"] = convert.components(components)
if strict_bounds:
params["strictbounds"] = "true"
url = "/maps/api/place/%sautocomplete/json" % url_part
return client._request(url, params).get("predictions", [])
def _autocomplete(client,
url_part,
input_text,
offset=None,
location=None,
radius=None,
language=None,
type=None,
components=None):
"""
Internal handler for ``autocomplete`` and ``autocomplete_query``.
See each method's docs for arg details.
"""
params = {"input": input_text}
if offset:
params["offset"] = offset
if location:
params["location"] = convert.latlng(location)
if radius:
params["radius"] = radius
if language:
params["language"] = language
if type:
params["type"] = type
if components:
params["components"] = convert.components(components)
url = "/maps/api/place/%sautocomplete/json" % url_part
return client._get(url, params)["predictions"]
def _autocomplete(client, url_part, input_text, offset=None, location=None,
radius=None, language=None, types=None, components=None,
strict_bounds=False):
"""
Internal handler for ``autocomplete`` and ``autocomplete_query``.
See each method's docs for arg details.
"""
params = {"input": input_text}
if offset:
params["offset"] = offset
if location:
params["location"] = convert.latlng(location)
if radius:
params["radius"] = radius
if language:
params["language"] = language
if types:
params["types"] = types
if components:
params["components"] = convert.components(components)
if strict_bounds:
params["strictbounds"] = "true"
url = "/maps/api/place/%sautocomplete/json" % url_part
return client._request(url, params).get("predictions", [])
def _autocomplete(client, url_part, input_text, session_token=None,
offset=None, location=None, radius=None, language=None,
types=None, components=None, strict_bounds=False):
"""
Internal handler for ``autocomplete`` and ``autocomplete_query``.
See each method's docs for arg details.
"""
params = {"input": input_text}
if session_token:
params["sessiontoken"] = session_token
if offset:
params["offset"] = offset
if location:
params["location"] = convert.latlng(location)
if radius:
params["radius"] = radius
if language:
params["language"] = language
if types:
params["types"] = types
if components:
if len(components) != 1 or list(components.keys())[0] != "country":
raise ValueError("Only country components are supported")
params["components"] = convert.components(components)
if strict_bounds:
params["strictbounds"] = "true"
url = "/maps/api/place/%sautocomplete/json" % url_part
return client._request(url, params).get("predictions", [])
async def _autocomplete(client,
url_part,
input_text,
offset=None,
location=None,
radius=None,
language=None,
types=None,
components=None,
strict_bounds=False):
params = {'input': input_text}
if offset:
params['offset'] = offset
if location:
params['location'] = convert.latlng(location)
if radius:
params['radius'] = radius
if language:
params['language'] = language
if types:
params['types'] = types
if components:
params['components'] = convert.components(components)
if strict_bounds:
params['strictbounds'] = 'true'
url = '/maps/api/place/%sautocomplete/json' % url_part
result = await client._request(url, params)
return result['predictions']
def geocode(client,
address=None,
components=None,
bounds=None,
region=None,
language=None):
params = {}
if address:
params["address"] = address
if components:
params["components"] = convert.components(components)
if bounds:
params["bounds"] = convert.bounds(bounds)
if region:
params["region"] = region
if language:
params["language"] = language
return client._request("/maps/api/geocode/json", params).get("results", [])
def geocode(client,
address=None,
place_id=None,
components=None,
bounds=None,
region=None,
language=None):
"""
Geocoding is the process of converting addresses
(like ``"1600 Amphitheatre Parkway, Mountain View, CA"``) into geographic
coordinates (like latitude 37.423021 and longitude -122.083739), which you
can use to place markers or position the map.
:param address: The address to geocode.
:type address: string
:param place_id: A textual identifier that uniquely identifies a place,
returned from a Places search.
:type place_id: string
:param components: A component filter for which you wish to obtain a
geocode, for example: ``{'administrative_area': 'TX','country': 'US'}``
:type components: dict
:param bounds: The bounding box of the viewport within which to bias geocode
results more prominently.
:type bounds: string or dict with northeast and southwest keys.
:param region: The region code, specified as a ccTLD ("top-level domain")
two-character value.
:type region: string
:param language: The language in which to return results.
:type language: string
:rtype: list of geocoding results.
"""
params = {}
if address:
params["address"] = address
if place_id:
params["place_id"] = place_id
if components:
params["components"] = convert.components(components)
if bounds:
params["bounds"] = convert.bounds(bounds)
if region:
params["region"] = region
if language:
params["language"] = language
return client._request("/maps/api/geocode/json", params).get("results", [])
def test_components(self):
c = {"country": "US"}
self.assertEqual("country:US", convert.components(c))
c = {"country": "US", "foo": 1}
self.assertEqual("country:US|foo:1", convert.components(c))
c = {"country": ["US", "AU"], "foo": 1}
self.assertEqual("country:AU|country:US|foo:1", convert.components(c))
with self.assertRaises(TypeError):
convert.components("test")
with self.assertRaises(TypeError):
convert.components(1)
with self.assertRaises(TypeError):
convert.components(("c", "b"))
def test_components(self):
c = {"country": "US"}
self.assertEqual("country:US", convert.components(c))
c = {"country": "US", "foo": 1}
self.assertEqual("country:US|foo:1", convert.components(c))
c = {"country": ["US", "AU"], "foo": 1}
self.assertEqual("country:AU|country:US|foo:1", convert.components(c))
with self.assertRaises(TypeError):
convert.components("test")
with self.assertRaises(TypeError):
convert.components(1)
with self.assertRaises(TypeError):
convert.components(("c", "b"))
def geocode(client, address=None, components=None, bounds=None, region=None,
language=None):
"""
Geocoding is the process of converting addresses
(like ``"1600 Amphitheatre Parkway, Mountain View, CA"``) into geographic
coordinates (like latitude 37.423021 and longitude -122.083739), which you
can use to place markers or position the map.
:param address: The address to geocode.
:type address: string
:param components: A component filter for which you wish to obtain a geocode,
for example:
``{'administrative_area': 'TX','country': 'US'}``
:type components: dict
:param bounds: The bounding box of the viewport within which to bias geocode
results more prominently.
:type bounds: string or dict with northeast and southwest keys.
:param region: The region code, specified as a ccTLD ("top-level domain")
two-character value.
:type region: string
:param language: The language in which to return results.
:type langauge: string
:rtype: list of geocoding results.
"""
params = {}
if address:
params["address"] = address
if components:
params["components"] = convert.components(components)
if bounds:
params["bounds"] = convert.bounds(bounds)
if region:
params["region"] = region
if language:
params["language"] = language
return client._get("/maps/api/geocode/json", params)["results"]
def _autocomplete(client, url_part, input_text, **params):
"""
Internal handler for ``autocomplete`` and ``autocomplete_query``.
See each method's docs for arg details.
"""
params['input'] = input_text
if 'location' in params:
params["location"] = convert.latlng(params["location"])
if 'components' in params:
params["components"] = convert.components(params["components"])
url = "/maps/api/place/%sautocomplete/json" % url_part
return client._request(url, params)["predictions"]
async def geocode(client, address=None, components=None,
bounds=None, region=None,
language=None):
params = {}
if address:
params['address'] = address
if components:
params['components'] = convert.components(components)
if bounds:
params['bounds'] = convert.bounds(bounds)
if region:
params['region'] = region
if language:
params['language'] = language
result = await client._request('/maps/api/geocode/json', params)
return result.get('results', [])
def static_map(client,
size,
center=None,
zoom=None,
scale=None,
format=None,
maptype=None,
language=None,
region=None,
markers=None,
path=None,
visible=None,
style=None):
"""
Downloads a map image from the Maps Static API.
See https://developers.google.com/maps/documentation/maps-static/intro
for more info, including more detail for each parameter below.
:param size: Defines the rectangular dimensions of the map image.
:type param: int or list
:param center: Defines the center of the map, equidistant from all edges
of the map.
:type center: dict or list or string
:param zoom: Defines the zoom level of the map, which determines the
magnification level of the map.
:type zoom: int
:param scale: Affects the number of pixels that are returned.
:type scale: int
:param format: Defines the format of the resulting image.
:type format: string
:param maptype: defines the type of map to construct. There are several
possible maptype values, including roadmap, satellite, hybrid,
and terrain.
:type maptype: string
:param language: defines the language to use for display of labels on
map tiles.
:type language: string
:param region: defines the appropriate borders to display, based on
geo-political sensitivities.
:type region: string
:param markers: define one or more markers to attach to the image at
specified locations.
:type markers: StaticMapMarker
:param path: defines a single path of two or more connected points to
overlay on the image at specified locations.
:type path: StaticMapPath
:param visible: specifies one or more locations that should remain visible
on the map, though no markers or other indicators will be displayed.
:type visible: list of dict
:param style: defines a custom style to alter the presentation of
a specific feature (roads, parks, and other features) of the map.
:type style: list of dict
:rtype: iterator containing the raw image data, which typically can be
used to save an image file locally. For example:
```
f = open(local_filename, 'wb')
for chunk in client.static_map(size=(400, 400),
center=(52.520103, 13.404871),
zoom=15):
if chunk:
f.write(chunk)
f.close()
```
"""
params = {"size": convert.size(size)}
if not markers:
if not (center or zoom is not None):
raise ValueError("both center and zoom are required"
"when markers is not specifed")
if center:
params["center"] = convert.latlng(center)
if zoom is not None:
params["zoom"] = zoom
if scale is not None:
params["scale"] = scale
if format:
if format not in MAPS_IMAGE_FORMATS:
raise ValueError("Invalid image format")
params['format'] = format
if maptype:
if maptype not in MAPS_MAP_TYPES:
raise ValueError("Invalid maptype")
params["maptype"] = maptype
if language:
params["language"] = language
if region:
params["region"] = region
if markers:
params["markers"] = markers
if path:
params["path"] = path
if visible:
params["visible"] = convert.location_list(visible)
if style:
params["style"] = convert.components(style)
response = client._request(
"/maps/api/staticmap",
params,
extract_body=lambda response: response,
requests_kwargs={"stream": True},
)
return response.iter_content()
