orionis 0.287.0__py3-none-any.whl → 0.289.0__py3-none-any.whl

orionis/services/standard/std.py

@@ -1,5 +1,5 @@
 from orionis.services.standard.contracts.std import IStdClass
-from orionis.services.standard.exceptions.path_value_exceptions import OrionisStdValueException
+from orionis.services.standard.exceptions.std_value_exception import OrionisStdValueException
 
 class StdClass(IStdClass):
     """
@@ -112,7 +112,7 @@ class StdClass(IStdClass):
             delattr(self, attr)
 
     @classmethod
-    def from_dict(cls, dictionary):
+    def fromDict(cls, dictionary):
         """
         Creates a StdClass instance from a dictionary.
 

orionis/services/system/contracts/imports.py

@@ -3,29 +3,49 @@ from abc import ABC, abstractmethod
 class IImports(ABC):
     """
     Interface for a utility to collect and display information about currently loaded Python modules.
+
+    Methods
+    -------
+    collect()
+        Collects information about user-defined Python modules currently loaded in sys.modules.
+
+    display()
+        Displays a formatted table of collected import statements.
+
+    clear()
+        Clears the collected imports list.
     """
 
     @abstractmethod
     def collect(self):
         """
-        Collects information about user-defined Python modules currently loaded in sys.modules.
-        Returns:
-            IImports: The current instance with updated imports information.
+        Collect information about user-defined Python modules currently loaded in sys.modules.
+
+        Returns
+        -------
+        IImports
+            The current instance with updated imports information.
         """
         pass
 
     @abstractmethod
     def display(self) -> None:
         """
-        Displays a formatted table of collected import statements.
-        Returns:
-            None
+        Display a formatted table of collected import statements.
+
+        Returns
+        -------
+        None
         """
         pass
 
     @abstractmethod
     def clear(self) -> None:
         """
-        Clears the collected imports list.
+        Clear the collected imports list.
+
+        Returns
+        -------
+        None
         """
         pass

orionis/services/system/contracts/workers.py

@@ -2,17 +2,22 @@ from abc import ABC, abstractmethod
 
 class IWorkers(ABC):
     """
-    Interface - Calculates the optimal number of workers a machine can handle based on CPU and memory resources.
+    Interface for calculating the optimal number of workers a machine can handle based on CPU and memory resources.
+
+    Notes
+    -----
+    Implementations should provide logic to determine the recommended number of worker processes
+    according to the available CPU and memory resources of the current machine.
     """
 
     @abstractmethod
     def calculate(self) -> int:
         """
-        Computes the maximum number of workers supported by the current machine.
+        Compute the maximum number of workers supported by the current machine.
 
         Returns
         -------
         int
-            The recommended number of worker processes based on CPU and memory limits.
+            Recommended number of worker processes based on CPU and memory limits.
         """
         pass

orionis/services/system/imports.py

@@ -3,30 +3,42 @@ from orionis.services.system.contracts.imports import IImports
 
 class Imports(IImports):
     """
-    A utility class to collect and display information about currently loaded Python modules.
+    Utility class to collect and display information about currently loaded Python modules.
+
+    This class provides methods to gather details about user-defined Python modules
+    currently loaded in `sys.modules`, excluding standard library and virtual environment modules.
+    It can display the collected information in a formatted table using the Rich library.
     """
 
     def __init__(self):
         """
-        Initializes the Imports object with an empty list to store module information.
+        Initialize the Imports object.
+
+        Initializes an empty list to store module information.
         """
         self.imports: List[Dict[str, Any]] = []
 
     def collect(self) -> 'Imports':
         """
-        Collects information about user-defined (non-standard library, non-venv) Python modules currently loaded in sys.modules.
+        Collect information about user-defined Python modules currently loaded.
+
         For each qualifying module, gathers:
             - The module's name.
             - The relative file path to the module from the current working directory.
             - A list of symbols (functions, classes, or submodules) defined in the module.
+
         Excludes:
             - Modules from the standard library.
             - Modules from the active virtual environment (if any).
             - Binary extension modules (.pyd, .dll, .so).
             - Special modules like "__main__", "__mp_main__", and modules starting with "_distutils".
-        The collected information is stored in self.imports as a list of dictionaries.
-        Returns:
-            Imports: The current instance with updated imports information.
+
+        The collected information is stored in `self.imports` as a list of dictionaries.
+
+        Returns
+        -------
+        Imports
+            The current instance with updated imports information.
         """
 
         import sys
