mloda 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

mloda_core/prepare/graph/graph.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from copy import copy
-from typing import Dict, List, Set
+from typing import DefaultDict, Dict, List, Set
 from uuid import UUID
 
 from mloda_core.prepare.graph.properties import EdgeProperties, NodeProperties
@@ -8,8 +8,8 @@ from mloda_core.prepare.graph.properties import EdgeProperties, NodeProperties
 
 class Graph:
     def __init__(self) -> None:
-        self.nodes: Dict[UUID, NodeProperties] = defaultdict(lambda: NodeProperties(None, None))  # type: ignore
-        self.edges: Dict[tuple[UUID, UUID], EdgeProperties] = defaultdict(lambda: EdgeProperties(None, None))  # type: ignore
+        self.nodes: DefaultDict[UUID, NodeProperties] = defaultdict(lambda: NodeProperties(None, None))  # type: ignore[arg-type]
+        self.edges: DefaultDict[tuple[UUID, UUID], EdgeProperties] = defaultdict(lambda: EdgeProperties(None, None))  # type: ignore[arg-type]
 
         self.adjacency_list: Dict[UUID, list[UUID]] = defaultdict(list)
 

mloda_core/prepare/identify_feature_group.py

@@ -1,4 +1,5 @@
 from typing import Optional, Set, Tuple, Type
+
 from mloda_core.prepare.accessible_plugins import FeatureGroupEnvironmentMapping
 from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
 from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
@@ -145,14 +146,20 @@ class IdentifyFeatureGroupClass:
         Check if the code is running in a notebook environment.
         """
         try:
-            from IPython import get_ipython  # type: ignore
+            from IPython import get_ipython  # type: ignore[attr-defined]
 
-            shell = get_ipython().__class__.__name__  # type: ignore
+            ipython_instance = get_ipython()  # type: ignore[no-untyped-call]
+            if ipython_instance is None:
+                return ""
+            shell: str = ipython_instance.__class__.__name__
             if shell == "ZMQInteractiveShell":
-                return """If you are running this in a notebook, please restart the kernel to clear any cached plugins. 
+                return """If you are running this in a notebook, please restart the kernel to clear any cached plugins.
                           If you experience this multiple times, please open an issue or contact the maintainers for prioritization.
                           https://github.com/mloda-ai/mloda/issues
                 """
+        except ImportError:
+            # IPython not installed
+            pass
         except Exception:
             # An exception here means we are not in a notebook environment.
             pass  # nosec B110

mloda_core/prepare/resolve_links.py

@@ -270,24 +270,92 @@ class ResolveLinks:
         if not self.links:
             return
 
