Skip to content
Sign up
This repository

public / django Octocat-spinner-32

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse code

Applied latest changes to `ListMixin` from Aryeh Leib Taurog and adde… 

…d him to AUTHORS; fixed memory leak introduced in r10174 -- no longer call `ListMixin.__init__` and set methods manually because it created references that prevented garbage collection; fixed several routines that had no need to be class methods.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@10494 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 5e58810e2197f13dc8372bfeae66e95b908f601d 1 parent ae7cb57
Justin Bronn authored

Showing 9 changed files with 267 additions and 121 deletions. Show Diff Stats Hide Diff Stats

  1. 1  AUTHORS
  2. 16  django/contrib/gis/geos/collections.py
  3. 1  django/contrib/gis/geos/geometry.py
  4. 8  django/contrib/gis/geos/linestring.py
  5. 157  django/contrib/gis/geos/mutable_list.py
  6. 10  django/contrib/gis/geos/point.py
  7. 32  django/contrib/gis/geos/polygon.py
  8. 36  django/contrib/gis/geos/tests/test_geos_mutation.py
  9. 127  django/contrib/gis/geos/tests/test_mutable_list.py
1  AUTHORS
View 
@@ -408,6 +408,7 @@ answer newbie questions, and generally made Django that much better:
408 408 
     Christian Tanzer <tanzer@swing.co.at>
409 409 
     Tyler Tarabula <tyler.tarabula@gmail.com>
410 410 
     Tyson Tate <tyson@fallingbullets.com>
  411 
+    Aryeh Leib Taurog <http://www.aryehleib.com/>
411 412 
     Frank Tegtmeyer <fte@fte.to>
412 413 
     Marcel Telka <marcel@telka.sk>
413 414 
     Terry Huang <terryh.tp@gmail.com>
16  django/contrib/gis/geos/collections.py
View 
@@ -49,8 +49,7 @@ def __len__(self):
49 49 
         return self.num_geom
50 50
51 51 
     ### Methods for compatibility with ListMixin ###
52   
-    @classmethod
53   
-    def _create_collection(cls, length, items):
  52 
+    def _create_collection(self, length, items):
54 53 
         # Creating the geometry pointer array.
55 54 
         geoms = get_pointer_arr(length)
56 55 
         for i, g in enumerate(items):
 
@@ -58,17 +57,17 @@ def _create_collection(cls, length, items):
58 57 
             # allow GEOSGeometry types (python wrappers) or pointer types
59 58 
             geoms[i] = capi.geom_clone(getattr(g, 'ptr', g))
60 59
61   
-        return capi.create_collection(c_int(cls._typeid), byref(geoms), c_uint(length))
  60 
+        return capi.create_collection(c_int(self._typeid), byref(geoms), c_uint(length))
62 61
63   
-    def _getitem_internal(self, index):
  62 
+    def _get_single_internal(self, index):
64 63 
         return capi.get_geomn(self.ptr, index)
65 64
66   
-    def _getitem_external(self, index):
  65 
+    def _get_single_external(self, index):
67 66 
         "Returns the Geometry from this Collection at the given index (0-based)."
68 67 
         # Checking the index and returning the corresponding GEOS geometry.
69   
-        return GEOSGeometry(capi.geom_clone(self._getitem_internal(index)), srid=self.srid)
  68 
+        return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid)
70 69
71   
-    def _set_collection(self, length, items):
  70 
+    def _set_list(self, length, items):
72 71 
         "Create a new collection, and destroy the contents of the previous pointer."
73 72 
         prev_ptr = self.ptr
74 73 
         srid = self.srid
 
@@ -76,6 +75,9 @@ def _set_collection(self, length, items):
76 75 
         if srid: self.srid = srid
77 76 
         capi.destroy_geom(prev_ptr)
78 77
  78 
+    _set_single = GEOSGeometry._set_single_rebuild
  79 
+    _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild
  80 
+
79 81 
     @property
80 82 
     def kml(self):
81 83 
         "Returns the KML for this Geometry Collection."
1  django/contrib/gis/geos/geometry.py
View 
@@ -90,7 +90,6 @@ def __init__(self, geo_input, srid=None):
90 90
91 91 
         # Post-initialization setup.
92 92 
         self._post_init(srid)
93   
-        super(GEOSGeometry, self).__init__()
94 93
95 94 
     def _post_init(self, srid):
96 95 
         "Helper routine for performing post-initialization setup."
8  django/contrib/gis/geos/linestring.py
View 
@@ -74,12 +74,12 @@ def __len__(self):
74 74 
         "Returns the number of points in this LineString."
75 75 
         return len(self._cs)
76 76
77   
-    def _getitem_external(self, index):
78   
-        self._checkindex(index)
  77 
+    def _get_single_external(self, index):
79 78 
         return self._cs[index]
80   
-    _getitem_internal = _getitem_external
81 79
82   
-    def _set_collection(self, length, items):
  80 
+    _get_single_internal = _get_single_external
  81 
+
  82 
+    def _set_list(self, length, items):
83 83 
         ndim = self._cs.dims #
