orionis 0.252.0__py3-none-any.whl → 0.265.0__py3-none-any.whl

orionis/luminate/services/paths/__init__.py

@@ -1,9 +0,0 @@
-from orionis.luminate.services.paths.resolver import Resolver
-
-__all__ = [
-    "Resolver",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This module provides a Resolver class that is used to resolve paths in the Orionis Framework application. "
-)

orionis/luminate/services/paths/resolver.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from orionis.luminate.support.paths.contracts.resolver import IResolver
+from orionis.luminate.services.paths.contracts.resolver import IResolver
 
 class Resolver(IResolver):
     """

orionis/luminate/{support → services}/standard/std.py

@@ -1,4 +1,4 @@
-from orionis.luminate.support.standard.contracts.std import IStdClass
+from orionis.luminate.services.standard.contracts.std import IStdClass
 
 class StdClass(IStdClass):
     """

orionis/luminate/services/system/contracts/imports.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+
+class IImports(ABC):
+    """
+    Interface for a utility to collect and display information about currently loaded Python modules.
+    """
+
+    @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.
+        """
+        pass
+
+    @abstractmethod
+    def display(self) -> None:
+        """
+        Displays a formatted table of collected import statements.
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        """
+        Clears the collected imports list.
+        """
+        pass

orionis/luminate/services/system/contracts/workers.py

@@ -0,0 +1,18 @@
+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.
+    """
+
+    @abstractmethod
+    def calculate(self) -> int:
+        """
+        Computes the maximum number of workers supported by the current machine.
+
+        Returns
+        -------
+        int
+            The recommended number of worker processes based on CPU and memory limits.
+        """
+        pass

orionis/luminate/services/system/imports.py

@@ -0,0 +1,124 @@
+from typing import List, Dict, Any
+from orionis.luminate.services.system.contracts.imports import IImports
+
+class Imports(IImports):
+    """
+    A utility class to collect and display information about currently loaded Python modules.
+    """
+
+    def __init__(self):
+        """
+        Initializes the Imports object with 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.
+        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.
+        """
+
+        import sys
+        import os
+        import types
+
+        self.imports.clear()
+        stdlib_paths = [os.path.dirname(os.__file__)]
+        venv_path = os.environ.get("VIRTUAL_ENV")
+        if venv_path:
+            venv_path = os.path.abspath(venv_path)
+
+        for name, module in sys.modules.items():
+            file:str = getattr(module, '__file__', None)
+
+            if (
+                file
+                and not any(file.startswith(stdlib_path) for stdlib_path in stdlib_paths)
+                and (not venv_path or not file.startswith(venv_path))
+                and not file.lower().endswith(('.pyd', '.dll', '.so'))
+                and name not in ("__main__", "__mp_main__")
+                and not name.startswith("_distutils")
+            ):
+                rel_file = os.path.relpath(file, os.getcwd())
+                symbols = []
+
+                try:
+                    for attr in dir(module):
+                        value = getattr(module, attr)
+                        if isinstance(value, (types.FunctionType, type, types.ModuleType)):
+                            if getattr(value, '__module__', None) == name:
+                                symbols.append(attr)
+                except Exception:
+                    pass
+
+                if not rel_file.endswith('__init__.py') and symbols:
+                    self.imports.append({
+                        "name": name,
+                        "file": rel_file,
+                        "symbols": symbols,
+                    })
+
+        return self
+
+    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.
+        The table includes columns for the import name, file, and imported symbols, and is
+        rendered inside a styled panel in the console.
+        Returns:
+            None
+        """
+
+        if not self.imports:
+            self.collect()
+
+        from rich.console import Console
+        from rich.table import Table
+        from rich.box import MINIMAL
+        from rich.panel import Panel
+
+        console = Console()
+        width = int(console.size.width * 0.75)
+
+        table = Table(
+            box=MINIMAL,
+            show_header=True,
+            show_edge=False,
+            pad_edge=False,
+            min_width=width,
+            padding=(0, 1),
+            collapse_padding=True,
+        )
+
+        table.add_column("Name", style="cyan", no_wrap=True)
+        table.add_column("File", style="white")
+        table.add_column("Symbols", style="magenta")
+
+        for imp in sorted(self.imports, key=lambda x: x["name"].lower()):
+            symbols_str = ", ".join(imp["symbols"])
+            table.add_row(imp["name"], imp["file"], symbols_str)
+
+        console.print(Panel(
+            table,
+            title="[bold blue]🔎 Loaded Python Modules (Orionis Imports Trace)[/bold blue]",
+            border_style="blue",
+            width=width
+        ))
+
+    def clear(self) -> None:
+        """
+        Clears the collected imports list.
+        """
+        self.imports.clear()

orionis/luminate/services/system/runtime_imports.py

@@ -0,0 +1,70 @@
+"""
+orionis.luminate.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.
+
+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
+
+Thread safety is ensured using a lock.
+
+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:
+    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.
+"""
+import builtins
+from collections import defaultdict
+from threading import Lock
+
+# Store the original __import__ function
+_original_import = builtins.__import__
+
+# Dictionary to count imports per module
+_import_count = defaultdict(int)
+
+# Lock to ensure thread safety
+_import_lock = Lock()
+
+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.
+
+    Returns:
+        The imported module.
+    """
+    # Check if the module name starts with 'orionis'
+    if str(name).startswith("orionis"):
+        with _import_lock:
+            _import_count[name] += 1
+            count = _import_count[name]
+
+            # Print the import details
+            print(
+                f"\033[1;37mModule\033[0m: \033[90m{name}\033[0m | "
+                f"\033[1;37mImported\033[0m: \033[90m{count}\033[0m | "
+                f"\033[1;37mFromList\033[0m: \033[90m{fromlist}\033[0m"
+            )
+
+    # Call the original import function
+    return _original_import(name, globals, locals, fromlist, level)
+
+# Override the built-in __import__ function
+builtins.__import__ = custom_import

orionis/luminate/services/{workers/maximum_workers.py → system/workers.py}

@@ -1,8 +1,9 @@
 import multiprocessing
 import math
 import psutil
+from orionis.luminate.services.system.contracts.workers import IWorkers
 
-class MaximumWorkers:
+class Workers(IWorkers):
     """
     Calculates the optimal number of workers a machine can handle based on CPU and memory resources.
 

orionis/luminate/services/wrapper/dicts/dot_dict.py

@@ -0,0 +1,115 @@
+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.
+    """
+
+    __slots__ = ()
+
+    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.
+        """
+
+        try:
+            value = self[key]
+            if isinstance(value, dict) and not isinstance(value, DotDict):
+                value = DotDict(value)
+                self[key] = value
+            return value
+        except KeyError:
+            return None
+
+    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.
+
+        """
+        if isinstance(value, dict) and not isinstance(value, DotDict):
+            value = DotDict(value)
+        self[key] = value
+
+    def __delattr__(self, key: str) -> None:
+        """
+        Deletes the attribute with the specified key from the dictionary.
+
+        Args:
+            key (str): The name of the attribute to delete.
+
+        Raises:
+            AttributeError: If the attribute does not exist.
+        """
+        try:
+            del self[key]
+        except KeyError as e:
+            raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{key}'") from e
+
+    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+        """
+        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.
+
+        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,
+            or the default value if the key is not present.
+        """
+        value = super().get(key, default)
+        if isinstance(value, dict) and not isinstance(value, DotDict):
+            value = DotDict(value)
+            self[key] = value
+        return value
+
+    def export(self) -> Dict[str, Any]:
+        """
+        Recursively exports the contents of the DotDict as a standard dictionary.
+
+        Returns:
+            Dict[str, Any]: 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()}
+
+    def copy(self) -> 'DotDict':
+        """
+        Create a deep copy of the DotDict instance.
+
+        Returns:
+            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()})
+
+    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.
+
+        Returns:
+            str: A string representation of the DotDict object.
+        """
+        return f"DotDict({super().__repr__()})"

orionis/luminate/support/introspection/__init__.py

