orionis 0.244.0__tar.gz → 0.246.0__tar.gz

{orionis-0.244.0/orionis.egg-info → orionis-0.246.0}/PKG-INFO

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

{orionis-0.244.0 → orionis-0.246.0}/orionis/framework.py

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

orionis-0.246.0/orionis/luminate/config/entities/testing.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from typing import List
+
+@dataclass(frozen=True, kw_only=True)
+class Testing:
+    """
+    Testing is a dataclass that holds configuration options for running tests.
+
+    Attributes:
+        verbosity (int): The verbosity level of the test output. Default is 2.
+            - 0: Silent
+            - 1: Minimal output
+            - 2: Detailed output (default)
+        execution_mode (ExecutionMode): The mode of test execution. Default is ExecutionMode.SEQUENTIAL.
+            - ExecutionMode.SEQUENTIAL: Tests are executed one after another.
+            - ExecutionMode.PARALLEL: Tests are executed in parallel.
+        max_workers (int): The maximum number of worker threads/processes to use when running tests in parallel. Default is 4.
+        fail_fast (bool): Whether to stop execution after the first test failure. Default is False.
+        print_result (bool): Whether to print the test results to the console. Default is True.
+        throw_exception (bool): Whether to throw an exception if a test fails. Default is False.
+        base_path (str): The base directory where tests are located. Default is 'tests'.
+        folder_path (str): The folder path pattern to search for tests. Default is '*'.
+        pattern (str): The filename pattern to identify test files. Default is 'test_*.py'.
+        test_name_pattern (str | None): A pattern to match specific test names. Default is None.
+        tags (List[str] | None): A list of tags to filter tests. Default is None.
+    """
+    verbosity: int = 2
+    execution_mode: str = 'sequential'
+    max_workers: int = 4
+    fail_fast: bool = False
+    print_result: bool = True
+    throw_exception: bool = False
+    base_path: str = 'tests'
+    folder_path: str = '*'
+    pattern: str = 'test_*.py'
+    test_name_pattern: str | None = None,
+    tags: List[str] | None = None

orionis-0.246.0/orionis/luminate/contracts/config/config.py

@@ -0,0 +1,27 @@
+from abc import ABC
+from dataclasses import dataclass
+
+@dataclass
+class EmptyData:
+    """
+    A placeholder dataclass that can be used as a default or empty configuration.
+    This class doesn't have any fields or data, but serves as a default value
+    for the 'config' attribute in classes implementing IConfig.
+    """
+    pass
+
+class IConfig(ABC):
+    """
+    An abstract base class that defines an interface for classes that must have
+    a `config` attribute.
+
+    The subclass is required to implement the `config` attribute, which should be
+    a dataclass instance representing the configuration data.
+
+    Attributes
+    ----------
+    config : object
+        A dataclass instance representing the configuration.
+    """
+
+    config = EmptyData()

{orionis-0.244.0 → orionis-0.246.0}/orionis/luminate/support/environment/env.py

@@ -8,6 +8,7 @@ from orionis.luminate.support.environment.functions import (
     _serialize_value,
     _delete_file
 )
+from orionis.luminate.support.patterns.singleton import SingletonMeta
 
 class Env(IEnv):
     """

orionis-0.246.0/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-0.244.0 → orionis-0.246.0}/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-0.244.0 → orionis-0.246.0}/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-0.246.0/orionis/luminate/test/core/contracts/test_unit.py

@@ -0,0 +1,122 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from orionis.luminate.test.enums.test_mode import ExecutionMode
+
+class IUnitTest(ABC):
+
+    @abstractmethod
+    def configure(
+            self,
+            verbosity: int = None,
+            execution_mode: ExecutionMode = None,
+            max_workers: int = None,
+            fail_fast: bool = None,
+            print_result: bool = None
+        ):
+        """
+        Configures the UnitTest instance with the specified parameters.
+
+        Parameters:
+            verbosity (int, optional): The verbosity level for test output. Defaults to None.
+            execution_mode (ExecutionMode, optional): The mode in which the tests will be executed. Defaults to None.
+            max_workers (int, optional): The maximum number of workers to use for parallel execution. Defaults to None.
+            fail_fast (bool, optional): Whether to stop execution upon the first failure. Defaults to None.
+            print_result (bool, optional): Whether to print the test results after execution. Defaults to None.
+
+        Returns:
+            UnitTest: The configured UnitTest instance.
+        """
+        pass
+
+    @abstractmethod
+    def discoverTestsInFolder(
+        self,
+        folder_path: str,
+        base_path: str = "tests",
+        pattern: str = "test_*.py",
+        test_name_pattern: Optional[str] = None,
+        tags: Optional[List[str]] = None
+    ):
+        """
+        Discovers and loads unit tests from a specified folder.
+        Args:
+            folder_path (str): The relative path to the folder containing the tests.
+            base_path (str, optional): The base directory where the test folder is located. Defaults to "tests".
+            pattern (str, optional): The filename pattern to match test files. Defaults to "test_*.py".
+            test_name_pattern (Optional[str], optional): A pattern to filter test names. Defaults to None.
+            tags (Optional[List[str]], optional): A list of tags to filter tests. Defaults to None.
+        Returns:
+            UnitTest: The current instance of the UnitTest class with the discovered tests added.
+        Raises:
+            ValueError: If the test folder does not exist, no tests are found, or an error occurs during test discovery.
+        """
+        pass
+
+    @abstractmethod
+    def discoverTestsInModule(self, module_name: str, test_name_pattern: Optional[str] = None):
+        """
+        Discovers and loads tests from a specified module, optionally filtering them
+        by a test name pattern, and adds them to the test suite.
+        Args:
+            module_name (str): The name of the module to discover tests from.
+            test_name_pattern (Optional[str]): A pattern to filter test names. Only
+                tests matching this pattern will be included. Defaults to None.
+        Returns:
+            UnitTest: The current instance of the UnitTest class, allowing method chaining.
+        Raises:
+            ValueError: If the specified module cannot be imported.
+        """
+        pass
+
+    @abstractmethod
+    def run(self, print_result: bool = None, throw_exception: bool = False) -> Dict[str, Any]:
+        """
+        Executes the test suite and processes the results.
+        Args:
+            print_result (bool, optional): If provided, overrides the instance's
+                `print_result` attribute to determine whether to print the test results.
+            throw_exception (bool, optional): If True, raises an exception if any
+                test failures or errors are detected.
+        Returns:
+            Dict[str, Any]: A summary of the test execution, including details such as
+            execution time, test results, and a timestamp.
+        Raises:
+            OrionisTestFailureException: If `throw_exception` is True and there are
+            test failures or errors.
+        """
+        pass
+
+    @abstractmethod
+    def getTestNames(self) -> List[str]:
+        """
+        Retrieves a list of test names from the test suite.
+
+        This method flattens the test suite and extracts the unique identifier
+        (`id`) of each test case.
+
+        Returns:
+            List[str]: A list of test names (unique identifiers) from the test suite.
+        """
+        pass
+
+    @abstractmethod
+    def getTestCount(self) -> int:
+        """
+        Calculate the total number of tests in the test suite.
+
+        This method flattens the test suite structure and counts the total
+        number of individual test cases.
+
+        Returns:
+            int: The total number of test cases in the test suite.
+        """
+        pass
+
+    @abstractmethod
+    def clearTests(self) -> None:
+        """
+        Clears the current test suite by reinitializing it to an empty `unittest.TestSuite`.
+
+        This method is used to reset the test suite, removing any previously added tests.
+        """
+        pass

orionis-0.246.0/orionis/luminate/test/core/test_suite.py

@@ -0,0 +1,92 @@
+import re
+from os import walk
+from orionis.luminate.config.entities.testing import Testing
+from orionis.luminate.test.core.test_unit import UnitTest
+from orionis.luminate.test.exceptions.test_config_exception import OrionisTestConfigException
+
+class TestSuite:
+
+    @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.
+        """
+
+        # 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(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