orionis 0.217.0__tar.gz → 0.219.0__tar.gz

{orionis-0.217.0/orionis.egg-info → orionis-0.219.0}/PKG-INFO

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

{orionis-0.217.0 → orionis-0.219.0}/orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.217.0"
+VERSION = "0.219.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"
@@ -26,7 +26,7 @@ SKELETON = "https://github.com/orionis-framework/skeleton"
 FRAMEWORK = "https://github.com/orionis-framework/framework"
 
 # URL to the project's documentation
-DOCS = "https://github.com/orionis-framework/docs"
+DOCS = "https://orionis-framework.com/"
 
 # API URL to the project's JSON data
 API = "https://pypi.org/pypi/orionis/json"

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/application.py

@@ -10,7 +10,7 @@ from orionis.luminate.foundation.environment.environment_bootstrapper import Env
 from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate.foundation.providers.service_providers_bootstrapper import ServiceProvidersBootstrapper
 from orionis.luminate.patterns.singleton import SingletonMeta
-from orionis.luminate.support.asyn_run import AsyncExecutor
+from orionis.luminate.support.async_io.async_coroutine import AsyncExecutor
 
 class Application(metaclass=SingletonMeta):
     """

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/container/resolve.py

@@ -1,7 +1,7 @@
 from typing import Any, Callable
 from orionis.luminate.container.container import Container
 from orionis.luminate.container.exception import OrionisContainerValueError
-from orionis.luminate.support.asyn_run import AsyncExecutor
+from orionis.luminate.support.async_io.async_coroutine import AsyncExecutor
 
 class Resolve:
     """

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/contracts/facades/facade.py

@@ -1,5 +1,5 @@
 from orionis.luminate.container.container import Container
-from orionis.luminate.support.asyn_run import AsyncExecutor
+from orionis.luminate.support.async_io.async_coroutine import AsyncExecutor
 
 class FacadeMeta(type):
     """

orionis-0.219.0/orionis/luminate/support/async_io/async_coroutine.py

@@ -0,0 +1,48 @@
+import asyncio
+from inspect import iscoroutine
+from typing import Any, Coroutine, TypeVar, Union
+from orionis.luminate.support.async_io.contracts.async_coroutine import IAsyncCoroutine
+
+T = TypeVar("T")
+
+class AsyncCoroutine(IAsyncCoroutine):
+    """
+    A utility class for executing coroutine objects in various asynchronous and synchronous contexts.
+    This class provides a static method to execute coroutine objects, handling different scenarios
+    such as running within an active event loop (e.g., in Jupyter notebooks or Starlette) or in a
+    synchronous context without an active event loop.
+
+    Methods
+    -------
+    execute(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]
+        Executes the given coroutine object, adapting to the current execution context.
+    """
+
+    @staticmethod
+    def execute(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
+        """
+        Executes the given coroutine object, adapting to the current execution context.
+        If there is an active event loop, it uses `asyncio.ensure_future` to schedule the coroutine.
+        If there is no active event loop, it uses `asyncio.run` to run the coroutine directly.
+        If the coroutine is already running, it returns a `Future` object that can be awaited.
+
+        Parameters
+        ----------
+        coro : Coroutine[Any, Any, T]
+            The coroutine object
+        """
+        if not iscoroutine(coro):
+            raise TypeError("Expected a coroutine object.")
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No hay loop activo: ejecutamos directamente
+            return asyncio.run(coro)
+
+        if loop.is_running():
+            # Ya hay un loop activo (notebooks, FastAPI, etc.)
+            return asyncio.ensure_future(coro)  # devuelve un Future (debes await si estás en async)
+        else:
+            # Estamos en código síncrono, pero con acceso al loop
+            return loop.run_until_complete(coro)

orionis-0.219.0/orionis/luminate/support/async_io/contracts/async_coroutine.py

@@ -0,0 +1,31 @@
+import asyncio
+from typing import Any, Coroutine, TypeVar, Union
+
+T = TypeVar("T")
+
+class IAsyncCoroutine:
+    """
+    Interface for executing asynchronous coroutines.
+
+    Methods
+    -------
+    execute(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]
+        Executes the given coroutine.
+    """
+
+    @staticmethod
+    def execute(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
+        """
+        Execute the given coroutine.
+
+        Parameters
+        ----------
+        coro : Coroutine[Any, Any, T]
+            The coroutine to be executed.
+
+        Returns
+        -------
+        Union[T, asyncio.Future]
+            The result of the coroutine execution or a Future object.
+        """
+        pass

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/support/standard/std.py

@@ -4,15 +4,6 @@ class StdClass(IStdClass):
     """
     A dynamic class that allows setting arbitrary attributes,
     similar to PHP's stdClass.
-
-    Examples
-    --------
-    >>> obj = StdClass(name='Raul', age=30)
-    >>> obj.name
-    'Raul'
-    >>> obj.update(age=31)
-    >>> obj.toDict()
-    {'name': 'Raul', 'age': 31}
     """
 
     def __init__(self, **kwargs):

orionis-0.219.0/orionis/luminate/test/contracts/test_std_out.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+class ITestStdOut:
+    """
+    Utility for printing debug info during tests, including caller context (file, line, method).
+    """
+
+    @staticmethod
+    def print(*args: Any) -> None:
+        """
+        Print arguments to the console with file, line, and method of the caller.
+
+        Parameters
+        ----------
+        *args : Any
+            Any values to print. The first argument is ignored (typically the class or context).
+        """

orionis-0.219.0/orionis/luminate/test/contracts/test_suite.py

@@ -0,0 +1,37 @@
+class ITests:
+    """
+    Provides utility methods to configure and execute unit tests from specified folders.
+    """
+
+    @staticmethod
+    def execute(folders: list, print_result:bool = True, throw_exception:bool = False):
+        """
+        Configure and run unit tests from a list of folder definitions.
+
+        Parameters
+        ----------
+        folders : list of dict
+            Each dict must include:
+            - 'folder_path' (str): Path to the folder with test files.
+            - 'base_path' (str): Base path for resolving test imports.
+            - 'pattern' (str): Glob pattern for test file names.
+
+        print_result : bool, default=True
+            Whether to print test results to the console.
+
+        throw_exception : bool, default=False
+            Whether to raise exceptions on test failures.
+
+        Returns
+        -------
+        UnitTestClass
+            The initialized and executed test suite.
+
+        Raises
+        ------
+        TypeError
+            If `folders` is not a list of dictionaries.
+        KeyError
+            If any dictionary lacks required keys: 'folder_path', 'base_path', or 'pattern'.
+        """
+        pass

orionis-0.219.0/orionis/luminate/test/contracts/test_unit.py

@@ -0,0 +1,82 @@
+from typing import Any, Dict, Optional
+
+class IUnitTest:
+    """
+    Advanced unit testing utility for discovering, executing, and reporting test results
+    with support for folder-based discovery, regex filtering, and customizable output.
+
+    Attributes
+    ----------
+    loader : unittest.TestLoader
+        Internal loader for test discovery.
+    suite : unittest.TestSuite
+        The aggregated test suite to be executed.
+    test_results : List[TestResult]
+        List of captured results per test, including status and errors.
+    start_time : float
+        Timestamp when the test execution started.
+    """
+
+    def addFolder(
+        self,
+        folder_path: str,
+        base_path: str = "tests",
+        pattern: str = "test_*.py",
+        test_name_pattern: Optional[str] = None
+    ):
+        """
+        Discover and add test cases from a given folder to the test suite.
+
+        Parameters
+        ----------
+        folder_path : str
+            Relative path to the folder containing test files.
+        base_path : str, default="tests"
+            Base path used to resolve full path to test modules.
+        pattern : str, default="test_*.py"
+            Glob pattern to match test filenames.
+        test_name_pattern : Optional[str], optional
+            Regex pattern to filter discovered test method names.
+
+        Returns
+        -------
+        UnitTest
+            Self instance for chaining.
+
+        Raises
+        ------
+        ValueError
+            If folder is invalid or no tests are found.
+        """
+        pass
+
+    def run(self, print_result:bool = True, throw_exception:bool = False) -> Dict[str, Any]:
+        """
+        Run all added tests and return a summary of the results.
+
+        Parameters
+        ----------
+        print_result : bool, default=True
+            Whether to print a formatted report to the console.
+        throw_exception : bool, default=False
+            Raise an exception if there are failures or errors.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Summary including:
+            - total_tests : int
+            - passed : int
+            - failed : int
+            - errors : int
+            - skipped : int
+            - total_time : str (e.g., '1.234 seconds')
+            - success_rate : str (e.g., '87.5%')
+            - test_details : List[Dict[str, Any]]
+
+        Raises
+        ------
+        OrionisTestFailureException
+            If any test fails or errors occur and `throw_exception=True`.
+        """
+        pass

orionis-0.219.0/orionis/luminate/test/test_case.py

@@ -0,0 +1,62 @@
+import unittest
+from orionis.luminate.test.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`."""
+    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.
+        """
+        await super().asyncSetUp()
+
+    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.
+        """
+        await super().asyncTearDown()
+
+# Another asynchronous test case class
+class TestAsyncCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
+    """
+    TestAsyncCase 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.
+        It ensures that the parent class's asyncSetUp method is invoked to initialize
+        """
+        await super().asyncSetUp()
+
+    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
+        """
+        await super().asyncTearDown()
+
+class TestSyncCase(unittest.TestCase, TestStdOut):
+    """
+    TestSyncCase 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.
+    """
+    pass

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/test/test_std_out.py

@@ -1,8 +1,9 @@
 import os
 import sys
 from orionis.luminate.console.output.console import Console
+from orionis.luminate.test.contracts.test_std_out import ITestStdOut
 
-class TestStdOut:
+class TestStdOut(ITestStdOut):
     """
     A utility class for printing debug information during testing. This class temporarily
     redirects the standard output and error streams to their original states to ensure
@@ -56,7 +57,7 @@ class TestStdOut:
         _line = sys._getframe(1).f_lineno
 
         # Print the contextual information and the provided arguments
-        Console.textMuted(f"[DEBUG] File: {_file}, Line: {_line}, Method: {_method}")
+        Console.textMuted(f"[Printout] File: {_file}, Line: {_line}, Method: {_method}")
         print(*args[1:], end='\n')
         Console.newLine()
 

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/test/test_suite.py

@@ -1,6 +1,7 @@
+from orionis.luminate.test.contracts.test_suite import ITests
 from orionis.luminate.test.test_unit import UnitTest as UnitTestClass
 
-class Tests:
+class Tests(ITests):
     """
     A class containing test utility methods.
 

{orionis-0.217.0 → orionis-0.219.0}/orionis/luminate/test/test_unit.py

@@ -7,11 +7,12 @@ from contextlib import redirect_stdout, redirect_stderr
 from dataclasses import asdict
 from typing import Any, Dict, List, Optional, Tuple
 from orionis.luminate.console.output.console import Console
+from orionis.luminate.test.contracts.test_unit import IUnitTest
 from orionis.luminate.test.test_exception import OrionisTestFailureException
 from orionis.luminate.test.test_result import TestResult
 from orionis.luminate.test.test_status import TestStatus
 
-class UnitTest:
+class UnitTest(IUnitTest):
     """
     An advanced testing framework for discovering, running, and analyzing unit tests.
 

{orionis-0.217.0 → orionis-0.219.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.217.0 → orionis-0.219.0}/orionis.egg-info/SOURCES.txt

@@ -169,8 +169,11 @@ orionis/luminate/services/files/__init__.py
 orionis/luminate/services/files/path_resolver_service.py
 orionis/luminate/services/log/__init__.py
 orionis/luminate/services/log/log_service.py
-orionis/luminate/support/asyn_run.py
-orionis/luminate/support/dot_dict.py
+orionis/luminate/support/adapters/__init__.py
+orionis/luminate/support/adapters/dot_dict.py
+orionis/luminate/support/async_io/__init__.py
+orionis/luminate/support/async_io/async_coroutine.py
+orionis/luminate/support/async_io/contracts/async_coroutine.py
 orionis/luminate/support/inspection/__init__.py
 orionis/luminate/support/inspection/container_integrity.py
 orionis/luminate/support/inspection/functions.py
