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

orionis/framework.py

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

orionis/luminate/support/inspection/reflexion_abstract.py

@@ -54,9 +54,25 @@ class ReflexionAbstract:
         """
         methods = []
         for method in self._abstract.__abstractmethods__:
-            methods.append(method)
+            if not isinstance(getattr(self._abstract, method), property):
+                methods.append(method)
         return set(methods)
 
+    def getAbstractProperties(self) -> Set[str]:
+        """Get all abstract property names required by the class.
+
+        Returns
+        -------
+        Set[str]
+            Set of abstract property names
+        """
+        properties = []
+        for name in getattr(self._abstract, '__abstractmethods__', set()):
+            attr = getattr(self._abstract, name, None)
+            if isinstance(attr, property):
+                properties.append(name)
+        return set(properties)
+
     def getConcreteMethods(self) -> Dict[str, Callable]:
         """Get all concrete methods implemented in the abstract class.
 
@@ -154,7 +170,31 @@ class ReflexionAbstract:
             If the method doesn't exist
         """
         method = getattr(self._abstract, methodName)
-        return inspect.signature(method)
+        if callable(method):
+            return inspect.signature(method)
+
+    def getPropertySignature(self, propertyName: str) -> inspect.Signature:
+        """Get the signature of an abstract property's getter.
+
+        Parameters
+        ----------
+        propertyName : str
+            Name of the abstract property
+
+        Returns
+        -------
+        inspect.Signature
+            The getter signature of the abstract property
+
+        Raises
+        ------
+        AttributeError
+            If the property doesn't exist or is not an abstract property
+        """
+        attr = getattr(self._abstract, propertyName, None)
+        if isinstance(attr, property) and attr.fget is not None:
+            return inspect.signature(attr.fget)
+        raise AttributeError(f"{propertyName} is not an abstract property or doesn't have a getter.")
 
     def getDocstring(self) -> Optional[str]:
         """Get the docstring of the abstract class.

orionis/luminate/support/inspection/reflexion_instance.py

@@ -198,7 +198,37 @@ class ReflexionInstance:
         '(x, y)'
         """
         method = getattr(self._instance, methodName)
-        return inspect.signature(method)
+        if callable(method):
+            return inspect.signature(method)
+
+    def getPropertySignature(self, propertyName: str) -> inspect.Signature:
+        """Get the signature of a property getter.
+
+        Parameters
+        ----------
+        propertyName : str
+            Name of the property
+
+        Returns
+        -------
+        inspect.Signature
+            The property's getter method signature
+
+        Raises
+        ------
+        AttributeError
+            If the property doesn't exist or is not a property
+
+        Examples
+        --------
+        >>> sig = reflex.getPropertySignature('config')
+        >>> str(sig)
+        '(self)'
+        """
+        attr = getattr(type(self._instance), propertyName, None)
+        if isinstance(attr, property) and attr.fget is not None:
+            return inspect.signature(attr.fget)
+        raise AttributeError(f"{propertyName} is not a property or doesn't have a getter.")
 
     def getDocstring(self) -> Optional[str]:
         """Get the docstring of the instance's class.

orionis/luminate/support/inspection/reflexion_instance_with_abstract.py

@@ -1,309 +1,230 @@
-from typing import Any, Type, Dict, List, Tuple, Callable, Optional, Set, TypeVar
-import inspect
 import abc
+import inspect
+from typing import Any, Dict, List, Tuple, Type, TypeVar, Union
+from orionis.luminate.support.inspection.reflexion_abstract import ReflexionAbstract
+from orionis.luminate.support.inspection.reflexion_instance import ReflexionInstance
 
 T = TypeVar('T')
 ABC = TypeVar('ABC', bound=abc.ABC)
 
 class ReflexionInstanceWithAbstract:
-    """A reflection object encapsulating a class instance and its abstract parent.
+    """Advanced reflection tool for analyzing concrete implementations against abstract bases.
 
-    This class provides methods to inspect both the concrete instance and its
-    abstract parent class, including their relationships and implementations.
+    Combines inspection of both concrete instances and their abstract parent classes,
+    providing detailed comparison and compatibility analysis.
 
     Parameters
     ----------
     instance : Any
-        The instance being reflected upon
+        The concrete instance to inspect
     abstract : Type[ABC]
-        The abstract parent class
+        The abstract base class/interface being implemented
 
     Attributes
     ----------
     _instance : Any
