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

mloda/__init__.py

@@ -0,0 +1,17 @@
+from mloda.core.api.request import mlodaAPI as API
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.feature_group import FeatureGroup as FeatureGroup
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework as ComputeFramework
+
+# Module-level API alias and function for `import mloda; mloda.API(...)` pattern
+run_all = API.run_all
+
+__all__ = [
+    "API",
+    "run_all",
+    "Feature",
+    "Options",
+    "FeatureGroup",
+    "ComputeFramework",
+]

{mloda_core → mloda/core}/abstract_plugins/components/base_artifact.py

@@ -1,8 +1,8 @@
 from abc import ABC
 from typing import Any, Optional, final
 
-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_set import FeatureSet
+from mloda.core.abstract_plugins.components.options import Options
 
 
 class BaseArtifact(ABC):

{mloda_core → mloda/core}/abstract_plugins/components/base_validator.py

@@ -38,6 +38,19 @@ class BaseValidator(ABC):
 
     @abstractmethod
     def validate(self, data: Any) -> Optional[bool]:
+        """
+        Validate the given data against the validation rules.
+
+        Subclasses must implement this method with their specific validation logic.
+
+        Args:
+            data: The data to validate.
+
+        Returns:
+            None: No validation needed/not applicable (neutral - passes by default)
+            True: Validation explicitly passed
+            False: Validation failed
+        """
         pass
 
     def handle_log_level(self, _error: str, _exception: Exception) -> None:

{mloda_core → mloda/core}/abstract_plugins/components/data_access_collection.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Set
 
-from mloda_core.abstract_plugins.components.hashable_dict import HashableDict
+from mloda.core.abstract_plugins.components.hashable_dict import HashableDict
 
 
 class DataAccessCollection:

{mloda_core → mloda/core}/abstract_plugins/components/data_types.py

@@ -95,6 +95,45 @@ class DataType(Enum):
         else:
             raise ValueError(f"Unsupported DataType: {data_type}")
 
