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

tiferet/models/container.py

@@ -0,0 +1,135 @@
+# *** imports
+
+# ** app
+from .settings import *
+
+
+# *** models
+
+# ** model: flagged_dependency
+class FlaggedDependency(ValueObject):
+    '''
+    A flagged container dependency object.
+    '''
+
+     # * attribute: module_path
+    module_path = StringType(
+        required=True,
+        metadata=dict(
+            description='The module path.'
+        )
+    )
+
+    # * attribute: class_name
+    class_name = StringType(
+        required=True,
+        metadata=dict(
+            description='The class name.'
+        )
+    )
+
+    # * attribute: flag
+    flag = StringType(
+        required=True,
+        metadata=dict(
+            description='The flag for the container dependency.'
+        )
+    )
+
+    # * attribute: parameters
+    parameters = DictType(
+        StringType,
+        default={},
+        metadata=dict(
+            description='The container dependency parameters.'
+        )
+    )
+
+
+# ** model: container_attribute
+class ContainerAttribute(Entity):
+    '''
+    An attribute that defines container injectior behavior.
+    '''
+
+    # * attribute: id
+    id = StringType(
+        required=True,
+        metadata=dict(
+            description='The unique identifier for the container attribute.'
+        )
+    )
+
+    # * attribute: module_path
+    module_path = StringType(
+        metadata=dict(
+            description='The non-flagged module path for the container attribute.'
+        )
+    )
+
+    # * attribute: class_name
+    class_name = StringType(
+        metadata=dict(
+            description='The non-flagged class name for the container attribute.'
+        )
+    )
+
+    # * attribute: parameters
+    parameters = DictType(
+        StringType,
+        default={},
+        metadata=dict(
+            description='The container attribute parameters.'
+        )
+    )
+
+    # * attribute: dependencies
+    dependencies = ListType(
+        ModelType(FlaggedDependency),
+        default=[],
+        metadata=dict(
+            description='The container attribute dependencies.'
+        )
+    )
+        
+    # * method: get_dependency
+    def get_dependency(self, *flags) -> FlaggedDependency:
+        '''
+        Gets a flagged container dependency by flag.
+
+        :param flags: The flags for the flagged container dependency.
+        :type flags: Tuple[str, ...]
+        :return: The flagged container dependency that matches the first provided flag.
+        :rtype: FlaggedDependency
+        '''
+
+        # Return the first dependency that matches any of the provided flags.
+        # Input flags are assumed ordinal in priority, so the first match is returned.
+        for flag in flags:
+            match = next(
+                (dependency for dependency in self.dependencies if dependency.flag == flag),
+                None
+            )
+            if match:
+                return match
+        
+        # Return None if no dependency matches the flags.
+        return None
+        
+    # * method: set_dependency
+    def set_dependency(self, dependency: FlaggedDependency):
+        '''
+        Sets a flagged container dependency.
+
+        :param dependency: The flagged container dependency to set.
+        :type dependency: ContainerDependency
+        '''
+
+        # Replace the value of the dependency if a dependency with the same flag exists.
+        for index, dep in enumerate(self.dependencies):
+            if dep.flag == dependency.flag:
+                self.dependencies[index] = dependency
+                return
+        
+        # Append the dependency otherwise.
+        self.dependencies.append(dependency)

tiferet/{domain → models}/error.py

@@ -1,19 +1,22 @@
 # *** imports 
 
 # ** core
-from ..domain import *
+from typing import List, Any
+
+# ** app
+from .settings import *
 
 
 # *** models
 
-# ** model: error_message0
+# ** model: error_message
 class ErrorMessage(ValueObject):
     '''
     An error message object.
     '''
 
     # * attribute: lang
-    lang = t.StringType(
+    lang = StringType(
         required=True,
         metadata=dict(
             description='The language of the error message text.'
@@ -21,30 +24,13 @@ class ErrorMessage(ValueObject):
     )
 
     # * attribute: text
-    text = t.StringType(
+    text = StringType(
         required=True,
         metadata=dict(
             description='The error message text.'
         )
     )
 
-    # * method: new
-    @staticmethod
-    def new(**kwargs) -> 'ErrorMessage':
-        '''Initializes a new ErrorMessage object.
-
-        :param kwargs: Additional keyword arguments.
-        :type kwargs: dict
-        :return: A new ErrorMessage object.
-        :rtype: ErrorMessage
-        '''
-
-        # Create and return a new ErrorMessage object.
-        return super(ErrorMessage, ErrorMessage).new(
-            ErrorMessage,
-            **kwargs
-        )
-
     # * method: format
     def format(self, *args) -> str:
         '''
@@ -71,7 +57,7 @@ class Error(Entity):
     '''
 
     # * attribute: name
-    name = t.StringType(
+    name = StringType(
         required=True,
         metadata=dict(
             description='The name of the error.'
@@ -79,15 +65,15 @@ class Error(Entity):
     )
 
     # * attribute: error_code
-    error_code = t.StringType(
+    error_code = StringType(
         metadata=dict(
             description='The unique code of the error.'
         )
     )
 
     # * attribute: message
-    message = t.ListType(
-        t.ModelType(ErrorMessage),
+    message = ListType(
+        ModelType(ErrorMessage),
         required=True,
         metadata=dict(
             description='The error message translations for the error.'
@@ -96,7 +82,7 @@ class Error(Entity):
 
     # * method: new
     @staticmethod
-    def new(name: str, id: str = None, error_code: str = None, **kwargs) -> 'Error':
+    def new(name: str, id: str = None, error_code: str = None, message: List[ErrorMessage | Any] = [], **kwargs) -> 'Error':
         '''Initializes a new Error object.
 
         :param name: The name of the error.
@@ -105,33 +91,42 @@ class Error(Entity):
         :type id: str
         :param error_code: The error code for the error.
         :type error_code: str
+        :param message: The error message translations for the error.
+        :type message: list 
         :param kwargs: Additional keyword arguments.
         :type kwargs: dict
         :return: A new Error object.
         '''
-
-        # Format name as upper case snake case.
-        name = name.upper().replace(' ', '_')
         
-        # Set Id as the name if not provided.
+        # Set Id as the name lower cased if not provided.
         if not id:
-            id = name
+            id = name.lower().replace(' ', '_')
 
-        # Set the error code as the name if not provided.
+        # Set the error code as the id upper cased if not provided.
         if not error_code:
-            error_code = name
+            error_code = id.upper().replace(' ', '_')
+
+        # Convert any error message dicts to ErrorMessage objects.
+        message_objs = []
+        for msg in message:
+            if isinstance(msg, ErrorMessage):
+                message_objs.append(msg)
+            elif not isinstance(msg, ErrorMessage) and isinstance(msg, dict):
+                message_objs.append(ValueObject.new(ErrorMessage, **msg))
+
 
         # Create and return a new Error object.
-        return super(Error, Error).new(
+        return Entity.new(
             Error,
             id=id,
             name=name,
             error_code=error_code,
+            message=message_objs,
             **kwargs
         )
 
-    # * method: format
-    def format(self, lang: str = 'en_US', *args) -> str:
+    # * method: format_message
+    def format_message(self, lang: str = 'en_US', *args) -> str:
         '''
         Formats the error message text for the specified language.
 
@@ -152,3 +147,58 @@ class Error(Entity):
 
             # Format the error message text.
             return msg.format(*args)
+        
+    # * method: format_response
+    def format_response(self, lang: str = 'en_US', *args, **kwargs) -> Any:
+        '''
+        Formats the error response for the specified language.
+
+        :param lang: The language of the error message text.
+        :type lang: str
+        :param args: The format arguments for the error message text.
+        :type args: tuple
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The formatted error response.
+        :rtype: dict
+        '''
+
+        # Format the error message text.
+        error_message = self.format_message(lang, *args)
+
+        # If the error message is not found, return no response.
+        if not error_message:
+            return None
+
+        # Return the formatted error response.
+        return dict(
+            error_code=self.error_code,
+            message=error_message,
+            **kwargs
+        )
+    
+    # * method: set_message
+    def set_message(self, lang: str, text: str):
+        '''
+        Sets the error message text for the specified language.
+
+        :param lang: The language of the error message text.
+        :type lang: str
+        :param text: The error message text.
+        :type text: str
+        '''
+
+        # Check if the message already exists for the language.
+        for msg in self.message:
+            if msg.lang == lang:
+                msg.text = text
+                return
+        
+        # If not, create a new ErrorMessage object and add it to the message list.
+        self.message.append(
+            ValueObject.new(
+                ErrorMessage,
+                lang=lang,
+                text=text
+            )
+        )

tiferet/{domain → models}/feature.py

@@ -1,11 +1,88 @@
 # *** imports
 
+# ** core
+from typing import Any
+import json
+
 # ** app
-from ..domain import *
+from .settings import *
 
 
 # *** models
 
+# ** model: request
+class Request(ValueObject):
+    '''
+    A request object.
+    '''
+
+    # * 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: set_result
+    def set_result(self, result: Any):
+        # 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, ModelObject):
+            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(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, ModelObject):
+                result_list.append(item.to_primitive())
+            else:
+                result_list.append(item)
+
+        # Serialize the result and set it.
+        self.result = json.dumps(result_list)
+
+    # * method: handle_response
+    def handle_response(self, **kwargs) -> Any:
+        '''
+        Handle the response.
+
+        :param kwargs: Additional keyword arguments.
+        :type kwargs: dict
+        :return: The response object.
+        :rtype: Any
+        '''
+
+        # Deserialize the result.
+        # Return None if the result is None.
+        return json.loads(self.result) if self.result else None
+
+
 # ** model: feature_command
 class FeatureCommand(ValueObject):
     '''
@@ -13,7 +90,7 @@ class FeatureCommand(ValueObject):
     '''
 
     # * attribute: name
-    name = t.StringType(
+    name = StringType(
         required=True,
         metadata=dict(
             description='The name of the feature handler.'
@@ -21,62 +98,44 @@ class FeatureCommand(ValueObject):
     )
 
     # * attribute: attribute_id
-    attribute_id = t.StringType(
+    attribute_id = StringType(
         required=True,
         metadata=dict(
             description='The container attribute ID for the feature command.'
         )
     )
 
-    # * attribute: params
-    params = t.DictType(
-        t.StringType(),
+    # * attribute: parameters
+    parameters = DictType(
+        StringType(),
         default={},
         metadata=dict(
             description='The custom parameters for the feature handler.'
         )
     )
 
-    # * attribute: return_to_data
-    return_to_data = t.BooleanType(
+    # * attribute: return_to_data (obsolete)
+    return_to_data = BooleanType(
+        default=False,
         metadata=dict(
             description='Whether to return the feature command result to the feature data context.'
         )
     )
 
     # * attribute: data_key
-    data_key = t.StringType(
+    data_key = StringType(
         metadata=dict(
             description='The data key to store the feature command result in if Return to Data is True.'
         )
     )
 
     # * attribute: pass_on_error
-    pass_on_error = t.BooleanType(
+    pass_on_error = BooleanType(
         metadata=dict(
             description='Whether to pass on the error if the feature handler fails.'
         )
     )
 
-    # * method: new
-    @staticmethod
-    def new(**kwargs) -> 'FeatureCommand':
-        '''Initializes a new FeatureCommand object.
-
-        :param kwargs: Additional keyword arguments.
-        :type kwargs: dict
-        :return: A new FeatureCommand object.
-        '''
-
-        # Create a new FeatureCommand object.
-        obj = FeatureCommand(dict(
-            **kwargs
-        ), strict=False)
-
-        # Validate and return the new FeatureCommand object.
-        obj.validate()
-        return obj
-
 
 # ** model: feature
 class Feature(Entity):
@@ -85,7 +144,7 @@ class Feature(Entity):
     '''
 
     # * attribute: name
-    name = t.StringType(
+    name = StringType(
         required=True,
         metadata=dict(
             description='The name of the feature.'
@@ -93,23 +152,23 @@ class Feature(Entity):
     )
 
     # * attribute: group_id
-    group_id = t.StringType(
+    group_id = StringType(
         required=True,
         metadata=dict(
             description='The context group identifier for the feature.'
         )
     )
 
-    # * attribute: description
-    description = t.StringType(
+    feature_key = StringType(
+        required=True,
         metadata=dict(
-            description='The description of the feature.'
+            description='The key of the feature.'
         )
     )
 
     # * attribute: commands
-    commands = t.ListType(
-        t.ModelType(FeatureCommand),
+    commands = ListType(
+        ModelType(FeatureCommand),
         default=[],
         metadata=dict(
             description='The command handler workflow for the feature.'
@@ -117,8 +176,8 @@ class Feature(Entity):
     )
 
     # * attribute: log_params
-    log_params = t.DictType(
-        t.StringType(),
+    log_params = DictType(
+        StringType(),
         default={},
         metadata=dict(
             description='The parameters to log for the feature.'
@@ -158,27 +217,28 @@ class Feature(Entity):
             description = name
 
         # Create and return a new Feature object.
-        return super(Feature, Feature).new(
+        return Entity.new(
             Feature,
             id=id,
             name=name,
             group_id=group_id,
+            feature_key=feature_key,
             description=description,
             **kwargs
         )
     
-    # * method: add_handler
-    def add_handler(self, handler: FeatureCommand, position: int = None):
-        '''Adds a handler to the feature.
+    # * method: add_command
+    def add_command(self, command: FeatureCommand, position: int = None):
+        '''Adds a service command to the feature.
 
-        :param handler: The handler to add.
-        :type handler: FeatureCommand
+        :param command: The service command to add.
+        :type command: FeatureCommand
         :param position: The position to add the handler at.
         :type position: int
         '''
 
-        # Add the handler to the feature.
+        # Add the feature command to the feature.
         if position is not None:
-            self.commands.insert(position, handler)
+            self.commands.insert(position, command)
         else:
-            self.commands.append(handler)
+            self.commands.append(command)