infdate 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

infdate/__init__.py

@@ -5,278 +5,284 @@ infdate: a wrapper around standard library’s datetime.date objects,
 capable of representing positive and negative infinity
 """
 
-import datetime
-import math
-
+from datetime import date, datetime
+from math import inf
 from typing import final, overload, Any, Final, TypeVar
 
-INFINITY: Final = math.inf
-NEGATIVE_INFINITY: Final = -math.inf
-
-INFINITE_DATE_DISPLAY: Final = "<inf>"
-NEGATIVE_INFINITE_DATE_DISPLAY: Final = "<-inf>"
 
-ISO_DATE_FORMAT: Final = "%Y-%m-%d"
-ISO_DATETIME_FORMAT_UTC: Final = f"{ISO_DATE_FORMAT}T%H:%M:%S.%f%Z"
+INFINITE_DATE_DISPLAY: Final[str] = "<inf>"
+NEGATIVE_INFINITE_DATE_DISPLAY: Final[str] = "<-inf>"
 
-D = TypeVar("D", bound="Date")
+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"
 
-class DateMeta(type):
-    """Date metaclass"""
+MIN_ORDINAL: Final[int] = date.min.toordinal()
+MAX_ORDINAL: Final[int] = date.max.toordinal()
 
-    @property
-    def min(cls: type[D], /) -> D:  # type: ignore[misc]
-        """Minimum possible Date"""
-        return cls(NEGATIVE_INFINITY)
 
-    @property
-    def max(cls: type[D], /) -> D:  # type: ignore[misc]
-        """Maximum possible Date"""
-        return cls(INFINITY)
+_GD = TypeVar("_GD", bound="GenericDate")
 
 
-class Date(metaclass=DateMeta):
-    """Date object capable of representing negative or positive infinity"""
+class GenericDate:
+    """Base Date object derived from an ordinal"""
 
-    resolution = 1
+    # pylint: disable=invalid-name
+    resolution: Final = 1
+    # pylint: enable=invalid-name
 
-    @overload
-    def __init__(self: D, year_or_strange_number: float, /) -> None: ...
-    @overload
-    def __init__(
-        self: D, year_or_strange_number: int, month: int, day: int, /
-    ) -> None: ...
-    @final
-    def __init__(
-        self: D, year_or_strange_number: int | float, /, month: int = 0, day: int = 0
-    ) -> None:
+    def __init__(self, ordinal: float, /) -> None:
         """Create a date-like object"""
-        if isinstance(year_or_strange_number, int):
-            self.__wrapped_date_obj: datetime.date | None = datetime.date(
-                int(year_or_strange_number), month, day
-            )
-            self.__ordinal: float | int = self.__wrapped_date_obj.toordinal()
-        elif math.isnan(year_or_strange_number):
-            raise ValueError("Cannot instantiate from NaN")
-        elif year_or_strange_number in (
-            INFINITY,
-            NEGATIVE_INFINITY,
-        ):
-            self.__ordinal = year_or_strange_number
-            self.__wrapped_date_obj = None
-        else:
-            raise ValueError("Cannot instantiate from a regular deterministic float")
-        #
+        self.__ordinal = ordinal
 
-    def toordinal(self: D) -> float | int:
-        """to ordinal (almost like datetime.date.toordinal())"""
+    def toordinal(self: _GD) -> float:
+        """to ordinal (almost like date.toordinal())"""
         return self.__ordinal
 
-    def get_date_object(self: D) -> datetime.date:
-        """Return the wrapped date object"""
-        if isinstance(self.__wrapped_date_obj, datetime.date):
-            return self.__wrapped_date_obj
-        #
-        raise ValueError("Non-deterministic date")
-
-    @property
-    def year(self: D) -> int:
-        """shortcut: year"""
-        return self.get_date_object().year
-
-    @property
-    def month(self: D) -> int:
-        """shortcut: month"""
-        return self.get_date_object().month
+    def __lt__(self: _GD, other: _GD, /) -> bool:
+        """Rich comparison: less"""
+        return self.__ordinal < other.toordinal()
 
-    @property
-    def day(self: D) -> int:
-        """shortcut: day"""
-        return self.get_date_object().day
+    def __le__(self: _GD, other: _GD, /) -> bool:
+        """Rich comparison: less or equal"""
+        return self < other or self == other
 
-    def replace(self: D, /, year: int = 0, month: int = 0, day: int = 0) -> D:
-        """Return a copy with year, month, and/or date replaced"""
-        internal_object = self.get_date_object()
-        return self.factory(
-            internal_object.replace(
-                year=year or internal_object.year,
-                month=month or internal_object.month,
-                day=day or internal_object.day,
-            )
-        )
+    def __gt__(self: _GD, other: _GD, /) -> bool:
+        """Rich comparison: greater"""
+        return self.__ordinal > other.toordinal()
 
-    def isoformat(self: D) -> str:
-        """Date representation in ISO format"""
-        return self.strftime(ISO_DATE_FORMAT)
+    def __ge__(self: _GD, other: _GD, /) -> bool:
+        """Rich comparison: greater or equal"""
+        return self > other or self == other
 
-    def strftime(self: D, fmt: str, /) -> str:
-        """String representation of the date"""
-        try:
-            date_object = self.get_date_object()
-        except ValueError as error:
-            if self.__ordinal == INFINITY:
-                return INFINITE_DATE_DISPLAY
-            #
-            if self.__ordinal == NEGATIVE_INFINITY:
-                return NEGATIVE_INFINITE_DATE_DISPLAY
-            #
-            raise error from error
-        #
-        return date_object.strftime(fmt or ISO_DATE_FORMAT)
+    def __eq__(self: _GD, other, /) -> bool:
+        """Rich comparison: equals"""
+        return self.__ordinal == other.toordinal()
 
-    __format__ = strftime
+    def __ne__(self: _GD, other, /) -> bool:
+        """Rich comparison: does not equal"""
+        return self.__ordinal != other.toordinal()
 
-    def __bool__(self: D) -> bool:
-        """True if a real date is wrapped"""
-        return self.__wrapped_date_obj is not None
+    def __bool__(self: _GD, /) -> bool:
+        """True only if a real date is wrapped"""
+        return False
 
-    def __hash__(self: D) -> int:
+    def __hash__(self: _GD, /) -> int:
         """hash value"""
         return hash(f"date with ordinal {self.__ordinal}")
 
-    def __add__(self: D, delta: int | float, /) -> D:
+    def _add_days(self: _GD, delta: int | float, /):
         """Add other, respecting maybe-nondeterministic values"""
+        # 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 (INFINITY, NEGATIVE_INFINITY):
+            for infinity_form in (inf, -inf):
                 if observed_item == infinity_form:
-                    return self.factory(infinity_form)
+                    if observed_item == self.__ordinal:
+                        return self
+                    #
+                    return fromordinal(observed_item)
                 #
             #
         #
-        return self.fromordinal(int(self.__ordinal) + int(delta))
+        # +/- 0 corner case
+        if not delta:
+            return self
+        #
+        # Return a RealDate instance if possible
+        return fromordinal(self.__ordinal + delta)
+
+    def __add__(self: _GD, delta: int | float, /) -> _GD:
+        """gd_instance1 + number capability"""
+        return self._add_days(delta)
 
     @overload
-    def __sub__(self: D, other: int | float, /) -> D: ...
+    def __sub__(self: _GD, other: int | float, /) -> _GD: ...
     @overload
-    def __sub__(self: D, other: D, /) -> int | float: ...
+    def __sub__(self: _GD, other: _GD, /) -> int | float: ...
     @final
-    def __sub__(self: D, other: D | int | float, /) -> D | int | float:
+    def __sub__(self: _GD, other: _GD | int | float, /) -> _GD | int | float:
         """subtract other, respecting possibly nondeterministic values"""
         if isinstance(other, (int, float)):
-            return self + -other
+            return self._add_days(-other)
         #
         return self.__ordinal - other.toordinal()
 
-    def __lt__(self: D, other: D, /) -> bool:
-        """Rich comparison: less"""
-        return self.__ordinal < other.toordinal()
+    def __repr__(self: _GD, /) -> str:
+        """String representation of the object"""
+        return f"{self.__class__.__name__}({repr(self.__ordinal)})"
 
-    def __le__(self: D, other: D, /) -> bool:
-        """Rich comparison: less or equal"""
-        return self < other or self == other
+    def __str__(self: _GD, /) -> str:
+        """String display of the object"""
+        return self.isoformat()
 
-    def __gt__(self: D, other: D, /) -> bool:
-        """Rich comparison: greater"""
-        return self.__ordinal > other.toordinal()
+    def isoformat(self: _GD, /) -> str:
+        """Date representation in ISO format"""
+        return self.strftime(ISO_DATE_FORMAT)
 
-    def __ge__(self: D, other: D, /) -> bool:
-        """Rich comparison: greater or equal"""
-        return self > other or self == other
+    def strftime(self: _GD, fmt: str, /) -> str:
+        """String representation of the date"""
+        raise NotImplementedError
 
-    def __eq__(self: D, other, /) -> bool:
-        """Rich comparison: equals"""
-        return self.__ordinal == other.toordinal()
+    def replace(self: _GD, /, year: int = 0, month: int = 0, day: int = 0) -> _GD:
+        """Return a copy with year, month, and/or date replaced"""
+        raise NotImplementedError
 
-    def __ne__(self: D, other, /) -> bool:
-        """Rich comparison: does not equal"""
-        return self.__ordinal != other.toordinal()
 
-    def __repr__(self: D, /) -> str:
+class InfinityDate(GenericDate):
+    """Infinity Date object"""
+
+    def __init__(self, /, *, past_bound: bool = False) -> None:
+        """Store -inf or inf"""
+        ordinal = -inf if past_bound else inf
+        super().__init__(ordinal)
+
+    def __repr__(self, /) -> str:
         """String representation of the object"""
-        try:
-            return f"{self.__class__.__name__}({self.year}, {self.month}, {self.day})"
-        except ValueError:
-            return f"{self.__class__.__name__}({repr(self.__ordinal)})"
+        return f"{self.__class__.__name__}(past_bound={self.toordinal() == -inf})"
+
+    def strftime(self, fmt: str, /) -> str:
+        """String representation of the date"""
+        if self.toordinal() == inf:
+            return INFINITE_DATE_DISPLAY
         #
+        return NEGATIVE_INFINITE_DATE_DISPLAY
+
+    __format__ = strftime
 
-    def __str__(self: D, /) -> str:
+    def replace(self, /, year: int = 0, month: int = 0, day: int = 0):
+        """Not supported in this class"""
+        raise TypeError(
+            f"{self.__class__.__name__} instances do not support .replace()"
+        )
+
+
+# pylint: disable=too-many-instance-attributes
+class RealDate(GenericDate):
+    """Real (deterministic) Date object based on date"""
+
+    def __init__(self, year: int, month: int, day: int) -> None:
+        """Create a date-like object"""
+        self._wrapped_date_object = date(year, month, day)
+        self.year = year
+        self.month = month
+        self.day = day
+        super().__init__(float(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
+        self.isocalendar = self._wrapped_date_object.isocalendar
+        self.ctime = self._wrapped_date_object.ctime
+
+    def __bool__(self, /) -> bool:
+        """True if a real date is wrapped"""
+        return True
+
+    def __repr__(self, /) -> str:
+        """String representation of the object"""
+        return f"{self.__class__.__name__}({self.year}, {self.month}, {self.day})"
+
+    def strftime(self, fmt: str, /) -> str:
         """String representation of the date"""
-        return self.isoformat()
+        return self._wrapped_date_object.strftime(fmt or ISO_DATE_FORMAT)
 
-    @classmethod
-    def today(cls: type[D], /) -> D:
-        """Today as Date object"""
-        return cls.factory(datetime.date.today())
-
-    @classmethod
-    def fromisoformat(
-        cls: type[D],
-        source: str,
-        /,
-    ) -> D:
-        """Create an instance from an iso format representation"""
-        lower_source_stripped = source.strip().lower()
-        if lower_source_stripped == INFINITE_DATE_DISPLAY:
-            return cls(INFINITY)
-        #
-        if lower_source_stripped == NEGATIVE_INFINITE_DATE_DISPLAY:
-            return cls(NEGATIVE_INFINITY)
-        #
-        return cls.factory(datetime.date.fromisoformat(lower_source_stripped))
-
-    @classmethod
-    def fromisocalendar(
-        cls: type[D],
-        /,
-        year: int,
-        week: int,
-        day: int,
-    ) -> D:
-        """Create an instance from an iso calendar date"""
-        return cls.factory(datetime.date.fromisocalendar(year, week, day))
-
-    @classmethod
-    def fromordinal(
-        cls: type[D],
-        source: float | int,
-        /,
-    ) -> D:
-        """Create an instance from a date ordinal"""
-        if isinstance(source, int):
-            return cls.factory(datetime.date.fromordinal(source))
-        #
-        if source in (NEGATIVE_INFINITY, INFINITY):
-            return cls(source)
-        #
-        raise ValueError(f"Invalid source for .fromordinal(): {source!r}")
-
-    @classmethod
-    def from_api_data(
-        cls: type[D],
-        source: Any,
-        /,
-        *,
-        fmt: str = ISO_DATETIME_FORMAT_UTC,
-        past_bound: bool = False,
-    ) -> D:
-        """Create an instance from string or another type,
-        assuming infinity in the latter case
-        """
-        if isinstance(source, str):
-            return cls.factory(datetime.datetime.strptime(source, fmt))
-        #
-        return cls(NEGATIVE_INFINITY if past_bound else INFINITY)
+    __format__ = strftime
 
-    @overload
-    @classmethod
-    def factory(cls: type[D], source: datetime.date | datetime.datetime, /) -> D: ...
-    @overload
-    @classmethod
-    def factory(cls: type[D], source: float, /) -> D: ...
-    @final
-    @classmethod
-    def factory(
-        cls: type[D], source: datetime.date | datetime.datetime | float, /
-    ) -> D:
-        """Create a new instance from a datetime.date or datetime.datetime object,
-        from
-        """
-        if isinstance(source, (datetime.date, datetime.datetime)):
-            return cls(source.year, source.month, source.day)
-        #
-        return cls(source)
+    def replace(self, /, year: int = 0, month: int = 0, day: int = 0):
+        """Return a copy with year, month, and/or date replaced"""
+        internal_object = self._wrapped_date_object
+        return from_datetime_object(
+            internal_object.replace(
+                year=year or internal_object.year,
+                month=month or internal_object.month,
+                day=day or internal_object.day,
+            )
+        )
 
 
-BEFORE_BIG_BANG: Final = Date.max
-SAINT_GLINGLIN: Final = Date.min
+# Absolute minimum and maximum dates
+MIN: Final[GenericDate] = InfinityDate(past_bound=True)
+MAX: Final[GenericDate] = InfinityDate(past_bound=False)
+
+
+# Factory functions
+
+
+def from_datetime_object(source: date | datetime, /) -> GenericDate:
+    """Create a new RealDate instance from a
+    date or datetime object
+    """
+    return RealDate(source.year, source.month, source.day)
+
+
+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
+    """
+    if isinstance(source, str):
+        return from_datetime_object(datetime.strptime(source, fmt))
+    #
+    if source == -inf or source is None and past_bound:
+        return MIN
+    #
+    if source == inf or source is None and not past_bound:
+        return MAX
+    #
+    raise ValueError(f"Don’t know how to convert {source!r} into a date")
+
+
+def fromordinal(ordinal: float | int) -> 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 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)
+
+
+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 == NEGATIVE_INFINITE_DATE_DISPLAY:
+        return MIN
+    #
+    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))
+
+
+def today() -> GenericDate:
+    """Today as RealDate object"""
+    return from_datetime_object(date.today())
+
+
+# Minimum and maximum real dates
+# setattr(RealDate, "min", fromordinal(MIN_ORDINAL))
+# setattr(RealDate, "max", fromordinal(MAX_ORDINAL))

