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

{mloda_core → mloda/core}/api/request.py

@@ -1,34 +1,36 @@
 from copy import deepcopy
 from typing import Any, Dict, List, Optional, Set, Type, Union
 
-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.plugin_option.plugin_collector import PlugInCollector
-from mloda_core.core.engine import Engine
-from mloda_core.api.prepare.setup_compute_framework import SetupComputeFramework
-from mloda_core.filter.global_filter import GlobalFilter
-from mloda_core.runtime.run import Runner
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.abstract_plugins.function_extender import WrapperFunctionExtender
-from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
-from mloda_core.abstract_plugins.components.parallelization_modes import ParallelizationModes
-from mloda_core.abstract_plugins.components.feature_collection import Features
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.link import Link
+from mloda.core.abstract_plugins.components.plugin_option.plugin_collector import PluginCollector
+from mloda.core.core.engine import Engine
+from mloda.core.api.prepare.setup_compute_framework import SetupComputeFramework
+from mloda.core.filter.global_filter import GlobalFilter
+from mloda.core.runtime.run import ExecutionOrchestrator
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.abstract_plugins.function_extender import Extender
+from mloda.core.abstract_plugins.components.data_access_collection import DataAccessCollection
+from mloda.core.abstract_plugins.components.parallelization_modes import ParallelizationMode
+from mloda.core.abstract_plugins.components.feature_collection import Features
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.link import Link
+from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
 class mlodaAPI:
     def __init__(
         self,
         requested_features: Union[Features, list[Union[Feature, str]]],
-        compute_frameworks: Union[Set[Type[ComputeFrameWork]], Optional[list[str]]] = None,
+        compute_frameworks: Union[Set[Type[ComputeFramework]], Optional[list[str]]] = None,
         links: Optional[Set[Link]] = None,
         data_access_collection: Optional[DataAccessCollection] = None,
         global_filter: Optional[GlobalFilter] = None,
         api_data: Optional[Dict[str, Dict[str, Any]]] = None,
-        plugin_collector: Optional[PlugInCollector] = None,
+        plugin_collector: Optional[PluginCollector] = None,
         copy_features: Optional[bool] = True,
+        strict_type_enforcement: bool = False,
     ) -> None:
         # The features object is potentially changed during the run, so we need to deepcopy it by default, so that follow up runs with the same object are not affected.
         # Set copy_features=False to disable deep copying for use cases where features contain non-copyable objects.
@@ -41,6 +43,7 @@ class mlodaAPI:
             for key_name, key_data in api_data.items():
                 api_input_data_collection.setup_key_class(key_name, list(key_data.keys()))
 
+        self.strict_type_enforcement = strict_type_enforcement
         self.features = self._process_features(_requested_features, api_input_data_collection)
         self.compute_framework = SetupComputeFramework(compute_frameworks, self.features).compute_frameworks
         self.links = links
@@ -50,7 +53,7 @@ class mlodaAPI:
         self.api_data = api_data
         self.plugin_collector = plugin_collector
 
-        self.runner: None | Runner = None
+        self.runner: None | ExecutionOrchestrator = None
         self.engine: None | Engine = None
 
         self.engine = self._create_engine()
@@ -66,22 +69,26 @@ class mlodaAPI:
         for feature in features:
             feature.initial_requested_data = True
             self._add_api_input_data(feature, api_input_data_collection)
