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

tiferet/contexts/app.py

@@ -1,104 +1,48 @@
 # *** imports
 
 # ** core
-from typing import Dict, Any, Tuple
+from typing import Dict, Any
 
 # ** app
-from .request import RequestContext
 from .feature import FeatureContext
 from .error import ErrorContext
-from .container import create_injector, import_dependency
-from ..domain import Model, StringType, DictType, ModelType
-from ..domain import AppInterface
-from ..repos import AppRepository
+from ..models.feature import Request
+from ..commands import (
+    Command,
+    ModelObject,
+    import_dependency,
+    TiferetError
+)
+from ..commands.app import (
+    AppInterface,
+    AppRepository,
+    ImportAppRepository
+)
+from ..commands.dependencies import create_injector, Injector
 
 
 # *** contexts
 
 # ** context: app_context
-class AppContext(Model):
-
-    # * attribute: app_repo_module_path
-    app_repo_module_path = StringType(
-        required=True,
-        default='tiferet.repos.app',
-        metadata=dict(
-            description='The application repository module path.'
-        ),
-    )
-
-    # * attribute: app_repo_class_name
-    app_repo_class_name = StringType(
-        required=True,
-        default='AppYamlProxy',
-        metadata=dict(
-            description='The application repository class name.'
-        ),
-    )
-
-    # * attribute: app_repo_parameters
-    app_repo_parameters = DictType(
-        StringType(),
-        default=dict(
-            app_config_file='app/configs/app.yml'
-        ),
-        metadata=dict(
-            description='The application repository parameters.'
-        ),
-    )
+class AppContext(object):
 
-    # * method: run
-    def run(self, interface_id: str, dependencies: Dict[str, Any] = {}, **kwargs) -> Any:
-        '''
-        Run the application interface.
-
-        :param interface_id: The interface ID.
-        :type interface_id: str
-        :param dependencies: The dependencies.
-        :type dependencies: dict
-        :param kwargs: Additional keyword arguments.
-        :type kwargs: dict
-        :return: The response.
-        :rtype: Any
-        '''
-
-        # Load the interface.
-        app_interface = self.load_interface(interface_id, **dependencies)
+    # * attribute: settings
+    settings: Dict[str, Any]
 
-        # Run the interface.
-        return app_interface.run(**kwargs)
-
-    # * method: load_interface
-    def load_interface(self, interface_id: str, **dependencies) -> AppInterface:
+    # * method: init
+    def __init__(self, settings: Dict[str, Any] = {}):
         '''
-        Load the application interface.
-
-        :param interface_id: The interface ID.
-        :type interface_id: str
-        :param dependencies: The dependencies.
-        :type dependencies: dict
-        :return: The application interface.
-        :rtype: AppInterface
+        Initialize the application context.
+        
+        :param settings: The application settings.
+        :type settings: dict
         '''
         
-        # Import the app repository.
-        app_repo = self.import_app_repo(
-            self.app_repo_module_path, 
-            self.app_repo_class_name, 
-            **self.app_repo_parameters
-        )
-
-        # Get the app interface.
-        app_interface = app_repo.get_interface(interface_id)
-
-        # Create the injector.
-        injector = self.create_injector(app_interface, **dependencies)
-
-        # Load the app interface context.
-        return getattr(injector, 'app_context')
+        # Assign settings attribute.
+        self.settings = settings
 
     # * method: import_app_repo
-    def import_app_repo(self, module_path: str, class_name: str, **kwargs) -> AppRepository:
+    def import_app_repo(self) -> AppRepository:
         '''
         Import the app repository.
 
@@ -112,92 +56,140 @@ class AppContext(Model):
         :rtype: AppRepository
         '''
 
-        # Try to import the module provided.
-        try:
-            return import_dependency(module_path, class_name)(**kwargs)
+        # Run and return the import app repository command.
+        return Command.handle(
+            ImportAppRepository,
+            **self.settings
+        )
+    
+    # * method: get_interface_settings
+    def get_interface_settings(self, interface_id: str) -> AppInterface:
+        '''
+        Get the settings for the application interface.
 
-        # Return None if nothing comes up.
-        except:
-            return None
-        
-    # ** method: create_injector
-    def create_injector(self, app_interface: AppInterface, **kwargs) -> Any:
+        :param interface_id: The interface ID.
+        :type interface_id: str
+        :return: The application interface settings.
+        :rtype: AppInterface
         '''
