infdate 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

infdate/__init__.py

@@ -1,40 +1,37 @@
 # -*- coding: utf-8 -*-
 
 """
-infdate: a wrapper around standard library’s datetime.date objects,
-capable of representing positive and negative infinity
+infdate: a wrapper around the standard library’s datetime.date objects,
+capable of representing past and future infinity
 """
 
+import warnings
+
 from datetime import date, datetime
-from math import inf
+from math import inf, trunc
 from typing import final, overload, Any, Final, TypeVar
 
 
 # -----------------------------------------------------------------------------
-# Public module constants:
-# display definitions, format strings, upper and loer ordinal boundaries
+# Internal module constants:
+# TypeVar for GenericDate
 # -----------------------------------------------------------------------------
 
-INFINITE_DATE_DISPLAY: Final[str] = "<inf>"
-NEGATIVE_INFINITE_DATE_DISPLAY: Final[str] = "<-inf>"
-
-INFINITY_SYMBOL: Final[str] = "∝"
-UP_TO_SYMBOL: Final[str] = "⤒"
-FROM_ON_SYMBOL: Final[str] = "↥"
-
-ISO_DATE_FORMAT: Final[str] = "%Y-%m-%d"
-ISO_DATETIME_FORMAT_UTC: Final[str] = f"{ISO_DATE_FORMAT}T%H:%M:%S.%fZ"
+_GD = TypeVar("_GD", bound="GenericDate")
 
-MIN_ORDINAL: Final[int] = date.min.toordinal()
-MAX_ORDINAL: Final[int] = date.max.toordinal()
+_INFINITY_FORMS = (-inf, inf)
 
 
 # -----------------------------------------------------------------------------
-# Internal module constants:
-# TypeVar for GenericDate
+# Public module constants:
+# format strings
 # -----------------------------------------------------------------------------
 
-_GD = TypeVar("_GD", bound="GenericDate")
+INFINITE_PAST_DATE_DISPLAY: Final[str] = "<-inf>"
+INFINITE_FUTURE_DATE_DISPLAY: Final[str] = "<inf>"
+
+ISO_DATE_FORMAT: Final[str] = "%Y-%m-%d"
+ISO_DATETIME_FORMAT_UTC: Final[str] = f"{ISO_DATE_FORMAT}T%H:%M:%S.%fZ"
 
 
 # -----------------------------------------------------------------------------
@@ -45,15 +42,15 @@ _GD = TypeVar("_GD", bound="GenericDate")
 class GenericDate:
     """Base Date object derived from an ordinal"""
 
-    # pylint: disable=invalid-name
-    resolution: Final = 1
-    # pylint: enable=invalid-name
-
-    def __init__(self, ordinal: float, /) -> None:
+    def __init__(self, ordinal: int | float, /) -> None:
         """Create a date-like object"""
-        self.__ordinal = ordinal
+        if ordinal in _INFINITY_FORMS:
+            self.__ordinal = ordinal
+        else:
+            self.__ordinal = trunc(ordinal)
+        #
 
-    def toordinal(self: _GD) -> float:
+    def toordinal(self: _GD) -> int | float:
         """to ordinal (almost like date.toordinal())"""
         return self.__ordinal
 
@@ -90,12 +87,14 @@ class GenericDate:
         return hash(f"date with ordinal {self.__ordinal}")
 
     def _add_days(self: _GD, delta: int | float, /):
-        """Add other, respecting maybe-nondeterministic values"""
+        """Add other, respecting maybe-nondeterministic values
+        (ie. -inf or inf)
+        """
         # Check for infinity in either self or delta,
         # and return a matching InfinityDate if found.
         # Re-use existing objects if possible.
         for observed_item in (delta, self.__ordinal):
-            for infinity_form in (inf, -inf):
+            for infinity_form in _INFINITY_FORMS:
                 if observed_item == infinity_form:
                     if observed_item == self.__ordinal:
                         return self
@@ -109,24 +108,30 @@ class GenericDate:
             return self
         #
         # Return a RealDate instance if possible
