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

tiferet/contexts/feature.py

@@ -2,122 +2,159 @@
 
 # ** app
 from .container import ContainerContext
-from .request import RequestContext
-from ..domain import *
-from ..repos.feature import FeatureRepository
+from .cache import CacheContext
+from ..handlers.feature import FeatureService
+from ..models.feature import Request
+from ..commands import *
 
 
 # *** contexts
 
 # ** context: feature_context
-class FeatureContext(Model):
-
-    # * attribute: features
-    features = DictType(
-        ModelType(Feature),
-        required=True,
-        metadata=dict(
-            description='The features lookup.'
-        )
-    )
+class FeatureContext(object):
 
     # * attribute: container
-    container = ModelType(
-        ContainerContext,
-        required=True,
-        metadata=dict(
-            description='The container context.'
-        ),
-    )
+    container: ContainerContext
+
+    # * attribute: cache
+    cache: CacheContext
+
+    # * attribute: feature_service
+    feature_service: FeatureService
 
     # * method: init
-    def __init__(self, feature_repo: FeatureRepository, container_context: ContainerContext):
+    def __init__(self, 
+            feature_service: FeatureService,
+            container: ContainerContext,
+            cache: CacheContext = None):
         '''
         Initialize the feature context.
 
-        :param feature_repo: The feature repository.
-        :type feature_repo: FeatureRepository
-        :param container_context: The container context.
-        :type container_context: ContainerContext
+        :param feature_service: The feature service to use for executing feature requests.
+        :type feature_service: FeatureService
+        :param container: The container context for dependency injection.
+        :type container: ContainerContext
+        :param cache: The cache context to use for caching feature data.
+        :type cache: CacheContext
         '''
 
-        # Create the features.
-        features = {feature.id: feature for feature in feature_repo.list()}
-
-        # Set the features and container.
-        ## NOTE: There is a bug in the schematics library that does not allow us to initialize 
-        ## the feature context with the container context directly.
-        super().__init__(dict(
-            features=features,
-        ))
-        self.container = container_context
+        # Assign the attributes.
+        self.feature_service = feature_service
+        self.container = container
+        self.cache = cache if cache else CacheContext()
 
-    # * method: parse_parameter
-    def parse_parameter(self, parameter: str) -> str:
+    # * method: load_feature_command
+    def load_feature_command(self, attribute_id: str) -> Command:
         '''
-        Parse a parameter.
+        Load a feature command by its attribute ID from the container.
 
-        :param parameter: The parameter to parse.
-        :type parameter: str
-        :return: The parsed parameter.
-        :rtype: str
+        :param attribute_id: The attribute ID of the command to load.
+        :type attribute_id: str
+        :return: The command object.
+        :rtype: Command
         '''
 
-        # Parse the parameter.
-        return self.container.parse_parameter(parameter)
+        # Attempt to retrieve the command from the container.
+        try:
+            return self.container.get_dependency(attribute_id)
         
-    # * method: execute
-    def execute(self, request: RequestContext, debug: bool = False, **kwargs):
+        # If the command is not found, raise an error.
+        except Exception as e:
+            raise_error.execute(
+                'FEATURE_COMMAND_LOADING_FAILED',
+                f'Failed to load feature command attribute: {attribute_id}. Ensure the container attributes is configured with the appropriate default settings/flags.',
+                attribute_id,
+                str(e)
+        )
+            
+    # * method: handle_command
+    def handle_command(self,
+        command: Command, 
+        request: Request,
+        data_key: str = None,
+        pass_on_error: bool = False,
+        **kwargs
+    ):
         '''
-        Execute the feature request.
+        Handle the execution of a command with the provided request and command-handling options.
         
+        :param command: The command to execute.
+        :type command: Command
         :param request: The request context object.
-        :type request: r.RequestContext
+        :type request: Request
         :param debug: Debug flag.
         :type debug: bool
+        :param data_key: Optional key to store the result in the request data.
+        :type data_key: str
+        :param pass_on_error: If True, pass on the error instead of raising it.
+        :type pass_on_error: bool
         :param kwargs: Additional keyword arguments.
         :type kwargs: dict
         '''
 
-        # Assert the feature exists.
-        assert request.feature_id in self.features, 'FEATURE_NOT_FOUND, {}'.format(request.feature_id)
+        # Execute the command with the request data and parameters, and optional contexts.
+        try:
+            result = command.execute(
+                **request.data,
+                **kwargs
+            )
+        except Exception as e:
+            if not pass_on_error:
+                raise e
+        finally:
+            print(f'Command {command.attribute_id} execution failed: {e}' if 'e' in locals() else '')
+
+        # If a data key is provided, store the result in the request data.
+        if data_key:
+            request.data[data_key] = result
+
+        # Otherwise, set the result.
+        else:
+            request.set_result(result)
 
-        # Iterate over the feature commands.
-        for command in self.features[request.feature_id].commands:
+        
+    # * method: execute_feature
+    def execute_feature(self, feature_id: str, request: Request, **kwargs):
+        '''
+        Execute a feature by its ID with the provided request.
+        
+        :param request: The request object.
+        :type request: Request
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        '''
 
-            # Get the feature command handler instance.
-            handler = self.container.get_dependency(command.attribute_id)
+        # Try to get the feature by its id from the cache.
+        # If it does not exist, retrieve it from the feature handler and cache it.
+        feature = self.cache.get(feature_id)
+        if not feature:
+            feature = self.feature_service.get_feature(feature_id)
+            self.cache.set(feature_id, feature)
+
+        # Load the command dependencies from the container for the feature.
+        commands = [
+            self.load_feature_command(cmd.attribute_id)
+            for cmd in feature.commands
+        ]
+              
+        # Execute the feature with the request and commands.
+        for index, cmd in enumerate(commands):
 
             # Parse the command parameters
             params = {
-                param: 
-                self.parse_parameter(
-                    command.params.get(param)
-                ) 
-                for param in command.params
+                param: self.feature_service.parse_parameter(value, request)
+                for param, value in feature.commands[index].parameters.items()
             }
 
-            # Execute the handler function.
-            # Handle assertion errors if pass on error is not set.
-            try:
-                result = handler.execute(
-                    **request.data,
-                    **params,
-                    debug=debug,
-                    **kwargs)
-                
-                # 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)
-
-            # Handle assertion errors if pass on error is not set.
-            except AssertionError as e:
-                if not command.pass_on_error:
-                    raise e 
-
-            
+            # Execute the command with the request data and parameters.
+            self.handle_command(
+                cmd,
+                request,
+                **params,
+                features=self.feature_service,
+                container=self.container,
+                cache=self.cache,
+                **kwargs
+            )
+
+            

tiferet/contracts/__init__.py

@@ -0,0 +1,4 @@
+# *** imports
+
+# ** app
+from .settings import *

tiferet/contracts/app.py

@@ -0,0 +1,92 @@
+# *** imports
+
+# ** core
+from typing import List, Dict, Any
+
+# ** app
+from .settings import *
+
+
+# *** contracts
+
+# ** contract: app_attribute
+class AppAttribute(ModelContract):
+    '''
+    An app dependency contract that defines the dependency attributes for an app interface.
+    '''
+
+    # * attribute: module_path
+    module_path: str
+
+    # * attribute: class_name
+    class_name: str
+
+    # * attribute: attribute_id
+    attribute_id: str
+
+
+# ** contract: app_interface
+class AppInterface(ModelContract):
+    '''
+    An app interface settings contract that defines the settings for an app interface.
+    '''
+
+    # * attribute: id
+    id: str
+
+    # * attribute: name
+    name: str
+
+    # * attribute: module_path
+    module_path: str
+
+    # * attribute: class_name
+    class_name: str
+
+    # * attribute: description
+    description: str
+
+    # * attribute: feature_flag
+    feature_flag: str
+
+    # * attribute: data_flag
+    data_flag: str
+
+    # * attribute: attributes
+    attributes: List[AppAttribute]
+
+    # * attribute: constants
+    constants: Dict[str, Any]
+
+
+# ** interface: app_repository
+class AppRepository(Repository):
+    '''
+    An app repository is a class that is used to get an app interface.
+    '''
+
+    # * method: get_interface
+    @abstractmethod
+    def get_interface(self, app_name: str) -> AppInterface:
+        '''
+        Get the app interface settings by name.
+
+        :param app_name: The name of the app. 
+        :type app_name: str
+        :return: The app interface.
+        :rtype: AppInterface
+        '''
+        # Not implemented.
+        raise NotImplementedError()
+    
+    # * method: list_interfaces
+    @abstractmethod
+    def list_interfaces(self) -> List[AppInterface]:
+        '''
+        List all app inferface settings.
+
+        :return: A list of app settings.
+        :rtype: List[AppInterface]
+        '''
+        # Not implemented.
+        raise NotImplementedError()

tiferet/contracts/cache.py

@@ -0,0 +1,70 @@
+# *** imports
+
+# ** core
+from abc import abstractmethod
+from typing import Any
+
+# ** app
+from .settings import Service
+
+
+# ** contracts
+
+# ** contract: cache_service
+class CacheService(Service):
+    '''
+    A contract for cache services in Tiferet applications.
+    '''
+
+    # * method: get
+    @abstractmethod
+    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
+        '''
+        raise NotImplementedError(
+            'The get method must be implemented by the cache service.'
+        )
+
+    # * method: set
+    @abstractmethod
+    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
+        '''
+        raise NotImplementedError(
+            'The set method must be implemented by the cache service.'
+        )
+
+    # * method: delete
+    @abstractmethod
+    def delete(self, key: str):
+        '''
+        Delete an item from the cache.
+
+        :param key: The key of the item to delete.
+        :type key: str
+        '''
+        raise NotImplementedError(
+            'The delete method must be implemented by the cache service.'
+        )
+
+    # * method: clear
+    @abstractmethod
+    def clear(self):
+        '''
+        Clear the entire cache.
+        '''
+        raise NotImplementedError(
+            'The clear method must be implemented by the cache service.'
+        )

tiferet/contracts/container.py

@@ -0,0 +1,147 @@
+# *** imports
+
+# ** core
+from typing import List, Dict, Tuple, Any
+from abc import abstractmethod
+
+# ** app
+from .settings import *
+
+
+# *** contracts
+
+# ** contract: flagged_dependency
+class FlaggedDependency(ModelContract):
+    '''
+    A contract for flagged dependencies.
+    '''
+
+    # * attribute: flag
+    flag: str
+
+    # * attribute: parameters
+    parameters: Dict[str, str]
+
+    # * attribute: module_path
+    module_path: str
+
+    # * attribute: class_name
+    class_name: str
+
+
+# ** contract: container_attribute
+class ContainerAttribute(ModelContract):
+    '''
+    A contract defining container injector attributes.
+    '''
+
+    # * attribute: id
+    id: str
+
+    # * attribute: module_path
+    module_path: str
+
+    # * attribute: class_name
+    class_name: str
+
+    # * attribute: parameters
+    parameters: Dict[str, Any]
+
+    # * attribute: dependencies
+    dependencies: List[FlaggedDependency]
+
+    # * method: get_dependency
+    @abstractmethod
+    def get_dependency(self, *flags) -> FlaggedDependency:
+        '''
+        Gets a container dependency by flag.
+
+        :param flags: The flags for the flagged container dependency.
+        :type flags: Tuple[str, ...]
+        :return: The container dependency.
+        :rtype: FlaggedDependency
+        '''
+        raise NotImplementedError('get_dependency method must be implemented in the ContainerAttribute class.')
+
+
+# ** contract: container_repository
+class ContainerRepository(Repository):
+    '''
+    An interface for accessing container attributes.
+    '''
+
+    # * method: get_attribute
+    @abstractmethod
+    def get_attribute(self, attribute_id: str, flag: str = None) -> ContainerAttribute:
+        '''
+        Get the attribute from the container repository.
+
+        :param attribute_id: The attribute id.
+        :type attribute_id: str
+        :param flag: An optional flag to filter the attribute.
+        :type flag: str
+        :return: The container attribute.
+        :rtype: ContainerAttribute
+        '''
+        raise NotImplementedError('get_attribute method must be implemented in the ContainerRepository class.')
+
+    # * method: list_all
+    @abstractmethod
+    def list_all(self) -> Tuple[List[ContainerAttribute], Dict[str, str]]:
+        '''
+        List all the container attributes and constants.
+
+        :return: The list of container attributes and constants.
+        :rtype: Tuple[List[ContainerAttribute], Dict[str, str]]
+        '''
+        raise NotImplementedError('list_all method must be implemented in the ContainerRepository class.')
+
+
+# ** contract: container_service
+class ContainerService(Service):
+    '''
+    An interface for accessing container dependencies.
+    '''
+
+   # * method: list_all
+    @abstractmethod
+    def list_all(self) -> Tuple[List[ContainerAttribute], Dict[str, str]]:
+        '''
+        List all container attributes and constants.
+
+        :return: A tuple containing a list of container attributes and a dictionary of constants.
+        :rtype: Tuple[List[ContainerAttribute], Dict[str, str]]
+        '''
+        raise NotImplementedError('list_all method must be implemented in the ContainerService class.')
+    
+     # * method: load_constants
+    @abstractmethod
+    def load_constants(self, attributes: List[ContainerAttribute], constants: Dict[str, str] = {}, flags: List[str] = []) -> Dict[str, str]:
+        '''
+        Load constants from the container attributes.
+
+        :param attributes: The list of container attributes.
+        :type attributes: List[ContainerAttribute]
+        :param constants: The dictionary of constants.
+        :type constants: Dict[str, str]
+        :param flags: Optional list of flags to filter the constants.
+        :type flags: List[str]
+        :return: A dictionary of constants.
+        :rtype: Dict[str, str]
+        '''
+        raise NotImplementedError('load_constants method must be implemented in the ContainerService class.')
+    
+    # * method: get_dependency_type
+    @abstractmethod
+    def get_dependency_type(self, attribute: ContainerAttribute, flags: List[str] = []) -> type:
+        '''
+        Get the type of a container attribute.
+
+        :param attribute: The container attribute.
+        :type attribute: ContainerAttribute
+        :param flags: Optional list of flags to filter the dependency type.
+        :type flags: List[str]
+        :return: The type of the container attribute.
+        :rtype: type
+        '''
+        raise NotImplementedError('get_dependency_type method must be implemented in the ContainerService class.')