84 84 
         hasz = self._cs.hasz # I don't understand why these are different
85 85
157  django/contrib/gis/geos/mutable_list.py
View 
@@ -2,45 +2,52 @@
2 2 
 # Released under the New BSD license.
3 3 
 """
4 4 
 This module contains a base type which provides list-style mutations
5   
-This is akin to UserList, but without specific data storage methods.
6   
-Possible candidate for a more general position in the source tree,
7   
-perhaps django.utils
  5 
+without specific data storage methods.
  6 
+
  7 
+See also http://www.aryehleib.com/MutableLists.html
8 8
9 9 
 Author: Aryeh Leib Taurog.
10 10 
 """
11 11 
 class ListMixin(object):
12 12 
     """
13   
-    A base class which provides complete list interface
14   
-    derived classes should implement the following:
  13 
+    A base class which provides complete list interface.
  14 
+    Derived classes must call ListMixin's __init__() function
  15 
+    and implement the following:
15 16
16   
-    function _getitem_external(self, i):
17   
-        Return single item with index i for general use
  17 
+    function _get_single_external(self, i):
  18 
+        Return single item with index i for general use.
  19 
+        The index i will always satisfy 0 <= i < len(self).
18 20
19   
-    function _getitem_internal(self, i):
  21 
+    function _get_single_internal(self, i):
20 22 
         Same as above, but for use within the class [Optional]
  23 
+        Note that if _get_single_internal and _get_single_internal return
  24 
+        different types of objects, _set_list must distinguish
  25 
+        between the two and handle each appropriately.
  26 
+
  27 
+    function _set_list(self, length, items):
  28 
+        Recreate the entire object.
21 29
22   
-    function _set_collection(self, length, items):
23   
-        Recreate the entire object
  30 
+        NOTE: items may be a generator which calls _get_single_internal.
  31 
+        Therefore, it is necessary to cache the values in a temporary:
  32 
+            temp = list(items)
  33 
+        before clobbering the original storage.
24 34
25 35 
     function _set_single(self, i, value):
26 36 
         Set the single item at index i to value [Optional]
27 37 
         If left undefined, all mutations will result in rebuilding
28   
-        the object using _set_collection.
  38 
+        the object using _set_list.
29 39
30 40 
     function __len__(self):
31 41 
         Return the length
32 42
33   
-    function __iter__(self):
34   
-        Return an iterator for the object
35   
-
36 43 
     int _minlength:
37 44 
         The minimum legal length [Optional]
38 45
39 46 
     int _maxlength:
40 47 
         The maximum legal length [Optional]
41 48
42   
-    iterable _allowed:
43   
-        A list of allowed item types [Optional]
  49 
+    type or tuple _allowed:
  50 
+        A type or tuple of allowed item types [Optional]
44 51
45 52 
     class _IndexError:
46 53 
         The type of exception to be raise on invalid index [Optional]
 
@@ -50,11 +57,11 @@ class _IndexError:
50 57 
     _maxlength = None
51 58 
     _IndexError = IndexError
52 59
53   
-    ### Python initialization and list interface methods ###
  60 
+    ### Python initialization and special list interface methods ###
54 61
55 62 
     def __init__(self, *args, **kwargs):
56   
-        if not hasattr(self, '_getitem_internal'):
57   
-            self._getitem_internal = self._getitem_external
  63 
+        if not hasattr(self, '_get_single_internal'):
  64 
+            self._get_single_internal = self._get_single_external
58 65
59 66 
         if not hasattr(self, '_set_single'):
60 67 
             self._set_single = self._set_single_rebuild
 
@@ -63,15 +70,15 @@ def __init__(self, *args, **kwargs):
63 70 
         super(ListMixin, self).__init__(*args, **kwargs)
64 71
65 72 
     def __getitem__(self, index):
66   
-        "Gets the coordinates of the point(s) at the specified index/slice."
  73 
+        "Get the item(s) at the specified index/slice."
67 74 
         if isinstance(index, slice):
68   
-            return [self._getitem_external(i) for i in xrange(*index.indices(len(self)))]
  75 
+            return [self._get_single_external(i) for i in xrange(*index.indices(len(self)))]
69 76 
         else:
70 77 
             index = self._checkindex(index)
71   
-            return self._getitem_external(index)
  78 
+            return self._get_single_external(index)
72 79
73 80 
     def __delitem__(self, index):
74   
-        "Delete the point(s) at the specified index/slice."
  81 
+        "Delete the item(s) at the specified index/slice."
75 82 
         if not isinstance(index, (int, long, slice)):
76 83 
             raise TypeError("%s is not a legal index" % index)
77 84 
 
@@ -84,14 +91,14 @@ def __delitem__(self, index):
84 91 
             indexRange  = range(*index.indices(origLen))
85 92
86 93 
         newLen      = origLen - len(indexRange)
87   
-        newItems    = ( self._getitem_internal(i)
  94 
+        newItems    = ( self._get_single_internal(i)
88 95 
                         for i in xrange(origLen)
89 96 
                         if i not in indexRange )
90 97
91 98 
         self._rebuild(newLen, newItems)
92 99
93 100 
     def __setitem__(self, index, val):
94   
-        "Sets the Geometry at the specified index."
  101 
+        "Set the item(s) at the specified index/slice."
95 102 
         if isinstance(index, slice):
96 103 
             self._set_slice(index, val)
97 104 
         else:
 
@@ -99,7 +106,74 @@ def __setitem__(self, index, val):
99 106 
             self._check_allowed((val,))
100 107 
             self._set_single(index, val)
101 108
  109 
+    def __iter__(self):
  110 
+        "Iterate over the items in the list"
  111 
+        for i in xrange(len(self)):
  112 
+            yield self[i]
  113 
+
  114 
+    ### Special methods for arithmetic operations ###
  115 
+    def __add__(self, other):
  116 
+        'add another list-like object'
  117 
+        return self.__class__(list(self) + list(other))
  118 
+
  119 
+    def __radd__(self, other):
  120 
+        'add to another list-like object'
  121 
+        return other.__class__(list(other) + list(self))
  122 
+
  123 
+    def __iadd__(self, other):
  124 
+        'add another list-like object to self'
  125 
+        self.extend(list(other))
  126 
+        return self
  127 
+
  128 
+    def __mul__(self, n):
  129 
+        'multiply'
  130 
+        return self.__class__(list(self) * n)
  131 
+
  132 
+    def __rmul__(self, n):
  133 
+        'multiply'
  134 
+        return self.__class__(list(self) * n)
  135 
+
  136 
+    def __imul__(self, n):
  137 
+        'multiply'
  138 
+        if n <= 0:
  139 
+            del self[:]
  140 
+        else:
  141 
+            cache = list(self)
  142 
+            for i in range(n-1):
  143 
+                self.extend(cache)
  144 
+        return self
  145 
+
  146 
+    def __cmp__(self, other):
  147 
+        'cmp'
  148 
+        slen = len(self)
  149 
+        for i in range(slen):
  150 
+            try:
  151 
+                c = cmp(self[i], other[i])
  152 
+            except IndexError:
  153 
+                # must be other is shorter
  154 
+                return 1
  155 
+            else:
  156 
+                # elements not equal
  157 
+                if c: return c
  158 
+
  159 
+        return cmp(slen, len(other))
  160 
+
102 161 
     ### Public list interface Methods ###
  162 
+    ## Non-mutating ##
  163 
+    def count(self, val):
  164 
+        "Standard list count method"
  165 
+        count = 0
  166 
+        for i in self:
  167 
+            if val == i: count += 1
  168 
+        return count
  169 
+
  170 
+    def index(self, val):
  171 
+        "Standard list index method"
  172 
+        for i in xrange(0, len(self)):
  173 
+            if self[i] == val: return i
  174 
+        raise ValueError('%s not found in object' % str(val))
  175 
+
  176 
+    ## Mutating ##
103 177 
     def append(self, val):
104 178 
         "Standard list append method"
105 179 
         self[len(self):] = [val]
 
@@ -120,32 +194,33 @@ def pop(self, index=-1):
120 194 
         del self[index]
121 195 
         return result
122 196
123   
-    def index(self, val):
124   
-        "Standard list index method"
125   
-        for i in xrange(0, len(self)):
126   
-            if self[i] == val: return i
127   
-        raise ValueError('%s not found in object' % str(val))
128   
-
129 197 
     def remove(self, val):
130 198 
         "Standard list remove method"
131 199 
         del self[self.index(val)]
132 200
133   
-    def count(self, val):
134   
-        "Standard list count method"
135   
-        count = 0
136   
-        for i in self:
137   
-            if val == i: count += 1
138   
-        return count
  201 
+    def reverse(self):
  202 
+        "Standard list reverse method"
  203 
+        self[:] = self[-1::-1]
139 204
140   
-    ### Private API routines unique to ListMixin ###
  205 
+    def sort(self, cmp=cmp, key=None, reverse=False):
  206 
+        "Standard list sort method"
  207 
+        if key:
  208 
+            temp = [(key(v),v) for v in self]
  209 
+            temp.sort(cmp=cmp, key=lambda x: x[0], reverse=reverse)
  210 
+            self[:] = [v[1] for v in temp]
  211 
+        else:
  212 
+            temp = list(self)
  213 
+            temp.sort(cmp=cmp, reverse=reverse)
  214 
+            self[:] = temp
141 215
  216 
+    ### Private routines ###
142 217 
     def _rebuild(self, newLen, newItems):
143 218 
         if newLen < self._minlength:
144 219 
             raise ValueError('Must have at least %d items' % self._minlength)
145 220 
         if self._maxlength is not None and newLen > self._maxlength:
146 221 
             raise ValueError('Cannot have more than %d items' % self._maxlength)
147 222
148   
-        self._set_collection(newLen, newItems)
  223 
+        self._set_list(newLen, newItems)
149 224
150 225 
     def _set_single_rebuild(self, index, value):
151 226 
         self._set_slice(slice(index, index + 1, 1), [value])
 
@@ -200,7 +275,7 @@ def newItems():
200 275 
                 if i in newVals:
201 276 
                     yield newVals[i]
202 277 
                 else:
203   
-                    yield self._getitem_internal(i)
  278 
+                    yield self._get_single_internal(i)
204 279
205 280 
         self._rebuild(newLen, newItems())
206 281 
 
@@ -229,6 +304,6 @@ def newItems():
229 304
230 305 
                 if i < origLen:
231 306 
                     if i < start or i >= stop:
232   
-                        yield self._getitem_internal(i)
  307 
+                        yield self._get_single_internal(i)
233 308
234 309 
         self._rebuild(newLen, newItems())
10  django/contrib/gis/geos/point.py
View 
@@ -5,6 +5,7 @@
5 5
6 6 
 class Point(GEOSGeometry):
7 7 
     _minlength = 2
  8 
+    _maxlength = 3
8 9
9 10 
     def __init__(self, x, y=None, z=None, srid=None):
10 11 
         """
 
