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

mloda_plugins/compute_framework/base_implementations/polars/polars_lazy_pyarrow_transformer.py

@@ -5,7 +5,7 @@ from mloda_core.abstract_plugins.components.framework_transformer.base_transform
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 try:
     import pyarrow as pa
@@ -13,7 +13,7 @@ except ImportError:
     pa = None
 
 
-class PolarsLazyPyarrowTransformer(BaseTransformer):
+class PolarsLazyPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between Polars LazyFrame and PyArrow Table.
 
@@ -66,4 +66,4 @@ class PolarsLazyPyarrowTransformer(BaseTransformer):
             raise ImportError("Polars is not installed. To be able to use this framework, please install polars.")
         # Convert PyArrow to DataFrame, then make it lazy
         df = pl.from_arrow(data)
-        return df.lazy()  # type: ignore
+        return df.lazy()  # type: ignore[union-attr]

mloda_plugins/compute_framework/base_implementations/polars/polars_merge_engine.py

@@ -7,7 +7,7 @@ from mloda_core.abstract_plugins.components.merge.base_merge_engine import BaseM
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 
 class PolarsMergeEngine(BaseMergeEngine):

mloda_plugins/compute_framework/base_implementations/polars/polars_pyarrow_transformer.py

@@ -5,7 +5,7 @@ from mloda_core.abstract_plugins.components.framework_transformer.base_transform
 try:
     import polars as pl
 except ImportError:
-    pl = None  # type: ignore
+    pl = None  # type: ignore[assignment]
 
 try:
     import pyarrow as pa
@@ -13,7 +13,7 @@ except ImportError:
     pa = None
 
 
-class PolarsPyarrowTransformer(BaseTransformer):
+class PolarsPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between Polars DataFrame and PyArrow Table.
 

mloda_plugins/compute_framework/base_implementations/pyarrow/pyarrow_filter_engine.py

@@ -40,11 +40,7 @@ class PyArrowFilterEngine(BaseFilterEngine):
         column_name = str(filter_feature.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}")
@@ -59,14 +55,8 @@ class PyArrowFilterEngine(BaseFilterEngine):
         column_name = str(filter_feature.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
@@ -90,11 +80,7 @@ class PyArrowFilterEngine(BaseFilterEngine):
             return data.filter(mask)
         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}")
@@ -111,11 +97,7 @@ class PyArrowFilterEngine(BaseFilterEngine):
         column_name = str(filter_feature.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}")
@@ -130,11 +112,7 @@ class PyArrowFilterEngine(BaseFilterEngine):
         column_name = str(filter_feature.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}")
@@ -151,11 +129,7 @@ class PyArrowFilterEngine(BaseFilterEngine):
         column_name = str(filter_feature.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/pyarrow/table.py

@@ -16,7 +16,7 @@ except ImportError:
     pd = None
 
 
-class PyarrowTable(ComputeFrameWork):
+class PyArrowTable(ComputeFrameWork):
     @staticmethod
     def is_available() -> bool:
         """Check if PyArrow is installed and available."""

mloda_plugins/compute_framework/base_implementations/python_dict/python_dict_filter_engine.py

@@ -45,11 +45,8 @@ class PythonDictFilterEngine(BaseFilterEngine):
         column_name = filter_feature.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}")
@@ -61,14 +58,10 @@ class PythonDictFilterEngine(BaseFilterEngine):
         column_name = filter_feature.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
@@ -94,11 +87,8 @@ class PythonDictFilterEngine(BaseFilterEngine):
                 ]
         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}")
@@ -112,11 +102,8 @@ class PythonDictFilterEngine(BaseFilterEngine):
         column_name = filter_feature.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}")
@@ -128,11 +115,8 @@ class PythonDictFilterEngine(BaseFilterEngine):
         column_name = filter_feature.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}")
@@ -151,11 +135,8 @@ class PythonDictFilterEngine(BaseFilterEngine):
         column_name = filter_feature.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/python_dict/python_dict_framework.py

@@ -82,7 +82,7 @@ class PythonDictFramework(ComputeFrameWork):
 
         transformed_data = self.apply_compute_framework_transformer(data)
         if transformed_data is not None:
-            return transformed_data  # type: ignore
+            return transformed_data  # type: ignore[no-any-return]
 
         if isinstance(data, dict):
             """Initial data: Transform columnar dict to row-based list of dicts"""

mloda_plugins/compute_framework/base_implementations/python_dict/python_dict_pyarrow_transformer.py

@@ -8,7 +8,7 @@ except ImportError:
     pa = None
 
 
-class PythonDictPyarrowTransformer(BaseTransformer):
+class PythonDictPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between PythonDict (List[Dict]) and PyArrow Table.
 

mloda_plugins/compute_framework/base_implementations/spark/spark_filter_engine.py

@@ -37,11 +37,8 @@ class SparkFilterEngine(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 +50,10 @@ class SparkFilterEngine(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 +75,8 @@ class SparkFilterEngine(BaseFilterEngine):
                 condition = F.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}")
@@ -102,11 +92,8 @@ class SparkFilterEngine(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}")
@@ -118,11 +105,8 @@ class SparkFilterEngine(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}")
@@ -135,11 +119,8 @@ class SparkFilterEngine(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/spark/spark_framework.py

@@ -119,14 +119,14 @@ class SparkFramework(ComputeFrameWork):
 
             # Handle empty dict
             if not data:
-                return spark.createDataFrame([], StructType([]))  # type: ignore
+                return spark.createDataFrame([], StructType([]))  # type: ignore[union-attr]
 
             # Infer schema from the first row of data
             first_key = next(iter(data.keys()))
             if not data[first_key]:  # Empty list
                 schema_fields = [StructField(col, StringType(), True) for col in data.keys()]
                 schema = StructType(schema_fields)
-                return spark.createDataFrame([], schema)  # type: ignore
+                return spark.createDataFrame([], schema)  # type: ignore[union-attr]
 
             # Create schema based on first values
             schema_fields = []
@@ -146,9 +146,9 @@ class SparkFramework(ComputeFrameWork):
                 for i in range(num_rows):
                     row = tuple(data[col][i] for col in data.keys())
                     rows.append(row)
-                return spark.createDataFrame(rows, schema)  # type: ignore
+                return spark.createDataFrame(rows, schema)  # type: ignore[union-attr]
             else:
-                return spark.createDataFrame([], schema)  # type: ignore
+                return spark.createDataFrame([], schema)  # type: ignore[union-attr]
 
         if hasattr(data, "__iter__") and not isinstance(data, (str, bytes, DataFrame)):
             """Added data: Add column to DataFrame"""

mloda_plugins/compute_framework/base_implementations/spark/spark_pyarrow_transformer.py

@@ -14,7 +14,7 @@ except ImportError:
     pa = None
 
 
-class SparkPyarrowTransformer(BaseTransformer):
+class SparkPyArrowTransformer(BaseTransformer):
     """
     Transformer for converting between Spark DataFrame and PyArrow Table.
 

mloda_plugins/config/feature/loader.py

@@ -14,7 +14,7 @@ from mloda_plugins.feature_group.experimental.default_options_key import Default
 
 
 def process_nested_features(options: Dict[str, Any]) -> Dict[str, Any]:
-    """Recursively convert nested mloda_source_features dicts to Feature objects.
+    """Recursively convert nested in_features dicts to Feature objects.
 
     Args:
         options: Dictionary of options that may contain nested feature definitions
@@ -24,11 +24,11 @@ def process_nested_features(options: Dict[str, Any]) -> Dict[str, Any]:
     """
     processed: Dict[str, Any] = {}
     for key, value in options.items():
-        if key == "mloda_source_features" and isinstance(value, dict):
+        if key == "in_features" and isinstance(value, dict):
             # This is a nested feature definition - convert it to a Feature object
             feature_name = value.get("name")
             if not feature_name:
-                raise ValueError(f"Nested mloda_source_features must have a 'name' field: {value}")
+                raise ValueError(f"Nested in_features must have a 'name' field: {value}")
 
             # Recursively process nested options
             nested_options = value.get("options", {})
@@ -39,17 +39,15 @@ def process_nested_features(options: Dict[str, Any]) -> Dict[str, Any]:
             if mloda_sources:
                 if isinstance(mloda_sources, list):
                     # For list, convert each to string (single sources) or keep as-is
-                    processed_nested_options["mloda_source_features"] = (
+                    processed_nested_options["in_features"] = (
                         mloda_sources if len(mloda_sources) > 1 else mloda_sources[0]
                     )
                 elif isinstance(mloda_sources, dict):
                     # Recursively create Feature for mloda_sources
-                    mloda_source_features = process_nested_features({"mloda_source_features": mloda_sources})[
-                        "mloda_source_features"
-                    ]
-                    processed_nested_options["mloda_source_features"] = mloda_source_features
+                    in_features = process_nested_features({"in_features": mloda_sources})["in_features"]
+                    processed_nested_options["in_features"] = in_features
                 else:
-                    processed_nested_options["mloda_source_features"] = mloda_sources
+                    processed_nested_options["in_features"] = mloda_sources
 
             # Create the Feature object
             processed[key] = Feature(name=feature_name, options=processed_nested_options)
@@ -104,7 +102,7 @@ def load_features_from_config(config_str: str, format: str = "json") -> List[Uni
                 # Handle mloda_sources if present
                 if item.mloda_sources:
                     # Always convert to frozenset for consistency
-                    context[DefaultOptionKeys.mloda_source_features] = frozenset(item.mloda_sources)
+                    context[DefaultOptionKeys.in_features] = frozenset(item.mloda_sources)
                 options = Options(group=item.group_options or {}, context=context)
                 feature = Feature(name=feature_name, options=options)
                 features.append(feature)
@@ -115,9 +113,7 @@ def load_features_from_config(config_str: str, format: str = "json") -> List[Uni
                 processed_options = process_nested_features(item.options)
                 # Always convert to frozenset for consistency (even single items)
                 source_value = frozenset(item.mloda_sources)
-                options = Options(
-                    group=processed_options, context={DefaultOptionKeys.mloda_source_features: source_value}
-                )
+                options = Options(group=processed_options, context={DefaultOptionKeys.in_features: source_value})
                 feature = Feature(name=feature_name, options=options)
                 features.append(feature)
                 feature_registry[feature_name] = feature
@@ -133,16 +129,14 @@ def load_features_from_config(config_str: str, format: str = "json") -> List[Uni
     # Pass 2: Resolve @feature_name references to Feature objects
     for feat in features:
         if isinstance(feat, Feature):
-            mloda_source = feat.options.context.get(DefaultOptionKeys.mloda_source_features)
+            mloda_source = feat.options.context.get(DefaultOptionKeys.in_features)
             if mloda_source:
                 # Handle both single string and frozenset of strings
                 if isinstance(mloda_source, str) and mloda_source.startswith("@"):
                     # Single reference string
                     referenced_name = mloda_source[1:]
                     if referenced_name in feature_registry:
-                        feat.options.context[DefaultOptionKeys.mloda_source_features] = feature_registry[
-                            referenced_name
-                        ]
+                        feat.options.context[DefaultOptionKeys.in_features] = feature_registry[referenced_name]
                     else:
                         raise ValueError(f"Feature reference '@{referenced_name}' not found in configuration")
                 elif isinstance(mloda_source, frozenset):
@@ -159,6 +153,6 @@ def load_features_from_config(config_str: str, format: str = "json") -> List[Uni
                             resolved_sources.append(source)
                     # Only replace if we actually resolved any references
                     if any(isinstance(s, str) and s.startswith("@") for s in mloda_source):
-                        feat.options.context[DefaultOptionKeys.mloda_source_features] = frozenset(resolved_sources)
+                        feat.options.context[DefaultOptionKeys.in_features] = frozenset(resolved_sources)
 
     return features

mloda_plugins/feature_group/experimental/aggregated_feature_group/base.py

@@ -4,6 +4,7 @@ Base implementation for aggregated feature groups.
 
 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
@@ -40,7 +41,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
 
     ### 1. String-Based Creation
 
-    Features follow the naming pattern: `{mloda_source_features}__{aggregation_type}_aggr`
+    Features follow the naming pattern: `{in_features}__{aggregation_type}_aggr`
 
     Examples:
     ```python
@@ -62,7 +63,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         options=Options(
             context={
                 AggregatedFeatureGroup.AGGREGATION_TYPE: "sum",
-                DefaultOptionKeys.mloda_source_features: "sales",
+                DefaultOptionKeys.in_features: "sales",
             }
         )
     )
@@ -73,7 +74,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
     ### Context Parameters (Default)
     These parameters don't affect Feature Group resolution/splitting:
     - `aggregation_type`: The type of aggregation to perform
-    - `mloda_source_features`: The source feature to aggregate
+    - `in_features`: The source feature to aggregate
 
     ### Group Parameters
     Currently none for AggregatedFeatureGroup. Parameters that affect Feature Group
@@ -96,7 +97,6 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         "median": "Median value",
     }
 
-    PATTERN = "__"
     PREFIX_PATTERN = r".*__([\w]+)_aggr$"
 
     # Property mapping for configuration-based feature creation
@@ -106,7 +106,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
             DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
             DefaultOptionKeys.mloda_strict_validation: True,  # Enable strict validation
         },
-        DefaultOptionKeys.mloda_source_features: {
+        DefaultOptionKeys.in_features: {
             "explanation": "Source feature to aggregate",
             DefaultOptionKeys.mloda_context: True,  # Mark as context parameter
             DefaultOptionKeys.mloda_strict_validation: False,  # Flexible validation
@@ -119,12 +119,12 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         source_feature: str | None = None
 
         # string based
-        _, source_feature = FeatureChainParser.parse_feature_name(feature_name, self.PATTERN, [self.PREFIX_PATTERN])
+        _, 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_source_features()
+        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}"
@@ -134,7 +134,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
     @classmethod
     def get_aggregation_type(cls, feature_name: str) -> str:
         """Extract the aggregation type from the feature name."""
-        prefix_part, _ = FeatureChainParser.parse_feature_name(feature_name, cls.PATTERN, [cls.PREFIX_PATTERN])
+        prefix_part, _ = FeatureChainParser.parse_feature_name(feature_name, [cls.PREFIX_PATTERN])
         if prefix_part is None:
             raise ValueError(f"Could not extract aggregation type from feature name: {feature_name}")
         return prefix_part
@@ -153,7 +153,6 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
             feature_name,
             options,
             property_mapping=cls.PROPERTY_MAPPING,
-            pattern=cls.PATTERN,
             prefix_patterns=[cls.PREFIX_PATTERN],
         )
 
@@ -178,13 +177,13 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
 
         # string based
         aggregation_type, source_feature_name = FeatureChainParser.parse_feature_name(
-            feature.name, cls.PATTERN, [cls.PREFIX_PATTERN]
+            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_source_features()
+        source_features = feature.options.get_in_features()
         source_feature = next(iter(source_features))
         source_feature_name = source_feature.get_name()
 
@@ -243,6 +242,7 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         return data
 
     @classmethod
+    @abstractmethod
     def _get_available_columns(cls, data: Any) -> Set[str]:
         """
         Get the set of available column names from the data.
@@ -253,9 +253,10 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         Returns:
             Set of column names available in the data
         """
-        raise NotImplementedError(f"_get_available_columns not implemented in {cls.__name__}")
+        ...
 
     @classmethod
+    @abstractmethod
     def _check_source_features_exist(cls, data: Any, feature_names: List[str]) -> None:
         """
         Check if the resolved source features exist in the data.
@@ -267,9 +268,10 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If none of the features exist in the data
         """
-        raise NotImplementedError(f"_check_source_features_exist not implemented in {cls.__name__}")
+        ...
 
     @classmethod
+    @abstractmethod
     def _add_result_to_data(cls, data: Any, feature_name: str, result: Any) -> Any:
         """
         Add the result to the data.
@@ -282,10 +284,11 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         Returns:
             The updated data
         """
-        raise NotImplementedError(f"_add_result_to_data not implemented in {cls.__name__}")
+        ...
 
     @classmethod
-    def _perform_aggregation(cls, data: Any, aggregation_type: str, mloda_source_features: List[str]) -> Any:
+    @abstractmethod
+    def _perform_aggregation(cls, data: Any, aggregation_type: str, in_features: List[str]) -> Any:
         """
         Method to perform the aggregation. Should be implemented by subclasses.
 
@@ -296,9 +299,9 @@ class AggregatedFeatureGroup(AbstractFeatureGroup):
         Args:
             data: The input data
             aggregation_type: The type of aggregation to perform
-            mloda_source_features: List of resolved source feature names to aggregate
+            in_features: List of resolved source feature names to aggregate
 
         Returns:
             The result of the aggregation
         """
-        raise NotImplementedError(f"_perform_aggregation not implemented in {cls.__name__}")
+        ...