Support duration for unknown hebrew & islamic years

Author: rlskoeser

src/undate/converters/base.py

@@ -148,6 +148,16 @@ class BaseCalendarConverter(BaseDateConverter):
     #: Converter name. Subclasses must define a unique name.
     name: str = "Base Calendar Converter"
 
+    #: arbitrary known non-leap year
+    NON_LEAP_YEAR: int
+    #: arbitrary known leap year
+    LEAP_YEAR: int
+
+    # minimum year for this calendar, if there is one
+    MIN_YEAR: None | int = None
+    # maximum year for this calendar, if there is one
+    MAX_YEAR: None | int = None
+
     def min_month(self) -> int:
         """Smallest numeric month for this calendar."""
         raise NotImplementedError

src/undate/converters/calendars/islamic/converter.py

@@ -26,6 +26,11 @@ class IslamicDateConverter(BaseCalendarConverter):
     #: arbitrary known leap year
     LEAP_YEAR: int = 1458
 
+    # minimum year for islamic calendar is 1 AH, does not go negative
+    MIN_YEAR: None | int = 1
+    # convertdate gives a month 34 for numpy max year 2.5^16, so scale it back a bit
+    MAX_YEAR = int(2.5e12)
+
     def __init__(self):
         self.transformer = IslamicDateTransformer()
 
@@ -71,6 +76,9 @@ def to_gregorian(self, year: int, month: int, day: int) -> tuple[int, int, int]:
         """Convert a Hijri date, specified by year, month, and day,
         to the Gregorian equivalent date. Returns a tuple of year, month, day.
         """
+        print(
+            f"islamic.to_gregorian(year={year}, month={month}, day={day}) = {islamic.to_gregorian(year, month, day)}"
+        )
         return islamic.to_gregorian(year, month, day)
 
     def parse(self, value: str) -> Union[Undate, UndateInterval]:

src/undate/undate.py

@@ -128,11 +128,11 @@ def calculate_earliest_latest(self, year, month, day):
                 min_year = int(str(year).replace(self.MISSING_DIGIT, "0"))
                 max_year = int(str(year).replace(self.MISSING_DIGIT, "9"))
         else:
-            # use the configured min/max allowable years if we
-            # don't have any other bounds
-            # TODO: make calendar-specific? these are min/max for gregorian
-            min_year = self.MIN_ALLOWABLE_YEAR
-            max_year = self.MAX_ALLOWABLE_YEAR
+            # if we don't have any other bounds,
+            # use calendar-specific min year if there is one, otherwise use
+            # the configured min/max allowable years
+            min_year = self.calendar_converter.MIN_YEAR or self.MIN_ALLOWABLE_YEAR
+            max_year = self.calendar_converter.MAX_YEAR or self.MAX_ALLOWABLE_YEAR
 
         # if month is passed in as a string but completely unknown,
         # treat as unknown/none (date precision already set in init)
@@ -192,6 +192,9 @@ def calculate_earliest_latest(self, year, month, day):
         self.earliest = Date(
             *self.calendar_converter.to_gregorian(min_year, earliest_month, min_day)
         )
+        print(
+            f"initializing latest, year={max_year} month={latest_month} day={max_day}"
+        )
         self.latest = Date(
             *self.calendar_converter.to_gregorian(max_year, latest_month, max_day)
         )

tests/test_undate.py

@@ -467,11 +467,13 @@ def test_partiallyknownyear_duration(self):
         # year duration logic should work in other calendars
         # islamic
         assert Undate("108X", calendar="Islamic").duration().days == UnInt(354, 355)
-        # NOTE: completely unknown years is not yet supported for other calendars, will cause an error
-        # assert Undate("XXXX", calendar="Islamic").duration().days == UnInt(354, 355)
+        # completely unknown years is calculated based on representative years
+        assert Undate("XXXX", calendar="Islamic").duration().days == UnInt(354, 355)
         assert Undate("536X", calendar="Hebrew").duration().days == UnInt(353, 385)
         # different set of years could vary
         assert Undate("53X2", calendar="Hebrew").duration().days == UnInt(354, 385)
+        # fully unknown year also works for Hebrew calendar
+        assert Undate("XXX", calendar="Hebrew").duration().days == UnInt(353, 385)
 
     def test_known_year(self):
         assert Undate(2022).known_year is True