orionis 0.304.0__py3-none-any.whl → 0.306.0__py3-none-any.whl

orionis/support/introspection/reflexion_concrete.py

@@ -1,276 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar
-import inspect
-
-T = TypeVar('T')
-
-class ReflexionConcrete:
-    """A reflection object encapsulating a concrete class.
-
-    Parameters
-    ----------
-    concrete : Type[T]
-        The concrete class being reflected upon
-
-    Attributes
-    ----------
-    _concrete : Type[T]
-        The encapsulated concrete class
-    """
-
-    def __init__(self, concrete: Type[T]) -> None:
-        """Initialize with the concrete class."""
-        self._concrete = concrete
-
-    def getClassName(self) -> str:
-        """Get the name of the concrete class.
-
-        Returns
-        -------
-        str
-            The name of the class
-        """
-        return self._concrete.__name__
-
-    def getClass(self) -> Type:
-        """Get the class of the instance.
-
-        Returns
-        -------
-        Type
-            The class object of the instance
-
-        Examples
-        --------
-        >>> reflex.getClass() is SomeClass
-        True
-        """
-        return self._concrete
-
-    def getModuleName(self) -> str:
-        """Get the name of the module where the class is defined.
-
-        Returns
-        -------
-        str
-            The module name
-        """
-        return self._concrete.__module__
-
-    def getAttributes(self) -> Dict[str, Any]:
-        """Get all class-level attributes.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary of attribute names and their values
-        """
-        return {
-            k: v for k, v in vars(self._concrete).items()
-            if not callable(v) and not isinstance(v, staticmethod) and not isinstance(v, classmethod) and not k.startswith('_') and not isinstance(v, property)
-        }
-
-    def getMethods(self) -> List[str]:
-        """Get all method names of the class.
-
-        Returns
-        -------
-        List[str]
-            List of method names
-        """
-        return [
-            name for name, member in inspect.getmembers(self._concrete, predicate=inspect.isfunction)
-            if not name.startswith('_')
-        ]
-
-    def getStaticMethods(self) -> List[str]:
-        """Get all static method names of the class.
-
-        Returns
-        -------
-        List[str]
-            List of static method names, excluding private methods
-        """
-        return [
-            name for name in dir(self._concrete)
-            if not name.startswith('_') and isinstance(inspect.getattr_static(self._concrete, name), staticmethod)
-        ]
-
-    def getPropertyNames(self) -> List[str]:
-        """Get all property names of the class.
-
-        Returns
-        -------
-        List[str]
-            List of property names
-        """
-        return [
-            name for name, val in vars(self._concrete).items()
-            if isinstance(val, property)
-        ]
-
-    def getMethodSignature(self, methodName: str) -> inspect.Signature:
-        """Get the signature of a class method.
-
-        Parameters
-        ----------
-        methodName : str
-            Name of the method
-
-        Returns
-        -------
-        inspect.Signature
-            The method signature
-
-        Raises
-        ------
-        AttributeError
-            If the method doesn't exist
-        """
-        method = getattr(self._concrete, methodName)
-        if callable(method):
-            return inspect.signature(method)
-        raise AttributeError(f"{methodName} is not a valid 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
-        """
-        attr = getattr(self._concrete, 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 class.
-
-        Returns
-        -------
-        Optional[str]
-            The class docstring, or None if not available
-        """
-        return self._concrete.__doc__
-
-    def getBaseClasses(self) -> Tuple[Type, ...]:
-        """Get the base classes of the class.
-
-        Returns
-        -------
-        Tuple[Type, ...]
-            Tuple of base classes
-        """
-        return self._concrete.__bases__
-
-    def isSubclassOf(self, cls: Type) -> bool:
-        """Check if the concrete class is a subclass of another.
-
-        Parameters
-        ----------
-        cls : Type
-            The parent class to check against
-
-        Returns
-        -------
-        bool
-            True if the concrete class is a subclass of the given class
-        """
-        return issubclass(self._concrete, cls)
-
-    def getSourceCode(self) -> Optional[str]:
-        """Get the source code of the class.
-
-        Returns
-        -------
-        Optional[str]
-            The source code if available, None otherwise
-        """
-        try:
-            return inspect.getsource(self._concrete)
-        except (TypeError, OSError):
-            return None
-
-    def getFileLocation(self) -> Optional[str]:
-        """Get the file location where the class is defined.
-
-        Returns
-        -------
-        Optional[str]
-            The file path if available, None otherwise
-        """
-        try:
-            return inspect.getfile(self._concrete)
-        except (TypeError, OSError):
-            return None
-
-    def getAnnotations(self) -> Dict[str, Any]:
-        """Get type annotations of the class.
-
-        Returns
-        -------
-        Dict[str, Any]
-            Dictionary of attribute names and their type annotations
-        """
-        return getattr(self._concrete, '__annotations__', {})
-
-    def hasAttribute(self, name: str) -> bool:
-        """Check if the class has a specific attribute.
-
-        Parameters
-        ----------
-        name : str
-            The attribute name to check
-
-        Returns
-        -------
-        bool
-            True if the attribute exists
-        """
-        return hasattr(self._concrete, name)
-
-    def getAttribute(self, name: str) -> Any:
-        """Get a class attribute by name.
-
-        Parameters
-        ----------
-        name : str
-            The attribute name
-
-        Returns
-        -------
-        Any
-            The attribute value
-
-        Raises
-        ------
-        AttributeError
-            If the attribute doesn't exist
-        """
-        return getattr(self._concrete, name)
-
-    def getCallableMembers(self) -> Dict[str, Callable]:
-        """Get all callable members (functions/methods) of the class.
-
-        Returns
-        -------
-        Dict[str, Callable]
-            Dictionary of method names and their callable objects
-        """
-        return {
-            name: member for name, member in inspect.getmembers(
-                self._concrete,
-                callable
-            ) if not name.startswith('__')
-        }

orionis/support/introspection/reflexion_concrete_with_abstract.py

@@ -1,185 +0,0 @@
-import abc
-import inspect
-from typing import Any, Dict, List, Tuple, Type, TypeVar, Union
-from orionis.support.introspection.abstracts.reflect_abstract import ReflexionAbstract
-from orionis.support.introspection.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/support/introspection/reflexion_instance_with_abstract.py

@@ -1,230 +0,0 @@
-import abc
-import inspect
-from typing import Any, Dict, List, Tuple, Type, TypeVar, Union
-from orionis.support.introspection.abstracts.reflect_abstract import ReflexionAbstract
-from orionis.support.introspection.instances.reflection_instance import ReflectionInstance
-
-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 = ReflectionInstance(instance)
-        self._abstract_reflexion = ReflexionAbstract(abstract)
-
-    @property
-    def concrete(self) -> ReflectionInstance:
-        """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