-        return fromordinal(self.__ordinal + delta)
+        return fromordinal(self.__ordinal + trunc(delta))
 
     def __add__(self: _GD, delta: int | float, /) -> _GD:
         """gd_instance1 + number capability"""
         return self._add_days(delta)
 
+    __radd__ = __add__
+
     @overload
     def __sub__(self: _GD, other: int | float, /) -> _GD: ...
     @overload
-    def __sub__(self: _GD, other: _GD, /) -> int | float: ...
+    def __sub__(self: _GD, other: _GD | date, /) -> int | float: ...
     @final
-    def __sub__(self: _GD, other: _GD | int | float, /) -> _GD | int | float:
+    def __sub__(self: _GD, other: _GD | date | int | float, /) -> _GD | int | float:
         """subtract other, respecting possibly nondeterministic values"""
         if isinstance(other, (int, float)):
             return self._add_days(-other)
         #
         return self.__ordinal - other.toordinal()
 
+    def __rsub__(self: _GD, other: _GD | date, /) -> int | float:
+        """subtract from other, respecting possibly nondeterministic values"""
+        return other.toordinal() - self.__ordinal
+
     def __repr__(self: _GD, /) -> str:
         """String representation of the object"""
         return f"{self.__class__.__name__}({repr(self.__ordinal)})"
@@ -147,6 +152,29 @@ class GenericDate:
         """Return a copy with year, month, and/or date replaced"""
         raise NotImplementedError
 
+    @overload
+    def pretty(
+        self: _GD,
+        /,
+        *,
+        inf_common_prefix: str,
+        inf_past_suffix: str,
+        inf_future_suffix: str,
+    ) -> str: ...
+    @overload
+    def pretty(self: _GD, /, *, fmt: str) -> str: ...
+    def pretty(
+        self: _GD,
+        /,
+        *,
+        inf_common_prefix: str = "",
+        inf_past_suffix: str = "",
+        inf_future_suffix: str = "",
+        fmt: str = ISO_DATE_FORMAT,
+    ) -> str:
+        """Return the date, pretty printed"""
+        raise NotImplementedError
+
 
 class InfinityDate(GenericDate):
     """Infinity Date object"""
@@ -154,6 +182,7 @@ class InfinityDate(GenericDate):
     def __init__(self, /, *, past_bound: bool = False) -> None:
         """Store -inf or inf"""
         ordinal = -inf if past_bound else inf
+        self.__is_past = past_bound
         super().__init__(ordinal)
 
     def __repr__(self, /) -> str:
@@ -162,10 +191,10 @@ class InfinityDate(GenericDate):
 
     def strftime(self, fmt: str, /) -> str:
         """String representation of the date"""
-        if self.toordinal() == inf:
-            return INFINITE_DATE_DISPLAY
+        if self.__is_past:
+            return INFINITE_PAST_DATE_DISPLAY
         #
-        return NEGATIVE_INFINITE_DATE_DISPLAY
+        return INFINITE_FUTURE_DATE_DISPLAY
 
     __format__ = strftime
 
@@ -175,6 +204,25 @@ class InfinityDate(GenericDate):
             f"{self.__class__.__name__} instances do not support .replace()"
         )
 
+    @final
+    def pretty(
+        self,
+        /,
+        *,
+        inf_common_prefix: str = "",
+        inf_past_suffix: str = "",
+        inf_future_suffix: str = "",
+        # pylint:disable = unused-argument ; required by inheritance
+        fmt: str = ISO_DATE_FORMAT,
+    ) -> str:
+        """Return the date, pretty printed"""
+        if self.__is_past:
+            pretty_result = f"{inf_common_prefix}{inf_past_suffix}"
+        else:
+            pretty_result = f"{inf_common_prefix}{inf_future_suffix}"
+        #
+        return pretty_result or self.isoformat()
+
 
 # pylint: disable=too-many-instance-attributes
 class RealDate(GenericDate):
@@ -186,7 +234,7 @@ class RealDate(GenericDate):
         self.year = year
         self.month = month
         self.day = day