+    @classmethod
+    def from_arrow_type(cls, arrow_type: pa.DataType) -> "DataType":
+        """
+        Converts a PyArrow DataType to the custom DataType enum.
+
+        Args:
+            arrow_type (pa.DataType): The PyArrow DataType to convert.
+
+        Returns:
+            DataType: The corresponding DataType enum member.
+
+        Raises:
+            ValueError: If the arrow_type is not supported.
+        """
+        if pa.types.is_int32(arrow_type):
+            return cls.INT32
+        elif pa.types.is_int64(arrow_type):
+            return cls.INT64
+        elif pa.types.is_float32(arrow_type):
+            return cls.FLOAT
+        elif pa.types.is_float64(arrow_type):
+            return cls.DOUBLE
+        elif pa.types.is_boolean(arrow_type):
+            return cls.BOOLEAN
+        elif pa.types.is_string(arrow_type) or pa.types.is_large_string(arrow_type):
+            return cls.STRING
+        elif pa.types.is_binary(arrow_type) or pa.types.is_large_binary(arrow_type):
+            return cls.BINARY
+        elif pa.types.is_date32(arrow_type):
+            return cls.DATE
+        elif pa.types.is_timestamp(arrow_type):
+            if arrow_type.unit == "ms":
+                return cls.TIMESTAMP_MILLIS
+            elif arrow_type.unit == "us":
+                return cls.TIMESTAMP_MICROS
+        elif pa.types.is_decimal(arrow_type):
+            return cls.DECIMAL
+        raise ValueError(f"Unsupported PyArrow type: {arrow_type}")
+
     @classmethod
     def infer_arrow_type(cls, value: Any) -> pa.DataType:
         """

{mloda_core → mloda/core}/abstract_plugins/components/feature.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import copy
 from typing import Any, Dict, Optional, Set, Type, Union
 from uuid import UUID, uuid4
-from mloda_core.abstract_plugins.components.data_types import DataType
-
-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.index.index import Index
-from mloda_core.abstract_plugins.components.link import Link
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.abstract_plugins.components.utils import get_all_subclasses
+from mloda.core.abstract_plugins.components.data_types import DataType
+
+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.index.index import Index
+from mloda.core.abstract_plugins.components.link import Link
+from mloda.core.abstract_plugins.compute_framework import ComputeFramework
+from mloda.core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.components.utils import get_all_subclasses
+from mloda.core.abstract_plugins.components.validators.feature_validator import FeatureValidator
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
@@ -22,7 +23,7 @@ class Feature:
         name (FeatureName): The name of the feature.
         options (Options): The options associated with the feature.
         domain (Optional[Domain]): The domain of the feature.
-        compute_frameworks (Optional[Set[Type[ComputeFrameWork]]]): The compute frameworks supported by the feature.
+        compute_frameworks (Optional[Set[Type[ComputeFramework]]]): The compute frameworks supported by the feature.
         data_type (Optional[DataType]): The data type of the feature.
         initial_requested_data (bool): Whether the data was initially requested.
         link (Optional[Link]): The link associated with the feature.
@@ -163,9 +164,23 @@ class Feature:
         return hash((self.name, self.options, self.domain, compute_frameworks_hashable, self.data_type, child_options))
 
     def is_different_data_type(self, other: Feature) -> bool:
-        return self.name == other.options and self.data_type == other.data_type
+        return self.name == other.name and self.data_type != other.data_type
 
     def has_similarity_properties(self) -> int:
+        """Hash for grouping features by compute framework, options, and data type.
+
+        When data_type is None, it's excluded from the hash so None-typed features
+        can be grouped with any typed features (handled by grouping logic).
+        """
+        compute_frameworks_hashable = (
+            frozenset(self.compute_frameworks) if self.compute_frameworks is not None else None
+        )
+        if self.data_type is not None:
+            return hash((self.options, compute_frameworks_hashable, self.data_type))
+        return hash((self.options, compute_frameworks_hashable))
+
+    def base_similarity_properties(self) -> int:
+        """Base hash excluding data_type - used for lenient grouping of None-typed features."""
         compute_frameworks_hashable = (
             frozenset(self.compute_frameworks) if self.compute_frameworks is not None else None
         )
@@ -180,21 +195,15 @@ class Feature:
 
     def _set_compute_framework(
         self, compute_framework: Optional[str], compute_framework_options: Optional[str]
-    ) -> Optional[Type[ComputeFrameWork]]:
-        if compute_framework or compute_framework_options:
-            subclasses_compute_frameworks = get_all_subclasses(ComputeFrameWork)
-
-            if compute_framework:
-                for subclass in subclasses_compute_frameworks:
-                    if compute_framework == subclass.get_class_name():
-                        return subclass
-                raise ValueError(f"Compute framework via parameter {compute_framework} not found.")
-
-            elif compute_framework_options:
-                for subclass in subclasses_compute_frameworks:
-                    if compute_framework_options == subclass.get_class_name():
-                        return subclass
-                raise ValueError(f"Compute framework via options {compute_framework_options} not found.")
+    ) -> Optional[Type[ComputeFramework]]:
+        if compute_framework:
+            return FeatureValidator.validate_and_resolve_compute_framework(
+                compute_framework, get_all_subclasses(ComputeFramework), "parameter"
+            )
+        elif compute_framework_options:
+            return FeatureValidator.validate_and_resolve_compute_framework(
+                compute_framework_options, get_all_subclasses(ComputeFramework), "options"
+            )
         return None
 
     def _set_uuid(self, uuid: UUID) -> Feature:
@@ -202,17 +211,14 @@ class Feature:
         self.uuid = uuid
         return self
 
-    def _set_compute_frameworks(self, compute_frameworks: Set[Type[ComputeFrameWork]]) -> Feature:
+    def _set_compute_frameworks(self, compute_frameworks: Set[Type[ComputeFramework]]) -> Feature:
         # use only for testing
         self.compute_frameworks = compute_frameworks
         return self
 
-    def get_compute_framework(self) -> Type[ComputeFrameWork]:
-        if self.compute_frameworks is None:
-            raise ValueError(
-                f"Feature {self.name} does not have any compute framework. This function can only be called when the frameworks were resolved."
-            )
-
+    def get_compute_framework(self) -> Type[ComputeFramework]:
+        FeatureValidator.validate_compute_frameworks_resolved(self.compute_frameworks, str(self.name))
+        assert self.compute_frameworks is not None
         return next(iter(self.compute_frameworks))
 
     def get_name(self) -> str:

{mloda_core → mloda/core}/abstract_plugins/components/feature_chainer/feature_chain_parser.py

@@ -7,9 +7,9 @@ from __future__ import annotations
 import re
 from typing import Any, Dict, List, Optional, Set, Tuple
 
-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.options import Options
+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.options import Options
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 # Separator constants for feature name parsing
@@ -103,23 +103,23 @@ class FeatureChainParser:
     @classmethod
     def _has_default_value(cls, property_value: Any) -> bool:
         """Check if property has a default value defined."""
-        return isinstance(property_value, dict) and DefaultOptionKeys.mloda_default in property_value
+        return isinstance(property_value, dict) and DefaultOptionKeys.default in property_value
 
     @classmethod
     def _is_context_parameter(cls, property_value: Any) -> bool:
         """Check if property is marked as context parameter in mapping."""
-        return isinstance(property_value, dict) and property_value.get(DefaultOptionKeys.mloda_context, False)
+        return isinstance(property_value, dict) and property_value.get(DefaultOptionKeys.context, False)
 
     @classmethod
     def _is_strict_validation(cls, property_value: Any) -> bool:
         """Check if property requires strict validation (values must be in mapping)."""
-        return isinstance(property_value, dict) and property_value.get(DefaultOptionKeys.mloda_strict_validation, False)
+        return isinstance(property_value, dict) and property_value.get(DefaultOptionKeys.strict_validation, False)
 
     @classmethod
     def _get_validation_function(cls, property_value: Any) -> Any:
         """Get validation function from property mapping if present."""
         if isinstance(property_value, dict):
-            return property_value.get(DefaultOptionKeys.mloda_validation_function, None)
+            return property_value.get(DefaultOptionKeys.validation_function, None)
         return None
 
     @classmethod
@@ -174,13 +174,13 @@ class FeatureChainParser:
             )
 
         if property_name in options.group:
-            return DefaultOptionKeys.mloda_group.value
+            return DefaultOptionKeys.group.value
         elif property_name in options.context:
-            return DefaultOptionKeys.mloda_context.value
+            return DefaultOptionKeys.context.value
         elif cls._is_context_parameter(property_value):
-            return DefaultOptionKeys.mloda_context.value
+            return DefaultOptionKeys.context.value
         else:
-            return DefaultOptionKeys.mloda_group.value
+            return DefaultOptionKeys.group.value
 
     @classmethod
     def _extract_property_values(cls, property_value: Any) -> Any:
@@ -188,11 +188,11 @@ class FeatureChainParser:
         if isinstance(property_value, dict):
             # Remove metadata keys, keep only the actual valid values
             metadata_keys = {
-                DefaultOptionKeys.mloda_default,
-                DefaultOptionKeys.mloda_context,
-                DefaultOptionKeys.mloda_group,
-                DefaultOptionKeys.mloda_strict_validation,
-                DefaultOptionKeys.mloda_validation_function,
+                DefaultOptionKeys.default,
+                DefaultOptionKeys.context,
+                DefaultOptionKeys.group,
+                DefaultOptionKeys.strict_validation,
+                DefaultOptionKeys.validation_function,
             }
             return {k: v for k, v in property_value.items() if k not in metadata_keys}
         return property_value
@@ -312,16 +312,16 @@ class FeatureChainParser:
         return False
 
     @classmethod
-    def extract_source_feature(cls, feature_name: str, suffix_pattern: str) -> str:
+    def extract_in_feature(cls, feature_name: str, suffix_pattern: str) -> str:
         """
