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

mloda_plugins/compute_framework/base_implementations/python_dict/python_dict_merge_engine.py

@@ -1,7 +1,7 @@
 from typing import Any, Set, Tuple
-from mloda_core.abstract_plugins.components.merge.base_merge_engine import BaseMergeEngine
-from mloda_core.abstract_plugins.components.index.index import Index
-from mloda_core.abstract_plugins.components.link import JoinType
+from mloda.provider import BaseMergeEngine
+from mloda.user import Index
+from mloda.user import JoinType
 
 
 class PythonDictMergeEngine(BaseMergeEngine):

mloda_plugins/compute_framework/base_implementations/python_dict/python_dict_pyarrow_transformer.py

@@ -1,6 +1,6 @@
 from typing import Any, Optional
 
-from mloda_core.abstract_plugins.components.framework_transformer.base_transformer import BaseTransformer
+from mloda.provider import BaseTransformer
 
 try:
     import pyarrow as pa

mloda_plugins/compute_framework/base_implementations/spark/spark_filter_engine.py

@@ -1,6 +1,6 @@
 from typing import Any
-from mloda_core.filter.filter_engine import BaseFilterEngine
-from mloda_core.filter.single_filter import SingleFilter
+from mloda.provider import BaseFilterEngine
+from mloda.user import SingleFilter
 
 try:
     from pyspark.sql import DataFrame

mloda_plugins/compute_framework/base_implementations/spark/spark_framework.py

@@ -1,10 +1,10 @@
 import logging
 from typing import Any, Set, Type, Optional
-from mloda_core.abstract_plugins.components.merge.base_merge_engine import BaseMergeEngine
+from mloda.provider import BaseMergeEngine
 from mloda_plugins.compute_framework.base_implementations.spark.spark_merge_engine import SparkMergeEngine
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.filter.filter_engine import BaseFilterEngine
+from mloda.user import FeatureName
+from mloda import ComputeFramework
+from mloda.provider import BaseFilterEngine
 from mloda_plugins.compute_framework.base_implementations.spark.spark_filter_engine import SparkFilterEngine
 
 try:
@@ -25,8 +25,8 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-class SparkFramework(ComputeFrameWork):
-    """Spark framework implementation for ComputeFrameWork.
+class SparkFramework(ComputeFramework):
+    """Spark framework implementation for ComputeFramework.
 
     This framework leverages Apache Spark for distributed data processing.
     It requires a SparkSession to be provided through the framework connection object.
@@ -62,11 +62,12 @@ class SparkFramework(ComputeFrameWork):
         except ImportError:
             return False
 
-    @staticmethod
-    def expected_data_framework() -> Any:
-        return SparkFramework.spark_dataframe()
+    @classmethod
+    def expected_data_framework(cls) -> Any:
+        return cls.spark_dataframe()
 
-    def merge_engine(self) -> Type[BaseMergeEngine]:
+    @classmethod
+    def merge_engine(cls) -> Type[BaseMergeEngine]:
         return SparkMergeEngine
 
     def select_data_by_column_names(self, data: Any, selected_feature_names: Set[FeatureName]) -> Any:
@@ -78,14 +79,14 @@ class SparkFramework(ComputeFrameWork):
         if self.data is not None:
             self.column_names = set(self.data.columns)
 
-    @staticmethod
-    def spark_dataframe() -> Any:
+    @classmethod
+    def spark_dataframe(cls) -> Any:
         if DataFrame is None:
             raise ImportError("PySpark is not installed. To be able to use this framework, please install pyspark.")
         return DataFrame
 
-    @staticmethod
-    def spark_session() -> Any:
+    @classmethod
+    def spark_session(cls) -> Any:
         if SparkSession is None:
             raise ImportError("PySpark is not installed. To be able to use this framework, please install pyspark.")
         return SparkSession
@@ -194,5 +195,6 @@ class SparkFramework(ComputeFrameWork):
 
         raise ValueError(f"Data {type(data)} is not supported by {self.__class__.__name__}")
 
-    def filter_engine(self) -> Type[BaseFilterEngine]:
+    @classmethod
+    def filter_engine(cls) -> Type[BaseFilterEngine]:
         return SparkFilterEngine

mloda_plugins/compute_framework/base_implementations/spark/spark_merge_engine.py

@@ -1,8 +1,8 @@
 from typing import Any, Tuple
 
