orionis 0.245.0__py3-none-any.whl → 0.247.0__py3-none-any.whl

orionis/luminate/services/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/luminate/services/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/luminate/services/workers/__init__.py

@@ -0,0 +1,10 @@
+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/services/workers/maximum_workers.py

@@ -0,0 +1,36 @@
+import multiprocessing
+import math
+import psutil
+
+class MaximumWorkers:
+    """
+    Calculates the optimal number of workers a machine can handle based on CPU and memory resources.
+
+    This class estimates the maximum number of Uvicorn (or similar) workers by considering:
+    - The number of available CPU cores.
+    - The total system memory (RAM).
+    - The estimated memory usage per worker (configurable).
+
+    Parameters
+    ----------
+    ram_per_worker : float, optional
+        Estimated amount of RAM (in GB) that each worker will consume. Default is 0.5 GB.
+    """
+
+    def __init__(self, ram_per_worker: float = 0.5):
+        self._cpu_count = multiprocessing.cpu_count()
+        self._ram_total_gb = psutil.virtual_memory().total / (1024 ** 3)
+        self._ram_per_worker = ram_per_worker
+
+    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.
+        """
+        max_workers_by_cpu = self._cpu_count
+        max_workers_by_ram = math.floor(self._ram_total_gb / self._ram_per_worker)
+        return min(max_workers_by_cpu, max_workers_by_ram)

orionis/luminate/support/introspection/abstracts/entities/abstract_class_attributes.py

@@ -0,0 +1,11 @@
+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/abstracts/reflect_abstract.py

@@ -3,11 +3,11 @@ import ast
 import inspect
 import types
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, TypeVar
-from orionis.luminate.support.introspection.contracts.reflexion_abstract import IReflexionAbstract
+from orionis.luminate.support.introspection.abstracts.entities.abstract_class_attributes import AbstractClassAttributes
 
 ABC = TypeVar('ABC', bound=abc.ABC)
 
-class ReflexionAbstract(IReflexionAbstract):
+class ReflexionAbstract:
     """A reflection object encapsulating an abstract class.
 
     Parameters
@@ -64,7 +64,7 @@ class ReflexionAbstract(IReflexionAbstract):
         """
         return self._abstract.__module__
 
-    def getAllAttributes(self) -> Dict[str, Any]:
+    def getAllAttributes(self) -> AbstractClassAttributes:
         """
         Get all attributes of the abstract class.
 
@@ -93,11 +93,161 @@ class ReflexionAbstract(IReflexionAbstract):
             else:
                 public[attr] = value
 
-        return {"public": public, "protected": protected, "private": private}
+        return AbstractClassAttributes(
+            public=public,
+            private=private,
+            protected=protected
+        )
 
