shapely 1.2.14__py2.7-win-amd64.egg → 1.2.18__py2.7-win-amd64.egg

shapely/tests/test_affinity.py

@@ -0,0 +1,239 @@
+import unittest
+from math import pi
+from shapely import affinity
+from shapely.wkt import loads as load_wkt
+from shapely.geometry import Point
+
+class AffineTestCase(unittest.TestCase):
+
+    def test_affine_params(self):
+        g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        self.assertRaises(
+            TypeError, affinity.affine_transform, g, None)
+        self.assertRaises(
+            TypeError, affinity.affine_transform, g, '123456')
+        self.assertRaises(ValueError, 
+            affinity.affine_transform, g, [1,2,3,4,5,6,7,8,9])
+        self.assertRaises(AttributeError, 
+            affinity.affine_transform, None, [1,2,3,4,5,6])
+
+    def test_affine_geom_types(self):
+        matrix2d = (1, 0,
+                    0, 1,
+                    0, 0)
+        matrix3d = (1, 0, 0,
+                    0, 1, 0,
+                    0, 0, 1,
+                    0, 0, 0)
+        def test_geom(g2, g3=None):
+            self.assertFalse(g2.has_z)
+            a2 = affinity.affine_transform(g2, matrix2d)
+            self.assertFalse(a2.has_z)
+            self.assertTrue(g2.equals(a2))
+            if g3 is not None:
+                self.assertTrue(g3.has_z)
+                a3 = affinity.affine_transform(g3, matrix3d)
+                self.assertTrue(a3.has_z)
+                self.assertTrue(g3.equals(a3))
+            return
+        pt2d = load_wkt('POINT(12.3 45.6)')
+        pt3d = load_wkt('POINT(12.3 45.6 7.89)')
+        test_geom(pt2d, pt3d)
+        ls2d = load_wkt('LINESTRING(0.9 3.4, 0.7 2, 2.5 2.7)')
+        ls3d = load_wkt('LINESTRING(0.9 3.4 3.3, 0.7 2 2.3, 2.5 2.7 5.5)')
+        test_geom(ls2d, ls3d)
+        test_geom(load_wkt('POLYGON((0.9 2.3, 0.5 1.1, 2.4 0.8, 0.9 2.3), '\
+                           '(1.1 1.7, 0.9 1.3, 1.4 1.2, 1.1 1.7), '\
+                           '(1.6 1.3, 1.7 1, 1.9 1.1, 1.6 1.3))'))
+        test_geom(load_wkt('MULTIPOINT ((-300 300), (700 300), '\
+                           '(-800 -1100), (200 -300))'))
+        test_geom(load_wkt('MULTILINESTRING((0 0, -0.7 -0.7, 0.6 -1), '\
+                           '(-0.5 0.5, 0.7 0.6, 0 -0.6))'))
+        test_geom(load_wkt('MULTIPOLYGON(((900 4300, -1100 -400, '\
+                           '900 -800, 900 4300)), '\
+                           '((1200 4300, 2300 4400, 1900 1000, 1200 4300)))'))
+        # GeometryCollection fails, since it does not have a good constructor
+        gc = load_wkt('GEOMETRYCOLLECTION(POINT(20 70),'\
+                      ' POLYGON((60 70, 13 35, 60 -30, 60 70)),'\
+                      ' LINESTRING(60 70, 50 100, 80 100))')
+        self.assertRaises(TypeError, test_geom, gc) # TODO: fix this
+
+    def test_affine_2d(self):
+        g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        # custom scale and translate
+        expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
+        matrix2d = (2, 0,
+                    0, 2.5,
+                    -5, 4.1)
+        a2 = affinity.affine_transform(g, matrix2d)
+        self.assertTrue(a2.almost_equals(expected2d))
+        self.assertFalse(a2.has_z)
+        # Make sure a 3D matrix does not make a 3D shape from a 2D input
+        matrix3d = (2, 0, 0,
+                    0, 2.5, 0,
+                    0, 0, 10,
+                    -5, 4.1, 100)
+        a3 = affinity.affine_transform(g, matrix3d)
+        self.assertTrue(a3.almost_equals(expected2d))
+        self.assertFalse(a3.has_z)
+
+    def test_affine_3d(self):
+        g2 = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
+        g3 = load_wkt('LINESTRING(2.4 4.1 100.2, 2.4 3 132.8, 3 3 128.6)')
+        # custom scale and translate
+        matrix2d = (2, 0,
+                    0, 2.5,
+                    -5, 4.1)
+        matrix3d = (2, 0, 0,
+                    0, 2.5, 0,
+                    0, 0, 0.3048,
+                    -5, 4.1, 100)
+        # Combinations of 2D and 3D geometries and matrices
+        a22 = affinity.affine_transform(g2, matrix2d)
+        a23 = affinity.affine_transform(g2, matrix3d)
+        a32 = affinity.affine_transform(g3, matrix2d)
+        a33 = affinity.affine_transform(g3, matrix3d)
+        # Check dimensions
+        self.assertFalse(a22.has_z)
+        self.assertFalse(a23.has_z)
+        self.assertTrue(a32.has_z)
+        self.assertTrue(a33.has_z)
+        # 2D equality checks
+        expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
+        expected3d = load_wkt('LINESTRING(-0.2 14.35 130.54096, '\
+                              '-0.2 11.6 140.47744, 1 11.6 139.19728)')
+        expected32 = load_wkt('LINESTRING(-0.2 14.35 100.2, '\
+                              '-0.2 11.6 132.8, 1 11.6 128.6)')
+        self.assertTrue(a22.almost_equals(expected2d))
+        self.assertTrue(a23.almost_equals(expected2d))
+        # Do explicit 3D check of coordinate values
+        for a, e in zip(a32.coords, expected32.coords):
+            for ap, ep in zip(a, e):
+                self.assertAlmostEqual(ap, ep)
+        for a, e in zip(a33.coords, expected3d.coords):
+            for ap, ep in zip(a, e):
+                self.assertAlmostEqual(ap, ep)
+
+class TransformOpsTestCase(unittest.TestCase):
+
+    def test_rotate(self):
+        ls = load_wkt('LINESTRING(240 400, 240 300, 300 300)')
+        # counter-clockwise degrees
+        rls = affinity.rotate(ls, 90)
+        els = load_wkt('LINESTRING(220 320, 320 320, 320 380)')
+        self.assertTrue(rls.equals(els))
+        # retest with named parameters for the same result
+        rls = affinity.rotate(geom=ls, angle=90, origin='center')
+        self.assertTrue(rls.equals(els))
+        # clockwise radians
+        rls = affinity.rotate(ls, -pi/2, use_radians=True)
+        els = load_wkt('LINESTRING(320 380, 220 380, 220 320)')
+        self.assertTrue(rls.equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        rls = affinity.rotate(ls, 90, origin='centroid')
+        els = load_wkt('LINESTRING(182.5 320, 282.5 320, 282.5 380)')
+        self.assertTrue(rls.equals(els))
+        # around the second coordinate tuple
+        rls = affinity.rotate(ls, 90, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(140 300, 240 300, 240 360)')
+        self.assertTrue(rls.equals(els))
+        # around the absolute Point of origin
+        rls = affinity.rotate(ls, 90, origin=Point(0,0))
+        els = load_wkt('LINESTRING(-400 240, -300 240, -300 300)')
+        self.assertTrue(rls.equals(els))
+
+    def test_scale(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test defaults of 1.0
+        sls = affinity.scale(ls)
+        self.assertTrue(sls.equals(ls))
+        # different scaling in different dimensions
+        sls = affinity.scale(ls, 2, 3, 0.5)
+        els = load_wkt('LINESTRING(210 500 5, 210 200 15, 330 200 10)')
+        self.assertTrue(sls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(sls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+        # retest with named parameters for the same result
+        sls = affinity.scale(geom=ls, xfact=2, yfact=3, zfact=0.5,
+                              origin='center')
+        self.assertTrue(sls.equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        sls = affinity.scale(ls, 2, 3, 0.5, origin='centroid')
+        els = load_wkt('LINESTRING(228.75 537.5, 228.75 237.5, 348.75 237.5)')
+        self.assertTrue(sls.equals(els))
+        # around the second coordinate tuple
+        sls = affinity.scale(ls, 2, 3, 0.5, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(240 600, 240 300, 360 300)')
+        self.assertTrue(sls.equals(els))
+        # around some other 3D Point of origin
+        sls = affinity.scale(ls, 2, 3, 0.5, origin=Point(100, 200, 1000))
+        els = load_wkt('LINESTRING(380 800 505, 380 500 515, 500 500 510)')
+        self.assertTrue(sls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(sls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+
+    def test_skew(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test default shear angles of 0.0
+        sls = affinity.skew(ls)
+        self.assertTrue(sls.equals(ls))
+        # different shearing in x- and y-directions
+        sls = affinity.skew(ls, 15, -30)
+        els = load_wkt('LINESTRING (253.39745962155615 417.3205080756888, '\
+                       '226.60254037844385 317.3205080756888, '\
+                       '286.60254037844385 282.67949192431126)')
+        self.assertTrue(sls.almost_equals(els))
+        # retest with radians for the same result
+        sls = affinity.skew(ls, pi/12, -pi/6, use_radians=True)
+        self.assertTrue(sls.almost_equals(els))
+        # retest with named parameters for the same result
+        sls = affinity.skew(geom=ls, xs=15, ys=-30,
+                             origin='center', use_radians=False)
+        self.assertTrue(sls.almost_equals(els))
+        ## other `origin` parameters
+        # around the centroid
+        sls = affinity.skew(ls, 15, -30, origin='centroid')
+        els = load_wkt('LINESTRING(258.42150697963973 406.49519052838332, '\
+                       '231.6265877365273980 306.4951905283833185, '\
+                       '291.6265877365274264 271.8541743770057337)')
+        self.assertTrue(sls.almost_equals(els))
+        # around the second coordinate tuple
+        sls = affinity.skew(ls, 15, -30, origin=ls.coords[1])
+        els = load_wkt('LINESTRING(266.7949192431123038 400, 240 300, '\
+                       '300 265.3589838486224153)')
+        self.assertTrue(sls.almost_equals(els))
+        # around the absolute Point of origin
+        sls = affinity.skew(ls, 15, -30, origin=Point(0,0))
+        els = load_wkt('LINESTRING(347.179676972449101 261.435935394489832, '\
+                       '320.3847577293367976 161.4359353944898317, '\
+                       '380.3847577293367976 126.7949192431122754)')
+        self.assertTrue(sls.almost_equals(els))
+
+    def test_translate(self):
+        ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
+        # test default offset of 0.0
+        tls = affinity.translate(ls)
+        self.assertTrue(tls.equals(ls))
+        # test all offsets
+        tls = affinity.translate(ls, 100, 400, -10)
+        els = load_wkt('LINESTRING(340 800 0, 340 700 20, 400 700 10)')
+        self.assertTrue(tls.equals(els))
+        # Do explicit 3D check of coordinate values
+        for a, b in zip(tls.coords, els.coords):
+            for ap, bp in zip(a, b):
+                self.assertEqual(ap, bp)
+        # retest with named parameters for the same result
+        tls = affinity.translate(geom=ls, xoff=100, yoff=400, zoff=-10)
+        self.assertTrue(tls.equals(els))
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(AffineTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(TransformOpsTestCase)])

shapely/tests/test_collection.py

@@ -1,4 +1,5 @@
 import unittest
+from shapely.geometry import LineString
 from shapely.geometry.collection import GeometryCollection
 
 class CollectionTestCase(unittest.TestCase):
@@ -7,5 +8,19 @@ class CollectionTestCase(unittest.TestCase):
         self.failUnlessEqual(len(m), 0)
         self.failUnlessEqual(m.geoms, [])
 
+    def test_child_with_deleted_parent(self):
+        # test that we can remove a collection while having
+        # childs around
+        a = LineString([(0, 0), (1, 1), (1,2), (2,2)])
+        b = LineString([(0, 0), (1, 1), (2,1), (2,2)])
+        collection = a.intersection(b)
+
+        child = collection.geoms[0]
+        # delete parent of child
+        del collection
+
+        # access geometry, this should not seg fault as 1.2.15 did
+        child.to_wkt()
+
 def test_suite():
     return unittest.TestLoader().loadTestsFromTestCase(CollectionTestCase)

shapely/tests/test_dlls.py

@@ -6,7 +6,7 @@ class LoadingTestCase(unittest.TestCase):
     def test_load(self):
         self.assertRaises(OSError, load_dll, 'geosh_c')
     def test_fallbacks(self):
-        a = load_dll('geosh_c', fallbacks=[
+        a = load_dll('geos_c', fallbacks=[
             '/opt/local/lib/libgeos_c.dylib', # MacPorts
             '/usr/local/lib/libgeos_c.dylib', # homebrew (Mac OS X)
             'libgeos_c.so.1',

shapely/tests/test_emptiness.py

@@ -1,19 +1,52 @@
 import unittest
 from shapely.geometry.base import BaseGeometry
-from shapely.geometry import Point
+import shapely.geometry as sgeom
+from shapely.geometry.polygon import LinearRing
+
 
 class EmptinessTestCase(unittest.TestCase):
     def test_empty_base(self):
         g = BaseGeometry()
-        self.failUnless(g._is_empty, True)
-    def test_empty_point(self):
-        p = Point()
-        self.failUnless(p._is_empty, True)
+        self.assertTrue(g._is_empty)
+
     def test_emptying_point(self):
-        p = Point(0, 0)
-        self.failIf(p._is_empty, False)
+        p = sgeom.Point(0, 0)
+        self.assertFalse(p._is_empty)
         p.empty()
-        self.failUnless(p._is_empty, True)
+        self.assertTrue(p._is_empty)
+
+    def test_none_geom(self):
+        p = BaseGeometry()
+        p._geom = None
+        self.assertTrue(p.is_empty)
+
+    def test_empty_point(self):
+        self.assertTrue(sgeom.Point().is_empty)
+        
+    def test_empty_multipoint(self):
+        self.assertTrue(sgeom.MultiPoint().is_empty)
+
+    def test_empty_geometry_collection(self):
+        self.assertTrue(sgeom.GeometryCollection().is_empty)
+
+    def test_empty_linestring(self):
+        self.assertTrue(sgeom.LineString().is_empty)
+
+    def test_empty_multilinestring(self):
+        self.assertTrue(sgeom.MultiLineString([]).is_empty)
+
+    def test_empty_polygon(self):
+        self.assertTrue(sgeom.Polygon().is_empty)
+
+    def test_empty_multipolygon(self):
+        self.assertTrue(sgeom.MultiPolygon([]).is_empty)
+
+    def test_empty_linear_ring(self):
+        self.assertTrue(LinearRing().is_empty)
+
 
 def test_suite():
     return unittest.TestLoader().loadTestsFromTestCase(EmptinessTestCase)
+
+if __name__ == '__main__':
+    unittest.main()

shapely/tests/test_ndarrays.py

@@ -0,0 +1,35 @@
+# Tests of support for Numpy ndarrays. See
+# https://github.com/sgillies/shapely/issues/26 for discussion.
+# Requires numpy.
+
+import unittest
+from shapely import geometry
+import numpy
+
+class TransposeTestCase(unittest.TestCase):
+    def test_multipoint(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asMultiPoint(t)
+        coords = reduce(lambda x, y: x + y, [list(g.coords) for g in s])
+        self.failUnlessEqual(
+            coords,
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+    def test_linestring(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asLineString(t)
+        self.failUnlessEqual(
+            list(s.coords),
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+    def test_polygon(self):
+        a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
+        t = a.T
+        s = geometry.asPolygon(t)
+        self.failUnlessEqual(
+            list(s.exterior.coords),
+            [(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TransposeTestCase)
+

shapely/tests/test_pickle.py

@@ -0,0 +1,15 @@
+from cPickle import dumps, loads, HIGHEST_PROTOCOL
+import unittest
+from shapely import geometry
+
+class TwoDeeTestCase(unittest.TestCase):
+    """."""
+    def test_linestring(self):
+        l = geometry.LineString(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)))
+        self.failUnlessEqual(l._ndim, 2)
+        s = dumps(l, HIGHEST_PROTOCOL)
+        t = loads(s)
+        self.failUnlessEqual(t._ndim, 2)
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TwoDeeTestCase)

shapely/tests/test_styles.py

@@ -0,0 +1,17 @@
+import unittest
+from shapely.geometry import CAP_STYLE, JOIN_STYLE
+
+class StylesTest(unittest.TestCase):
+    def test_cap(self):
+        self.assertEqual(CAP_STYLE.round, 1)
+        self.assertEqual(CAP_STYLE.flat, 2)
+        self.assertEqual(CAP_STYLE.square, 3)
+    def test_join(self):
+        self.assertEqual(JOIN_STYLE.round, 1)
+        self.assertEqual(JOIN_STYLE.mitre, 2)
+        self.assertEqual(JOIN_STYLE.bevel, 3)
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(StylesTest)])

shapely/tests/test_transform.py

@@ -0,0 +1,61 @@
+import unittest
+from shapely import geometry
+from shapely.ops import transform
+
+class IdentityTestCase(unittest.TestCase):
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+    def func(self, x, y, z=None):
+        return tuple(filter(None, [x, y, z]))
+    def test_point(self):
+        g = geometry.Point(0, 1)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'Point')
+        self.failUnlessEqual(list(h.coords), [(0, 1)])
+    def test_line(self):
+        g = geometry.LineString(((0, 1), (2, 3)))
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'LineString')
+        self.failUnlessEqual(list(h.coords), [(0, 1), (2, 3)])
+    def test_polygon(self):
+        g = geometry.Point(0, 1).buffer(1.0)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'Polygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+    def test_multipolygon(self):
+        g = geometry.MultiPoint([(0, 1), (0, 4)]).buffer(1.0)
+        h = transform(self.func, g)
+        self.failUnlessEqual(h.geom_type, 'MultiPolygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+
+class LambdaTestCase(unittest.TestCase):
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+    def test_point(self):
+        g = geometry.Point(0, 1)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'Point')
+        self.failUnlessEqual(list(h.coords), [(1.0, 2.0)])
+    def test_line(self):
+        g = geometry.LineString(((0, 1), (2, 3)))
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'LineString')
+        self.failUnlessEqual(list(h.coords), [(1.0, 2.0), (3.0, 4.0)])
+    def test_polygon(self):
+        g = geometry.Point(0, 1).buffer(1.0)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'Polygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+        self.failUnlessAlmostEqual(h.centroid.x, 1.0)
+        self.failUnlessAlmostEqual(h.centroid.y, 2.0)
+    def test_multipolygon(self):
+        g = geometry.MultiPoint([(0, 1), (0, 4)]).buffer(1.0)
+        h = transform(lambda x, y, z=None: (x+1.0, y+1.0), g)
+        self.failUnlessEqual(h.geom_type, 'MultiPolygon')
+        self.failUnlessAlmostEqual(g.area, h.area)
+        self.failUnlessAlmostEqual(h.centroid.x, 1.0)
+        self.failUnlessAlmostEqual(h.centroid.y, 3.5)
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        unittest.TestLoader().loadTestsFromTestCase(IdentityTestCase),
+        unittest.TestLoader().loadTestsFromTestCase(LambdaTestCase)])

shapely/tests/test_unary_union.py

@@ -0,0 +1,40 @@
+from itertools import islice
+import unittest
+from shapely.geometry import Point
+from shapely.ops import unary_union
+
+def halton(base):
+    """Returns an iterator over an infinite Halton sequence"""
+    def value(index):
+        result = 0.0
+        f = 1.0/base
+        i = index
+        while i > 0:
+            result += f * (i % base)
+            i = i/base
+            f = f/base
+        return result
+    i = 1
+    while i > 0:
+        yield value(i)
+        i += 1
+
+class UnionTestCase(unittest.TestCase):
+    def test_1(self):
+        # Instead of random points, use deterministic, pseudo-random Halton
+        # sequences for repeatability sake.
+        coords = zip(
+            list(islice(halton(5), 20, 120)),
+            list(islice(halton(7), 20, 120)) )
+        patches = [Point(xy).buffer(0.05) for xy in coords]
+        u = unary_union(patches)
+        self.failUnlessEqual(u.geom_type, 'MultiPolygon')
+        self.failUnlessAlmostEqual(u.area, 0.71857254056)
+
+def test_suite():
+    try:
+        patches = [Point((0, 0)).buffer(0.05)]
+        unary_union(patches)
+    except KeyError:
+        return lambda x: None
+    return unittest.TestLoader().loadTestsFromTestCase(UnionTestCase)

shapely/tests/wkt_locale.txt

@@ -0,0 +1,28 @@
+Test locale independence of WKT
+===============================
+
+Set locale to one that uses a comma as decimal seperator`
+
+  >>> import locale, sys
+  >>> if sys.platform == 'win32':
+  ...     _ = locale.setlocale(locale.LC_ALL, 'portuguese_brazil')
+  ... else:
+  ...     _ = locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
+
+Test reading and writing`
+
+  >>> from shapely.wkt import loads
+  >>> p = loads('POINT (0.0 0.0)')
+  >>> p.x == 0.0
+  True
+  >>> p.y == 0.0
+  True
+  >>> p.wkt
+  'POINT (0.0...)'
+  >>> from shapely.wkt import dumps
+  >>> dumps(p)
+  'POINT (0.0...)'
+
+Reset locale
+
+  >>> _ = locale.setlocale(locale.LC_ALL, '')

shapely/wkb.py

@@ -1,24 +1,13 @@
 """Load/dump geometries using the well-known binary (WKB) format
 """
 
-from ctypes import pointer, c_size_t, c_char_p, c_void_p
-
-from shapely.geos import lgeos, ReadingError
-
+from shapely.geometry.base import geom_from_wkb, geom_to_wkb
 
 # Pickle-like convenience functions
 
-def deserialize(data):
-    geom = lgeos.GEOSGeomFromWKB_buf(c_char_p(data), c_size_t(len(data)));
-    if not geom:
-        raise ReadingError(
-            "Could not create geometry because of errors while reading input.")
-    return geom
-
 def loads(data):
     """Load a geometry from a WKB string."""
-    from shapely.geometry.base import geom_factory
-    return geom_factory(deserialize(data))
+    return geom_from_wkb(data)
 
 def load(fp):
     """Load a geometry from an open file."""
@@ -27,10 +16,7 @@ def load(fp):
 
 def dumps(ob):
     """Dump a WKB representation of a geometry to a byte string."""
-    if ob is None or ob._geom is None:
-        raise ValueError("Null geometry supports no operations")
-    size = c_size_t()
-    return lgeos.GEOSGeomToWKB_buf(c_void_p(ob._geom), pointer(size))
+    return geom_to_wkb(ob)
 
 def dump(ob, fp):
     """Dump a geometry to an open file."""