tiferet 1.0.0a19__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

tiferet/data/feature.py

@@ -4,8 +4,9 @@
 from schematics.types.serializable import serializable
 
 # 
-from ..domain import *
-from ..domain.feature import Feature, FeatureCommand
+from ..data import DataObject
+from ..contracts.feature import Feature as FeatureContract, FeatureCommand as FeatureCommandContract
+from ..models.feature import *
 
 
 class FeatureCommandData(FeatureCommand, DataObject):
@@ -23,11 +24,22 @@ class FeatureCommandData(FeatureCommand, DataObject):
 
         # Define the roles for the feature handler data.
         roles = {
-            'to_model': DataObject.allow(),
+            'to_model': DataObject.deny('parameters'),
             'to_data': DataObject.allow()
         }
 
-    def map(self, role: str = 'to_model', **kwargs) -> FeatureCommand:
+    # * attributes
+    parameters = DictType(
+        StringType(),
+        default={},
+        serialized_name='params',
+        deserialize_from=['params', 'parameters'],
+        metadata=dict(
+            description='The parameters for the feature.'
+        )
+    )
+
+    def map(self, role: str = 'to_model', **kwargs) -> FeatureCommandContract:
         '''
         Maps the feature handler data to a feature handler object.
         
@@ -38,7 +50,10 @@ class FeatureCommandData(FeatureCommand, DataObject):
         :return: A new feature handler object.
         :rtype: f.FeatureCommand
         '''
-        return super().map(FeatureCommand, role, **kwargs)
+        return super().map(FeatureCommand, 
+            role, 
+            parameters=self.parameters,
+            **kwargs)
 
 
 class FeatureData(Feature, DataObject):
@@ -59,8 +74,9 @@ class FeatureData(Feature, DataObject):
             'to_model': DataObject.deny('feature_key'),
             'to_data': DataObject.deny('feature_key', 'group_id', 'id')
         }
-
-    commands = t.ListType(t.ModelType(FeatureCommandData),
+    
+    # * attributes
+    commands = ListType(ModelType(FeatureCommandData),
                           deserialize_from=['handlers', 'functions', 'commands'],)
     
     @serializable
@@ -72,7 +88,7 @@ class FeatureData(Feature, DataObject):
         # Return the feature key.
         return self.id.split('.')[-1]
 
-    def map(self, role: str = 'to_model', **kwargs) -> Feature:
+    def map(self, role: str = 'to_model', **kwargs) -> FeatureContract:
         '''
         Maps the feature data to a feature object.
 
@@ -87,6 +103,9 @@ class FeatureData(Feature, DataObject):
         # Map the feature data to a feature object.
         return super().map(Feature, role, 
             feature_key=self.feature_key,
+            commands=[
+                command.map(role, **kwargs) for command in self.commands
+            ],
             **kwargs
         )
 

tiferet/{domain/core.py → data/settings.py}

@@ -3,82 +3,23 @@
 # ** core
 from typing import Any
 
-# ** infra
-from schematics import Model
-
 # ** app
-from ..configs import *
-
-
-# *** models
-
-# ** model: model_object
-class ModelObject(Model):
-    '''
-    A domain model object.
-    '''
-
-    # * method: new
-    @staticmethod
-    def new(
-        model_type: type,
-        validate: bool = True,
-        strict: bool = True,
-        **kwargs
-    ) -> Any:
-        '''
-        Initializes a new model object.
-
-        :param model_type: The type of model object to create.
-        :type model_type: type
-        :param validate: True to validate the model object.
-        :type validate: bool
-        :param strict: True to enforce strict mode for the model object.
-        :type strict: bool
-        :param kwargs: Keyword arguments.
-        :type kwargs: dict
-        :return: A new model object.
-        :rtype: Any
-        '''
-
-        # Create a new model object.
-        _object = model_type(dict(
-            **kwargs
-        ), strict=strict)
-
-        # Validate if specified.
-        if validate:
-            _object.validate()
+from ..contracts.settings import ModelContract
+from ..models.settings import *
 
-        # Return the new model object.
-        return _object
 
+# *** constants
 
-# ** model: entity
-class Entity(ModelObject):
-    '''
-    A domain model entity.
-    '''
+# ** constant: default_module_path
+DEFAULT_MODULE_PATH = 'tiferet.contexts.app'
 
-    # ** attribute: id
-    id = StringType(
-        required=True,
-        metadata=dict(
-            description='The entity unique identifier.'
-        )
-    )
+# ** constant: default_class_name
+DEFAULT_CLASS_NAME = 'AppInterfaceContext'
 
 
-# ** model: value_object
-class ValueObject(ModelObject):
-    '''
-    A domain model value object.
-    '''
-
-    pass
-
+# *** classes
 
-# ** model: data_object
+# ** class: data_object
 class DataObject(Model):
     '''
     A data representation object.
@@ -90,7 +31,7 @@ class DataObject(Model):
             role: str = 'to_model',
             validate: bool = True,
             **kwargs
-            ) -> ModelObject:
+            ) -> ModelContract:
         '''
         Maps the model data to a model object.
 
@@ -102,8 +43,8 @@ class DataObject(Model):
         :type validate: bool
         :param kwargs: Additional keyword arguments for mapping.
         :type kwargs: dict
-        :return: A new model object.
-        :rtype: ModelObject
+        :return: A new model object as a contract.
+        :rtype: ModelContract
         '''
 
         # Get primitive of the model data and merge with the keyword arguments.
@@ -113,7 +54,12 @@ class DataObject(Model):
             _data[key] = value
 
         # Map the data object to a model object.
-        _object = type.new(**_data, strict=False)
+        # Attempt to create a new model object with a custom factory method.
+        # If the factory method does not exist, employ the standard method.
+        try:
+            _object = type.new(**_data, strict=False)
+        except Exception:
+            _object = ModelObject.new(type, **_data, strict=False)
 
         # Validate if specified.
         if validate:
@@ -158,6 +104,7 @@ class DataObject(Model):
         # Return the data object.
         return obj
 
+    # ** method: from_data
     @staticmethod
     def from_data(
         data: type,
@@ -179,6 +126,14 @@ class DataObject(Model):
     # ** method: allow
     @staticmethod
     def allow(*args) -> Any:
+        '''
+        Creates a whitelist transform for data mapping.
+
+        :param args: Fields to allow in the transform.
+        :type args: tuple
+        :return: The whitelist transform.
+        :rtype: Any
+        '''
 
         # Create a whitelist transform.
         # Create a wholelist transform if no arguments are specified.
@@ -190,30 +145,15 @@ class DataObject(Model):
     # ** method: deny
     @staticmethod
     def deny(*args) -> Any:
+        '''
+        Creates a blacklist transform for data mapping.
+
+        :param args: Fields to deny in the transform.
+        :type args: tuple
+        :return: The blacklist transform.
+        :rtype: Any
+        '''
 
         # Create a blacklist transform.
         from schematics.transforms import blacklist
-        return blacklist(*args)
-
-
-# ** model: module_dependency
-class ModuleDependency(ValueObject):
-    '''
-    A module dependency.
-    '''
-
-    # * attribute: module_path
-    module_path = StringType(
-        required=True,
-        metadata=dict(
-            description='The module path.'
-        )
-    )
-
-    # * attribute: class_name
-    class_name = StringType(
-        required=True,
-        metadata=dict(
-            description='The class name.'
-        )
-    )
+        return blacklist(*args)

tiferet/handlers/container.py

@@ -0,0 +1,116 @@
+# *** imports
+
+# ** app
+from ..commands import *
+from ..contracts.container import *
+
+
+# *** handlers
+
+# ** handler: container_handler
+class ContainerHandler(ContainerService):
+
+    '''
+    A container handler is a class that is used to create a container object.
+    '''
+
+    # * attribute: container_repo
+    container_repo: ContainerRepository
+
+    # * method: __init__
+    def __init__(self, container_repo: ContainerRepository):
+        '''
+        Initialize the container handler.
+
+        :param name: The name of the container.
+        :type name: str
+        :param dependencies: The dependencies.
+        :type dependencies: dict
+        '''
+        
+        # Assign the container repository.
+        self.container_repo = container_repo
+    
+    # * method: list_all
+    def list_all(self) -> Tuple[List[ContainerAttribute], Dict[str, str]]:
+        '''
+        List all container attributes and constants.
+
+        :return: A tuple containing a list of container attributes and a dictionary of constants.
+        :rtype: Tuple[List[ContainerAttribute], Dict[str, str]]
+        '''
+
+        # Retrieve all container attributes and constants from the repository.
+        attributes, constants = self.container_repo.list_all()
+
+        # Return the attributes and constants.
+        return attributes, constants
+    
+    # * method: load_constants
+    def load_constants(self, attributes: List[ContainerAttribute], constants: Dict[str, str] = {}, flags: List[str] = []) -> Dict[str, str]:
+        '''
+        Load constants from the container attributes.
+
+        :param attributes: The list of container attributes.
+        :type attributes: List[ContainerAttribute]
+        :param constants: The dictionary of constants.
+        :type constants: Dict[str, str]
+        :return: A dictionary of constants.
+        :rtype: Dict[str, str]
+        '''
+
+        # Raise an error if there are no attributes provided.
+        if not attributes:
+            raise_error.execute(
+                'CONTAINER_ATTRIBUTES_NOT_FOUND',
+                'No container attributes provided to load the container.',
+            )
+
+        # If constants are provided, clean the parameters using the parse_parameter command.
+        constants = {k: parse_parameter.execute(v) for k, v in constants.items()}
+
+        # Iterate through each attribute to clean parameter dictionaries.
+        # For each attribute, parse its parameters and add them to the constants dictionary.
+        # For each dependency, parse its parameters and add them to the constants dictionary.
+        for attr in attributes:
+            constants.update({k: parse_parameter.execute(v) for k, v in attr.parameters.items()})
+            dependency = attr.get_dependency(flags)
+            if dependency:
+                constants.update({k: parse_parameter.execute(v) for k, v in dependency.parameters.items()})
+
+        # Return the updated constants dictionary.
+        return constants
+    
+    # * method: get_dependency_type
+    def get_dependency_type(self, attribute: ContainerAttribute, flags: List[str] = []) -> type:
+        '''
+        Get the type of a container attribute.
+
+        :param attribute: The container attribute.
+        :type attribute: ContainerAttribute
+        :return: The type of the container attribute.
+        :rtype: type
+        '''
+
+        # Check the flagged dependencies for the type first.
+        for dep in attribute.dependencies:
+            if dep.flag in flags:
+                return import_dependency.execute(
+                    dep.module_path,
+                    dep.class_name
+                ) 
+        
+        # Otherwise defer to an available default type.
+        if attribute.module_path and attribute.class_name:
+            return import_dependency.execute(
+                attribute.module_path,
+                attribute.class_name
+            )
+            
+        # If no type is found, raise an error.
+        raise_error.execute(
+            'DEPENDENCY_TYPE_NOT_FOUND',
+            f'No dependency type found for attribute {attribute.id} with flags {flags}.',
+            attribute.id,
+            flags
+        )

tiferet/handlers/error.py

@@ -0,0 +1,49 @@
+# *** imports
+
+# ** app
+from ..contracts.error import *
+
+
+# *** handlers
+
+# ** handler: error_handler
+class ErrorHandler(ErrorService):
+    '''
+    A handler for error objects.
+    '''
+
+    # * attribute: error_repo
+    error_repo: ErrorRepository
+
+    # * method: init
+    def __init__(self, error_repo: ErrorRepository):
+        '''
+        Initialize the error handler.
+
+        :param error_repo: The error repository to use for handling errors.
+        :type error_repo: ErrorRepository
+        '''
+        
+        # Assign the attributes.
+        self.error_repo = error_repo
+
+    # * method: load_errors
+    def load_errors(self, configured_errors: List[Error] = []) -> List[Error]:
+        '''
+        Load errors by their codes.
+
+        :param configured_errors: The list of hard-coded errors to load.
+        :type configured_errors: List[Error]
+        :return: The list of loaded errors.
+        :rtype: List[Error]
+        '''
+        
+        # Load the errors from the repository.
+        errors = self.error_repo.list()
+
+        # If there are configured errors, extend the list with them.
+        if configured_errors:
+            errors.extend(configured_errors)
+
+        # Return the list of errors.
+        return errors

tiferet/handlers/feature.py

@@ -0,0 +1,94 @@
+# *** imports
+
+# ** app
+from ..commands import *
+from ..contracts.feature import *
+
+
+# *** handlers
+
+# ** handler: feature_handler
+class FeatureHandler(FeatureService):
+    '''
+    Feature handler for executing feature requests.
+    '''
+
+    # * attribute: feature_repo
+    feature_repo: FeatureRepository
+
+    # * method: __init__
+    def __init__(self, feature_repo: FeatureRepository):
+        '''
+        Initialize the feature handler.
+
+        :param feature_repo: The feature repository to use for retrieving features.
+        :type feature_repo: FeatureRepository
+        '''
+
+        # Assign the feature repository.
+        self.feature_repo = feature_repo
+
+    # * method: parse_parameter
+    def parse_parameter(self, parameter: str, request: Request = None) -> str:
+        '''
+        Parse a parameter.
+
+        
+        :param parameter: The parameter to parse.
+        :type parameter: str:
+        param request: The request object containing data for parameter parsing.
+        :type request: Request
+        :return: The parsed parameter.
+        :rtype: str
+        '''
+
+        # Parse the parameter if it not a request parameter.
+        if not parameter.startswith('$r.'):
+            return parse_parameter.execute(parameter)
+        
+        # Raise an error if the request is and the parameter comes from the request.
+        if not request and parameter.startswith('$r.'):
+            raise_error.execute(
+                'REQUEST_NOT_FOUND',
+                'Request data is not available for parameter parsing.',
+                parameter
+            )
+    
+        # Parse the parameter from the request if provided.
+        result = request.data.get(parameter[3:], None)
+        
+        # Raise an error if the parameter is not found in the request data.
+        if result is None:
+            raise_error.execute(
+                'PARAMETER_NOT_FOUND',
+                f'Parameter {parameter} not found in request data.',
+                parameter
+            )
+
+        # Return the parsed parameter.
+        return result
+
+    # * method: get_feature
+    def get_feature(self, feature_id: str) -> Feature:
+        '''
+        Get a feature by its ID.
+
+        :param feature_id: The ID of the feature to retrieve.
+        :type feature_id: str
+        :return: The feature model contract.
+        :rtype: Feature
+        '''
+
+        # Retrieve the feature from the repository.
+        feature = self.feature_repo.get(feature_id)
+
+        # Verify the feature is not None.
+        if not feature:
+            raise_error.execute(
+                'FEATURE_NOT_FOUND',
+                f'Feature not found: {feature_id}',
+                feature_id
+            )
+
+        # Return the feature.
+        return feature

tiferet/models/__init__.py

@@ -0,0 +1,4 @@
+# *** imports
+
+# ** app
+from .settings import *

tiferet/models/app.py

@@ -0,0 +1,150 @@
+# *** imports
+
+# ** app
+from .settings import *
+
+
+# *** models
+
+# ** model: app_attribute
+class AppAttribute(ValueObject):
+    
+    # * attribute: module_path
+    module_path = StringType(
+        required=True,
+        metadata=dict(
+            description='The module path for the app dependency.'
+        )
+    )
+
+    # * attribute: class_name
+    class_name = StringType(
+        required=True,
+        metadata=dict(
+            description='The class name for the app dependency.'
+        )
+    )
+
+    # * attribute: attribute_id
+    attribute_id = StringType(
+        required=True,
+        metadata=dict(
+            description='The attribute id for the application dependency.'
+        ),
+    )
+
+    # * attribute: parameters
+    parameters = DictType(
+        StringType,
+        default={},
+        metadata=dict(
+            description='The parameters for the application dependency.'
+        ),
+    )
+
+
+# ** model: app_interface
+class AppInterface(Entity):
+    '''
+    The base application interface object.
+    '''
+
+    # * attribute: name
+    name = StringType(
+        required=True,
+        metadata=dict(
+            description='The name of the application interface.'
+        ),
+    )  
+
+    # * attribute: module_path
+    module_path = StringType(
+        required=True,
+        metadata=dict(
+            description='The module path for the application instance context.'
+        ),
+    )
+
+    # * attribute: class_name
+    class_name = StringType(
+        required=True,
+        metadata=dict(
+            description='The class name for the application instance context.'
+        ),
+    )
+
+    # attribute: feature_flag
+    feature_flag = StringType(
+        default='default',
+        metadata=dict(
+            description='The feature flag.'
+        ),
+    )
+
+    # attribute: data_flag
+    data_flag = StringType(
+        default='default',
+        metadata=dict(
+            description='The data flag.'
+        ),
+    )
+
+    # * attribute: attributes
+    attributes = ListType(
+        ModelType(AppAttribute),
+        required=True,
+        default=[],
+        metadata=dict(
+            description='The application instance attributes.'
+        ),
+    )
+
+    # * attribute: constants
+    constants = DictType(
+        StringType,
+        default={},
+        metadata=dict(
+            description='The application dependency constants.'
+        ),
+    )
+
+    # * method: add_attribute
+    def add_attribute(self, module_path: str, class_name: str, attribute_id: str):
+        '''
+        Add a dependency attribute to the app interface.
+
+        :param module_path: The module path for the app dependency attribute.
+        :type module_path: str
+        :param class_name: The class name for the app dependency attribute.
+        :type class_name: str
+        :param attribute_id: The id for the app dependency attribute.
+        :type attribute_id: str
+        :return: The added dependency.
+        :rtype: AppDependency
+        '''
+
+        # Create a new AppDependency object.
+        dependency = ValueObject.new(
+            AppAttribute,
+            module_path=module_path,
+            class_name=class_name,
+            attribute_id=attribute_id
+        )
+
+        # Add the dependency to the list of dependencies.
+        self.attributes.append(dependency)
+    
+    # * method: get_attribute
+    def get_attribute(self, attribute_id: str) -> AppAttribute:
+        '''
+        Get the dependency attribute by attribute id.
+
+        :param attribute_id: The attribute id of the dependency attribute.
+        :type attribute_id: str
+        :return: The dependency attribute.
+        :rtype: AppAttribute
+        '''
+
+        # Get the dependency attribute by attribute id.
+        return next((attr for attr in self.attributes if attr.attribute_id == attribute_id), None)
+