diff --git a/django/contrib/gis/geoip/__init__.py b/django/contrib/gis/geoip/__init__.py deleted file mode 100644 index 237567dd8ad..00000000000 --- a/django/contrib/gis/geoip/__init__.py +++ /dev/null @@ -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 diff --git a/django/contrib/gis/geoip/base.py b/django/contrib/gis/geoip/base.py deleted file mode 100644 index d40ae7e9ae8..00000000000 --- a/django/contrib/gis/geoip/base.py +++ /dev/null @@ -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 diff --git a/django/contrib/gis/geoip/libgeoip.py b/django/contrib/gis/geoip/libgeoip.py deleted file mode 100644 index c5f5d24b827..00000000000 --- a/django/contrib/gis/geoip/libgeoip.py +++ /dev/null @@ -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 diff --git a/django/contrib/gis/geoip/prototypes.py b/django/contrib/gis/geoip/prototypes.py deleted file mode 100644 index 74b9b2142f0..00000000000 --- a/django/contrib/gis/geoip/prototypes.py +++ /dev/null @@ -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) diff --git a/docs/ref/contrib/gis/geoip.txt b/docs/ref/contrib/gis/geoip.txt deleted file mode 100644 index 212aee12afe..00000000000 --- a/docs/ref/contrib/gis/geoip.txt +++ /dev/null @@ -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 - `, 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. diff --git a/docs/ref/contrib/gis/index.txt b/docs/ref/contrib/gis/index.txt index 7345a514012..24d9172841c 100644 --- a/docs/ref/contrib/gis/index.txt +++ b/docs/ref/contrib/gis/index.txt @@ -22,7 +22,6 @@ of spatially enabled data. measure geos gdal - geoip geoip2 utils commands diff --git a/docs/releases/2.0.txt b/docs/releases/2.0.txt index 88b24e9b553..35859c05ca7 100644 --- a/docs/releases/2.0.txt +++ b/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. diff --git a/tests/gis_tests/test_geoip.py b/tests/gis_tests/test_geoip.py deleted file mode 100644 index 4871386ef84..00000000000 --- a/tests/gis_tests/test_geoip.py +++ /dev/null @@ -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='') - # 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='') - - 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='') - - 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 = '' % { - 'version': force_text(GeoIP_lib_version()), - 'country': country_path, - 'city': city_path, - } - else: - expected = '' % { - 'country': country_path, - 'city': city_path, - } - self.assertEqual(repr(g), expected)