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

orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.205.0"
+VERSION = "0.207.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 Any, Type, Dict, List, Tuple, Callable, Optional, TypeVar, Set
-import inspect
 import abc
-from functools import wraps
+import ast
+import inspect
+import types
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, TypeVar
 
 ABC = TypeVar('ABC', bound=abc.ABC)
 
@@ -51,7 +52,10 @@ class ReflexionAbstract:
         Set[str]
             Set of abstract method names
         """
-        return {name for name, _ in self._abstract.__abstractmethods__}
+        methods = []
+        for method in self._abstract.__abstractmethods__:
+            methods.append(method)
+        return set(methods)
 
     def getConcreteMethods(self) -> Dict[str, Callable]:
         """Get all concrete methods implemented in the abstract class.
@@ -88,13 +92,32 @@ class ReflexionAbstract:
         Returns
         -------
         List[str]
-            List of class method names
+            List of class method names, excluding private/protected methods (starting with '_')
+
+        Notes
+        -----
+        - Uses inspect.getattr_static to avoid method binding
+        - Properly handles both @classmethod decorator and classmethod instances
+        - Filters out private/protected methods (starting with '_')
+
+        Examples
+        --------
+        >>> class MyAbstract(ABC):
+        ...     @classmethod
+        ...     def factory(cls): pass
+        ...     @classmethod
+        ...     def _protected_factory(cls): pass
+        >>> reflex = ReflexionAbstract(MyAbstract)
+        >>> reflex.getClassMethods()
+        ['factory']
         """
         return [
-            name for name, member in inspect.getmembers(
-                self._abstract,
-                predicate=lambda x: isinstance(x, classmethod))
-            if not name.startswith('_')
+            name for name in dir(self._abstract)
+            if not name.startswith('_') and
+            isinstance(
+                inspect.getattr_static(self._abstract, name),
+                (classmethod, types.MethodType)
+            )
         ]
 
     def getProperties(self) -> List[str]:
@@ -153,7 +176,7 @@ class ReflexionAbstract:
         """
         return tuple(
             base for base in self._abstract.__bases__
-            if inspect.isabstract(base)
+            if inspect.isabstract(base) or issubclass(base, abc.ABC) or isinstance(base, abc.ABCMeta)
         )
 
     def getInterfaceMethods(self) -> Dict[str, inspect.Signature]:
@@ -220,29 +243,48 @@ class ReflexionAbstract:
         """
         return self._abstract.__annotations__
 
-    def getDecorators(self, method_name: str) -> List[Callable]:
-        """Get decorators applied to a method.
+    def getDecorators(self, method_name: str) -> List[str]:
+        """
+        Get decorators applied to a method.
 
         Parameters
         ----------
         method_name : str
-            Name of the method
-
-        Returns
-        -------
-        List[Callable]
-            List of decorator functions
+            Name of the method to inspect
         """
-        method = getattr(self._abstract, method_name)
-        decorators = []
-
-        if hasattr(method, '__wrapped__'):
-            # Unwrap decorated functions
-            while hasattr(method, '__wrapped__'):
-                decorators.append(method)
-                method = method.__wrapped__
+        method = getattr(self._abstract, method_name, None)
+        if method is None:
+            return []
 
