Revise frequency handling (partially) and added helpers for division.

Author: Eli

tests/test_extrapolation.py

@@ -12,15 +12,15 @@
 
 # Core test cases
 def test_constant_forward():
-    ts = pd.Series([1, 2, 3], index=pd.date_range("2020-01-01", periods=3, freq="d"))
+    ts = pd.Series([1, 2, 3], index=pd.date_range("2020-01-01", periods=3, freq="D"))
     result = extrapolate_ts(ts, end="2020-01-05", method="constant", val=10)
-    expected = pd.Series([1, 2, 3, 10, 10], index=pd.date_range("2020-01-01", periods=5, freq="d"))
+    expected = pd.Series([1, 2, 3, 10, 10], index=pd.date_range("2020-01-01", periods=5, freq="D"))
     assert_series_equal(result, expected)
 
 def test_constant_backward():
-    ts = pd.Series([4, 5, 6], index=pd.date_range("2020-01-03", periods=3, freq="d"))
+    ts = pd.Series([4, 5, 6], index=pd.date_range("2020-01-03", periods=3, freq="D"))
     result = extrapolate_ts(ts, start="2020-01-01", method="constant", val=0)
-    expected = pd.Series([0, 0, 4, 5, 6], index=pd.date_range("2020-01-01", periods=5, freq="d"))
+    expected = pd.Series([0, 0, 4, 5, 6], index=pd.date_range("2020-01-01", periods=5, freq="D"))
     assert_series_equal(result, expected)
 
 def test_taper_forward():
@@ -58,7 +58,7 @@ def test_taper_without_val():
         extrapolate_ts(ts, end="2020-01-02", method="taper")
 
 def test_linear_with_val_error():
-    ts = pd.Series([1, 2], index=pd.date_range("2020-01-01", periods=2, freq="d"))
+    ts = pd.Series([1, 2], index=pd.date_range("2020-01-01", periods=2, freq="D"))
     with pytest.raises(ValueError, match="does not use 'val'"):
         extrapolate_ts(ts, start="2019-12-30", end="2020-01-03", method="linear_slope", val=99)
 
@@ -91,7 +91,7 @@ def generate_series(start, periods, freq, values=None):
 
 
 def test_taper_across_frequencies():
-    freqs = ["15min", "h", "d"]
+    freqs = ["15min", "h", "D"]
     for freq in freqs:
         ts = generate_series("2020-01-01", periods=2, freq=freq, values=[10, 20])
         interval = ts.index[1] - ts.index[0]
@@ -100,13 +100,13 @@ def test_taper_across_frequencies():
         assert result.index[-1] == end_time
 
 
-def test_taper_across_frequencies():
+def test_taper_across_frequencies2():
     results = {}
-    for freq in ["15min", "h", "d"]:
+    for freq in ["15min", "h", "D"]:
         ts = generate_series("2020-01-01", periods=2, freq=freq, values=[10, 10])  # Ensure 2+ points
         step = ts.index[1] - ts.index[0]
         end_time = ts.index[-1] + 3 * step
         result = extrapolate_ts(ts, end=end_time, method="taper", val=0.0)
-        assert result.index.freqstr.lower() == freq
+        assert result.index.freqstr == freq
         results[freq] = result
 

tests/test_interval_ops.py

@@ -0,0 +1,41 @@
+import pytest
+import pandas as pd
+from vtools.data.vtime import safe_divide_interval
+
+
+def test_int_division():
+    assert safe_divide_interval(24, 1) == 24
+
+
+def test_string_offsets():
+    assert safe_divide_interval("1D", "1h") == 24
+    assert safe_divide_interval("15min", "5min") == 3
+
+
+def test_timedelta():
+    assert safe_divide_interval(pd.Timedelta("1D"), pd.Timedelta("1h")) == 24
+
+
+def test_mixed_types():
+    assert safe_divide_interval("1D", pd.Timedelta("1h")) == 24
+    assert safe_divide_interval(pd.Timedelta("1D"), "1h") == 24
+
+
+def test_non_integer_division_fails():
+    with pytest.raises(ValueError):
+        safe_divide_interval("1D", "7h")
+
+
+def test_month_rejected():
+    with pytest.raises(TypeError):
+        safe_divide_interval("1M", "1D")
+
+
+def test_year_rejected():
+    with pytest.raises(TypeError):
+        safe_divide_interval("1Y", "1D")
+
+
+def test_zero_division():
+    with pytest.raises(ZeroDivisionError):
+        safe_divide_interval("1D", "0H")

