From b44912a18a65a937206b77acd43b6e2609ed5dd6 Mon Sep 17 00:00:00 2001 From: eschalk Date: Wed, 7 Feb 2024 22:40:42 +0100 Subject: [PATCH 1/6] Test formatting platform --- xarray/tests/test_formatting.py | 184 ++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index 1ee6c86d064..e4c5a561f8e 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -872,3 +872,187 @@ def test_display_nbytes() -> None: * foo (foo) int16 2kB 0 1 2 3 4 5 6 ... 1194 1195 1196 1197 1198 1199 """.strip() assert actual == expected + + +@pytest.mark.skipif( + ON_WINDOWS, + reason="Default numpy's dtypes vary according to OS", +) +def test_array_repr_dtypes() -> None: + + # Integer dtypes + + ds = xr.DataArray(np.array([0]), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") + actual = repr(ds) + expected = """ + Size: 1B +array([0], dtype=int8) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int16"), dims="x") + actual = repr(ds) + expected = """ + Size: 2B +array([0], dtype=int16) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int32"), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0], dtype=int32) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int64"), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + # Float dtypes + + ds = xr.DataArray(np.array([0.0]), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0.]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float16"), dims="x") + actual = repr(ds) + expected = """ + Size: 2B +array([0.], dtype=float16) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float32"), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0.], dtype=float32) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float64"), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0.]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + +@pytest.mark.skipif( + not ON_WINDOWS, + reason="Default numpy's dtypes vary according to OS", +) +def test_array_repr_dtypes_on_windows() -> None: + + # Integer dtypes + + ds = xr.DataArray(np.array([0]), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") + actual = repr(ds) + expected = """ + Size: 1B +array([0], dtype=int8) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int16"), dims="x") + actual = repr(ds) + expected = """ + Size: 2B +array([0], dtype=int16) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int32"), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="int64"), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0], dtype=int64) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + # Float dtypes + + ds = xr.DataArray(np.array([0.0]), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0.]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float16"), dims="x") + actual = repr(ds) + expected = """ + Size: 2B +array([0.], dtype=float16) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float32"), dims="x") + actual = repr(ds) + expected = """ + Size: 4B +array([0.]) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + ds = xr.DataArray(np.array([0], dtype="float64"), dims="x") + actual = repr(ds) + expected = """ + Size: 8B +array([0.], dtype=float64) +Dimensions without coordinates: x + """.strip() + assert actual == expected From 4b30717685711ba624871f5625f1bfacc2475a87 Mon Sep 17 00:00:00 2001 From: eschalk Date: Wed, 7 Feb 2024 23:02:53 +0100 Subject: [PATCH 2/6] Default is float64 --- xarray/tests/test_formatting.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index e4c5a561f8e..aebb6e6d558 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -1024,7 +1024,7 @@ def test_array_repr_dtypes_on_windows() -> None: ds = xr.DataArray(np.array([0.0]), dims="x") actual = repr(ds) expected = """ - Size: 4B + Size: 8B array([0.]) Dimensions without coordinates: x """.strip() @@ -1043,7 +1043,7 @@ def test_array_repr_dtypes_on_windows() -> None: actual = repr(ds) expected = """ Size: 4B -array([0.]) +array([0.], dtype=float32) Dimensions without coordinates: x """.strip() assert actual == expected @@ -1052,7 +1052,7 @@ def test_array_repr_dtypes_on_windows() -> None: actual = repr(ds) expected = """ Size: 8B -array([0.], dtype=float64) +array([0.]) Dimensions without coordinates: x """.strip() assert actual == expected From 27a66043bd15b0195fd9d8b903fcd8fa74d66444 Mon Sep 17 00:00:00 2001 From: eschalk Date: Wed, 7 Feb 2024 23:13:40 +0100 Subject: [PATCH 3/6] Try to differentiate between OS-dependant and independant dtypes for CI safety --- xarray/tests/test_formatting.py | 101 ++++++++++++++------------------ 1 file changed, 44 insertions(+), 57 deletions(-) diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index aebb6e6d558..9a64d8a3c39 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -874,55 +874,62 @@ def test_display_nbytes() -> None: assert actual == expected -@pytest.mark.skipif( - ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", -) -def test_array_repr_dtypes() -> None: +def test_array_repr_dtypes(): - # Integer dtypes + # Signed integer dtypes - ds = xr.DataArray(np.array([0]), dims="x") + ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") actual = repr(ds) expected = """ - Size: 8B -array([0]) + Size: 1B +array([0], dtype=int8) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") + ds = xr.DataArray(np.array([0], dtype="int16"), dims="x") + actual = repr(ds) + expected = """ + Size: 2B +array([0], dtype=int16) +Dimensions without coordinates: x + """.strip() + assert actual == expected + + # Unsigned integer dtypes + + ds = xr.DataArray(np.array([0], dtype="uint8"), dims="x") actual = repr(ds) expected = """ Size: 1B -array([0], dtype=int8) +array([0], dtype=uint8) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int16"), dims="x") + ds = xr.DataArray(np.array([0], dtype="uint16"), dims="x") actual = repr(ds) expected = """ Size: 2B -array([0], dtype=int16) +array([0], dtype=uint16) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int32"), dims="x") + ds = xr.DataArray(np.array([0], dtype="uint32"), dims="x") actual = repr(ds) expected = """ Size: 4B -array([0], dtype=int32) +array([0], dtype=uint32) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int64"), dims="x") + ds = xr.DataArray(np.array([0], dtype="uint64"), dims="x") actual = repr(ds) expected = """ Size: 8B -array([0]) +array([0], dtype=uint64) Dimensions without coordinates: x """.strip() assert actual == expected @@ -967,45 +974,27 @@ def test_array_repr_dtypes() -> None: @pytest.mark.skipif( - not ON_WINDOWS, + ON_WINDOWS, reason="Default numpy's dtypes vary according to OS", ) -def test_array_repr_dtypes_on_windows() -> None: +def test_array_repr_dtypes_unix() -> None: - # Integer dtypes + # Signed integer dtypes ds = xr.DataArray(np.array([0]), dims="x") actual = repr(ds) expected = """ - Size: 4B + Size: 8B array([0]) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") - actual = repr(ds) - expected = """ - Size: 1B -array([0], dtype=int8) -Dimensions without coordinates: x - """.strip() - assert actual == expected - - ds = xr.DataArray(np.array([0], dtype="int16"), dims="x") - actual = repr(ds) - expected = """ - Size: 2B -array([0], dtype=int16) -Dimensions without coordinates: x - """.strip() - assert actual == expected - ds = xr.DataArray(np.array([0], dtype="int32"), dims="x") actual = repr(ds) expected = """ Size: 4B -array([0]) +array([0], dtype=int32) Dimensions without coordinates: x """.strip() assert actual == expected @@ -1014,45 +1003,43 @@ def test_array_repr_dtypes_on_windows() -> None: actual = repr(ds) expected = """ Size: 8B -array([0], dtype=int64) +array([0]) Dimensions without coordinates: x """.strip() assert actual == expected - # Float dtypes - ds = xr.DataArray(np.array([0.0]), dims="x") - actual = repr(ds) - expected = """ - Size: 8B -array([0.]) -Dimensions without coordinates: x - """.strip() - assert actual == expected +@pytest.mark.skipif( + not ON_WINDOWS, + reason="Default numpy's dtypes vary according to OS", +) +def test_array_repr_dtypes_on_windows() -> None: - ds = xr.DataArray(np.array([0], dtype="float16"), dims="x") + # Integer dtypes + + ds = xr.DataArray(np.array([0]), dims="x") actual = repr(ds) expected = """ - Size: 2B -array([0.], dtype=float16) + Size: 4B +array([0]) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="float32"), dims="x") + ds = xr.DataArray(np.array([0], dtype="int32"), dims="x") actual = repr(ds) expected = """ Size: 4B -array([0.], dtype=float32) +array([0]) Dimensions without coordinates: x """.strip() assert actual == expected - ds = xr.DataArray(np.array([0], dtype="float64"), dims="x") + ds = xr.DataArray(np.array([0], dtype="int64"), dims="x") actual = repr(ds) expected = """ Size: 8B -array([0.]) +array([0], dtype=int64) Dimensions without coordinates: x """.strip() assert actual == expected From e3647e6f2df0ed4ccfb2febd56b8b69f3af492bc Mon Sep 17 00:00:00 2001 From: eschalk Date: Thu, 8 Feb 2024 20:06:31 +0100 Subject: [PATCH 4/6] wip --- xarray/tests/test_dataarray.py | 96 +++++---------------------------- xarray/tests/test_formatting.py | 63 +++++++++++----------- xarray/tests/test_variable.py | 28 ++++------ 3 files changed, 53 insertions(+), 134 deletions(-) diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py index e5fbe76103a..d898d3a30b9 100644 --- a/xarray/tests/test_dataarray.py +++ b/xarray/tests/test_dataarray.py @@ -71,8 +71,6 @@ pytest.mark.filterwarnings("error:All-NaN (slice|axis) encountered"), ] -ON_WINDOWS = sys.platform == "win32" - class TestDataArray: @pytest.fixture(autouse=True) @@ -87,61 +85,34 @@ def setup(self): self.mindex = pd.MultiIndex.from_product( [["a", "b"], [1, 2]], names=("level_1", "level_2") ) - self.mda = DataArray([0, 1, 2, 3], coords={"x": self.mindex}, dims="x") + self.mda = DataArray([0, 1, 2, 3], coords={"x": self.mindex}, dims="x").astype( + np.uint64 + ) - @pytest.mark.skipif( - ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) def test_repr(self) -> None: v = Variable(["time", "x"], [[1, 2, 3], [4, 5, 6]], {"foo": "bar"}) - coords = {"x": np.arange(3, dtype=np.int64), "other": np.int64(0)} + v = v.astype(np.uint64) + coords = {"x": np.arange(3, dtype=np.uint64), "other": np.uint64(0)} data_array = DataArray(v, coords, name="my_variable") expected = dedent( """\ Size: 48B array([[1, 2, 3], - [4, 5, 6]]) - Coordinates: - * x (x) int64 24B 0 1 2 - other int64 8B 0 - Dimensions without coordinates: time - Attributes: - foo: bar""" - ) - assert expected == repr(data_array) - - @pytest.mark.skipif( - not ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) - def test_repr_windows(self) -> None: - v = Variable(["time", "x"], [[1, 2, 3], [4, 5, 6]], {"foo": "bar"}) - coords = {"x": np.arange(3, dtype=np.int64), "other": np.int64(0)} - data_array = DataArray(v, coords, name="my_variable") - expected = dedent( - """\ - Size: 24B - array([[1, 2, 3], - [4, 5, 6]]) + [4, 5, 6]], dtype=uint64) Coordinates: - * x (x) int64 24B 0 1 2 - other int64 8B 0 + * x (x) uint64 24B 0 1 2 + other uint64 8B 0 Dimensions without coordinates: time Attributes: foo: bar""" ) assert expected == repr(data_array) - @pytest.mark.skipif( - ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) def test_repr_multiindex(self) -> None: expected = dedent( """\ Size: 32B - array([0, 1, 2, 3]) + array([0, 1, 2, 3], dtype=uint64) Coordinates: * x (x) object 32B MultiIndex * level_1 (x) object 32B 'a' 'a' 'b' 'b' @@ -149,59 +120,20 @@ def test_repr_multiindex(self) -> None: ) assert expected == repr(self.mda) - @pytest.mark.skipif( - not ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) - def test_repr_multiindex_windows(self) -> None: - expected = dedent( - """\ - Size: 16B - array([0, 1, 2, 3]) - Coordinates: - * x (x) object 32B MultiIndex - * level_1 (x) object 32B 'a' 'a' 'b' 'b' - * level_2 (x) int64 32B 1 2 1 2""" - ) - assert expected == repr(self.mda) - - @pytest.mark.skipif( - ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) def test_repr_multiindex_long(self) -> None: mindex_long = pd.MultiIndex.from_product( [["a", "b", "c", "d"], [1, 2, 3, 4, 5, 6, 7, 8]], names=("level_1", "level_2"), ) - mda_long = DataArray(list(range(32)), coords={"x": mindex_long}, dims="x") + mda_long = DataArray( + list(range(32)), coords={"x": mindex_long}, dims="x" + ).astype(np.uint64) expected = dedent( """\ Size: 256B array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) - Coordinates: - * x (x) object 256B MultiIndex - * level_1 (x) object 256B 'a' 'a' 'a' 'a' 'a' 'a' ... 'd' 'd' 'd' 'd' 'd' 'd' - * level_2 (x) int64 256B 1 2 3 4 5 6 7 8 1 2 3 4 ... 5 6 7 8 1 2 3 4 5 6 7 8""" - ) - assert expected == repr(mda_long) - - @pytest.mark.skipif( - not ON_WINDOWS, - reason="Default numpy's dtypes vary according to OS", - ) - def test_repr_multiindex_long_windows(self) -> None: - mindex_long = pd.MultiIndex.from_product( - [["a", "b", "c", "d"], [1, 2, 3, 4, 5, 6, 7, 8]], - names=("level_1", "level_2"), - ) - mda_long = DataArray(list(range(32)), coords={"x": mindex_long}, dims="x") - expected = dedent( - """\ - Size: 128B - array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], + dtype=uint64) Coordinates: * x (x) object 256B MultiIndex * level_1 (x) object 256B 'a' 'a' 'a' 'a' 'a' 'a' ... 'd' 'd' 'd' 'd' 'd' 'd' diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index 9a64d8a3c39..8c0a6efa863 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -466,26 +466,24 @@ def test_diff_dataset_repr(self) -> None: assert actual == expected def test_array_repr(self) -> None: - ds = xr.Dataset(coords={"foo": [1, 2, 3], "bar": [1, 2, 3]}) + ds = xr.Dataset( + coords={ + "foo": np.array([1, 2, 3], dtype=np.uint64), + "bar": np.array([1, 2, 3], dtype=np.uint64), + } + ) ds[(1, 2)] = xr.DataArray([0], dims="test") ds_12 = ds[(1, 2)] # Test repr function behaves correctly: actual = formatting.array_repr(ds_12) - if ON_WINDOWS: - expected = dedent( - """\ - Size: 4B - array([0]) - Dimensions without coordinates: test""" - ) - else: - expected = dedent( - """\ - Size: 8B - array([0]) - Dimensions without coordinates: test""" - ) + + expected = dedent( + """\ + Size: 8B + array([0]) + Dimensions without coordinates: test""" + ) assert actual == expected @@ -499,21 +497,12 @@ def test_array_repr(self) -> None: with xr.set_options(display_expand_data=False): actual = formatting.array_repr(ds[(1, 2)]) - if ON_WINDOWS: - expected = dedent( - """\ - Size: 4B - 0 - Dimensions without coordinates: test""" - ) - - else: - expected = dedent( - """\ - Size: 8B - 0 - Dimensions without coordinates: test""" - ) + expected = dedent( + """\ + Size: 8B + 0 + Dimensions without coordinates: test""" + ) assert actual == expected @@ -682,15 +671,16 @@ def test__mapping_repr(display_max_rows, n_vars, n_attr) -> None: b = defchararray.add("attr_", np.arange(0, n_attr).astype(str)) c = defchararray.add("coord", np.arange(0, n_vars).astype(str)) attrs = {k: 2 for k in b} - coords = {_c: np.array([0, 1]) for _c in c} + coords = {_c: np.array([0, 1], dtype=np.uint64) for _c in c} data_vars = dict() for v, _c in zip(a, coords.items()): data_vars[v] = xr.DataArray( name=v, - data=np.array([3, 4]), + data=np.array([3, 4], dtype=np.uint64), dims=[_c[0]], coords=dict([_c]), ) + ds = xr.Dataset(data_vars) ds.attrs = attrs @@ -727,7 +717,7 @@ def test__mapping_repr(display_max_rows, n_vars, n_attr) -> None: dims_values = formatting.dim_summary_limited( ds, col_width=col_width + 1, max_rows=display_max_rows ) - expected_size = "640B" if ON_WINDOWS else "1kB" + expected_size = "1kB" expected = f"""\ Size: {expected_size} {dims_start}({dims_values}) @@ -876,6 +866,13 @@ def test_display_nbytes() -> None: def test_array_repr_dtypes(): + # These dtypes are expected to be represented similarly + # on Ubuntu, macOS and Windows environments of the CI. + # Unsigned integer could be used as easy replacements + # for tests where the data-type does not matter, + # but the repr does, including the size + # (size of a int == size of an uint) + # Signed integer dtypes ds = xr.DataArray(np.array([0], dtype="int8"), dims="x") diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 0c094635787..16e433337d3 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -1231,26 +1231,16 @@ def test_as_variable(self): def test_repr(self): v = Variable(["time", "x"], [[1, 2, 3], [4, 5, 6]], {"foo": "bar"}) - if ON_WINDOWS: - expected = dedent( - """ - Size: 24B - array([[1, 2, 3], - [4, 5, 6]]) - Attributes: - foo: bar + v = v.astype(np.uint64) + expected = dedent( """ - ).strip() - else: - expected = dedent( - """ - Size: 48B - array([[1, 2, 3], - [4, 5, 6]]) - Attributes: - foo: bar - """ - ).strip() + Size: 48B + array([[1, 2, 3], + [4, 5, 6]], dtype=uint64) + Attributes: + foo: bar + """ + ).strip() assert expected == repr(v) def test_repr_lazy_data(self): From fc622d3a4a173338a85b0c7493d1dd4aa3dee73c Mon Sep 17 00:00:00 2001 From: eschalk Date: Thu, 8 Feb 2024 20:10:01 +0100 Subject: [PATCH 5/6] fixed tests --- xarray/tests/test_variable.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/xarray/tests/test_variable.py b/xarray/tests/test_variable.py index 16e433337d3..eb71df0dae6 100644 --- a/xarray/tests/test_variable.py +++ b/xarray/tests/test_variable.py @@ -1,6 +1,5 @@ from __future__ import annotations -import sys import warnings from abc import ABC from copy import copy, deepcopy @@ -59,8 +58,6 @@ [{"x": (3, 1), "z": 2}, ((3, 1), (0, 0), (2, 2))], ] -ON_WINDOWS = sys.platform == "win32" - @pytest.fixture def var(): From 4ff15899fe1cd8349870f14ddb1f7bd16229b7e6 Mon Sep 17 00:00:00 2001 From: eschalk Date: Thu, 8 Feb 2024 20:31:53 +0100 Subject: [PATCH 6/6] forgot one test --- xarray/tests/test_formatting.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/xarray/tests/test_formatting.py b/xarray/tests/test_formatting.py index 8c0a6efa863..6923d26b79a 100644 --- a/xarray/tests/test_formatting.py +++ b/xarray/tests/test_formatting.py @@ -472,7 +472,7 @@ def test_array_repr(self) -> None: "bar": np.array([1, 2, 3], dtype=np.uint64), } ) - ds[(1, 2)] = xr.DataArray([0], dims="test") + ds[(1, 2)] = xr.DataArray(np.array([0], dtype=np.uint64), dims="test") ds_12 = ds[(1, 2)] # Test repr function behaves correctly: @@ -481,7 +481,7 @@ def test_array_repr(self) -> None: expected = dedent( """\ Size: 8B - array([0]) + array([0], dtype=uint64) Dimensions without coordinates: test""" )