polytope-python 1.0.5__tar.gz → 1.0.7__tar.gz

{polytope-python-1.0.5/polytope_python.egg-info → polytope-python-1.0.7}/PKG-INFO

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

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/backends/datacube.py

@@ -1,6 +1,6 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Dict
 
 from ...utility.combinatorics import validate_axes
 from ..datacube_axis import DatacubeAxis
@@ -31,9 +31,10 @@ class Datacube(ABC):
         self.merged_axes = []
         self.unwanted_path = {}
         self.compressed_axes = compressed_axes_options
+        self.grid_md5_hash = None
 
     @abstractmethod
-    def get(self, requests: TensorIndexTree) -> Any:
+    def get(self, requests: TensorIndexTree, context: Dict) -> Any:
         """Return data given a set of request trees"""
 
     @property
@@ -69,6 +70,7 @@ class Datacube(ABC):
             # TODO: do we use this?? This shouldn't work for a disk in lat/lon on a octahedral or other grid??
             for compressed_grid_axis in transformation.compressed_grid_axes:
                 self.compressed_grid_axes.append(compressed_grid_axis)
+                self.grid_md5_hash = transformation.md5_hash
         if len(final_axis_names) > 1:
             self.coupled_axes.append(final_axis_names)
             for axis in final_axis_names:
@@ -128,7 +130,7 @@ class Datacube(ABC):
         indexes = axis.find_indexes(path, self)
         idx_between = axis.find_indices_between(indexes, lower, upper, self, method)
 
-        logging.info(f"For axis {axis.name} between {lower} and {upper}, found indices {idx_between}")
+        logging.debug(f"For axis {axis.name} between {lower} and {upper}, found indices {idx_between}")
 
         return idx_between
 

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/backends/fdb.py

@@ -77,7 +77,10 @@ class FDBDatacube(Datacube):
         for axis_name in axes_to_remove:
             self._axes.pop(axis_name, None)
 
-    def get(self, requests: TensorIndexTree):
+    def get(self, requests: TensorIndexTree, context=None):
+        if context is None:
+            context = {}
+        requests.pprint()
         if len(requests.children) == 0:
             return requests
         fdb_requests = []
@@ -103,11 +106,11 @@ class FDBDatacube(Datacube):
                 uncompressed_request = {}
                 for i, key in enumerate(compressed_request[0].keys()):
                     uncompressed_request[key] = combi[i]
-                complete_uncompressed_request = (uncompressed_request, compressed_request[1])
+                complete_uncompressed_request = (uncompressed_request, compressed_request[1], self.grid_md5_hash)
                 complete_list_complete_uncompressed_requests.append(complete_uncompressed_request)
                 complete_fdb_decoding_info.append(fdb_requests_decoding_info[j])
         logging.debug("The requests we give GribJump are: %s", complete_list_complete_uncompressed_requests)
-        output_values = self.gj.extract(complete_list_complete_uncompressed_requests)
+        output_values = self.gj.extract(complete_list_complete_uncompressed_requests, context)
         logging.debug("GribJump outputs: %s", output_values)
         self.assign_fdb_output_to_nodes(output_values, complete_fdb_decoding_info)
 
@@ -123,7 +126,7 @@ class FDBDatacube(Datacube):
 
         # First when request node is root, go to its children
         if requests.axis.name == "root":
-            logging.info("Looking for data for the tree: %s", [leaf.flatten() for leaf in requests.leaves])
+            logging.debug("Looking for data for the tree: %s", [leaf.flatten() for leaf in requests.leaves])
 
             for c in requests.children:
                 self.get_fdb_requests(c, fdb_requests, fdb_requests_decoding_info)
@@ -160,8 +163,8 @@ class FDBDatacube(Datacube):
                 new_current_start_idx = []
                 for j, idx in enumerate(sub_lat_idxs):
                     if idx not in seen_indices:
-                        # TODO: need to remove it from the values in the corresponding tree node
-                        # TODO: need to read just the range we give to gj ... DONE?
+                        # NOTE: need to remove it from the values in the corresponding tree node
+                        # NOTE: need to read just the range we give to gj
                         original_fdb_node_range_vals.append(actual_fdb_node[0].values[j])
                         seen_indices.add(idx)
                         new_current_start_idx.append(idx)
