tiferet 1.0.0a0__py3-none-any.whl

app/domain/error.py

@@ -0,0 +1,136 @@
+# *** imports 
+
+# ** core
+from ..domain import *
+
+
+# *** models
+
+# ** model: error_message0
+class ErrorMessage(ValueObject):
+    '''
+    An error message object.
+    '''
+
+    # * attribute: lang
+    lang = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The language of the error message text.'
+        )
+    )
+
+    # * attribute: text
+    text = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The error message text.'
+        )
+    )
+
+    # * method: format
+    def format(self, *args) -> str:
+        '''
+        Formats the error message text.
+
+        :param args: The arguments to format the error message text with.
+        :type args: tuple
+        :return: The formatted error message text.
+        :rtype: str
+        '''
+
+        # If there are no arguments, return the error message text.
+        if not args:
+            return self.text
+
+        # Format the error message text and return it.
+        return self.text.format(*args)
+
+
+# ** model: error
+class Error(Entity):
+    '''
+    An error object.
+    '''
+
+    # * attribute: name
+    name = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The name of the error.'
+        )
+    )
+
+    # * attribute: error_code
+    error_code = t.StringType(
+        metadata=dict(
+            description='The unique code of the error.'
+        )
+    )
+
+    # * attribute: message
+    message = t.ListType(
+        t.ModelType(ErrorMessage),
+        required=True,
+        metadata=dict(
+            description='The error message translations for the error.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(name: str, id: str = None, error_code: str = None, **kwargs) -> 'Error':
+        '''Initializes a new Error object.
+
+        :param name: The name of the error.
+        :type name: str
+        :param id: The unique identifier for the error.
+        :type id: str
+        :param error_code: The error code for the error.
+        :type error_code: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new Error object.
+        '''
+
+        # Format name as upper case snake case.
+        name = name.upper().replace(' ', '_')
+        
+        # Set Id as the name if not provided.
+        if not id:
+            id = name
+
+        # Set the error code as the name if not provided.
+        if not error_code:
+            error_code = name
+
+        # Create and return a new Error object.
+        return super(Error, Error).new(
+            id=id,
+            name=name,
+            error_code=error_code,
+            **kwargs
+        )
+
+    # * method: format
+    def format(self, lang: str = 'en_US', *args) -> str:
+        '''
+        Formats the error message text for the specified language.
+
+        :param lang: The language of the error message text.
+        :type lang: str
+        :param args: The format arguments for the error message text.
+        :type args: tuple
+        :return: The formatted error message text.
+        :rtype: str
+        '''
+
+        # Iterate through the error messages.
+        for msg in self.message:
+
+            # Skip if the language does not match.
+            if msg.lang != lang:
+                continue
+
+            # Format the error message text.
+            return msg.format(*args)

app/domain/feature.py

@@ -0,0 +1,176 @@
+# *** imports
+
+# ** app
+from ..domain import *
+
+
+# *** models
+
+# ** model: feature_command
+class FeatureCommand(ValueObject):
+    '''
+    A command object for a feature command.
+    '''
+
+    # * attribute: name
+    name = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The name of the feature handler.'
+        )
+    )
+
+    # * attribute: attribute_id
+    attribute_id = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The container attribute ID for the feature command.'
+        )
+    )
+
+    # * attribute: params
+    params = t.DictType(
+        t.StringType(),
+        default={},
+        metadata=dict(
+            description='The custom parameters for the feature handler.'
+        )
+    )
+
+    # * attribute: return_to_data
+    return_to_data = t.BooleanType(
+        metadata=dict(
+            description='Whether to return the feature command result to the feature data context.'
+        )
+    )
+
+    # * attribute: data_key
+    data_key = t.StringType(
+        metadata=dict(
+            description='The data key to store the feature command result in if Return to Data is True.'
+        )
+    )
+
+    # * attribute: pass_on_error
+    pass_on_error = t.BooleanType(
+        metadata=dict(
+            description='Whether to pass on the error if the feature handler fails.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(**kwargs) -> 'FeatureCommand':
+        '''Initializes a new FeatureCommand object.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new FeatureCommand object.
+        '''
+
+        # Create a new FeatureCommand object.
+        obj = FeatureCommand(dict(
+            **kwargs
+        ), strict=False)
+
+        # Validate and return the new FeatureCommand object.
+        obj.validate()
+        return obj
+
+
+# ** model: feature
+class Feature(Entity):
+    '''
+    A feature object.
+    '''
+
+    # * attribute: name
+    name = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The name of the feature.'
+        )
+    )
+
+    # * attribute: group_id
+    group_id = t.StringType(
+        required=True,
+        metadata=dict(
+            description='The context group identifier for the feature.'
+        )
+    )
+
+    # * attribute: description
+    description = t.StringType(
+        metadata=dict(
+            description='The description of the feature.'
+        )
+    )
+
+    # * attribute: commands
+    commands = t.ListType(
+        t.ModelType(FeatureCommand),
+        default=[],
+        metadata=dict(
+            description='The command handler workflow for the feature.'
+        )
+    )
+
+    # * attribute: log_params
+    log_params = t.DictType(
+        t.StringType(),
+        default={},
+        metadata=dict(
+            description='The parameters to log for the feature.'
+        )
+    )
+
+    # * method: new
+    @staticmethod
+    def new(name: str, group_id: str, feature_key: str, description: str = None, **kwargs) -> 'Feature':
+        '''Initializes a new Feature object.
+
+        :param name: The name of the feature.
+        :type name: str
+        :param group_id: The context group identifier of the feature.
+        :type group_id: str
+        :param feature_key: The key of the feature.
+        :type feature_key: str
+        :param description: The description of the feature.
+        :type description: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: A new Feature object.
+        '''
+
+        # Feature ID is the group ID and feature key separated by a period.
+        id = f'{group_id}.{feature_key}'
+
+        # Set the description as the name if not provided.
+        if not description:
+            description = name
+
+        # Create and return a new Feature object.
+        return super(Feature, Feature).new(
+            id=id,
+            name=name,
+            group_id=group_id,
+            description=description,
+            **kwargs
+        )
+    
+    # * method: add_handler
+    def add_handler(self, handler: FeatureCommand, position: int = None):
+        '''Adds a handler to the feature.
+
+        :param handler: The handler to add.
+        :type handler: FeatureCommand
+        :param position: The position to add the handler at.
+        :type position: int
+        '''
+
+        # Add the handler to the feature.
+        if position:
+            self.commands.insert(position, handler)
+        else:
+            self.commands.append(handler)

app/repos/app.py

@@ -0,0 +1,102 @@
+# *** imports
+
+# ** app
+from ..domain.app import AppInterface
+from ..data.app import AppInterfaceData
+from ..clients import yaml as yaml_client
+
+
+# *** repository
+
+# ** interface: app_repository
+class AppRepository(object):
+    '''
+    An app repository is a class that is used to get an app interface.
+    '''
+
+    # * method: list_interfaces
+    def list_interfaces(self) -> list[AppInterface]:
+        '''
+        List all app interfaces.
+
+        :return: The list of app interfaces.
+        :rtype: list[AppInterface]
+        '''
+
+        # Not implemented.
+        raise NotImplementedError()
+
+    # * method: get_interface
+    def get_interface(self, id: str) -> AppInterface:
+        '''
+        Get the app interface.
+
+        :param id: The app interface id.
+        :type id: str
+        :return: The app interface.
+        :rtype: AppInterface
+        '''
+
+        # Not implemented.
+        raise NotImplementedError()
+
+
+# ** proxy: yaml_proxy
+class YamlProxy(object):
+
+    # * field: config_file
+    config_file: str = None
+
+    # * method: init
+    def __init__(self, app_config_file: str):
+        '''
+        Initialize the YAML proxy.
+
+        :param app_config_file: The application configuration file.
+        :type app_config_file: str
+        '''
+
+        # Set the configuration file.
+        self.config_file = app_config_file
+
+    # * method: list_interfaces
+    def list_interfaces(self) -> list[AppInterface]:
+        '''
+        List all app interfaces.
+
+        :return: The list of app interfaces.
+        :rtype: list[AppInterface]
+        '''
+
+        # Load the app interface data from the yaml configuration file and map it to the app interface object.
+        interfaces = yaml_client.load(
+            self.config_file,
+            create_data=lambda data: [
+                AppInterfaceData.new(
+                    **record
+                ).map() for record in data],
+            start_node=lambda data: data.get('interfaces'))
+
+        # Return the list of app interface objects.
+        return interfaces
+
+    # * method: get_interface
+    def get_interface(self, id: str) -> AppInterface:
+        '''
+        Get the app interface.
+
+        :param id: The app interface id.
+        :type id: str
+        :return: The app interface.
+        :rtype: AppInterface
+        '''
+
+        # Load the app interface data from the yaml configuration file.
+        _data: AppInterface = yaml_client.load(
+            self.config_file,
+            create_data=lambda data: AppInterfaceData.new (
+                id=id, **data),
+            start_node=lambda data: data.get('interfaces').get(id))
+
+        # Return the app interface object.
+        return _data.map()

app/repos/container.py

@@ -0,0 +1,164 @@
+# *** imports
+
+# ** core
+from typing import List, Dict, Tuple
+
+# ** app
+from ..domain.container import ContainerAttribute
+from ..data.container import ContainerAttributeYamlData
+from ..clients import yaml as yaml_client
+
+
+# *** repository
+
+# * interface: container_repository
+class ContainerRepository(object):
+    '''
+    Container repository interface.
+    '''
+
+    # * field: role
+    read_role: str = None
+
+    # * field: write_role
+    write_role: str = None
+
+    # * method: get_attribute
+    def get_attribute(self, attribute_id: str, type: str) -> ContainerAttribute:
+        '''
+        Get the container attribute.
+
+        :param attribute_id: The attribute id.
+        :type attribute_id: str
+        :param type: The container attribute type.
+        :type type: str
+        :return: The container attribute.
+        :rtype: ContainerAttribute
+        '''
+
+        # Not implemented.
+        raise NotImplementedError()
+
+    # * method: list_all
+    def list_all(self) -> Tuple[List[ContainerAttribute], List[str]]:
+        '''
+        List all the container attributes and constants.
+
+        :return: The list of container attributes and constants.
+        :rtype: List[ContainerAttribute]
+        '''
+
+        # Not implemented.
+        raise NotImplementedError()
+
+    # * method: save_attribute
+    def save_attribute(self, attribute: ContainerAttribute):
+        '''
+        Save the container attribute.
+
+        :param attribute: The container attribute.
+        :type attribute: ContainerAttribute
+        '''
+
+        # Not implemented.
+        raise NotImplementedError
+
+
+# ** proxy: yaml_proxy
+class YamlProxy(ContainerRepository):
+    '''
+    Yaml proxy for container attributes.
+    '''
+
+    # * init
+    def __init__(self, container_config_file: str, read_role: str = 'to_object.yaml', write_role: str = 'to_data.yaml'):
+        '''
+        Initialize the yaml proxy.
+        
+        :param container_config_file: The YAML file path for the container configuration.
+        :type container_config_file: str
+        :param read_role: The read role for the yaml proxy.
+        :type read_role: str
+        :param write_role: The write role for the yaml proxy.
+        :type write_role: str
+        '''
+
+        # Set the container configuration file.
+        self.config_file = container_config_file
+
+        # Set the read role.
+        self.read_role = read_role
+
+        # Set the write role.
+        self.write_role = write_role
+
+    # * method: get_attribute
+    def get_attribute(self, attribute_id: str, type: str) -> ContainerAttribute:
+        '''
+        Get the attribute from the yaml file.
+
+        :param attribute_id: The attribute id.
+        :type attribute_id: str
+        :param type: The attribute type.
+        :type type: str
+        :return: The container attribute.
+        :rtype: ContainerAttribute
+        '''
+
+        # Load the attribute data from the yaml configuration file.
+        data = yaml_client.load(
+            self.config_file,
+            create_data=lambda data: ContainerAttributeYamlData.new(
+                id=attribute_id, **data),
+            start_node=lambda data: data.get('attrs').get(attribute_id),
+        )
+
+        # If the data is None or the type does not match, return None.
+        if data is None or data.type != type:
+            return None
+        
+        # Return the attribute.
+        return data.map(self.read_role)
+
+    # * method: list_all
+    def list_all(self) -> Tuple[List[ContainerAttribute], Dict[str, str]]:
+        '''
+        List all the container attributes and constants.
+
+        :return: The list of container attributes and constants.
+        :rtype: List[ContainerAttribute]
+        '''
+
+        # Load the attribute data from the yaml configuration file.
+        attr_data, consts = yaml_client.load(
+            self.config_file,
+            create_data=lambda data: (
+                [ContainerAttributeYamlData.new(id=id, **attr_data) for id, attr_data in data.get('attrs', {}).items()],
+                data.get('const', {}),
+            ),
+        )
+
+        # Return the list of container attributes.
+        return (
+            [data.map(self.read_role) for data in attr_data],
+            consts
+        )
+
+    # * method: save_attribute
+    def save_attribute(self, attribute: ContainerAttribute):
+        '''
+        Save the attribute to the yaml file.
+
+        :param attribute: The attribute to save.
+        :type attribute: ContainerAttribute
+        '''
+
+        # Create a new container attribute data object.
+        data = ContainerAttributeYamlData.from_model(attribute)
+
+        # Update the attribute data.
+        yaml_client.save(
+            self.config_file,
+            data.to_primitive(role=self.write_role),
+            f'container/attrs/{attribute.id}'
+        )