+            # Propagate strict_type_enforcement to typed features only
+            if self.strict_type_enforcement and feature.data_type is not None:
+                feature.options.add(DefaultOptionKeys.strict_type_enforcement, True)
 
         return features
 
     @staticmethod
     def run_all(
         features: Union[Features, list[Union[Feature, str]]],
-        compute_frameworks: Union[Set[Type[ComputeFrameWork]], Optional[list[str]]] = None,
+        compute_frameworks: Union[Set[Type[ComputeFramework]], Optional[list[str]]] = None,
         links: Optional[Set[Link]] = None,
         data_access_collection: Optional[DataAccessCollection] = None,
-        parallelization_modes: Set[ParallelizationModes] = {ParallelizationModes.SYNC},
+        parallelization_modes: Set[ParallelizationMode] = {ParallelizationMode.SYNC},
         flight_server: Optional[Any] = None,
-        function_extender: Optional[Set[WrapperFunctionExtender]] = None,
+        function_extender: Optional[Set[Extender]] = None,
         global_filter: Optional[GlobalFilter] = None,
         api_data: Optional[Dict[str, Dict[str, Any]]] = None,
-        plugin_collector: Optional[PlugInCollector] = None,
+        plugin_collector: Optional[PluginCollector] = None,
         copy_features: Optional[bool] = True,
+        strict_type_enforcement: bool = False,
     ) -> List[Any]:
         """
         Run feature computation in one step.
@@ -99,6 +106,7 @@ class mlodaAPI:
                 Auto-creates ApiInputDataCollection internally.
             plugin_collector: Plugin collector.
             copy_features: Whether to deep copy features (default True).
+            strict_type_enforcement: If True, enforce strict type matching for typed features.
 
         Returns:
             List of computed results.
@@ -118,14 +126,15 @@ class mlodaAPI:
             api_data=api_data,
             plugin_collector=plugin_collector,
             copy_features=copy_features,
+            strict_type_enforcement=strict_type_enforcement,
         )
         return api._execute_batch_run(parallelization_modes, flight_server, function_extender)
 
     def _execute_batch_run(
         self,
-        parallelization_modes: Set[ParallelizationModes] = {ParallelizationModes.SYNC},
+        parallelization_modes: Set[ParallelizationMode] = {ParallelizationMode.SYNC},
         flight_server: Optional[Any] = None,
-        function_extender: Optional[Set[WrapperFunctionExtender]] = None,
+        function_extender: Optional[Set[Extender]] = None,
     ) -> List[Any]:
         """Encapsulates the batch run execution flow."""
         self._batch_run(parallelization_modes, flight_server, function_extender)
@@ -133,9 +142,9 @@ class mlodaAPI:
 
     def _batch_run(
         self,
-        parallelization_modes: Set[ParallelizationModes] = {ParallelizationModes.SYNC},
+        parallelization_modes: Set[ParallelizationMode] = {ParallelizationMode.SYNC},
         flight_server: Optional[Any] = None,
-        function_extender: Optional[Set[WrapperFunctionExtender]] = None,
+        function_extender: Optional[Set[Extender]] = None,
         api_data: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Sets up the engine runner and runs the engine computation."""