@@ -36,7 +37,6 @@ def __init__(self, x, y=None, z=None, srid=None):
36 37 
         #  createPoint factory.
37 38 
         super(Point, self).__init__(point, srid=srid)
38 39
39   
-    @classmethod
40 40 
     def _create_point(self, ndim, coords):
41 41 
         """
42 42 
         Create a coordinate sequence, set X, Y, [Z], and create point
 
@@ -52,7 +52,7 @@ def _create_point(self, ndim, coords):
52 52
53 53 
         return capi.create_point(cs)
54 54
55   
-    def _set_collection(self, length, items):
  55 
+    def _set_list(self, length, items):
56 56 
         ptr = self._create_point(length, items)
57 57 
         if ptr:
58 58 
             capi.destroy_geom(self.ptr)
 
@@ -76,15 +76,15 @@ def __len__(self):
76 76 
         if self.hasz: return 3
77 77 
         else: return 2
78 78
79   
-    def _getitem_external(self, index):
80   
-        self._checkindex(index)
  79 
+    def _get_single_external(self, index):
81 80 
         if index == 0:
82 81 
             return self.x
83 82 
         elif index == 1:
84 83 
             return self.y
85 84 
         elif index == 2:
86 85 
             return self.z
87   
-    _getitem_internal = _getitem_external
  86 
+
  87 
+    _get_single_internal = _get_single_external
88 88
89 89 
     def get_x(self):
90 90 
         "Returns the X component of the Point."
32  django/contrib/gis/geos/polygon.py
View 
@@ -59,9 +59,8 @@ def from_bbox(cls, bbox):
59 59 
         return GEOSGeometry( 'POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' %  (
60 60 
                 x0, y0, x0, y1, x1, y1, x1, y0, x0, y0) )
61 61
62   
-    ### These classmethods and routines are needed for list-like operation w/ListMixin ###
63   
-    @classmethod
64   
-    def _create_polygon(cls, length, items):
  62 
+    ### These routines are needed for list-like operation w/ListMixin ###
  63 
+    def _create_polygon(self, length, items):
65 64 
         # Instantiate LinearRing objects if necessary, but don't clone them yet
66 65 
         # _construct_ring will throw a TypeError if a parameter isn't a valid ring
67 66 
         # If we cloned the pointers here, we wouldn't be able to clean up
 
@@ -71,30 +70,28 @@ def _create_polygon(cls, length, items):
71 70 
             if isinstance(r, GEOM_PTR):
72 71 
                 rings.append(r)
73 72 
             else:
74   
-                rings.append(cls._construct_ring(r))
  73 
+                rings.append(self._construct_ring(r))
75 74
76   
-        shell = cls._clone(rings.pop(0))
  75 
+        shell = self._clone(rings.pop(0))
77 76
78 77 
         n_holes = length - 1
79 78 
         if n_holes:
80 79 
             holes = get_pointer_arr(n_holes)
81 80 
             for i, r in enumerate(rings):
82   
-                holes[i] = cls._clone(r)
  81 
+                holes[i] = self._clone(r)
83 82 
                 holes_param = byref(holes)
84 83 
         else:
85 84 
             holes_param = None
86 85
87 86 
         return capi.create_polygon(shell, holes_param, c_uint(n_holes))
88 87
89   
-    @classmethod
90   
-    def _clone(cls, g):
  88 
+    def _clone(self, g):
91 89 
         if isinstance(g, GEOM_PTR):
92 90 
             return capi.geom_clone(g)
93 91 
         else:
94 92 
             return capi.geom_clone(g.ptr)
95 93
96   
-    @classmethod
97   
-    def _construct_ring(cls, param, msg='Parameter must be a sequence of LinearRings or objects that can initialize to LinearRings'):
  94 
+    def _construct_ring(self, param, msg='Parameter must be a sequence of LinearRings or objects that can initialize to LinearRings'):
98 95 
         "Helper routine for trying to construct a ring from the given parameter."
99 96 
         if isinstance(param, LinearRing): return param
100 97 
         try:
 
@@ -103,7 +100,7 @@ def _construct_ring(cls, param, msg='Parameter must be a sequence of LinearRings
103 100 
         except TypeError:
104 101 
             raise TypeError(msg)
105 102
106   
-    def _set_collection(self, length, items):
  103 
+    def _set_list(self, length, items):
107 104 
         # Getting the current pointer, replacing with the newly constructed
108 105 
         # geometry, and destroying the old geometry.
109 106 
         prev_ptr = self.ptr
 
@@ -112,7 +109,7 @@ def _set_collection(self, length, items):
112 109 
         if srid: self.srid = srid
113 110 
         capi.destroy_geom(prev_ptr)
114 111
115   
-    def _getitem_internal(self, index):
  112 
+    def _get_single_internal(self, index):
116 113 
         """
