orionis 0.200.0__py3-none-any.whl → 0.203.0__py3-none-any.whl

orionis/luminate/support/inspection/reflexion_module.py

@@ -0,0 +1,19 @@
+class ReflexionModule:
+    """A reflection object encapsulating a module.
+
+    Parameters
+    ----------
+    module : str
+        The module name being reflected upon
+
+    Attributes
+    ----------
+    _module : str
+        The encapsulated module name
+    """
+
+    def __init__(self, module: str) -> None:
+        """Initialize with the module name."""
+        self._module = module
+
+

orionis/luminate/support/inspection/reflexion_module_with_classname.py

@@ -0,0 +1,22 @@
+class ReflexionModuleWithClassName:
+    """A reflection object encapsulating a module and a class name.
+
+    Parameters
+    ----------
+    module : str
+        The module name being reflected upon
+    class_name : str
+        The class name in the module
+
+    Attributes
+    ----------
+    _module : str
+        The encapsulated module name
+    _class_name : str
+        The encapsulated class name
+    """
+
+    def __init__(self, module: str, class_name: str) -> None:
+        """Initialize with the module name and class name."""
+        self._module = module
+        self._class_name = class_name

orionis/luminate/test/{exception.py → test_exception.py}

@@ -31,7 +31,6 @@ class OrionisTestFailureException(Exception):
         response : str
             The message describing the test failure.
         """
-        # Pass the response to the base Exception class
         super().__init__(response)
 
     def __str__(self) -> str:
@@ -43,4 +42,4 @@ class OrionisTestFailureException(Exception):
         str
             A formatted string containing the exception name and response message.
         """
-        return f"[OrionisTestFailureException]: {self.args[0]}"
+        return f"OrionisTestFailureException: {self.args[0]}"

orionis/luminate/test/test_result.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Optional
+from orionis.luminate.test.test_status import TestStatus
+
+@dataclass
+class TestResult:
+    """
+    Data class containing detailed information about a test result.
+
+    Attributes
+    ----------
+    name : str
+        The name of the test.
+    status : TestStatus
+        The status of the test, indicating whether it passed, failed, or was skipped.
+    execution_time : float
+        The time taken to execute the test, in seconds.
+    error_message : str, optional
+        The error message if the test failed, by default None.
+    traceback : str, optional
+        The traceback information if the test failed, by default None.
+    file_path : str, optional
+        The file path where the test is located, by default None.
+    """
+    name: str
+    status: TestStatus
+    execution_time: float
+    error_message: Optional[str] = None
+    traceback: Optional[str] = None
+    file_path: Optional[str] = None

orionis/luminate/test/test_status.py

@@ -0,0 +1,22 @@
+from enum import Enum, auto
+
+class TestStatus(Enum):
+    """
+    TestStatus(Enum)
+    Enum representing the possible statuses of a test.
+
+    Attributes
+    ----------
+    PASSED : auto()
+        Indicates that the test was executed successfully without any issues.
+    FAILED : auto()
+        Indicates that the test was executed but did not meet the expected outcome.
+    ERRORED : auto()
+        Indicates that an error occurred during the execution of the test.
+    SKIPPED : auto()
+        Indicates that the test was intentionally skipped and not executed.
+    """
+    PASSED = auto()
+    FAILED = auto()
+    ERRORED = auto()
+    SKIPPED = auto()

orionis/luminate/test/tests.py

@@ -0,0 +1,67 @@
+from orionis.luminate.test.unit_test import UnitTest as UnitTestClass
+
+class Tests:
+    """
+    A class containing test utility methods.
+
+    Methods
+    -------
+    folders(folders: list) -> UnitTestClass
+        Validates folder configurations and initializes test suite.
+    """
+
+    @staticmethod
+    def execute(folders: list, print_result:bool = True, throw_exception:bool = False):
+        """
+        Validate folder configurations and initialize test suite.
+
+        Parameters
+        ----------
+        folders : list
+            List of folder configuration dictionaries. Each dictionary must contain:
+            - folder_path : str
+                Path to the folder containing test files
+            - base_path : str
+                Base path for the tests
+            - pattern : str
+                File pattern to match test files
+
+        Returns
+        -------
+        UnitTestClass
+            Initialized test suite with added folders
+
+        Raises
+        ------
+        TypeError
+            If folders is not a list or contains non-dictionary items
+        KeyError
+            If any folder dictionary is missing required keys
+
+        Examples
+        --------
+        >>> Tests.folders([
+        ...     {
+        ...         'folder_path': 'example',
+        ...         'base_path': 'tests',
+        ...         'pattern': 'test_*.py'
+        ...     }
+        ... ])
+        """
+        if not isinstance(folders, list):
+            raise TypeError("folders must be a list")
+
+        for folder in folders:
+            if not isinstance(folder, dict):
+                raise TypeError("each folder must be a dictionary")
+            if not all(key in folder for key in ['folder_path', 'base_path', 'pattern']):
+                raise KeyError("each folder must contain 'folder_path', 'base_path' and 'pattern' keys")
+
+        tests = UnitTestClass()
+        for folder in folders:
+            tests.addFolder(
+                base_path=folder['base_path'],
+                folder_path=folder['folder_path'],
+                pattern=folder['pattern']
+            )
+        return tests.run(print_result, throw_exception)

