orionis 0.210.0__tar.gz → 0.211.0__tar.gz

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

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

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

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

{orionis-0.210.0 → orionis-0.211.0}/orionis/luminate/support/inspection/functions.py

@@ -2,7 +2,7 @@ from typing import Any, Type
 import inspect
 import importlib
 
-def is_valid_module(module_name: str) -> bool:
+def _is_valid_module(module_name: str) -> bool:
     """Check if a module name is valid and can be imported.
 
     Parameters
@@ -21,7 +21,7 @@ def is_valid_module(module_name: str) -> bool:
     except ImportError:
         return False
 
-def ensure_valid_module(module_name: str) -> None:
+def _ensure_valid_module(module_name: str) -> None:
     """Ensure a module name is valid and can be imported.
 
     Parameters
@@ -36,10 +36,10 @@ def ensure_valid_module(module_name: str) -> None:
     """
     if not isinstance(module_name, str):
         raise TypeError(f"Module name must be a string, got {type(module_name)}")
-    if not is_valid_module(module_name):
+    if not _is_valid_module(module_name):
         raise ValueError(f"Invalid or non-importable module: {module_name}")
 
-def is_instantiable_class(cls: Type) -> bool:
+def _is_instantiable_class(cls: Type) -> bool:
     """Check if a class is concrete and can be instantiated.
 
     Parameters
@@ -54,7 +54,7 @@ def is_instantiable_class(cls: Type) -> bool:
     """
     if not isinstance(cls, type):
         return False
-    if is_abstract_class(cls):
+    if _is_abstract_class(cls):
         return False
     try:
         # Try to create an instance to verify it's truly concrete
@@ -63,7 +63,33 @@ def is_instantiable_class(cls: Type) -> bool:
     except TypeError:
         return False
 
-def ensure_instantiable_class(cls: Type) -> None:
+def _ensure_not_builtin_type(cls: Type) -> None:
+    """Ensure a class is not a built-in or primitive type.
+
+    Parameters
+    ----------
+    cls : Type
+        The class to check
+
+    Raises
+    ------
+    TypeError
+        If the input is not a class
+    ValueError
+        If the class is a built-in or primitive type
+    """
+    if not isinstance(cls, type):
+        raise TypeError(f"Expected a class, got {type(cls)}")
+
+    builtin_types = {
+        int, float, str, bool, bytes, type(None), complex,
+        list, tuple, dict, set, frozenset
+    }
+
+    if cls in builtin_types:
+        raise ValueError(f"Class '{cls.__name__}' is a built-in or primitive type and cannot be used.")
+
+def _ensure_instantiable_class(cls: Type) -> None:
     """Ensure a class is concrete and can be instantiated.
 
     Parameters
@@ -78,16 +104,18 @@ def ensure_instantiable_class(cls: Type) -> None:
     ValueError
         If the class is abstract or cannot be instantiated
     """
+    if _ensure_not_builtin_type(cls):
+        raise TypeError(f"Invalid class: {cls!r}")
     if not isinstance(cls, type):
         raise TypeError(f"Expected a class, got {type(cls)}")
-    if is_abstract_class(cls):
+    if _is_abstract_class(cls):
         raise ValueError(f"Class '{cls.__name__}' is abstract")
     try:
         cls()
     except TypeError as e:
         raise ValueError(f"Class '{cls.__name__}' cannot be instantiated: {str(e)}")
 
-def is_valid_class_name(module_name: str, class_name: str) -> bool:
+def _is_valid_class_name(module_name: str, class_name: str) -> bool:
     """Check if a class exists in a given module.
 
     Parameters
@@ -108,7 +136,7 @@ def is_valid_class_name(module_name: str, class_name: str) -> bool:
     except ImportError:
         return False
 
-def ensure_valid_class_name(module_name: str, class_name: str) -> None:
+def _ensure_valid_class_name(module_name: str, class_name: str) -> None:
     """Ensure a class exists in a given module.
 
     Parameters
@@ -123,10 +151,10 @@ def ensure_valid_class_name(module_name: str, class_name: str) -> None:
     ValueError
         If the class doesn't exist in the module
     """
-    if not is_valid_class_name(module_name, class_name):
+    if not _is_valid_class_name(module_name, class_name):
         raise ValueError(f"Class '{class_name}' not found in module '{module_name}'")
 
-def is_user_defined_class_instance(instance: Any) -> bool:
+def _is_user_defined_class_instance(instance: Any) -> bool:
     """Check if an object is an instance of a user-defined class.
 
     Parameters
@@ -141,7 +169,7 @@ def is_user_defined_class_instance(instance: Any) -> bool:
     """
     return isinstance(instance, object) and type(instance).__module__ not in {'builtins', 'abc', '__main__'}
 