117 114 
         Returns the ring at the specified index.  The first index, 0, will
118 115 
         always return the exterior ring.  Indices > 0 will return the
 
@@ -120,8 +117,8 @@ def _getitem_internal(self, index):
120 117 
         return the first and second interior ring, respectively).
121 118
122 119 
         CAREFUL: Internal/External are not the same as Interior/Exterior!
123   
-        _getitem_internal returns a pointer from the existing geometries for use
124   
-        internally by the object's methods.  _getitem_external returns a clone
  120 
+        _get_single_internal returns a pointer from the existing geometries for use
  121 
+        internally by the object's methods.  _get_single_external returns a clone
125 122 
         of the same geometry for use by external code.
126 123 
         """
127 124 
         if index == 0:
 
@@ -130,8 +127,11 @@ def _getitem_internal(self, index):
130 127 
             # Getting the interior ring, have to subtract 1 from the index.
131 128 
             return capi.get_intring(self.ptr, index-1)
132 129
133   
-    def _getitem_external(self, index):
134   
-        return GEOSGeometry(capi.geom_clone(self._getitem_internal(index)), srid=self.srid)
  130 
+    def _get_single_external(self, index):
  131 
+        return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid)
  132 
+
  133 
+    _set_single = GEOSGeometry._set_single_rebuild
  134 
+    _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild
135 135
136 136 
     #### Polygon Properties ####
137 137 
     @property
36  django/contrib/gis/geos/tests/test_geos_mutation.py
View 
@@ -45,15 +45,15 @@ def test00_GEOSIndexException(self):
45 45 
     def test01_PointMutations(self):
46 46 
         'Testing Point mutations'
47 47 
         for p in (Point(1,2,3), fromstr('POINT (1 2 3)')):
48   
-            self.assertEqual(p._getitem_external(1), 2.0, 'Point _getitem_external')
  48 
+            self.assertEqual(p._get_single_external(1), 2.0, 'Point _get_single_external')
49 49
50 50 
             # _set_single
51 51 
             p._set_single(0,100)
52 52 
             self.assertEqual(p.coords, (100.0,2.0,3.0), 'Point _set_single')
53 53
54   
-            # _set_collection
55   
-            p._set_collection(2,(50,3141))
56   
-            self.assertEqual(p.coords, (50.0,3141.0), 'Point _set_collection')
  54 
+            # _set_list
  55 
+            p._set_list(2,(50,3141))
  56 
+            self.assertEqual(p.coords, (50.0,3141.0), 'Point _set_list')
57 57
58 58 
     def test02_PointExceptions(self):
59 59 
         'Testing Point exceptions'
 
@@ -72,15 +72,15 @@ def test04_LineStringMutations(self):
72 72 
         'Testing LineString mutations'
73 73 
         for ls in (LineString((1,0),(4,1),(6,-1)),
74 74 
                     fromstr('LINESTRING (1 0,4 1,6 -1)')):
75   
-            self.assertEqual(ls._getitem_external(1), (4.0,1.0), 'LineString _getitem_external')
  75 
+            self.assertEqual(ls._get_single_external(1), (4.0,1.0), 'LineString _get_single_external')
76 76
77 77 
             # _set_single
78 78 
             ls._set_single(0,(-50,25))
79 79 
             self.assertEqual(ls.coords, ((-50.0,25.0),(4.0,1.0),(6.0,-1.0)), 'LineString _set_single')
80 80
81   
-            # _set_collection
82   
-            ls._set_collection(2, ((-50.0,25.0),(6.0,-1.0)))
83   
-            self.assertEqual(ls.coords, ((-50.0,25.0),(6.0,-1.0)), 'LineString _set_collection')
  81 
+            # _set_list
  82 
+            ls._set_list(2, ((-50.0,25.0),(6.0,-1.0)))
  83 
+            self.assertEqual(ls.coords, ((-50.0,25.0),(6.0,-1.0)), 'LineString _set_list')
84 84
85 85 
             lsa = LineString(ls.coords)
86 86 
             for f in geos_function_tests:
 
@@ -91,20 +91,20 @@ def test05_Polygon(self):
91 91 
         for pg in (Polygon(((1,0),(4,1),(6,-1),(8,10),(1,0)),
92 92 
                             ((5,4),(6,4),(6,3),(5,4))),
93 93 
                     fromstr('POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))')):
94   
-            self.assertEqual(pg._getitem_external(0),
  94 
+            self.assertEqual(pg._get_single_external(0),
95 95 
                             LinearRing((1,0),(4,1),(6,-1),(8,10),(1,0)),
96   
-                            'Polygon _getitem_external(0)')
97   
-            self.assertEqual(pg._getitem_external(1),
  96 
+                            'Polygon _get_single_external(0)')
  97 
+            self.assertEqual(pg._get_single_external(1),
98 98 
                             LinearRing((5,4),(6,4),(6,3),(5,4)),
99   
-                            'Polygon _getitem_external(1)')
  99 
+                            'Polygon _get_single_external(1)')
100 100
101   
-            # _set_collection
102   
-            pg._set_collection(2, (((1,2),(10,0),(12,9),(-1,15),(1,2)),
  101 
+            # _set_list
  102 
+            pg._set_list(2, (((1,2),(10,0),(12,9),(-1,15),(1,2)),
103 103 
                             ((4,2),(5,2),(5,3),(4,2))))
104 104 
             self.assertEqual(pg.coords,
105 105 
                     (((1.0,2.0),(10.0,0.0),(12.0,9.0),(-1.0,15.0),(1.0,2.0)),
106 106 
                         ((4.0,2.0),(5.0,2.0),(5.0,3.0),(4.0,2.0))),
107   
-                    'Polygon _set_collection')
  107 
+                    'Polygon _set_list')
108 108
109 109 
             lsa = Polygon(*pg.coords)
110 110 
             for f in geos_function_tests:
 
@@ -114,10 +114,10 @@ def test06_Collection(self):
114 114 
         'Testing Collection mutations'
115 115 
         for mp in (MultiPoint(*map(Point,((3,4),(-1,2),(5,-4),(2,8)))),
116 116 
                     fromstr('MULTIPOINT (3 4,-1 2,5 -4,2 8)')):
117   
-            self.assertEqual(mp._getitem_external(2), Point(5,-4), 'Collection _getitem_external')
  117 
+            self.assertEqual(mp._get_single_external(2), Point(5,-4), 'Collection _get_single_external')
118 118
119   
-            mp._set_collection(3, map(Point,((5,5),(3,-2),(8,1))))
120   
-            self.assertEqual(mp.coords, ((5.0,5.0),(3.0,-2.0),(8.0,1.0)), 'Collection _set_collection')
  119 
+            mp._set_list(3, map(Point,((5,5),(3,-2),(8,1))))
  120 
+            self.assertEqual(mp.coords, ((5.0,5.0),(3.0,-2.0),(8.0,1.0)), 'Collection _set_list')
121 121
122 122 
             lsa = MultiPoint(*map(Point,((5,5),(3,-2),(8,1))))
123 123 
             for f in geos_function_tests:
127  django/contrib/gis/geos/tests/test_mutable_list.py
View
... ... 
@@ -1,4 +1,6 @@
1   
-# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved.
  1 
+# Copyright (c) 2008-2009 Aryeh Leib Taurog, http://www.aryehleib.com
  2 
+# All rights reserved.
  3 
+#
2 4 
 # Modified from original contribution by Aryeh Leib Taurog, which was
3 5 
 # released under the New BSD license.
4 6 
 import unittest
 
@@ -12,13 +14,11 @@ def __init__(self, i_list, *args, **kwargs):
12 14
13 15 
     def __len__(self):  return len(self._list)
14 16
15   
-    def __iter__(self): return iter(self._list)
16   
-
17 17 
     def __str__(self):  return str(self._list)
18 18
19 19 
     def __repr__(self): return repr(self._list)
20 20
21   
-    def _set_collection(self, length, items):
  21 
+    def _set_list(self, length, items):
22 22 
         # this would work:
23 23 
         # self._list = self._mytype(items)
24 24 
         # but then we wouldn't be testing length parameter
 
@@ -28,13 +28,9 @@ def _set_collection(self, length, items):
28 28
29 29 
         self._list = self._mytype(itemList)
30 30
31   
-    def _getitem_external(self, index):
  31 
+    def _get_single_external(self, index):
32 32 
         return self._list[index]
33 33
34   
-    _getitem_internal = _getitem_external
35   
-    _set_single = ListMixin._set_single_rebuild
36   
-    _assign_extended_slice = ListMixin._assign_extended_slice_rebuild
37   
-
38 34 
 class UserListB(UserListA):
39 35 
     _mytype = list
40 36 
 
@@ -55,22 +51,19 @@ class ListMixinTest(unittest.TestCase):
55 51 
     limit = 3
56 52 
     listType = UserListA
57 53
58   
-    @classmethod
59   
-    def lists_of_len(cls, length=None):
60   
-        if length is None: length = cls.limit
  54 
+    def lists_of_len(self, length=None):
  55 
+        if length is None: length = self.limit
61 56 
         pl = range(length)
62   
-        return pl, cls.listType(pl)
  57 
+        return pl, self.listType(pl)
63 58
64   
-    @classmethod
65   
-    def limits_plus(cls, b):
66   
-        return range(-cls.limit - b, cls.limit + b)
  59 
+    def limits_plus(self, b):
  60 
+        return range(-self.limit - b, self.limit + b)
67 61
68   
-    @classmethod
69   
-    def step_range(cls):
70   
-        return range(-1 - cls.limit, 0) + range(1, 1 + cls.limit)
  62 
+    def step_range(self):
  63 
+        return range(-1 - self.limit, 0) + range(1, 1 + self.limit)
71 64
72 65 
     def test01_getslice(self):
73   
-        'Testing slice retrieval'
  66 
+        'Slice retrieval'
74 67 
         pl, ul = self.lists_of_len()
75 68 
         for i in self.limits_plus(1):
76 69 
             self.assertEqual(pl[i:], ul[i:], 'slice [%d:]' % (i))
 
@@ -89,7 +82,7 @@ def test01_getslice(self):
89 82 
             self.assertEqual(pl[::k], ul[::k], 'slice [::%d]' % (k))
90 83
91 84 
     def test02_setslice(self):
92   
-        'Testing slice assignment'
  85 
+        'Slice assignment'
93 86 
         def setfcn(x,i,j,k,L): x[i:j:k] = range(L)
94 87 
         pl, ul = self.lists_of_len()
95 88 
         for slen in range(self.limit + 1):
 
@@ -145,7 +138,7 @@ def setfcn(x,i,j,k,L): x[i:j:k] = range(L)
145 138
146 139
147 140 
     def test03_delslice(self):
148   
-        'Testing delete slice'
  141 
+        'Delete slice'
149 142 
         for Len in range(self.limit):
150 143 
             pl, ul = self.lists_of_len(Len)
151 144 
             del pl[:]
 
@@ -189,7 +182,7 @@ def test03_delslice(self):
189 182 
                 self.assertEqual(pl[:], ul[:], 'del slice [::%d]' % (k))
190 183
191 184 
     def test04_get_set_del_single(self):
192   
-        'Testing get/set/delete single item'
  185 
+        'Get/set/delete single item'
193 186 
         pl, ul = self.lists_of_len()
194 187 
         for i in self.limits_plus(0):
195 188 
             self.assertEqual(pl[i], ul[i], 'get single item [%d]' % i)
 
@@ -207,7 +200,7 @@ def test04_get_set_del_single(self):
207 200 
             self.assertEqual(pl[:], ul[:], 'del single item [%d]' % i)
208 201
209 202 
     def test05_out_of_range_exceptions(self):
210   
-        'Testing out of range exceptions'
  203 
+        'Out of range exceptions'
211 204 
         def setfcn(x, i): x[i] = 20
212 205 
         def getfcn(x, i): return x[i]
213 206 
         def delfcn(x, i): del x[i]
 
@@ -218,7 +211,7 @@ def delfcn(x, i): del x[i]
218 211 
             self.assertRaises(IndexError, delfcn, ul, i) # 'del index %d' % i)
219 212
220 213 
     def test06_list_methods(self):
221   
-        'Testing list methods'
  214 
+        'List methods'
222 215 
         pl, ul = self.lists_of_len()
223 216 
         pl.append(40)
224 217 
         ul.append(40)
 
@@ -228,6 +221,10 @@ def test06_list_methods(self):
228 221 
         ul.extend(range(50,55))
229 222 
         self.assertEqual(pl[:], ul[:], 'extend')
230 223
  224 
+        pl.reverse()
  225 
+        ul.reverse()
  226 
+        self.assertEqual(pl[:], ul[:], 'reverse')
  227 
+
231 228 
         for i in self.limits_plus(1):
232 229 
             pl, ul = self.lists_of_len()
233 230 
             pl.insert(i,50)
 
@@ -267,7 +264,7 @@ def removefcn(x, v): return x.remove(v)
267 264 
         self.assertRaises(ValueError, removefcn, ul, 40)
268 265
269 266 
     def test07_allowed_types(self):
270   
-        'Testing type-restricted list'
  267 
+        'Type-restricted list'
271 268 
         pl, ul = self.lists_of_len()
272 269 
         ul._allowed = (int, long)
273 270 
         ul[1] = 50
 
@@ -277,7 +274,7 @@ def setfcn(x, i, v): x[i] = v
277 274 
         self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), ('hello','goodbye'))
278 275
279 276 
     def test08_min_length(self):
280   
-        'Testing length limits'
  277 
+        'Length limits'
281 278 
         pl, ul = self.lists_of_len()
282 279 
         ul._minlength = 1
283 280 
         def delfcn(x,i): del x[:i]
 
@@ -293,13 +290,13 @@ def setfcn(x,i): x[:i] = []
293 290 
         self.assertRaises(ValueError, ul.append, 10)
294 291
295 292 
     def test09_iterable_check(self):
296   
-        'Testing error on assigning non-iterable to slice'
  293 
+        'Error on assigning non-iterable to slice'
297 294 
         pl, ul = self.lists_of_len(self.limit + 1)
298 295 
         def setfcn(x, i, v): x[i] = v
299 296 
         self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), 2)
300 297
301 298 
     def test10_checkindex(self):
302   
-        'Testing index check'
  299 
+        'Index check'
303 300 
         pl, ul = self.lists_of_len()
304 301 
         for i in self.limits_plus(0):
305 302 
             if i < 0:
 
@@ -313,6 +310,78 @@ def test10_checkindex(self):
313 310 
         ul._IndexError = TypeError
314 311 
         self.assertRaises(TypeError, ul._checkindex, -self.limit - 1)
315 312
  313 
+    def test_11_sorting(self):
  314 
+        'Sorting'
  315 
+        pl, ul = self.lists_of_len()
  316 
+        pl.insert(0, pl.pop())
  317 
+        ul.insert(0, ul.pop())
  318 
+        pl.sort()
  319 
+        ul.sort()
  320 
+        self.assertEqual(pl[:], ul[:], 'sort')
  321 
+        mid = pl[len(pl) / 2]
  322 
+        pl.sort(key=lambda x: (mid-x)**2)
  323 
+        ul.sort(key=lambda x: (mid-x)**2)
  324 
+        self.assertEqual(pl[:], ul[:], 'sort w/ key')
  325 
+
  326 
+        pl.insert(0, pl.pop())
  327 
+        ul.insert(0, ul.pop())
  328 
+        pl.sort(reverse=True)
  329 
+        ul.sort(reverse=True)
  330 
+        self.assertEqual(pl[:], ul[:], 'sort w/ reverse')
  331 
+        mid = pl[len(pl) / 2]
  332 
+        pl.sort(key=lambda x: (mid-x)**2)
  333 
+        ul.sort(key=lambda x: (mid-x)**2)
  334 
+        self.assertEqual(pl[:], ul[:], 'sort w/ key')
  335 
+
  336 
+    def test_12_arithmetic(self):
  337 
+        'Arithmetic'
  338 
+        pl, ul = self.lists_of_len()
  339 
+        al = range(10,14)
  340 
+        self.assertEqual(list(pl + al), list(ul + al), 'add')
  341 
+        self.assertEqual(type(ul), type(ul + al), 'type of add result')
  342 
+        self.assertEqual(list(al + pl), list(al + ul), 'radd')
  343 
+        self.assertEqual(type(al), type(al + ul), 'type of radd result')
  344 
+        objid = id(ul)
  345 
+        pl += al
  346 
+        ul += al
  347 
+        self.assertEqual(pl[:], ul[:], 'in-place add')
  348 
+        self.assertEqual(objid, id(ul), 'in-place add id')
  349 
+
  350 
+        for n in (-1,0,1,3):
  351 
+            pl, ul = self.lists_of_len()
  352 
+            self.assertEqual(list(pl * n), list(ul * n), 'mul by %d' % n)
  353 
+            self.assertEqual(type(ul), type(ul * n), 'type of mul by %d result' % n)
  354 
+            self.assertEqual(list(n * pl), list(n * ul), 'rmul by %d' % n)
  355 
+            self.assertEqual(type(ul), type(n * ul), 'type of rmul by %d result' % n)
  356 
+            objid = id(ul)
  357 
+            pl *= n
  358 
+            ul *= n
  359 
+            self.assertEqual(pl[:], ul[:], 'in-place mul by %d' % n)
  360 
+            self.assertEqual(objid, id(ul), 'in-place mul by %d id' % n)
  361 
+
  362 
+        pl, ul = self.lists_of_len()
  363 
+        self.assertEqual(pl, ul, 'cmp for equal')
  364 
+        self.assert_(pl >= ul, 'cmp for gte self')
  365 
+        self.assert_(pl <= ul, 'cmp for lte self')
  366 
+        self.assert_(ul >= pl, 'cmp for self gte')
  367 
+        self.assert_(ul <= pl, 'cmp for self lte')
  368 
+
  369 
+        self.assert_(pl + [5] > ul, 'cmp')
  370 
+        self.assert_(pl + [5] >= ul, 'cmp')
  371 
+        self.assert_(pl < ul + [2], 'cmp')
  372 
+        self.assert_(pl <= ul + [2], 'cmp')
  373 
+        self.assert_(ul + [5] > pl, 'cmp')
  374 
+        self.assert_(ul + [5] >= pl, 'cmp')
  375 
+        self.assert_(ul < pl + [2], 'cmp')
  376 
+        self.assert_(ul <= pl + [2], 'cmp')
  377 
+
  378 
+        pl[1] = 20
  379 
+        self.assert_(pl > ul, 'cmp for gt self')
  380 
+        self.assert_(ul < pl, 'cmp for self lt')
  381 
+        pl[1] = -20
  382 
+        self.assert_(pl < ul, 'cmp for lt self')
  383 
+        self.assert_(pl < ul, 'cmp for lt self')
  384 
+
316 385 
 class ListMixinTestSingle(ListMixinTest):
317 386 
     listType = UserListB
318 387

0 notes on commit 5e58810

Please sign in to comment.
Something went wrong with that request. Please try again.