@@ -1,5 +0,0 @@
-from orionis.luminate.support.introspection.reflection import Reflection
-
-__all__ = [
-    "Reflection"
-]

orionis/luminate/support/introspection/container_integrity.py

@@ -2,8 +2,8 @@ import re
 import inspect
 from abc import ABC
 from typing import Any, Callable, Set, Type
-from orionis.luminate.container.exception import OrionisContainerValueError, OrionisContainerTypeError
-from orionis.luminate.contracts.container.container_integrity import IContainerIntegrity
+from orionis.luminate._container.exception import OrionisContainerValueError, OrionisContainerTypeError
+from orionis.luminate._contracts.container.container_integrity import IContainerIntegrity
 
 class ContainerIntegrity(IContainerIntegrity):
 

orionis/luminate/support/introspection/instances/__init__.py

@@ -1,5 +0,0 @@
-from orionis.luminate.support.introspection.instances.reflection_instance import ReflectionInstance
-
-__all__ = [
-    "ReflectionInstance",
-]

orionis/luminate/support/introspection/reflection.py

@@ -1,6 +1,6 @@
 import abc
 from typing import Any, Type, TypeVar
-from orionis.luminate.contracts.support.reflection import IReflection
+from orionis.luminate._contracts.support.reflection import IReflection
 from orionis.luminate.support.introspection.helpers.functions import HelpersReflection
 from orionis.luminate.support.introspection.abstracts.reflect_abstract import ReflexionAbstract
 from orionis.luminate.support.introspection.reflexion_concrete import ReflexionConcrete

orionis/luminate/test/__init__.py

@@ -1,23 +0,0 @@
-from orionis.luminate.test.cases.test_async import AsyncTestCase
-from orionis.luminate.test.cases.test_case import TestCase
-from orionis.luminate.test.cases.test_sync import SyncTestCase
-from orionis.luminate.test.core.test_suite import TestSuite
-from orionis.luminate.test.core.test_unit import UnitTest
-
-__all__ = [
-    "TestSuite",
-    "UnitTest",
-    "AsyncTestCase",
-    "TestCase",
-    "SyncTestCase",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "Orionis Framework - Component Test Suites is a microframework "
-    "for creating unit and integration tests. "
-    "It allows you to write tests quickly and easily, "
-    "using a clear and concise syntax. "
-    "Supports both asynchronous and synchronous tests, "
-    "as well as the creation of test suites and parallel test execution. "
-    "It uses Python's native unittest module for test creation."
-)

orionis/luminate/test/cases/test_async.py

@@ -1,23 +1,55 @@
 import unittest
-from orionis.luminate.test.output.test_std_out import TestStdOut
+from orionis.luminate.test.output.dumper import TestDumper
 
-class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
+class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
     """
-    AsyncTestCase is a test case class designed for asynchronous unit testing.
-    It inherits from `unittest.IsolatedAsyncioTestCase` to provide support for
-    async test methods and `TestStdOut` for additional functionality.
+    Base test case for async unit tests.
     """
 
     async def asyncSetUp(self):
         """
-        Asynchronous setup method called before each test.
-        It ensures that the parent class's asyncSetUp method is invoked to initialize
+        Asynchronous setup method for test cases.
+
+        This method is called before each test coroutine is run. It first calls the parent
+        class's asyncSetUp method to perform any necessary setup defined in the superclass,
+        then calls the onAsyncSetup coroutine for additional setup specific to this test case.
+
+        Override onAsyncSetup to implement custom asynchronous setup logic.
+
+        Returns:
+            Awaitable: Completes when setup is finished.
         """
         await super().asyncSetUp()
+        await self.onAsyncSetup()
 
     async def asyncTearDown(self):
         """
         Asynchronous teardown method called after each test.
-        It ensures that the parent class's asyncTearDown method is invoked to clean up
+
+        This method performs any necessary asynchronous cleanup by first calling
+        `onAsyncTeardown()` for custom teardown logic, then invoking the superclass's
+        `asyncTearDown()` to ensure proper teardown in the class hierarchy.
+        """
+        await self.onAsyncTeardown()
+        await super().asyncTearDown()
+
+    async def onAsyncSetup(self):
+        """
+        Asynchronous setup method to be executed before running tests.
+
+        This method can be overridden to perform any asynchronous initialization
+        required for the test case. By default, it does nothing.
+
+        Returns:
+            None
+        """
+        pass
+
+    async def onAsyncTeardown(self):
+        """
+        Asynchronous teardown method to be executed after each test case.
+
+        This method can be overridden to perform any necessary cleanup operations
+        that need to run asynchronously after the completion of a test case.
         """
-        await super().asyncTearDown()
+        pass

orionis/luminate/test/cases/test_case.py

@@ -1,28 +1,42 @@
 import unittest
-from orionis.luminate.test.output.test_std_out import TestStdOut
+from orionis.luminate.test.output.dumper import TestDumper
 
-class TestCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
+class TestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
     """
-    A base test case class for asynchronous unit tests.
-    Inherits from:
-        unittest.IsolatedAsyncioTestCase: Provides support for asynchronous test methods and setup/teardown.
-        TestStdOut: Mixin for capturing or testing standard output during tests.
-    This class defines asynchronous setup and teardown methods to ensure proper initialization and cleanup
-    of resources before and after each test case.
+    Base test case for async unit tests.
     """
 
     async def asyncSetUp(self):
         """
         Asynchronous setup method called before each test.
-        It ensures that the parent class's asyncSetUp method is invoked to initialize
-        any required resources.
+
+        This method first calls the parent class's asyncSetUp method to ensure any inherited setup logic is executed.
+        Then, it calls the onAsyncSetup method, which can be used to perform additional asynchronous setup specific to this test case.
+
+        Override this method to customize asynchronous setup behavior for your tests.
         """
         await super().asyncSetUp()
+        await self.onAsyncSetup()
 
     async def asyncTearDown(self):
         """
         Asynchronous teardown method called after each test.
-        It ensures that the parent class's asyncTearDown method is invoked to clean up
-        any resources used during the test.
+
+        This method performs any necessary asynchronous cleanup by first invoking
+        the custom `onAsyncTeardown` coroutine, followed by the superclass's
+        `asyncTearDown` method to ensure proper teardown in the test lifecycle.
+        """
+        await self.onAsyncTeardown()
+        await super().asyncTearDown()
+
+    async def onAsyncSetup(self):
+        """
+        Hook for subclasses to add async setup logic.
+        """
+        pass
+
+    async def onAsyncTeardown(self):
+        """
+        Hook for subclasses to add async teardown logic.
         """
-        await super().asyncTearDown()
+        pass

orionis/luminate/test/cases/test_sync.py

@@ -1,11 +1,33 @@
 import unittest
-from orionis.luminate.test.output.test_std_out import TestStdOut
+from orionis.luminate.test.output.dumper import TestDumper
 
-class SyncTestCase(unittest.TestCase, TestStdOut):
+class SyncTestCase(unittest.TestCase, TestDumper):
     """
-    SyncTestCase is a test case class designed for synchronous unit testing.
-    It inherits from `unittest.TestCase` to provide support for standard test methods
-    and `TestStdOut` for additional functionality.
+    Base test case for sync unit tests.
     """
 
-    pass
+    def setUp(self):
+        """
+        Synchronous setup method called before each test.
+        """
+        super().setUp()
+        self.onSetup()
+
+    def tearDown(self):
+        """
+        Synchronous teardown method called after each test.
+        """
+        self.onTeardown()
+        super().tearDown()
+
+    def onSetup(self):
+        """
+        Hook for subclasses to add setup logic.
+        """
+        pass
+
+    def onTeardown(self):
+        """
+        Hook for subclasses to add teardown logic.
+        """
+        pass

orionis/luminate/test/output/contracts/{test_std_out.py → dumper.py}

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-class ITestStdOut(ABC):
+
+class ITestDumper(ABC):
     """
     Interface for standard output debugging utilities.
     This interface defines methods for dumping debugging information, capturing the caller's file, method, and line number, and utilizing a Debug class to output the information. Implementations should provide mechanisms to output or log the provided arguments for debugging purposes