@@ -186,8 +189,6 @@ class FDBDatacube(Datacube):
 
             second_ax = requests.children[0].children[0].axis
 
-            # TODO: actually, here we should not remap the nearest_pts, we should instead unmap the
-            # found_latlon_pts and then remap them later once we have compared found_latlon_pts and nearest_pts
             nearest_pts = [
                 [lat_val, second_ax._remap_val_to_axis_range(lon_val)]
                 for (lat_val, lon_val) in zip(
@@ -324,8 +325,6 @@ class FDBDatacube(Datacube):
         request_ranges_with_idx = list(enumerate(interm_request_ranges))
         sorted_list = sorted(request_ranges_with_idx, key=lambda x: x[1][0])
         original_indices, sorted_request_ranges = zip(*sorted_list)
-        logging.debug("We sorted the request ranges into: %s", sorted_request_ranges)
-        logging.debug("The sorted and unique leaf node ranges are: %s", new_fdb_node_ranges)
         return (original_indices, sorted_request_ranges, new_fdb_node_ranges)
 
     def datacube_natural_indexes(self, axis, subarray):

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/backends/mock.py

@@ -24,10 +24,12 @@ class MockDatacube(Datacube):
             self.stride[k] = stride_cumulative
             stride_cumulative *= self.dimensions[k]
 
-    def get(self, requests: TensorIndexTree):
+    def get(self, requests: TensorIndexTree, context=None):
         # Takes in a datacube and verifies the leaves of the tree are complete
         # (ie it found values for all datacube axis)
 
+        if context is None:
+            context = {}
         for r in requests.leaves:
             path = r.flatten()
             if len(path.items()) == len(self.dimensions.items()):

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/backends/xarray.py

@@ -50,12 +50,14 @@ class XArrayDatacube(Datacube):
                 val = self._axes[name].type
                 self._check_and_add_axes(options, name, val)
 
-    def get(self, requests, leaf_path=None, axis_counter=0):
+    def get(self, requests, context=None, leaf_path=None, axis_counter=0):
+        if context is None:
+            context = {}
         if leaf_path is None:
             leaf_path = {}
         if requests.axis.name == "root":
             for c in requests.children:
-                self.get(c, leaf_path, axis_counter + 1)
+                self.get(c, context, leaf_path, axis_counter + 1)
         else:
             key_value_path = {requests.axis.name: requests.values}
             ax = requests.axis
@@ -66,7 +68,7 @@ class XArrayDatacube(Datacube):
             if len(requests.children) != 0:
                 # We are not a leaf and we loop over
                 for c in requests.children:
-                    self.get(c, leaf_path, axis_counter + 1)
+                    self.get(c, context, leaf_path, axis_counter + 1)
             else:
                 if self.axis_counter != axis_counter:
                     requests.remove_branch()

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/tensor_index_tree.py

@@ -81,8 +81,12 @@ class TensorIndexTree(object):
                     for i in range(len(other.values)):
                         other_val = other.values[i]
                         self_val = self.values[i]
-                        if abs(other_val - self_val) > 2 * max(other.axis.tol, self.axis.tol):
-                            return False
+                        if self.axis.can_round:
+                            if abs(other_val - self_val) > 2 * max(other.axis.tol, self.axis.tol):
+                                return False
+                        else:
+                            if other_val != self_val:
+                                return False
                     return True
 
     def __lt__(self, other):
@@ -101,6 +105,7 @@ class TensorIndexTree(object):
     def add_value(self, value):
         new_values = list(self.values)
         new_values.append(value)
+        new_values.sort()
         self.values = tuple(new_values)
 
     def create_child(self, axis, value, next_nodes):
@@ -217,7 +222,7 @@ class TensorIndexTree(object):
     def get_ancestors(self):
         ancestors = []
         current_node = self
-        while current_node.axis != TensorIndexTree.root:
+        while current_node.axis.name != "root":
             ancestors.append(current_node)
             current_node = current_node.parent
         return ancestors[::-1]

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/datacube_mappers.py

@@ -20,6 +20,7 @@ class DatacubeMapper(DatacubeAxisTransformation):
         self._final_mapped_axes = self._final_transformation._mapped_axes
         self._axis_reversed = self._final_transformation._axis_reversed
         self.compressed_grid_axes = self._final_transformation.compressed_grid_axes
+        self.md5_hash = self._final_transformation.md5_hash
 
     def generate_final_transformation(self):
         map_type = _type_to_datacube_mapper_lookup[self.grid_type]

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/healpix.py

@@ -13,6 +13,7 @@ class HealpixGridMapper(DatacubeMapper):
         self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False}
         self._first_axis_vals = self.first_axis_vals()
         self.compressed_grid_axes = [self._mapped_axes[1]]
+        self.md5_hash = md5_hash.get(resolution, None)
 
     def first_axis_vals(self):
         rad2deg = 180 / math.pi
@@ -133,3 +134,7 @@ class HealpixGridMapper(DatacubeMapper):
         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
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/healpix_nested.py

@@ -17,6 +17,7 @@ class NestedHealpixGridMapper(DatacubeMapper):
         self.k = int(math.log2(self.Nside))
         self.Npix = 12 * self.Nside * self.Nside
         self.Ncap = (self.Nside * (self.Nside - 1)) << 1
+        self.md5_hash = md5_hash.get(resolution, None)
 
     def first_axis_vals(self):
         rad2deg = 180 / math.pi
@@ -211,3 +212,7 @@ class NestedHealpixGridMapper(DatacubeMapper):
 
     def int_sqrt(self, i):
         return int(math.sqrt(i + 0.5))
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/local_regular.py

@@ -15,9 +15,11 @@ class LocalRegularGridMapper(DatacubeMapper):
         if not isinstance(resolution, list):
             self.first_resolution = resolution
             self.second_resolution = resolution
+            self.md5_hash = md5_hash.get(resolution, None)
         else:
             self.first_resolution = resolution[0]
             self.second_resolution = resolution[1]
+            self.md5_hash = md5_hash.get(tuple(resolution), None)
         self._first_deg_increment = (local_area[1] - local_area[0]) / self.first_resolution
         self._second_deg_increment = (local_area[3] - local_area[2]) / self.second_resolution
         self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False}
