meh

Author: bartfeenstra

betty/calendar.py

@@ -0,0 +1,42 @@
+"""
+The calendar API.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from betty.machine_name import MachineName
+
+
+class Calendar(ABC):
+    """
+    A calendar.
+    """
+
+    @property
+    @abstractmethod
+    def id(self) -> MachineName:
+        """
+        The unique calendar ID.
+        """
+
+    @abstractmethod
+    def months(self, year: int, /) -> int:
+        """
+        Get the number of months for the given year.
+        """
+
+    @abstractmethod
+    def days(self, year: int, month: int, /) -> int:
+        """
+        Get the number of days for the given month.
+        """
+
+    @abstractmethod
+    def to_gregorian(self, year: int, month: int, day: int, /) -> tuple[int, int, int]:
+        """
+        Convert a date on this calendar to one on the Gregorian calendar.
+        """

betty/calendars/__init__.py

@@ -0,0 +1,3 @@
+"""
+Reusable calendars.
+"""

betty/calendars/gregorian.py

@@ -0,0 +1,35 @@
+"""
+Gregorian calendars.
+"""
+
+from __future__ import annotations
+
+from calendar import monthrange
+from typing import Final, final, override
+
+from betty.calendar import Calendar
+from betty.classtools import Singleton
+from betty.machine_name import MachineName
+
+
+@final
+class Gregorian(Calendar, Singleton):
+    """
+    The Gregorian calendar.
+
+    This calendar is proleptic, which means it extends back indefinitely.
+    """
+
+    id: Final[MachineName] = MachineName("gregorian")
+
+    @override
+    def months(self, year: int, /) -> int:
+        return 12
+
+    @override
+    def days(self, year: int, month: int, /) -> int:
+        return monthrange(year, month)[1]
+
+    @override
+    def to_gregorian(self, year: int, month: int, day: int, /) -> tuple[int, int, int]:
+        return year, month, day

betty/calendars/julian.py

@@ -0,0 +1,34 @@
+"""
+Julian calendars.
+"""
+
+from __future__ import annotations
+
+from typing import Final, final, override
+
+from convertdate.julian import month_length, to_gregorian
+
+from betty.calendar import Calendar
+from betty.classtools import Singleton
+from betty.machine_name import MachineName
+
+
+@final
+class Julian(Calendar, Singleton):
+    """
+    The Julian calendar.
+    """
+
+    id: Final[MachineName] = MachineName("julian")
+
+    @override
+    def months(self, year: int, /) -> int:
+        raise NotImplementedError
+
+    @override
+    def days(self, year: int, month: int, /) -> int:
+        return month_length(year, month)
+
+    @override
+    def to_gregorian(self, year: int, month: int, day: int, /) -> tuple[int, int, int]:
+        return to_gregorian(year, month, day)

betty/date.py

@@ -4,14 +4,14 @@
 
 from __future__ import annotations
 
-import calendar
 import datetime
 import operator
 from functools import total_ordering
 from typing import TYPE_CHECKING, Any, Final, final, override
 
 from babel import dates
 
+from betty.calendars.gregorian import Gregorian
 from betty.data import Data
 from betty.datas.aggregate.record import FieldDefinition
 from betty.datas.aggregate.record.object import ObjectDefinition
@@ -28,6 +28,7 @@
     from collections.abc import Callable, Mapping
     from types import NotImplementedType
 
+    from betty.calendar import Calendar
     from betty.localizer import Localizer
 
 
@@ -57,18 +58,18 @@
         ),
     },
     samples=[
-        lambda: Sample(Date(), label="Minimal", size=Size.MINIMAL),
+        lambda: Sample(Date(1), label="Minimal", size=Size.MINIMAL),
         lambda: Sample(Date(1970, 1, 1, fuzzy=True), label="Full", size=Size.FULL),
     ],
 )
 class Date(Localizable, Data):
     """
-    A (Gregorian) date.
+    A date.
     """
 
     __slots__ = ("year", "month", "day", "fuzzy", "normalized")
 
-    _localize_formats: Final[dict[tuple[bool, bool, bool], Localizable]] = {
+    _format_date_patterns: Final[dict[tuple[bool, bool, bool], Localizable]] = {
         (True, True, True): pgettext("date", "MMMM d, y"),
         (True, True, False): pgettext("date", "MMMM, y"),
         (True, False, True): pgettext("date", "'day' d 'of the month,' y"),
@@ -85,11 +86,17 @@ def __init__(
         month: int | None = None,
         day: int | None = None,
         *,
+        calendar: Calendar = Gregorian(),  # noqa: B008
         fuzzy: bool = False,
     ):
         if year is None and month is None and day is None:
             raise ValueError("Dates require a year, and/or a month, and/or a day.")
         super().__init__()
+        self.calendar: Final[Calendar] = calendar
+        """
+        The calendar on which the date is expressed.
+        """
+
         self.year: Final[int | None] = year
         """
         The year.
