infdate 0.1.0__tar.gz

infdate-0.1.0/.gitignore

@@ -0,0 +1,140 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytest and coverage output
+testreport.xml
+coverage.xml
+
+# Morast extracted overrides and results
+docs/reference/
+.morast/overrides/*+extracted.md
+
+# uv lock file
+uv.lock
+

infdate-0.1.0/.gitlab-ci.yml

@@ -0,0 +1,32 @@
+# ==============================================================================
+# Python pipeline for infdate
+# using components
+# ==============================================================================
+
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE != "merge_request_event"
+
+
+include:
+  - component: $CI_SERVER_FQDN/blackstream-x/generic-components/meta-gitlab-security@~latest
+  - component: $CI_SERVER_FQDN/blackstream-x/python-components/meta-uv-pipeline@feature/uv-version
+    inputs:
+      uv-version: "0.7.13"
+      mypy-args: "--exclude tools/"
+      python-version: "3.13"
+      python-variant: "alpine"
+      pylint-args: "--disable=fixme --report=yes"
+      pytest-rules:
+        - if: $CI_COMMIT_TAG == null
+      pytest-matrix:
+        - TEST_PYTHON_VERSION: ["3.10", "3.11", "3.12", "3.14-rc"]
+      pypi-project-name: infdate
+
+
+stages:
+  - codestyle
+  - test
+  - pre-build
+  - build
+  - upload

infdate-0.1.0/LICENSE

@@ -0,0 +1,18 @@
+MIT No Attribution
+
+Copyright 2025 Rainer Schwarzbach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

infdate-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+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/README.md

@@ -0,0 +1,18 @@
+# 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/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "infdate"
+version = "0.1.0"
+description = "Date object wrapper supporting infinity"
+readme = "README.md"
+authors = [
+    { name = "Rainer Schwarzbach", email = "rainer@blackstream.de" }
+]
+requires-python = ">=3.11"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Intended Audience :: Developers",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://gitlab.com/blackstream-x/infdate"
+CI = "https://gitlab.com/blackstream-x/infdate/-/pipelines"
+"Bug Tracker" = "https://gitlab.com/blackstream-x/infdate/-/issues"
+Repository = "https://gitlab.com/blackstream-x/infdate.git"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

infdate-0.1.0/reports/docs/build-info.json

@@ -0,0 +1,8 @@
+{
+  "ci_pipeline_created_at": "2025-06-23T16:10:13Z",
+  "ci_pipeline_id": "1884836730",
+  "ci_pipeline_url": "https://gitlab.com/blackstream-x/infdate/-/pipelines/1884836730",
+  "ci_project_title": "infdate",
+  "ci_project_url": "https://gitlab.com/blackstream-x/infdate",
+  "ci_commit_sha": "de24ba8b624157e46f55f13115ee5c9fcfa5ba7e"
+}

infdate-0.1.0/reports/docs/build-info.md

@@ -0,0 +1,9 @@
+# Build Information
+
+_provided by [glsr-present](https://pypi.org/project/glsr-present/) 0.3.6_
+
+[infdate](https://gitlab.com/blackstream-x/infdate)
+built with pipeline
+[1884836730](https://gitlab.com/blackstream-x/infdate/-/pipelines/1884836730)
+(build started 2025-06-23T16:10:13Z)
+

infdate-0.1.0/reports/test-junit.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><testsuites name="pytest tests"><testsuite name="pytest" errors="0" failures="0" skipped="0" tests="16" time="0.453" timestamp="2025-06-23T16:10:55.667613+00:00" hostname="runner-jhcjxvh-project-71015407-concurrent-0"><testcase classname="tests.test_infdate.Date" name="test_arbitrary_date" time="0.003" /><testcase classname="tests.test_infdate.Date" name="test_float_init" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_ge" time="0.054" /><testcase classname="tests.test_infdate.Date" name="test_gt" time="0.044" /><testcase classname="tests.test_infdate.Date" name="test_hashable" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_le" time="0.053" /><testcase classname="tests.test_infdate.Date" name="test_lt" time="0.043" /><testcase classname="tests.test_infdate.Date" name="test_max" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_min" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_nan_init" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_ne" time="0.044" /><testcase classname="tests.test_infdate.Date" name="test_replace" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_str" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_sub_date" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_sub_or_add_days" time="0.001" /><testcase classname="tests.test_infdate.Date" name="test_today" time="0.001" /></testsuite></testsuites>

infdate-0.1.0/src/infdate/__init__.py

@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+
+"""
+infdate: a wrapper around standard library’s datetime.date objects,
+capable of representing positive and negative infinity
+"""
+
+import datetime
+import math
+
+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"
+
+D = TypeVar("D", bound="Date")
+
+
+class DateMeta(type):
+    """Date metaclass"""
+
+    @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)
+
+
+class Date(metaclass=DateMeta):
+    """Date object capable of representing negative or positive infinity"""
+
+    resolution = 1
+
+    @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:
+        """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")
+        #
+
+    def toordinal(self: D) -> float | int:
+        """to ordinal (almost like datetime.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
+
+    @property
+    def day(self: D) -> int:
+        """shortcut: day"""
+        return self.get_date_object().day
+
+    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 isoformat(self: D) -> str:
+        """Date representation in ISO format"""
+        return self.strftime(ISO_DATE_FORMAT)
+
+    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)
+
+    __format__ = strftime
+
+    def __bool__(self: D) -> bool:
+        """True if a real date is wrapped"""
+        return self.__wrapped_date_obj is not None
+
+    def __hash__(self: D) -> int:
+        """hash value"""
+        return hash(f"date with ordinal {self.__ordinal}")
+
+    def __add__(self: D, delta: int | float, /) -> D:
+        """Add other, respecting maybe-nondeterministic values"""
+        for observed_item in (delta, self.__ordinal):
+            for infinity_form in (INFINITY, NEGATIVE_INFINITY):
+                if observed_item == infinity_form:
+                    return self.factory(infinity_form)
+                #
+            #
+        #
+        return self.fromordinal(int(self.__ordinal) + int(delta))
+
+    @overload
+    def __sub__(self: D, other: int | float, /) -> D: ...
+    @overload
+    def __sub__(self: D, other: D, /) -> int | float: ...
+    @final
+    def __sub__(self: D, other: D | int | float, /) -> D | int | float:
+        """subtract other, respecting possibly nondeterministic values"""
+        if isinstance(other, (int, float)):
+            return self + -other
+        #
+        return self.__ordinal - other.toordinal()
+
+    def __lt__(self: D, other: D, /) -> bool:
+        """Rich comparison: less"""
+        return self.__ordinal < other.toordinal()
+
+    def __le__(self: D, other: D, /) -> bool:
+        """Rich comparison: less or equal"""
+        return self < other or self == other
+
+    def __gt__(self: D, other: D, /) -> bool:
+        """Rich comparison: greater"""
+        return self.__ordinal > other.toordinal()
+
+    def __ge__(self: D, other: D, /) -> bool:
+        """Rich comparison: greater or equal"""
+        return self > other or self == other
+
+    def __eq__(self: D, other, /) -> bool:
+        """Rich comparison: equals"""
+        return self.__ordinal == other.toordinal()
+
+    def __ne__(self: D, other, /) -> bool:
+        """Rich comparison: does not equal"""
+        return self.__ordinal != other.toordinal()
+
+    def __repr__(self: D, /) -> 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)})"
+        #
+
+    def __str__(self: D, /) -> str:
+        """String representation of the date"""
+        return self.isoformat()
+
+    @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)
+
+    @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)
+
+
+BEFORE_BIG_BANG: Final = Date.max
+SAINT_GLINGLIN: Final = Date.min

infdate-0.1.0/src/infdate/__main__.py

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

infdate-0.1.0/tests/test_infdate.py

@@ -0,0 +1,341 @@
+# -None*- coding: utf-8 -*-
+
+"""
+Tests for the infdate module
+"""
+
+import datetime
+import math
+import secrets
+import unittest
+
+
+import infdate
+
+
+MAX_ORDINAL = datetime.date.max.toordinal()
+
+
+def random_deterministic_date() -> infdate.Date:
+    """Helper function: create a random deterministic Date"""
+    return infdate.Date.fromordinal(secrets.randbelow(MAX_ORDINAL) + 1)
+
+
+class VerboseTestCase(unittest.TestCase):
+    """Testcase showinf maximum differences"""
+
+    def setUp(self):
+        """set maxDiff"""
+        self.maxDiff = None  # pylint: disable=invalid-name ; name from unittest module
+
+
+class Date(VerboseTestCase):
+    """Date objects"""
+
+    def test_max(self):
+        """Date.max"""
+        max_date = infdate.Date.max
+        with self.subTest("ordinal"):
+            self.assertEqual(max_date.toordinal(), math.inf)
+        #
+        with self.subTest("bool"):
+            self.assertFalse(max_date)
+        #
+        for attribute in ("year", "month", "day"):
+            with self.subTest("failure", attribute=attribute):
+                self.assertRaisesRegex(
+                    ValueError, "^Non-deterministic date$", getattr, max_date, attribute
+                )
+            #
+        #
+        with self.subTest("repr"):
+            self.assertEqual(repr(max_date), "Date(inf)")
+        #
+        with self.subTest("isoformat"):
+            self.assertEqual(max_date.isoformat(), "<inf>")
+        #
+
+    def test_min(self):
+        """Date.min"""
+        min_date = infdate.Date.min
+        with self.subTest("ordinal"):
+            self.assertEqual(min_date.toordinal(), -math.inf)
+        #
+        with self.subTest("bool"):
+            self.assertFalse(min_date)
+        #
+        for attribute in ("year", "month", "day"):
+            with self.subTest("failure", attribute=attribute):
+                self.assertRaisesRegex(
+                    ValueError, "^Non-deterministic date$", getattr, min_date, attribute
+                )
+            #
+        #
+        with self.subTest("repr"):
+            self.assertEqual(repr(min_date), "Date(-inf)")
+        #
+        with self.subTest("isoformat"):
+            self.assertEqual(min_date.isoformat(), "<-inf>")
+        #
+
+    def test_nan_init(self):
+        """Try to initialize with NaN"""
+        self.assertRaisesRegex(
+            ValueError, "^Cannot instantiate from NaN$", infdate.Date, math.nan
+        )
+
+    def test_float_init(self):
+        """Try to initialize with a regular float"""
+        self.assertRaisesRegex(
+            ValueError,
+            "^Cannot instantiate from a regular deterministic float$",
+            infdate.Date,
+            12.345,
+        )
+
+    def test_arbitrary_date(self):
+        """arbitrary date"""
+        some_date = infdate.Date(2023, 5, 23)
+        expected_ordinal = datetime.date(2023, 5, 23).toordinal()
+        with self.subTest("ordinal"):
+            self.assertEqual(some_date.toordinal(), expected_ordinal)
+        #
+        with self.subTest("bool"):
+            self.assertTrue(some_date)
+        #
+        for attribute, expected_value in (("year", 2023), ("month", 5), ("day", 23)):
+            with self.subTest(
+                "success", attribute=attribute, expected_value=expected_value
+            ):
+                self.assertEqual(getattr(some_date, attribute), expected_value)
+            #
+        #
+        with self.subTest("repr"):
+            self.assertEqual(repr(some_date), "Date(2023, 5, 23)")
+        #
+        with self.subTest("isoformat"):
+            self.assertEqual(some_date.isoformat(), "2023-05-23")
+        #
+
+    def test_replace(self):
+        """.replace() method"""
+        min_date = infdate.Date.min
+        with self.subTest("failure"):
+            self.assertRaisesRegex(
+                ValueError, "^Non-deterministic date$", min_date.replace, month=6
+            )
+        #
+        some_date = infdate.Date(1234, 5, 6)
+        old_year = 1234
+        old_month = 5
+        old_day = 6
+        for new_year in (1, 2000, 5000, 9999):
+            with self.subTest("replaced", new_year=new_year):
+                new_date = some_date.replace(year=new_year)
+                self.assertEqual(new_date.year, new_year)
+                self.assertEqual(new_date.month, old_month)
+                self.assertEqual(new_date.day, old_day)
+            #
+        #
+        for new_month in (1, 4, 7, 12):
+            with self.subTest("replaced", new_month=new_month):
+                new_date = some_date.replace(month=new_month)
+                self.assertEqual(new_date.year, old_year)
+                self.assertEqual(new_date.month, new_month)
+                self.assertEqual(new_date.day, old_day)
+            #
+        #
+        for new_day in (1, 10, 16, 31):
+            with self.subTest("replaced", new_day=new_day):
+                new_date = some_date.replace(day=new_day)
+                self.assertEqual(new_date.year, old_year)
+                self.assertEqual(new_date.month, old_month)
+                self.assertEqual(new_date.day, new_day)
+            #
+        #
+
+    def test_hashable(self):
+        """hash(date_instance) capability; Date instances are usable as dict keys"""
+        isaac = infdate.Date(1643, 1, 4)
+        ada = infdate.Date(1815, 12, 10)
+        birthdays = {isaac: "Newton", ada: "Lovelace"}
+        self.assertEqual(birthdays[isaac], "Newton")
+        self.assertEqual(birthdays[ada], "Lovelace")
+
+    def test_sub_or_add_days(self):
+        """date_instance +/- number of days capability"""
+        bernoulli = infdate.Date(1655, 1, 6)
+        self.assertEqual(bernoulli + 60, infdate.Date(1655, 3, 7))
+        self.assertEqual(bernoulli - 60, infdate.Date(1654, 11, 7))
+        self.assertEqual(bernoulli - math.inf, infdate.Date.min)
+        self.assertEqual(bernoulli + math.inf, infdate.Date.max)
+        self.assertEqual(infdate.Date.max - 1, infdate.Date.max)
+        self.assertEqual(infdate.Date.max + 1, infdate.Date.max)
+        self.assertEqual(infdate.Date.min - 1, infdate.Date.min)
+        self.assertEqual(infdate.Date.min + 1, infdate.Date.min)
+        self.assertEqual(infdate.Date.max - math.inf, infdate.Date.min)
+        self.assertEqual(infdate.Date.max + math.inf, infdate.Date.max)
+        self.assertEqual(infdate.Date.min - math.inf, infdate.Date.min)
+        self.assertEqual(infdate.Date.min + math.inf, infdate.Date.max)
+        self.assertRaises(ValueError, bernoulli.__add__, math.nan)
+        self.assertRaises(ValueError, bernoulli.__sub__, math.nan)
+        # Adding math.nan to or subtrating it from the infinity dates
+        # does not raise an error because infinity is checked first,
+        # before calculating a result
+        self.assertEqual(infdate.Date.min + math.nan, infdate.Date.min)
+        self.assertEqual(infdate.Date.max - math.nan, infdate.Date.max)
+
+    def test_sub_date(self):
+        """date_instance - date_instance capability"""
+        chernobyl = infdate.Date(1986, 4, 26)
+        fukushima = infdate.Date(2011, 3, 11)
+        self.assertEqual(fukushima - chernobyl, 9085)
+        self.assertEqual(chernobyl - fukushima, -9085)
+        self.assertEqual(infdate.Date.max - fukushima, math.inf)
+        self.assertEqual(chernobyl - infdate.Date.min, math.inf)
+        self.assertEqual(infdate.Date.min - fukushima, -math.inf)
+        self.assertEqual(chernobyl - infdate.Date.max, -math.inf)
+        self.assertEqual(infdate.Date.min - infdate.Date.max, -math.inf)
+        self.assertEqual(infdate.Date.max - infdate.Date.min, math.inf)
+        # subtracting infinite dates from themselves results in NaN
+        self.assertTrue(math.isnan(infdate.Date.max - infdate.Date.max))
+        self.assertTrue(math.isnan(infdate.Date.min - infdate.Date.min))
+
+    # pylint: disable=comparison-with-itself ; to show lt/gt ↔ le/ge difference
+
+    def test_lt(self):
+        """less than"""
+        mindate = infdate.Date.min
+        maxdate = infdate.Date.max
+        for iteration in range(1, 1001):
+            random_date = random_deterministic_date()
+            with self.subTest(
+                "compared to <-inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(mindate < random_date)
+                self.assertFalse(random_date < mindate)
+            #
+            with self.subTest(
+                "compared to <inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(random_date < maxdate)
+                self.assertFalse(maxdate < random_date)
+            #
+            with self.subTest(
+                "compared to itself", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(random_date < random_date)
+            #
+        #
+
+    def test_le(self):
+        """less than or equal"""
+        mindate = infdate.Date.min
+        maxdate = infdate.Date.max
+        for iteration in range(1, 1001):
+            random_date = random_deterministic_date()
+            with self.subTest(
+                "compared to <-inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(mindate <= random_date)
+                self.assertFalse(random_date <= mindate)
+            #
+            with self.subTest(
+                "compared to <inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(random_date <= maxdate)
+                self.assertFalse(maxdate <= random_date)
+            #
+            with self.subTest(
+                "compared to itself", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(random_date <= random_date)
+            #
+        #
+
+    def test_gt(self):
+        """greater than"""
+        mindate = infdate.Date.min
+        maxdate = infdate.Date.max
+        for iteration in range(1, 1001):
+            random_date = random_deterministic_date()
+            with self.subTest(
+                "compared to <-inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(mindate > random_date)
+                self.assertTrue(random_date > mindate)
+            #
+            with self.subTest(
+                "compared to <inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(random_date > maxdate)
+                self.assertTrue(maxdate > random_date)
+            #
+            with self.subTest(
+                "compared to itself", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(random_date > random_date)
+            #
+        #
+
+    def test_ge(self):
+        """greater than or equal"""
+        mindate = infdate.Date.min
+        maxdate = infdate.Date.max
+        for iteration in range(1, 1001):
+            random_date = random_deterministic_date()
+            with self.subTest(
+                "compared to <-inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(mindate >= random_date)
+                self.assertTrue(random_date >= mindate)
+            #
+            with self.subTest(
+                "compared to <inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(random_date >= maxdate)
+                self.assertTrue(maxdate >= random_date)
+            #
+            with self.subTest(
+                "compared to itself", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(random_date <= random_date)
+            #
+        #
+
+    def test_ne(self):
+        """not equal"""
+        mindate = infdate.Date.min
+        maxdate = infdate.Date.max
+        for iteration in range(1, 1001):
+            random_date = random_deterministic_date()
+            with self.subTest(
+                "compared to <-inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(mindate != random_date)
+                self.assertTrue(random_date != mindate)
+            #
+            with self.subTest(
+                "compared to <inf>", iteration=iteration, random_date=random_date
+            ):
+                self.assertTrue(random_date != maxdate)
+                self.assertTrue(maxdate != random_date)
+            #
+            with self.subTest(
+                "compared to itself", iteration=iteration, random_date=random_date
+            ):
+                self.assertFalse(random_date != random_date)
+            #
+        #
+
+    def test_str(self):
+        """hash(date_instance) capability; Date instances are usable as dict keys"""
+        isaac = infdate.Date(1643, 1, 4)
+        self.assertEqual(str(isaac), "1643-01-04")
+
+    def test_today(self):
+        """.today() classmethod"""
+        today = datetime.date.today()
+        self.assertEqual(
+            infdate.Date.today(), infdate.Date(today.year, today.month, today.day)
+        )

infdate-0.1.0/tools/ci_get_pypi_token.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# /// script
+# dependencies = [
+#   "requests",
+# ]
+# ///
+
+"""
+Script for outputting athe PYPI token, compare
+<https://stefan.sofa-rockers.org/2024/11/14/gitlab-trusted-publisher/>
+but eliminating the need for curl in the container image
+
+Run using "uv run tools/ci_get_pypi_token.py"
+"""
+
+import os
+
+import requests
+
+
+if __name__ == "__main__":
+    response = requests.post(
+        os.environ.get("PYPI_OIDC_URL"),
+        json={"token": os.environ.get("PYPI_ID_TOKEN")},
+        timeout=10,
+    )
+    print(response.json()["token"])

infdate-0.1.0/tools/codestyle.sh

@@ -0,0 +1,13 @@
+echo -e "--- mypy ---\n"
+uvx mypy --exclude tools/ .
+echo -e "\n--- pylint src ---"
+uvx pylint src
+echo -e "--- pylint tests ---"
+PYTHONPATH=src uvx pylint tests
+echo -e "--- ruff check ---\n"
+uvx ruff check
+echo -e "\n--- ruff format ---\n"
+uvx ruff format
+echo -e "\n--- ty check ---\n"
+# --ignore unresolved-import
+uvx ty check src tests

infdate-0.1.0/tools/pytest.sh

@@ -0,0 +1,2 @@
+python_version=${1:-3.11}
+uvx --python ${python_version} --with-editable . --with pytest-cov pytest --cov src --cov tests --cov-precision 2 --cov-report term-missing tests