diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/contrib/gis/geos')
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 |