add totuple method and tests

Author: ScottBoyce

DateIntervalCycler/DateIntervalCycler.py

@@ -137,6 +137,12 @@ class DateIntervalCycler:
                only_start=False, only_end=False, step=1) -> list[Union[dt.datetime, tuple[dt.datetime, dt.datetime]]]:
             Converts the intervals to a list.
 
+        totuple(start_override=None, end_override=None, from_current_position=False
+                ) -> list[Union[dt.datetime, tuple[dt.datetime, dt.datetime]]]:
+            Return a tuple containing the first_interval_start, and then all the remaining
+            interval_end dates (including last_interval_end).
+            Note: `cid.totuple() == tuple(cid.tolist(only_start=True)) + (cid.last_interval_end,)`
+
         set_first_interval_start(first_interval_start, start_before_first_interval=False):
             Sets the start date of the interval range. Changing the start date invokes reset().
 
@@ -1194,6 +1200,79 @@ def _tolist_intervals(self, only_start: bool, only_end: bool, step: int):
                     lst.append(self.interval)
         return lst
 
+    def totuple(
+        self,
+        start_override: Union[None, dt.datetime, dt.date, int] = None,
+        end_override: Union[None, dt.datetime, dt.date, int] = None,
+        from_current_position: bool = False,
+    ) -> tuple[dt.datetime, ...]:
+        """
+        Return a tuple containing the first_interval_start, and then all
+        the remaining interval_end dates (including last_interval_end).
+
+        The tuple can use the current interval as the start or use all the intervals.
+        The tuple can optionally specify a different starting and/or ending date.
+        If last_interval_end is None, then end_override must be specified,
+        so there is an end to the tuple.
+
+        Note, both the end date and end_override dates are inclusive.
+
+        Note2, self.totuple() == tuple(self.tolist(only_start=True)) + (self.last_interval_end,)
+               len(self.totuple()) == len(self.tolist()) + 1
+
+        Args:
+            start_override (Union[None, dt.datetime, dt.date, int], optional): Override for the start date of the list.
+                                                                               If int, then the interval at index is the
+                                                                               start of the list. Defaults to None.
+            end_override (Union[None, dt.datetime, dt.date, int], optional): Override for the end date of the list.
+                                                                             If int, then the (index-1) interval is the
+                                                                             end of the list. Defaults to None.
+            from_current_position (bool, optional): Flag to start list from current interval. Defaults to False.
+
+
+        Returns:
+            tuple[dt.datetime, ...]: The DateIntervalCycler date series as a tuple.
+        """
+
+        if not self._has_last_end_date and end_override is None:
+            raise ValueError(
+                "\nDateIntervalCycler.totuple must specify an ending date\n"
+                "either when initializing the DateIntervalCycler object with `end=` or\n"
+                "or by passing `end_override` into this function."
+            )
+
+        cid = self.copy()  # No reset, but do a shallow copy
+
+        if start_override is not None:
+            if isinstance(start_override, int):
+                cid.set_first_interval_start(self[start_override][0])
+            else:
+                cid.set_first_interval_start(start_override)
+
+        elif not from_current_position:
+            cid.reset()
+
+        if end_override is not None:
+            if isinstance(end_override, int):
+                end_override = self[end_override][0]
+            elif type(end_override) is not dt.datetime:
+                try:
+                    end_override = dt.datetime(end_override.year, end_override.month, end_override.day)
+                except AttributeError:
+                    raise ValueError(
+                        "\nDateIntervalCycler.set_last_interval_end: Invalid last_interval_end.\n"
+                        f"Received: {end_override}"
+                    )
+            cid._last_end_date = end_override
+            cid._has_last_end_date = True
+            cid._len = -999  # no need to recalculate for dummy variable
+            if end_override <= cid._p0_date:
+                cid._at_last_interval = 1
+            if end_override <= cid._first_start_date:
+                return ()
+
+        return tuple(it for it in cid.iter(only_start=True)) + (cid._last_end_date,)
+
     def _to_datetime(self, p, y: Optional[int] = None, feb29_move_next_fix=True) -> dt.datetime:
         """
         Internal method that converts a cycle index to a datetime object using current interval's

pyproject.toml

@@ -41,6 +41,7 @@ content-type = "text/markdown"
 [tool.pytest.ini_options]
 # agressive parallel options
 addopts = "-ra --dist worksteal -nauto" # Defaults to parallel tests, comment out if you want serial.
+# addopts = "-ra -v --dist worksteal -nauto" # parallel run with verbose output.
 # addopts="-ra --dist worksteal -nauto --run-slow-skip"  # run skip tests and skip subset tests
 # addopts="-ra --dist worksteal -nauto -m 'not slow'"  # on run fast tests
 # addopts = "-ra --dist worksteal -nauto -q"  # supress output during testing

tests/test_simple_edge_cases.py

@@ -215,6 +215,178 @@ def test_large_date_range():
     assert len(intervals) == len(cid) == 100
 
 
+def test_leap_year_handling_len1_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2019, 2, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 1 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple((dt(2019, 1, 1), dt(2019, 2, 1)))
+
+    cid = DateIntervalCycler([(2, 29)], dt(2020, 1, 1), dt(2020, 2, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 2
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple((dt(2020, 1, 1), dt(2020, 2, 1)))
+
+
+def test_leap_year_handling_len2_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2020, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 2 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2019, 1, 1), dt(2019, 2, 28), dt(2020, 1, 1)),
+    )
+    cid = DateIntervalCycler([(2, 29)], dt(2020, 1, 1), dt(2021, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 2 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2020, 1, 1), dt(2020, 2, 29), dt(2021, 1, 1)),
+    )
+
+
+def test_leap_year_handling_len3_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2021, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 3 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2019, 1, 1), dt(2019, 2, 28), dt(2020, 2, 29), dt(2021, 1, 1)),
+    )
+
+    cid = DateIntervalCycler([(2, 29)], dt(2020, 1, 1), dt(2022, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 3 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2020, 1, 1), dt(2020, 2, 29), dt(2021, 2, 28), dt(2022, 1, 1)),
+    )
+
+
+def test_leap_year_handling_len4_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2022, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 4 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2019, 1, 1), dt(2019, 2, 28), dt(2020, 2, 29), dt(2021, 2, 28), dt(2022, 1, 1)),
+    )
+
+
+def test_leap_year_handling_len6_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2024, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 6 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (
+            dt(2019, 1, 1),
+            dt(2019, 2, 28),
+            dt(2020, 2, 29),
+            dt(2021, 2, 28),
+            dt(2022, 2, 28),
+            dt(2023, 2, 28),
+            dt(2024, 1, 1),
+        ),
+    )
+
+
+def test_leap_year_handling_len7_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2025, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 7 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (
+            dt(2019, 1, 1),
+            dt(2019, 2, 28),
+            dt(2020, 2, 29),
+            dt(2021, 2, 28),
+            dt(2022, 2, 28),
+            dt(2023, 2, 28),
+            dt(2024, 2, 29),
+            dt(2025, 1, 1),
+        ),
+    )
+
+
+def test_leap_year_handling_len8_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2026, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 8 + 1
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (
+            dt(2019, 1, 1),
+            dt(2019, 2, 28),
+            dt(2020, 2, 29),
+            dt(2021, 2, 28),
+            dt(2022, 2, 28),
+            dt(2023, 2, 28),
+            dt(2024, 2, 29),
+            dt(2025, 2, 28),
+            dt(2026, 1, 1),
+        ),
+    )
+
+
+def test_leap_year_handling_totuple():
+    cid = DateIntervalCycler([(2, 29)], dt(2019, 1, 1), dt(2021, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 4
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2019, 1, 1), dt(2019, 2, 28), dt(2020, 2, 29), dt(2021, 1, 1)),
+    )
+
+
+def test_cycle_on_year_edge_totuple():
+    cid = DateIntervalCycler([(1, 1), (12, 31)], dt(2020, 1, 1), dt(2021, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 3
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2020, 1, 1), dt(2020, 12, 31), dt(2021, 1, 1)),
+    )
+
+
+def test_monthly_cycle_totuple():
+    cid = DateIntervalCycler([(1, 15), (2, 15)], dt(2020, 1, 1), dt(2021, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == 4
+    assert len(date_series) == len(cid) + 1
+    assert date_series == tuple(
+        (dt(2020, 1, 1), dt(2020, 1, 15), dt(2020, 2, 15), dt(2021, 1, 1)),
+    )
+
+
+def test_one_day_cycle_totuple():
+    cid = DateIntervalCycler([(1, 1)], dt(2020, 1, 1), dt(2020, 1, 2))
+    date_series = cid.totuple()
+    assert len(date_series) == 2
+    assert date_series == tuple((dt(2020, 1, 1), dt(2020, 1, 2)))
+
+    cid = DateIntervalCycler([(1, 1), (1, 2)], dt(2020, 1, 1), dt(2020, 1, 3))
+    date_series = cid.totuple()
+    assert len(date_series) == 3
+    assert date_series == tuple((dt(2020, 1, 1), dt(2020, 1, 2), dt(2020, 1, 3)))
+
+
+def test_large_date_range_totuple():
+    cid = DateIntervalCycler([(1, 1)], dt(2000, 1, 1), dt(2100, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == len(cid) + 1 == 100 + 1
+
+    cid = DateIntervalCycler([(1, 1)], dt(2000, 1, 1), dt(2100, 1, 2))
+    date_series = cid.totuple()
+    assert len(date_series) == len(cid) + 1 == 101 + 1  # extra interval for (dt(2100, 1, 1), dt(2100, 1, 2))
+
+    cid = DateIntervalCycler([(1, 1)], dt(2000, 1, 30), dt(2100, 1, 1))
+    date_series = cid.totuple()
+    assert len(date_series) == len(cid) + 1 == 100 + 1
+
+
 def test_invalid_month():
     with pytest.raises(ValueError):
         DateIntervalCycler([(13, 1)], dt(2020, 1, 1), dt(2021, 1, 1))

tests/test_size_attribute.py

@@ -124,6 +124,7 @@ def test_size_attribute_cycle():
             for end in end_list:
                 cid = DateIntervalCycler(cycles, start, end)
                 assert cid.size == len(cid.tolist())
+                assert cid.size == len(cid.totuple()) - 1
 
 
 def test_size_attribute_cycle_with_set():
@@ -134,4 +135,5 @@ def test_size_attribute_cycle_with_set():
             cid.set_first_interval_start(start)
             for end in end_list:
                 cid.set_last_interval_end(end)
-                assert len(cid) == len(cid.tolist())  # len(cid) == cid.size
+                assert len(cid) == len(cid.tolist())
+                assert len(cid) == len(cid.totuple()) - 1