GeoAlchemy2 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

geoalchemy2/comparator.py

@@ -37,7 +37,7 @@ Using the ORM::
     Session.query(Cls).order_by(Cls.geom.distance_box('POINT(0 0)')).limit(10)
 """
 
-from typing import Union
+from typing import Any
 
 from sqlalchemy import types as sqltypes
 from sqlalchemy.dialects.postgresql import DOUBLE_PRECISION
@@ -65,7 +65,7 @@ SAME: custom_op = custom_op("~=")
 DISTANCE_CENTROID: custom_op = custom_op("<->")
 DISTANCE_BOX: custom_op = custom_op("<#>")
 
-_COMPARATOR_INPUT_TYPE = Union[str, WKBElement, WKTElement]
+_COMPARATOR_INPUT_TYPE = str | WKBElement | WKTElement
 
 
 class BaseComparator(UserDefinedType.Comparator):
@@ -80,13 +80,13 @@ class BaseComparator(UserDefinedType.Comparator):
 
     key = None
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         # Function names that don't start with "ST_" are rejected.
         # This is not to mess up with SQLAlchemy's use of
         # hasattr/getattr on Column objects.
 
         if not name.lower().startswith("st_"):
-            raise AttributeError
+            raise AttributeError(f"Attribute {name} not found")
 
         # We create our own _FunctionGenerator here, and use it in place of
         # SQLAlchemy's "func" object. This is to be able to "bind" the

geoalchemy2/elements.py

@@ -35,6 +35,11 @@ class _SpatialElement:
 
     """
 
+    # Define __slots__ to restrict attributes in this class.
+    # This is done intentionally to improve performance by preventing
+    # the creation of a dynamic __dict__ for each instance.
+    __slots__ = ("srid", "data", "extended")
+
     def __init__(self, data, srid: int = -1, extended: Optional[bool] = None) -> None:
         self.srid = srid
         self.data = data
@@ -114,8 +119,16 @@ class WKTElement(_SpatialElement):
         wkt_element_1 = WKTElement('POINT(5 45)')
         wkt_element_2 = WKTElement('POINT(5 45)', srid=4326)
         wkt_element_3 = WKTElement('SRID=4326;POINT(5 45)', extended=True)
+
+    Note::
+        This class uses ``__slots__`` to restrict its attributes and improve memory efficiency by
+        preventing the creation of a dynamic ``__dict__`` for each instance.
+        If you require dynamic attributes or support for weak references, use the
+        ``DynamicWKTElement`` subclass, which provides these capabilities.
     """
 
+    __slots__ = ()
+
     _REMOVE_SRID = re.compile("(SRID=([0-9]+); ?)?(.*)")
     SPLIT_WKT_PATTERN = re.compile(r"((SRID=\d+) *; *)?([\w ]+) *(\([-\d\. ,\(\)]+\))")
 
@@ -160,6 +173,15 @@ class WKTElement(_SpatialElement):
         return WKTElement(self.data, self.srid, self.extended)
 
 
+class DynamicWKTElement(WKTElement):
+    """This is a subclass of ``WKTElement`` that allows dynamic attributes.
+
+    It is useful when you need to add attributes dynamically to the object.
+    """
+
+    __slots__ = ("__dict__", "__weakref__")
+
+
 class WKBElement(_SpatialElement):
     """Instances of this class wrap a WKB or EWKB value.
 
@@ -172,13 +194,21 @@ class WKBElement(_SpatialElement):
 
     Note: you can create ``WKBElement`` objects from Shapely geometries
     using the :func:`geoalchemy2.shape.from_shape` function.
