Refs #25184 -- Removed contrib.gis.geoip per deprecation timeline.

django/contrib/gis/geoip/__init__.py

@@ -1,21 +0,0 @@
-"""
- This module houses the GeoIP object, a ctypes wrapper for the MaxMind GeoIP(R)
- C API (http://www.maxmind.com/app/c).  This is an alternative to the GPL
- licensed Python GeoIP interface provided by MaxMind.
-
- GeoIP(R) is a registered trademark of MaxMind, LLC of Boston, Massachusetts.
-
- For IP-based geolocation, this module requires the GeoLite Country and City
- datasets, in binary format (CSV will not work!).  The datasets may be
- downloaded from MaxMind at http://www.maxmind.com/download/geoip/database/.
- Grab GeoIP.dat.gz and GeoLiteCity.dat.gz, and unzip them in the directory
- corresponding to settings.GEOIP_PATH.
-"""
-__all__ = ['HAS_GEOIP']
-
-try:
-    from .base import GeoIP, GeoIPException
-    HAS_GEOIP = True
-    __all__ += ['GeoIP', 'GeoIPException']
-except RuntimeError:  # libgeoip.py raises a RuntimeError if no GeoIP library is found
-    HAS_GEOIP = False

django/contrib/gis/geoip/base.py

@@ -1,292 +0,0 @@
-import os
-import re
-import warnings
-from ctypes import c_char_p
-
-from django.contrib.gis.geoip.libgeoip import GEOIP_SETTINGS
-from django.contrib.gis.geoip.prototypes import (
-    GeoIP_country_code_by_addr, GeoIP_country_code_by_name,
-    GeoIP_country_name_by_addr, GeoIP_country_name_by_name,
-    GeoIP_database_info, GeoIP_delete, GeoIP_lib_version, GeoIP_open,
-    GeoIP_record_by_addr, GeoIP_record_by_name,
-)
-from django.core.validators import ipv4_re
-from django.utils import six
-from django.utils.deprecation import RemovedInDjango20Warning
-from django.utils.encoding import force_bytes, force_text
-
-# Regular expressions for recognizing the GeoIP free database editions.
-free_regex = re.compile(r'^GEO-\d{3}FREE')
-lite_regex = re.compile(r'^GEO-\d{3}LITE')
-
-
-class GeoIPException(Exception):
-    pass
-
-
-class GeoIP(object):
-    # The flags for GeoIP memory caching.
-    # GEOIP_STANDARD - read database from filesystem, uses least memory.
-    #
-    # GEOIP_MEMORY_CACHE - load database into memory, faster performance
-    #        but uses more memory
-    #
-    # GEOIP_CHECK_CACHE - check for updated database.  If database has been
-    #        updated, reload filehandle and/or memory cache.  This option
-    #        is not thread safe.
-    #
-    # GEOIP_INDEX_CACHE - just cache the most frequently accessed index
-    #        portion of the database, resulting in faster lookups than
-    #        GEOIP_STANDARD, but less memory usage than GEOIP_MEMORY_CACHE -
-    #        useful for larger databases such as GeoIP Organization and
-    #        GeoIP City.  Note, for GeoIP Country, Region and Netspeed
-    #        databases, GEOIP_INDEX_CACHE is equivalent to GEOIP_MEMORY_CACHE
-    #
-    # GEOIP_MMAP_CACHE - load database into mmap shared memory ( not available
-    #       on Windows).
-    GEOIP_STANDARD = 0
-    GEOIP_MEMORY_CACHE = 1
-    GEOIP_CHECK_CACHE = 2
-    GEOIP_INDEX_CACHE = 4
-    GEOIP_MMAP_CACHE = 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):
-        """
-        Initializes the GeoIP object, no parameters are required to use default
-        settings.  Keyword arguments may be passed in to customize the locations
-        of the GeoIP data sets.
-
-        * path: Base directory to where GeoIP data is located or the full path
-            to where the city or country data files (*.dat) are located.
-            Assumes that both the city and country data sets are located in
-            this directory; overrides the GEOIP_PATH settings attribute.
-
-        * cache: The cache settings when opening up the GeoIP datasets,
-            and may be an integer in (0, 1, 2, 4, 8) corresponding to
-            the GEOIP_STANDARD, GEOIP_MEMORY_CACHE, GEOIP_CHECK_CACHE,
-            GEOIP_INDEX_CACHE, and GEOIP_MMAP_CACHE, `GeoIPOptions` C API
-            settings,  respectively.  Defaults to 0, meaning that the data is read
-            from the disk.
-
-        * country: The name of the GeoIP country data file.  Defaults to
-            'GeoIP.dat'; overrides the GEOIP_COUNTRY settings attribute.
-
-        * city: The name of the GeoIP city data file.  Defaults to
-            'GeoLiteCity.dat'; overrides the GEOIP_CITY settings attribute.
-        """
-
-        warnings.warn(
-            "django.contrib.gis.geoip is deprecated in favor of "
-            "django.contrib.gis.geoip2 and the MaxMind GeoLite2 database "
-            "format.", RemovedInDjango20Warning, 2
-        )
-
-        # Checking the given cache option.
-        if cache in self.cache_options:
-            self._cache = cache
-        else:
-            raise GeoIPException('Invalid GeoIP caching option: %s' % cache)
-
-        # Getting the GeoIP data path.
-        if not path:
-            path = GEOIP_SETTINGS.get('GEOIP_PATH')
-            if not path:
-                raise GeoIPException('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 and open them.
-            country_db = os.path.join(path, country or GEOIP_SETTINGS.get('GEOIP_COUNTRY', 'GeoIP.dat'))
-            if os.path.isfile(country_db):
-                self._country = GeoIP_open(force_bytes(country_db), cache)
-                self._country_file = country_db
-
-            city_db = os.path.join(path, city or GEOIP_SETTINGS.get('GEOIP_CITY', 'GeoLiteCity.dat'))
-            if os.path.isfile(city_db):
-                self._city = GeoIP_open(force_bytes(city_db), 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.
-            ptr = GeoIP_open(force_bytes(path), cache)
-            info = GeoIP_database_info(ptr)
-            if lite_regex.match(info):
-                # GeoLite City database detected.
-                self._city = ptr
-                self._city_file = path
-            elif free_regex.match(info):
-                # GeoIP Country database detected.
-                self._country = ptr
-                self._country_file = path
-            else:
-                raise GeoIPException('Unable to recognize database edition: %s' % info)
-        else:
-            raise GeoIPException('GeoIP path must be a valid file or directory.')
-
-    def __del__(self):
-        # Cleaning any GeoIP file handles lying around.
-        if GeoIP_delete is None:
-            return
-        if self._country:
-            GeoIP_delete(self._country)
-        if self._city:
-            GeoIP_delete(self._city)
-
-    def __repr__(self):
-        version = ''
-        if GeoIP_lib_version is not None:
-            version += ' [v%s]' % force_text(GeoIP_lib_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, 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 GeoIPException('Invalid GeoIP country and city data files.')
-        elif country and not self._country:
-            raise GeoIPException('Invalid GeoIP country data file: %s' % self._country_file)
-        elif city and not self._city:
-            raise GeoIPException('Invalid GeoIP city data file: %s' % self._city_file)
-
-        # Return the query string back to the caller. GeoIP only takes bytestrings.
-        return force_bytes(query)
-
-    def city(self, query):
-        """
-        Returns 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)
-        if ipv4_re.match(query):
-            # If an IP address was passed in
-            return GeoIP_record_by_addr(self._city, c_char_p(enc_query))
-        else:
-            # If a FQDN was passed in.
-            return GeoIP_record_by_name(self._city, c_char_p(enc_query))
-
-    def country_code(self, query):
-        "Returns the country code for the given IP Address or FQDN."
-        enc_query = self._check_query(query, city_or_country=True)
-        if self._country:
-            if ipv4_re.match(query):
-                return GeoIP_country_code_by_addr(self._country, enc_query)
-            else:
-                return GeoIP_country_code_by_name(self._country, enc_query)
-        else:
-            return self.city(query)['country_code']
-
-    def country_name(self, query):
-        "Returns the country name for the given IP Address or FQDN."
-        enc_query = self._check_query(query, city_or_country=True)
-        if self._country:
-            if ipv4_re.match(query):
-                return GeoIP_country_name_by_addr(self._country, enc_query)
-            else:
-                return GeoIP_country_name_by_name(self._country, enc_query)
-        else:
-            return self.city(query)['country_name']
-
-    def country(self, query):
-        """
-        Returns 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
-        return {'country_code': self.country_code(query),
-                'country_name': self.country_name(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):
-        "Returns a tuple of the (longitude, latitude) for the given query."
-        return self.coords(query)
-
-    def lat_lon(self, query):
-        "Returns a tuple of the (latitude, longitude) for the given query."
-        return self.coords(query, ('latitude', 'longitude'))
-
-    def geos(self, query):
-        "Returns 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 country_info(self):
-        "Returns information about the GeoIP country database."
-        if self._country is None:
-            ci = 'No GeoIP Country data in "%s"' % self._country_file
-        else:
-            ci = GeoIP_database_info(self._country)
-        return ci
-
-    @property
-    def city_info(self):
-        "Returns information about the GeoIP city database."
-        if self._city is None:
-            ci = 'No GeoIP City data in "%s"' % self._city_file
-        else:
-            ci = GeoIP_database_info(self._city)
-        return ci
-
-    @property
-    def info(self):
-        "Returns information about the GeoIP library and databases in use."
-        info = ''
-        if GeoIP_lib_version:
-            info += 'GeoIP Library:\n\t%s\n' % GeoIP_lib_version()
-        return info + 'Country:\n\t%s\nCity:\n\t%s' % (self.country_info, self.city_info)
-
-    # #### Methods for compatibility w/the GeoIP-Python API. ####
-    @classmethod
-    def open(cls, full_path, cache):
-        return GeoIP(full_path, cache)
-
-    def _rec_by_arg(self, arg):
-        if self._city:
-            return self.city(arg)
-        else:
-            return self.country(arg)
-    region_by_addr = city
-    region_by_name = city
-    record_by_addr = _rec_by_arg
-    record_by_name = _rec_by_arg
-    country_code_by_addr = country_code
-    country_code_by_name = country_code
-    country_name_by_addr = country_name
-    country_name_by_name = country_name

django/contrib/gis/geoip/libgeoip.py

@@ -1,34 +0,0 @@
-import os
-from ctypes import CDLL
-from ctypes.util import find_library
-
-from django.conf import settings
-
-# Creating the settings dictionary with any settings, if needed.
-GEOIP_SETTINGS = {key: getattr(settings, key)
-                  for key in ('GEOIP_PATH', 'GEOIP_LIBRARY_PATH', 'GEOIP_COUNTRY', 'GEOIP_CITY')
-                  if hasattr(settings, key)}
-lib_path = GEOIP_SETTINGS.get('GEOIP_LIBRARY_PATH')
-
-# The shared library for the GeoIP C API.  May be downloaded
-#  from http://www.maxmind.com/download/geoip/api/c/
-if lib_path:
-    lib_name = None
-else:
-    # TODO: Is this really the library name for Windows?
-    lib_name = 'GeoIP'
-
-# Getting the path to the GeoIP library.
-if lib_name:
-    lib_path = find_library(lib_name)
-if lib_path is None:
-    raise RuntimeError('Could not find the GeoIP library (tried "%s"). '
-                       'Try setting GEOIP_LIBRARY_PATH in your settings.' % lib_name)
-lgeoip = CDLL(lib_path)
-
-# Getting the C `free` for the platform.
-if os.name == 'nt':
-    libc = CDLL('msvcrt')
-else:
-    libc = CDLL(None)
-free = libc.free

django/contrib/gis/geoip/prototypes.py

@@ -1,132 +0,0 @@
-from ctypes import POINTER, Structure, c_char_p, c_float, c_int, string_at
-
-from django.contrib.gis.geoip.libgeoip import free, lgeoip
-
-
-# #### GeoIP C Structure definitions ####
-
-class GeoIPRecord(Structure):
-    _fields_ = [('country_code', c_char_p),
-                ('country_code3', c_char_p),
-                ('country_name', c_char_p),
-                ('region', c_char_p),
-                ('city', c_char_p),
-                ('postal_code', c_char_p),
-                ('latitude', c_float),
-                ('longitude', c_float),
-                # TODO: In 1.4.6 this changed from `int dma_code;` to
-                # `union {int metro_code; int dma_code;};`.  Change
-                # to a `ctypes.Union` in to accommodate in future when
-                # pre-1.4.6 versions are no longer distributed.
-                ('dma_code', c_int),
-                ('area_code', c_int),
-                ('charset', c_int),
-                ('continent_code', c_char_p),
-                ]
-
-
-geoip_char_fields = [name for name, ctype in GeoIPRecord._fields_ if ctype is c_char_p]
-GEOIP_DEFAULT_ENCODING = 'iso-8859-1'
-geoip_encodings = {
-    0: 'iso-8859-1',
-    1: 'utf8',
-}
-
-
-class GeoIPTag(Structure):
-    pass
-
-
-RECTYPE = POINTER(GeoIPRecord)
-DBTYPE = POINTER(GeoIPTag)
-
-# #### ctypes function prototypes ####
-
-# GeoIP_lib_version appeared in version 1.4.7.
-if hasattr(lgeoip, 'GeoIP_lib_version'):
-    GeoIP_lib_version = lgeoip.GeoIP_lib_version
-    GeoIP_lib_version.argtypes = None
-    GeoIP_lib_version.restype = c_char_p
-else:
-    GeoIP_lib_version = None
-
-# For freeing memory allocated within a record
-GeoIPRecord_delete = lgeoip.GeoIPRecord_delete
-GeoIPRecord_delete.argtypes = [RECTYPE]
-GeoIPRecord_delete.restype = None
-
-
-# For retrieving records by name or address.
-def check_record(result, func, cargs):
-    if result:
-        # Checking the pointer to the C structure, if valid pull out elements
-        # into a dictionary.
-        rec = result.contents
-        record = {fld: getattr(rec, fld) for fld, ctype in rec._fields_}
-
-        # Now converting the strings to unicode using the proper encoding.
-        encoding = geoip_encodings[record['charset']]
-        for char_field in geoip_char_fields:
-            if record[char_field]:
-                record[char_field] = record[char_field].decode(encoding)
-
-        # Free the memory allocated for the struct & return.
-        GeoIPRecord_delete(result)
-        return record
-    else:
-        return None
-
-
-def record_output(func):
-    func.argtypes = [DBTYPE, c_char_p]
-    func.restype = RECTYPE
-    func.errcheck = check_record
-    return func
-
-
-GeoIP_record_by_addr = record_output(lgeoip.GeoIP_record_by_addr)
-GeoIP_record_by_name = record_output(lgeoip.GeoIP_record_by_name)
-
-
-# For opening & closing GeoIP database files.
-GeoIP_open = lgeoip.GeoIP_open
-GeoIP_open.restype = DBTYPE
-GeoIP_delete = lgeoip.GeoIP_delete
-GeoIP_delete.argtypes = [DBTYPE]
-GeoIP_delete.restype = None
-
-
-# This is so the string pointer can be freed within Python.
-class geoip_char_p(c_char_p):
-    pass
-
-
-def check_string(result, func, cargs):
-    if result:
-        s = string_at(result)
-        free(result)
-    else:
-        s = ''
-    return s.decode(GEOIP_DEFAULT_ENCODING)
-
-
-GeoIP_database_info = lgeoip.GeoIP_database_info
-GeoIP_database_info.restype = geoip_char_p
-GeoIP_database_info.errcheck = check_string
-
-
-# String output routines.
-def string_output(func):
-    def _err_check(result, func, cargs):
-        if result:
-            return result.decode(GEOIP_DEFAULT_ENCODING)
-        return result
-    func.restype = c_char_p
-    func.errcheck = _err_check
-    return func
-
-
-GeoIP_country_code_by_addr = string_output(lgeoip.GeoIP_country_code_by_addr)
-GeoIP_country_code_by_name = string_output(lgeoip.GeoIP_country_code_by_name)
-GeoIP_country_name_by_addr = string_output(lgeoip.GeoIP_country_name_by_addr)
-GeoIP_country_name_by_name = string_output(lgeoip.GeoIP_country_name_by_name)

docs/ref/contrib/gis/geoip.txt

@@ -1,223 +0,0 @@
-======================
-Geolocation with GeoIP
-======================
-
-.. module:: django.contrib.gis.geoip
-    :synopsis: High-level Python interface for MaxMind's GeoIP C library.
-
-.. deprecated:: 1.9
-
-    This module is deprecated in favor of :doc:`django.contrib.gis.geoip2
-    </ref/contrib/gis/geoip2>`, which supports IPv6 and the GeoLite2 database
-    format.
-
-The :class:`GeoIP` object is a ctypes wrapper for the
-`MaxMind GeoIP C API`__. [#]_
-
-In order to perform IP-based geolocation, the :class:`GeoIP` object requires
-the GeoIP C library and either the GeoIP `Country`__ or `City`__
-datasets in binary format (the CSV files will not work!).  These datasets may be
-`downloaded from MaxMind`__.  Grab the ``GeoLiteCountry/GeoIP.dat.gz`` and
-``GeoLiteCity.dat.gz`` files and unzip them in a directory corresponding to what
-you set :setting:`GEOIP_PATH` with in your settings.  See the example and
-reference below for more details.
-
-__ https://www.maxmind.com/app/c
-__ https://www.maxmind.com/app/country
-__ https://www.maxmind.com/app/city
-__ https://www.maxmind.com/download/geoip/database/
-
-Example
-=======
-
-Assuming you have the GeoIP C library installed, here is an example of its
-usage::
-
-    >>> from django.contrib.gis.geoip import GeoIP
-    >>> g = GeoIP()
-    >>> g.country('google.com')
-    {'country_code': 'US', 'country_name': 'United States'}
-    >>> g.city('72.14.207.99')
-    {'area_code': 650,
-    'city': 'Mountain View',
-    'country_code': 'US',
-    'country_code3': 'USA',
-    'country_name': 'United States',
-    'dma_code': 807,
-    'latitude': 37.419200897216797,
-    'longitude': -122.05740356445312,
-    'postal_code': '94043',
-    'region': 'CA'}
-    >>> g.lat_lon('salon.com')
-    (37.789798736572266, -122.39420318603516)
-    >>> g.lon_lat('uh.edu')
-    (-95.415199279785156, 29.77549934387207)
-    >>> g.geos('24.124.1.80').wkt
-    'POINT (-95.2087020874023438 39.0392990112304688)'
-
-``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:`GeoIP` object.
-
-.. setting:: GEOIP_LIBRARY_PATH
-
-``GEOIP_LIBRARY_PATH``
-----------------------
-
-A string specifying the location of the GeoIP C library.  Typically,
-this setting is only used if the GeoIP C library is in a non-standard
-location (e.g., ``/home/sue/lib/libGeoIP.so``).
-
-.. setting:: GEOIP_COUNTRY
-
-``GEOIP_COUNTRY``
------------------
-
-The basename to use for the GeoIP country data file.
-Defaults to ``'GeoIP.dat'``.
-
-.. setting:: GEOIP_CITY
-
-``GEOIP_CITY``
---------------
-
-The basename to use for the GeoIP city data file.
-Defaults to ``'GeoLiteCity.dat'``.
-
-``GeoIP`` API
-=============
-
-.. class:: GeoIP(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 data sets.  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
-                     (.dat) are located.  Assumes that both the city and
-                     country data sets are located in this directory;
-                     overrides the :setting:`GEOIP_PATH` settings attribute.
-
-``cache``            The cache settings when opening up the GeoIP datasets,
-                     and may be an integer in (0, 1, 2, 4) corresponding to
-                     the ``GEOIP_STANDARD``, ``GEOIP_MEMORY_CACHE``,
-                     ``GEOIP_CHECK_CACHE``, and ``GEOIP_INDEX_CACHE``
-                     ``GeoIPOptions`` C API settings, respectively.
-                     Defaults to 0 (``GEOIP_STANDARD``).
-
-``country``          The name of the GeoIP country data file.  Defaults
-                     to ``GeoIP.dat``.  Setting this keyword overrides the
-                     :setting:`GEOIP_COUNTRY` settings attribute.
-
-``city``             The name of the GeoIP city data file.  Defaults to
-                     ``GeoLiteCity.dat``.  Setting this keyword overrides
-                     the :setting:`GEOIP_CITY` settings attribute.
-===================  =======================================================
-
-``GeoIP`` Methods
-=================
-
-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:: GeoIP.city(query)
-
-Returns a dictionary of city information for the given query.  Some
-of the values in the dictionary may be undefined (``None``).
-
-.. method:: GeoIP.country(query)
-
-Returns a dictionary with the country code and country for the given
-query.
-
-.. method:: GeoIP.country_code(query)
-
-Returns only the country code corresponding to the query.
-
-.. method:: GeoIP.country_name(query)
-
-Returns only the country name corresponding to the query.
-
-Coordinate Retrieval
---------------------
-
-.. method:: GeoIP.coords(query)
-
-Returns a coordinate tuple of (longitude, latitude).
-
-.. method:: GeoIP.lon_lat(query)
-
-Returns a coordinate tuple of (longitude, latitude).
-
-.. method:: GeoIP.lat_lon(query)
-
-Returns a coordinate tuple of (latitude, longitude),
-
-.. method:: GeoIP.geos(query)
-
-Returns a :class:`django.contrib.gis.geos.Point` object corresponding to the query.
-
-Database Information
---------------------
-
-.. attribute:: GeoIP.country_info
-
-This property returns information about the GeoIP country database.
-
-.. attribute:: GeoIP.city_info
-
-This property returns information about the GeoIP city database.
-
-.. attribute:: GeoIP.info
-
-This property returns information about all GeoIP databases (both city
-and country), and the version of the GeoIP C library (if supported).
-
-GeoIP-Python API compatibility methods
-----------------------------------------
-
-These methods exist to ease compatibility with any code using MaxMind's
-existing Python API.
-
-.. classmethod:: GeoIP.open(path, cache)
-
-This classmethod instantiates the GeoIP object from the given database path
-and given cache setting.
-
-.. method:: GeoIP.region_by_addr(query)
-
-.. method:: GeoIP.region_by_name(query)
-
-.. method:: GeoIP.record_by_addr(query)
-
-.. method:: GeoIP.record_by_name(query)
-
-.. method:: GeoIP.country_code_by_addr(query)
-
-.. method:: GeoIP.country_code_by_name(query)
-
-.. method:: GeoIP.country_name_by_addr(query)
-
-.. method:: GeoIP.country_name_by_name(query)
-
-.. rubric:: Footnotes
-.. [#] GeoIP(R) is a registered trademark of MaxMind, LLC of Boston, Massachusetts.

docs/ref/contrib/gis/index.txt

@@ -22,7 +22,6 @@ of spatially enabled data.
     measure
     geos
     gdal
-    geoip
     geoip2
     utils
     commands

docs/releases/2.0.txt

@@ -263,3 +263,5 @@ these features.
 * ``django.contrib.auth.tests.utils.skipIfCustomUser()`` is removed.
 
 * The ``GeoManager`` and ``GeoQuerySet`` classes are removed.
+
+* The ``django.contrib.gis.geoip`` module is removed.

tests/gis_tests/test_geoip.py

@@ -1,178 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
-import os
-import socket
-import unittest
-import warnings
-from unittest import skipUnless
-
-from django.conf import settings
-from django.contrib.gis.geoip import HAS_GEOIP
-from django.contrib.gis.geos import HAS_GEOS, GEOSGeometry
-from django.test import ignore_warnings
-from django.utils import six
-from django.utils.deprecation import RemovedInDjango20Warning
-from django.utils.encoding import force_text
-
-if HAS_GEOIP:
-    from django.contrib.gis.geoip import GeoIP, GeoIPException
-    from django.contrib.gis.geoip.prototypes import GeoIP_lib_version
-
-
-# Note: Requires use of both the GeoIP country and city datasets.
-# The GEOIP_DATA path should be the only setting set (the directory
-# should contain links or the actual database files 'GeoIP.dat' and
-# 'GeoLiteCity.dat'.
-
-
-@skipUnless(
-    HAS_GEOIP and getattr(settings, "GEOIP_PATH", None),
-    "GeoIP is required along with the GEOIP_PATH setting."
-)
-@ignore_warnings(category=RemovedInDjango20Warning)
-class GeoIPTest(unittest.TestCase):
-    addr = '162.242.220.127'
-    fqdn = 'www.djangoproject.com'
-
-    def _is_dns_available(self, domain):
-        # Naive check to see if there is DNS available to use.
-        # Used to conditionally skip fqdn geoip checks.
-        # See #25407 for details.
-        ErrClass = socket.error if six.PY2 else OSError
-        try:
-            socket.gethostbyname(domain)
-            return True
-        except ErrClass:
-            return False
-
-    def test01_init(self):
-        "Testing GeoIP initialization."
-        g1 = GeoIP()  # Everything inferred from GeoIP path
-        path = settings.GEOIP_PATH
-        g2 = GeoIP(path, 0)  # Passing in data path explicitly.
-        g3 = GeoIP.open(path, 0)  # MaxMind Python API syntax.
-
-        for g in (g1, g2, g3):
-            self.assertTrue(g._country)
-            self.assertTrue(g._city)
-
-        # Only passing in the location of one database.
-        city = os.path.join(path, 'GeoLiteCity.dat')
-        cntry = os.path.join(path, 'GeoIP.dat')
-        g4 = GeoIP(city, country='')
-        self.assertIsNone(g4._country)
-        g5 = GeoIP(cntry, city='')
-        self.assertIsNone(g5._city)
-
-        # Improper parameters.
-        bad_params = (23, 'foo', 15.23)
-        for bad in bad_params:
-            with self.assertRaises(GeoIPException):
-                GeoIP(cache=bad)
-            if isinstance(bad, six.string_types):
-                e = GeoIPException
-            else:
-                e = TypeError
-            with self.assertRaises(e):
-                GeoIP(bad, 0)
-
-    def test02_bad_query(self):
-        "Testing GeoIP query parameter checking."
-        cntry_g = GeoIP(city='<foo>')
-        # No city database available, these calls should fail.
-        with self.assertRaises(GeoIPException):
-            cntry_g.city('google.com')
-        with self.assertRaises(GeoIPException):
-            cntry_g.coords('yahoo.com')
-
-        # Non-string query should raise TypeError
-        with self.assertRaises(TypeError):
-            cntry_g.country_code(17)
-        with self.assertRaises(TypeError):
-            cntry_g.country_name(GeoIP)
-
-    def test03_country(self):
-        "Testing GeoIP country querying methods."
-        g = GeoIP(city='<foo>')
-
-        queries = [self.addr]
-        if self._is_dns_available(self.fqdn):
-            queries.append(self.fqdn)
-        for query in queries:
-            for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
-                self.assertEqual('US', func(query), 'Failed for func %s and query %s' % (func, query))
-            for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
-                self.assertEqual('United States', func(query), 'Failed for func %s and query %s' % (func, query))
-            self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
-                             g.country(query))
-
-    @skipUnless(HAS_GEOS, "Geos is required")
-    def test04_city(self):
-        "Testing GeoIP city querying methods."
-        g = GeoIP(country='<foo>')
-
-        queries = [self.addr]
-        if self._is_dns_available(self.fqdn):
-            queries.append(self.fqdn)
-        for query in queries:
-            # Country queries should still work.
-            for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
-                self.assertEqual('US', func(query))
-            for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
-                self.assertEqual('United States', func(query))
-            self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
-                             g.country(query))
-
-            # City information dictionary.
-            d = g.city(query)
-            self.assertEqual('USA', d['country_code3'])
-            self.assertEqual('San Antonio', d['city'])
-            self.assertEqual('TX', d['region'])
-            self.assertEqual(210, d['area_code'])
-            geom = g.geos(query)
-            self.assertIsInstance(geom, GEOSGeometry)
-            lon, lat = (-98, 29)
-            lat_lon = g.lat_lon(query)
-            lat_lon = (lat_lon[1], lat_lon[0])
-            for tup in (geom.tuple, g.coords(query), g.lon_lat(query), lat_lon):
-                self.assertAlmostEqual(lon, tup[0], 0)
-                self.assertAlmostEqual(lat, tup[1], 0)
-
-    def test05_unicode_response(self):
-        "Testing that GeoIP strings are properly encoded, see #16553."
-        g = GeoIP()
-        fqdn = "hs-duesseldorf.de"
-        if self._is_dns_available(fqdn):
-            d = g.city(fqdn)
-            self.assertEqual('Düsseldorf', d['city'])
-        d = g.country('200.26.205.1')
-        # Some databases have only unaccented countries
-        self.assertIn(d['country_name'], ('Curaçao', 'Curacao'))
-
-    def test_deprecation_warning(self):
-        with warnings.catch_warnings(record=True) as warns:
-            warnings.simplefilter('always')
-            GeoIP()
-
-        self.assertEqual(len(warns), 1)
-        msg = str(warns[0].message)
-        self.assertIn('django.contrib.gis.geoip is deprecated', msg)
-
-    def test_repr(self):
-        path = settings.GEOIP_PATH
-        g = GeoIP(path=path)
-        country_path = g._country_file
-        city_path = g._city_file
-        if GeoIP_lib_version:
-            expected = '<GeoIP [v%(version)s] _country_file="%(country)s", _city_file="%(city)s">' % {
-                'version': force_text(GeoIP_lib_version()),
-                'country': country_path,
-                'city': city_path,
-            }
-        else:
-            expected = '<GeoIP _country_file="%(country)s", _city_file="%(city)s">' % {
-                'country': country_path,
-                'city': city_path,
-            }
-        self.assertEqual(repr(g), expected)