@@ -39,7 +51,7 @@ class Imports(IImports):
         if venv_path:
             venv_path = os.path.abspath(venv_path)
 
-        for name, module in sys.modules.items():
+        for name, module in list(sys.modules.items()):
             file:str = getattr(module, '__file__', None)
 
             if (
@@ -73,12 +85,15 @@ class Imports(IImports):
 
     def display(self) -> None:
         """
-        Displays a formatted table of collected import statements using the Rich library.
-        If the imports have not been collected yet, it calls self.collect() to gather them.
+        Display a formatted table of collected import statements using the Rich library.
+
+        If the imports have not been collected yet, it calls `self.collect()` to gather them.
         The table includes columns for the import name, file, and imported symbols, and is
         rendered inside a styled panel in the console.
-        Returns:
-            None
+
+        Returns
+        -------
+        None
         """
 
         if not self.imports:
@@ -119,6 +134,10 @@ class Imports(IImports):
 
     def clear(self) -> None:
         """
-        Clears the collected imports list.
+        Clear the collected imports list.
+
+        Returns
+        -------
+        None
         """
         self.imports.clear()

orionis/services/system/runtime_imports.py

@@ -1,27 +1,29 @@
 """
-orionis.services.system.runtime_imports
-
-This module overrides Python's built-in import mechanism to monitor and log
-the number of times modules from the 'orionis' package are imported.
+Overrides Python's built-in import mechanism to monitor and log the number of times
+modules from the 'orionis' package are imported.
 
 Each time a module whose name starts with 'orionis' is imported, a message is printed
-showing:
-    - The module name
-    - The number of times it has been imported
-    - The fromlist used in the import
+showing the module name, the number of times it has been imported, and the fromlist
+used in the import. Thread safety is ensured using a lock.
+
+.. warning::
+    This affects the global import system for the current Python process.
+    To disable, restore ``builtins.__import__`` to its original value.
 
-Thread safety is ensured using a lock.
+Examples
+--------
+Import this module at the very beginning of your application to enable import tracking
+for 'orionis' modules. No further configuration is required.
 
-Usage:
-    Import this module at the very beginning of your application to enable import tracking
-    for 'orionis' modules. No further configuration is required.
+Example output::
 
-Example output:
     Module: orionis.example | Imported: 2 | FromList: ('submodule',)
 
-Note:
-    This affects the global import system for the current Python process.
-    To disable, restore builtins.__import__ to its original value.
+Notes
+-----
+- This module should be imported before any other 'orionis' modules to ensure all imports are tracked.
+- Thread safety is provided via a threading.Lock.
+
 """
 import builtins
 from collections import defaultdict
@@ -40,14 +42,22 @@ def custom_import(name, globals=None, locals=None, fromlist=(), level=0):
     """
     Custom import function that tracks imports of 'orionis' modules.
 
-    Args:
-        name (str): The name of the module to import.
-        globals (dict, optional): The global namespace.
-        locals (dict, optional): The local namespace.
-        fromlist (tuple, optional): Names to import from the module.
-        level (int, optional): Relative import level.
+    Parameters
+    ----------
+    name : str
+        The name of the module to import.
+    globals : dict, optional
+        The global namespace.
+    locals : dict, optional
+        The local namespace.
+    fromlist : tuple, optional
+        Names to import from the module.
+    level : int, optional
+        Relative import level.
 
-    Returns:
+    Returns
+    -------
+    module
         The imported module.
     """
     # Check if the module name starts with 'orionis'

orionis/services/system/workers.py

@@ -5,17 +5,15 @@ from orionis.services.system.contracts.workers import IWorkers
 
 class Workers(IWorkers):
     """
-    Calculates the optimal number of workers a machine can handle based on CPU and memory resources.
+    Estimate the optimal number of worker processes based on system CPU and memory resources.
 
-    This class estimates the maximum number of Uvicorn (or similar) workers by considering:
-    - The number of available CPU cores.
-    - The total system memory (RAM).
-    - The estimated memory usage per worker (configurable).
+    This class calculates the recommended number of Uvicorn (or similar) workers by considering:
+    the number of available CPU cores, total system memory (RAM), and the estimated memory usage per worker.
 
     Parameters
     ----------
     ram_per_worker : float, optional
-        Estimated amount of RAM (in GB) that each worker will consume. Default is 0.5 GB.
+        Estimated amount of RAM in gigabytes (GB) that each worker will consume. Default is 0.5.
     """
 
     def __init__(self, ram_per_worker: float = 0.5):
@@ -25,12 +23,12 @@ class Workers(IWorkers):
 
     def calculate(self) -> int:
         """
-        Computes the maximum number of workers supported by the current machine.
+        Compute the maximum number of workers supported by the current machine.
 
         Returns
         -------
         int
-            The recommended number of worker processes based on CPU and memory limits.
+            The recommended number of worker processes based on CPU and memory constraints.
         """
         max_workers_by_cpu = self._cpu_count
         max_workers_by_ram = math.floor(self._ram_total_gb / self._ram_per_worker)

orionis/services/wrapper/dicts/dot_dict.py

@@ -2,9 +2,11 @@ from typing import Any, Optional, Dict
 
 class DotDict(dict):
     """
-    A dictionary subclass that allows attribute-style access to keys, with full support for nested dictionaries.
-    Nested dicts are automatically converted to DotDict instances, enabling recursive dot notation.
-    Missing keys return None instead of raising AttributeError or KeyError.
+    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__ = ()
@@ -12,14 +14,21 @@ class DotDict(dict):
     def __getattr__(self, key: str) -> Optional[Any]:
         """
         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.
-        Args:
-            key (str): The attribute name to retrieve.
-        Returns:
-            Optional[Any]: The value associated with the key, converted to DotDict if applicable, or None if the key is not found.
-        """
 
+        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.
+
+        Parameters
+        ----------
+        key : str
+            The attribute name to retrieve.
+
+        Returns
+        -------
+        value : Any or None
+            The value associated with the key, converted to DotDict if applicable,
+            or None if the key is not found.
+        """
         try:
             value = self[key]
             if isinstance(value, dict) and not isinstance(value, DotDict):
@@ -31,15 +40,19 @@ class DotDict(dict):
 
     def __setattr__(self, key: str, value: Any) -> None:
         """
-        Sets an attribute on 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.
-
-        Args:
-            key (str): The attribute name to set.
-            value (Any): The value to assign to the attribute. If it's a dict, it will be converted to a DotDict.
-
+        Set an attribute on 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.
+
+        Parameters
+        ----------
+        key : str
+            The attribute name to set.
+        value : Any
+            The value to assign to the attribute. If it's a dict, it will be
+            converted to a DotDict.
         """
         if isinstance(value, dict) and not isinstance(value, DotDict):
             value = DotDict(value)
@@ -47,13 +60,17 @@ class DotDict(dict):
 
     def __delattr__(self, key: str) -> None:
         """
-        Deletes the attribute with the specified key from the dictionary.
+        Delete the attribute with the specified key from the dictionary.
 
-        Args:
-            key (str): The name of the attribute to delete.
+        Parameters
+        ----------
+        key : str
+            The name of the attribute to delete.
 
-        Raises:
-            AttributeError: If the attribute does not exist.
+        Raises
+        ------
+        AttributeError
+            If the attribute does not exist.
         """
         try:
             del self[key]
@@ -67,12 +84,17 @@ class DotDict(dict):
         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.
 
-        Args:
-            key (str): The key to look up in the dictionary.
-            default (Optional[Any], optional): The value to return if the key is not found. Defaults to None.
-
-        Returns:
-            Optional[Any]: The value associated with the key, converted to a DotDict if it is a dict,
+        Parameters
+        ----------
+        key : str
+            The key to look up in the dictionary.
+        default : Any, optional
+            The value to return if the key is not found. Defaults to None.
+
+        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.
         """
         value = super().get(key, default)
@@ -83,24 +105,41 @@ class DotDict(dict):
 
     def export(self) -> Dict[str, Any]:
         """
-        Recursively exports the contents of the DotDict as a standard dictionary.
+        Recursively export the contents of the DotDict as a standard dictionary.
 
-        Returns:
-            Dict[str, Any]: A dictionary representation of the DotDict, where any nested DotDict instances
+        Returns
+        -------
+        result : dict
+            A dictionary representation of the DotDict, where any nested DotDict instances
             are also converted to dictionaries via their own export method.
         """
-        return {k: v.export() if isinstance(v, DotDict) else v for k, v in self.items()}
+        result = {}
+        for k, v in self.items():
+            if isinstance(v, DotDict):
+                result[k] = v.export()
+            else:
+                result[k] = v
+        return result
 
     def copy(self) -> 'DotDict':
         """
         Create a deep copy of the DotDict instance.
 
-        Returns:
-            DotDict: A new DotDict object with recursively copied contents. 
+        Returns
+        -------
+        copied : DotDict
+            A new DotDict object with recursively copied contents.
             Nested DotDict and dict instances are also copied to ensure no shared references.
         """
-        return DotDict({k: v.copy() if isinstance(v, DotDict) else (DotDict(v) if isinstance(v, dict) else v)
-                        for k, v in self.items()})
+        copied = {}
+        for k, v in self.items():
+            if isinstance(v, DotDict):
+                copied[k] = v.copy()
+            elif isinstance(v, dict):
+                copied[k] = DotDict(v).copy()
+            else:
+                copied[k] = v
+        return DotDict(copied)
 
     def __repr__(self) -> str:
         """
@@ -109,7 +148,9 @@ class DotDict(dict):
         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.
 
-        Returns:
-            str: A string representation of the DotDict object.
+        Returns
+        -------
+        repr_str : str
+            A string representation of the DotDict object.
         """
-        return f"DotDict({super().__repr__()})"
+        return super().__repr__()

orionis/unittesting.py

@@ -26,16 +26,16 @@ from orionis.test.suites.test_unit import UnitTest
 
 # Import standard unittest components for compatibility
 from unittest import (
-    TestLoader as UnittestTestLoader,
-    TestSuite as UnittestTestSuite,
-    TestResult as UnittestTestResult,
+    TestLoader,
+    TestSuite as StandardTestSuite,
+    TestResult as StandardTestResult
 )
 
 # Import mock classes for creating test doubles
 from unittest.mock import (
-    Mock as UnittestMock,
-    MagicMock as UnittestMagicMock,
-    patch as unittest_mock_patch,
+    Mock,
+    MagicMock,
+    patch
 )
 
 # Define the public API of this module
@@ -54,11 +54,11 @@ __all__ = [
     "Configuration",
     "TestSuite",
     "UnitTest",
-    "UnittestTestLoader",
-    "UnittestTestSuite",
-    "UnittestTestResult",
-    "UnittestMock",
-    "UnittestMagicMock",
+    "TestLoader",
+    "StandardTestSuite",
+    "StandardTestResult",
+    "Mock",
+    "MagicMock",
     "TestHistory",
-    "unittest_mock_patch",
+    "patch",
 ]

{orionis-0.287.0.dist-info → orionis-0.289.0.dist-info}/METADATA

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