Date collections and MEOS sync

pymeos/.gitignore

@@ -1,9 +1,17 @@
 .idea
+.vscode
+
+.micromamba
+d
+
 build
 dist
 docs/_build
 
 *.egg-info
 .pytest_cache
+*.pyc
+
+sandbox.py
 
-sandbox.py
+coverage.xml

pymeos/pymeos/__init__.py

@@ -29,7 +29,7 @@
     MeosGeoJsonOutputError,
 )
 
-__version__ = "1.1.3b3"
+__version__ = "1.1.3rc1"
 __all__ = [
     # initialization
     "pymeos_initialize",

pymeos/pymeos/aggregators/general_aggregators.py

@@ -1,13 +1,25 @@
 from datetime import datetime
 from typing import Union
 
-from pymeos_cffi import *
+from pymeos_cffi import (
+    timestamptz_tcount_transfn,
+    datetime_to_timestamptz,
+    tstzset_tcount_transfn,
+    temporal_tcount_transfn,
+    tstzspan_tcount_transfn,
+    tstzspanset_tcount_transfn,
+    temporal_extent_transfn,
+    timestamptz_extent_transfn,
+    set_extent_transfn,
+    span_extent_transfn,
+    spanset_extent_transfn,
+)
 
 from .aggregator import BaseAggregator
 from ..boxes import Box
+from ..collections import Time, TsTzSet, TsTzSpan, TsTzSpanSet
 from ..main import TIntSeq, TIntSeqSet
 from ..temporal import Temporal, TInterpolation
-from ..collections import Time, TsTzSet, TsTzSpan, TsTzSpanSet
 
 
 class TemporalInstantCountAggregator(
@@ -27,7 +39,7 @@ class TemporalInstantCountAggregator(
     @classmethod
     def _add(cls, state, temporal):
         if isinstance(temporal, datetime):
-            state = timestamp_tcount_transfn(state, datetime_to_timestamptz(temporal))
+            state = timestamptz_tcount_transfn(state, datetime_to_timestamptz(temporal))
         elif isinstance(temporal, TsTzSet):
             state = tstzset_tcount_transfn(state, temporal._inner)
         elif (
@@ -85,7 +97,7 @@ def _add(cls, state, temporal):
         if isinstance(temporal, Temporal):
             state = temporal_extent_transfn(state, temporal._inner)
         elif isinstance(temporal, datetime):
-            state = timestamp_extent_transfn(state, datetime_to_timestamptz(temporal))
+            state = timestamptz_extent_transfn(state, datetime_to_timestamptz(temporal))
         elif isinstance(temporal, TsTzSet):
             state = set_extent_transfn(state, temporal._inner)
         elif isinstance(temporal, TsTzSpan):

pymeos/pymeos/aggregators/time_aggregators.py

@@ -1,7 +1,14 @@
 from datetime import datetime
 from typing import Union
 
-from pymeos_cffi import *
+from pymeos_cffi import (
+    timestamptz_union_transfn,
+    datetime_to_timestamptz,
+    set_union_transfn,
+    set_union_finalfn,
+    union_spanset_span,
+    union_spanset_spanset,
+)
 
 from .aggregator import BaseAggregator
 from ..collections import TsTzSet, TsTzSpan, TsTzSpanSet
@@ -21,7 +28,7 @@ class TimeInstantaneousUnionAggregator(
     @classmethod
     def _add(cls, state, temporal):
         if isinstance(temporal, datetime):
-            state = timestamp_union_transfn(state, datetime_to_timestamptz(temporal))
+            state = timestamptz_union_transfn(state, datetime_to_timestamptz(temporal))
         elif isinstance(temporal, TsTzSet):
             state = set_union_transfn(state, temporal._inner)
         else:

pymeos/pymeos/boxes/stbox.py

@@ -250,7 +250,7 @@ def from_geometry_time(
         else:
             raise TypeError(
                 f"Operation not supported with types "
-                "{geometry.__class__} and {time.__class__}"
+                f"{geometry.__class__} and {time.__class__}"
             )
         return STBox(_inner=result)
 

pymeos/pymeos/boxes/tbox.py

@@ -4,8 +4,8 @@
 
 from pymeos_cffi import *
 
-from ..main import TNumber
 from ..collections import *
+from ..main import TNumber, TInt, TFloat
 
 
 class TBox:
@@ -159,9 +159,9 @@ def from_value(value: Union[int, float, IntSpan, FloatSpan]) -> TBox:
         elif isinstance(value, float):
             result = float_to_tbox(value)
         elif isinstance(value, IntSpan):
-            result = numspan_to_tbox(value._inner)
+            result = span_to_tbox(value._inner)
         elif isinstance(value, FloatSpan):
-            result = numspan_to_tbox(value._inner)
+            result = span_to_tbox(value._inner)
         else:
             raise TypeError(f"Operation not supported with type {value.__class__}")
         return TBox(_inner=result)
@@ -185,11 +185,11 @@ def from_time(time: Time) -> TBox:
         if isinstance(time, datetime):
             result = timestamptz_to_tbox(datetime_to_timestamptz(time))
         elif isinstance(time, TsTzSet):
-            result = tstzset_to_tbox(time._inner)
+            result = set_to_tbox(time._inner)
         elif isinstance(time, TsTzSpan):
-            result = tstzspan_to_tbox(time._inner)
+            result = span_to_tbox(time._inner)
         elif isinstance(time, TsTzSpanSet):
-            result = tstzspanset_to_tbox(time._inner)
+            result = spanset_to_tbox(time._inner)
         else:
             raise TypeError(f"Operation not supported with type {time.__class__}")
         return TBox(_inner=result)
@@ -1081,9 +1081,14 @@ def nearest_approach_distance(self, other: Union[TBox, TNumber]) -> float:
             nad_tbox_tbox
         """
         if isinstance(other, TBox):
-            return nad_tbox_tbox(self._inner, other._inner)
-        elif isinstance(other, TNumber):
-            return nad_tnumber_tbox(other._inner, self._inner)
+            if self._is_float():
+                return nad_tboxfloat_tboxfloat(self._inner, other._inner)
+            else:
+                return nad_tboxint_tboxint(self._inner, other._inner)
+        elif isinstance(other, TInt):
+            return nad_tint_tbox(other._inner, self._inner)
+        elif isinstance(other, TFloat):
+            return nad_tfloat_tbox(other._inner, self._inner)
         else:
             raise TypeError(f"Operation not supported with type {other.__class__}")
 

pymeos/pymeos/collections/__init__.py

@@ -9,11 +9,16 @@
     "Set",
     "Span",
     "SpanSet",
+    "TimeDate",
+    "date",
+    "DateSet",
+    "DateSpan",
+    "DateSpanSet",
     "Time",
+    "datetime",
     "TsTzSet",
     "TsTzSpan",
     "TsTzSpanSet",
-    "datetime",
     "timedelta",
     "TextSet",
     "GeoSet",

pymeos/pymeos/collections/base/collection.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, Type
 
 T = TypeVar("T")
-Self = TypeVar("Self", bound="Set[Any]")
+Self = TypeVar("Self")
 
 
 class Collection(Generic[T], ABC):
@@ -29,10 +29,6 @@ def __contains__(self, item):
     def overlaps(self, other) -> bool:
         raise NotImplementedError()
 
-    # @abstractmethod
-    # def is_same(self, other) -> bool:
-    # raise NotImplementedError()
-
     # ------------------------- Position Operations ---------------------------
     @abstractmethod
     def is_left(self, other) -> bool:
@@ -54,9 +50,9 @@ def is_right(self, other) -> bool:
 
     # ------------------------- Database Operations ---------------------------
     @classmethod
-    def read_from_cursor(cls, value, _=None):
+    def read_from_cursor(cls: Type[Self], value, _=None):
         """
-        Reads a :class:`STBox` from a database cursor. Used when automatically
+        Reads a :class:`Collection` from a database cursor. Used when automatically
         loading objects from the database.
         Users should use the class constructor instead.
         """

pymeos/pymeos/collections/base/set.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Optional, Union, List
+from typing import Optional, Union, List, overload
 from typing import TypeVar, Type, Callable, Any, TYPE_CHECKING, Iterable
 
 from pymeos_cffi import *
@@ -12,6 +12,9 @@
     from .spanset import SpanSet
     from .span import Span
 
+    from ..number import IntSet, IntSpan, IntSpanSet, FloatSet, FloatSpan, FloatSpanSet
+    from ..time import DateSet, DateSpan, DateSpanSet, TsTzSet, TsTzSpan, TsTzSpanSet
+
 T = TypeVar("T")
 Self = TypeVar("Self", bound="Set[Any]")
 
@@ -75,7 +78,9 @@ def from_wkb(cls: Type[Self], wkb: bytes) -> Self:
         MEOS Functions:
             set_from_wkb
         """
-        return cls(_inner=set_from_wkb(wkb))
+        from ...factory import _CollectionFactory
+
+        return _CollectionFactory.create_collection(set_from_wkb(wkb))
 
     @classmethod
     def from_hexwkb(cls: Type[Self], hexwkb: str) -> Self:
@@ -90,11 +95,13 @@ def from_hexwkb(cls: Type[Self], hexwkb: str) -> Self:
         MEOS Functions:
             set_from_hexwkb
         """
-        return cls(_inner=(set_from_hexwkb(hexwkb)))
+        from ...factory import _CollectionFactory
+
+        return _CollectionFactory.create_collection((set_from_hexwkb(hexwkb)))
 
     # ------------------------- Output ----------------------------------------
     @abstractmethod
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Return the string representation of the content of ``self``.
 
@@ -103,7 +110,7 @@ def __str__(self):
         """
         raise NotImplementedError()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Return the string representation of ``self``.
 
@@ -138,20 +145,22 @@ def as_hexwkb(self) -> str:
         return set_as_hexwkb(self._inner, -1)[0]
 
     # ------------------------- Conversions -----------------------------------
-    @abstractmethod
-    def to_spanset(self) -> SpanSet:
-        """
-        Returns a SpanSet that contains a Span for each element in ``self``.
+    @overload
+    def to_span(self: Type[IntSet]) -> IntSpan:
+        ...
 
-        Returns:
-            A new :class:`SpanSet` instance
+    @overload
+    def to_span(self: Type[FloatSet]) -> FloatSpan:
+        ...
 
-        MEOS Functions:
-            set_to_spanset
-        """
-        return set_to_spanset(self._inner)
+    @overload
+    def to_span(self: Type[TsTzSet]) -> TsTzSpan:
+        ...
+
+    @overload
+    def to_span(self: Type[DateSet]) -> DateSpan:
+        ...
 
-    @abstractmethod
     def to_span(self) -> Span:
         """
         Returns a span that encompasses ``self``.
@@ -162,7 +171,39 @@ def to_span(self) -> Span:
         MEOS Functions:
             set_span
         """
-        return set_span(self._inner)
+        from ...factory import _CollectionFactory
+
+        return _CollectionFactory.create_collection(set_span(self._inner))
+
+    @overload
+    def to_spanset(self: Type[IntSet]) -> IntSpanSet:
+        ...
+
+    @overload
+    def to_spanset(self: Type[FloatSet]) -> FloatSpanSet:
+        ...
+
+    @overload
+    def to_spanset(self: Type[TsTzSet]) -> TsTzSpanSet:
+        ...
+
+    @overload
+    def to_spanset(self: Type[DateSet]) -> DateSpanSet:
+        ...
+
+    def to_spanset(self) -> SpanSet:
+        """
+        Returns a SpanSet that contains a Span for each element in ``self``.
+
+        Returns:
+            A new :class:`SpanSet` instance
+
+        MEOS Functions:
+            set_to_spanset
+        """
+        from ...factory import _CollectionFactory
+
+        return _CollectionFactory.create_collection(set_to_spanset(self._inner))
 
     # ------------------------- Accessors -------------------------------------
 
@@ -250,8 +291,7 @@ def is_contained_in(self, container) -> bool:
             True if contained, False otherwise
 
         MEOS Functions:
-            contained_span_span, contained_span_spanset, contained_set_set,
-            contained_spanset_spanset
+            contained_set_set
         """
         if isinstance(container, Set):
             return contained_set_set(self._inner, container._inner)
@@ -388,30 +428,17 @@ def is_right(self, other) -> bool:
             raise TypeError(f"Operation not supported with type {other.__class__}")
 
     # ------------------------- Distance Operations ---------------------------
-    def distance(self, other) -> float:
+    def distance(self, other):
         """
         Returns the distance between ``self`` and ``other``.
 
         Args:
             other: object to compare with
 
         Returns:
-            A :class:`float` instance
-
-        MEOS Functions:
-            distance_set_set, distance_span_span, distance_spanset_span
+            The distance metric in the appropriate format depending on the subclass.
         """
-        from .span import Span
-        from .spanset import SpanSet
-
-        if isinstance(other, Set):
-            return distance_set_set(self._inner, other._inner)
-        elif isinstance(other, Span):
-            return distance_span_span(set_span(self._inner), other._inner)
-        elif isinstance(other, SpanSet):
-            return distance_spanset_span(other._inner, set_span(self._inner))
-        else:
-            raise TypeError(f"Operation not supported with type {other.__class__}")
+        raise TypeError(f"Operation not supported with type {other.__class__}")
 
     # ------------------------- Set Operations --------------------------------
     @abstractmethod