orionis 0.203.0__tar.gz → 0.205.0__tar.gz

{orionis-0.203.0/orionis.egg-info → orionis-0.205.0}/PKG-INFO

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

{orionis-0.203.0 → orionis-0.205.0}/orionis/framework.py

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

orionis-0.205.0/orionis/luminate/support/inspection/reflexion_abstract.py

@@ -0,0 +1,271 @@
+from typing import Any, Type, Dict, List, Tuple, Callable, Optional, TypeVar, Set
+import inspect
+import abc
+from functools import wraps
+
+ABC = TypeVar('ABC', bound=abc.ABC)
+
+class ReflexionAbstract:
+    """A reflection object encapsulating an abstract class.
+
+    Parameters
+    ----------
+    abstract : Type[ABC]
+        The abstract class being reflected upon
+
+    Attributes
+    ----------
+    _abstract : Type[ABC]
+        The encapsulated abstract class
+    """
+
+    def __init__(self, abstract: Type[ABC]) -> None:
+        """Initialize with the abstract class."""
+        self._abstract = abstract
+
+    def getClassName(self) -> str:
+        """Get the name of the abstract class.
+
+        Returns
+        -------
+        str
+            The name of the abstract class
+        """
+        return self._abstract.__name__
+
+    def getModuleName(self) -> str:
+        """Get the name of the module where the abstract class is defined.
+
+        Returns
+        -------
+        str
+            The module name
+        """
+        return self._abstract.__module__
+
+    def getAbstractMethods(self) -> Set[str]:
+        """Get all abstract method names required by the class.
+
+        Returns
+        -------
+        Set[str]
+            Set of abstract method names
+        """
+        return {name for name, _ in self._abstract.__abstractmethods__}
+
+    def getConcreteMethods(self) -> Dict[str, Callable]:
+        """Get all concrete methods implemented in the abstract class.
+
+        Returns
+        -------
+        Dict[str, Callable]
+            Dictionary of method names and their implementations
+        """
+        return {
+            name: member for name, member in inspect.getmembers(
+                self._abstract,
+                predicate=inspect.isfunction
+            ) if not name.startswith('_') and name not in self.getAbstractMethods()
+        }
+
+    def getStaticMethods(self) -> List[str]:
+        """Get all static method names of the abstract class.
+
+        Returns
+        -------
+        List[str]
+            List of static method names
+        """
+        return [
+            name for name in dir( self._abstract)
+            if not name.startswith('_') and
+            isinstance(inspect.getattr_static( self._abstract, name), staticmethod)
+        ]
+
+    def getClassMethods(self) -> List[str]:
+        """Get all class method names of the abstract class.
+
+        Returns
+        -------
+        List[str]
+            List of class method names
+        """
+        return [
+            name for name, member in inspect.getmembers(
+                self._abstract,
+                predicate=lambda x: isinstance(x, classmethod))
+            if not name.startswith('_')
+        ]
+
+    def getProperties(self) -> List[str]:
+        """Get all property names of the abstract class.
+
+        Returns
+        -------
+        List[str]
+            List of property names
+        """
+        return [
+            name for name, member in inspect.getmembers(
+                self._abstract,
+                predicate=lambda x: isinstance(x, property))
+            if not name.startswith('_')
+        ]
+
+    def getMethodSignature(self, methodName: str) -> inspect.Signature:
+        """Get the signature of a method.
+
+        Parameters
+        ----------
+        methodName : str
+            Name of the method
+
+        Returns
+        -------
+        inspect.Signature
+            The method signature
+
+        Raises
+        ------
+        AttributeError
+            If the method doesn't exist
+        """
+        method = getattr(self._abstract, methodName)
+        return inspect.signature(method)
+
+    def getDocstring(self) -> Optional[str]:
+        """Get the docstring of the abstract class.
+
+        Returns
+        -------
+        Optional[str]
+            The class docstring
+        """
+        return self._abstract.__doc__
+
+    def getBaseAbstractClasses(self) -> Tuple[Type[ABC], ...]:
+        """Get the abstract base classes.
+
+        Returns
+        -------
+        Tuple[Type[ABC], ...]
+            Tuple of abstract base classes
+        """
+        return tuple(
+            base for base in self._abstract.__bases__
+            if inspect.isabstract(base)
+        )
+
+    def getInterfaceMethods(self) -> Dict[str, inspect.Signature]:
+        """Get all abstract methods with their signatures.
+
+        Returns
+        -------
+        Dict[str, inspect.Signature]
+            Dictionary of method names and their signatures
+        """
+        return {
+            name: inspect.signature(getattr(self._abstract, name))
+            for name in self.getAbstractMethods()
+        }
+
+    def isSubclassOf(self, abstract_class: Type[ABC]) -> bool:
+        """Check if the abstract class inherits from another abstract class.
+
+        Parameters
+        ----------
+        abstract_class : Type[ABC]
+            The abstract class to check against
+
+        Returns
+        -------
+        bool
+            True if this is a subclass
+        """
+        return issubclass(self._abstract, abstract_class)
+
+    def getSourceCode(self) -> Optional[str]:
+        """Get the source code of the abstract class.
+
+        Returns
+        -------
+        Optional[str]
+            The source code if available
+        """
+        try:
+            return inspect.getsource(self._abstract)
+        except (TypeError, OSError):
+            return None
+
+    def getFileLocation(self) -> Optional[str]:
+        """Get the file location where the abstract class is defined.
+
+        Returns
+        -------
+        Optional[str]
+            The file path if available
+        """
+        try:
+            return inspect.getfile(self._abstract)
+        except (TypeError, OSError):
+            return None
+
+    def getAnnotations(self) -> Dict[str, Any]:
+        """Get type annotations of the abstract class.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their type annotations
+        """
+        return self._abstract.__annotations__
+
+    def getDecorators(self, method_name: str) -> List[Callable]:
+        """Get decorators applied to a method.
+
+        Parameters
+        ----------
+        method_name : str
+            Name of the method
+
+        Returns
+        -------
+        List[Callable]
+            List of decorator functions
+        """
+        method = getattr(self._abstract, method_name)
+        decorators = []
+
+        if hasattr(method, '__wrapped__'):
+            # Unwrap decorated functions
+            while hasattr(method, '__wrapped__'):
+                decorators.append(method)
+                method = method.__wrapped__
+
+        return decorators
+
+    def isProtocol(self) -> bool:
+        """Check if the abstract class is a Protocol.
+
+        Returns
+        -------
+        bool
+            True if this is a Protocol class
+        """
+        return hasattr(self._abstract, '_is_protocol') and self._abstract._is_protocol
+
+    def getRequiredAttributes(self) -> Set[str]:
+        """For Protocol classes, get required attributes.
+
+        Returns
+        -------
+        Set[str]
+            Set of required attribute names
+        """
+        if not self.isProtocol():
+            return set()
+
+        return {
+            name for name in dir(self._abstract)
+            if not name.startswith('_') and not inspect.isfunction(getattr(self._abstract, name))
+        }

{orionis-0.203.0 → orionis-0.205.0}/orionis/luminate/support/inspection/reflexion_instance.py

@@ -99,6 +99,32 @@ class ReflexionInstance:
             predicate=inspect.ismethod
         )]
 
+    def getStaticMethods(self) -> List[str]:
+        """Get all static method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of static method names, excluding private methods (starting with '_')
+
+        Examples
+        --------
+        >>> class MyClass:
+        ...     @staticmethod
+        ...     def static_method(): pass
+        ...     @staticmethod
+        ...     def _private_static(): pass
+        ...
+        >>> reflex = ReflexionInstance(MyClass())
+        >>> reflex.getStaticMethods()
+        ['static_method']
+        """
+        return [
+            name for name in dir(self._instance.__class__)
+            if not name.startswith('_') and
+            isinstance(inspect.getattr_static(self._instance.__class__, name), staticmethod)
+        ]
+
     def getPropertyNames(self) -> List[str]:
         """Get all property names of the instance.
 

orionis-0.205.0/orionis/luminate/test/test_output.py

@@ -0,0 +1,65 @@
+import sys
+from orionis.luminate.console.output.console import Console
+import os
+
+class PrinterInTest:
+    """
+    A utility class for printing debug information during testing. This class temporarily
+    redirects the standard output and error streams to their original states to ensure
+    proper console output, and provides contextual information about the file and line
+    number where the print call was made.
+    Methods
+    -------
+    print(*args)
+        Prints the provided arguments to the console with contextual information
+        about the file and line number of the caller. If no arguments are provided,
+        the method does nothing.
+    """
+
+    def print(*args):
+        """
+        Prints the provided arguments to the console with contextual information
+        about the file and line number of the caller. The output is formatted with
+        muted text decorations for better readability.
+        Parameters
+        ----------
+        *args : tuple
+            The arguments to be printed. The first argument is ignored, and the
+            remaining arguments are printed. If no arguments are provided, the
+            method does nothing.
+        Notes
+        -----
+        - The method temporarily redirects `sys.stdout` and `sys.stderr` to their
+          original states (`sys.__stdout__` and `sys.__stderr__`) to ensure proper
+          console output.
+        - The contextual information includes the file path and line number of the
+          caller, which is displayed in a muted text format.
+        - After printing, the method restores the original `sys.stdout` and
+          `sys.stderr` streams.
+        """
+
+        # Check if the first argument is a string and remove it from the args tuple
+        if len(args) == 0:
+            return
+
+        # Change the output stream to the original stdout and stderr
+        # to avoid any issues with the console output
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+
+        # Get the file name and line number of the caller
+        # using sys._getframe(1) to access the caller's frame
+        _file = os.path.relpath(sys._getframe(1).f_code.co_filename, start=os.getcwd())
+        _method = sys._getframe(1).f_code.co_name
+        _line = sys._getframe(1).f_lineno
+
+        # Print the contextual information and the provided arguments
+        Console.textMuted(f"[DEBUG] File: {_file}, Line: {_line}, Method: {_method}")
+        print(*args[1:], end='\n')
+        Console.newLine()
+
+        # Restore the original stdout and stderr streams
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr

{orionis-0.203.0 → orionis-0.205.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.203.0 → orionis-0.205.0}/orionis.egg-info/SOURCES.txt

@@ -190,6 +190,7 @@ orionis/luminate/support/inspection/reflexion_module.py
 orionis/luminate/support/inspection/reflexion_module_with_classname.py
 orionis/luminate/test/__init__.py
 orionis/luminate/test/test_exception.py
+orionis/luminate/test/test_output.py
 orionis/luminate/test/test_result.py
 orionis/luminate/test/test_status.py
 orionis/luminate/test/tests.py
@@ -204,9 +205,10 @@ orionis/static/logos/OrionisFramework.psd
 orionis/static/logos/OrionisFramework2.png
 orionis/static/logos/OrionisFramework3.png
 tests/__init__.py
-tests/main.py
 tests/example/__init__.py
 tests/example/test_example.py
 tests/support/__init__.py
 tests/support/inspection/__init__.py
-tests/support/inspection/test_reflection.py
+tests/support/inspection/test_reflection_instance.py
+tests/support/inspection/fakes/__init__.py
+tests/support/inspection/fakes/fake_reflection.py

{orionis-0.203.0 → orionis-0.205.0}/tests/example/test_example.py

@@ -1,5 +1,4 @@
 import unittest
-
 class TestExample(unittest.TestCase):
     """
     Unit tests for basic example functionality.

orionis-0.205.0/tests/support/inspection/fakes/fake_reflection.py

@@ -0,0 +1,60 @@
+class BaseFakeClass:
+    pass
+
+class FakeClass(BaseFakeClass):
+    """This is a test class for ReflexionInstance.
+
+    Attributes
+    ----------
+    public_attr : int
+        An example public attribute
+    _private_attr : str
+        An example "private" attribute
+    """
+
+    class_attr: str = "class_value"
+
+    def __init__(self) -> None:
+        self.public_attr = 42
+        self._private_attr = "secret"
+        self.dynamic_attr = None
+
+    def instance_method(self, x: int, y: int) -> int:
+        """Adds two numbers.
+
+        Parameters
+        ----------
+        x : int
+            First number
+        y : int
+            Second number
+
+        Returns
+        -------
+        int
+            The sum of x and y
+        """
+        return x + y
+
+    @property
+    def computed_property(self) -> str:
+        """A computed property."""
+        return f"Value: {self.public_attr}"
+
+    @classmethod
+    def class_method(cls) -> str:
+        """A class method."""
+        return f"Class attr: {cls.class_attr}"
+
+    @staticmethod
+    def static_method(text: str) -> str:
+        """A static method."""
+        return text.upper()
+
+    def __private_method(self) -> str:
+        """A 'private' method."""
+        return "This is private"
+
+    def _protected_method(self) -> str:
+        """A 'protected' method."""
+        return "This is protected"

orionis-0.205.0/tests/support/inspection/test_reflection_instance.py

