mloda 0.4.4__tar.gz → 0.4.5__tar.gz

{mloda-0.4.4/mloda.egg-info → mloda-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mloda
-Version: 0.4.4
+Version: 0.4.5
 Summary: mloda.ai: Open Data Access for ML and AI
 Author-email: Tom Kaltofen <info@mloda.ai>
 License: Apache-2.0

mloda-0.4.5/mloda/core/abstract_plugins/components/domain.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from typing import Any
+
+
+class Domain:
+    """Represents a domain for isolating features across business contexts.
+
+    Domains enable data isolation between different contexts (Sales, Finance, Test, etc.).
+    The framework matches feature domains to feature group domains for resolution.
+
+    Definition:
+        - Feature: via `domain` parameter or `options={"domain": "..."}`
+        - FeatureGroup: via `get_domain()` classmethod (default: "default_domain")
+
+    Propagation:
+        When a parent feature has a domain, child features inherit it automatically.
+        You can override this by setting an explicit domain on each dependent feature.
+
+        +------------------------------------------+---------------+------------------+
+        | Child Definition                         | Parent Domain | Result           |
+        +------------------------------------------+---------------+------------------+
+        | "child" (string)                         | "Sales"       | Inherits "Sales" |
+        | Feature("child")                         | "Sales"       | Inherits "Sales" |
+        | Feature("child", domain="Finance")       | "Sales"       | Keeps "Finance"  |
+        | Any                                      | None          | No domain        |
+        +------------------------------------------+---------------+------------------+
+
+    Validation:
+        IdentifyFeatureGroupClass ensures at least one feature group matches the feature's domain.
+        If a feature has no domain and multiple groups match, an error is raised.
+    """
+
+    def __init__(self, name: str):
+        self.name = name
+
+    @classmethod
+    def get_default_domain(cls) -> Domain:
+        """
+        No specified domain leads to default domain.
+        """
+        return Domain("default_domain")
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Domain):
+            raise ValueError(f"Cannot compare Domain with {type(other)}")
+        return self.name == other.name
+
+    def __hash__(self) -> int:
+        return hash(self.name)

{mloda-0.4.4 → mloda-0.4.5}/mloda/core/abstract_plugins/components/feature_chainer/feature_chain_parser.py

@@ -92,11 +92,8 @@ class FeatureChainParser:
         """Internal method for matching pattern-based features - used by match_configuration_feature_chain_parser."""
         _feature_name: FeatureName = FeatureName(feature_name) if isinstance(feature_name, str) else feature_name
 
-        try:
-            has_prefix_configuration, source_feature = cls.parse_feature_name(_feature_name, prefix_patterns, pattern)
-            if has_prefix_configuration is None or source_feature is None:
-                return False
-        except ValueError:
+        has_prefix_configuration, source_feature = cls.parse_feature_name(_feature_name, prefix_patterns, pattern)
+        if has_prefix_configuration is None or source_feature is None:
             return False
         return True
 
@@ -304,7 +301,6 @@ class FeatureChainParser:
                 return True
 
         # configuration-based
-
         if property_mapping is not None:
             return cls._validate_options_against_property_mapping(options, property_mapping)
 

{mloda-0.4.4 → mloda-0.4.5}/mloda/core/abstract_plugins/components/feature_chainer/feature_chain_parser_mixin.py

@@ -131,13 +131,16 @@ class FeatureChainParserMixin:
         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,
-        )
+        try:
+            # 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,
+            )
+        except ValueError:
+            return False
 
         # If basic match succeeded and it's a string-based feature, call validation hook
         if result:

{mloda-0.4.4 → mloda-0.4.5}/mloda/core/abstract_plugins/components/feature_collection.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Generator, List, Optional, Set, Union
 from uuid import UUID
+from mloda.core.abstract_plugins.components.domain import Domain
 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
@@ -17,9 +18,11 @@ class Features:
         features: List[Union[Feature, str]],
         child_options: Optional[Options] = None,
         child_uuid: Optional[UUID] = None,
+        parent_domain: Optional[str] = None,
     ) -> None:
         self.collection: List[Feature] = []
         self.child_uuid: Optional[UUID] = child_uuid
+        self.parent_domain: Optional[str] = parent_domain
 
         self.parent_uuids: set[UUID] = set()
 
@@ -36,7 +39,11 @@ class Features:
             if child_options.group == {} and child_options.context == {}:
                 child_options = Options({})
 
-            feature = Feature(name=feature, options=child_options) if isinstance(feature, str) else feature
+            if isinstance(feature, str):
+                feature = Feature(name=feature, options=child_options, domain=self.parent_domain)
+            else:
+                if feature.domain is None and self.parent_domain is not None:
+                    feature.domain = Domain(self.parent_domain)
             if child_uuid:
                 self.parent_uuids.add(feature.uuid)
                 self.child_uuid = child_uuid

{mloda-0.4.4 → mloda-0.4.5}/mloda/core/core/engine.py

@@ -116,7 +116,10 @@ class Engine:
         added = self.add_feature_to_collection(feature_group_class, feature, features.child_uuid)
 
         if added:
-            self._handle_input_features_recursion(feature_group_class, feature.uuid, feature.options, feature.name)
+            parent_domain = feature.domain.name if feature.domain else None
+            self._handle_input_features_recursion(
+                feature_group_class, feature.uuid, feature.options, feature.name, parent_domain=parent_domain
+            )
 
         if self.global_filter:
             self._add_filter_feature(feature_group_class, feature_group, feature, features)
@@ -265,7 +268,12 @@ class Engine:
             self.feature_link_parents[child_uuid].add(wanted_uuid)
 
     def _handle_input_features_recursion(
-        self, feature_group_class: Type[FeatureGroup], uuid: UUID, options: Options, feature_name: FeatureName
+        self,
+        feature_group_class: Type[FeatureGroup],
+        uuid: UUID,
+        options: Options,
+        feature_name: FeatureName,
+        parent_domain: Optional[str] = None,
     ) -> None:
         """Handles recursion for input features of a feature group."""
         feature_group = feature_group_class()
@@ -278,7 +286,9 @@ class Engine:
             input_features = None
 
         if input_features:
-            features = Features(list(input_features), child_options=options, child_uuid=uuid)
+            features = Features(
+                list(input_features), child_options=options, child_uuid=uuid, parent_domain=parent_domain
+            )
             if features.child_uuid is None:
                 raise ValueError(f"Features {features} has no parent uuid although it should have one.")
             self.feature_link_parents[features.child_uuid] = features.parent_uuids

{mloda-0.4.4 → mloda-0.4.5/mloda.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mloda
-Version: 0.4.4
+Version: 0.4.5
 Summary: mloda.ai: Open Data Access for ML and AI
 Author-email: Tom Kaltofen <info@mloda.ai>
 License: Apache-2.0

{mloda-0.4.4 → mloda-0.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mloda"
-version = "0.4.4"
+version = "0.4.5"
 description = "mloda.ai: Open Data Access for ML and AI"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "Apache-2.0" }

mloda-0.4.4/mloda/core/abstract_plugins/components/domain.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-
-class Domain:
-    """
-    Documentation domain:
-
-    default value is default_domain. The purpose of this is to allow for a default domain to be used if no domain is given.
-    Usecase: Testing, POCS etc. This is a tool to make life easier for the user.
-
-    can be defined by:
-    feature.domain: either by options or by domain
-    feature_group.domain: returns the domain name rule for the feature group
-
-    We validate in IdentifyFeatureGroupClass that there is atleast one feature group with the same domain as the feature.
-    If the feature does not have a domain, and we have not exactly one matching feature group to the feature, we raise an error.
-    """
-
-    def __init__(self, name: str):
-        self.name = name
-
-    @classmethod
-    def get_default_domain(cls) -> Domain:
-        """
-        No specified domain leads to default domain.
-        """
-        return Domain("default_domain")
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Domain):
-            raise ValueError(f"Cannot compare Domain with {type(other)}")
-        return self.name == other.name
-
-    def __hash__(self) -> int:
-        return hash(self.name)