orionis/luminate/test/unit_test.py

@@ -1,107 +1,327 @@
 import io
 import re
+import time
+import traceback
 import unittest
-from contextlib import redirect_stdout
+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.test_exception import OrionisTestFailureException
+from orionis.luminate.test.test_result import TestResult
+from orionis.luminate.test.test_status import TestStatus
 
 class UnitTest:
     """
-    A testing framework for discovering and running unit tests in a structured way.
+    An advanced testing framework for discovering, running, and analyzing unit tests.
+
+    Features include:
+    - Detailed test discovery and filtering
+    - Comprehensive result reporting
+    - Performance timing
+    - Customizable output formatting
+    - Failure analysis
 
     Attributes
     ----------
     loader : unittest.TestLoader
-        A test loader instance used to discover tests.
+        Test loader instance for discovering tests
     suite : unittest.TestSuite
-        A test suite that holds all discovered tests.
-
-    Methods
-    -------
-    add_folder_tests(folder_path: str, pattern: str = 'test_*.py') -> None
-        Adds test cases from a specified folder to the test suite.
-    run_tests() -> None
-        Executes all tests in the test suite and raises an exception if any fail.
+        Test suite holding discovered tests
+    test_results : List[TestResult]
+        Detailed results of executed tests
+    start_time : float
+        Timestamp when test execution began
     """
 
     def __init__(self) -> None:
-        """
-        Initializes the TestOrionisFramework class, setting up the test loader and suite.
-        """
+        """Initialize the testing framework."""
         self.loader = unittest.TestLoader()
         self.suite = unittest.TestSuite()
+        self.test_results: List[TestResult] = []
+        self.start_time: float = 0.0
 
-    def addFolderTests(self, folder_path: str, pattern: str = "test_*.py") -> None:
+    def addFolder(
+            self,
+            folder_path: str,
+            base_path: str = "tests",
+            pattern: str = "test_*.py",
+            test_name_pattern: Optional[str] = None
+        ) -> 'UnitTest':
         """
-        Adds all test cases from a specified folder to the test suite.
+        Discover and add tests from a specified folder to the test suite.
 
         Parameters
         ----------
         folder_path : str
-            The relative path to the folder containing test files.
+            Path to the folder containing test files
         pattern : str, optional
-            A pattern to match test files (default is 'test_*.py').
+            Pattern to match test files (default 'test_*.py')
+        test_name_pattern : Optional[str], optional
+            Regex pattern to filter test names
 
         Raises
         ------
         ValueError
-            If the folder path is invalid or no tests are found.
+            If the folder is invalid or no tests are found
         """
-        self.loader.discover(f"tests", pattern=pattern)
-
         try:
-            tests = self.loader.discover(f"tests/{folder_path}", pattern=pattern)
-            if not list(tests):  # Check if tests were found
-                raise ValueError(f"No tests found in 'tests/{folder_path}' with pattern '{pattern}'.")
+            tests = self.loader.discover(
+                start_dir=f"{base_path}/{folder_path}",
+                pattern=pattern,
+                top_level_dir=None
+            )
+
+            if test_name_pattern:
+                tests = self._filter_tests_by_name(tests, test_name_pattern)
+
+            if not list(tests):
+                raise ValueError(f"No tests found in '{base_path}/{folder_path}' matching pattern '{pattern}'")
+
             self.suite.addTests(tests)
+
+            return self
+
+        except ImportError as e:
+            raise ValueError(f"Error importing tests from '{base_path}/{folder_path}': {str(e)}")
         except Exception as e:
