tiferet 1.0.0a0__py3-none-any.whl

app/data/app.py

@@ -0,0 +1,227 @@
+# *** imports
+
+# ** app
+from ..configs import *
+from ..domain import DataObject
+from ..domain.app import AppDependency, AppInterface, AppRepositoryConfiguration
+
+
+# *** data
+
+# ** data: app_dependency_yaml_data
+class AppDependencyYamlData(AppDependency, DataObject):
+    '''
+    A YAML data representation of an app dependency object.
+    '''
+
+    class Options():
+        '''
+        The options for the app dependency data.
+        '''
+        serialize_when_none = False
+        roles = {
+            'to_model': DataObject.allow(),
+            'to_data.yaml': DataObject.deny('attribute_id')
+        }
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppDependencyYamlData':
+        '''
+        Initializes a new YAML representation of an AppDependency object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppDependencyData object.
+        :rtype: AppDependencyData
+        '''
+
+        # Create a new AppDependencyData object.
+        return AppDependencyYamlData(
+            super(AppDependencyYamlData, AppDependencyYamlData).new(
+                **kwargs
+            )
+        )
+    
+    # * method: map
+    def map(self, **kwargs) -> AppDependency:
+        '''
+        Maps the app dependency data to an app dependency object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new app dependency object.
+        :rtype: AppDependency
+        '''
+
+        # Map the app dependency data.
+        return super().map(AppDependency, **kwargs)
+    
+
+# ** data: app_interface_yaml_data
+class AppInterfaceYamlData(AppInterface, DataObject):
+    '''
+    A data representation of an app interface object.
+    '''
+
+    class Options():
+        '''
+        The options for the app interface data.
+        '''
+        serialize_when_none = False
+        roles = {
+            'to_model': DataObject.allow(),
+            'to_data.yaml': DataObject.deny('id')
+        }
+
+    # attribute: app_context
+    app_context = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The application context dependency.'
+        ),
+    )
+
+    # * attribute: feature_context
+    feature_context = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The feature context dependency.'
+        ),
+    )
+
+    # * attribute: container_context
+    container_context = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The container context dependency.'
+        ),
+    )
+
+    # * attribute: error_context
+    error_context = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The error context dependency.'
+        ),
+    )
+
+    # * attribute: feature_repo
+    feature_repo = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The feature repository dependency.'
+        ),
+    )
+
+    # * attribute: container_repo
+    container_repo = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The container repository dependency.'
+        ),
+    )
+
+    # * attribute: error_repo
+    error_repo = ModelType(
+        AppDependencyYamlData,
+        required=True,
+        metadata=dict(
+            description='The error repository dependency.'
+        ),
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppInterfaceYamlData':
+        '''
+        Initializes a new YAML representation of an AppInterface object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppInterfaceData object.
+        :rtype: AppInterfaceData
+        '''
+
+        # Create a new AppInterfaceData object.
+        return AppInterfaceYamlData(
+            super(AppInterfaceYamlData, AppInterfaceYamlData).new(
+                **kwargs
+            )
+        )
+    
+    # * method: map
+    def map(self, **kwargs) -> AppInterface:
+        '''
+        Maps the app interface data to an app interface object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new app interface object.
+        :rtype: AppInterface
+        '''
+
+        # Map the app interface data.
+        return super().map(AppInterface, **kwargs)
+
+
+# ** data: app_repository_configuration_yaml_data
+class AppRepositoryConfigurationYamlData(DataObject):
+    '''
+    A YAML data representation of an app repository configuration object.
+    '''
+
+    class Options():
+        '''
+        The options for the app repository configuration data.
+        '''
+        serialize_when_none = False
+        roles = {
+            'to_model': DataObject.allow(),
+            'to_data.yaml': DataObject.allow()
+        }
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'AppRepositoryConfigurationYamlData':
+        '''
+        Initializes a new YAML representation of an AppRepositoryConfiguration object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new AppRepositoryConfigurationData object.
+        :rtype: AppRepositoryConfigurationData
+        '''
+
+        # Create a new AppRepositoryConfigurationData object.
+        return AppRepositoryConfigurationYamlData(
+            super(AppRepositoryConfigurationYamlData, AppRepositoryConfigurationYamlData).new(
+                **kwargs
+            )
+        )
+    
+    # * method: map
+    def map(self, **kwargs) -> AppRepositoryConfiguration:
+        '''
+        Maps the app repository configuration data to an app repository configuration object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new app repository configuration object.
+        :rtype: AppRepositoryConfiguration
+        '''
+
+        # Map the app repository configuration data.
+        return super().map(AppRepositoryConfiguration, **kwargs)

app/data/container.py

@@ -0,0 +1,179 @@
+# *** imports
+
+# ** app
+from ..configs import *
+from ..domain import DataObject
+from ..domain.container import ContainerAttribute, ContainerDependency
+
+
+# *** data
+
+# ** data: container_dependency_yaml_data
+class ContainerDependencyYamlData(ContainerDependency, DataObject):
+    '''
+    A data representation of a container dependency object.
+    '''
+
+    class Options():
+        '''
+        The options for the container dependency data.
+        '''
+
+        serialize_when_none = False
+        roles = {
+            'to_model': DataObject.allow(),
+            'to_data.yaml': DataObject.deny('flag')
+        }
+
+    # * attribute: flag
+    flag = StringType(
+        metadata=dict(
+            description='The flag is no longer required due to the YAML format.'
+        ),
+    )
+
+    # * attribute: parameters
+    parameters = DictType(
+        StringType, 
+        default={}, 
+        serialize_name='params', 
+        deserialize_from=['params'],
+        metadata=dict(
+            description='The parameters need to now account for new data names in the YAML format.'
+        ),
+    )
+
+    # * method: map
+    def map(self, **kwargs) -> ContainerDependency:
+        '''
+        Maps the container dependency data to a container dependency object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :return: A new container dependency object.
+        '''
+
+        # Map to the container dependency object.
+        return super().map(ContainerDependency, **kwargs)
+    
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ContainerDependencyYamlData':
+        '''
+        Initializes a new ContainerDependencyData object from YAML data.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ContainerDependencyData object.
+        :rtype: ContainerDependencyYamlData
+        '''
+
+        # Create a new ContainerDependencyYamlData object.
+        data = ContainerDependencyYamlData(dict(
+            **kwargs,
+        ), strict=False)
+
+        # Validate and return the object.
+        data.validate()
+        return data
+    
+    # * method: from_model
+    @staticmethod
+    def from_model(model: ContainerDependency, **kwargs) -> 'ContainerDependencyYamlData':
+        '''
+        Initializes a new ContainerDependencyData object from a model object.
+
+        :param model: The container dependency model object.
+        :type model: ContainerDependency
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Create and return a new ContainerDependencyData object.
+        return ContainerDependencyYamlData.new(
+            **model.to_primitive(),
+            **kwargs,
+        )
+
+
+# ** data: container_attribute_yaml_data
+class ContainerAttributeYamlData(ContainerAttribute, DataObject):
+    '''
+    A data representation of a container attribute object.
+    '''
+
+    class Options():
+        '''
+        The options for the container attribute data.
+        '''
+
+        serialize_when_none = False
+        roles = {
+            'to_model': DataObject.allow(),
+            'to_data.yaml': DataObject.deny('id')
+        }
+
+    # * attribute: dependencies
+    dependencies = DictType(
+        ModelType(ContainerDependencyYamlData), 
+        default=[], 
+        serialize_name='deps', 
+        deserialize_from=['deps', 'dependencies'],
+        metadata=dict(
+            description='The dependencies are now a key-value pair keyed by the flags.'
+        ),
+    )
+
+    # * method: map
+    def map(self, **kwargs) -> ContainerAttribute:
+        '''
+        Maps the container attribute data to a container attribute object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Map to the container attribute object with the dependencies.
+        return super().map(ContainerAttribute, 
+            dependencies=[dep.map(flag=flag) for flag, dep in self.dependencies.items()],
+            **kwargs)
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ContainerAttributeYamlData':
+        '''
+        Initializes a new ContainerAttributeData object from YAML data.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Create a new ContainerAttributeData object.
+        data = ContainerAttributeYamlData(dict(
+            **kwargs,
+        ), strict=False)
+
+        
+        # Validate and return the object.
+        data.validate()
+        return data
+    
+    # * method: from_model
+    @staticmethod
+    def from_model(model: ContainerAttribute, **kwargs) -> 'ContainerAttributeYamlData':
+        '''
+        Initializes a new ContainerAttributeData object from a model object.
+
+        :param model: The container attribute model object.
+        :type model: ContainerAttribute
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Create a new ContainerAttributeData object.
+        return ContainerAttributeYamlData.new(
+            id=model.id,
+            type=model.type,
+            dependencies = {dep.flag: dep for dep in model.dependencies},
+        )
+    

app/data/error.py

@@ -0,0 +1,99 @@
+# *** imports
+
+# ** app
+from ..configs import *
+from ..domain import DataObject
+from ..domain.error import Error, ErrorMessage
+
+
+# *** data
+
+# ** data: error_message_data
+class ErrorMessageData(ErrorMessage, DataObject):
+    '''
+    A data representation of an error message object.
+    '''
+
+    class Options():
+        serialize_when_none = False
+        roles = {
+            'to_data.yaml': DataObject.allow('id'),
+            'to_object.yaml': DataObject.allow()
+        }
+
+
+# ** data: error_data
+class ErrorData(Error, DataObject):
+    '''
+    A data representation of an error object.
+    '''
+
+    class Options():
+        serialize_when_none = False
+        roles = {
+            'to_data.yaml': DataObject.deny('id'),
+            'to_object.yaml': DataObject.allow()
+        }
+
+    # * attribute: message
+    message = ListType(
+        ModelType(ErrorMessageData),
+        required=True,
+        metadata=dict(
+            description='The error messages.'
+        )
+    )
+
+    # * method: map
+    def map(self, role: str = 'to_object.yaml', **kwargs):
+        '''
+        Maps the error data to an error object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new error object.
+        :rtype: Error
+        '''
+
+        # Map the error messages.
+        return super().map(Error, role, **kwargs)
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'ErrorData':
+        '''
+        Creates a new ErrorData object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ErrorData object.
+        :rtype: ErrorData
+        '''
+
+        # Create a new ErrorData object.
+        return ErrorData(
+            super(ErrorData, ErrorData).new(**kwargs)
+        )
+
+    # * method: from_yaml_data
+
+    @staticmethod
+    def from_yaml_data(id: str, **kwargs):
+        '''
+        Initializes a new ErrorData object from yaml data.
+
+        :param id: The unique identifier for the error.
+        :type id: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new ErrorData object.
+        :rtype: ErrorData
+        '''
+
+        # Create a new ErrorData object.
+        return ErrorData.new(
+            id=id,
+            **kwargs
+        )

app/data/feature.py

@@ -0,0 +1,132 @@
+
+from schematics.types.serializable import serializable
+
+from ..domain import *
+from ..domain.feature import Feature, FeatureCommand
+
+
+class FeatureCommandData(FeatureCommand, DataObject):
+    '''
+    A data representation of a feature handler.
+    '''
+
+    class Options():
+        '''
+        The default options for the feature handler data.
+        '''
+
+        # Set the serialize when none flag to false.
+        serialize_when_none = False
+
+        # Define the roles for the feature handler data.
+        roles = {
+            'to_object.yaml': DataObject.allow(),
+            'to_data.yaml': DataObject.allow()
+        }
+
+    def map(self, role: str = 'to_object', **kwargs) -> FeatureCommand:
+        '''
+        Maps the feature handler data to a feature handler object.
+        
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new feature handler object.
+        :rtype: f.FeatureCommand
+        '''
+        return super().map(FeatureCommand, role, **kwargs)
+
+
+class FeatureData(Feature, DataObject):
+    '''
+    A data representation of a feature.
+    '''
+
+    class Options():
+        '''
+        The default options for the feature data.
+        '''
+
+        # Set the serialize when none flag to false.
+        serialize_when_none = False
+
+        # Define the roles for the feature data.
+        roles = {
+            'to_object.yaml': DataObject.deny('feature_key'),
+            'to_data.yaml': DataObject.deny('feature_key', 'group_id', 'id')
+        }
+
+    commands = t.ListType(t.ModelType(FeatureCommandData),
+                          deserialize_from=['handlers', 'functions', 'commands'],)
+    
+    @serializable
+    def feature_key(self):
+        '''
+        Gets the feature key.
+        '''
+
+        # Return the feature key.
+        return self.id.split('.')[-1]
+
+    def map(self, role: str = 'to_object.yaml', **kwargs) -> Feature:
+        '''
+        Maps the feature data to a feature object.
+
+        :param role: The role for the mapping.
+        :type role: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new feature object.
+        :rtype: f.Feature
+        '''
+
+        # Map the feature data to a feature object.
+        return super().map(Feature, role, **kwargs)
+
+    @staticmethod
+    def new(**kwargs) -> 'FeatureData':
+        '''
+        Initializes a new FeatureData object from a Feature object.
+        
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new FeatureData object.
+        :rtype: FeatureData
+        '''
+
+        # Create a new FeatureData object.
+        _data = FeatureData(
+            dict(**kwargs,), 
+            strict=False
+        )
+
+        # Validate and return the new FeatureData object.
+        _data.validate()
+        return _data
+
+    @staticmethod
+    def from_yaml_data(id: str, group_id: str, **kwargs) -> 'FeatureData':
+        '''
+        Initializes a new FeatureData object from yaml data.
+        
+        :param id: The feature id.
+        :type id: str
+        :param group_id: The context group id.
+        :type group_id: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new FeatureData object.
+        :rtype: FeatureData
+        '''
+
+        # Create a new FeatureData object.
+        _data = FeatureData(
+            dict(**kwargs, 
+                 id=id, group_id=group_id
+            ), 
+            strict=False)
+
+        # Validate and return the new FeatureData object.
+        _data.validate()
+        return _data

app/domain/__init__.py

@@ -0,0 +1,5 @@
+from .core import *
+from .app import AppInterface
+from .container import ContainerAttribute
+from .error import Error
+from .feature import Feature