infdate-0.2.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: infdate
+Version: 0.2.0
+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
+
+Class hierarchy:
+
+    └── GenericDate
+        ├── InfinityDate
+        └── RealDate
+
+
+
+**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 similöar semantics.
+
+For any valid **RealDate** instance, the following is **True**:
+
+``` python
+infdate.MIN < infdate.RealDate(1, 1, 1) <= real_date_instance <= infdate.RealDate(9999, 12, 31) < infdate.MAX
+```
+
+The following factory methods from the **datetime.date** class
+are provided as module-level functions:
+
+*   **fromordinal()** (also accepting **-math.inf** or **math.inf**)
+*   **fromisoformat()**
+*   **fromisocalendar()**
+*   **today()**
+
+**fromtimestamp()** is still missing by mistake.
+
+Two additional factory functions are provided in the module:
+
+*   **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].
+
+Some notable difference from the **datetime.date** class:
+
+*   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
+    (because **math.inf** is a float), not a **datetime.timedelta** instance.
+
+*   Likewise, you cannot add or subtract **datetime.timedelta** instances
+    from n **InfinityDate** or **RealDate**, only **loat** or **int**.
+
+
+## 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
+```
+
+You can compare **InfinityDate**, **RealDate** and **datetime.date** instances,
+and subtract them from each other (although currently, `__rsub__` is not implemented yet,
+so subtracting an **InfinityDate** or **RealDate** from a **datetime.date**
+still gives 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.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+infdate/__init__.py,sha256=wBa4EXdkOXSSsX3QpBwx8jIpz3s6UETUoJnTlnqRNhc,9422
+infdate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+infdate-0.2.0.dist-info/METADATA,sha256=_g58qFMeECVrjNn0Z_t3Bggox3GHYXqY9NGVwA75ld4,4573
+infdate-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+infdate-0.2.0.dist-info/licenses/LICENSE,sha256=867pxriiObx28vCU1JsRtu3H9kUKyl54e0-xl1IIv3Y,913
+infdate-0.2.0.dist-info/RECORD,,

infdate/__main__.py

@@ -1,8 +0,0 @@
-"""
-Script functionality
-"""
-
-
-def hello() -> str:
-    """hello pylint C0116"""
-    return "Hello from infdate!"

infdate-0.1.0.dist-info/METADATA

@@ -1,42 +0,0 @@
-Metadata-Version: 2.4
-Name: infdate
-Version: 0.1.0
-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_
-
-The **Date** class provided in this package wraps the standard library’s
-**datetime.date** class and adds the capability to specify dates in positive
-(after everything else) or negative (before everything else) infinity,
-and to do calculations (add days, or subtract days or other **Date** instances)
-with these objects.
-
-For easier usage, differences are expressed as integers (1 = one day)
-or floats (inf and -inf _only_).
-
-These capabilities can come handy when dealing with API representations of dates,
-eg. in GitLab’s [Personal Access Tokens API].
-
-* * *
-[Personal Access Tokens API]: https://docs.gitlab.com/api/personal_access_tokens/

infdate-0.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-infdate/__init__.py,sha256=_gJvzSUHx1bvs6xCWI9fhDniWhFR2RD5VQUaFKZoP7U,8890
-infdate/__main__.py,sha256=RtLjAiDLfFTpSFuU68nKhVfBUkxqDhhIY2jNxgL2cW4,113
-infdate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-infdate-0.1.0.dist-info/METADATA,sha256=p-zgj6Xlvz79e_QBIC0DrmHBilf83e-u7olcyyjLDA4,1821
-infdate-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-infdate-0.1.0.dist-info/licenses/LICENSE,sha256=867pxriiObx28vCU1JsRtu3H9kUKyl54e0-xl1IIv3Y,913
-infdate-0.1.0.dist-info/RECORD,,