Upgrade to Django 1.11

- Database integration yet to be tested

29 files changed, 0 insertions, 4726 deletions

diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py
deleted file mode 100644
index 945f561..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""
-The GeoDjango GEOS module.  Please consult the GeoDjango documentation
-for more details: 
-  http://geodjango.org/docs/geos.html
-"""
-try:
-    from .libgeos import geos_version, geos_version_info, GEOS_PREPARE
-    HAS_GEOS = True
-except ImportError:
-    HAS_GEOS = False
-
-if HAS_GEOS:
-    from .geometry import GEOSGeometry, wkt_regex, hex_regex
-    from .point import Point
-    from .linestring import LineString, LinearRing
-    from .polygon import Polygon
-    from .collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon
-    from .error import GEOSException, GEOSIndexError
-    from .io import WKTReader, WKTWriter, WKBReader, WKBWriter
-    from .factory import fromfile, fromstr
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/base.py b/lib/python2.7/site-packages/django/contrib/gis/geos/base.py
deleted file mode 100644
index fd2693e..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/base.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from ctypes import c_void_p
-
-from django.contrib.gis.geos.error import GEOSException
-
-# Trying to import GDAL libraries, if available.  Have to place in
-# try/except since this package may be used outside GeoDjango.
-try:
-    from django.contrib.gis import gdal
-except ImportError:
-    # A 'dummy' gdal module.
-    class GDALInfo(object):
-        HAS_GDAL = False
-    gdal = GDALInfo()
-
-# NumPy supported?
-try:
-    import numpy
-except ImportError:
-    numpy = False
-
-class GEOSBase(object):
-    """
-    Base object for GEOS objects that has a pointer access property
-    that controls access to the underlying C pointer.
-    """
-    # Initially the pointer is NULL.
-    _ptr = None
-
-    # Default allowed pointer type.
-    ptr_type = c_void_p
-
-    # Pointer access property.
-    def _get_ptr(self):
-        # Raise an exception if the pointer isn't valid don't
-        # want to be passing NULL pointers to routines --
-        # that's very bad.
-        if self._ptr: return self._ptr
-        else: raise GEOSException('NULL GEOS %s pointer encountered.' % self.__class__.__name__)
-
-    def _set_ptr(self, ptr):
-        # Only allow the pointer to be set with pointers of the
-        # compatible type or None (NULL).
-        if ptr is None or isinstance(ptr, self.ptr_type):
-            self._ptr = ptr
-        else:
-            raise TypeError('Incompatible pointer type')
-
-    # Property for controlling access to the GEOS object pointers.  Using
-    # this raises an exception when the pointer is NULL, thus preventing
-    # the C library from attempting to access an invalid memory location.
-    ptr = property(_get_ptr, _set_ptr)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py b/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py
deleted file mode 100644
index 2b62bce..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""
- This module houses the Geometry Collection objects:
- GeometryCollection, MultiPoint, MultiLineString, and MultiPolygon
-"""
-from ctypes import c_int, c_uint, byref
-from django.contrib.gis.geos.error import GEOSException
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOS_PREPARE
-from django.contrib.gis.geos.linestring import LineString, LinearRing
-from django.contrib.gis.geos.point import Point
-from django.contrib.gis.geos.polygon import Polygon
-from django.contrib.gis.geos import prototypes as capi
-from django.utils.six.moves import xrange
-
-class GeometryCollection(GEOSGeometry):
-    _typeid = 7
-
-    def __init__(self, *args, **kwargs):
-        "Initializes a Geometry Collection from a sequence of Geometry objects."
-
-        # Checking the arguments
-        if not args:
-            raise TypeError('Must provide at least one Geometry to initialize %s.' % self.__class__.__name__)
-
-        if len(args) == 1:
-            # If only one geometry provided or a list of geometries is provided
-            #  in the first argument.
-            if isinstance(args[0], (tuple, list)):
-                init_geoms = args[0]
-            else:
-                init_geoms = args
-        else:
-            init_geoms = args
-
-        # Ensuring that only the permitted geometries are allowed in this collection
-        # this is moved to list mixin super class
-        self._check_allowed(init_geoms)
-
-        # Creating the geometry pointer array.
-        collection = self._create_collection(len(init_geoms), iter(init_geoms))
-        super(GeometryCollection, self).__init__(collection, **kwargs)
-
-    def __iter__(self):
-        "Iterates over each Geometry in the Collection."
-        for i in xrange(len(self)):
-            yield self[i]
-
-    def __len__(self):
-        "Returns the number of geometries in this Collection."
-        return self.num_geom
-
-    ### Methods for compatibility with ListMixin ###
-    def _create_collection(self, length, items):
-        # Creating the geometry pointer array.
-        geoms = get_pointer_arr(length)
-        for i, g in enumerate(items):
-            # this is a little sloppy, but makes life easier
-            # allow GEOSGeometry types (python wrappers) or pointer types
-            geoms[i] = capi.geom_clone(getattr(g, 'ptr', g))
-
-        return capi.create_collection(c_int(self._typeid), byref(geoms), c_uint(length))
-
-    def _get_single_internal(self, index):
-        return capi.get_geomn(self.ptr, index)
-
-    def _get_single_external(self, index):
-        "Returns the Geometry from this Collection at the given index (0-based)."
-        # Checking the index and returning the corresponding GEOS geometry.
-        return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid)
-
-    def _set_list(self, length, items):
-        "Create a new collection, and destroy the contents of the previous pointer."
-        prev_ptr = self.ptr
-        srid = self.srid
-        self.ptr = self._create_collection(length, items)
-        if srid: self.srid = srid
-        capi.destroy_geom(prev_ptr)
-
-    _set_single = GEOSGeometry._set_single_rebuild
-    _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild
-
-    @property
-    def kml(self):
-        "Returns the KML for this Geometry Collection."
-        return '<MultiGeometry>%s</MultiGeometry>' % ''.join([g.kml for g in self])
-
-    @property
-    def tuple(self):
-        "Returns a tuple of all the coordinates in this Geometry Collection"
-        return tuple([g.tuple for g in self])
-    coords = tuple
-
-# MultiPoint, MultiLineString, and MultiPolygon class definitions.
-class MultiPoint(GeometryCollection):
-    _allowed = Point
-    _typeid = 4
-
-class MultiLineString(GeometryCollection):
-    _allowed = (LineString, LinearRing)
-    _typeid = 5
-
-    @property
-    def merged(self):
-        """
-        Returns a LineString representing the line merge of this
-        MultiLineString.
-        """
-        return self._topology(capi.geos_linemerge(self.ptr))
-
-class MultiPolygon(GeometryCollection):
-    _allowed = Polygon
-    _typeid = 6
-
-    @property
-    def cascaded_union(self):
-        "Returns a cascaded union of this MultiPolygon."
-        if GEOS_PREPARE:
-            return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)
-        else:
-            raise GEOSException('The cascaded union operation requires GEOS 3.1+.')
-
-# Setting the allowed types here since GeometryCollection is defined before
-# its subclasses.
-GeometryCollection._allowed = (Point, LineString, LinearRing, Polygon, MultiPoint, MultiLineString, MultiPolygon)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py b/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py
deleted file mode 100644
index acf34f7..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""
- This module houses the GEOSCoordSeq object, which is used internally
- by GEOSGeometry to house the actual coordinates of the Point,
- LineString, and LinearRing geometries.
-"""
-from ctypes import c_double, c_uint, byref
-from django.contrib.gis.geos.base import GEOSBase, numpy
-from django.contrib.gis.geos.error import GEOSException, GEOSIndexError
-from django.contrib.gis.geos.libgeos import CS_PTR
-from django.contrib.gis.geos import prototypes as capi
-from django.utils.six.moves import xrange
-
-class GEOSCoordSeq(GEOSBase):
-    "The internal representation of a list of coordinates inside a Geometry."
-
-    ptr_type = CS_PTR
-
-    #### Python 'magic' routines ####
-    def __init__(self, ptr, z=False):
-        "Initializes from a GEOS pointer."
-        if not isinstance(ptr, CS_PTR):
-            raise TypeError('Coordinate sequence should initialize with a CS_PTR.')
-        self._ptr = ptr
-        self._z = z
-
-    def __iter__(self):
-        "Iterates over each point in the coordinate sequence."
-        for i in xrange(self.size):
-            yield self[i]
-
-    def __len__(self):
-        "Returns the number of points in the coordinate sequence."
-        return int(self.size)
-
-    def __str__(self):
-        "Returns the string representation of the coordinate sequence."
-        return str(self.tuple)
-
-    def __getitem__(self, index):
-        "Returns the coordinate sequence value at the given index."
-        coords = [self.getX(index), self.getY(index)]
-        if self.dims == 3 and self._z:
-            coords.append(self.getZ(index))
-        return tuple(coords)
-
-    def __setitem__(self, index, value):
-        "Sets the coordinate sequence value at the given index."
-        # Checking the input value
-        if isinstance(value, (list, tuple)):
-            pass
-        elif numpy and isinstance(value, numpy.ndarray):
-            pass
-        else:
-            raise TypeError('Must set coordinate with a sequence (list, tuple, or numpy array).')
-        # Checking the dims of the input
-        if self.dims == 3 and self._z:
-            n_args = 3
-            set_3d = True
-        else:
-            n_args = 2
-            set_3d = False
-        if len(value) != n_args:
-            raise TypeError('Dimension of value does not match.')
-        # Setting the X, Y, Z
-        self.setX(index, value[0])
-        self.setY(index, value[1])
-        if set_3d: self.setZ(index, value[2])
-
-    #### Internal Routines ####
-    def _checkindex(self, index):
-        "Checks the given index."
-        sz = self.size
-        if (sz < 1) or (index < 0) or (index >= sz):
-            raise GEOSIndexError('invalid GEOS Geometry index: %s' % str(index))
-
-    def _checkdim(self, dim):
-        "Checks the given dimension."
-        if dim < 0 or dim > 2:
-            raise GEOSException('invalid ordinate dimension "%d"' % dim)
-
-    #### Ordinate getting and setting routines ####
-    def getOrdinate(self, dimension, index):
-        "Returns the value for the given dimension and index."
-        self._checkindex(index)
-        self._checkdim(dimension)
-        return capi.cs_getordinate(self.ptr, index, dimension, byref(c_double()))
-
-    def setOrdinate(self, dimension, index, value):
-        "Sets the value for the given dimension and index."
-        self._checkindex(index)
-        self._checkdim(dimension)
-        capi.cs_setordinate(self.ptr, index, dimension, value)
-
-    def getX(self, index):
-        "Get the X value at the index."
-        return self.getOrdinate(0, index)
-
-    def setX(self, index, value):
-        "Set X with the value at the given index."
-        self.setOrdinate(0, index, value)
-
-    def getY(self, index):
-        "Get the Y value at the given index."
-        return self.getOrdinate(1, index)
-
-    def setY(self, index, value):
-        "Set Y with the value at the given index."
-        self.setOrdinate(1, index, value)
-
-    def getZ(self, index):
-        "Get Z with the value at the given index."
-        return self.getOrdinate(2, index)
-
-    def setZ(self, index, value):
-        "Set Z with the value at the given index."
-        self.setOrdinate(2, index, value)
-
-    ### Dimensions ###
-    @property
-    def size(self):
-        "Returns the size of this coordinate sequence."
-        return capi.cs_getsize(self.ptr, byref(c_uint()))
-
-    @property
-    def dims(self):
-        "Returns the dimensions of this coordinate sequence."
-        return capi.cs_getdims(self.ptr, byref(c_uint()))
-
-    @property
-    def hasz(self):
-        """
-        Returns whether this coordinate sequence is 3D.  This property value is
-        inherited from the parent Geometry.
-        """
-        return self._z
-
-    ### Other Methods ###
-    def clone(self):
-        "Clones this coordinate sequence."
-        return GEOSCoordSeq(capi.cs_clone(self.ptr), self.hasz)
-
-    @property
-    def kml(self):
-        "Returns the KML representation for the coordinates."
-        # Getting the substitution string depending on whether the coordinates have
-        #  a Z dimension.
-        if self.hasz: substr = '%s,%s,%s '
-        else: substr = '%s,%s,0 '
-        return '<coordinates>%s</coordinates>' % \
-            ''.join([substr % self[i] for i in xrange(len(self))]).strip()
-
-    @property
-    def tuple(self):
-        "Returns a tuple version of this coordinate sequence."
-        n = self.size
-        if n == 1: return self[0]
-        else: return tuple([self[i] for i in xrange(n)])
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/error.py b/lib/python2.7/site-packages/django/contrib/gis/geos/error.py
deleted file mode 100644
index 46bdfe6..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/error.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""
- This module houses the GEOS exceptions, specifically, GEOSException and
- GEOSGeometryIndexError.
-"""
-
-class GEOSException(Exception):
-    "The base GEOS exception, indicates a GEOS-related error."
-    pass
-
-class GEOSIndexError(GEOSException, KeyError):
-    """
-    This exception is raised when an invalid index is encountered, and has
-    the 'silent_variable_feature' attribute set to true.  This ensures that
-    django's templates proceed to use the next lookup type gracefully when
-    an Exception is raised.  Fixes ticket #4740.
-    """
-    # "If, during the method lookup, a method raises an exception, the exception
-    #  will be propagated, unless the exception has an attribute 
-    #  `silent_variable_failure` whose value is True." -- Django template docs.
-    silent_variable_failure = True
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py b/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py
deleted file mode 100644
index 2e5fa4f..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from django.contrib.gis import memoryview
-from django.contrib.gis.geos.geometry import GEOSGeometry, wkt_regex, hex_regex
-
-from django.utils import six
-
-
-def fromfile(file_h):
-    """
-    Given a string file name, returns a GEOSGeometry. The file may contain WKB,
-    WKT, or HEX.
-    """
-    # If given a file name, get a real handle.
-    if isinstance(file_h, six.string_types):
-        with open(file_h, 'rb') as file_h:
-            buf = file_h.read()
-    else:
-        buf = file_h.read()
-
-    # If we get WKB need to wrap in memoryview(), so run through regexes.
-    if isinstance(buf, bytes):
-        try:
-            decoded = buf.decode()
-            if wkt_regex.match(decoded) or hex_regex.match(decoded):
-                return GEOSGeometry(decoded)
-        except UnicodeDecodeError:
-            pass
-    else:
-        return GEOSGeometry(buf)
-
-    return GEOSGeometry(memoryview(buf))
-
-
-def fromstr(string, **kwargs):
-    "Given a string value, returns a GEOSGeometry object."
-    return GEOSGeometry(string, **kwargs)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py b/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py
deleted file mode 100644
index b088ec2..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py
+++ /dev/null
@@ -1,715 +0,0 @@
-"""
- This module contains the 'base' GEOSGeometry object -- all GEOS Geometries
- inherit from this object.
-"""
-from __future__ import unicode_literals
-
-# Python, ctypes and types dependencies.
-from ctypes import addressof, byref, c_double
-
-from django.contrib.gis import memoryview
-# super-class for mutable list behavior
-from django.contrib.gis.geos.mutable_list import ListMixin
-
-from django.contrib.gis.gdal.error import SRSException
-
-# GEOS-related dependencies.
-from django.contrib.gis.geos.base import GEOSBase, gdal
-from django.contrib.gis.geos.coordseq import GEOSCoordSeq
-from django.contrib.gis.geos.error import GEOSException, GEOSIndexError
-from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE
-from django.contrib.gis.geos.mutable_list import ListMixin
-
-# All other functions in this module come from the ctypes
-# prototypes module -- which handles all interaction with
-# the underlying GEOS library.
-from django.contrib.gis.geos import prototypes as capi
-
-# These functions provide access to a thread-local instance
-# of their corresponding GEOS I/O class.
-from django.contrib.gis.geos.prototypes.io import wkt_r, wkt_w, wkb_r, wkb_w, ewkb_w
-
-# For recognizing geometry input.
-from django.contrib.gis.geometry.regex import hex_regex, wkt_regex, json_regex
-
-from django.utils import six
-from django.utils.encoding import force_bytes, force_text
-
-
-class GEOSGeometry(GEOSBase, ListMixin):
-    "A class that, generally, encapsulates a GEOS geometry."
-
-    # Raise GEOSIndexError instead of plain IndexError
-    # (see ticket #4740 and GEOSIndexError docstring)
-    _IndexError = GEOSIndexError
-
-    ptr_type = GEOM_PTR
-
-    #### Python 'magic' routines ####
-    def __init__(self, geo_input, srid=None):
-        """
-        The base constructor for GEOS geometry objects, and may take the
-        following inputs:
-
-         * strings:
-            - WKT
-            - HEXEWKB (a PostGIS-specific canonical form)
-            - GeoJSON (requires GDAL)
-         * buffer:
-            - WKB
-
-        The `srid` keyword is used to specify the Source Reference Identifier
-        (SRID) number for this Geometry.  If not set, the SRID will be None.
-        """
-        if isinstance(geo_input, bytes):
-            geo_input = force_text(geo_input)
-        if isinstance(geo_input, six.string_types):
-            wkt_m = wkt_regex.match(geo_input)
-            if wkt_m:
-                # Handling WKT input.
-                if wkt_m.group('srid'): srid = int(wkt_m.group('srid'))
-                g = wkt_r().read(force_bytes(wkt_m.group('wkt')))
-            elif hex_regex.match(geo_input):
-                # Handling HEXEWKB input.
-                g = wkb_r().read(force_bytes(geo_input))
-            elif gdal.HAS_GDAL and json_regex.match(geo_input):
-                # Handling GeoJSON input.
-                g = wkb_r().read(gdal.OGRGeometry(geo_input).wkb)
-            else:
-                raise ValueError('String or unicode input unrecognized as WKT EWKT, and HEXEWKB.')
-        elif isinstance(geo_input, GEOM_PTR):
-            # When the input is a pointer to a geomtry (GEOM_PTR).
-            g = geo_input
-        elif isinstance(geo_input, memoryview):
-            # When the input is a buffer (WKB).
-            g = wkb_r().read(geo_input)
-        elif isinstance(geo_input, GEOSGeometry):
-            g = capi.geom_clone(geo_input.ptr)
-        else:
-            # Invalid geometry type.
-            raise TypeError('Improper geometry input type: %s' % str(type(geo_input)))
-
-        if bool(g):
-            # Setting the pointer object with a valid pointer.
-            self.ptr = g
-        else:
-            raise GEOSException('Could not initialize GEOS Geometry with given input.')
-
-        # Post-initialization setup.
-        self._post_init(srid)
-
-    def _post_init(self, srid):
-        "Helper routine for performing post-initialization setup."
-        # Setting the SRID, if given.
-        if srid and isinstance(srid, int): self.srid = srid
-
-        # Setting the class type (e.g., Point, Polygon, etc.)
-        self.__class__ = GEOS_CLASSES[self.geom_typeid]
-
-        # Setting the coordinate sequence for the geometry (will be None on
-        # geometries that do not have coordinate sequences)
-        self._set_cs()
-
-    def __del__(self):
-        """
-        Destroys this Geometry; in other words, frees the memory used by the
-        GEOS C++ object.
-        """
-        if self._ptr: capi.destroy_geom(self._ptr)
-
-    def __copy__(self):
-        """
-        Returns a clone because the copy of a GEOSGeometry may contain an
-        invalid pointer location if the original is garbage collected.
-        """
-        return self.clone()
-
-    def __deepcopy__(self, memodict):
-        """
-        The `deepcopy` routine is used by the `Node` class of django.utils.tree;
-        thus, the protocol routine needs to be implemented to return correct
-        copies (clones) of these GEOS objects, which use C pointers.
-        """
-        return self.clone()
-
-    def __str__(self):
-        "WKT is used for the string representation."
-        return self.wkt
-
-    def __repr__(self):
-        "Short-hand representation because WKT may be very large."
-        return '<%s object at %s>' % (self.geom_type, hex(addressof(self.ptr)))
-
-    # Pickling support
-    def __getstate__(self):
-        # The pickled state is simply a tuple of the WKB (in string form)
-        # and the SRID.
-        return bytes(self.wkb), self.srid
-
-    def __setstate__(self, state):
-        # Instantiating from the tuple state that was pickled.
-        wkb, srid = state
-        ptr = wkb_r().read(memoryview(wkb))
-        if not ptr: raise GEOSException('Invalid Geometry loaded from pickled state.')
-        self.ptr = ptr
-        self._post_init(srid)
-
-    # Comparison operators
-    def __eq__(self, other):
-        """
-        Equivalence testing, a Geometry may be compared with another Geometry
-        or a WKT representation.
-        """
-        if isinstance(other, six.string_types):
-            return self.wkt == other
-        elif isinstance(other, GEOSGeometry):
-            return self.equals_exact(other)
-        else:
-            return False
-
-    def __ne__(self, other):
-        "The not equals operator."
-        return not (self == other)
-
-    ### Geometry set-like operations ###
-    # Thanks to Sean Gillies for inspiration:
-    #  http://lists.gispython.org/pipermail/community/2007-July/001034.html
-    # g = g1 | g2
-    def __or__(self, other):
-        "Returns the union of this Geometry and the other."
-        return self.union(other)
-
-    # g = g1 & g2
-    def __and__(self, other):
-        "Returns the intersection of this Geometry and the other."
-        return self.intersection(other)
-
-    # g = g1 - g2
-    def __sub__(self, other):
-        "Return the difference this Geometry and the other."
-        return self.difference(other)
-
-    # g = g1 ^ g2
-    def __xor__(self, other):
-        "Return the symmetric difference of this Geometry and the other."
-        return self.sym_difference(other)
-
-    #### Coordinate Sequence Routines ####
-    @property
-    def has_cs(self):
-        "Returns True if this Geometry has a coordinate sequence, False if not."
-        # Only these geometries are allowed to have coordinate sequences.
-        if isinstance(self, (Point, LineString, LinearRing)):
-            return True
-        else:
-            return False
-
-    def _set_cs(self):
-        "Sets the coordinate sequence for this Geometry."
-        if self.has_cs:
-            self._cs = GEOSCoordSeq(capi.get_cs(self.ptr), self.hasz)
-        else:
-            self._cs = None
-
-    @property
-    def coord_seq(self):
-        "Returns a clone of the coordinate sequence for this Geometry."
-        if self.has_cs:
-            return self._cs.clone()
-
-    #### Geometry Info ####
-    @property
-    def geom_type(self):
-        "Returns a string representing the Geometry type, e.g. 'Polygon'"
-        return capi.geos_type(self.ptr).decode()
-
-    @property
-    def geom_typeid(self):
-        "Returns an integer representing the Geometry type."
-        return capi.geos_typeid(self.ptr)
-
-    @property
-    def num_geom(self):
-        "Returns the number of geometries in the Geometry."
-        return capi.get_num_geoms(self.ptr)
-
-    @property
-    def num_coords(self):
-        "Returns the number of coordinates in the Geometry."
-        return capi.get_num_coords(self.ptr)
-
-    @property
-    def num_points(self):
-        "Returns the number points, or coordinates, in the Geometry."
-        return self.num_coords
-
-    @property
-    def dims(self):
-        "Returns the dimension of this Geometry (0=point, 1=line, 2=surface)."
-        return capi.get_dims(self.ptr)
-
-    def normalize(self):
-        "Converts this Geometry to normal form (or canonical form)."
-        return capi.geos_normalize(self.ptr)
-
-    #### Unary predicates ####
-    @property
-    def empty(self):
-        """
-        Returns a boolean indicating whether the set of points in this Geometry
-        are empty.
-        """
-        return capi.geos_isempty(self.ptr)
-
-    @property
-    def hasz(self):
-        "Returns whether the geometry has a 3D dimension."
-        return capi.geos_hasz(self.ptr)
-
-    @property
-    def ring(self):
-        "Returns whether or not the geometry is a ring."
-        return capi.geos_isring(self.ptr)
-
-    @property
-    def simple(self):
-        "Returns false if the Geometry not simple."
-        return capi.geos_issimple(self.ptr)
-
-    @property
-    def valid(self):
-        "This property tests the validity of this Geometry."
-        return capi.geos_isvalid(self.ptr)
-
-    @property
-    def valid_reason(self):
-        """
-        Returns a string containing the reason for any invalidity.
-        """
-        if not GEOS_PREPARE:
-            raise GEOSException('Upgrade GEOS to 3.1 to get validity reason.')
-        return capi.geos_isvalidreason(self.ptr).decode()
-
-    #### Binary predicates. ####
-    def contains(self, other):
-        "Returns true if other.within(this) returns true."
-        return capi.geos_contains(self.ptr, other.ptr)
-
-    def crosses(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is T*T****** (for a point and a curve,a point and an area or a line and
-        an area) 0******** (for two curves).
-        """
-        return capi.geos_crosses(self.ptr, other.ptr)
-
-    def disjoint(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is FF*FF****.
-        """
-        return capi.geos_disjoint(self.ptr, other.ptr)
-
-    def equals(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is T*F**FFF*.
-        """
-        return capi.geos_equals(self.ptr, other.ptr)
-
-    def equals_exact(self, other, tolerance=0):
-        """
-        Returns true if the two Geometries are exactly equal, up to a
-        specified tolerance.
-        """
-        return capi.geos_equalsexact(self.ptr, other.ptr, float(tolerance))
-
-    def intersects(self, other):
-        "Returns true if disjoint returns false."
-        return capi.geos_intersects(self.ptr, other.ptr)
-
-    def overlaps(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves).
-        """
-        return capi.geos_overlaps(self.ptr, other.ptr)
-
-    def relate_pattern(self, other, pattern):
-        """
-        Returns true if the elements in the DE-9IM intersection matrix for the
-        two Geometries match the elements in pattern.
-        """
-        if not isinstance(pattern, six.string_types) or len(pattern) > 9:
-            raise GEOSException('invalid intersection matrix pattern')
-        return capi.geos_relatepattern(self.ptr, other.ptr, force_bytes(pattern))
-
-    def touches(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is FT*******, F**T***** or F***T****.
-        """
-        return capi.geos_touches(self.ptr, other.ptr)
-
-    def within(self, other):
-        """
-        Returns true if the DE-9IM intersection matrix for the two Geometries
-        is T*F**F***.
-        """
-        return capi.geos_within(self.ptr, other.ptr)
-
-    #### SRID Routines ####
-    def get_srid(self):
-        "Gets the SRID for the geometry, returns None if no SRID is set."
-        s = capi.geos_get_srid(self.ptr)
-        if s == 0: return None
-        else: return s
-
-    def set_srid(self, srid):
-        "Sets the SRID for the geometry."
-        capi.geos_set_srid(self.ptr, srid)
-    srid = property(get_srid, set_srid)
-
-    #### Output Routines ####
-    @property
-    def ewkt(self):
-        """
-        Returns the EWKT (WKT + SRID) of the Geometry.  Note that Z values
-        are *not* included in this representation because GEOS does not yet
-        support serializing them.
-        """
-        if self.get_srid(): return 'SRID=%s;%s' % (self.srid, self.wkt)
-        else: return self.wkt
-
-    @property
-    def wkt(self):
-        "Returns the WKT (Well-Known Text) representation of this Geometry."
-        return wkt_w(3 if self.hasz else 2).write(self).decode()
-
-    @property
-    def hex(self):
-        """
-        Returns the WKB of this Geometry in hexadecimal form.  Please note
-        that the SRID is not included in this representation because it is not
-        a part of the OGC specification (use the `hexewkb` property instead).
-        """
-        # A possible faster, all-python, implementation:
-        #  str(self.wkb).encode('hex')
-        return wkb_w(3 if self.hasz else 2).write_hex(self)
-
-    @property
-    def hexewkb(self):
-        """
-        Returns the EWKB of this Geometry in hexadecimal form.  This is an
-        extension of the WKB specification that includes SRID value that are
-        a part of this geometry.
-        """
-        if self.hasz and not GEOS_PREPARE:
-            # See: http://trac.osgeo.org/geos/ticket/216
-            raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D HEXEWKB.')
-        return ewkb_w(3 if self.hasz else 2).write_hex(self)
-
-    @property
-    def json(self):
-        """
-        Returns GeoJSON representation of this Geometry if GDAL is installed.
-        """
-        if gdal.HAS_GDAL:
-            return self.ogr.json
-        else:
-            raise GEOSException('GeoJSON output only supported when GDAL is installed.')
-    geojson = json
-
-    @property
-    def wkb(self):
-        """
-        Returns the WKB (Well-Known Binary) representation of this Geometry
-        as a Python buffer.  SRID and Z values are not included, use the
-        `ewkb` property instead.
-        """
-        return wkb_w(3 if self.hasz else 2).write(self)
-
-    @property
-    def ewkb(self):
-        """
-        Return the EWKB representation of this Geometry as a Python buffer.
-        This is an extension of the WKB specification that includes any SRID
-        value that are a part of this geometry.
-        """
-        if self.hasz and not GEOS_PREPARE:
-            # See: http://trac.osgeo.org/geos/ticket/216
-            raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D EWKB.')
-        return ewkb_w(3 if self.hasz else 2).write(self)
-
-    @property
-    def kml(self):
-        "Returns the KML representation of this Geometry."
-        gtype = self.geom_type
-        return '<%s>%s</%s>' % (gtype, self.coord_seq.kml, gtype)
-
-    @property
-    def prepared(self):
-        """
-        Returns a PreparedGeometry corresponding to this geometry -- it is
-        optimized for the contains, intersects, and covers operations.
-        """
-        if GEOS_PREPARE:
-            return PreparedGeometry(self)
-        else:
-            raise GEOSException('GEOS 3.1+ required for prepared geometry support.')
-
-    #### GDAL-specific output routines ####
-    @property
-    def ogr(self):
-        "Returns the OGR Geometry for this Geometry."
-        if not gdal.HAS_GDAL:
-            raise GEOSException('GDAL required to convert to an OGRGeometry.')
-        if self.srid:
-            try:
-                return gdal.OGRGeometry(self.wkb, self.srid)
-            except SRSException:
-                pass
-        return gdal.OGRGeometry(self.wkb)
-
-    @property
-    def srs(self):
-        "Returns the OSR SpatialReference for SRID of this Geometry."
-        if not gdal.HAS_GDAL:
-            raise GEOSException('GDAL required to return a SpatialReference object.')
-        if self.srid:
-            try:
-                return gdal.SpatialReference(self.srid)
-            except SRSException:
-                pass
-        return None
-
-    @property
-    def crs(self):
-        "Alias for `srs` property."
-        return self.srs
-
-    def transform(self, ct, clone=False):
-        """
-        Requires GDAL. Transforms the geometry according to the given
-        transformation object, which may be an integer SRID, and WKT or
-        PROJ.4 string. By default, the geometry is transformed in-place and
-        nothing is returned. However if the `clone` keyword is set, then this
-        geometry will not be modified and a transformed clone will be returned
-        instead.
-        """
-        srid = self.srid
-
-        if ct == srid:
-            # short-circuit where source & dest SRIDs match
-            if clone:
-                return self.clone()
-            else:
-                return
-
-        if (srid is None) or (srid < 0):
-            raise GEOSException("Calling transform() with no SRID set is not supported")
-
-        if not gdal.HAS_GDAL:
-            raise GEOSException("GDAL library is not available to transform() geometry.")
-
-        # Creating an OGR Geometry, which is then transformed.
-        g = self.ogr
-        g.transform(ct)
-        # Getting a new GEOS pointer
-        ptr = wkb_r().read(g.wkb)
-        if clone:
-            # User wants a cloned transformed geometry returned.
-            return GEOSGeometry(ptr, srid=g.srid)
-        if ptr:
-            # Reassigning pointer, and performing post-initialization setup
-            # again due to the reassignment.
-            capi.destroy_geom(self.ptr)
-            self.ptr = ptr
-            self._post_init(g.srid)
-        else:
-            raise GEOSException('Transformed WKB was invalid.')
-
-    #### Topology Routines ####
-    def _topology(self, gptr):
-        "Helper routine to return Geometry from the given pointer."
-        return GEOSGeometry(gptr, srid=self.srid)
-
-    @property
-    def boundary(self):
-        "Returns the boundary as a newly allocated Geometry object."
-        return self._topology(capi.geos_boundary(self.ptr))
-
-    def buffer(self, width, quadsegs=8):
-        """
-        Returns a geometry that represents all points whose distance from this
-        Geometry is less than or equal to distance. Calculations are in the
-        Spatial Reference System of this Geometry. The optional third parameter sets
-        the number of segment used to approximate a quarter circle (defaults to 8).
-        (Text from PostGIS documentation at ch. 6.1.3)
-        """
-        return self._topology(capi.geos_buffer(self.ptr, width, quadsegs))
-
-    @property
-    def centroid(self):
-        """
-        The centroid is equal to the centroid of the set of component Geometries
-        of highest dimension (since the lower-dimension geometries contribute zero
-        "weight" to the centroid).
-        """
-        return self._topology(capi.geos_centroid(self.ptr))
-
-    @property
-    def convex_hull(self):
-        """
-        Returns the smallest convex Polygon that contains all the points
-        in the Geometry.
-        """
-        return self._topology(capi.geos_convexhull(self.ptr))
-
-    def difference(self, other):
-        """
-        Returns a Geometry representing the points making up this Geometry
-        that do not make up other.
-        """
-        return self._topology(capi.geos_difference(self.ptr, other.ptr))
-
-    @property
-    def envelope(self):
-        "Return the envelope for this geometry (a polygon)."
-        return self._topology(capi.geos_envelope(self.ptr))
-
-    def interpolate(self, distance):
-        if not isinstance(self, (LineString, MultiLineString)):
-            raise TypeError('interpolate only works on LineString and MultiLineString geometries')
-        if not hasattr(capi, 'geos_interpolate'):
-            raise NotImplementedError('interpolate requires GEOS 3.2+')
-        return self._topology(capi.geos_interpolate(self.ptr, distance))
-
-    def interpolate_normalized(self, distance):
-        if not isinstance(self, (LineString, MultiLineString)):
-            raise TypeError('interpolate only works on LineString and MultiLineString geometries')
-        if not hasattr(capi, 'geos_interpolate_normalized'):
-            raise NotImplementedError('interpolate_normalized requires GEOS 3.2+')
-        return self._topology(capi.geos_interpolate_normalized(self.ptr, distance))
-
-    def intersection(self, other):
-        "Returns a Geometry representing the points shared by this Geometry and other."
-        return self._topology(capi.geos_intersection(self.ptr, other.ptr))
-
-    @property
-    def point_on_surface(self):
-        "Computes an interior point of this Geometry."
-        return self._topology(capi.geos_pointonsurface(self.ptr))
-
-    def project(self, point):
-        if not isinstance(point, Point):
-            raise TypeError('locate_point argument must be a Point')
-        if not isinstance(self, (LineString, MultiLineString)):
-            raise TypeError('locate_point only works on LineString and MultiLineString geometries')
-        if not hasattr(capi, 'geos_project'):
-            raise NotImplementedError('geos_project requires GEOS 3.2+')
-        return capi.geos_project(self.ptr, point.ptr)
-
-    def project_normalized(self, point):
-        if not isinstance(point, Point):
-            raise TypeError('locate_point argument must be a Point')
-        if not isinstance(self, (LineString, MultiLineString)):
-            raise TypeError('locate_point only works on LineString and MultiLineString geometries')
-        if not hasattr(capi, 'geos_project_normalized'):
-            raise NotImplementedError('project_normalized requires GEOS 3.2+')
-        return capi.geos_project_normalized(self.ptr, point.ptr)
-
-    def relate(self, other):
-        "Returns the DE-9IM intersection matrix for this Geometry and the other."
-        return capi.geos_relate(self.ptr, other.ptr).decode()
-
-    def simplify(self, tolerance=0.0, preserve_topology=False):
-        """
-        Returns the Geometry, simplified using the Douglas-Peucker algorithm
-        to the specified tolerance (higher tolerance => less points).  If no
-        tolerance provided, defaults to 0.
-
-        By default, this function does not preserve topology - e.g. polygons can
-        be split, collapse to lines or disappear holes can be created or
-        disappear, and lines can cross. By specifying preserve_topology=True,
-        the result will have the same dimension and number of components as the
-        input. This is significantly slower.
-        """
-        if preserve_topology:
-            return self._topology(capi.geos_preservesimplify(self.ptr, tolerance))
-        else:
-            return self._topology(capi.geos_simplify(self.ptr, tolerance))
-
-    def sym_difference(self, other):
-        """
-        Returns a set combining the points in this Geometry not in other,
-        and the points in other not in this Geometry.
-        """
-        return self._topology(capi.geos_symdifference(self.ptr, other.ptr))
-
-    def union(self, other):
-        "Returns a Geometry representing all the points in this Geometry and other."
-        return self._topology(capi.geos_union(self.ptr, other.ptr))
-
-    #### Other Routines ####
-    @property
-    def area(self):
-        "Returns the area of the Geometry."
-        return capi.geos_area(self.ptr, byref(c_double()))
-
-    def distance(self, other):
-        """
-        Returns the distance between the closest points on this Geometry
-        and the other. Units will be in those of the coordinate system of
-        the Geometry.
-        """
-        if not isinstance(other, GEOSGeometry):
-            raise TypeError('distance() works only on other GEOS Geometries.')
-        return capi.geos_distance(self.ptr, other.ptr, byref(c_double()))
-
-    @property
-    def extent(self):
-        """
-        Returns the extent of this geometry as a 4-tuple, consisting of
-        (xmin, ymin, xmax, ymax).
-        """
-        env = self.envelope
-        if isinstance(env, Point):
-            xmin, ymin = env.tuple
-            xmax, ymax = xmin, ymin
-        else:
-            xmin, ymin = env[0][0]
-            xmax, ymax = env[0][2]
-        return (xmin, ymin, xmax, ymax)
-
-    @property
-    def length(self):
-        """
-        Returns the length of this Geometry (e.g., 0 for point, or the
-        circumfrence of a Polygon).
-        """
-        return capi.geos_length(self.ptr, byref(c_double()))
-
-    def clone(self):
-        "Clones this Geometry."
-        return GEOSGeometry(capi.geom_clone(self.ptr), srid=self.srid)
-
-# Class mapping dictionary.  Has to be at the end to avoid import
-# conflicts with GEOSGeometry.
-from django.contrib.gis.geos.linestring import LineString, LinearRing
-from django.contrib.gis.geos.point import Point
-from django.contrib.gis.geos.polygon import Polygon
-from django.contrib.gis.geos.collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon
-GEOS_CLASSES = {0 : Point,
-                1 : LineString,
-                2 : LinearRing,
-                3 : Polygon,
-                4 : MultiPoint,
-                5 : MultiLineString,
-                6 : MultiPolygon,
-                7 : GeometryCollection,
-                }
-
-# If supported, import the PreparedGeometry class.
-if GEOS_PREPARE:
-    from django.contrib.gis.geos.prepared import PreparedGeometry
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/io.py
deleted file mode 100644
index 54ba6b4..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/io.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""
-Module that holds classes for performing I/O operations on GEOS geometry
-objects.  Specifically, this has Python implementations of WKB/WKT
-reader and writer classes.
-"""
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.prototypes.io import _WKTReader, _WKBReader, WKBWriter, WKTWriter
-
-# Public classes for (WKB|WKT)Reader, which return GEOSGeometry
-class WKBReader(_WKBReader):
-    def read(self, wkb):
-        "Returns a GEOSGeometry for the given WKB buffer."
-        return GEOSGeometry(super(WKBReader, self).read(wkb))
-
-class WKTReader(_WKTReader):
-    def read(self, wkt):
-        "Returns a GEOSGeometry for the given WKT string."
-        return GEOSGeometry(super(WKTReader, self).read(wkt))
-
-
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py b/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py
deleted file mode 100644
index 6963b78..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""
- This module houses the ctypes initialization procedures, as well
- as the notice and error handler function callbacks (get called
- when an error occurs in GEOS).
-
- This module also houses GEOS Pointer utilities, including
- get_pointer_arr(), and GEOM_PTR.
-"""
-import logging
-import os
-import re
-from ctypes import c_char_p, Structure, CDLL, CFUNCTYPE, POINTER
-from ctypes.util import find_library
-
-from django.contrib.gis.geos.error import GEOSException
-from django.core.exceptions import ImproperlyConfigured
-
-logger = logging.getLogger('django.contrib.gis')
-
-# Custom library path set?
-try:
-    from django.conf import settings
-    lib_path = settings.GEOS_LIBRARY_PATH
-except (AttributeError, EnvironmentError,
-        ImportError, ImproperlyConfigured):
-    lib_path = None
-
-# Setting the appropriate names for the GEOS-C library.
-if lib_path:
-    lib_names = None
-elif os.name == 'nt':
-    # Windows NT libraries
-    lib_names = ['geos_c', 'libgeos_c-1']
-elif os.name == 'posix':
-    # *NIX libraries
-    lib_names = ['geos_c', 'GEOS']
-else:
-    raise ImportError('Unsupported OS "%s"' % os.name)
-
-# Using the ctypes `find_library` utility to find the path to the GEOS
-# shared library.  This is better than manually specifiying each library name
-# and extension (e.g., libgeos_c.[so|so.1|dylib].).
-if lib_names:
-    for lib_name in lib_names:
-        lib_path = find_library(lib_name)
-        if not lib_path is None: break
-
-# No GEOS library could be found.
-if lib_path is None:
-    raise ImportError('Could not find the GEOS library (tried "%s"). '
-                        'Try setting GEOS_LIBRARY_PATH in your settings.' %
-                        '", "'.join(lib_names))
-
-# Getting the GEOS C library.  The C interface (CDLL) is used for
-# both *NIX and Windows.
-# See the GEOS C API source code for more details on the library function calls:
-#  http://geos.refractions.net/ro/doxygen_docs/html/geos__c_8h-source.html
-lgeos = CDLL(lib_path)
-
-# The notice and error handler C function callback definitions.
-# Supposed to mimic the GEOS message handler (C below):
-#  typedef void (*GEOSMessageHandler)(const char *fmt, ...);
-NOTICEFUNC = CFUNCTYPE(None, c_char_p, c_char_p)
-def notice_h(fmt, lst):
-    fmt, lst = fmt.decode(), lst.decode()
-    try:
-        warn_msg = fmt % lst
-    except:
-        warn_msg = fmt
-    logger.warning('GEOS_NOTICE: %s\n' % warn_msg)
-notice_h = NOTICEFUNC(notice_h)
-
-ERRORFUNC = CFUNCTYPE(None, c_char_p, c_char_p)
-def error_h(fmt, lst):
-    fmt, lst = fmt.decode(), lst.decode()
-    try:
-        err_msg = fmt % lst
-    except:
-        err_msg = fmt
-    logger.error('GEOS_ERROR: %s\n' % err_msg)
-error_h = ERRORFUNC(error_h)
-
-#### GEOS Geometry C data structures, and utility functions. ####
-
-# Opaque GEOS geometry structures, used for GEOM_PTR and CS_PTR
-class GEOSGeom_t(Structure): pass
-class GEOSPrepGeom_t(Structure): pass
-class GEOSCoordSeq_t(Structure): pass
-class GEOSContextHandle_t(Structure): pass
-
-# Pointers to opaque GEOS geometry structures.
-GEOM_PTR = POINTER(GEOSGeom_t)
-PREPGEOM_PTR = POINTER(GEOSPrepGeom_t)
-CS_PTR = POINTER(GEOSCoordSeq_t)
-CONTEXT_PTR  = POINTER(GEOSContextHandle_t)
-
-# Used specifically by the GEOSGeom_createPolygon and GEOSGeom_createCollection
-#  GEOS routines
-def get_pointer_arr(n):
-    "Gets a ctypes pointer array (of length `n`) for GEOSGeom_t opaque pointer."
-    GeomArr = GEOM_PTR * n
-    return GeomArr()
-
-# Returns the string version of the GEOS library. Have to set the restype
-# explicitly to c_char_p to ensure compatibility accross 32 and 64-bit platforms.
-geos_version = lgeos.GEOSversion
-geos_version.argtypes = None
-geos_version.restype = c_char_p
-
-# Regular expression should be able to parse version strings such as
-# '3.0.0rc4-CAPI-1.3.3', '3.0.0-CAPI-1.4.1', '3.4.0dev-CAPI-1.8.0' or '3.4.0dev-CAPI-1.8.0 r0'
-version_regex = re.compile(
-    r'^(?P<version>(?P<major>\d+)\.(?P<minor>\d+)\.(?P<subminor>\d+))'
-    r'((rc(?P<release_candidate>\d+))|dev)?-CAPI-(?P<capi_version>\d+\.\d+\.\d+)( r\d+)?$'
-)
-def geos_version_info():
-    """
-    Returns a dictionary containing the various version metadata parsed from
-    the GEOS version string, including the version number, whether the version
-    is a release candidate (and what number release candidate), and the C API
-    version.
-    """
-    ver = geos_version().decode()
-    m = version_regex.match(ver)
-    if not m:
-        raise GEOSException('Could not parse version info string "%s"' % ver)
-    return dict((key, m.group(key)) for key in (
-        'version', 'release_candidate', 'capi_version', 'major', 'minor', 'subminor'))
-
-# Version numbers and whether or not prepared geometry support is available.
-_verinfo = geos_version_info()
-GEOS_MAJOR_VERSION = int(_verinfo['major'])
-GEOS_MINOR_VERSION = int(_verinfo['minor'])
-GEOS_SUBMINOR_VERSION = int(_verinfo['subminor'])
-del _verinfo
-GEOS_VERSION = (GEOS_MAJOR_VERSION, GEOS_MINOR_VERSION, GEOS_SUBMINOR_VERSION)
-GEOS_PREPARE = GEOS_VERSION >= (3, 1, 0)
-
-if GEOS_PREPARE:
-    # Here we set up the prototypes for the initGEOS_r and finishGEOS_r
-    # routines.  These functions aren't actually called until they are
-    # attached to a GEOS context handle -- this actually occurs in
-    # geos/prototypes/threadsafe.py.
-    lgeos.initGEOS_r.restype = CONTEXT_PTR
-    lgeos.finishGEOS_r.argtypes = [CONTEXT_PTR]
-else:
-    # When thread-safety isn't available, the initGEOS routine must be called
-    # first.  This function takes the notice and error functions, defined
-    # as Python callbacks above, as parameters. Here is the C code that is
-    # wrapped:
-    #  extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function, GEOSMessageHandler error_function);
-    lgeos.initGEOS(notice_h, error_h)
-    # Calling finishGEOS() upon exit of the interpreter.
-    import atexit
-    atexit.register(lgeos.finishGEOS)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py b/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py
deleted file mode 100644
index 4784ea7..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py
+++ /dev/null
@@ -1,153 +0,0 @@
-from django.contrib.gis.geos.base import numpy
-from django.contrib.gis.geos.coordseq import GEOSCoordSeq
-from django.contrib.gis.geos.error import GEOSException
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.point import Point
-from django.contrib.gis.geos import prototypes as capi
-from django.utils.six.moves import xrange
-
-class LineString(GEOSGeometry):
-    _init_func = capi.create_linestring
-    _minlength = 2
-
-    #### Python 'magic' routines ####
-    def __init__(self, *args, **kwargs):
-        """
-        Initializes on the given sequence -- may take lists, tuples, NumPy arrays
-        of X,Y pairs, or Point objects.  If Point objects are used, ownership is
-        _not_ transferred to the LineString object.
-
-        Examples:
-         ls = LineString((1, 1), (2, 2))
-         ls = LineString([(1, 1), (2, 2)])
-         ls = LineString(array([(1, 1), (2, 2)]))
-         ls = LineString(Point(1, 1), Point(2, 2))
-        """
-        # If only one argument provided, set the coords array appropriately
-        if len(args) == 1: coords = args[0]
-        else: coords = args
-
-        if isinstance(coords, (tuple, list)):
-            # Getting the number of coords and the number of dimensions -- which
-            #  must stay the same, e.g., no LineString((1, 2), (1, 2, 3)).
-            ncoords = len(coords)
-            if coords: ndim = len(coords[0])
-            else: raise TypeError('Cannot initialize on empty sequence.')
-            self._checkdim(ndim)
-            # Incrementing through each of the coordinates and verifying
-            for i in xrange(1, ncoords):
-                if not isinstance(coords[i], (tuple, list, Point)):
-                    raise TypeError('each coordinate should be a sequence (list or tuple)')
-                if len(coords[i]) != ndim: raise TypeError('Dimension mismatch.')
-            numpy_coords = False
-        elif numpy and isinstance(coords, numpy.ndarray):
-            shape = coords.shape # Using numpy's shape.
-            if len(shape) != 2: raise TypeError('Too many dimensions.')
-            self._checkdim(shape[1])
-            ncoords = shape[0]
-            ndim = shape[1]
-            numpy_coords = True
-        else:
-            raise TypeError('Invalid initialization input for LineStrings.')
-
-        # Creating a coordinate sequence object because it is easier to
-        # set the points using GEOSCoordSeq.__setitem__().
-        cs = GEOSCoordSeq(capi.create_cs(ncoords, ndim), z=bool(ndim==3))
-
-        for i in xrange(ncoords):
-            if numpy_coords: cs[i] = coords[i,:]
-            elif isinstance(coords[i], Point): cs[i] = coords[i].tuple
-            else: cs[i] = coords[i]
-
-        # If SRID was passed in with the keyword arguments
-        srid = kwargs.get('srid', None)
-
-        # Calling the base geometry initialization with the returned pointer
-        #  from the function.
-        super(LineString, self).__init__(self._init_func(cs.ptr), srid=srid)
-
-    def __iter__(self):
-        "Allows iteration over this LineString."
-        for i in xrange(len(self)):
-            yield self[i]
-
-    def __len__(self):
-        "Returns the number of points in this LineString."
-        return len(self._cs)
-
-    def _get_single_external(self, index):
-        return self._cs[index]
-
-    _get_single_internal = _get_single_external
-
-    def _set_list(self, length, items):
-        ndim = self._cs.dims #
-        hasz = self._cs.hasz # I don't understand why these are different
-
-        # create a new coordinate sequence and populate accordingly
-        cs = GEOSCoordSeq(capi.create_cs(length, ndim), z=hasz)
-        for i, c in enumerate(items):
-            cs[i] = c
-
-        ptr = self._init_func(cs.ptr)
-        if ptr:
-            capi.destroy_geom(self.ptr)
-            self.ptr = ptr
-            self._post_init(self.srid)
-        else:
-            # can this happen?
-            raise GEOSException('Geometry resulting from slice deletion was invalid.')
-
-    def _set_single(self, index, value):
-        self._checkindex(index)
-        self._cs[index] = value
-
-    def _checkdim(self, dim):
-        if dim not in (2, 3): raise TypeError('Dimension mismatch.')
-
-    #### Sequence Properties ####
-    @property
-    def tuple(self):
-        "Returns a tuple version of the geometry from the coordinate sequence."
-        return self._cs.tuple
-    coords = tuple
-
-    def _listarr(self, func):
-        """
-        Internal routine that returns a sequence (list) corresponding with
-        the given function.  Will return a numpy array if possible.
-        """
-        lst = [func(i) for i in xrange(len(self))]
-        if numpy: return numpy.array(lst) # ARRRR!
-        else: return lst
-
-    @property
-    def array(self):
-        "Returns a numpy array for the LineString."
-        return self._listarr(self._cs.__getitem__)
-
-    @property
-    def merged(self):
-        "Returns the line merge of this LineString."
-        return self._topology(capi.geos_linemerge(self.ptr))
-
-    @property
-    def x(self):
-        "Returns a list or numpy array of the X variable."
-        return self._listarr(self._cs.getX)
-
-    @property
-    def y(self):
-        "Returns a list or numpy array of the Y variable."
-        return self._listarr(self._cs.getY)
-
-    @property
-    def z(self):
-        "Returns a list or numpy array of the Z variable."
-        if not self.hasz: return None
-        else: return self._listarr(self._cs.getZ)
-
-# LinearRings are LineStrings used within Polygons.
-class LinearRing(LineString):
-    _minLength = 4
-    _init_func = capi.create_linearring
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py b/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py
deleted file mode 100644
index 0418282..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py
+++ /dev/null
@@ -1,328 +0,0 @@
-# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved.
-# Released under the New BSD license.
-"""
-This module contains a base type which provides list-style mutations
-without specific data storage methods.
-
-See also http://www.aryehleib.com/MutableLists.html
-
-Author: Aryeh Leib Taurog.
-"""
-from django.utils.functional import total_ordering
-from django.utils import six
-from django.utils.six.moves import xrange
-
-@total_ordering
-class ListMixin(object):
-    """
-    A base class which provides complete list interface.
-    Derived classes must call ListMixin's __init__() function
-    and implement the following:
-
-    function _get_single_external(self, i):
-        Return single item with index i for general use.
-        The index i will always satisfy 0 <= i < len(self).
-
-    function _get_single_internal(self, i):
-        Same as above, but for use within the class [Optional]
-        Note that if _get_single_internal and _get_single_internal return
-        different types of objects, _set_list must distinguish
-        between the two and handle each appropriately.
-
-    function _set_list(self, length, items):
-        Recreate the entire object.
-
-        NOTE: items may be a generator which calls _get_single_internal.
-        Therefore, it is necessary to cache the values in a temporary:
-            temp = list(items)
-        before clobbering the original storage.
-
-    function _set_single(self, i, value):
-        Set the single item at index i to value [Optional]
-        If left undefined, all mutations will result in rebuilding
-        the object using _set_list.
-
-    function __len__(self):
-        Return the length
-
-    int _minlength:
-        The minimum legal length [Optional]
-
-    int _maxlength:
-        The maximum legal length [Optional]
-
-    type or tuple _allowed:
-        A type or tuple of allowed item types [Optional]
-
-    class _IndexError:
-        The type of exception to be raise on invalid index [Optional]
-    """
-
-    _minlength = 0
-    _maxlength = None
-    _IndexError = IndexError
-
-    ### Python initialization and special list interface methods ###
-
-    def __init__(self, *args, **kwargs):
-        if not hasattr(self, '_get_single_internal'):
-            self._get_single_internal = self._get_single_external
-
-        if not hasattr(self, '_set_single'):
-            self._set_single = self._set_single_rebuild
-            self._assign_extended_slice = self._assign_extended_slice_rebuild
-
-        super(ListMixin, self).__init__(*args, **kwargs)
-
-    def __getitem__(self, index):
-        "Get the item(s) at the specified index/slice."
-        if isinstance(index, slice):
-            return [self._get_single_external(i) for i in xrange(*index.indices(len(self)))]
-        else:
-            index = self._checkindex(index)
-            return self._get_single_external(index)
-
-    def __delitem__(self, index):
-        "Delete the item(s) at the specified index/slice."
-        if not isinstance(index, six.integer_types + (slice,)):
-            raise TypeError("%s is not a legal index" % index)
-
-        # calculate new length and dimensions
-        origLen     = len(self)
-        if isinstance(index, six.integer_types):
-            index = self._checkindex(index)
-            indexRange  = [index]
-        else:
-            indexRange  = range(*index.indices(origLen))
-
-        newLen      = origLen - len(indexRange)
-        newItems    = ( self._get_single_internal(i)
-                        for i in xrange(origLen)
-                        if i not in indexRange )
-
-        self._rebuild(newLen, newItems)
-
-    def __setitem__(self, index, val):
-        "Set the item(s) at the specified index/slice."
-        if isinstance(index, slice):
-            self._set_slice(index, val)
-        else:
-            index = self._checkindex(index)
-            self._check_allowed((val,))
-            self._set_single(index, val)
-
-    def __iter__(self):
-        "Iterate over the items in the list"
-        for i in xrange(len(self)):
-            yield self[i]
-
-    ### Special methods for arithmetic operations ###
-    def __add__(self, other):
-        'add another list-like object'
-        return self.__class__(list(self) + list(other))
-
-    def __radd__(self, other):
-        'add to another list-like object'
-        return other.__class__(list(other) + list(self))
-
-    def __iadd__(self, other):
-        'add another list-like object to self'
-        self.extend(list(other))
-        return self
-
-    def __mul__(self, n):
-        'multiply'
-        return self.__class__(list(self) * n)
-
-    def __rmul__(self, n):
-        'multiply'
-        return self.__class__(list(self) * n)
-
-    def __imul__(self, n):
-        'multiply'
-        if n <= 0:
-            del self[:]
-        else:
-            cache = list(self)
-            for i in range(n-1):
-                self.extend(cache)
-        return self
-
-    def __eq__(self, other):
-        olen = len(other)
-        for i in range(olen):
-            try:
-                c = self[i] == other[i]
-            except self._IndexError:
-                # self must be shorter
-                return False
-            if not c:
-                return False
-        return len(self) == olen
-
-    def __lt__(self, other):
-        olen = len(other)
-        for i in range(olen):
-            try:
-                c = self[i] < other[i]
-            except self._IndexError:
-                # self must be shorter
-                return True
-            if c:
-                return c
-            elif other[i] < self[i]:
-                return False
-        return len(self) < olen
-
-    ### Public list interface Methods ###
-    ## Non-mutating ##
-    def count(self, val):
-        "Standard list count method"
-        count = 0
-        for i in self:
-            if val == i: count += 1
-        return count
-
-    def index(self, val):
-        "Standard list index method"
-        for i in xrange(0, len(self)):
-            if self[i] == val: return i
-        raise ValueError('%s not found in object' % str(val))
-
-    ## Mutating ##
-    def append(self, val):
-        "Standard list append method"
-        self[len(self):] = [val]
-
-    def extend(self, vals):
-        "Standard list extend method"
-        self[len(self):] = vals
-
-    def insert(self, index, val):
-        "Standard list insert method"
-        if not isinstance(index, six.integer_types):
-            raise TypeError("%s is not a legal index" % index)
-        self[index:index] = [val]
-
-    def pop(self, index=-1):
-        "Standard list pop method"
-        result = self[index]
-        del self[index]
-        return result
-
-    def remove(self, val):
-        "Standard list remove method"
-        del self[self.index(val)]
-
-    def reverse(self):
-        "Standard list reverse method"
-        self[:] = self[-1::-1]
-
-    def sort(self, cmp=None, key=None, reverse=False):
-        "Standard list sort method"
-        if key:
-            temp = [(key(v),v) for v in self]
-            temp.sort(key=lambda x: x[0], reverse=reverse)
-            self[:] = [v[1] for v in temp]
-        else:
-            temp = list(self)
-            if cmp is not None:
-                temp.sort(cmp=cmp, reverse=reverse)
-            else:
-                temp.sort(reverse=reverse)
-            self[:] = temp
-
-    ### Private routines ###
-    def _rebuild(self, newLen, newItems):
-        if newLen < self._minlength:
-            raise ValueError('Must have at least %d items' % self._minlength)
-        if self._maxlength is not None and newLen > self._maxlength:
-            raise ValueError('Cannot have more than %d items' % self._maxlength)
-
-        self._set_list(newLen, newItems)
-
-    def _set_single_rebuild(self, index, value):
-        self._set_slice(slice(index, index + 1, 1), [value])
-
-    def _checkindex(self, index, correct=True):
-        length = len(self)
-        if 0 <= index < length:
-            return index
-        if correct and -length <= index < 0:
-            return index + length
-        raise self._IndexError('invalid index: %s' % str(index))
-
-    def _check_allowed(self, items):
-        if hasattr(self, '_allowed'):
-            if False in [isinstance(val, self._allowed) for val in items]:
-                raise TypeError('Invalid type encountered in the arguments.')
-
-    def _set_slice(self, index, values):
-        "Assign values to a slice of the object"
-        try:
-            iter(values)
-        except TypeError:
-            raise TypeError('can only assign an iterable to a slice')
-
-        self._check_allowed(values)
-
-        origLen     = len(self)
-        valueList   = list(values)
-        start, stop, step = index.indices(origLen)
-
-        # CAREFUL: index.step and step are not the same!
-        # step will never be None
-        if index.step is None:
-            self._assign_simple_slice(start, stop, valueList)
-        else:
-            self._assign_extended_slice(start, stop, step, valueList)
-
-    def _assign_extended_slice_rebuild(self, start, stop, step, valueList):
-        'Assign an extended slice by rebuilding entire list'
-        indexList   = range(start, stop, step)
-        # extended slice, only allow assigning slice of same size
-        if len(valueList) != len(indexList):
-            raise ValueError('attempt to assign sequence of size %d '
-                             'to extended slice of size %d'
-                             % (len(valueList), len(indexList)))
-
-        # we're not changing the length of the sequence
-        newLen  = len(self)
-        newVals = dict(zip(indexList, valueList))
-        def newItems():
-            for i in xrange(newLen):
-                if i in newVals:
-                    yield newVals[i]
-                else:
-                    yield self._get_single_internal(i)
-
-        self._rebuild(newLen, newItems())
-
-    def _assign_extended_slice(self, start, stop, step, valueList):
-        'Assign an extended slice by re-assigning individual items'
-        indexList   = range(start, stop, step)
-        # extended slice, only allow assigning slice of same size
-        if len(valueList) != len(indexList):
-            raise ValueError('attempt to assign sequence of size %d '
-                             'to extended slice of size %d'
-                             % (len(valueList), len(indexList)))
-
-        for i, val in zip(indexList, valueList):
-            self._set_single(i, val)
-
-    def _assign_simple_slice(self, start, stop, valueList):
-        'Assign a simple slice; Can assign slice of any length'
-        origLen = len(self)
-        stop = max(start, stop)
-        newLen  = origLen - stop + start + len(valueList)
-        def newItems():
-            for i in xrange(origLen + 1):
-                if i == start:
-                    for val in valueList:
-                        yield val
-
-                if i < origLen:
-                    if i < start or i >= stop:
-                        yield self._get_single_internal(i)
-
-        self._rebuild(newLen, newItems())
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/point.py b/lib/python2.7/site-packages/django/contrib/gis/geos/point.py
deleted file mode 100644
index 907347d..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/point.py
+++ /dev/null
@@ -1,137 +0,0 @@
-from ctypes import c_uint
-from django.contrib.gis.geos.error import GEOSException
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos import prototypes as capi
-from django.utils import six
-from django.utils.six.moves import xrange
-
-class Point(GEOSGeometry):
-    _minlength = 2
-    _maxlength = 3
-
-    def __init__(self, x, y=None, z=None, srid=None):
-        """
-        The Point object may be initialized with either a tuple, or individual
-        parameters.
-
-        For Example:
-        >>> p = Point((5, 23)) # 2D point, passed in as a tuple
-        >>> p = Point(5, 23, 8) # 3D point, passed in with individual parameters
-        """
-        if isinstance(x, (tuple, list)):
-            # Here a tuple or list was passed in under the `x` parameter.
-            ndim = len(x)
-            coords = x
-        elif isinstance(x, six.integer_types + (float,)) and isinstance(y, six.integer_types + (float,)):
-            # Here X, Y, and (optionally) Z were passed in individually, as parameters.
-            if isinstance(z, six.integer_types + (float,)):
-                ndim = 3
-                coords = [x, y, z]
-            else:
-                ndim = 2
-                coords = [x, y]
-        else:
-            raise TypeError('Invalid parameters given for Point initialization.')
-
-        point = self._create_point(ndim, coords)
-
-        # Initializing using the address returned from the GEOS
-        #  createPoint factory.
-        super(Point, self).__init__(point, srid=srid)
-
-    def _create_point(self, ndim, coords):
-        """
-        Create a coordinate sequence, set X, Y, [Z], and create point
-        """
-        if ndim < 2 or ndim > 3:
-            raise TypeError('Invalid point dimension: %s' % str(ndim))
-
-        cs = capi.create_cs(c_uint(1), c_uint(ndim))
-        i = iter(coords)
-        capi.cs_setx(cs, 0, next(i))
-        capi.cs_sety(cs, 0, next(i))
-        if ndim == 3: capi.cs_setz(cs, 0, next(i))
-
-        return capi.create_point(cs)
-
-    def _set_list(self, length, items):
-        ptr = self._create_point(length, items)
-        if ptr:
-            capi.destroy_geom(self.ptr)
-            self._ptr = ptr
-            self._set_cs()
-        else:
-            # can this happen?
-            raise GEOSException('Geometry resulting from slice deletion was invalid.')
-
-    def _set_single(self, index, value):
-        self._cs.setOrdinate(index, 0, value)
-
-    def __iter__(self):
-        "Allows iteration over coordinates of this Point."
-        for i in xrange(len(self)):
-            yield self[i]
-
-    def __len__(self):
-        "Returns the number of dimensions for this Point (either 0, 2 or 3)."
-        if self.empty: return 0
-        if self.hasz: return 3
-        else: return 2
-
-    def _get_single_external(self, index):
-        if index == 0:
-            return self.x
-        elif index == 1:
-            return self.y
-        elif index == 2:
-            return self.z
-
-    _get_single_internal = _get_single_external
-
-    def get_x(self):
-        "Returns the X component of the Point."
-        return self._cs.getOrdinate(0, 0)
-
-    def set_x(self, value):
-        "Sets the X component of the Point."
-        self._cs.setOrdinate(0, 0, value)
-
-    def get_y(self):
-        "Returns the Y component of the Point."
-        return self._cs.getOrdinate(1, 0)
-
-    def set_y(self, value):
-        "Sets the Y component of the Point."
-        self._cs.setOrdinate(1, 0, value)
-
-    def get_z(self):
-        "Returns the Z component of the Point."
-        if self.hasz:
-            return self._cs.getOrdinate(2, 0)
-        else:
-            return None
-
-    def set_z(self, value):
-        "Sets the Z component of the Point."
-        if self.hasz:
-            self._cs.setOrdinate(2, 0, value)
-        else:
-            raise GEOSException('Cannot set Z on 2D Point.')
-
-    # X, Y, Z properties
-    x = property(get_x, set_x)
-    y = property(get_y, set_y)
-    z = property(get_z, set_z)
-
-    ### Tuple setting and retrieval routines. ###
-    def get_coords(self):
-        "Returns a tuple of the point."
-        return self._cs.tuple
-
-    def set_coords(self, tup):
-        "Sets the coordinates of the point with the given tuple."
-        self._cs[0] = tup
-
-    # The tuple and coords properties
-    tuple = property(get_coords, set_coords)
-    coords = tuple
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py b/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py
deleted file mode 100644
index c50f549..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py
+++ /dev/null
@@ -1,170 +0,0 @@
-from ctypes import c_uint, byref
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOM_PTR
-from django.contrib.gis.geos.linestring import LinearRing
-from django.contrib.gis.geos import prototypes as capi
-from django.utils import six
-from django.utils.six.moves import xrange
-
-class Polygon(GEOSGeometry):
-    _minlength = 1
-
-    def __init__(self, *args, **kwargs):
-        """
-        Initializes on an exterior ring and a sequence of holes (both
-        instances may be either LinearRing instances, or a tuple/list
-        that may be constructed into a LinearRing).
-
-        Examples of initialization, where shell, hole1, and hole2 are
-        valid LinearRing geometries:
-        >>> poly = Polygon(shell, hole1, hole2)
-        >>> poly = Polygon(shell, (hole1, hole2))
-
-        Example where a tuple parameters are used:
-        >>> poly = Polygon(((0, 0), (0, 10), (10, 10), (0, 10), (0, 0)),
-                           ((4, 4), (4, 6), (6, 6), (6, 4), (4, 4)))
-        """
-        if not args:
-            raise TypeError('Must provide at least one LinearRing, or a tuple, to initialize a Polygon.')
-
-        # Getting the ext_ring and init_holes parameters from the argument list
-        ext_ring = args[0]
-        init_holes = args[1:]
-        n_holes = len(init_holes)
-
-        # If initialized as Polygon(shell, (LinearRing, LinearRing)) [for backward-compatibility]
-        if n_holes == 1 and isinstance(init_holes[0], (tuple, list)):
-            if len(init_holes[0]) == 0:
-                init_holes  = ()
-                n_holes     = 0
-            elif isinstance(init_holes[0][0], LinearRing):
-                init_holes  = init_holes[0]
-                n_holes     = len(init_holes)
-
-        polygon = self._create_polygon(n_holes + 1, (ext_ring,) + init_holes)
-        super(Polygon, self).__init__(polygon, **kwargs)
-
-    def __iter__(self):
-        "Iterates over each ring in the polygon."
-        for i in xrange(len(self)):
-            yield self[i]
-
-    def __len__(self):
-        "Returns the number of rings in this Polygon."
-        return self.num_interior_rings + 1
-
-    @classmethod
-    def from_bbox(cls, bbox):
-        "Constructs a Polygon from a bounding box (4-tuple)."
-        x0, y0, x1, y1 = bbox
-        for z in bbox:
-            if not isinstance(z, six.integer_types + (float,)):
-                return GEOSGeometry('POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' %
-                                    (x0, y0, x0, y1, x1, y1, x1, y0, x0, y0))
-        return Polygon(((x0, y0), (x0, y1), (x1, y1), (x1, y0), (x0, y0)))
-
-    ### These routines are needed for list-like operation w/ListMixin ###
-    def _create_polygon(self, length, items):
-        # Instantiate LinearRing objects if necessary, but don't clone them yet
-        # _construct_ring will throw a TypeError if a parameter isn't a valid ring
-        # If we cloned the pointers here, we wouldn't be able to clean up
-        # in case of error.
-        rings = []
-        for r in items:
-            if isinstance(r, GEOM_PTR):
-                rings.append(r)
-            else:
-                rings.append(self._construct_ring(r))
-
-        shell = self._clone(rings.pop(0))
-
-        n_holes = length - 1
-        if n_holes:
-            holes = get_pointer_arr(n_holes)
-            for i, r in enumerate(rings):
-                holes[i] = self._clone(r)
-                holes_param = byref(holes)
-        else:
-            holes_param = None
-
-        return capi.create_polygon(shell, holes_param, c_uint(n_holes))
-
-    def _clone(self, g):
-        if isinstance(g, GEOM_PTR):
-            return capi.geom_clone(g)
-        else:
-            return capi.geom_clone(g.ptr)
-
-    def _construct_ring(self, param, msg='Parameter must be a sequence of LinearRings or objects that can initialize to LinearRings'):
-        "Helper routine for trying to construct a ring from the given parameter."
-        if isinstance(param, LinearRing): return param
-        try:
-            ring = LinearRing(param)
-            return ring
-        except TypeError:
-            raise TypeError(msg)
-
-    def _set_list(self, length, items):
-        # Getting the current pointer, replacing with the newly constructed
-        # geometry, and destroying the old geometry.
-        prev_ptr = self.ptr
-        srid = self.srid
-        self.ptr = self._create_polygon(length, items)
-        if srid: self.srid = srid
-        capi.destroy_geom(prev_ptr)
-
-    def _get_single_internal(self, index):
-        """
-        Returns the ring at the specified index.  The first index, 0, will
-        always return the exterior ring.  Indices > 0 will return the
-        interior ring at the given index (e.g., poly[1] and poly[2] would
-        return the first and second interior ring, respectively).
-
-        CAREFUL: Internal/External are not the same as Interior/Exterior!
-        _get_single_internal returns a pointer from the existing geometries for use
-        internally by the object's methods.  _get_single_external returns a clone
-        of the same geometry for use by external code.
-        """
-        if index == 0:
-            return capi.get_extring(self.ptr)
-        else:
-            # Getting the interior ring, have to subtract 1 from the index.
-            return capi.get_intring(self.ptr, index-1)
-
-    def _get_single_external(self, index):
-        return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid)
-
-    _set_single = GEOSGeometry._set_single_rebuild
-    _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild
-
-    #### Polygon Properties ####
-    @property
-    def num_interior_rings(self):
-        "Returns the number of interior rings."
-        # Getting the number of rings
-        return capi.get_nrings(self.ptr)
-
-    def _get_ext_ring(self):
-        "Gets the exterior ring of the Polygon."
-        return self[0]
-
-    def _set_ext_ring(self, ring):
-        "Sets the exterior ring of the Polygon."
-        self[0] = ring
-
-    # Properties for the exterior ring/shell.
-    exterior_ring = property(_get_ext_ring, _set_ext_ring)
-    shell = exterior_ring
-
-    @property
-    def tuple(self):
-        "Gets the tuple for each ring in this Polygon."
-        return tuple([self[i].tuple for i in xrange(len(self))])
-    coords = tuple
-
-    @property
-    def kml(self):
-        "Returns the KML representation of this Polygon."
-        inner_kml = ''.join(["<innerBoundaryIs>%s</innerBoundaryIs>" % self[i+1].kml
-                             for i in xrange(self.num_interior_rings)])
-        return "<Polygon><outerBoundaryIs>%s</outerBoundaryIs>%s</Polygon>" % (self[0].kml, inner_kml)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py
deleted file mode 100644
index ae2548f..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from django.contrib.gis.geos.base import GEOSBase
-from django.contrib.gis.geos.geometry import GEOSGeometry
-from django.contrib.gis.geos.prototypes import prepared as capi
-
-class PreparedGeometry(GEOSBase):
-    """
-    A geometry that is prepared for performing certain operations.
-    At the moment this includes the contains covers, and intersects
-    operations.
-    """
-    ptr_type = capi.PREPGEOM_PTR
-
-    def __init__(self, geom):
-        # Keeping a reference to the original geometry object to prevent it
-        # from being garbage collected which could then crash the prepared one
-        # See #21662
-        self._base_geom = geom
-        if not isinstance(geom, GEOSGeometry):
-            raise TypeError
-        self.ptr = capi.geos_prepare(geom.ptr)
-
-    def __del__(self):
-        if self._ptr: capi.prepared_destroy(self._ptr)
-
-    def contains(self, other):
-        return capi.prepared_contains(self.ptr, other.ptr)
-
-    def contains_properly(self, other):
-        return capi.prepared_contains_properly(self.ptr, other.ptr)
-
-    def covers(self, other):
-        return capi.prepared_covers(self.ptr, other.ptr)
-
-    def intersects(self, other):
-        return capi.prepared_intersects(self.ptr, other.ptr)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py
deleted file mode 100644
index 89b96c0..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py
+++ /dev/null
@@ -1,30 +0,0 @@
-"""
- This module contains all of the GEOS ctypes function prototypes. Each
- prototype handles the interaction between the GEOS library and Python
- via ctypes.
-"""
-
-# Coordinate sequence routines.
-from django.contrib.gis.geos.prototypes.coordseq import (create_cs, get_cs,
-    cs_clone, cs_getordinate, cs_setordinate, cs_getx, cs_gety, cs_getz,
-    cs_setx, cs_sety, cs_setz, cs_getsize, cs_getdims)
-
-# Geometry routines.
-from django.contrib.gis.geos.prototypes.geom import (from_hex, from_wkb, from_wkt,
-    create_point, create_linestring, create_linearring, create_polygon, create_collection,
-    destroy_geom, get_extring, get_intring, get_nrings, get_geomn, geom_clone,
-    geos_normalize, geos_type, geos_typeid, geos_get_srid, geos_set_srid,
-    get_dims, get_num_coords, get_num_geoms,
-    to_hex, to_wkb, to_wkt)
-
-# Miscellaneous routines.
-from django.contrib.gis.geos.prototypes.misc import *
-
-# Predicates
-from django.contrib.gis.geos.prototypes.predicates import (geos_hasz, geos_isempty,
-    geos_isring, geos_issimple, geos_isvalid, geos_contains, geos_crosses,
-    geos_disjoint, geos_equals, geos_equalsexact, geos_intersects,
-    geos_intersects, geos_overlaps, geos_relatepattern, geos_touches, geos_within)
-
-# Topology routines
-from django.contrib.gis.geos.prototypes.topology import *
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py
deleted file mode 100644
index 68b9480..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py
+++ /dev/null
@@ -1,83 +0,0 @@
-from ctypes import c_double, c_int, c_uint, POINTER
-from django.contrib.gis.geos.libgeos import GEOM_PTR, CS_PTR
-from django.contrib.gis.geos.prototypes.errcheck import last_arg_byref, GEOSException
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-## Error-checking routines specific to coordinate sequences. ##
-def check_cs_ptr(result, func, cargs):
-    "Error checking on routines that return Geometries."
-    if not result:
-        raise GEOSException('Error encountered checking Coordinate Sequence returned from GEOS C function "%s".' % func.__name__)
-    return result
-
-def check_cs_op(result, func, cargs):
-    "Checks the status code of a coordinate sequence operation."
-    if result == 0:
-        raise GEOSException('Could not set value on coordinate sequence')
-    else:
-        return result
-
-def check_cs_get(result, func, cargs):
-    "Checking the coordinate sequence retrieval."
-    check_cs_op(result, func, cargs)
-    # Object in by reference, return its value.
-    return last_arg_byref(cargs)
-
-## Coordinate sequence prototype generation functions. ##
-def cs_int(func):
-    "For coordinate sequence routines that return an integer."
-    func.argtypes = [CS_PTR, POINTER(c_uint)]
-    func.restype = c_int
-    func.errcheck = check_cs_get
-    return func
-
-def cs_operation(func, ordinate=False, get=False):
-    "For coordinate sequence operations."
-    if get:
-        # Get routines get double parameter passed-in by reference.
-        func.errcheck = check_cs_get
-        dbl_param = POINTER(c_double)
-    else:
-        func.errcheck = check_cs_op
-        dbl_param = c_double
-
-    if ordinate:
-        # Get/Set ordinate routines have an extra uint parameter.
-        func.argtypes = [CS_PTR, c_uint, c_uint, dbl_param]
-    else:
-        func.argtypes = [CS_PTR, c_uint, dbl_param]
-
-    func.restype = c_int
-    return func
-
-def cs_output(func, argtypes):
-    "For routines that return a coordinate sequence."
-    func.argtypes = argtypes
-    func.restype = CS_PTR
-    func.errcheck = check_cs_ptr
-    return func
-
-## Coordinate Sequence ctypes prototypes ##
-
-# Coordinate Sequence constructors & cloning.
-cs_clone = cs_output(GEOSFunc('GEOSCoordSeq_clone'), [CS_PTR])
-create_cs = cs_output(GEOSFunc('GEOSCoordSeq_create'), [c_uint, c_uint])
-get_cs = cs_output(GEOSFunc('GEOSGeom_getCoordSeq'), [GEOM_PTR])
-
-# Getting, setting ordinate
-cs_getordinate = cs_operation(GEOSFunc('GEOSCoordSeq_getOrdinate'), ordinate=True, get=True)
-cs_setordinate = cs_operation(GEOSFunc('GEOSCoordSeq_setOrdinate'), ordinate=True)
-
-# For getting, x, y, z
-cs_getx = cs_operation(GEOSFunc('GEOSCoordSeq_getX'), get=True)
-cs_gety = cs_operation(GEOSFunc('GEOSCoordSeq_getY'), get=True)
-cs_getz = cs_operation(GEOSFunc('GEOSCoordSeq_getZ'), get=True)
-
-# For setting, x, y, z
-cs_setx = cs_operation(GEOSFunc('GEOSCoordSeq_setX'))
-cs_sety = cs_operation(GEOSFunc('GEOSCoordSeq_setY'))
-cs_setz = cs_operation(GEOSFunc('GEOSCoordSeq_setZ'))
-
-# These routines return size & dimensions.
-cs_getsize = cs_int(GEOSFunc('GEOSCoordSeq_getSize'))
-cs_getdims = cs_int(GEOSFunc('GEOSCoordSeq_getDimensions'))
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py
deleted file mode 100644
index 97fcd21..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py
+++ /dev/null
@@ -1,95 +0,0 @@
-"""
- Error checking functions for GEOS ctypes prototype functions.
-"""
-import os
-from ctypes import c_void_p, string_at, CDLL
-from django.contrib.gis.geos.error import GEOSException
-from django.contrib.gis.geos.libgeos import GEOS_VERSION
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-# Getting the `free` routine used to free the memory allocated for
-# string pointers returned by GEOS.
-if GEOS_VERSION >= (3, 1, 1):
-    # In versions 3.1.1 and above, `GEOSFree` was added to the C API
-    # because `free` isn't always available on all platforms.
-    free = GEOSFunc('GEOSFree')
-    free.argtypes = [c_void_p]
-    free.restype = None
-else:
-    # Getting the `free` routine from the C library of the platform.
-    if os.name == 'nt':
-        # On NT, use the MS C library.
-        libc = CDLL('msvcrt')
-    else:
-        # On POSIX platforms C library is obtained by passing None into `CDLL`.
-        libc = CDLL(None)
-    free = libc.free
-
-### ctypes error checking routines ###
-def last_arg_byref(args):
-    "Returns the last C argument's value by reference."
-    return args[-1]._obj.value
-
-def check_dbl(result, func, cargs):
-    "Checks the status code and returns the double value passed in by reference."
-    # Checking the status code
-    if result != 1: return None
-    # Double passed in by reference, return its value.
-    return last_arg_byref(cargs)
-
-def check_geom(result, func, cargs):
-    "Error checking on routines that return Geometries."
-    if not result:
-        raise GEOSException('Error encountered checking Geometry returned from GEOS C function "%s".' % func.__name__)
-    return result
-
-def check_minus_one(result, func, cargs):
-    "Error checking on routines that should not return -1."
-    if result == -1:
-        raise GEOSException('Error encountered in GEOS C function "%s".' % func.__name__)
-    else:
-        return result
-
-def check_predicate(result, func, cargs):
-    "Error checking for unary/binary predicate functions."
-    val = ord(result) # getting the ordinal from the character
-    if val == 1: return True
-    elif val == 0: return False
-    else:
-        raise GEOSException('Error encountered on GEOS C predicate function "%s".' % func.__name__)
-
-def check_sized_string(result, func, cargs):
-    """
-    Error checking for routines that return explicitly sized strings.
-
-    This frees the memory allocated by GEOS at the result pointer.
-    """
-    if not result:
-        raise GEOSException('Invalid string pointer returned by GEOS C function "%s"' % func.__name__)
-    # A c_size_t object is passed in by reference for the second
-    # argument on these routines, and its needed to determine the
-    # correct size.
-    s = string_at(result, last_arg_byref(cargs))
-    # Freeing the memory allocated within GEOS
-    free(result)
-    return s
-
-def check_string(result, func, cargs):
-    """
-    Error checking for routines that return strings.
-
-    This frees the memory allocated by GEOS at the result pointer.
-    """
-    if not result: raise GEOSException('Error encountered checking string return value in GEOS C function "%s".' % func.__name__)
-    # Getting the string value at the pointer address.
-    s = string_at(result)
-    # Freeing the memory allocated within GEOS
-    free(result)
-    return s
-
-def check_zero(result, func, cargs):
-    "Error checking on routines that should not return 0."
-    if result == 0:
-        raise GEOSException('Error encountered in GEOS C function "%s".' % func.__name__)
-    else:
-        return result
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py
deleted file mode 100644
index 2683c2e..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py
+++ /dev/null
@@ -1,119 +0,0 @@
-from ctypes import c_char_p, c_int, c_size_t, c_ubyte, POINTER
-from django.contrib.gis.geos.libgeos import CS_PTR, GEOM_PTR
-from django.contrib.gis.geos.prototypes.errcheck import (
-    check_geom, check_minus_one, check_sized_string, check_string, check_zero)
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-# This is the return type used by binary output (WKB, HEX) routines.
-c_uchar_p = POINTER(c_ubyte)
-
-# We create a simple subclass of c_char_p here because when the response
-# type is set to c_char_p, you get a _Python_ string and there's no way
-# to access the string's address inside the error checking function.
-# In other words, you can't free the memory allocated inside GEOS.  Previously,
-# the return type would just be omitted and the integer address would be
-# used -- but this allows us to be specific in the function definition and
-# keeps the reference so it may be free'd.
-class geos_char_p(c_char_p):
-    pass
-
-### ctypes generation functions ###
-def bin_constructor(func):
-    "Generates a prototype for binary construction (HEX, WKB) GEOS routines."
-    func.argtypes = [c_char_p, c_size_t]
-    func.restype = GEOM_PTR
-    func.errcheck = check_geom
-    return func
-
-# HEX & WKB output
-def bin_output(func):
-    "Generates a prototype for the routines that return a sized string."
-    func.argtypes = [GEOM_PTR, POINTER(c_size_t)]
-    func.errcheck = check_sized_string
-    func.restype = c_uchar_p
-    return func
-
-def geom_output(func, argtypes):
-    "For GEOS routines that return a geometry."
-    if argtypes: func.argtypes = argtypes
-    func.restype = GEOM_PTR
-    func.errcheck = check_geom
-    return func
-
-def geom_index(func):
-    "For GEOS routines that return geometries from an index."
-    return geom_output(func, [GEOM_PTR, c_int])
-
-def int_from_geom(func, zero=False):
-    "Argument is a geometry, return type is an integer."
-    func.argtypes = [GEOM_PTR]
-    func.restype = c_int
-    if zero:
-        func.errcheck = check_zero
-    else:
-        func.errcheck = check_minus_one
-    return func
-
-def string_from_geom(func):
-    "Argument is a Geometry, return type is a string."
-    func.argtypes = [GEOM_PTR]
-    func.restype = geos_char_p
-    func.errcheck = check_string
-    return func
-
-### ctypes prototypes ###
-
-# Deprecated creation routines from WKB, HEX, WKT
-from_hex = bin_constructor(GEOSFunc('GEOSGeomFromHEX_buf'))
-from_wkb = bin_constructor(GEOSFunc('GEOSGeomFromWKB_buf'))
-from_wkt = geom_output(GEOSFunc('GEOSGeomFromWKT'), [c_char_p])
-
-# Deprecated output routines
-to_hex = bin_output(GEOSFunc('GEOSGeomToHEX_buf'))
-to_wkb = bin_output(GEOSFunc('GEOSGeomToWKB_buf'))
-to_wkt = string_from_geom(GEOSFunc('GEOSGeomToWKT'))
-
-# The GEOS geometry type, typeid, num_coordites and number of geometries
-geos_normalize = int_from_geom(GEOSFunc('GEOSNormalize'))
-geos_type = string_from_geom(GEOSFunc('GEOSGeomType'))
-geos_typeid = int_from_geom(GEOSFunc('GEOSGeomTypeId'))
-get_dims = int_from_geom(GEOSFunc('GEOSGeom_getDimensions'), zero=True)
-get_num_coords = int_from_geom(GEOSFunc('GEOSGetNumCoordinates'))
-get_num_geoms = int_from_geom(GEOSFunc('GEOSGetNumGeometries'))
-
-# Geometry creation factories
-create_point = geom_output(GEOSFunc('GEOSGeom_createPoint'), [CS_PTR])
-create_linestring = geom_output(GEOSFunc('GEOSGeom_createLineString'), [CS_PTR])
-create_linearring = geom_output(GEOSFunc('GEOSGeom_createLinearRing'), [CS_PTR])
-
-# Polygon and collection creation routines are special and will not
-# have their argument types defined.
-create_polygon = geom_output(GEOSFunc('GEOSGeom_createPolygon'), None)
-create_collection = geom_output(GEOSFunc('GEOSGeom_createCollection'), None)
-
-# Ring routines
-get_extring = geom_output(GEOSFunc('GEOSGetExteriorRing'), [GEOM_PTR])
-get_intring = geom_index(GEOSFunc('GEOSGetInteriorRingN'))
-get_nrings = int_from_geom(GEOSFunc('GEOSGetNumInteriorRings'))
-
-# Collection Routines
-get_geomn = geom_index(GEOSFunc('GEOSGetGeometryN'))
-
-# Cloning
-geom_clone = GEOSFunc('GEOSGeom_clone')
-geom_clone.argtypes = [GEOM_PTR]
-geom_clone.restype = GEOM_PTR
-
-# Destruction routine.
-destroy_geom = GEOSFunc('GEOSGeom_destroy')
-destroy_geom.argtypes = [GEOM_PTR]
-destroy_geom.restype = None
-
-# SRID routines
-geos_get_srid = GEOSFunc('GEOSGetSRID')
-geos_get_srid.argtypes = [GEOM_PTR]
-geos_get_srid.restype = c_int
-
-geos_set_srid = GEOSFunc('GEOSSetSRID')
-geos_set_srid.argtypes = [GEOM_PTR, c_int]
-geos_set_srid.restype = None
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py
deleted file mode 100644
index 1e80351..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py
+++ /dev/null
@@ -1,265 +0,0 @@
-import threading
-from ctypes import byref, c_char_p, c_int, c_char, c_size_t, Structure, POINTER
-from django.contrib.gis import memoryview
-from django.contrib.gis.geos.base import GEOSBase
-from django.contrib.gis.geos.libgeos import GEOM_PTR
-from django.contrib.gis.geos.prototypes.errcheck import check_geom, check_string, check_sized_string
-from django.contrib.gis.geos.prototypes.geom import c_uchar_p, geos_char_p
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-from django.utils import six
-from django.utils.encoding import force_bytes
-
-### The WKB/WKT Reader/Writer structures and pointers ###
-class WKTReader_st(Structure): pass
-class WKTWriter_st(Structure): pass
-class WKBReader_st(Structure): pass
-class WKBWriter_st(Structure): pass
-
-WKT_READ_PTR  = POINTER(WKTReader_st)
-WKT_WRITE_PTR = POINTER(WKTWriter_st)
-WKB_READ_PTR  = POINTER(WKBReader_st)
-WKB_WRITE_PTR = POINTER(WKBReader_st)
-
-### WKTReader routines ###
-wkt_reader_create = GEOSFunc('GEOSWKTReader_create')
-wkt_reader_create.restype = WKT_READ_PTR
-
-wkt_reader_destroy = GEOSFunc('GEOSWKTReader_destroy')
-wkt_reader_destroy.argtypes = [WKT_READ_PTR]
-
-wkt_reader_read = GEOSFunc('GEOSWKTReader_read')
-wkt_reader_read.argtypes = [WKT_READ_PTR, c_char_p]
-wkt_reader_read.restype = GEOM_PTR
-wkt_reader_read.errcheck = check_geom
-
-### WKTWriter routines ###
-wkt_writer_create = GEOSFunc('GEOSWKTWriter_create')
-wkt_writer_create.restype = WKT_WRITE_PTR
-
-wkt_writer_destroy = GEOSFunc('GEOSWKTWriter_destroy')
-wkt_writer_destroy.argtypes = [WKT_WRITE_PTR]
-
-wkt_writer_write = GEOSFunc('GEOSWKTWriter_write')
-wkt_writer_write.argtypes = [WKT_WRITE_PTR, GEOM_PTR]
-wkt_writer_write.restype = geos_char_p
-wkt_writer_write.errcheck = check_string
-
-try:
-    wkt_writer_get_outdim = GEOSFunc('GEOSWKTWriter_getOutputDimension')
-    wkt_writer_get_outdim.argtypes = [WKT_WRITE_PTR]
-    wkt_writer_get_outdim.restype = c_int
-    wkt_writer_set_outdim = GEOSFunc('GEOSWKTWriter_setOutputDimension')
-    wkt_writer_set_outdim.argtypes = [WKT_WRITE_PTR, c_int]
-except AttributeError:
-    # GEOSWKTWriter_get/setOutputDimension has been introduced in GEOS 3.3.0
-    # Always return 2 if not available
-    wkt_writer_get_outdim = lambda ptr: 2
-    wkt_writer_set_outdim = lambda ptr, dim: None
-
-### WKBReader routines ###
-wkb_reader_create = GEOSFunc('GEOSWKBReader_create')
-wkb_reader_create.restype = WKB_READ_PTR
-
-wkb_reader_destroy = GEOSFunc('GEOSWKBReader_destroy')
-wkb_reader_destroy.argtypes = [WKB_READ_PTR]
-
-def wkb_read_func(func):
-    # Although the function definitions take `const unsigned char *`
-    # as their parameter, we use c_char_p here so the function may
-    # take Python strings directly as parameters.  Inside Python there
-    # is not a difference between signed and unsigned characters, so
-    # it is not a problem.
-    func.argtypes = [WKB_READ_PTR, c_char_p, c_size_t]
-    func.restype = GEOM_PTR
-    func.errcheck = check_geom
-    return func
-
-wkb_reader_read = wkb_read_func(GEOSFunc('GEOSWKBReader_read'))
-wkb_reader_read_hex = wkb_read_func(GEOSFunc('GEOSWKBReader_readHEX'))
-
-### WKBWriter routines ###
-wkb_writer_create = GEOSFunc('GEOSWKBWriter_create')
-wkb_writer_create.restype = WKB_WRITE_PTR
-
-wkb_writer_destroy = GEOSFunc('GEOSWKBWriter_destroy')
-wkb_writer_destroy.argtypes = [WKB_WRITE_PTR]
-
-# WKB Writing prototypes.
-def wkb_write_func(func):
-    func.argtypes = [WKB_WRITE_PTR, GEOM_PTR, POINTER(c_size_t)]
-    func.restype = c_uchar_p
-    func.errcheck = check_sized_string
-    return func
-
-wkb_writer_write = wkb_write_func(GEOSFunc('GEOSWKBWriter_write'))
-wkb_writer_write_hex = wkb_write_func(GEOSFunc('GEOSWKBWriter_writeHEX'))
-
-# WKBWriter property getter/setter prototypes.
-def wkb_writer_get(func, restype=c_int):
-    func.argtypes = [WKB_WRITE_PTR]
-    func.restype = restype
-    return func
-
-def wkb_writer_set(func, argtype=c_int):
-    func.argtypes = [WKB_WRITE_PTR, argtype]
-    return func
-
-wkb_writer_get_byteorder = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getByteOrder'))
-wkb_writer_set_byteorder = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setByteOrder'))
-wkb_writer_get_outdim    = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getOutputDimension'))
-wkb_writer_set_outdim    = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setOutputDimension'))
-wkb_writer_get_include_srid = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getIncludeSRID'), restype=c_char)
-wkb_writer_set_include_srid = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setIncludeSRID'), argtype=c_char)
-
-### Base I/O Class ###
-class IOBase(GEOSBase):
-    "Base class for GEOS I/O objects."
-    def __init__(self):
-        # Getting the pointer with the constructor.
-        self.ptr = self._constructor()
-
-    def __del__(self):
-        # Cleaning up with the appropriate destructor.
-        if self._ptr: self._destructor(self._ptr)
-
-### Base WKB/WKT Reading and Writing objects ###
-
-# Non-public WKB/WKT reader classes for internal use because
-# their `read` methods return _pointers_ instead of GEOSGeometry
-# objects.
-class _WKTReader(IOBase):
-    _constructor = wkt_reader_create
-    _destructor = wkt_reader_destroy
-    ptr_type = WKT_READ_PTR
-
-    def read(self, wkt):
-        if not isinstance(wkt, (bytes, six.string_types)):
-            raise TypeError
-        return wkt_reader_read(self.ptr, force_bytes(wkt))
-
-class _WKBReader(IOBase):
-    _constructor = wkb_reader_create
-    _destructor = wkb_reader_destroy
-    ptr_type = WKB_READ_PTR
-
-    def read(self, wkb):
-        "Returns a _pointer_ to C GEOS Geometry object from the given WKB."
-        if isinstance(wkb, memoryview):
-            wkb_s = bytes(wkb)
-            return wkb_reader_read(self.ptr, wkb_s, len(wkb_s))
-        elif isinstance(wkb, (bytes, six.string_types)):
-            return wkb_reader_read_hex(self.ptr, wkb, len(wkb))
-        else:
-            raise TypeError
-
-### WKB/WKT Writer Classes ###
-class WKTWriter(IOBase):
-    _constructor = wkt_writer_create
-    _destructor = wkt_writer_destroy
-    ptr_type = WKT_WRITE_PTR
-
-    def write(self, geom):
-        "Returns the WKT representation of the given geometry."
-        return wkt_writer_write(self.ptr, geom.ptr)
-
-    @property
-    def outdim(self):
-        return wkt_writer_get_outdim(self.ptr)
-
-    @outdim.setter
-    def outdim(self, new_dim):
-        if not new_dim in (2, 3):
-            raise ValueError('WKT output dimension must be 2 or 3')
-        wkt_writer_set_outdim(self.ptr, new_dim)
-
-
-class WKBWriter(IOBase):
-    _constructor = wkb_writer_create
-    _destructor = wkb_writer_destroy
-    ptr_type = WKB_WRITE_PTR
-
-    def write(self, geom):
-        "Returns the WKB representation of the given geometry."
-        return memoryview(wkb_writer_write(self.ptr, geom.ptr, byref(c_size_t())))
-
-    def write_hex(self, geom):
-        "Returns the HEXEWKB representation of the given geometry."
-        return wkb_writer_write_hex(self.ptr, geom.ptr, byref(c_size_t()))
-
-    ### WKBWriter Properties ###
-
-    # Property for getting/setting the byteorder.
-    def _get_byteorder(self):
-        return wkb_writer_get_byteorder(self.ptr)
-
-    def _set_byteorder(self, order):
-        if not order in (0, 1): raise ValueError('Byte order parameter must be 0 (Big Endian) or 1 (Little Endian).')
-        wkb_writer_set_byteorder(self.ptr, order)
-
-    byteorder = property(_get_byteorder, _set_byteorder)
-
-    # Property for getting/setting the output dimension.
-    def _get_outdim(self):
-        return wkb_writer_get_outdim(self.ptr)
-
-    def _set_outdim(self, new_dim):
-        if not new_dim in (2, 3): raise ValueError('WKB output dimension must be 2 or 3')
-        wkb_writer_set_outdim(self.ptr, new_dim)
-
-    outdim = property(_get_outdim, _set_outdim)
-
-    # Property for getting/setting the include srid flag.
-    def _get_include_srid(self):
-        return bool(ord(wkb_writer_get_include_srid(self.ptr)))
-
-    def _set_include_srid(self, include):
-        if bool(include): flag = b'\x01'
-        else: flag = b'\x00'
-        wkb_writer_set_include_srid(self.ptr, flag)
-
-    srid = property(_get_include_srid, _set_include_srid)
-
-# `ThreadLocalIO` object holds instances of the WKT and WKB reader/writer
-# objects that are local to the thread.  The `GEOSGeometry` internals
-# access these instances by calling the module-level functions, defined
-# below.
-class ThreadLocalIO(threading.local):
-    wkt_r = None
-    wkt_w = None
-    wkb_r = None
-    wkb_w = None
-    ewkb_w = None
-
-thread_context = ThreadLocalIO()
-
-# These module-level routines return the I/O object that is local to the
-# thread. If the I/O object does not exist yet it will be initialized.
-def wkt_r():
-    if not thread_context.wkt_r:
-        thread_context.wkt_r = _WKTReader()
-    return thread_context.wkt_r
-
-def wkt_w(dim=2):
-    if not thread_context.wkt_w:
-        thread_context.wkt_w = WKTWriter()
-    thread_context.wkt_w.outdim = dim
-    return thread_context.wkt_w
-
-def wkb_r():
-    if not thread_context.wkb_r:
-        thread_context.wkb_r = _WKBReader()
-    return thread_context.wkb_r
-
-def wkb_w(dim=2):
-   if not thread_context.wkb_w:
-       thread_context.wkb_w = WKBWriter()
-   thread_context.wkb_w.outdim = dim
-   return thread_context.wkb_w
-
-def ewkb_w(dim=2):
-    if not thread_context.ewkb_w:
-        thread_context.ewkb_w = WKBWriter()
-        thread_context.ewkb_w.srid = True
-    thread_context.ewkb_w.outdim = dim
-    return thread_context.ewkb_w
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py
deleted file mode 100644
index 5a9b555..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""
- This module is for the miscellaneous GEOS routines, particularly the
- ones that return the area, distance, and length.
-"""
-from ctypes import c_int, c_double, POINTER
-from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE
-from django.contrib.gis.geos.prototypes.errcheck import check_dbl, check_string
-from django.contrib.gis.geos.prototypes.geom import geos_char_p
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-from django.utils.six.moves import xrange
-
-__all__ = ['geos_area', 'geos_distance', 'geos_length']
-
-### ctypes generator function ###
-def dbl_from_geom(func, num_geom=1):
-    """
-    Argument is a Geometry, return type is double that is passed
-    in by reference as the last argument.
-    """
-    argtypes = [GEOM_PTR for i in xrange(num_geom)]
-    argtypes += [POINTER(c_double)]
-    func.argtypes = argtypes
-    func.restype = c_int # Status code returned
-    func.errcheck = check_dbl
-    return func
-
-### ctypes prototypes ###
-
-# Area, distance, and length prototypes.
-geos_area = dbl_from_geom(GEOSFunc('GEOSArea'))
-geos_distance = dbl_from_geom(GEOSFunc('GEOSDistance'), num_geom=2)
-geos_length = dbl_from_geom(GEOSFunc('GEOSLength'))
-
-# Validity reason; only in GEOS 3.1+
-if GEOS_PREPARE:
-    geos_isvalidreason = GEOSFunc('GEOSisValidReason')
-    geos_isvalidreason.argtypes = [GEOM_PTR]
-    geos_isvalidreason.restype = geos_char_p
-    geos_isvalidreason.errcheck = check_string
-    __all__.append('geos_isvalidreason')
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py
deleted file mode 100644
index bf69bb1..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""
- This module houses the GEOS ctypes prototype functions for the
- unary and binary predicate operations on geometries.
-"""
-from ctypes import c_char, c_char_p, c_double
-from django.contrib.gis.geos.libgeos import GEOM_PTR
-from django.contrib.gis.geos.prototypes.errcheck import check_predicate
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-## Binary & unary predicate functions ##
-def binary_predicate(func, *args):
-    "For GEOS binary predicate functions."
-    argtypes = [GEOM_PTR, GEOM_PTR]
-    if args: argtypes += args
-    func.argtypes = argtypes
-    func.restype = c_char
-    func.errcheck = check_predicate
-    return func
-
-def unary_predicate(func):
-    "For GEOS unary predicate functions."
-    func.argtypes = [GEOM_PTR]
-    func.restype = c_char
-    func.errcheck = check_predicate
-    return func
-
-## Unary Predicates ##
-geos_hasz = unary_predicate(GEOSFunc('GEOSHasZ'))
-geos_isempty = unary_predicate(GEOSFunc('GEOSisEmpty'))
-geos_isring = unary_predicate(GEOSFunc('GEOSisRing'))
-geos_issimple = unary_predicate(GEOSFunc('GEOSisSimple'))
-geos_isvalid = unary_predicate(GEOSFunc('GEOSisValid'))
-
-## Binary Predicates ##
-geos_contains = binary_predicate(GEOSFunc('GEOSContains'))
-geos_crosses = binary_predicate(GEOSFunc('GEOSCrosses'))
-geos_disjoint = binary_predicate(GEOSFunc('GEOSDisjoint'))
-geos_equals = binary_predicate(GEOSFunc('GEOSEquals'))
-geos_equalsexact = binary_predicate(GEOSFunc('GEOSEqualsExact'), c_double)
-geos_intersects = binary_predicate(GEOSFunc('GEOSIntersects'))
-geos_overlaps = binary_predicate(GEOSFunc('GEOSOverlaps'))
-geos_relatepattern = binary_predicate(GEOSFunc('GEOSRelatePattern'), c_char_p)
-geos_touches = binary_predicate(GEOSFunc('GEOSTouches'))
-geos_within = binary_predicate(GEOSFunc('GEOSWithin'))
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py
deleted file mode 100644
index 7342d7d..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from ctypes import c_char
-from django.contrib.gis.geos.libgeos import GEOM_PTR, PREPGEOM_PTR
-from django.contrib.gis.geos.prototypes.errcheck import check_predicate
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-# Prepared geometry constructor and destructors.
-geos_prepare = GEOSFunc('GEOSPrepare')
-geos_prepare.argtypes = [GEOM_PTR]
-geos_prepare.restype = PREPGEOM_PTR
-
-prepared_destroy = GEOSFunc('GEOSPreparedGeom_destroy')
-prepared_destroy.argtpes = [PREPGEOM_PTR]
-prepared_destroy.restype = None
-
-# Prepared geometry binary predicate support.
-def prepared_predicate(func):
-    func.argtypes= [PREPGEOM_PTR, GEOM_PTR]
-    func.restype = c_char
-    func.errcheck = check_predicate
-    return func
-
-prepared_contains = prepared_predicate(GEOSFunc('GEOSPreparedContains'))
-prepared_contains_properly = prepared_predicate(GEOSFunc('GEOSPreparedContainsProperly'))
-prepared_covers = prepared_predicate(GEOSFunc('GEOSPreparedCovers'))
-prepared_intersects = prepared_predicate(GEOSFunc('GEOSPreparedIntersects'))
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py
deleted file mode 100644
index 2c9d25e..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import threading
-from django.contrib.gis.geos.libgeos import lgeos, notice_h, error_h, CONTEXT_PTR
-
-class GEOSContextHandle(object):
-    """
-    Python object representing a GEOS context handle.
-    """
-    def __init__(self):
-        # Initializing the context handler for this thread with
-        # the notice and error handler.
-        self.ptr = lgeos.initGEOS_r(notice_h, error_h)
-
-    def __del__(self):
-        if self.ptr: lgeos.finishGEOS_r(self.ptr)
-
-# Defining a thread-local object and creating an instance
-# to hold a reference to GEOSContextHandle for this thread.
-class GEOSContext(threading.local):
-    handle = None
-
-thread_context = GEOSContext()
-
-class GEOSFunc(object):
-    """
-    Class that serves as a wrapper for GEOS C Functions, and will
-    use thread-safe function variants when available.
-    """
-    def __init__(self, func_name):
-        try:
-            # GEOS thread-safe function signatures end with '_r', and
-            # take an additional context handle parameter.
-            self.cfunc = getattr(lgeos, func_name + '_r')
-            self.threaded = True
-            # Create a reference here to thread_context so it's not
-            # garbage-collected before an attempt to call this object.
-            self.thread_context = thread_context
-        except AttributeError:
-            # Otherwise, use usual function.
-            self.cfunc = getattr(lgeos, func_name)
-            self.threaded = False
-
-    def __call__(self, *args):
-        if self.threaded:
-            # If a context handle does not exist for this thread, initialize one.
-            if not self.thread_context.handle:
-                self.thread_context.handle = GEOSContextHandle()
-            # Call the threaded GEOS routine with pointer of the context handle
-            # as the first argument.
-            return self.cfunc(self.thread_context.handle.ptr, *args)
-        else:
-            return self.cfunc(*args)
-
-    def __str__(self):
-        return self.cfunc.__name__
-
-    # argtypes property
-    def _get_argtypes(self):
-        return self.cfunc.argtypes
-
-    def _set_argtypes(self, argtypes):
-        if self.threaded:
-            new_argtypes = [CONTEXT_PTR]
-            new_argtypes.extend(argtypes)
-            self.cfunc.argtypes = new_argtypes
-        else:
-            self.cfunc.argtypes = argtypes
-
-    argtypes = property(_get_argtypes, _set_argtypes)
-
-    # restype property
-    def _get_restype(self):
-        return self.cfunc.restype
-
-    def _set_restype(self, restype):
-        self.cfunc.restype = restype
-
-    restype = property(_get_restype, _set_restype)
-
-    # errcheck property
-    def _get_errcheck(self):
-        return self.cfunc.errcheck
-
-    def _set_errcheck(self, errcheck):
-        self.cfunc.errcheck = errcheck
-
-    errcheck = property(_get_errcheck, _set_errcheck)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py
deleted file mode 100644
index dfea3e9..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py
+++ /dev/null
@@ -1,64 +0,0 @@
-"""
- This module houses the GEOS ctypes prototype functions for the
- topological operations on geometries.
-"""
-__all__ = ['geos_boundary', 'geos_buffer', 'geos_centroid', 'geos_convexhull',
-           'geos_difference', 'geos_envelope', 'geos_intersection', 
-           'geos_linemerge', 'geos_pointonsurface', 'geos_preservesimplify',
-           'geos_simplify', 'geos_symdifference', 'geos_union', 'geos_relate']
-
-from ctypes import c_double, c_int
-from django.contrib.gis.geos.libgeos import geos_version_info, GEOM_PTR, GEOS_PREPARE
-from django.contrib.gis.geos.prototypes.errcheck import check_geom, check_minus_one, check_string
-from django.contrib.gis.geos.prototypes.geom import geos_char_p
-from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc
-
-def topology(func, *args, **kwargs):
-    "For GEOS unary topology functions."
-    argtypes = [GEOM_PTR]
-    if args: argtypes += args
-    func.argtypes = argtypes
-    func.restype = kwargs.get('restype', GEOM_PTR)
-    func.errcheck = kwargs.get('errcheck', check_geom)
-    return func
-
-### Topology Routines ###
-geos_boundary = topology(GEOSFunc('GEOSBoundary'))
-geos_buffer = topology(GEOSFunc('GEOSBuffer'), c_double, c_int)
-geos_centroid = topology(GEOSFunc('GEOSGetCentroid'))
-geos_convexhull = topology(GEOSFunc('GEOSConvexHull'))
-geos_difference = topology(GEOSFunc('GEOSDifference'), GEOM_PTR)
-geos_envelope = topology(GEOSFunc('GEOSEnvelope'))
-geos_intersection = topology(GEOSFunc('GEOSIntersection'), GEOM_PTR)
-geos_linemerge = topology(GEOSFunc('GEOSLineMerge'))
-geos_pointonsurface = topology(GEOSFunc('GEOSPointOnSurface'))
-geos_preservesimplify = topology(GEOSFunc('GEOSTopologyPreserveSimplify'), c_double)
-geos_simplify = topology(GEOSFunc('GEOSSimplify'), c_double)
-geos_symdifference = topology(GEOSFunc('GEOSSymDifference'), GEOM_PTR)
-geos_union = topology(GEOSFunc('GEOSUnion'), GEOM_PTR)
-
-# GEOSRelate returns a string, not a geometry.
-geos_relate = GEOSFunc('GEOSRelate')
-geos_relate.argtypes = [GEOM_PTR, GEOM_PTR]
-geos_relate.restype = geos_char_p
-geos_relate.errcheck = check_string
-
-# Routines only in GEOS 3.1+
-if GEOS_PREPARE:
-    geos_cascaded_union = GEOSFunc('GEOSUnionCascaded')
-    geos_cascaded_union.argtypes = [GEOM_PTR]
-    geos_cascaded_union.restype = GEOM_PTR
-    __all__.append('geos_cascaded_union')
-
-# Linear referencing routines
-info = geos_version_info()
-if info['version'] >= '3.2.0':
-    geos_project = topology(GEOSFunc('GEOSProject'), GEOM_PTR,
-        restype=c_double, errcheck=check_minus_one)
-    geos_interpolate = topology(GEOSFunc('GEOSInterpolate'), c_double)
-
-    geos_project_normalized = topology(GEOSFunc('GEOSProjectNormalized'),
-        GEOM_PTR, restype=c_double, errcheck=check_minus_one)
-    geos_interpolate_normalized = topology(GEOSFunc('GEOSInterpolateNormalized'), c_double)
-    __all__.extend(['geos_project', 'geos_interpolate',
-        'geos_project_normalized', 'geos_interpolate_normalized'])
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py
+++ /dev/null
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py
deleted file mode 100644
index c8e064b..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py
+++ /dev/null
@@ -1,1108 +0,0 @@
-from __future__ import unicode_literals
-
-import ctypes
-import json
-import random
-from binascii import a2b_hex, b2a_hex
-from io import BytesIO
-
-from django.contrib.gis.gdal import HAS_GDAL
-
-from django.contrib.gis import memoryview
-from django.contrib.gis.geometry.test_data import TestDataMixin
-
-from django.utils.encoding import force_bytes
-from django.utils import six
-from django.utils.six.moves import xrange
-from django.utils import unittest
-from django.utils.unittest import skipUnless
-
-from .. import HAS_GEOS
-
-if HAS_GEOS:
-    from .. import (GEOSException, GEOSIndexError, GEOSGeometry,
-        GeometryCollection, Point, MultiPoint, Polygon, MultiPolygon, LinearRing,
-        LineString, MultiLineString, fromfile, fromstr, geos_version_info,
-        GEOS_PREPARE)
-    from ..base import gdal, numpy, GEOSBase
-
-
-@skipUnless(HAS_GEOS, "Geos is required.")
-class GEOSTest(unittest.TestCase, TestDataMixin):
-
-    @property
-    def null_srid(self):
-        """
-        Returns the proper null SRID depending on the GEOS version.
-        See the comments in `test_srid` for more details.
-        """
-        info = geos_version_info()
-        if info['version'] == '3.0.0' and info['release_candidate']:
-            return -1
-        else:
-            return None
-
-    def test_base(self):
-        "Tests out the GEOSBase class."
-        # Testing out GEOSBase class, which provides a `ptr` property
-        # that abstracts out access to underlying C pointers.
-        class FakeGeom1(GEOSBase):
-            pass
-
-        # This one only accepts pointers to floats
-        c_float_p = ctypes.POINTER(ctypes.c_float)
-        class FakeGeom2(GEOSBase):
-            ptr_type = c_float_p
-
-        # Default ptr_type is `c_void_p`.
-        fg1 = FakeGeom1()
-        # Default ptr_type is C float pointer
-        fg2 = FakeGeom2()
-
-        # These assignments are OK -- None is allowed because
-        # it's equivalent to the NULL pointer.
-        fg1.ptr = ctypes.c_void_p()
-        fg1.ptr = None
-        fg2.ptr = c_float_p(ctypes.c_float(5.23))
-        fg2.ptr = None
-
-        # Because pointers have been set to NULL, an exception should be
-        # raised when we try to access it.  Raising an exception is
-        # preferrable to a segmentation fault that commonly occurs when
-        # a C method is given a NULL memory reference.
-        for fg in (fg1, fg2):
-            # Equivalent to `fg.ptr`
-            self.assertRaises(GEOSException, fg._get_ptr)
-
-        # Anything that is either not None or the acceptable pointer type will
-        # result in a TypeError when trying to assign it to the `ptr` property.
-        # Thus, memmory addresses (integers) and pointers of the incorrect type
-        # (in `bad_ptrs`) will not be allowed.
-        bad_ptrs = (5, ctypes.c_char_p(b'foobar'))
-        for bad_ptr in bad_ptrs:
-            # Equivalent to `fg.ptr = bad_ptr`
-            self.assertRaises(TypeError, fg1._set_ptr, bad_ptr)
-            self.assertRaises(TypeError, fg2._set_ptr, bad_ptr)
-
-    def test_wkt(self):
-        "Testing WKT output."
-        for g in self.geometries.wkt_out:
-            geom = fromstr(g.wkt)
-            if geom.hasz and geos_version_info()['version'] >= '3.3.0':
-                self.assertEqual(g.ewkt, geom.wkt)
-
-    def test_hex(self):
-        "Testing HEX output."
-        for g in self.geometries.hex_wkt:
-            geom = fromstr(g.wkt)
-            self.assertEqual(g.hex, geom.hex.decode())
-
-    def test_hexewkb(self):
-        "Testing (HEX)EWKB output."
-        # For testing HEX(EWKB).
-        ogc_hex = b'01010000000000000000000000000000000000F03F'
-        ogc_hex_3d = b'01010000800000000000000000000000000000F03F0000000000000040'
-        # `SELECT ST_AsHEXEWKB(ST_GeomFromText('POINT(0 1)', 4326));`
-        hexewkb_2d = b'0101000020E61000000000000000000000000000000000F03F'
-        # `SELECT ST_AsHEXEWKB(ST_GeomFromEWKT('SRID=4326;POINT(0 1 2)'));`
-        hexewkb_3d = b'01010000A0E61000000000000000000000000000000000F03F0000000000000040'
-
-        pnt_2d = Point(0, 1, srid=4326)
-        pnt_3d = Point(0, 1, 2, srid=4326)
-
-        # OGC-compliant HEX will not have SRID value.
-        self.assertEqual(ogc_hex, pnt_2d.hex)
-        self.assertEqual(ogc_hex_3d, pnt_3d.hex)
-
-        # HEXEWKB should be appropriate for its dimension -- have to use an
-        # a WKBWriter w/dimension set accordingly, else GEOS will insert
-        # garbage into 3D coordinate if there is none.  Also, GEOS has a
-        # a bug in versions prior to 3.1 that puts the X coordinate in
-        # place of Z; an exception should be raised on those versions.
-        self.assertEqual(hexewkb_2d, pnt_2d.hexewkb)
-        if GEOS_PREPARE:
-            self.assertEqual(hexewkb_3d, pnt_3d.hexewkb)
-            self.assertEqual(True, GEOSGeometry(hexewkb_3d).hasz)
-        else:
-            try:
-                hexewkb = pnt_3d.hexewkb
-            except GEOSException:
-                pass
-            else:
-                self.fail('Should have raised GEOSException.')
-
-        # Same for EWKB.
-        self.assertEqual(memoryview(a2b_hex(hexewkb_2d)), pnt_2d.ewkb)
-        if GEOS_PREPARE:
-            self.assertEqual(memoryview(a2b_hex(hexewkb_3d)), pnt_3d.ewkb)
-        else:
-            try:
-                ewkb = pnt_3d.ewkb
-            except GEOSException:
-                pass
-            else:
-                self.fail('Should have raised GEOSException')
-
-        # Redundant sanity check.
-        self.assertEqual(4326, GEOSGeometry(hexewkb_2d).srid)
-
-    def test_kml(self):
-        "Testing KML output."
-        for tg in self.geometries.wkt_out:
-            geom = fromstr(tg.wkt)
-            kml = getattr(tg, 'kml', False)
-            if kml: self.assertEqual(kml, geom.kml)
-
-    def test_errors(self):
-        "Testing the Error handlers."
-        # string-based
-        for err in self.geometries.errors:
-            with self.assertRaises((GEOSException, ValueError)):
-                _ = fromstr(err.wkt)
-
-        # Bad WKB
-        self.assertRaises(GEOSException, GEOSGeometry, memoryview(b'0'))
-
-        class NotAGeometry(object):
-            pass
-
-        # Some other object
-        self.assertRaises(TypeError, GEOSGeometry, NotAGeometry())
-        # None
-        self.assertRaises(TypeError, GEOSGeometry, None)
-
-    def test_wkb(self):
-        "Testing WKB output."
-        for g in self.geometries.hex_wkt:
-            geom = fromstr(g.wkt)
-            wkb = geom.wkb
-            self.assertEqual(b2a_hex(wkb).decode().upper(), g.hex)
-
-    def test_create_hex(self):
-        "Testing creation from HEX."
-        for g in self.geometries.hex_wkt:
-            geom_h = GEOSGeometry(g.hex)
-            # we need to do this so decimal places get normalised
-            geom_t = fromstr(g.wkt)
-            self.assertEqual(geom_t.wkt, geom_h.wkt)
-
-    def test_create_wkb(self):
-        "Testing creation from WKB."
-        for g in self.geometries.hex_wkt:
-            wkb = memoryview(a2b_hex(g.hex.encode()))
-            geom_h = GEOSGeometry(wkb)
-            # we need to do this so decimal places get normalised
-            geom_t = fromstr(g.wkt)
-            self.assertEqual(geom_t.wkt, geom_h.wkt)
-
-    def test_ewkt(self):
-        "Testing EWKT."
-        srids = (-1, 32140)
-        for srid in srids:
-            for p in self.geometries.polygons:
-                ewkt = 'SRID=%d;%s' % (srid, p.wkt)
-                poly = fromstr(ewkt)
-                self.assertEqual(srid, poly.srid)
-                self.assertEqual(srid, poly.shell.srid)
-                self.assertEqual(srid, fromstr(poly.ewkt).srid) # Checking export
-
-    @skipUnless(HAS_GDAL, "GDAL is required.")
-    def test_json(self):
-        "Testing GeoJSON input/output (via GDAL)."
-        for g in self.geometries.json_geoms:
-            geom = GEOSGeometry(g.wkt)
-            if not hasattr(g, 'not_equal'):
-                # Loading jsons to prevent decimal differences
-                self.assertEqual(json.loads(g.json), json.loads(geom.json))
-                self.assertEqual(json.loads(g.json), json.loads(geom.geojson))
-            self.assertEqual(GEOSGeometry(g.wkt), GEOSGeometry(geom.json))
-
-    def test_fromfile(self):
-        "Testing the fromfile() factory."
-        ref_pnt = GEOSGeometry('POINT(5 23)')
-
-        wkt_f = BytesIO()
-        wkt_f.write(force_bytes(ref_pnt.wkt))
-        wkb_f = BytesIO()
-        wkb_f.write(bytes(ref_pnt.wkb))
-
-        # Other tests use `fromfile()` on string filenames so those
-        # aren't tested here.
-        for fh in (wkt_f, wkb_f):
-            fh.seek(0)
-            pnt = fromfile(fh)
-            self.assertEqual(ref_pnt, pnt)
-
-    def test_eq(self):
-        "Testing equivalence."
-        p = fromstr('POINT(5 23)')
-        self.assertEqual(p, p.wkt)
-        self.assertNotEqual(p, 'foo')
-        ls = fromstr('LINESTRING(0 0, 1 1, 5 5)')
-        self.assertEqual(ls, ls.wkt)
-        self.assertNotEqual(p, 'bar')
-        # Error shouldn't be raise on equivalence testing with
-        # an invalid type.
-        for g in (p, ls):
-            self.assertNotEqual(g, None)
-            self.assertNotEqual(g, {'foo' : 'bar'})
-            self.assertNotEqual(g, False)
-
-    def test_points(self):
-        "Testing Point objects."
-        prev = fromstr('POINT(0 0)')
-        for p in self.geometries.points:
-            # Creating the point from the WKT
-            pnt = fromstr(p.wkt)
-            self.assertEqual(pnt.geom_type, 'Point')
-            self.assertEqual(pnt.geom_typeid, 0)
-            self.assertEqual(p.x, pnt.x)
-            self.assertEqual(p.y, pnt.y)
-            self.assertEqual(True, pnt == fromstr(p.wkt))
-            self.assertEqual(False, pnt == prev)
-
-            # Making sure that the point's X, Y components are what we expect
-            self.assertAlmostEqual(p.x, pnt.tuple[0], 9)
-            self.assertAlmostEqual(p.y, pnt.tuple[1], 9)
-
-            # Testing the third dimension, and getting the tuple arguments
-            if hasattr(p, 'z'):
-                self.assertEqual(True, pnt.hasz)
-                self.assertEqual(p.z, pnt.z)
-                self.assertEqual(p.z, pnt.tuple[2], 9)
-                tup_args = (p.x, p.y, p.z)
-                set_tup1 = (2.71, 3.14, 5.23)
-                set_tup2 = (5.23, 2.71, 3.14)
-            else:
-                self.assertEqual(False, pnt.hasz)
-                self.assertEqual(None, pnt.z)
-                tup_args = (p.x, p.y)
-                set_tup1 = (2.71, 3.14)
-                set_tup2 = (3.14, 2.71)
-
-            # Centroid operation on point should be point itself
-            self.assertEqual(p.centroid, pnt.centroid.tuple)
-
-            # Now testing the different constructors
-            pnt2 = Point(tup_args)  # e.g., Point((1, 2))
-            pnt3 = Point(*tup_args) # e.g., Point(1, 2)
-            self.assertEqual(True, pnt == pnt2)
-            self.assertEqual(True, pnt == pnt3)
-
-            # Now testing setting the x and y
-            pnt.y = 3.14
-            pnt.x = 2.71
-            self.assertEqual(3.14, pnt.y)
-            self.assertEqual(2.71, pnt.x)
-
-            # Setting via the tuple/coords property
-            pnt.tuple = set_tup1
-            self.assertEqual(set_tup1, pnt.tuple)
-            pnt.coords = set_tup2
-            self.assertEqual(set_tup2, pnt.coords)
-
-            prev = pnt # setting the previous geometry
-
-    def test_multipoints(self):
-        "Testing MultiPoint objects."
-        for mp in self.geometries.multipoints:
-            mpnt = fromstr(mp.wkt)
-            self.assertEqual(mpnt.geom_type, 'MultiPoint')
-            self.assertEqual(mpnt.geom_typeid, 4)
-
-            self.assertAlmostEqual(mp.centroid[0], mpnt.centroid.tuple[0], 9)
-            self.assertAlmostEqual(mp.centroid[1], mpnt.centroid.tuple[1], 9)
-
-            self.assertRaises(GEOSIndexError, mpnt.__getitem__, len(mpnt))
-            self.assertEqual(mp.centroid, mpnt.centroid.tuple)
-            self.assertEqual(mp.coords, tuple(m.tuple for m in mpnt))
-            for p in mpnt:
-                self.assertEqual(p.geom_type, 'Point')
-                self.assertEqual(p.geom_typeid, 0)
-                self.assertEqual(p.empty, False)
-                self.assertEqual(p.valid, True)
-
-    def test_linestring(self):
-        "Testing LineString objects."
-        prev = fromstr('POINT(0 0)')
-        for l in self.geometries.linestrings:
-            ls = fromstr(l.wkt)
-            self.assertEqual(ls.geom_type, 'LineString')
-            self.assertEqual(ls.geom_typeid, 1)
-            self.assertEqual(ls.empty, False)
-            self.assertEqual(ls.ring, False)
-            if hasattr(l, 'centroid'):
-                self.assertEqual(l.centroid, ls.centroid.tuple)
-            if hasattr(l, 'tup'):
-                self.assertEqual(l.tup, ls.tuple)
-
-            self.assertEqual(True, ls == fromstr(l.wkt))
-            self.assertEqual(False, ls == prev)
-            self.assertRaises(GEOSIndexError, ls.__getitem__, len(ls))
-            prev = ls
-
-            # Creating a LineString from a tuple, list, and numpy array
-            self.assertEqual(ls, LineString(ls.tuple))  # tuple
-            self.assertEqual(ls, LineString(*ls.tuple)) # as individual arguments
-            self.assertEqual(ls, LineString([list(tup) for tup in ls.tuple])) # as list
-            self.assertEqual(ls.wkt, LineString(*tuple(Point(tup) for tup in ls.tuple)).wkt) # Point individual arguments
-            if numpy: self.assertEqual(ls, LineString(numpy.array(ls.tuple))) # as numpy array
-
-    def test_multilinestring(self):
-        "Testing MultiLineString objects."
-        prev = fromstr('POINT(0 0)')
-        for l in self.geometries.multilinestrings:
-            ml = fromstr(l.wkt)
-            self.assertEqual(ml.geom_type, 'MultiLineString')
-            self.assertEqual(ml.geom_typeid, 5)
-
-            self.assertAlmostEqual(l.centroid[0], ml.centroid.x, 9)
-            self.assertAlmostEqual(l.centroid[1], ml.centroid.y, 9)
-
-            self.assertEqual(True, ml == fromstr(l.wkt))
-            self.assertEqual(False, ml == prev)
-            prev = ml
-
-            for ls in ml:
-                self.assertEqual(ls.geom_type, 'LineString')
-                self.assertEqual(ls.geom_typeid, 1)
-                self.assertEqual(ls.empty, False)
-
-            self.assertRaises(GEOSIndexError, ml.__getitem__, len(ml))
-            self.assertEqual(ml.wkt, MultiLineString(*tuple(s.clone() for s in ml)).wkt)
-            self.assertEqual(ml, MultiLineString(*tuple(LineString(s.tuple) for s in ml)))
-
-    def test_linearring(self):
-        "Testing LinearRing objects."
-        for rr in self.geometries.linearrings:
-            lr = fromstr(rr.wkt)
-            self.assertEqual(lr.geom_type, 'LinearRing')
-            self.assertEqual(lr.geom_typeid, 2)
-            self.assertEqual(rr.n_p, len(lr))
-            self.assertEqual(True, lr.valid)
-            self.assertEqual(False, lr.empty)
-
-            # Creating a LinearRing from a tuple, list, and numpy array
-            self.assertEqual(lr, LinearRing(lr.tuple))
-            self.assertEqual(lr, LinearRing(*lr.tuple))
-            self.assertEqual(lr, LinearRing([list(tup) for tup in lr.tuple]))
-            if numpy: self.assertEqual(lr, LinearRing(numpy.array(lr.tuple)))
-
-    def test_polygons_from_bbox(self):
-        "Testing `from_bbox` class method."
-        bbox = (-180, -90, 180, 90)
-        p = Polygon.from_bbox(bbox)
-        self.assertEqual(bbox, p.extent)
-
-        # Testing numerical precision
-        x = 3.14159265358979323
-        bbox = (0, 0, 1, x)
-        p = Polygon.from_bbox(bbox)
-        y = p.extent[-1]
-        self.assertEqual(format(x, '.13f'), format(y, '.13f'))
-
-    def test_polygons(self):
-        "Testing Polygon objects."
-
-        prev = fromstr('POINT(0 0)')
-        for p in self.geometries.polygons:
-            # Creating the Polygon, testing its properties.
-            poly = fromstr(p.wkt)
-            self.assertEqual(poly.geom_type, 'Polygon')
-            self.assertEqual(poly.geom_typeid, 3)
-            self.assertEqual(poly.empty, False)
-            self.assertEqual(poly.ring, False)
-            self.assertEqual(p.n_i, poly.num_interior_rings)
-            self.assertEqual(p.n_i + 1, len(poly)) # Testing __len__
-            self.assertEqual(p.n_p, poly.num_points)
-
-            # Area & Centroid
-            self.assertAlmostEqual(p.area, poly.area, 9)
-            self.assertAlmostEqual(p.centroid[0], poly.centroid.tuple[0], 9)
-            self.assertAlmostEqual(p.centroid[1], poly.centroid.tuple[1], 9)
-
-            # Testing the geometry equivalence
-            self.assertEqual(True, poly == fromstr(p.wkt))
-            self.assertEqual(False, poly == prev) # Should not be equal to previous geometry
-            self.assertEqual(True, poly != prev)
-
-            # Testing the exterior ring
-            ring = poly.exterior_ring
-            self.assertEqual(ring.geom_type, 'LinearRing')
-            self.assertEqual(ring.geom_typeid, 2)
-            if p.ext_ring_cs:
-                self.assertEqual(p.ext_ring_cs, ring.tuple)
-                self.assertEqual(p.ext_ring_cs, poly[0].tuple) # Testing __getitem__
-
-            # Testing __getitem__ and __setitem__ on invalid indices
-            self.assertRaises(GEOSIndexError, poly.__getitem__, len(poly))
-            self.assertRaises(GEOSIndexError, poly.__setitem__, len(poly), False)
-            self.assertRaises(GEOSIndexError, poly.__getitem__, -1 * len(poly) - 1)
-
-            # Testing __iter__
-            for r in poly:
-                self.assertEqual(r.geom_type, 'LinearRing')
-                self.assertEqual(r.geom_typeid, 2)
-
-            # Testing polygon construction.
-            self.assertRaises(TypeError, Polygon, 0, [1, 2, 3])
-            self.assertRaises(TypeError, Polygon, 'foo')
-
-            # Polygon(shell, (hole1, ... holeN))
-            rings = tuple(r for r in poly)
-            self.assertEqual(poly, Polygon(rings[0], rings[1:]))
-
-            # Polygon(shell_tuple, hole_tuple1, ... , hole_tupleN)
-            ring_tuples = tuple(r.tuple for r in poly)
-            self.assertEqual(poly, Polygon(*ring_tuples))
-
-            # Constructing with tuples of LinearRings.
-            self.assertEqual(poly.wkt, Polygon(*tuple(r for r in poly)).wkt)
-            self.assertEqual(poly.wkt, Polygon(*tuple(LinearRing(r.tuple) for r in poly)).wkt)
-
-    def test_polygon_comparison(self):
-        p1 = Polygon(((0, 0), (0, 1), (1, 1), (1, 0), (0, 0)))
-        p2 = Polygon(((0, 0), (0, 1), (1, 0), (0, 0)))
-        self.assertTrue(p1 > p2)
-        self.assertFalse(p1 < p2)
-        self.assertFalse(p2 > p1)
-        self.assertTrue(p2 < p1)
-
-        p3 = Polygon(((0, 0), (0, 1), (1, 1), (2, 0), (0, 0)))
-        p4 = Polygon(((0, 0), (0, 1), (2, 2), (1, 0), (0, 0)))
-        self.assertFalse(p4 < p3)
-        self.assertTrue(p3 < p4)
-        self.assertTrue(p4 > p3)
-        self.assertFalse(p3 > p4)
-
-    def test_multipolygons(self):
-        "Testing MultiPolygon objects."
-        prev = fromstr('POINT (0 0)')
-        for mp in self.geometries.multipolygons:
-            mpoly = fromstr(mp.wkt)
-            self.assertEqual(mpoly.geom_type, 'MultiPolygon')
-            self.assertEqual(mpoly.geom_typeid, 6)
-            self.assertEqual(mp.valid, mpoly.valid)
-
-            if mp.valid:
-                self.assertEqual(mp.num_geom, mpoly.num_geom)
-                self.assertEqual(mp.n_p, mpoly.num_coords)
-                self.assertEqual(mp.num_geom, len(mpoly))
-                self.assertRaises(GEOSIndexError, mpoly.__getitem__, len(mpoly))
-                for p in mpoly:
-                    self.assertEqual(p.geom_type, 'Polygon')
-                    self.assertEqual(p.geom_typeid, 3)
-                    self.assertEqual(p.valid, True)
-                self.assertEqual(mpoly.wkt, MultiPolygon(*tuple(poly.clone() for poly in mpoly)).wkt)
-
-    def test_memory_hijinks(self):
-        "Testing Geometry __del__() on rings and polygons."
-        #### Memory issues with rings and polygons
-
-        # These tests are needed to ensure sanity with writable geometries.
-
-        # Getting a polygon with interior rings, and pulling out the interior rings
-        poly = fromstr(self.geometries.polygons[1].wkt)
-        ring1 = poly[0]
-        ring2 = poly[1]
-
-        # These deletes should be 'harmless' since they are done on child geometries
-        del ring1
-        del ring2
-        ring1 = poly[0]
-        ring2 = poly[1]
-
-        # Deleting the polygon
-        del poly
-
-        # Access to these rings is OK since they are clones.
-        s1, s2 = str(ring1), str(ring2)
-
-    def test_coord_seq(self):
-        "Testing Coordinate Sequence objects."
-        for p in self.geometries.polygons:
-            if p.ext_ring_cs:
-                # Constructing the polygon and getting the coordinate sequence
-                poly = fromstr(p.wkt)
-                cs = poly.exterior_ring.coord_seq
-
-                self.assertEqual(p.ext_ring_cs, cs.tuple) # done in the Polygon test too.
-                self.assertEqual(len(p.ext_ring_cs), len(cs)) # Making sure __len__ works
-
-                # Checks __getitem__ and __setitem__
-                for i in xrange(len(p.ext_ring_cs)):
-                    c1 = p.ext_ring_cs[i] # Expected value
-                    c2 = cs[i] # Value from coordseq
-                    self.assertEqual(c1, c2)
-
-                    # Constructing the test value to set the coordinate sequence with
-                    if len(c1) == 2: tset = (5, 23)
-                    else: tset = (5, 23, 8)
-                    cs[i] = tset
-
-                    # Making sure every set point matches what we expect
-                    for j in range(len(tset)):
-                        cs[i] = tset
-                        self.assertEqual(tset[j], cs[i][j])
-
-    def test_relate_pattern(self):
-        "Testing relate() and relate_pattern()."
-        g = fromstr('POINT (0 0)')
-        self.assertRaises(GEOSException, g.relate_pattern, 0, 'invalid pattern, yo')
-        for rg in self.geometries.relate_geoms:
-            a = fromstr(rg.wkt_a)
-            b = fromstr(rg.wkt_b)
-            self.assertEqual(rg.result, a.relate_pattern(b, rg.pattern))
-            self.assertEqual(rg.pattern, a.relate(b))
-
-    def test_intersection(self):
-        "Testing intersects() and intersection()."
-        for i in xrange(len(self.geometries.topology_geoms)):
-            a = fromstr(self.geometries.topology_geoms[i].wkt_a)
-            b = fromstr(self.geometries.topology_geoms[i].wkt_b)
-            i1 = fromstr(self.geometries.intersect_geoms[i].wkt)
-            self.assertEqual(True, a.intersects(b))
-            i2 = a.intersection(b)
-            self.assertEqual(i1, i2)
-            self.assertEqual(i1, a & b) # __and__ is intersection operator
-            a &= b # testing __iand__
-            self.assertEqual(i1, a)
-
-    def test_union(self):
-        "Testing union()."
-        for i in xrange(len(self.geometries.topology_geoms)):
-            a = fromstr(self.geometries.topology_geoms[i].wkt_a)
-            b = fromstr(self.geometries.topology_geoms[i].wkt_b)
-            u1 = fromstr(self.geometries.union_geoms[i].wkt)
-            u2 = a.union(b)
-            self.assertEqual(u1, u2)
-            self.assertEqual(u1, a | b) # __or__ is union operator
-            a |= b # testing __ior__
-            self.assertEqual(u1, a)
-
-    def test_difference(self):
-        "Testing difference()."
-        for i in xrange(len(self.geometries.topology_geoms)):
-            a = fromstr(self.geometries.topology_geoms[i].wkt_a)
-            b = fromstr(self.geometries.topology_geoms[i].wkt_b)
-            d1 = fromstr(self.geometries.diff_geoms[i].wkt)
-            d2 = a.difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a - b) # __sub__ is difference operator
-            a -= b # testing __isub__
-            self.assertEqual(d1, a)
-
-    def test_symdifference(self):
-        "Testing sym_difference()."
-        for i in xrange(len(self.geometries.topology_geoms)):
-            a = fromstr(self.geometries.topology_geoms[i].wkt_a)
-            b = fromstr(self.geometries.topology_geoms[i].wkt_b)
-            d1 = fromstr(self.geometries.sdiff_geoms[i].wkt)
-            d2 = a.sym_difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a ^ b) # __xor__ is symmetric difference operator
-            a ^= b # testing __ixor__
-            self.assertEqual(d1, a)
-
-    def test_buffer(self):
-        "Testing buffer()."
-        for bg in self.geometries.buffer_geoms:
-            g = fromstr(bg.wkt)
-
-            # The buffer we expect
-            exp_buf = fromstr(bg.buffer_wkt)
-            quadsegs = bg.quadsegs
-            width = bg.width
-
-            # Can't use a floating-point for the number of quadsegs.
-            self.assertRaises(ctypes.ArgumentError, g.buffer, width, float(quadsegs))
-
-            # Constructing our buffer
-            buf = g.buffer(width, quadsegs)
-            self.assertEqual(exp_buf.num_coords, buf.num_coords)
-            self.assertEqual(len(exp_buf), len(buf))
-
-            # Now assuring that each point in the buffer is almost equal
-            for j in xrange(len(exp_buf)):
-                exp_ring = exp_buf[j]
-                buf_ring = buf[j]
-                self.assertEqual(len(exp_ring), len(buf_ring))
-                for k in xrange(len(exp_ring)):
-                    # Asserting the X, Y of each point are almost equal (due to floating point imprecision)
-                    self.assertAlmostEqual(exp_ring[k][0], buf_ring[k][0], 9)
-                    self.assertAlmostEqual(exp_ring[k][1], buf_ring[k][1], 9)
-
-    def test_srid(self):
-        "Testing the SRID property and keyword."
-        # Testing SRID keyword on Point
-        pnt = Point(5, 23, srid=4326)
-        self.assertEqual(4326, pnt.srid)
-        pnt.srid = 3084
-        self.assertEqual(3084, pnt.srid)
-        self.assertRaises(ctypes.ArgumentError, pnt.set_srid, '4326')
-
-        # Testing SRID keyword on fromstr(), and on Polygon rings.
-        poly = fromstr(self.geometries.polygons[1].wkt, srid=4269)
-        self.assertEqual(4269, poly.srid)
-        for ring in poly: self.assertEqual(4269, ring.srid)
-        poly.srid = 4326
-        self.assertEqual(4326, poly.shell.srid)
-
-        # Testing SRID keyword on GeometryCollection
-        gc = GeometryCollection(Point(5, 23), LineString((0, 0), (1.5, 1.5), (3, 3)), srid=32021)
-        self.assertEqual(32021, gc.srid)
-        for i in range(len(gc)): self.assertEqual(32021, gc[i].srid)
-
-        # GEOS may get the SRID from HEXEWKB
-        # 'POINT(5 23)' at SRID=4326 in hex form -- obtained from PostGIS
-        # using `SELECT GeomFromText('POINT (5 23)', 4326);`.
-        hex = '0101000020E610000000000000000014400000000000003740'
-        p1 = fromstr(hex)
-        self.assertEqual(4326, p1.srid)
-
-        # In GEOS 3.0.0rc1-4  when the EWKB and/or HEXEWKB is exported,
-        # the SRID information is lost and set to -1 -- this is not a
-        # problem on the 3.0.0 version (another reason to upgrade).
-        exp_srid = self.null_srid
-
-        p2 = fromstr(p1.hex)
-        self.assertEqual(exp_srid, p2.srid)
-        p3 = fromstr(p1.hex, srid=-1) # -1 is intended.
-        self.assertEqual(-1, p3.srid)
-
-    @skipUnless(HAS_GDAL, "GDAL is required.")
-    def test_custom_srid(self):
-        """ Test with a srid unknown from GDAL """
-        pnt = Point(111200, 220900, srid=999999)
-        self.assertTrue(pnt.ewkt.startswith("SRID=999999;POINT (111200.0"))
-        self.assertIsInstance(pnt.ogr, gdal.OGRGeometry)
-        self.assertIsNone(pnt.srs)
-
-        # Test conversion from custom to a known srid
-        c2w = gdal.CoordTransform(
-            gdal.SpatialReference('+proj=mill +lat_0=0 +lon_0=0 +x_0=0 +y_0=0 +R_A +ellps=WGS84 +datum=WGS84 +units=m +no_defs'),
-            gdal.SpatialReference(4326))
-        new_pnt = pnt.transform(c2w, clone=True)
-        self.assertEqual(new_pnt.srid, 4326)
-        self.assertAlmostEqual(new_pnt.x, 1, 3)
-        self.assertAlmostEqual(new_pnt.y, 2, 3)
-
-    def test_mutable_geometries(self):
-        "Testing the mutability of Polygons and Geometry Collections."
-        ### Testing the mutability of Polygons ###
-        for p in self.geometries.polygons:
-            poly = fromstr(p.wkt)
-
-            # Should only be able to use __setitem__ with LinearRing geometries.
-            self.assertRaises(TypeError, poly.__setitem__, 0, LineString((1, 1), (2, 2)))
-
-            # Constructing the new shell by adding 500 to every point in the old shell.
-            shell_tup = poly.shell.tuple
-            new_coords = []
-            for point in shell_tup: new_coords.append((point[0] + 500., point[1] + 500.))
-            new_shell = LinearRing(*tuple(new_coords))
-
-            # Assigning polygon's exterior ring w/the new shell
-            poly.exterior_ring = new_shell
-            s = str(new_shell) # new shell is still accessible
-            self.assertEqual(poly.exterior_ring, new_shell)
-            self.assertEqual(poly[0], new_shell)
-
-        ### Testing the mutability of Geometry Collections
-        for tg in self.geometries.multipoints:
-            mp = fromstr(tg.wkt)
-            for i in range(len(mp)):
-                # Creating a random point.
-                pnt = mp[i]
-                new = Point(random.randint(21, 100), random.randint(21, 100))
-                # Testing the assignment
-                mp[i] = new
-                s = str(new) # what was used for the assignment is still accessible
-                self.assertEqual(mp[i], new)
-                self.assertEqual(mp[i].wkt, new.wkt)
-                self.assertNotEqual(pnt, mp[i])
-
-        # MultiPolygons involve much more memory management because each
-        # Polygon w/in the collection has its own rings.
-        for tg in self.geometries.multipolygons:
-            mpoly = fromstr(tg.wkt)
-            for i in xrange(len(mpoly)):
-                poly = mpoly[i]
-                old_poly = mpoly[i]
-                # Offsetting the each ring in the polygon by 500.
-                for j in xrange(len(poly)):
-                    r = poly[j]
-                    for k in xrange(len(r)): r[k] = (r[k][0] + 500., r[k][1] + 500.)
-                    poly[j] = r
-
-                self.assertNotEqual(mpoly[i], poly)
-                # Testing the assignment
-                mpoly[i] = poly
-                s = str(poly) # Still accessible
-                self.assertEqual(mpoly[i], poly)
-                self.assertNotEqual(mpoly[i], old_poly)
-
-        # Extreme (!!) __setitem__ -- no longer works, have to detect
-        # in the first object that __setitem__ is called in the subsequent
-        # objects -- maybe mpoly[0, 0, 0] = (3.14, 2.71)?
-        #mpoly[0][0][0] = (3.14, 2.71)
-        #self.assertEqual((3.14, 2.71), mpoly[0][0][0])
-        # Doing it more slowly..
-        #self.assertEqual((3.14, 2.71), mpoly[0].shell[0])
-        #del mpoly
-
-    def test_threed(self):
-        "Testing three-dimensional geometries."
-        # Testing a 3D Point
-        pnt = Point(2, 3, 8)
-        self.assertEqual((2.,3.,8.), pnt.coords)
-        self.assertRaises(TypeError, pnt.set_coords, (1.,2.))
-        pnt.coords = (1.,2.,3.)
-        self.assertEqual((1.,2.,3.), pnt.coords)
-
-        # Testing a 3D LineString
-        ls = LineString((2., 3., 8.), (50., 250., -117.))
-        self.assertEqual(((2.,3.,8.), (50.,250.,-117.)), ls.tuple)
-        self.assertRaises(TypeError, ls.__setitem__, 0, (1.,2.))
-        ls[0] = (1.,2.,3.)
-        self.assertEqual((1.,2.,3.), ls[0])
-
-    def test_distance(self):
-        "Testing the distance() function."
-        # Distance to self should be 0.
-        pnt = Point(0, 0)
-        self.assertEqual(0.0, pnt.distance(Point(0, 0)))
-
-        # Distance should be 1
-        self.assertEqual(1.0, pnt.distance(Point(0, 1)))
-
-        # Distance should be ~ sqrt(2)
-        self.assertAlmostEqual(1.41421356237, pnt.distance(Point(1, 1)), 11)
-
-        # Distances are from the closest vertex in each geometry --
-        #  should be 3 (distance from (2, 2) to (5, 2)).
-        ls1 = LineString((0, 0), (1, 1), (2, 2))
-        ls2 = LineString((5, 2), (6, 1), (7, 0))
-        self.assertEqual(3, ls1.distance(ls2))
-
-    def test_length(self):
-        "Testing the length property."
-        # Points have 0 length.
-        pnt = Point(0, 0)
-        self.assertEqual(0.0, pnt.length)
-
-        # Should be ~ sqrt(2)
-        ls = LineString((0, 0), (1, 1))
-        self.assertAlmostEqual(1.41421356237, ls.length, 11)
-
-        # Should be circumfrence of Polygon
-        poly = Polygon(LinearRing((0, 0), (0, 1), (1, 1), (1, 0), (0, 0)))
-        self.assertEqual(4.0, poly.length)
-
-        # Should be sum of each element's length in collection.
-        mpoly = MultiPolygon(poly.clone(), poly)
-        self.assertEqual(8.0, mpoly.length)
-
-    def test_emptyCollections(self):
-        "Testing empty geometries and collections."
-        gc1 = GeometryCollection([])
-        gc2 = fromstr('GEOMETRYCOLLECTION EMPTY')
-        pnt = fromstr('POINT EMPTY')
-        ls = fromstr('LINESTRING EMPTY')
-        poly = fromstr('POLYGON EMPTY')
-        mls = fromstr('MULTILINESTRING EMPTY')
-        mpoly1 = fromstr('MULTIPOLYGON EMPTY')
-        mpoly2 = MultiPolygon(())
-
-        for g in [gc1, gc2, pnt, ls, poly, mls, mpoly1, mpoly2]:
-            self.assertEqual(True, g.empty)
-
-            # Testing len() and num_geom.
-            if isinstance(g, Polygon):
-                self.assertEqual(1, len(g)) # Has one empty linear ring
-                self.assertEqual(1, g.num_geom)
-                self.assertEqual(0, len(g[0]))
-            elif isinstance(g, (Point, LineString)):
-                self.assertEqual(1, g.num_geom)
-                self.assertEqual(0, len(g))
-            else:
-                self.assertEqual(0, g.num_geom)
-                self.assertEqual(0, len(g))
-
-            # Testing __getitem__ (doesn't work on Point or Polygon)
-            if isinstance(g, Point):
-                self.assertRaises(GEOSIndexError, g.get_x)
-            elif isinstance(g, Polygon):
-                lr = g.shell
-                self.assertEqual('LINEARRING EMPTY', lr.wkt)
-                self.assertEqual(0, len(lr))
-                self.assertEqual(True, lr.empty)
-                self.assertRaises(GEOSIndexError, lr.__getitem__, 0)
-            else:
-                self.assertRaises(GEOSIndexError, g.__getitem__, 0)
-
-    def test_collections_of_collections(self):
-        "Testing GeometryCollection handling of other collections."
-        # Creating a GeometryCollection WKT string composed of other
-        # collections and polygons.
-        coll = [mp.wkt for mp in self.geometries.multipolygons if mp.valid]
-        coll.extend([mls.wkt for mls in self.geometries.multilinestrings])
-        coll.extend([p.wkt for p in self.geometries.polygons])
-        coll.extend([mp.wkt for mp in self.geometries.multipoints])
-        gc_wkt = 'GEOMETRYCOLLECTION(%s)' % ','.join(coll)
-
-        # Should construct ok from WKT
-        gc1 = GEOSGeometry(gc_wkt)
-
-        # Should also construct ok from individual geometry arguments.
-        gc2 = GeometryCollection(*tuple(g for g in gc1))
-
-        # And, they should be equal.
-        self.assertEqual(gc1, gc2)
-
-    @skipUnless(HAS_GDAL, "GDAL is required.")
-    def test_gdal(self):
-        "Testing `ogr` and `srs` properties."
-        g1 = fromstr('POINT(5 23)')
-        self.assertIsInstance(g1.ogr, gdal.OGRGeometry)
-        self.assertIsNone(g1.srs)
-
-        if GEOS_PREPARE:
-            g1_3d = fromstr('POINT(5 23 8)')
-            self.assertIsInstance(g1_3d.ogr, gdal.OGRGeometry)
-            self.assertEqual(g1_3d.ogr.z, 8)
-
-        g2 = fromstr('LINESTRING(0 0, 5 5, 23 23)', srid=4326)
-        self.assertIsInstance(g2.ogr, gdal.OGRGeometry)
-        self.assertIsInstance(g2.srs, gdal.SpatialReference)
-        self.assertEqual(g2.hex, g2.ogr.hex)
-        self.assertEqual('WGS 84', g2.srs.name)
-
-    def test_copy(self):
-        "Testing use with the Python `copy` module."
-        import copy
-        poly = GEOSGeometry('POLYGON((0 0, 0 23, 23 23, 23 0, 0 0), (5 5, 5 10, 10 10, 10 5, 5 5))')
-        cpy1 = copy.copy(poly)
-        cpy2 = copy.deepcopy(poly)
-        self.assertNotEqual(poly._ptr, cpy1._ptr)
-        self.assertNotEqual(poly._ptr, cpy2._ptr)
-
-    @skipUnless(HAS_GDAL, "GDAL is required to transform geometries")
-    def test_transform(self):
-        "Testing `transform` method."
-        orig = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-        trans = GEOSGeometry('POINT (992385.4472045 481455.4944650)', 2774)
-
-        # Using a srid, a SpatialReference object, and a CoordTransform object
-        # for transformations.
-        t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
-        t1.transform(trans.srid)
-        t2.transform(gdal.SpatialReference('EPSG:2774'))
-        ct = gdal.CoordTransform(gdal.SpatialReference('WGS84'), gdal.SpatialReference(2774))
-        t3.transform(ct)
-
-        # Testing use of the `clone` keyword.
-        k1 = orig.clone()
-        k2 = k1.transform(trans.srid, clone=True)
-        self.assertEqual(k1, orig)
-        self.assertNotEqual(k1, k2)
-
-        prec = 3
-        for p in (t1, t2, t3, k2):
-            self.assertAlmostEqual(trans.x, p.x, prec)
-            self.assertAlmostEqual(trans.y, p.y, prec)
-
-    @skipUnless(HAS_GDAL, "GDAL is required to transform geometries")
-    def test_transform_3d(self):
-        p3d = GEOSGeometry('POINT (5 23 100)', 4326)
-        p3d.transform(2774)
-        if GEOS_PREPARE:
-            self.assertEqual(p3d.z, 100)
-        else:
-            self.assertIsNone(p3d.z)
-
-    @skipUnless(HAS_GDAL, "GDAL is required.")
-    def test_transform_noop(self):
-        """ Testing `transform` method (SRID match) """
-        # transform() should no-op if source & dest SRIDs match,
-        # regardless of whether GDAL is available.
-        if gdal.HAS_GDAL:
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            gt = g.tuple
-            g.transform(4326)
-            self.assertEqual(g.tuple, gt)
-            self.assertEqual(g.srid, 4326)
-
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            g1 = g.transform(4326, clone=True)
-            self.assertEqual(g1.tuple, g.tuple)
-            self.assertEqual(g1.srid, 4326)
-            self.assertTrue(g1 is not g, "Clone didn't happen")
-
-        old_has_gdal = gdal.HAS_GDAL
-        try:
-            gdal.HAS_GDAL = False
-
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            gt = g.tuple
-            g.transform(4326)
-            self.assertEqual(g.tuple, gt)
-            self.assertEqual(g.srid, 4326)
-
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            g1 = g.transform(4326, clone=True)
-            self.assertEqual(g1.tuple, g.tuple)
-            self.assertEqual(g1.srid, 4326)
-            self.assertTrue(g1 is not g, "Clone didn't happen")
-        finally:
-            gdal.HAS_GDAL = old_has_gdal
-
-    def test_transform_nosrid(self):
-        """ Testing `transform` method (no SRID or negative SRID) """
-
-        g = GEOSGeometry('POINT (-104.609 38.255)', srid=None)
-        self.assertRaises(GEOSException, g.transform, 2774)
-
-        g = GEOSGeometry('POINT (-104.609 38.255)', srid=None)
-        self.assertRaises(GEOSException, g.transform, 2774, clone=True)
-
-        g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
-        self.assertRaises(GEOSException, g.transform, 2774)
-
-        g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
-        self.assertRaises(GEOSException, g.transform, 2774, clone=True)
-
-    @skipUnless(HAS_GDAL, "GDAL is required.")
-    def test_transform_nogdal(self):
-        """ Testing `transform` method (GDAL not available) """
-        old_has_gdal = gdal.HAS_GDAL
-        try:
-            gdal.HAS_GDAL = False
-
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            self.assertRaises(GEOSException, g.transform, 2774)
-
-            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
-            self.assertRaises(GEOSException, g.transform, 2774, clone=True)
-        finally:
-            gdal.HAS_GDAL = old_has_gdal
-
-    def test_extent(self):
-        "Testing `extent` method."
-        # The xmin, ymin, xmax, ymax of the MultiPoint should be returned.
-        mp = MultiPoint(Point(5, 23), Point(0, 0), Point(10, 50))
-        self.assertEqual((0.0, 0.0, 10.0, 50.0), mp.extent)
-        pnt = Point(5.23, 17.8)
-        # Extent of points is just the point itself repeated.
-        self.assertEqual((5.23, 17.8, 5.23, 17.8), pnt.extent)
-        # Testing on the 'real world' Polygon.
-        poly = fromstr(self.geometries.polygons[3].wkt)
-        ring = poly.shell
-        x, y = ring.x, ring.y
-        xmin, ymin = min(x), min(y)
-        xmax, ymax = max(x), max(y)
-        self.assertEqual((xmin, ymin, xmax, ymax), poly.extent)
-
-    def test_pickle(self):
-        "Testing pickling and unpickling support."
-        # Using both pickle and cPickle -- just 'cause.
-        from django.utils.six.moves import cPickle
-        import pickle
-
-        # Creating a list of test geometries for pickling,
-        # and setting the SRID on some of them.
-        def get_geoms(lst, srid=None):
-            return [GEOSGeometry(tg.wkt, srid) for tg in lst]
-        tgeoms = get_geoms(self.geometries.points)
-        tgeoms.extend(get_geoms(self.geometries.multilinestrings, 4326))
-        tgeoms.extend(get_geoms(self.geometries.polygons, 3084))
-        tgeoms.extend(get_geoms(self.geometries.multipolygons, 900913))
-
-        # The SRID won't be exported in GEOS 3.0 release candidates.
-        no_srid = self.null_srid == -1
-        for geom in tgeoms:
-            s1, s2 = cPickle.dumps(geom), pickle.dumps(geom)
-            g1, g2 = cPickle.loads(s1), pickle.loads(s2)
-            for tmpg in (g1, g2):
-                self.assertEqual(geom, tmpg)
-                if not no_srid: self.assertEqual(geom.srid, tmpg.srid)
-
-    @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required")
-    def test_prepared(self):
-        "Testing PreparedGeometry support."
-        # Creating a simple multipolygon and getting a prepared version.
-        mpoly = GEOSGeometry('MULTIPOLYGON(((0 0,0 5,5 5,5 0,0 0)),((5 5,5 10,10 10,10 5,5 5)))')
-        prep = mpoly.prepared
-
-        # A set of test points.
-        pnts = [Point(5, 5), Point(7.5, 7.5), Point(2.5, 7.5)]
-        covers = [True, True, False] # No `covers` op for regular GEOS geoms.
-        for pnt, c in zip(pnts, covers):
-            # Results should be the same (but faster)
-            self.assertEqual(mpoly.contains(pnt), prep.contains(pnt))
-            self.assertEqual(mpoly.intersects(pnt), prep.intersects(pnt))
-            self.assertEqual(c, prep.covers(pnt))
-
-        # Original geometry deletion should not crash the prepared one (#21662)
-        del mpoly
-        self.assertTrue(prep.covers(Point(5, 5)))
-
-    def test_line_merge(self):
-        "Testing line merge support"
-        ref_geoms = (fromstr('LINESTRING(1 1, 1 1, 3 3)'),
-                     fromstr('MULTILINESTRING((1 1, 3 3), (3 3, 4 2))'),
-                     )
-        ref_merged = (fromstr('LINESTRING(1 1, 3 3)'),
-                      fromstr('LINESTRING (1 1, 3 3, 4 2)'),
-                      )
-        for geom, merged in zip(ref_geoms, ref_merged):
-            self.assertEqual(merged, geom.merged)
-
-    @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required")
-    def test_valid_reason(self):
-        "Testing IsValidReason support"
-
-        g = GEOSGeometry("POINT(0 0)")
-        self.assertTrue(g.valid)
-        self.assertIsInstance(g.valid_reason, six.string_types)
-        self.assertEqual(g.valid_reason, "Valid Geometry")
-
-        g = GEOSGeometry("LINESTRING(0 0, 0 0)")
-
-        self.assertFalse(g.valid)
-        self.assertIsInstance(g.valid_reason, six.string_types)
-        self.assertTrue(g.valid_reason.startswith("Too few points in geometry component"))
-
-    @skipUnless(HAS_GEOS and geos_version_info()['version'] >= '3.2.0', "geos >= 3.2.0 is required")
-    def test_linearref(self):
-        "Testing linear referencing"
-
-        ls = fromstr('LINESTRING(0 0, 0 10, 10 10, 10 0)')
-        mls = fromstr('MULTILINESTRING((0 0, 0 10), (10 0, 10 10))')
-
-        self.assertEqual(ls.project(Point(0, 20)), 10.0)
-        self.assertEqual(ls.project(Point(7, 6)), 24)
-        self.assertEqual(ls.project_normalized(Point(0, 20)), 1.0/3)
-
-        self.assertEqual(ls.interpolate(10), Point(0, 10))
-        self.assertEqual(ls.interpolate(24), Point(10, 6))
-        self.assertEqual(ls.interpolate_normalized(1.0/3), Point(0, 10))
-
-        self.assertEqual(mls.project(Point(0, 20)), 10)
-        self.assertEqual(mls.project(Point(7, 6)), 16)
-
-        self.assertEqual(mls.interpolate(9), Point(0, 9))
-        self.assertEqual(mls.interpolate(17), Point(10, 7))
-
-    def test_geos_version(self):
-        """Testing the GEOS version regular expression."""
-        from django.contrib.gis.geos.libgeos import version_regex
-        versions = [('3.0.0rc4-CAPI-1.3.3', '3.0.0', '1.3.3'),
-                    ('3.0.0-CAPI-1.4.1', '3.0.0', '1.4.1'),
-                    ('3.4.0dev-CAPI-1.8.0', '3.4.0', '1.8.0'),
-                    ('3.4.0dev-CAPI-1.8.0 r0', '3.4.0', '1.8.0')]
-        for v_init, v_geos, v_capi in versions:
-            m = version_regex.match(v_init)
-            self.assertTrue(m, msg="Unable to parse the version string '%s'" % v_init)
-            self.assertEqual(m.group('version'), v_geos)
-            self.assertEqual(m.group('capi_version'), v_capi)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py
deleted file mode 100644
index 40b708a..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py
+++ /dev/null
@@ -1,134 +0,0 @@
-# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved.
-# Modified from original contribution by Aryeh Leib Taurog, which was
-# released under the New BSD license.
-
-from django.utils import unittest
-from django.utils.unittest import skipUnless
-
-from .. import HAS_GEOS
-
-if HAS_GEOS:
-    from .. import *
-    from ..error import GEOSIndexError
-
-
-def getItem(o,i): return o[i]
-def delItem(o,i): del o[i]
-def setItem(o,i,v): o[i] = v
-
-if HAS_GEOS:
-    def api_get_distance(x): return x.distance(Point(-200,-200))
-
-def api_get_buffer(x): return x.buffer(10)
-def api_get_geom_typeid(x): return x.geom_typeid
-def api_get_num_coords(x): return x.num_coords
-def api_get_centroid(x): return x.centroid
-def api_get_empty(x): return x.empty
-def api_get_valid(x): return x.valid
-def api_get_simple(x): return x.simple
-def api_get_ring(x): return x.ring
-def api_get_boundary(x): return x.boundary
-def api_get_convex_hull(x): return x.convex_hull
-def api_get_extent(x): return x.extent
-def api_get_area(x): return x.area
-def api_get_length(x): return x.length
-
-geos_function_tests =  [ val for name, val in vars().items()
-                        if hasattr(val, '__call__')
-                        and name.startswith('api_get_') ]
-
-
-@skipUnless(HAS_GEOS, "Geos is required.")
-class GEOSMutationTest(unittest.TestCase):
-    """
-    Tests Pythonic Mutability of Python GEOS geometry wrappers
-    get/set/delitem on a slice, normal list methods
-    """
-
-    def test00_GEOSIndexException(self):
-        'Testing Geometry GEOSIndexError'
-        p = Point(1,2)
-        for i in range(-2,2): p._checkindex(i)
-        self.assertRaises(GEOSIndexError, p._checkindex, 2)
-        self.assertRaises(GEOSIndexError, p._checkindex, -3)
-
-    def test01_PointMutations(self):
-        'Testing Point mutations'
-        for p in (Point(1,2,3), fromstr('POINT (1 2 3)')):
-            self.assertEqual(p._get_single_external(1), 2.0, 'Point _get_single_external')
-
-            # _set_single
-            p._set_single(0,100)
-            self.assertEqual(p.coords, (100.0,2.0,3.0), 'Point _set_single')
-
-            # _set_list
-            p._set_list(2,(50,3141))
-            self.assertEqual(p.coords, (50.0,3141.0), 'Point _set_list')
-
-    def test02_PointExceptions(self):
-        'Testing Point exceptions'
-        self.assertRaises(TypeError, Point, range(1))
-        self.assertRaises(TypeError, Point, range(4))
-
-    def test03_PointApi(self):
-        'Testing Point API'
-        q = Point(4,5,3)
-        for p in (Point(1,2,3), fromstr('POINT (1 2 3)')):
-            p[0:2] = [4,5]
-            for f in geos_function_tests:
-                self.assertEqual(f(q), f(p), 'Point ' + f.__name__)
-
-    def test04_LineStringMutations(self):
-        'Testing LineString mutations'
-        for ls in (LineString((1,0),(4,1),(6,-1)),
-                    fromstr('LINESTRING (1 0,4 1,6 -1)')):
-            self.assertEqual(ls._get_single_external(1), (4.0,1.0), 'LineString _get_single_external')
-
-            # _set_single
-            ls._set_single(0,(-50,25))
-            self.assertEqual(ls.coords, ((-50.0,25.0),(4.0,1.0),(6.0,-1.0)), 'LineString _set_single')
-
-            # _set_list
-            ls._set_list(2, ((-50.0,25.0),(6.0,-1.0)))
-            self.assertEqual(ls.coords, ((-50.0,25.0),(6.0,-1.0)), 'LineString _set_list')
-
-            lsa = LineString(ls.coords)
-            for f in geos_function_tests:
-                self.assertEqual(f(lsa), f(ls), 'LineString ' + f.__name__)
-
-    def test05_Polygon(self):
-        'Testing Polygon mutations'
-        for pg in (Polygon(((1,0),(4,1),(6,-1),(8,10),(1,0)),
-                            ((5,4),(6,4),(6,3),(5,4))),
-                    fromstr('POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))')):
-            self.assertEqual(pg._get_single_external(0),
-                            LinearRing((1,0),(4,1),(6,-1),(8,10),(1,0)),
-                            'Polygon _get_single_external(0)')
-            self.assertEqual(pg._get_single_external(1),
-                            LinearRing((5,4),(6,4),(6,3),(5,4)),
-                            'Polygon _get_single_external(1)')
-
-            # _set_list
-            pg._set_list(2, (((1,2),(10,0),(12,9),(-1,15),(1,2)),
-                            ((4,2),(5,2),(5,3),(4,2))))
-            self.assertEqual(pg.coords,
-                    (((1.0,2.0),(10.0,0.0),(12.0,9.0),(-1.0,15.0),(1.0,2.0)),
-                        ((4.0,2.0),(5.0,2.0),(5.0,3.0),(4.0,2.0))),
-                    'Polygon _set_list')
-
-            lsa = Polygon(*pg.coords)
-            for f in geos_function_tests:
-                self.assertEqual(f(lsa), f(pg), 'Polygon ' + f.__name__)
-
-    def test06_Collection(self):
-        'Testing Collection mutations'
-        for mp in (MultiPoint(*map(Point,((3,4),(-1,2),(5,-4),(2,8)))),
-                    fromstr('MULTIPOINT (3 4,-1 2,5 -4,2 8)')):
-            self.assertEqual(mp._get_single_external(2), Point(5,-4), 'Collection _get_single_external')
-
-            mp._set_list(3, map(Point,((5,5),(3,-2),(8,1))))
-            self.assertEqual(mp.coords, ((5.0,5.0),(3.0,-2.0),(8.0,1.0)), 'Collection _set_list')
-
-            lsa = MultiPoint(*map(Point,((5,5),(3,-2),(8,1))))
-            for f in geos_function_tests:
-                self.assertEqual(f(lsa), f(mp), 'MultiPoint ' + f.__name__)
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py
deleted file mode 100644
index 34eeaf9..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py
+++ /dev/null
@@ -1,116 +0,0 @@
-from __future__ import unicode_literals
-
-import binascii
-import unittest
-
-from django.contrib.gis import memoryview
-from django.utils.unittest import skipUnless
-
-from ..import HAS_GEOS
-
-if HAS_GEOS:
-    from .. import GEOSGeometry, WKTReader, WKTWriter, WKBReader, WKBWriter, geos_version_info
-
-
-@skipUnless(HAS_GEOS, "Geos is required.")
-class GEOSIOTest(unittest.TestCase):
-
-    def test01_wktreader(self):
-        # Creating a WKTReader instance
-        wkt_r = WKTReader()
-        wkt = 'POINT (5 23)'
-
-        # read() should return a GEOSGeometry
-        ref = GEOSGeometry(wkt)
-        g1 = wkt_r.read(wkt.encode())
-        g2 = wkt_r.read(wkt)
-
-        for geom in (g1, g2):
-            self.assertEqual(ref, geom)
-
-        # Should only accept six.string_types objects.
-        self.assertRaises(TypeError, wkt_r.read, 1)
-        self.assertRaises(TypeError, wkt_r.read, memoryview(b'foo'))
-
-    def test02_wktwriter(self):
-        # Creating a WKTWriter instance, testing its ptr property.
-        wkt_w = WKTWriter()
-        self.assertRaises(TypeError, wkt_w._set_ptr, WKTReader.ptr_type())
-
-        ref = GEOSGeometry('POINT (5 23)')
-        ref_wkt = 'POINT (5.0000000000000000 23.0000000000000000)'
-        self.assertEqual(ref_wkt, wkt_w.write(ref).decode())
-
-    def test03_wkbreader(self):
-        # Creating a WKBReader instance
-        wkb_r = WKBReader()
-
-        hex = b'000000000140140000000000004037000000000000'
-        wkb = memoryview(binascii.a2b_hex(hex))
-        ref = GEOSGeometry(hex)
-
-        # read() should return a GEOSGeometry on either a hex string or
-        # a WKB buffer.
-        g1 = wkb_r.read(wkb)
-        g2 = wkb_r.read(hex)
-        for geom in (g1, g2):
-            self.assertEqual(ref, geom)
-
-        bad_input = (1, 5.23, None, False)
-        for bad_wkb in bad_input:
-            self.assertRaises(TypeError, wkb_r.read, bad_wkb)
-
-    def test04_wkbwriter(self):
-        wkb_w = WKBWriter()
-
-        # Representations of 'POINT (5 23)' in hex -- one normal and
-        # the other with the byte order changed.
-        g = GEOSGeometry('POINT (5 23)')
-        hex1 = b'010100000000000000000014400000000000003740'
-        wkb1 = memoryview(binascii.a2b_hex(hex1))
-        hex2 = b'000000000140140000000000004037000000000000'
-        wkb2 = memoryview(binascii.a2b_hex(hex2))
-
-        self.assertEqual(hex1, wkb_w.write_hex(g))
-        self.assertEqual(wkb1, wkb_w.write(g))
-
-        # Ensuring bad byteorders are not accepted.
-        for bad_byteorder in (-1, 2, 523, 'foo', None):
-            # Equivalent of `wkb_w.byteorder = bad_byteorder`
-            self.assertRaises(ValueError, wkb_w._set_byteorder, bad_byteorder)
-
-        # Setting the byteorder to 0 (for Big Endian)
-        wkb_w.byteorder = 0
-        self.assertEqual(hex2, wkb_w.write_hex(g))
-        self.assertEqual(wkb2, wkb_w.write(g))
-
-        # Back to Little Endian
-        wkb_w.byteorder = 1
-
-        # Now, trying out the 3D and SRID flags.
-        g = GEOSGeometry('POINT (5 23 17)')
-        g.srid = 4326
-
-        hex3d = b'0101000080000000000000144000000000000037400000000000003140'
-        wkb3d = memoryview(binascii.a2b_hex(hex3d))
-        hex3d_srid = b'01010000A0E6100000000000000000144000000000000037400000000000003140'
-        wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid))
-
-        # Ensuring bad output dimensions are not accepted
-        for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None):
-            # Equivalent of `wkb_w.outdim = bad_outdim`
-            self.assertRaises(ValueError, wkb_w._set_outdim, bad_outdim)
-
-        # These tests will fail on 3.0.0 because of a bug that was fixed in 3.1:
-        # http://trac.osgeo.org/geos/ticket/216
-        if not geos_version_info()['version'].startswith('3.0.'):
-            # Now setting the output dimensions to be 3
-            wkb_w.outdim = 3
-
-            self.assertEqual(hex3d, wkb_w.write_hex(g))
-            self.assertEqual(wkb3d, wkb_w.write(g))
-
-            # Telling the WKBWriter to include the srid in the representation.
-            wkb_w.srid = True
-            self.assertEqual(hex3d_srid, wkb_w.write_hex(g))
-            self.assertEqual(wkb3d_srid, wkb_w.write(g))
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py
deleted file mode 100644
index a4a56f2..0000000
--- a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py
+++ /dev/null
@@ -1,397 +0,0 @@
-# Copyright (c) 2008-2009 Aryeh Leib Taurog, http://www.aryehleib.com
-# All rights reserved.
-#
-# Modified from original contribution by Aryeh Leib Taurog, which was
-# released under the New BSD license.
-from django.contrib.gis.geos.mutable_list import ListMixin
-from django.utils import six
-from django.utils import unittest
-
-
-class UserListA(ListMixin):
-    _mytype = tuple
-    def __init__(self, i_list, *args, **kwargs):
-        self._list = self._mytype(i_list)
-        super(UserListA, self).__init__(*args, **kwargs)
-
-    def __len__(self):  return len(self._list)
-
-    def __str__(self):  return str(self._list)
-
-    def __repr__(self): return repr(self._list)
-
-    def _set_list(self, length, items):
-        # this would work:
-        # self._list = self._mytype(items)
-        # but then we wouldn't be testing length parameter
-        itemList = ['x'] * length
-        for i, v in enumerate(items):
-            itemList[i] = v
-
-        self._list = self._mytype(itemList)
-
-    def _get_single_external(self, index):
-        return self._list[index]
-
-class UserListB(UserListA):
-    _mytype = list
-
-    def _set_single(self, index, value):
-        self._list[index] = value
-
-def nextRange(length):
-    nextRange.start += 100
-    return range(nextRange.start, nextRange.start + length)
-
-nextRange.start = 0
-
-class ListMixinTest(unittest.TestCase):
-    """
-    Tests base class ListMixin by comparing a list clone which is
-    a ListMixin subclass with a real Python list.
-    """
-    limit = 3
-    listType = UserListA
-
-    def lists_of_len(self, length=None):
-        if length is None: length = self.limit
-        pl = list(range(length))
-        return pl, self.listType(pl)
-
-    def limits_plus(self, b):
-        return range(-self.limit - b, self.limit + b)
-
-    def step_range(self):
-        return list(range(-1 - self.limit, 0)) + list(range(1, 1 + self.limit))
-
-    def test01_getslice(self):
-        'Slice retrieval'
-        pl, ul = self.lists_of_len()
-        for i in self.limits_plus(1):
-            self.assertEqual(pl[i:], ul[i:], 'slice [%d:]' % (i))
-            self.assertEqual(pl[:i], ul[:i], 'slice [:%d]' % (i))
-
-            for j in self.limits_plus(1):
-                self.assertEqual(pl[i:j], ul[i:j], 'slice [%d:%d]' % (i,j))
-                for k in self.step_range():
-                    self.assertEqual(pl[i:j:k], ul[i:j:k], 'slice [%d:%d:%d]' % (i,j,k))
-
-            for k in self.step_range():
-                self.assertEqual(pl[i::k], ul[i::k], 'slice [%d::%d]' % (i,k))
-                self.assertEqual(pl[:i:k], ul[:i:k], 'slice [:%d:%d]' % (i,k))
-
-        for k in self.step_range():
-            self.assertEqual(pl[::k], ul[::k], 'slice [::%d]' % (k))
-
-    def test02_setslice(self):
-        'Slice assignment'
-        def setfcn(x,i,j,k,L): x[i:j:k] = range(L)
-        pl, ul = self.lists_of_len()
-        for slen in range(self.limit + 1):
-            ssl = nextRange(slen)
-            ul[:] = ssl
-            pl[:] = ssl
-            self.assertEqual(pl, ul[:], 'set slice [:]')
-
-            for i in self.limits_plus(1):
-                ssl = nextRange(slen)
-                ul[i:] = ssl
-                pl[i:] = ssl
-                self.assertEqual(pl, ul[:], 'set slice [%d:]' % (i))
-
-                ssl = nextRange(slen)
-                ul[:i] = ssl
-                pl[:i] = ssl
-                self.assertEqual(pl, ul[:], 'set slice [:%d]' % (i))
-
-                for j in self.limits_plus(1):
-                    ssl = nextRange(slen)
-                    ul[i:j] = ssl
-                    pl[i:j] = ssl
-                    self.assertEqual(pl, ul[:], 'set slice [%d:%d]' % (i, j))
-
-                    for k in self.step_range():
-                        ssl = nextRange( len(ul[i:j:k]) )
-                        ul[i:j:k] = ssl
-                        pl[i:j:k] = ssl
-                        self.assertEqual(pl, ul[:], 'set slice [%d:%d:%d]' % (i, j, k))
-
-                        sliceLen = len(ul[i:j:k])
-                        self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen + 1)
-                        if sliceLen > 2:
-                            self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen - 1)
-
-                for k in self.step_range():
-                    ssl = nextRange( len(ul[i::k]) )
-                    ul[i::k] = ssl
-                    pl[i::k] = ssl
-                    self.assertEqual(pl, ul[:], 'set slice [%d::%d]' % (i, k))
-
-                    ssl = nextRange( len(ul[:i:k]) )
-                    ul[:i:k] = ssl
-                    pl[:i:k] = ssl
-                    self.assertEqual(pl, ul[:], 'set slice [:%d:%d]' % (i, k))
-
-            for k in self.step_range():
-                ssl = nextRange(len(ul[::k]))
-                ul[::k] = ssl
-                pl[::k] = ssl
-                self.assertEqual(pl, ul[:], 'set slice [::%d]' % (k))
-
-
-    def test03_delslice(self):
-        'Delete slice'
-        for Len in range(self.limit):
-            pl, ul = self.lists_of_len(Len)
-            del pl[:]
-            del ul[:]
-            self.assertEqual(pl[:], ul[:], 'del slice [:]')
-            for i in range(-Len - 1, Len + 1):
-                pl, ul = self.lists_of_len(Len)
-                del pl[i:]
-                del ul[i:]
-                self.assertEqual(pl[:], ul[:], 'del slice [%d:]' % (i))
-                pl, ul = self.lists_of_len(Len)
-                del pl[:i]
-                del ul[:i]
-                self.assertEqual(pl[:], ul[:], 'del slice [:%d]' % (i))
-                for j in range(-Len - 1, Len + 1):
-                    pl, ul = self.lists_of_len(Len)
-                    del pl[i:j]
-                    del ul[i:j]
-                    self.assertEqual(pl[:], ul[:], 'del slice [%d:%d]' % (i,j))
-                    for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
-                        pl, ul = self.lists_of_len(Len)
-                        del pl[i:j:k]
-                        del ul[i:j:k]
-                        self.assertEqual(pl[:], ul[:], 'del slice [%d:%d:%d]' % (i,j,k))
-
-                for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
-                    pl, ul = self.lists_of_len(Len)
-                    del pl[:i:k]
-                    del ul[:i:k]
-                    self.assertEqual(pl[:], ul[:], 'del slice [:%d:%d]' % (i,k))
-
-                    pl, ul = self.lists_of_len(Len)
-                    del pl[i::k]
-                    del ul[i::k]
-                    self.assertEqual(pl[:], ul[:], 'del slice [%d::%d]' % (i,k))
-
-            for k in list(range(-Len - 1, 0)) + list(range(1, Len)):
-                pl, ul = self.lists_of_len(Len)
-                del pl[::k]
-                del ul[::k]
-                self.assertEqual(pl[:], ul[:], 'del slice [::%d]' % (k))
-
-    def test04_get_set_del_single(self):
-        'Get/set/delete single item'
-        pl, ul = self.lists_of_len()
-        for i in self.limits_plus(0):
-            self.assertEqual(pl[i], ul[i], 'get single item [%d]' % i)
-
-        for i in self.limits_plus(0):
-            pl, ul = self.lists_of_len()
-            pl[i] = 100
-            ul[i] = 100
-            self.assertEqual(pl[:], ul[:], 'set single item [%d]' % i)
-
-        for i in self.limits_plus(0):
-            pl, ul = self.lists_of_len()
-            del pl[i]
-            del ul[i]
-            self.assertEqual(pl[:], ul[:], 'del single item [%d]' % i)
-
-    def test05_out_of_range_exceptions(self):
-        'Out of range exceptions'
-        def setfcn(x, i): x[i] = 20
-        def getfcn(x, i): return x[i]
-        def delfcn(x, i): del x[i]
-        pl, ul = self.lists_of_len()
-        for i in (-1 - self.limit, self.limit):
-            self.assertRaises(IndexError, setfcn, ul, i) # 'set index %d' % i)
-            self.assertRaises(IndexError, getfcn, ul, i) # 'get index %d' % i)
-            self.assertRaises(IndexError, delfcn, ul, i) # 'del index %d' % i)
-
-    def test06_list_methods(self):
-        'List methods'
-        pl, ul = self.lists_of_len()
-        pl.append(40)
-        ul.append(40)
-        self.assertEqual(pl[:], ul[:], 'append')
-
-        pl.extend(range(50,55))
-        ul.extend(range(50,55))
-        self.assertEqual(pl[:], ul[:], 'extend')
-
-        pl.reverse()
-        ul.reverse()
-        self.assertEqual(pl[:], ul[:], 'reverse')
-
-        for i in self.limits_plus(1):
-            pl, ul = self.lists_of_len()
-            pl.insert(i,50)
-            ul.insert(i,50)
-            self.assertEqual(pl[:], ul[:], 'insert at %d' % i)
-
-        for i in self.limits_plus(0):
-            pl, ul = self.lists_of_len()
-            self.assertEqual(pl.pop(i), ul.pop(i), 'popped value at %d' % i)
-            self.assertEqual(pl[:], ul[:], 'after pop at %d' % i)
-
-        pl, ul = self.lists_of_len()
-        self.assertEqual(pl.pop(), ul.pop(i), 'popped value')
-        self.assertEqual(pl[:], ul[:], 'after pop')
-
-        pl, ul = self.lists_of_len()
-        def popfcn(x, i): x.pop(i)
-        self.assertRaises(IndexError, popfcn, ul, self.limit)
-        self.assertRaises(IndexError, popfcn, ul, -1 - self.limit)
-
-        pl, ul = self.lists_of_len()
-        for val in range(self.limit):
-            self.assertEqual(pl.index(val), ul.index(val), 'index of %d' % val)
-
-        for val in self.limits_plus(2):
-            self.assertEqual(pl.count(val), ul.count(val), 'count %d' % val)
-
-        for val in range(self.limit):
-            pl, ul = self.lists_of_len()
-            pl.remove(val)
-            ul.remove(val)
-            self.assertEqual(pl[:], ul[:], 'after remove val %d' % val)
-
-        def indexfcn(x, v): return x.index(v)
-        def removefcn(x, v): return x.remove(v)
-        self.assertRaises(ValueError, indexfcn, ul, 40)
-        self.assertRaises(ValueError, removefcn, ul, 40)
-
-    def test07_allowed_types(self):
-        'Type-restricted list'
-        pl, ul = self.lists_of_len()
-        ul._allowed = six.integer_types
-        ul[1] = 50
-        ul[:2] = [60, 70, 80]
-        def setfcn(x, i, v): x[i] = v
-        self.assertRaises(TypeError, setfcn, ul, 2, 'hello')
-        self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), ('hello','goodbye'))
-
-    def test08_min_length(self):
-        'Length limits'
-        pl, ul = self.lists_of_len()
-        ul._minlength = 1
-        def delfcn(x,i): del x[:i]
-        def setfcn(x,i): x[:i] = []
-        for i in range(self.limit - ul._minlength + 1, self.limit + 1):
-            self.assertRaises(ValueError, delfcn, ul, i)
-            self.assertRaises(ValueError, setfcn, ul, i)
-        del ul[:ul._minlength]
-
-        ul._maxlength = 4
-        for i in range(0, ul._maxlength - len(ul)):
-            ul.append(i)
-        self.assertRaises(ValueError, ul.append, 10)
-
-    def test09_iterable_check(self):
-        'Error on assigning non-iterable to slice'
-        pl, ul = self.lists_of_len(self.limit + 1)
-        def setfcn(x, i, v): x[i] = v
-        self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), 2)
-
-    def test10_checkindex(self):
-        'Index check'
-        pl, ul = self.lists_of_len()
-        for i in self.limits_plus(0):
-            if i < 0:
-                self.assertEqual(ul._checkindex(i), i + self.limit, '_checkindex(neg index)')
-            else:
-                self.assertEqual(ul._checkindex(i), i, '_checkindex(pos index)')
-
-        for i in (-self.limit - 1, self.limit):
-            self.assertRaises(IndexError, ul._checkindex, i)
-
-        ul._IndexError = TypeError
-        self.assertRaises(TypeError, ul._checkindex, -self.limit - 1)
-
-    def test_11_sorting(self):
-        'Sorting'
-        pl, ul = self.lists_of_len()
-        pl.insert(0, pl.pop())
-        ul.insert(0, ul.pop())
-        pl.sort()
-        ul.sort()
-        self.assertEqual(pl[:], ul[:], 'sort')
-        mid = pl[len(pl) // 2]
-        pl.sort(key=lambda x: (mid-x)**2)
-        ul.sort(key=lambda x: (mid-x)**2)
-        self.assertEqual(pl[:], ul[:], 'sort w/ key')
-
-        pl.insert(0, pl.pop())
-        ul.insert(0, ul.pop())
-        pl.sort(reverse=True)
-        ul.sort(reverse=True)
-        self.assertEqual(pl[:], ul[:], 'sort w/ reverse')
-        mid = pl[len(pl) // 2]
-        pl.sort(key=lambda x: (mid-x)**2)
-        ul.sort(key=lambda x: (mid-x)**2)
-        self.assertEqual(pl[:], ul[:], 'sort w/ key')
-
-    def test_12_arithmetic(self):
-        'Arithmetic'
-        pl, ul = self.lists_of_len()
-        al = list(range(10,14))
-        self.assertEqual(list(pl + al), list(ul + al), 'add')
-        self.assertEqual(type(ul), type(ul + al), 'type of add result')
-        self.assertEqual(list(al + pl), list(al + ul), 'radd')
-        self.assertEqual(type(al), type(al + ul), 'type of radd result')
-        objid = id(ul)
-        pl += al
-        ul += al
-        self.assertEqual(pl[:], ul[:], 'in-place add')
-        self.assertEqual(objid, id(ul), 'in-place add id')
-
-        for n in (-1,0,1,3):
-            pl, ul = self.lists_of_len()
-            self.assertEqual(list(pl * n), list(ul * n), 'mul by %d' % n)
-            self.assertEqual(type(ul), type(ul * n), 'type of mul by %d result' % n)
-            self.assertEqual(list(n * pl), list(n * ul), 'rmul by %d' % n)
-            self.assertEqual(type(ul), type(n * ul), 'type of rmul by %d result' % n)
-            objid = id(ul)
-            pl *= n
-            ul *= n
-            self.assertEqual(pl[:], ul[:], 'in-place mul by %d' % n)
-            self.assertEqual(objid, id(ul), 'in-place mul by %d id' % n)
-
-        pl, ul = self.lists_of_len()
-        self.assertEqual(pl, ul, 'cmp for equal')
-        self.assertFalse(ul == pl + [2], 'cmp for not equal')
-        self.assertTrue(pl >= ul, 'cmp for gte self')
-        self.assertTrue(pl <= ul, 'cmp for lte self')
-        self.assertTrue(ul >= pl, 'cmp for self gte')
-        self.assertTrue(ul <= pl, 'cmp for self lte')
-
-        self.assertTrue(pl + [5] > ul, 'cmp')
-        self.assertTrue(pl + [5] >= ul, 'cmp')
-        self.assertTrue(pl < ul + [2], 'cmp')
-        self.assertTrue(pl <= ul + [2], 'cmp')
-        self.assertTrue(ul + [5] > pl, 'cmp')
-        self.assertTrue(ul + [5] >= pl, 'cmp')
-        self.assertTrue(ul < pl + [2], 'cmp')
-        self.assertTrue(ul <= pl + [2], 'cmp')
-
-        # Also works with a custom IndexError
-        ul_longer = ul + [2]
-        ul_longer._IndexError = TypeError
-        ul._IndexError = TypeError
-        self.assertFalse(ul_longer == pl)
-        self.assertFalse(ul == ul_longer)
-        self.assertTrue(ul_longer > ul)
-
-        pl[1] = 20
-        self.assertTrue(pl > ul, 'cmp for gt self')
-        self.assertTrue(ul < pl, 'cmp for self lt')
-        pl[1] = -20
-        self.assertTrue(pl < ul, 'cmp for lt self')
-        self.assertTrue(pl < ul, 'cmp for lt self')
-
-class ListMixinTestSingle(ListMixinTest):
-    listType = UserListB