@@ -68,3 +70,7 @@ class LocalRegularGridMapper(DatacubeMapper):
         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
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/octahedral.py

@@ -15,6 +15,7 @@ class OctahedralGridMapper(DatacubeMapper):
         self._second_axis_spacing = {}
         self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False}
         self.compressed_grid_axes = [self._mapped_axes[1]]
+        self.md5_hash = md5_hash.get(resolution, None)
 
     def gauss_first_guess(self):
         i = 0
@@ -2750,3 +2751,9 @@ class OctahedralGridMapper(DatacubeMapper):
         (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
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {
+    1280: "158db321ae8e773681eeb40e0a3d350f",
+}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/reduced_ll.py

@@ -12,6 +12,7 @@ class ReducedLatLonMapper(DatacubeMapper):
         self._axis_reversed = {mapped_axes[0]: False, mapped_axes[1]: False}
         self._first_axis_vals = self.first_axis_vals()
         self.compressed_grid_axes = [self._mapped_axes[1]]
+        self.md5_hash = md5_hash.get(resolution, None)
 
     def first_axis_vals(self):
         resolution = 180 / (self._resolution - 1)
@@ -1504,3 +1505,7 @@ class ReducedLatLonMapper(DatacubeMapper):
         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
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_mappers/mapper_types/regular.py

@@ -13,6 +13,7 @@ class RegularGridMapper(DatacubeMapper):
         self._axis_reversed = {mapped_axes[0]: True, mapped_axes[1]: False}
         self._first_axis_vals = self.first_axis_vals()
         self.compressed_grid_axes = [self._mapped_axes[1]]
+        self.md5_hash = md5_hash.get(resolution, None)
 
     def first_axis_vals(self):
         first_ax_vals = [90 - i * self.deg_increment for i in range(2 * self._resolution)]
@@ -56,3 +57,7 @@ class RegularGridMapper(DatacubeMapper):
         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
+
+
+# md5 grid hash in form {resolution : hash}
+md5_hash = {}

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/datacube/transformations/datacube_merger/datacube_merger.py

@@ -93,6 +93,5 @@ class DatacubeAxisMerger(DatacubeAxisTransformation):
         if node.axis.name == self._first_axis:
             (new_first_vals, new_second_vals) = self.unmerge(node.values)
             node.values = new_first_vals
-            # TODO: actually need to give the second axis of the transformation to get the interm axis
             interm_node = node.add_node_layer_after(self._second_axis, new_second_vals)
         return (interm_node, unwanted_path)

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/engine/hullslicer.py

@@ -109,11 +109,8 @@ class HullSlicer(Engine):
         return remapped_val
 
     def _build_sliceable_child(self, polytope, ax, node, datacube, values, next_nodes, slice_axis_idx):
-        if len(values) == 0:
-            node.remove_branch()
-
         for i, value in enumerate(values):
-            if i == 0:
+            if i == 0 or ax.name not in self.compressed_axes:
                 fvalue = ax.to_float(value)
                 new_polytope = slice(polytope, ax.name, fvalue, slice_axis_idx)
                 remapped_val = self.remap_values(ax, value)
@@ -124,38 +121,41 @@ class HullSlicer(Engine):
                     child["unsliced_polytopes"].add(new_polytope)
                 next_nodes.append(child)
             else:
-                if ax.name not in self.compressed_axes:
-                    fvalue = ax.to_float(value)
-                    new_polytope = slice(polytope, ax.name, fvalue, slice_axis_idx)
-                    remapped_val = self.remap_values(ax, value)
-                    (child, next_nodes) = node.create_child(ax, remapped_val, next_nodes)
-                    child["unsliced_polytopes"] = copy(node["unsliced_polytopes"])
-                    child["unsliced_polytopes"].remove(polytope)
-                    if new_polytope is not None:
-                        child["unsliced_polytopes"].add(new_polytope)
-                    next_nodes.append(child)
-                else:
-                    remapped_val = self.remap_values(ax, value)
-                    child.add_value(remapped_val)
+                remapped_val = self.remap_values(ax, value)
+                child.add_value(remapped_val)
 
     def _build_branch(self, ax, node, datacube, next_nodes):
         if ax.name not in self.compressed_axes:
+            parent_node = node.parent
+            right_unsliced_polytopes = []
             for polytope in node["unsliced_polytopes"]:
                 if ax.name in polytope._axes:
-                    lower, upper, slice_axis_idx = polytope.extents(ax.name)
-                    # here, first check if the axis is an unsliceable axis and directly build node if it is
-                    # NOTE: we should have already created the ax_is_unsliceable cache before
-                    if self.ax_is_unsliceable[ax.name]:
-                        self._build_unsliceable_child(polytope, ax, node, datacube, [lower], next_nodes, slice_axis_idx)
-                    else:
-                        values = self.find_values_between(polytope, ax, node, datacube, lower, upper)
-                        self._build_sliceable_child(polytope, ax, node, datacube, values, next_nodes, slice_axis_idx)
+                    right_unsliced_polytopes.append(polytope)
+            for i, polytope in enumerate(right_unsliced_polytopes):
+                node._parent = parent_node
+                lower, upper, slice_axis_idx = polytope.extents(ax.name)
+                # here, first check if the axis is an unsliceable axis and directly build node if it is
+                # NOTE: we should have already created the ax_is_unsliceable cache before
+                if self.ax_is_unsliceable[ax.name]:
+                    self._build_unsliceable_child(polytope, ax, node, datacube, [lower], next_nodes, slice_axis_idx)
+                else:
+                    values = self.find_values_between(polytope, ax, node, datacube, lower, upper)
+                    # NOTE: need to only remove the branches if the values are empty,
+                    # but only if there are no other possible children left in the tree that
+                    # we can append and if somehow this happens before and we need to remove, then what do we do??
+                    if i == len(right_unsliced_polytopes) - 1:
+                        # we have iterated all polytopes and we can now remove the node if we need to
+                        if len(values) == 0 and len(node.children) == 0:
+                            node.remove_branch()
+                    self._build_sliceable_child(polytope, ax, node, datacube, values, next_nodes, slice_axis_idx)
         else:
             all_values = []
             all_lowers = []
             first_polytope = False
             first_slice_axis_idx = False
+            parent_node = node.parent
             for polytope in node["unsliced_polytopes"]:
+                node._parent = parent_node
                 if ax.name in polytope._axes:
                     # keep track of the first polytope defined on the given axis
                     if not first_polytope:
@@ -173,6 +173,8 @@ class HullSlicer(Engine):
                     first_polytope, ax, node, datacube, all_lowers, next_nodes, first_slice_axis_idx
                 )
             else:
