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

tiferet/__init__.py

@@ -1,5 +1,6 @@
 # *** imports
 
 # ** app
-from .contexts import *
-from .domain import *
+from .contexts.app import AppContext as App
+from .commands import *
+from .contracts import *

tiferet/commands/__init__.py

@@ -0,0 +1,6 @@
+# *** imports
+
+# ** app
+from .settings import *
+from .core import *
+from ..models import *

tiferet/commands/app.py

@@ -0,0 +1,102 @@
+# *** imports
+
+# ** app
+from .settings import *
+from .core import import_dependency
+from ..contracts.app import AppRepository, AppInterface
+
+
+# *** commands:
+
+# ** command: import_app_repository
+class ImportAppRepository(Command):
+    '''
+    A command to import an app repository.
+    '''
+
+    # * method: execute
+    def execute(self,
+                app_repo_module_path: str = 'tiferet.proxies.yaml.app',
+                app_repo_class_name: str = 'AppYamlProxy',
+                app_repo_params: Dict[str, Any] = dict(
+                    app_config_file='app/configs/app.yml'
+                ),
+                **kwargs
+                ) -> AppRepository:
+        '''
+        Execute the command.
+
+        :param app_repo_module_path: The application repository module path.
+        :type app_repo_module_path: str
+        :param app_repo_class_name: The application repository class name.
+        :type app_repo_class_name: str
+        :param app_repo_params: The application repository parameters.
+        :type app_repo_params: dict
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The application repository instance.
+        :rtype: AppRepository
+        :raises TiferetError: If the import fails.
+        '''
+
+        # Import the app repository.
+        try:
+            result = import_dependency.execute(
+                app_repo_module_path,
+                app_repo_class_name
+            )(**app_repo_params)
+
+        # Raise an error if the import fails.
+        except TiferetError as e:
+            self.raise_error(
+                'APP_REPOSITORY_IMPORT_FAILED',
+                f'Failed to import app repository: {e}.',
+                str(e)
+            )
+
+        # Return the imported app repository.
+        return result
+
+
+# ** command: get_app_interface
+class GetAppInterface(Command):
+    '''
+    A command to get the application interface by its ID.
+    '''
+
+    def __init__(self, app_repo: AppRepository):
+        '''
+        Initialize the LoadAppInterface command.
+
+        :param app_repo: The application repository instance.
+        :type app_repo: AppRepository
+        '''
+        
+        # Set the application repository.
+        self.app_repo = app_repo
+
+    # * method: execute
+    def execute(self, interface_id: str, **kwargs) -> AppInterface:
+        '''
+        Execute the command to load the application interface.
+
+        :param interface_id: The ID of the application interface to load.
+        :type interface_id: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The loaded application interface.
+        :rtype: AppInterface
+        :raises TiferetError: If the interface cannot be found.
+        '''
+
+        # Load the application interface.
+        # Raise an error if the interface is not found.
+        interface = self.app_repo.get_interface(interface_id)
+        if not interface:
+            self.raise_error(
+                'APP_INTERFACE_NOT_FOUND',
+                f'App interface with ID {interface_id} not found.'
+            )
+
+        # Return the loaded application interface.
+        return interface

tiferet/commands/core.py

@@ -0,0 +1,124 @@
+# *** imports
+
+# ** core
+from typing import Dict, Any
+import os
+from importlib import import_module
+
+# ** app
+from .settings import *
+
+
+# *** commands
+
+# ** command: parse_parameter
+class ParseParameter(Command):
+    '''
+    A command to parse a parameter from a string.
+    '''
+
+    # * method: execute
+    def execute(self, parameter: str) -> Dict[str, Any]:
+        '''
+        Execute the command.
+
+        :param parameter: The parameter to parse.
+        :type parameter: str
+        :return: The parsed parameter.
+        :rtype: str
+        '''
+
+        # Parse the parameter.
+        try:
+
+            # If the parameter is an environment variable, get the value.
+            if parameter.startswith('$env.'):
+                result = os.getenv(parameter[5:])
+
+                # Raise an exception if the environment variable is not found.
+                if not result:
+                    raise Exception('Environment variable not found.')
+
+                # Return the result if the environment variable is found.
+                return result
+
+            # Return the parameter as is if it is not an environment variable.
+            return parameter
+
+        # Raise an error if the parameter parsing fails.
+        except Exception as e:
+            self.raise_error(
+                'PARAMETER_PARSING_FAILED',
+                f'Failed to parse parameter: {parameter}. Error: {str(e)}',
+                parameter,
+                str(e)
+            )
+
+
+# ** command: import_dependency
+class ImportDependency(Command):
+    '''
+    A command to import a dependency from a module.
+    '''
+
+    # * method: execute
+    def execute(self, module_path: str, class_name: str, **kwargs) -> Any:
+        '''
+        Execute the command.
+
+        :param module_path: The module path to import from.
+        :type module_path: str
+        :param class_name: The class name to import.
+        :type class_name: str
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The imported class instance.
+        :rtype: Any
+        '''
+
+        # Import module.
+        try:
+            return getattr(import_module(module_path), class_name)
+
+        # Raise an error if the dependency import fails.
+        except Exception as e:
+            self.raise_error(
+                'IMPORT_DEPENDENCY_FAILED',
+                f'Failed to import dependency: {module_path} from module {class_name}. Error: {str(e)}',
+                module_path,
+                class_name,
+                str(e),
+            )
+
+
+# ** command: raise_error
+class RaiseError(Command):
+    '''
+    A command to raise an error with a specific message.
+    '''
+
+    # * method: execute
+    def execute(self, error_code: str, message: str = None, *args) -> None:
+        '''
+        Execute the command.
+
+        :param error_code: The error code to raise.
+        :type error_code: str
+        :param args: Additional arguments for the error message.
+        :type args: tuple
+        '''
+
+        # Raise an error with the specified code and arguments.
+        raise TiferetError(error_code, message, *args)
+
+
+# *** command_variables
+
+# ** command_variable: parse_parameter
+parse_parameter = ParseParameter()
+
+# ** command_variable: import_dependency
+import_dependency = ImportDependency()
+
+# ** command_variable: raise_error
+raise_error = RaiseError()

tiferet/commands/dependencies.py

@@ -0,0 +1,76 @@
+# *** imports
+
+# ** core
+from typing import Any, Dict
+
+# ** infra
+from dependencies import Injector
+from dependencies.exceptions import DependencyError
+
+# ** app
+from ..commands import *
+
+
+# *** commands
+
+# ** command: create_injector
+class CreateInjector(Command):
+    '''
+    A command to create a dependencies (library) injector object with the given dependencies.
+    '''
+
+    def execute(self, name: str, dependencies: Dict[str, type], **kwargs) -> Any:
+        '''
+        Execute the command to create an injector object.
+
+        :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.
+        return type(name, (Injector,), {**dependencies, **kwargs})
+
+
+# ** command: get_dependency
+class GetDependency(Command):
+    '''
+    A command to get a dependency from the injector.
+    '''
+
+    def execute(self, injector: Injector, dependency_name: str) -> Any:
+        '''
+        Execute the command to get a dependency from the injector.
+
+        :param injector: The injector object.
+        :type injector: Injector
+        :param dependency_name: The name of the dependency to get.
+        :type dependency_name: str
+        :return: The dependency object.
+        :rtype: Any
+        '''
+    
+        # Return the dependency from the injector.
+        try:
+            return getattr(injector, dependency_name)
+        
+        # If the dependency does not exist or cannot be resolved, raise an error.
+        except DependencyError as e:
+            self.raise_error(
+                'INVALID_DEPENDENCY_ERROR',
+                f'Dependency {dependency_name} could not be resolved: {str(e)}',
+                dependency_name,
+                str(e)
+            )
+
+
+# *** command_variables
+
+# ** command_variable: create_injector
+create_injector = CreateInjector()
+
+# ** command_variable: get_dependency
+get_dependency = GetDependency()

tiferet/commands/settings.py

@@ -0,0 +1,101 @@
+# *** imports
+
+# ** core
+from typing import Dict, Any
+
+# ** app
+from ..configs import TiferetError
+
+
+# *** classes
+
+# ** class: command
+class Command(object):
+    '''
+    A base class for an app command object.
+    '''
+
+    # * method: execute
+    def execute(self, **kwargs) -> Any:
+        '''
+        Execute the service command.
+        
+        :param kwargs: The command arguments.
+        :type kwargs: dict
+        :return: The command result.
+        :rtype: Any
+        '''
+
+        # Not implemented.
+        raise NotImplementedError()
+
+    # * method: raise_error
+    def raise_error(self, error_code: str, message: str = None, *args):
+        '''
+        Raise an error with the given error code and arguments.
+
+        :param error_code: The error code.
+        :type error_code: str
+        :param message: The error message.
+        :type message: str
+        :param args: Additional error arguments.
+        :type args: tuple
+        '''
+
+        # Raise the TiferetError with the given error code and arguments.
+        raise TiferetError(
+            error_code,
+            message,
+            *args
+        )    
+
+    # * method: verify
+    def verify(self, expression: bool, error_code: str, message: str = None, *args):
+        '''
+        Verify an expression and raise an error if it is false.
+
+        :param expression: The expression to verify.
+        :type expression: bool
+        :param error_code: The error code.
+        :type error_code: str
+        :param message: The error message.
+        :type message: str
+        :param args: Additional error arguments.
+        :type args: tuple
+        '''
+
+        # Verify the expression.
+        try:
+            assert expression
+        except AssertionError:
+            self.raise_error(
+                error_code,
+                message,
+                *args
+            )
+
+    # * method: handle
+    @staticmethod
+    def handle(
+            command: type,
+            dependencies: Dict[str, Any] = {},
+            **kwargs) -> Any:
+        '''
+        Handle an app command instance.
+
+        :param command: The command to handle.
+        :type command: type
+        :param dependencies: The command dependencies.
+        :type dependencies: Dict[str, Any]
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The result of the command.
+        :rtype: Any
+        '''
+
+        # Get the command handler.
+        command_handler = command(**dependencies)
+
+        # Execute the command handler.
+        result = command_handler.execute(**kwargs)
+        return result

tiferet/configs/__init__.py

@@ -1,69 +1,5 @@
 # *** 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
+from .settings import *
+from ..models.settings import *

tiferet/configs/error.py

@@ -0,0 +1,48 @@
+# *** imports
+
+
+# *** configs
+
+# ** config: errors
+ERRORS = [
+    dict(
+        id='parameter_parsing_failed',
+        name='Parameter Parsing Failed',
+        error_code='PARAMETER_PARSING_FAILED',
+        message=[
+            dict(lang='en_US', text='Failed to parse parameter: {}. Error: {}')
+        ]
+    ),
+    dict(
+        id='import_dependency_failed',
+        name='Import Dependency Failed',
+        error_code='IMPORT_DEPENDENCY_FAILED',
+        message=[
+            dict(lang='en_US', text='Failed to import dependency: {} from module {}. Error: {}')
+        ]
+    ),
+    dict(
+        id='app_repository_import_failed',
+        name='App Repository Import Failed',
+        error_code='APP_REPOSITORY_IMPORT_FAILED',
+        message=[
+            dict(lang='en_US', text='Failed to import app repository: {}.')
+        ]
+    ),
+    dict(
+        id='app_interface_not_found',
+        name='App Interface Not Found',
+        error_code='APP_INTERFACE_NOT_FOUND',
+        message=[
+            dict(lang='en_US', text='App interface with ID {} not found.')
+        ]
+    ),
+    dict(
+        id='feature_command_loading_failed',
+        name='Feature Command Loading Failed',
+        error_code='FEATURE_COMMAND_LOADING_FAILED',
+        message=[
+            dict(lang='en_US', text='Failed to load feature command attribute: {}. Ensure the container attributes are configured with the appropriate default settings/flags. {}')
+        ]
+    )
+]

tiferet/configs/settings.py

@@ -0,0 +1,37 @@
+# *** imports
+
+# ** core
+import json
+
+
+# *** classes
+
+
+# ** class: tiferet_error
+class TiferetError(Exception):
+    '''
+    A base exception for Tiferet.
+    '''
+
+    def __init__(self, error_code: str, message: str = None, *args):
+        '''
+        Initialize the exception.
+        
+        :param error_code: The error code.
+        :type error_code: str
+        :param message: An optional error message for internal exception handling.
+        :type message: str
+        :param args: Additional arguments for the error message.
+        :type args: tuple
+        '''
+
+        # Set the error code and arguments.
+        self.error_code = error_code
+
+        # Initialize base exception with error data.
+        super().__init__(
+            json.dumps(dict(
+                error_code=error_code,
+                message=message,
+            )), *args
+        )

tiferet/contexts/__init__.py

@@ -1,8 +0,0 @@
-# *** imports
-
-# ** app
-from .app import AppContext, AppContext as App, AppInterfaceContext
-from .container import ContainerContext
-from .error import ErrorContext
-from .feature import FeatureContext
-from .request import RequestContext