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

mloda_plugins/feature_group/experimental/data_quality/missing_value/base.py

@@ -8,16 +8,19 @@ import copy
 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 MissingValueFeatureGroup(AbstractFeatureGroup):
+class MissingValueFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for all missing value imputation feature groups.
 
@@ -83,7 +86,7 @@ class MissingValueFeatureGroup(AbstractFeatureGroup):
     ### String-Based Creation
 
     ```python
-    from mloda_core.abstract_plugins.components.feature import Feature
+    from mloda import Feature
 
     # Impute missing income values with mean
     feature = Feature(name="income__mean_imputed")
@@ -101,8 +104,8 @@ class MissingValueFeatureGroup(AbstractFeatureGroup):
     ### Configuration-Based Creation
 
     ```python
-    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.feature_group.experimental.default_options_key import DefaultOptionKeys
 
     # Mean imputation using configuration
@@ -160,46 +163,31 @@ class MissingValueFeatureGroup(AbstractFeatureGroup):
 
     PREFIX_PATTERN = r".*__([\w]+)_imputed$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
     PROPERTY_MAPPING = {
         IMPUTATION_METHOD: {
             **IMPUTATION_METHODS,
-            DefaultOptionKeys.mloda_context: True,
+            DefaultOptionKeys.context: True,
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source feature to impute missing values",
-            DefaultOptionKeys.mloda_context: True,
+            DefaultOptionKeys.context: True,
         },
         "constant_value": {
             "explanation": "Constant value to use for constant imputation method",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,  # Default is None, required only for constant method
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,  # Default is None, required only for constant method
         },
         "group_by_features": {
             "explanation": "Optional list of features to group by before imputation",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,  # Default is None (no grouping)
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,  # Default is None (no grouping)
         },
     }
 
-    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
-
-        # Try string-based parsing first
-        # parse_feature_name returns (operation_config, source_feature)
-        operation_config, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
-        if source_feature is not None:
-            return {Feature(source_feature)}
-
-        # Fall back to configuration-based approach
-        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_imputation_method(cls, feature_name: str) -> str:
         """Extract the imputation method from the feature name."""
@@ -223,21 +211,36 @@ class MissingValueFeatureGroup(AbstractFeatureGroup):
         return imputation_method
 
     @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 missing value features."""
-
-        # 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_imputation_method(cls, feature: Feature) -> Optional[str]:
+        """
+        Extract imputation method from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based.
+
+        Args:
+            feature: The feature to extract imputation method from
+
+        Returns:
+            Imputation method name or None if not found
+        """
+        feature_name = feature.get_name()
+
+        # Try string-based parsing first
+        if FeatureChainParser.is_chained_feature(feature_name):
+            # Use get_imputation_method which handles parse_feature_name correctly
+            return cls.get_imputation_method(feature_name)
+
+        # Fall back to configuration-based approach
+        imputation_method = feature.options.get(cls.IMPUTATION_METHOD)
+
+        # Validate imputation method if found
+        if imputation_method is not None and imputation_method not in cls.IMPUTATION_METHODS:
+            raise ValueError(
+                f"Unsupported imputation method: {imputation_method}. "
+                f"Supported methods: {', '.join(cls.IMPUTATION_METHODS.keys())}"
+            )
+
+        return str(imputation_method) if imputation_method is not None else None
 
     @classmethod
     def _extract_imputation_method_and_source_feature(cls, feature: Feature) -> tuple[str, str]:
@@ -255,37 +258,13 @@ class MissingValueFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        imputation_method = None
-        source_feature_name: str | None = None
-
-        # Try string-based parsing first
-        feature_name_str = feature.name.name if hasattr(feature.name, "name") else str(feature.name)
-
-        if FeatureChainParser.is_chained_feature(feature_name_str):
-            # Use get_imputation_method which already handles parse_feature_name correctly
-            imputation_method = cls.get_imputation_method(feature_name_str)
-            # Use extract_source_feature which returns everything before the last __
-            source_feature_name = FeatureChainParser.extract_source_feature(feature_name_str, cls.PREFIX_PATTERN)
-            return imputation_method, source_feature_name
+        source_features = cls._extract_source_features(feature)
+        imputation_method = cls._extract_imputation_method(feature)
 
-        # Fall back to configuration-based approach
-        source_features = feature.options.get_in_features()
-        source_feature = next(iter(source_features))
-        source_feature_name = source_feature.get_name()
-
-        imputation_method = feature.options.get(cls.IMPUTATION_METHOD)
-
-        if imputation_method is None or source_feature_name is None:
-            raise ValueError(f"Could not extract imputation method and source feature from: {feature.name}")
-
-        # Validate imputation method (no need to strip "imputed" from config-based method)
-        if imputation_method not in cls.IMPUTATION_METHODS:
-            raise ValueError(
-                f"Unsupported imputation method: {imputation_method}. "
-                f"Supported methods: {', '.join(cls.IMPUTATION_METHODS.keys())}"
-            )
+        if imputation_method is None:
+            raise ValueError(f"Could not extract imputation method from: {feature.name}")
 
-        return imputation_method, source_feature_name
+        return imputation_method, source_features[0]
 
     @classmethod
     def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:

mloda_plugins/feature_group/experimental/data_quality/missing_value/pandas.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 from typing import Any, List, Optional, 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.data_quality.missing_value.base import MissingValueFeatureGroup
@@ -20,7 +20,7 @@ except ImportError:
 
 class PandasMissingValueFeatureGroup(MissingValueFeatureGroup):
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         return {PandasDataFrame}
 
     @classmethod

mloda_plugins/feature_group/experimental/data_quality/missing_value/pyarrow.py

@@ -9,7 +9,7 @@ from typing import Any, List, Optional, 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.data_quality.missing_value.base import MissingValueFeatureGroup
@@ -17,7 +17,7 @@ from mloda_plugins.feature_group.experimental.data_quality.missing_value.base im
 
 class PyArrowMissingValueFeatureGroup(MissingValueFeatureGroup):
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         return {PyArrowTable}
 
     @classmethod

mloda_plugins/feature_group/experimental/data_quality/missing_value/python_dict.py

@@ -8,7 +8,7 @@ import statistics
 from collections import Counter
 from typing import Any, Dict, List, Optional, Set, Type, Union
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 
 from mloda_plugins.compute_framework.base_implementations.python_dict.python_dict_framework import PythonDictFramework
 from mloda_plugins.feature_group.experimental.data_quality.missing_value.base import MissingValueFeatureGroup
@@ -23,7 +23,7 @@ class PythonDictMissingValueFeatureGroup(MissingValueFeatureGroup):
     """
 
     @classmethod
-    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:
+    def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:
         return {PythonDictFramework}
 
     @classmethod

mloda_plugins/feature_group/experimental/default_options_key.py

@@ -3,28 +3,25 @@ from enum import Enum
 
 class DefaultOptionKeys(str, Enum):
     """
+    Default option keys used to configure mloda feature groups.
 
-    This class contains the default option keys for mloda.
+    These keys are used to look up configuration values in Options objects.
+    The enum value serves as both the option key and the default column name.
 
-    These keys are used to set options for the features as conventions.
-
-    For faster development and prototyping, it was decided to use the Option object to move configurations around.
-    When the framework matured and we learned more about the requirements, we can refactor this to a more sophisticated solution.
-
-    However we use the DefaultOptions object to store needed keywords.
+    Time-Related Keys:
+    - `reference_time`: Key for the event timestamp column. Value: "reference_time"
+    - `time_travel`: Key for the validity timestamp column. Value: "time_travel_filter"
 
+    These values are used as default column names when not customized via Options.
     """
 
     in_features = "in_features"
-    mloda_source_feature_group = "mloda_source_feature_group"
-    mloda_feature_chainer_parser_key = "mloda_feature_chainer_parser_key"
-    reference_time = "time_filter"
-    mloda_default = "default"
-    mloda_context = "context"
-    mloda_group = "group"
-    mloda_strict_validation = "strict_validation"
-    mloda_validation_function = "validation_function"
-
-    @classmethod
-    def list(cls) -> list[str]:
-        return [member.value for member in cls]
+    feature_chainer_parser_key = "feature_chainer_parser_key"
+    reference_time = "reference_time"
+    time_travel = "time_travel_filter"
+    default = "default"
+    context = "context"
+    group = "group"
+    strict_validation = "strict_validation"
+    validation_function = "validation_function"
+    strict_type_enforcement = "strict_type_enforcement"

mloda_plugins/feature_group/experimental/dimensionality_reduction/base.py

@@ -7,16 +7,19 @@ from __future__ import annotations
 from abc import abstractmethod
 from typing import Any, 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 DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
+class DimensionalityReductionFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for all dimensionality reduction feature groups.
 
@@ -113,41 +116,46 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
     # Define the prefix pattern for this feature group
     PREFIX_PATTERN = r".*__([\w]+)_(\d+)d$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    IN_FEATURE_SEPARATOR = ","
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = None
+
     PROPERTY_MAPPING = {
         ALGORITHM: {
             **REDUCTION_ALGORITHMS,
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
         },
         DIMENSION: {
             "explanation": "Target dimension for the reduction (positive integer)",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, (int, str))
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, (int, str))
             and str(value).isdigit()
             and int(value) > 0,
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source features to use for dimensionality reduction",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
         },
         # t-SNE specific parameters
         TSNE_MAX_ITER: {
             "explanation": "Maximum number of iterations for t-SNE optimization",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": 250,
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, (int, str))
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, (int, str))
             and str(value).isdigit()
             and int(value) > 0,
         },
         TSNE_N_ITER_WITHOUT_PROGRESS: {
             "explanation": "Maximum iterations without progress before early stopping (t-SNE)",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": 50,
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, (int, str))
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, (int, str))
             and str(value).isdigit()
             and int(value) > 0,
         },
@@ -155,8 +163,8 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
             "barnes_hut": "Barnes-Hut approximation (faster, O(n log n))",
             "exact": "Exact method (slower, O(n^2))",
             "explanation": "t-SNE computation method",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": "barnes_hut",
         },
         # PCA specific parameters
@@ -166,54 +174,32 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
             "arpack": "Truncated SVD using ARPACK",
             "randomized": "Randomized SVD",
             "explanation": "SVD solver algorithm for PCA",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": "auto",
         },
         # ICA specific parameters
         ICA_MAX_ITER: {
             "explanation": "Maximum number of iterations for ICA",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": 200,
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, (int, str))
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, (int, str))
             and str(value).isdigit()
             and int(value) > 0,
         },
         # Isomap specific parameters
         ISOMAP_N_NEIGHBORS: {
             "explanation": "Number of neighbors for Isomap",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
             "default": 5,
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, (int, str))
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, (int, str))
             and str(value).isdigit()
             and int(value) > 0,
         },
     }
 
-    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
-
-        # Try string-based parsing first
-        _, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
-        if source_feature is not None:
-            # Handle multiple source features (comma-separated)
-            source_features = set()
-            for feature in source_feature.split(","):
-                source_features.add(Feature(feature.strip()))
-            return source_features
-
-        # Fall back to configuration-based approach
-        source_featurez = options.get_in_features()
-        if len(source_featurez) != 1:
-            raise ValueError(
-                f"Expected exactly one source feature, but found {len(source_featurez)}: {source_featurez}"
-            )
-        return set(source_featurez)
-
     @classmethod
     def parse_reduction_suffix(cls, feature_name: str) -> tuple[str, int]:
         """
@@ -265,35 +251,28 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
             raise ValueError(f"Invalid dimension: {dimension_str}. Must be a positive integer.")
 
     @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 dimensionality reduction 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],
-        )
+    def _validate_string_match(cls, feature_name: str, _operation_config: str, _source_feature: str) -> bool:
+        """
+        Validate that a string-based feature name has valid dimensionality reduction components.
 