+
+    Note::
+        This class uses ``__slots__`` to restrict its attributes and improve memory efficiency by
+        preventing the creation of a dynamic ``__dict__`` for each instance.
+        If you require dynamic attributes or support for weak references, use the
+        ``DynamicWKBElement`` subclass, which provides these capabilities.
     """
 
+    __slots__ = ()
+
     geom_from: str = "ST_GeomFromWKB"
     geom_from_extended_version: str = "ST_GeomFromEWKB"
 
     def __init__(
-        self, data: Union[str, bytes, memoryview], srid: int = -1, extended: Optional[bool] = None
+        self, data: str | bytes | memoryview, srid: int = -1, extended: Optional[bool] = None
     ) -> None:
         if srid == -1 or extended is None or extended:
             # read srid from the EWKB
@@ -216,14 +246,18 @@ class WKBElement(_SpatialElement):
                 srid = int(wkb_srid)
         _SpatialElement.__init__(self, data, srid, extended)
 
+    @staticmethod
+    def _wkb_to_hex(data: Union[str, bytes, memoryview]) -> str:
+        """Convert WKB to hex string."""
+        if isinstance(data, str):
+            # SpatiaLite case
+            return data.lower()
+        return str(binascii.hexlify(data), encoding="utf-8").lower()
+
     @property
     def desc(self) -> str:
         """This element's description string."""
-        if isinstance(self.data, str):
-            # SpatiaLite case
-            return self.data.lower()
-        desc = str(binascii.hexlify(self.data), encoding="utf-8").lower()
-        return desc
+        return self._wkb_to_hex(self.data)
 
     @staticmethod
     def _data_from_desc(desc) -> bytes:
@@ -277,7 +311,7 @@ class WKBElement(_SpatialElement):
             )
             wkb_type_int |= 536870912  # Set SRID bit to 1 and keep all other bits
 
-            data: Union[str, memoryview]
+            data: str | memoryview
             if isinstance(self.data, str):
                 wkb_type_hex = binascii.hexlify(
                     wkb_type_int.to_bytes(4, "little" if byte_order else "big")
@@ -303,13 +337,30 @@ class WKBElement(_SpatialElement):
         return WKBElement(self.data, self.srid)
 
 
+class DynamicWKBElement(WKBElement):
+    """This is a subclass of ``WKBElement`` that allows dynamic attributes.
+
+    It is useful when you need to add attributes dynamically to the object.
+    """
+
+    __slots__ = ("__dict__", "__weakref__")
+
+
 class RasterElement(_SpatialElement):
     """Instances of this class wrap a ``raster`` value.
 
     Raster values read from the database are converted to instances of this type. In
     most cases you won't need to create ``RasterElement`` instances yourself.
+
+    Note::
+        This class uses ``__slots__`` to restrict its attributes and improve memory efficiency by
+        preventing the creation of a dynamic ``__dict__`` for each instance.
+        If you require dynamic attributes or support for weak references, use the
+        ``DynamicRasterElement`` subclass, which provides these capabilities.
     """
 
+    __slots__ = ()
+
     geom_from_extended_version: str = "raster"
 
     def __init__(self, data: Union[str, bytes, memoryview]) -> None:
@@ -337,9 +388,20 @@ class RasterElement(_SpatialElement):
         return desc
 
 
+class DynamicRasterElement(RasterElement):
+    """This is a subclass of ``RasterElement`` that allows dynamic attributes.
+
+    It is useful when you need to add attributes dynamically to the object.
+    """
+
+    __slots__ = ("__dict__", "__weakref__")
+
+
 class CompositeElement(FunctionElement):
     """Instances of this class wrap a Postgres composite type."""
 
+    __slots__ = ("name", "type")
+
     inherit_cache: bool = False
     """The cache is disabled for this class."""
 
@@ -361,6 +423,9 @@ __all__: List[str] = [
     "RasterElement",
     "WKBElement",
     "WKTElement",
+    "DynamicRasterElement",
+    "DynamicWKBElement",
+    "DynamicWKTElement",
 ]
 
 

geoalchemy2/functions.py

@@ -76,6 +76,7 @@ from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import annotation
 from sqlalchemy.sql import functions
 from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy.sql.selectable import FromClause
 
 from geoalchemy2 import elements
 from geoalchemy2._functions import _FUNCTIONS
@@ -134,11 +135,11 @@ class TableRowElement(ColumnElement):
     inherit_cache: bool = False
     """The cache is disabled for this class."""
 
-    def __init__(self, selectable: bool) -> None:
+    def __init__(self, selectable: FromClause) -> None:
         self.selectable = selectable
 
     @property
-    def _from_objects(self) -> List[bool]:
+    def _from_objects(self) -> List[FromClause]:
         return [self.selectable]