polytope-python 1.0.30__tar.gz → 1.0.32__tar.gz

polytope_python-1.0.32/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: polytope-python
+Version: 1.0.32
+Summary: Polytope datacube feature extraction library
+Home-page: https://github.com/ecmwf/polytope
+Author: ECMWF
+Author-email: James.Hawkes@ecmwf.int, Mathilde.Leuridan@ecmwf.int
+License-File: LICENSE
+Requires-Dist: numpy==1.26.4
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: sortedcontainers
+Requires-Dist: tripy
+Requires-Dist: xarray
+Requires-Dist: conflator
+Requires-Dist: protobuf
+
+Polytope is a library for extracting complex data from datacubes. It provides an API for
+                        non-orthogonal access to data, where the stencil used to extract data from the datacube can be
+                        any arbitrary n-dimensional polygon (called a polytope). This can be used to efficiently
+                        extract complex features from a datacube, such as polygon regions or spatio-temporal paths.

{polytope-python-1.0.30 → polytope_python-1.0.32}/polytope_feature/datacube/backends/fdb.py

@@ -3,7 +3,7 @@ import operator
 from copy import deepcopy
 from itertools import product
 
-from ...utility.exceptions import BadGridError, BadRequestError
+from ...utility.exceptions import BadGridError, BadRequestError, GribJumpNoIndexError
 from ...utility.geometry import nearest_pt
 from .datacube import Datacube, TensorIndexTree
 
@@ -145,6 +145,9 @@ class FDBDatacube(Datacube):
             if "BadValue: Grid hash mismatch" in str(e):
                 logging.info("Error is: %s", e)
                 raise BadGridError()
+            if "Missing JumpInfo" in str(e):
+                logging.info("Error is: %s", e)
+                raise GribJumpNoIndexError()
             else:
                 raise e
 

{polytope-python-1.0.30 → polytope_python-1.0.32}/polytope_feature/utility/exceptions.py

@@ -38,3 +38,8 @@ class UnsliceableShapeError(PolytopeError, KeyError):
 class BadGridError(PolytopeError, ValueError):
     def __init__(self):
         self.message = "Data on this grid is not supported by Polytope."
+
+
+class GribJumpNoIndexError(PolytopeError, ValueError):
+    def __init__(self):
+        self.message = "GribJump index for this data is not yet available."

polytope_python-1.0.32/polytope_feature/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.32"

polytope_python-1.0.32/polytope_python.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: polytope-python
+Version: 1.0.32
+Summary: Polytope datacube feature extraction library
+Home-page: https://github.com/ecmwf/polytope
+Author: ECMWF
+Author-email: James.Hawkes@ecmwf.int, Mathilde.Leuridan@ecmwf.int
+License-File: LICENSE
+Requires-Dist: numpy==1.26.4
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: sortedcontainers
+Requires-Dist: tripy
+Requires-Dist: xarray
+Requires-Dist: conflator
+Requires-Dist: protobuf
+
+Polytope is a library for extracting complex data from datacubes. It provides an API for
+                        non-orthogonal access to data, where the stencil used to extract data from the datacube can be
+                        any arbitrary n-dimensional polygon (called a polytope). This can be used to efficiently
+                        extract complex features from a datacube, such as polygon regions or spatio-temporal paths.

{polytope-python-1.0.30 → polytope_python-1.0.32}/polytope_python.egg-info/SOURCES.txt

@@ -52,4 +52,65 @@ polytope_python.egg-info/SOURCES.txt
 polytope_python.egg-info/dependency_links.txt
 polytope_python.egg-info/not-zip-safe
 polytope_python.egg-info/requires.txt