+                if len(all_values) == 0:
+                    node.remove_branch()
                 self._build_sliceable_child(
                     first_polytope, ax, node, datacube, all_values, next_nodes, first_slice_axis_idx
                 )

polytope-python-1.0.7/polytope/options.py

@@ -0,0 +1,78 @@
+import argparse
+from abc import ABC
+from typing import Dict, List, Literal, Optional, Union
+
+from conflator import ConfigModel, Conflator
+from pydantic import ConfigDict
+
+
+class TransformationConfig(ConfigModel):
+    model_config = ConfigDict(extra="forbid")
+    name: str = ""
+
+
+class CyclicConfig(TransformationConfig):
+    name: Literal["cyclic"]
+    range: List[float] = [0]
+
+
+class MapperConfig(TransformationConfig):
+    name: Literal["mapper"]
+    type: str = ""
+    resolution: Union[int, List[int]] = 0
+    axes: List[str] = [""]
+    local: Optional[List[float]] = None
+
+
+class ReverseConfig(TransformationConfig):
+    name: Literal["reverse"]
+    is_reverse: bool = False
+
+
+class TypeChangeConfig(TransformationConfig):
+    name: Literal["type_change"]
+    type: str = "int"
+
+
+class MergeConfig(TransformationConfig):
+    name: Literal["merge"]
+    other_axis: str = ""
+    linkers: List[str] = [""]
+
+
+action_subclasses_union = Union[CyclicConfig, MapperConfig, ReverseConfig, TypeChangeConfig, MergeConfig]
+
+
+class AxisConfig(ConfigModel):
+    axis_name: str = ""
+    transformations: list[action_subclasses_union]
+
+
+path_subclasses_union = Union[str, int, float]
+
+
+class GribJumpAxesConfig(ConfigModel):
+    axis_name: str = ""
+    values: List[str] = [""]
+
+
+class Config(ConfigModel):
+    axis_config: List[AxisConfig] = []
+    compressed_axes_config: List[str] = [""]
+    pre_path: Optional[Dict[str, path_subclasses_union]] = {}
+    alternative_axes: List[GribJumpAxesConfig] = []
+
+
+class PolytopeOptions(ABC):
+    @staticmethod
+    def get_polytope_options(options):
+        parser = argparse.ArgumentParser(allow_abbrev=False)
+        conflator = Conflator(app_name="polytope", model=Config, cli=False, argparser=parser, **options)
+        config_options = conflator.load()
+
+        axis_config = config_options.axis_config
+        compressed_axes_config = config_options.compressed_axes_config
+        pre_path = config_options.pre_path
+        alternative_axes = config_options.alternative_axes
+
+        return (axis_config, compressed_axes_config, pre_path, alternative_axes)

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/polytope.py

