Merge branch 'hotfix/0.5.2'

Author: rlskoeser

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 0.5.2
+- repr for Undate, UndateInterval, and UnDelta now produce fully-qualified, constructor-style strings with deterministic field ordering.
+- Added Undate.unknown_year property and is_unknown() method to check for fully-unknown year/month/day.
+- bugfix: comparisons (eq, gt, lt) and contains (in) now return False when year is unknown
+- bugfix: month durations for non-Gregorian dates now returns an integer when month length is known
+
 ## 0.5.1
 - Correct license identifier in CITATION.cff so it is valid
 

README.md

@@ -121,13 +121,13 @@ earliest and latest possible dates for comparison purposes so you can
 sort dates and compare with equals, greater than, and less than. You
 can also compare with python `datetime.date` objects.
 
-```python
+```python 
 >>> november7_2020 = Undate(2020, 11, 7)
 >>> november_2001 = Undate(2001, 11)
 >>> year2k = Undate(2000)
 >>> ad100 = Undate(100)
 >>> sorted([november7_2020, november_2001, year2k, ad100])
-[<Undate 0100>, <Undate 2000>, <Undate 2001-11>, <Undate 2020-11-07>]
+[undate.Undate(year=100, calendar="Gregorian"), undate.Undate(year=2000, calendar="Gregorian"), undate.Undate(year=2001, month=11, calendar="Gregorian"), undate.Undate(year=2020, month=11, day=7, calendar="Gregorian")]
 >>> november7_2020 > november_2001
 True
 >>> year2k < ad100
@@ -161,17 +161,17 @@ and latest date as part of the range.
 ```python
 >>> from undate import UndateInterval
 >>> UndateInterval(Undate(1900), Undate(2000))
-<UndateInterval 1900/2000>
+undate.UndateInterval(earliest=undate.Undate(year=1900, calendar="Gregorian"), latest=undate.Undate(year=2000, calendar="Gregorian"))
 >>> UndateInterval(Undate(1801), Undate(1900), label="19th century")
+undate.UndateInterval(earliest=undate.Undate(year=1801, calendar="Gregorian"), latest=undate.Undate(year=1900, calendar="Gregorian"), label="19th century")
 >>> UndateInterval(Undate(1801), Undate(1900), label="19th century").duration().days
 36524
-<UndateInterval '19th century' (1801/1900)>
 >>> UndateInterval(Undate(1901), Undate(2000), label="20th century")
-<UndateInterval '20th century' (1901/2000)>
+undate.UndateInterval(earliest=undate.Undate(year=1901, calendar="Gregorian"), latest=undate.Undate(year=2000, calendar="Gregorian"), label="20th century")
 >>> UndateInterval(latest=Undate(2000))  # before 2000
-<UndateInterval ../2000>
+undate.UndateInterval(latest=undate.Undate(year=2000, calendar="Gregorian"))
 >>> UndateInterval(Undate(1900))  # after 1900
-<UndateInterval 1900/>
+undate.UndateInterval(earliest=undate.Undate(year=1900, calendar="Gregorian"))
 >>> UndateInterval(Undate(1900), Undate(2000), label="19th century").duration().days
 36890
 >>> UndateInterval(Undate(2000, 1, 1), Undate(2000, 1,31)).duration().days
@@ -186,15 +186,15 @@ are "ISO8601" and "EDTF" and supported calendars.
 ```python
 >>> from undate import Undate
 >>> Undate.parse("2002", "ISO8601")
-<Undate 2002>
+undate.Undate(year=2002, calendar="Gregorian")
 >>> Undate.parse("2002-05", "EDTF")
-<Undate 2002-05>
+undate.Undate(year=2002, month=5, calendar="Gregorian")
 >>> Undate.parse("--05-03", "ISO8601")
-<Undate --05-03>
+undate.Undate(month=5, day=3, calendar="Gregorian")
 >>> Undate.parse("--05-03", "ISO8601").format("EDTF")
 'XXXX-05-03'