-polytope_python.egg-info/top_level.txt
+polytope_python.egg-info/top_level.txt
+tests/test_axis_mappers.py
+tests/test_bad_request_error.py
+tests/test_combinatorics.py
+tests/test_cyclic_axis_over_negative_vals.py
+tests/test_cyclic_axis_slicer_not_0.py
+tests/test_cyclic_axis_slicing.py
+tests/test_cyclic_nearest.py
+tests/test_cyclic_simple.py
+tests/test_cyclic_snapping.py
+tests/test_datacube_axes_init.py
+tests/test_datacube_mock.py
+tests/test_datacube_xarray.py
+tests/test_date_time_unmerged.py
+tests/test_ecmwf_oper_data_fdb.py
+tests/test_engine_slicer.py
+tests/test_fdb_datacube.py
+tests/test_fdb_unmap_tree.py
+tests/test_float_type.py
+tests/test_healpix_mapper.py
+tests/test_healpix_nested_grid.py
+tests/test_hull_slicer.py
+tests/test_hullslicer_engine.py
+tests/test_incomplete_tree_fdb.py
+tests/test_local_grid_cyclic.py
+tests/test_local_regular_grid.py
+tests/test_local_swiss_grid.py
+tests/test_mappers.py
+tests/test_merge_cyclic_octahedral.py
+tests/test_merge_octahedral_one_axis.py
+tests/test_merge_transformation.py
+tests/test_multiple_param_fdb.py
+tests/test_octahedral_grid.py
+tests/test_override_md5_hash_options.py
+tests/test_point_nearest.py
+tests/test_point_shape.py
+tests/test_profiling_requesttree.py
+tests/test_reduced_ll_grid.py
+tests/test_regular_grid.py
+tests/test_regular_reduced_grid.py
+tests/test_request_tree.py
+tests/test_request_trees_after_slicing.py
+tests/test_reverse_transformation.py
+tests/test_shapes.py
+tests/test_slice_date_range_fdb.py
+tests/test_slice_date_range_fdb_v2.py
+tests/test_slice_fdb_box.py
+tests/test_slicer_engine.py
+tests/test_slicer_era5.py
+tests/test_slicer_xarray.py
+tests/test_slicing_unsliceable_axis.py
+tests/test_slicing_xarray_3D.py
+tests/test_slicing_xarray_4D.py
+tests/test_snapping.py
+tests/test_snapping_real_data.py
+tests/test_tree_protobuf.py
+tests/test_tree_protobuf_encoding.py
+tests/test_tree_protobuf_encoding_fdb.py
+tests/test_type_change_transformation.py
+tests/test_union_gj.py
+tests/test_union_point_box.py
+tests/test_wave_spectra_data.py

polytope_python-1.0.32/tests/test_axis_mappers.py

