tiferet 1.0.0a0__py3-none-any.whl

app/clients/yaml.py

@@ -0,0 +1,93 @@
+# *** imports
+
+# ** infra
+import yaml
+
+
+# *** functions
+
+# ** function: load
+def load(path: str, create_data = lambda data: data, start_node = lambda data: data, **kwargs):
+    '''
+    Load the data from the yaml file.
+
+    :param path: The path to the yaml file.
+    :type path: str
+    :param create_data: The function to create the data.
+    :type create_data: function
+    :param start_node: The function to start the node.
+    :type start_node: function
+    :param kwargs: Additional keyword arguments.
+    :type kwargs: dict
+    :return: The data.
+    :rtype: dict
+    '''
+
+    # Load the data from the yaml file.
+    with open(path, 'r') as file:
+        data = yaml.safe_load(file)
+
+    # Find the start node.
+    try:
+        data = start_node(data)
+    except AttributeError:
+        return None
+    
+    # Return the data if it is None.
+    if data == None:
+        return None
+    
+    # Create and return the data.
+    return create_data(data, **kwargs)
+
+
+# ** function: save
+def save(yaml_file: str, data: dict, data_save_path: str = None):
+    '''
+    Save the data to the yaml file.
+
+    :param yaml_file: The path to the yaml file.
+    :type yaml_file: str
+    :param data: The data to save.
+    :type data: dict
+    :param data_save_path: The path to save the data to.
+    :type data_save_path: str
+    '''
+
+    # Save the data to the yaml file and exit if no save path is provided.
+    if not data_save_path:
+        with open(yaml_file, 'w') as file:
+            yaml.safe_dump(data, file)
+        return
+
+    # Load the yaml data.
+    with open(yaml_file, 'r') as file:
+        yaml_data = yaml.safe_load(file)
+
+    # Get the data save path list.
+    save_path_list = data_save_path.split('/')
+
+    # Update the yaml data.
+    new_yaml_data = None
+    for fragment in save_path_list[:-1]:
+
+        # If the new yaml data exists, update it.
+        try:
+            new_yaml_data = new_yaml_data[fragment]
+
+        # If the new yaml data does not exist, create it from the yaml data.
+        except TypeError:
+            new_yaml_data = yaml_data[fragment]
+            continue  
+
+        # If the fragment does not exist on 
+        except KeyError: 
+            new_yaml_data[fragment] = {}
+            new_yaml_data = new_yaml_data[fragment]
+
+    # Update the yaml data.
+    new_yaml_data[save_path_list[-1]] = data
+
+    # Save the updated yaml data.
+    with open(yaml_file, 'w') as file:
+        yaml.safe_dump(yaml_data, file)

app/commands/container.py

@@ -0,0 +1,54 @@
+from ..repos.container import ContainerRepository
+from ..domain.container import ContainerAttribute, ContainerDependency
+from ..services import container as container_service
+
+
+class SetContainerAttribute(object):
+    '''
+    Command to set a new container attribute
+    '''
+
+    container_repo: ContainerRepository
+
+    def __init__(self, container_repo: ContainerRepository):
+        '''
+        Initialize the command to set a new container attribute.
+
+        :param container_repo: The container repository.
+        :type container_repo: ContainerRepository
+        '''
+
+        self.container_repo = container_repo
+
+    def execute(self, attribute_id: str, type: str, **kwargs):
+        '''
+        Execute the command to set a new container attribute.
+
+        :param attribute_id: The attribute id.
+        :type attribute_id: str
+        :param type: The attribute type.
+        :type type: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+        
+        # Look up the container attribute.
+        attribute: ContainerAttribute = self.container_repo.get_attribute(attribute_id, type)
+
+        # If not attribute is found, create a new one.
+        if not attribute:
+            attribute = ContainerAttribute.new(
+                id=attribute_id,
+                type=type,
+                dependencies=[ContainerDependency.new(**kwargs)])
+        
+        # Otherwise, create the container depenedency and add it to the attribute.
+        else:
+            dependency = ContainerDependency.new(**kwargs)
+            attribute.set_dependency(dependency)
+
+        # Save the container attribute.
+        self.container_repo.save_attribute(attribute=attribute)
+
+        # Return the new container attribute.
+        return attribute

app/commands/error.py

@@ -0,0 +1,21 @@
+from ..domain.error import Error
+from ..repos.error import ErrorRepository
+
+class AddNewError(object):
+
+    def __init__(self, error_repo: ErrorRepository):
+        self.error_repo = error_repo
+
+    def execute(self, **kwargs) -> Error:
+
+        # Create a new error.
+        error: Error = Error.new(**kwargs)
+
+        # Assert that the error does not already exist.
+        assert not self.error_repo.exists(error.id), f'ERROR_ALREADY_EXISTS: {error.id}'
+
+        # Save the error.
+        self.error_repo.save(error)
+
+        # Return the new error.
+        return error

app/commands/feature.py

@@ -0,0 +1,90 @@
+from ..domain.feature import Feature
+from ..domain.feature import FeatureHandler
+from ..repos.feature import FeatureRepository
+
+
+class AddNewFeature(object):
+    '''
+    Add a new feature.
+    '''
+
+    def __init__(self, feature_repo: FeatureRepository):
+        '''
+        Initialize the command.
+        
+        :param feature_repo: The feature repository.
+        :type feature_repo: FeatureRepository
+        '''
+
+        # Set the feature repository.
+        self.feature_repo = feature_repo
+
+    def execute(self, **kwargs) -> Feature:
+        '''
+        Execute the command to add a new feature.
+        
+        :param kwargs: The keyword arguments.
+        :type kwargs: dict
+        :return: The new feature.
+        '''
+
+        # Create a new feature.
+        feature = Feature.new(**kwargs)
+
+        # Assert that the feature does not already exist.
+        assert not self.feature_repo.exists(
+            feature.id), f'FEATURE_ALREADY_EXISTS: {feature.id}'
+
+        # Save and return the feature.
+        self.feature_repo.save(feature)
+        return feature
+
+
+class AddFeatureHandler(object):
+    '''
+    Adds a feature handler to a feature.
+    '''
+
+    def __init__(self, feature_repo: FeatureRepository):
+        '''
+        Initialize the command.
+        
+        :param feature_repo: The feature repository.
+        :type feature_repo: FeatureRepository
+        '''
+
+        # Set the feature repository.
+        self.feature_repo = feature_repo
+
+    def execute(self, feature_id: str, position: int = None, **kwargs):
+        '''
+        Execute the command to add a feature handler to a feature.
+
+        :param feature_id: The feature ID.
+        :type feature_id: str
+        :param position: The position of the handler.
+        :type position: int
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The updated feature.
+        :rtype: Feature
+        '''
+
+        # Create a new feature handler instance.
+        handler = FeatureHandler.new(**kwargs)
+
+        # Get the feature using the feature ID.
+        feature = self.feature_repo.get(feature_id)
+
+        # Assert that the feature was successfully found.
+        assert feature is not None, f'FEATURE_NOT_FOUND: {feature_id}'
+
+        # Add the feature handler to the feature.
+        feature.add_handler(
+            handler,
+            position=position
+        )
+
+        # Save and return the feature.
+        self.feature_repo.save(feature)
+        return feature

app/configs/__init__.py

@@ -0,0 +1,69 @@
+# *** imports
+
+# ** infra
+from schematics import types as t
+
+
+# *** config
+
+# ** config (class): string_type
+class StringType(t.StringType):
+    '''
+    A string type.
+    '''
+
+    pass
+
+
+# ** config (class): integer_type
+class IntegerType(t.IntType):
+    '''
+    An integer type.
+    '''
+
+    pass
+
+
+# ** config (class): float_type
+class FloatType(t.FloatType):
+    '''
+    A float type.
+    '''
+
+    pass
+
+
+# ** config (class): boolean_type
+class BooleanType(t.BooleanType):
+    '''
+    A boolean type.
+    '''
+
+    pass
+
+
+# ** config (class): list_type
+class ListType(t.ListType):
+    '''
+    A list type.
+    '''
+
+    pass
+
+
+# ** config (class): dict_type
+class DictType(t.DictType):
+    '''
+    A dictionary type.
+    '''
+
+    pass
+
+
+# ** config (class): model_type
+class ModelType(t.ModelType):
+    '''
+    A model type.
+    '''
+
+    pass

app/configs/app.py

@@ -0,0 +1,16 @@
+# *** imports
+
+# ** app
+from ..domain.app import AppRepositoryConfiguration
+
+
+# *** constants
+
+# ** constant: APP_REPO
+APP_REPO = AppRepositoryConfiguration.new(
+    module_path='app.repositories.app',
+    class_name='YamlProxy',
+    params=dict(
+        app_config_file='app/configs/app.yaml'
+    ),
+)

app/configs/container.py

@@ -0,0 +1,91 @@
+# *** imports
+
+# ** app
+from ..domain.container import ContainerAttribute, ContainerDependency
+
+
+# *** configs (container_attribute)
+
+# ** config: feature_repo
+feature_repo = ContainerAttribute.new(
+    id='feature_repo',
+    type='data',
+    flags=[
+        ContainerDependency.new(
+            flag='yaml',
+            module_path='app.repositories.feature',
+            class_name='YamlProxy',
+            parameters={
+                'feature_config_file': 'app/configs/features.yml'
+            }
+        )
+    ]
+)
+
+# ** config: error_repo
+error_repo = ContainerAttribute.new(
+    id='error_repo',
+    type='data',
+    flags=[
+        ContainerDependency.new(
+            flag='yaml',
+            module_path='app.repositories.error',
+            class_name='YamlProxy',
+            parameters={
+                'error_config_file': 'app/configs/errors.yml'
+            }
+        )
+    ]
+)
+
+# ** config: set_container_attribute
+set_container_attribute = ContainerAttribute.new(
+    id='set_container_attribute',
+    type='feature',
+    flags=[
+        ContainerDependency.new(
+            flag='core',
+            module_path='app.commands.container',
+            class_name='SetContainerAttribute'
+        )
+    ]
+)
+
+# ** config: add_new_feature
+add_new_feature = ContainerAttribute.new(
+    id='add_new_feature',
+    type='feature',
+    flags=[
+        ContainerDependency.new(
+            flag='core',
+            module_path='app.commands.feature',
+            class_name='AddNewFeature'
+        )
+    ]
+)
+
+# ** config: add_feature_command
+add_feature_command = ContainerAttribute.new(
+    id='add_feature_command',
+    type='feature',
+    flags=[
+        ContainerDependency.new(
+            flag='core',
+            module_path='app.commands.feature',
+            class_name='AddFeatureCommand'
+        )
+    ]
+)
+
+# ** config: add_new_error
+add_new_error = ContainerAttribute.new(
+    id='add_new_error',
+    type='feature',
+    flags=[
+        ContainerDependency.new(
+            flag='core',
+            module_path='app.commands.error',
+            class_name='AddNewError'
+        )
+    ]
+)

app/contexts/__init__.py

@@ -0,0 +1,2 @@
+from .app import AppContext
+from .env import EnvironmentContext

app/contexts/app.py

@@ -0,0 +1,130 @@
+# *** imports
+
+# ** core
+from typing import Any 
+
+# ** app
+from .request import RequestContext
+from .feature import FeatureContext
+from .error import ErrorContext
+from ..domain import *
+
+
+# *** contexts
+
+# ** context: app_interface_context
+class AppInterfaceContext(Model): 
+
+    # * attribute: name
+    name = StringType(
+        required=True,
+        metadata=dict(
+            description='The application name.'
+        )
+    )
+
+    # * field: features
+    features = ModelType(
+        FeatureContext,
+        required=True,
+        metadata=dict(
+            description='The feature context.'
+        )
+    )
+
+    # * field: errors
+    errors = ModelType(
+        ErrorContext,
+        required=True,
+        metadata=dict(
+            description='The error context.'
+        )
+    )
+
+    # * method: init
+    def __init__(self, app_name: str, feature_context: FeatureContext, error_context: ErrorContext):
+        '''
+        Initialize the application interface context.
+
+        :param app_name: The application name.
+        :type app_name: str
+        :param feature_context: The feature context.
+        :type feature_context: FeatureContext
+        :param error_context: The error context.
+        :type error_context: ErrorContext
+        '''
+
+        # Initialize the model.
+        super().__init__(dict(
+            name=app_name,
+            features=feature_context,
+            errors=error_context
+        ))
+
+    # * method: parse_request
+    def parse_request(self, request: Any, **kwargs) -> RequestContext:
+        '''
+        Parse the incoming request.
+
+        :param request: The incoming request.
+        :type request: Any
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The request context.
+        :rtype: RequestContext
+        '''
+
+        # Parse request.
+        return request
+    
+    # * method: execute_feature
+    def execute_feature(self, request: RequestContext, **kwargs):
+        '''
+        Execute the feature context.
+
+        :param request: The request context.
+        :type request: RequestContext
+        '''
+
+        # Execute feature context and return session.
+        self.features.execute(request, **kwargs)
+    
+    # * method: handle_response
+    def handle_response(self, request: RequestContext) -> Any:
+        '''
+        Handle the response.
+
+        :param request: The request context.
+        :type request: RequestContext
+        :return: The response.
+        :rtype: Any
+        '''
+        
+        # Import the JSON module.
+        import json
+
+        # Return the response.
+        return json.loads(request.result)
+    
+    # * method: run
+    def run(self, **kwargs):
+        '''
+        Run the application interface.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+        
+        # Parse request.
+        request = self.parse_request(**kwargs)
+
+        # Execute feature context and return session.
+        # Handle error and return response if triggered.
+        has_error, message = self.errors.handle_error(lambda: self.execute_feature(request, **kwargs))
+
+        # Handle error if present.
+        if has_error:
+            return message
+
+        # Handle response.
+        return self.handle_response(request)