a }cC@s ddlZddlZddlZddlZddlmZddlmZmZm Z m Z m Z m Z ddl mZmZmZmZmZmZmZmZddlmZddlmZmZdZdeZed d e e fDZGd d d Ze d e!fdddiZ"eeeeeeeeeeeeed Z#e!Z$GdddZ%ddZ&ddZ'dS)N)compat)AdapterHTTPErrorBaseAsyncAdapterBaseSyncAdapterRequestsAdapter URLLibAdapterget_retry_after)ConfigurationErrorGeocoderAuthenticationFailureGeocoderInsufficientPrivilegesGeocoderQueryErrorGeocoderQuotaExceededGeocoderRateLimitedGeocoderServiceErrorGeocoderTimedOut)Point) __version__logger)Geocoderoptionszgeopy/%sccs|]}|jr|VqdSN)Z is_available).0Z adapter_clsrP/var/www/html/django/DPS/env/lib/python3.9/site-packages/geopy/geocoders/base.py #src@s(eZdZdZeZdZdZdZdZ e Z dS)raThe `options` object contains default configuration values for geocoders, e.g. `timeout` and `User-Agent`. Instead of passing a custom value to each geocoder individually, you can override a default value in this object. Please note that not all geocoders use all attributes of this object. For example, some geocoders don't respect the ``default_scheme`` attribute. Refer to the specific geocoder's initializer doc for a list of parameters which that geocoder accepts. Example for overriding default ``timeout`` and ``user_agent``:: >>> import geopy.geocoders >>> from geopy.geocoders import Nominatim >>> geopy.geocoders.options.default_user_agent = 'my_app/1' >>> geopy.geocoders.options.default_timeout = 7 >>> geolocator = Nominatim() >>> print(geolocator.headers) {'User-Agent': 'my_app/1'} >>> print(geolocator.timeout) 7 Attributes: default_adapter_factory A callable which returns a :class:`geopy.adapters.BaseAdapter` instance. Adapters are different implementations of HTTP clients. See :mod:`geopy.adapters` for more info. This callable accepts two keyword args: ``proxies`` and ``ssl_context``. A class might be specified as this callable as well. Example:: import geopy.geocoders geopy.geocoders.options.default_adapter_factory = geopy.adapters.URLLibAdapter geopy.geocoders.options.default_adapter_factory = ( lambda proxies, ssl_context: MyAdapter( proxies=proxies, ssl_context=ssl_context, my_custom_arg=42 ) ) If `requests `_ package is installed, the default adapter is :class:`geopy.adapters.RequestsAdapter`. Otherwise it is :class:`geopy.adapters.URLLibAdapter`. .. versionadded:: 2.0 default_proxies Tunnel requests through HTTP proxy. By default the system proxies are respected (e.g. `HTTP_PROXY` and `HTTPS_PROXY` env vars or platform-specific proxy settings, such as macOS or Windows native preferences -- see :func:`urllib.request.getproxies` for more details). The `proxies` value for using system proxies is ``None``. To disable system proxies and issue requests directly, explicitly pass an empty dict as a value for `proxies`: ``{}``. To use a custom HTTP proxy location, pass a string. Valid examples are: - ``"192.0.2.0:8080"`` - ``"john:passw0rd@192.0.2.0:8080"`` - ``"http://john:passw0rd@192.0.2.0:8080"`` Please note: - Scheme part (``http://``) of the proxy is ignored. - Only `http` proxy is supported. Even if the proxy scheme is `https`, it will be ignored, and the connection between client and proxy would still be unencrypted. However, `https` requests via `http` proxy are still supported (via `HTTP CONNECT` method). Raw urllib-style `proxies` dict might be provided instead of a string: - ``{"https": "192.0.2.0:8080"}`` -- means that HTTP proxy would be used only for requests having `https` scheme. String `proxies` value is automatically used for both schemes, and is provided as a shorthand for the urllib-style `proxies` dict. For more information, see documentation on :func:`urllib.request.getproxies`. default_scheme Use ``'https'`` or ``'http'`` as the API URL's scheme. default_ssl_context An :class:`ssl.SSLContext` instance with custom TLS verification settings. Pass ``None`` to use the interpreter's defaults (that is to use the system's trusted CA certificates). To use the CA bundle used by `requests` library:: import ssl import certifi import geopy.geocoders ctx = ssl.create_default_context(cafile=certifi.where()) geopy.geocoders.options.default_ssl_context = ctx To disable TLS certificate verification completely:: import ssl import geopy.geocoders ctx = ssl.create_default_context() ctx.check_hostname = False ctx.verify_mode = ssl.CERT_NONE geopy.geocoders.options.default_ssl_context = ctx See docs for the :class:`ssl.SSLContext` class for more examples. default_timeout Time, in seconds, to wait for the geocoding service to respond before raising a :class:`geopy.exc.GeocoderTimedOut` exception. Pass `None` to disable timeout. default_user_agent User-Agent header to send with the requests to geocoder API. Nhttps) __name__ __module__ __qualname____doc___DEFAULT_ADAPTER_CLASSdefault_adapter_factorydefault_proxiesdefault_schemedefault_ssl_contextdefault_timeout_DEFAULT_USER_AGENTdefault_user_agentrrrrr*s robject__repr__cCsdS)NDEFAULT_SENTINELr)selfrrrr-) iiiiiiiiiiiiic@s~eZdZdZdeededdddZddZdd Zd d Zd d Z dddZ dddZ ddZ edddddZ ddZdS)rz( Template object for geocoders. N)schemetimeoutproxies user_agent ssl_contextadapter_factorycCs|ptj|_|jdvrtd|tur*|ntj|_|tur>|ntj|_d|pPtj i|_ |turb|ntj |_ t |jtr|j|jd|_|durtj}||j|j d|_t |jtrd|_n(t |jtrd|_ntdt|jfdS)N)httprz)Supported schemes are `http` and `https`.z User-Agent)r1r3FTzAAdapter %r must extend either BaseSyncAdapter or BaseAsyncAdapter)rr$r/r r+r&r0r#r1r(headersr%r3 isinstancestrr"adapterr_Geocoder__run_asyncrtype)r,r/r0r1r2r3r4rrr__init__s@         zGeocoder.__init__cCs.|jrtd|j}||jus*Jd|S)zContext manager for synchronous adapters. At exit all open connections will be closed. In synchronous mode context manager usage is not required, and connections will be automatically closed by garbage collection. z-`async with` must be used with async adapters&adapter's __enter__ must return `self`)r: TypeErrorr9 __enter__r,resrrrr?s  zGeocoder.__enter__cCs|j|||dSr)r9__exit__r,exc_typeexc_valexc_tbrrrrBszGeocoder.__exit__cs4|jstd|jIdH}||jus0Jd|S)aContext manager for asynchronous adapters. At exit all open connections will be closed. In asynchronous mode context manager usage is not required, however, it is strongly advised to avoid warnings about resources leaks. z.`async with` cannot be used with sync adaptersNr=)r:r>r9 __aenter__r@rrrrGs zGeocoder.__aenter__cs|j|||IdHdSr)r9 __aexit__rCrrrrH#szGeocoder.__aexit__%(lat)s,%(lon)scCs.t|tst|}|tt|jt|jdS)zb Do the right thing on "point" input. For geocoders with reverse methods. )ZlatZlon)r7rdict_format_coordinatelatitude longitude)r,point output_formatrrr_coerce_point_to_string&s   z Geocoder._coerce_point_to_string#%(lat1)s,%(lon1)s,%(lat2)s,%(lon2)scCsjt|dkrtd|\}}t|t|}}|tt|j|jt|j|jt|j|jt|j|jdS)aD Transform bounding box boundaries to a string matching `output_format` from the following formats: - [Point(lat1, lon1), Point(lat2, lon2)] - [[lat1, lon1], [lat2, lon2]] - ["lat1,lon1", "lat2,lon2"] It is guaranteed that lat1 <= lat2 and lon1 <= lon2. z%Unsupported format for a bounding box)Zlat1Zlon1Zlat2Zlon2)lenr rrJminrLrMmax)r,ZbboxrOp1p2rrr_format_bounding_box8s    zGeocoder._format_bounding_boxcCsdS)au Geocoder-specific exceptions handler. Override if custom exceptions processing is needed. For example, raising an appropriate GeocoderQuotaExceeded on non-200 response with a textual message in the body about the exceeded quota. Return `NONE_RESULT` to have the geocoding call return `None` (meaning empty result). Nr)r,errorrrr_geocoder_exception_handlerNs z$Geocoder._geocoder_exception_handlerT)r0is_jsonr6c sj}|r|||tur$|nj}zV|rDjj|||dnjj|||djrtfdd}|WSWSWnFt y}z. |} | t urWYd}~dSWYd}~n d}~00dS)z= For a generated query URL, get the results. )r0r6c stz(IdH}t|r$|IdH}|WStyn}z.|}|turXWYd}~dSWYd}~n d}~00dSr)inspect isawaitable Exception_adapter_error_handler NONE_RESULT)rArYcallbackresultr,rrfutts   z$Geocoder._call_geocoder..futN) r6copyupdater+r0r9Zget_jsonZget_textr:r^r_r`) r,urlrbr0r[r6Z req_headersrdrYrArrar_call_geocoderZs&     zGeocoder._call_geocodercCst|tr~|jr&tjd|j|jdd||}|tur&|g|Ri|WdS1s00YdSrr)r,argskwargs)func sync_lockrr locked_syncsz"_synchronized..locked_syncNc sdurtr^dus$Jtur^|g|Ri|}t|rZ|IdH}|S4IdHntzH|g|Ri|}t|r|IdH}|WdWdIdHSd0WdIdHq1IdHs0YdSr)asyncioLocklockedr current_taskr\r])r,rrrsrA) async_lockasync_lock_taskrtrr locked_asyncs&      z#_synchronized..locked_asynccs@t|jt}|r&|g|Ri|S|g|Ri|SdSr)r7r9r)r,rrrsZ run_async)r}rvrrfs z_synchronized..f) threadingRLock functoolswraps)rtr~r)r{r|rtr}rvrur _synchronizedsr)(rwrr\rZgeopyrZgeopy.adaptersrrrrrrZ geopy.excr r r r r rrrZ geopy.pointrZ geopy.utilrr__all__r'nextr!rr;r)r+rnr`rrKrrrrrsJ  (  S