+    def getAttributes(self) -> Dict[str, Any]:
+        """
+        Get all attributes of the instance.
 
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return {**attr.public, **attr.private, **attr.protected}
 
+    def getPublicAttributes(self) -> Dict[str, Any]:
+        """
+        Get all public attributes of the instance.
 
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of public attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.public
+
+    def getPrivateAttributes(self) -> Dict[str, Any]:
+        """
+        Get all private attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of private attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.private
+
+    def getProtectedAttributes(self) -> Dict[str, Any]:
+        """
+        Get all Protected attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of Protected attribute names and their values
+        """
+        attr = self.getAllAttributes()
+        return attr.protected
+
+    def getAllMethods(self) -> Dict[str, List[str]]:
+        """
+        Categorize all methods and relevant members of the abstract class into public, private, protected,
+        static, asynchronous, synchronous, class methods, magic methods, abstract methods, and properties.
+
+        Returns
+        -------
+        Dict[str, List[str]]
+            A dictionary categorizing methods and attributes into various types.
+        """
+        class_name = self.getClassName()
+        private_prefix = f"_{class_name}"
+        attributes = set(self.getAttributes().keys()) | {attr for attr in dir(self._abstract) if attr.startswith('_abc_')}
+
+        result = {
+            "public": [],
+            "private": [],
+            "protected": [],
+            "static": [],
+            "asynchronous": [],
+            "synchronous": [],
+            "class_methods": [],
+            "asynchronous_static": [],
+            "synchronous_static": [],
+            "magic": [],
+            "abstract": [],
+            "abstract_class_methods": [],
+            "abstract_static_methods": []
+        }
+
+        # Precompute all members once
+        members = inspect.getmembers(self._abstract)
+        static_attrs = {}
+
+        # First pass to collect all relevant information
+        for name, attr in members:
+            if name in attributes:
+                continue
+
+            # Get static attribute once
+            static_attr = inspect.getattr_static(self._abstract, name)
+            static_attrs[name] = static_attr
+
+            # Magic methods
+            if name.startswith("__") and name.endswith("__"):
+                result["magic"].append(name)
+                continue
+
+            # Static and class methods
+            if isinstance(static_attr, staticmethod):
+                result["static"].append(name)
+            elif isinstance(static_attr, classmethod):
+                result["class_methods"].append(name)
+
+            # Private, protected, public
+            if name.startswith(private_prefix):
+                clean_name = name.replace(private_prefix, "")
+                result["private"].append(clean_name)
+            elif name.startswith("_"):
+                result["protected"].append(name)
+            else:
+                result["public"].append(name)
+
+            # Async methods
+            if inspect.iscoroutinefunction(attr):
+                clean_name = name.replace(private_prefix, "")
+                if name in result["static"]:
+                    result["asynchronous_static"].append(clean_name)
+                else:
+                    result["asynchronous"].append(clean_name)
+
+        # Second pass for synchronous methods (needs info from first pass)
+        for name, attr in members:
+            if name in attributes or name in result["magic"] or name in result["class_methods"] or name in result["static"]:
+                continue
+
+            if inspect.isfunction(attr):
+                clean_name = name.replace(private_prefix, "")
+                if clean_name not in result["asynchronous"]:
+                    result["synchronous"].append(clean_name)
+
+        # Synchronous static methods
+        for name in result["static"]:
+            if name not in attributes and name not in result["asynchronous_static"] and name not in result["class_methods"]:
+                result["synchronous_static"].append(name)
+
+        # Abstract methods
+        abstract_methods = getattr(self._abstract, "__abstractmethods__", set())
+        for name in abstract_methods:
+            if name in attributes:
+                continue
+
+            static_attr = static_attrs.get(name, inspect.getattr_static(self._abstract, name))
+            if isinstance(static_attr, staticmethod):
+                result["abstract_static_methods"].append(name)
+            elif isinstance(static_attr, classmethod):
+                result["abstract_class_methods"].append(name)
+            elif not isinstance(static_attr, property):
+                result["abstract"].append(name)
+
+        return result
 
 
 
@@ -109,19 +259,7 @@ class ReflexionAbstract(IReflexionAbstract):
 
 
 
-    def getAbstractMethods(self) -> Set[str]:
-        """Get all abstract method names required by the class.
 
-        Returns
-        -------
-        Set[str]
-            Set of abstract method names
-        """
-        methods = []
-        for method in self._abstract.__abstractmethods__:
-            if not isinstance(getattr(self._abstract, method), property):
-                methods.append(method)
-        return set(methods)
 
     def getAbstractProperties(self) -> Set[str]:
         """Get all abstract property names required by the class.

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

@@ -171,8 +171,8 @@ class ReflectionInstance(IReflectionInstance):
     def getAllMethods(self):
         """
         Retrieves and categorizes all methods of the instance's class into various classifications.
-        This method inspects the instance's class and its methods, categorizing them into public, private, 
-        protected, static, asynchronous, synchronous, class methods, asynchronous static, synchronous static, 
+        This method inspects the instance's class and its methods, categorizing them into public, private,
+        protected, static, asynchronous, synchronous, class methods, asynchronous static, synchronous static,
         and magic methods.
         Returns
         -------

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