before send to remote

env/lib/python3.8/site-packages/django/contrib/gis/geoip2/__init__.py

@@ -0,0 +1,24 @@
+"""
+This module houses the GeoIP2 object, a wrapper for the MaxMind GeoIP2(R)
+Python API (https://geoip2.readthedocs.io/). This is an alternative to the
+Python GeoIP2 interface provided by MaxMind.
+
+GeoIP(R) is a registered trademark of MaxMind, Inc.
+
+For IP-based geolocation, this module requires the GeoLite2 Country and City
+datasets, in binary format (CSV will not work!). The datasets may be
+downloaded from MaxMind at https://dev.maxmind.com/geoip/geoip2/geolite2/.
+Grab GeoLite2-Country.mmdb.gz and GeoLite2-City.mmdb.gz, and unzip them in the
+directory corresponding to settings.GEOIP_PATH.
+"""
+__all__ = ["HAS_GEOIP2"]
+
+try:
+    import geoip2  # NOQA
+except ImportError:
+    HAS_GEOIP2 = False
+else:
+    from .base import GeoIP2, GeoIP2Exception
+
+    HAS_GEOIP2 = True
+    __all__ += ["GeoIP2", "GeoIP2Exception"]

env/lib/python3.8/site-packages/django/contrib/gis/geoip2/base.py