-            raise ValueError(f"Error discovering tests in 'tests/{folder_path}': {e}")
+            raise ValueError(f"Unexpected error discovering tests: {str(e)}")
+
+    def _filter_tests_by_name(self, suite: unittest.TestSuite, pattern: str) -> unittest.TestSuite:
+        """Filter tests based on a name pattern."""
+        filtered_suite = unittest.TestSuite()
+        regex = re.compile(pattern)
+
+        for test in self._flatten_test_suite(suite):
+            if regex.search(test.id()):
+                filtered_suite.addTest(test)
 
-    def extract_error_file(self, traceback: str) -> str:
-        """Extracts the file path from a traceback message."""
-        match = re.search(r'File "([^"]+)"', traceback)
-        return match.group(1) if match else None
+        return filtered_suite
 
-    def run(self) -> dict:
+    def _flatten_test_suite(self, suite: unittest.TestSuite) -> List[unittest.TestCase]:
+        """Flatten a test suite into a list of test cases."""
+        tests = []
+        for item in suite:
+            if isinstance(item, unittest.TestSuite):
+                tests.extend(self._flatten_test_suite(item))
+            else:
+                tests.append(item)
+        return tests
+
+    def _extract_error_info(self, traceback_str: str) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Extract file path and clean traceback from error output.
+
+        Parameters
+        ----------
+        traceback_str : str
+            The full traceback string
+
+        Returns
+        -------
+        Tuple[Optional[str], Optional[str]]
+            (file_path, clean_traceback)
         """
-        Runs all tests added to the test suite.
+        file_match = re.search(r'File "([^"]+)"', traceback_str)
+        file_path = file_match.group(1) if file_match else None
+
+        # Clean up traceback by removing framework internals
+        tb_lines = traceback_str.split('\n')
+        clean_tb = '\n'.join(line for line in tb_lines if not any(s in line for s in ['unittest/', 'lib/python']))
+
+        return file_path, clean_tb
+
+    def run(self, print_result:bool = True, throw_exception:bool = False) -> Dict[str, Any]:
+        """
+        Execute all tests in the test suite with comprehensive reporting.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Detailed summary of test results including:
+            - total_tests
+            - passed
+            - failed
+            - errors
+            - skipped
+            - total_time
+            - test_details
 
         Raises
         ------
         OrionisTestFailureException
-            If one or more tests fail.
+            If any tests fail or error occurs
         """
-        Console.newLine()
-        Console.info("Running Tests... 🔍")
-        Console.newLine()
+        self.start_time = time.time()
+        if print_result:
+            Console.newLine()
+            Console.info("🚀 Starting Test Execution...")
+            Console.newLine()
 
-        # Capture output safely
+        # Setup output capture
         output_buffer = io.StringIO()
-        with redirect_stdout(output_buffer):
-            runner = unittest.TextTestRunner(stream=output_buffer, verbosity=2)
+        error_buffer = io.StringIO()
+
+        # Execute tests
+        with redirect_stdout(output_buffer), redirect_stderr(error_buffer):
+            runner = unittest.TextTestRunner(
+                stream=output_buffer,
+                verbosity=2,
+                resultclass=self._create_custom_result_class()
+            )
             result = runner.run(self.suite)
 
-        # Display summary table
-        summary = {
-            "tests": result.testsRun,
-            "failures": len(result.failures),
-            "errors": len(result.errors)
+        # Process results
+        execution_time = time.time() - self.start_time
+        summary = self._generate_summary(result, execution_time)
+
+        # Print captured output
+        if print_result:
+            self._display_results(summary, result)
+
+        # if there are any errors or failures, raise an exception
+        if not result.wasSuccessful():
+            if throw_exception:
+                raise OrionisTestFailureException(
+                    f"{summary['failed'] + summary['errors']} test(s) failed"
+                )
+
+        # Return summary of results
+        return summary
+
+    def _create_custom_result_class(self) -> type:
+        """Create a custom TestResult class to capture detailed information."""
+
+        this = self
+        class OrionisTestResult(unittest.TextTestResult):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.test_results = []
+
+            def addSuccess(self, test):
+                super().addSuccess(test)
+                self.test_results.append(
+                    TestResult(
+                        name=str(test),
+                        status=TestStatus.PASSED,
+                        execution_time=0.0
+                    )
+                )
+
+            def addFailure(self, test, err):
+                super().addFailure(test, err)
+                tb_str = ''.join(traceback.format_exception(*err))
+                file_path, clean_tb = this._extract_error_info(tb_str)
+                self.test_results.append(
+                    TestResult(
+                        name=str(test),
+                        status=TestStatus.FAILED,
+                        execution_time=0.0,
+                        error_message=str(err[1]),
+                        traceback=clean_tb,
+                        file_path=file_path
+                    )
+                )
+
+            def addError(self, test, err):
+                super().addError(test, err)
+                tb_str = ''.join(traceback.format_exception(*err))
+                file_path, clean_tb = this._extract_error_info(tb_str)
+                self.test_results.append(
+                    TestResult(
+                        name=str(test),
+                        status=TestStatus.ERRORED,
+                        execution_time=0.0,
+                        error_message=str(err[1]),
+                        traceback=clean_tb,
+                        file_path=file_path
+                    )
+                )
+
+            def addSkip(self, test, reason):
+                super().addSkip(test, reason)
+                self.test_results.append(
+                    TestResult(
+                        name=str(test),
+                        status=TestStatus.SKIPPED,
+                        execution_time=0.0,
+                        error_message=reason
+                    )
+                )
+
+        return OrionisTestResult
+
+    def _generate_summary(self, result: unittest.TestResult, execution_time: float) -> Dict[str, Any]:
+        """Generate a comprehensive test summary."""
+
+        test_details = []
+        for test_result in result.test_results:
+            rst:dict = asdict(test_result)
+            test_details.append({
+                'name': rst.get('name'),
+                'status': rst.get('status').name,
+                'execution_time': float(rst.get('execution_time', 0)),
+                'error_message': rst.get('error_message', None),
+                'traceback': rst.get('traceback', None),
+                'file_path': rst.get('file_path', None)
+            })
+
+        return {
+            "total_tests": result.testsRun,
+            "passed": result.testsRun - len(result.failures) - len(result.errors) - len(result.skipped),
+            "failed": len(result.failures),
+            "errors": len(result.errors),
+            "skipped": len(result.skipped),
+            "total_time": f"{execution_time:.3f} seconds",
+            "success_rate": f"{((result.testsRun - len(result.failures) - len(result.errors)) / result.testsRun * 100):.1f}%",
+            "test_details": test_details
         }
-        Console.table(headers=summary.keys(), rows=[summary.values()])
+
+    def _display_results(self, summary: Dict[str, Any], result: unittest.TestResult) -> None:
+        """Display test results in a formatted manner."""
+        # Summary table
+        Console.table(
+            headers=["Total", "Passed", "Failed", "Errors", "Skipped", "Duration", "Success Rate"],
+            rows=[[
+                summary["total_tests"],
+                summary["passed"],
+                summary["failed"],
+                summary["errors"],
+                summary["skipped"],
+                summary["total_time"],
+                summary["success_rate"]
+            ]]
+        )
         Console.newLine()
 
-        # Display failure details
-        if result.failures:
-            for test_case, traceback in result.failures:
-                title = self.extract_error_file(traceback) or "Error in test"
+        # Detailed failure/error reporting
+        if result.failures or result.errors:
+            Console.textSuccessBold("Test Failures and Errors")
+            for test, traceback_str in result.failures + result.errors:
+                file_path, clean_tb = self._extract_error_info(traceback_str)
+                title = f"❌ {test.id()}" + (f" ({file_path})" if file_path else "")
                 Console.fail(title)
-                Console.write(traceback)
+                Console.write(clean_tb)
+                Console.newLine()
 
-            Console.error(f"{summary['Failures']} test(s) failed.")
-            Console.newLine()
+        # Performance highlights
+        if len(self.test_results) > 10:
+            slow_tests = sorted(
+                [r for r in self.test_results if r.status == TestStatus.PASSED],
+                key=lambda x: x.execution_time,
+                reverse=True
+            )[:3]
+            if slow_tests:
+                Console.textSuccessBold("⏱️ Slowest Passing Tests")
+                for test in slow_tests:
+                    Console.warning(f"{test.name}: {test.execution_time:.3f}s")
 
+        # Final status
+        if result.wasSuccessful():
+            Console.success("✅ All tests passed successfully!")
         else:
-            Console.success("All tests passed successfully.")
-            Console.newLine()
-
-        # Return summary
-        return summary
+            Console.error(
+                f"❌ {summary['failed'] + summary['errors']} test(s) failed "
+                f"(Success Rate: {summary['success_rate']})"
+            )
+        Console.newLine()

{orionis-0.200.0.dist-info → orionis-0.203.0.dist-info}/METADATA

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

{orionis-0.200.0.dist-info → orionis-0.203.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console.py,sha256=4gYWxf0fWYgJ4RKwARvnTPh06FL3GJ6SAZ7R2NzOICw,1342
-orionis/framework.py,sha256=ukJ6tp7s8GNGQ1nIgOUTu9IIbTPgBVsujwBidfNeaUw,1469
+orionis/framework.py,sha256=Xh76tA5RZNGvPeGOth1XVlsBeaj_fhTEcYBbxQoXLdU,1469
 orionis/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/installer/manager.py,sha256=Li4TVziRXWfum02xNG4JHwbnLk-u8xzHjdqKz-D894k,2755
 orionis/installer/output.py,sha256=7O9qa2xtXMB_4ZvVi-Klneom9YazwygAd_4uYAoxhbU,8548
@@ -45,7 +45,7 @@ orionis/luminate/console/output/progress_bar.py,sha256=ZiPGcUaN3EINeLRKgLGtS1GAb
 orionis/luminate/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
 orionis/luminate/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/container/container.py,sha256=9xdODX1h4YK6V-THrfgm5XN95imobExzrb4bllizrWQ,18321
-orionis/luminate/container/container_integrity.py,sha256=lFQ41IN_3Z0SbtJzZ_9jewoaUI4xlsBEFXPfn-p82uI,7976
+orionis/luminate/container/container_integrity.py,sha256=6d9FsGk-Rm1AXgqBS3Nww49dR7n1ptXTTNyGUuBHgNY,10111
 orionis/luminate/container/exception.py,sha256=ap1SqYEjQEEHXJJTNmL7V1jrmRjgT5_7geZ95MYkhMA,1691
 orionis/luminate/container/lifetimes.py,sha256=2lbdiV7R2WlJf1cLD6eBxLnJud_lZvX1IhQH2Djy3Ww,375
 orionis/luminate/container/resolve.py,sha256=Vg0VI3DGzZO6-D3AHX1BpEoiyC5hPDTR-NuiWkl7U_c,2306
@@ -122,7 +122,7 @@ orionis/luminate/facades/files/path_facade.py,sha256=z6DLW7IiBc6nonEwcIbylgpbrM9
 orionis/luminate/facades/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/facades/log/log_facade.py,sha256=8WTLtCvfSdF9ve3lrc3GV0hXxNtolah8WJWfkMUQ_JI,699
 orionis/luminate/facades/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/facades/tests/tests_facade.py,sha256=hvNMU8idxxfvz4x-1_jeloff2Gee0k61VfUhxDrR6eg,1667
+orionis/luminate/facades/tests/tests_facade.py,sha256=TxtxYGLqT3Z199Kox8RL9hGbA4guZie855SJZ6DgfYQ,1662
 orionis/luminate/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/foundation/config/config_bootstrapper.py,sha256=Zdk3C-asIc0zizRI6r_V-e3mQQ1yuh39B8DHdspOxw0,7508
@@ -167,9 +167,23 @@ orionis/luminate/support/dot_dict.py,sha256=FVHfBuAGTTVMjNG01Fix645fRNKKUMmNx61p
 orionis/luminate/support/exception_parse.py,sha256=S4KU0s-MCEbulPrf0N9tLZZIN3Sjn-tOKYtQCP0Xe0k,1655
 orionis/luminate/support/reflection.py,sha256=TbWZ_cer0PXrPlwCYFbUJRymlzYxXT0E4C5XCsSc3mw,11951
 orionis/luminate/support/std.py,sha256=TqrgMxF_i5ubYGT5LOvHCH7HOHNmI8CE1kG9pNoSniY,1390
+orionis/luminate/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/support/inspection/container_integrity.py,sha256=6d9FsGk-Rm1AXgqBS3Nww49dR7n1ptXTTNyGUuBHgNY,10111
+orionis/luminate/support/inspection/functions.py,sha256=XVDLdygONcfDNlH7CZ6muNdtYHLgNp5RybqC3smL4Y4,6400
+orionis/luminate/support/inspection/reflection.py,sha256=x_UHBY9pBSKgct13-u1WbhoONqLoGG60OpgoCsKE0AI,20368
+orionis/luminate/support/inspection/reflexion_abstract.py,sha256=T3Zsi2KT2cS2-Upu0NDcW5FTrcytTLxlmBfZ_KAYA3Y,554
+orionis/luminate/support/inspection/reflexion_concrete.py,sha256=0WOlLeTWLwMeAUReoaJetqlnT1_TxW_jMnbk_yXRR0g,549
+orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=ZuAFoSPkgbOFMIbVR0hvlkKsm1dIpY1_bsXxZxvXcmU,801
+orionis/luminate/support/inspection/reflexion_instance.py,sha256=ROmZ-hxYdnrCsYdzjZyH4KhDZxKEWkDM5ZTPg4BmGmc,9079
+orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=dag6QdVp1CydREWdpQvzAyOPX3q-lSb0_XzB0u3odQE,9629
+orionis/luminate/support/inspection/reflexion_module.py,sha256=OgBXpqNJHkmq-gX4rqFStv-WVNe9R38RsgUgfHpak8k,405
+orionis/luminate/support/inspection/reflexion_module_with_classname.py,sha256=YZHZI0XUZkSWnq9wrGxrIXtI64nY9yVSZoMe7PZXq8Y,620
 orionis/luminate/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/test/exception.py,sha256=VJaZ7VMZfdKW1ov_GwKp2HAz_NYobujJxDt5RaPHuVQ,1395
-orionis/luminate/test/unit_test.py,sha256=7pZWRYRtLRz5_EZBWuXHZShRm7y5ICtl-52FTrsUqso,3652
+orionis/luminate/test/test_exception.py,sha256=21PILTXnMuL5-wT3HGKjIklt8VeIYDcQDN346i-BbJw,1336
+orionis/luminate/test/test_result.py,sha256=Px2_M70r_y7BntRITk_h0IPTbSTW5XhDyklMKHm3JJI,999
+orionis/luminate/test/test_status.py,sha256=vNKRmp1lud_ZGTayf3A8wO_0vEYdFABy_oMw-RcEc1c,673
+orionis/luminate/test/tests.py,sha256=KZRFHB6C8S2DN6JHqJ2sIuSNAUMh9JW1Yn-XGjXjjTw,2218
+orionis/luminate/test/unit_test.py,sha256=HtPDWzFXpgFwWYej8z2BArU4k5lItH57K_E-l21MBWo,12070
 orionis/static/ascii/icon.ascii,sha256=IgrlVjcYxcCrr0cJuJkOnEz0aEdAQBTyLzO5ainKsWc,398
 orionis/static/ascii/info.ascii,sha256=HF_o2eXaiw5iqcOhHfnPByn5GJ_O2eBwSK3IpTfYOwY,457
 orionis/static/bg/galaxy.jpg,sha256=_FuPghOe9LBrIWv1eKZ9fiZR72sEz5obvXGDnD7MzTc,172244
@@ -180,12 +194,15 @@ orionis/static/logos/OrionisFramework.psd,sha256=QFMRe_HENaIgQi9VWMvNV3OHKOFofFG
 orionis/static/logos/OrionisFramework2.png,sha256=Z_-yBHNSo33QeSTyi-8GfiFozdRqUomIZ28bGx6Py5c,256425
 orionis/static/logos/OrionisFramework3.png,sha256=BPG9ZB58vDALavI9OMmr8Ym0DQa44s5NL_3M4M6dIYs,193734
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/tools/class_example.py,sha256=dIPD997Y15n6WmKhWoOFSwEldRm9MdOHTZZ49eF1p3c,1056
-tests/tools/test_reflection.py,sha256=bhLQ7VGVod4B8sv-rW9AjnOumvaBVsoxieA3sdoM2yM,5244
-orionis-0.200.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.200.0.dist-info/METADATA,sha256=i_qQVL-L_p2MpEodOI4lXSM_Lumn2b9wEnc7RuoUYRw,3003
-orionis-0.200.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.200.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.200.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.200.0.dist-info/RECORD,,
+tests/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/example/test_example.py,sha256=IyhepxT7QPQcV2IYGuUDBWgd6sqDSko4-kImbRgqLX4,558
+tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/test_reflection.py,sha256=CQu1j63lHEg2w5Ht8ofaGRmgl1WDNHMnwHjvx5ljs8g,191
+orionis-0.203.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.203.0.dist-info/METADATA,sha256=b8whHtPL9ouHumRWVzSHYM1FfdcGUoR1sVDrcQcV5lY,3003
+orionis-0.203.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.203.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.203.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.203.0.dist-info/RECORD,,