Removes parent keyword from DataTree constructor

flamingbear · flamingbear · commit 7c530f5a3c09 · 2024-09-02T18:25:11.000-06:00
But it doesn't fix all the tests There's three tests that I don't fully know
what should be tested or if they still make sense.
diff --git a/xarray/core/datatree.py b/xarray/core/datatree.py
@@ -424,7 +424,6 @@ class DataTree(
     def __init__(
         self,
         data: Dataset | DataArray | None = None,
-        parent: DataTree | None = None,
         children: Mapping[str, DataTree] | None = None,
         name: str | None = None,
     ):
@@ -440,8 +439,6 @@ def __init__(
         data : Dataset, DataArray, or None, optional
             Data to store under the .ds attribute of this node. DataArrays will
             be promoted to Datasets. Default is None.
-        parent : DataTree, optional
-            Parent node to this node. Default is None.
         children : Mapping[str, DataTree], optional
             Any child nodes of this node. Default is None.
         name : str, optional
@@ -462,7 +459,6 @@ def __init__(
         self._set_node_data(_coerce_to_dataset(data))
 
         # shallow copy to avoid modifying arguments in-place (see GH issue #9196)
-        self.parent = parent.copy() if parent is not None else None
         self.children = {name: child.copy() for name, child in children.items()}
 
     def _set_node_data(self, ds: Dataset):
@@ -1100,7 +1096,7 @@ def from_dict(
             obj = root_data.copy()
             obj.orphan()
         else:
-            obj = cls(name=name, data=root_data, parent=None, children=None)
+            obj = cls(name=name, data=root_data, children=None)
 
         def depth(item) -> int:
             pathstr, _ = item
diff --git a/xarray/tests/test_datatree.py b/xarray/tests/test_datatree.py
@@ -55,7 +55,9 @@ def test_setparent_unnamed_child_node_fails(self):
     def test_create_two_children(self):
         root_data = xr.Dataset({"a": ("y", [6, 7, 8]), "set0": ("x", [9, 10])})
         set1_data = xr.Dataset({"a": 0, "b": 1})
-
+        # root = DataTree.from_dict(
+        #     {"/": root_data, "/set1": set1_data, "/set1/set2": None}
+        # )
         root: DataTree = DataTree(data=root_data)
         set1: DataTree = DataTree(name="set1", parent=root, data=set1_data)
         DataTree(name="set1", parent=root)
@@ -195,9 +197,13 @@ def test_to_dataset(self):
 
 class TestVariablesChildrenNameCollisions:
     def test_parent_already_has_variable_with_childs_name(self):
-        dt: DataTree = DataTree(data=xr.Dataset({"a": [0], "b": 1}))
         with pytest.raises(KeyError, match="already contains a variable named a"):
-            DataTree(name="a", data=None, parent=dt)
+            DataTree.from_dict({"/": xr.Dataset({"a": [0], "b": 1}), "/a": None})
+
+    def test_parent_already_has_variable_with_childs_name_update(self):
+        dt: DataTree = DataTree(data=xr.Dataset({"a": [0], "b": 1}))
+        with pytest.raises(ValueError, match="already contains a variable named a"):
+            dt.update({"a": DataTree()})
 
     def test_assign_when_already_child_with_variables_name(self):
         dt = DataTree.from_dict(
@@ -249,8 +255,7 @@ def test_getitem_single_data_variable_from_node(self):
         assert_identical(folder1["results/highres/temp"], data["temp"])
 
     def test_getitem_nonexistent_node(self):
-        folder1: DataTree = DataTree(name="folder1")
-        DataTree(name="results", parent=folder1)
+        folder1: DataTree = DataTree.from_dict({"/results": DataTree()}, name="folder1")
         with pytest.raises(KeyError):
             folder1["results/highres"]
 
@@ -448,10 +453,10 @@ def test_setitem_new_empty_node(self):
         assert_identical(mary.to_dataset(), xr.Dataset())
 
     def test_setitem_overwrite_data_in_node_with_none(self):
-        john: DataTree = DataTree(name="john")
-        mary: DataTree = DataTree(name="mary", parent=john, data=xr.Dataset())
+        john: DataTree = DataTree.from_dict({"/mary": xr.Dataset()}, name="john")
+
         john["mary"] = DataTree()
-        assert_identical(mary.to_dataset(), xr.Dataset())
+        assert_identical(john["mary"].to_dataset(), xr.Dataset())
 
         john.ds = xr.Dataset()  # type: ignore[assignment]
         with pytest.raises(ValueError, match="has no name"):
@@ -633,8 +638,13 @@ def test_view_contents(self):
 
     def test_immutability(self):
         # See issue https://github.com/xarray-contrib/datatree/issues/38
-        dt: DataTree = DataTree(name="root", data=None)
-        DataTree(name="a", data=None, parent=dt)
+        dt = DataTree.from_dict(
+            {
+                "/": None,
+                "/a": None,
+            },
+            name="root",
+        )
 
         with pytest.raises(
             AttributeError, match="Mutation of the DatasetView is not allowed"
@@ -1087,44 +1097,51 @@ def test_filter(self):
 class TestDSMethodInheritance:
     def test_dataset_method(self):
         ds = xr.Dataset({"a": ("x", [1, 2, 3])})
-        dt: DataTree = DataTree(data=ds)
-        DataTree(name="results", parent=dt, data=ds)
+        dt = DataTree.from_dict(
+            {
+                "/": ds,
+                "/results": ds,
+            }
+        )
 
-        expected: DataTree = DataTree(data=ds.isel(x=1))
-        DataTree(name="results", parent=expected, data=ds.isel(x=1))
+        expected = DataTree.from_dict(
+            {
+                "/": ds.isel(x=1),
+                "/results": ds.isel(x=1),
+            }
+        )
 
         result = dt.isel(x=1)
         assert_equal(result, expected)
 
     def test_reduce_method(self):
         ds = xr.Dataset({"a": ("x", [False, True, False])})
-        dt: DataTree = DataTree(data=ds)
-        DataTree(name="results", parent=dt, data=ds)
+        dt = DataTree.from_dict({"/": ds, "/results": ds})
 
-        expected: DataTree = DataTree(data=ds.any())
-        DataTree(name="results", parent=expected, data=ds.any())
+        expected = DataTree.from_dict({"/": ds.any(), "/results": ds.any()})
 
         result = dt.any()
         assert_equal(result, expected)
 
     def test_nan_reduce_method(self):
         ds = xr.Dataset({"a": ("x", [1, 2, 3])})
-        dt: DataTree = DataTree(data=ds)
-        DataTree(name="results", parent=dt, data=ds)
+        dt = DataTree.from_dict({"/": ds, "/results": ds})
 
-        expected: DataTree = DataTree(data=ds.mean())
-        DataTree(name="results", parent=expected, data=ds.mean())
+        expected = DataTree.from_dict({"/": ds.mean(), "/results": ds.mean()})
 
         result = dt.mean()
         assert_equal(result, expected)
 
     def test_cum_method(self):
         ds = xr.Dataset({"a": ("x", [1, 2, 3])})
-        dt: DataTree = DataTree(data=ds)
-        DataTree(name="results", parent=dt, data=ds)
+        dt = DataTree.from_dict({"/": ds, "/results": ds})
 
-        expected: DataTree = DataTree(data=ds.cumsum())
-        DataTree(name="results", parent=expected, data=ds.cumsum())
+        expected = DataTree.from_dict(
+            {
+                "/": ds.cumsum(),
+                "/results": ds.cumsum(),
+            }
+        )
 
         result = dt.cumsum()
         assert_equal(result, expected)
@@ -1134,11 +1151,9 @@ class TestOps:
     def test_binary_op_on_int(self):
         ds1 = xr.Dataset({"a": [5], "b": [3]})
         ds2 = xr.Dataset({"x": [0.1, 0.2], "y": [10, 20]})
-        dt: DataTree = DataTree(data=ds1)
-        DataTree(name="subnode", data=ds2, parent=dt)
+        dt = DataTree.from_dict({"/": ds1, "/subnode": ds2})
 
-        expected: DataTree = DataTree(data=ds1 * 5)
-        DataTree(name="subnode", data=ds2 * 5, parent=expected)
+        expected = DataTree.from_dict({"/": ds1 * 5, "/subnode": ds2 * 5})
 
         # TODO: Remove ignore when ops.py is migrated?
         result: DataTree = dt * 5  # type: ignore[assignment,operator]
@@ -1147,24 +1162,32 @@ def test_binary_op_on_int(self):
     def test_binary_op_on_dataset(self):
         ds1 = xr.Dataset({"a": [5], "b": [3]})
         ds2 = xr.Dataset({"x": [0.1, 0.2], "y": [10, 20]})
-        dt: DataTree = DataTree(data=ds1)
-        DataTree(name="subnode", data=ds2, parent=dt)
+        dt = DataTree.from_dict(
+            {
+                "/": ds1,
+                "/subnode": ds2,
+            }
+        )
+
         other_ds = xr.Dataset({"z": ("z", [0.1, 0.2])})
 
-        expected: DataTree = DataTree(data=ds1 * other_ds)
-        DataTree(name="subnode", data=ds2 * other_ds, parent=expected)
+        expected = DataTree.from_dict(
+            {
+                "/": ds1 * other_ds,
+                "/subnode": ds2 * other_ds,
+            }
+        )
 
         result = dt * other_ds
         assert_equal(result, expected)
 
     def test_binary_op_on_datatree(self):
         ds1 = xr.Dataset({"a": [5], "b": [3]})
         ds2 = xr.Dataset({"x": [0.1, 0.2], "y": [10, 20]})
-        dt: DataTree = DataTree(data=ds1)
-        DataTree(name="subnode", data=ds2, parent=dt)
 
-        expected: DataTree = DataTree(data=ds1 * ds1)
-        DataTree(name="subnode", data=ds2 * ds2, parent=expected)
+        dt = DataTree.from_dict({"/": ds1, "/subnode": ds2})
+
+        expected = DataTree.from_dict({"/": ds1 * ds1, "/subnode": ds2 * ds2})
 
         # TODO: Remove ignore when ops.py is migrated?
         result: DataTree = dt * dt  # type: ignore[operator]