->>> Undate.parse("1800/1900")
-<UndateInterval 1800/1900>
+>>> Undate.parse("1800/1900", format="EDTF")
+undate.UndateInterval(earliest=undate.Undate(year=1800, calendar="Gregorian"), latest=undate.Undate(year=1900, calendar="Gregorian"))
 ```
 
 ### Calendars
@@ -215,26 +215,26 @@ comparison across dates from different calendars.
 >>> from undate import Undate
 >>> tammuz4816 = Undate.parse("26 Tammuz 4816", "Hebrew")
 >>> tammuz4816
-<Undate '26 Tammuz 4816 Anno Mundi' 4816-04-26 (Hebrew)>
+undate.Undate(year=4816, month=4, day=26, label="26 Tammuz 4816 Anno Mundi", calendar="Hebrew")
 >>> rajab495 = Undate.parse("Rajab 495", "Islamic")
 >>> rajab495
-<Undate 'Rajab 495 Hijrī' 0495-07 (Islamic)>
+undate.Undate(year=495, month=7, label="Rajab 495 Islamic", calendar="Islamic")
 >>> y2k = Undate.parse("2001", "EDTF")
 >>> y2k
-<Undate 2001 (Gregorian)>
+undate.Undate(year=2001, calendar="Gregorian")
 >>> [str(d.earliest) for d in [rajab495, tammuz4816, y2k]]
 ['1102-04-28', '1056-07-17', '2001-01-01']
 >>> [str(d.precision) for d in [rajab495, tammuz4816, y2k]]
 ['MONTH', 'DAY', 'YEAR']
 >>> sorted([rajab495, tammuz4816, y2k])
-[<Undate '26 Tammuz 4816 Anno Mundi' 4816-04-26 (Hebrew)>, <Undate 'Rajab 495 Hijrī' 0495-07 (Islamic)>, <Undate 2001 (Gregorian)>]
+[undate.Undate(year=4816, month=4, day=26, label="26 Tammuz 4816 Anno Mundi", calendar="Hebrew"), undate.Undate(year=495, month=7, label="Rajab 495 Islamic", calendar="Islamic"), undate.Undate(year=2001, calendar="Gregorian")]
 ```
 
 ---
 
-For more examples, refer to the code notebooks included in the[examples]
-(https://github.com/dh-tech/undate-python/tree/main/examples/) in this
-repository.
+For more examples, refer to the code notebooks included in the 
+[examples](https://github.com/dh-tech/undate-python/tree/main/examples/) 
+directory in this repository.
 
 ## Documentation
 

src/undate/__init__.py

@@ -1,7 +1,14 @@
-__version__ = "0.5.1"
+__version__ = "0.5.2"
 
-from undate.date import DatePrecision
+from undate.date import DatePrecision, UnDelta
 from undate.undate import Undate, Calendar
 from undate.interval import UndateInterval
 
-__all__ = ["Undate", "UndateInterval", "Calendar", "DatePrecision", "__version__"]
+__all__ = [
+    "Undate",
+    "UndateInterval",
+    "Calendar",
+    "DatePrecision",
+    "UnDelta",
+    "__version__",
+]

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

@@ -21,6 +21,11 @@ class HebrewDateConverter(BaseCalendarConverter):
     name: str = "Hebrew"
     calendar_name: str = "Anno Mundi"
 
+    #: earliest possible year in the Hebrew calendar is year 1, it does not go negative
+    MIN_YEAR: 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)
+
     #: arbitrary known non-leap year; 4816 is a non-leap year with 353 days (minimum possible)
     NON_LEAP_YEAR: int = 4816
     #: arbitrary known leap year; 4837 is a leap year with 385 days (maximum possible)

src/undate/date.py

@@ -145,7 +145,7 @@ def __init__(self, *days: int):
     def __repr__(self):
         # customize string representation  for simpler notation; default
         # specifies full UnInt initialization with upper and lower keywords
-        return f"{self.__class__.__name__}(days=[{self.days.lower},{self.days.upper}])"
+        return f"undate.{self.__class__.__name__}({self.days.lower},{self.days.upper})"
 
     def __eq__(self, other: object) -> bool:
         # is an uncertain duration ever *equal* another, even if the values are the same?

src/undate/interval.py

@@ -70,9 +70,15 @@ def format(self, format) -> str:
         raise ValueError(f"Unsupported format '{format}'")
 
     def __repr__(self) -> str:
-        if self.label:
-            return "<UndateInterval '%s' (%s)>" % (self.label, self)
-        return "<UndateInterval %s>" % self
+        init_opts = {
+            "earliest": repr(self.earliest) if self.earliest else None,
+            "latest": repr(self.latest) if self.latest else None,
+            "label": f"{self.label!r}" if self.label else None,
+        }
+        init_str = ", ".join(
+            [f"{key}={val}" for key, val in init_opts.items() if val is not None]
+        )
+        return f"undate.UndateInterval({init_str})"
 
     def __eq__(self, other) -> bool:
         # currently doesn't support comparison with any other types