-        Create the injector.
+
+        # Import the app repository.
+        app_repo = self.import_app_repo()
+
+        # Get the app interface.
+        return app_repo.get_interface(interface_id)
+
+    # ** method: create_app_injector
+    def create_app_injector(self, app_interface: AppInterface) -> Injector:
+        '''
+        Create the app dependency injector.
 
         :param app_interface: The app interface.
         :type app_interface: AppInterface
         :param kwargs: Additional keyword arguments.
         :type kwargs: dict
-        :return: The injector.
-        :rtype: Any
+        :return: The dependencies injector.
+        :rtype: Injector
         '''
 
         # Retrieve the app context dependency.
-        app_context = app_interface.get_dependency('app_context')
-
-        # Get the dependencies for the app interface.
         dependencies = dict(
+            app_context=import_dependency.execute(
+                app_interface.module_path,
+                app_interface.class_name,
+            )
+        )
+
+        # Add the remaining app context attributes.
+        for attr in app_interface.attributes:
+            dependencies[attr.attribute_id] = import_dependency.execute(
+                attr.module_path,
+                attr.class_name,
+            )
+
+        # Create the injector.
+        injector = create_injector.execute(
+            app_interface.id, 
+            dependencies,
             interface_id=app_interface.id,
-            app_name=app_interface.name,
-            feature_flag=app_interface.feature_flag,
-            data_flag=app_interface.data_flag,
-            app_context=import_dependency(
-                app_context.module_path,
-                app_context.class_name,
-            ),
             **app_interface.constants
         )
 
-        # Add the remaining dependencies from the app interface.
-        dependencies.update({dep.attribute_id: import_dependency(dep.module_path, dep.class_name) for dep in app_interface.dependencies})
+        # Return the injector.
+        return injector
+    
+       # * method: load_interface
+    def load_interface(self, interface_id: str) -> 'AppInterfaceContext':
+        '''
+        Load the application interface.
 
-        # Create the injector.
-        return create_injector(app_interface.id, **dependencies, **kwargs)
+        :param interface_id: The interface ID.
+        :type interface_id: str
+        :return: The application interface context.
+        :rtype: AppInterfaceContext
+        '''
+
+        # Get the app interface.
+        app_interface = self.get_interface_settings(interface_id)
+
+        # Create the app injector.
+        injector = self.create_app_injector(app_interface)
+
+        # Load the app interface context.
+        return getattr(injector, 'app_context')
+
+    # * method: run
+    def run(self,
+            interface_id: str,
+            feature_id: str,
+            headers: Dict[str, str] = {},
+            data: Dict[str, Any] = {},
+            debug: bool = False,
+            **kwargs
+        ) -> Any:
+        '''
+        Run the application interface.
+
+        :param interface_id: The interface ID.
+        :type interface_id: str
+        :param dependencies: The dependencies.
+        :type dependencies: dict
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The response.
+        :rtype: Any
+        '''
+
+        # Load the interface.
+        app_interface = self.load_interface(interface_id)
+
+        # Run the interface.
+        return app_interface.run(
+            feature_id, 
+            headers, 
+            data, 
+            debug=debug,
+            **kwargs
+        )
 
 
 # ** context: app_interface_context
-class AppInterfaceContext(Model): 
+class AppInterfaceContext(object): 
     '''
     The application interface context is a class that is used to create and run the application interface.
     '''
 
     # * attribute: interface_id
-    interface_id = StringType(
-        required=True,
-        metadata=dict(
-            description='The interface ID.'
-        ),
-    )
-
-    # * 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.'
-        ),
-    )
+    interface_id: str
+
+    # * attribute: features
+    features: FeatureContext
+
+    # * attribute: errors
+    errors: ErrorContext
 
     # * method: init
-    def __init__(self, interface_id: str, app_name: str, feature_context: FeatureContext, error_context: ErrorContext):
+    def __init__(self, interface_id: str, features: FeatureContext, errors: ErrorContext):
         '''
         Initialize the application interface context.
 
@@ -205,85 +197,126 @@ class AppInterfaceContext(Model):
         :type interface_id: str
         :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
+        :param features: The feature context.
+        :type features: FeatureContext
+        :param errors: The error context.
+        :type errors: ErrorContext
         '''
 
-        # Initialize the model.
-        super().__init__(dict(
-            interface_id=interface_id,
-            name=app_name
-        ))
-        self.features = feature_context
-        self.errors = error_context
+        # Assign instance variables.
+        self.interface_id = interface_id
+        self.features = features
+        self.errors = errors
 
     # * method: parse_request
-    def parse_request(self, request: Any, **kwargs) -> Tuple[RequestContext, dict]:
+    def parse_request(self, headers: Dict[str, str] = {}, data: Dict[str, Any] = {}) -> Request:
         '''
         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
+        :param headers: The request headers.
+        :type headers: dict
+        :param data: The request data.
+        :type data: dict
+        :return: The parsed request.
+        :rtype: Request
         '''
 
-        # Parse request.
-        return request, kwargs
+        # Add the interface id to the request headers.
+        headers.update(dict(
+            interface_id=self.interface_id,
+        ))
+
+        # Create the request model object.
+        request = ModelObject.new(
+            Request,
+            headers=headers,
+            data=data,
+        )
+
+        # Return the request model object.
+        return request
     
     # * method: execute_feature
-    def execute_feature(self, request: RequestContext, **kwargs):
+    def execute_feature(self, feature_id: str, request: Request, **kwargs):
         '''
         Execute the feature context.
 
-        :param request: The request context.
-        :type request: RequestContext
+        :param feature_id: The feature identifier.
+        :type feature_id: str
+        :param request: The request.
+        :type request: Request
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
         '''
 
+        # Add the feature id to the request headers.
+        request.headers.update(dict(
+            feature_id=feature_id
+        ))
+
         # Execute feature context and return session.
-        self.features.execute(request, **kwargs)
-    
+        self.features.execute_feature(feature_id, request, **kwargs)
+
+    # * method: handle_error
+    def handle_error(self, error: Exception) -> Any:
+        '''
+        Handle the error and return the response.
+
+        :param error: The error to handle.
+        :type error: Exception
+        :return: The error response.
+        :rtype: Any
+        '''
+        
+        # Print the error to the console.
+        print('Error:', error)
+
+        # Handle the error and return the response.
+        return self.errors.handle_error(error)
+
     # * method: handle_response
-    def handle_response(self, request: RequestContext) -> Any:
+    def handle_response(self, request: Request) -> Any:
         '''
-        Handle the response.
+        Handle the response from the request.
 
         :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) if request.result else None
+        # Handle the response and return it.
+        return request.handle_response()
     
     # * method: run
-    def run(self, **kwargs):
+    def run(self, 
+            feature_id: str, 
+            headers: Dict[str, str] = {}, 
+            data: Dict[str, Any] = {},
+            **kwargs) -> Any:
         '''
-        Run the application interface.
-
+        Run the application interface by executing the feature.
+
+        :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
         '''
         
         # Parse request.
-        request, kwargs = self.parse_request(**kwargs)
+        request = self.parse_request(headers, data)
 
         # Execute feature context and return session.
         try:
-            self.execute_feature(request, **kwargs)
+            self.execute_feature(feature_id, request, **kwargs)
 
         # Handle error and return response if triggered.
-        except Exception as e:
-            print('Error:', e)
-            return self.errors.handle_error(e)
+        except TiferetError as e:
+            return self.handle_error(e)
 
         # Handle response.
         return self.handle_response(request)

tiferet/contexts/cache.py

@@ -0,0 +1,76 @@
+# *** imports
+
+# ** core
+from typing import Dict, Any
+
+# ** app
+from ..configs import *
+
+
+# *** contexts
+
+# ** context: cache_context
+class CacheContext(object):
+    '''
+    A context for managing cache operations within Tiferet applications.
+    '''
+    
+    # * attribute: cache (private)
+    _cache = Dict[str, Any]
+
+    # * method: init
+    def __init__(self, cache: Dict[str, Any] = {}):
+        '''
+        Initialize the cache context.
+        :param cache: An optional initial cache dictionary.
+        :type cache: dict
+        '''
+
+        # Initialize the cache with the provided dictionary.
+        self._cache = cache
+
+    # * method: get
+    def get(self, key: str) -> Any:
+        '''
+        Retrieve an item from the cache.
+        :param key: The key of the item to retrieve.
+        :type key: str
+        :return: The cached item or None if not found.
+        :rtype: Any
+        '''
+
+        # Return the item from the cache.
+        return self._cache.get(key)
+
+    # * method: set
+    def set(self, key: str, value: Any):
+        '''
+        Store an item in the cache.
+        :param key: The key to store the value under.
+        :type key: str
+        :param value: The value to store.
+        :type value: Any
+        '''
+
+        # Store the value in the cache.
+        self._cache[key] = value
+
+    # * method: delete
+    def delete(self, key: str):
+        '''
+        Remove an item from the cache.
+        :param key: The key of the item to remove.
+        :type key: str
+        '''
+
+        # Remove the item from the cache.
+        self._cache.pop(key, None)
+
+    # * method: clear
+    def clear(self):
+        '''
+        Clear all items from the cache.
+        '''
+
+        # Clear the cache.
+        self._cache.clear()