@@ -146,12 +155,12 @@ class mlodaAPI:
 
     def _run_engine_computation(
         self,
-        parallelization_modes: Set[ParallelizationModes] = {ParallelizationModes.SYNC},
-        function_extender: Optional[Set[WrapperFunctionExtender]] = None,
+        parallelization_modes: Set[ParallelizationMode] = {ParallelizationMode.SYNC},
+        function_extender: Optional[Set[Extender]] = None,
         api_data: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Runs the engine computation within a context manager."""
-        if not isinstance(self.runner, Runner):
+        if not isinstance(self.runner, ExecutionOrchestrator):
             raise ValueError("You need to run setup_engine_runner beforehand.")
 
         try:
@@ -162,8 +171,8 @@ class mlodaAPI:
 
     def _enter_runner_context(
         self,
-        parallelization_modes: Set[ParallelizationModes],
-        function_extender: Optional[Set[WrapperFunctionExtender]],
+        parallelization_modes: Set[ParallelizationMode],
+        function_extender: Optional[Set[Extender]],
         api_data: Optional[Dict[str, Any]],
     ) -> None:
         """Enters the runner context."""
@@ -206,7 +215,7 @@ class mlodaAPI:
 
     def _setup_engine_runner(
         self,
-        parallelization_modes: Set[ParallelizationModes] = {ParallelizationModes.SYNC},
+        parallelization_modes: Set[ParallelizationMode] = {ParallelizationMode.SYNC},
         flight_server: Optional[Any] = None,
     ) -> None:
         """Sets up the engine runner based on parallelization mode."""
@@ -215,12 +224,12 @@ class mlodaAPI:
 
         self.runner = (
             self.engine.compute(flight_server)
-            if ParallelizationModes.MULTIPROCESSING in parallelization_modes
+            if ParallelizationMode.MULTIPROCESSING in parallelization_modes
             else self.engine.compute()
         )
 
-        if not isinstance(self.runner, Runner):
-            raise ValueError("Runner initialization failed.")
+        if not isinstance(self.runner, ExecutionOrchestrator):
+            raise ValueError("ExecutionOrchestrator initialization failed.")
 
     def get_result(self) -> List[Any]:
         if self.runner is None:

{mloda_core → mloda/core}/core/cfw_manager.py

@@ -2,9 +2,9 @@ from multiprocessing.managers import BaseManager
 from typing import Any, Dict, Optional, Set, Tuple, Type
 from uuid import UUID
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.abstract_plugins.function_extender import WrapperFunctionExtender
-from mloda_core.abstract_plugins.components.parallelization_modes import ParallelizationModes
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.abstract_plugins.function_extender import Extender
+from mloda.core.abstract_plugins.components.parallelization_modes import ParallelizationMode
 
 import logging
 
@@ -27,8 +27,8 @@ class CfwManager:
 
     def __init__(
         self,
-        parallelization_modes: Set[ParallelizationModes],
-        function_extender: Optional[Set[WrapperFunctionExtender]] = None,
+        parallelization_modes: Set[ParallelizationMode],
+        function_extender: Optional[Set[Extender]] = None,
     ) -> None:
         """
         Initializes the CfwManager.
@@ -147,7 +147,7 @@ class CfwManager:
             raise ValueError(f"UUID {uuid} already exists in compute_frameworks")
         self.compute_frameworks[uuid] = (cls_name, children_if_root)
 
-    def get_initialized_compute_framework_uuid(self, cf_class: Type[ComputeFrameWork], feature_uuid: UUID) -> UUID:
+    def get_initialized_compute_framework_uuid(self, cf_class: Type[ComputeFramework], feature_uuid: UUID) -> UUID:
         """
         Retrieves the UUID of an initialized Compute Framework.
 
@@ -173,7 +173,7 @@ class CfwManager:
         """Retrieves the location for multiprocessing."""
         return self.location
 
-    def get_parallelization_modes(self) -> Set[ParallelizationModes]:
+    def get_parallelization_modes(self) -> Set[ParallelizationMode]:
         """Retrieves the set of parallelization modes."""
         return self.parallelization_modes
 
@@ -199,7 +199,7 @@ class CfwManager:
         """Retrieves the dictionary of compute frameworks."""
         return self.compute_frameworks
 
-    def get_function_extender(self) -> Optional[Set[WrapperFunctionExtender]]:
+    def get_function_extender(self) -> Optional[Set[Extender]]:
         """Retrieves the optional set of function extenders."""
         return self.function_extender
 

{mloda_core → mloda/core}/core/engine.py

@@ -4,45 +4,45 @@ from typing import Dict, Optional, Set, Type
 from uuid import UUID
 import uuid
 
-from mloda_core.abstract_plugins.components.index.add_index_feature import create_index_feature
-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.index.add_index_feature import create_index_feature
+from mloda.core.abstract_plugins.components.index.index import Index
+from mloda.core.abstract_plugins.components.input_data.api.api_input_data_collection import (
     ApiInputDataCollection,
 )
-from mloda_core.abstract_plugins.components.plugin_option.plugin_collector import PlugInCollector
-from mloda_core.filter.global_filter import GlobalFilter
-from mloda_core.prepare.accessible_plugins import PreFilterPlugins
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
-from mloda_core.abstract_plugins.components.data_types import DataType
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.prepare.execution_plan import ExecutionPlan
-from mloda_core.prepare.graph.build_graph import BuildGraph
-from mloda_core.prepare.resolve_graph import ResolveGraph
-from mloda_core.runtime.run import Runner
-from mloda_core.prepare.identify_feature_group import IdentifyFeatureGroupClass
-from mloda_core.runtime.flight.runner_flight_server import ParallelRunnerFlightServer
-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_collection import Features
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.abstract_plugins.components.link import Link
-from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
+from mloda.core.abstract_plugins.components.plugin_option.plugin_collector import PluginCollector
+from mloda.core.filter.global_filter import GlobalFilter
+from mloda.core.prepare.accessible_plugins import PreFilterPlugins
+from mloda.core.abstract_plugins.components.feature_name import FeatureName
+from mloda.core.abstract_plugins.components.data_access_collection import DataAccessCollection
+from mloda.core.abstract_plugins.components.data_types import DataType
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.prepare.execution_plan import ExecutionPlan
+from mloda.core.prepare.graph.build_graph import BuildGraph
+from mloda.core.prepare.resolve_graph import ResolveGraph
+from mloda.core.runtime.run import ExecutionOrchestrator
+from mloda.core.prepare.identify_feature_group import IdentifyFeatureGroupClass
+from mloda.core.runtime.flight.runner_flight_server import ParallelRunnerFlightServer
+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_collection import Features
+from mloda.core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.components.link import Link
+from mloda.core.abstract_plugins.components.validators.link_validator import LinkValidator
 
 
 class Engine:
     def __init__(
         self,
         features: Features,
-        compute_frameworks: Set[Type[ComputeFrameWork]],
+        compute_frameworks: Set[Type[ComputeFramework]],
         links: Optional[Set[Link]],
         data_access_collection: Optional[DataAccessCollection] = None,
         global_filter: Optional[GlobalFilter] = None,
         api_input_data_collection: Optional[ApiInputDataCollection] = None,
-        plugin_collector: Optional[PlugInCollector] = None,
+        plugin_collector: Optional[PluginCollector] = None,
     ) -> None:
         # setup variables which track the primary sources and the compute platforms
-        self.feature_group_collection: Dict[Type[AbstractFeatureGroup], Set[Feature]] = defaultdict(set)
+        self.feature_group_collection: Dict[Type[FeatureGroup], Set[Feature]] = defaultdict(set)
 
         # use global filters
         self.global_filter = global_filter
@@ -53,7 +53,7 @@ class Engine:
         # get accessible feature groups and their compute platforms
         self.accessible_plugins = PreFilterPlugins(compute_frameworks, plugin_collector).get_accessible_plugins()
         # get links
-        Link.validate(links)
+        LinkValidator.validate_links(links)
         self.links = links
 
         # set api input collection if relevant
@@ -66,11 +66,11 @@ class Engine:
         self.data_access_collection = data_access_collection
         self.execution_planner = self.create_setup_execution_plan(features)
 
-    def compute(self, flight_server: Optional[ParallelRunnerFlightServer] = None) -> Runner:
-        runner = Runner(self.execution_planner, flight_server)
-        if isinstance(runner, Runner):
-            return runner
-        raise ValueError("Runner setup failed.")
+    def compute(self, flight_server: Optional[ParallelRunnerFlightServer] = None) -> ExecutionOrchestrator:
+        orchestrator = ExecutionOrchestrator(self.execution_planner, flight_server)
+        if isinstance(orchestrator, ExecutionOrchestrator):
+            return orchestrator
+        raise ValueError("ExecutionOrchestrator setup failed.")
 
     def create_setup_execution_plan(self, features: Features) -> ExecutionPlan:
         self.setup_features_recursion(features)
@@ -124,15 +124,15 @@ class Engine:
         if feature_group.index_columns():
             self._add_index_feature(feature_group_class, feature_group, feature, features)
 
-    def _set_feature_name(self, feature: Feature, feature_group: AbstractFeatureGroup) -> None:
+    def _set_feature_name(self, feature: Feature, feature_group: FeatureGroup) -> None:
         """Sets the feature name using the feature group's logic."""
         feature.name = feature_group.set_feature_name(feature.options, feature.name)
 
     def _set_compute_framework_and_data_type(
         self,
         feature: Feature,
-        compute_frameworks: Set[Type[ComputeFrameWork]],
-        feature_group_class: Type[AbstractFeatureGroup],
+        compute_frameworks: Set[Type[ComputeFramework]],
+        feature_group_class: Type[FeatureGroup],
     ) -> None:
         """Sets the compute framework and data type for the feature."""
         feature = self.set_compute_framework(feature, compute_frameworks)
@@ -140,7 +140,7 @@ class Engine:
 
     def _identify_feature_group_and_frameworks(
         self, feature: Feature
-    ) -> tuple[Type[AbstractFeatureGroup], Set[Type[ComputeFrameWork]]]:
+    ) -> tuple[Type[FeatureGroup], Set[Type[ComputeFramework]]]:
         """Identifies the feature group class and compute frameworks for a given feature."""
         identifier = IdentifyFeatureGroupClass(
             feature, self.accessible_plugins, self.links, self.data_access_collection
@@ -149,8 +149,8 @@ class Engine:
 
     def _add_index_feature(
         self,
-        feature_group_class: Type[AbstractFeatureGroup],
-        feature_group: AbstractFeatureGroup,
+        feature_group_class: Type[FeatureGroup],
+        feature_group: FeatureGroup,
         feature: Feature,
         features: Features,
     ) -> None:
@@ -166,8 +166,8 @@ class Engine:
 
     def _process_index_feature(
         self,
-        feature_group_class: Type[AbstractFeatureGroup],
-        feature_group: AbstractFeatureGroup,
+        feature_group_class: Type[FeatureGroup],
+        feature_group: FeatureGroup,
         feature: Feature,
         features: Features,
         index: Index,
@@ -185,8 +185,8 @@ class Engine:
 
     def _create_and_add_index_feature(
         self,
-        feature_group_class: Type[AbstractFeatureGroup],
-        feature_group: AbstractFeatureGroup,
+        feature_group_class: Type[FeatureGroup],
+        feature_group: FeatureGroup,
         feature: Feature,
         features: Features,
         index: Index,
@@ -197,8 +197,8 @@ class Engine:
 
     def _add_filter_feature(
         self,
-        feature_group_class: Type[AbstractFeatureGroup],
-        feature_group: AbstractFeatureGroup,
+        feature_group_class: Type[FeatureGroup],
+        feature_group: FeatureGroup,
         feature: Feature,
         features: Features,
     ) -> None:
@@ -230,7 +230,7 @@ class Engine:
 
     def add_feature_to_collection(
         self,
-        feature_group_class: Type[AbstractFeatureGroup],
+        feature_group_class: Type[FeatureGroup],
         feature: Feature,
         child_uuid: Optional[UUID],
         if_index_feature: bool = False,
@@ -265,7 +265,7 @@ class Engine:
             self.feature_link_parents[child_uuid].add(wanted_uuid)
 
     def _handle_input_features_recursion(
-        self, feature_group_class: Type[AbstractFeatureGroup], uuid: UUID, options: Options, feature_name: FeatureName
+        self, feature_group_class: Type[FeatureGroup], uuid: UUID, options: Options, feature_name: FeatureName
     ) -> None:
         """Handles recursion for input features of a feature group."""
         feature_group = feature_group_class()
@@ -284,7 +284,7 @@ class Engine:
             self.feature_link_parents[features.child_uuid] = features.parent_uuids
             self.setup_features_recursion(features)
 
-    def set_compute_framework(self, feature: Feature, compute_frameworks: Set[Type[ComputeFrameWork]]) -> Feature:
+    def set_compute_framework(self, feature: Feature, compute_frameworks: Set[Type[ComputeFramework]]) -> Feature:
         """
         This function leads to that the feature has always a compute framework set!
         """
@@ -297,7 +297,7 @@ class Engine:
             feature.compute_frameworks = compute_frameworks
         return feature
 
-    def set_data_type(self, feature: Feature, feature_group_class: Type[AbstractFeatureGroup]) -> Optional[DataType]:
+    def set_data_type(self, feature: Feature, feature_group_class: Type[FeatureGroup]) -> Optional[DataType]:
         fg_data_type = feature_group_class.return_data_type_rule(feature)
         if feature.data_type and fg_data_type:
             if feature.data_type != fg_data_type:

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

@@ -2,9 +2,9 @@ from abc import ABC, abstractmethod
 from typing import Any, Optional, Set, Union, final
 from uuid import UUID, uuid4
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.core.cfw_manager import CfwManager
-from mloda_core.abstract_plugins.components.parallelization_modes import ParallelizationModes
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.core.cfw_manager import CfwManager
+from mloda.core.abstract_plugins.components.parallelization_modes import ParallelizationMode
 
 
 class Step(ABC):
@@ -17,8 +17,8 @@ class Step(ABC):
     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]:
         """Define what executing this step involves."""
@@ -29,9 +29,9 @@ class Step(ABC):
         """Return result uuids of this step"""
         return set()
 
-    def get_parallelization_mode(self) -> Set[ParallelizationModes]:
+    def get_parallelization_mode(self) -> Set[ParallelizationMode]:
         # TODO: This is a placeholder. We will need to add this to feature group later.
-        return {ParallelizationModes.SYNC, ParallelizationModes.THREADING, ParallelizationModes.MULTIPROCESSING}
+        return {ParallelizationMode.SYNC, ParallelizationMode.THREADING, ParallelizationMode.MULTIPROCESSING}
 
     @final
     def get_result_uuid(self) -> UUID:

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

@@ -1,21 +1,21 @@
 from typing import Any, Optional, Set, Type, Union
 from uuid import UUID, uuid4
-from mloda_core.abstract_plugins.components.base_artifact import BaseArtifact
-from mloda_core.abstract_plugins.components.input_data.api.base_api_data import BaseApiData
-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.abstract_plugins.components.feature_set import FeatureSet
+from mloda.core.abstract_plugins.components.base_artifact import BaseArtifact
+from mloda.core.abstract_plugins.components.input_data.api.base_api_data import BaseApiData
+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.abstract_plugins.components.feature_set import FeatureSet
 
 
 class FeatureGroupStep(Step):
     def __init__(
         self,
-        feature_group: Type[AbstractFeatureGroup],
+        feature_group: Type[FeatureGroup],
         features: FeatureSet,
         required_uuids: Set[UUID],
-        compute_framework: Type[ComputeFrameWork],
+        compute_framework: Type[ComputeFramework],
         children_if_root: set[UUID] = set(),
         api_input_data: Union[BaseApiData, bool] = False,
     ) -> None:
@@ -41,8 +41,8 @@ class FeatureGroupStep(Step):
     def execute(
         self,
         cfw_register: CfwManager,
-        cfw: ComputeFrameWork,
-        from_cfw: Optional[Union[ComputeFrameWork, UUID]] = None,  # Not used in this implementation
+        cfw: ComputeFramework,
+        from_cfw: Optional[Union[ComputeFramework, UUID]] = None,  # Not used in this implementation
         data: Optional[Any] = None,
     ) -> Optional[Any]:
         self.location = cfw_register.get_location()
@@ -61,7 +61,7 @@ class FeatureGroupStep(Step):
             return data
         return None
 
-    def run_calculate_feature(self, cfw: ComputeFrameWork, data: Optional[Any] = None) -> Any:
+    def run_calculate_feature(self, cfw: ComputeFramework, data: Optional[Any] = None) -> Any:
         if self.feature_group.calculate_feature is None:
             raise ValueError("FeatureGroup calculate_feature is not implemented")
 

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

@@ -1,20 +1,20 @@
 from typing import Optional, Set, Type, Any, Union
 from uuid import UUID, uuid4
-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.abstract_plugins.components.framework_transformer.cfw_transformer import ComputeFrameworkTransformer
+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.components.link import Link
-from mloda_core.runtime.flight.flight_server import FlightServer
+from mloda.core.core.step.abstract_step import Step
+from mloda.core.abstract_plugins.components.link import Link
+from mloda.core.runtime.flight.flight_server import FlightServer
 
 
 class JoinStep(Step):
     def __init__(
         self,
         link: Link,
-        left_framework: Type[ComputeFrameWork],
-        right_framework: Type[ComputeFrameWork],
+        left_framework: Type[ComputeFramework],
+        right_framework: Type[ComputeFramework],
         required_uuids: Set[UUID],
         left_framework_uuids: Set[UUID],
         right_framework_uuids: Set[UUID],
@@ -31,7 +31,7 @@ class JoinStep(Step):
     def get_uuids(self) -> Set[UUID]:
         return {self.uuid, self.link.uuid}
 
-    def _merge_data(self, cfw: ComputeFrameWork, from_cfw_data: Any) -> None:
+    def _merge_data(self, cfw: ComputeFramework, from_cfw_data: Any) -> None:
         """Merges data from another ComputeFramework into the current one."""
         merge_engine_class = cfw.merge_engine()
         framework_connection = cfw.get_framework_connection_object()
@@ -42,7 +42,7 @@ class JoinStep(Step):
         )
         cfw.set_column_names()
 
-    def _upload_data_if_needed(self, cfw: ComputeFrameWork, cfw_register: CfwManager) -> None:
+    def _upload_data_if_needed(self, cfw: ComputeFramework, cfw_register: CfwManager) -> None:
         """Uploads the merged data to Flyway if a location is configured."""
         if self.location:
             if cfw_register.get_uuid_flyway_datasets(cfw.uuid):
@@ -51,8 +51,8 @@ class JoinStep(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()
@@ -69,7 +69,7 @@ class JoinStep(Step):
 
         return None
 
-    def get_data(self, from_cfw: Union[UUID, ComputeFrameWork], cfw: ComputeFrameWork) -> Any:
+    def get_data(self, from_cfw: Union[UUID, ComputeFramework], cfw: ComputeFramework) -> 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.
@@ -86,7 +86,7 @@ class JoinStep(Step):
             raise ValueError("From_cfw is a UUID, but we are not using flightserver.")
         return from_cfw.get_data(), from_cfw.uuid
 
-    def matched(self, other_framework: Type[ComputeFrameWork], uuid: UUID) -> Optional[UUID]:
+    def matched(self, other_framework: Type[ComputeFramework], uuid: UUID) -> Optional[UUID]:
         """
         If matched, return the uuid of the join step.
         """