Add DataTree.prune() method …

doc/whats-new.rst

@@ -12,6 +12,11 @@ v2025.07.2 (unreleased)
 
 New Features
 ~~~~~~~~~~~~
+- Added :py:attr:`DataTree.is_data_empty` property to check if a node contains data variables with actual data (:issue:`10590`, :pull:`10598`).
+  By `Alfonso Ladino <https://github.com/aladinor`_.
+- Added :py:meth:`DataTree.prune` method to remove empty nodes while preserving tree structure.
+  Useful for cleaning up DataTree after time-based filtering operations (:issue:`10590`, :pull:`10598`).
+  By `Alfonso Ladino <https://github.com/aladinor`_.
 
 
 Breaking changes

xarray/core/datatree.py

@@ -686,6 +686,13 @@ def is_empty(self) -> bool:
         """False if node contains any data or attrs. Does not look at children."""
         return not (self.has_data or self.has_attrs)
 
+    @property
+    def is_data_empty(self) -> bool:
+        """False if node contains any data variables with actual data. Does not look at children."""
+        if not self._data_variables:
+            return True
+        return not any(var.size > 0 for var in self._data_variables.values())
+
     @property
     def is_hollow(self) -> bool:
         """True if only leaf nodes contain data."""
@@ -1448,6 +1455,42 @@ def filter_like(self, other: DataTree) -> DataTree:
         other_keys = {key for key, _ in other.subtree_with_keys}
         return self.filter(lambda node: node.relative_to(self) in other_keys)
 
+    def prune(self) -> DataTree:
+        """
+        Remove empty nodes from the tree.
+
+        Returns a new tree containing only nodes that contain data variables.
+        Intermediate nodes are kept if they are required to support non-empty children.
+
+        Returns
+        -------
+        DataTree
+            A new tree with empty nodes removed.
+
+        See Also
+        --------
+        filter
+        is_data_empty
+
+        Examples
+        --------
+        >>> dt = xr.DataTree.from_dict(
+        ...     {
+        ...         "/a": xr.Dataset({"foo": ("x", [1, 2])}),
+        ...         "/b": xr.Dataset(),  # empty dataset
+        ...     }
+        ... )
+        >>> dt.prune()
+        <xarray.DataTree>
+        Group: /
+        └── Group: /a
+                Dimensions:  (x: 2)
+                Dimensions without coordinates: x
+                Data variables:
+                    foo      (x) int64 16B 1 2
+        """
+        return self.filter(lambda node: not node.is_data_empty)
+
     def match(self, pattern: str) -> DataTree:
         """
         Return nodes with paths matching pattern.

xarray/tests/test_datatree.py

@@ -1942,6 +1942,75 @@ def test_filter(self) -> None:
         )
         assert_identical(actual, expected)
 
+    def test_is_data_empty(self) -> None:
+        ds_with_data = xr.Dataset({"foo": ("x", [1, 2])})
+        dt_with_data = DataTree(dataset=ds_with_data)
+        assert dt_with_data.is_data_empty is False
+
+        ds_coords_only = xr.Dataset(coords={"x": [1, 2]})
+        dt_coords_only = DataTree(dataset=ds_coords_only)
+        assert dt_coords_only.is_data_empty is True
+
+        dt_empty = DataTree()
+        assert dt_empty.is_data_empty is True
+
+        ds_zero_size = xr.Dataset({"var": ("time", [])})
+        dt_zero_size = DataTree(dataset=ds_zero_size)
+        assert dt_zero_size.is_data_empty is True
+
+    def test_prune_basic(self) -> None:
+        tree = DataTree.from_dict(
+            {"/a": xr.Dataset({"foo": ("x", [1, 2])}), "/b": xr.Dataset()}
+        )
+
+        pruned = tree.prune()
+
+        assert "a" in pruned.children
+        assert "b" not in pruned.children
+        assert_identical(
+            pruned.children["a"].to_dataset(), tree.children["a"].to_dataset()
+        )
+
+    def test_prune_with_intermediate_nodes(self) -> None:
+        tree = DataTree.from_dict(
+            {
+                "/": xr.Dataset(),
+                "/group1": xr.Dataset(),
+                "/group1/subA": xr.Dataset({"temp": ("x", [1, 2])}),
+                "/group1/subB": xr.Dataset(),
+                "/group2": xr.Dataset(),
+            }
+        )
+
+        pruned = tree.prune()
+
+        assert "group1" in pruned.children
+        assert "subA" in pruned.children["group1"].children
+        assert "subB" not in pruned.children["group1"].children
+        assert "group2" not in pruned.children
+
+    def test_prune_after_filtering(self) -> None:
+        import pandas as pd
+
+        ds1 = xr.Dataset(
+            {"foo": ("time", [1, 2, 3, 4, 5])},
+            coords={"time": pd.date_range("2023-01-01", periods=5, freq="D")},
+        )
+        ds2 = xr.Dataset(
+            {"var": ("time", [1, 2, 3, 4, 5])},
+            coords={"time": pd.date_range("2023-01-04", periods=5, freq="D")},
+        )
+
+        tree = DataTree.from_dict({"a": ds1, "b": ds2})
+        filtered = tree.sel(time=slice("2023-01-01", "2023-01-03"))
+
+        assert "b" in filtered.children
+        assert filtered.children["b"].is_data_empty is True
+
+        pruned = filtered.prune()
+        assert "a" in pruned.children
+        assert "b" not in pruned.children
+
 
 class TestIndexing:
     def test_isel_siblings(self) -> None: