orionis 0.1.0__py3-none-any.whl

orionis/luminate/test/exception.py

@@ -0,0 +1,48 @@
+class OrionisTestFailureException(Exception):
+    """
+    Custom exception raised when test execution results in one or more failures.
+
+    This exception is used to indicate that a test suite run has encountered failures.
+    It stores a response message detailing the number of failed tests or other relevant
+    error information.
+
+    Parameters
+    ----------
+    response : str
+        A message describing the reason for the test failure.
+
+    Attributes
+    ----------
+    response : str
+        Stores the response message describing the failure.
+
+    Methods
+    -------
+    __str__() -> str
+        Returns a string representation of the exception, including the response message.
+    """
+
+    def __init__(self, response: str):
+        """
+        Initializes the exception with a response message.
+
+        Parameters
+        ----------
+        response : str
+            The message describing the test failure.
+        """
+        self.response = response
+
+        # Ensures proper initialization of the Exception class
+        super().__init__(response)
+
+    def __str__(self) -> str:
+        """
+        Returns a human-readable string representation of the exception.
+
+        Returns
+        -------
+        str
+            A formatted string containing the exception name and response message.
+        """
+        return f"OrionisTestFailureException: {self.response}"

orionis/luminate/test/unit_test.py

@@ -0,0 +1,108 @@
+import io
+import re
+import unittest
+from contextlib import redirect_stdout
+from orionis.luminate.console.output.console import Console
+from orionis.luminate.contracts.test.unit_test_interface import IUnitTest
+
+class UnitTest(IUnitTest):
+    """
+    A testing framework for discovering and running unit tests in a structured way.
+
+    Attributes
+    ----------
+    loader : unittest.TestLoader
+        A test loader instance used to discover 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.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the TestOrionisFramework class, setting up the test loader and suite.
+        """
+        self.loader = unittest.TestLoader()
+        self.suite = unittest.TestSuite()
+
+    def addFolderTests(self, folder_path: str, pattern: str = "test_*.py") -> None:
+        """
+        Adds all test cases from a specified folder to the test suite.
+
+        Parameters
+        ----------
+        folder_path : str
+            The relative path to the folder containing test files.
+        pattern : str, optional
+            A pattern to match test files (default is 'test_*.py').
+
+        Raises
+        ------
+        ValueError
+            If the folder path 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}'.")
+            self.suite.addTests(tests)
+        except Exception as e:
+            raise ValueError(f"Error discovering tests in 'tests/{folder_path}': {e}")
+
+    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
+
+    def run(self) -> dict:
+        """
+        Runs all tests added to the test suite.
+
+        Raises
+        ------
+        OrionisTestFailureException
+            If one or more tests fail.
+        """
+        Console.newLine()
+        Console.info("Running Tests... 🔍")
+        Console.newLine()
+
+        # Capture output safely
+        output_buffer = io.StringIO()
+        with redirect_stdout(output_buffer):
+            runner = unittest.TextTestRunner(stream=output_buffer, verbosity=2)
+            result = runner.run(self.suite)
+
+        # Display summary table
+        summary = {
+            "tests": result.testsRun,
+            "failures": len(result.failures),
+            "errors": len(result.errors)
+        }
+        Console.table(headers=summary.keys(), rows=[summary.values()])
+        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"
+                Console.fail(title)
+                Console.write(traceback)
+
+            Console.error(f"{summary['Failures']} test(s) failed.")
+            Console.newLine()
+
+        else:
+            Console.success("All tests passed successfully.")
+            Console.newLine()
+
+        # Return summary
+        return summary

orionis/luminate/tools/reflection.py

@@ -0,0 +1,390 @@
+import os
+import inspect
+import importlib
+from enum import Enum
+from typing import Any, List, Optional
+from orionis.luminate.contracts.tools.reflection_interface import IReflection
+
+class Reflection(IReflection):
+    """
+    The Reflection class dynamically loads a class from a module and inspects its attributes,
+    methods, properties, and other properties at runtime. It supports checking the existence of
+    classes, methods, properties, constants, and can instantiate classes if they are not abstract.
+
+    Attributes
+    ----------
+    classname : str, optional
+        The name of the class to reflect upon. Default is None.
+    module_name : str, optional
+        The name of the module where the class is defined. Default is None.
+    cls : type, optional
+        The class object after it has been imported and assigned. Default is None.
+    """
+
+    def __init__(self, target: Optional[Any] = None, module: Optional[str] = None):
+        """
+        Initializes the Reflection instance with an optional class name, module name, or instance.
+
+        Parameters
+        ----------
+        target : Any, optional
+            The class name as a string, the class type, or an instance of the class. Default is None.
+        module : str, optional
+            The name of the module where the class is defined. Default is None.
+        """
+        self.classname = None
+        self.module_name = module
+        self.cls = None
+
+        if isinstance(target, str):
+            self.classname = target
+        elif isinstance(target, type):
+            self.cls = target
+            self.classname = target.__name__
+        elif target is not None:
+            self.cls = target.__class__
+            self.classname = self.cls.__name__
+
+        if self.module_name and not self.cls:
+            self.safeImport()
+
+    def safeImport(self):
+        """
+        Safely imports the specified module and assigns the class object if a classname is provided.
+
+        This method raises a ValueError if the module cannot be imported or if the class does not exist
+        within the module.
+
+        Raises
+        ------
+        ValueError
+            If the module cannot be imported or the class does not exist in the module.
+        """
+        try:
+            module = importlib.import_module(self.module_name)
+            if self.classname:
+                self.cls = getattr(module, self.classname, None)
+                if self.cls is None:
+                    raise ValueError(f"Class '{self.classname}' not found in module '{self.module_name}'.")
+        except ImportError as e:
+            raise ValueError(f"Error importing module '{self.module_name}': {e}")
+
+    def getFile(self) -> str:
+        """
+        Retrieves the file path where the class is defined.
+
+        Returns
+        -------
+        str
+            The file path if the class is found, otherwise raises an error.
+
+        Raises
+        ------
+        ValueError
+            If the class has not been loaded yet.
+        """
+        if not self.cls:
+            raise ValueError("Class not loaded. Use 'safeImport()' first.")
+        return inspect.getfile(self.cls)
+
+    def hasClass(self) -> bool:
+        """
+        Checks whether the class object is available.
+
+        Returns
+        -------
+        bool
+            True if the class is loaded, False otherwise.
+        """
+        return self.cls is not None
+
+    def hasMethod(self, method_name: str) -> bool:
+        """
+        Checks whether the specified method exists in the class.
+
+        Parameters
+        ----------
+        method_name : str
+            The name of the method to check.
+
+        Returns
+        -------
+        bool
+            True if the method exists, False otherwise.
+        """
+        return hasattr(self.cls, method_name) if self.cls else False
+
+    def hasProperty(self, prop: str) -> bool:
+        """
+        Checks whether the specified property exists in the class.
+
+        Parameters
+        ----------
+        prop : str
+            The name of the property to check.
+
+        Returns
+        -------
+        bool
+            True if the property exists, False otherwise.
+        """
+        return hasattr(self.cls, prop) if self.cls else False
+
+    def hasConstant(self, constant: str) -> bool:
+        """
+        Checks whether the specified constant exists in the class.
+
+        Parameters
+        ----------
+        constant : str
+            The name of the constant to check.
+
+        Returns
+        -------
+        bool
+            True if the constant exists, False otherwise.
+        """
+        return hasattr(self.cls, constant) if self.cls else False
+
+    def getAttributes(self) -> List[str]:
+        """
+        Retrieves a list of all attributes (including methods and properties) of the class.
+
+        Returns
+        -------
+        list
+            A list of attribute names in the class.
+        """
+        return dir(self.cls) if self.cls else []
+
+    def getConstructor(self):
+        """
+        Retrieves the constructor (__init__) of the class.
+
+        Returns
+        -------
+        function or None
+            The constructor method if available, otherwise None.
+        """
+        return self.cls.__init__ if self.cls else None
+
+    def getDocComment(self) -> Optional[str]:
+        """
+        Retrieves the docstring of the class.
+
+        Returns
+        -------
+        str or None
+            The docstring of the class if available, otherwise None.
+        """
+        if not self.cls:
+            raise ValueError("Class not loaded. Use 'safeImport()' first.")
+        return self.cls.__doc__
+
+    def getFileName(self, remove_extension: bool = False) -> str:
+        """
+        Retrieves the file name where the class is defined, the same as `get_file()`.
+
+        Parameters
+        ----------
+        remove_extension : bool, optional
+            If True, the file extension will be removed from the filename. Default is False.
+
+        Returns
+        -------
+        str
+            The file name of the class definition.
+        """
+        file_name = os.path.basename(self.getFile())
+        if remove_extension:
+            file_name = os.path.splitext(file_name)[0]
+        return file_name
+
+    def getMethod(self, method_name: str):
+        """
+        Retrieves the specified method from the class.
+
+        Parameters
+        ----------
+        method_name : str
+            The name of the method to retrieve.
+
+        Returns
+        -------
+        function or None
+            The method if it exists, otherwise None.
+        """
+        return getattr(self.cls, method_name, None) if self.cls else None
+
+    def getMethods(self) -> List[str]:
+        """
+        Retrieves a list of all methods in the class.
+
+        Returns
+        -------
+        list
+            A list of method names in the class.
+        """
+        return [method for method, _ in inspect.getmembers(self.cls, predicate=inspect.isfunction)] if self.cls else []
+
+    def getName(self) -> str:
+        """
+        Retrieves the name of the class.
+
+        Returns
+        -------
+        str or None
+            The name of the class if available, otherwise None.
+        """
+        return self.cls.__name__ if self.cls else None
+
+    def getParentClass(self) -> Optional[tuple]:
+        """
+        Retrieves the parent classes (base classes) of the class.
+
+        Returns
+        -------
+        tuple or None
+            A tuple of base classes if available, otherwise None.
+        """
+        return self.cls.__bases__ if self.cls else None
+
+    def getProperties(self) -> List[str]:
+        """
+        Retrieves a list of all properties of the class.
+
+        Returns
+        -------
+        list
+            A list of property names in the class.
+        """
+        return [name for name, value in inspect.getmembers(self.cls, lambda x: isinstance(x, property))] if self.cls else []
+
+    def getProperty(self, prop: str):
+        """
+        Retrieves the specified property from the class.
+
+        Parameters
+        ----------
+        prop : str
+            The name of the property to retrieve.
+
+        Returns
+        -------
+        property or None
+            The property if it exists, otherwise None.
+        """
+        return getattr(self.cls, prop, None) if self.cls else None
+
+    def isAbstract(self) -> bool:
+        """
+        Checks whether the class is abstract.
+
+        Returns
+        -------
+        bool
+            True if the class is abstract, False otherwise.
+        """
+        return hasattr(self.cls, '__abstractmethods__') and bool(self.cls.__abstractmethods__) if self.cls else False
+
+    def isEnum(self) -> bool:
+        """
+        Checks whether the class is an enumeration.
+
+        Returns
+        -------
+        bool
+            True if the class is a subclass of Enum, False otherwise.
+        """
+        return self.cls is not None and isinstance(self.cls, type) and issubclass(self.cls, Enum)
+
+    def isSubclassOf(self, parent: type) -> bool:
+        """
+        Checks whether the class is a subclass of the specified parent class.
+
+        Parameters
+        ----------
+        parent : type
+            The parent class to check against.
+
+        Returns
+        -------
+        bool
+            True if the class is a subclass of the parent, False otherwise.
+        """
+        return self.cls is not None and issubclass(self.cls, parent)
+
+    def isInstanceOf(self, instance: Any) -> bool:
+        """
+        Checks whether the class is an instance of the specified class.
+
+        Parameters
+        ----------
+        parent : type
+            The class to check against.
+
+        Returns
+        -------
+        bool
+            True if the class is a subclass of the parent, False otherwise.
+        """
+        return self.cls is not None and isinstance(instance, self.cls)
+
+    def isIterable(self) -> bool:
+        """
+        Checks whether the class is iterable.
+
+        Returns
+        -------
+        bool
+            True if the class is iterable, False otherwise.
+        """
+        return hasattr(self.cls, '__iter__') if self.cls else False
+
+    def isInstantiable(self) -> bool:
+        """
+        Checks whether the class can be instantiated.
+
+        Returns
+        -------
+        bool
+            True if the class is callable and not abstract, False otherwise.
+        """
+        return self.cls is not None and callable(self.cls) and not self.isAbstract()
+
+    def newInstance(self, *args, **kwargs):
+        """
+        Creates a new instance of the class if it is instantiable.
+
+        Parameters
+        ----------
+        args : tuple
+            Arguments to pass to the class constructor.
+        kwargs : dict
+            Keyword arguments to pass to the class constructor.
+
+        Returns
+        -------
+        object
+            A new instance of the class.
+
+        Raises
+        ------
+        TypeError
+            If the class is not instantiable.
+        """
+        if self.isInstantiable():
+            return self.cls(*args, **kwargs)
+        raise TypeError(f"Cannot instantiate class '{self.classname}'. It may be abstract or not callable.")
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the Reflection instance.
+
+        Returns
+        -------
+        str
+            A string describing the class and module.
+        """
+        status = "loaded" if self.cls else "not loaded"
+        return f"<Orionis Reflection class '{self.classname}' in module '{self.module_name}' ({status})>"

orionis/luminate/tools/std.py

@@ -0,0 +1,53 @@
+from orionis.luminate.contracts.tools.std_interface import IStdClass
+
+class StdClass(IStdClass):
+    """
+    A dynamic class that allows setting arbitrary attributes,
+    similar to PHP's stdClass.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the StdClass with optional keyword arguments.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Key-value pairs to set as attributes.
+        """
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def __repr__(self):
+        """
+        Returns a string representation of the object.
+
+        Returns
+        -------
+        str
+            A formatted string showing the object's attributes.
+        """
+        return f"{self.__class__.__name__}({self.__dict__})"
+
+    def toDict(self):
+        """
+        Converts the object's attributes to a dictionary.
+
+        Returns
+        -------
+        dict
+            A dictionary representation of the object's attributes.
+        """
+        return self.__dict__
+
+    def update(self, **kwargs):
+        """
+        Updates the object's attributes dynamically.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Key-value pairs to update attributes.
+        """
+        for key, value in kwargs.items():
+            setattr(self, key, value)

orionis-0.1.0.dist-info/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 - 2025 RAÚL MAURICIO UÑATE CASTRO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

orionis-0.1.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.2
+Name: orionis
+Version: 0.1.0
+Summary: Orionis Framework – Elegant, Fast, and Powerful.
+Home-page: https://github.com/orionis-framework/framework
+Author: Raul Mauricio Uñate Castro
+Author-email: raulmauriciounate@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: apscheduler>=3.11.0
+Requires-Dist: python-dotenv>=1.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# **Orionis Framework – An Opinionated Python Framework**
+**⚡ Orionis Framework – Elegant, Fast, and Powerful 🚀**