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

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/luminate/support/inspection/reflexion_abstract.py

@@ -1,7 +1,8 @@
-from typing import Type, TypeVar
+from typing import Any, Type, Dict, List, Tuple, Callable, Optional, TypeVar, Set
+import inspect
 import abc
+from functools import wraps
 
-T = TypeVar('T')
 ABC = TypeVar('ABC', bound=abc.ABC)
 
 class ReflexionAbstract:
@@ -21,3 +22,250 @@ class ReflexionAbstract:
     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/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/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.dist-info → orionis-0.205.0.dist-info}/METADATA

@@ -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.dist-info → orionis-0.205.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=Xh76tA5RZNGvPeGOth1XVlsBeaj_fhTEcYBbxQoXLdU,1469
+orionis/framework.py,sha256=fUxv8sJtO5v-ERZPJzgKhGDePNz3AbKp-n-HE7IIhZo,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
@@ -171,15 +171,16 @@ orionis/luminate/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQ
 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_abstract.py,sha256=yZTl_oZACjlXKKPmQimGsfre3qQUO2hbNDf7PJ4gKZE,7661
 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.py,sha256=k6bpRYjLeTUDqquluYrDZUtBLpLuGe4wm7PMUM8Sz-E,9914
 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/test_exception.py,sha256=21PILTXnMuL5-wT3HGKjIklt8VeIYDcQDN346i-BbJw,1336
+orionis/luminate/test/test_output.py,sha256=7QvkxbKOp56GcznjaJSX9I072gkut1NvuaexqO3v8BM,2768
 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
@@ -194,15 +195,16 @@ 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/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/example/test_example.py,sha256=MNYissCEa0mzx1YA2gTiqXRX8r2v_vfB_Ew0jBFmBag,556
 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,,
+tests/support/inspection/test_reflection_instance.py,sha256=aYi4qmuAzQ4-gAUrtc9Lx6gNR4Mw4GcOF_T8iWsWZoQ,7266
+tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/fakes/fake_reflection.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
+orionis-0.205.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.205.0.dist-info/METADATA,sha256=aFCgP3-K5OmZ5KziS4bEwafD_YPA4RxPvIZHjYCIHb0,3003
+orionis-0.205.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.205.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.205.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.205.0.dist-info/RECORD,,

tests/example/test_example.py

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

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"

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)

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)