@@ -0,0 +1,122 @@
+import pandas as pd
+
+from polytope_feature.datacube.datacube_axis import (
+    DatacubeAxisCyclic,
+    FloatDatacubeAxis,
+    IntDatacubeAxis,
+    PandasTimedeltaDatacubeAxis,
+    PandasTimestampDatacubeAxis,
+)
+from polytope_feature.options import PolytopeOptions
+
+
+class TestAxisMappers:
+    def setup_method(self, method):
+        pass
+
+    def test_int_axis(self):
+        axis = IntDatacubeAxis()
+        assert axis.parse(2) == 2.0
+        assert axis.to_float(2) == 2.0
+        assert axis.from_float(2) == 2.0
+        assert axis.serialize(2) == 2
+        assert axis.remap([2, 3]) == [[2, 3]]
+
+    def test_float_axis(self):
+        axis = FloatDatacubeAxis()
+        assert axis.parse(2) == 2.0
+        assert axis.to_float(2) == 2.0
+        assert axis.from_float(2) == 2.0
+        assert axis.serialize(2.0) == 2.0
+        assert axis.remap([2, 3]) == [[2, 3]]
+
+    def test_float_axis_cyclic(self):
+        axis = FloatDatacubeAxis()
+
+        axis.is_cyclic = True
+        assert axis.parse(2) == 2.0
+        assert axis.to_float(2) == 2.0
+        assert axis.from_float(2) == 2.0
+        assert axis.serialize(2.0) == 2.0
+
+        options = {
+            "axis_config": [
+                {"axis_name": "long", "transformations": [{"name": "cyclic", "range": [0, 1.0]}]},
+            ],
+        }
+        transformation = PolytopeOptions.get_polytope_options(options)[0][0]
+        transformation_option = transformation.transformations[0]
+        transformation = DatacubeAxisCyclic("", transformation_option)
+        # Test the to_intervals function
+        transformation.range = [1, 3]
+        assert transformation.to_intervals([4, 7], [[]], axis) == [[4, 5], [5, 7], [7, 7]]
+        # Test the cyclic_remap function
+
+        transformation.range = [0, 1]
+        assert transformation.remap([0, 2], [[]], axis) == [[-1e-12, 1.000000000001], [-1e-12, 1.000000000001]]
+
+        transformation.range = [1, 2]
+        assert transformation.remap([1, 3], [[]], axis) == [
+            [0.999999999999, 2.000000000001],
+            [0.999999999999, 2.000000000001],
+        ]
+
+        transformation.range = [1, 3]
+        assert transformation.remap([1, 4], [[]], axis) == [
+            [0.999999999999, 3.000000000001],
+            [0.999999999999, 2.000000000001],
+        ]
+
+        transformation.range = [2, 4]
+        assert transformation.remap([0, 5], [[]], axis) == [
+            [1.999999999999, 4.000000000001],
+            [1.999999999999, 4.000000000001],
+            [1.999999999999, 3.000000000001],
+        ]
+        transformation.range = [2.3, 4.6]
+        remapped = transformation.remap([0.3, 5.7], [[]], axis)
+        assert remapped == [
+            [2.5999999999989996, 4.600000000001],
+            [2.2999999999989997, 4.600000000001],
+            [2.2999999999989997, 3.4000000000010004],
+        ]
+
+        # Test the to_cyclic_value function
+        transformation.range = [1, 3]
+        remapped = transformation.remap([0, 7], [[]], axis)
+        assert remapped == [
+            [1.999999999999, 3.000000000001],
+            [0.999999999999, 3.000000000001],
+            [0.999999999999, 3.000000000001],
+            [0.999999999999, 3.000000000001],
+        ]
+        remapped = transformation.remap([-1, 2], [[]], axis)
+        assert remapped == [[0.999999999999, 3.000000000001], [0.999999999999, 2.000000000001]]
+
+        # Test the cyclic_offset function
+        assert transformation.offset([3.05, 3.1], axis, 0) == 2
+        assert transformation.offset([1.05, 1.1], axis, 0) == 0
+        assert transformation.offset([-5.0, -4.95], axis, 0) == -6
+        assert transformation.offset([5.05, 5.1], axis, 0) == 4
+
+    def test_timedelta_axis(self):
+        axis = PandasTimedeltaDatacubeAxis()
+        time1 = pd.Timedelta("1 days")
+        time2 = pd.Timedelta("1 days 2 hours")
+        assert axis.parse(time1) == pd.Timedelta("1 days 00:00:00")
+        assert axis.to_float(time1) == 86400.0
+        assert axis.from_float(3600) == pd.Timedelta("0 days 01:00:00")
+        assert axis.serialize(time1) == "1 days 00:00:00"
+        assert axis.remap([time1, time2]) == [[pd.Timedelta("1 days 00:00:00"), pd.Timedelta("1 days 02:00:00")]]
+
+    def test_timestamp_axis(self):
+        axis = PandasTimestampDatacubeAxis()
+        time1 = pd.Timestamp("2017-01-01 11:00:00")
+        time2 = pd.Timestamp("2017-01-01 12:00:00")
+        assert axis.parse(time1) == pd.Timestamp("2017-01-01 11:00:00")
+        assert axis.to_float(time1) == 1483268400.0
+        assert axis.from_float(1483268400.0) == pd.Timestamp("2017-01-01 11:00:00")
+        assert axis.serialize(time1) == "2017-01-01 11:00:00"
+        assert axis.remap([time1, time2]) == [
+            [pd.Timestamp("2017-01-01 11:00:00"), pd.Timestamp("2017-01-01 12:00:00")]
+        ]

polytope_python-1.0.32/tests/test_bad_request_error.py

@@ -0,0 +1,65 @@
+import pytest
+
+from polytope_feature.engine.hullslicer import HullSlicer
+from polytope_feature.polytope import Polytope
+from polytope_feature.utility.exceptions import BadRequestError
+
+# import geopandas as gpd
+# import matplotlib.pyplot as plt
+
+
+class TestSlicingFDBDatacube:
+    def setup_method(self, method):
+        # Create a dataarray with 3 labelled axes using different index types
+        self.options = {
+            "axis_config": [
+                {"axis_name": "step", "transformations": [{"name": "type_change", "type": "int"}]},
+                {"axis_name": "number", "transformations": [{"name": "type_change", "type": "int"}]},
+                {
+                    "axis_name": "date",
+                    "transformations": [{"name": "merge", "other_axis": "time", "linkers": ["T", "00"]}],
+                },
+                {
+                    "axis_name": "values",
+                    "transformations": [
+                        {"name": "mapper", "type": "octahedral", "resolution": 1280, "axes": ["latitude", "longitude"]}
+                    ],
+                },
+                {"axis_name": "latitude", "transformations": [{"name": "reverse", "is_reverse": True}]},
+                {"axis_name": "longitude", "transformations": [{"name": "cyclic", "range": [0, 360]}]},
+            ],
+            "compressed_axes_config": [
+                "longitude",
+                "latitude",
+                "levtype",
+                "step",
+                "date",
+                "domain",
+                "expver",
+                "param",
+                "class",
+                "stream",
+                "type",
+            ],
+            "pre_path": {
+                "class": "od",
+                "expver": "0001",
+                "levtype": "sfc",
+                "stream": "oper",
+                "date": "20230621T120000",
+            },
+        }
+
+    # Testing different shapes
+    @pytest.mark.fdb
+    def test_fdb_datacube(self):
+        import pygribjump as gj
+
+        with pytest.raises(BadRequestError):
+            self.fdbdatacube = gj.GribJump()
+            self.slicer = HullSlicer()
+            self.API = Polytope(
+                datacube=self.fdbdatacube,
+                engine=self.slicer,
+                options=self.options,
+            )

polytope_python-1.0.32/tests/test_combinatorics.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pytest
+
+from polytope_feature import ConvexPolytope
+from polytope_feature.utility.combinatorics import group, tensor_product, validate_axes
+from polytope_feature.utility.exceptions import (
+    AxisNotFoundError,
+    AxisOverdefinedError,
+    AxisUnderdefinedError,
+)
+
+
+class TestCombinatorics:
+    def setup_method(self, method):
+        pass
+
+    def test_group_and_product(self):
+        p1 = ConvexPolytope(["x", "y"], [[1, 2], [3, 4], [5, 6]])
+        p2 = ConvexPolytope(["a", "b"], [[1, 2], [3, 4], [5, 6]])
+        p3 = ConvexPolytope(["b", "a"], [[1, 2], [3, 4], [5, 6]])
+        p4 = ConvexPolytope(np.array(["a", "b"]), [[1, 2], [3, 4], [5, 6]])
+        p5 = ConvexPolytope(("a", "b"), [[1, 2], [3, 4], [5, 6]])
+
+        groups, all_axes = group([p1, p2, p3, p4, p5])
+
+        assert len(groups) == 2
+        assert len(groups[("x", "y")]) == 1
+        assert len(groups[("a", "b")]) == 4
+        assert len(all_axes) == 4
+
+        combinations = tensor_product(groups)
+
+        assert len(combinations) == 4
+        for c in combinations:
+            assert len(c) == 2
+
+    def test_group_with_different_number_of_axes(self):
+        p1 = ConvexPolytope(["x", "y"], [[1, 2], [3, 4], [5, 6]])
+        p2 = ConvexPolytope(["a", "b", "c"], [[1, 2], [3, 4], [5, 6]])
+
+        groups, all_axes = group([p1, p2])
+
+        assert len(groups) == 2
+        assert len(groups[("x", "y")]) == 1
+        assert len(groups[("a", "b", "c")]) == 1
+        assert len(all_axes) == 5
+
+    def test_validate_axes(self):
+        with pytest.raises(AxisNotFoundError):
+            validate_axes(["x", "y", "z"], ["x", "y", "z", "a"])
+        with pytest.raises(AxisUnderdefinedError):
+            validate_axes(["x", "y", "z"], ["x", "y"])
+        with pytest.raises(AxisUnderdefinedError):
+            validate_axes(["x", "y", "z"], ["x", "y", "b"])
+        with pytest.raises(AxisUnderdefinedError):
+            validate_axes(["x", "y", "z"], [])
+        with pytest.raises(AxisUnderdefinedError):
+            validate_axes(["x", "y", "z"], ["a"])
+        with pytest.raises(AxisOverdefinedError):
+            validate_axes(["x", "y", "z"], ["x", "x", "y", "z"])
+        with pytest.raises(AxisOverdefinedError):
+            validate_axes(["x", "y", "z"], ["x", "x", "x"])
+
+        assert validate_axes([], [])
+        assert validate_axes(["x"], ["x"])
+        assert validate_axes(["x", "y", "z"], ["x", "y", "z"])
+        assert validate_axes(["x", "y", "z"], ["z", "x", "y"])
+
+
+TestCombinatorics().test_group_and_product()
+TestCombinatorics().test_validate_axes()

