GeoAlchemy2 0.6.2__tar.gz → 0.6.3__tar.gz

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/CHANGES.txt

@@ -1,6 +1,16 @@
 GeoAlchemy 2 Changelog
 ======================
 
+0.6.3
+-----
+
+* Add some missing functions @adrien-berchet (#224)
+* Do not register functions.GenericFunction for sqlalchemy>=1.3.4 @adrien-berchet (#226)
+* Redefine the geometry_type/dimension consistency checks @elemoine (#228)
+* Correct a spelling mistake @EdwardBetts (#229)
+* Do not assume the "public" schema @elemoine (#231)
+* Add all geometry constructors @adrien-berchet (#232)
+
 0.6.2
 -----
 

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3/GeoAlchemy2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: GeoAlchemy2
-Version: 0.6.2
+Version: 0.6.3
 Summary: Using SQLAlchemy with Spatial Databases
 Home-page: http://geoalchemy.org/
 Author: Eric Lemoine

{GeoAlchemy2-0.6.2/GeoAlchemy2.egg-info → GeoAlchemy2-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: GeoAlchemy2
-Version: 0.6.2
+Version: 0.6.3
 Summary: Using SQLAlchemy with Spatial Databases
 Home-page: http://geoalchemy.org/
 Author: Eric Lemoine

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/geoalchemy2/__init__.py

@@ -59,7 +59,6 @@ def _setup_ddl_event_listeners():
 
             if event == 'before-drop':
                 # Drop the managed Geometry columns
-                table_schema = table.schema or 'public'
                 for c in gis_cols:
                     if bind.dialect.name == 'sqlite':
                         drop_func = 'DiscardGeometryColumn'
@@ -78,7 +77,6 @@ def _setup_ddl_event_listeners():
             # Restore original column list including managed Geometry columns
             table.columns = table.info.pop('_saved_columns')
 
-            table_schema = table.schema or 'public'
             for c in table.c:
                 # Add the managed Geometry columns with AddGeometryColumn()
                 if isinstance(c.type, Geometry) and c.type.management is True:
@@ -105,10 +103,15 @@ def _setup_ddl_event_listeners():
                         stmt = stmt.execution_options(autocommit=True)
                         bind.execute(stmt)
                     elif bind.dialect.name == 'postgresql':
-                        bind.execute('CREATE INDEX "idx_%s_%s" ON "%s"."%s" '
-                                     'USING GIST ("%s")' %
-                                     (table.name, c.name, table_schema,
-                                      table.name, c.name))
+                        if table.schema:
+                            bind.execute('CREATE INDEX "idx_%s_%s" ON "%s"."%s" '
+                                         'USING GIST ("%s")' %
+                                         (table.name, c.name, table.schema,
+                                          table.name, c.name))
+                        else:
+                            bind.execute('CREATE INDEX "idx_%s_%s" ON "%s" '
+                                         'USING GIST ("%s")' %
+                                         (table.name, c.name, table.name, c.name))
                     else:
                         raise ArgumentError('dialect {} is not supported'.format(bind.dialect.name))
 
@@ -117,10 +120,15 @@ def _setup_ddl_event_listeners():
                 # Note the use of ST_ConvexHull since most raster operators are
                 # based on the convex hull of the rasters.
                 if isinstance(c.type, Raster) and c.type.spatial_index is True:
-                    bind.execute('CREATE INDEX "idx_%s_%s" ON "%s"."%s" '
-                                 'USING GIST (ST_ConvexHull("%s"))' %
-                                 (table.name, c.name, table_schema,
-                                  table.name, c.name))
+                    if table.schema:
+                        bind.execute('CREATE INDEX "idx_%s_%s" ON "%s"."%s" '
+                                     'USING GIST (ST_ConvexHull("%s"))' %
+                                     (table.name, c.name, table.schema,
+                                      table.name, c.name))
+                    else:
+                        bind.execute('CREATE INDEX "idx_%s_%s" ON "%s" '
+                                     'USING GIST (ST_ConvexHull("%s"))' %
+                                     (table.name, c.name, table.name, c.name))
 
         elif event == 'after-drop':
             # Restore original column list including managed Geometry columns

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/geoalchemy2/comparator.py

@@ -86,7 +86,7 @@ class BaseComparator(UserDefinedType.Comparator):
         # This is not to mess up with SQLAlchemy's use of
         # hasattr/getattr on Column objects.
 
-        if not name.startswith('ST_'):
+        if not name.lower().startswith('st_'):
             raise AttributeError
 
         # We create our own _FunctionGenerator here, and use it in place of

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/geoalchemy2/functions.py

@@ -84,6 +84,10 @@ class GenericFunction(functions.GenericFunction):
             type = Geometry
     """
 
+    # Set _register to False in order not to register this class in
+    # sqlalchemy.sql.functions._registry. Only its children will be registered.
+    _register = False
+
     def __init__(self, *args, **kwargs):
         expr = kwargs.pop('expr', None)
         if expr is not None:
@@ -96,15 +100,180 @@ class GenericFunction(functions.GenericFunction):
 
 
 _FUNCTIONS = [
+    #
+    # Geometry Constructors
+    #
+
+    ('ST_BdPolyFromText', types.Geometry,
+     'Construct a Polygon given an arbitrary collection of closed linestrings'
+     'as a MultiLineString Well-Known text representation.'),
+
+    ('ST_BdMPolyFromText', types.Geometry,
+     'Construct a MultiPolygon given an arbitrary collection of closed '
+     'linestrings as a MultiLineString text representation Well-Known text '
+     'representation.'),
+
+    ('ST_Box2dFromGeoHash', types.Geometry,
+     'Return a BOX2D from a GeoHash string.'),
+
+    ('ST_GeogFromText', types.Geography,
+     'Return a specified geography value from Well-Known Text representation '
+     'or extended (WKT).'),
+
+    ('ST_GeographyFromText', types.Geography,
+     'Return a specified geography value from Well-Known Text representation '
+     'or extended (WKT).'),
+
+    ('ST_GeogFromWKB', types.Geography,
+     'Creates a geography instance from a Well-Known Binary geometry '
+     'representation (WKB) or extended Well Known Binary (EWKB).'),
+
+    ('ST_GeomFromTWKB', types.Geometry,
+     'Creates a geometry instance from a TWKB ("Tiny Well-Known Binary") '
+     'geometry representation.'),
+
+    ('ST_GeomCollFromText', types.Geometry,
+     'Makes a collection Geometry from collection WKT with the given SRID. If '
+     'SRID is not given, it defaults to 0.'),
+
+    ('ST_GeomFromEWKB', types.Geometry,
+     'Return a specified ST_Geometry value from Extended Well-Known Binary '
+     'representation (EWKB).'),
+
+    ('ST_GeomFromEWKT', types.Geometry,
+     'Return a specified ST_Geometry value from Extended Well-Known Text '
+     'representation (EWKT).'),
+
+    ('ST_GeometryFromText', types.Geometry,
+     'Return a specified ST_Geometry value from Well-Known Text representation'
+     ' (WKT). This is an alias name for ST_GeomFromText'),
+
+    ('ST_GeomFromGeoHash', types.Geometry,
+     'Return a geometry from a GeoHash string.'),
+
+    ('ST_GeomFromGML', types.Geometry,
+     'Takes as input GML representation of geometry and outputs a PostGIS '
+     'geometry object'),
+
+    ('ST_GeomFromGeoJSON', types.Geometry,
+     'Takes as input a geojson representation of a geometry and outputs a '
+     'PostGIS geometry object'),
+
+    ('ST_GeomFromKML', types.Geometry,
+     'Takes as input KML representation of geometry and outputs a PostGIS '
+     'geometry object'),
+
+    ('ST_GMLToSQL', types.Geometry,
+     'Return a specified ST_Geometry value from GML representation. This is an'
+     ' alias name for ST_GeomFromGML'),
+
+    ('ST_GeomFromText', types.Geometry,
+     'Return a specified ST_Geometry value from Well-Known Text representation'
+     ' (WKT).'),
+
+    ('ST_GeomFromWKB', types.Geometry,
+     'Creates a geometry instance from a Well-Known Binary geometry '
+     'representation (WKB) and optional SRID.'),
+
+    ('ST_LineFromEncodedPolyline', types.Geometry,
+     'Creates a LineString from an Encoded Polyline.'),
+
+    ('ST_LineFromMultiPoint', types.Geometry,
+     'Creates a LineString from a MultiPoint geometry.'),
+
+    ('ST_LineFromText', types.Geometry,
+     'Makes a Geometry from WKT representation with the given SRID. If SRID is'
+     ' not given, it defaults to 0.'),
+
+    ('ST_LineFromWKB', types.Geometry,
+     'Makes a LINESTRING from WKB with the given SRID'),
+
+    ('ST_LinestringFromWKB', types.Geometry,
+     'Makes a geometry from WKB with the given SRID.'),
+
+    ('ST_MakeBox2D', types.Geometry,
+     'Creates a BOX2D defined by the given point geometries.'),
+
+    ('ST_3DMakeBox', types.Geometry,
+     'Creates a BOX3D defined by the given 3d point geometries.'),
+
+    ('ST_MakeLine', types.Geometry,
+     'Creates a Linestring from point, multipoint, or line geometries.'),
+
+    ('ST_MakeEnvelope', types.Geometry,
+     'Creates a rectangular Polygon formed from the given minimums and '
+     'maximums. Input values must be in SRS specified by the SRID.'),
+
+    ('ST_MakePolygon', types.Geometry,
+     'Creates a Polygon formed by the given shell. Input geometries must be '
+     'closed LINESTRINGS.'),
+
+    ('ST_MakePoint', types.Geometry,
+     'Creates a 2D, 3DZ or 4D point geometry.'),
+
+    ('ST_MakePointM', types.Geometry,
+     'Creates a point geometry with an x y and m coordinate.'),
+
+    ('ST_MLineFromText', types.Geometry,
+     'Return a specified ST_MultiLineString value from WKT representation.'),
+
+    ('ST_MPointFromText', types.Geometry,
+     'Makes a Geometry from WKT with the given SRID. If SRID is not given, it '
+     'defaults to 0.'),
+
+    ('ST_MPolyFromText', types.Geometry,
+     'Makes a MultiPolygon Geometry from WKT with the given SRID. If SRID is '
+     'not given, it defaults to 0.'),
+
+    ('ST_Point', types.Geometry,
+     'Returns an ST_Point with the given coordinate values. OGC alias for '
+     'ST_MakePoint.'),
+
+    ('ST_PointFromGeoHash', types.Geometry,
+     'Return a point from a GeoHash string.'),
+
+    ('ST_PointFromText', types.Geometry,
+     'Makes a point Geometry from WKT with the given SRID. If SRID is not '
+     'given, it defaults to unknown.'),
+
+    ('ST_PointFromWKB', types.Geometry,
+     'Makes a geometry from WKB with the given SRID'),
+
+    ('ST_Polygon', types.Geometry,
+     'Returns a polygon built from the specified linestring and SRID.'),
+
+    ('ST_PolygonFromText', types.Geometry,
+     'Makes a Geometry from WKT with the given SRID. If SRID is not given, it '
+     'defaults to 0.'),
+
+    ('ST_WKBToSQL', types.Geometry,
+     'Return a specified ST_Geometry value from Well-Known Binary '
+     'representation (WKB). This is an alias name for ST_GeomFromWKB that '
+     'takes no srid'),
+
+    ('ST_WKTToSQL', types.Geometry,
+     'Return a specified ST_Geometry value from Well-Known Text representation'
+     ' (WKT). This is an alias name for ST_GeomFromText'),
+
     #
     # Geometry Accessors
     #
 
+    ('ST_Boundary', types.Geometry,
+     'Returns the closure of the combinatorial boundary of this Geometry.'),
+
+    ('ST_BoundingDiagonal', types.Geometry,
+     'Returns the diagonal of the supplied geometry\'s bounding box.'),
+
+    ('ST_EndPoint', types.Geometry,
+     'Returns the last point of a ``LINESTRING`` or ``CIRCULARLINESTRING`` '
+     'geometry as a ``POINT``.'),
+
     ('ST_Envelope', types.Geometry,
      'Returns a geometry representing the double precision (float8) bounding'
      'box of the supplied geometry.'),
 
-    ('ST_GeometryN', None,
+    ('ST_GeometryN', types.Geometry,
      'Return the 1-based Nth geometry if the geometry is a '
      '``GEOMETRYCOLLECTION``, ``(MULTI)POINT``, ``(MULTI)LINESTRING``, '
      '``MULTICURVE`` or ``(MULTI)POLYGON``, ``POLYHEDRALSURFACE`` Otherwise, '
@@ -113,16 +282,38 @@ _FUNCTIONS = [
     ('ST_GeometryType', None,
      'Return the geometry type of the ``ST_Geometry`` value.'),
 
+    ('ST_InteriorRingN', types.Geometry,
+     'Return the Nth interior linestring ring of the polygon geometry. Return '
+     '``NULL`` if the geometry is not a polygon or the given N is out of '
+     'range.'),
+
     ('ST_IsValid', None,
      'Returns ``True`` if the ``ST_Geometry`` is well formed.'),
 
     ('ST_NPoints', None,
      'Return the number of points (vertices) in a geometry.'),
 
+    ('ST_PatchN', types.Geometry,
+     'Return the 1-based Nth geometry (face) if the geometry is a '
+     '``POLYHEDRALSURFACE``, ``POLYHEDRALSURFACEM``. Otherwise, return '
+     '``NULL``.'),
+
+    ('ST_PointN', types.Geometry,
+     'Return the Nth point in the first LineString or circular LineString in '
+     'the geometry. Negative values are counted backwards from the end of the '
+     'LineString. Returns ``NULL`` if there is no linestring in the geometry.'
+     ),
+
+    ('ST_Points', types.Geometry,
+     'Returns a MultiPoint containing all of the coordinates of a geometry.'),
+
     ('ST_SRID', None,
      'Returns the spatial reference identifier for the ``ST_Geometry`` as '
      'defined in ``spatial_ref_sys`` table.'),
 
+    ('ST_StartPoint', types.Geometry,
+     'Returns the first point of a ``LINESTRING`` geometry as a ``POINT``.'),
+
     ('ST_X', None,
      'Return the X coordinate of the point, or ``None`` if not available. '
      'Input must be a point.'),
@@ -139,10 +330,124 @@ _FUNCTIONS = [
     # Geometry Editors
     #
 
+    ('ST_AddPoint', types.Geometry,
+     'Add a point to a LineString.'),
+
+    ('ST_Affine', types.Geometry,
+     'Apply a 3d affine transformation to a geometry.'),
+
+    ('ST_CollectionExtract', types.Geometry,
+     'Given a (multi)geometry, return a (multi)geometry consisting only of '
+     'elements of the specified type.'),
+
+    ('ST_CollectionHomogenize', types.Geometry,
+     'Given a geometry collection, return the "simplest" representation of '
+     'the contents.'),
+
+    ('ST_ExteriorRing', types.Geometry,
+     'Returns a line string representing the exterior ring of the ``POLYGON`` '
+     'geometry. Return ``NULL`` if the geometry is not a polygon. Will not '
+     'work with ``MULTIPOLYGON``.'),
+
+    ('ST_Force2D', types.Geometry,
+     'Force the geometries into a "2-dimensional mode".'),
+
+    ('ST_Force3D', types.Geometry,
+     ('Force the geometries into XYZ mode. This is an alias for ``ST_Force3DZ``.',
+      'ST_Force_3D')),
+
+    ('ST_Force3DM', types.Geometry,
+     ('Force the geometries into XYM mode.', 'ST_Force_3DM')),
+
+    ('ST_Force3DZ', types.Geometry,
+     ('Force the geometries into XYZ mode.', 'ST_Force_3DZ')),
+
+    ('ST_Force4D', types.Geometry,
+     ('Force the geometries into XYZM mode.', 'ST_Force_4D')),
+
+    ('ST_ForceCollection', types.Geometry,
+     ('Convert the geometry into a ``GEOMETRYCOLLECTION``.',
+      'ST_Force_Collection')),
+
+    ('ST_ForceCurve', types.Geometry,
+     'Upcast a geometry into its curved type, if applicable.'),
+
+    ('ST_ForcePolygonCCW', types.Geometry,
+     'Orients all exterior rings counter-clockwise and all interior rings '
+     'clockwise.'),
+
+    ('ST_ForcePolygonCW', types.Geometry,
+     'Orients all exterior rings clockwise and all interior rings '
+     'counter-clockwise.'),
+
+    ('ST_ForceRHR', types.Geometry,
+     'Force the orientation of the vertices in a polygon to follow the '
+     'Right-Hand-Rule.'),
+
+    ('ST_ForceSFS', types.Geometry,
+     'Force the geometries to use SFS 1.1 geometry types only.'),
+
+    ('ST_M', None,
+     'Return the M coordinate of the point, or ``NULL`` if not available. '
+     'Input must be a point.'),
+
+    ('ST_Multi', types.Geometry,
+     'Return the geometry as a ``MULTI*`` geometry.'),
+
+    ('ST_Normalize', types.Geometry,
+     'Return the geometry in its canonical form.'),
+
+    ('ST_QuantizeCoordinates', types.Geometry,
+     'Sets least significant bits of coordinates to zero.'),
+
+    ('ST_RemovePoint', types.Geometry,
+     'Remove point from a linestring.'),
+
+    ('ST_Reverse', types.Geometry,
+     'Return the geometry with vertex order reversed.'),
+
+    ('ST_Rotate', types.Geometry,
+     'Rotate a geometry rotRadians counter-clockwise about an origin.'),
+
+    ('ST_RotateX', types.Geometry,
+     'Rotate a geometry rotRadians about the X axis.'),
+
+    ('ST_RotateY', types.Geometry,
+     'Rotate a geometry rotRadians about the Y axis.'),
+
+    ('ST_RotateZ', types.Geometry,
+     'Rotate a geometry rotRadians about the Z axis.'),
+
+    ('ST_Scale', types.Geometry,
+     'Scale a geometry by given factors.'),
+
+    ('ST_Segmentize', types.Geometry,
+     'Return a modified geometry/geography having no segment longer than the '
+     'given distance.'),
+
+    ('ST_SetPoint', types.Geometry,
+     'Replace point of a linestring with a given point.'),
+
+    ('ST_SetSRID', types.Geometry,
+     'Set the SRID on a geometry to a particular integer value.'),
+
+    ('ST_Snap', types.Geometry,
+     'Snap segments and vertices of input geometry to vertices of a reference '
+     'geometry.'),
+
+    ('ST_SnapToGrid', types.Geometry,
+     'Snap all points of the input geometry to a regular grid.'),
+
     ('ST_Transform', types.Geometry,
      'Return a new geometry with its coordinates transformed to the SRID '
      'referenced by the integer parameter.'),
 
+    ('ST_Translate', types.Geometry,
+     'Translate a geometry by given offsets.'),
+
+    ('ST_TransScale', types.Geometry,
+     'Translate a geometry by given factors and offsets.'),
+
     #
     # Geometry Outputs
     #
@@ -338,34 +643,18 @@ _FUNCTIONS = [
      'If \'start\' and \'end\' have the same value this is equivalent '
      'to ST_LineInterpolatePoint.'),
 
-    ('ST_Union', types.Geometry,
-     'Returns a geometry that represents the point set union of the '
-     'Geometries.'),
-
     ('ST_Simplify', types.Geometry,
      'Returns a "simplified" version of the given geometry using the '
      'Douglas-Peucker algorithm.'),
 
+    ('ST_Union', types.Geometry,
+     'Returns a geometry that represents the point set union of the '
+     'Geometries.'),
+
     #
     # Raster Constructors
     #
 
-    ('ST_GeomFromText', types.Geometry,
-     'Constructs a PostGIS ST_Geometry object from the OGC Well-Known text '
-     'representation.'),
-
-    ('ST_GeomFromEWKT', types.Geometry,
-     'Constructs a PostGIS ST_Geometry object from the OGC Extended Well-Known '
-     'text (EWKT) representation.'),
-
-    ('ST_GeomFromEWKB', types.Geometry,
-     'Constructs a PostGIS ST_Geometry object from the OGC Extended Well-Known '
-     'binary (EWKB) representation.'),
-
-    ('ST_GeogFromText', types.Geography,
-     'Returns a geography object from the well-known text or extended well-known '
-     'representation.'),
-
     ('ST_AsRaster', types.Raster,
      ('Converts a PostGIS geometry to a PostGIS raster.', 'RT_ST_AsRaster')),
 

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/geoalchemy2/types.py

@@ -76,9 +76,19 @@ class _GISType(UserDefinedType):
 
         The dimension of the geometry. Default is ``2``.
 
-        When set to ``3`` then the "geometry_type" is constrained to terminate
-        on either ``"Z"`` or ``"M"``. When set to ``4`` then the
-        "geometry_type" must terminate with ``"ZM"``.
+        With ``management`` set to ``True``, that is when ``AddGeometryColumn`` is used
+        to add the geometry column, there are two constraints:
+
+        * The ``geometry_type`` must not end with ``"ZM"``.  This is due to PostGIS'
+          ``AddGeometryColumn`` failing with ZM geometry types. Instead the "simple"
+          geometry type (e.g. POINT rather POINTZM) should be used with ``dimension``
+          set to ``4``.
+        * When the ``geometry_type`` ends with ``"Z"`` or ``"M"`` then ``dimension``
+          must be set to ``3``.
+
+        With ``management`` set to ``False`` (the default) ``dimension`` is not
+        taken into account, and the actual dimension is fully defined with the
+        ``geometry_type``.
 
     ``spatial_index``
 
@@ -181,19 +191,19 @@ class _GISType(UserDefinedType):
             raise ArgumentError('srid must be convertible to an integer')
         if geometry_type:
             geometry_type = geometry_type.upper()
-
-            if ((dimension == 4 and not geometry_type.endswith('ZM'))
-                or (dimension == 3
-                    and not (geometry_type.endswith('Z')
-                             or (geometry_type.endswith('M')
-                             and not geometry_type.endswith('ZM'))))
-                or (dimension == 2
-                    and (geometry_type.endswith('ZM')
-                         or geometry_type.endswith('Z')
-                         or geometry_type.endswith('M')))):
-                raise ArgumentError(
-                    'invalid geometry_type {!r} for dimension {}'.format(
-                        geometry_type, dimension))
+            if management:
+                if geometry_type.endswith('ZM'):
+                    # PostGIS' AddGeometryColumn does not work with ZM geometry types. Instead
+                    # the simple geometry type (e.g. POINT rather POINTZM) should be used with
+                    # dimension set to 4
+                    raise ArgumentError(
+                        'with management=True use geometry_type={!r} and '
+                        'dimension=4 for {!r} geometries'.format(geometry_type[:-2], geometry_type))
+                elif geometry_type[-1] in ('Z', 'M') and dimension != 3:
+                    # If a Z or M geometry type is used then dimension must be set to 3
+                    raise ArgumentError(
+                        'with management=True dimension must be 3 for '
+                        '{!r} geometries'.format(geometry_type))
         else:
             if management:
                 raise ArgumentError('geometry_type set to None not compatible '
@@ -201,9 +211,6 @@ class _GISType(UserDefinedType):
             if srid > 0:
                 warnings.warn('srid not enforced when geometry_type is None')
 
-            if dimension > 2:
-                raise ArgumentError('geometry type set to None not compatible '
-                                    'with dimension > 2')
         if use_typmod and not management:
             warnings.warn('use_typmod ignored when management is False')
         return geometry_type, srid

{GeoAlchemy2-0.6.2 → GeoAlchemy2-0.6.3}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 
-version = '0.6.2'
+version = '0.6.3'
 
 setup(
     name='GeoAlchemy2',