Move interval object and tests into separate files

docs/undate/core.rst

@@ -1,13 +1,16 @@
 Undate objects
 ==============
 
-undates and undate intervals
+dates, intervals, and calendar
 ------------------------------
 
 .. autoclass:: undate.undate.Undate
    :members:
 
-.. autoclass:: undate.undate.UndateInterval
+.. autoclass:: undate.undate.Calendar
+   :members:
+
+.. autoclass:: undate.interval.UndateInterval
    :members:
 
 date, timedelta, and date precision

examples/notebooks/shxco_partial_date_durations.ipynb

@@ -316,14 +316,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "metadata": {
     "id": "y_MqgrQW64uI"
    },
    "outputs": [],
    "source": [
+    "from undate import UndateInterval\n",
     "from undate.date import ONE_DAY\n",
-    "from undate.undate import UndateInterval\n",
     "from undate.converters.iso8601 import ISO8601DateFormat\n",
     "\n",
     "def undate_duration(start_date, end_date):\n",

src/undate/__init__.py

@@ -1,6 +1,7 @@
 __version__ = "0.4.0.dev0"
 
 from undate.date import DatePrecision
-from undate.undate import Undate, UndateInterval
+from undate.undate import Undate, Calendar
+from undate.interval import UndateInterval
 
-__all__ = ["Undate", "UndateInterval", "DatePrecision", "__version__"]
+__all__ = ["Undate", "UndateInterval", "Calendar", "DatePrecision", "__version__"]

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

@@ -3,10 +3,10 @@
 from convertdate import hebrew  # type: ignore
 from lark.exceptions import UnexpectedCharacters
 
+from undate import Undate, UndateInterval
 from undate.converters.base import BaseCalendarConverter
 from undate.converters.calendars.hebrew.parser import hebrew_parser
 from undate.converters.calendars.hebrew.transformer import HebrewDateTransformer
-from undate.undate import Undate, UndateInterval
 
 
 class HebrewDateConverter(BaseCalendarConverter):

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

@@ -1,6 +1,6 @@
 from lark import Transformer, Tree
 
-from undate.undate import Undate, Calendar
+from undate import Undate, Calendar
 
 
 class HebrewUndate(Undate):

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

@@ -3,10 +3,10 @@
 from convertdate import islamic  # type: ignore
 from lark.exceptions import UnexpectedCharacters
 
+from undate import Undate, UndateInterval
 from undate.converters.base import BaseCalendarConverter
 from undate.converters.calendars.hijri.parser import hijri_parser
 from undate.converters.calendars.hijri.transformer import HijriDateTransformer
-from undate.undate import Undate, UndateInterval
 
 
 class HijriDateConverter(BaseCalendarConverter):

src/undate/converters/calendars/hijri/transformer.py

@@ -1,6 +1,6 @@
 from lark import Transformer, Tree
 
-from undate.undate import Undate, Calendar
+from undate import Undate, Calendar
 
 
 class HijriUndate(Undate):

src/undate/converters/edtf/converter.py

@@ -2,11 +2,12 @@
 
 from lark.exceptions import UnexpectedCharacters
 
+from undate import Undate, UndateInterval
 from undate.converters.base import BaseDateConverter
 from undate.converters.edtf.parser import edtf_parser
 from undate.converters.edtf.transformer import EDTFTransformer
 from undate.date import DatePrecision
-from undate.undate import Undate, UndateInterval
+
 
 #: character for unspecified digits
 EDTF_UNSPECIFIED_DIGIT: str = "X"

src/undate/converters/edtf/transformer.py

@@ -1,6 +1,6 @@
 from lark import Token, Transformer, Tree
 
-from undate.undate import Undate, UndateInterval
+from undate import Undate, UndateInterval
 
 
 class EDTFTransformer(Transformer):

src/undate/converters/iso8601.py

@@ -1,7 +1,7 @@
 from typing import Dict, List, Union
 
+from undate import Undate, UndateInterval
 from undate.converters.base import BaseDateConverter
-from undate.undate import Undate, UndateInterval
 
 
 class ISO8601DateFormat(BaseDateConverter):

src/undate/interval.py

@@ -0,0 +1,124 @@
+import datetime
+
+# Pre 3.10 requires Union for multiple types, e.g. Union[int, None] instead of int | None
+from typing import Optional, Union
+
+
+from undate import Undate
+from undate.date import ONE_DAY, ONE_YEAR, Timedelta
+from undate.converters.base import BaseDateConverter
+
+
+class UndateInterval:
+    """A date range between two uncertain dates.
+
+    :param earliest: Earliest undate
+    :type earliest: `undate.Undate`
+    :param latest: Latest undate
+    :type latest:  `undate.Undate`
+    :param label: A string to label a specific undate interval, similar to labels of `undate.Undate`.
+    :type label: `str`
+    """
+
+    # date range between two undates
+    earliest: Union[Undate, None]
+    latest: Union[Undate, None]
+    label: Union[str, None]
+
+    # TODO: let's think about adding an optional precision / length /size field
+    # using DatePrecision
+
+    def __init__(
+        self,
+        earliest: Optional[Undate] = None,
+        latest: Optional[Undate] = None,
+        label: Optional[str] = None,
+    ):
+        # for now, assume takes two undate objects;
+        # support conversion from datetime
+        if earliest and not isinstance(earliest, Undate):
+            # NOTE: some overlap with Undate._comparison_type method
+            # maybe support conversion from other formats later
+            if isinstance(earliest, datetime.date):
+                earliest = Undate.from_datetime_date(earliest)
+            else:
+                raise ValueError(
+                    f"earliest date {earliest} cannot be converted to Undate"
+                )
+        if latest and not isinstance(latest, Undate):
+            if isinstance(latest, datetime.date):
+                latest = Undate.from_datetime_date(latest)
+            else:
+                raise ValueError(f"latest date {latest} cannot be converted to Undate")
+
+        # check that the interval is valid
+        if latest and earliest and latest <= earliest:
+            raise ValueError(f"invalid interval {earliest}-{latest}")
+
+        self.earliest = earliest
+        self.latest = latest
+        self.label = label
+
+    def __str__(self) -> str:
+        # using EDTF syntax for open ranges
+        return "%s/%s" % (self.earliest or "..", self.latest or "")
+
+    def format(self, format) -> str:
+        """format this undate interval as a string using the specified format;
+        for now, only supports named converters"""
+        converter_cls = BaseDateConverter.available_converters().get(format, None)
+        if converter_cls:
+            return converter_cls().to_string(self)
+
+        raise ValueError(f"Unsupported format '{format}'")
+
+    def __repr__(self) -> str:
+        if self.label:
+            return "<UndateInterval '%s' (%s)>" % (self.label, self)
+        return "<UndateInterval %s>" % self
+
+    def __eq__(self, other) -> bool:
+        # consider interval equal if both dates are equal
+        return self.earliest == other.earliest and self.latest == other.latest
+
+    def duration(self) -> Timedelta:
+        """Calculate the duration between two undates.
+        Note that durations are inclusive (i.e., a closed interval), and
+        include both the earliest and latest date rather than the difference
+        between them.
+
+        :returns: A duration
+        :rtype: Timedelta
+        """
+        # what is the duration of this date range?
+
+        # if range is open-ended, can't calculate
+        if self.earliest is None or self.latest is None:
+            return NotImplemented
+
+        # if both years are known, subtract end of range from beginning of start
+        if self.latest.known_year and self.earliest.known_year:
+            return self.latest.latest - self.earliest.earliest + ONE_DAY
+
+        # if neither year is known...
+        elif not self.latest.known_year and not self.earliest.known_year:
+            # under what circumstances can we assume that if both years
+            # are unknown the dates are in the same year or sequential?
+            duration = self.latest.earliest - self.earliest.earliest
+            # if we get a negative, we've wrapped from end of one year
+            # to the beginning of the next;
+            # recalculate assuming second date is in the subsequent year
+            if duration.days < 0:
+                end = self.latest.earliest + ONE_YEAR
+                duration = end - self.earliest.earliest
+
+            # add the additional day *after* checking for a negative
+            # or after recalculating with adjusted year
+            duration += ONE_DAY
+
+            return duration
+
+        else:
+            # is there any meaningful way to calculate duration
+            # if one year is known and the other is not?
+            raise NotImplementedError

src/undate/undate.py

@@ -1,8 +1,12 @@
-import datetime
-import re
+from __future__ import annotations
 
+import datetime
 from enum import auto
+import re
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from undate.interval import UndateInterval
 try:
     # StrEnum was only added in python 3.11
     from enum import StrEnum
@@ -14,7 +18,7 @@
 from typing import Dict, Optional, Union
 
 from undate.converters.base import BaseDateConverter
-from undate.date import ONE_DAY, ONE_MONTH_MAX, ONE_YEAR, Date, DatePrecision, Timedelta
+from undate.date import ONE_DAY, ONE_MONTH_MAX, Date, DatePrecision, Timedelta
 
 
 class Calendar(StrEnum):
@@ -218,7 +222,7 @@ def __repr__(self) -> str:
         return f"<Undate{label_str} {self} ({self.calendar.name.title()})>"
 
     @classmethod
-    def parse(cls, date_string, format) -> Union["Undate", "UndateInterval"]:
+    def parse(cls, date_string, format) -> Union["Undate", UndateInterval]:
         """parse a string to an undate or undate interval using the specified format;
         for now, only supports named converters"""
         converter_cls = BaseDateConverter.available_converters().get(format, None)
@@ -487,98 +491,3 @@ def _missing_digit_minmax(
         min_val = int("".join(new_min_val))
         max_val = int("".join(new_max_val))
         return (min_val, max_val)
-
-
-class UndateInterval:
-    """A date range between two uncertain dates.
-
-    :param earliest: Earliest undate
-    :type earliest: `undate.Undate`
-    :param latest: Latest undate
-    :type latest:  `undate.Undate`
-    :param label: A string to label a specific undate interval, similar to labels of `undate.Undate`.
-    :type label: `str`
-    """
-
-    # date range between two undates
-    earliest: Union[Undate, None]
-    latest: Union[Undate, None]
-    label: Union[str, None]
-
-    # TODO: let's think about adding an optional precision / length /size field
-    # using DatePrecision
-
-    def __init__(
-        self,
-        earliest: Optional[Undate] = None,
-        latest: Optional[Undate] = None,
-        label: Optional[str] = None,
-    ):
-        # for now, assume takes two undate objects
-        self.earliest = earliest
-        self.latest = latest
-        self.label = label
-
-    def __str__(self) -> str:
-        # using EDTF syntax for open ranges
-        return "%s/%s" % (self.earliest or "..", self.latest or "")
-
-    def format(self, format) -> str:
-        """format this undate interval as a string using the specified format;
-        for now, only supports named converters"""
-        converter_cls = BaseDateConverter.available_converters().get(format, None)
-        if converter_cls:
-            return converter_cls().to_string(self)
-
-        raise ValueError(f"Unsupported format '{format}'")
-
-    def __repr__(self) -> str:
-        if self.label:
-            return "<UndateInterval '%s' (%s)>" % (self.label, self)
-        return "<UndateInterval %s>" % self
-
-    def __eq__(self, other) -> bool:
-        # consider interval equal if both dates are equal
-        return self.earliest == other.earliest and self.latest == other.latest
-
-    def duration(self) -> Timedelta:
-        """Calculate the duration between two undates.
-        Note that durations are inclusive (i.e., a closed interval), and
-        include both the earliest and latest date rather than the difference
-        between them.
-
-        :returns: A duration
-        :rtype: Timedelta
-        """
-        # what is the duration of this date range?
-
-        # if range is open-ended, can't calculate
-        if self.earliest is None or self.latest is None:
-            return NotImplemented
-
-        # if both years are known, subtract end of range from beginning of start
-        if self.latest.known_year and self.earliest.known_year:
-            return self.latest.latest - self.earliest.earliest + ONE_DAY
-
-        # if neither year is known...
-        elif not self.latest.known_year and not self.earliest.known_year:
-            # under what circumstances can we assume that if both years
-            # are unknown the dates are in the same year or sequential?
-            duration = self.latest.earliest - self.earliest.earliest
-            # if we get a negative, we've wrapped from end of one year
-            # to the beginning of the next;
-            # recalculate assuming second date is in the subsequent year
-            if duration.days < 0:
-                end = self.latest.earliest + ONE_YEAR
-                duration = end - self.earliest.earliest
-
-            # add the additional day *after* checking for a negative
-            # or after recalculating with adjusted year
-            duration += ONE_DAY
-
-            return duration
-
-        else:
-            # is there any meaningful way to calculate duration
-            # if one year is known and the other is not?
-            raise NotImplementedError

tests/test_converters/edtf/test_edtf_transformer.py

@@ -1,7 +1,8 @@
 import pytest
+
+from undate import Undate, UndateInterval
 from undate.converters.edtf.parser import edtf_parser
 from undate.converters.edtf.transformer import EDTFTransformer
-from undate.undate import Undate, UndateInterval
 
 # for now, just test that valid dates can be parsed
 

tests/test_converters/test_edtf.py

@@ -1,7 +1,7 @@
 import pytest
 from undate.converters.edtf import EDTFDateConverter
 from undate.date import DatePrecision
-from undate.undate import Undate, UndateInterval
+from undate import Undate, UndateInterval
 
 
 class TestEDTFDateConverter:

tests/test_converters/test_iso8601.py

@@ -1,5 +1,5 @@
+from undate import Undate, UndateInterval
 from undate.converters.iso8601 import ISO8601DateFormat
-from undate.undate import Undate, UndateInterval
 
 
 class TestISO8601DateFormat: