mloda 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

mloda_plugins/feature_group/experimental/node_centrality/base.py

@@ -4,18 +4,19 @@ Base implementation for node centrality feature groups.
 
 from __future__ import annotations
 
-from typing import Any, Optional, Set, Type, 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 typing import Any, Optional
+
+from mloda import FeatureGroup
+from mloda import Feature
+from mloda.provider import FeatureChainParser
+from mloda.provider import (
+    FeatureChainParserMixin,
+)
+from mloda.provider import FeatureSet
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
-class NodeCentralityFeatureGroup(AbstractFeatureGroup):
+class NodeCentralityFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     # Option keys for centrality configuration
     CENTRALITY_TYPE = "centrality_type"
     GRAPH_TYPE = "graph_type"
@@ -131,49 +132,35 @@ class NodeCentralityFeatureGroup(AbstractFeatureGroup):
     # Define the suffix pattern for this feature group (L→R format: source__operation)
     PREFIX_PATTERN = r".*__([\w]+)_centrality$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
     # Property mapping for configuration-based feature creation
     PROPERTY_MAPPING = {
         # Context parameters (don't affect Feature Group resolution)
         CENTRALITY_TYPE: {
             **CENTRALITY_TYPES,  # All supported centrality types as valid options
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
         },
         GRAPH_TYPE: {
             **GRAPH_TYPES,  # All supported graph types as valid options
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
-            DefaultOptionKeys.mloda_default: "undirected",
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
+            DefaultOptionKeys.default: "undirected",
         },
         WEIGHT_COLUMN: {
             "explanation": "Column name for edge weights (optional)",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source feature representing the nodes for centrality calculation",
-            DefaultOptionKeys.mloda_context: True,
+            DefaultOptionKeys.context: True,
         },
     }
 
-    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 parse_centrality_prefix(cls, feature_name: str) -> str:
         """
@@ -221,24 +208,6 @@ class NodeCentralityFeatureGroup(AbstractFeatureGroup):
         """Extract the centrality type from the feature name."""
         return cls.parse_centrality_prefix(feature_name)
 
-    @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 centrality features."""
-        if isinstance(feature_name, FeatureName):
-            feature_name = feature_name.name
-
-        return FeatureChainParser.match_configuration_feature_chain_parser(
-            feature_name,
-            options,
-            property_mapping=cls.PROPERTY_MAPPING,
-            prefix_patterns=[cls.PREFIX_PATTERN],
-        )
-
     @classmethod
     def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
         """
@@ -290,35 +259,38 @@ class NodeCentralityFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        centrality_type = None
-        source_feature_name: str | None = None
+        source_features = cls._extract_source_features(feature)
+        centrality_type = cls._extract_centrality_type(feature)
+        if centrality_type is None:
+            raise ValueError(f"Could not extract centrality type from: {feature.name}")
+        return centrality_type, source_features[0]
 
+    @classmethod
+    def _extract_centrality_type(cls, feature: Feature) -> Optional[str]:
+        """
+        Extract centrality type from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based approach.
+
+        Args:
+            feature: The feature to extract centrality type from
+
+        Returns:
+            The centrality type, or None if not found
+
+        Raises:
+            ValueError: If centrality type cannot be extracted
+        """
         # Try string-based parsing first
-        # Note: parse_feature_name returns (operation_config, source_feature) for L→R format
-        # The operation_config is already extracted by the regex group (e.g., "degree" from "degree_centrality")
         suffix_part, source_feature_name = FeatureChainParser.parse_feature_name(feature.name, [cls.PREFIX_PATTERN])
         if source_feature_name is not None and suffix_part is not None:
             # The suffix_part is already the centrality type (extracted by regex group)
-            centrality_type = suffix_part
-            if centrality_type in cls.CENTRALITY_TYPES:
-                return centrality_type, source_feature_name
+            if suffix_part in cls.CENTRALITY_TYPES:
+                return suffix_part
 
         # Fall back to configuration-based approach
-        source_features = feature.options.get_in_features()
-        if len(source_features) != 1:
-            raise ValueError(
-                f"Expected exactly one source feature, but found {len(source_features)}: {source_features}"
-            )
-
-        source_feature = next(iter(source_features))
-        source_feature_name = source_feature.get_name()
-
         centrality_type = feature.options.get(cls.CENTRALITY_TYPE)
-
-        if centrality_type is None or source_feature_name is None:
-            raise ValueError(f"Could not extract centrality type and source feature from: {feature.name}")
-
-        return centrality_type, source_feature_name
+        return str(centrality_type) if centrality_type is not None else None
 
     @classmethod
     def _check_source_feature_exists(cls, data: Any, feature_name: str) -> None:

mloda_plugins/feature_group/experimental/node_centrality/pandas.py

@@ -14,14 +14,14 @@ except ImportError:
     pd = None
     np = None  # type: ignore
 
-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.node_centrality.base import NodeCentralityFeatureGroup
 
 
 class PandasNodeCentralityFeatureGroup(NodeCentralityFeatureGroup):
     @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}
 

mloda_plugins/feature_group/experimental/sklearn/encoding/base.py

@@ -5,20 +5,23 @@ Base implementation for scikit-learn encoding feature groups.
 from __future__ import annotations
 
 import datetime
-from typing import Any, Dict, Optional, Set, Type, 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_core.abstract_plugins.components.base_artifact import BaseArtifact
+from typing import Any, Dict, Optional, Set, Type
+
+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.provider import BaseArtifact
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 from mloda_plugins.feature_group.experimental.sklearn.sklearn_artifact import SklearnArtifact
 
 
-class EncodingFeatureGroup(AbstractFeatureGroup):
+class EncodingFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for scikit-learn encoding feature groups.
 
@@ -55,8 +58,8 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
     Uses Options with proper group/context parameter separation:
 
     ```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
 
     feature = Feature(
@@ -75,7 +78,7 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
     ### String-Based Creation
 
     ```python
-    from mloda_core.abstract_plugins.components.feature import Feature
+    from mloda import Feature
 
     # OneHot encoding - creates multiple binary columns
     feature = Feature(name="product_category__onehot_encoded")
@@ -92,8 +95,8 @@ class EncodingFeatureGroup(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
 
     # OneHot encoding using configuration
     feature = Feature(
@@ -168,19 +171,23 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
 
     # Define patterns for parsing
     PATTERN = "__"
-    SUFFIX_PATTERN = r".*__(onehot|label|ordinal)_encoded(~\d+)?$"
+    PREFIX_PATTERN = r".*__(onehot|label|ordinal)_encoded(~\d+)?$"
+
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
 
     # Property mapping for new configuration-based approach
     PROPERTY_MAPPING = {
         ENCODER_TYPE: {
             **SUPPORTED_ENCODERS,  # All supported encoder types as valid options
-            DefaultOptionKeys.mloda_context: True,  # Context parameter
-            DefaultOptionKeys.mloda_strict_validation: True,  # Enable strict validation
+            DefaultOptionKeys.context: True,  # Context parameter
+            DefaultOptionKeys.strict_validation: True,  # Enable strict validation
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source feature to encode",
-            DefaultOptionKeys.mloda_context: True,  # Context parameter
-            DefaultOptionKeys.mloda_strict_validation: False,  # Flexible validation
+            DefaultOptionKeys.context: True,  # Context parameter
+            DefaultOptionKeys.strict_validation: False,  # Flexible validation
         },
     }
 
@@ -193,7 +200,7 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
         """Extract source feature from either configuration-based options or string parsing."""
 
         # Try string-based parsing first
-        _, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.SUFFIX_PATTERN])
+        _, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
         if source_feature is not None:
             # Remove ~suffix if present (for OneHot column patterns like category~1)
             base_feature = self.get_column_base_feature(source_feature)
@@ -210,7 +217,7 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
     @classmethod
     def get_encoder_type(cls, feature_name: str) -> str:
         """Extract the encoder type from the feature name."""
-        encoder_type, _ = FeatureChainParser.parse_feature_name(feature_name, [cls.SUFFIX_PATTERN])
+        encoder_type, _ = FeatureChainParser.parse_feature_name(feature_name, [cls.PREFIX_PATTERN])
         if encoder_type is None:
             raise ValueError(f"Invalid encoding feature name format: {feature_name}")
 
@@ -223,22 +230,6 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
 
         return encoder_type
 
-    @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 using unified parser."""
-        # 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.SUFFIX_PATTERN],
-        )
-
     @classmethod
     def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
         """
@@ -307,33 +298,42 @@ class EncodingFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        encoder_type = None
-        source_feature_name: str | None = None
+        source_features = cls._extract_source_features(feature)
+        encoder_type = cls._extract_encoder_type(feature)
+        if encoder_type is None:
+            raise ValueError(f"Could not extract encoder type from: {feature.name}")
+        return encoder_type, source_features[0]
 
-        # Try string-based parsing first
+    @classmethod
+    def _extract_encoder_type(cls, feature: Feature) -> Optional[str]:
+        """
+        Extract encoder type from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based approach.
+
+        Args:
+            feature: The feature to extract encoder type from
+
+        Returns:
+            Encoder type string, or None if not found
+
+        Raises:
+            ValueError: If encoder type is unsupported
+        """
         feature_name_str = feature.name.name if hasattr(feature.name, "name") else str(feature.name)
 
         if FeatureChainParser.is_chained_feature(feature_name_str):
             encoder_type = cls.get_encoder_type(feature_name_str)
-            source_feature_name = FeatureChainParser.extract_source_feature(feature_name_str, cls.SUFFIX_PATTERN)
-            return encoder_type, source_feature_name
-
-        # 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()
+            return encoder_type
 
         encoder_type = feature.options.get(cls.ENCODER_TYPE)
 
-        if encoder_type is None or source_feature_name is None:
-            raise ValueError(f"Could not extract encoder type and source feature from: {feature.name}")
-
-        if encoder_type not in cls.SUPPORTED_ENCODERS:
+        if encoder_type is not None and encoder_type not in cls.SUPPORTED_ENCODERS:
             raise ValueError(
                 f"Unsupported encoder type: {encoder_type}. Supported types: {', '.join(cls.SUPPORTED_ENCODERS.keys())}"
             )
 
-        return encoder_type, source_feature_name
+        return str(encoder_type) if encoder_type is not None else None
 
     @classmethod
     def _import_sklearn_components(cls) -> Dict[str, Any]:

mloda_plugins/feature_group/experimental/sklearn/encoding/pandas.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Any, 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.sklearn.encoding.base import EncodingFeatureGroup
@@ -21,7 +21,7 @@ class PandasEncodingFeatureGroup(EncodingFeatureGroup):
     """
 
     @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/sklearn/pipeline/base.py

@@ -7,18 +7,21 @@ from __future__ import annotations
 import datetime
 from typing import Any, Dict, FrozenSet, List, Optional, Set, Type, 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_core.abstract_plugins.components.base_artifact import BaseArtifact
+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.provider import BaseArtifact
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 from mloda_plugins.feature_group.experimental.sklearn.sklearn_artifact import SklearnArtifact
 
 
-class SklearnPipelineFeatureGroup(AbstractFeatureGroup):
+class SklearnPipelineFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for scikit-learn pipeline feature groups.
 
@@ -88,22 +91,22 @@ class SklearnPipelineFeatureGroup(AbstractFeatureGroup):
     PROPERTY_MAPPING = {
         PIPELINE_NAME: {
             **PIPELINE_TYPES,  # All supported pipeline types as valid options
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,  # Default is None as steps + params also work
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,  # Default is None as steps + params also work
         },
         PIPELINE_STEPS: {
             "explanation": "List of pipeline steps as (name, transformer) tuples",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,  # Default is None as pipeline_types also work
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,  # Default is None as pipeline_types also work
         },
         PIPELINE_PARAMS: {
             "explanation": "Pipeline parameters dictionary",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_default: None,  # Default is None as pipeline_types also work
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.default: None,  # Default is None as pipeline_types also work
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source features for sklearn pipeline (comma-separated)",
-            DefaultOptionKeys.mloda_context: True,
+            DefaultOptionKeys.context: True,
         },
     }
 
@@ -111,6 +114,12 @@ class SklearnPipelineFeatureGroup(AbstractFeatureGroup):
     PATTERN = "__"
     PREFIX_PATTERN = r".*__sklearn_pipeline_([\w]+)$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    # Pipelines support variable number of in_features
+    IN_FEATURE_SEPARATOR = ","  # Use comma for multiple source features
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES: Optional[int] = None  # Unlimited
+
     @staticmethod
     def artifact() -> Type[BaseArtifact] | None:
         """Return the artifact class for sklearn pipeline persistence."""
@@ -143,6 +152,8 @@ class SklearnPipelineFeatureGroup(AbstractFeatureGroup):
         # The regex already extracts just the pipeline name (e.g., "scaling" from "income__sklearn_pipeline_scaling")
         return prefix_part
 
+    # Note: Custom match_feature_group_criteria() required instead of inheriting from mixin
+    # because this feature group has unique pre-check logic (PIPELINE_NAME vs PIPELINE_STEPS mutual exclusivity)
     @classmethod
     def match_feature_group_criteria(
         cls,
@@ -248,43 +259,45 @@ class SklearnPipelineFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
+        source_features = cls._extract_source_features(feature)
+        pipeline_name = cls._extract_pipeline_name(feature)
+        if pipeline_name is None:
+            raise ValueError(f"Could not extract pipeline name from: {feature.name}")
+        return pipeline_name, source_features
+
+    @classmethod
+    def _extract_pipeline_name(cls, feature: Feature) -> Optional[str]:
+        """
+        Extract pipeline name from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based approach.
+
+        Args:
+            feature: The feature to extract pipeline name from
+
+        Returns:
+            Pipeline name or None if extraction fails
+        """
         # 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):
-            pipeline_name = cls.get_pipeline_name(feature_name_str)
-            _, source_features_str = FeatureChainParser.parse_feature_name(feature_name_str, [cls.PREFIX_PATTERN])
-
-            if source_features_str is not None:
-                # Handle multiple source features
-                if "," in source_features_str:
-                    source_features = [f.strip() for f in source_features_str.split(",")]
-                else:
-                    source_features = [source_features_str]
-
-                return pipeline_name, source_features
+            prefix_part, _ = FeatureChainParser.parse_feature_name(feature_name_str, [cls.PREFIX_PATTERN])
+            if prefix_part is not None:
+                return prefix_part
 
         # Fall back to configuration-based approach
         pipeline_name = feature.options.get(cls.PIPELINE_NAME)
         pipeline_steps = feature.options.get(cls.PIPELINE_STEPS)
-        source_features_set = feature.options.get_in_features()
-        source_features = [sf.get_name() for sf in source_features_set]
 
         # Handle mutual exclusivity: either PIPELINE_NAME or PIPELINE_STEPS
         if pipeline_name is not None:
-            # Using predefined pipeline
-            if not source_features:
-                raise ValueError(f"Could not extract source features from: {feature.name}")
-            return pipeline_name, source_features
+            return str(pipeline_name)
         elif pipeline_steps is not None:
             # Using custom pipeline steps - use "custom" as pipeline name
-            if not source_features:
-                raise ValueError(f"Could not extract source features from: {feature.name}")
-            return "custom", source_features
-        else:
-            raise ValueError(
-                f"Could not extract pipeline configuration from: {feature.name}. Must provide either PIPELINE_NAME or PIPELINE_STEPS."
-            )
+            return "custom"
+
+        return None
 
     @classmethod
     def _get_pipeline_config_from_feature(cls, feature: Feature, pipeline_name: str) -> Dict[str, Any]:

mloda_plugins/feature_group/experimental/sklearn/pipeline/pandas.py

@@ -4,10 +4,9 @@ Pandas implementation for scikit-learn pipeline feature groups.
 
 from __future__ import annotations
 
-import numpy as np
-from typing import Any, List, Set, Type, Union
+from typing import Any, 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.sklearn.pipeline.base import SklearnPipelineFeatureGroup
@@ -22,7 +21,7 @@ class PandasSklearnPipelineFeatureGroup(SklearnPipelineFeatureGroup):
     """
 
     @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}