Fixed bugs having to do with interval arithmetic.

Author: Eli

tests/test_filter.py

@@ -58,6 +58,49 @@ def test_butterworth_noevenorder():
     with pytest.raises(ValueError):
         butterworth(ts0, order=7)
 
+def _make_hourly_ts(n=200):
+    start = pd.Timestamp(2000, 2, 3)
+    freq = hours(1)
+    data = np.sin(np.linspace(0, 10 * np.pi, n))
+    return rts(data, start, freq)
+
+
+def test_butterworth_both_period_and_frequency_raises():
+    ts0 = _make_hourly_ts()
+    with pytest.raises(ValueError, match="simultaneously"):
+        butterworth(ts0, cutoff_period=hours(40), cutoff_frequency=0.2)
+
+
+def test_butterworth_missing_cutoff_raises():
+    ts0 = _make_hourly_ts()
+    with pytest.raises(ValueError, match="must be given"):
+        butterworth(ts0)
+
+
+def test_butterworth_cutoff_frequency_branch_preserves_freq():
+    ts0 = _make_hourly_ts()
+    ts_filt = butterworth(ts0, cutoff_frequency=0.2)
+    assert ts_filt.index.freq == ts0.index.freq
+    assert ts_filt.shape == ts0.shape
+
+
+def test_butterworth_cutoff_period_string_branch_preserves_freq():
+    ts0 = _make_hourly_ts()
+    # use lowercase 'h' to avoid Pandas4Warning for 'H'
+    ts_filt = butterworth(ts0, cutoff_period="40h")
+    assert ts_filt.index.freq == ts0.index.freq
+    assert ts_filt.shape == ts0.shape
+
+
+def test_butterworth_cutoff_period_calendar_rejected():
+    ts0 = _make_hourly_ts()
+    # Calendar-dependent periods (month/year) should not be allowed for fixed-interval math
+    with pytest.raises(TypeError):
+        butterworth(ts0, cutoff_period="1ME")
+
+
+
+
 def test_godin(filter_params):
     """Test Godin filter on a 1-hour interval series with four frequencies."""
     st = pd.Timestamp(1990, 2, 3, 11, 15)

tests/test_interval_ops.py

@@ -39,3 +39,19 @@ def test_year_rejected():
 def test_zero_division():
     with pytest.raises(ZeroDivisionError):
         safe_divide_interval("1D", "0H")
+
+def test_ratio_ok_when_not_int_required():
+    assert safe_divide_interval("1D", "7h", require_int=False) == pytest.approx(24/7)
+
+def test_mixed_scalar_interval_rejected():
+    with pytest.raises(TypeError):
+        safe_divide_interval(24, "1h")
+    with pytest.raises(TypeError):
+        safe_divide_interval("1h", 24)
+        
+        
+def test_zero_division():
+    with pytest.raises(ZeroDivisionError):
+        safe_divide_interval("1D", "0h")
+
+        

vtools/data/vtime.py

@@ -107,18 +107,24 @@ def to_timedelta(x):
     """
     Convert x to pandas.Timedelta if and only if it represents
     a fixed-length duration.
+
+    Notes
+    -----
+    Numeric values are rejected because they are unit-ambiguous.
     """
     if isinstance(x, (int, np.integer, float)):
-        return pd.Timedelta(x, unit="ns")
+        raise TypeError(
+            "Numeric values are ambiguous as time intervals; "
+            "use a Timedelta, offset (hours(1)), or a string like '1h'."
+        )
 
     if isinstance(x, pd.Timedelta):
         return x
 
-    # FIRST: try Timedelta parsing (handles "1H", "1D", etc.)
+    # 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)
+            x = x.replace("H", "h").replace("d", "D").replace("T", "t")
         return pd.Timedelta(x)
     except Exception:
         pass
@@ -138,8 +144,34 @@ def to_timedelta(x):
     return pd.Timedelta(off.nanos, unit="ns")
 
 
-
 def safe_divide_interval(a, b, *, tol=1e-12, require_int=True):
+    """
+    Divide two intervals (or two scalars) safely.
+
+    - interval / interval -> float ratio (or int if require_int)
+    - scalar / scalar     -> numeric ratio
+    - mixed scalar/interval -> TypeError
+    """
+    a_is_num = isinstance(a, (int, np.integer, float))
+    b_is_num = isinstance(b, (int, np.integer, float))
+
+    if a_is_num and b_is_num:
+        if b == 0:
+            raise ZeroDivisionError("Division by zero")
+        r = a / b
+        if require_int:
+            r_int = int(round(r))
+            if abs(r - r_int) > tol:
+                raise ValueError(f"Scalars are not evenly divisible: {a!r} / {b!r} = {r}")
+            return r_int
+        return float(r)
+
+    if a_is_num or b_is_num:
+        raise TypeError(
+            "safe_divide_interval does not support scalar/interval division; "
+            "use explicit Timedelta scaling instead."
+        )
+
     td_a = to_timedelta(a)
     td_b = to_timedelta(b)
 
@@ -157,4 +189,3 @@ def safe_divide_interval(a, b, *, tol=1e-12, require_int=True):
         return r_int
 
     return float(ratio)
-

vtools/functions/colname_align.py

@@ -55,7 +55,8 @@ def transition_ts(ts0, ts1, names=None, ...):
 
 
 def align_names(result, names):
-    if not names:
+
+    if names is None:
         return result
 
     # Series case

vtools/functions/filter.py

@@ -382,7 +382,7 @@ def _lanczos_impl(
         m = int(1.25 * 2.0 / cf)
     elif type(m) != int:
         try:
-            m = int(m / freq)
+            m = safe_divide_interval(m, freq)
         except:
             raise TypeError(
                 "filter_len was not an int or divisible by filter_len (probably a type incompatiblity)"
@@ -550,7 +550,7 @@ def butterworth(ts, cutoff_period=None, cutoff_frequency=None, order=4):
     if cf is None:
         if not (cutoff_period is None):
             cutoff_period = pd.tseries.frequencies.to_offset(cutoff_period)
-            cf = 2.0 * freq / cutoff_period
+            cf = 2.0 * safe_divide_interval(freq, cutoff_period, require_int=False)
         else:
             cf = butterworth_cutoff_frequencies[interval]
 
@@ -560,12 +560,6 @@ def butterworth(ts, cutoff_period=None, cutoff_frequency=None, order=4):
     out = ts.copy(deep=True)
     out[:] = d2
 
-    #    prop={}
-    #    for key,val in ts.props.items():
-    #        prop[key]=val
-    #    prop[TIMESTAMP]=INST
-    #    prop[AGGREGATION]=INDIVIDUAL
-    #    time_interval
     return out
 
 
@@ -642,14 +636,6 @@ def godin(ts):
     return dfg
 
 
-def convert_span_to_nstep(freq, span):
-    if type(span) == int:
-        return span
-    span = pd.tseries.frequencies.to_offset(span)
-    freq = pd.tseries.frequencies.to_offset(freq)
-    return int(span / freq)
-
-
 def _gf1d(ts, sigma, order, mode, cval, truncate):
     tscopy = ts.copy()
     tscopy.loc[:] = gaussian_filter1d(
@@ -689,7 +675,7 @@ def ts_gaussian_filter(ts, sigma, order=0, mode="reflect", cval=0.0, truncate=4.
     """
     freq = ts.index.freq
     if type(sigma) != int:
-        sigma = convert_span_to_nstep(freq, sigma)
+        sigma = safe_divide_interval(freq, sigma, require_int=True)
 
     if isinstance(ts, pd.Series):
         tsout = _gf1d(