212 lines
6.9 KiB
Python
212 lines
6.9 KiB
Python
from functools import partial
|
|
from urllib.parse import urlencode
|
|
|
|
from geopy.geocoders.base import DEFAULT_SENTINEL, Geocoder
|
|
from geopy.location import Location
|
|
from geopy.util import logger
|
|
|
|
__all__ = ("MapQuest", )
|
|
|
|
|
|
class MapQuest(Geocoder):
|
|
"""Geocoder using the MapQuest API based on Licensed data.
|
|
|
|
Documentation at:
|
|
https://developer.mapquest.com/documentation/geocoding-api/
|
|
|
|
MapQuest provides two Geocoding APIs:
|
|
|
|
- :class:`geopy.geocoders.OpenMapQuest` Nominatim-alike API
|
|
which is based on Open data from OpenStreetMap.
|
|
- :class:`geopy.geocoders.MapQuest` (this class) MapQuest's own API
|
|
which is based on Licensed data.
|
|
"""
|
|
|
|
geocode_path = '/geocoding/v1/address'
|
|
reverse_path = '/geocoding/v1/reverse'
|
|
|
|
def __init__(
|
|
self,
|
|
api_key,
|
|
*,
|
|
scheme=None,
|
|
timeout=DEFAULT_SENTINEL,
|
|
proxies=DEFAULT_SENTINEL,
|
|
user_agent=None,
|
|
ssl_context=DEFAULT_SENTINEL,
|
|
adapter_factory=None,
|
|
domain='www.mapquestapi.com'
|
|
):
|
|
"""
|
|
:param str api_key: The API key required by Mapquest to perform
|
|
geocoding requests. API keys are managed through MapQuest's "Manage Keys"
|
|
page (https://developer.mapquest.com/user/me/apps).
|
|
|
|
:param str scheme:
|
|
See :attr:`geopy.geocoders.options.default_scheme`.
|
|
|
|
:param int timeout:
|
|
See :attr:`geopy.geocoders.options.default_timeout`.
|
|
|
|
:param dict proxies:
|
|
See :attr:`geopy.geocoders.options.default_proxies`.
|
|
|
|
:param str user_agent:
|
|
See :attr:`geopy.geocoders.options.default_user_agent`.
|
|
|
|
:type ssl_context: :class:`ssl.SSLContext`
|
|
:param ssl_context:
|
|
See :attr:`geopy.geocoders.options.default_ssl_context`.
|
|
|
|
:param callable adapter_factory:
|
|
See :attr:`geopy.geocoders.options.default_adapter_factory`.
|
|
|
|
.. versionadded:: 2.0
|
|
|
|
:param str domain: base api domain for mapquest
|
|
"""
|
|
super().__init__(
|
|
scheme=scheme,
|
|
timeout=timeout,
|
|
proxies=proxies,
|
|
user_agent=user_agent,
|
|
ssl_context=ssl_context,
|
|
adapter_factory=adapter_factory,
|
|
)
|
|
|
|
self.api_key = api_key
|
|
self.domain = domain.strip('/')
|
|
|
|
self.geocode_api = (
|
|
'%s://%s%s' % (self.scheme, self.domain, self.geocode_path)
|
|
)
|
|
self.reverse_api = (
|
|
'%s://%s%s' % (self.scheme, self.domain, self.reverse_path)
|
|
)
|
|
|
|
def _parse_json(self, json, exactly_one=True):
|
|
'''Returns location, (latitude, longitude) from json feed.'''
|
|
features = json['results'][0]['locations']
|
|
|
|
if features == []:
|
|
return None
|
|
|
|
def parse_location(feature):
|
|
addr_keys = [
|
|
'street',
|
|
'adminArea6',
|
|
'adminArea5',
|
|
'adminArea4',
|
|
'adminArea3',
|
|
'adminArea2',
|
|
'adminArea1',
|
|
'postalCode'
|
|
]
|
|
|
|
location = [feature[k] for k in addr_keys if feature.get(k)]
|
|
return ", ".join(location)
|
|
|
|
def parse_feature(feature):
|
|
location = parse_location(feature)
|
|
longitude = feature['latLng']['lng']
|
|
latitude = feature['latLng']['lat']
|
|
return Location(location, (latitude, longitude), feature)
|
|
|
|
if exactly_one:
|
|
return parse_feature(features[0])
|
|
else:
|
|
return [parse_feature(feature) for feature in features]
|
|
|
|
def geocode(
|
|
self,
|
|
query,
|
|
*,
|
|
exactly_one=True,
|
|
timeout=DEFAULT_SENTINEL,
|
|
limit=None,
|
|
bounds=None
|
|
):
|
|
"""
|
|
Return a location point by address.
|
|
|
|
:param str query: The address or query you wish to geocode.
|
|
|
|
:param bool exactly_one: Return one result or a list of results, if
|
|
available.
|
|
|
|
:param int timeout: Time, in seconds, to wait for the geocoding service
|
|
to respond before raising a :class:`geopy.exc.GeocoderTimedOut`
|
|
exception. Set this only if you wish to override, on this call
|
|
only, the value set during the geocoder's initialization.
|
|
|
|
:param int limit: Limit the maximum number of items in the
|
|
response. This will be reset to one if ``exactly_one`` is True.
|
|
|
|
:param bounds: The bounding box of the viewport within which
|
|
to bias geocode results more prominently.
|
|
Example: ``[Point(22, 180), Point(-22, -180)]``.
|
|
:type bounds: list or tuple of 2 items of :class:`geopy.point.Point` or
|
|
``(latitude, longitude)`` or ``"%(latitude)s, %(longitude)s"``.
|
|
|
|
:rtype: ``None``, :class:`geopy.location.Location` or a list of them, if
|
|
``exactly_one=False``.
|
|
"""
|
|
params = {}
|
|
params['key'] = self.api_key
|
|
params['location'] = query
|
|
|
|
if limit is not None:
|
|
params['maxResults'] = limit
|
|
|
|
if exactly_one:
|
|
params["maxResults"] = 1
|
|
|
|
if bounds:
|
|
params['boundingBox'] = self._format_bounding_box(
|
|
bounds, "%(lat2)s,%(lon1)s,%(lat1)s,%(lon2)s"
|
|
)
|
|
|
|
url = '?'.join((self.geocode_api, urlencode(params)))
|
|
|
|
logger.debug("%s.geocode: %s", self.__class__.__name__, url)
|
|
callback = partial(self._parse_json, exactly_one=exactly_one)
|
|
return self._call_geocoder(url, callback, timeout=timeout)
|
|
|
|
def reverse(
|
|
self,
|
|
query,
|
|
*,
|
|
exactly_one=True,
|
|
timeout=DEFAULT_SENTINEL
|
|
):
|
|
"""
|
|
Return an address by location point.
|
|
|
|
:param query: The coordinates for which you wish to obtain the
|
|
closest human-readable addresses.
|
|
:type query: :class:`geopy.point.Point`, list or tuple of ``(latitude,
|
|
longitude)``, or string as ``"%(latitude)s, %(longitude)s"``.
|
|
|
|
:param bool exactly_one: Return one result or a list of results, if
|
|
available.
|
|
|
|
:param int timeout: Time, in seconds, to wait for the geocoding service
|
|
to respond before raising a :class:`geopy.exc.GeocoderTimedOut`
|
|
exception. Set this only if you wish to override, on this call
|
|
only, the value set during the geocoder's initialization.
|
|
|
|
:rtype: ``None``, :class:`geopy.location.Location` or a list of them, if
|
|
``exactly_one=False``.
|
|
"""
|
|
params = {}
|
|
params['key'] = self.api_key
|
|
|
|
point = self._coerce_point_to_string(query, "%(lat)s,%(lon)s")
|
|
params['location'] = point
|
|
|
|
url = '?'.join((self.reverse_api, urlencode(params)))
|
|
|
|
logger.debug("%s.reverse: %s", self.__class__.__name__, url)
|
|
callback = partial(self._parse_json, exactly_one=exactly_one)
|
|
return self._call_geocoder(url, callback, timeout=timeout)
|