-        for link in self.links:
-            for child, parents in self.graph.parent_to_children_mapping.items():
-                for parent_in in parents:
-                    for parent_out in parents:
-                        if parent_in == parent_out:
-                            continue
-
-                        r_left = self.graph.get_nodes()[parent_in]
-                        r_right = self.graph.get_nodes()[parent_out]
-
-                        if link.matches(
-                            other_left_feature_group=r_left.feature_group_class,
-                            other_right_feature_group=r_right.feature_group_class,
-                        ):
-                            key = self.create_link_trekker_key(
-                                link, r_left.feature.compute_frameworks, r_right.feature.compute_frameworks
-                            )
-                            self.set_link_trekker(key, child)
+        for child, parents in self.graph.parent_to_children_mapping.items():
+            for parent_in in parents:
+                for parent_out in parents:
+                    if parent_in == parent_out:
+                        continue
+
+                    r_left = self.graph.get_nodes()[parent_in]
+                    r_right = self.graph.get_nodes()[parent_out]
+                    left_fg = r_left.feature_group_class
+                    right_fg = r_right.feature_group_class
+
+                    # Two-pass matching: exact match first, then polymorphic
+                    matched_links = self._find_matching_links(left_fg, right_fg)
+
+                    for matched_link in matched_links:
+                        key = self.create_link_trekker_key(
+                            matched_link, r_left.feature.compute_frameworks, r_right.feature.compute_frameworks
+                        )
+                        self.set_link_trekker(key, child)
+
+    def _find_matching_links(self, left_fg: type, right_fg: type) -> List[Link]:
+        """Find all matching links using two-pass matching: exact first, then polymorphic.
+
+        Returns all exact matches if any exist, otherwise returns the most specific
+        polymorphic matches (closest in inheritance hierarchy).
+        """
+        if self.links is None:
+            return []
+
+        # Pass 1: Collect all exact matches
+        exact_matches = [link for link in self.links if link.matches_exact(left_fg, right_fg)]
+        if exact_matches:
+            return exact_matches
+
+        # Pass 2: If no exact matches, find most specific polymorphic matches
+        polymorphic_matches = [link for link in self.links if link.matches_polymorphic(left_fg, right_fg)]
+        if not polymorphic_matches:
+            return []
+
+        # Find the most specific match (smallest inheritance distance)
+        return self._select_most_specific_links(polymorphic_matches, left_fg, right_fg)
+
+    def _inheritance_distance(self, child: type, parent: type) -> int:
+        """Calculate the inheritance distance from child to parent in the MRO.
+
+        Returns the number of steps in the Method Resolution Order from child to parent.
+        Returns a large number if parent is not in child's MRO.
+        """
+        try:
+            mro = child.__mro__
+            return mro.index(parent)
+        except (ValueError, AttributeError):
+            return 9999  # Not in hierarchy
+
+    def _select_most_specific_links(self, links: List[Link], left_fg: type, right_fg: type) -> List[Link]:
+        """Select links that are most specific (closest in inheritance hierarchy).
+
+        For each link, calculates the inheritance distance on both sides.
+        Only considers links where both sides have the same inheritance distance
+        (to avoid sibling mismatches). Returns links with the minimum distance.
+        """
+        if not links:
+            return []
+
+        # Calculate distance for each link, filtering out unbalanced matches
+        link_distances: List[Tuple[Link, int]] = []
+        for link in links:
+            left_dist = self._inheritance_distance(left_fg, link.left_feature_group)
+            right_dist = self._inheritance_distance(right_fg, link.right_feature_group)
+
+            # Only consider links where both sides have the same inheritance level
+            # This prevents sibling class mismatches for self-join patterns
+            link_is_self_join = link.left_feature_group == link.right_feature_group
+            # For self-joins: require same concrete class to prevent sibling mismatches
+            # For different-class joins: balanced distance is sufficient
+            if left_dist == right_dist and (not link_is_self_join or left_fg == right_fg):
+                link_distances.append((link, left_dist))
+
+        if not link_distances:
+            return []
+
+        # Find minimum distance
+        min_dist = min(dist for _, dist in link_distances)
+
+        # Return all links with minimum distance
+        return [link for link, dist in link_distances if dist == min_dist]
 
     def set_link_trekker(self, link_trekker_key: LinkFrameworkTrekker, uuid: UUID) -> None:
         self.link_trekker.update(link_trekker_key, uuid)

mloda_core/runtime/flight/flight_server.py

@@ -18,7 +18,7 @@ def create_location(host: str = "0.0.0.0") -> str:
     return f"grpc://{host}:{port}"
 
 
-class FlightServer(flight.FlightServerBase):  # type: ignore
+class FlightServer(flight.FlightServerBase):  # type: ignore[misc]
     def __init__(self, location: Any = create_location()) -> None:
         self.tables: Dict[str, Any] = {}  # Dictionary to store tables
         self.location = location

mloda_core/runtime/run.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections import defaultdict
 import multiprocessing
 import queue
@@ -59,10 +61,10 @@ class Runner:
         # multiprocessing
         self.location: Optional[str] = None
         self.tasks: List[Union[threading.Thread, multiprocessing.Process]] = []
-        self.process_register: Dict[  # type: ignore
-            UUID, Tuple[multiprocessing.Process, multiprocessing.Queue, multiprocessing.Queue]
+        self.process_register: Dict[
+            UUID, Tuple[multiprocessing.Process, multiprocessing.Queue[Any], multiprocessing.Queue[Any]]
         ] = defaultdict()
-        self.result_queues_collection: Set[multiprocessing.Queue] = set()  # type: ignore
+        self.result_queues_collection: Set[multiprocessing.Queue[Any]] = set()
         self.result_uuids_collection: Set[UUID] = set()
 
         # Initialize framework transformer
@@ -524,7 +526,7 @@ class Runner:
         """
         MyManager.register("CfwManager", CfwManager)
         self.manager = MyManager().__enter__()
-        self.cfw_register = self.manager.CfwManager(parallelization_modes, function_extender)  # type: ignore
+        self.cfw_register = self.manager.CfwManager(parallelization_modes, function_extender)  # type: ignore[attr-defined]
 
         if self.flight_server:
             if self.flight_server.flight_server_process is None:
@@ -587,7 +589,7 @@ class Runner:
 
     def _get_execution_function(
         self, mode_by_cfw_register: Set[ParallelizationModes], mode_by_step: Set[ParallelizationModes]
-    ) -> Callable:  # type: ignore
+    ) -> Callable[[Any], None]:
         """
         Identifies the execution mode and returns the corresponding execute step function.
 

mloda_core/runtime/worker/multiprocessing_worker.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import logging
 import multiprocessing
 import time
 import traceback
-from typing import Any, Union
+from typing import Any, Set, Union
 from uuid import UUID
 from queue import Empty
 
@@ -16,16 +18,16 @@ from mloda_core.core.step.transform_frame_work_step import TransformFrameworkSte
 logger = logging.getLogger(__name__)
 
 
-def _handle_stop_command(command_queue: multiprocessing.Queue) -> None:  # type: ignore
+def _handle_stop_command(command_queue: multiprocessing.Queue[Any]) -> None:
     """Puts a 'STOP' command in the command queue."""
     if command_queue:
         command_queue.put("STOP", block=False)
 
 
 def _handle_data_dropping(
-    command_queue: multiprocessing.Queue,  # type: ignore
+    command_queue: multiprocessing.Queue[Any],
     cfw: ComputeFrameWork,
-    command: set,  # type: ignore
+    command: Set[Any],
     location: str,
 ) -> bool:
     """Handles dropping already calculated data based on the provided command."""
@@ -46,7 +48,7 @@ def _execute_command(
     """Executes a given command based on its type."""
     if isinstance(command, JoinStep):
         # Left framework here, because it is already transformed beforehand
-        from_cfw = cfw_register.get_cfw_uuid(command.left_framework.get_class_name(), command.link.uuid)  # type: ignore
+        from_cfw = cfw_register.get_cfw_uuid(command.left_framework.get_class_name(), command.link.uuid)  # type: ignore[assignment]
 
         if from_cfw is None:
             from_cfw = cfw_register.get_cfw_uuid(
@@ -74,7 +76,7 @@ def _handle_command_result(
     cfw: ComputeFrameWork,
     location: str,
     data: Any,
-    result_queue: multiprocessing.Queue,  # type: ignore
+    result_queue: multiprocessing.Queue[Any],
 ) -> None:
     """Handles the result of a command execution, including uploading data if necessary."""
     if not isinstance(data, str) and isinstance(command, FeatureGroupStep):
@@ -89,8 +91,8 @@ def _handle_command_result(
 
 
 def worker(
-    command_queue: multiprocessing.Queue,  # type: ignore
-    result_queue: multiprocessing.Queue,  # type: ignore
+    command_queue: multiprocessing.Queue[Any],
+    result_queue: multiprocessing.Queue[Any],
     cfw_register: CfwManager,
     cfw: ComputeFrameWork,
     from_cfw: UUID,
@@ -135,7 +137,7 @@ def worker(
         time.sleep(0.0001)
 
 
-def error_out(cfw_register: CfwManager, command_queue: multiprocessing.Queue) -> None:  # type: ignore
+def error_out(cfw_register: CfwManager, command_queue: multiprocessing.Queue[Any]) -> None:
     msg = """This is a critical error, the location should not be None."""
     logging.error(msg)
     exc_info = traceback.format_exc()

mloda_plugins/compute_framework/base_implementations/duckdb/duckdb_filter_engine.py

@@ -31,11 +31,7 @@ class DuckDBFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -49,14 +45,8 @@ class DuckDBFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Check if this is a complex parameter with max/max_exclusive or a simple one with value
-        has_max = False
-        has_value = False
-
-        for param in filter_feature.parameter:
-            if param[0] == "max":
-                has_max = True
-            elif param[0] == "value":
-                has_value = True
+        has_max = filter_feature.parameter.max_value is not None
+        has_value = filter_feature.parameter.value is not None
 
         if has_max:
             # Complex parameter - use get_min_max_operator
@@ -78,11 +68,7 @@ class DuckDBFilterEngine(BaseFilterEngine):
                 condition = f'"{column_name}" <= {max_parameter}'
         elif has_value:
             # Simple parameter - extract the value
-            value = None
-            for param in filter_feature.parameter:
-                if param[0] == "value":
-                    value = param[1]
-                    break
+            value = filter_feature.parameter.value
 
             if value is None:
                 raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -98,11 +84,7 @@ class DuckDBFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -120,11 +102,7 @@ class DuckDBFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -139,11 +117,7 @@ class DuckDBFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the values from the parameter
-        values = None
-        for param in filter_feature.parameter:
-            if param[0] == "values":
-                values = param[1]
-                break
+        values = filter_feature.parameter.values
 
         if values is None:
             raise ValueError(f"Filter parameter 'values' not found in {filter_feature.parameter}")

mloda_plugins/compute_framework/base_implementations/duckdb/duckdb_pyarrow_transformer.py

@@ -13,7 +13,7 @@ except ImportError:
     pa = None
 
 
-class DuckDBPyarrowTransformer(BaseTransformer):
+class DuckDBPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between DuckDB relations and PyArrow Table.
 

mloda_plugins/compute_framework/base_implementations/iceberg/iceberg_filter_engine.py

@@ -6,13 +6,13 @@ try:
     from pyiceberg.table import Table as IcebergTable
     from pyiceberg.expressions import GreaterThan, LessThan, GreaterThanOrEqual, LessThanOrEqual, EqualTo, And
 except ImportError:
-    IcebergTable: Optional[Type] = None  # type: ignore
-    GreaterThan: Optional[Type] = None  # type: ignore
-    LessThan: Optional[Type] = None  # type: ignore
-    GreaterThanOrEqual: Optional[Type] = None  # type: ignore
-    LessThanOrEqual: Optional[Type] = None  # type: ignore
-    EqualTo: Optional[Type] = None  # type: ignore
-    And: Optional[Type] = None  # type: ignore
+    IcebergTable: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    GreaterThan: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    LessThan: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    GreaterThanOrEqual: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    LessThanOrEqual: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    EqualTo: Optional[Type[Any]] = None  # type: ignore[no-redef]
+    And: Optional[Type[Any]] = None  # type: ignore[no-redef]
 
 
 class IcebergFilterEngine(BaseFilterEngine):
@@ -111,7 +111,7 @@ class IcebergFilterEngine(BaseFilterEngine):
                 max_expr = (
                     LessThan(column_name, max_param) if is_max_exclusive else LessThanOrEqual(column_name, max_param)
                 )
-                expressions.append(max_expr)  # type: ignore
+                expressions.append(max_expr)  # type: ignore[arg-type]
 
             if len(expressions) == 1:
                 return expressions[0]
@@ -123,15 +123,25 @@ class IcebergFilterEngine(BaseFilterEngine):
     @classmethod
     def _extract_parameter_value(cls, filter_feature: SingleFilter, param_name: str) -> Any:
         """Extract a parameter value from filter feature."""
-        for param in filter_feature.parameter:
-            if param[0] == param_name:
-                return param[1]
+        if param_name == "value":
+            return filter_feature.parameter.value
+        elif param_name == "values":
+            return filter_feature.parameter.values
+        elif param_name == "min":
+            return filter_feature.parameter.min_value
+        elif param_name == "max":
+            return filter_feature.parameter.max_value
+        elif param_name == "max_exclusive":
+            return filter_feature.parameter.max_exclusive
         return None
 
     @classmethod
     def _has_parameter(cls, filter_feature: SingleFilter, param_name: str) -> bool:
         """Check if filter feature has a specific parameter."""
-        return any(param[0] == param_name for param in filter_feature.parameter)
+        value = cls._extract_parameter_value(filter_feature, param_name)
+        if param_name == "max_exclusive":
+            return True
+        return value is not None
 
     # Standard filter methods - not used for Iceberg but required by interface
     @classmethod

mloda_plugins/compute_framework/base_implementations/iceberg/iceberg_framework.py

@@ -10,8 +10,8 @@ try:
     from pyiceberg.table import Table as IcebergTable
     import pyarrow as pa
 except ImportError:
-    Catalog = None  # type: ignore
-    IcebergTable = None  # type: ignore
+    Catalog = None  # type: ignore[assignment,misc]
+    IcebergTable = None  # type: ignore[assignment,misc]
     pa = None
 
 

mloda_plugins/compute_framework/base_implementations/iceberg/iceberg_pyarrow_transformer.py

@@ -5,11 +5,11 @@ try:
     from pyiceberg.table import Table as IcebergTable
     import pyarrow as pa
 except ImportError:
-    IcebergTable = None  # type: ignore
+    IcebergTable = None  # type: ignore[assignment,misc]
     pa = None
 
 
-class IcebergPyarrowTransformer(BaseTransformer):
+class IcebergPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between Iceberg tables and PyArrow tables.
 

mloda_plugins/compute_framework/base_implementations/pandas/dataframe.py

@@ -12,7 +12,7 @@ except ImportError:
     pd = None
 
 
-class PandasDataframe(ComputeFrameWork):
+class PandasDataFrame(ComputeFrameWork):
     @staticmethod
     def is_available() -> bool:
         """Check if Pandas is installed and available."""
@@ -25,7 +25,7 @@ class PandasDataframe(ComputeFrameWork):
 
     @staticmethod
     def expected_data_framework() -> Any:
-        return PandasDataframe.pd_dataframe()
+        return PandasDataFrame.pd_dataframe()
 
     def merge_engine(self) -> Type[BaseMergeEngine]:
         return PandasMergeEngine

mloda_plugins/compute_framework/base_implementations/pandas/pandaspyarrowtransformer.py

@@ -13,7 +13,7 @@ except ImportError:
     pa = None
 
 
-class PandasPyarrowTransformer(BaseTransformer):
+class PandasPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between Pandas DataFrame and PyArrow Table.
 

mloda_plugins/compute_framework/base_implementations/polars/dataframe.py

@@ -9,10 +9,10 @@ from mloda_plugins.compute_framework.base_implementations.polars.polars_filter_e
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 
-class PolarsDataframe(ComputeFrameWork):
+class PolarsDataFrame(ComputeFrameWork):
     @staticmethod
     def is_available() -> bool:
         """Check if Polars is installed and available."""
@@ -25,7 +25,7 @@ class PolarsDataframe(ComputeFrameWork):
 
     @staticmethod
     def expected_data_framework() -> Any:
-        return PolarsDataframe.pl_dataframe()
+        return PolarsDataFrame.pl_dataframe()
 
     def merge_engine(self) -> Type[BaseMergeEngine]:
         return PolarsMergeEngine

mloda_plugins/compute_framework/base_implementations/polars/lazy_dataframe.py

@@ -1,18 +1,18 @@
 from typing import Any, Set, Type
 from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_plugins.compute_framework.base_implementations.polars.dataframe import PolarsDataframe
+from mloda_plugins.compute_framework.base_implementations.polars.dataframe import PolarsDataFrame
 from mloda_core.abstract_plugins.components.merge.base_merge_engine import BaseMergeEngine
 from mloda_plugins.compute_framework.base_implementations.polars.polars_lazy_merge_engine import PolarsLazyMergeEngine
 
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 
-class PolarsLazyDataframe(PolarsDataframe):
+class PolarsLazyDataFrame(PolarsDataFrame):
     """
-    Lazy evaluation version of PolarsDataframe using pl.LazyFrame.
+    Lazy evaluation version of PolarsDataFrame using pl.LazyFrame.
 
     This compute framework defers execution of operations until results are explicitly
     requested, enabling query optimization and reduced memory usage for large datasets.
@@ -20,7 +20,7 @@ class PolarsLazyDataframe(PolarsDataframe):
 
     @staticmethod
     def expected_data_framework() -> Any:
-        return PolarsLazyDataframe.pl_lazy_frame()
+        return PolarsLazyDataFrame.pl_lazy_frame()
 
     def merge_engine(self) -> Type[BaseMergeEngine]:
         return PolarsLazyMergeEngine

mloda_plugins/compute_framework/base_implementations/polars/polars_filter_engine.py

@@ -5,7 +5,7 @@ from mloda_core.filter.single_filter import SingleFilter
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 
 class PolarsFilterEngine(BaseFilterEngine):
@@ -37,11 +37,7 @@ class PolarsFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -53,14 +49,8 @@ class PolarsFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Check if this is a complex parameter with max/max_exclusive or a simple one with value
-        has_max = False
-        has_value = False
-
-        for param in filter_feature.parameter:
-            if param[0] == "max":
-                has_max = True
-            elif param[0] == "value":
-                has_value = True
+        has_max = filter_feature.parameter.max_value is not None
+        has_value = filter_feature.parameter.value is not None
 
         if has_max:
             # Complex parameter - use get_min_max_operator
@@ -82,11 +72,7 @@ class PolarsFilterEngine(BaseFilterEngine):
                 return data.filter(pl.col(column_name) <= max_parameter)
         elif has_value:
             # Simple parameter - extract the value
-            value = None
-            for param in filter_feature.parameter:
-                if param[0] == "value":
-                    value = param[1]
-                    break
+            value = filter_feature.parameter.value
 
             if value is None:
                 raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -100,11 +86,7 @@ class PolarsFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -116,11 +98,7 @@ class PolarsFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the value from the parameter
-        value = None
-        for param in filter_feature.parameter:
-            if param[0] == "value":
-                value = param[1]
-                break
+        value = filter_feature.parameter.value
 
         if value is None:
             raise ValueError(f"Filter parameter 'value' not found in {filter_feature.parameter}")
@@ -132,11 +110,7 @@ class PolarsFilterEngine(BaseFilterEngine):
         column_name = filter_feature.name.name
 
         # Extract the values from the parameter
-        values = None
-        for param in filter_feature.parameter:
-            if param[0] == "values":
-                values = param[1]
-                break
+        values = filter_feature.parameter.values
 
         if values is None:
             raise ValueError(f"Filter parameter 'values' not found in {filter_feature.parameter}")

mloda_plugins/compute_framework/base_implementations/polars/polars_lazy_merge_engine.py

@@ -5,7 +5,7 @@ from mloda_plugins.compute_framework.base_implementations.polars.polars_merge_en
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 
 class PolarsLazyMergeEngine(PolarsMergeEngine):