@@ -0,0 +1,147 @@
+import unittest
+from orionis.luminate.support.inspection.reflection import Reflection
+from orionis.luminate.support.inspection.reflexion_instance import ReflexionInstance
+from orionis.luminate.test.test_output import PrinterInTest
+from tests.support.inspection.fakes.fake_reflection import BaseFakeClass, FakeClass
+
+class TestReflection(unittest.TestCase, PrinterInTest):
+    """
+    Unit tests for the Reflection class.
+    This class tests the functionality of the Reflection class, ensuring that it correctly handles
+    """
+
+    def testReflectionInstanceExceptionValueError(self):
+        """Test that Reflection.instance raises ValueError for invalid types."""
+        with self.assertRaises(ValueError):
+            Reflection.instance(str)
+
+    def testReflectionInstance(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        self.assertIsInstance(Reflection.instance(FakeClass()), ReflexionInstance)
+
+    def testReflectionInstanceGetClassName(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getClassName(), "FakeClass")
+
+    def testReflectionInstanceGetClass(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getClass(), FakeClass)
+
+    def testReflectionInstanceGetModuleName(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflection")
+
+    def testReflectionInstanceGetAttributes(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        attributes = reflex.getAttributes()
+        self.assertTrue("public_attr" in attributes)
+        self.assertTrue("_private_attr" in attributes)
+        self.assertTrue("dynamic_attr" in attributes)
+
+    def testReflectionInstanceGetMethods(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getMethods()
+        self.assertTrue("instance_method" in methods)
+        self.assertTrue("class_method" in methods)
+
+    def testReflectionInstanceGetStaticMethods(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        methods = reflex.getStaticMethods()
+        self.assertTrue("static_method" in methods)
+
+    def testReflectionInstanceGetPropertyNames(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        properties = reflex.getPropertyNames()
+        self.assertTrue("computed_property" in properties)
+
+    def testReflectionInstanceCallMethod(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        result = reflex.callMethod("instance_method", 1, 2)
+        self.assertEqual(result, 3)
+
+    def testReflectionInstanceGetMethodSignature(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        signature = reflex.getMethodSignature("instance_method")
+        self.assertEqual(str(signature), "(x: int, y: int) -> int")
+
+    def testReflectionInstanceGetDocstring(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        docstring = reflex.getDocstring()
+        self.assertIn("This is a test class for ReflexionInstance", docstring)
+
+    def testReflectionInstanceGetBaseClasses(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        base_classes = reflex.getBaseClasses()
+        self.assertIn(BaseFakeClass, base_classes)
+
+    def testReflectionInstanceIsInstanceOf(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertTrue(reflex.isInstanceOf(BaseFakeClass))
+
+    def testReflectionInstanceGetSourceCode(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        source_code = reflex.getSourceCode()
+        self.assertIn("class FakeClass(BaseFakeClass):", source_code)
+
+    def testReflectionInstanceGetFileLocation(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        file_location = reflex.getFileLocation()
+        self.assertIn("fake_reflection.py", file_location)
+
+    def testReflectionInstanceGetAnnotations(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        annotations = reflex.getAnnotations()
+        self.assertEqual("{'class_attr': <class 'str'>}", str(annotations))
+
+    def testReflectionInstanceHasAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        self.assertTrue(reflex.hasAttribute("public_attr"))
+        self.assertFalse(reflex.hasAttribute("non_existent_attr"))
+
+    def testReflectionInstanceGetAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        attr_value = reflex.getAttribute("public_attr")
+        self.assertEqual(attr_value, 42)
+
+    def testReflectionInstanceGetCallableMembers(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        reflex = Reflection.instance(FakeClass())
+        callable_members = reflex.getCallableMembers()
+        self.assertIn("instance_method", callable_members)
+        self.assertIn("class_method", callable_members)
+        self.assertIn("static_method", callable_members)
+
+    def testReflectionInstanceSetAttribute(self):
+        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+
+        # Create a new macro function
+        def myMacro(cls:FakeClass, num):
+            return cls.instance_method(10, 12) + num
+
+        # Create an instance of FakeClass and set the macro as an attribute
+        reflex = Reflection.instance(FakeClass())
+        reflex.setAttribute("myMacro", myMacro)
+
+        # Check if the macro was set correctly
+        self.assertTrue(reflex.hasAttribute("myMacro"))
+
+        # Call the macro method and check the result
+        result = reflex.callMethod("myMacro", reflex._instance, 3)
+        self.assertEqual(result, 25)

orionis-0.203.0/orionis/luminate/support/inspection/reflexion_abstract.py

@@ -1,23 +0,0 @@
-from typing import Type, TypeVar
-import abc
-
-T = TypeVar('T')
-ABC = TypeVar('ABC', bound=abc.ABC)
-
-class ReflexionAbstract:
-    """A reflection object encapsulating an abstract class.
-
-    Parameters
-    ----------
-    abstract : Type[ABC]
-        The abstract class being reflected upon
-
-    Attributes
-    ----------
-    _abstract : Type[ABC]
-        The encapsulated abstract class
-    """
-
-    def __init__(self, abstract: Type[ABC]) -> None:
-        """Initialize with the abstract class."""
-        self._abstract = abstract

orionis-0.203.0/tests/support/inspection/test_reflection.py

@@ -1,9 +0,0 @@
-import unittest
-
-class TestReflection(unittest.TestCase):
-    """
-    Unit tests for basic example functionality.
-    """
-
-    def testReflection(self):
-        self.assertEqual(3, 3)