-        super().__init__(float(self._wrapped_date_object.toordinal()))
+        super().__init__(self._wrapped_date_object.toordinal())
         self.timetuple = self._wrapped_date_object.timetuple
         self.weekday = self._wrapped_date_object.weekday
         self.isoweekday = self._wrapped_date_object.isoweekday
@@ -218,29 +266,78 @@ class RealDate(GenericDate):
             )
         )
 
+    @final
+    def pretty(
+        self,
+        /,
+        *,
+        inf_common_prefix: str = "",
+        inf_past_suffix: str = "",
+        inf_future_suffix: str = "",
+        fmt: str = ISO_DATE_FORMAT,
+    ) -> str:
+        """Return the date, pretty printed"""
+        return self.strftime(fmt)
+
+
+# -----------------------------------------------------------------------------
+# Private module functions
+# -----------------------------------------------------------------------------
+
+
+def _from_datetime_object(source: date | datetime, /) -> GenericDate:
+    """Create a new RealDate instance from a
+    date or datetime object (module-private function)
+    """
+    return RealDate(source.year, source.month, source.day)
+
 
 # -----------------------------------------------------------------------------
 # Public module constants continued:
-# absolute minimum and maximum dates
+# minimum and maximum dates and ordinals, resolution (one day)
 # -----------------------------------------------------------------------------
 
-MIN: Final[GenericDate] = InfinityDate(past_bound=True)
-MAX: Final[GenericDate] = InfinityDate(past_bound=False)
+
+INFINITE_PAST: Final[GenericDate] = InfinityDate(past_bound=True)
+INFINITE_FUTURE: Final[GenericDate] = InfinityDate(past_bound=False)
+
+MIN: Final[GenericDate] = INFINITE_PAST
+MAX: Final[GenericDate] = INFINITE_FUTURE
+
+REAL_MIN: Final[GenericDate] = _from_datetime_object(date.min)
+REAL_MAX: Final[GenericDate] = _from_datetime_object(date.max)
+
+MIN_ORDINAL: Final[int] = date.min.toordinal()
+MAX_ORDINAL: Final[int] = date.max.toordinal()
+
+RESOLUTION: Final[int] = 1
 
 
 # -----------------------------------------------------------------------------
-# Module-level factory functions
+# Public module-level factory functions
 # -----------------------------------------------------------------------------
 
 
-def from_datetime_object(source: date | datetime, /) -> GenericDate:
+def fromdatetime(source: date | datetime, /) -> GenericDate:
     """Create a new RealDate instance from a
     date or datetime object
     """
