tiferet 1.0.0a19__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

tiferet/contexts/container.py

@@ -1,50 +1,13 @@
 # *** imports
 
 # ** core
-import os
-from typing import Any
+from typing import Any, List
 
 # ** app
-from ..domain import *
-from ..repos.container import ContainerRepository
-
-
-# *** functions
-
-# ** function: create_injector
-def create_injector(name: str, **dependencies) -> Any:
-    '''
-    Create an injector object with the given dependencies.
-
-    :param name: The name of the injector.
-    :type name: str
-    :param dependencies: The dependencies.
-    :type dependencies: dict
-    :return: The injector object.
-    :rtype: Any
-    '''
-
-    # Create container.
-    from dependencies import Injector
-    return type(f'{name.capitalize()}Container', (Injector,), {**dependencies})
-
-
-# ** function: import_dependency
-def import_dependency(module_path: str, class_name: str) -> Any:
-    '''
-    Import an object dependency from its configured Python module.
-
-    :param module_path: The module path.
-    :type module_path: str
-    :param class_name: The class name.
-    :type class_name: str
-    :return: The dependency.
-    :rtype: Any
-    '''
-
-    # Import module.
-    from importlib import import_module
-    return getattr(import_module(module_path), class_name)
+from .cache import CacheContext
+from ..handlers.container import ContainerService
+from ..commands import *
+from ..commands.dependencies import *
 
 
 # *** contexts
@@ -55,178 +18,117 @@ class ContainerContext(Model):
     A container context is a class that is used to create a container object.
     '''
 
-    # * attribute: interface_id
-    interface_id = StringType(
-        required=True,
-        metadata=dict(
-            description='The interface ID.'
-        ),
-    )
-
-    # * 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.'
-        ),
-    )
+    # * attribute: cache
+    cache: CacheContext
+
+    # * attribute: container_service
+    container_service: ContainerService
+
 
     # * method: init
-    def __init__(self, interface_id: str, container_repo: ContainerRepository, feature_flag: str, data_flag: str):
+    def __init__(self, container_service: ContainerService, cache: CacheContext = None):
         '''
         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
+        :param container_service: The container service to use for executing container requests.
+        :type container_service: ContainerService
+        :param cache: The cache context to use for caching container data.
+        :type cache: CacheContext
         '''
 
-        # Add the attributes and constants as empty dictionaries.
-        attributes = {}
-        constants = {}
-        
-        # Get and set attributes and constants.
-        attrs, consts = container_repo.list_all()
-
-        # Parse the constants.
-        constants.update({key: self.parse_parameter(consts[key]) for key in consts})
-        
-        # Add the attributes to the context.
-        for attr in attrs:
-            
-            # If the attribute already exists, set the dependencies.
-            if attr.id in attributes:
-                for dep in attr.dependencies:
-                    attr.set_dependency(dep)
-                    continue
-
-            # Otherwise, add the attribute.
-            attributes[attr.id] = attr
-
-            # Add any parameters as constants.
-            for dep in attr.dependencies:
-                for key in dep.parameters:
-                    constants[key] = self.parse_parameter(dep.parameters[key])
-
-        # Add the constants and attributes to the context.
-        super().__init__(dict(
-            interface_id=interface_id,
-            feature_flag=feature_flag,
-            data_flag=data_flag,
-            attributes=attributes,
-            constants=constants,
-        ))
-
+        # Assign the attributes.
+        self.container_service = container_service
+        self.cache = cache if cache else CacheContext()
     
-    # * method: parse_environment_parameter
-    def parse_parameter(self, parameter: str) -> str:
-
-        # If the parameter is an environment variable, get the value.
-        if parameter.startswith('$env.'):
-            return os.getenv(parameter[5:])
-        
-        # Otherwise, return the parameter.
-        return parameter
-
-    # * method: get_dependency
-    def get_dependency(self, attribute_id: str):
+    # * method: create_cache_key
+    def create_cache_key(self, flags: List[str] = None) -> str:
         '''
-        Get a dependency from the container.
+        Create a cache key for the container.
 
-        :param attribute_id: The attribute id of the dependency.
-        :type attribute_id: str
-        :return: The attribute value.
-        :rtype: Any
+        :param flags: The feature or data flags to use.
+        :type flags: List[str]
+        :return: The cache key.
+        :rtype: str
         '''
 
-        # Create the injector.
-        injector = self.create_injector()
-
-        # Get attribute.
-        return getattr(injector, attribute_id)
+        # Create the cache key from the flags.
+        return f"feature_container{'_' + '_'.join(flags) if flags else ''}"
 
-    # * method: create_injector
-    def create_injector(self, **kwargs) -> Any:
+    # * method: build_injector
+    def build_injector(self,
+            flags: List[str] = None,
+        ) -> Injector:
         '''
-        Add a container to the context.
+        Build the container injector.
 
-        :param kwargs: Additional keyword arguments.
-        :type kwargs: dict
+        :param flags: The feature or data flags to use.
+        :type flags: List[str]
         :return: The container injector object.
-        :rtype: Any
+        :rtype: Injector
         '''
 
-        # 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 the cache key for the injector from the flags.
+        cache_key = self.create_cache_key(flags)
+
+        # Check if the injector is already cached.
+        cached_injector = self.cache.get(cache_key)
+        if cached_injector:
+            return cached_injector
 
-        # Create container.
-        return create_injector( 
-            self.interface_id, 
-            **self.constants, 
-            **dependencies, 
-            **kwargs)
+        # Get all attributes and constants from the container service.
+        attributes, constants = self.container_service.list_all()
 
-    # * method: import_dependency
-    def import_dependency(self, attribute: ContainerAttribute, flag: str) -> Any:
+        # Load constants from the attributes.
+        constants = self.container_service.load_constants(attributes, constants, flags)
+
+        # Create the dependencies for the injector.
+        dependencies = {}
+        for attr in attributes:
+            try:
+                dependencies[attr.id] = self.container_service.get_dependency_type(attr, flags)
+            except TiferetError as e:
+                raise e
+                    
+
+        # Create the injector with the dependencies and constants.
+        injector = create_injector.execute(
+            cache_key,
+            dependencies=dependencies,
+            **constants
+        )
+
+        # Cache the injector.
+        self.cache.set(cache_key, injector)
+
+        # Return the injector.
+        return injector
+    
+    # * method: get_dependency
+    def get_dependency(self, attribute_id: str, flags: List[str] = []) -> Any:
         '''
-        Import a container attribute dependency from its configured Python module.
+        Get an injector dependency by its attribute ID.
 
-        :param attribute: The container attribute.
-        :type attribute: ContainerAttribute
-        :param flag: The flag for the dependency.
-        :type flag: str
-        :return: The dependency.
+        :return: The container attribute.
         :rtype: Any
         '''
 
-        # Get the dependency.
-        dependency = attribute.get_dependency(flag)
+        # Get the cached injector.
+        injector = self.build_injector(flags)
 
-        # 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')
+        # Get the dependency from the injector.
+        dependency = get_dependency.execute(
+            injector=injector,
+            dependency_name=attribute_id,
+        )
+        
+        # Raise an error if the dependency is not found.
+        if not dependency:
+            raise_error.execute(
+                'CONTAINER_DEPENDENCY_NOT_FOUND',
+                f'Dependency with ID {attribute_id} not found in container with flags {flags}.',
+                attribute_id,
+                flags
+            )
 
-        # Import the dependency.
-        return import_dependency(dependency.module_path, dependency.class_name)
+        # Return the dependency.
+        return dependency

tiferet/contexts/error.py

@@ -4,71 +4,97 @@
 from typing import Any, Tuple, List
 
 # ** app
-from ..domain import *
-from ..repos.error import ErrorRepository
+from .cache import CacheContext
+from ..configs.error import ERRORS
+from ..handlers.error import ErrorService
+from ..models.error import Error, ModelObject
+from ..commands import raise_error, TiferetError
 
 
 # *** contexts
 
 # ** context: error_context
-class ErrorContext(Model):
+class ErrorContext(object):
     '''
     The error context object.
     '''
 
-    # * attribute: errors
-    errors = DictType(
-        ModelType(Error),
-        required=True,
-        metadata=dict(
-            description='The errors lookup.'
-        )
-    )
+    # * attribute: error_service
+    error_service: ErrorService
+
+    # * attribute: cache
+    cache: CacheContext
 
     # * method: init
-    def __init__(self, error_repo: ErrorRepository):
+    def __init__(self, error_service: ErrorService, cache: CacheContext = None):
         '''
-        Initialize the error context object.
-        
-        :param error_repo: The error repository.
-        :type error_repo: ErrorRepository
+        Initialize the error context.
+
+        :param error_service: The error service to use for handling errors.
+        :type error_service: ErrorService
+        :param cache: The cache context to use for caching error data.
+        :type cache: CacheContext
+        '''
+
+        # Assign the attributes.
+        self.error_service = error_service
+        self.cache = cache if cache else CacheContext()
+
+    # * method: load_errors
+    def load_errors(self) -> List[Error]:
         '''
+        Load errors from the error service.
 
-        # Create the errors lookup from the error repository.
-        errors = {error.id: error for error in error_repo.list()}
+        :return: The list of loaded errors.
+        :rtype: List[Error]
+        '''
 
-        # Add custom errors.
-        errors.update({error.id: error for error in self.load_custom_errors()})
+        # Convert configured errors to a list of error objects.
+        configured_errors = [
+            ModelObject.new(
+                Error,
+                **error_data
+        ) for error_data in ERRORS]
 
-        # Set the errors lookup and validate.
-        super().__init__(dict(errors=errors))
-        self.validate()
+        # Load errors from the error service, including any configured errors.
+        return self.error_service.load_errors(configured_errors)
 
-    # * method: load_custom_errors
-    def load_custom_errors(self) -> List[Error]:
+    
+    # * method: get_error_by_code
+    def get_error_by_code(self, error_code: str) -> Error:
         '''
-        Load custom errors.
+        Get an error by its code.
 
-        :return: The list of custom errors.
-        :rtype: list
+        :param error_code: The error code to retrieve.
+        :type error_code: str
+        :return: The error object.
+        :rtype: Error
         '''
 
-        # Get custom errors.
-        return [
-            Error.new(
-                name='FEATURE_NOT_FOUND',
-                error_code='FEATURE_NOT_FOUND',
-                message=[
-                    ErrorMessage.new(
-                        lang='en_US',
-                        text='The feature with ID was not found: {}'
-                    )
-                ]
+        # Check to see if there is an error map in the cache.
+        error_map = self.cache.get('error_map')
+
+        # If there is no error map or the error code does not exist in the map,
+        # we need to load the errors from the error service and create a new error map.
+        # This is to ensure that we always have the latest errors available.
+        if not error_map or not error_map.get(error_code):
+            errors = self.load_errors()
+            error_map = {error.error_code: error for error in errors}
+            self.cache.set('error_map', error_map)
+
+        # Raise an error if the error code does not exist in the error map.
+        if not error_map or error_code not in error_map:
+            raise_error.execute(
+                'ERROR_NOT_FOUND', 
+                f'Error not found: {error_code}.',
+                error_code
             )
-        ]
+
+        # Return the error object from the error map.
+        return error_map.get(error_code)
 
     # * method: handle_error
-    def handle_error(self, exception: Exception, lang: str = 'en_US', **kwargs) -> Tuple[bool, Any]:
+    def handle_error(self, exception: TiferetError, lang: str = 'en_US', **kwargs) -> Tuple[bool, Any]:
         '''
         Handle an error.
 
@@ -80,47 +106,19 @@ class ErrorContext(Model):
         :rtype: bool
         '''
 
-        # Execute the feature function and handle the errors.
-        if isinstance(exception, AssertionError):
-            return self.format_error_response(str(exception), lang, **kwargs)
+        # Raise the exception if it is not a Tiferet error.
+        if not isinstance(exception, TiferetError):
+            raise exception
 
-    # * method: format_error_response
-    def format_error_response(self, error_message: str, lang: str, **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 into error name and data.
-        message_tokens = error_message.split(': ', 1)
-
-        # Get error name and data.
-        if len(message_tokens) > 1:
-            error_name, error_data = message_tokens
-        else:
-            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 []),
-            error_code=error.error_code,
+        # Get the error by its code from the error service.
+        error = self.get_error_by_code(exception.error_code)
+        
+        # Format the error response.
+        error_response = error.format_response(
+            lang,
+            *exception.args[1:],
             **kwargs
         )
 
-        # Return error response.
+        # Return the error response.
         return error_response
-
-