Fixed #25184 -- Added support for MaxMind GeoLite2 database format

"""

This module houses the GeoIP2 object, a wrapper for the MaxMind GeoIP2(R)

Python API (http://geoip2.readthedocs.org/). 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 http://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:

    from .base import GeoIP2, GeoIP2Exception

    HAS_GEOIP2 = True

    __all__ += ['GeoIP2', 'GeoIP2Exception']

except ImportError:

    HAS_GEOIP2 = False

import os

import socket

import geoip2.database

from django.conf import settings

from django.core.validators import ipv4_re

from django.utils import six

from django.utils.ipv6 import is_valid_ipv6_address

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(object):

    # 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 = {opt: None for opt in (0, 1, 2, 4, 8)}

    # 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 in self.cache_options:

            self._cache = cache

        else:

            raise GeoIP2Exception('Invalid GeoIP caching option: %s' % cache)

        # Getting the GeoIP data path.

        if not path:

            path = GEOIP_SETTINGS['GEOIP_PATH']

            if not path:

                raise GeoIP2Exception('GeoIP path must be provided via parameter or the GEOIP_PATH setting.')

        if not isinstance(path, six.string_types):

            raise TypeError('Invalid path type: %s' % type(path).__name__)

        if os.path.isdir(path):

            # 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 = os.path.join(path, country or GEOIP_SETTINGS['GEOIP_COUNTRY'])

            if os.path.isfile(country_db):

                self._country = geoip2.database.Reader(country_db, mode=cache)

                self._country_file = country_db

            city_db = os.path.join(path, city or GEOIP_SETTINGS['GEOIP_CITY'])

            if os.path.isfile(city_db):

                self._city = geoip2.database.Reader(city_db, mode=cache)

                self._city_file = city_db

        elif os.path.isfile(path):

            # 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(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):

        if self._country:

            return self._country

        else:

            return 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 _check_query(self, query, country=False, city=False, city_or_country=False):

        "Helper routine for checking the query and database availability."

        # Making sure a string was passed in for the query.

        if not isinstance(query, six.string_types):

            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 country and not self._country:

            raise GeoIP2Exception('Invalid GeoIP country data file: %s' % self._country_file)

        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.

        if not (ipv4_re.match(query) or is_valid_ipv6_address(query)):

            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."

        enc_query = self._check_query(query, city_or_country=True)

        return self.country(enc_query)['country_code']

    def country_name(self, query):

        "Return the country name for the given IP Address or FQDN."

        enc_query = self._check_query(query, city_or_country=True)

        return self.country(enc_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:

            from django.contrib.gis.geos import Point

            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)

def City(response):

    return {

        'city': response.city.name,

        'country_code': response.country.iso_code,

        'country_name': response.country.name,

        'dma_code': response.location.metro_code,

        'latitude': response.location.latitude,

        'longitude': response.location.longitude,

        'postal_code': response.postal.code,

        'region': response.subdivisions[0].iso_code if len(response.subdivisions) else None,

    }

def Country(response):

    return {

        'country_code': response.country.iso_code,

        'country_name': response.country.name,

    }

*  bcrypt_

*  docutils_

*  geoip2_

*  jinja2_ 2.7+

*  numpy_

*  Pillow_

.. _bcrypt: https://pypi.python.org/pypi/bcrypt

.. _docutils: https://pypi.python.org/pypi/docutils

.. _geoip2: https://pypi.python.org/pypi/geoip2

.. _jinja2: https://pypi.python.org/pypi/jinja2

.. _numpy: https://pypi.python.org/pypi/numpy

.. _Pillow: https://pypi.python.org/pypi/Pillow/

=======================

Geolocation with GeoIP2

=======================

.. module:: django.contrib.gis.geoip2

   :synopsis: Python interface for MaxMind's GeoIP2 databases.

.. versionadded:: 1.9

The :class:`GeoIP2` object is a wrapper for the `MaxMind geoip2 Python

library`__. [#]_

In order to perform IP-based geolocation, the :class:`GeoIP2` object requires

the `geoip2 Python library`__ and the GeoIP `Country` and/or `City` `datasets

in binary format`__ (the CSV files will not work!). Grab the

``GeoLite2-Country.mmdb.gz`` and ``GeoLite2-City.mmdb.gz`` files and unzip them

in a directory corresponding to the :setting:`GEOIP_PATH` setting.

Additionally, it is recommended to install the `libmaxminddb C library`__, so

that ``geoip2`` can leverage the C library's faster speed.

__ http://geoip2.readthedocs.org/

__ https://pypi.python.org/pypi/geoip2

__ http://dev.maxmind.com/geoip/geoip2/geolite2/

__ https://github.com/maxmind/libmaxminddb

Example

=======

Here is an example of its usage::

     >>> from django.contrib.gis.geoip2 import GeoIP2

     >>> g = GeoIP2()

     >>> g.country('google.com')

     {'country_code': 'US', 'country_name': 'United States'}

     >>> g.city('72.14.207.99')

     {'city': 'Mountain View',

     'country_code': 'US',

     'country_name': 'United States',

     'dma_code': 807,

     'latitude': 37.419200897216797,

     'longitude': -122.05740356445312,

     'postal_code': '94043',

     'region': 'CA'}

     >>> g.lat_lon('salon.com')

     (39.0437, -77.4875)

     >>> g.lon_lat('uh.edu')

     (-95.4342, 29.834)

     >>> g.geos('24.124.1.80').wkt

     'POINT (-97.0000000000000000 38.0000000000000000)'

``GeoIP`` Settings

==================

.. setting:: GEOIP_PATH

GEOIP_PATH

----------

A string specifying the directory where the GeoIP data files are

located. This setting is *required* unless manually specified

with ``path`` keyword when initializing the :class:`GeoIP2` object.

.. setting:: GEOIP_COUNTRY

GEOIP_COUNTRY

-------------

The basename to use for the GeoIP country data file. Defaults to

``'GeoLite2-Country.mmdb'``.

.. setting:: GEOIP_CITY

GEOIP_CITY

----------

The basename to use for the GeoIP city data file. Defaults to

``'GeoLite2-City.mmdb'``.

``GeoIP`` API

=============

.. class:: GeoIP2(path=None, cache=0, country=None, city=None)

The ``GeoIP`` object does not require any parameters to use the default

settings. However, at the very least the :setting:`GEOIP_PATH` setting

should be set with the path of the location of your GeoIP datasets. The

following initialization keywords may be used to customize any of the

defaults.

===================  =======================================================

Keyword Arguments    Description

===================  =======================================================

``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 datasets are located in this directory;

                     overrides the :setting:`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``, and

                     ``GEOIP_INDEX_CACHE`` ``MODE_MEMORY`` C API settings,

                     respectively. Defaults to 0 (``MODE_AUTO``).

``country``          The name of the GeoIP country data file. Defaults

                     to ``GeoLite2-Country.mmdb``. Setting this keyword

                     overrides the :setting:`GEOIP_COUNTRY` setting.

``city``             The name of the GeoIP city data file. Defaults to

                     ``GeoLite2-City.mmdb``. Setting this keyword overrides

                     the :setting:`GEOIP_CITY` setting.

===================  =======================================================

``GeoIP`` Methods

=================

Instantiating

-------------

.. classmethod:: GeoIP2.open(path, cache)

This classmethod instantiates the GeoIP object from the given database path

and given cache setting.

Querying

--------

All the following querying routines may take either a string IP address

or a fully qualified domain name (FQDN). For example, both

``'205.186.163.125'`` and ``'djangoproject.com'`` would be valid query

parameters.

.. method:: GeoIP2.city(query)

Returns a dictionary of city information for the given query. Some

of the values in the dictionary may be undefined (``None``).

.. method:: GeoIP2.country(query)

Returns a dictionary with the country code and country for the given

query.

.. method:: GeoIP2.country_code(query)

Returns the country code corresponding to the query.

.. method:: GeoIP2.country_name(query)

Returns the country name corresponding to the query.

Coordinate Retrieval

--------------------

.. method:: GeoIP2.coords(query)

Returns a coordinate tuple of (longitude, latitude).

.. method:: GeoIP2.lon_lat(query)

Returns a coordinate tuple of (longitude, latitude).

.. method:: GeoIP2.lat_lon(query)

Returns a coordinate tuple of (latitude, longitude),

.. method:: GeoIP2.geos(query)

Returns a :class:`~django.contrib.gis.geos.Point` object corresponding to the

query.

.. rubric:: Footnotes

.. [#] GeoIP(R) is a registered trademark of MaxMind, Inc.