orionis 0.253.0__py3-none-any.whl → 0.266.0__py3-none-any.whl

orionis/luminate/providers/files/paths_provider.py

@@ -1,20 +0,0 @@
-from orionis.luminate.contracts.services.files.path_resolver_service import IPathResolverService
-from orionis.luminate.providers.service_provider import ServiceProvider
-from orionis.luminate.services_.files.path_resolver_service import PathResolverService
-
-class PathResolverProvider(ServiceProvider):
-
-    def register(self) -> None:
-        """
-        Registers services or bindings into the given container.
-        """
-        self.app.singleton(IPathResolverService, PathResolverService)
-
-    async def boot(self) -> None:
-        """
-        Boot the service provider.
-
-        This method is intended to be overridden by subclasses to perform
-        any necessary bootstrapping or initialization tasks.
-        """
-        await self.app.make(IPathResolverService)

orionis/luminate/services/workers/__init__.py

@@ -1,10 +0,0 @@
-from orionis.luminate.services.workers.maximum_workers import MaximumWorkers
-
-__all__ = [
-    "MaximumWorkers",
-]
-__author__ = "Raúl Mauricio Uñate Castro"
-__description__ = (
-    "This module provides a class to calculate the maximum number of workers "
-    "that can be run on a machine based on its CPU and memory resources. "
-)

orionis/luminate/support/adapters/dot_dict.py

@@ -1,29 +0,0 @@
-class DotDict(dict):
-
-    """
-    A dictionary subclass that allows access to dictionary values using dot notation, with handling for missing keys.
-    This class extends the built-in `dict` class to provide attribute-style access to dictionary keys. If a key is not found,
-    it returns `None` instead of raising a `KeyError`. Additionally, nested dictionaries are automatically converted to `DotDict`
-    instances.
-    Methods
-    -------
-    __getattr__(item)
-        Retrieves the value associated with the given key using dot notation. If the key does not exist, returns `None`.
-        If the value is a dictionary, it is converted to a `DotDict` instance.
-    """
-
-    def __getattr__(self, item):
-        """
-        Retrieves the value associated with the given key using dot notation. If the key does not exist, returns `None`.
-        If the value is a dictionary, it is converted to a `DotDict` instance.
-        """
-
-        # Retrieve the value associated with the key
-        value = self.get(item, None)
-
-        # If the value is a dictionary, convert it to a DotDict instance
-        if isinstance(value, dict):
-            return DotDict(value)
-
-        # Otherwise, return the value
-        return value

orionis/luminate/support/asynchrony/async_io.py

@@ -1,40 +0,0 @@
-import asyncio
-from inspect import iscoroutine
-from typing import Any, Coroutine, TypeVar, Union
-from orionis.luminate.support.asynchrony.contracts.async_coroutine import IAsyncIO
-
-T = TypeVar("T")
-
-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
-    """
-
-    @staticmethod
-    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.
-        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:
-            return asyncio.run(coro)
-
-        if loop.is_running():
-            return asyncio.ensure_future(coro)
-        else:
-            return loop.run_until_complete(coro)

orionis/luminate/support/asynchrony/contracts/async_coroutine.py

@@ -1,26 +0,0 @@
-import asyncio
-from typing import Any, Coroutine, TypeVar, Union
-
-T = TypeVar("T")
-
-class IAsyncIO:
-    """
-    Interface for executing asynchronous coroutines.
-    """
-
-    @staticmethod
-    def run(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/luminate/support/introspection/abstracts/entities/abstract_class_attributes.py

@@ -1,11 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict
-
-@dataclass(frozen=True, kw_only=True)
-class AbstractClassAttributes:
-    """
-    A class to represent the attributes of an entity.
-    """
-    public: Dict[str, Any]
-    private: Dict[str, Any]
-    protected: Dict[str, Any]

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

@@ -1,5 +0,0 @@
-from orionis.luminate.support.introspection.dependencies.reflect_dependencies import ReflectDependencies
-
-__all__ = [
-    "ReflectDependencies"
-]

orionis/luminate/support/introspection/dependencies/entities/class_dependencies.py

@@ -1,11 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List
-from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
-
-@dataclass(frozen=True, kw_only=True)
-class ClassDependency:
-    """
-    A class to represent a dependency of a class instance.
-    """
-    resolved: Dict[ResolvedDependency, Any]
-    unresolved: List[str]

orionis/luminate/support/introspection/dependencies/entities/method_dependencies.py

@@ -1,11 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List
-from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
-
-@dataclass(frozen=True, kw_only=True)
-class MethodDependency:
-    """
-    A class to represent a method dependency of a class instance.
-    """
-    resolved: Dict[ResolvedDependency, Any]
-    unresolved: List[str]

orionis/luminate/support/introspection/dependencies/entities/resolved_dependencies.py

@@ -1,12 +0,0 @@
-from dataclasses import dataclass
-from typing import Type
-
-@dataclass(frozen=True, kw_only=True)
-class ResolvedDependency:
-    """
-    A class to represent a resolved dependency of a class instance.
-    """
-    module_name: str
-    class_name: str
-    type: Type
-    full_class_path: str

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

@@ -1,67 +0,0 @@
-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/luminate/support/paths/resolver.py

@@ -1,83 +0,0 @@
-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/luminate/test/core/contracts/test_suite.py

@@ -1,30 +0,0 @@
-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):
-    """
-    Interface for configuring and initializing a UnitTest suite using a provided Testing configuration.
-    Methods:
-        config(config: Testing) -> UnitTest:
-    """
-
-    @staticmethod
-    @abstractmethod
-    def config(config:Testing) -> UnitTest:
-        """
-        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/test_suite.py

@@ -1,93 +0,0 @@
-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(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 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
-        if not isinstance(config, Testing):
-            raise OrionisTestConfigException("The config parameter must be an instance of the Testing class.")
-
-        # Initialize the test suite
-        tests = UnitTest()
-
-        # Assign config values to the test suite
-        tests.configure(
-            verbosity=config.verbosity,
-            execution_mode=config.execution_mode,
-            max_workers=config.max_workers,
-            fail_fast=config.fail_fast,
-            print_result=config.print_result,
-            throw_exception=config.throw_exception
-        )
-
-        # Extract configuration values
-        base_path = config.base_path
-        folder_path = config.folder_path
-        pattern = config.pattern
-
-        # Helper function to list folders matching the pattern
-        def list_matching_folders(custom_path: str, pattern: str):
-            matched_folders = []
-            for root, _, files in walk(custom_path):
-                for file in files:
-                    if re.fullmatch(pattern.replace('*', '.*').replace('?', '.'), file):
-                        relative_path = root.replace(base_path, '').replace('\\', '/').lstrip('/')
-                        if relative_path not in matched_folders:
-                            matched_folders.append(relative_path)
-            return matched_folders
-
-        # Discover folders
-        discovered_folders = []
-        if folder_path == '*':
-            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(f"{base_path}/{custom_path}", pattern))
-        else:
-            discovered_folders.extend(list_matching_folders(folder_path, pattern))
-
-        # Add discovered folders to the test suite
-        for folder in discovered_folders:
-            tests.discoverTestsInFolder(
-                folder_path=folder,
-                base_path=base_path,
-                pattern=pattern,
-                test_name_pattern=config.test_name_pattern if config.test_name_pattern else None,
-                tags=config.tags if config.tags else None
-            )
-
-        # Return the initialized test suite
-        return tests