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

{mloda_core → mloda/core}/core/step/transform_frame_work_step.py

@@ -1,24 +1,24 @@
 from typing import Any, Optional, Set, Type, Union
 from uuid import UUID, uuid4
 
-from mloda_core.abstract_plugins.components.framework_transformer.cfw_transformer import (
+from mloda.core.abstract_plugins.components.framework_transformer.cfw_transformer import (
     ComputeFrameworkTransformer,
 )
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.core.cfw_manager import CfwManager
-from mloda_core.core.step.abstract_step import Step
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.runtime.flight.flight_server import FlightServer
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.core.cfw_manager import CfwManager
+from mloda.core.core.step.abstract_step import Step
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.runtime.flight.flight_server import FlightServer
 
 
 class TransformFrameworkStep(Step):
     def __init__(
         self,
-        from_framework: Type[ComputeFrameWork],
-        to_framework: Type[ComputeFrameWork],
+        from_framework: Type[ComputeFramework],
+        to_framework: Type[ComputeFramework],
         required_uuids: Set[UUID],
-        from_feature_group: Type[AbstractFeatureGroup],
-        to_feature_group: Type[AbstractFeatureGroup],
+        from_feature_group: Type[FeatureGroup],
+        to_feature_group: Type[FeatureGroup],
         link_id: Optional[UUID] = None,
         right_framework_uuids: Set[UUID] = set(),
     ) -> None:
@@ -57,8 +57,8 @@ class TransformFrameworkStep(Step):
     def execute(
         self,
         cfw_register: CfwManager,
-        cfw: ComputeFrameWork,
-        from_cfw: Optional[Union[ComputeFrameWork, UUID]] = None,
+        cfw: ComputeFramework,
+        from_cfw: Optional[Union[ComputeFramework, UUID]] = None,
         data: Optional[Any] = None,
     ) -> Optional[Any]:
         self.location = cfw_register.get_location()
@@ -79,7 +79,7 @@ class TransformFrameworkStep(Step):
             return data
         return None
 
-    def get_column_names(self, cfw_register: CfwManager, from_cfw: Union[ComputeFrameWork, UUID]) -> Set[str]:
+    def get_column_names(self, cfw_register: CfwManager, from_cfw: Union[ComputeFramework, UUID]) -> Set[str]:
         if self.location and isinstance(from_cfw, UUID):
             return cfw_register.get_column_names(from_cfw)
 
@@ -88,7 +88,7 @@ class TransformFrameworkStep(Step):
 
         return from_cfw.get_column_names()
 
-    def get_data(self, cfw: Union[ComputeFrameWork, UUID]) -> Any:
+    def get_data(self, cfw: Union[ComputeFramework, UUID]) -> Any:
         """
         This method is used to get the data from the compute framework.
         If we are using multiprocessing, we use flightserver to transport the data.
@@ -104,10 +104,10 @@ class TransformFrameworkStep(Step):
 
         return cfw.get_data()
 
-    def set_data(self, cfw: ComputeFrameWork, data: Any) -> None:
+    def set_data(self, cfw: ComputeFramework, data: Any) -> None:
         cfw.set_data(data)
 
-    def transform(self, cfw: ComputeFrameWork, data: Any, feature_names: Set[str]) -> Any:
+    def transform(self, cfw: ComputeFramework, data: Any, feature_names: Set[str]) -> Any:
         if self.equal_frameworks():
             return data
 

{mloda_core → mloda/core}/filter/filter_engine.py

@@ -1,7 +1,7 @@
 from abc import ABC
 from typing import Any
 
-from mloda_core.filter.single_filter import SingleFilter
+from mloda.core.filter.single_filter import SingleFilter
 
 
 class BaseFilterEngine(ABC):

{mloda_core → mloda/core}/filter/filter_type_enum.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class FilterTypeEnum(Enum):
+class FilterType(Enum):
     min = "min"
     max = "max"
     equal = "equal"

{mloda_core → mloda/core}/filter/global_filter.py

@@ -2,14 +2,14 @@ from copy import deepcopy
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, Set, Tuple, Type, Union
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.domain import Domain
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.filter.filter_type_enum import FilterTypeEnum
-from mloda_core.filter.single_filter import SingleFilter
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.abstract_plugins.components.domain import Domain
+from mloda.core.abstract_plugins.components.feature_name import FeatureName
+from mloda.core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.components.data_access_collection import DataAccessCollection
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.filter.filter_type_enum import FilterType
+from mloda.core.filter.single_filter import SingleFilter
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
@@ -33,10 +33,10 @@ class GlobalFilter:
         and features in the context of a data processing pipeline.
         """
         self.filters: Set[SingleFilter] = set()
-        self.collection: Dict[Tuple[Type[AbstractFeatureGroup], FeatureName], Set[SingleFilter]] = {}
+        self.collection: Dict[Tuple[Type[FeatureGroup], FeatureName], Set[SingleFilter]] = {}
 
     def add_filter(
-        self, filter_feature: Union[Feature, str], filter_type: Union[str, FilterTypeEnum], parameter: Dict[str, Any]
+        self, filter_feature: Union[Feature, str], filter_type: Union[str, FilterType], parameter: Dict[str, Any]
     ) -> None:
         """
         Adds a `SingleFilter` to the `filters` set based on the provided feature, filter type, and parameters.
@@ -45,8 +45,8 @@ class GlobalFilter:
         - filter_feature: The feature or its name used for filtering. It can be a string or a `Feature` object.
             To identify if a filter is used, we need to check if the feature is part of the feature group.
             During this process, we enrich the filter feature with the options of the feature.
-        - filter_type: The type of filtering operation (e.g., equals, greater than). It can be a string or a `FilterTypeEnum`.
-            This filter_type does not need to match the FilterTypeEnum, but it should be a string that is meaningful in the concrete
+        - filter_type: The type of filtering operation (e.g., equals, greater than). It can be a string or a `FilterType`.
+            This filter_type does not need to match the FilterType, but it should be a string that is meaningful in the concrete
             Featuregroup implementation.
         - parameter: A dictionary of filter-specific options.
         """
@@ -55,7 +55,7 @@ class GlobalFilter:
 
     def add_filter_to_collection(
         self,
-        feature_group: Type[AbstractFeatureGroup],
+        feature_group: Type[FeatureGroup],
         filtered_feature_name: FeatureName,
         single_filter: SingleFilter,
     ) -> None:
@@ -69,7 +69,7 @@ class GlobalFilter:
 
     def identity_matched_filters(
         self,
-        feature_group: Type[AbstractFeatureGroup],
+        feature_group: Type[FeatureGroup],
         feat: Feature,
         data_access_collection: Optional[DataAccessCollection] = None,
     ) -> Set[SingleFilter]:
@@ -115,7 +115,7 @@ class GlobalFilter:
 
     def criteria(
         self,
-        feature_group: Type[AbstractFeatureGroup],
+        feature_group: Type[FeatureGroup],
         filter: SingleFilter,
         data_access_collection: Optional[DataAccessCollection] = None,
     ) -> bool:
@@ -124,7 +124,7 @@ class GlobalFilter:
         )
 
     def domain(
-        self, filter: SingleFilter, feature_domain: Union[None, Domain], feature_group: Type[AbstractFeatureGroup]
+        self, filter: SingleFilter, feature_domain: Union[None, Domain], feature_group: Type[FeatureGroup]
     ) -> bool:
         # We have matched already the feature group and the feature.
         # Thus, we take the feature group domain if the feature domain is not set.
@@ -176,8 +176,8 @@ class GlobalFilter:
         valid_from: Optional[datetime] = None,
         valid_to: Optional[datetime] = None,
         max_exclusive: bool = True,
-        time_filter_feature: Union[str, Feature] = DefaultOptionKeys.reference_time,
-        time_travel_filter_feature: Union[str, Feature] = "time_travel_filter",
+        event_time_column: Union[str, Feature] = DefaultOptionKeys.reference_time,
+        validity_time_column: Union[str, Feature] = DefaultOptionKeys.time_travel,
     ) -> None:
         """
         Adds time-based filters (`event_from`, `event_to`) and optionally time-travel filters (`valid_from`, `valid_to`).
@@ -197,21 +197,21 @@ class GlobalFilter:
         - valid_from (Optional[datetime]): Start of the validity period (optional, with timezone).
         - valid_to (Optional[datetime]): End of the validity period (optional, with timezone).
         - max_exclusive (bool): If True, the `event_to` and `valid_to` values are treated as exclusive.
-        - time_filter_feature: the feature description for the time filter. Default is DefaultOptionKeys.reference_time.
-        - time_travel_filter_feature: the feature description for the time travel filter. Default is "time_travel_filter".
+        - event_time_column: the column name for the event time filter. Default is DefaultOptionKeys.reference_time.
+        - validity_time_column: the column name for the validity time filter. Default is DefaultOptionKeys.time_travel.
 
         The `single_filters` created will be converted to UTC as ISO 8601 formatted strings to ensure consistency
         across time zones and avoid ambiguity when comparing or processing time-based data.
         """
 
-        self._add_range_filter(time_filter_feature, event_from, event_to, max_exclusive)
+        self._add_range_filter(event_time_column, event_from, event_to, max_exclusive)
 
         # validate that both valid_from and valid_to are provided together
         if (valid_from is not None and valid_to is None) or (valid_from is None and valid_to is not None):
             raise ValueError("Both `valid_from` and `valid_to` must be provided together, or neither should be.")
 
         if valid_from and valid_to:
-            self._add_range_filter(time_travel_filter_feature, valid_from, valid_to, max_exclusive)
+            self._add_range_filter(validity_time_column, valid_from, valid_to, max_exclusive)
 
     def _add_range_filter(
         self, filter_feature: Union[str, Feature], time_from: datetime, time_to: datetime, max_exclusive: bool
@@ -219,7 +219,7 @@ class GlobalFilter:
         _time_from = self._check_and_convert_time_info(time_from)
         _time_to = self._check_and_convert_time_info(time_to)
         self.add_filter(
-            filter_feature, FilterTypeEnum.range, {"min": _time_from, "max": _time_to, "max_exclusive": max_exclusive}
+            filter_feature, FilterType.range, {"min": _time_from, "max": _time_to, "max_exclusive": max_exclusive}
         )
 
     def _check_and_convert_time_info(self, time_with_tz: datetime) -> str:

{mloda_core → mloda/core}/filter/single_filter.py

@@ -2,8 +2,8 @@ from typing import Any, Dict, Union
 import uuid
 
 
-from mloda_core.filter.filter_type_enum import FilterTypeEnum
-from mloda_core.filter.filter_parameter import FilterParameterImpl
+from mloda.core.filter.filter_type_enum import FilterType
+from mloda.core.filter.filter_parameter import FilterParameterImpl
 
 
 class SingleFilter:
@@ -14,7 +14,7 @@ class SingleFilter:
     def __init__(
         self,
         filter_feature: Union[str, Any],  # Union[str, Feature]
-        filter_type: Union[str, FilterTypeEnum],
+        filter_type: Union[str, FilterType],
         parameter: Dict[str, Any],
     ) -> None:
         """
@@ -31,11 +31,11 @@ class SingleFilter:
 
         self.uuid = uuid.uuid4()
 
-    def handle_filter_type(self, filter_type: Union[str, FilterTypeEnum]) -> str:
+    def handle_filter_type(self, filter_type: Union[str, FilterType]) -> str:
         if not filter_type:
             raise ValueError(f"Filter type evaluates to false {filter_type}.")
 
-        if isinstance(filter_type, FilterTypeEnum):
+        if isinstance(filter_type, FilterType):
             return filter_type.value
         elif isinstance(filter_type, str):
             return filter_type
@@ -43,7 +43,7 @@ class SingleFilter:
         raise ValueError(f"Wrong type of Filter. {filter_type}")
 
     def handle_filter_feature(self, filter_feature: Union[str, Any]) -> Any:  # Union[str, Feature]
-        from mloda_core.abstract_plugins.components.feature import Feature
+        from mloda.core.abstract_plugins.components.feature import Feature
 
         if isinstance(filter_feature, Feature):
             return filter_feature

{mloda_core → mloda/core}/prepare/accessible_plugins.py

@@ -1,21 +1,20 @@
 from copy import deepcopy
 from typing import Optional, Set, Type
-from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
-from mloda_core.abstract_plugins.components.plugin_option.plugin_collector import PlugInCollector
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda.core.abstract_plugins.components.plugin_option.plugin_collector import PluginCollector
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.utils import get_all_subclasses
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.abstract_plugins.components.utils import get_all_subclasses
 
 
-FeatureGroupEnvironmentMapping = dict[Type[AbstractFeatureGroup], Set[Type[ComputeFrameWork]]]
+FeatureGroupEnvironmentMapping = dict[Type[FeatureGroup], Set[Type[ComputeFramework]]]
 
 
 class PreFilterPlugins:
     def __init__(
         self,
-        compute_frameworks: Set[Type[ComputeFrameWork]],
-        plugin_collector: Optional[PlugInCollector] = None,
+        compute_frameworks: Set[Type[ComputeFramework]],
+        plugin_collector: Optional[PluginCollector] = None,
     ) -> None:
         feature_groups = self._set_feature_groups(plugin_collector)
         compute_frameworks = self._set_compute_frameworks(compute_frameworks)
@@ -27,9 +26,7 @@ class PreFilterPlugins:
     def get_accessible_plugins(self) -> FeatureGroupEnvironmentMapping:
         return self.accessible_plugins
 
-    def _set_feature_groups(
-        self, plugin_collector: Optional[PlugInCollector] = None
-    ) -> Set[Type[AbstractFeatureGroup]]:
+    def _set_feature_groups(self, plugin_collector: Optional[PluginCollector] = None) -> Set[Type[FeatureGroup]]:
         accessible_feature_groups = self.get_featuregroup_subclasses()
 
         if plugin_collector:
@@ -43,12 +40,12 @@ class PreFilterPlugins:
 
     def _set_compute_frameworks(
         self,
-        compute_frameworks: Set[Type[ComputeFrameWork]],
-    ) -> Set[Type[ComputeFrameWork]]:
+        compute_frameworks: Set[Type[ComputeFramework]],
+    ) -> Set[Type[ComputeFramework]]:
         return compute_frameworks.intersection(self.get_cfw_subclasses())
 
     def resolve_feature_group_compute_framework_limitations(
-        self, feature_groups: Set[Type[AbstractFeatureGroup]], compute_frameworks: Set[Type[ComputeFrameWork]]
+        self, feature_groups: Set[Type[FeatureGroup]], compute_frameworks: Set[Type[ComputeFramework]]
     ) -> FeatureGroupEnvironmentMapping:
         accessible_plugins: FeatureGroupEnvironmentMapping = {}
         for feature_group in feature_groups:
@@ -62,11 +59,11 @@ class PreFilterPlugins:
         return accessible_plugins
 
     @staticmethod
-    def get_cfw_subclasses() -> Set[Type[ComputeFrameWork]]:
-        all_subclasses = get_all_subclasses(ComputeFrameWork)
+    def get_cfw_subclasses() -> Set[Type[ComputeFramework]]:
+        all_subclasses = get_all_subclasses(ComputeFramework)
         available_subclasses = {cls for cls in all_subclasses if cls.is_available()}
         return available_subclasses
 
     @staticmethod
-    def get_featuregroup_subclasses() -> Set[Type[AbstractFeatureGroup]]:
-        return get_all_subclasses(AbstractFeatureGroup)
+    def get_featuregroup_subclasses() -> Set[Type[FeatureGroup]]:
+        return get_all_subclasses(FeatureGroup)

{mloda_core → mloda/core}/prepare/execution_plan.py

@@ -2,27 +2,27 @@ from copy import copy, deepcopy
 from typing import Any, Generator, List, Optional, Set, Tuple, Type, Dict, Union
 from uuid import UUID
 
-from mloda_core.abstract_plugins.components.index.index import Index
+from mloda.core.abstract_plugins.components.index.index import Index
 
-from mloda_core.abstract_plugins.components.input_data.api.api_input_data_collection import (
+from mloda.core.abstract_plugins.components.input_data.api.api_input_data_collection import (
     ApiInputDataCollection,
 )
-from mloda_core.abstract_plugins.components.input_data.api.base_api_data import BaseApiData
-from mloda_core.abstract_plugins.components.input_data.api.api_input_data import ApiInputData
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.filter.global_filter import GlobalFilter
-from mloda_core.filter.single_filter import SingleFilter
-from mloda_core.prepare.joinstep_collection import JoinStepCollection
-from mloda_core.prepare.graph.graph import Graph
-from mloda_core.prepare.resolve_graph import PlannedQueue
-from mloda_core.prepare.resolve_links import LinkFrameworkTrekker, LinkTrekker
-from mloda_core.core.step.feature_group_step import FeatureGroupStep
-from mloda_core.core.step.join_step import JoinStep
-from mloda_core.core.step.transform_frame_work_step import TransformFrameworkStep
-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_set import FeatureSet
-from mloda_core.abstract_plugins.components.link import JoinType, Link
+from mloda.core.abstract_plugins.components.input_data.api.base_api_data import BaseApiData
+from mloda.core.abstract_plugins.components.input_data.api.api_input_data import ApiInputData
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.filter.global_filter import GlobalFilter
+from mloda.core.filter.single_filter import SingleFilter
+from mloda.core.prepare.joinstep_collection import JoinStepCollection
+from mloda.core.prepare.graph.graph import Graph
+from mloda.core.prepare.resolve_graph import PlannedQueue
+from mloda.core.prepare.resolve_links import LinkFrameworkTrekker, LinkTrekker
+from mloda.core.core.step.feature_group_step import FeatureGroupStep
+from mloda.core.core.step.join_step import JoinStep
+from mloda.core.core.step.transform_frame_work_step import TransformFrameworkStep
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.feature_set import FeatureSet
+from mloda.core.abstract_plugins.components.link import JoinType, Link
 from collections import defaultdict
 import logging
 
@@ -69,7 +69,7 @@ class ExecutionPlan:
                 pre_execution_plan.append(element)
                 continue
 
-            elif issubclass(element[0], AbstractFeatureGroup):
+            elif issubclass(element[0], FeatureGroup):
                 if not isinstance(element[1], set):
                     raise ValueError(f"Element {element} is not a valid element.")
 
@@ -481,7 +481,7 @@ class ExecutionPlan:
 
     def find_fg_per_uuid(
         self, pre_execution_plan: List[Union[LinkFrameworkTrekker, FeatureGroupStep]], uuid: UUID
-    ) -> Type[AbstractFeatureGroup]:
+    ) -> Type[FeatureGroup]:
         """
         This function finds the feature group per UUID in the pre_execution_plan.
 
@@ -587,7 +587,7 @@ class ExecutionPlan:
     def is_valid_join_step(
         self,
         link_fw: LinkFrameworkTrekker,
-        children_fw: type[ComputeFrameWork],
+        children_fw: type[ComputeFramework],
         children_uuid: UUID,
         graph: Graph,
     ) -> bool | Tuple[Set[UUID], Set[UUID]]:
@@ -676,7 +676,7 @@ class ExecutionPlan:
     def case_link_equal_feature_groups(
         self,
         link_fw: LinkFrameworkTrekker,
-        children_fw: type[ComputeFrameWork],
+        children_fw: type[ComputeFramework],
         children_uuid: UUID,
         graph: Graph,
     ) -> bool | Tuple[Set[UUID], Set[UUID]]:
@@ -724,8 +724,8 @@ class ExecutionPlan:
             if link_fw[1] != graph.nodes[uuid].feature.get_compute_framework():
                 continue
 
-            if link_fw[0].left_pointer is not None:
-                if not self.check_pointer(link_fw[0].left_pointer, link_fw, graph, uuid):
+            if link_fw[0].self_left_alias is not None:
+                if not self.check_pointer(link_fw[0].self_left_alias, link_fw, graph, uuid):
                     continue
 
             # loop over all other feature set collections
@@ -737,9 +737,9 @@ class ExecutionPlan:
                 if link_fw[2] != graph.nodes[_uuid].feature.get_compute_framework():
                     continue
 
-                if link_fw[0].right_pointer is not None:
+                if link_fw[0].self_right_alias is not None:
                     if not self.check_pointer(
-                        link_fw[0].right_pointer,
+                        link_fw[0].self_right_alias,
                         link_fw,
                         graph,
                         _uuid,
@@ -775,11 +775,11 @@ class ExecutionPlan:
     def check_pointer(
         self, pointer_dict: Dict[str, Any], link_fw: LinkFrameworkTrekker, graph: Graph, uuid: UUID
     ) -> bool:
-        if link_fw[0].right_pointer is None:
-            raise ValueError("This should not happen. If one pointer is set, the other should be set as well.")
+        if link_fw[0].self_right_alias is None:
+            raise ValueError("This should not happen. If one alias is set, the other should be set as well.")
 
-        if link_fw[0].left_pointer is None:
-            raise ValueError("This should not happen. If one pointer is set, the other should be set as well.")
+        if link_fw[0].self_left_alias is None:
+            raise ValueError("This should not happen. If one alias is set, the other should be set as well.")
 
         for k, v in graph.nodes[uuid].feature.options.items():
             for _k, _v in pointer_dict.items():
@@ -806,7 +806,7 @@ class ExecutionPlan:
 
     def run_feature_group(
         self,
-        feature_group_features: Tuple[Type[AbstractFeatureGroup], Set[Feature]],
+        feature_group_features: Tuple[Type[FeatureGroup], Set[Feature]],
         parent_to_children_mapping: Dict[UUID, Set[UUID]],
         pre_required_uuids: Set[UUID],
     ) -> Dict[int, FeatureGroupStep]:
@@ -853,7 +853,7 @@ class ExecutionPlan:
         return fg_steps
 
     def prepare_api_input_data(
-        self, feature_group: Type[AbstractFeatureGroup], feature_set: FeatureSet
+        self, feature_group: Type[FeatureGroup], feature_set: FeatureSet
     ) -> Union[bool, BaseApiData]:
         if not isinstance(feature_group.input_data(), ApiInputData):
             return False
@@ -879,15 +879,13 @@ class ExecutionPlan:
 
         return matching_cls_initialized
 
-    def add_artifact_to_feature_set(self, feature_group: Type[AbstractFeatureGroup], feature_set: FeatureSet) -> None:
+    def add_artifact_to_feature_set(self, feature_group: Type[FeatureGroup], feature_set: FeatureSet) -> None:
         if feature_group.artifact() is None:
             return
 
         feature_set.add_artifact_name()
 
-    def add_single_filters_to_feature_set(
-        self, feature_group: Type[AbstractFeatureGroup], feature_set: FeatureSet
-    ) -> None:
+    def add_single_filters_to_feature_set(self, feature_group: Type[FeatureGroup], feature_set: FeatureSet) -> None:
         if self.global_filter is None:
             return
 
@@ -957,11 +955,39 @@ class ExecutionPlan:
         return new_set
 
     def group_features_by_compute_framework_and_options(self, features: Set[Feature]) -> Dict[int, Set[Feature]]:
+        """Group features by compute framework, options, and data type.
+
+        Features with data_type=None are "lenient" - they join existing groups
+        with matching base properties (options + compute_frameworks).
+        This allows index columns (which have no explicit type) to stay grouped
+        with typed features from the same FeatureGroup.
+        """
         hash_collector: Dict[int, Set[Feature]] = defaultdict(set)
+        none_typed_features: list[Feature] = []
 
-        # get features with same compute framework and options
+        # First pass: group features with explicit data_type
         for feature in features:
-            f_hash = feature.has_similarity_properties()
-            hash_collector[f_hash].add(feature)
+            if feature.data_type is None:
+                none_typed_features.append(feature)
+            else:
+                f_hash = feature.has_similarity_properties()
+                hash_collector[f_hash].add(feature)
+
+        # Second pass: assign None-typed features to existing groups with matching base hash
+        for feature in none_typed_features:
+            base_hash = feature.base_similarity_properties()
+            assigned = False
+
+            # Find an existing group with matching base properties
+            for existing_hash, group in hash_collector.items():
+                any_feature = next(iter(group))
+                if any_feature.base_similarity_properties() == base_hash:
+                    hash_collector[existing_hash].add(feature)
+                    assigned = True
+                    break
+
+            if not assigned:
+                # No matching typed group found, create a new group for this None-typed feature
+                hash_collector[base_hash].add(feature)
 
         return hash_collector

{mloda_core → mloda/core}/prepare/graph/build_graph.py

@@ -1,16 +1,16 @@
 from typing import Dict, Set, Type
 from uuid import UUID
-from mloda_core.prepare.graph.graph import Graph
-from mloda_core.prepare.graph.properties import EdgeProperties, NodeProperties
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.feature import Feature
+from mloda.core.prepare.graph.graph import Graph
+from mloda.core.prepare.graph.properties import EdgeProperties, NodeProperties
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.abstract_plugins.components.feature import Feature
 
 
 class BuildGraph:
     def __init__(
         self,
         feature_link_parents: Dict[UUID, Set[UUID]],
-        feature_group_collection: Dict[Type[AbstractFeatureGroup], Set[Feature]],
+        feature_group_collection: Dict[Type[FeatureGroup], Set[Feature]],
     ) -> None:
         self._graph = Graph()
         self.feature_link_parents = feature_link_parents
@@ -29,7 +29,7 @@ class BuildGraph:
                 self.graph.add_edge(parent, child, self._create_edge_properties(parent, child))
 
     def _create_property_mapping(
-        self, feature_group_collection: Dict[Type[AbstractFeatureGroup], Set[Feature]]
+        self, feature_group_collection: Dict[Type[FeatureGroup], Set[Feature]]
     ) -> Dict[UUID, NodeProperties]:
         """
         Creates a flattened mapping of feature UUIDs to NodeProperties.

{mloda_core → mloda/core}/prepare/graph/graph.py

@@ -3,7 +3,7 @@ from copy import copy
 from typing import DefaultDict, Dict, List, Set
 from uuid import UUID
 
-from mloda_core.prepare.graph.properties import EdgeProperties, NodeProperties
+from mloda.core.prepare.graph.properties import EdgeProperties, NodeProperties
 
 
 class Graph:

{mloda_core → mloda/core}/prepare/graph/properties.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Type
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.feature_group import FeatureGroup
+from mloda.core.abstract_plugins.components.feature import Feature
 
 
 class NodeProperties:
-    def __init__(self, feature: Feature, feature_group_class: Type[AbstractFeatureGroup]) -> None:
+    def __init__(self, feature: Feature, feature_group_class: Type[FeatureGroup]) -> None:
         self.feature = feature
         self.feature_group_class = feature_group_class
         self.name = feature.name
@@ -19,8 +19,8 @@ class NodeProperties:
 class EdgeProperties:
     def __init__(
         self,
-        parent_feature_group_class: Type[AbstractFeatureGroup],
-        child_feature_group_class: Type[AbstractFeatureGroup],
+        parent_feature_group_class: Type[FeatureGroup],
+        child_feature_group_class: Type[FeatureGroup],
     ) -> None:
         self.parent_feature_group_class = parent_feature_group_class
         self.child_feature_group_class = child_feature_group_class