-from mloda_core.abstract_plugins.components.index.index import Index
-from mloda_core.abstract_plugins.components.link import JoinType
-from mloda_core.abstract_plugins.components.merge.base_merge_engine import BaseMergeEngine
+from mloda.user import Index
+from mloda.user import JoinType
+from mloda.provider import BaseMergeEngine
 
 try:
     from pyspark.sql import DataFrame

mloda_plugins/compute_framework/base_implementations/spark/spark_pyarrow_transformer.py

@@ -1,6 +1,6 @@
 from typing import Any, Optional
 
-from mloda_core.abstract_plugins.components.framework_transformer.base_transformer import BaseTransformer
+from mloda.provider import BaseTransformer
 
 try:
     from pyspark.sql import DataFrame, SparkSession

mloda_plugins/config/feature/loader.py

@@ -6,8 +6,8 @@ to mloda Feature instances.
 """
 
 from typing import List, Union, Dict, Any
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.options import Options
+from mloda import Feature
+from mloda import Options
 from mloda_plugins.config.feature.parser import parse_json
 from mloda_plugins.config.feature.models import FeatureConfig
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys

mloda_plugins/feature_group/experimental/aggregated_feature_group/base.py

@@ -7,16 +7,19 @@ from __future__ import annotations
 from abc import abstractmethod
 from typing import Any, List, Optional, Set, Union
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.feature_set import FeatureSet
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.abstract_plugins.components.feature_chainer.feature_chain_parser import FeatureChainParser
+from mloda import FeatureGroup
+from mloda import Feature
+from mloda.user import FeatureName
+from mloda.provider import FeatureSet
+from mloda import Options
+from mloda.provider import FeatureChainParser
+from mloda.provider import (
+    FeatureChainParserMixin,
+)
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
-class AggregatedFeatureGroup(AbstractFeatureGroup):
+class AggregatedFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for all aggregated feature groups.
 
@@ -99,38 +102,24 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
 
     PREFIX_PATTERN = r".*__([\w]+)_aggr$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
     # Property mapping for configuration-based feature creation
     PROPERTY_MAPPING = {
         AGGREGATION_TYPE: {
             **AGGREGATION_TYPES,  # All supported aggregation types as valid values
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: True,  # Enable strict validation
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: True,  # Enable strict validation
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source feature to aggregate",
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: False,  # Flexible validation
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: False,  # Flexible validation
         },
     }
 
-    def input_features(self, options: Options, feature_name: FeatureName) -> Optional[Set[Feature]]:
-        """Extract source feature from either configuration-based options or string parsing."""
-
-        source_feature: str | None = None
-
-        # string based
-        _, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
-        if source_feature is not None:
-            return {Feature(source_feature)}
-
-        # configuration based
-        source_features = options.get_in_features()
-        if len(source_features) != 1:
-            raise ValueError(
-                f"Expected exactly one source feature, but found {len(source_features)}: {source_features}"
-            )
-        return set(source_features)
-
     @classmethod
     def get_aggregation_type(cls, feature_name: str) -> str:
         """Extract the aggregation type from the feature name."""
@@ -140,21 +129,26 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         return prefix_part
 
     @classmethod
-    def match_feature_group_criteria(
-        cls,
-        feature_name: Union[FeatureName, str],
-        options: Options,
-        data_access_collection: Optional[Any] = None,
-    ) -> bool:
-        """Check if feature name matches the expected pattern and aggregation type."""
-
-        # Use the unified parser with property mapping for full configuration support
-        return FeatureChainParser.match_configuration_feature_chain_parser(
-            feature_name,
-            options,
-            property_mapping=cls.PROPERTY_MAPPING,
-            prefix_patterns=[cls.PREFIX_PATTERN],
-        )
+    def _extract_aggregation_type(cls, feature: Feature) -> Optional[str]:
+        """
+        Extract aggregation type from a feature.
+
+        Tries string-based parsing first, falls back to configuration.
+
+        Args:
+            feature: The feature to extract aggregation type from
+
+        Returns:
+            The aggregation type, or None if not found
+        """
+        # Try string-based parsing first
+        aggregation_type, _ = FeatureChainParser.parse_feature_name(feature.name, [cls.PREFIX_PATTERN])
+        if aggregation_type is not None:
+            return aggregation_type
+
+        # Fall back to configuration
+        aggregation_type = feature.options.get(cls.AGGREGATION_TYPE)
+        return str(aggregation_type) if aggregation_type is not None else None
 
     @classmethod
     def _extract_aggr_and_source_feature(cls, feature: Feature) -> tuple[str, str]:
@@ -172,27 +166,16 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        aggregation_type = None
-        source_feature_name: str | None = None
+        # Use the mixin method to extract source features
+        source_features = cls._extract_source_features(feature)
 
-        # string based
-        aggregation_type, source_feature_name = FeatureChainParser.parse_feature_name(
-            feature.name, [cls.PREFIX_PATTERN]
-        )
-        if aggregation_type is not None and source_feature_name is not None:
-            return aggregation_type, source_feature_name
-
-        # configuration based
-        source_features = feature.options.get_in_features()
-        source_feature = next(iter(source_features))
-        source_feature_name = source_feature.get_name()
-
-        aggregation_type = feature.options.get(cls.AGGREGATION_TYPE)
+        # Extract aggregation type
+        aggregation_type = cls._extract_aggregation_type(feature)
 
-        if aggregation_type is None or source_feature_name is None:
-            raise ValueError(f"Could not extract aggregation type and source feature from: {feature.name}")
+        if aggregation_type is None:
+            raise ValueError(f"Could not extract aggregation type from: {feature.name}")
 
-        return aggregation_type, source_feature_name
+        return aggregation_type, source_features[0]
 
     @classmethod
     def _supports_aggregation_type(cls, aggregation_type: str) -> bool:

mloda_plugins/feature_group/experimental/aggregated_feature_group/pandas.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Any, List, Set, Type, Union
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 
 from mloda_plugins.compute_framework.base_implementations.pandas.dataframe import PandasDataFrame
 from mloda_plugins.feature_group.experimental.aggregated_feature_group.base import AggregatedFeatureGroup
@@ -14,7 +14,7 @@ from mloda_plugins.feature_group.experimental.aggregated_feature_group.base impo
 
 class PandasAggregatedFeatureGroup(AggregatedFeatureGroup):
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         """Specify that this feature group works with Pandas."""
         return {PandasDataFrame}
 

mloda_plugins/feature_group/experimental/aggregated_feature_group/polars_lazy.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Any, List, Set, Type, Union
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 
 from mloda_plugins.compute_framework.base_implementations.polars.lazy_dataframe import PolarsLazyDataFrame
 from mloda_plugins.feature_group.experimental.aggregated_feature_group.base import AggregatedFeatureGroup
@@ -26,7 +26,7 @@ class PolarsLazyAggregatedFeatureGroup(AggregatedFeatureGroup):
     """
 
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         """Specify that this feature group works with Polars Lazy DataFrames."""
         return {PolarsLazyDataFrame}
 

mloda_plugins/feature_group/experimental/aggregated_feature_group/pyarrow.py

@@ -9,7 +9,7 @@ from typing import Any, List, Set, Type, Union
 import pyarrow as pa
 import pyarrow.compute as pc
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 
 from mloda_plugins.compute_framework.base_implementations.pyarrow.table import PyArrowTable
 from mloda_plugins.feature_group.experimental.aggregated_feature_group.base import AggregatedFeatureGroup
@@ -23,7 +23,7 @@ class PyArrowAggregatedFeatureGroup(AggregatedFeatureGroup):
     """
 
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         """Specify that this feature group works with PyArrow."""
         return {PyArrowTable}
 

mloda_plugins/feature_group/experimental/clustering/base.py

@@ -7,16 +7,19 @@ from __future__ import annotations
 from abc import abstractmethod
 from typing import Any, List, Optional, Set, Union
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.feature_chainer.feature_chain_parser import FeatureChainParser
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.feature_set import FeatureSet
-from mloda_core.abstract_plugins.components.options import Options
+from mloda import FeatureGroup
+from mloda import Feature
+from mloda.provider import FeatureChainParser
+from mloda.provider import (
+    FeatureChainParserMixin,
+)
+from mloda.user import FeatureName
+from mloda.provider import FeatureSet
+from mloda import Options
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
-class ClusteringFeatureGroup(AbstractFeatureGroup):
+class ClusteringFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     # Option keys for clustering configuration
     """
     Base class for all clustering feature groups.
@@ -105,53 +108,49 @@ class ClusteringFeatureGroup(AbstractFeatureGroup):
     # Define the prefix pattern for this feature group
     PREFIX_PATTERN = r".*__cluster_([\w]+)_([\w]+)$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = None  # Unlimited in_features allowed
+
     # Property mapping for configuration-based feature creation
     PROPERTY_MAPPING = {
         ALGORITHM: {
             **CLUSTERING_ALGORITHMS,  # All supported algorithms as valid values
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: True,  # Enable strict validation
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: True,  # Enable strict validation
         },
         K_VALUE: {
             "explanation": "Number of clusters or 'auto' for automatic determination",
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: True,  # Enable strict validation
-            DefaultOptionKeys.mloda_validation_function: lambda value: value == "auto"
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: True,  # Enable strict validation
+            DefaultOptionKeys.validation_function: lambda value: value == "auto"
             or (isinstance(value, (int, str)) and str(value).isdigit() and int(value) > 0),
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source features to use for clustering",
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: False,  # Flexible validation
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: False,  # Flexible validation
         },
         OUTPUT_PROBABILITIES: {
             "explanation": "Whether to output cluster probabilities/distances as separate columns using ~N suffix pattern",
-            DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
-            DefaultOptionKeys.mloda_strict_validation: False,  # Flexible validation
-            DefaultOptionKeys.mloda_default: False,  # Default is False (don't output probabilities)
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, bool),
+            DefaultOptionKeys.context: True,  # Mark as context parameter
+            DefaultOptionKeys.strict_validation: False,  # Flexible validation
+            DefaultOptionKeys.default: False,  # Default is False (don't output probabilities)
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, bool),
         },
     }
 
-    def input_features(self, options: Options, feature_name: FeatureName) -> Optional[Set[Feature]]:
-        """Extract source features from either string parsing or configuration-based options."""
-
-        # string based
-        source_features_str: str | None = None
-        _, source_features_str = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
-
-        if source_features_str is not None:
-            # Handle multiple source features (ampersand-separated)
-            source_features = set()
-            for feature in source_features_str.split("&"):
-                source_features.add(Feature(feature.strip()))
-            return source_features
-
-        # configuration based
-        source_features_frozen = options.get_in_features()
-        if len(source_features_frozen) < 1:
-            raise ValueError(f"Feature '{feature_name}' requires at least one source feature, but none were provided.")
-        return set(source_features_frozen)
+    @classmethod
+    def _validate_string_match(cls, feature_name: str, operation_config: str, source_feature: str) -> bool:
+        """Validate clustering-specific string patterns using parse_clustering_prefix()."""
+        if FeatureChainParser.is_chained_feature(feature_name):
+            try:
+                # Use existing validation logic that validates algorithm and k_value
+                cls.parse_clustering_prefix(feature_name)
+            except ValueError:
+                # If validation fails, this feature doesn't match
+                return False
+        return True
 
     @classmethod
     def parse_clustering_prefix(cls, feature_name: str) -> tuple[str, str]:
@@ -213,41 +212,12 @@ class ClusteringFeatureGroup(AbstractFeatureGroup):
         k_value = cls.parse_clustering_prefix(feature_name)[1]
         return k_value if k_value == "auto" else int(k_value)
 
-    @classmethod
-    def match_feature_group_criteria(
-        cls,
-        feature_name: Union[FeatureName, str],
-        options: Options,
-        data_access_collection: Optional[Any] = None,
-    ) -> bool:
-        """Check if feature name matches the expected pattern for clustering features."""
-
-        # Use the unified parser with property mapping for full configuration support
-        result = FeatureChainParser.match_configuration_feature_chain_parser(
-            feature_name,
-            options,
-            property_mapping=cls.PROPERTY_MAPPING,
-            prefix_patterns=[cls.PREFIX_PATTERN],
-        )
-
-        # If it matches and it's a string-based feature, validate with our custom logic
-        if result:
-            feature_name_str = feature_name.name if isinstance(feature_name, FeatureName) else feature_name
-
-            # Check if this is a string-based feature (contains the pattern)
-            if FeatureChainParser.is_chained_feature(feature_name_str):
-                try:
-                    # Use existing validation logic that validates algorithm and k_value
-                    cls.parse_clustering_prefix(feature_name_str)
-                except ValueError:
-                    # If validation fails, this feature doesn't match
-                    return False
-        return result
+    # Custom validation done via _validate_string_match() hook
 
     @classmethod