-        The encapsulated instance
+        The concrete instance being analyzed
     _abstract : Type[ABC]
-        The encapsulated abstract parent class
+        The abstract base class/interface
+    _concrete_reflexion : ReflexionInstance
+        Reflection helper for the concrete instance
+    _abstract_reflexion : ReflexionAbstract
+        Reflection helper for the abstract class
     """
 
     def __init__(self, instance: Any, abstract: Type[ABC]) -> None:
-        """Initialize with the instance and abstract parent."""
         self._instance = instance
         self._abstract = abstract
+        self._concrete_reflexion = ReflexionInstance(instance)
+        self._abstract_reflexion = ReflexionAbstract(abstract)
 
-    def getClassName(self) -> str:
-        """Get the name of the instance's class.
-
-        Returns
-        -------
-        str
-            The name of the concrete class
-        """
-        return self._instance.__class__.__name__
-
-    def getAbstractClassName(self) -> str:
-        """Get the name of the abstract parent class.
-
-        Returns
-        -------
-        str
-            The name of the abstract class
-        """
-        return self._abstract.__name__
-
-    def getImplementationStatus(self) -> Dict[str, bool]:
-        """Check which abstract methods are implemented.
-
-        Returns
-        -------
-        Dict[str, bool]
-            Dictionary mapping abstract method names to implementation status
-        """
-        abstract_methods = getattr(self._abstract, '__abstractmethods__', set())
-        return {
-            method: method in dir(self._instance)
-            for method in abstract_methods
-        }
+    @property
+    def concrete(self) -> ReflexionInstance:
+        """Access the concrete instance reflection helper."""
+        return self._concrete_reflexion
 
-    def getMissingImplementations(self) -> Set[str]:
-        """Get abstract methods not implemented by the concrete class.
+    @property
+    def abstract(self) -> ReflexionAbstract:
+        """Access the abstract class reflection helper."""
+        return self._abstract_reflexion
 
-        Returns
-        -------
-        Set[str]
-            Set of abstract method names not implemented
-        """
-        abstract_methods = getattr(self._abstract, '__abstractmethods__', set())
-        return abstract_methods - set(dir(self._instance))
-
-    def isProperImplementation(self) -> bool:
-        """Check if the instance properly implements all abstract methods.
+    def getImplementationAnalysis(self) -> Dict[str, Dict[str, Union[bool, str, inspect.Signature]]]:
+        """Comprehensive analysis of implementation compliance.
 
         Returns
         -------
-        bool
-            True if all abstract methods are implemented, False otherwise
+        Dict[str, Dict[str, Union[bool, str, inspect.Signature]]]
+            Detailed analysis including:
+            - 'implemented': Whether method is implemented
+            - 'signature_match': Whether signatures match
+            - 'abstract_signature': Signature from abstract class
+            - 'concrete_signature': Signature from concrete class
         """
-        return len(self.getMissingImplementations()) == 0
-
-    def getAbstractMethods(self) -> Set[str]:
-        """Get all abstract methods from the parent class.
-
-        Returns
-        -------
-        Set[str]
-            Set of abstract method names
-        """
-        return getattr(self._abstract, '__abstractmethods__', set())
-
-    def getConcreteMethods(self) -> List[str]:
-        """Get all concrete methods of the instance.
-
-        Returns
-        -------
-        List[str]
-            List of method names implemented by the instance
-        """
-        return [name for name, _ in inspect.getmembers(
-            self._instance,
-            predicate=inspect.ismethod
-        )]
-
-    def getOverriddenMethods(self) -> Dict[str, Tuple[Type, Type]]:
-        """Get methods that override abstract ones with their signatures.
-
-        Returns
-        -------
-        Dict[str, Tuple[Type, Type]]
-            Dictionary mapping method names to tuples of
-            (abstract_signature, concrete_signature)
-        """
-        overridden = {}
-        abstract_methods = self.getAbstractMethods()
-
+        analysis = {}
+        abstract_methods = self._abstract_reflexion.getAbstractMethods()
         for method in abstract_methods:
-            if hasattr(self._instance, method):
-                abstract_sig = inspect.signature(getattr(self._abstract, method))
-                concrete_sig = inspect.signature(getattr(self._instance, method))
-                overridden[method] = (abstract_sig, concrete_sig)
+            entry = {
+                'implemented': False,
+                'abstract_signature': None,
+                'concrete_signature': None,
+                'signature_match': False,
+                'type' : 'method'
+            }
 