-        # 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
+        Validates algorithm and dimension using parse_reduction_suffix().
 
-            # 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 dimension
-                    cls.parse_reduction_suffix(feature_name_str)
-                except ValueError:
-                    # If validation fails, this feature doesn't match
-                    return False
-        return result
+        Args:
+            feature_name: The full feature name to validate
+            _operation_config: The operation config extracted by the regex (unused)
+            _source_feature: The source feature extracted by the regex (unused)
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if FeatureChainParser.is_chained_feature(feature_name):
+            try:
+                # Use existing validation logic that validates algorithm and dimension
+                cls.parse_reduction_suffix(feature_name)
+            except ValueError:
+                # If validation fails, this feature doesn't match
+                return False
+        return True
 
     @classmethod
     def _extract_algorithm_dimension_and_source_features(cls, feature: Feature) -> tuple[str, int, list[str], Options]:
@@ -311,30 +290,38 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        algorithm = None
-        dimension = None
-        source_features = None
+        source_features = cls._extract_source_features(feature)
+        algorithm, dimension, algo_options = cls._extract_dim_reduction_params(feature)
+        if algorithm is None or dimension is None:
+            raise ValueError(f"Could not extract algorithm and dimension from: {feature.name}")
+        return algorithm, dimension, source_features, algo_options
 
-        # Try string-based parsing first
+    @classmethod
+    def _extract_dim_reduction_params(cls, feature: Feature) -> tuple[Optional[str], Optional[int], Options]:
+        """
+        Extract dimensionality reduction algorithm, dimension, and options from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based approach.
+
+        Args:
+            feature: The feature to extract parameters from
+
+        Returns:
+            Tuple of (algorithm, dimension, algorithm_options)
+        """
         feature_name_str = feature.name.name if hasattr(feature.name, "name") else str(feature.name)
 
+        # Try string-based parsing first
         if FeatureChainParser.is_chained_feature(feature_name_str):
             algorithm, dimension = cls.parse_reduction_suffix(feature_name_str)
-            source_features_str = FeatureChainParser.extract_source_feature(feature_name_str, cls.PREFIX_PATTERN)
-            source_features = [feature.strip() for feature in source_features_str.split(",")]
-            # For string-based features, still extract algorithm-specific options from feature.options
-            return algorithm, dimension, source_features, feature.options
+            return algorithm, dimension, feature.options
 
         # Fall back to configuration-based approach
-        source_features_set = feature.options.get_in_features()
-        source_feature = next(iter(source_features_set))
-        source_features = [source_feature.get_name()]
-
         algorithm = feature.options.get(cls.ALGORITHM)
         dimension = feature.options.get(cls.DIMENSION)
 
         if algorithm is None or dimension is None:
-            raise ValueError(f"Could not extract algorithm and dimension from: {feature.name}")
+            return None, None, feature.options
 
         # Validate algorithm
         if algorithm not in cls.REDUCTION_ALGORITHMS:
@@ -344,12 +331,11 @@ class DimensionalityReductionFeatureGroup(AbstractFeatureGroup):
             )
 
         # Validate and convert dimension
-
         dimension = int(dimension)
         if dimension <= 0:
             raise ValueError(f"Invalid dimension: {dimension}. Must be a positive integer.")
 
-        return algorithm, dimension, source_features, feature.options
+        return algorithm, dimension, feature.options
 
     @classmethod
     def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:

mloda_plugins/feature_group/experimental/dimensionality_reduction/pandas.py

@@ -27,14 +27,14 @@ except ImportError:
     SKLEARN_AVAILABLE = False
 
 
-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.dimensionality_reduction.base import DimensionalityReductionFeatureGroup
 
 
 class PandasDimensionalityReductionFeatureGroup(DimensionalityReductionFeatureGroup):
     @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}