tiferet 1.0.0a0__py3-none-any.whl

app/contexts/container.py

@@ -0,0 +1,167 @@
+# *** imports
+
+# ** core
+from typing import Any
+
+# ** app
+from ..configs import container
+from ..domain import *
+from ..services import container_service
+from ..repos.container import ContainerRepository
+
+
+# *** contexts
+
+# ** contexts: container_context
+class ContainerContext(Model):
+    '''
+    A container context is a class that is used to create a container object.
+    '''
+
+    # * attribute: attributes
+    attributes = DictType(
+        ModelType(ContainerAttribute), 
+        default={}, 
+        required=True,
+        metadata=dict(
+            description='The container attributes.'
+        ),
+    )
+
+    # * attribute: constants
+    constants = DictType(
+        StringType, 
+        default={},
+        metadata=dict(
+            description='The container constants.'
+        ),
+    )
+
+    # * attribute: feature_flag
+    feature_flag = StringType(
+        required=True,
+        default='core',
+        metadata=dict(
+            description='The feature flag.'
+        ),
+    )
+
+    # * attribute: data_flag
+    data_flag = StringType(
+        required=True,
+        metadata=dict(
+            description='The data flag.'
+        ),
+    )
+
+    # * method: init
+    def __init__(self, interface_id: str, container_repo: ContainerRepository, feature_flag: str, data_flag: str):
+        '''
+        Initialize the container context.
+
+        :param interface_id: The interface ID.
+        :type interface_id: str
+        :param container_repo: The container repository.
+        :type container_repo: ContainerRepository
+        :param interface_flag: The interface flag.
+        :type interface_flag: str
+        :param feature_flag: The feature flag.
+        :type feature_flag: str
+        :param data_flag: The data flag.
+        :type data_flag: str
+        '''
+
+        # Then set the interface id and injector flags.
+        self.interface_id = interface_id
+        self.feature_flag = feature_flag
+        self.data_flag = data_flag
+
+        # Add the default container attributes first if any.
+        self.attributes = vars(container)
+        
+        # Get and set attributes and constants.
+        attrs, consts = container_repo.list_all()
+        
+        # Add the attributes to the context.
+        for attr in attrs:
+            attribute: ContainerAttribute = self.attributes[attr.id]
+
+            # If the attribute already exists, set the dependencies.
+            if attr.id in self.attributes:
+                for dep in attr.dependencies:
+                    attribute.set_dependency(dep)
+                    continue
+
+            # Otherwise, add the attribute.
+            self.attributes[attr.id] = attr
+
+        # Add the constants to the context.
+        self.constants = consts
+
+    # * method: get_dependency
+    def get_dependency(self, attribute_id: str):
+        '''
+        Get a dependency from the container.
+
+        :param attribute_id: The attribute id of the dependency.
+        :type attribute_id: str
+        :return: The attribute value.
+        :rtype: Any
+        '''
+
+        # Create the injector.
+        injector = self.create_injector()
+
+        # Get attribute.
+        return getattr(injector, attribute_id)
+
+    # * method: create_injector
+    def create_injector(self, **kwargs) -> Any:
+        '''
+        Add a container to the context.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The container injector object.
+        :rtype: Any
+        '''
+
+        # Import dependencies.
+        dependencies = {}
+        for attribute_id in self.attributes:
+            attribute = self.attributes[attribute_id]
+            flag_map = dict(
+                feature=self.feature_flag,
+                data=self.data_flag,
+            )
+            dependencies[attribute_id] = self.import_dependency(attribute, flag_map[attribute.type])
+
+        # Create container.
+        return container_service.create_injector(self, 
+            self.interface_id, 
+            **self.constants, 
+            **dependencies, 
+            **kwargs)
+
+    # * method: import_dependency
+    def import_dependency(self, attribute: ContainerAttribute, flag: str) -> Any:
+        '''
+        Import a container attribute dependency from its configured Python module.
+
+        :param attribute: The container attribute.
+        :type attribute: ContainerAttribute
+        :param flag: The flag for the dependency.
+        :type flag: str
+        :return: The dependency.
+        :rtype: Any
+        '''
+
+        # Get the dependency.
+        dependency = attribute.get_dependency(flag)
+
+        # If there is no dependency and the attribute is a feature, import the default feature.
+        if not dependency and attribute.type == 'feature':
+            dependency = attribute.get_dependency('core')
+
+        # Import the dependency.
+        return container_service.import_dependency(dependency.module_path, dependency.class_name)

app/contexts/env.py

@@ -0,0 +1,109 @@
+# *** imports
+
+# ** infra
+from schematics import Model
+
+# ** app
+from .app import AppInterfaceContext
+from ..services import container_service
+from ..domain import *
+from ..repos.app import AppRepository
+
+
+# *** contexts
+
+# ** context: environment_context
+class EnvironmentContext(Model):
+    '''
+    An environment context is a class that is used to create and run the app interface context.
+    '''
+
+    # * attribute: interfaces
+    interfaces = DictType(
+        ModelType(AppInterface), 
+        default={},
+        metadata=dict(
+            description='The app interfaces keyed by interface ID.'
+        ),
+    )
+
+    # * method: init
+    def __init__(self, **kwargs):
+        '''
+        Initialize the environment context.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Load the app repository.
+        app_repo = self.load_app_repo()
+
+        # Load the interface configuration.
+        self.interfaces = {interface.id: interface for interface in app_repo.list_interfaces()}
+
+    # * method: start
+    def start(self, interface_id: str, **kwargs):
+        '''
+        Start the environment context.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Load the app context.
+        app_context = self.load_app_context(interface_id)
+
+        # Run the app context.
+        app_context.run(
+            interface_id=interface_id,
+            **kwargs
+        )
+
+    # * method: load_app_repo
+    def load_app_repo(self) -> AppRepository:
+        '''
+        Load the app interface repository.
+
+        :return: The app repository.
+        :rtype: AppRepository
+        '''
+
+        # Load the app repository configuration.
+        from ..configs.app import APP_REPO
+
+        # Return the app repository.
+        return container_service.import_dependency(APP_REPO.module_path, APP_REPO.class_name)(**APP_REPO.params)
+
+    # * method: load_app_context
+    def load_app_context(self, interface_id: str) -> AppInterfaceContext:
+        '''
+        Load the app context.
+
+        :param container: The app container.
+        :type container: AppContainer
+        :return: The app context.
+        :rtype: AppContext
+        '''
+
+        # Get the app interface.
+        app_interface: AppInterface = self.interfaces.get(interface_id)
+
+        # Get the dependencies for the app interface.
+        dependencies = dict(
+            interface_id=app_interface.id,
+            feature_flag=app_interface.feature_flag,
+            data_flag=app_interface.data_flag,
+            **app_interface.constants
+        )
+        for dep in app_interface.get_dependencies():
+            dependencies[dep.attribute_id] = container_service.import_dependency(dep.module_path, dep.class_name)
+
+        # Create the injector from the dependencies, constants, and the app interface.
+        injector = container_service.create_injector(
+            app_interface.id
+            **dependencies
+        )
+
+        # Return the app context.
+        return getattr(injector, 'app_context')

app/contexts/error.py

@@ -0,0 +1,95 @@
+# *** imports
+
+# ** core
+from typing import Any, Tuple
+
+# ** app
+from ..domain import *
+from ..repos.error import ErrorRepository
+
+
+# *** contexts
+
+# ** context: error_context
+class ErrorContext(Model):
+    '''
+    The error context object.
+    '''
+
+    # * attribute: errors
+    errors = DictType(
+        ModelType(Error),
+        required=True,
+        metadata=dict(
+            description='The errors lookup.'
+        )
+    )
+
+    # * method: init
+    def __init__(self, error_repo: ErrorRepository):
+        '''
+        Initialize the error context object.
+        
+        :param error_repo: The error repository.
+        :type error_repo: ErrorRepository
+        '''
+
+        # Create the errors lookup from the error repository.
+        errors = {error.name: error for error in error_repo.list()}
+
+        # Set the errors lookup and validate.
+        super().__init__(dict(errors=errors))
+        self.validate()
+
+    # * method: handle_error
+    def handle_error(self, execute_feature: Any) -> Tuple[bool, Any]:
+        '''
+        Handle an error.
+
+        :param func: The execute feature function to handle.
+        :type func: function
+        :return: Whether the error was handled.
+        :rtype: bool
+        '''
+
+        # Execute the feature function and handle the errors.
+        try:
+            execute_feature()
+            return (False, None)
+        except AssertionError as e:
+            return (True, self.format_error_response(str(e)))
+
+    # * method: format_error_response
+    def format_error_response(self, error_message: str, lang: str = 'en_US', **kwargs) -> Any:
+        '''
+        Format the error response.
+
+        :param error_message: The error message.
+        :type error_message: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The formatted error message.
+        :rtype: Any
+        '''
+
+        # Split error message.
+        try:
+            error_name, error_data = error_message.split(': ')
+        except ValueError:
+            error_name = error_message
+            error_data = None
+
+        # Format error data if present.
+        error_data = error_data.split(', ') if error_data else None
+
+        # Get error.
+        error = self.errors.get(error_name)
+
+        # Set error response.
+        error_response = dict(
+            message=error.format(lang, *error_data if error_data else []),
+            **kwargs
+        )
+
+        # Return error response.
+        return error_response

app/contexts/feature.py

@@ -0,0 +1,79 @@
+# *** imports
+
+# ** app
+from .container import ContainerContext
+from .request import RequestContext
+from ..domain import *
+from ..repos.feature import FeatureRepository
+
+
+# *** contexts
+
+# ** context: feature_context
+class FeatureContext(Model):
+
+    # * attribute: features
+    features = DictType(
+        ModelType(Feature),
+        required=True,
+        metadata=dict(
+            description='The features lookup.'
+        )
+    )
+
+    # * attribute: container
+    container = ModelType(
+        ContainerContext,
+        required=True,
+        metadata=dict(
+            description='The container context.'
+        ),
+    )
+
+    # * method: init
+    def __init__(self, feature_repo: FeatureRepository, container: ContainerContext):
+
+        # Set the features.
+        self.features = {feature.id: feature for feature in feature_repo.list()}
+
+        # Set the container context.
+        self.container = container
+        
+    # * method: execute
+    def execute(self, request: RequestContext, debug: bool = False, **kwargs):
+        '''
+        Execute the feature request.
+        
+        :param request: The request context object.
+        :type request: r.RequestContext
+        :param debug: Debug flag.
+        :type debug: bool
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Iterate over the feature commands.
+        for command in self.features[request.feature_id].commands:
+
+            # Get the feature command handler instance.
+            handler = self.container.get_dependency(command.attribute_id)
+
+            # Execute the handler function.
+            # Handle assertion errors if pass on error is not set.
+            try:
+                result = handler.execute(
+                    **request.data,
+                    **command.params,
+                    **kwargs)
+            except AssertionError as e:
+                if not command.pass_on_error:
+                    raise e 
+
+            # Return the result to the session context if return to data is set.
+            if command.return_to_data:
+                request.data[command.data_key] = result
+                continue
+
+            # Set the result in the request context.
+            if result:
+                request.set_result(result)

app/contexts/request.py

@@ -0,0 +1,108 @@
+# *** imports
+
+# ** core
+from typing import Dict
+
+# ** app
+from ..domain import *
+
+
+# *** contexts
+
+# ** context: request_context
+class RequestContext(Model):
+    '''
+    The context for an application request.
+    '''
+
+    # * attribute: feature_id
+    feature_id = StringType(
+        required=True,
+        metadata=dict(
+            description='The feature identifier for the request.'
+        )
+    )
+
+    # * attribute: headers
+    headers = DictType(
+        StringType(),
+        metadata=dict(
+            description='The request headers.'
+        )
+    )
+
+    # * attribute: data
+    data = DictType(
+        StringType(),
+        metadata=dict(
+            description='The request data.'
+        )
+    )
+
+    # * attribute: result
+    result = StringType(
+        metadata=dict(
+            description='The request result.'
+        )
+    )
+
+    # * method: init
+    def __init__(self, feature_id: str, headers: Dict[str, str], data: Dict[str, str]):
+        '''
+        Initialize the request context object.
+
+        :param feature_id: The feature identifier.
+        :type feature_id: str
+        :param headers: The request headers.
+        :type headers: dict
+        :param data: The request data.
+        :type data: dict
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
+
+        # Set the context attributes.
+        self.feature_id = feature_id
+        self.headers = headers
+        self.data = data
+
+        # Validate the context.
+        self.validate()
+
+    # * method: set_result
+    def set_result(self, result: Any):
+        '''
+        Set the serialized result value.
+
+        :param result: The result object.
+        :type result: Any
+        '''
+
+        # Import the json module.
+        import json
+
+        # Set the result as a serialized empty dictionary if it is None.
+        if not result:
+            self.result = json.dumps({})
+            return
+            
+        # If the result is a Model, convert it to a primitive dictionary and serialize it.
+        if isinstance(result, Model):
+            self.result = json.dumps(result.to_primitive())
+            return
+
+        # If the result is not a list, it must be a dict, so serialize it and set it.
+        if type(self.result) != list:
+            self.result = json.dumps(result)
+            return
+
+        # If the result is a list, convert each item to a primitive dictionary.
+        result_list = []
+        for item in result:
+            if isinstance(item, Model):
+                result_list.append(item.to_primitive())
+            else:
+                result_list.append(item)
+
+        # Serialize the result and set it.
+        self.result = json.dumps(result_list)

app/data/__init__.py

@@ -0,0 +1,4 @@
+from typing import List, Dict
+
+from .error import *
+from .feature import *