-        Extract the source feature from a feature name based on the suffix pattern.
+        Extract the in_feature from a feature name based on the suffix pattern.
 
         Args:
             feature_name: The feature name to parse
             suffix_pattern: Regex pattern for the suffix (e.g., r"^.+__([w]+)$")
 
         Returns:
-            The source feature part of the name
+            The in_feature part of the name
 
         Raises:
             ValueError: If the feature name doesn't match the expected pattern

mloda/core/abstract_plugins/components/feature_chainer/feature_chain_parser_mixin.py

@@ -0,0 +1,197 @@
+"""
+Mixin class providing default implementations for feature chain parsing.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Set, cast
+
+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.options import Options
+from mloda.core.abstract_plugins.components.feature_chainer.feature_chain_parser import (
+    FeatureChainParser,
+    CHAIN_SEPARATOR,
+    INPUT_SEPARATOR,
+)
+
+
+class FeatureChainParserMixin:
+    """
+    Mixin providing default implementations for feature chain parsing.
+
+    Subclasses should define:
+    - PREFIX_PATTERN or SUFFIX_PATTERN: Regex patterns for matching
+    - PROPERTY_MAPPING: Property validation mapping
+    - IN_FEATURE_SEPARATOR: Optional custom separator (default: "&")
+    - MIN_IN_FEATURES: Optional minimum in_feature count (default: 1)
+    - MAX_IN_FEATURES: Optional maximum in_feature count (default: None)
+    """
+
+    IN_FEATURE_SEPARATOR: str = INPUT_SEPARATOR
+    MIN_IN_FEATURES: int = 1
+    MAX_IN_FEATURES: Optional[int] = None
+
+    @classmethod
+    def _validate_string_match(cls, _feature_name: str, _operation_config: str, _in_feature: str) -> bool:
+        """
+        Hook for subclasses to provide custom validation for string-based matches.
+
+        Args:
+            _feature_name: The full feature name
+            _operation_config: The parsed operation configuration
+            _in_feature: The parsed in_feature
+
+        Returns:
+            True if the match is valid, False otherwise
+        """
+        return True
+
+    def input_features(self, options: Options, feature_name: FeatureName) -> Optional[Set[Feature]]:
+        """
+        Parse input features from feature name or options.
+
+        First attempts to parse in_features from the feature name string.
+        Falls back to options.get_in_features() if string parsing fails.
+
+        Args:
+            options: Options containing configuration
+            feature_name: Feature name to parse
+
+        Returns:
+            Set of Feature objects representing input features, or None
+
+        Raises:
+            ValueError: If in_feature constraints are violated
+        """
+        _feature_name = feature_name.name if isinstance(feature_name, FeatureName) else feature_name
+
+        prefix_patterns = self._get_prefix_patterns()
+        operation_config, in_feature = FeatureChainParser.parse_feature_name(
+            _feature_name, prefix_patterns, CHAIN_SEPARATOR
+        )
+
+        # String-based parsing succeeded
+        if operation_config is not None and in_feature is not None and in_feature:
+            in_features = in_feature.split(self.IN_FEATURE_SEPARATOR)
+            self._validate_in_feature_count(in_features, _feature_name)
+            return {Feature(f) for f in in_features}
+
+        # Configuration-based fallback using get_in_features()
+        in_features_set = options.get_in_features()
+        self._validate_in_feature_count(list(in_features_set), _feature_name)
+        return set(in_features_set)
+
+    def _validate_in_feature_count(self, in_features: List[Any], feature_name: str) -> None:
+        """
+        Validate that in_feature count meets min/max constraints.
+
+        Args:
+            in_features: List of in_features (strings or Feature objects)
+            feature_name: Original feature name for error messages
+
+        Raises:
+            ValueError: If constraints are violated
+        """
+        count = len(in_features)
+
+        if count < self.MIN_IN_FEATURES:
+            raise ValueError(
+                f"Feature '{feature_name}' requires at least {self.MIN_IN_FEATURES} in_feature(s), but found {count}"
+            )
+
+        if self.MAX_IN_FEATURES is not None and count > self.MAX_IN_FEATURES:
+            raise ValueError(
+                f"Feature '{feature_name}' allows at most {self.MAX_IN_FEATURES} in_feature(s), but found {count}"
+            )
+
+    @classmethod
+    def match_feature_group_criteria(
+        cls,
+        feature_name: str | FeatureName,
+        options: Options,
+        _data_access_collection: Any = None,
+    ) -> bool:
+        """
+        Match feature against criteria using pattern-based or config-based parsing.
+
+        Delegates to FeatureChainParser.match_configuration_feature_chain_parser() and
+        optionally calls _validate_string_match() hook for custom validation.
+
+        Args:
+            feature_name: Feature name to match
+            options: Options containing configuration
+            data_access_collection: Optional data access collection (unused)
+
+        Returns:
+            True if feature matches criteria, False otherwise
+        """
+        _feature_name = feature_name.name if isinstance(feature_name, FeatureName) else feature_name
+
+        prefix_patterns = cls._get_prefix_patterns()
+        property_mapping = cls._get_property_mapping()
+
+        # Use the unified parser for basic matching
+        result = FeatureChainParser.match_configuration_feature_chain_parser(
+            _feature_name,
+            options,
+            property_mapping=property_mapping,
+            prefix_patterns=prefix_patterns,
+        )
+
+        # If basic match succeeded and it's a string-based feature, call validation hook
+        if result:
+            operation_config, source_feature = FeatureChainParser.parse_feature_name(
+                _feature_name, prefix_patterns, CHAIN_SEPARATOR
+            )
+            if operation_config is not None and source_feature is not None:
+                if not cls._validate_string_match(_feature_name, operation_config, source_feature):
+                    return False
+
+        return result
+
+    @classmethod
+    def _get_prefix_patterns(cls) -> List[str]:
+        """Get prefix/suffix patterns from class attributes."""
+        patterns = []
+        if hasattr(cls, "PREFIX_PATTERN"):
+            patterns.append(cls.PREFIX_PATTERN)
+        if hasattr(cls, "SUFFIX_PATTERN"):
+            patterns.append(cls.SUFFIX_PATTERN)
+        return patterns
+
+    @classmethod
+    def _get_property_mapping(cls) -> Optional[Dict[str, Any]]:
+        """Get property mapping from class attribute."""
+        if hasattr(cls, "PROPERTY_MAPPING"):
+            return cast(Dict[str, Any], cls.PROPERTY_MAPPING)
+        return None
+
+    @classmethod
+    def _extract_source_features(cls, feature: Feature) -> List[str]:
+        """
+        Extract source features from a feature.
+
+        Tries string-based parsing first, falls back to configuration-based.
+        Uses class attributes IN_FEATURE_SEPARATOR and PREFIX_PATTERN.
+
+        Args:
+            feature: The feature to extract source features from
+
+        Returns:
+            List of source feature names
+        """
+        feature_name = feature.get_name()
+        prefix_patterns = cls._get_prefix_patterns()
+
+        operation_config, source_feature = FeatureChainParser.parse_feature_name(
+            feature_name, prefix_patterns, CHAIN_SEPARATOR
+        )
+
+        # String-based parsing succeeded
+        if operation_config is not None and source_feature is not None and source_feature:
+            return source_feature.split(cls.IN_FEATURE_SEPARATOR)
+
+        # Configuration-based fallback using get_in_features()
+        in_features_set = feature.options.get_in_features()
+        return [f.get_name() for f in in_features_set]

{mloda_core → mloda/core}/abstract_plugins/components/feature_collection.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import Generator, List, Optional, Set, Union
 from uuid import UUID
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.options import Options
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 
 
@@ -56,7 +56,7 @@ class Features:
 
         Protected keys are determined dynamically by reading:
         - in_features (always protected)
-        - Keys listed in feature_options.get(mloda_feature_chainer_parser_key)
+        - Keys listed in feature_options.get(feature_chainer_parser_key)
 
         Args:
             feature_options: Parent feature's options (will be updated)
@@ -67,8 +67,8 @@ class Features:
         """
         # Get protected keys dynamically from the feature options
         protected_keys = {DefaultOptionKeys.in_features}
-        if feature_options.get(DefaultOptionKeys.mloda_feature_chainer_parser_key):
-            protected_keys.update(feature_options.get(DefaultOptionKeys.mloda_feature_chainer_parser_key))
+        if feature_options.get(DefaultOptionKeys.feature_chainer_parser_key):
+            protected_keys.update(feature_options.get(DefaultOptionKeys.feature_chainer_parser_key))
 
         # Check for conflicts in non-protected keys only
         for key_child, value_child in child_options.items():
@@ -87,7 +87,7 @@ class Features:
                         )
 
         # Merge child options into parent, excluding protected keys
-        # update_with_protected_keys will read mloda_feature_chainer_parser_key dynamically
+        # update_with_protected_keys will read feature_chainer_parser_key dynamically
         feature_options.update_with_protected_keys(child_options)
 
     def check_duplicate_feature(self, feature: Feature) -> None:

{mloda_core → mloda/core}/abstract_plugins/components/feature_group_version.py

@@ -25,11 +25,11 @@ class FeatureGroupVersion(ABC):
         Returns a SHA-256 hash of the target class's source code.
         """
 
-        # Import AbstractFeatureGroup locally to avoid circular import.
-        from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
+        # Import FeatureGroup locally to avoid circular import.
+        from mloda.core.abstract_plugins.feature_group import FeatureGroup
 
-        if not issubclass(target_class, AbstractFeatureGroup):
-            raise ValueError(f"target_class must be a subclass of AbstractFeatureGroup: {target_class}")
+        if not issubclass(target_class, FeatureGroup):
+            raise ValueError(f"target_class must be a subclass of FeatureGroup: {target_class}")
 
         source = inspect.getsource(target_class)
         return hashlib.sha256(source.encode("utf-8")).hexdigest()
@@ -52,10 +52,10 @@ class FeatureGroupVersion(ABC):
           - a SHA-256 hash of the target class's source code.
         """
 
-        # Import AbstractFeatureGroup locally to avoid circular import.
-        from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
+        # Import FeatureGroup locally to avoid circular import.
+        from mloda.core.abstract_plugins.feature_group import FeatureGroup
 
-        if not issubclass(target_class, AbstractFeatureGroup):
-            raise ValueError(f"target_class must be a subclass of AbstractFeatureGroup: {target_class}")
+        if not issubclass(target_class, FeatureGroup):
+            raise ValueError(f"target_class must be a subclass of FeatureGroup: {target_class}")
 
         return f"{cls.mloda_version()}-{cls.module_name(target_class)}-{cls.class_source_hash(target_class)}"

{mloda_core → mloda/core}/abstract_plugins/components/feature_set.py

@@ -1,11 +1,12 @@
 from typing import Any, Optional, Set, Type
 from uuid import UUID
 
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.filter.filter_engine import BaseFilterEngine
-from mloda_core.filter.single_filter import SingleFilter
+from mloda.core.abstract_plugins.components.feature_name import FeatureName
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.options import Options
+from mloda.core.abstract_plugins.components.validators.feature_set_validator import FeatureSetValidator
+from mloda.core.filter.filter_engine import BaseFilterEngine
+from mloda.core.filter.single_filter import SingleFilter
 
 
 class FeatureSet:
@@ -22,8 +23,8 @@ class FeatureSet:
         self.filter_engine: Type[BaseFilterEngine] = BaseFilterEngine
 
     def add_artifact_name(self) -> None:
-        if self.options is None:
-            raise ValueError("No options set. Call this after adding a feature to ensure Options are initialized.")
+        FeatureSetValidator.validate_options_initialized(self.options, "add_artifact_name")
+        assert self.options is not None  # Type narrowing for mypy
 
         for feature_name in self.get_all_names():
             if feature_name in self.options.keys():
@@ -72,35 +73,28 @@ class FeatureSet:
             Prefer accessing options directly from individual features when possible.
             Only use this when you need to ensure all features share the same option value.
         """
-        if self.options is None:
-            raise ValueError("No options set. Call this after adding a feature to ensure Options are initialized.")
-        self.validate_equal_options()
+        FeatureSetValidator.validate_options_initialized(self.options, "get_options_key")
+        assert self.options is not None  # Type narrowing for mypy
+        FeatureSetValidator.validate_equal_options(self.features)
         return self.options.get(key)
 
     def validate_equal_options(self) -> None:
         """Checks if all features have the same options."""
-        _options = None
-        for feature in self.features:
-            if _options:
-                if _options != feature.options:
-                    raise ValueError("All features must have the same options.")
-            _options = feature.options
+        FeatureSetValidator.validate_equal_options(self.features)
 
     def get_initial_requested_features(self) -> Set[FeatureName]:
         return {feature.name for feature in self.features if feature.initial_requested_data}
 
     def get_name_of_one_feature(self) -> FeatureName:
-        if self.name_of_one_feature is None:
-            raise ValueError("No feature added yet. Add a feature before calling this method.")
+        FeatureSetValidator.validate_feature_added(
+            self.name_of_one_feature.name if self.name_of_one_feature else None, "get_name_of_one_feature"
+        )
+        assert self.name_of_one_feature is not None  # Type narrowing for mypy
         return self.name_of_one_feature
 
     def add_filters(self, single_filters: Set[SingleFilter]) -> None:
-        if self.filters is not None:
-            raise ValueError("Filters already set. This should be called once during setup of the feature set.")
-
-        if not isinstance(single_filters, Set):
-            raise ValueError("Filters should be a set.")
-
+        FeatureSetValidator.validate_filters_not_set(self.filters)
+        FeatureSetValidator.validate_filters_is_set_type(single_filters)
         self.filters = single_filters
 
     def get_artifact(self, config: Options) -> Any: