orionis 0.409.0__py3-none-any.whl → 0.411.0__py3-none-any.whl

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.409.0"
+VERSION = "0.411.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/support/patterns/singleton/meta.py

@@ -6,8 +6,25 @@ T = TypeVar('T')
 
 class Singleton(type):
     """
-    Thread-safe + Async-safe singleton metaclass.
-    Works for both synchronous and asynchronous contexts.
+    Thread-safe and async-safe singleton metaclass.
+
+    Ensures that only one instance of a class exists, regardless of whether the code is running in a synchronous or asynchronous context. This metaclass provides both a synchronous (`__call__`) and asynchronous (`__acall__`) method for instance creation, using appropriate locking mechanisms to prevent race conditions in multi-threaded or async environments.
+
+    Attributes
+    ----------
+    _instances : Dict[Type[T], T]
+        Stores singleton instances for each class using this metaclass.
+    _lock : threading.Lock
+        Thread lock for synchronizing instance creation in synchronous contexts.
+    _async_lock : asyncio.Lock
+        Async lock for synchronizing instance creation in asynchronous contexts.
+
+    Methods
+    -------
+    __call__(cls, *args, **kwargs)
+        Synchronously creates or retrieves the singleton instance.
+    __acall__(cls, *args, **kwargs)
+        Asynchronously creates or retrieves the singleton instance.
     """
 
     _instances: Dict[Type[T], T] = {}
@@ -16,41 +33,74 @@ class Singleton(type):
 
     def __call__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
         """
-        Creates and returns a singleton instance of the class.
+        Synchronously creates or retrieves a singleton instance of the class.
 
-        If an instance of the class does not already exist, this method acquires a lock to ensure thread safety,
-        creates a new instance using the provided arguments, and stores it in the class-level _instances dictionary.
-        Subsequent calls return the existing instance.
+        This method ensures that only one instance of the class is created, even in multi-threaded environments.
+        If the instance does not exist, it acquires a thread lock to prevent race conditions, creates the instance,
+        and stores it in the class-level `_instances` dictionary. If the instance already exists, it simply returns
+        the existing instance.
 
-        Args:
-            *args: Positional arguments to pass to the class constructor.
-            **kwargs: Keyword arguments to pass to the class constructor.
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to pass to the class constructor.
+        **kwargs : Any
+            Keyword arguments to pass to the class constructor.
 
-        Returns:
-            T: The singleton instance of the class.
+        Returns
+        -------
+        T
+            The singleton instance of the class.
         """
+
+        # Check if the instance already exists
         if cls not in cls._instances:
+
+            # Acquire the thread lock to ensure thread safety
             with cls._lock:
+
+                # Double-check if the instance was created while waiting for the lock
                 if cls not in cls._instances:
+
+                    # Create and store the singleton instance
                     cls._instances[cls] = super().__call__(*args, **kwargs)
+
+        # Return the singleton instance
         return cls._instances[cls]
 
     async def __acall__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
         """
         Asynchronously creates or retrieves a singleton instance of the class.
 
-        If an instance of the class does not exist, acquires an asynchronous lock to ensure thread safety,
-        creates the instance, and stores it. Subsequent calls return the existing instance.
+        This method ensures that only one instance of the class is created, even in asynchronous contexts.
+        If the instance does not exist, it acquires an asynchronous lock to prevent race conditions,
+        creates the instance, and stores it in the class-level `_instances` dictionary. If the instance
+        already exists, it simply returns the existing instance.
 
-        Args:
-            *args: Positional arguments to pass to the class constructor.
-            **kwargs: Keyword arguments to pass to the class constructor.
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to pass to the class constructor.
+        **kwargs : Any
+            Keyword arguments to pass to the class constructor.
 
-        Returns:
-            T: The singleton instance of the class.
+        Returns
+        -------
+        T
+            The singleton instance of the class.
         """
+
+        # Check if the instance already exists
         if cls not in cls._instances:
+
+            # Acquire the asynchronous lock to ensure async safety
             async with cls._async_lock:
+
+                # Double-check if the instance was created while waiting for the lock
                 if cls not in cls._instances:
+
+                    # Create and store the singleton instance
                     cls._instances[cls] = super().__call__(*args, **kwargs)
+
+        # Return the singleton instance
         return cls._instances[cls]

orionis/support/wrapper/dot_dict.py

@@ -1,13 +1,6 @@
 from typing import Any, Optional, Dict
 
 class DotDict(dict):
-    """
-    Dictionary subclass with attribute-style access and recursive dot notation.
-
-    This class allows accessing dictionary keys as attributes, with automatic
-    conversion of nested dictionaries to DotDict instances. Missing keys return
-    None instead of raising AttributeError or KeyError.
-    """
 
     __slots__ = ()
 
@@ -16,7 +9,7 @@ class DotDict(dict):
         Retrieve the value associated with the given key as an attribute.
 
         If the value is a dictionary (but not already a DotDict), it is converted
-        to a DotDict and updated in-place. Returns None if the key does not exist.
+        to a DotDict and updated in-place. If the key does not exist, returns None.
 
         Parameters
         ----------
@@ -25,56 +18,92 @@ class DotDict(dict):
 
         Returns
         -------
-        value : Any or None
-            The value associated with the key, converted to DotDict if applicable,
-            or None if the key is not found.
+        Any or None
+            The value associated with the key. If the value is a dict, it is converted
+            to a DotDict before returning. Returns None if the key is not present.
+
+        Notes
+        -----
+        This method allows attribute-style access to dictionary keys. If the value
+        is a plain dictionary, it is automatically wrapped as a DotDict for consistency.
         """
         try:
-            value = self[key]
+            value = self[key]  # Attempt to retrieve the value by key
+            # Convert plain dicts to DotDict for attribute access
             if isinstance(value, dict) and not isinstance(value, DotDict):
                 value = DotDict(value)
-                self[key] = value
+                self[key] = value  # Update the value in-place
             return value
         except KeyError:
+            # Return None if the key does not exist
             return None
 
     def __setattr__(self, key: str, value: Any) -> None:
         """
-        Set an attribute on the DotDict instance.
+        Assign a value to an attribute of the DotDict instance.
 
-        If the value assigned is a dictionary (but not already a DotDict), it is
-        automatically converted into a DotDict. The attribute is stored as a
-        key-value pair in the underlying dictionary.
+        This method enables attribute-style assignment for dictionary keys. If the
+        assigned value is a plain dictionary (not a DotDict), it is automatically
+        converted to a DotDict for consistency and recursive attribute access.
 
         Parameters
         ----------
         key : str
-            The attribute name to set.
+            The attribute name to assign.
         value : Any
-            The value to assign to the attribute. If it's a dict, it will be
-            converted to a DotDict.
+            The value to assign to the attribute. If it is a dict (but not a DotDict),
+            it will be converted to a DotDict before assignment.
+
+        Returns
+        -------
+        None
+            This method does not return a value.
+
+        Notes
+        -----
+        The attribute is stored as a key-value pair in the underlying dictionary.
+        This allows seamless attribute-style access and assignment for dictionary keys.
         """
+
+        # Convert plain dicts to DotDict for recursive attribute access
         if isinstance(value, dict) and not isinstance(value, DotDict):
             value = DotDict(value)
+
+        # Store the value in the underlying dictionary using the key
         self[key] = value
 
     def __delattr__(self, key: str) -> None:
         """
-        Delete the attribute with the specified key from the dictionary.
+        Remove an attribute from the DotDict instance.
+
+        This method deletes the key-value pair corresponding to the given attribute name
+        from the underlying dictionary. If the key does not exist, an AttributeError is raised.
 
         Parameters
         ----------
         key : str
-            The name of the attribute to delete.
+            The name of the attribute to remove.
+
+        Returns
+        -------
+        None
+            This method does not return a value.
 
         Raises
         ------
         AttributeError
-            If the attribute does not exist.
+            If the specified attribute does not exist in the DotDict.
+
+        Notes
+        -----
+        This method enables attribute-style deletion for dictionary keys, allowing
+        seamless removal of items using dot notation.
         """
         try:
+            # Attempt to delete the key from the dictionary
             del self[key]
         except KeyError as e:
+            # Raise AttributeError if the key is not present
             raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{key}'") from e
 
     def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
@@ -82,7 +111,8 @@ class DotDict(dict):
         Retrieve the value associated with the given key, returning a default value if the key is not found.
 
         If the retrieved value is a plain dictionary (not a DotDict), it is converted to a DotDict,
-        stored back in the dictionary, and then returned.
+        stored back in the dictionary, and then returned. This ensures consistent attribute-style access
+        for nested dictionaries.
 
         Parameters
         ----------
@@ -93,64 +123,113 @@ class DotDict(dict):
 
         Returns
         -------
-        value : Any or None
-            The value associated with the key, converted to a DotDict if it is a dict,
-            or the default value if the key is not present.
+        Any or None
+            The value associated with the key, converted to a DotDict if it is a dict.
+            If the key is not present, returns the specified default value.
+
+        Notes
+        -----
+        This method overrides the standard dict.get() to provide automatic conversion of nested
+        dictionaries to DotDict instances, enabling recursive attribute-style access.
         """
+        # Retrieve the value using the base dict's get method
         value = super().get(key, default)
+        # If the value is a plain dict, convert it to DotDict for consistency
         if isinstance(value, dict) and not isinstance(value, DotDict):
             value = DotDict(value)
-            self[key] = value
+            self[key] = value  # Store the converted value back in the dictionary
         return value
 
     def export(self) -> Dict[str, Any]:
         """
-        Recursively export the contents of the DotDict as a standard dictionary.
+        Recursively export the contents of the DotDict as a standard Python dictionary.
+
+        This method traverses the DotDict and converts all nested DotDict instances
+        into regular dictionaries by recursively calling their `export` method.
+        Non-DotDict values are included as-is. This ensures that the returned object
+        is composed entirely of built-in Python types, making it suitable for serialization
+        or interoperability with code expecting standard dictionaries.
+
+        Parameters
+        ----------
+        None
 
         Returns
         -------
         result : dict
-            A dictionary representation of the DotDict, where any nested DotDict instances
-            are also converted to dictionaries via their own export method.
+            A dictionary representation of the DotDict, where all nested DotDict instances
+            are recursively converted to dictionaries. Non-DotDict values are returned unchanged.
+
+        Notes
+        -----
+        This method is useful for converting a DotDict (which supports attribute-style access)
+        into a plain dictionary for use with APIs, serialization, or other libraries that
+        require standard dict objects.
         """
         result = {}
+        # Iterate through all key-value pairs in the DotDict
         for k, v in self.items():
             if isinstance(v, DotDict):
+                # Recursively export nested DotDicts
                 result[k] = v.export()
             else:
+                # Include non-DotDict values as-is
                 result[k] = v
         return result
 
     def copy(self) -> 'DotDict':
         """
-        Create a deep copy of the DotDict instance.
+        Create a deep copy of the DotDict instance, recursively copying all nested DotDict and dict objects.
+
+        This method traverses the DotDict and ensures that all nested DotDict and dict instances are
+        copied recursively, so that the returned DotDict is fully independent of the original. Non-dict
+        values are copied by reference.
 
         Returns
         -------
-        copied : DotDict
-            A new DotDict object with recursively copied contents.
-            Nested DotDict and dict instances are also copied to ensure no shared references.
+        DotDict
+            A new DotDict instance containing a deep copy of the original contents. All nested DotDict
+            and dict objects are recursively copied, ensuring no shared references with the original.
+
+        Notes
+        -----
+        This method is useful when you need a completely independent copy of a DotDict, including all
+        nested structures, to avoid unintended side effects from shared references.
         """
         copied = {}
+        # Iterate through all key-value pairs in the DotDict
         for k, v in self.items():
             if isinstance(v, DotDict):
+                # Recursively copy nested DotDict instances
                 copied[k] = v.copy()
             elif isinstance(v, dict):
+                # Convert plain dicts to DotDict and recursively copy
                 copied[k] = DotDict(v).copy()
             else:
+                # Copy non-dict values by reference
                 copied[k] = v
+        # Return a new DotDict containing the copied data
         return DotDict(copied)
 
     def __repr__(self) -> str:
         """
         Return a string representation of the DotDict instance.
 
-        This method overrides the default __repr__ implementation to provide a more informative
-        string that includes the class name 'DotDict' and the representation of the underlying dictionary.
+        This method overrides the default `__repr__` implementation to provide a concise
+        and informative string that displays the class name (`DotDict`) and the contents
+        of the underlying dictionary. This is useful for debugging and logging, as it
+        clearly distinguishes DotDict objects from regular dictionaries.
 
         Returns
         -------
-        repr_str : str
-            A string representation of the DotDict object.
+        str
+            A string representation of the DotDict object, formatted as
+            'DotDict({...})', where {...} is the dictionary content.
+
+        Notes
+        -----
+        The returned string uses the base dictionary's representation, but is prefixed
+        with the DotDict class name for clarity.
         """
+        # Use the base dict's __repr__ for the contents, but keep DotDict class name
         return super().__repr__()

{orionis-0.409.0.dist-info → orionis-0.411.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.409.0
+Version: 0.411.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.409.0.dist-info → orionis-0.411.0.dist-info}/RECORD

@@ -258,7 +258,7 @@ orionis/foundation/providers/progress_bar_provider.py,sha256=WW3grNgH-yV2meSSTeO
 orionis/foundation/providers/testing_provider.py,sha256=iJSN2RIChbYIL-1ue6vmPmDMCSrvERDkti4Er9MPiLA,1102
 orionis/foundation/providers/workers_provider.py,sha256=kiQjQRyUEyiBX2zcbF_KmqRgvc7Bvxsvg5oMtIvYniM,1075
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=gDHNRNaGwPg6hB5oPpbTWnhoaub6TUsKO_Q5kDfk_kE,4960
+orionis/metadata/framework.py,sha256=wQLkWeq7vpfowJoSfUdTQO9y5ZNFQ0NyuElKBvZM5y4,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -371,7 +371,7 @@ orionis/support/formatter/exceptions/contracts/__init__.py,sha256=47DEQpj8HBSa-_
 orionis/support/formatter/exceptions/contracts/parser.py,sha256=HcWN7nJrvD7xLREPKEnBhyG30IkkAB7Bx_hGpcfb0ZE,912
 orionis/support/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/support/patterns/singleton/__init__.py,sha256=BIyMYL5yXpzv_F-jsSEtoKYseGlM8jdJT8hwGuXZZl8,62
-orionis/support/patterns/singleton/meta.py,sha256=YN5mSSQeIX_Gh_TK5HD-ms6IYBTRsRcuzoUtpX-9kYY,2134
+orionis/support/patterns/singleton/meta.py,sha256=Flq6UNaBPJqx8gZv7m6lEAbgorPjkbEWH4LVRKt-Vs8,4114
 orionis/support/standard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/support/standard/std.py,sha256=afe3m7XzzzbFa89RhPVN11LKcgkL3afQHNXHhH3GwjQ,3679
 orionis/support/standard/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -379,7 +379,7 @@ orionis/support/standard/contracts/std.py,sha256=w4F0fIHIOhCPPiBgTLIIWR9EFdjeTjL
 orionis/support/standard/exceptions/__init__.py,sha256=MPwL4i8GSUtLJ82wQ_SlcdgtnIBRk3_CR7JbDhxHf20,93
 orionis/support/standard/exceptions/value.py,sha256=7xry_TZz3k-BLAZTR_uDiQ0RfXOkSBOnBzp9kKUl5xE,471
 orionis/support/wrapper/__init__.py,sha256=jGoWoIGYuRYqMYQKlrX7Dpcbg-AGkHoB_aM2xhu73yc,62
-orionis/support/wrapper/dot_dict.py,sha256=VdAUH-DO6y86pl_9N6v-vU9mdLraWh5HjVzI5iC1dMs,5295
+orionis/support/wrapper/dot_dict.py,sha256=L4J_3id0EHXyjv5FCofXK0ONC2WOoAXZSwX1csitf5E,9299
 orionis/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/kernel.py,sha256=i1VlWl4ZqfGxpc1-JiV3RS0rTrfOMqZJAde1GADK00c,5500
 orionis/test/cases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -428,7 +428,7 @@ orionis/test/validators/web_report.py,sha256=-h3Fe9jY93_kzUhd2NBIqEfCcBpu-8Ei9x3
 orionis/test/validators/workers.py,sha256=LGffDKtK6SKixFKzIYPQpI5aFeQPAGXpv_LUtmEu6g4,1102
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=3ICz68l-WF3BtnYqH5m-ktN9UD00MELMbmMnyJDV74A,4768
-orionis-0.409.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.411.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/test_container.py,sha256=asv8TkkupVoex6SWod74NBl4dSs7wb9mLmu_glNdNy8,14815
@@ -523,22 +523,22 @@ tests/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 tests/services/asynchrony/test_services_asynchrony_coroutine.py,sha256=34Y0D6w2bVo_dm3oj0wzedMIJuSYieUG9Y2J1EQmZeo,3439
 tests/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/environment/test_services_environment.py,sha256=6UH3g2Z2DQYtGnyySCRnT35VCENlL-PQWHIdH6zA9rw,3767
-tests/services/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/test_reflection.py,sha256=AaBi0zi7GphOqnagV8N48GZHUuoT7743Pw3oc6_As6I,13700
-tests/services/inspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/dependencies/test_reflect_dependencies.py,sha256=KspAnaVW-ataFrsHWgNApYK431oF-7oDiw_Q1pRD3IQ,7340
-tests/services/inspection/dependencies/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/dependencies/mocks/mock_user.py,sha256=RxATxe0-Vm4HfX5jKz9Tny42E2fmrdtEN6ZEntbqRL8,912
-tests/services/inspection/dependencies/mocks/mock_user_controller.py,sha256=P3sOUXVZ55auudwiNtvNCEQuTz0cgAZjvhicLZ4xaz4,1208
-tests/services/inspection/dependencies/mocks/mock_users_permissions.py,sha256=oENXbS2qmQUudYSmnhB8fgHBqXZdbplplB-Y2nbx4hw,1388
-tests/services/inspection/reflection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/reflection/test_reflection_abstract.py,sha256=5TuuibsbX6Pc478Tu8Ldo68PkTRgTKi-mQbu2YS3u7E,27408
-tests/services/inspection/reflection/test_reflection_callable.py,sha256=lc0tnFMkBqyF5BtaGEtsMzSB3K0rfX4jDSc-rzmtN7o,6846
-tests/services/inspection/reflection/test_reflection_concrete.py,sha256=MRc1psghTgPzjVRUMc8eg8guhLi7Nl1iaYEgzAkMC-Y,44635
-tests/services/inspection/reflection/test_reflection_instance.py,sha256=xaCLsTblTajd-fVMVLYL6ZsYC2msa81EGKu6fEAQ03g,46294
-tests/services/inspection/reflection/test_reflection_module.py,sha256=NbHJT0BokFjgC4Jw6Ax0YP5QVircXmwC6uAO33CeIeM,19765
-tests/services/inspection/reflection/mock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/reflection/mock/fake_reflect_instance.py,sha256=iqWoT6tNym3OijK0wcF0iKMp3HTlq5kAoztzC4fdTlM,18595
+tests/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/introspection/test_reflection.py,sha256=AaBi0zi7GphOqnagV8N48GZHUuoT7743Pw3oc6_As6I,13700
+tests/services/introspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/introspection/dependencies/test_reflect_dependencies.py,sha256=8Tuz76-RUPQuUPzx0aUALiXwbmEr2q7RrMp_wV2SQw0,7361
+tests/services/introspection/dependencies/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/introspection/dependencies/mocks/mock_user.py,sha256=RxATxe0-Vm4HfX5jKz9Tny42E2fmrdtEN6ZEntbqRL8,912
+tests/services/introspection/dependencies/mocks/mock_user_controller.py,sha256=Hu4Xys5HENpKaLqsEAjtp_C-M9y6ozmJ_-qmj3ZvK6c,1214
+tests/services/introspection/dependencies/mocks/mock_users_permissions.py,sha256=oENXbS2qmQUudYSmnhB8fgHBqXZdbplplB-Y2nbx4hw,1388
+tests/services/introspection/reflection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/introspection/reflection/test_reflection_abstract.py,sha256=V2d_N-dyXrFL1h1FvOpyVMse5Mw_qvnd_yUWYVkIG10,27417
+tests/services/introspection/reflection/test_reflection_callable.py,sha256=lc0tnFMkBqyF5BtaGEtsMzSB3K0rfX4jDSc-rzmtN7o,6846
+tests/services/introspection/reflection/test_reflection_concrete.py,sha256=nG9FBwvd7_E6skZBPRT19lifjKfBSCRx-Sc16ZtZnOI,44650
+tests/services/introspection/reflection/test_reflection_instance.py,sha256=k4V190KLob-rBILK7S6zU5VktqW1IOTNSYZNXNxF4p4,46306
+tests/services/introspection/reflection/test_reflection_module.py,sha256=BmKWDu7JOgq-Jwb1eVbqZjt6GHN3nW0a4NKJDvJvLSM,19768
+tests/services/introspection/reflection/mock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/introspection/reflection/mock/fake_reflect_instance.py,sha256=iqWoT6tNym3OijK0wcF0iKMp3HTlq5kAoztzC4fdTlM,18595
 tests/services/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/log/test_log.py,sha256=fCI2gX9-YN1z-xPMwIlggUFHeBlqfUajQoyQu4dmao0,2868
 tests/services/path/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -553,16 +553,16 @@ tests/support/parsers/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 tests/support/parsers/mocks/mock_custom_error.py,sha256=LWgjeog2rpmfw6j7Bgzvfvmeby8uSBuB1B3d_DgRcFQ,752
 tests/support/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/support/patterns/singleton/test_patterns_singleton.py,sha256=DjLdEB8FM55YesKmJUMU74l6XKgGhV5A2mcH-GHTZEQ,961
+tests/support/patterns/singleton/test_patterns_singleton.py,sha256=L7Q2QEBwSdG_JGfSB4s4AKqxsV4cXeKR1d8V7MbyzFY,1461
 tests/support/standard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/standard/test_services_std.py,sha256=U0hNF50YE4aLE3Z9yWB2awl9owFQRIV8ptSN7G3xZSk,5517
 tests/support/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/support/wrapper/test_services_wrapper_docdict.py,sha256=nTNrvJkMSPx_aopEQ9Tgy8OKgzDIkgx5EZQKfYSKZzo,4991
+tests/support/wrapper/test_services_wrapper_docdict.py,sha256=Q_qyqZodLiTQ6Pv9zILfIoZj6l-WPzNWuIoRf1GTGY0,7535
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=aWOOJiHji_U7gcJHbDukgMmfBEEQCLQdyqpXJD5q4BE,4643
 tests/testing/test_testing_unit.py,sha256=Krz0Bw1toI9qvLtKtYe_slNvi7fYmZbHK1i4DRPMfUM,7952
-orionis-0.409.0.dist-info/METADATA,sha256=iEyS0RyKrDuwXTfiq4cbNkO2eEQtShI75BY8NrSTDJg,4772
-orionis-0.409.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.409.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.409.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.409.0.dist-info/RECORD,,
+orionis-0.411.0.dist-info/METADATA,sha256=81oCjYi2PnQnkDud4fwUp7UPJu8X5Q2VlFNuBTKMYLA,4772
+orionis-0.411.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.411.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.411.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.411.0.dist-info/RECORD,,

tests/services/{inspection → introspection}/dependencies/mocks/mock_user_controller.py

@@ -1,5 +1,5 @@
-from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
-from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.introspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
 
 
 class UserController:

tests/services/{inspection → introspection}/dependencies/test_reflect_dependencies.py

@@ -7,9 +7,9 @@ from orionis.services.introspection.dependencies.reflection import (
     KnownDependency
 )
 from orionis.test.cases.asynchronous import AsyncTestCase
-from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
-from tests.services.inspection.dependencies.mocks.mock_user_controller import UserController
-from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.introspection.dependencies.mocks.mock_user_controller import UserController
+from tests.services.introspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
 
 class TestReflectDependencies(AsyncTestCase):
     """
@@ -48,9 +48,9 @@ class TestReflectDependencies(AsyncTestCase):
 
         # Check resolved dependencies for 'user_repository'
         dependencies:KnownDependency = dep_user_repository
-        self.assertEqual(dependencies.module_name, 'tests.services.inspection.dependencies.mocks.mock_user')
+        self.assertEqual(dependencies.module_name, 'tests.services.introspection.dependencies.mocks.mock_user')
         self.assertEqual(dependencies.class_name, 'FakeUser')
-        self.assertEqual(dependencies.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_user.FakeUser')
+        self.assertEqual(dependencies.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_user.FakeUser')
         self.assertEqual(dependencies.type, FakeUser)
 
     async def testReflectionDependenciesGetMethodDependencies(self):
@@ -80,9 +80,9 @@ class TestReflectDependencies(AsyncTestCase):
         self.assertIsInstance(dep_user_permissions, KnownDependency)
 
         # Check resolved dependencies for 'user_permissions'
-        self.assertEqual(dep_user_permissions.module_name, 'tests.services.inspection.dependencies.mocks.mock_users_permissions')
+        self.assertEqual(dep_user_permissions.module_name, 'tests.services.introspection.dependencies.mocks.mock_users_permissions')
         self.assertEqual(dep_user_permissions.class_name, 'FakeUserWithPermissions')
-        self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
+        self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
         self.assertEqual(dep_user_permissions.type, FakeUserWithPermissions)
 
         # Check Instance of KnownDependency for 'permissions'

tests/services/{inspection → introspection}/reflection/test_reflection_abstract.py

@@ -1,6 +1,6 @@
 from orionis.services.introspection.abstract.reflection import ReflectionAbstract
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import AbstractFakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import AbstractFakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServiceReflectionAbstract(AsyncTestCase):
@@ -27,7 +27,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -35,7 +35,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.AbstractFakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.AbstractFakeClass')
 
     async def testGetDocstring(self):
         """

tests/services/{inspection → introspection}/reflection/test_reflection_concrete.py

@@ -1,6 +1,6 @@
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import FakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServiceReflectionConcrete(AsyncTestCase):
@@ -44,11 +44,11 @@ class TestServiceReflectionConcrete(AsyncTestCase):
         """
         Tests that the getModuleName method of the ReflectionConcrete class returns the correct module name
         for the provided FakeClass. Asserts that the returned module name matches the expected string
-        'tests.services.inspection.reflection.mock.fake_reflect_instance'.
+        'tests.services.introspection.reflection.mock.fake_reflect_instance'.
         """
         reflect = ReflectionConcrete(FakeClass)
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -57,11 +57,11 @@ class TestServiceReflectionConcrete(AsyncTestCase):
 
         Asserts:
             The returned string matches the expected module path and class name:
-            'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass'
+            'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass'
         """
         reflect = ReflectionConcrete(FakeClass)
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass')
 
     async def testGetDocstring(self):
         """

tests/services/{inspection → introspection}/reflection/test_reflection_instance.py

@@ -1,5 +1,5 @@
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
-from tests.services.inspection.reflection.mock.fake_reflect_instance import FakeClass
+from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.services.introspection.instances.reflection import ReflectionInstance
 from orionis.test.cases.asynchronous import AsyncTestCase
 
@@ -43,11 +43,11 @@ class TestServiceReflectionInstance(AsyncTestCase):
 
         Asserts:
             The returned module name matches the expected string
-            'tests.services.inspection.reflection.mock.fake_reflect_instance'.
+            'tests.services.introspection.reflection.mock.fake_reflect_instance'.
         """
         reflect = ReflectionInstance(FakeClass())
         module_name = reflect.getModuleName()
-        self.assertEqual(module_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance')
+        self.assertEqual(module_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance')
 
     async def testGetModuleWithClassName(self):
         """
@@ -59,7 +59,7 @@ class TestServiceReflectionInstance(AsyncTestCase):
         """
         reflect = ReflectionInstance(FakeClass())
         module_with_class_name = reflect.getModuleWithClassName()
-        self.assertEqual(module_with_class_name, 'tests.services.inspection.reflection.mock.fake_reflect_instance.FakeClass')
+        self.assertEqual(module_with_class_name, 'tests.services.introspection.reflection.mock.fake_reflect_instance.FakeClass')
 
     async def testGetDocstring(self):
         """

tests/services/{inspection → introspection}/reflection/test_reflection_module.py

@@ -4,7 +4,7 @@ from orionis.services.introspection.exceptions import ReflectionTypeError, Refle
 
 class TestServiceReflectionModule(AsyncTestCase):
 
-    module_name = 'tests.services.inspection.reflection.mock.fake_reflect_instance'
+    module_name = 'tests.services.introspection.reflection.mock.fake_reflect_instance'
 
     async def testGetModule(self):
         """

tests/support/patterns/singleton/test_patterns_singleton.py

@@ -2,26 +2,39 @@ from orionis.support.patterns.singleton import Singleton
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestPatternsSingleton(AsyncTestCase):
-    """
-    Test cases for the Singleton metaclass.
-
-    This class contains asynchronous test methods to verify the correct behavior
-    of the Singleton metaclass, ensuring that only one instance of a class is created.
-    """
 
     async def testSingleton(self):
         """
-        Test the Singleton metaclass.
+        Tests the behavior of the Singleton metaclass.
+
+        Validates that a class using the Singleton metaclass only ever creates a single instance,
+        regardless of how many times it is instantiated. Also checks that the initial state of the
+        singleton instance remains unchanged after subsequent instantiations.
+
+        Parameters
+        ----------
+        self : TestPatternsSingleton
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. Assertions are used to verify singleton behavior.
 
-        Ensures that only one instance of a class using the Singleton metaclass is created,
-        regardless of how many times the class is instantiated.
         """
+        # Define a class using the Singleton metaclass
         class SingletonClass(metaclass=Singleton):
             def __init__(self, value):
                 self.value = value
 
+        # Create the first instance of SingletonClass
         instance1 = SingletonClass(1)
+
+        # Attempt to create a second instance with a different value
         instance2 = SingletonClass(2)
 
+        # Assert that both instances are actually the same object
         self.assertIs(instance1, instance2)
+
+        # Assert that the value remains as set by the first instantiation
         self.assertEqual(instance1.value, 1)

tests/support/wrapper/test_services_wrapper_docdict.py

@@ -2,77 +2,123 @@ from orionis.support.wrapper import DotDict
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestSupportWrapperDocDict(AsyncTestCase):
-    """
-    Test cases for the DotDict class which provides dictionary with dot notation access.
-
-    Notes
-    -----
-    These tests cover dot notation access, assignment, deletion, and utility methods
-    for the DotDict class, ensuring correct behavior and compatibility with nested
-    dictionaries.
-    """
 
     async def testDotNotationAccess(self):
         """
-        Test dot notation access for dictionary values.
+        Tests dot notation access for dictionary values.
+
+        This method verifies that values in a DotDict instance can be accessed using dot notation.
+        It checks that existing keys return their corresponding values, nested dictionaries are
+        accessible via chained dot notation, and accessing a non-existent key returns None.
 
-        Verifies that both existing and non-existing keys can be accessed via dot notation,
-        with `None` returned for missing keys.
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance with initial values
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
+
+        # Access existing key using dot notation
         self.assertEqual(dd.key1, 'value1')
+
+        # Access nested dictionary value using chained dot notation
         self.assertEqual(dd.nested.inner, 42)
+
+        # Access non-existent key, should return None
         self.assertIsNone(dd.non_existent)
 
     async def testDotNotationAssignment(self):
         """
-        Test assignment of dictionary values using dot notation.
+        Tests assignment of dictionary values using dot notation.
+
+        This method verifies that new keys can be added and existing keys can be updated
+        using dot notation. It also checks that nested dictionaries assigned via dot notation
+        are automatically converted to DotDict instances.
 
-        Verifies that new keys can be added and existing keys can be updated using dot notation,
-        with automatic conversion of nested dictionaries to DotDict.
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and assign values using dot notation
         dd = DotDict()
+
+        # Assign new key using dot notation
         dd.key1 = 'value1'
+
+        # Assign nested dictionary, should convert to DotDict
         dd.nested = {'inner': 42}
 
+        # Verify the assignments
         self.assertEqual(dd['key1'], 'value1')
         self.assertIsInstance(dd.nested, DotDict)
         self.assertEqual(dd.nested.inner, 42)
 
     async def testDotNotationDeletion(self):
         """
-        Test deletion of dictionary keys using dot notation.
+        Tests deletion of dictionary keys using dot notation.
 
