def _request(self, url, *, timeout, headers):
try:
resp = self.session.get(url, timeout=timeout, headers=headers)
except Exception as error:
message = str(error)
if isinstance(error, SocketTimeout):
raise GeocoderTimedOut("Service timed out")
elif isinstance(error, SSLError):
if "timed out" in message:
raise GeocoderTimedOut("Service timed out")
elif isinstance(error, requests.ConnectionError):
if "unauthorized" in message.lower():
raise GeocoderServiceError(message)
else:
raise GeocoderUnavailable(message)
elif isinstance(error, requests.Timeout):
raise GeocoderTimedOut("Service timed out")
raise GeocoderServiceError(message)
else:
if resp.status_code >= 400:
raise AdapterHTTPError(
"Non-successful status code %s" % resp.status_code,
status_code=resp.status_code,
text=resp.text,
)
return resp
def get_text(self, url, *, timeout, headers):
req = Request(url=url, headers=headers)
try:
page = self.urlopen(req, timeout=timeout)
except Exception as error:
message = str(error.args[0]) if len(error.args) else str(error)
if isinstance(error, HTTPError):
code = error.getcode()
body = self._read_http_error_body(error)
raise AdapterHTTPError(message, status_code=code, text=body)
elif isinstance(error, URLError):
if "timed out" in message:
raise GeocoderTimedOut("Service timed out")
elif "unreachable" in message:
raise GeocoderUnavailable("Service not available")
elif isinstance(error, SocketTimeout):
raise GeocoderTimedOut("Service timed out")
elif isinstance(error, SSLError):
if "timed out" in message:
raise GeocoderTimedOut("Service timed out")
raise GeocoderServiceError(message)
else:
text = self._decode_page(page)
status_code = page.getcode()
if status_code >= 400:
raise AdapterHTTPError(
"Non-successful status code %s" % status_code,
status_code=status_code, text=text
)
return text
def get_geo_info(self):
try:
response = self.__reader.city(self.__ip)
self.__continent = [
response.continent.geoname_id, response.continent.names["es"]
]
self.__country = [
response.country.geoname_id,
response.country.is_in_european_union,
response.country.iso_code, response.country.names["es"]
]
self.__city = [response.city.geoname_id, response.city.name]
self.__location = [
response.location.latitude, response.location.longitude,
response.location.time_zone
]
geolocator = Nominatim(user_agent='IPGeo')
location = geolocator.reverse(
str(self.__location[0]) + "," + str(self.__location[1]))
address = location.raw["address"][
"road"] if "road" in location.raw["address"] else ""
address += " " + location.raw["address"][
"house_number"] if "house_number" in location.raw[
"address"] else ""
address += " " + location.raw["address"][
"city"] if "city" in location.raw["address"] else ""
address += " " + location.raw["address"][
"county"] if "county" in location.raw["address"] else ""
address += " Cod.Postal: " + location.raw["address"][
"postcode"] if "postcode" in location.raw["address"] else ""
self.__location.insert(0, address)
self.__postal_code = [response.postal.code]
self.__traits = [
response.traits.isp, response.traits.autonomous_system_number,
response.traits.autonomous_system_organization,
response.traits.domain, response.traits.ip_address,
response.traits.network
]
yield [[self.__ip], [self.__continent], [self.__country],
[self.__city], [self.__location], [self.__postal_code],
[self.__traits]]
self.__reader.close()
except GeocoderUnavailable:
raise GeocoderUnavailable(
"No se pudo establecer conexion, compruebe su conexion a internet"
)
except FileNotFoundError:
raise FileNotFoundError("[X] Base de dato no encontrada")
def _call_geocoder(self,
url,
timeout=None,
raw=False,
requester=None,
deserializer=json.loads,
**kwargs):
"""
For a generated query URL, get the results.
"""
requester = requester or self.urlopen
try:
page = requester(url, timeout=(timeout or self.timeout), **kwargs)
except Exception as error: # pylint: disable=W0703
message = (str(error) if not py3k else
(str(error.args[0]) if len(error.args) else str(error)))
if hasattr(self, '_geocoder_exception_handler'):
self._geocoder_exception_handler(error, message) # pylint: disable=E1101
if isinstance(error, HTTPError):
code = error.getcode()
try:
raise ERROR_CODE_MAP[code](message)
except KeyError:
raise GeocoderServiceError(message)
elif isinstance(error, URLError):
if "timed out" in message:
raise GeocoderTimedOut('Service timed out')
elif "unreachable" in message:
raise GeocoderUnavailable('Service not available')
elif isinstance(error, SocketTimeout):
raise GeocoderTimedOut('Service timed out')
elif isinstance(error, SSLError):
if "timed out" in message:
raise GeocoderTimedOut('Service timed out')
raise GeocoderServiceError(message)
if hasattr(page, 'getcode'):
status_code = page.getcode()
elif hasattr(page, 'status_code'):
status_code = page.status_code
else:
status_code = None
if status_code in ERROR_CODE_MAP:
raise ERROR_CODE_MAP[page.status_code]("\n%s" % decode_page(page))
if raw:
return page
page = decode_page(page)
if deserializer is not None:
try:
return deserializer(page)
except ValueError:
raise GeocoderParseError(
"Could not deserialize using deserializer:\n%s" % page)
else:
return page
def _parse_json(self, doc, exactly_one=True):
"""
Parse a location name, latitude, and longitude from an JSON response.
"""
status_code = doc.get("statusCode", 200)
if status_code != 200:
err = doc.get("errorDetails", "")
if status_code == 401:
raise GeocoderAuthenticationFailure(err)
elif status_code == 403:
raise GeocoderInsufficientPrivileges(err)
elif status_code == 429:
raise GeocoderRateLimited(err)
elif status_code == 503:
raise GeocoderUnavailable(err)
else:
raise GeocoderServiceError(err)
try:
resources = doc['Response']['View'][0]['Result']
except IndexError:
resources = None
if not resources:
return None
def parse_resource(resource):
"""
Parse each return object.
"""
stripchars = ", \n"
addr = resource['Location']['Address']
address = addr.get('Label', '').strip(stripchars)
city = addr.get('City', '').strip(stripchars)
state = addr.get('State', '').strip(stripchars)
zipcode = addr.get('PostalCode', '').strip(stripchars)
country = addr.get('Country', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
display_pos = resource['Location']['DisplayPosition']
latitude = float(display_pos['Latitude'])
longitude = float(display_pos['Longitude'])
return Location(location, (latitude, longitude), resource)
if exactly_one:
return parse_resource(resources[0])
else:
return [parse_resource(resource) for resource in resources]
def _parse_json(doc, exactly_one=True): # pylint: disable=W0221
"""
Parse a location name, latitude, and longitude from an JSON response.
"""
status_code = doc.get("statusCode", 200)
if status_code != 200:
err = doc.get("errorDetails", "")
if status_code == 401:
raise GeocoderAuthenticationFailure(err)
elif status_code == 403:
raise GeocoderInsufficientPrivileges(err)
elif status_code == 429:
raise GeocoderQuotaExceeded(err)
elif status_code == 503:
raise GeocoderUnavailable(err)
else:
raise GeocoderServiceError(err)
resources = doc['resourceSets'][0]['resources']
if resources is None or not len(resources): # pragma: no cover
return None
def parse_resource(resource):
"""
Parse each return object.
"""
stripchars = ", \n"
addr = resource['address']
address = addr.get('addressLine', '').strip(stripchars)
city = addr.get('locality', '').strip(stripchars)
state = addr.get('adminDistrict', '').strip(stripchars)
zipcode = addr.get('postalCode', '').strip(stripchars)
country = addr.get('countryRegion', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
latitude = resource['point']['coordinates'][0] or None
longitude = resource['point']['coordinates'][1] or None
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(location, (latitude, longitude), resource)
if exactly_one:
return parse_resource(resources[0])
else:
return [parse_resource(resource) for resource in resources]
def _normalize_exceptions(self):
try:
yield
except (GeopyError, AdapterHTTPError, AssertionError):
raise
except Exception as error:
message = str(error)
if isinstance(error, asyncio.TimeoutError):
raise GeocoderTimedOut("Service timed out")
elif isinstance(error, SSLError):
if "timed out" in message:
raise GeocoderTimedOut("Service timed out")
elif isinstance(error, aiohttp.ClientConnectionError):
raise GeocoderUnavailable(message)
raise GeocoderServiceError(message)
def _call_geocoder(self,
url,
timeout=DEFAULT_SENTINEL,
raw=False,
requester=None,
deserializer=json.loads,
**kwargs):
"""
For a generated query URL, get the results.
"""
if requester:
req = url # Don't construct an urllib's Request for a custom requester.
# `requester` might be anything which can issue an HTTP request.
# Assume that `requester` is a method of the `requests` library.
# Requests, however, doesn't accept SSL context in its HTTP
# request methods. A custom HTTP adapter has to be created for that.
# So the current usage is not directly compatible with `requests`.
requester = functools.partial(requester,
context=self.ssl_context,
proxies=self.proxies,
headers=self.headers)
else:
if isinstance(url, Request):
# copy Request
headers = self.headers.copy()
headers.update(url.header_items())
req = Request(url=url.get_full_url(), headers=headers)
else:
req = Request(url=url, headers=self.headers)
requester = requester or self.urlopen
if timeout is None:
warnings.warn(
('`timeout=None` has been passed to a geocoder call. Using '
'default geocoder timeout. In geopy 2.0 the '
'behavior will be different: None will mean "no timeout" '
'instead of "default geocoder timeout". Pass '
'geopy.geocoders.base.DEFAULT_SENTINEL instead of None '
'to get rid of this warning.'), DeprecationWarning)
timeout = DEFAULT_SENTINEL
timeout = (timeout
if timeout is not DEFAULT_SENTINEL else self.timeout)
try:
page = requester(req, timeout=timeout, **kwargs)
except Exception as error:
message = (str(error) if not py3k else
(str(error.args[0]) if len(error.args) else str(error)))
self._geocoder_exception_handler(error, message)
if isinstance(error, HTTPError):
code = error.getcode()
try:
raise ERROR_CODE_MAP[code](message)
except KeyError:
raise GeocoderServiceError(message)
elif isinstance(error, URLError):
if "timed out" in message:
raise GeocoderTimedOut('Service timed out')
elif "unreachable" in message:
raise GeocoderUnavailable('Service not available')
elif isinstance(error, SocketTimeout):
raise GeocoderTimedOut('Service timed out')
elif isinstance(error, SSLError):
if "timed out" in message:
raise GeocoderTimedOut('Service timed out')
raise GeocoderServiceError(message)
if hasattr(page, 'getcode'):
status_code = page.getcode()
elif hasattr(page, 'status_code'):
status_code = page.status_code
else:
status_code = None
if status_code in ERROR_CODE_MAP:
raise ERROR_CODE_MAP[page.status_code]("\n%s" % decode_page(page))
if raw:
return page
page = decode_page(page)
if deserializer is not None:
try:
return deserializer(page)
except ValueError:
raise GeocoderParseError(
"Could not deserialize using deserializer:\n%s" % page)
else:
return page