polytope-python 1.0.34__tar.gz → 1.0.36__tar.gz

{polytope_python-1.0.34/polytope_python.egg-info → polytope_python-1.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polytope-python
-Version: 1.0.34
+Version: 1.0.36
 Summary: Polytope datacube feature extraction library
 Home-page: https://github.com/ecmwf/polytope
 Author: ECMWF

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/backends/fdb.py

@@ -227,17 +227,22 @@ class FDBDatacube(Datacube):
             first_ax_name = requests.children[0].axis.name
             second_ax_name = requests.children[0].children[0].axis.name
 
-            if first_ax_name not in self.nearest_search.keys() or second_ax_name not in self.nearest_search.keys():
+            axes_in_nearest_search = [
+                first_ax_name not in self.nearest_search.keys(),
+                second_ax_name not in self.nearest_search.keys(),
+            ]
+
+            if all(not item for item in axes_in_nearest_search):
                 raise Exception("nearest point search axes are wrong")
 
             second_ax = requests.children[0].children[0].axis
+            nearest_pts = self.nearest_search.get(first_ax_name, None)
+            if nearest_pts is None:
+                nearest_pts = self.nearest_search[second_ax_name]
 
-            nearest_pts = [
-                [lat_val, second_ax._remap_val_to_axis_range(lon_val)]
-                for (lat_val, lon_val) in zip(
-                    self.nearest_search[first_ax_name][0], self.nearest_search[second_ax_name][0]
-                )
-            ]
+            transformed_nearest_pts = []
+            for point in nearest_pts:
+                transformed_nearest_pts.append([point[0], second_ax._remap_val_to_axis_range(point[1])])
 
             found_latlon_pts = []
             for lat_child in requests.children:
@@ -246,7 +251,7 @@ class FDBDatacube(Datacube):
 
             # now find the nearest lat lon to the points requested
             nearest_latlons = []
-            for pt in nearest_pts:
+            for pt in transformed_nearest_pts:
                 nearest_latlon = nearest_pt(found_latlon_pts, pt)
                 nearest_latlons.append(nearest_latlon)
 

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py

@@ -99,16 +99,14 @@ class DatacubeMapper(DatacubeAxisTransformation):
             return self.second_axis_vals(first_val)
 
     def unmap_path_key(self, key_value_path, leaf_path, unwanted_path, axis):
-        value = key_value_path[axis.name]
+        values = key_value_path[axis.name]
         if axis.name == self._mapped_axes()[0]:
             unwanted_val = key_value_path[self._mapped_axes()[0]]
             unwanted_path[axis.name] = unwanted_val
         if axis.name == self._mapped_axes()[1]:
             first_val = unwanted_path[self._mapped_axes()[0]]
-            unmapped_idx = []
-            for val in value:
-                unmapped_idx.append(self.unmap(first_val, (val,)))
-            # unmapped_idx = self.unmap(first_val, value)
+            # unmapped_idx = [self.unmap(first_val, (val,)) for val in value]
+            unmapped_idx = self.unmap(first_val, values)
             leaf_path.pop(self._mapped_axes()[0], None)
             key_value_path.pop(axis.name)
             key_value_path[self.old_axis] = unmapped_idx

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/healpix.py

@@ -133,14 +133,17 @@ class HealpixGridMapper(DatacubeMapper):
             else:
                 return idx
 
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
         first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
         first_idx = self._first_axis_vals.index(first_value)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        healpix_index = self.axes_idx_to_healpix_idx(first_idx, second_idx)
-        return healpix_index
+        return_idxs = []
+        for second_val in second_vals:
+            second_val = [i for i in self.second_axis_vals(first_val) if second_val - tol <= i <= second_val + tol][0]
+            second_idx = self.second_axis_vals(first_val).index(second_val)
+            healpix_index = self.axes_idx_to_healpix_idx(first_idx, second_idx)
+            return_idxs.append(healpix_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/healpix_nested.py

@@ -1,4 +1,3 @@
-import bisect
 import math
 
 from ..datacube_mappers import DatacubeMapper
@@ -14,9 +13,11 @@ class NestedHealpixGridMapper(DatacubeMapper):
         self._first_axis_vals = self.first_axis_vals()
         self.compressed_grid_axes = [self._mapped_axes[1]]
         self.Nside = self._resolution
+        self._cached_longitudes = {}
         self.k = int(math.log2(self.Nside))
         self.Npix = 12 * self.Nside * self.Nside
         self.Ncap = (self.Nside * (self.Nside - 1)) << 1
+        self._healpix_longitudes = {}
         if md5_hash is not None:
             self.md5_hash = md5_hash
         else:
@@ -58,7 +59,9 @@ class NestedHealpixGridMapper(DatacubeMapper):
         return values
 
     def second_axis_vals_from_idx(self, first_val_idx):
-        values = self.HEALPix_longitudes(first_val_idx)
+        if first_val_idx not in self._healpix_longitudes:
+            self._healpix_longitudes[first_val_idx] = self.HEALPix_longitudes(first_val_idx)
+        values = self._healpix_longitudes[first_val_idx]
         return values
 
     def HEALPix_nj(self, i):
@@ -74,14 +77,19 @@ class NestedHealpixGridMapper(DatacubeMapper):
             return self.HEALPix_nj(ni - 1 - i)
 
     def HEALPix_longitudes(self, i):
-        Nj = self.HEALPix_nj(i)
-        step = 360.0 / Nj
-        start = (
-            step / 2.0 if i < self._resolution or 3 * self._resolution - 1 < i or (i + self._resolution) % 2 else 0.0
-        )
-
-        longitudes = [start + n * step for n in range(Nj)]
-
+        if i in self._cached_longitudes:
+            return self._cached_longitudes[i]
+        else:
+            Nj = self.HEALPix_nj(i)
+            step = 360.0 / Nj
+            start = (
+                step / 2.0
+                if i < self._resolution or 3 * self._resolution - 1 < i or (i + self._resolution) % 2
+                else 0.0
+            )
+
+            longitudes = [start + n * step for n in range(Nj)]
+            self._cached_longitudes[i] = longitudes
         return longitudes
 
     def map_second_axis(self, first_val, lower, upper):
@@ -110,43 +118,25 @@ class NestedHealpixGridMapper(DatacubeMapper):
                 idx += second_idx
                 return idx
 
-    def find_second_idx(self, first_val, second_val):
-        tol = 1e-10
-        second_axis_vals = self.second_axis_vals(first_val)
-        second_idx = bisect.bisect_left(second_axis_vals, second_val - tol)
-        return second_idx
-
-    def unmap_first_val_to_start_line_idx(self, first_val):
-        tol = 1e-8
-        first_val = [i for i in self._first_axis_vals if first_val - tol <= i <= first_val + tol][0]
-        first_idx = self._first_axis_vals.index(first_val)
-        idx = 0
-        for i in range(self._resolution - 1):
-            if i != first_idx:
-                idx += 4 * (i + 1)
-            else:
-                return idx
-        for i in range(self._resolution - 1, 3 * self._resolution):
-            if i != first_idx:
-                idx += 4 * self._resolution
-            else:
-                return idx
-        for i in range(3 * self._resolution, 4 * self._resolution - 1):
-            if i != first_idx:
-                idx += 4 * (4 * self._resolution - 1 - i + 1)
-            else:
-                return idx
-
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
-        first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
-        first_idx = self._first_axis_vals.index(first_value)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        healpix_index = self.axes_idx_to_healpix_idx(first_idx, second_idx)
-        # TODO: here do conversion of ring to nested healpix representation before returning
-        healpix_index = self.ring_to_nested(healpix_index)
-        return healpix_index
+        first_idx = next(
+            (i for i, val in enumerate(self._first_axis_vals) if first_val[0] - tol <= val <= first_val[0] + tol), None
+        )
+        if first_idx is None:
+            return None
+        second_axis_vals = self.second_axis_vals_from_idx(first_idx)
+
+        return_idxs = []
+        for second_val in second_vals:
+            second_idx = next(
+                (i for i, val in enumerate(second_axis_vals) if second_val - tol <= val <= second_val + tol), None
+            )
+            if second_idx is None:
+                return None
+            healpix_index = self.axes_idx_to_healpix_idx(first_idx, second_idx)
+            return_idxs.append(healpix_index)
+        return return_idxs
 
     def div_03(self, a, b):
         t = 1 if a >= (b << 1) else 0

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/local_regular.py

@@ -81,14 +81,17 @@ class LocalRegularGridMapper(DatacubeMapper):
         first_idx = self._first_axis_vals.index(first_val)
         return first_idx * self.second_resolution
 
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
         first_val = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
         first_idx = self._first_axis_vals.index(first_val)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        final_index = self.axes_idx_to_regular_idx(first_idx, second_idx)
-        return final_index
+        return_idxs = []
+        for second_val in second_vals:
+            second_val = [i for i in self.second_axis_vals(first_val) if second_val - tol <= i <= second_val + tol][0]
+            second_idx = self.second_axis_vals(first_val).index(second_val)
+            final_index = self.axes_idx_to_regular_idx(first_idx, second_idx)
+            return_idxs.append(final_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/octahedral.py

@@ -7877,16 +7877,19 @@ class OctahedralGridMapper(DatacubeMapper):
     def find_second_axis_idx(self, first_val, second_val):
         (second_axis_spacing, first_idx) = self.second_axis_spacing(first_val)
         tol = 1e-8
-        if second_val[0] / second_axis_spacing > int(second_val[0] / second_axis_spacing) + 1 - tol:
-            second_idx = int(second_val[0] / second_axis_spacing) + 1
+        if second_val / second_axis_spacing > int(second_val / second_axis_spacing) + 1 - tol:
+            second_idx = int(second_val / second_axis_spacing) + 1
         else:
-            second_idx = int(second_val[0] / second_axis_spacing)
+            second_idx = int(second_val / second_axis_spacing)
         return (first_idx, second_idx)
 
-    def unmap(self, first_val, second_val):
-        (first_idx, second_idx) = self.find_second_axis_idx(first_val, second_val)
-        octahedral_index = self.axes_idx_to_octahedral_idx(first_idx, second_idx)
-        return octahedral_index
+    def unmap(self, first_val, second_vals):
+        return_idxs = []
+        for second_val in second_vals:
+            (first_idx, second_idx) = self.find_second_axis_idx(first_val, second_val)
+            octahedral_index = self.axes_idx_to_octahedral_idx(first_idx, second_idx)
+            return_idxs.append(octahedral_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_gaussian.py

@@ -1432,25 +1432,17 @@ class ReducedGaussianGridMapper(DatacubeMapper):
                 idx += second_idx
                 return idx
 
-    # def find_second_idx(self, first_val, second_val):
-    #     tol = 1e-10
-    #     second_axis_vals = self.second_axis_vals(first_val)
-    #     second_idx = bisect.bisect_left(second_axis_vals, second_val[0] - tol)
-    #     return second_idx
-
-    # def unmap(self, first_val, second_val):
-    #     (first_idx, second_idx) = self.find_second_idx(first_val, second_val)
-    #     octahedral_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx)
-    #     return octahedral_index
-
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
         first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
         first_idx = self._first_axis_vals.index(first_value)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        reduced_gaussian_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx)
-        return reduced_gaussian_index
+        return_idxs = []
+        for second_val in second_vals:
+            second_val = [i for i in self.second_axis_vals(first_val) if second_val - tol <= i <= second_val + tol][0]
+            second_idx = self.second_axis_vals(first_val).index(second_val)
+            reduced_gaussian_index = self.axes_idx_to_reduced_gaussian_idx(first_idx, second_idx)
+            return_idxs.append(reduced_gaussian_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/reduced_ll.py

@@ -5114,14 +5114,17 @@ class ReducedLatLonMapper(DatacubeMapper):
         second_idx = bisect.bisect_left(second_axis_vals, second_val - tol)
         return second_idx
 
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
         first_value = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
         first_idx = self._first_axis_vals.index(first_value)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        reduced_ll_index = self.axes_idx_to_reduced_ll_idx(first_idx, second_idx)
-        return reduced_ll_index
+        return_idxs = []
+        for second_val in second_vals:
+            second_val = [i for i in self.second_axis_vals(first_val) if second_val - tol <= i <= second_val + tol][0]
+            second_idx = self.second_axis_vals(first_val).index(second_val)
+            reduced_ll_index = self.axes_idx_to_reduced_ll_idx(first_idx, second_idx)
+            return_idxs.append(reduced_ll_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/transformations/datacube_mappers/mapper_types/regular.py

@@ -61,14 +61,17 @@ class RegularGridMapper(DatacubeMapper):
         first_idx = self._first_axis_vals.index(first_val)
         return first_idx * 4 * self._resolution
 
-    def unmap(self, first_val, second_val):
+    def unmap(self, first_val, second_vals):
         tol = 1e-8
         first_val = [i for i in self._first_axis_vals if first_val[0] - tol <= i <= first_val[0] + tol][0]
         first_idx = self._first_axis_vals.index(first_val)
-        second_val = [i for i in self.second_axis_vals(first_val) if second_val[0] - tol <= i <= second_val[0] + tol][0]
-        second_idx = self.second_axis_vals(first_val).index(second_val)
-        final_index = self.axes_idx_to_regular_idx(first_idx, second_idx)
-        return final_index
+        return_idxs = []
+        for second_val in second_vals:
+            second_val = [i for i in self.second_axis_vals(first_val) if second_val - tol <= i <= second_val + tol][0]
+            second_idx = self.second_axis_vals(first_val).index(second_val)
+            final_index = self.axes_idx_to_regular_idx(first_idx, second_idx)
+            return_idxs.append(final_index)
+        return return_idxs
 
 
 # md5 grid hash in form {resolution : hash}

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/datacube/tree_encoding.py

@@ -38,7 +38,8 @@ def encode_child(tree: TensorIndexTree, child: TensorIndexTree, node, result_siz
 
     if child.hidden:
         # add indexes to parent and add also indexes size...
-        node.indexes.extend(tree.indexes)
+        for tree_indexes in tree.indexes:
+            node.indexes.extend(tree_indexes)
         break_tag = False
         return break_tag
 

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/engine/hullslicer.py

@@ -8,7 +8,7 @@ import scipy.spatial
 from ..datacube.backends.datacube import Datacube
 from ..datacube.datacube_axis import UnsliceableDatacubeAxis
 from ..datacube.tensor_index_tree import TensorIndexTree
-from ..shapes import ConvexPolytope
+from ..shapes import ConvexPolytope, Product
 from ..utility.combinatorics import group, tensor_product
 from ..utility.exceptions import UnsliceableShapeError
 from ..utility.geometry import lerp
@@ -76,8 +76,6 @@ class HullSlicer(Engine):
         upper = ax.from_float(upper + tol)
         flattened = node.flatten()
         method = polytope.method
-        if method == "nearest":
-            datacube.nearest_search[ax.name] = polytope.points
 
         # NOTE: caching
         # Create a coupled_axes list inside of datacube and add to it during axis formation, then here
@@ -214,7 +212,11 @@ class HullSlicer(Engine):
 
         # Convert the polytope points to float type to support triangulation and interpolation
         for p in polytopes:
-            self._unique_continuous_points(p, datacube)
+            if isinstance(p, Product):
+                for poly in p.polytope():
+                    self._unique_continuous_points(poly, datacube)
+            else:
+                self._unique_continuous_points(p, datacube)
 
         groups, input_axes = group(polytopes)
         datacube.validate(input_axes)
@@ -233,7 +235,16 @@ class HullSlicer(Engine):
                     new_c.extend(combi)
                 else:
                     new_c.append(combi)
-            r["unsliced_polytopes"] = set(new_c)
+            # NOTE TODO: here some of the polys in new_c can be a Product shape instead of a ConvexPolytope
+            # -> need to go through the polytopes in new_c and replace the Products with their sub-ConvexPolytopes
+            final_polys = []
+            for poly in new_c:
+                if isinstance(poly, Product):
+                    final_polys.extend(poly.polytope())
+                else:
+                    final_polys.append(poly)
+            # r["unsliced_polytopes"] = set(new_c)
+            r["unsliced_polytopes"] = set(final_polys)
             current_nodes = [r]
             for ax in datacube.axes.values():
                 next_nodes = []

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/polytope.py

@@ -64,6 +64,13 @@ class Polytope:
         """Higher-level API which takes a request and uses it to slice the datacube"""
         logging.info("Starting request for %s ", self.context)
         self.datacube.check_branching_axes(request)
+        for polytope in request.polytopes():
+            method = polytope.method
+            if method == "nearest":
+                if self.datacube.nearest_search.get(polytope.axes()[0], None) is None:
+                    self.datacube.nearest_search[polytope.axes()[0]] = polytope.values
+                else:
+                    self.datacube.nearest_search[polytope.axes()[0]].append(polytope.values[0])
         request_tree = self.engine.extract(self.datacube, request.polytopes())
         logging.info("Created request tree for %s ", self.context)
         self.datacube.get(request_tree, self.context)

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_feature/shapes.py

@@ -61,6 +61,42 @@ class ConvexPolytope(Shape):
         return [self]
 
 
+class Product(Shape):
+    """Shape that takes two polytopes and 'multiplies' them together to obtain higher-dimensional shape"""
+
+    def __init__(self, *polytopes, method, value):
+        # TODO
+        all_axes = []
+        for poly in polytopes:
+            all_axes.extend(poly.axes())
+        self._axes = list(set(all_axes))
+        # Check there weren't any duplicates in the polytopes' axes
+        assert len(self._axes) == len(all_axes)
+
+        self._polytopes = []
+        for poly in polytopes:
+            self._polytopes.extend(poly.polytope())
+
+        self.is_in_union = False
+        self.method = method
+        self.values = value
+
+        self.is_orthogonal = False
+
+        polys_orthogonal = [poly.is_orthogonal for poly in polytopes]
+        if all(polys_orthogonal):
+            self.is_orthogonal = True
+
+    def add_to_union(self):
+        self.is_in_union = True
+
+    def axes(self):
+        return self._axes
+
+    def polytope(self):
+        return self._polytopes
+
+
 # This is the only shape which can slice on axes without a discretizer or interpolator
 class Select(Shape):
     """Matches several discrete values"""
@@ -89,19 +125,22 @@ class Point(Shape):
         self._axes = axes
         self.values = values
         self.method = method
-        self.polytopes = []
-        if method == "nearest":
-            assert len(self.values) == 1
-        for i in range(len(axes)):
-            polytope_points = [v[i] for v in self.values]
-            self.polytopes.extend(
-                [ConvexPolytope([axes[i]], [[point]], self.method, is_orthogonal=True) for point in polytope_points]
-            )
+        assert len(values) == 1
 
     def axes(self):
         return self._axes
 
     def polytope(self):
+        # TODO: change this to use the Product instead and return a Product here of the two 1D selects
+
+        polytopes = []
+        for point in self.values:
+            poly_to_mult = []
+            for i in range(len(self._axes)):
+                poly_to_mult.append(ConvexPolytope([self._axes[i]], [[point[i]]], self.method, is_orthogonal=True))
+            polytopes.append(Product(*poly_to_mult, method=self.method, value=[point]))
+        self.polytopes = polytopes
+
         return self.polytopes
 
     def __repr__(self):

polytope_python-1.0.36/polytope_feature/version.py

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

{polytope_python-1.0.34 → polytope_python-1.0.36/polytope_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polytope-python
-Version: 1.0.34
+Version: 1.0.36
 Summary: Polytope datacube feature extraction library
 Home-page: https://github.com/ecmwf/polytope
 Author: ECMWF

{polytope_python-1.0.34 → polytope_python-1.0.36}/polytope_python.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ tests/test_octahedral_grid.py
 tests/test_override_md5_hash_options.py
 tests/test_point_nearest.py
 tests/test_point_shape.py
+tests/test_point_union.py
 tests/test_profiling_requesttree.py
 tests/test_reduced_ll_grid.py
 tests/test_regular_grid.py

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_fdb_unmap_tree.py

@@ -73,13 +73,13 @@ class TestSlicingFDBDatacube:
             assert leaf.hidden
             assert leaf._parent.hidden
             assert leaf._parent._parent.indexes == [
-                3294704,
-                3294705,
-                3294706,
-                3289572,
-                3289573,
-                3289574,
-                3284444,
-                3284445,
-                3284446,
+                [3294704],
+                [3294705],
+                [3294706],
+                [3289572],
+                [3289573],
+                [3289574],
+                [3284444],
+                [3284445],
+                [3284446],
             ]

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_healpix_mapper.py

@@ -70,7 +70,7 @@ class TestHealpixGrid:
                 eccodes_result = nearest_points[0][0]["value"]
 
                 mapper = HealpixGridMapper("base", ["base1", "base2"], 32)
-                assert nearest_points[0][0]["index"] == mapper.unmap((lat,), (lon,))
+                assert nearest_points[0][0]["index"] == mapper.unmap((lat,), (lon,))[0]
                 assert eccodes_lat - tol <= lat
                 assert lat <= eccodes_lat + tol
                 assert eccodes_lon - tol <= lon

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_mappers.py

@@ -102,6 +102,6 @@ class TestMapper:
         base_axis = "base"
         resolution = 1280
         octahedral_mapper = OctahedralGridMapper(base_axis, mapped_axes, resolution)
-        assert octahedral_mapper.unmap((89.94618771566562,), (0,)) == 0
-        assert octahedral_mapper.unmap((0.035149384215604956,), (0,)) == 3299840 - 5136
-        assert octahedral_mapper.unmap((-0.035149384215604956,), (0,)) == 3299840
+        assert octahedral_mapper.unmap((89.94618771566562,), (0,))[0] == 0
+        assert octahedral_mapper.unmap((0.035149384215604956,), (0,))[0] == 3299840 - 5136
+        assert octahedral_mapper.unmap((-0.035149384215604956,), (0,))[0] == 3299840

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_point_shape.py

@@ -4,7 +4,7 @@ import xarray as xr
 
 from polytope_feature.engine.hullslicer import HullSlicer
 from polytope_feature.polytope import Polytope, Request
-from polytope_feature.shapes import Point, Select
+from polytope_feature.shapes import Point, Select, Union
 
 
 class TestSlicing3DXarrayDatacube:
@@ -30,20 +30,26 @@ class TestSlicing3DXarrayDatacube:
         assert result.leaves[0].axis.name == "level"
 
     def test_multiple_points(self):
-        request = Request(Point(["step", "level"], [[3, 10], [3, 12]]), Select("date", ["2000-01-01"]))
+        # request = Request(Point(["step", "level"], [[3, 10], [3, 12]]), Select("date", ["2000-01-01"]))
+        request = Request(
+            Union(["step", "level"], Point(["step", "level"], [[3, 10]]), Point(["step", "level"], [[3, 12]])),
+            Select("date", ["2000-01-01"]),
+        )
         result = self.API.retrieve(request)
         result.pprint()
-        assert len(result.leaves) == 1
+        assert len(result.leaves) == 2
         assert result.leaves[0].axis.name == "level"
 
     def test_point_surrounding_step(self):
         request = Request(Point(["step", "level"], [[2, 10]], method="surrounding"), Select("date", ["2000-01-01"]))
         result = self.API.retrieve(request)
+        result.pprint()
         assert len(result.leaves) == 1
         assert np.shape(result.leaves[0].result[1]) == (1, 2, 3)
 
     def test_point_surrounding_exact_step(self):
         request = Request(Point(["step", "level"], [[3, 10]], method="surrounding"), Select("date", ["2000-01-01"]))
         result = self.API.retrieve(request)
+        result.pprint()
         assert len(result.leaves) == 1
         assert np.shape(result.leaves[0].result[1]) == (1, 3, 3)

polytope_python-1.0.36/tests/test_point_union.py

@@ -0,0 +1,148 @@
+import pandas as pd
+import pytest
+
+from polytope_feature.engine.hullslicer import HullSlicer
+from polytope_feature.polytope import Polytope, Request
+from polytope_feature.shapes import Point, Select, Span, Union
+
+
+class TestSlicingFDBDatacube:
+    def setup_method(self, method):
+        # Create a dataarray with 3 labelled axes using different index types
+        self.options = {
+            "axis_config": [
+                {"axis_name": "number", "transformations": [{"name": "type_change", "type": "int"}]},
+                {"axis_name": "step", "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]}]},
+            ],
+            "pre_path": {"class": "od", "expver": "0001", "levtype": "sfc", "stream": "oper"},
+            "compressed_axes_config": [
+                "longitude",
+                "latitude",
+                "levtype",
+                "step",
+                "date",
+                "domain",
+                "expver",
+                "param",
+                "class",
+                "stream",
+                "type",
+            ],
+        }
+
+    # Testing different shapes
+    @pytest.mark.fdb
+    def test_fdb_datacube(self):
+        import pygribjump as gj
+
+        request = Request(
+            Select("step", [0]),
+            Select("levtype", ["sfc"]),
+            Span("date", pd.Timestamp("20230625T120000"), pd.Timestamp("20230626T120000")),
+            Select("domain", ["g"]),
+            Select("expver", ["0001"]),
+            Select("param", ["167"]),
+            Select("class", ["od"]),
+            Select("stream", ["oper"]),
+            Select("type", ["an"]),
+            Union(
+                ["latitude", "longitude"],
+                Point(["latitude", "longitude"], [[20, 20]], method="nearest"),
+                Point(["latitude", "longitude"], [[0, 0]], method="nearest"),
+                Point(["latitude", "longitude"], [[0, 20]], method="nearest"),
+                Point(["latitude", "longitude"], [[25, 30]], method="nearest"),
+                Point(["latitude", "longitude"], [[-30, 90]], method="nearest"),
+                Point(["latitude", "longitude"], [[-60, -30]], method="nearest"),
+                Point(["latitude", "longitude"], [[-15, -45]], method="nearest"),
+                Point(["latitude", "longitude"], [[20, 0]], method="nearest"),
+            ),
+        )
+
+        self.fdbdatacube = gj.GribJump()
+        self.slicer = HullSlicer()
+        self.API = Polytope(
+            datacube=self.fdbdatacube,
+            engine=self.slicer,
+            options=self.options,
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 8
+
+    @pytest.mark.fdb
+    def test_fdb_datacube_surrounding(self):
+        import pygribjump as gj
+
+        request = Request(
+            Select("step", [0]),
+            Select("levtype", ["sfc"]),
+            Span("date", pd.Timestamp("20230625T120000"), pd.Timestamp("20230626T120000")),
+            Select("domain", ["g"]),
+            Select("expver", ["0001"]),
+            Select("param", ["167"]),
+            Select("class", ["od"]),
+            Select("stream", ["oper"]),
+            Select("type", ["an"]),
+            Union(
+                ["latitude", "longitude"],
+                Point(["latitude", "longitude"], [[25, 30]], method="surrounding"),
+                Point(["latitude", "longitude"], [[-15, -45]], method="surrounding"),
+            ),
+        )
+
+        self.fdbdatacube = gj.GribJump()
+        self.slicer = HullSlicer()
+        self.API = Polytope(
+            datacube=self.fdbdatacube,
+            engine=self.slicer,
+            options=self.options,
+        )
+        result = self.API.retrieve(request)
+        result.pprint()
+        assert len(result.leaves) == 4
+        tot_leaves = 0
+        for leaf in result.leaves:
+            tot_leaves += len(leaf.result)
+        assert tot_leaves == 9
+
+    # @pytest.mark.fdb
+    # def test_fdb_datacube_mix_methods(self):
+    #     import pygribjump as gj
+
+    #     request = Request(
+    #         Select("step", [0]),
+    #         Select("levtype", ["sfc"]),
+    #         Span("date", pd.Timestamp("20230625T120000"), pd.Timestamp("20230626T120000")),
+    #         Select("domain", ["g"]),
+    #         Select("expver", ["0001"]),
+    #         Select("param", ["167"]),
+    #         Select("class", ["od"]),
+    #         Select("stream", ["oper"]),
+    #         Select("type", ["an"]),
+    #         Union(["latitude", "longitude"],
+    #               Point(["latitude", "longitude"], [[25, 30]], method="nearest"),
+    #               Point(["latitude", "longitude"], [[-15, -45]], method="surrounding"))
+    #     )
+
+    #     self.fdbdatacube = gj.GribJump()
+    #     self.slicer = HullSlicer()
+    #     self.API = Polytope(
+    #         datacube=self.fdbdatacube,
+    #         engine=self.slicer,
+    #         options=self.options,
+    #     )
+    #     result = self.API.retrieve(request)
+    #     result.pprint()
+    #     assert len(result.leaves) == 6

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_regular_grid.py

@@ -116,7 +116,7 @@ class TestRegularGrid:
             eccodes_lats.append(eccodes_lat)
 
             mapper = RegularGridMapper("base", ["base1", "base2"], 30)
-            assert nearest_points[121][0]["index"] == mapper.unmap((lat,), (lon,))
+            assert nearest_points[121][0]["index"] == mapper.unmap((lat,), (lon,))[0]
 
             assert eccodes_lat - tol <= lat
             assert lat <= eccodes_lat + tol

{polytope_python-1.0.34 → polytope_python-1.0.36}/tests/test_regular_reduced_grid.py

@@ -10,6 +10,8 @@ from polytope_feature.shapes import Box, Select
 class TestSlicingFDBDatacube:
     def setup_method(self, method):
         # Create a dataarray with 3 labelled axes using different index types
+        # TODO: This uses the wrong fdb/schema/data so the hash for the grid is wrong
+        # BUT the validation against eccodes is OK because the GRIB file is the same grid as Polytope returns
         self.options = {
             "axis_config": [
                 {"axis_name": "step", "transformations": [{"name": "type_change", "type": "int"}]},
@@ -25,6 +27,7 @@ class TestSlicingFDBDatacube:
                             "type": "reduced_gaussian",
                             "resolution": 320,
                             "axes": ["latitude", "longitude"],
+                            "md5_hash": "158db321ae8e773681eeb40e0a3d350f",
                         }
                     ],
                 },

polytope_python-1.0.34/polytope_feature/version.py

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