tests/test_merge_splice.py

@@ -13,8 +13,8 @@
 @pytest.fixture
 def sample_data():
     """Create sample time series data for tests."""
-    idx1 = pd.date_range("2023-01-01", periods=5, freq="d")
-    idx2 = pd.date_range("2023-01-03", periods=5, freq="d")
+    idx1 = pd.date_range("2023-01-01", periods=5, freq="D")
+    idx2 = pd.date_range("2023-01-03", periods=5, freq="D")
     series1 = pd.Series([1, 2, np.nan, 4, 5], index=idx1, name="A")
     series2 = pd.Series([10, 20, 30, np.nan, 50], index=idx2, name="A")
     df1 = pd.DataFrame({"A": [1, np.nan, 3, 4, 5]}, index=idx1)
@@ -110,7 +110,7 @@ def test_series_merge(self, sample_data):
         result = ts_merge((s1, s2), names="A")
         expected = pd.Series(
             [1, 2, 10, 4, 5, np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -120,7 +120,7 @@ def test_single_column_dataframe(self, sample_data):
         result = ts_merge((df1, df2))
         expected = pd.DataFrame(
             {"A": [1., np.nan, 3., 4., 5., 40., 50.]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -130,15 +130,15 @@ def test_multi_column_dataframe(self, sample_data):
         expected = pd.DataFrame({
             "A": [1., 2., 100, 4, 5, np.nan, 500],
             "B": [10., np.nan, 30, 40, 50, 4000, 5000]
-        }, index=pd.date_range("2023-01-01", periods=7, freq="d"))
+        }, index=pd.date_range("2023-01-01", periods=7, freq="D"))
         pd.testing.assert_frame_equal(result, expected)
 
     def test_series_merge_with_names(self, sample_data):
         s1, s2 = sample_data["series1"], sample_data["series2"]
         result = ts_merge((s1, s2), names="new_name")
         expected = pd.Series(
             [1., 2., 10, 4, 5, np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="new_name"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -148,7 +148,7 @@ def test_dataframe_merge_with_renaming(self, sample_data):
         result = ts_merge((df1, df2), names="Renamed_A")
         expected = pd.DataFrame(
             {"Renamed_A": [1., np.nan, 3., 4., 5., 40, 50]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -157,7 +157,7 @@ def test_dataframe_merge_with_custom_column_selection(self, sample_data):
         result = ts_merge((df_multi1, df_multi2), names=["A"])
         expected = pd.DataFrame(
             {"A": [1, 2, 100, 4, 5, np.nan, 500]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -179,7 +179,7 @@ def test_splice_prefer_first(self, sample_data):
         result = ts_splice((s1, s2), transition="prefer_first")
         expected = pd.Series(
             [1., 2, np.nan, 4, 5, np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -189,7 +189,7 @@ def test_splice_prefer_last(self, sample_data):
         result = ts_splice((s1, s2), transition="prefer_last")
         expected = pd.Series(
             [1., 2, 10, 20., 30., np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -199,7 +199,7 @@ def test_splice_series_with_names(self, sample_data):
         result = ts_splice((s1, s2), names="new_name", transition="prefer_last")
         expected = pd.Series(
             [1, 2, 10, 20, 30, np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="new_name"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -210,7 +210,7 @@ def test_splice_with_custom_transitions(self, sample_data):
         result = ts_splice((s1, s2), transition=transition_points)
         expected = pd.Series(
             [1, 2, np.nan, 4., 30., np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -220,7 +220,7 @@ def test_splice_dataframe_prefer_first(self, sample_data):
         result = ts_splice((df1, df2), transition="prefer_first")
         expected = pd.DataFrame(
             {"A": [1, np.nan, 3, 4, 5, 40, 50]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -229,7 +229,7 @@ def test_splice_dataframe_prefer_last(self, sample_data):
         result = ts_splice((df1, df2), transition="prefer_last")
         expected = pd.DataFrame(
             {"A": [1., np.nan, 10, 20., np.nan, 40, 50]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -239,15 +239,15 @@ def test_splice_multi_column_dataframe(self, sample_data):
         expected = pd.DataFrame({
             "A": [1., 2, 100, 200, 300., np.nan, 500],
             "B": [10., np.nan, 1000., 2000., np.nan, 4000, 5000]
-        }, index=pd.date_range("2023-01-01", periods=7, freq="d"))
+        }, index=pd.date_range("2023-01-01", periods=7, freq="D"))
         pd.testing.assert_frame_equal(result, expected)
 
     def test_splice_with_renaming(self, sample_data):
         s1, s2 = sample_data["series1"], sample_data["series2"]
         result = ts_splice((s1, s2), names="Renamed_A", transition="prefer_last")
         expected = pd.Series(
             [1., 2, 10., 20., 30, np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="Renamed_A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -257,7 +257,7 @@ def test_splice_multi_column_dataframe_with_column_selection(self, sample_data):
         result = ts_splice((df_multi1, df_multi2), names=["A"], transition="prefer_last")
         expected = pd.DataFrame(
             {"A": [1., 2, 100, 200, 300, np.nan, 500]},
-            index=pd.date_range("2023-01-01", periods=7, freq="d")
+            index=pd.date_range("2023-01-01", periods=7, freq="D")
         )
         pd.testing.assert_frame_equal(result, expected)
 
@@ -266,7 +266,7 @@ def test_splice_floor_dates(self, sample_data):
         result = ts_splice((s1, s2), transition="prefer_last", floor_dates=True)
         expected = pd.Series(
             [1., 2, 10, 20., 30., np.nan, 50],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A"
         )
         pd.testing.assert_series_equal(result, expected)
@@ -288,9 +288,9 @@ def test_splice_irregular_series(self, irregular_sample_data):
 class TestErrorConditions:
     def test_mismatched_column_names(self, sample_data):
         df1 = pd.DataFrame({"X": [1, 2, np.nan, 4, 5]}, 
-                           index=pd.date_range("2023-01-01", periods=5, freq="d"))
+                           index=pd.date_range("2023-01-01", periods=5, freq="D"))
         df2 = pd.DataFrame({"Y": [10, 20, np.nan, 40, 50]}, 
-                           index=pd.date_range("2023-01-03", periods=5, freq="d"))
+                           index=pd.date_range("2023-01-03", periods=5, freq="D"))
         with pytest.raises(ValueError, match="All input columns must be identical when `names` is None"):
             ts_merge((df1, df2))
 
@@ -366,7 +366,7 @@ def test_blend_series_no_blend_length_equiv_to_merge(self, sample_data):
         # For reference, this is the same expectation as TestTsMerge.test_series_merge
         expected = pd.Series(
             [1., 2., 10., 4., 5., np.nan, 50.],
-            index=pd.date_range("2023-01-01", periods=7, freq="d"),
+            index=pd.date_range("2023-01-01", periods=7, freq="D"),
             name="A",
         )
         pd.testing.assert_series_equal(result, expected)
@@ -384,7 +384,7 @@ def test_blend_series_integer_window(self, sample_data):
         result = ts_blend((s1, s2), blend_length=2)
 
         # Union index: 2023-01-01..07
-        idx = pd.date_range("2023-01-01", periods=7, freq="d")
+        idx = pd.date_range("2023-01-01", periods=7, freq="D")
 
         # Expected values (see derivation in chat):
         # high-priority gaps (NaN) at days 3, 6, 7 (in union),
@@ -407,7 +407,7 @@ def test_blend_dataframe_integer_window(self, sample_data):
 
         result = ts_blend((df1, df2), blend_length=2)
 
-        idx = pd.date_range("2023-01-01", periods=7, freq="d")
+        idx = pd.date_range("2023-01-01", periods=7, freq="D")
         # Derived expectations for column "A":
         # - Fill high-priority gaps using low where possible
         # - Then blend near gaps using the same kernel as in the series test
@@ -447,7 +447,7 @@ def test_blend_series_with_names(self, sample_data):
         s1, s2 = sample_data["series1"], sample_data["series2"]
         result = ts_blend((s1, s2), names="new_name", blend_length=2)
 
-        idx = pd.date_range("2023-01-01", periods=7, freq="d")
+        idx = pd.date_range("2023-01-01", periods=7, freq="D")
         expected = pd.Series(
             [1.0, 2.0, 10.0, 8.0, 11.25, np.nan, 50.0],
             index=idx,

vtools/data/vtime.py

@@ -18,7 +18,7 @@
 import pandas as pd
 
 
-__all__ = ["seconds", "minutes", "hours", "days", "months", "years"]
+__all__ = ["seconds", "minutes", "hours", "days", "months", "years","to_timedelta", "safe_divide_interval"]
 
 
 def seconds(s):
@@ -91,3 +91,70 @@ def dst_to_standard_naive(ts, dst_zone="US/Pacific", standard_zone="Etc/GMT+8"):
         .tz_localize(None)
     )
     return ts2
+
+
+_FIXED_OFFSET_CLASSES = (
+    pd.offsets.Day,
+    pd.offsets.Hour,
+    pd.offsets.Minute,
+    pd.offsets.Second,
+    pd.offsets.Milli,
+    pd.offsets.Micro,
+    pd.offsets.Nano,
+)
+
+def to_timedelta(x):
+    """
+    Convert x to pandas.Timedelta if and only if it represents
+    a fixed-length duration.
+    """
+    if isinstance(x, (int, np.integer, float)):
+        return pd.Timedelta(x, unit="ns")
+
+    if isinstance(x, pd.Timedelta):
+        return x
+
+    # FIRST: try Timedelta parsing (handles "1H", "1D", etc.)
+    try:
+        if isinstance(x, str):
+            x = x.replace("H", "h").replace("d", "D").replace("T", "t")  # standardize case
+            print(x)
+        return pd.Timedelta(x)
+    except Exception:
+        pass
+
+    # FALLBACK: try fixed pandas offsets
+    try:
+        off = pd.tseries.frequencies.to_offset(x)
+    except Exception as e:
+        raise TypeError(f"Cannot interpret interval {x!r}") from e
+
+    if not isinstance(off, _FIXED_OFFSET_CLASSES):
+        raise TypeError(
+            f"Offset {type(off).__name__} is calendar-dependent "
+            "and not a fixed-length interval"
+        )
+
+    return pd.Timedelta(off.nanos, unit="ns")
+
+
+
+def safe_divide_interval(a, b, *, tol=1e-12, require_int=True):
+    td_a = to_timedelta(a)
+    td_b = to_timedelta(b)
+
+    if td_b == pd.Timedelta(0):
+        raise ZeroDivisionError("Division by zero interval")
+
+    ratio = td_a / td_b
+
+    if require_int:
+        r_int = int(round(ratio))
+        if abs(ratio - r_int) > tol:
+            raise ValueError(
+                f"Intervals are not evenly divisible: {a!r} / {b!r} = {ratio}"
+            )
+        return r_int
+
+    return float(ratio)
+