orionis 0.246.0__py3-none-any.whl → 0.248.0__py3-none-any.whl

orionis/luminate/test/__init__.py

@@ -10,4 +10,14 @@ __all__ = [
     "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

@@ -6,17 +6,8 @@ class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
     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.
-    Methods
-    -------
-    asyncSetUp()
-        Asynchronous setup method called before each test. It ensures that the
-        parent class's asyncSetUp method is invoked to initialize any required
-        resources.
-    asyncTearDown()
-        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.
     """
+
     async def asyncSetUp(self):
         """
         Asynchronous setup method called before each test.

orionis/luminate/test/cases/test_case.py

@@ -3,9 +3,14 @@ from orionis.luminate.test.output.test_std_out import TestStdOut
 
 class TestCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
     """
-    TestCase is a base class for unit tests that provides support for asynchronous
-    testing using `unittest.IsolatedAsyncioTestCase` and additional functionality
-    from `TestStdOut`."""
+    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.
+    """
+
     async def asyncSetUp(self):
         """
         Asynchronous setup method called before each test.

orionis/luminate/test/cases/test_sync.py

@@ -7,4 +7,5 @@ class SyncTestCase(unittest.TestCase, TestStdOut):
     It inherits from `unittest.TestCase` to provide support for standard test methods
     and `TestStdOut` for additional functionality.
     """
+
     pass

orionis/luminate/test/core/contracts/test_suite.py

@@ -1,42 +1,30 @@
 from abc import ABC, abstractmethod
+from orionis.luminate.config.entities.testing import Testing
+from orionis.luminate.test.core.test_unit import UnitTest
 
 class ITestSuite(ABC):
     """
-    Provides utility methods to configure and execute unit tests from specified folders.
+    Interface for configuring and initializing a UnitTest suite using a provided Testing configuration.
+    Methods:
+        config(config: Testing) -> UnitTest:
     """
 
     @staticmethod
     @abstractmethod
-    def load(
-        base_path: str = 'tests',
-        folder_path: list | str = '*',
-        pattern: str = 'test_*.py'
-    ):
+    def config(config:Testing) -> UnitTest:
         """
-        Discover and initialize a test suite from the specified folder(s).
-
-        This method scans the provided folder(s) for test files matching the given pattern
-        and initializes a test suite with the discovered files.
-
-        Parameters
-        ----------
-        base_path : str, optional
-            The base path for the tests. Defaults to 'tests'.
-        folder_path : str or list of str, optional
-            Path(s) to the folder(s) containing test files. Use '*' to scan all folders
-            under the base path. Defaults to '*'.
-        pattern : str, optional
-            File pattern to match test files. Defaults to 'test_*.py'.
-
-        Returns
-        -------
-        UnitTestClass
-            An initialized test suite containing the discovered test files.
-
-        Raises
-        ------
-        TypeError
-            If `base_path` is not a string, `folder_path` is not a string or list, or
-            `pattern` is not a string.
+        Configures and initializes a UnitTest suite based on the provided Testing configuration.
+        Args:
+            config (Testing): An instance of the Testing class containing configuration options for the test suite.
+        Returns:
+            UnitTest: An initialized UnitTest suite configured according to the provided settings.
+        Raises:
+            OrionisTestConfigException: If the config parameter is not an instance of the Testing class.
+        The function performs the following steps:
+            - Validates the type of the config parameter.
+            - Initializes a UnitTest suite and applies configuration values from the Testing instance.
+            - Discovers folders containing test files based on the specified base path, folder path(s), and filename pattern.
+            - Adds discovered test folders to the UnitTest suite, applying optional test name patterns and tags.
+            - Returns the configured UnitTest suite ready for execution.
         """
         pass

orionis/luminate/test/core/contracts/test_unit.py

@@ -3,6 +3,10 @@ from typing import Any, Dict, List, Optional
 from orionis.luminate.test.enums.test_mode import ExecutionMode
 
 class IUnitTest(ABC):
+    """
+    IUnitTest is an abstract base class that defines the contract for a unit testing interface within the Orionis framework.
+    This interface provides methods for configuring the test runner, discovering tests in folders or modules, executing tests, retrieving test information, and managing the test suite. Implementations of this interface are expected to provide mechanisms for flexible test discovery, execution, and result handling, supporting features such as verbosity control, parallel execution, test filtering, and result reporting.
+    """
 
     @abstractmethod
     def configure(

orionis/luminate/test/core/test_suite.py

@@ -1,38 +1,39 @@
 import re
 from os import walk
 from orionis.luminate.config.entities.testing import Testing
+from orionis.luminate.test.core.contracts.test_suite import ITestSuite
 from orionis.luminate.test.core.test_unit import UnitTest
 from orionis.luminate.test.exceptions.test_config_exception import OrionisTestConfigException
 
-class TestSuite:
+class TestSuite(ITestSuite):
+    """
+    TestSuite provides static configuration and initialization of a unit test suite based on a given Testing configuration.
+    Methods:
+        config(config: Testing) -> UnitTest
+            Configures and initializes a test suite using the provided Testing configuration.
+            - Validates the type of the configuration object.
+            - Sets up the UnitTest suite with parameters such as verbosity, execution mode, worker count, and error handling.
+            - Discovers test folders based on base path, folder path(s), and filename pattern, supporting wildcards.
+            - Adds discovered test folders to the suite, optionally filtering by test name pattern and tags.
+        OrionisTestConfigException: If the provided config is not an instance of the Testing class.
+    """
 
     @staticmethod
     def config(config:Testing) -> UnitTest:
         """
-            Configures and initializes a test suite based on the provided configuration.
-            Args:
-                config (Testing): An instance of the `Testing` class containing configuration
-                                  parameters for the test suite.
-            Returns:
-                UnitTest: An initialized test suite configured with the provided settings.
-            Raises:
-                OrionisTestConfigException: If the `config` parameter is not an instance of
-                                            the `Testing` class.
-            The function performs the following steps:
-            1. Validates that the `config` parameter is an instance of the `Testing` class.
-            2. Initializes a `UnitTest` object and assigns configuration values to it.
-            3. Extracts configuration values such as `base_path`, `folder_path`, and `pattern`.
-            4. Discovers folders matching the specified `folder_path` and `pattern`:
-               - If `folder_path` is '*', all matching folders in the `base_path` are discovered.
-               - If `folder_path` is a list, matching folders in each path are discovered.
-               - Otherwise, matching folders in the specified `folder_path` are discovered.
-            5. Adds discovered folders to the test suite by calling `discoverTestsInFolder`.
-            Notes:
-                - The `list_matching_folders` helper function is used to find folders matching
-                  the specified pattern.
-                - The `pattern` supports wildcard characters (`*` and `?`) for flexible matching.
-                - The `test_name_pattern` and `tags` from the `config` are used when adding
-                  folders to the test suite.
+        Configures and initializes a UnitTest suite based on the provided Testing configuration.
+        Args:
+            config (Testing): An instance of the Testing class containing configuration options for the test suite.
+        Returns:
+            UnitTest: An initialized UnitTest suite configured according to the provided settings.
+        Raises:
+            OrionisTestConfigException: If the config parameter is not an instance of the Testing class.
+        The function performs the following steps:
+            - Validates the type of the config parameter.
+            - Initializes a UnitTest suite and applies configuration values from the Testing instance.
+            - Discovers folders containing test files based on the specified base path, folder path(s), and filename pattern.
+            - Adds discovered test folders to the UnitTest suite, applying optional test name patterns and tags.
+            - Returns the configured UnitTest suite ready for execution.
         """
 
         # Check if the config is an instance of Testing
@@ -74,7 +75,7 @@ class TestSuite:
             discovered_folders.extend(list_matching_folders(base_path, pattern))
         elif isinstance(folder_path, list):
             for custom_path in folder_path:
-                discovered_folders.extend(list_matching_folders(custom_path, pattern))
+                discovered_folders.extend(list_matching_folders(f"{base_path}/{custom_path}", pattern))
         else:
             discovered_folders.extend(list_matching_folders(folder_path, pattern))
 

orionis/luminate/test/core/test_unit.py

@@ -27,38 +27,6 @@ class UnitTest(IUnitTest):
     customizable verbosity, fail-fast behavior, and rich output formatting using the `rich` library.
         loader (unittest.TestLoader): The test loader used to discover and load tests.
         suite (unittest.TestSuite): The test suite containing the discovered tests.
-    Methods:
-        configure(verbosity, execution_mode, max_workers, fail_fast, print_result):
-        discoverTestsInFolder(folder_path, base_path, pattern, test_name_pattern, tags):
-        discoverTestsInModule(module_name, test_name_pattern):
-            Discovers and loads tests from a specified module, optionally filtering them by a test name pattern.
-        run(print_result, throw_exception):
-        getTestNames():
-        getTestCount():
-            Calculates the total number of tests in the test suite.
-        clearTests():
-    Private Methods:
-        _startMessage():
-        _runTestsSequentially(output_buffer, error_buffer):
-        _runTestsInParallel(output_buffer, error_buffer):
-            Executes tests in parallel using a thread pool.
-        _mergeTestResults(combined_result, individual_result):
-        _createCustomResultClass():
-            Creates a custom test result class that extends `unittest.TextTestResult` for enhanced functionality.
-        _generateSummary(result, execution_time):
-            Generates a summary of the test results, including details about each test and overall statistics.
-        _printSummaryTable(summary):
-        _filterTestsByName(suite, pattern):
-        _filterTestsByTags(suite, tags):
-        _flattenTestSuite(suite):
-        _sanitizeTraceback(test_path, traceback_test):
-            Sanitizes a traceback string to extract and display the most relevant parts related to a specific test file.
-        _displayResults(summary, result):
-            Displays the results of the test execution, including a summary table and detailed information about failed or errored tests.
-        _extractErrorInfo(traceback_str):
-            Extracts error information from a traceback string, including the file path and cleaned-up traceback.
-        _finishMessage(summary):
-            Displays a formatted message indicating the completion of the test suite execution.
     """
 
     def __init__(self) -> None:
@@ -93,7 +61,7 @@ class UnitTest(IUnitTest):
         self.rich_console = RichConsole()
         self.orionis_console = Console()
         self.discovered_tests: List = []
-        self.width_table: int = 0
+        self.width_output_component: int = int(self.rich_console.width * 0.75)
         self.throw_exception: bool = False
 
     def configure(
@@ -241,18 +209,25 @@ class UnitTest(IUnitTest):
             test_count = len(list(self._flattenTestSuite(self.suite)))
             mode_text = f"[stat]Parallel with {self.max_workers} workers[/stat]" if self.execution_mode == ExecutionMode.PARALLEL else "Sequential"
             textlines = [
-                f"[bold]Total Tests:[/bold] [stat]{test_count}[/stat]",
-                f"[bold]Mode:[/bold] {mode_text}",
+                f"[bold]Total Tests:[/bold] [dim]{test_count}[/dim]",
+                f"[bold]Mode:[/bold] [dim]{mode_text}[/dim]",
                 f"[bold]Started at:[/bold] [dim]{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}[/dim]"
             ]
-            text = '  |  '.join(textlines).replace('[bold]', '').replace('[/bold]', '').replace('[stat]', '').replace('[/stat]', '').replace('[dim]', '').replace('[/dim]', '')
-            self.width_table = len(text) + 4
 
             self.orionis_console.newLine()
-            self.rich_console.print(Panel.fit(text, border_style="blue", title="🧪 Orionis Framework - Test Suite", title_align="left"))
+            self.rich_console.print(
+                Panel(
+                    '\n'.join(textlines),
+                    border_style="blue",
+                    title="🧪 Orionis Framework - Component Test Suite",
+                    title_align="center",
+                    width=self.width_output_component,
+                    padding=(0, 1)
+                )
+            )
             self.orionis_console.newLine()
 
-    def run(self, print_result: bool = None, throw_exception: bool = False) -> Dict[str, Any]:
+    def run(self, print_result: bool = None, throw_exception: bool = None) -> Dict[str, Any]:
         """
         Executes the test suite and processes the results.
         Args:
@@ -593,7 +568,12 @@ class UnitTest(IUnitTest):
         Returns:
             None
         """
-        table = Table(show_header=True, header_style="bold white", width=self.width_table, border_style="blue")
+        table = Table(
+            show_header=True,
+            header_style="bold white",
+            width=self.width_output_component,
+            border_style="blue"
+        )
         table.add_column("Total", justify="center")
         table.add_column("Passed", justify="center")
         table.add_column("Failed", justify="center")
@@ -789,6 +769,9 @@ class UnitTest(IUnitTest):
                 icon = "❌" if test["status"] == TestStatus.FAILED.name else "💥"
                 border_color = "yellow" if test["status"] == TestStatus.FAILED.name else "red"
 
+                if test['execution_time'] == 0:
+                    test['execution_time'] = 0.001
+
                 panel = Panel(
                     syntax,
                     title=f"{icon} {test['method']}",
@@ -796,7 +779,8 @@ class UnitTest(IUnitTest):
                     border_style=border_color,
                     title_align="left",
                     padding=(1, 1),
-                    subtitle_align="right"
+                    subtitle_align="right",
+                    width=self.width_output_component
                 )
                 self.rich_console.print(panel)
                 self.orionis_console.newLine()
@@ -859,14 +843,13 @@ class UnitTest(IUnitTest):
 
         status_icon = "✅" if (summary['failed'] + summary['errors']) == 0 else "❌"
         msg = f"Test suite completed in {summary['total_time']:.2f} seconds"
-        len_spaces = max(0, int(self.width_table - len(msg)))
-        spaces = ' ' * (len_spaces - 4)
         self.rich_console.print(
-            Panel.fit(
-                f"{msg}{spaces}",
+            Panel(
+                msg,
                 border_style="blue",
                 title=f"{status_icon} Test Suite Finished",
                 title_align='left',
+                width=self.width_output_component,
                 padding=(0, 1)
             )
         )

orionis/luminate/test/entities/test_result.py

@@ -2,25 +2,22 @@ from dataclasses import dataclass
 from typing import Any, Optional
 from orionis.luminate.test.enums.test_status import TestStatus
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, kw_only=True)
 class TestResult:
     """
-    Data class containing detailed information about a test result.
+    Represents the result of a test execution.
 
-    Attributes
-    ----------
-    name : str
-        The name of the test.
-    status : TestStatus
-        The status of the test, indicating whether it passed, failed, or was skipped.
-    execution_time : float
-        The time taken to execute the test, in seconds.
-    error_message : str, optional
-        The error message if the test failed, by default None.
-    traceback : str, optional
-        The traceback information if the test failed, by default None.
-    file_path : str, optional
-        The file path where the test is located, by default None.
+    Attributes:
+        id (Any): Unique identifier for the test result.
+        name (str): Name of the test.
+        status (TestStatus): Status of the test execution (e.g., passed, failed).
+        execution_time (float): Time taken to execute the test, in seconds.
+        error_message (Optional[str]): Error message if the test failed, otherwise None.
+        traceback (Optional[str]): Traceback information if an error occurred, otherwise None.
+        class_name (Optional[str]): Name of the class containing the test, if applicable.
+        method (Optional[str]): Name of the method representing the test, if applicable.
+        module (Optional[str]): Name of the module containing the test, if applicable.
+        file_path (Optional[str]): Path to the file containing the test, if applicable.
     """
     id: Any
     name: str

orionis/luminate/test/exceptions/test_exception.py

@@ -49,4 +49,4 @@ class OrionisTestFailureException(Exception):
         Returns:
             str: A formatted string describing the exception.
         """
-        return f"OrionisTestFailureException: {self.args[0]}"
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/luminate/test/output/contracts/test_std_out.py

@@ -1,17 +1,28 @@
-from typing import Any
-
-class ITestStdOut:
+from abc import ABC, abstractmethod
+class ITestStdOut(ABC):
     """
-    Utility for printing debug info during tests, including caller context (file, line, method).
+    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
     """
 
-    @staticmethod
-    def print(*args: Any) -> None:
+    @abstractmethod
+    def dd(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
         """
-        Print arguments to the console with file, line, and method of the caller.
+        pass
 
-        Parameters
-        ----------
-        *args : Any
-            Any values to print. The first argument is ignored (typically the class or context).
+    @abstractmethod
+    def dump(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
         """
+        pass

orionis/luminate/test/output/test_std_out.py

@@ -1,108 +1,97 @@
 import os
 import sys
-from orionis.luminate.console.output.console import Console
 from orionis.luminate.test.output.contracts.test_std_out import ITestStdOut
+from orionis.luminate.console.dumper.dump_die import Debug
 
 class TestStdOut(ITestStdOut):
     """
-    TestStdOut is a class that provides methods for printing messages to the console
-    and exiting the program. It is designed to be used in a testing environment where
-    console output is important for debugging and reporting purposes.
-    It includes methods for printing messages with contextual information about the
-    file, line number, and method name of the caller. The class also provides a method
-    for forcefully exiting the program with a specified exit code.
+    TestStdOut provides utility methods for debugging and outputting information during test execution.
+    This class implements methods to determine if an object is a test case instance and to output debugging
+    information using the Debug class. It ensures that standard output and error streams are properly managed
+    during debugging dumps, and captures the caller's file and line number for context.
     """
 
-    def console(self):
+    def __isTestCaseClass(self, value):
         """
-        Returns an instance of the Console class for printing messages to the console.
-        Ensures that the original stdout and stderr streams are used during the operation.
+        Determines if the given value is an instance of a test case class.
+        This method checks whether the provided value is an instance of one of the
+        predefined test case classes: AsyncTestCase, TestCase, or SyncTestCase.
+        If the value is None or an ImportError occurs during the import of the
+        test case classes, the method returns False.
+        Args:
+            value: The object to be checked.
+        Returns:
+            bool: True if the value is an instance of AsyncTestCase, TestCase,
+            or SyncTestCase; False otherwise.
         """
+        try:
+            if value is None:
+                return False
+            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
+            return isinstance(value, (AsyncTestCase, TestCase, SyncTestCase))
+        except Exception:
+            return False
+
+    def dd(self, *args):
+        """
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
+        """
+        if not args:
+            return
+
         original_stdout = sys.stdout
         original_stderr = sys.stderr
+
         try:
             sys.stdout = sys.__stdout__
             sys.stderr = sys.__stderr__
-            return Console
+
+            caller_frame = sys._getframe(1)
+            _file = os.path.abspath(caller_frame.f_code.co_filename)
+            _line = caller_frame.f_lineno
+
+            dumper = Debug(f"{_file}:{_line}")
+            if self.__isTestCaseClass(args[0]):
+                dumper.dd(*args[1:])
+            else:
+                dumper.dd(*args)
         finally:
-            # Restore the original stdout and stderr streams
             sys.stdout = original_stdout
             sys.stderr = original_stderr
 
-    def exit(self) -> None:
+    def dump(self, *args):
         """
-        Force close the program with the specified exit code. This method is a wrapper
-        around `os._exit(1)` to ensure that the program terminates immediately without
-        """
-        os._exit(1)
-
-    def dd(self, *args) -> None:
+        Dumps debugging information using the Debug class.
+        This method captures the caller's file, method, and line number,
+        and uses the Debug class to output debugging information.
+        Args:
+            *args: Variable length argument list to be dumped.
         """
-        Prints the provided arguments to the console with contextual information
-        about the file and line number of the caller, and then exits the program.
-        Parameters
-        ----------
-        *args : tuple
-            The arguments to be printed. The first argument is ignored, and the
-            remaining arguments are printed. If no arguments are provided, the
-            method does nothing.
-        Notes
-        -----
-        - The method temporarily redirects `sys.stdout` and `sys.stderr` to their
-          original states (`sys.__stdout__` and `sys.__stderr__`) to ensure proper
-          console output.
-        - The contextual information includes the file path and line number of the
-          caller, which is displayed in a muted text format.
-        - After printing, the method restores the original `sys.stdout` and
-          `sys.stderr` streams.
-        """
-        self.dump(*args)
-        self.exit()
-
-    def dump(*args):
-        """
-        Prints the provided arguments to the console with contextual information
-        about the file and line number of the caller. The output is formatted with
-        muted text decorations for better readability.
-        Parameters
-        ----------
-        *args : tuple
-            The arguments to be printed. The first argument is ignored, and the
-            remaining arguments are printed. If no arguments are provided, the
-            method does nothing.
-        Notes
-        -----
-        - The method temporarily redirects `sys.stdout` and `sys.stderr` to their
-          original states (`sys.__stdout__` and `sys.__stderr__`) to ensure proper
-          console output.
-        - The contextual information includes the file path and line number of the
-          caller, which is displayed in a muted text format.
-        - After printing, the method restores the original `sys.stdout` and
-          `sys.stderr` streams.
-        """
-
-        # Check if the first argument is a string and remove it from the args tuple
-        if len(args) == 0:
+        if not args:
             return
 
-        # Change the output stream to the original stdout and stderr
-        # to avoid any issues with the console output
         original_stdout = sys.stdout
         original_stderr = sys.stderr
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
 
-        # Get the file name and line number of the caller
-        # using sys._getframe(1) to access the caller's frame
-        _file = os.path.relpath(sys._getframe(1).f_code.co_filename, start=os.getcwd())
-        _method = sys._getframe(1).f_code.co_name
-        _line = sys._getframe(1).f_lineno
+        try:
+            sys.stdout = sys.__stdout__
+            sys.stderr = sys.__stderr__
 
-        # Print the contextual information and the provided arguments
-        Console.textMuted(f"File: {_file}, Line: {_line}, Method: {_method}")
-        print(*args, end='\n')
-        Console.newLine()
+            caller_frame = sys._getframe(1)
+            _file = os.path.abspath(caller_frame.f_code.co_filename)
+            _line = caller_frame.f_lineno
 
-        # Restore the original stdout and stderr streams
-        sys.stdout = original_stdout
-        sys.stderr = original_stderr
+            dumper = Debug(f"{_file}:{_line}")
+            if self.__isTestCaseClass(args[0]):
+                dumper.dump(*args[1:])
+            else:
+                dumper.dump(*args)
+        finally:
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr

{orionis-0.246.0.dist-info → orionis-0.248.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.246.0
+Version: 0.248.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro
@@ -14,6 +14,9 @@ License-File: LICENCE
 Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: cryptography>=44.0.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier