orionis 0.206.0__tar.gz → 0.208.0__tar.gz

{orionis-0.206.0/orionis.egg-info → orionis-0.208.0}/PKG-INFO

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

{orionis-0.206.0 → orionis-0.208.0}/orionis/framework.py

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

{orionis-0.206.0 → orionis-0.208.0}/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,26 @@ class ReflexionAbstract:
         Set[str]
             Set of abstract method names
         """
-        return {name for name, _ in self._abstract.__abstractmethods__}
+        methods = []
+        for method in self._abstract.__abstractmethods__:
+            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.
@@ -88,13 +108,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]:
@@ -131,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.
@@ -153,7 +216,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 +283,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 = []
+        method = getattr(self._abstract, method_name, None)
+        if method is None:
+            return []
 
-        if hasattr(method, '__wrapped__'):
-            # Unwrap decorated functions
-            while hasattr(method, '__wrapped__'):
-                decorators.append(method)
-                method = method.__wrapped__
-
-        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.206.0 → orionis-0.208.0}/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-0.208.0/orionis/luminate/support/inspection/reflexion_instance_with_abstract.py

@@ -0,0 +1,230 @@
+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:
+    """Advanced reflection tool for analyzing concrete implementations against abstract bases.
+
+    Combines inspection of both concrete instances and their abstract parent classes,
+    providing detailed comparison and compatibility analysis.
+
+    Parameters
+    ----------
+    instance : Any
+        The concrete instance to inspect
+    abstract : Type[ABC]
+        The abstract base class/interface being implemented
+
+    Attributes
+    ----------
+    _instance : Any
+        The concrete instance being analyzed
+    _abstract : Type[ABC]
+        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:
+        self._instance = instance
+        self._abstract = abstract
+        self._concrete_reflexion = ReflexionInstance(instance)
+        self._abstract_reflexion = ReflexionAbstract(abstract)
+
+    @property
+    def concrete(self) -> ReflexionInstance:
+        """Access the concrete instance reflection helper."""
+        return self._concrete_reflexion
+
+    @property
+    def abstract(self) -> ReflexionAbstract:
+        """Access the abstract class reflection helper."""
+        return self._abstract_reflexion
+
+    def getImplementationAnalysis(self) -> Dict[str, Dict[str, Union[bool, str, inspect.Signature]]]:
+        """Comprehensive analysis of implementation compliance.
+
+        Returns
+        -------
+        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
+        """
+        analysis = {}
+        abstract_methods = self._abstract_reflexion.getAbstractMethods()
+        for method in abstract_methods:
+            entry = {
+                'implemented': False,
+                'abstract_signature': None,
+                'concrete_signature': None,
+                'signature_match': False,
+                'type' : 'method'
+            }
+
+            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, 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
+        }
+
+        return {
+            'methods': non_inherited_methods,
+            'properties': non_inherited_properties,
+            'attributes': non_inherited_attributes
+        }
+
+    def validateImplementation(self) -> Tuple[bool, Dict[str, List[str]]]:
+        """Validate the implementation against the abstract base.
+
+        Returns
+        -------
+        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
+        """
+        issues = {
+            'missing': [],
+            'signature_mismatch': [],
+            'type_mismatch': []
+        }
+
+        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)
+
+        is_valid = not any(issues.values())
+        return (is_valid, issues)
+
+    def getHierarchyAnalysis(self) -> Dict[str, List[str]]:
+        """Analyze the class hierarchy relationships.
+
+        Returns
+        -------
+        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
+        """
+        concrete_hierarchy = [cls.__name__ for cls in inspect.getmro(self._instance.__class__)]
+        abstract_hierarchy = [cls.__name__ for cls in inspect.getmro(self._abstract)]
+
+        concrete_bases = set(inspect.getmro(self._instance.__class__))
+        abstract_bases = set(inspect.getmro(self._abstract))
+        common = concrete_bases & abstract_bases - {self._abstract, object}
+
+        return {
+            'concrete_hierarchy': concrete_hierarchy,
+            'abstract_hierarchy': abstract_hierarchy,
+            'common_ancestors': [cls.__name__ for cls in common]
+        }
+
+    def getImplementationCoverage(self) -> float:
+        """Calculate the percentage of abstract methods implemented.
+
+        Returns
+        -------
+        float
+            Implementation coverage percentage (0.0 to 1.0)
+        """
+        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
+
+        return attr_implemented / attr_len if attr_len > 0 else 0.0

{orionis-0.206.0 → orionis-0.208.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.206.0 → orionis-0.208.0}/orionis.egg-info/SOURCES.txt

@@ -209,6 +209,10 @@ tests/example/__init__.py
 tests/example/test_example.py
 tests/support/__init__.py
 tests/support/inspection/__init__.py
+tests/support/inspection/test_reflection_abstract.py
 tests/support/inspection/test_reflection_instance.py
+tests/support/inspection/test_reflection_instance_with_abstract.py
 tests/support/inspection/fakes/__init__.py
-tests/support/inspection/fakes/fake_reflection.py
+tests/support/inspection/fakes/fake_reflection_abstract.py
+tests/support/inspection/fakes/fake_reflection_instance.py
+tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py