tonik 0.1.19__tar.gz → 0.1.20__tar.gz

{tonik-0.1.19 → tonik-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tonik
-Version: 0.1.19
+Version: 0.1.20
 Summary: Store time series data as HDF5 files and access them through an API.
 Project-URL: Homepage, https://tsc-tools.github.io/tonik
 Project-URL: Issues, https://github.com/tsc-tools/tonik/issues

{tonik-0.1.19 → tonik-0.1.20}/pixi.lock

@@ -3681,8 +3681,8 @@ packages:
   timestamp: 1763054914403
 - pypi: ./
   name: tonik
-  version: 0.1.19
-  sha256: 03b2f4ca6b94c1b2cf29416606b0ac3bc812c1217ce395773496dfad962da544
+  version: 0.1.20
+  sha256: 34ecbc02a23b22c1e089cf36f78c90c6c214a3e88b9d272f69e349157f1728c6
   requires_dist:
   - h5py>=3.8
   - datashader>=0.14

{tonik-0.1.19 → tonik-0.1.20}/pyproject.toml

@@ -12,7 +12,7 @@ exclude = [
 
 [project]
 name = "tonik"
-version = "0.1.19"
+version = "0.1.20"
 authors = [
   { name="Yannik Behr", email="y.behr@gns.cri.nz" },
   { name="Christof Mueller", email="c.mueller@gns.cri.nz" }

{tonik-0.1.19 → tonik-0.1.20}/src/tonik/utils.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Union
 from datetime import datetime, timezone, timedelta
 
 import numpy as np
@@ -13,12 +13,40 @@ def generate_test_data(dim=1, ndays=30, nfreqs=10,
                        freq_names=None, add_nans=True):
     """
     Generate a 1D or 2D feature for testing.
+
+    Parameters
+    ----------
+    dim : int
+        Dimension of the data (1 or 2).
+    ndays : int
+        Number of days to generate data for.
+    nfreqs : int
+        Number of frequencies (only for dim=2).
+    tstart : datetime
+        Start time of the data.
+    freq : str
+        Frequency of the data (e.g., '10min').
+    intervals : int
+        Number of intervals to generate. If None, calculated from ndays and freq.
+    feature_names : list
+        Names of the features to generate.
+    seed : int
+        Random seed for reproducibility.
+    freq_names : list
+        Names of the frequency dimensions (only for dim=2).
+    add_nans : bool
+        Whether to add NaN values to the data.
+
+    Returns
+    -------
+    xr.Dataset
+        Generated test dataset.
     """
     assert dim < 3
     assert dim > 0
 
     if intervals is None:
-        nints = ndays * 6 * 24
+        nints = ndays * int(pd.Timedelta('1h')/pd.Timedelta(freq)) * 24
     else:
         nints = intervals
     dates = pd.date_range(tstart, freq=freq, periods=nints)
@@ -59,6 +87,116 @@ def generate_test_data(dim=1, ndays=30, nfreqs=10,
     return xds
 
 
+def round_datetime(dt: datetime, interval: Union[int, float, timedelta]) -> datetime:
+    """
+    Find closest multiple of interval to given time.
+
+    Parameters:
+    -----------
+    dt : datetime
+        The datetime to round.
+    interval : Union[int, float, timedelta]
+        The interval to which to round the datetime.
+
+    Returns:
+    --------
+    datetime
+        The rounded datetime.
+    """
+    # Normalize interval to whole seconds (supports float/timedelta inputs)
+    if isinstance(interval, timedelta):
+        interval_sec = int(interval.total_seconds())
+    else:
+        interval_sec = int(interval)
+
+    if interval_sec <= 0:
+        raise ValueError("interval must be positive (seconds)")
+
+    # Accept ObsPy UTCDateTime transparently (preserve type on return)
+    _is_obspy = False
+    try:
+        from obspy import UTCDateTime as _UTCDateTime  # type: ignore
+        if isinstance(dt, _UTCDateTime):
+            _is_obspy = True
+            dt_py = dt.datetime  # Python datetime in UTC
+        else:
+            dt_py = dt
+    except Exception:
+        dt_py = dt
+
+    epoch = (
+        datetime(1970, 1, 1)
+        if dt_py.tzinfo is None
+        else datetime(1970, 1, 1, tzinfo=dt_py.tzinfo)
+    )
+
+    # Compute integer seconds since epoch to avoid float precision issues
+    seconds = int((dt_py - epoch).total_seconds())
+    floored = (seconds + 0.5 * interval_sec) % interval_sec
+    rounded = epoch + timedelta(seconds=seconds + 0.5 * interval_sec - floored)
+
+    if _is_obspy:
+        from obspy import UTCDateTime as _UTCDateTime  # type: ignore
+        return _UTCDateTime(rounded)
+
+    return rounded
+
+
+def floor_datetime(dt: datetime, interval: Union[int, float, timedelta]) -> datetime:
+    """
+    Floor a datetime to the latest multiple of a given interval.
+
+    Assumes ``dt`` represents a UTC time (naive or tz-aware is fine) and
+    aligns against the Unix epoch 1970-01-01T00:00:00Z. The interval is in
+    seconds (int/float) or a timedelta. Returns a datetime with the same
+    "naive vs aware" form as ``dt``.
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> floor_datetime(datetime.fromisoformat('2025-11-27T10:12:43'), 600)
+    datetime.datetime(2025, 11, 27, 10, 10)
+    """
+
+    # Normalize interval to whole seconds (supports float/timedelta inputs)
+    if isinstance(interval, timedelta):
+        interval_sec = int(interval.total_seconds())
+    else:
+        interval_sec = int(interval)
+
+    if interval_sec <= 0:
+        raise ValueError("interval must be positive (seconds)")
+
+    # Accept ObsPy UTCDateTime transparently (preserve type on return)
+    _is_obspy = False
+    try:
+        from obspy import UTCDateTime as _UTCDateTime  # type: ignore
+        if isinstance(dt, _UTCDateTime):
+            _is_obspy = True
+            dt_py = dt.datetime  # Python datetime in UTC
+        else:
+            dt_py = dt
+    except Exception:
+        dt_py = dt
+
+    epoch = (
+        datetime(1970, 1, 1)
+        if dt_py.tzinfo is None
+        else datetime(1970, 1, 1, tzinfo=dt_py.tzinfo)
+    )
+
+    # Compute integer seconds since epoch to avoid float precision issues
+    seconds = int((dt_py - epoch).total_seconds())
+    floored = seconds - (seconds % interval_sec)
+    rounded = epoch + timedelta(seconds=floored)
+
+    if _is_obspy:
+        from obspy import UTCDateTime as _UTCDateTime  # type: ignore
+        return _UTCDateTime(rounded)
+
+    return rounded
+
+
 def get_dt(times):
     """
     Infer the sampling of the time dimension.

tonik-0.1.20/tests/test_utils.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timedelta, timezone
+import numpy as np
+import pytest
+
+from tonik.utils import (extract_consecutive_integers,
+                         generate_test_data,
+                         round_datetime,
+                         floor_datetime)
+
+
+def test_extract_consecutive_integers():
+    nums = [1, 2, 3, 5, 6, 7, 8, 10]
+    assert extract_consecutive_integers(
+        nums) == [[1, 2, 3], [5, 6, 7, 8], [10]]
+    assert extract_consecutive_integers([1]) == [[1]]
+    assert extract_consecutive_integers(np.array([1, 2, 4])) == [[1, 2], [4]]
+
+
+def test_generate_test_data():
+    """
+    Test data generation function.
+    """
+    tstart = datetime.now(timezone.utc) - timedelta(days=30)
+    tstart = floor_datetime(tstart, timedelta(days=1))
+    tstart = tstart.replace(tzinfo=None)
+    data = generate_test_data(tstart='2023-01-01', freq='1min', seed=42,
+                              ndays=3)
+    assert 'datetime' in data.coords
+    assert data.rsam.shape[0] == 3*24*60  # 24 hours + start point
+    assert 'rsam' in data.data_vars
+    assert 'dsar' in data.data_vars
+    # Check for NaNs
+    n_nans = np.isnan(data.dsar.values).sum()
+    assert n_nans == 408
+
+
+def test_floor_datetime_basic_10min():
+    dt = datetime.fromisoformat("2025-11-27T10:12:43")
+    out = floor_datetime(dt, 600)
+    assert out == datetime(2025, 11, 27, 10, 10, 0)
+
+
+def test_floor_datetime_on_boundary():
+    dt = datetime.fromisoformat("2025-11-27T10:20:00")
+    out = floor_datetime(dt, 600)
+    assert out == dt
+
+
+def test_floor_datetime_timedelta_interval():
+    dt = datetime.fromisoformat("2025-11-27T10:29:59")
+    out = floor_datetime(dt, timedelta(minutes=10))
+    assert out == datetime(2025, 11, 27, 10, 20, 0)
+
+
+def test_floor_datetime_invalid_interval():
+    dt = datetime.fromisoformat("2025-11-27T10:12:43")
+    with pytest.raises(ValueError):
+        floor_datetime(dt, 0)
+    with pytest.raises(ValueError):
+        floor_datetime(dt, -15)
+
+
+def test_floor_datetime_preserves_timezone_utc():
+    dt = datetime(2025, 11, 27, 10, 12, 43, tzinfo=timezone.utc)
+    out = floor_datetime(dt, 600)
+    assert out == datetime(2025, 11, 27, 10, 10, 0, tzinfo=timezone.utc)
+
+
+def test_floor_datetime_with_obspy_UTCDateTime():
+    try:
+        from obspy import UTCDateTime
+    except Exception:
+        pytest.skip("obspy not available")
+
+    t = UTCDateTime(2025, 11, 27, 10, 12, 43)
+    out = floor_datetime(t, 600)
+    assert isinstance(out, UTCDateTime)
+    assert out == UTCDateTime(2025, 11, 27, 10, 10, 0)
+
+
+def test_round_datetime_basic_10min():
+    dt = datetime.fromisoformat("2025-11-27T10:12:43")
+    out = round_datetime(dt, 600)
+    assert out == datetime(2025, 11, 27, 10, 10)
+
+    dt = datetime.fromisoformat("2025-11-27T10:10:00")
+    out = round_datetime(dt, 600)
+    assert out == datetime(2025, 11, 27, 10, 10)
+
+    dt = datetime.fromisoformat("2025-11-27T10:17:00")
+    out = round_datetime(dt, 600)
+    assert out == datetime(2025, 11, 27, 10, 20)

tonik-0.1.19/tests/test_utils.py

@@ -1,11 +0,0 @@
-import numpy as np
-
-from tonik.utils import extract_consecutive_integers
-
-
-def test_extract_consecutive_integers():
-    nums = [1, 2, 3, 5, 6, 7, 8, 10]
-    assert extract_consecutive_integers(
-        nums) == [[1, 2, 3], [5, 6, 7, 8], [10]]
-    assert extract_consecutive_integers([1]) == [[1]]
-    assert extract_consecutive_integers(np.array([1, 2, 4])) == [[1, 2], [4]]