-    return RealDate(source.year, source.month, source.day)
+    return _from_datetime_object(source)
 
 
-def from_native_type(
+def from_datetime_object(source: date | datetime, /) -> GenericDate:
+    """Create a new RealDate instance from a
+    date or datetime object (deprecated function name)
+    """
+    warnings.warn(
+        "outdated function name, please use fromdatetime() instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return fromdatetime(source)
+
+
+def fromnative(
     source: Any,
     /,
     *,
@@ -251,7 +348,7 @@ def from_native_type(
     assuming infinity in the latter case
     """
     if isinstance(source, str):
-        return from_datetime_object(datetime.strptime(source, fmt))
+        return _from_datetime_object(datetime.strptime(source, fmt))
     #
     if source == -inf or source is None and past_bound:
         return MIN
@@ -262,69 +359,63 @@ def from_native_type(
     raise ValueError(f"Don’t know how to convert {source!r} into a date")
 
 
+def from_native_type(
+    source: Any,
+    /,
+    *,
+    fmt: str = ISO_DATETIME_FORMAT_UTC,
+    past_bound: bool = False,
+) -> GenericDate:
+    """Create an InfinityDate or RealDate instance from string or another type,
+    assuming infinity in the latter case (deprecated function name)
+    """
+    warnings.warn(
+        "outdated function name, please use fromnative() instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return fromnative(source, fmt=fmt, past_bound=past_bound)
+
+
 def fromtimestamp(timestamp: float) -> GenericDate:
     """Create an InfinityDate or RealDate instance from the provided timestamp"""
-    if timestamp == -inf:
-        return MIN
-    #
-    if timestamp == inf:
-        return MAX
+    if timestamp in _INFINITY_FORMS:
+        return INFINITE_PAST if timestamp == -inf else INFINITE_FUTURE
     #
     stdlib_date_object = date.fromtimestamp(timestamp)
-    return from_datetime_object(stdlib_date_object)
+    return _from_datetime_object(stdlib_date_object)
 
 
-def fromordinal(ordinal: float | int) -> GenericDate:
+def fromordinal(ordinal: int | float) -> GenericDate:
     """Create an InfinityDate or RealDate instance from the provided ordinal"""
-    if ordinal == -inf:
-        return MIN
-    #
-    if ordinal == inf:
-        return MAX
-    #
-    try:
-        new_ordinal = int(ordinal)
-    except ValueError as error:
-        raise ValueError(f"Cannot convert {ordinal!r} to integer") from error
+    if ordinal in _INFINITY_FORMS:
+        return INFINITE_PAST if ordinal == -inf else INFINITE_FUTURE
     #
+    new_ordinal = trunc(ordinal)
     if not MIN_ORDINAL <= new_ordinal <= MAX_ORDINAL:
         raise OverflowError("RealDate value out of range")
     #
     stdlib_date_object = date.fromordinal(new_ordinal)
-    return from_datetime_object(stdlib_date_object)
-
-
-# -----------------------------------------------------------------------------
-# Public module constants continued:
-# minimum and maximum real dates
-# -----------------------------------------------------------------------------
-
-REAL_MIN: Final[GenericDate] = fromordinal(MIN_ORDINAL)
-REAL_MAX: Final[GenericDate] = fromordinal(MAX_ORDINAL)
-
-
-# -----------------------------------------------------------------------------
-# Module-level factory functions continued
-# -----------------------------------------------------------------------------
+    return _from_datetime_object(stdlib_date_object)
 
 
 def fromisoformat(source: str, /) -> GenericDate:
     """Create an InfinityDate or RealDate instance from an iso format representation"""
     lower_source_stripped = source.strip().lower()
-    if lower_source_stripped == INFINITE_DATE_DISPLAY:
-        return MAX
+    if lower_source_stripped == INFINITE_FUTURE_DATE_DISPLAY:
+        return INFINITE_FUTURE
     #
-    if lower_source_stripped == NEGATIVE_INFINITE_DATE_DISPLAY:
-        return MIN
+    if lower_source_stripped == INFINITE_PAST_DATE_DISPLAY:
+        return INFINITE_PAST
     #
-    return from_datetime_object(date.fromisoformat(source))
+    return _from_datetime_object(date.fromisoformat(source))
 
 
 def fromisocalendar(year: int, week: int, weekday: int) -> GenericDate:
     """Create a RealDate instance from an iso calendar date"""
-    return from_datetime_object(date.fromisocalendar(year, week, weekday))
+    return _from_datetime_object(date.fromisocalendar(year, week, weekday))
 
 
 def today() -> GenericDate:
     """Today as RealDate object"""
-    return from_datetime_object(date.today())
+    return _from_datetime_object(date.today())

infdate-0.2.3.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: infdate
+Version: 0.2.3
+Summary: Date object wrapper supporting infinity
+Project-URL: Homepage, https://gitlab.com/blackstream-x/infdate
+Project-URL: CI, https://gitlab.com/blackstream-x/infdate/-/pipelines
+Project-URL: Bug Tracker, https://gitlab.com/blackstream-x/infdate/-/issues
+Project-URL: Repository, https://gitlab.com/blackstream-x/infdate.git
+Author-email: Rainer Schwarzbach <rainer@blackstream.de>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# infdate
+
+_Python module for date calculations implementing a concept of infinity_
+
+## Module description
+
+### Classes overview
+
+    └── GenericDate
+        ├── InfinityDate
+        └── RealDate
+
+
+The base class **GenericDate** should not be instantiated
+but can be used as a type annotation. In fact, it should be preferred
+over the other classes for that purpose.
+
+**InfinityDate** can represent either past or future infinity.
+The module-level constants **INFINITE_PAST** and **INFINITE_FUTURE**
+contain the two possible **InfinityDate** instance variations.
+
+**RealDate** instances represent real dates like the standard library’s
+**[datetime.date]** class, with mostly equal or similar semantics.
+The module -level constants **REAL_MIN** and **REAL_MAX** are the eqivalents
+of **datetime.date.min** and **datetime.date.max** as **RealDate** instances.
+
+For any valid **RealDate** instance, the following is **True**:
+
+``` python
+infdate.MIN < infdate.REAL_MIN <= real_date_instance <= infdate.REAL_MAX < infdate.MAX
+```
+
+### Module-level constants
+
+*   **INFINITE_PAST** = **InfinityDate(**_past_bound_=`True`**)** → infinity before any date
+*   **INFINITE_FUTURE** = **InfinityDate(**_past_bound_=`False`**)** → infinity after any date
+*   **MIN** = **INFINITE_PAST**
+*   **MAX** = **INFINITE_FUTURE**
+*   **REAL_MIN** = **RealDate(**_`1`, `1`, `1`_**)** → the same date as **datetime.date.min**
+*   **REAL_MAX** = **RealDate(**_`9999`, `12`, `31`_**)** → the same date as **datetime.date.max**
+*   **MIN_ORDINAL** = `1` → the same value as **datetime.date.min.toordinal()**
+*   **MAX_ORDINAL** = `3652059` → the same value as **datetime.date.max.toordinal()**
+*   **RESOLUTION** = `1` → represents the lowest possible date difference: _one day_
+
+
+### Module-level factory functions
+
+The following factory methods from the **datetime.date** class
+are provided as module-level functions:
+
+*   **fromtimestamp()** (also accepting **-math.inf** or **math.inf**)
+*   **fromordinal()** (also accepting **-math.inf** or **math.inf**)
+*   **fromisoformat()**
+*   **fromisocalendar()**
+*   **today()**
+
+Two additional factory functions are provided:
+
+*   **fromdatetime()** to create a **RealDate** instance from a
+    **datetime.date** or **datetime.datetime** instance
+    (deprecated old name: _from_datetime_object()_).
+
+*   **fromnative()** to create an **InfinityDate** or **RealDate**
+    instance from a string, from **None**, **-math.inf** or **math.inf**
+    (deprecated old name: _from_native_type()_).
+
+    This can come handy when dealing with API representations of dates,
+    eg. in GitLab’s [Personal Access Tokens API].
+
+
+### Differences between the infdate module classes and datetime.date
+
+Some notable difference from the **datetime.date** class, mainly due to the design decision to express date differences in pure numbers (ie. **float** because **math.inf** also is a float):
+
+*   infdate module classes have no **max**, **min** or **resolution** attributes,
+    but there are [module-level constants] serving the same purpose.
+
+*   The **.toordinal()** method returns **int**, **math.inf**, or **-math.inf**.
+
+*   Subtracting a date from an **InfinityDate** or **RealDate** always returns
+    an **int**, **math.inf**, or **-math.inf** instead of a **datetime.timedelta** instance.
+
+*   Likewise, you cannot add or subtract **datetime.timedelta** instances
+    from an **InfinityDate** or **RealDate**, only **float** or **int**
+    (support for adding and subtracting datetime.timedelta instances might be added in the future, [see the feature request]).
+
+*   infdate module classes have a **.pretty()** method that can be used to format **RealDate** instances with a format string like **.strftime()** (provided with the _fmt_ argument that defaults to the ISO format `%Y-%m-%d`),
+    or to apply a custom format to **InfinityDate** classes using the _inf_common_prefix_, _inf_past_suffix_ and _inf_future_suffix_ arguments.
+
+
+## Example usage
+
+``` pycon
+>>> import infdate
+>>> today = infdate.today()
+>>> today
+RealDate(2025, 6, 30)
+>>> print(f"US date notation: {today:%m/%d/%y}")
+US date notation: 06/30/25
+>>> today.ctime()
+'Mon Jun 30 00:00:00 2025'
+>>> today.isocalendar()
+datetime.IsoCalendarDate(year=2025, week=27, weekday=1)
+>>> yesterday = today - 1
+>>> yesterday.ctime()
+'Sun Jun 29 00:00:00 2025'
+>>> today - yesterday
+1
+>>> infdate.INFINITE_PAST
+InfinityDate(past_bound=True)
+>>> infdate.INFINITE_FUTURE
+InfinityDate(past_bound=False)
+>>> infdate.INFINITE_FUTURE - today
+inf
+>>> infdate.INFINITE_FUTURE - infdate.INFINITE_PAST
+inf
+```
+
+**InfinityDate** and **RealDate** instances can be compared with each other, and also with **datetime.date** instances.
+
+Subtracting **InfinityDate** or **RealDate** and **datetime.date** instances from each other also works:
+
+``` pycon
+>>> from datetime import date
+>>> stdlib_today = date.today()
+>>> stdlib_today
+datetime.date(2025, 6, 30)
+>>> today == stdlib_today
+True
+>>> yesterday < stdlib_today
+True
+>>> yesterday - stdlib_today
+-1
+>>> stdlib_today - yesterday
+1
+>>> stdlib_today - infdate.INFINITE_PAST
+inf
+```
+
+
+* * *
+[datetime.date]: https://docs.python.org/3/library/datetime.html#date-objects
+[Personal Access Tokens API]: https://docs.gitlab.com/api/personal_access_tokens/
+[module-level constants]: #module-level-constants
+[see the feature request]: https://gitlab.com/blackstream-x/infdate/-/issues/6

infdate-0.2.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+infdate/__init__.py,sha256=9YUvBcztVWjzQYvu6N0ISSrG_OoH6BjusxX3TGNNv5s,13774
+infdate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+infdate-0.2.3.dist-info/METADATA,sha256=oX3erUYcGq-4dmRxqqMxyOG_RCHvTivIiFL3WcxaN94,6569
+infdate-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+infdate-0.2.3.dist-info/licenses/LICENSE,sha256=867pxriiObx28vCU1JsRtu3H9kUKyl54e0-xl1IIv3Y,913
+infdate-0.2.3.dist-info/RECORD,,

infdate-0.2.1.dist-info/METADATA

@@ -1,147 +0,0 @@
-Metadata-Version: 2.4
-Name: infdate
-Version: 0.2.1
-Summary: Date object wrapper supporting infinity
-Project-URL: Homepage, https://gitlab.com/blackstream-x/infdate
-Project-URL: CI, https://gitlab.com/blackstream-x/infdate/-/pipelines
-Project-URL: Bug Tracker, https://gitlab.com/blackstream-x/infdate/-/issues
-Project-URL: Repository, https://gitlab.com/blackstream-x/infdate.git
-Author-email: Rainer Schwarzbach <rainer@blackstream.de>
-License-File: LICENSE
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
-# infdate
-
-_Python module for date calculations implementing a concept of infinity_
-
-## Module description
-
-### Classes overview
-
-    └── GenericDate
-        ├── InfinityDate
-        └── RealDate
-
-
-The base class **GenericDate** should not be instantiated but can be used as a type annotation.
-
-**InfinityDate** can represent either positive or negative infinity.
-The module-level constants **MIN** and **MAX** contain the two possible
-**InfinityDate** instance variations.
-
-**RealDate** instances represent real dates like the standard library’s
-**datetime.date** class, with mostly equal or similar semantics. The module -level constants **REAL_MIN** and **REAL_MAX** are the eqivalents of **datetime.date.min** and **datetime.date.max** as **RealDate** instances.
-
-For any valid **RealDate** instance, the following is **True**:
-
-``` python
-infdate.MIN < infdate.REAL_MIN <= real_date_instance <= infdate.REAL_MAX < infdate.MAX
-```
-
-### Module-level factory functions
-
-
-The following factory methods from the **datetime.date** class
-are provided as module-level functions:
-
-*   **fromtimestamp()** (also accepting **-math.inf** or **math.inf**)
-*   **fromordinal()** (also accepting **-math.inf** or **math.inf**)
-*   **fromisoformat()**
-*   **fromisocalendar()**
-*   **today()**
-
-Two additional factory functions are provided:
-
-*   **from_datetime_object()** to create a **RealDate** instance from a
-    **datetime.date** or **datetime.datetime** instance
-
-*   **from_native_type()** to create an **InfinityDate** or **RealDate**
-    instance from a string, from **None**, **-math.inf** or **math.inf**.
-
-    This can come handy when dealing with API representations of dates,
-    eg. in GitLab’s [Personal Access Tokens API].
-
-
-### Differences between infdate classes and datetime.date
-
-Some notable difference from the **datetime.date** class, mainly due to the design decision to express date differences in pure numbers (ie. **float** because **math.inf** also is a float):
-
-*   The **.toordinal()** method returns **float** instead of **int**
-
-*   The **resolution** attribute is **1.0** instead of **datetime.timedelta(days=1)**
-    but also represents exactly one day.
-
-*   Subtracting a date from an **InfinityDate** or **RealDate** always returns a float instead of a **datetime.timedelta** instance.
-
-*   Likewise, you cannot add or subtract **datetime.timedelta** instances
-    from an **InfinityDate** or **RealDate**, only **float** or **int** (support for adding and subtracting datetime.timedelta instances might be added in the future).
-
-
-## Example usage
-
-``` pycon
->>> import infdate
->>> today = infdate.today()
->>> today
-RealDate(2025, 6, 25)
->>> print(today)
-2025-06-25
->>> print(f"US date notation {today:%m/%d/%y}")
-US date notation 06/25/25
->>> today.ctime()
-'Wed Jun 25 00:00:00 2025'
->>> today.isocalendar()
-datetime.IsoCalendarDate(year=2025, week=26, weekday=3)
->>>
->>> yesterday = today - 1
->>> yesterday.ctime()
-'Tue Jun 24 00:00:00 2025'
->>>
->>> today - yesterday
-1.0
->>> infdate.MIN
-InfinityDate(past_bound=True)
->>> infdate.MAX
-InfinityDate(past_bound=False)
->>> infdate.MAX - today
-inf
->>> infdate.MAX - infdate.MIN
-inf
-```
-
-**InfinityDate** and **RealDate** instances can be compared with each other, and also with **datetime.date** instances.
-
-Subtracting instances from each other also works, but currently, `__rsub__` is not implemented yet, so although the other direction works, subtracting an **InfinityDate** or **RealDate** _from_ a **datetime.date**
-currently still raises a **TypeError**):
-
-    >>> from datetime import date
-    >>> stdlib_today = date.today()
-    >>> today == stdlib_today
-    True
-    >>> yesterday < stdlib_today
-    True
-    >>> yesterday - stdlib_today
-    -1.0
-    >>> stdlib_today - yesterday
-    Traceback (most recent call last):
-      File "<python-input-22>", line 1, in <module>
-        stdlib_today - yesterday
-        ~~~~~~~~~~~~~^~~~~~~~~~~
-    TypeError: unsupported operand type(s) for -: 'datetime.date' and 'RealDate'
-
-
-
-* * *
-[Personal Access Tokens API]: https://docs.gitlab.com/api/personal_access_tokens/

infdate-0.2.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-infdate/__init__.py,sha256=n3WfJnHma_FGelLrkOjBt4gj49P-_rlsqc0FTLmUxCI,11195
-infdate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-infdate-0.2.1.dist-info/METADATA,sha256=V85LBfMkyB66rZJI4ceghR0KL-x0b2RQoOo-0_Sr77s,5205
-infdate-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-infdate-0.2.1.dist-info/licenses/LICENSE,sha256=867pxriiObx28vCU1JsRtu3H9kUKyl54e0-xl1IIv3Y,913
-infdate-0.2.1.dist-info/RECORD,,