-        return decorators
+        try:
+            source = inspect.getsource(self._abstract)
+        except (OSError, TypeError):
+            return []
+
+        tree = ast.parse(source)
+
+        class DecoratorVisitor(ast.NodeVisitor):
+            def __init__(self):
+                self.decorators = []
+
+            def visit_FunctionDef(self, node):
+                if node.name == method_name:
+                    for deco in node.decorator_list:
+                        if isinstance(deco, ast.Name):
+                            self.decorators.append(deco.id)
+                        elif isinstance(deco, ast.Call):
+                            # handles decorators with arguments like @deco(arg)
+                            if isinstance(deco.func, ast.Name):
+                                self.decorators.append(deco.func.id)
+                        elif isinstance(deco, ast.Attribute):
+                            self.decorators.append(deco.attr)
+                    # No need to visit deeper
+                    return
+
+        visitor = DecoratorVisitor()
+        visitor.visit(tree)
+
+        return visitor.decorators
 
     def isProtocol(self) -> bool:
         """Check if the abstract class is a Protocol.

{orionis-0.205.0.dist-info → orionis-0.207.0.dist-info}/METADATA

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

{orionis-0.205.0.dist-info → orionis-0.207.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=fUxv8sJtO5v-ERZPJzgKhGDePNz3AbKp-n-HE7IIhZo,1469
+orionis/framework.py,sha256=eb4WxXbyAXkX44A065Y_hEHg-PyA8LWfMluqcfrxYJA,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,7 +171,7 @@ 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=yZTl_oZACjlXKKPmQimGsfre3qQUO2hbNDf7PJ4gKZE,7661
+orionis/luminate/support/inspection/reflexion_abstract.py,sha256=pKjLZFAfCHcve39FiIeAyAJiSxKhOWBkMsPub3Sa-RI,9313
 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=k6bpRYjLeTUDqquluYrDZUtBLpLuGe4wm7PMUM8Sz-E,9914
@@ -199,12 +199,14 @@ tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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_instance.py,sha256=aYi4qmuAzQ4-gAUrtc9Lx6gNR4Mw4GcOF_T8iWsWZoQ,7266
+tests/support/inspection/test_reflection_abstract.py,sha256=ntrwbhYdZBWWCuHI0k_Vttd4jclhZ-wLwopb1XhAB_k,8750
+tests/support/inspection/test_reflection_instance.py,sha256=4aBFeLgOmNvO5rbyd6EFioU4_DgXddV5pL3el23mFtA,6681
 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/support/inspection/fakes/fake_reflection_abstract.py,sha256=7qtz44brfFzE4oNYi9kIsvdWP79nP2FnzSz-0bU__pg,5045
+tests/support/inspection/fakes/fake_reflection_instance.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
+orionis-0.207.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.207.0.dist-info/METADATA,sha256=OTZC93qgIgplcgvUxPIBdQtjs_420Y0HUyWXCy4mshU,3003
+orionis-0.207.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.207.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.207.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.207.0.dist-info/RECORD,,

tests/support/inspection/fakes/fake_reflection_abstract.py

@@ -0,0 +1,218 @@
+from abc import ABC, abstractmethod
+from typing import Callable
+from functools import wraps
+
+def decorator_example(func: Callable) -> Callable:
+    """Example decorator for testing purposes.
+
+    Parameters
+    ----------
+    func : Callable
+        The function to be decorated
+
+    Returns
+    -------
+    Callable
+        The wrapped function
+
+    Notes
+    -----
+    This is a simple identity decorator used for testing decorator detection.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapper
+
+
+def another_decorator(func: Callable) -> Callable:
+    """Another example decorator for testing multiple decorators.
+
+    Parameters
+    ----------
+    func : Callable
+        The function to be decorated
+
+    Returns
+    -------
+    Callable
+        The wrapped function with added prefix
+
+    Examples
+    --------
+    >>> @another_decorator
+    ... def test(): return "hello"
+    >>> test()
+    'Decorated: hello'
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return f"Decorated: {func(*args, **kwargs)}"
+    return wrapper
+
+
+class FakeAbstractClass(ABC):
+    """A fake abstract class for testing reflection capabilities.
+
+    This class contains all elements needed to test ReflexionAbstract functionality:
+    - Abstract methods
+    - Concrete methods
+    - Static methods
+    - Class methods
+    - Properties
+    - Decorated methods
+    - Type annotations
+    - Protected/private methods
+
+    Attributes
+    ----------
+    class_attr : str
+        A class-level attribute with type annotation
+    _value : float
+        Protected attribute used by computed_property setter
+    """
+
+    class_attr: str = "class_value"
+
+    @abstractmethod
+    def abstract_method(self, x: int, y: int) -> int:
+        """Required abstract method.
+
+        Parameters
+        ----------
+        x : int
+            First integer parameter
+        y : int
+            Second integer parameter
+
+        Returns
+        -------
+        int
+            The result of some operation
+
+        Notes
+        -----
+        This method must be implemented by concrete subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def another_abstract(self, text: str) -> str:
+        """Another required abstract method.
+
+        Parameters
+        ----------
+        text : str
+            Input string to process
+
+        Returns
+        -------
+        str
+            Processed string result
+        """
+        pass
+
+    def concrete_method(self, value: float) -> str:
+        """Concrete implemented method.
+
+        Parameters
+        ----------
+        value : float
+            Numeric value to format
+
+        Returns
+        -------
+        str
+            Formatted string representation
+        """
+        return f"Value: {value}"
+
+    @staticmethod
+    def static_helper(flag: bool) -> str:
+        """Static helper method.
+
+        Parameters
+        ----------
+        flag : bool
+            Boolean flag to determine output
+
+        Returns
+        -------
+        str
+            "Enabled" if flag is True, "Disabled" otherwise
+        """
+        return "Enabled" if flag else "Disabled"
+
+    @classmethod
+    def create_instance(cls) -> 'FakeAbstractClass':
+        """Class method factory.
+
+        Returns
+        -------
+        FakeAbstractClass
+            New instance of the class
+
+        Notes
+        -----
+        This cannot actually instantiate the abstract class, but serves
+        as an example of a class method.
+        """
+        return cls()
+
+    @property
+    def computed_property(self) -> float:
+        """Computed property example.
+
+        Returns
+        -------
+        float
+            The value of pi approximation
+        """
+        return 3.1416
+
+    @computed_property.setter
+    def computed_property(self, value: float):
+        """Setter for computed property.
+
+        Parameters
+        ----------
+        value : float
+            New value to set
+        """
+        self._value = value
+
+    @decorator_example
+    @another_decorator
+    def decorated_method(self) -> str:
+        """Method with multiple decorators.
+
+        Returns
+        -------
+        str
+            Always returns "decorated" with decorator transformations
+
+        Notes
+        -----
+        Used to test decorator inspection functionality.
+        """
+        return "decorated"
+
+    def _protected_method(self) -> str:
+        """Protected method (should be filtered in results).
+
+        Returns
+        -------
+        str
+            Constant string "protected"
+        """
+        return "protected"
+
+    def __private_method(self) -> str:
+        """Private method (should be filtered in results).
+
+        Returns
+        -------
+        str
+            Constant string "private"
+        """
+        return "private"