@@ -201,6 +204,10 @@ orionis/luminate/test/test_status.py
 orionis/luminate/test/test_std_out.py
 orionis/luminate/test/test_suite.py
 orionis/luminate/test/test_unit.py
+orionis/luminate/test/contracts/__init__.py
+orionis/luminate/test/contracts/test_std_out.py
+orionis/luminate/test/contracts/test_suite.py
+orionis/luminate/test/contracts/test_unit.py
 orionis/static/ascii/icon.ascii
 orionis/static/ascii/info.ascii
 orionis/static/bg/galaxy.jpg
@@ -214,6 +221,12 @@ tests/__init__.py
 tests/example/__init__.py
 tests/example/test_example.py
 tests/support/__init__.py
+tests/support/adapters/__init__.py
+tests/support/adapters/test_doct_dict.py
+tests/support/adapters/fakes/__init__.py
+tests/support/adapters/fakes/fake_dict.py
+tests/support/async_io/__init__.py
+tests/support/async_io/test_async_coroutine.py
 tests/support/inspection/__init__.py
 tests/support/inspection/test_reflection_abstract.py
 tests/support/inspection/test_reflection_concrete.py

orionis-0.219.0/tests/support/adapters/fakes/fake_dict.py

@@ -0,0 +1,15 @@
+fake_dict = {
+    "type": "framework",
+    "name": "Orionis Framework",
+    "features": {
+        "authentication": True,
+        "csrf_protection": True,
+        "session_management": True,
+        "logging": True,
+        "error_handling": True,
+        "database_integration": True,
+        "template_engine": True,
+        "api_support": True,
+        "routing": True
+    }
+}

orionis-0.219.0/tests/support/adapters/test_doct_dict.py

@@ -0,0 +1,21 @@
+from orionis.luminate.support.adapters.dot_dict import DotDict
+from orionis.luminate.test.test_case import TestCase
+from tests.support.adapters.fakes.fake_dict import fake_dict
+
+class TestsDotDict(TestCase):
+
+    async def testAccessByDot(self):
+        """
+        Test the ability to access dictionary values using dot notation.
+        """
+        # Create a DotDict instance from the fake_dict
+        dot_dict = DotDict(fake_dict)
+
+        # Access the 'type' attribute using dot notation
+        self.assertEqual(dot_dict.type, "framework")
+
+        # Access the 'name' attribute using dot notation
+        self.assertEqual(dot_dict.name, "Orionis Framework")
+
+        # Access a nested attribute using dot notation
+        self.assertEqual(dot_dict.features.authentication, True)

orionis-0.219.0/tests/support/async_io/test_async_coroutine.py

@@ -0,0 +1,35 @@
+from orionis.luminate.support.async_io.async_coroutine import AsyncCoroutine
+from orionis.luminate.test.test_case import TestCase
+from tests.support.adapters.fakes.fake_dict import fake_dict
+
+class TestsAsyncCoroutine(TestCase):
+
+    async def testExecuteWithActiveEventLoop(self):
+        """
+        Test the execution of a coroutine within an active event loop.
+        This test simulates a scenario where the coroutine is executed in an environment with an active event loop,
+        such as a Jupyter notebook or a Starlette application.
+        """
+        async def sample_coroutine():
+            return "Hello, World!"
+
+        result = await AsyncCoroutine.execute(sample_coroutine())
+        self.assertEqual(result, "Hello, World!")
+
+    async def testExecuteWithoutActiveEventLoop(self):
+        """
+        Test the execution of a coroutine without an active event loop.
+        This test simulates a scenario where the coroutine is executed in a synchronous context without an active event loop.
+        """
+        async def sample_coroutine():
+            return "Hello, World!"
+        result = await AsyncCoroutine.execute(sample_coroutine())
+        self.assertEqual(result, "Hello, World!")
+
+    async def testExecuteWithNonCoroutine(self):
+        """
+        Test the execution of a non-coroutine object.
+        This test checks that a TypeError is raised when a non-coroutine object is passed to the execute method.
+        """
+        with self.assertRaises(TypeError) as context:
+            AsyncCoroutine.execute("not a coroutine")