add terms to conf.py, make docstrings more accurate, expand tests for…

… dataset pad function

doc/conf.py

@@ -153,6 +153,9 @@
     "matplotlib colormap name": ":doc:`matplotlib colormap name <matplotlib:gallery/color/colormap_reference>`",
     "matplotlib axes object": ":py:class:`matplotlib axes object <matplotlib.axes.Axes>`",
     "colormap": ":py:class:`colormap <matplotlib.colors.Colormap>`",
+    # xarray terms
+    "dim name": ":term:`dimension name <name>`",
+    "var name": ":term:`variable name <name>`",
     # objects without namespace: xarray
     "DataArray": "~xarray.DataArray",
     "Dataset": "~xarray.Dataset",

xarray/core/dataset.py

@@ -9209,7 +9209,7 @@ def pad(
             length for all axes.
             Default is ``None``, to use the entire axis.
         constant_values : scalar, tuple, mapping of dim name to scalar or tuple, or \
-            mapping of var name to scalar, tuple or to mapping of dim name to scalar or tuple, default: 0
+            mapping of var name to scalar, tuple or to mapping of dim name to scalar or tuple, default: None
             Used in 'constant'. The values to set the padded values for each data variable / axis.
             ``{var_1: {dim_1: (before_1, after_1), ... dim_N: (before_N, after_N)}, ...
             var_M: (before, after)}`` unique pad constants per data variable.
@@ -9219,8 +9219,8 @@ def pad(
             dimension.
             ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
             all dimensions.
-            Default is 0.
-        end_values : scalar, tuple or mapping of hashable to tuple, default: 0
+            Default is ``None``, pads with ``np.nan``.
+        end_values : scalar, tuple or mapping of hashable to tuple, default: None
             Used in 'linear_ramp'.  The values used for the ending value of the
             linear_ramp and that will form the edge of the padded array.
             ``{dim_1: (before_1, after_1), ... dim_N: (before_N, after_N)}`` unique
@@ -9229,7 +9229,7 @@ def pad(
             axis.
             ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
             all axes.
-            Default is 0.
+            Default is None.
         reflect_type : {"even", "odd", None}, optional
             Used in "reflect", and "symmetric".  The "even" style is the
             default with an unaltered reflection around the edge value.  For
@@ -9299,7 +9299,8 @@ def pad(
                 indexes[k] = idx
 
         per_data_var_constant_values = {}
-        if isinstance(constant_values, dict):
+        if utils.is_dict_like(constant_values):
+            constant_values = dict(constant_values)
             for k in self.data_vars:
                 if v := constant_values.pop(k, None):
                     per_data_var_constant_values[k] = v

xarray/tests/test_dataset.py

@@ -6699,46 +6699,80 @@ def test_polyfit_warnings(self) -> None:
             ds.var1.polyfit("dim2", 10, full=True)
             assert len(ws) == 1
 
+    @staticmethod
+    def _test_data_var_interior(
+        original_data_var, padded_data_var, padded_dim_name, expected_pad_values
+    ):
+        np.testing.assert_equal(
+            np.unique(padded_data_var.isel({padded_dim_name: [0, -1]})),
+            expected_pad_values,
+        )
+        np.testing.assert_array_equal(
+            padded_data_var.isel({padded_dim_name: slice(1, -1)}), original_data_var
+        )
+
+    @pytest.mark.parametrize("padded_dim_name", ["dim1", "dim2", "dim3", "time"])
     @pytest.mark.parametrize(
-        ["constant_values", "expected"],
+        ["constant_values"],
         [
-            pytest.param(None, {"var1": np.nan}, id="default"),
-            pytest.param(42, {"var1": 42, "var2": 42}, id="scalar"),
-            pytest.param((42, 43), {"var1": (42, 43), "var2": (42, 43)}, id="tuple"),
-            pytest.param({"dim2": 42}, {"var1": 42, "var2": 42}, id="per dim scalar"),
-            pytest.param(
-                {"dim2": (42, 43)},
-                {"var1": (42, 43), "var2": (42, 43)},
-                id="per dim tuple",
-            ),
-            pytest.param(
-                {"var1": 42, "var2": (42, 43)},
-                {"var1": 42, "var2": (42, 43)},
-                id="per var",
-            ),
-            pytest.param(
-                {"var1": 42, "dim2": (42, 43)},
-                {"var1": 42, "var2": (42, 43)},
-                id="mixed",
-            ),
+            pytest.param(None, id="default"),
+            pytest.param(42, id="scalar"),
+            pytest.param((42, 43), id="tuple"),
+            pytest.param({"dim1": 42, "dim2": 43}, id="per dim scalar"),
+            pytest.param({"dim1": (42, 43), "dim2": (43, 44)}, id="per dim tuple"),
+            pytest.param({"var1": 42, "var2": (42, 43)}, id="per var"),
+            pytest.param({"var1": 42, "dim1": (42, 43)}, id="mixed"),
         ],
     )
-    def test_pad(self, constant_values, expected) -> None:
+    def test_pad(self, padded_dim_name, constant_values) -> None:
         ds = create_test_data(seed=1)
-        padded = ds.pad(dim2=(1, 1), constant_values=constant_values)
-
-        assert padded["dim2"].shape == (11,)
-        assert padded["var1"].shape == (8, 11)
-        assert padded["var2"].shape == (8, 11)
-        assert padded["var3"].shape == (10, 8)
-        assert dict(padded.sizes) == {"dim1": 8, "dim2": 11, "dim3": 10, "time": 20}
-
-        for var, expected_value in expected.items():
-            np.testing.assert_equal(
-                np.unique(padded[var].isel(dim2=[0, -1]).data), expected_value
-            )
-        # np.testing.assert_equal(padded["var1"].isel(dim2=[0, -1]).data, 42)
-        np.testing.assert_equal(padded["dim2"][[0, -1]].data, np.nan)
+        padded = ds.pad({padded_dim_name: (1, 1)}, constant_values=constant_values)
+
+        # test padded dim values and size
+        for ds_dim_name, ds_dim in ds.sizes.items():
+            if ds_dim_name == padded_dim_name:
+                np.testing.assert_equal(padded.sizes[ds_dim_name], ds_dim + 2)
+                if ds_dim_name in padded.coords:
+                    assert padded[ds_dim_name][[0, -1]].isnull().all()
+            else:
+                np.testing.assert_equal(padded.sizes[ds_dim_name], ds_dim)
+
+        # check if coord "numbers" with dimention dim3 is paded correctly
+        if padded_dim_name == "dim3":
+            assert padded["numbers"][[0, -1]].isnull().all()
+            # twarning: passes but dtype changes from int to float
+            np.testing.assert_array_equal(padded["numbers"][1:-1], ds["numbers"])
+
+        # test if data_vars are paded with correct values
+        for data_var_name, data_var in padded.data_vars.items():
+            if padded_dim_name in data_var.dims:
+                if isinstance(constant_values, dict):
+                    if (
+                        expected := constant_values.get(data_var_name, None)
+                    ) is not None:
+                        self._test_data_var_interior(
+                            ds[data_var_name], data_var, padded_dim_name, expected
+                        )
+                    elif (
+                        expected := constant_values.get(padded_dim_name, None)
+                    ) is not None:
+                        self._test_data_var_interior(
+                            ds[data_var_name], data_var, padded_dim_name, expected
+                        )
+                    else:
+                        self._test_data_var_interior(
+                            ds[data_var_name], data_var, padded_dim_name, 0
+                        )
+                elif constant_values:
+                    self._test_data_var_interior(
+                        ds[data_var_name], data_var, padded_dim_name, constant_values
+                    )
+                else:
+                    self._test_data_var_interior(
+                        ds[data_var_name], data_var, padded_dim_name, np.nan
+                    )
+            else:
+                assert_array_equal(data_var, ds[data_var_name])
 
     @pytest.mark.parametrize(
         ["keep_attrs", "attrs", "expected"],