tests/support/inspection/test_reflection_abstract.py

@@ -0,0 +1,229 @@
+from abc import ABC
+import unittest
+from orionis.luminate.support.inspection.reflection import Reflection
+from orionis.luminate.test.test_output import PrinterInTest
+from tests.support.inspection.fakes.fake_reflection_abstract import FakeAbstractClass
+
+class TestReflexionAbstract(unittest.TestCase, PrinterInTest):
+    """Test cases for ReflexionAbstract using FakeAbstractClass.
+
+    This test suite verifies all functionality of the ReflexionAbstract class
+    using FakeAbstractClass as the test subject.
+    """
+
+    def testReflectionAbstractExceptionValueError(self):
+        """Class setup method.
+
+        Initializes the ReflexionAbstract instance with FakeAbstractClass
+        before any tests run.
+        """
+        with self.assertRaises(ValueError):
+            Reflection.abstract(str)
+
+    def testReflectionAbstractGetClassName(self):
+        """Test getClassName() method.
+
+        Verifies that:
+        - The returned class name matches exactly
+        - The return type is str
+        """
+        class_name = Reflection.abstract(FakeAbstractClass).getClassName()
+        self.assertEqual(class_name, "FakeAbstractClass")
+        self.assertIsInstance(class_name, str)
+
+    def testReflectionAbstractGetModuleName(self):
+        """Test getModuleName() method.
+
+        Verifies that:
+        - The module name is returned
+        - The name is a string
+        """
+        module_name = Reflection.abstract(FakeAbstractClass).getModuleName()
+        self.assertTrue(module_name == 'tests.support.inspection.fakes.fake_reflection_abstract')
+        self.assertIsInstance(module_name, str)
+
+    def testReflectionAbstractGetAbstractMethods(self):
+        """Test getAbstractMethods() method.
+
+        Verifies that:
+        - All abstract methods are detected
+        - No concrete methods are included
+        - Return type is correct
+        """
+        methods = Reflection.abstract(FakeAbstractClass).getAbstractMethods()
+        expected = {'abstract_method', 'another_abstract'}
+        self.assertEqual(methods, expected)
+        self.assertIsInstance(methods, set)
+
+    def testReflectionAbstractGetConcreteMethods(self):
+        """Test getConcreteMethods() method.
+
+        Verifies that:
+        - Concrete methods are detected
+        - Abstract methods are excluded
+        - Protected/private methods are excluded
+        """
+        methods = Reflection.abstract(FakeAbstractClass).getConcreteMethods()
+        self.assertIn('static_helper', methods)
+        self.assertIn('concrete_method', methods)
+        self.assertIn('decorated_method', methods)
+        self.assertNotIn('abstract_method', methods)
+        self.assertNotIn('_protected_method', methods)
+        self.assertNotIn('__private_method', methods)
+
+    def testReflectionAbstractGetStaticMethods(self):
+        """Test getStaticMethods() method.
+
+        Verifies that:
+        - Static methods are detected
+        - Only static methods are included
+        - Protected/private methods are excluded
+        """
+        static_methods = Reflection.abstract(FakeAbstractClass).getStaticMethods()
+        self.assertIn('static_helper', static_methods)
+        self.assertEqual(len(static_methods), 1)
+        self.assertNotIn('create_instance', static_methods)
+
+    def testReflectionAbstractGetClassMethods(self):
+        """Test getClassMethods() method.
+
+        Verifies that:
+        - Class methods are detected
+        - Only class methods are included
+        - Protected/private methods are excluded
+        """
+        class_methods = Reflection.abstract(FakeAbstractClass).getClassMethods()
+        self.assertIn('create_instance', class_methods)
+        self.assertEqual(len(class_methods), 1)
+        self.assertNotIn('static_helper', class_methods)
+
+    def testReflectionAbstractGetProperties(self):
+        """Test getProperties() method.
+
+        Verifies that:
+        - Properties are detected
+        - Only properties are included
+        - Protected/private properties are excluded
+        """
+        props = Reflection.abstract(FakeAbstractClass).getProperties()
+        self.assertIn('computed_property', props)
+        self.assertEqual(len(props), 1)
+
+    def testReflectionAbstractGetMethodSignature(self):
+        """Test getMethodSignature() method.
+
+        Verifies that:
+        - Correct signature is returned
+        - Parameters are properly detected
+        - Return type is properly detected
+        """
+        sig = Reflection.abstract(FakeAbstractClass).getMethodSignature('abstract_method')
+        params = list(sig.parameters.keys())
+        self.assertEqual(params, ['self', 'x', 'y'])
+        self.assertEqual(sig.return_annotation, int)
+
+    def testReflectionAbstractGetDocstring(self):
+        """Test getDocstring() method.
+
+        Verifies that:
+        - Docstring is returned
+        - Docstring contains expected content
+        """
+        doc = Reflection.abstract(FakeAbstractClass).getDocstring()
+        self.assertTrue(doc.startswith("A fake abstract class"))
+        self.assertIsInstance(doc, str)
+
+    def testReflectionAbstractGetBaseAbstractClasses(self):
+        """Test getBaseAbstractClasses() method.
+
+        Verifies that:
+        - Base abstract classes are detected
+        - Only abstract bases are included
+        """
+        bases = Reflection.abstract(FakeAbstractClass).getBaseAbstractClasses()
+        self.assertEqual(bases, (ABC,))
+
+    def testReflectionAbstractGetInterfaceMethods(self):
+        """Test getInterfaceMethods() method.
+
+        Verifies that:
+        - Interface methods are detected
+        - Signatures are correct
+        - Only abstract methods are included
+        """
+        interface = Reflection.abstract(FakeAbstractClass).getInterfaceMethods()
+        self.assertEqual(len(interface), 2)
+        self.assertIn('abstract_method', interface)
+        sig = interface['abstract_method']
+        self.assertEqual(list(sig.parameters.keys()), ['self', 'x', 'y'])
+
+    def testReflectionAbstractIsSubclassOf(self):
+        """Test isSubclassOf() method.
+
+        Verifies that:
+        - Correctly identifies abstract base classes
+        - Returns False for non-parent classes
+        """
+        self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(ABC))
+        self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(object))
+
+    def testReflectionAbstractGetSourceCode(self):
+        """Test getSourceCode() method.
+
+        Verifies that:
+        - Source code is returned
+        - Contains class definition
+        """
+        source = Reflection.abstract(FakeAbstractClass).getSourceCode()
+        self.assertIsNotNone(source)
+        self.assertIn("class FakeAbstractClass(ABC):", source)
+
+    def testReflectionAbstractGetFileLocation(self):
+        """Test getFileLocation() method.
+
+        Verifies that:
+        - File location is returned
+        - Path ends with .py extension
+        """
+        location = Reflection.abstract(FakeAbstractClass).getFileLocation()
+        self.assertIsNotNone(location)
+        self.assertTrue('fake_reflection_abstract.py' in location)
+
+    def testReflectionAbstractGetAnnotations(self):
+        """Test getAnnotations() method.
+
+        Verifies that:
+        - Annotations are detected
+        - Class attributes are included
+        """
+        annotations = Reflection.abstract(FakeAbstractClass).getAnnotations()
+        self.assertIn('class_attr', annotations)
+        self.assertEqual(annotations['class_attr'], str)
+
+    def testReflectionAbstractGetDecorators(self):
+        """Test getDecorators() method.
+
+        Verifies that:
+        - Decorators are detected
+        - Correct number of decorators is returned
+        - Decorator order is preserved
+        """
+        decorators = Reflection.abstract(FakeAbstractClass).getDecorators('decorated_method')
+        for decorator in decorators:
+            self.assertTrue(decorator in ['decorator_example', 'another_decorator'])
+
+    def testReflectionAbstractIsProtocol(self):
+        """Test isProtocol() method.
+
+        Verifies that:
+        - Correctly identifies non-Protocol classes
+        """
+        self.assertFalse(Reflection.abstract(FakeAbstractClass).isProtocol())
+
+    def testReflectionAbstractGetRequiredAttributes(self):
+        """Test getRequiredAttributes() method.
+
+        Verifies that:
+        - Returns empty set for non-Protocol classes
+        """
+        self.assertEqual(Reflection.abstract(FakeAbstractClass).getRequiredAttributes(), set())