@@ -1,3 +1,4 @@
+import logging
 from typing import List
 
 from .options import PolytopeOptions
@@ -55,9 +56,14 @@ class Polytope:
         """Low-level API which takes a polytope geometry object and uses it to slice the datacube"""
         return self.engine.extract(self.datacube, polytopes)
 
-    def retrieve(self, request: Request, method="standard"):
+    def retrieve(self, request: Request, method="standard", context=None):
         """Higher-level API which takes a request and uses it to slice the datacube"""
+        if context is None:
+            context = {}
+        logging.info("Starting request for %s ", context)
         self.datacube.check_branching_axes(request)
         request_tree = self.engine.extract(self.datacube, request.polytopes())
-        self.datacube.get(request_tree)
+        logging.info("Created request tree for %s ", context)
+        self.datacube.get(request_tree, context)
+        logging.info("Retrieved data for %s ", context)
         return request_tree

{polytope-python-1.0.5 → polytope-python-1.0.7}/polytope/utility/exceptions.py

@@ -1,4 +1,8 @@
-class AxisOverdefinedError(KeyError):
+class PolytopeError(Exception):
+    pass
+
+
+class AxisOverdefinedError(PolytopeError, KeyError):
     def __init__(self, axis):
         self.axis = axis
         self.message = (
@@ -7,19 +11,19 @@ class AxisOverdefinedError(KeyError):
         )
 
 