polytope_python-1.0.32/tests/test_cyclic_axis_over_negative_vals.py

@@ -0,0 +1,156 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from polytope_feature.engine.hullslicer import HullSlicer
+from polytope_feature.polytope import Polytope, Request
+from polytope_feature.shapes import Box, Select
+
+
+class TestSlicingCyclicAxisNegVals:
+    def setup_method(self, method):
+        # Create a dataarray with 3 labelled axes using different index types
+        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],
+                "level": range(1, 130),
+                "long": [-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0, -1.1][::-1],
+            },
+        )
+        options = {
+            "axis_config": [
+                {"axis_name": "long", "transformations": [{"name": "cyclic", "range": [-1.1, -0.1]}]},
+                {"axis_name": "level", "transformations": [{"name": "cyclic", "range": [1, 129]}]},
+            ],
+            "compressed_axes_config": ["long", "level", "step", "date"],
+        }
+        self.slicer = HullSlicer()
+        self.API = Polytope(datacube=array, engine=self.slicer, options=options)
+
+    # Testing different shapes
+
+    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])
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-1.1,),
+            (-1.0,),
+            (-0.9,),
+            (-0.8,),
+            (-0.7,),
+            (-0.6,),
+            (-0.5,),
+            (-0.4,),
+            (-0.3,),
+            (-0.2,),
+        ]
+
+    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])
+        )
+        result = self.API.retrieve(request)
+        # result.pprint()
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-1.0,),
+            (-0.9,),
+            (-0.8,),
+            (-0.7,),
+            (-0.6,),
+            (-0.5,),
+            (-0.4,),
+            (-0.3,),
+        ]
+
+    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])
+        )
+        result = self.API.retrieve(request)
+        # result.pprint()
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-0.7,),
+            (-0.6,),
+            (-0.5,),
+            (-0.4,),
+            (-0.3,),
+        ]
+
+    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])
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-1.1,),
+            (-1.1,),
+            (-1.0,),
+            (-1.0,),
+            (-0.9,),
+            (-0.9,),
+            (-0.8,),
+            (-0.8,),
+            (-0.7,),
+            (-0.7,),
+            (-0.7,),
+            (-0.6,),
+            (-0.6,),
+            (-0.6,),
+            (-0.5,),
+            (-0.5,),
+            (-0.5,),
+            (-0.4,),
+            (-0.4,),
+            (-0.4,),
+            (-0.3,),
+            (-0.3,),
+            (-0.3,),
+            (-0.2,),
+            (-0.2,),
+        ]
+
+    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])
+        )
+        result = self.API.retrieve(request)
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-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])
+        )
+        result = self.API.retrieve(request)
+        # result.pprint()
+        assert len(result.leaves) == 1
+        assert [(val,) for val in result.leaves[0].values] == [
+            (-1.0,),
+            (-0.9,),
+            (-0.8,),
+            (-0.7,),
+            (-0.7,),
+            (-0.6,),
+            (-0.5,),
+            (-0.4,),
+            (-0.3,),
+            (-0.2,),
+            (-0.1,),
+        ]