-    def _extract_algorithm_k_value_and_source_features(cls, feature: Feature) -> tuple[str, Union[int, str], list[str]]:
+    def _extract_clustering_params(cls, feature: Feature) -> tuple[Optional[str], Optional[Union[int, str]]]:
         """
-        Extract algorithm, k_value, and source features from a feature.
+        Extract algorithm and k_value from a feature.
 
         Tries string-based approach first, falls back to configuration-based.
 
@@ -255,47 +225,49 @@ class ClusteringFeatureGroup(AbstractFeatureGroup):
             feature: The feature to extract parameters from
 
         Returns:
-            Tuple of (algorithm, k_value, source_features_list)
+            Tuple of (algorithm, k_value) or (None, None) if extraction fails
 
         Raises:
-            ValueError: If parameters cannot be extracted
+            ValueError: If string-based parsing fails due to invalid format
         """
-        algorithm = None
-        k_value: str | int | None = None
-        source_features = None
-
-        # string based
+        # Try string-based parsing first
         algorithm_str, source_features_str = FeatureChainParser.parse_feature_name(feature.name, [cls.PREFIX_PATTERN])
         if algorithm_str is not None and source_features_str is not None:
-            # Parse the algorithm and k_value from the prefix
             algorithm, k_value_str = cls.parse_clustering_prefix(feature.get_name())
+            k_value: Union[int, str] = "auto" if k_value_str == "auto" else int(k_value_str)
+            return algorithm, k_value
 
-            # Convert k_value to appropriate type
-            if k_value_str == "auto":
-                k_value = "auto"
-            else:
-                k_value = int(k_value_str)
+        # Fall back to configuration-based
+        algorithm = feature.options.get(cls.ALGORITHM)
+        k_value_raw = feature.options.get(cls.K_VALUE)
 
-            # Parse source features (ampersand-separated)
-            source_features = [feature.strip() for feature in source_features_str.split("&")]
+        if k_value_raw is None:
+            return algorithm, None
 
-            return algorithm, k_value, source_features
+        k_value = "auto" if k_value_raw == "auto" else int(k_value_raw)
+        return algorithm, k_value
 
-        # configuration based
-        source_features_frozen = feature.options.get_in_features()
-        source_features = [source_feature.get_name() for source_feature in source_features_frozen]
+    @classmethod
+    def _extract_algorithm_k_value_and_source_features(cls, feature: Feature) -> tuple[str, Union[int, str], list[str]]:
+        """
+        Extract algorithm, k_value, and source features from a feature.
 
-        algorithm = feature.options.get(cls.ALGORITHM)
-        k_value_raw = feature.options.get(cls.K_VALUE)
+        Tries string-based approach first, falls back to configuration-based.
 
-        # Convert k_value to appropriate type
-        if k_value_raw == "auto":
-            k_value = "auto"
-        else:
-            k_value = int(k_value_raw)
+        Args:
+            feature: The feature to extract parameters from
+
+        Returns:
+            Tuple of (algorithm, k_value, source_features_list)
+
+        Raises:
+            ValueError: If parameters cannot be extracted
+        """
+        source_features = cls._extract_source_features(feature)
+        algorithm, k_value = cls._extract_clustering_params(feature)
 
-        if algorithm is None or k_value is None or not source_features:
-            raise ValueError(f"Could not extract algorithm, k_value, and source features from: {feature.name}")
+        if algorithm is None or k_value is None:
+            raise ValueError(f"Could not extract algorithm and k_value from: {feature.name}")
 
         return algorithm, k_value, source_features
 

mloda_plugins/feature_group/experimental/clustering/pandas.py

@@ -27,14 +27,14 @@ except ImportError:
     np = None  # type: ignore[assignment]
 
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 from mloda_plugins.compute_framework.base_implementations.pandas.dataframe import PandasDataFrame
 from mloda_plugins.feature_group.experimental.clustering.base import ClusteringFeatureGroup
 
 
 class PandasClusteringFeatureGroup(ClusteringFeatureGroup):
     @classmethod
-    def compute_framework_rule(cls) -> set[type[ComputeFrameWork]]:
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]]:
         """Define the compute framework for this feature group."""
         return {PandasDataFrame}