-class AxisUnderdefinedError(KeyError):
+class AxisUnderdefinedError(PolytopeError, KeyError):
     def __init__(self, axis):
         self.axis = axis
         self.message = f"Axis {axis} is underdefined. It does not appear in any input polytope."
 
 
-class AxisNotFoundError(KeyError):
+class AxisNotFoundError(PolytopeError, KeyError):
     def __init__(self, axis):
         self.axis = axis
         self.message = f"Axis {axis} does not exist in the datacube."
 
 
-class UnsliceableShapeError(KeyError):
+class UnsliceableShapeError(PolytopeError, KeyError):
     def __init__(self, axis):
         self.axis = axis
         self.message = f"Higher-dimensional shape does not support unsliceable axis {axis.name}."

polytope-python-1.0.7/polytope/version.py

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

{polytope-python-1.0.5 → polytope-python-1.0.7/polytope_python.egg-info}/PKG-INFO

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

polytope-python-1.0.5/polytope/options.py

@@ -1,67 +0,0 @@
-import argparse
-from abc import ABC
-from typing import Dict, List, Literal, Optional, Union
-
-from conflator import ConfigModel, Conflator
-from pydantic import ConfigDict
-
-
-class PolytopeOptions(ABC):
-    @staticmethod
-    def get_polytope_options(options):
-        class TransformationConfig(ConfigModel):
-            model_config = ConfigDict(extra="forbid")
-            name: str = ""
-
-        class CyclicConfig(TransformationConfig):
-            name: Literal["cyclic"]
-            range: List[float] = [0]
-
-        class MapperConfig(TransformationConfig):
-            name: Literal["mapper"]
-            type: str = ""
-            resolution: Union[int, List[int]] = 0
-            axes: List[str] = [""]
-            local: Optional[List[float]] = None
-
-        class ReverseConfig(TransformationConfig):
-            name: Literal["reverse"]
-            is_reverse: bool = False
-
-        class TypeChangeConfig(TransformationConfig):
-            name: Literal["type_change"]
-            type: str = "int"
-
-        class MergeConfig(TransformationConfig):
-            name: Literal["merge"]
-            other_axis: str = ""
-            linkers: List[str] = [""]
-
-        action_subclasses_union = Union[CyclicConfig, MapperConfig, ReverseConfig, TypeChangeConfig, MergeConfig]
-
-        class AxisConfig(ConfigModel):
-            axis_name: str = ""
-            transformations: list[action_subclasses_union]
-
-        path_subclasses_union = Union[str, int, float]
-
-        class GribJumpAxesConfig(ConfigModel):
-            axis_name: str = ""
-            values: List[str] = [""]
-
-        class Config(ConfigModel):
-            axis_config: List[AxisConfig] = []
-            compressed_axes_config: List[str] = [""]
-            pre_path: Optional[Dict[str, path_subclasses_union]] = {}
-            alternative_axes: List[GribJumpAxesConfig] = []
-
-        parser = argparse.ArgumentParser(allow_abbrev=False)
-        conflator = Conflator(app_name="polytope", model=Config, cli=False, argparser=parser, **options)
-        config_options = conflator.load()
-
-        axis_config = config_options.axis_config
-        compressed_axes_config = config_options.compressed_axes_config
-        pre_path = config_options.pre_path
-        alternative_axes = config_options.alternative_axes
-
-        return (axis_config, compressed_axes_config, pre_path, alternative_axes)

polytope-python-1.0.5/polytope/version.py

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