tests/support/inspection/test_reflection_instance.py

@@ -2,40 +2,39 @@ 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
+from tests.support.inspection.fakes.fake_reflection_instance 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."""
+        """Ensure 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."""
+        """Verify 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."""
+        """Check that getClassName returns the correct class name."""
         reflex = Reflection.instance(FakeClass())
         self.assertEqual(reflex.getClassName(), "FakeClass")
 
     def testReflectionInstanceGetClass(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Ensure getClass returns the correct class."""
         reflex = Reflection.instance(FakeClass())
         self.assertEqual(reflex.getClass(), FakeClass)
 
     def testReflectionInstanceGetModuleName(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Verify getModuleName returns the correct module name."""
         reflex = Reflection.instance(FakeClass())
-        self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflection")
+        self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflection_instance")
 
     def testReflectionInstanceGetAttributes(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Check that getAttributes returns all attributes of the class."""
         reflex = Reflection.instance(FakeClass())
         attributes = reflex.getAttributes()
         self.assertTrue("public_attr" in attributes)
@@ -43,85 +42,85 @@ class TestReflection(unittest.TestCase, PrinterInTest):
         self.assertTrue("dynamic_attr" in attributes)
 
     def testReflectionInstanceGetMethods(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Ensure getMethods returns all methods of the class."""
         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."""
+        """Verify getStaticMethods returns all static methods of the class."""
         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."""
+        """Check that getPropertyNames returns all property names."""
         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."""
+        """Ensure callMethod correctly invokes a method with arguments."""
         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."""
+        """Verify getMethodSignature returns the correct method signature."""
         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."""
+        """Check that getDocstring returns the correct class docstring."""
         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."""
+        """Ensure getBaseClasses returns the correct base classes."""
         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."""
+        """Verify isInstanceOf checks inheritance correctly."""
         reflex = Reflection.instance(FakeClass())
         self.assertTrue(reflex.isInstanceOf(BaseFakeClass))
 
     def testReflectionInstanceGetSourceCode(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Check that getSourceCode returns the class source code."""
         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."""
+        """Ensure getFileLocation returns the correct file path."""
         reflex = Reflection.instance(FakeClass())
         file_location = reflex.getFileLocation()
-        self.assertIn("fake_reflection.py", file_location)
+        self.assertIn("fake_reflection_instance.py", file_location)
 
     def testReflectionInstanceGetAnnotations(self):
-        """Test that Reflection.instance returns an instance of ReflexionInstance."""
+        """Verify getAnnotations returns the correct class annotations."""
         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."""
+        """Check that hasAttribute correctly identifies attributes."""
         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."""
+        """Ensure getAttribute retrieves the correct attribute value."""
         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."""
+        """Verify getCallableMembers returns all callable members."""
         reflex = Reflection.instance(FakeClass())
         callable_members = reflex.getCallableMembers()
         self.assertIn("instance_method", callable_members)
@@ -129,19 +128,14 @@ class TestReflection(unittest.TestCase, PrinterInTest):
         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):
+        """Check that setAttribute correctly sets a new attribute."""
+        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)
+        self.assertEqual(result, 25)