tsam-xarray 0.5.2__tar.gz → 0.6.0__tar.gz

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/.github/workflows/dependabot-auto-merge.yaml

@@ -13,7 +13,7 @@ jobs:
     if: github.actor == 'dependabot[bot]'
     runs-on: ubuntu-24.04
     steps:
-      - uses: dependabot/fetch-metadata@v2
+      - uses: dependabot/fetch-metadata@v3
         id: metadata
 
       - name: Generate app token

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/.github/workflows/release.yaml

@@ -20,7 +20,7 @@ jobs:
           app-id: ${{ secrets.APP_ID }}
           private-key: ${{ secrets.APP_PRIVATE_KEY }}
 
-      - uses: googleapis/release-please-action@v4
+      - uses: googleapis/release-please-action@v5
         id: release
         with:
           token: ${{ steps.app-token.outputs.token }}

tsam_xarray-0.6.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.6.0"
+}

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.6.0](https://github.com/FBumann/tsam_xarray/compare/v0.5.2...v0.6.0) (2026-05-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* **ClusteringResult:** `time_coords` attribute and the `_time_coords_to_dict` / `_time_coords_from_dict` helpers have been removed. The time index now lives inside the tsam `ClusteringResult` payload (`time_index`) and flows through `aggregate` / `disaggregate` natively. Pre-0.6 JSONs are still loadable — the legacy outer `time_coords` field is forwarded to the inner `time_index` with a `DeprecationWarning`. Re-save to silence the warning. ([#83](https://github.com/FBumann/tsam_xarray/pull/83))
+
+
+### Refactors
+
+* Reuse tsam 3.4's `DatetimeIndex` round-trip in `disaggregate`, dropping the parallel `time_coords` field, the compact serialization helpers, and the manual `MultiIndex` truncation in `_disaggregate_single`. ([#83](https://github.com/FBumann/tsam_xarray/pull/83))
+
+
+### Dependencies
+
+* Bump minimum `tsam` to `>=3.4.0` (required for the `time_index` round-trip above).
+* Bump `googleapis/release-please-action` from 4 to 5. ([#82](https://github.com/FBumann/tsam_xarray/pull/82))
+* Bump `dependabot/fetch-metadata` from 2 to 3. ([#81](https://github.com/FBumann/tsam_xarray/pull/81))
+
 ## [0.5.2](https://github.com/FBumann/tsam_xarray/compare/v0.5.1...v0.5.2) (2026-04-01)
 
 

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsam_xarray
-Version: 0.5.2
+Version: 0.6.0
 Summary: Lightweight xarray wrapper for tsam time series aggregation
 License-Expression: MIT
 License-File: LICENSE
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.11
 Requires-Dist: bottleneck>=1.4
-Requires-Dist: tsam>=3.3.0
+Requires-Dist: tsam>=3.4.0
 Requires-Dist: xarray>=2024.1
 Provides-Extra: plot
 Requires-Dist: plotly>=5; extra == 'plot'

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
 ]
 dependencies = [
     "bottleneck>=1.4",
-    "tsam>=3.3.0",
+    "tsam>=3.4.0",
     "xarray>=2024.1",
 ]
 

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/src/tsam_xarray/_clustering.py

@@ -21,25 +21,6 @@ from tsam_xarray._core import (
 )
 
 
-def _time_coords_to_dict(tc: pd.DatetimeIndex) -> dict[str, Any] | list[str]:
-    """Serialize a DatetimeIndex compactly when possible.
-
-    Regular indices are stored as ``{start, periods, freq}`` (~3 values).
-    Irregular indices fall back to a full ISO string list.
-    """
-    freq = pd.infer_freq(tc)
-    if freq is not None:
-        return {"start": tc[0].isoformat(), "periods": len(tc), "freq": freq}
-    return [t.isoformat() for t in tc]
-
-
-def _time_coords_from_dict(raw: dict[str, Any] | list[str]) -> pd.DatetimeIndex:
-    """Deserialize a DatetimeIndex from either compact or list format."""
-    if isinstance(raw, dict):
-        return pd.date_range(raw["start"], periods=raw["periods"], freq=raw["freq"])
-    return pd.DatetimeIndex(raw)
-
-
 @dataclass(frozen=True, repr=False)
 class ClusteringResult:
     """Reusable clustering result with xarray dimension metadata.
@@ -54,8 +35,6 @@ class ClusteringResult:
         slice_dims: Dimension(s) aggregated independently.
         clusterings: Per-slice tsam clustering.
             Single entry ``{(): result}`` when no slicing.
-        time_coords: Original time coordinates.
-            Needed for ``disaggregate()``.
         n_clusters: Number of clusters.
         n_original_periods: Number of original periods.
         n_timesteps_per_period: Timesteps per period.
@@ -80,7 +59,6 @@ class ClusteringResult:
     cluster_dim: list[str]
     slice_dims: list[str]
     clusterings: dict[tuple[Hashable, ...], tsam.ClusteringResult]
-    time_coords: pd.DatetimeIndex | None = field(default=None, repr=False)
     _cache: dict[str, Any] = field(
         default_factory=dict, repr=False, init=False, compare=False
     )
@@ -427,29 +405,10 @@ class ClusteringResult:
         Returns:
             Data with ``cluster`` and ``timestep`` replaced by
             the original ``time`` dimension.
-
-        Raises:
-            ValueError: If time coordinates are not available
-                (e.g., loaded from an old JSON that predates
-                this feature).
         """
-        if self.time_coords is None:
-            msg = (
-                "No time coordinates available. "
-                "This ClusteringResult was loaded from a JSON file "
-                "that does not contain time coordinate data. "
-                "Re-run aggregate() or save from a newer version."
-            )
-            raise ValueError(msg)
-
         slice_dims = self.slice_dims
         if not slice_dims:
-            cr = self.clusterings[()]
-            return _disaggregate_single(
-                self.time_coords,
-                cr,
-                data,
-            )
+            return _disaggregate_single(self.clusterings[()], data)
 
         import itertools
 
@@ -460,7 +419,7 @@ class ClusteringResult:
             sel = dict(zip(slice_dims, key, strict=True))
             data_slice = data.sel(sel)
             cr = _lookup_clustering(self.clusterings, key)
-            results.append(_disaggregate_single(self.time_coords, cr, data_slice))
+            results.append(_disaggregate_single(cr, data_slice))
 
         return _concat_along_dims(results, slice_dims, slice_coords)
 
@@ -479,15 +438,12 @@ class ClusteringResult:
                     "clustering": cr.to_dict(),
                 }
             )
-        data: dict[str, Any] = {
+        return {
             "time_dim": self.time_dim,
             "cluster_dim": self.cluster_dim,
             "slice_dims": self.slice_dims,
             "clusterings": entries,
         }
-        if self.time_coords is not None:
-            data["time_coords"] = _time_coords_to_dict(self.time_coords)
-        return data
 
     def to_json(self, path: str | Path, **json_kwargs: Any) -> None:
         """Save clustering to JSON file.
@@ -510,21 +466,31 @@ class ClusteringResult:
         Returns:
             The loaded ``ClusteringResult``.
         """
+        # Backcompat: pre-0.6 wrappers stored the time index as an outer
+        # ``time_coords`` key while the inner tsam blob (written by tsam<3.4)
+        # had no ``time_index``. Forward it so disaggregate keeps datetimes.
+        if "time_coords" in data:
+            import warnings
+
+            warnings.warn(
+                "Loading a legacy tsam_xarray JSON with an outer 'time_coords' "
+                "field; re-save with to_json() to silence this warning.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            for entry in data["clusterings"]:
+                entry["clustering"].setdefault("time_index", data["time_coords"])
+
         clusterings: dict[tuple[Hashable, ...], tsam.ClusteringResult] = {}
         for entry in data["clusterings"]:
             key = tuple(entry["key"])
             clusterings[key] = tsam.ClusteringResult.from_dict(entry["clustering"])
 
-        time_coords: pd.DatetimeIndex | None = None
-        if "time_coords" in data:
-            time_coords = _time_coords_from_dict(data["time_coords"])
-
         return cls(
             time_dim=data["time_dim"],
             cluster_dim=data["cluster_dim"],
             slice_dims=data.get("slice_dims", []),
             clusterings=clusterings,
-            time_coords=time_coords,
         )
 
     @classmethod
@@ -653,7 +619,6 @@ def _apply_single(
         cluster_dim=col_dims,
         slice_dims=[],
         clusterings={(): tsam_result.clustering},
-        time_coords=pd.DatetimeIndex(da.coords[time_dim].values),
     )
 
     return AggregationResult(
@@ -670,11 +635,14 @@ def _apply_single(
 
 
 def _disaggregate_single(
-    time_coords: pd.DatetimeIndex,
     cr: tsam.ClusteringResult,
     data: xr.DataArray,
 ) -> xr.DataArray:
-    """Disaggregate a single (non-sliced) DataArray using a ClusteringResult."""
+    """Disaggregate a single (non-sliced) DataArray using a ClusteringResult.
+
+    Relies on tsam's ``cr.disaggregate()`` to return a DataFrame indexed
+    by the original ``DatetimeIndex`` stored on the clustering.
+    """
     other_dims = [str(d) for d in data.dims if d not in ("cluster", "timestep")]
     ordered = data.transpose("cluster", "timestep", *other_dims)
 
@@ -686,10 +654,11 @@ def _disaggregate_single(
     flat = ordered.values.reshape(n_clusters * n_timesteps, -1)
 
     if cr.segment_durations is not None:
-        idx_tuples = []
-        for c in clusters:
-            for seg, dur in enumerate(cr.segment_durations[int(c)]):
-                idx_tuples.append((int(c), seg, int(dur)))
+        idx_tuples = [
+            (int(c), seg, int(dur))
+            for c in clusters
+            for seg, dur in enumerate(cr.segment_durations[int(c)])
+        ]
         mi = pd.MultiIndex.from_tuples(
             idx_tuples, names=["cluster", "segment", "duration"]
         )
@@ -700,12 +669,10 @@ def _disaggregate_single(
 
     df = pd.DataFrame(flat, index=mi, columns=range(flat.shape[1]))
     expanded = cr.disaggregate(df)
-
-    n_original = len(time_coords)
-    vals = expanded.values[:n_original]
+    time_coords = expanded.index
 
     if other_dims:
-        vals = vals.reshape(n_original, *other_sizes)
+        vals = expanded.values.reshape(len(time_coords), *other_sizes)
         result = xr.DataArray(
             vals,
             dims=["time", *other_dims],
@@ -716,7 +683,7 @@ def _disaggregate_single(
                 result = result.assign_coords({d: data.coords[d]})
     else:
         result = xr.DataArray(
-            vals[:, 0],
+            expanded.values[:, 0],
             dims=["time"],
             coords={"time": time_coords},
         )

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/src/tsam_xarray/_core.py

@@ -475,7 +475,6 @@ def _aggregate_single(
         cluster_dim=col_dims,
         slice_dims=[],
         clusterings={(): tsam_result.clustering},
-        time_coords=pd.DatetimeIndex(da.coords[time_dim].values),
     )
 
     return AggregationResult(
@@ -562,7 +561,6 @@ def _concat_results(
         cluster_dim=first.clustering.cluster_dim,
         slice_dims=slice_dims,
         clusterings=merged_clusterings,
-        time_coords=first.clustering.time_coords,
     )
 
     return AggregationResult(

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/src/tsam_xarray/_result.py

@@ -211,10 +211,7 @@ class AggregationResult:
 
     def _disaggregate_single(self, data: xr.DataArray) -> xr.DataArray:
         """Disaggregate without slice dims."""
-        import pandas as pd
-
         from tsam_xarray._clustering import _disaggregate_single
 
-        time_coords = pd.DatetimeIndex(self.original.coords["time"].values)
         cr = self.clustering.clusterings[()]
-        return _disaggregate_single(time_coords, cr, data)
+        return _disaggregate_single(cr, data)

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/src/tsam_xarray/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/test/test_aggregate.py

@@ -1283,30 +1283,8 @@ class TestClusteringDisaggregate:
         expected = result.disaggregate(result.cluster_representatives)
         xr.testing.assert_allclose(dis, expected)
 
-    def test_disaggregate_no_time_coords_raises(self):
-        """ClusteringInfo without time_coords raises ValueError."""
-        from tsam_xarray._clustering import ClusteringInfo
-
-        da = _make_da()
-        da_flat = da.isel(region=0).drop_vars("region")
-        result = tsam_xarray.aggregate(
-            da_flat,
-            time_dim="time",
-            cluster_dim="variable",
-            n_clusters=4,
-        )
-        # Construct a ClusteringInfo without time_coords
-        ci = ClusteringInfo(
-            time_dim="time",
-            cluster_dim=["variable"],
-            slice_dims=[],
-            clusterings=result.clustering.clusterings,
-        )
-        with pytest.raises(ValueError, match="No time coordinates"):
-            ci.disaggregate(result.cluster_representatives)
-
-    def test_json_backward_compat(self, tmp_path):
-        """Old JSON without time_coords loads fine, disaggregate raises."""
+    def test_legacy_time_coords_json(self, tmp_path):
+        """Legacy JSON with outer ``time_coords`` loads with a warning."""
         import json
 
         da = _make_da()
@@ -1320,61 +1298,19 @@ class TestClusteringDisaggregate:
         path = tmp_path / "clustering.json"
         result.clustering.to_json(str(path))
 
-        # Strip time_coords from saved JSON
+        # Forge a pre-0.6 file: outer time_coords + inner blob without time_index.
         with open(path) as f:
             data = json.load(f)
-        del data["time_coords"]
+        tc = data["clusterings"][0]["clustering"].pop("time_index")
+        data["time_coords"] = tc
         with open(path, "w") as f:
             json.dump(data, f)
 
-        clustering = tsam_xarray.load_clustering(str(path))
-        assert clustering.time_coords is None
-        # apply() still works
-        new_result = clustering.apply(da_flat)
-        assert new_result.n_clusters == 4
-        # disaggregate() raises
-        with pytest.raises(ValueError, match="No time coordinates"):
-            clustering.disaggregate(result.cluster_representatives)
-
-    def test_time_coords_in_json(self, tmp_path):
-        """time_coords are serialized in JSON."""
-        import json
+        with pytest.warns(DeprecationWarning, match="legacy tsam_xarray JSON"):
+            clustering = tsam_xarray.load_clustering(str(path))
 
-        da = _make_da()
-        da_flat = da.isel(region=0).drop_vars("region")
-        result = tsam_xarray.aggregate(
-            da_flat,
-            time_dim="time",
-            cluster_dim="variable",
-            n_clusters=4,
-        )
-        path = tmp_path / "clustering.json"
-        result.clustering.to_json(str(path))
-        with open(path) as f:
-            data = json.load(f)
-        assert "time_coords" in data
-        tc = data["time_coords"]
-        # Regular index → compact dict format
-        assert isinstance(tc, dict)
-        assert tc["periods"] == da_flat.sizes["time"]
-
-    def test_time_coords_roundtrip(self, tmp_path):
-        """time_coords survive JSON round-trip."""
-        da = _make_da()
-        da_flat = da.isel(region=0).drop_vars("region")
-        result = tsam_xarray.aggregate(
-            da_flat,
-            time_dim="time",
-            cluster_dim="variable",
-            n_clusters=4,
-        )
-        path = tmp_path / "clustering.json"
-        result.clustering.to_json(str(path))
-        clustering = tsam_xarray.load_clustering(str(path))
-        np.testing.assert_array_equal(
-            result.clustering.time_coords,
-            clustering.time_coords,
-        )
+        dis = clustering.disaggregate(result.cluster_representatives)
+        assert dis.indexes["time"].equals(da_flat.indexes["time"])
 
     def test_1d_disaggregate(self, tmp_path):
         """Disaggregate works on 1D time series."""

{tsam_xarray-0.5.2 → tsam_xarray-0.6.0}/test/test_parametrized.py

@@ -505,61 +505,3 @@ class TestClusteringIORoundtrip:
         clustering = tsam_xarray.load_clustering(str(path))
         new_result = clustering.apply(agg_case.da)
         assert new_result.is_transferred
-
-
-class TestTimeCoordsSerialization:
-    """Compact time_coords serialization helpers."""
-
-    def test_regular_index_compact(self):
-        """Regular DatetimeIndex is stored as {start, periods, freq}."""
-        import pandas as pd
-
-        from tsam_xarray._clustering import _time_coords_to_dict
-
-        tc = pd.date_range("2025-01-01", periods=8760, freq="h")
-        d = _time_coords_to_dict(tc)
-        assert isinstance(d, dict)
-        assert set(d) == {"start", "periods", "freq"}
-        assert d["periods"] == 8760
-
-    def test_regular_index_roundtrip(self):
-        """Compact format round-trips exactly."""
-        import pandas as pd
-
-        from tsam_xarray._clustering import (
-            _time_coords_from_dict,
-            _time_coords_to_dict,
-        )
-
-        tc = pd.date_range("2025-01-01", periods=8760, freq="h")
-        restored = _time_coords_from_dict(_time_coords_to_dict(tc))
-        pd.testing.assert_index_equal(tc, restored)
-
-    def test_irregular_index_fallback(self):
-        """Irregular DatetimeIndex falls back to list of ISO strings."""
-        import pandas as pd
-
-        from tsam_xarray._clustering import (
-            _time_coords_from_dict,
-            _time_coords_to_dict,
-        )
-
-        tc = pd.DatetimeIndex(["2025-01-01", "2025-01-03", "2025-01-07"])
-        d = _time_coords_to_dict(tc)
-        assert isinstance(d, list)
-        restored = _time_coords_from_dict(d)
-        pd.testing.assert_index_equal(tc, restored)
-
-    def test_old_list_format_still_loads(self):
-        """List format (pre-compact) is still accepted by from_dict."""
-        from tsam_xarray._clustering import _time_coords_from_dict
-
-        raw = ["2025-01-01T00:00:00", "2025-01-01T01:00:00"]
-        restored = _time_coords_from_dict(raw)
-        assert len(restored) == 2
-
-    def test_dict_roundtrip_uses_compact(self, agg_case: AggregateCase):
-        """to_dict uses compact format for regular time indices."""
-        result = _aggregate(agg_case)
-        d = result.clustering.to_dict()
-        assert isinstance(d["time_coords"], dict)

tsam_xarray-0.5.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.5.2"
-}