-        return overridden
-
-    def checkSignatureCompatibility(self) -> Dict[str, bool]:
-        """Check if implemented methods match abstract signatures.
+            if hasattr(self._instance, method):
+                entry['implemented'] = True
+                abstract_sig = self._abstract_reflexion.getMethodSignature(method)
+                concrete_sig = self._concrete_reflexion.getMethodSignature(method)
+
+                entry.update({
+                    'abstract_signature': abstract_sig,
+                    'concrete_signature': concrete_sig,
+                    'signature_match': (
+                        abstract_sig.parameters == concrete_sig.parameters and
+                        abstract_sig.return_annotation == concrete_sig.return_annotation
+                    )
+                })
+
+            analysis[method] = entry
+
+        abstract_properties = self._abstract_reflexion.getAbstractProperties()
+        for prop in abstract_properties:
+            entry = {
+                'implemented': False,
+                'abstract_signature': None,
+                'concrete_signature': None,
+                'signature_match': False,
+                'type' : 'property'
+            }
+
+            if hasattr(self._instance, prop):
+                entry['implemented'] = True
+                abstract_sig = self._abstract_reflexion.getPropertySignature(prop)
+                concrete_sig = self._concrete_reflexion.getPropertySignature(prop)
+
+                entry.update({
+                    'abstract_signature': abstract_sig,
+                    'concrete_signature': concrete_sig,
+                    'signature_match': (
+                        abstract_sig.parameters == concrete_sig.parameters and
+                        abstract_sig.return_annotation == concrete_sig.return_annotation
+                    )
+                })
+
+            analysis[prop] = entry
+
+        return analysis
+
+    def getNonInheritedImplementation(self) -> Dict[str, Any]:
+        """Get implementation details for methods, properties, and attributes not inherited from other parents.
 
         Returns
         -------
-        Dict[str, bool]
-            Dictionary mapping method names to compatibility status
-        """
-        compatibility = {}
-        overridden = self.getOverriddenMethods()
-
-        for method, (abstract_sig, concrete_sig) in overridden.items():
-            compatibility[method] = (
-                abstract_sig.parameters == concrete_sig.parameters and
-                abstract_sig.return_annotation == concrete_sig.return_annotation
-            )
-
-        return compatibility
-
-    def getAbstractProperties(self) -> Set[str]:
-        """Get all abstract properties from the parent class.
+        Dict[str, Any]
+            Dictionary containing:
+            - 'methods': List of non-inherited method names
+            - 'properties': List of non-inherited property names
+            - 'attributes': Dict of non-inherited attributes
+        """
+        # Get all members from concrete class (non-inherited methods, properties, and attributes)
+        concrete_members = set(dir(self._instance.__class__))
+
+        # Get members from the abstract class (base class)
+        base_members = set(dir(self._abstract))
+
+        # Filter out inherited members (methods, properties, and attributes)
+        non_inherited_methods = [
+            name for name in concrete_members
+            if callable(getattr(self._instance.__class__, name)) and name not in base_members
+        ]
+
+        non_inherited_properties = [
+            name for name in concrete_members
+            if isinstance(getattr(self._instance.__class__, name, None), property) and name not in base_members
+        ]
+
+        non_inherited_attributes = {
+            name: getattr(self._instance.__class__, name)
+            for name in concrete_members
+            if not callable(getattr(self._instance.__class__, name)) and not isinstance(getattr(self._instance.__class__, name, None), property) and name not in base_members
+        }
 
-        Returns
-        -------
-        Set[str]
-            Set of abstract property names
-        """
         return {
-            name for name, member in inspect.getmembers(
-                self._abstract,
-                lambda x: isinstance(x, property) and 
-                name in getattr(self._abstract, '__abstractmethods__', set())
-            )
+            'methods': non_inherited_methods,
+            'properties': non_inherited_properties,
+            'attributes': non_inherited_attributes
         }
 
-    def getInstanceAttributes(self) -> Dict[str, Any]:
-        """Get all attributes of the concrete instance.
+    def validateImplementation(self) -> Tuple[bool, Dict[str, List[str]]]:
+        """Validate the implementation against the abstract base.
 
         Returns
         -------
