tiferet 1.0.0a0__py3-none-any.whl

app/domain/app.py

@@ -0,0 +1,330 @@
+# *** imports
+
+# ** app
+from ..configs import *
+from ..domain import *
+
+
+# *** models
+
+# ** model: app_dependency
+class AppDependency(ModuleDependency):
+
+    # * attribute: attribute_id
+    attribute_id = StringType(
+        required=True,
+        metadata=dict(
+            description='The attribute id for the application dependency.'
+        ),
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppDependency':
+        '''
+        Initializes a new AppDependency object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppDependency object.
+        :rtype: AppDependency
+        '''
+
+        # Create and return a new AppDependency object.
+        return super(AppDependency, AppDependency).new(
+            AppDependency,
+            **kwargs
+        )
+
+# ** 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: description
+    description = StringType(
+        metadata=dict(
+            description='The description of the application interface.'
+        ),
+    )
+
+    # attribute: feature_flag
+    feature_flag = StringType(
+        required=True,
+        metadata=dict(
+            description='The feature flag.'
+        ),
+    )
+
+    # attribute: data_flag
+    data_flag = StringType(
+        required=True,
+        metadata=dict(
+            description='The data flag.'
+        ),
+    )
+
+    # * attribute: app_context
+    app_context = ModelType(
+        AppDependency,
+        required=True,
+        metadata=dict(
+            description='The application context dependency.'
+        ),
+    )
+
+    # * attribute: feature_context
+    feature_context = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='feature_context',
+            module_path='app.contexts.feature',
+            class_name='FeatureContext',
+        ),
+        metadata=dict(
+            description='The feature context dependency.'
+        ),
+    )
+
+    # * attribute: container_context
+    container_context = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='container_context',
+            module_path='app.contexts.container',
+            class_name='ContainerContext',
+        ),
+        metadata=dict(
+            description='The container context dependency.'
+        ),
+    )
+
+    # * attribute: error_context
+    error_context = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='error_context',
+            module_path='app.contexts.error',
+            class_name='ErrorContext',
+        ),
+        metadata=dict(
+            description='The error context dependency.'
+        ),
+    )
+
+    # * attribute: feature_repo
+    feature_repo = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='feature_repo',
+            module_path='app.repositories.feature',
+            class_name='FeatureRepository',
+        ),
+        metadata=dict(
+            description='The feature repository dependency.'
+        ),
+    )
+
+    # * attribute: container_repo
+    container_repo = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='container_repo',
+            module_path='app.repositories.container',
+            class_name='ContainerRepository',
+        ),
+        metadata=dict(
+            description='The container repository dependency.'
+        ),
+    )
+
+    # * attribute: error_repo
+    error_repo = ModelType(
+        AppDependency,
+        required=True,
+        default=AppDependency.new(
+            attribute_id='error_repo',
+            module_path='app.repositories.error',
+            class_name='ErrorRepository',
+        ),
+        metadata=dict(
+            description='The error repository dependency.'
+        ),
+    )
+
+    # * attribute: constants
+    constants = DictType(
+        StringType,
+        default=dict(
+            container_config_file='app/configs/container.yml',
+            feature_config_file='app/configs/features.yml',
+            error_config_file='app/configs/errors.yml',
+        ),
+        metadata=dict(
+            description='The application dependency constants.'
+        ),
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppInterface':
+        '''
+        Initializes a new AppInterface object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppInterface object.
+        :rtype: AppInterface
+        '''
+
+        # Create and return a new AppInterface object.
+        return super(AppInterface, AppInterface).new(
+            AppInterface,
+            **kwargs
+        )
+    
+    # * method: list_dependencies
+    def get_dependencies(self) -> list:
+        '''
+        Lists the dependencies for the application interface.
+
+        :return: The list of dependencies for the application interface.
+        :rtype: list
+        '''
+
+        # Return the list of dependencies for the application interface.
+        return [
+            self.app_context,
+            self.feature_context,
+            self.container_context,
+            self.error_context,
+            self.feature_repo,
+            self.container_repo,
+            self.error_repo,
+        ]
+
+
+# ** model: app_repository_configuration
+class AppRepositoryConfiguration(ModuleDependency):
+    '''
+    The import configuration for the application repository.
+    '''
+
+    # * attribute: module_path
+    module_path = StringType(
+        required=True,
+        default='app.repositories.app',
+        metadata=dict(
+            description='The module path for the application repository.'
+        ),
+    )
+
+    # * attribute: class_name
+    class_name = StringType(
+        required=True,
+        default='YamlProxy',
+        metadata=dict(
+            description='The class name for the application repository.'
+        ),
+    )
+
+    # * attribute: params
+    params = DictType(
+        StringType,
+        default=dict(
+            app_config_file='app/configs/app.yml',
+        ),
+        metadata=dict(
+            description='The application repository configuration parameters.'
+        ),
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppRepositoryConfiguration':
+        '''
+        Initializes a new AppRepositoryConfiguration object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppRepositoryConfiguration object.
+        :rtype: AppRepositoryConfiguration
+        '''
+
+        # Create and return a new AppRepositoryConfiguration object.
+        return super(AppRepositoryConfiguration, AppRepositoryConfiguration).new(
+            AppRepositoryConfiguration,
+            **kwargs
+        )
+
+
+# ** model: app_configuration
+class AppConfiguration(Entity):
+    '''
+    The application configuration object.
+    '''
+
+    # * attribute: name
+    name = StringType(
+        required=True,
+        metadata=dict(
+            description='The name of the application.'
+        )
+    )
+
+    # * attribute: description
+    description = StringType(
+        metadata=dict(
+            description='The description of the application.'
+        )
+    )
+
+    # * attribute: app_repo
+    app_repo = ModelType(AppRepositoryConfiguration,
+        required=True,
+        metadata=dict(
+            description='The application repository configuration.'
+        ),
+    )
+
+    # * attribute: interfaces
+    interfaces = ListType(
+        ModelType(AppInterface),
+        required=True,
+        default=[],
+        metadata=dict(
+            description='The application interfaces.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppConfiguration':
+        '''
+        Initializes a new AppConfiguration object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppConfiguration object.
+        :rtype: AppConfiguration
+        '''
+
+        # Create and return a new AppConfiguration object.
+        return super(AppConfiguration, AppConfiguration).new(
+            AppConfiguration,
+            **kwargs
+        )

app/domain/container.py

@@ -0,0 +1,141 @@
+# *** imports
+
+# ** app
+from ..domain import *
+
+# *** constants
+
+# */ list[str]
+CONTAINER_ATTRIBUTE_TYPE_CHOICES = [
+    'interface',
+    'feature',
+    'data'
+]
+
+
+# *** models
+
+# ** model: container_depenedency
+class ContainerDependency(ModuleDependency):
+    '''
+    A container dependency object.
+    '''
+
+    # * attribute: flag
+    flag = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The flag for the container dependency.'
+        )
+    )
+
+    # * attribute: parameters
+    parameters = t.DictType(
+        t.StringType,
+        default={},
+        metadata=dict(
+            description='The container dependency parameters.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ContainerDependency':
+        '''
+        Initializes a new ContainerDependency object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ContainerDependency object.
+        :rtype: ContainerDependency
+        '''
+
+        # Create and return a new ContainerDependency object.
+        super(ContainerDependency, ContainerDependency).new(
+            ContainerDependency,
+            **kwargs)
+
+
+# ** model: container_attribute
+class ContainerAttribute(Entity):
+    '''
+    An attribute that defines container injectior behavior.
+    '''
+
+    # * attribute: id
+    id = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The unique identifier for the container attribute.'
+        )
+    )
+
+    # * attribute: type
+    type = t.StringType(
+        required=True,
+        choices=CONTAINER_ATTRIBUTE_TYPE_CHOICES,
+        metadata=dict(
+            description='The type of container attribute.'
+        )
+    )
+
+    # * attribute: dependencies
+    dependencies = t.ListType(
+        t.ModelType(ContainerDependency),
+        default=[],
+        metadata=dict(
+            description='The container attribute dependencies.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ContainerAttribute':
+        '''
+        Initializes a new ContainerAttribute object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ContainerAttribute object.
+        :rtype: ContainerAttribute
+        '''
+
+        # Create and return a new ContainerAttribute object.
+        super(ContainerAttribute, ContainerAttribute).new(
+            ContainerAttribute,
+            **kwargs)
+        
+    # * method: set_dependency
+    def set_dependency(self, dependency: ContainerDependency):
+        '''
+        Sets a container dependency.
+
+        :param dependency: The container dependency to set.
+        :type dependency: ContainerDependency
+        '''
+
+        # Replace the value of the dependency if a dependency with the same flag exists.
+        for index, _dependency in enumerate(self.dependencies):
+            if _dependency.flag == dependency.flag:
+                self.dependencies[index] = dependency
+                return
+        
+        # Append the dependency otherwise.
+        self.dependencies.append(dependency)
+        
+    # * method: get_dependency
+    def get_dependency(self, flag: str) -> ContainerDependency:
+        '''
+        Gets a container dependency by flag.
+
+        :param flag: The flag for the container dependency.
+        :type flag: str
+        :return: The container dependency.
+        :rtype: ContainerDependency
+        '''
+
+        # Return the dependency with the matching flag.
+        return next(
+            (dependency for dependency in self.dependencies if dependency.flag == flag),
+            None
+        )

app/domain/core.py

@@ -0,0 +1,199 @@
+# *** imports
+
+# ** 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()
+
+        # Return the new model object.
+        return _object
+
+
+# ** model: entity
+class Entity(ModelObject):
+    '''
+    A domain model entity.
+    '''
+
+    # ** attribute: id
+    id = StringType(
+        required=True,
+        metadata=dict(
+            description='The entity unique identifier.'
+        )
+    )
+
+
+# ** model: value_object
+class ValueObject(ModelObject):
+    '''
+    A domain model value object.
+    '''
+
+    pass
+
+
+# ** model: data_object
+class DataObject(Model):
+    '''
+    A data representation object.
+    '''
+
+    # ** method: map
+    def map(self,
+            type: ModelObject,
+            role: str = 'to_model',
+            **kwargs
+            ) -> ModelObject:
+        '''
+        Maps the model data to a model object.
+
+        :param type: The type of model object to map to.
+        :type type: type
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments for mapping.
+        :type kwargs: dict
+        :return: A new model object.
+        :rtype: ModelObject
+        '''
+
+        # Get primitive of the model data and merge with the keyword arguments.
+        # Give priority to the keyword arguments.
+        _data = self.to_primitive(role=role)
+        for key, value in kwargs.items():
+            _data[key] = value
+
+        # Map the data object to a model object.
+        _object = type.new(**_data, strict=False)
+
+        # Return the model data.
+        return _object
+    
+    # ** method: from_model
+    @staticmethod
+    def from_model(
+        model: ModelObject,
+        **kwargs
+    ) -> 'DataObject':
+        '''
+        Initializes a new data object from a model object.
+
+        :param model: The type of model object to map from.
+        :type model: type
+        :param kwargs: Keyword arguments.
+        :type kwargs: dict
+        :return: A new data object.
+        :rtype: DataObject
+        '''
+
+        # Create a new data object.
+        return DataObject(
+            model.new(**kwargs, strict=False),
+            strict=False,
+        )
+
+    # ** method: allow
+    @staticmethod
+    def allow(*args) -> Any:
+
+        # Create a whitelist transform.
+        # Create a wholelist transform if no arguments are specified.
+        from schematics.transforms import whitelist, wholelist
+        if args:
+            return whitelist(*args)
+        return wholelist()
+
+    # ** method: deny
+    @staticmethod
+    def deny(*args) -> Any:
+
+        # Create a blacklist transform.
+        from schematics.transforms import blacklist
+        return blacklist(*args)
+
+
+# ** model: module_dependency
+class ModuleDependency(Model):
+    '''
+    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.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ModuleDependency':
+        '''
+        Initializes a new ModuleDependency object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ModuleDependency object.
+        :rtype: ModuleDependency
+        '''
+
+        # Create a new ModuleDependency object.
+        return super(ModuleDependency, ModuleDependency).new(
+            ModuleDependency,
+            **kwargs
+        )