orionis 0.200.0__py3-none-any.whl → 0.202.0__py3-none-any.whl

orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py

@@ -0,0 +1,31 @@
+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
+
+

orionis/luminate/support/inspection/reflexion_instance.py

@@ -0,0 +1,364 @@
+from typing import Any, Type, Dict, List, Tuple, Callable, Optional
+import inspect
+
+class ReflexionInstance:
+    """A reflection object encapsulating a class instance.
+
+    Parameters
+    ----------
+    instance : Any
+        The instance being reflected upon
+
+    Attributes
+    ----------
+    _instance : Any
+        The encapsulated instance
+    """
+
+    def __init__(self, instance: Any) -> None:
+        """Initialize with the instance to reflect upon."""
+        self._instance = instance
+
+    def getClassName(self) -> str:
+        """Get the name of the instance's class.
+
+        Returns
+        -------
+        str
+            The name of the class
+
+        Examples
+        --------
+        >>> obj = SomeClass()
+        >>> reflex = ReflexionInstance(obj)
+        >>> reflex.getClassName()
+        'SomeClass'
+        """
+        return self._instance.__class__.__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._instance.__class__
+
+    def getModuleName(self) -> str:
+        """Get the name of the module where the class is defined.
+
+        Returns
+        -------
+        str
+            The module name
+
+        Examples
+        --------
+        >>> reflex.getModuleName()
+        'some_module'
+        """
+        return self._instance.__class__.__module__
+
+    def getAttributes(self) -> Dict[str, Any]:
+        """Get all attributes of the instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their values
+
+        Examples
+        --------
+        >>> reflex.getAttributes()
+        {'attr1': value1, 'attr2': value2}
+        """
+        return vars(self._instance)
+
+    def getMethods(self) -> List[str]:
+        """Get all method names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of method names
+
+        Examples
+        --------
+        >>> reflex.getMethods()
+        ['method1', 'method2']
+        """
+        return [name for name, _ in inspect.getmembers(
+            self._instance,
+            predicate=inspect.ismethod
+        )]
+
+    def getPropertyNames(self) -> List[str]:
+        """Get all property names of the instance.
+
+        Returns
+        -------
+        List[str]
+            List of property names
+
+        Examples
+        --------
+        >>> reflex.getPropertyNames()
+        ['prop1', 'prop2']
+        """
+        return [name for name, _ in inspect.getmembers(
+            self._instance.__class__,
+            lambda x: isinstance(x, property)
+        )]
+
+    def callMethod(self, methodName: str, *args: Any, **kwargs: Any) -> Any:
+        """Call a method on the instance.
+
+        Parameters
+        ----------
+        methodName : str
+            Name of the method to call
+        *args : Any
+            Positional arguments for the method
+        **kwargs : Any
+            Keyword arguments for the method
+
+        Returns
+        -------
+        Any
+            The return value of the method
+
+        Raises
+        ------
+        AttributeError
+            If the method doesn't exist
+
+        Examples
+        --------
+        >>> reflex.callMethod('calculate', 2, 3)
+        5
+        """
+        method = getattr(self._instance, methodName)
+        return method(*args, **kwargs)
+
+    def getMethodSignature(self, methodName: str) -> inspect.Signature:
+        """Get the signature of a method.
+
+        Parameters
+        ----------
+        methodName : str
+            Name of the method
+
+        Returns
+        -------
+        inspect.Signature
+            The method signature
+
+        Raises
+        ------
+        AttributeError
+            If the method doesn't exist
+
+        Examples
+        --------
+        >>> sig = reflex.getMethodSignature('calculate')
+        >>> str(sig)
+        '(x, y)'
+        """
+        method = getattr(self._instance, methodName)
+        return inspect.signature(method)
+
+    def getDocstring(self) -> Optional[str]:
+        """Get the docstring of the instance's class.
+
+        Returns
+        -------
+        Optional[str]
+            The class docstring, or None if not available
+
+        Examples
+        --------
+        >>> reflex.getDocstring()
+        'This class does something important.'
+        """
+        return self._instance.__class__.__doc__
+
+    def getBaseClasses(self) -> Tuple[Type, ...]:
+        """Get the base classes of the instance's class.
+
+        Returns
+        -------
+        Tuple[Type, ...]
+            Tuple of base classes
+
+        Examples
+        --------
+        >>> reflex.getBaseClasses()
+        (<class 'object'>,)
+        """
+        return self._instance.__class__.__bases__
+
+    def isInstanceOf(self, cls: Type) -> bool:
+        """Check if the instance is of a specific class.
+
+        Parameters
+        ----------
+        cls : Type
+            The class to check against
+
+        Returns
+        -------
+        bool
+            True if the instance is of the specified class
+
+        Examples
+        --------
+        >>> reflex.isInstanceOf(SomeClass)
+        True
+        """
+        return isinstance(self._instance, cls)
+
+    def getSourceCode(self) -> Optional[str]:
+        """Get the source code of the instance's class.
+
+        Returns
+        -------
+        Optional[str]
+            The source code if available, None otherwise
+
+        Examples
+        --------
+        >>> print(reflex.getSourceCode())
+        class SomeClass:
+            def __init__(self):
+                ...
+        """
+        try:
+            return inspect.getsource(self._instance.__class__)
+        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
+
+        Examples
+        --------
+        >>> reflex.getFileLocation()
+        '/path/to/module.py'
+        """
+        try:
+            return inspect.getfile(self._instance.__class__)
+        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
+
+        Examples
+        --------
+        >>> reflex.getAnnotations()
+        {'name': str, 'value': int}
+        """
+        return self._instance.__class__.__annotations__
+
+    def hasAttribute(self, name: str) -> bool:
+        """Check if the instance has a specific attribute.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name to check
+
+        Returns
+        -------
+        bool
+            True if the attribute exists
+
+        Examples
+        --------
+        >>> reflex.hasAttribute('important_attr')
+        True
+        """
+        return hasattr(self._instance, name)
+
+    def getAttribute(self, name: str) -> Any:
+        """Get an attribute value by name.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+
+        Returns
+        -------
+        Any
+            The attribute value
+
+        Raises
+        ------
+        AttributeError
+            If the attribute doesn't exist
+
+        Examples
+        --------
+        >>> reflex.getAttribute('count')
+        42
+        """
+        return getattr(self._instance, name)
+
+    def setAttribute(self, name: str, value: Any) -> None:
+        """Set an attribute value.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+        value : Any
+            The value to set
+
+        Raises
+        ------
+        AttributeError
+            If the attribute is read-only
+
+        Examples
+        --------
+        >>> reflex.setAttribute('count', 100)
+        """
+        setattr(self._instance, name, value)
+
+    def getCallableMembers(self) -> Dict[str, Callable]:
+        """Get all callable members (methods) of the instance.
+
+        Returns
+        -------
+        Dict[str, Callable]
+            Dictionary of method names and their callable objects
+
+        Examples
+        --------
+        >>> reflex.getCallableMembers()
+        {'calculate': <bound method SomeClass.calculate>, ...}
+        """
+        return {
+            name: member for name, member in inspect.getmembers(
+                self._instance,
+                callable
+            ) if not name.startswith('__')
+        }

orionis/luminate/support/inspection/reflexion_instance_with_abstract.py

@@ -0,0 +1,309 @@
+from typing import Any, Type, Dict, List, Tuple, Callable, Optional, Set, TypeVar
+import inspect
+import abc
+
+T = TypeVar('T')
+ABC = TypeVar('ABC', bound=abc.ABC)
+
+class ReflexionInstanceWithAbstract:
+    """A reflection object encapsulating a class instance and its abstract parent.
+
+    This class provides methods to inspect both the concrete instance and its
+    abstract parent class, including their relationships and implementations.
+
+    Parameters
+    ----------
+    instance : Any
+        The instance being reflected upon
+    abstract : Type[ABC]
+        The abstract parent class
+
+    Attributes
+    ----------
+    _instance : Any
+        The encapsulated instance
+    _abstract : Type[ABC]
+        The encapsulated abstract parent class
+    """
+
+    def __init__(self, instance: Any, abstract: Type[ABC]) -> None:
+        """Initialize with the instance and abstract parent."""
+        self._instance = instance
+        self._abstract = 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
+        }
+
+    def getMissingImplementations(self) -> Set[str]:
+        """Get abstract methods not implemented by the concrete class.
+
+        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.
+
+        Returns
+        -------
+        bool
+            True if all abstract methods are implemented, False otherwise
+        """
+        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()
+
+        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)
+
+        return overridden
+
+    def checkSignatureCompatibility(self) -> Dict[str, bool]:
+        """Check if implemented methods match abstract signatures.
+
+        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.
+
+        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())
+            )
+        }
+
+    def getInstanceAttributes(self) -> Dict[str, Any]:
+        """Get all attributes of the concrete instance.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their values
+        """
+        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__
+
+    def getAbstractClassHierarchy(self) -> List[Type]:
+        """Get the inheritance hierarchy of the abstract class.
+
+        Returns
+        -------
+        List[Type]
+            List of classes in the inheritance hierarchy
+        """
+        return inspect.getmro(self._abstract)
+
+    def getConcreteClassHierarchy(self) -> List[Type]:
+        """Get the inheritance hierarchy of the concrete class.
+
+        Returns
+        -------
+        List[Type]
+            List of classes in the inheritance hierarchy
+        """
+        return inspect.getmro(self._instance.__class__)
+
+    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.
+
+        Returns
+        -------
+        Optional[str]
+            The source code if available, None otherwise
+        """
+        try:
+            return inspect.getsource(self._instance.__class__)
+        except (TypeError, OSError):
+            return None
+
+    def getAbstractClassFile(self) -> Optional[str]:
+        """Get the file location of the abstract class definition.
+
+        Returns
+        -------
+        Optional[str]
+            The file path if available, None otherwise
+        """
+        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.
+
+        Returns
+        -------
+        Optional[str]
+            The file path if available, None otherwise
+        """
+        try:
+            return inspect.getfile(self._instance.__class__)
+        except (TypeError, OSError):
+            return None