-        Dict[str, Any]
-            Dictionary of attribute names and their values
+        Tuple[bool, Dict[str, List[str]]]
+            - First element: True if fully valid implementation
+            - Second element: Dictionary of issues by category:
+                * 'missing': Missing required methods
+                * 'signature_mismatch': Methods with signature mismatches
+                * 'type_mismatch': Methods with return type mismatches
         """
-        return vars(self._instance)
-
-    def getAbstractClassDocstring(self) -> Optional[str]:
-        """Get the docstring of the abstract parent class.
-
-        Returns
-        -------
-        Optional[str]
-            The abstract class docstring, or None if not available
-        """
-        return self._abstract.__doc__
-
-    def getConcreteClassDocstring(self) -> Optional[str]:
-        """Get the docstring of the concrete instance's class.
-
-        Returns
-        -------
-        Optional[str]
-            The concrete class docstring, or None if not available
-        """
-        return self._instance.__class__.__doc__
-
-    def getAbstractClassModule(self) -> str:
-        """Get the module name where the abstract class is defined.
-
-        Returns
-        -------
-        str
-            The module name of the abstract class
-        """
-        return self._abstract.__module__
-
-    def getConcreteClassModule(self) -> str:
-        """Get the module name where the concrete class is defined.
-
-        Returns
-        -------
-        str
-            The module name of the concrete class
-        """
-        return self._instance.__class__.__module__
-
-    def isDirectSubclass(self) -> bool:
-        """Check if the concrete class directly inherits from the abstract class.
-
-        Returns
-        -------
-        bool
-            True if direct subclass, False otherwise
-        """
-        return self._abstract in self._instance.__class__.__bases__
+        issues = {
+            'missing': [],
+            'signature_mismatch': [],
+            'type_mismatch': []
+        }
 
-    def getAbstractClassHierarchy(self) -> List[Type]:
-        """Get the inheritance hierarchy of the abstract class.
+        analysis = self.getImplementationAnalysis()
+        for method, data in analysis.items():
+            if not data['implemented']:
+                issues['missing'].append(method)
+            elif not data['signature_match']:
+                issues['signature_mismatch'].append(method)
+                # Check specifically for return type mismatch
+                abstract_return = data['abstract_signature'].return_annotation
+                concrete_return = data['concrete_signature'].return_annotation
+                if abstract_return != concrete_return and abstract_return is not inspect.Parameter.empty:
+                    issues['type_mismatch'].append(method)
 
-        Returns
-        -------
-        List[Type]
-            List of classes in the inheritance hierarchy
-        """
-        return inspect.getmro(self._abstract)
+        is_valid = not any(issues.values())
+        return (is_valid, issues)
 
-    def getConcreteClassHierarchy(self) -> List[Type]:
-        """Get the inheritance hierarchy of the concrete class.
+    def getHierarchyAnalysis(self) -> Dict[str, List[str]]:
+        """Analyze the class hierarchy relationships.
 
         Returns
         -------
-        List[Type]
-            List of classes in the inheritance hierarchy
+        Dict[str, List[str]]
+            Dictionary containing:
+            - 'concrete_hierarchy': List of class names in concrete hierarchy
+            - 'abstract_hierarchy': List of class names in abstract hierarchy
+            - 'common_ancestors': List of common ancestor class names
         """
-        return inspect.getmro(self._instance.__class__)
+        concrete_hierarchy = [cls.__name__ for cls in inspect.getmro(self._instance.__class__)]
+        abstract_hierarchy = [cls.__name__ for cls in inspect.getmro(self._abstract)]
 
-    def getCommonBaseClasses(self) -> List[Type]:
-        """Get base classes common to both abstract and concrete classes.
-
-        Returns
-        -------
-        List[Type]
-            List of common base classes
-        """
-        abstract_bases = set(inspect.getmro(self._abstract))
         concrete_bases = set(inspect.getmro(self._instance.__class__))
-        return list(abstract_bases & concrete_bases - {self._abstract, object})
-
-    def getAbstractClassSource(self) -> Optional[str]:
-        """Get the source code of the abstract class.
-
-        Returns
-        -------
-        Optional[str]
-            The source code if available, None otherwise
-        """
-        try:
-            return inspect.getsource(self._abstract)
-        except (TypeError, OSError):
-            return None
-
-    def getConcreteClassSource(self) -> Optional[str]:
-        """Get the source code of the concrete class.
+        abstract_bases = set(inspect.getmro(self._abstract))
+        common = concrete_bases & abstract_bases - {self._abstract, object}
 
-        Returns
-        -------
-        Optional[str]
-            The source code if available, None otherwise
-        """
-        try:
-            return inspect.getsource(self._instance.__class__)
-        except (TypeError, OSError):
-            return None
+        return {
+            'concrete_hierarchy': concrete_hierarchy,
+            'abstract_hierarchy': abstract_hierarchy,
+            'common_ancestors': [cls.__name__ for cls in common]
+        }
 