-        Verifies that existing keys can be deleted and an AttributeError is raised
-        when trying to delete non-existent keys.
+        This method verifies that existing keys can be deleted using dot notation.
+        It also checks that attempting to delete a non-existent key raises an AttributeError.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and delete an existing key
         dd = DotDict({'key1': 'value1', 'key2': 'value2'})
+
+        # Delete existing key using dot notation
         del dd.key1
         self.assertNotIn('key1', dd)
 
+        # Attempt to delete non-existent key, should raise AttributeError
         with self.assertRaises(AttributeError):
             del dd.non_existent
 
     async def testGetMethod(self):
         """
-        Test the `get` method with automatic DotDict conversion.
+        Tests the `get` method with automatic DotDict conversion.
 
-        Verifies that the `get` method returns the correct value or default,
-        and converts nested dictionaries to DotDict instances.
+        This method verifies that the `get` method returns the correct value for a given key,
+        returns the provided default for missing keys, and converts nested dictionaries to
+        DotDict instances when accessed.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and test the `get` method
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
 
         self.assertEqual(dd.get('key1'), 'value1')
         self.assertEqual(dd.get('non_existent', 'default'), 'default')
+
+        # Nested dictionary should be returned as DotDict
         self.assertIsInstance(dd.get('nested'), DotDict)
         self.assertEqual(dd.get('nested').inner, 42)
 
     async def testExportMethod(self):
         """
-        Test the `export` method for recursive conversion to regular dict.
+        Tests the `export` method for recursive conversion to regular dict.
 
-        Verifies that all nested DotDict instances are converted back to regular dicts.
+        This method verifies that calling `export` on a DotDict instance recursively converts
+        all nested DotDict objects back to regular Python dictionaries.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and export it
         dd = DotDict({
             'key1': 'value1',
             'nested': DotDict({
@@ -82,6 +128,8 @@ class TestSupportWrapperDocDict(AsyncTestCase):
         })
 
         exported = dd.export()
+
+        # Top-level and nested DotDicts should be converted to dicts
         self.assertIsInstance(exported, dict)
         self.assertIsInstance(exported['nested'], dict)
         self.assertIsInstance(exported['nested']['deep'], dict)
@@ -89,19 +137,32 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testCopyMethod(self):
         """
-        Test the `copy` method for deep copy with DotDict conversion.
+        Tests the `copy` method for deep copy with DotDict conversion.
 
-        Verifies that the copy is independent of the original and maintains DotDict structure.
+        This method verifies that copying a DotDict instance produces an independent copy,
+        with all nested dictionaries converted to DotDict instances. It checks that changes
+        to the copy do not affect the original.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and copy it
         original = DotDict({
             'key1': 'value1',
             'nested': {'inner': 42}
         })
 
+        # Copy the original DotDict
         copied = original.copy()
+
+        # Modify the copy and verify original is unchanged
         copied.key1 = 'modified'
         copied.nested.inner = 100
 
+        # Check that original remains unchanged
         self.assertEqual(original.key1, 'value1')
         self.assertEqual(original.nested.inner, 42)
         self.assertEqual(copied.key1, 'modified')
@@ -110,9 +171,15 @@ class TestSupportWrapperDocDict(AsyncTestCase):
 
     async def testNestedDictConversion(self):
         """
-        Test automatic conversion of nested dictionaries to DotDict.
+        Tests automatic conversion of nested dictionaries to DotDict.
 
-        Verifies that nested dicts are converted both during initialization and assignment.
+        This method verifies that nested dictionaries are converted to DotDict instances
+        both during initialization and dynamic assignment.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
         dd = DotDict({
             'level1': {
@@ -122,20 +189,29 @@ class TestSupportWrapperDocDict(AsyncTestCase):
             }
         })
 
+        # Nested dicts should be DotDict instances
         self.assertIsInstance(dd.level1, DotDict)
         self.assertIsInstance(dd.level1.level2, DotDict)
         self.assertEqual(dd.level1.level2.value, 42)
 
-        # Test dynamic assignment
+        # Test dynamic assignment of nested dict
         dd.new_nested = {'a': {'b': 1}}
         self.assertIsInstance(dd.new_nested, DotDict)
         self.assertIsInstance(dd.new_nested.a, DotDict)
 
     async def testReprMethod(self):
         """
-        Test the string representation of DotDict.
+        Tests the string representation of DotDict.
+
+        This method verifies that the `__repr__` method of DotDict returns a string
+        representation that includes the DotDict prefix.
 
-        Verifies that the `__repr__` method includes the DotDict prefix.
+        Returns
+        -------
+        None
+            This is a test method and does not return a value.
         """
+
+        # Create a DotDict instance and test its string representation
         dd = DotDict({'key': 'value'})
         self.assertEqual(repr(dd), "{'key': 'value'}")