-def ensure_user_defined_class_instance(instance: Any) -> None:
+def _ensure_user_defined_class_instance(instance: Any) -> None:
     """Ensure an object is an instance of a user-defined class.
 
     Parameters
@@ -164,7 +192,7 @@ def ensure_user_defined_class_instance(instance: Any) -> None:
     if module == '__main__':
         raise ValueError("Instance originates from '__main__', origin indeterminate.")
 
-def is_abstract_class(cls: Type) -> bool:
+def _is_abstract_class(cls: Type) -> bool:
     """Check if a class is abstract.
 
     Parameters
@@ -179,7 +207,7 @@ def is_abstract_class(cls: Type) -> bool:
     """
     return isinstance(cls, type) and bool(getattr(cls, '__abstractmethods__', False))
 
-def ensure_abstract_class(cls: Type) -> None:
+def _ensure_abstract_class(cls: Type) -> None:
     """Ensure a class is abstract.
 
     Parameters
@@ -196,10 +224,10 @@ def ensure_abstract_class(cls: Type) -> None:
     """
     if not isinstance(cls, type):
         raise TypeError(f"Invalid class: {cls!r}")
-    if not is_abstract_class(cls):
+    if not _is_abstract_class(cls):
         raise ValueError(f"Class '{cls.__name__}' is not abstract.")
 
-def is_concrete_class(cls: Type) -> bool:
+def _is_concrete_class(cls: Type) -> bool:
     """Check if a class is concrete.
 
     Parameters
@@ -212,9 +240,9 @@ def is_concrete_class(cls: Type) -> bool:
     bool
         True if the class is concrete, False otherwise
     """
-    return isinstance(cls, type) and not is_abstract_class(cls)
+    return isinstance(cls, type) and not _is_abstract_class(cls)
 
-def ensure_concrete_class(cls: Type) -> None:
+def _ensure_concrete_class(cls: Type) -> None:
     """Ensure a class is concrete.
 
     Parameters
@@ -231,5 +259,5 @@ def ensure_concrete_class(cls: Type) -> None:
     """
     if not isinstance(cls, type):
         raise TypeError(f"Invalid class: {cls!r}")
-    if not is_concrete_class(cls):
+    if not _is_concrete_class(cls):
         raise ValueError(f"Class '{cls.__name__}' is not concrete.")

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

@@ -0,0 +1,221 @@
+import abc
+from typing import Any, Type, TypeVar
+from orionis.luminate.support.inspection.functions import (
+    _ensure_abstract_class,
+    _ensure_instantiable_class,
+    _ensure_user_defined_class_instance,
+    _ensure_valid_class_name,
+    _ensure_valid_module,
+)
+from orionis.luminate.support.inspection.reflexion_abstract import ReflexionAbstract
+from orionis.luminate.support.inspection.reflexion_concrete import ReflexionConcrete
+from orionis.luminate.support.inspection.reflexion_concrete_with_abstract import ReflexionConcreteWithAbstract
+from orionis.luminate.support.inspection.reflexion_instance import ReflexionInstance
+from orionis.luminate.support.inspection.reflexion_instance_with_abstract import ReflexionInstanceWithAbstract
+from orionis.luminate.support.inspection.reflexion_module import ReflexionModule
+from orionis.luminate.support.inspection.reflexion_module_with_classname import ReflexionModuleWithClassName
+
+T = TypeVar('T')
+ABC = TypeVar('ABC', bound=abc.ABC)
+
+class Reflection:
+    """A static class providing factory methods for creating reflection objects.
+
+    This class provides methods to create various types of reflection objects
+    that encapsulate different aspects of Python's reflection capabilities.
+    Each method validates its inputs before creating the appropriate reflection object.
+
+    Methods
+    -------
+    instance(instance: Any) -> ReflexionInstance
+        Creates a reflection object for a class instance
+    instanceWithAbstract(instance: Any, abstract: Type[ABC]) -> ReflexionInstanceWithAbstract
+        Creates a reflection object for a class instance with its abstract parent
+    abstract(abstract: Type[ABC]) -> ReflexionAbstract
+        Creates a reflection object for an abstract class
+    concrete(concrete: Type[T]) -> ReflexionConcrete
+        Creates a reflection object for a concrete class
+    concreteWithAbstract(concrete: Type[T], abstract: Type[ABC]) -> ReflexionConcreteWithAbstract
+        Creates a reflection object for a concrete class with its abstract parent
+    module(module: str) -> ReflexionModule
+        Creates a reflection object for a module
+    moduleWithClassName(module: str, class_name: str) -> ReflexionModuleWithClassName
+        Creates a reflection object for a module with a specific class name
+    """
+
+    @staticmethod
+    def instance(instance: Any) -> 'ReflexionInstance':
+        """Create a reflection object for a class instance.
+
+        Parameters
+        ----------
+        instance : Any
+            The instance to reflect upon
+
+        Returns
+        -------
+        ReflexionInstance
+            A reflection object encapsulating the instance
+
+        Raises
+        ------
+        TypeError
+            If the input is not an object instance
+        ValueError
+            If the instance is from builtins, abc, or __main__
+        """
+        _ensure_user_defined_class_instance(instance)
+        return ReflexionInstance(instance)
+
+    @staticmethod
+    def instanceWithAbstract(instance: Any, abstract: Type[ABC]) -> 'ReflexionInstanceWithAbstract':
+        """Create a reflection object for a class instance with its abstract parent.
+
+        Parameters
+        ----------
+        instance : Any
+            The instance to reflect upon
+        abstract : Type[ABC]
+            The abstract parent class
+
+        Returns
+        -------
+        ReflexionInstanceWithAbstract
+            A reflection object encapsulating the instance and its abstract parent
+
+        Raises
+        ------
+        TypeError
+            If the instance is not an object or abstract is not a class
+        ValueError
+            If the instance is invalid or abstract is not actually abstract
+        """
+        _ensure_user_defined_class_instance(instance)
+        _ensure_abstract_class(abstract)
+        return ReflexionInstanceWithAbstract(instance, abstract)
+
+    @staticmethod
+    def abstract(abstract: Type[ABC]) -> 'ReflexionAbstract':
+        """Create a reflection object for an abstract class.
+
+        Parameters
+        ----------
+        abstract : Type[ABC]
+            The abstract class to reflect upon
+
+        Returns
+        -------
+        ReflexionAbstract
+            A reflection object encapsulating the abstract class
+
+        Raises
+        ------
+        TypeError
+            If the input is not a class
+        ValueError
+            If the class is not abstract
+        """
+        _ensure_abstract_class(abstract)
+        return ReflexionAbstract(abstract)
+
+    @staticmethod
+    def concrete(concrete: Type[T]) -> 'ReflexionConcrete':
+        """Create a reflection object for a concrete class.
+
+        Parameters
+        ----------
+        concrete : Type[T]
+            The concrete class to reflect upon
+
+        Returns
+        -------
+        ReflexionConcrete
+            A reflection object encapsulating the concrete class
+
+        Raises
+        ------
+        TypeError
+            If the input is not a class
+        ValueError
+            If the class is abstract or cannot be instantiated
+        """
+        _ensure_instantiable_class(concrete)
+        return ReflexionConcrete(concrete)
+
+    @staticmethod
+    def concreteWithAbstract(concrete: Type[T], abstract: Type[ABC]) -> 'ReflexionConcreteWithAbstract':
+        """Create a reflection object for a concrete class with its abstract parent.
+
+        Parameters
+        ----------
+        concrete : Type[T]
+            The concrete class to reflect upon
+        abstract : Type[ABC]
+            The abstract parent class
+
+        Returns
+        -------
+        ReflexionConcreteWithAbstract
+            A reflection object encapsulating the concrete class and its abstract parent
+
+        Raises
+        ------
+        TypeError
+            If either input is not a class
+        ValueError
+            If concrete is not instantiable or abstract is not actually abstract
+        """
+        _ensure_instantiable_class(concrete)
+        _ensure_abstract_class(abstract)
+        return ReflexionConcreteWithAbstract(concrete, abstract)
+
+    @staticmethod
+    def module(module: str) -> 'ReflexionModule':
+        """Create a reflection object for a module.
+
+        Parameters
+        ----------
+        module : str
+            The module name to reflect upon
+
+        Returns
+        -------
+        ReflexionModule
+            A reflection object encapsulating the module
+
+        Raises
+        ------
+        TypeError
+            If the input is not a string
+        ValueError
+            If the module cannot be imported
+        """
+        _ensure_valid_module(module)
+        return ReflexionModule(module)
+
+    @staticmethod
+    def moduleWithClassName(module: str, class_name: str) -> 'ReflexionModuleWithClassName':
+        """Create a reflection object for a module with a specific class name.
+
+        Parameters
+        ----------
+        module : str
+            The module name to reflect upon
+        class_name : str
+            The class name to look for in the module
+
+        Returns
+        -------
+        ReflexionModuleWithClassName
+            A reflection object encapsulating the module and class name
+
+        Raises
+        ------
+        TypeError
+            If either input is not a string
+        ValueError
+            If the module cannot be imported or the class doesn't exist in it
+        """
+        _ensure_valid_module(module)
+        _ensure_valid_class_name(module, class_name)
+        return ReflexionModuleWithClassName(module, class_name)

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

@@ -0,0 +1,276 @@
+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-0.210.0 → orionis-0.211.0/orionis.egg-info}/PKG-INFO

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