-    def getAbstractClassFile(self) -> Optional[str]:
-        """Get the file location of the abstract class definition.
+    def getImplementationCoverage(self) -> float:
+        """Calculate the percentage of abstract methods implemented.
 
         Returns
         -------
-        Optional[str]
-            The file path if available, None otherwise
+        float
+            Implementation coverage percentage (0.0 to 1.0)
         """
-        try:
-            return inspect.getfile(self._abstract)
-        except (TypeError, OSError):
-            return None
-
-    def getConcreteClassFile(self) -> Optional[str]:
-        """Get the file location of the concrete class definition.
+        attr = self.getImplementationAnalysis()
+        attr_len = len(attr) * 2
+        attr_implemented = 0
+        for method in attr.values():
+            if method.get('implemented'):
+                attr_implemented += 2 if method.get('signature_match') else 1
 
-        Returns
-        -------
-        Optional[str]
-            The file path if available, None otherwise
-        """
-        try:
-            return inspect.getfile(self._instance.__class__)
-        except (TypeError, OSError):
-            return None
+        return attr_implemented / attr_len if attr_len > 0 else 0.0

orionis/luminate/test/test_case.py

@@ -0,0 +1,5 @@
+import unittest
+from orionis.luminate.test.test_std_out import TestStdOut
+
+class TestCase(unittest.TestCase, TestStdOut):
+    pass

orionis/luminate/test/{test_output.py → test_std_out.py}

@@ -1,8 +1,8 @@
+import os
 import sys
 from orionis.luminate.console.output.console import Console
-import os
 
-class PrinterInTest:
+class TestStdOut:
     """
     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

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

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

{orionis-0.207.0.dist-info → orionis-0.209.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=eb4WxXbyAXkX44A065Y_hEHg-PyA8LWfMluqcfrxYJA,1469
+orionis/framework.py,sha256=U51WcK-STfeqKJkXH8t51BUJpV_Zg8o-exE-7tgVj8k,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,18 +171,19 @@ 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=pKjLZFAfCHcve39FiIeAyAJiSxKhOWBkMsPub3Sa-RI,9313
+orionis/luminate/support/inspection/reflexion_abstract.py,sha256=U_VAGQN0ZDMgjxYPhNrLxFt6F8_-8zXcA_B5djTV4GE,10731
 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
-orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=dag6QdVp1CydREWdpQvzAyOPX3q-lSb0_XzB0u3odQE,9629
+orionis/luminate/support/inspection/reflexion_instance.py,sha256=LNAgw4sZvHT7UMiObHTGk7xgqpIeKYHAQRgRpuPfEas,10842
+orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=PI_VSH8baxjPgheOYc9tQAlLq9mjxGm5zCOr-bLVksg,9406
 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_case.py,sha256=jFhNcUZWuDTDFpe_nYJTqXQChA4z5kxu0I2YCONGSVk,134
 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/test_std_out.py,sha256=annYLGDkskRpMuLwTAswwrgrYmwsXIyKE02M_ePv-qc,2765
 orionis/luminate/test/tests.py,sha256=KZRFHB6C8S2DN6JHqJ2sIuSNAUMh9JW1Yn-XGjXjjTw,2218
 orionis/luminate/test/unit_test.py,sha256=HtPDWzFXpgFwWYej8z2BArU4k5lItH57K_E-l21MBWo,12070
 orionis/static/ascii/icon.ascii,sha256=IgrlVjcYxcCrr0cJuJkOnEz0aEdAQBTyLzO5ainKsWc,398
@@ -196,17 +197,19 @@ orionis/static/logos/OrionisFramework2.png,sha256=Z_-yBHNSo33QeSTyi-8GfiFozdRqUo
 orionis/static/logos/OrionisFramework3.png,sha256=BPG9ZB58vDALavI9OMmr8Ym0DQa44s5NL_3M4M6dIYs,193734
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/example/test_example.py,sha256=MNYissCEa0mzx1YA2gTiqXRX8r2v_vfB_Ew0jBFmBag,556
+tests/example/test_example.py,sha256=8EYjl1b-J_479dmJdQoAcKCKr7JUydW7EmPQpeiF13Y,586
 tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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/test_reflection_abstract.py,sha256=K78avxUlI_dYKofSvVcuaVLAz-CivWSe3RkhrO-IRcA,9185
+tests/support/inspection/test_reflection_instance.py,sha256=qwYu_y3wiZzhegrRo97r1bWxW2YGxDdnnU-Hq4lZtAE,6930
+tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RNLf9RfRtM2nTY6Yfc8rPibSEVZkl8Pw2w962vsragk,4048
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
+orionis-0.209.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.209.0.dist-info/METADATA,sha256=C6g0E0x63bfx_67XUWursBiX083LFbgx4gehabf_lR0,3003
+orionis-0.209.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.209.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.209.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.209.0.dist-info/RECORD,,

tests/example/test_example.py

@@ -1,5 +1,6 @@
-import unittest
-class TestExample(unittest.TestCase):
+from orionis.luminate.test.test_case import TestCase
+
+class TestExample(TestCase):
     """
     Unit tests for basic example functionality.
     """

tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py

@@ -0,0 +1,45 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict
+
+class IDataProcessor(ABC):
+    """Interfaz para procesamiento de datos."""
+
+    @property
+    @abstractmethod
+    def config(self) -> Dict[str, str]:
+        """Configuración del procesador."""
+        pass
+
+    @abstractmethod
+    def process(self, data: List[float]) -> Dict[str, float]:
+        """Procesa una lista de números y devuelve métricas."""
+        pass
+
+    @abstractmethod
+    def validate_input(self, raw_data: str) -> bool:
+        """Valida si los datos en crudo pueden ser procesados."""
+        pass
+
+class FakeDataProcessor:
+    """Implementación concreta fake de IDataProcessor."""
+
+    def __init__(self):
+        self._config = {"mode": "standard"}
+        self._version = "1.0"
+
+    @property
+    def config(self) -> Dict[str, str]:
+        """Implementación correcta de la propiedad."""
+        return self._config
+
+    def process(self, values: List[float]) -> Dict[str, float]:
+        """Implementación con tipo de retorno incorrecto (float vs Dict)."""
+        return sum(values) / len(values) if values else 0.0
+
+    def validate_input(self, source: str) -> bool:
+        """Implementación con parámetro renombrado (source vs raw_data)."""
+        return bool(source)
+
+    def extra_method(self) -> str:
+        """Método adicional no definido en la interfaz."""
+        return f"Processing with version {self._version}"

tests/support/inspection/test_reflection_abstract.py

@@ -1,10 +1,9 @@
 from abc import ABC
-import unittest
 from orionis.luminate.support.inspection.reflection import Reflection
-from orionis.luminate.test.test_output import PrinterInTest
+from orionis.luminate.test.test_case import TestCase
 from tests.support.inspection.fakes.fake_reflection_abstract import FakeAbstractClass
 
-class TestReflexionAbstract(unittest.TestCase, PrinterInTest):
+class TestReflexionAbstract(TestCase):
     """Test cases for ReflexionAbstract using FakeAbstractClass.
 
     This test suite verifies all functionality of the ReflexionAbstract class
@@ -226,4 +225,13 @@ class TestReflexionAbstract(unittest.TestCase, PrinterInTest):
         Verifies that:
         - Returns empty set for non-Protocol classes
         """
-        self.assertEqual(Reflection.abstract(FakeAbstractClass).getRequiredAttributes(), set())
+        self.assertEqual(Reflection.abstract(FakeAbstractClass).getRequiredAttributes(), set())
+
+    def testReflectionAbstractGetAbstractProperties(self):
+        """Test getRequiredMethods() method."""
+        self.assertEqual(Reflection.abstract(FakeAbstractClass).getAbstractProperties(), set())
+
+    def testReflectionAbstractGetPropertySignature(self):
+        """Test getPropertySignature() method."""
+        signature = Reflection.abstract(FakeAbstractClass).getPropertySignature('computed_property')
+        self.assertEqual(str(signature), '(self) -> float')

tests/support/inspection/test_reflection_instance.py

@@ -1,10 +1,9 @@
-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 orionis.luminate.test.test_case import TestCase
 from tests.support.inspection.fakes.fake_reflection_instance import BaseFakeClass, FakeClass
 
-class TestReflection(unittest.TestCase, PrinterInTest):
+class TestReflection(TestCase):
     """
     Unit tests for the Reflection class.
     """
@@ -139,3 +138,8 @@ class TestReflection(unittest.TestCase, PrinterInTest):
 
         result = reflex.callMethod("myMacro", reflex._instance, 3)
         self.assertEqual(result, 25)
+
+    def testReflectionInstanceGetPropertySignature(self):
+        """Ensure getPropertySignature returns the correct property signature."""
+        signature = Reflection.instance(FakeClass()).getPropertySignature('computed_property')
+        self.assertEqual(str(signature), '(self) -> str')

tests/support/inspection/test_reflection_instance_with_abstract.py

@@ -0,0 +1,79 @@
+from orionis.luminate.support.inspection.reflexion_instance_with_abstract import ReflexionInstanceWithAbstract
+from orionis.luminate.test.test_case import TestCase
+from tests.support.inspection.fakes.fake_reflection_instance_with_abstract import FakeDataProcessor, IDataProcessor
+
+class TestReflexionWithFakes(TestCase):
+
+    def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
+        """Test reflexion con IDataProcessor y FakeDataProcessor."""
+        processor = FakeDataProcessor()
+        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
+
+        # Get Implementation analysis
+        analysis = inspector.getImplementationAnalysis()
+
+        # Verifying implemented methods
+        self.assertTrue(analysis['validate_input']['implemented'])
+        self.assertEqual(str(analysis['validate_input']['abstract_signature']), "(self, raw_data: str) -> bool")
+        self.assertEqual(str(analysis['validate_input']['concrete_signature']), "(source: str) -> bool")
+        self.assertFalse(analysis['validate_input']['signature_match'])
+        self.assertEqual(analysis['validate_input']['type'], 'method')
+
+        self.assertTrue(analysis['process']['implemented'])
+        self.assertEqual(str(analysis['process']['abstract_signature']), "(self, data: List[float]) -> Dict[str, float]")
+        self.assertEqual(str(analysis['process']['concrete_signature']), "(values: List[float]) -> Dict[str, float]")
+        self.assertFalse(analysis['process']['signature_match'])
+        self.assertEqual(analysis['process']['type'], 'method')
+
+        self.assertTrue(analysis['config']['implemented'])
+        self.assertEqual(str(analysis['config']['abstract_signature']), "(self) -> Dict[str, str]")
+        self.assertEqual(str(analysis['config']['concrete_signature']), "(self) -> Dict[str, str]")
+        self.assertTrue(analysis['config']['signature_match'])
+        self.assertEqual(analysis['config']['type'], 'property')
+
+    def testReflexionInstanceWithAbstractGetNonInheritedImplementation(self):
+        """Test reflexion con IDataProcessor y FakeDataProcessor."""
+        processor = FakeDataProcessor()
+        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
+
+        # Get Non-Inherited implementation analysis
+        analysis = inspector.getNonInheritedImplementation()
+
+        # Verifying implemented methods
+        self.assertIn('extra_method', analysis['methods'])
+
+    def testReflexionInstanceWithAbstractValidateImplementation(self):
+        """Test reflexion con IDataProcessor y FakeDataProcessor."""
+        processor = FakeDataProcessor()
+        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
+
+        # Get Implementation analysis
+        is_valid, issues = inspector.validateImplementation()
+
+        # Verifying implemented methods
+        self.assertFalse(is_valid)
+        self.assertIn('process', issues['signature_mismatch'])
+
+    def testReflexionInstanceWithAbstractGetHierarchyAnalysis(self):
+        """Test reflexion con IDataProcessor y FakeDataProcessor."""
+        processor = FakeDataProcessor()
+        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
+
+        # Get Hierarchy analysis
+        analysis = inspector.getHierarchyAnalysis()
+
+        # Verifying implemented methods
+        self.assertEqual(analysis['common_ancestors'], [])
+        self.assertIn('IDataProcessor', analysis['abstract_hierarchy'])
+        self.assertIn('FakeDataProcessor', analysis['concrete_hierarchy'])
+
+    def testReflexionInstanceWithAbstractGetImplementationCoverage(self):
+        """Test reflexion con IDataProcessor y FakeDataProcessor."""
+        processor = FakeDataProcessor()
+        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
+
+        # Get Implementation coverage
+        coverage = inspector.getImplementationCoverage()
+
+        # Verifying implemented methods
+        self.assertTrue(coverage >= 0.66)