From 3f7449b40484913f696c9aa0b58a1e0595dead11 Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan Date: Tue, 13 Jun 2023 14:21:58 +0200 Subject: [PATCH 1/2] dataarrays instead of datasets --- examples/3D_shipping_route.py | 2 +- examples/3D_shipping_route_str.py | 2 +- examples/4D_flight_path.py | 2 +- examples/country_slicing.py | 2 +- examples/cyclic_route_around_earth.py | 2 +- examples/read_me_example.py | 2 +- examples/slicing_all_ecmwf_countries.py | 2 +- examples/timeseries_example.py | 2 +- examples/wind_farms.py | 10 ++- performance/scalability_test.py | 2 +- performance/scalability_test_2.py | 42 ++++----- polytope/datacube/xarray.py | 12 ++- tests/test_cyclic_axis_over_negative_vals.py | 32 ++++--- tests/test_cyclic_axis_slicer_not_0.py | 32 ++++--- tests/test_cyclic_axis_slicing.py | 67 +++++++++------ tests/test_datacube_xarray.py | 11 +-- tests/test_float_type.py | 20 +++-- tests/test_hullslicer_engine.py | 1 - tests/test_slicer_era5.py | 2 +- tests/test_slicer_xarray.py | 7 +- tests/test_slicing_unsliceable_axis.py | 10 ++- tests/test_slicing_xarray_3D.py | 87 ++++++++++++------- tests/test_slicing_xarray_4D.py | 90 +++++++++++++------- 23 files changed, 273 insertions(+), 168 deletions(-) diff --git a/examples/3D_shipping_route.py b/examples/3D_shipping_route.py index cf3f8402..0e5f7cb0 100644 --- a/examples/3D_shipping_route.py +++ b/examples/3D_shipping_route.py @@ -14,7 +14,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib").u10 self.array = array self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) diff --git a/examples/3D_shipping_route_str.py b/examples/3D_shipping_route_str.py index f0af827f..fc624d97 100644 --- a/examples/3D_shipping_route_str.py +++ b/examples/3D_shipping_route_str.py @@ -13,7 +13,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("./examples/data/output4.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/output4.grib", engine="cfgrib").u10 self.xarraydatacube = XArrayDatacube(array) self.array = array self.slicer = HullSlicer() diff --git a/examples/4D_flight_path.py b/examples/4D_flight_path.py index c7793476..87db4720 100644 --- a/examples/4D_flight_path.py +++ b/examples/4D_flight_path.py @@ -12,7 +12,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("./examples/data/temp_model_levels.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/temp_model_levels.grib", engine="cfgrib").t options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) for dim in array.dims: diff --git a/examples/country_slicing.py b/examples/country_slicing.py index e8181255..481e7c99 100644 --- a/examples/country_slicing.py +++ b/examples/country_slicing.py @@ -12,7 +12,7 @@ class Test: def setup_method(self, method): - array = xr.open_dataset("./examples/data/output8.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/output8.grib", engine="cfgrib").t2m options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() diff --git a/examples/cyclic_route_around_earth.py b/examples/cyclic_route_around_earth.py index beacd10c..404df875 100644 --- a/examples/cyclic_route_around_earth.py +++ b/examples/cyclic_route_around_earth.py @@ -11,7 +11,7 @@ class Test: def setup_method(self, method): - array = xr.open_dataset("./examples/data/output8.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/output8.grib", engine="cfgrib").t2m options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() diff --git a/examples/read_me_example.py b/examples/read_me_example.py index bb1eeee1..db36664a 100644 --- a/examples/read_me_example.py +++ b/examples/read_me_example.py @@ -4,7 +4,7 @@ from polytope.polytope import Polytope, Request from polytope.shapes import Box, Select -array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib") +array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib").u10 options = {"longitude": {"Cyclic": [0, 360.0]}} diff --git a/examples/slicing_all_ecmwf_countries.py b/examples/slicing_all_ecmwf_countries.py index f6b756eb..6038160e 100644 --- a/examples/slicing_all_ecmwf_countries.py +++ b/examples/slicing_all_ecmwf_countries.py @@ -12,7 +12,7 @@ class Test: def setup_method(self, method): - array = xr.open_dataset(".examples/data/output8.grib", engine="cfgrib") + array = xr.open_dataset(".examples/data/output8.grib", engine="cfgrib").t2m options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() diff --git a/examples/timeseries_example.py b/examples/timeseries_example.py index 87f87bdd..876d0865 100644 --- a/examples/timeseries_example.py +++ b/examples/timeseries_example.py @@ -13,7 +13,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("./examples/data/timeseries_t2m.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/timeseries_t2m.grib", engine="cfgrib").t2m self.xarraydatacube = XArrayDatacube(array) for dim in array.dims: array = array.sortby(dim) diff --git a/examples/wind_farms.py b/examples/wind_farms.py index 63190492..45ff54c6 100644 --- a/examples/wind_farms.py +++ b/examples/wind_farms.py @@ -16,7 +16,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/winds.grib", engine="cfgrib").u10 self.array = array options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) @@ -73,10 +73,12 @@ def test_slice_shipping_route(self): long = long - 360 lats.append(lat) longs.append(long) - u10_idx = result.leaves[i].result["u10"] + # u10_idx = result.leaves[i].result["u10"] + u10_idx = result.leaves[i].result[1] wind_u = u10_idx - v10_idx = result.leaves[i].result["v10"] - wind_v = v10_idx + # v10_idx = result.leaves[i].result["v10"] + # wind_v = v10_idx + wind_v = 0 winds_u.append(wind_u) winds_v.append(wind_v) parameter_values.append(math.sqrt(wind_u**2 + wind_v**2)) diff --git a/performance/scalability_test.py b/performance/scalability_test.py index 186fd561..98eeac9d 100644 --- a/performance/scalability_test.py +++ b/performance/scalability_test.py @@ -11,7 +11,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("../examples/data/temp_model_levels.grib", engine="cfgrib") + array = xr.open_dataset("../examples/data/temp_model_levels.grib", engine="cfgrib").t options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) for dim in array.dims: diff --git a/performance/scalability_test_2.py b/performance/scalability_test_2.py index de39adc4..9330fd60 100644 --- a/performance/scalability_test_2.py +++ b/performance/scalability_test_2.py @@ -11,7 +11,7 @@ class Test: def setup_method(self): - array = xr.open_dataset("../examples/data/temp_model_levels.grib", engine="cfgrib") + array = xr.open_dataset("./examples/data/temp_model_levels.grib", engine="cfgrib").t options = {"longitude": {"Cyclic": [0, 360.0]}} self.xarraydatacube = XArrayDatacube(array) for dim in array.dims: @@ -82,23 +82,23 @@ def test_scalability_2D_v3(self): print(len(result.leaves)) print(time.time() - time_start) - def test_scalability_2D_v4(self): - union = Box(["latitude", "longitude"], [0 - 100, 0], [20 - 100, 36]) - for i in range(9): - box = Box(["latitude", "longitude"], [20 * (i + 1) - 100, 0], [20 * (i + 2) - 100, 36]) - union = Union(["latitude", "longitude"], union, box) - for j in range(9): - box = Box(["latitude", "longitude"], [0 - 100, 36 * (j + 1)], [20 - 100, 36 * (j + 2)]) - union = Union(["latitude", "longitude"], union, box) - for i in range(9): - for j in range(9): - box = Box( - ["latitude", "longitude"], [20 * (i + 1) - 100, 36 * (j + 1)], [20 * (i + 2) - 100, 36 * (j + 2)] - ) - union = Union(["latitude", "longitude"], union, box) - time_start = time.time() - print(time_start) - request = Request(union, Select("step", [np.timedelta64(0, "ns")]), Select("hybrid", [1])) - result = self.API.retrieve(request) - print(len(result.leaves)) - print(time.time() - time_start) + # def test_scalability_2D_v4(self): + # union = Box(["latitude", "longitude"], [0 - 100, 0], [20 - 100, 36]) + # for i in range(9): + # box = Box(["latitude", "longitude"], [20 * (i + 1) - 100, 0], [20 * (i + 2) - 100, 36]) + # union = Union(["latitude", "longitude"], union, box) + # for j in range(9): + # box = Box(["latitude", "longitude"], [0 - 100, 36 * (j + 1)], [20 - 100, 36 * (j + 2)]) + # union = Union(["latitude", "longitude"], union, box) + # for i in range(9): + # for j in range(9): + # box = Box( + # ["latitude", "longitude"], [20 * (i + 1) - 100, 36 * (j + 1)], [20 * (i + 2) - 100, 36 * (j + 2)] + # ) + # union = Union(["latitude", "longitude"], union, box) + # time_start = time.time() + # print(time_start) + # request = Request(union, Select("step", [np.timedelta64(0, "ns")]), Select("hybrid", [1])) + # result = self.API.retrieve(request) + # print(len(result.leaves)) + # print(time.time() - time_start) diff --git a/polytope/datacube/xarray.py b/polytope/datacube/xarray.py index bc32d770..52ee283a 100644 --- a/polytope/datacube/xarray.py +++ b/polytope/datacube/xarray.py @@ -25,6 +25,7 @@ np.float64: FloatAxis(), np.str_: UnsliceableaAxis(), str: UnsliceableaAxis(), + np.object_ : UnsliceableaAxis() } @@ -69,9 +70,12 @@ def get(self, requests: IndexTree): # TODO: Here, once we flatten the path, we want to remap the values on the axis to fit the datacube... if len(path.items()) == len(self.dataarray.coords): subxarray = self.dataarray.sel(path, method="nearest") - data_variables = subxarray.data_vars - result_tuples = [(key, value) for key, value in data_variables.items()] - r.result = dict(result_tuples) + value = subxarray.item() + key = subxarray.name + # data_variables = subxarray.data_vars + # result_tuples = [(key, value) for key, value in data_variables.items()] + # r.result = dict(result_tuples) + r.result = (key, value) else: r.remove_branch() @@ -142,7 +146,7 @@ def get_indices(self, path: DatacubePath, axis, lower, upper): def has_index(self, path: DatacubePath, axis, index): # when we want to obtain the value of an unsliceable axis, need to check the values does exist in the datacube - subarray = self.dataarray.sel(path)[axis.name] + subarray = self.dataarray.sel(path, method='nearest')[axis.name] subarray_vals = subarray.values return index in subarray_vals diff --git a/tests/test_cyclic_axis_over_negative_vals.py b/tests/test_cyclic_axis_over_negative_vals.py index 3b0fe574..a0ee1e1c 100644 --- a/tests/test_cyclic_axis_over_negative_vals.py +++ b/tests/test_cyclic_axis_over_negative_vals.py @@ -21,6 +21,7 @@ def setup_method(self, method): "long": [-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1], }, ) + array = array.to_array() options = {"long": {"Cyclic": [-1.1, -0.1]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -30,12 +31,13 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -60,12 +62,13 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -86,21 +89,23 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -155,21 +160,24 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] + assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, + -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, diff --git a/tests/test_cyclic_axis_slicer_not_0.py b/tests/test_cyclic_axis_slicer_not_0.py index 3b94f150..a8c2f6d4 100644 --- a/tests/test_cyclic_axis_slicer_not_0.py +++ b/tests/test_cyclic_axis_slicer_not_0.py @@ -21,6 +21,7 @@ def setup_method(self, method): "long": [-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1], }, ) + array = array.to_array() options = {"long": {"Cyclic": [-1.1, -0.1]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -30,12 +31,13 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -60,12 +62,13 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -86,21 +89,23 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -155,21 +160,24 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] + assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, + -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, diff --git a/tests/test_cyclic_axis_slicing.py b/tests/test_cyclic_axis_slicing.py index fcd8bab4..9c800146 100644 --- a/tests/test_cyclic_axis_slicing.py +++ b/tests/test_cyclic_axis_slicing.py @@ -21,6 +21,7 @@ def setup_method(self, method): "long": [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0], }, ) + array = array.to_array() options = {"long": {"Cyclic": [0, 1.0]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -30,12 +31,13 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -60,12 +62,13 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_across_seam_repeated(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 1.0]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.0], [3, 1.0]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -92,12 +95,13 @@ def test_cyclic_float_axis_across_seam_repeated(self): def test_cyclic_float_axis_across_seam_repeated_twice(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 2.0]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.0], [3, 2.0]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 * 2 - 2 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -144,12 +148,13 @@ def test_cyclic_float_axis_across_seam_repeated_twice(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -170,21 +175,23 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -239,21 +246,24 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] + assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, + -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, @@ -280,19 +290,21 @@ def test_cyclic_float_axis_below_axis_range_crossing_seam(self): def test_cyclic_float_axis_reversed(self): request = Request( - Box(["step", "long"], [0, 1.7], [3, 1.3]), Select("date", ["2000-01-01"]), Select("level", [128]) + Box(["step", "long"], [0, 1.7], [3, 1.3]), Select("date", ["2000-01-01"]), Select("level", [128]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_two_cyclic_axis_wrong_axis_order(self): - request = Request(Box(["step", "long", "level"], [0, 1.3, 131], [3, 1.7, 132]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "long", "level"], [0, 1.3, 131], [3, 1.7, 132]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 1.3, 1.4, 1.5, @@ -316,11 +328,12 @@ def test_two_cyclic_axis_wrong_axis_order(self): ] def test_two_cyclic_axis(self): - request = Request(Box(["step", "level", "long"], [0, 131, 1.3], [3, 132, 1.7]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level", "long"], [0, 131, 1.3], [3, 132, 1.7]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.value for leaf in result.leaves] == [ + assert [leaf.parent.value for leaf in result.leaves] == [ 1.3, 1.4, 1.5, @@ -344,15 +357,17 @@ def test_two_cyclic_axis(self): ] def test_select_cyclic_float_axis_edge(self): - request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0])) + request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 6 - assert [leaf.value for leaf in result.leaves] == [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + assert [leaf.parent.value for leaf in result.leaves] == [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] def test_cyclic_int_axis(self): - request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0.1])) + request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 6 - assert [leaf.value for leaf in result.leaves] == [0.1, 0.1, 0.1, 0.1, 0.1, 0.1] + assert [leaf.parent.value for leaf in result.leaves] == [0.1, 0.1, 0.1, 0.1, 0.1, 0.1] diff --git a/tests/test_datacube_xarray.py b/tests/test_datacube_xarray.py index b18f91f9..52e61172 100644 --- a/tests/test_datacube_xarray.py +++ b/tests/test_datacube_xarray.py @@ -16,21 +16,22 @@ def setup_method(self, method): def test_validate(self): dims = np.random.randn(1, 1, 1) array = xr.Dataset(data_vars=dict(param=(["x", "y", "z"], dims)), coords={"x": [1], "y": [1], "z": [1]}) + array = array.to_array() datacube = Datacube.create(array, options={}) datacube = Datacube.create(array, options={}) - datacube.validate(["x", "y", "z"]) - datacube.validate(["x", "z", "y"]) + datacube.validate(["x", "y", "z", "variable"]) + datacube.validate(["x", "z", "y", "variable"]) with pytest.raises(AxisNotFoundError): - datacube.validate(["x", "y", "z", "w"]) + datacube.validate(["x", "y", "z", "w", "variable"]) with pytest.raises(AxisNotFoundError): - datacube.validate(["w", "x", "y", "z"]) + datacube.validate(["w", "x", "y", "z", "variable"]) with pytest.raises(AxisOverdefinedError): - datacube.validate(["x", "x", "y", "z"]) + datacube.validate(["x", "x", "y", "z", "variable"]) def test_create(self): # Create a dataarray with 3 labelled axes using different index types diff --git a/tests/test_float_type.py b/tests/test_float_type.py index 4b42ce42..eca66d8e 100644 --- a/tests/test_float_type.py +++ b/tests/test_float_type.py @@ -20,7 +20,7 @@ def setup_method(self, method): "alt": np.arange(0.0, 20.0, 0.1), }, ) - + array = array.to_array() self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -28,36 +28,42 @@ def setup_method(self, method): def test_slicing_span(self): # TODO: some problems with floating point values and values inside the datacube being slightly off. # This has been fixed by introducing tolerances, but could be better handled using exact arithmetic. - request = Request(Span("lat", 4.1, 4.3), Select("long", [4.1]), Select("alt", [4.1])) + request = Request(Span("lat", 4.1, 4.3), Select("long", [4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 3 def test_slicing_point(self): - request = Request(Select("lat", [4.1]), Select("long", [4.1]), Select("alt", [4.1])) + request = Request(Select("lat", [4.1]), Select("long", [4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 1 and not result.leaves[0].is_root() @pytest.mark.skip(reason="Points too close, need exact arithmetic") def test_slicing_very_close_point(self): - request = Request(Select("lat", [4.1]), Select("long", [4.0999919, 4.1]), Select("alt", [4.1])) + request = Request(Select("lat", [4.1]), Select("long", [4.0999919, 4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 1 def test_slicing_points_higher_precision(self): - request = Request(Select("lat", [4.12]), Select("long", [4.1]), Select("alt", [4.1])) + request = Request(Select("lat", [4.12]), Select("long", [4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() assert result.leaves[0].is_root() def test_slicing_points_empty_span_higher_precision(self): - request = Request(Span("lat", 4.11, 4.12), Select("long", [4.1]), Select("alt", [4.1])) + request = Request(Span("lat", 4.11, 4.12), Select("long", [4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].is_root() def test_slicing_points_span_higher_precision(self): - request = Request(Span("lat", 4.09, 4.12), Select("long", [4.1]), Select("alt", [4.1])) + request = Request(Span("lat", 4.09, 4.12), Select("long", [4.1]), Select("alt", [4.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert not result.leaves[0].is_root() and len(result.leaves) == 1 diff --git a/tests/test_hullslicer_engine.py b/tests/test_hullslicer_engine.py index f113caf6..4bb15fb4 100644 --- a/tests/test_hullslicer_engine.py +++ b/tests/test_hullslicer_engine.py @@ -18,7 +18,6 @@ def setup_method(self, method): "level": np.arange(0, 100, 1), }, ) - self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) diff --git a/tests/test_slicer_era5.py b/tests/test_slicer_era5.py index 2e7f7795..e3f55e7c 100644 --- a/tests/test_slicer_era5.py +++ b/tests/test_slicer_era5.py @@ -8,7 +8,7 @@ class TestSlicingEra5Data: def setup_method(self, method): - array = xr.open_dataset("./tests/data/era5-levels-members.grib", engine="cfgrib") + array = xr.open_dataset("./tests/data/era5-levels-members.grib", engine="cfgrib").t self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) diff --git a/tests/test_slicer_xarray.py b/tests/test_slicer_xarray.py index ec67c69f..564e807f 100644 --- a/tests/test_slicer_xarray.py +++ b/tests/test_slicer_xarray.py @@ -19,12 +19,13 @@ def setup_method(self, method): "level": range(1, 130), }, ) - + array = array.to_array() self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) def test_2D_box(self): - request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() @@ -34,6 +35,7 @@ def test_2D_box_with_date_range(self): # TODO: conversion from numpy to Point class should allow dropping the pd.Timestamp # It should convert to correct type Span("date", lower=pd.Timestamp("2000-01-01"), upper=pd.Timestamp("2000-01-05")), + Select("variable", ["param"]) ) result = self.API.retrieve(request) result.pprint() @@ -41,6 +43,7 @@ def test_2D_box_with_date_range(self): def test_3D_box_with_date(self): request = Request( Box(["step", "level", "date"], [3, 10, pd.Timestamp("2000-01-01")], [6, 11, pd.Timestamp("2000-01-01")]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) result.pprint() diff --git a/tests/test_slicing_unsliceable_axis.py b/tests/test_slicing_unsliceable_axis.py index a16d9937..fdbb1cbd 100644 --- a/tests/test_slicing_unsliceable_axis.py +++ b/tests/test_slicing_unsliceable_axis.py @@ -18,6 +18,7 @@ def setup_method(self, method): data_vars=dict(param=(["date", "variable", "level"], dims)), coords={"date": pd.date_range("2000-01-01", "2000-01-03", 3), "variable": ["a"], "level": range(1, 130)}, ) + array = array.to_array(dim="parameter") self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -25,19 +26,22 @@ def setup_method(self, method): # Testing different shapes def test_finding_existing_variable(self): - request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["a"])) + request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["a"]), + Select("parameter", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 def test_finding_nonexisting_variable(self): - request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["b"])) + request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["b"]), + Select("parameter", ["param"])) with pytest.raises(ValueError): result = self.API.retrieve(request) result.pprint() def test_unsliceable_axis_in_a_shape(self): # does it work when we ask a box or disk of an unsliceable axis? - request = Request(Box(["level", "variable"], [10, "a"], [11, "a"]), Select("date", ["2000-01-01"])) + request = Request(Box(["level", "variable"], [10, "a"], [11, "a"]), Select("date", ["2000-01-01"]), + Select("parameter", ["param"])) with pytest.raises(UnsliceableShapeError): result = self.API.retrieve(request) result.pprint() diff --git a/tests/test_slicing_xarray_3D.py b/tests/test_slicing_xarray_3D.py index 6aba3900..aca668c5 100644 --- a/tests/test_slicing_xarray_3D.py +++ b/tests/test_slicing_xarray_3D.py @@ -33,6 +33,7 @@ def setup_method(self, method): "level": range(1, 130), }, ) + array = array.to_array(dim="variable") self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -40,68 +41,79 @@ def setup_method(self, method): # Testing different shapes def test_2D_box(self): - request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 def test_2D_box_union_disjoint_boxes(self): box1 = Box(["step", "level"], [3, 10], [6, 11]) box2 = Box(["step", "level"], [7, 15], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 + 6 def test_2D_box_union_overlapping_boxes(self): box1 = Box(["step", "level"], [3, 9], [6, 11]) box2 = Box(["step", "level"], [6, 10], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 6 + 24 - 2 def test_point(self): - request = Request(Select("date", ["2000-01-03"]), Select("level", [100]), Select("step", [3])) + request = Request(Select("date", ["2000-01-03"]), Select("level", [100]), Select("step", [3]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_segment(self): - request = Request(Span("level", 10, 11), Select("date", ["2000-01-01"]), Select("step", [9])) + request = Request(Span("level", 10, 11), Select("date", ["2000-01-01"]), Select("step", [9]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 def test_union_line_point(self): seg1 = Span("step", 4.3, 6.2) pt1 = Select("step", [6.20001]) - request = Request(Union(["step"], seg1, pt1), Select("date", ["2000-01-01"]), Select("level", [100])) + request = Request(Union(["step"], seg1, pt1), Select("date", ["2000-01-01"]), Select("level", [100]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_union_boxes_intersect_one_point(self): box1 = Box(["step", "level"], [3, 10], [6, 11]) box2 = Box(["step", "level"], [6, 11], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 + 3 * 7 - 1 def test_mix_existing_nonexisting_data(self): - request = Request(Select("date", ["2000-01-03", "2000-01-04"]), Select("level", [100]), Select("step", [3])) + request = Request(Select("date", ["2000-01-03", "2000-01-04"]), Select("level", [100]), Select("step", [3]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_disk(self): - request = Request(Disk(["level", "step"], [6, 6], [3, 3]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [6, 6], [3, 3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 9 def test_concave_polygon(self): points = [[1, 0], [3, 0], [2, 3], [3, 6], [1, 6]] - request = Request(Polygon(["level", "step"], points), Select("date", ["2000-01-01"])) + request = Request(Polygon(["level", "step"], points), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 8 def test_polytope(self): points = [[0, 1], [3, 1], [3, 2], [0, 2]] - request = Request(ConvexPolytope(["step", "level"], points), Select("date", ["2000-01-01"])) + request = Request(ConvexPolytope(["step", "level"], points), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 4 @@ -112,49 +124,57 @@ def test_union_empty_lines(self): # Slices non-existing step data seg1 = Span("step", 4, 5) seg2 = Span("step", 10, 11) - request = Request(Union(["step"], seg1, seg2), Select("date", ["2000-01-01"]), Select("level", [100])) + request = Request(Union(["step"], seg1, seg2), Select("date", ["2000-01-01"]), Select("level", [100]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_level(self): # Slices non-existing level data - request = Request(Box(["step", "level"], [3, 10.5], [7, 10.99]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [3, 10.5], [7, 10.99]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_level_step(self): # Slices non-existing level and step data - request = Request(Box(["step", "level"], [4, 10.5], [5, 10.99]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [4, 10.5], [5, 10.99]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_step(self): # Slices non-existing step and level data - request = Request(Box(["step", "level"], [4, 10], [5, 10.49]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [4, 10], [5, 10.49]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_floating_steps(self): # Slices through no step data and float type level data - request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 11.8]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 11.8]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_step_level_float(self): # Slices empty step and level box - request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 10.8]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 10.8]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_no_step_unordered(self): # Slice empty box because no step is available - request = Request(Box(["level", "step"], [10, 4], [10, 5]), Select("date", ["2000-01-01"])) + request = Request(Box(["level", "step"], [10, 4], [10, 5]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_date(self): # Slices non-existing date data - request = Request(Select("date", ["2000-01-04"]), Select("level", [100]), Select("step", [3])) + request = Request(Select("date", ["2000-01-04"]), Select("level", [100]), Select("step", [3]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -162,7 +182,8 @@ def test_two_nonexisting_close_points(self): # Slices two close points neither of which are available in the datacube pt1 = Select("step", [2.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -171,7 +192,8 @@ def test_union_two_nonexisting_points(self): # However if we round these points, we get points in the datacube pt1 = Select("step", [6.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -179,19 +201,22 @@ def test_two_close_points_no_level(self): # Slices non-existing step points and non-existing level pt1 = Select("step", [2.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100.1]), Select("date", ["2000-01-01"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100.1]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_point_float_level(self): # Slices non-existing level data - request = Request(Select("step", [3]), Select("level", [99.1]), Select("date", ["2000-01-02"])) + request = Request(Select("step", [3]), Select("level", [99.1]), Select("date", ["2000-01-02"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_segment(self): # Slices non-existing step data - request = Request(Span("step", 3.2, 3.23), Select("level", [99]), Select("date", ["2000-01-01"])) + request = Request(Span("step", 3.2, 3.23), Select("level", [99]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -199,13 +224,15 @@ def test_nonexisting_segment(self): def test_flat_box(self): # Should slice through a line in the step direction - request = Request(Box(["step", "level"], [4, 10], [7, 10]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level"], [4, 10], [7, 10]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_box(self): # Should slice a line in the level direction - request = Request(Box(["level", "step"], [3, 3], [6, 3]), Select("date", ["2000-01-01"])) + request = Request(Box(["level", "step"], [3, 3], [6, 3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 @@ -214,7 +241,8 @@ def test_swept_concave_polygon(self): points = [(1, 0), (3, 0), (3, 6), (2, 6), (2, 3), (1, 3)] concave_polygon = Polygon(["level", "step"], points) swept_poly = PathSegment(["level", "step"], concave_polygon, [0, 0], [1, 3]) - request = Request(swept_poly, Select("date", ["2000-01-01"])) + request = Request(swept_poly, Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 12 @@ -227,7 +255,8 @@ def test_intersection_point_disk_polygon(self): r1 = math.cos(math.pi / 12) * (8 - 4 * math.sqrt(3)) + sys.float_info.epsilon # note that we need a small perturbation to make up for rounding errors r2 = 3 * math.cos(math.pi / 12) * (math.sqrt(3) - 2) * (8 - 4 * math.sqrt(3)) / (4 * math.sqrt(3) - 7) - request = Request(Disk(["level", "step"], [0, 0], [r1, r2]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [0, 0], [r1, r2]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) paths = [r.flatten().values() for r in result.leaves] - assert (pd.Timestamp("2000-01-01 00:00:00"), 3.0, 1.0) in paths + assert (pd.Timestamp("2000-01-01 00:00:00"), 3.0, 1.0, "param") in paths diff --git a/tests/test_slicing_xarray_4D.py b/tests/test_slicing_xarray_4D.py index 38267482..582b50af 100644 --- a/tests/test_slicing_xarray_4D.py +++ b/tests/test_slicing_xarray_4D.py @@ -34,7 +34,7 @@ def setup_method(self, method): "lat": np.around(np.arange(0.0, 10.0, 0.1), 15), }, ) - + array = array.to_array() self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -42,20 +42,23 @@ def setup_method(self, method): # Testing different shapes def test_3D_box(self): - request = Request(Box(["step", "level", "lat"], [3, 10, 5.0], [6, 11, 6.0]), Select("date", ["2000-01-01"])) + request = Request(Box(["step", "level", "lat"], [3, 10, 5.0], [6, 11, 6.0]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 * 2 * 11 def test_4D_box(self): request = Request( Box(["step", "level", "lat", "date"], [3, 10, 5.0, "2000-01-01"], [6, 11, 6.0, "2000-01-02"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 2 * 2 * 11 * 2 def test_circle_int(self): request = Request( - Disk(["step", "level"], [9, 10], [6, 6]), Select("date", ["2000-01-01"]), Select("lat", [5.2]) + Disk(["step", "level"], [9, 10], [6, 6]), Select("date", ["2000-01-01"]), Select("lat", [5.2]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 37 @@ -63,28 +66,32 @@ def test_circle_int(self): def test_circles_barely_touching_int(self): disk1 = Disk(["step", "level"], [6, 10], [5.9, 6]) disk2 = Disk(["step", "level"], [15, 10], [2.9, 3]) - request = Request(Union(["step", "level"], disk1, disk2), Select("date", ["2000-01-01"]), Select("lat", [5.1])) + request = Request(Union(["step", "level"], disk1, disk2), Select("date", ["2000-01-01"]), Select("lat", [5.1]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 45 def test_circles_intersecting_float(self): disk1 = Disk(["step", "lat"], [6, 4.0], [6.99, 0.1]) disk2 = Disk(["step", "lat"], [15, 2.0], [4.99, 0.3]) - request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10])) + request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 24 def test_circles_touching_float(self): disk1 = Disk(["step", "lat"], [6, 4.0], [3, 1.9]) disk2 = Disk(["step", "lat"], [15, 2.0], [3, 2.1]) - request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10])) + request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 101 def test_pathsegment_swept_2D_box(self): box1 = Box(["step", "level"], [3, 0], [6, 1]) request = Request( - PathSegment(["step", "level"], box1, [3, 1], [6, 2]), Select("lat", [4.0]), Select("date", ["2000-01-01"]) + PathSegment(["step", "level"], box1, [3, 1], [6, 2]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() @@ -94,7 +101,8 @@ def test_pathsegment_swept_2D_box_bis(self): # Had a floating point problem because of the latitude box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.1]), Select("date", ["2000-01-01"]) + PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.1]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() @@ -103,7 +111,8 @@ def test_pathsegment_swept_2D_box_bis(self): def test_pathsegment_swept_circle(self): circ1 = Disk(["step", "level"], [6, 3], [3, 2]) request = Request( - PathSegment(["step", "level"], circ1, [3, 3], [6, 6]), Select("lat", [5.5]), Select("date", ["2000-01-01"]) + PathSegment(["step", "level"], circ1, [3, 3], [6, 6]), Select("lat", [5.5]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() @@ -112,7 +121,8 @@ def test_pathsegment_swept_circle(self): def test_path_swept_box_2_points(self): box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - Path(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.3]), Select("date", ["2000-01-01"]) + Path(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) # result.pprint() @@ -121,20 +131,22 @@ def test_path_swept_box_2_points(self): def test_path_swept_box_3_points(self): box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - Path(["step", "level"], box1, [3, 3], [6, 6], [9, 9]), Select("lat", [4.3]), Select("date", ["2000-01-01"]) + Path(["step", "level"], box1, [3, 3], [6, 6], [9, 9]), Select("lat", [4.3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 18 def test_polygon_other_than_triangle(self): polygon = Polygon(["step", "level"], [[3, 3], [3, 5], [6, 5], [6, 7]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 6 def test_ellipsoid(self): ellipsoid = Ellipsoid(["step", "level", "lat"], [6, 3, 2.1], [3, 1, 0.1]) - request = Request(ellipsoid, Select("date", ["2000-01-01"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 7 @@ -143,7 +155,8 @@ def test_ellipsoid(self): def test_empty_circle(self): # Slices a circle with no data inside request = Request( - Disk(["step", "level"], [5, 3.4], [0.5, 0.2]), Select("date", ["2000-01-01"]), Select("lat", [5.1]) + Disk(["step", "level"], [5, 3.4], [0.5, 0.2]), Select("date", ["2000-01-01"]), Select("lat", [5.1]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -151,7 +164,8 @@ def test_empty_circle(self): def test_float_box(self): # Slices a box with no data inside request = Request( - Box(["step", "lat"], [10.1, 1.01], [10.3, 1.04]), Select("date", ["2000-01-01"]), Select("level", [10]) + Box(["step", "lat"], [10.1, 1.01], [10.3, 1.04]), Select("date", ["2000-01-01"]), Select("level", [10]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -160,7 +174,8 @@ def test_path_empty_box(self): # Slices the path of a box with no data inside, but gives data because the box is swept over a datacube value box1 = Box(["step", "level"], [2.4, 3.1], [2.5, 3.4]) request = Request( - PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]) + PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 1 @@ -172,6 +187,7 @@ def test_path_empty_box_empty(self): PathSegment(["step", "level"], box1, [1.1, 3.3], [2.7, 3.6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -179,7 +195,7 @@ def test_path_empty_box_empty(self): def test_ellipsoid_empty(self): # Slices an empty ellipsoid which doesn't have any step value ellipsoid = Ellipsoid(["step", "level", "lat"], [5, 3, 2.1], [0, 0, 0]) - request = Request(ellipsoid, Select("date", ["2000-01-01"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -188,7 +204,8 @@ def test_ellipsoid_empty(self): def test_span_bounds(self): # Tests that span also works in reverse order request = Request( - Span("level", 100, 98), Select("step", [3]), Select("lat", [5.5]), Select("date", ["2000-01-01"]) + Span("level", 100, 98), Select("step", [3]), Select("lat", [5.5]), Select("date", ["2000-01-01"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 3 @@ -198,53 +215,60 @@ def test_span_bounds(self): def test_ellipsoid_one_point(self): # Slices through a point (center of the ellipsoid) ellipsoid = Ellipsoid(["step", "level", "lat"], [6, 3, 2.1], [0, 0, 0]) - request = Request(ellipsoid, Select("date", ["2000-01-01"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 assert not result.leaves[0].axis == IndexTree.root def test_flat_box_level(self): # Slices a line in the step direction - request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [3, 9]), Select("date", ["2000-01-01"])) + request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [3, 9]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 3 def test_flat_box_step(self): # Slices a line in the level direction - request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [7, 3]), Select("date", ["2000-01-01"])) + request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [7, 3]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert len(result.leaves) == 5 def test_flat_disk_nonexisting(self): # Slices an empty disk because there is no step level - request = Request(Disk(["level", "step"], [4, 5], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 5], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_flat_disk_line(self): # Slices a line in the level direction - request = Request(Disk(["level", "step"], [4, 6], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 6], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 8 def test_flat_disk_line_step(self): # Slices a line in the step direction - request = Request(Disk(["level", "step"], [4, 6], [0, 3]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 6], [0, 3]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 3 def test_flat_disk_empty(self): # Slices an empty disk because there is no step - request = Request(Disk(["level", "step"], [4, 5], [0, 0.5]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 5], [0, 0.5]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert result.leaves[0].axis == IndexTree.root def test_disk_point(self): # Slices a point because the origin of the disk is a datacube point - request = Request(Disk(["level", "step"], [4, 6], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 6], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 1 @@ -252,7 +276,8 @@ def test_disk_point(self): def test_empty_disk(self): # Slices an empty object because the origin of the disk is not a datacube point - request = Request(Disk(["level", "step"], [4, 5], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) + request = Request(Disk(["level", "step"], [4, 5], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), + Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert result.leaves[0].axis == IndexTree.root @@ -260,7 +285,7 @@ def test_empty_disk(self): def test_polygon_line(self): # Slices a line defined through the polygon shape polygon = Polygon(["step", "level"], [[3, 3], [3, 6], [3, 3], [3, 3]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 4 @@ -269,7 +294,7 @@ def test_polygon_point(self): # Slices a point defined through the polygon object with several initial point entries. # Tests whether duplicate points are removed as they should polygon = Polygon(["step", "level"], [[3, 3], [3, 3], [3, 3], [3, 3]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 1 @@ -278,7 +303,7 @@ def test_polygon_point(self): def test_polygon_empty(self): # Slices a point which isn't in the datacube (defined through the polygon shape) polygon = Polygon(["step", "level"], [[2, 3.1]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -289,18 +314,19 @@ def test_axis_specified_twice(self): request = Request( Box(["step", "level"], [3, 10], [6, 11]), Box(["step", "lat", "date"], [3, 5.0, "2000-01-01"], [6, 6.0, "2000-01-02"]), + Select("variable", ["param"]) ) result = self.API.retrieve(request) result.pprint() def test_not_all_axes_defined(self): with pytest.raises(AxisUnderdefinedError): - request = Request(Box(["step", "level"], [3, 10], [6, 11])) + request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() def test_not_all_axes_exist(self): with pytest.raises(KeyError): - request = Request(Box(["weather", "level"], [3, 10], [6, 11])) + request = Request(Box(["weather", "level"], [3, 10], [6, 11]), Select("variable", ["param"])) result = self.API.retrieve(request) result.pprint() From 977f1e8b2f734e8ff476b09e5dfba5814291e349 Mon Sep 17 00:00:00 2001 From: Mathilde Leuridan Date: Thu, 22 Jun 2023 10:47:38 +0200 Subject: [PATCH 2/2] remove the method=nearest in has_idx --- polytope/datacube/xarray.py | 7 +- tests/test_cyclic_axis_over_negative_vals.py | 38 +++----- tests/test_cyclic_axis_slicer_not_0.py | 38 +++----- tests/test_cyclic_axis_slicing.py | 75 ++++++--------- tests/test_float_type.py | 27 ++---- tests/test_slicer_xarray.py | 14 +-- tests/test_slicing_unsliceable_axis.py | 16 ++-- tests/test_slicing_xarray_3D.py | 93 +++++++----------- tests/test_slicing_xarray_4D.py | 99 +++++++------------- 9 files changed, 150 insertions(+), 257 deletions(-) diff --git a/polytope/datacube/xarray.py b/polytope/datacube/xarray.py index 511faa29..3e079ba6 100644 --- a/polytope/datacube/xarray.py +++ b/polytope/datacube/xarray.py @@ -25,7 +25,7 @@ np.float64: FloatAxis(), np.str_: UnsliceableaAxis(), str: UnsliceableaAxis(), - np.object_ : UnsliceableaAxis() + np.object_: UnsliceableaAxis(), } @@ -69,9 +69,6 @@ def get(self, requests: IndexTree): subxarray = self.dataarray.sel(path, method="nearest") value = subxarray.item() key = subxarray.name - # data_variables = subxarray.data_vars - # result_tuples = [(key, value) for key, value in data_variables.items()] - # r.result = dict(result_tuples) r.result = (key, value) else: r.remove_branch() @@ -142,7 +139,7 @@ def get_indices(self, path: DatacubePath, axis, lower, upper): def has_index(self, path: DatacubePath, axis, index): # when we want to obtain the value of an unsliceable axis, need to check the values does exist in the datacube - subarray = self.dataarray.sel(path, method='nearest')[axis.name] + subarray = self.dataarray.sel(path)[axis.name] subarray_vals = subarray.values return index in subarray_vals diff --git a/tests/test_cyclic_axis_over_negative_vals.py b/tests/test_cyclic_axis_over_negative_vals.py index a0ee1e1c..57c4a678 100644 --- a/tests/test_cyclic_axis_over_negative_vals.py +++ b/tests/test_cyclic_axis_over_negative_vals.py @@ -11,9 +11,9 @@ class TestSlicing3DXarrayDatacube: def setup_method(self, method): # Create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 6, 129, 11) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level", "long"], dims)), + array = xr.DataArray( + np.random.randn(3, 6, 129, 11), + dims=("date", "step", "level", "long"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15], @@ -21,7 +21,6 @@ def setup_method(self, method): "long": [-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1], }, ) - array = array.to_array() options = {"long": {"Cyclic": [-1.1, -0.1]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -31,13 +30,12 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -62,13 +60,12 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -89,23 +86,21 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -160,24 +155,21 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, - -0.3] + assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, diff --git a/tests/test_cyclic_axis_slicer_not_0.py b/tests/test_cyclic_axis_slicer_not_0.py index b3aa6f2a..93147c05 100644 --- a/tests/test_cyclic_axis_slicer_not_0.py +++ b/tests/test_cyclic_axis_slicer_not_0.py @@ -11,9 +11,9 @@ class TestSlicing3DXarrayDatacube: def setup_method(self, method): # create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 6, 129, 11) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level", "long"], dims)), + array = xr.DataArray( + np.random.randn(3, 6, 129, 11), + dims=("date", "step", "level", "long"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15], @@ -21,7 +21,6 @@ def setup_method(self, method): "long": [-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1], }, ) - array = array.to_array() options = {"long": {"Cyclic": [-1.1, -0.1]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -31,12 +30,11 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) assert len(result.leaves) == 20 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -61,13 +59,12 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -88,23 +85,21 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -159,24 +154,21 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, - -0.3] + assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, diff --git a/tests/test_cyclic_axis_slicing.py b/tests/test_cyclic_axis_slicing.py index 321f9f35..e5cbfb3a 100644 --- a/tests/test_cyclic_axis_slicing.py +++ b/tests/test_cyclic_axis_slicing.py @@ -11,9 +11,9 @@ class TestSlicing3DXarrayDatacube: def setup_method(self, method): # Create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 6, 129, 11) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level", "long"], dims)), + array = xr.DataArray( + np.random.randn(3, 6, 129, 11), + dims=("date", "step", "level", "long"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15], @@ -21,7 +21,6 @@ def setup_method(self, method): "long": [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0], }, ) - array = array.to_array() options = {"long": {"Cyclic": [0, 1.0]}, "level": {"Cyclic": [1, 129]}} self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() @@ -31,12 +30,11 @@ def setup_method(self, method): def test_cyclic_float_axis_across_seam(self): request = Request( - Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.8], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) assert len(result.leaves) == 20 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.8, 0.9, 1.0, @@ -61,13 +59,12 @@ def test_cyclic_float_axis_across_seam(self): def test_cyclic_float_axis_across_seam_repeated(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 1.0]), Select("date", ["2000-01-01"]), Select("level", [128]), - # Select("variable", ["param"]) + Box(["step", "long"], [0, 0.0], [3, 1.0]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -94,13 +91,12 @@ def test_cyclic_float_axis_across_seam_repeated(self): def test_cyclic_float_axis_across_seam_repeated_twice(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 2.0]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.0], [3, 2.0]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 * 2 - 2 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -147,13 +143,12 @@ def test_cyclic_float_axis_across_seam_repeated_twice(self): def test_cyclic_float_axis_inside_cyclic_range(self): request = Request( - Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.0], [3, 0.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 16 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.0, 0.1, 0.2, @@ -174,23 +169,23 @@ def test_cyclic_float_axis_inside_cyclic_range(self): def test_cyclic_float_axis_above_axis_range(self): request = Request( - Box(["step", "long"], [0, 1.3], [3, 1.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 1.3], [3, 1.7]), + Select("date", ["2000-01-01"]), + Select("level", [128]), ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_cyclic_float_axis_two_range_loops(self): request = Request( - Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 0.3], [3, 2.7]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 50 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 0.3, 0.4, 0.5, @@ -245,24 +240,21 @@ def test_cyclic_float_axis_two_range_loops(self): def test_cyclic_float_axis_below_axis_range(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, -0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, - -0.3] + assert [leaf.value for leaf in result.leaves] == [-0.7, -0.6, -0.5, -0.4, -0.3, -0.7, -0.6, -0.5, -0.4, -0.3] def test_cyclic_float_axis_below_axis_range_crossing_seam(self): request = Request( - Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, -0.7], [3, 0.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 22 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ -0.7, -0.6, -0.5, @@ -289,21 +281,19 @@ def test_cyclic_float_axis_below_axis_range_crossing_seam(self): def test_cyclic_float_axis_reversed(self): request = Request( - Box(["step", "long"], [0, 1.7], [3, 1.3]), Select("date", ["2000-01-01"]), Select("level", [128]), - Select("variable", ["param"]) + Box(["step", "long"], [0, 1.7], [3, 1.3]), Select("date", ["2000-01-01"]), Select("level", [128]) ) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 10 - assert [leaf.parent.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] + assert [leaf.value for leaf in result.leaves] == [1.3, 1.4, 1.5, 1.6, 1.7, 1.3, 1.4, 1.5, 1.6, 1.7] def test_two_cyclic_axis_wrong_axis_order(self): - request = Request(Box(["step", "long", "level"], [0, 1.3, 131], [3, 1.7, 132]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "long", "level"], [0, 1.3, 131], [3, 1.7, 132]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 1.3, 1.4, 1.5, @@ -327,12 +317,11 @@ def test_two_cyclic_axis_wrong_axis_order(self): ] def test_two_cyclic_axis(self): - request = Request(Box(["step", "level", "long"], [0, 131, 1.3], [3, 132, 1.7]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level", "long"], [0, 131, 1.3], [3, 132, 1.7]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 20 - assert [leaf.parent.value for leaf in result.leaves] == [ + assert [leaf.value for leaf in result.leaves] == [ 1.3, 1.4, 1.5, @@ -356,17 +345,15 @@ def test_two_cyclic_axis(self): ] def test_select_cyclic_float_axis_edge(self): - request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 6 - assert [leaf.parent.value for leaf in result.leaves] == [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + assert [leaf.value for leaf in result.leaves] == [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] def test_cyclic_int_axis(self): - request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0.1]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [0, 3], [3, 5]), Select("date", ["2000-01-01"]), Select("long", [0.1])) result = self.API.retrieve(request) # result.pprint() assert len(result.leaves) == 6 - assert [leaf.parent.value for leaf in result.leaves] == [0.1, 0.1, 0.1, 0.1, 0.1, 0.1] + assert [leaf.value for leaf in result.leaves] == [0.1, 0.1, 0.1, 0.1, 0.1, 0.1] diff --git a/tests/test_float_type.py b/tests/test_float_type.py index eca66d8e..0b07c79a 100644 --- a/tests/test_float_type.py +++ b/tests/test_float_type.py @@ -11,59 +11,50 @@ class TestFloatType: def setup_method(self, method): # Create a dataarray with 3 labelled axes using float type - dims = np.random.randn(100, 101, 200) - array = xr.Dataset( - data_vars=dict(param=(["lat", "long", "alt"], dims)), + array = xr.DataArray( + np.random.randn(100, 101, 200), + dims=("lat", "long", "alt"), coords={ "lat": np.arange(0.0, 10.0, 0.1), "long": np.arange(4.09999, 4.1 + 0.0000001, 0.0000001), "alt": np.arange(0.0, 20.0, 0.1), }, ) - array = array.to_array() self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) def test_slicing_span(self): - # TODO: some problems with floating point values and values inside the datacube being slightly off. - # This has been fixed by introducing tolerances, but could be better handled using exact arithmetic. - request = Request(Span("lat", 4.1, 4.3), Select("long", [4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Span("lat", 4.1, 4.3), Select("long", [4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 3 def test_slicing_point(self): - request = Request(Select("lat", [4.1]), Select("long", [4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Select("lat", [4.1]), Select("long", [4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 1 and not result.leaves[0].is_root() @pytest.mark.skip(reason="Points too close, need exact arithmetic") def test_slicing_very_close_point(self): - request = Request(Select("lat", [4.1]), Select("long", [4.0999919, 4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Select("lat", [4.1]), Select("long", [4.0999919, 4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) result.pprint() assert len(result.leaves) == 1 def test_slicing_points_higher_precision(self): - request = Request(Select("lat", [4.12]), Select("long", [4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Select("lat", [4.12]), Select("long", [4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) result.pprint() assert result.leaves[0].is_root() def test_slicing_points_empty_span_higher_precision(self): - request = Request(Span("lat", 4.11, 4.12), Select("long", [4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Span("lat", 4.11, 4.12), Select("long", [4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) assert result.leaves[0].is_root() def test_slicing_points_span_higher_precision(self): - request = Request(Span("lat", 4.09, 4.12), Select("long", [4.1]), Select("alt", [4.1]), - Select("variable", ["param"])) + request = Request(Span("lat", 4.09, 4.12), Select("long", [4.1]), Select("alt", [4.1])) result = self.API.retrieve(request) assert not result.leaves[0].is_root() and len(result.leaves) == 1 diff --git a/tests/test_slicer_xarray.py b/tests/test_slicer_xarray.py index b9b9b927..a7aecaab 100644 --- a/tests/test_slicer_xarray.py +++ b/tests/test_slicer_xarray.py @@ -10,22 +10,20 @@ class TestXarraySlicing: def setup_method(self, method): # Create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 6, 129) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level"], dims)), + array = xr.DataArray( + np.random.randn(3, 6, 129), + dims=("date", "step", "level"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15], "level": range(1, 130), }, ) - array = array.to_array() self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) def test_2D_box(self): - request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) result.pprint() @@ -33,15 +31,13 @@ def test_2D_box_with_date_range(self): request = Request( Box(["step", "level"], [3, 10], [6, 11]), Span("date", lower=pd.Timestamp("2000-01-01"), upper=pd.Timestamp("2000-01-05")), - Select("variable", ["param"]) ) result = self.API.retrieve(request) result.pprint() def test_3D_box_with_date(self): request = Request( - Box(["step", "level", "date"], [3, 10, pd.Timestamp("2000-01-01")], [6, 11, pd.Timestamp("2000-01-01")]), - Select("variable", ["param"]) + Box(["step", "level", "date"], [3, 10, pd.Timestamp("2000-01-01")], [6, 11, pd.Timestamp("2000-01-01")]) ) result = self.API.retrieve(request) result.pprint() diff --git a/tests/test_slicing_unsliceable_axis.py b/tests/test_slicing_unsliceable_axis.py index fdbb1cbd..45c21cdb 100644 --- a/tests/test_slicing_unsliceable_axis.py +++ b/tests/test_slicing_unsliceable_axis.py @@ -13,12 +13,11 @@ class TestSlicing3DXarrayDatacube: def setup_method(self, method): # create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 1, 129) - array = xr.Dataset( - data_vars=dict(param=(["date", "variable", "level"], dims)), + array = xr.DataArray( + np.random.randn(3, 1, 129), + dims=("date", "variable", "level"), coords={"date": pd.date_range("2000-01-01", "2000-01-03", 3), "variable": ["a"], "level": range(1, 130)}, ) - array = array.to_array(dim="parameter") self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -26,22 +25,19 @@ def setup_method(self, method): # Testing different shapes def test_finding_existing_variable(self): - request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["a"]), - Select("parameter", ["param"])) + request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["a"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 def test_finding_nonexisting_variable(self): - request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["b"]), - Select("parameter", ["param"])) + request = Request(Box(["level"], [10], [11]), Select("date", ["2000-01-01"]), Select("variable", ["b"])) with pytest.raises(ValueError): result = self.API.retrieve(request) result.pprint() def test_unsliceable_axis_in_a_shape(self): # does it work when we ask a box or disk of an unsliceable axis? - request = Request(Box(["level", "variable"], [10, "a"], [11, "a"]), Select("date", ["2000-01-01"]), - Select("parameter", ["param"])) + request = Request(Box(["level", "variable"], [10, "a"], [11, "a"]), Select("date", ["2000-01-01"])) with pytest.raises(UnsliceableShapeError): result = self.API.retrieve(request) result.pprint() diff --git a/tests/test_slicing_xarray_3D.py b/tests/test_slicing_xarray_3D.py index aca668c5..a90943e3 100644 --- a/tests/test_slicing_xarray_3D.py +++ b/tests/test_slicing_xarray_3D.py @@ -24,16 +24,15 @@ class TestSlicing3DXarrayDatacube: def setup_method(self, method): # Create a dataarray with 3 labelled axes using different index types - dims = np.random.randn(3, 6, 129) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level"], dims)), + array = xr.DataArray( + np.random.randn(3, 6, 129), + dims=("date", "step", "level"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15], "level": range(1, 130), }, ) - array = array.to_array(dim="variable") self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -41,79 +40,68 @@ def setup_method(self, method): # Testing different shapes def test_2D_box(self): - request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 def test_2D_box_union_disjoint_boxes(self): box1 = Box(["step", "level"], [3, 10], [6, 11]) box2 = Box(["step", "level"], [7, 15], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 + 6 def test_2D_box_union_overlapping_boxes(self): box1 = Box(["step", "level"], [3, 9], [6, 11]) box2 = Box(["step", "level"], [6, 10], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 6 + 24 - 2 def test_point(self): - request = Request(Select("date", ["2000-01-03"]), Select("level", [100]), Select("step", [3]), - Select("variable", ["param"])) + request = Request(Select("date", ["2000-01-03"]), Select("level", [100]), Select("step", [3])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_segment(self): - request = Request(Span("level", 10, 11), Select("date", ["2000-01-01"]), Select("step", [9]), - Select("variable", ["param"])) + request = Request(Span("level", 10, 11), Select("date", ["2000-01-01"]), Select("step", [9])) result = self.API.retrieve(request) assert len(result.leaves) == 2 def test_union_line_point(self): seg1 = Span("step", 4.3, 6.2) pt1 = Select("step", [6.20001]) - request = Request(Union(["step"], seg1, pt1), Select("date", ["2000-01-01"]), Select("level", [100]), - Select("variable", ["param"])) + request = Request(Union(["step"], seg1, pt1), Select("date", ["2000-01-01"]), Select("level", [100])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_union_boxes_intersect_one_point(self): box1 = Box(["step", "level"], [3, 10], [6, 11]) box2 = Box(["step", "level"], [6, 11], [12, 17]) - request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step", "level"], box1, box2), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 + 3 * 7 - 1 def test_mix_existing_nonexisting_data(self): - request = Request(Select("date", ["2000-01-03", "2000-01-04"]), Select("level", [100]), Select("step", [3]), - Select("variable", ["param"])) + request = Request(Select("date", ["2000-01-03", "2000-01-04"]), Select("level", [100]), Select("step", [3])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_disk(self): - request = Request(Disk(["level", "step"], [6, 6], [3, 3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [6, 6], [3, 3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 9 def test_concave_polygon(self): points = [[1, 0], [3, 0], [2, 3], [3, 6], [1, 6]] - request = Request(Polygon(["level", "step"], points), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Polygon(["level", "step"], points), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 8 def test_polytope(self): points = [[0, 1], [3, 1], [3, 2], [0, 2]] - request = Request(ConvexPolytope(["step", "level"], points), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(ConvexPolytope(["step", "level"], points), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 4 @@ -124,57 +112,49 @@ def test_union_empty_lines(self): # Slices non-existing step data seg1 = Span("step", 4, 5) seg2 = Span("step", 10, 11) - request = Request(Union(["step"], seg1, seg2), Select("date", ["2000-01-01"]), Select("level", [100]), - Select("variable", ["param"])) + request = Request(Union(["step"], seg1, seg2), Select("date", ["2000-01-01"]), Select("level", [100])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_level(self): # Slices non-existing level data - request = Request(Box(["step", "level"], [3, 10.5], [7, 10.99]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [3, 10.5], [7, 10.99]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_level_step(self): # Slices non-existing level and step data - request = Request(Box(["step", "level"], [4, 10.5], [5, 10.99]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [4, 10.5], [5, 10.99]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_step(self): # Slices non-existing step and level data - request = Request(Box(["step", "level"], [4, 10], [5, 10.49]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [4, 10], [5, 10.49]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_floating_steps(self): # Slices through no step data and float type level data - request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 11.8]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 11.8]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_box_no_step_level_float(self): # Slices empty step and level box - request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 10.8]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [4.1, 10.3], [5.7, 10.8]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_empty_no_step_unordered(self): # Slice empty box because no step is available - request = Request(Box(["level", "step"], [10, 4], [10, 5]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["level", "step"], [10, 4], [10, 5]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_date(self): # Slices non-existing date data - request = Request(Select("date", ["2000-01-04"]), Select("level", [100]), Select("step", [3]), - Select("variable", ["param"])) + request = Request(Select("date", ["2000-01-04"]), Select("level", [100]), Select("step", [3])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -182,8 +162,7 @@ def test_two_nonexisting_close_points(self): # Slices two close points neither of which are available in the datacube pt1 = Select("step", [2.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -192,8 +171,7 @@ def test_union_two_nonexisting_points(self): # However if we round these points, we get points in the datacube pt1 = Select("step", [6.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -201,22 +179,19 @@ def test_two_close_points_no_level(self): # Slices non-existing step points and non-existing level pt1 = Select("step", [2.99]) pt2 = Select("step", [3.001]) - request = Request(Union(["step"], pt1, pt2), Select("level", [100.1]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Union(["step"], pt1, pt2), Select("level", [100.1]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_point_float_level(self): # Slices non-existing level data - request = Request(Select("step", [3]), Select("level", [99.1]), Select("date", ["2000-01-02"]), - Select("variable", ["param"])) + request = Request(Select("step", [3]), Select("level", [99.1]), Select("date", ["2000-01-02"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_nonexisting_segment(self): # Slices non-existing step data - request = Request(Span("step", 3.2, 3.23), Select("level", [99]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Span("step", 3.2, 3.23), Select("level", [99]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -224,15 +199,13 @@ def test_nonexisting_segment(self): def test_flat_box(self): # Should slice through a line in the step direction - request = Request(Box(["step", "level"], [4, 10], [7, 10]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level"], [4, 10], [7, 10]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 def test_box(self): # Should slice a line in the level direction - request = Request(Box(["level", "step"], [3, 3], [6, 3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["level", "step"], [3, 3], [6, 3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 @@ -241,8 +214,7 @@ def test_swept_concave_polygon(self): points = [(1, 0), (3, 0), (3, 6), (2, 6), (2, 3), (1, 3)] concave_polygon = Polygon(["level", "step"], points) swept_poly = PathSegment(["level", "step"], concave_polygon, [0, 0], [1, 3]) - request = Request(swept_poly, Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(swept_poly, Select("date", ["2000-01-01"])) result = self.API.retrieve(request) self.xarraydatacube.get(result) assert len(result.leaves) == 12 @@ -255,8 +227,7 @@ def test_intersection_point_disk_polygon(self): r1 = math.cos(math.pi / 12) * (8 - 4 * math.sqrt(3)) + sys.float_info.epsilon # note that we need a small perturbation to make up for rounding errors r2 = 3 * math.cos(math.pi / 12) * (math.sqrt(3) - 2) * (8 - 4 * math.sqrt(3)) / (4 * math.sqrt(3) - 7) - request = Request(Disk(["level", "step"], [0, 0], [r1, r2]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [0, 0], [r1, r2]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) paths = [r.flatten().values() for r in result.leaves] - assert (pd.Timestamp("2000-01-01 00:00:00"), 3.0, 1.0, "param") in paths + assert (pd.Timestamp("2000-01-01 00:00:00"), 3.0, 1.0) in paths diff --git a/tests/test_slicing_xarray_4D.py b/tests/test_slicing_xarray_4D.py index 7d8025d6..449e5838 100644 --- a/tests/test_slicing_xarray_4D.py +++ b/tests/test_slicing_xarray_4D.py @@ -24,9 +24,9 @@ class TestSlicing4DXarrayDatacube: def setup_method(self, method): # Create a dataarray with 4 labelled axes using different index types - dims = np.random.randn(3, 7, 129, 100) - array = xr.Dataset( - data_vars=dict(param=(["date", "step", "level", "lat"], dims)), + array = xr.DataArray( + np.random.randn(3, 7, 129, 100), + dims=("date", "step", "level", "lat"), coords={ "date": pd.date_range("2000-01-01", "2000-01-03", 3), "step": [0, 3, 6, 9, 12, 15, 18], @@ -34,7 +34,6 @@ def setup_method(self, method): "lat": np.around(np.arange(0.0, 10.0, 0.1), 15), }, ) - array = array.to_array() self.xarraydatacube = XArrayDatacube(array) self.slicer = HullSlicer() self.API = Polytope(datacube=array, engine=self.slicer) @@ -42,23 +41,18 @@ def setup_method(self, method): # Testing different shapes def test_3D_box(self): - request = Request(Box(["step", "level", "lat"], [3, 10, 5.0], [6, 11, 6.0]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Box(["step", "level", "lat"], [3, 10, 5.0], [6, 11, 6.0]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 * 2 * 11 def test_4D_box(self): - request = Request( - Box(["step", "level", "lat", "date"], [3, 10, 5.0, "2000-01-01"], [6, 11, 6.0, "2000-01-02"]), - Select("variable", ["param"]) - ) + request = Request(Box(["step", "level", "lat", "date"], [3, 10, 5.0, "2000-01-01"], [6, 11, 6.0, "2000-01-02"])) result = self.API.retrieve(request) assert len(result.leaves) == 2 * 2 * 11 * 2 def test_circle_int(self): request = Request( - Disk(["step", "level"], [9, 10], [6, 6]), Select("date", ["2000-01-01"]), Select("lat", [5.2]), - Select("variable", ["param"]) + Disk(["step", "level"], [9, 10], [6, 6]), Select("date", ["2000-01-01"]), Select("lat", [5.2]) ) result = self.API.retrieve(request) assert len(result.leaves) == 37 @@ -66,32 +60,28 @@ def test_circle_int(self): def test_circles_barely_touching_int(self): disk1 = Disk(["step", "level"], [6, 10], [5.9, 6]) disk2 = Disk(["step", "level"], [15, 10], [2.9, 3]) - request = Request(Union(["step", "level"], disk1, disk2), Select("date", ["2000-01-01"]), Select("lat", [5.1]), - Select("variable", ["param"])) + request = Request(Union(["step", "level"], disk1, disk2), Select("date", ["2000-01-01"]), Select("lat", [5.1])) result = self.API.retrieve(request) assert len(result.leaves) == 45 def test_circles_intersecting_float(self): disk1 = Disk(["step", "lat"], [6, 4.0], [6.99, 0.1]) disk2 = Disk(["step", "lat"], [15, 2.0], [4.99, 0.3]) - request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10]), - Select("variable", ["param"])) + request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10])) result = self.API.retrieve(request) assert len(result.leaves) == 24 def test_circles_touching_float(self): disk1 = Disk(["step", "lat"], [6, 4.0], [3, 1.9]) disk2 = Disk(["step", "lat"], [15, 2.0], [3, 2.1]) - request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10]), - Select("variable", ["param"])) + request = Request(Union(["step", "lat"], disk1, disk2), Select("date", ["2000-01-01"]), Select("level", [10])) result = self.API.retrieve(request) assert len(result.leaves) == 101 def test_pathsegment_swept_2D_box(self): box1 = Box(["step", "level"], [3, 0], [6, 1]) request = Request( - PathSegment(["step", "level"], box1, [3, 1], [6, 2]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + PathSegment(["step", "level"], box1, [3, 1], [6, 2]), Select("lat", [4.0]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) # result.pprint() @@ -101,8 +91,7 @@ def test_pathsegment_swept_2D_box_bis(self): # Had a floating point problem because of the latitude box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.1]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.1]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) # result.pprint() @@ -111,8 +100,7 @@ def test_pathsegment_swept_2D_box_bis(self): def test_pathsegment_swept_circle(self): circ1 = Disk(["step", "level"], [6, 3], [3, 2]) request = Request( - PathSegment(["step", "level"], circ1, [3, 3], [6, 6]), Select("lat", [5.5]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + PathSegment(["step", "level"], circ1, [3, 3], [6, 6]), Select("lat", [5.5]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) # result.pprint() @@ -121,8 +109,7 @@ def test_pathsegment_swept_circle(self): def test_path_swept_box_2_points(self): box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - Path(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + Path(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.3]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 12 @@ -130,22 +117,20 @@ def test_path_swept_box_2_points(self): def test_path_swept_box_3_points(self): box1 = Box(["step", "level"], [3, 3], [6, 5]) request = Request( - Path(["step", "level"], box1, [3, 3], [6, 6], [9, 9]), Select("lat", [4.3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + Path(["step", "level"], box1, [3, 3], [6, 6], [9, 9]), Select("lat", [4.3]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 18 def test_polygon_other_than_triangle(self): polygon = Polygon(["step", "level"], [[3, 3], [3, 5], [6, 5], [6, 7]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 6 def test_ellipsoid(self): ellipsoid = Ellipsoid(["step", "level", "lat"], [6, 3, 2.1], [3, 1, 0.1]) - request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 7 @@ -154,8 +139,7 @@ def test_ellipsoid(self): def test_empty_circle(self): # Slices a circle with no data inside request = Request( - Disk(["step", "level"], [5, 3.4], [0.5, 0.2]), Select("date", ["2000-01-01"]), Select("lat", [5.1]), - Select("variable", ["param"]) + Disk(["step", "level"], [5, 3.4], [0.5, 0.2]), Select("date", ["2000-01-01"]), Select("lat", [5.1]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -163,8 +147,7 @@ def test_empty_circle(self): def test_float_box(self): # Slices a box with no data inside request = Request( - Box(["step", "lat"], [10.1, 1.01], [10.3, 1.04]), Select("date", ["2000-01-01"]), Select("level", [10]), - Select("variable", ["param"]) + Box(["step", "lat"], [10.1, 1.01], [10.3, 1.04]), Select("date", ["2000-01-01"]), Select("level", [10]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -173,8 +156,7 @@ def test_path_empty_box(self): # Slices the path of a box with no data inside, but gives data because the box is swept over a datacube value box1 = Box(["step", "level"], [2.4, 3.1], [2.5, 3.4]) request = Request( - PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + PathSegment(["step", "level"], box1, [3, 3], [6, 6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 1 @@ -186,7 +168,6 @@ def test_path_empty_box_empty(self): PathSegment(["step", "level"], box1, [1.1, 3.3], [2.7, 3.6]), Select("lat", [4.0]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) ) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -194,7 +175,7 @@ def test_path_empty_box_empty(self): def test_ellipsoid_empty(self): # Slices an empty ellipsoid which doesn't have any step value ellipsoid = Ellipsoid(["step", "level", "lat"], [5, 3, 2.1], [0, 0, 0]) - request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -203,8 +184,7 @@ def test_ellipsoid_empty(self): def test_span_bounds(self): # Tests that span also works in reverse order request = Request( - Span("level", 100, 98), Select("step", [3]), Select("lat", [5.5]), Select("date", ["2000-01-01"]), - Select("variable", ["param"]) + Span("level", 100, 98), Select("step", [3]), Select("lat", [5.5]), Select("date", ["2000-01-01"]) ) result = self.API.retrieve(request) assert len(result.leaves) == 3 @@ -214,72 +194,64 @@ def test_span_bounds(self): def test_ellipsoid_one_point(self): # Slices through a point (center of the ellipsoid) ellipsoid = Ellipsoid(["step", "level", "lat"], [6, 3, 2.1], [0, 0, 0]) - request = Request(ellipsoid, Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(ellipsoid, Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 assert not result.leaves[0].axis == IndexTree.root def test_flat_box_level(self): # Slices a line in the step direction - request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [3, 9]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [3, 9]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 3 def test_flat_box_step(self): # Slices a line in the level direction - request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [7, 3]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Select("lat", [6]), Box(["level", "step"], [3, 3], [7, 3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 5 def test_flat_disk_nonexisting(self): # Slices an empty disk because there is no step level - request = Request(Disk(["level", "step"], [4, 5], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 5], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_flat_disk_line(self): # Slices a line in the level direction - request = Request(Disk(["level", "step"], [4, 6], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 6], [4, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 8 def test_flat_disk_line_step(self): # Slices a line in the step direction - request = Request(Disk(["level", "step"], [4, 6], [0, 3]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 6], [0, 3]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 3 def test_flat_disk_empty(self): # Slices an empty disk because there is no step - request = Request(Disk(["level", "step"], [4, 5], [0, 0.5]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 5], [0, 0.5]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_disk_point(self): # Slices a point because the origin of the disk is a datacube point - request = Request(Disk(["level", "step"], [4, 6], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 6], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 assert not result.leaves[0].axis == IndexTree.root def test_empty_disk(self): # Slices an empty object because the origin of the disk is not a datacube point - request = Request(Disk(["level", "step"], [4, 5], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"]), - Select("variable", ["param"])) + request = Request(Disk(["level", "step"], [4, 5], [0, 0]), Select("lat", [6]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root def test_polygon_line(self): # Slices a line defined through the polygon shape polygon = Polygon(["step", "level"], [[3, 3], [3, 6], [3, 3], [3, 3]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 4 @@ -287,7 +259,7 @@ def test_polygon_point(self): # Slices a point defined through the polygon object with several initial point entries. # Tests whether duplicate points are removed as they should polygon = Polygon(["step", "level"], [[3, 3], [3, 3], [3, 3], [3, 3]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert len(result.leaves) == 1 assert not result.leaves[0].axis == IndexTree.root @@ -295,7 +267,7 @@ def test_polygon_point(self): def test_polygon_empty(self): # Slices a point which isn't in the datacube (defined through the polygon shape) polygon = Polygon(["step", "level"], [[2, 3.1]]) - request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"]), Select("variable", ["param"])) + request = Request(polygon, Select("lat", [4.3]), Select("date", ["2000-01-01"])) result = self.API.retrieve(request) assert result.leaves[0].axis == IndexTree.root @@ -306,19 +278,18 @@ def test_axis_specified_twice(self): request = Request( Box(["step", "level"], [3, 10], [6, 11]), Box(["step", "lat", "date"], [3, 5.0, "2000-01-01"], [6, 6.0, "2000-01-02"]), - Select("variable", ["param"]) ) result = self.API.retrieve(request) result.pprint() def test_not_all_axes_defined(self): with pytest.raises(AxisUnderdefinedError): - request = Request(Box(["step", "level"], [3, 10], [6, 11]), Select("variable", ["param"])) + request = Request(Box(["step", "level"], [3, 10], [6, 11])) result = self.API.retrieve(request) result.pprint() def test_not_all_axes_exist(self): with pytest.raises(KeyError): - request = Request(Box(["weather", "level"], [3, 10], [6, 11]), Select("variable", ["param"])) + request = Request(Box(["weather", "level"], [3, 10], [6, 11])) result = self.API.retrieve(request) result.pprint()