orionis 0.222.0__tar.gz → 0.224.0__tar.gz

{orionis-0.222.0/orionis.egg-info → orionis-0.224.0}/PKG-INFO

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

{orionis-0.222.0 → orionis-0.224.0}/orionis/framework.py

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

{orionis-0.222.0 → orionis-0.224.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.async_io.async_coroutine import AsyncExecutor
+from orionis.luminate.support.async.async_io import AsyncExecutor
 
 class Application(metaclass=SingletonMeta):
     """

{orionis-0.222.0 → orionis-0.224.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.async_io.async_coroutine import AsyncExecutor
+from orionis.luminate.support.async.async_io import AsyncExecutor
 
 class Resolve:
     """

{orionis-0.222.0 → orionis-0.224.0}/orionis/luminate/contracts/facades/facade.py

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

orionis-0.222.0/orionis/luminate/support/async_io/async_coroutine.py → orionis-0.224.0/orionis/luminate/support/asynchrony/async_io.py

@@ -1,25 +1,20 @@
 import asyncio
 from inspect import iscoroutine
 from typing import Any, Coroutine, TypeVar, Union
-from orionis.luminate.support.async_io.contracts.async_coroutine import IAsyncCoroutine
+from orionis.luminate.support.asynchrony.contracts.async_coroutine import IAsyncIO
 
 T = TypeVar("T")
 
-class AsyncCoroutine(IAsyncCoroutine):
+class AsyncIO(IAsyncIO):
     """
     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.
+    synchronous context without an active event
     """
 
     @staticmethod
-    def execute(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
+    def run(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.

{orionis-0.222.0/orionis/luminate/support/async_io → orionis-0.224.0/orionis/luminate/support/asynchrony}/contracts/async_coroutine.py

@@ -3,18 +3,13 @@ from typing import Any, Coroutine, TypeVar, Union
 
 T = TypeVar("T")
 
-class IAsyncCoroutine:
+class IAsyncIO:
     """
     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]:
+    def run(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
         """
         Execute the given coroutine.
 

orionis-0.224.0/orionis/luminate/support/paths/contracts/resolver.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+class IResolver(ABC):
+    """
+    Interface for a utility class that resolves file and directory paths relative to a base path.
+    """
+
+    @abstractmethod
+    def __init__(self, root_path: Optional[str] = None):
+        """
+        Initializes the resolver with an optional root path.
+
+        Parameters
+        ----------
+        root_path : str, optional
+            The root directory to resolve relative paths from.
+        """
+        pass
+
+    @abstractmethod
+    def relativePath(self, relative_path: str):
+        """
+        Resolves a relative path into an absolute one and validates its existence.
+
+        Parameters
+        ----------
+        relative_path : str
+            The relative path to resolve.
+
+        Returns
+        -------
+        ResolverInterface
+            The instance itself for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the resolved path does not exist.
+        ValueError
+            If the resolved path is neither a file nor a directory.
+        """
+        pass
+
+    @abstractmethod
+    def toString(self) -> str:
+        """
+        Returns the resolved path as a string.
+
+        Returns
+        -------
+        str
+            The resolved path.
+        """
+        pass
+
+    @abstractmethod
+    def __str__(self) -> str:
+        """
+        Returns the resolved path as a string (for print or str()).
+
+        Returns
+        -------
+        str
+            The resolved path.
+        """
+        pass

orionis-0.224.0/orionis/luminate/support/paths/resolver.py

@@ -0,0 +1,83 @@
+import os
+from pathlib import Path
+from orionis.luminate.support.paths.contracts.resolver import IResolver
+
+class Resolver(IResolver):
+    """
+    A utility class for resolving file and directory paths relative to the project's root directory.
+    """
+
+    def __init__(self, root_path: str = None):
+        """
+        Initializes the Resolver instance with the project's root directory.
+
+        Parameters
+        ----------
+        root_path : str, optional
+            The root directory of the project. If not provided, it defaults to the current working directory.
+        """
+        self.base_path = Path(root_path).resolve() if root_path else Path(os.getcwd()).resolve()
+        self.resolved_path = None
+
+    def relativePath(self, relative_path: str) -> 'Resolver':
+        """
+        Resolves a given relative path to an absolute path and validates its existence.
+
+        This method combines the project's root directory with the provided relative path,
+        resolves it to an absolute path, and ensures it exists as either a directory or a file.
+
+        Parameters
+        ----------
+        relative_path : str
+            The relative path to a directory or file to be resolved.
+
+        Returns
+        -------
+        Resolver
+            The current instance of the Resolver class with the resolved path.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the resolved path does not exist.
+        ValueError
+            If the resolved path is neither a valid directory nor a file.
+        """
+        # Combine the base path with the relative path and resolve it
+        resolved_path = (self.base_path / relative_path).resolve()
+
+        # Validate that the path exists
+        if not resolved_path.exists():
+            raise FileNotFoundError(f"The requested path does not exist: {resolved_path}")
+
+        # Validate that the path is either a directory or a file
+        if not (resolved_path.is_dir() or resolved_path.is_file()):
+            raise ValueError(f"The requested path is neither a valid directory nor a file: {resolved_path}")
+
+        # Store the resolved path in the instance variable
+        self.resolved_path = resolved_path
+
+        # Return the current instance
+        return self
+
+    def toString(self) -> str:
+        """
+        Returns the string representation of the resolved path.
+
+        Returns
+        -------
+        str
+            The resolved path as a string.
+        """
+        return str(self.resolved_path)
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the resolved path.
+
+        Returns
+        -------
+        str
+            The resolved path as a string.
+        """
+        return str(self.resolved_path)

{orionis-0.222.0 → orionis-0.224.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.222.0 → orionis-0.224.0}/orionis.egg-info/SOURCES.txt

@@ -170,9 +170,10 @@ orionis/luminate/services/log/log_service.py
 orionis/luminate/support/__init__.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/asynchrony/__init__.py
+orionis/luminate/support/asynchrony/async_io.py
+orionis/luminate/support/asynchrony/contracts/__init__.py
+orionis/luminate/support/asynchrony/contracts/async_coroutine.py
 orionis/luminate/support/inspection/__init__.py
 orionis/luminate/support/inspection/container_integrity.py
 orionis/luminate/support/inspection/functions.py
@@ -191,6 +192,10 @@ orionis/luminate/support/parsers/__init__.py
 orionis/luminate/support/parsers/exception_parser.py
 orionis/luminate/support/parsers/contracts/__init__.py
 orionis/luminate/support/parsers/contracts/exception_parser.py
+orionis/luminate/support/paths/__init__.py
+orionis/luminate/support/paths/resolver.py
+orionis/luminate/support/paths/contracts/__init__.py
+orionis/luminate/support/paths/contracts/resolver.py
 orionis/luminate/support/patterns/__init__.py
 orionis/luminate/support/patterns/singleton.py
 orionis/luminate/support/standard/__init__.py
@@ -244,6 +249,8 @@ tests/support/parsers/__init__.py
 tests/support/parsers/test_exception_parser.py
 tests/support/parsers/fakes/__init__.py
 tests/support/parsers/fakes/fake_custom_error.py
+tests/support/path/__init__.py
+tests/support/path/test_resolver.py
 tests/support/patterns/__init__.py
 tests/support/patterns/test_singleton.py
 tests/support/standard/__init__.py

{orionis-0.222.0 → orionis-0.224.0}/tests/support/async_io/test_async_coroutine.py

@@ -1,7 +1,7 @@
-from orionis.luminate.support.async_io.async_coroutine import AsyncCoroutine
+from orionis.luminate.support.asynchrony.async_io import AsyncIO
 from orionis.luminate.test.test_case import TestCase
 
-class TestsAsyncCoroutine(TestCase):
+class TestsAsyncIO(TestCase):
 
     async def testExecuteWithActiveEventLoop(self):
         """
@@ -12,7 +12,7 @@ class TestsAsyncCoroutine(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = await AsyncCoroutine.execute(sample_coroutine())
+        result = await AsyncIO.run(sample_coroutine())
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithoutActiveEventLoop(self):
@@ -23,7 +23,7 @@ class TestsAsyncCoroutine(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = AsyncCoroutine.execute(sample_coroutine())
+        result = AsyncIO.run(sample_coroutine())
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithNonCoroutine(self):
@@ -35,4 +35,4 @@ class TestsAsyncCoroutine(TestCase):
             return "Hello, World!"
 
         with self.assertRaises(TypeError):
-            AsyncCoroutine.execute(sample_no_coroutine())
+            AsyncIO.run(sample_no_coroutine())

orionis-0.224.0/tests/support/path/test_resolver.py

@@ -0,0 +1,33 @@
+from orionis.luminate.support.paths.resolver import Resolver
+from orionis.luminate.test.test_case import TestCase
+
+class TestsResolver(TestCase):
+
+    async def testFileNotFound(self):
+        """
+        Test the Resolver class for a non-existent file path.
+        """
+        file_path = "non_existent_file.txt"
+        with self.assertRaises(FileNotFoundError):
+            Resolver().relativePath(file_path)
+
+    async def testValidFilePath(self):
+        """
+        Test the Resolver class for a valid file path.
+        """
+        path = Resolver().relativePath('orionis/luminate/test/test_suite.py').toString()
+        self.assertTrue(path.endswith('test_suite.py'))
+
+    async def testOtherBasePath(self):
+        """
+        Test the Resolver class for a different base path.
+        """
+        path = Resolver('orionis/luminate/test').relativePath('test_suite.py').toString()
+        self.assertTrue(path.endswith('test_suite.py'))
+
+    async def testEqualOutputString(self):
+        """
+        Test the Resolver class for a string representation of the resolved path.
+        """
+        path = Resolver().relativePath('orionis/luminate/test/test_suite.py')
+        self.assertEqual(path.toString(), str(path))