orionis 0.211.0__tar.gz → 0.213.0__tar.gz

{orionis-0.211.0/orionis.egg-info → orionis-0.213.0}/PKG-INFO

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

{orionis-0.211.0 → orionis-0.213.0}/orionis/framework.py

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

orionis-0.213.0/orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py

@@ -0,0 +1,185 @@
+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_concrete import ReflexionConcrete
+
+T = TypeVar('T')
+ABC = TypeVar('ABC', bound=abc.ABC)
+
+class ReflexionConcreteWithAbstract:
+    """Advanced reflection tool for analyzing concrete classes against abstract bases.
+
+    Allows static analysis of class definitions to verify compatibility
+    and adherence to interface contracts without instantiation.
+
+    Parameters
+    ----------
+    concrete : Type[T]
+        The concrete class to inspect
+    abstract : Type[ABC]
+        The abstract base class/interface being implemented
+
+    Attributes
+    ----------
+    _concrete : Type[T]
+        The concrete class being analyzed
+    _abstract : Type[ABC]
+        The abstract base class/interface
+    _concrete_reflexion : ReflexionConcrete
+        Reflection helper for the concrete class
+    _abstract_reflexion : ReflexionAbstract
+        Reflection helper for the abstract class
+    """
+
+    def __init__(self, concrete: Type[T], abstract: Type[ABC]) -> None:
+        self._concrete = concrete
+        self._abstract = abstract
+        self._concrete_reflexion = ReflexionConcrete(concrete)
+        self._abstract_reflexion = ReflexionAbstract(abstract)
+
+    @property
+    def concrete(self) -> ReflexionConcrete:
+        """Access the concrete class 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."""
+        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._concrete, 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._concrete, 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 validateImplementation(self) -> Tuple[bool, Dict[str, List[str]]]:
+        """Validate the implementation against the abstract base."""
+        issues = {
+            'missing': [],
+            'signature_mismatch': [],
+            'type_mismatch': []
+        }
+
+        analysis = self.getImplementationAnalysis()
+        for name, data in analysis.items():
+            if not data['implemented']:
+                issues['missing'].append(name)
+            elif not data['signature_match']:
+                issues['signature_mismatch'].append(name)
+                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(name)
+
+        is_valid = not any(issues.values())
+        return (is_valid, issues)
+
+    def getImplementationCoverage(self) -> float:
+        """Calculate the percentage of abstract methods/properties implemented."""
+        analysis = self.getImplementationAnalysis()
+        total = len(analysis) * 2
+        implemented = 0
+        for item in analysis.values():
+            if item['implemented']:
+                implemented += 2 if item['signature_match'] else 1
+        return implemented / total if total else 0.0
+
+    def getNonInheritedImplementation(self) -> Dict[str, Any]:
+        """Get implementation details for methods, properties, and attributes not inherited from the abstract base."""
+        concrete_members = set(dir(self._concrete))
+        base_members = set(dir(self._abstract))
+
+        non_inherited_methods = [
+            name for name in concrete_members
+            if callable(getattr(self._concrete, name, None)) and name not in base_members
+        ]
+
+        non_inherited_properties = [
+            name for name in concrete_members
+            if isinstance(getattr(self._concrete, name, None), property) and name not in base_members
+        ]
+
+        non_inherited_attributes = {
+            name: getattr(self._concrete, name, None)
+            for name in concrete_members
+            if (
+                not callable(getattr(self._concrete, name, None)) and
+                not isinstance(getattr(self._concrete, name, None), property) and
+                name not in base_members
+            )
+        }
+
+        return {
+            'methods': non_inherited_methods,
+            'properties': non_inherited_properties,
+            'attributes': non_inherited_attributes
+        }
+
+    def getHierarchyAnalysis(self) -> Dict[str, List[str]]:
+        """Analyze the class hierarchy relationships."""
+        concrete_hierarchy = [cls.__name__ for cls in inspect.getmro(self._concrete)]
+        abstract_hierarchy = [cls.__name__ for cls in inspect.getmro(self._abstract)]
+
+        concrete_bases = set(inspect.getmro(self._concrete))
+        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]
+        }

{orionis-0.211.0 → orionis-0.213.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.211.0 → orionis-0.213.0}/orionis.egg-info/SOURCES.txt

@@ -210,10 +210,12 @@ tests/support/__init__.py
 tests/support/inspection/__init__.py
 tests/support/inspection/test_reflection_abstract.py
 tests/support/inspection/test_reflection_concrete.py
+tests/support/inspection/test_reflection_concrete_with_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_abstract.py
 tests/support/inspection/fakes/fake_reflection_concrete.py
+tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py
 tests/support/inspection/fakes/fake_reflection_instance.py
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py

orionis-0.213.0/tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py

@@ -0,0 +1,78 @@
+import abc
+from typing import Any, Dict, List
+
+class AbstractService(abc.ABC):
+    """
+    Abstract interface for service-like behavior.
+
+    Methods
+    -------
+    process(data: str) -> bool
+        Perform processing on input data.
+
+    reset() -> None
+        Reset the internal state of the service.
+
+    configure(options: Dict[str, Any]) -> None
+        Apply configuration settings to the service.
+
+    get_logs(limit: int = 10) -> List[str]
+        Retrieve a limited number of log messages.
+
+    Properties
+    ----------
+    status : str
+        Current status of the service.
+    """
+
+    @abc.abstractmethod
+    def process(self, data: str) -> bool:
+        """Perform processing on input data."""
+        pass
+
+    @abc.abstractmethod
+    def reset(self) -> None:
+        """Reset the internal state of the service."""
+        pass
+
+    @abc.abstractmethod
+    def configure(self, options: Dict[str, Any]) -> None:
+        """Apply configuration settings to the service."""
+        pass
+
+    @abc.abstractmethod
+    def get_logs(self, limit: int = 10) -> List[str]:
+        """Retrieve a limited number of log messages."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def status(self) -> str:
+        """Current status of the service."""
+        pass
+
+class PartiallyImplementedService:
+    """
+    A partial implementation of AbstractService.
+
+    This class mimics the interface but lacks some methods/properties,
+    making it useful for testing reflection-based validation.
+    """
+
+    def process(self, data: str) -> bool:
+        """Basic processing implementation."""
+        return bool(data)
+
+    def get_logs(self, limit: int = 10) -> List[str]:
+        """Return a fixed list of logs (mock implementation)."""
+        return [f"log {i}" for i in range(limit)]
+
+    # ❌ Missing: reset()
+    # ❌ Missing: configure()
+    # ❌ Missing: status (property)
+
+    def extra(self) -> str:
+        """An extra method not part of the abstract interface."""
+        return "Just extra"
+
+    version: str = "1.0"

orionis-0.213.0/tests/support/inspection/test_reflection_concrete_with_abstract.py

@@ -0,0 +1,87 @@
+from orionis.luminate.support.inspection.reflexion_concrete_with_abstract import ReflexionConcreteWithAbstract
+from orionis.luminate.test.test_case import TestCase
+from tests.support.inspection.fakes.fake_reflection_concrete_with_abstract import AbstractService, PartiallyImplementedService
+
+class TestReflexionConcreteWithAbstract(TestCase):
+
+    def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
+        """Test reflexion con AbstractService y PartiallyImplementedService."""
+        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
+
+        # Get Implementation analysis
+        analysis = inspector.getImplementationAnalysis()
+
+        # Verifying implemented methods
+        self.assertFalse(analysis['configure']['implemented'])
+        self.assertIsNone(analysis['configure']['abstract_signature'])
+        self.assertIsNone(analysis['configure']['concrete_signature'])
+        self.assertFalse(analysis['configure']['signature_match'])
+        self.assertEqual(analysis['configure']['type'], 'method')
+
+        self.assertTrue(analysis['get_logs']['implemented'])
+        self.assertEqual(str(analysis['get_logs']['abstract_signature']), "(self, limit: int = 10) -> List[str]")
+        self.assertEqual(str(analysis['get_logs']['concrete_signature']), "(self, limit: int = 10) -> List[str]")
+        self.assertTrue(analysis['get_logs']['signature_match'])
+        self.assertEqual(analysis['get_logs']['type'], 'method')
+
+        self.assertFalse(analysis['reset']['implemented'])
+        self.assertIsNone(analysis['reset']['abstract_signature'])
+        self.assertIsNone(analysis['reset']['concrete_signature'])
+        self.assertFalse(analysis['reset']['signature_match'])
+        self.assertEqual(analysis['reset']['type'], 'method')
+
+        self.assertTrue(analysis['process']['implemented'])
+        self.assertEqual(str(analysis['process']['abstract_signature']), "(self, data: str) -> bool")
+        self.assertEqual(str(analysis['process']['concrete_signature']), "(self, data: str) -> bool")
+        self.assertTrue(analysis['process']['signature_match'])
+        self.assertEqual(analysis['process']['type'], 'method')
+
+        self.assertFalse(analysis['status']['implemented'])
+        self.assertIsNone(analysis['status']['abstract_signature'])
+        self.assertIsNone(analysis['status']['concrete_signature'])
+        self.assertFalse(analysis['status']['signature_match'])
+        self.assertEqual(analysis['status']['type'], 'property')
+
+    def testReflexionConcreteWithAbstractGetNonInheritedImplementation(self):
+        """Test reflexion con AbstractService y PartiallyImplementedService."""
+        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
+
+        # Get Non-Inherited implementation analysis
+        analysis = inspector.getNonInheritedImplementation()
+
+        self.assertIn('extra', analysis['methods'])
+        self.assertListEqual(analysis['properties'], [])
+        self.assertIn('__annotations__', analysis['attributes'])
+
+    def testReflexionConcreteWithAbstractValidateImplementation(self):
+        """Test reflexion con AbstractService y PartiallyImplementedService."""
+        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
+
+        # Get Implementation analysis
+        is_valid, issues = inspector.validateImplementation()
+
+        # Verifying implemented methods
+        self.assertFalse(is_valid)
+        self.assertIn('reset', issues['missing'])
+
+    def testReflexionConcreteWithAbstractGetHierarchyAnalysis(self):
+        """Test reflexion con AbstractService y PartiallyImplementedService."""
+        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
+
+        # Get Hierarchy analysis
+        analysis = inspector.getHierarchyAnalysis()
+
+        # Verifying implemented methods
+        self.assertEqual(analysis['common_ancestors'], [])
+        self.assertIn('AbstractService', analysis['abstract_hierarchy'])
+        self.assertIn('PartiallyImplementedService', analysis['concrete_hierarchy'])
+
+    def testReflexionConcreteWithAbstractGetImplementationCoverage(self):
+        """Test reflexion con AbstractService y PartiallyImplementedService."""
+        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
+
+        # Get Implementation coverage
+        coverage = inspector.getImplementationCoverage()
+
+        # Verifying implemented methods
+        self.assertTrue(coverage >= 0.4)

orionis-0.211.0/orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py

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