@@ -0,0 +1,238 @@
+import socket
+
+import geoip2.database
+
+from django.conf import settings
+from django.contrib.gis.geos import Point
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_ipv46_address
+from django.utils._os import to_path
+
+from .resources import City, Country
+
+# Creating the settings dictionary with any settings, if needed.
+GEOIP_SETTINGS = {
+    "GEOIP_PATH": getattr(settings, "GEOIP_PATH", None),
+    "GEOIP_CITY": getattr(settings, "GEOIP_CITY", "GeoLite2-City.mmdb"),
+    "GEOIP_COUNTRY": getattr(settings, "GEOIP_COUNTRY", "GeoLite2-Country.mmdb"),
+}
+
+
+class GeoIP2Exception(Exception):
+    pass
+
+
+class GeoIP2:
+    # The flags for GeoIP memory caching.
+    # Try MODE_MMAP_EXT, MODE_MMAP, MODE_FILE in that order.
+    MODE_AUTO = 0
+    # Use the C extension with memory map.
+    MODE_MMAP_EXT = 1
+    # Read from memory map. Pure Python.
+    MODE_MMAP = 2
+    # Read database as standard file. Pure Python.
+    MODE_FILE = 4
+    # Load database into memory. Pure Python.
+    MODE_MEMORY = 8
+    cache_options = frozenset(
+        (MODE_AUTO, MODE_MMAP_EXT, MODE_MMAP, MODE_FILE, MODE_MEMORY)
+    )
+
+    # Paths to the city & country binary databases.
+    _city_file = ""
+    _country_file = ""
+
+    # Initially, pointers to GeoIP file references are NULL.
+    _city = None
+    _country = None
+
+    def __init__(self, path=None, cache=0, country=None, city=None):
+        """
+        Initialize the GeoIP object. No parameters are required to use default
+        settings. Keyword arguments may be passed in to customize the locations
+        of the GeoIP datasets.
+
+        * path: Base directory to where GeoIP data is located or the full path
+            to where the city or country data files (*.mmdb) are located.
+            Assumes that both the city and country data sets are located in
+            this directory; overrides the GEOIP_PATH setting.
+
+        * cache: The cache settings when opening up the GeoIP datasets. May be
+            an integer in (0, 1, 2, 4, 8) corresponding to the MODE_AUTO,
+            MODE_MMAP_EXT, MODE_MMAP, MODE_FILE, and MODE_MEMORY,
+            `GeoIPOptions` C API settings,  respectively. Defaults to 0,
+            meaning MODE_AUTO.
+
+        * country: The name of the GeoIP country data file. Defaults to
+            'GeoLite2-Country.mmdb'; overrides the GEOIP_COUNTRY setting.
+
+        * city: The name of the GeoIP city data file. Defaults to
+            'GeoLite2-City.mmdb'; overrides the GEOIP_CITY setting.
+        """
+        # Checking the given cache option.
+        if cache not in self.cache_options:
+            raise GeoIP2Exception("Invalid GeoIP caching option: %s" % cache)
+
+        # Getting the GeoIP data path.
+        path = path or GEOIP_SETTINGS["GEOIP_PATH"]
+        if not path:
+            raise GeoIP2Exception(
+                "GeoIP path must be provided via parameter or the GEOIP_PATH setting."
+            )
+
+        path = to_path(path)
+        if path.is_dir():
+            # Constructing the GeoIP database filenames using the settings
+            # dictionary. If the database files for the GeoLite country
+            # and/or city datasets exist, then try to open them.
+            country_db = path / (country or GEOIP_SETTINGS["GEOIP_COUNTRY"])
+            if country_db.is_file():
+                self._country = geoip2.database.Reader(str(country_db), mode=cache)
+                self._country_file = country_db
+
+            city_db = path / (city or GEOIP_SETTINGS["GEOIP_CITY"])
+            if city_db.is_file():
+                self._city = geoip2.database.Reader(str(city_db), mode=cache)
+                self._city_file = city_db
+            if not self._reader:
+                raise GeoIP2Exception("Could not load a database from %s." % path)
+        elif path.is_file():
+            # Otherwise, some detective work will be needed to figure out
+            # whether the given database path is for the GeoIP country or city
+            # databases.
+            reader = geoip2.database.Reader(str(path), mode=cache)
+            db_type = reader.metadata().database_type
+
+            if db_type.endswith("City"):
+                # GeoLite City database detected.
+                self._city = reader
+                self._city_file = path
+            elif db_type.endswith("Country"):
+                # GeoIP Country database detected.
+                self._country = reader
+                self._country_file = path
+            else:
+                raise GeoIP2Exception(
+                    "Unable to recognize database edition: %s" % db_type
+                )
+        else:
+            raise GeoIP2Exception("GeoIP path must be a valid file or directory.")
+
+    @property
+    def _reader(self):
+        return self._country or self._city
+
+    @property
+    def _country_or_city(self):
+        if self._country:
+            return self._country.country
+        else:
+            return self._city.city
+
+    def __del__(self):
+        # Cleanup any GeoIP file handles lying around.
+        if self._reader:
+            self._reader.close()
+
+    def __repr__(self):
+        meta = self._reader.metadata()
+        version = "[v%s.%s]" % (
+            meta.binary_format_major_version,
+            meta.binary_format_minor_version,
+        )
+        return (
+            '<%(cls)s %(version)s _country_file="%(country)s", _city_file="%(city)s">'
+            % {
+                "cls": self.__class__.__name__,
+                "version": version,
+                "country": self._country_file,
+                "city": self._city_file,
+            }
+        )
+
+    def _check_query(self, query, city=False, city_or_country=False):
+        "Check the query and database availability."
+        # Making sure a string was passed in for the query.
+        if not isinstance(query, str):
+            raise TypeError(
+                "GeoIP query must be a string, not type %s" % type(query).__name__
+            )
+
+        # Extra checks for the existence of country and city databases.
+        if city_or_country and not (self._country or self._city):
+            raise GeoIP2Exception("Invalid GeoIP country and city data files.")
+        elif city and not self._city:
+            raise GeoIP2Exception("Invalid GeoIP city data file: %s" % self._city_file)
+
+        # Return the query string back to the caller. GeoIP2 only takes IP addresses.
+        try:
+            validate_ipv46_address(query)
+        except ValidationError:
+            query = socket.gethostbyname(query)
+
+        return query
+
+    def city(self, query):
+        """
+        Return a dictionary of city information for the given IP address or
+        Fully Qualified Domain Name (FQDN). Some information in the dictionary
+        may be undefined (None).
+        """
+        enc_query = self._check_query(query, city=True)
+        return City(self._city.city(enc_query))
+
+    def country_code(self, query):
+        "Return the country code for the given IP Address or FQDN."
+        return self.country(query)["country_code"]
+
+    def country_name(self, query):
+        "Return the country name for the given IP Address or FQDN."
+        return self.country(query)["country_name"]
+
+    def country(self, query):
+        """
+        Return a dictionary with the country code and name when given an
+        IP address or a Fully Qualified Domain Name (FQDN). For example, both
+        '24.124.1.80' and 'djangoproject.com' are valid parameters.
+        """
+        # Returning the country code and name
+        enc_query = self._check_query(query, city_or_country=True)
+        return Country(self._country_or_city(enc_query))
+
+    # #### Coordinate retrieval routines ####
+    def coords(self, query, ordering=("longitude", "latitude")):
+        cdict = self.city(query)
+        if cdict is None:
+            return None
+        else:
+            return tuple(cdict[o] for o in ordering)
+
+    def lon_lat(self, query):
+        "Return a tuple of the (longitude, latitude) for the given query."
+        return self.coords(query)
+
+    def lat_lon(self, query):
+        "Return a tuple of the (latitude, longitude) for the given query."
+        return self.coords(query, ("latitude", "longitude"))
+
+    def geos(self, query):
+        "Return a GEOS Point object for the given query."
+        ll = self.lon_lat(query)
+        if ll:
+            return Point(ll, srid=4326)
+        else:
+            return None
+
+    # #### GeoIP Database Information Routines ####
+    @property
+    def info(self):
+        "Return information about the GeoIP library and databases in use."
+        meta = self._reader.metadata()
+        return "GeoIP Library:\n\t%s.%s\n" % (
+            meta.binary_format_major_version,
+            meta.binary_format_minor_version,
+        )
+
+    @classmethod
+    def open(cls, full_path, cache):
+        return GeoIP2(full_path, cache)

env/lib/python3.8/site-packages/django/contrib/gis/geoip2/resources.py

@@ -0,0 +1,22 @@
+def City(response):
+    return {
+        "city": response.city.name,
+        "continent_code": response.continent.code,
+        "continent_name": response.continent.name,
+        "country_code": response.country.iso_code,
+        "country_name": response.country.name,
+        "dma_code": response.location.metro_code,
+        "is_in_european_union": response.country.is_in_european_union,
+        "latitude": response.location.latitude,
+        "longitude": response.location.longitude,
+        "postal_code": response.postal.code,
+        "region": response.subdivisions[0].iso_code if response.subdivisions else None,
+        "time_zone": response.location.time_zone,
+    }
+
+
+def Country(response):
+    return {
+        "country_code": response.country.iso_code,
+        "country_name": response.country.name,
+    }