@@ -110,34 +117,38 @@ def __init__(
         Whether the year, month, and/or day are fuzzy, e.g. not exactly known. 
         """
 
-        self.normalized: Final[AnyDate | None] = self._normalize()
-        """
-        The normalized, expanded, comparable variant of this date, if at least a year is available,
-        """
-
-    def _normalize(self) -> AnyDate | None:
+    # @todo Do we use this still?
+    def _get_comparable(self) -> AnyDate | None:
         if self.year is None:
             return None
         if self.month is not None and self.day is not None:
             return self
         if self.month is None:
             month_start = 1
-            month_end = 12
+            month_end = self.calendar.months(self.year)
         else:
             month_start = month_end = self.month
         if self.day is None:
             day_start = 1
-            day_end = calendar.monthrange(self.year, month_end)[1]
+            day_end = self.calendar.days(self.year, month_end)
         else:
             day_start = day_end = self.day
         return DateRange(
-            Date(self.year, month_start, day_start, fuzzy=self.fuzzy),
-            Date(self.year, month_end, day_end, fuzzy=self.fuzzy),
+            Date(
+                *self.calendar.to_gregorian(self.year, month_start, day_start),
+                calendar=Gregorian(),
+                fuzzy=self.fuzzy,
+            ),
+            Date(
+                *self.calendar.to_gregorian(self.year, month_end, day_end),
+                calendar=Gregorian(),
+                fuzzy=self.fuzzy,
+            ),
         )
 
     @override
     def localize(self, localizer: Localizer, /) -> LocalizedStr:
-        pattern = self._localize_formats[
+        pattern = self._format_date_patterns[
             (self.year is not None, self.month is not None, self.day is not None)
         ].localize(localizer)
         localized = LocalizedStr(
@@ -159,25 +170,15 @@ def localize(self, localizer: Localizer, /) -> LocalizedStr:
     def _compare(
         self, other: Any, comparator: Callable[[Any, Any], bool], /
     ) -> bool | NotImplementedType:
-        if not isinstance(other, Date):
+        if not self.year:
             return NotImplemented
-        if self.normalized is self and other.normalized is other:
+        if not isinstance(other, Date):
             return NotImplemented
-        if not self.normalized or not other.normalized:
+        if not other.year:
             return NotImplemented
         return comparator(
-            (
-                self.normalized.year,
-                self.normalized.month,
-                self.normalized.day,
-                self.normalized.fuzzy,
-            ),
-            (
-                other.normalized.year,
-                other.normalized.month,
-                other.normalized.day,
-                other.normalized.fuzzy,
-            ),
+            (self.year, self.month, self.day, self.fuzzy),
+            (other.year, other.month, other.day, other.fuzzy),
         )
 
     def __contains__(self, other: AnyDate) -> bool:
@@ -241,7 +242,7 @@ class DateRange(Localizable, Data):
 
     __slots__ = ("start", "start_is_boundary", "end", "end_is_boundary", "normalized")
 
-    _localize_formats: Final[Mapping[tuple[bool | None, bool | None], Localizable]] = {
+    _localizables: Final[Mapping[tuple[bool | None, bool | None], Localizable]] = {
         (False, False): _("from {start_date} until {end_date}"),
         (False, True): _("from {start_date} until sometime before {end_date}"),
         (True, False): _("from sometime after {start_date} until {end_date}"),
@@ -268,57 +269,43 @@ def __init__(
         self.start_is_boundary: Final[bool] = start_is_boundary
         self.end: Final[Date | None] = end
         self.end_is_boundary: Final[bool] = end_is_boundary
-        self.normalized: Final[DateRange | None] = self._normalize()
-        """
-        The normalized, expanded, comparable variant of this date range, if at least a start and/or end year is available,
-        """
+        self._comparable: Final[DateRange | None] = self._get_comparable()
 
-    def _normalize(self) -> DateRange | None:
-        start = self.start.normalized if self.start else None
-        end = self.end.normalized if self.end else None
-        if start is None and end is None:
-            return None
-        if self.start is start and self.end is end:
+    def _get_comparable(self) -> DateRange | None:
+        if self.start and self.start.year is not None:
             return self
-        return DateRange(
-            None
-            if start is None
-            else start
-            if isinstance(start, Date)
-            else start.start,
-            None if end is None else end if isinstance(end, Date) else end.end,
-            start_is_boundary=self.start_is_boundary,
-            end_is_boundary=self.end_is_boundary,
-        )
+        if self.end and self.end.year is not None:
+            return self
+        return None
 
     @override
     def localize(self, localizer: Localizer, /) -> LocalizedStr:
-        formatter_configuration: tuple[bool | None, bool | None] = (None, None)
-        formatter_arguments = {}
+        localizable_key: tuple[bool | None, bool | None] = (None, None)
+        localizable_args = {}
 
         if self.start:
-            formatter_arguments["start_date"] = self.start.localize(localizer)
-            formatter_configuration = (
+            localizable_args["start_date"] = self.start.localize(localizer)
+            localizable_key = (
                 self.start_is_boundary,
-                formatter_configuration[1],
+                localizable_key[1],
             )
 
         if self.end:
-            formatter_arguments["end_date"] = self.end.localize(localizer)
-            formatter_configuration = (
-                formatter_configuration[0],
+            localizable_args["end_date"] = self.end.localize(localizer)
+            localizable_key = (
+                localizable_key[0],
                 self.end_is_boundary,
             )
 
         return (
             self
-            ._localize_formats[formatter_configuration]
-            .format(**formatter_arguments)
+            ._localizables[localizable_key]
+            .format(**localizable_args)
             .localize(localizer)
         )
 
     def __contains__(self, other: AnyDate) -> bool:
-        if not self.normalized:
+        if not self._comparable:
             return False
 
         if isinstance(other, Date):

pyproject.toml

@@ -22,6 +22,7 @@ dependencies = [
     'aiohttp-client-cache ~= 0.14',
     'aiosqlite ~= 0.21',
     'babel ~= 2.16',
+    'convertdate ~= 2.4',
     'docutils ~= 0.21',
     'geopy ~= 2.4',
     'jinja2 ~= 3.1',