orionis 0.210.0__py3-none-any.whl → 0.211.0__py3-none-any.whl

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/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/luminate/support/inspection/reflection.py

@@ -1,11 +1,11 @@
 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,
+    _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
@@ -64,7 +64,7 @@ class Reflection:
         ValueError
             If the instance is from builtins, abc, or __main__
         """
-        ensure_user_defined_class_instance(instance)
+        _ensure_user_defined_class_instance(instance)
         return ReflexionInstance(instance)
 
     @staticmethod
@@ -90,8 +90,8 @@ class Reflection:
         ValueError
             If the instance is invalid or abstract is not actually abstract
         """
-        ensure_user_defined_class_instance(instance)
-        ensure_abstract_class(abstract)
+        _ensure_user_defined_class_instance(instance)
+        _ensure_abstract_class(abstract)
         return ReflexionInstanceWithAbstract(instance, abstract)
 
     @staticmethod
@@ -115,7 +115,7 @@ class Reflection:
         ValueError
             If the class is not abstract
         """
-        ensure_abstract_class(abstract)
+        _ensure_abstract_class(abstract)
         return ReflexionAbstract(abstract)
 
     @staticmethod
@@ -139,7 +139,7 @@ class Reflection:
         ValueError
             If the class is abstract or cannot be instantiated
         """
-        ensure_instantiable_class(concrete)
+        _ensure_instantiable_class(concrete)
         return ReflexionConcrete(concrete)
 
     @staticmethod
@@ -165,8 +165,8 @@ class Reflection:
         ValueError
             If concrete is not instantiable or abstract is not actually abstract
         """
-        ensure_instantiable_class(concrete)
-        ensure_abstract_class(abstract)
+        _ensure_instantiable_class(concrete)
+        _ensure_abstract_class(abstract)
         return ReflexionConcreteWithAbstract(concrete, abstract)
 
     @staticmethod
@@ -190,7 +190,7 @@ class Reflection:
         ValueError
             If the module cannot be imported
         """
-        ensure_valid_module(module)
+        _ensure_valid_module(module)
         return ReflexionModule(module)
 
     @staticmethod
@@ -216,434 +216,6 @@ class Reflection:
         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)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    # def __inidt__(self,
-    #     instance: Any = None, # Instancia ya creada de una clase
-    #     concrete: Callable[..., Any] = None, # Clase concreta a instanciar
-    #     abstract: Callable[..., Any] = None,    # Clase abstracta a implementar en clases hijas
-    #     module: str = None, # Módulo donde se encuentra la clase
-    #     class_name: str = None # Nombre de la clase
-    # ):
-
-    #     # Garantizar que al menos un argumento sea proporcionado
-    #     if not any([abstract, concrete, module, class_name]):
-    #         raise ValueError("At least one argument must be provided.")
-
-
-    #     # Validar que 'abstract' y 'concrete' sean callables
-    #     if abstract and not callable(abstract):
-    #         raise TypeError("The 'abstract' argument must be callable.")
-    #     if concrete and not callable(concrete):
-    #         raise TypeError("The 'concrete' argument must be callable.")
-
-    #     # Validar que si se proporciona una clase, también se proporcione el módulo
-    #     if class_name and not module:
-    #         raise ValueError("If a class name is provided, a module name must also be provided.")
-
-    #     # Validar que el módulo exista e importarlo
-    #     if module:
-    #         try:
-    #             self._module = importlib.import_module(module)
-    #         except ModuleNotFoundError:
-    #             raise ValueError(f"Module '{module}' not found.")
-
-    #     # Validar que la clase exista en el módulo
-    #     if module and class_name:
-    #         if not hasattr(self._module, class_name):
-    #             raise ValueError(f"Class '{class_name}' not found in module '{module}'.")
-
-    #     # Validar que la clase no sea abstracta antes de instanciarla
-    #     if concrete and inspect.isabstract(concrete):
-    #         raise TypeError(f"Cannot instantiate abstract class '{concrete.__name__}'.")
-
-
-    # def safeImport(self):
-    #     """
-    #     Safely imports the specified module and assigns the class object if a classname is provided.
-
-    #     This method raises a ValueError if the module cannot be imported or if the class does not exist
-    #     within the module.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If the module cannot be imported or the class does not exist in the module.
-    #     """
-    #     try:
-    #         module = importlib.import_module(self.module_name)
-    #         if self.classname:
-    #             self.cls = getattr(module, self.classname, None)
-    #             if self.cls is None:
-    #                 raise ValueError(f"Class '{self.classname}' not found in module '{self.module_name}'.")
-    #     except ImportError as e:
-    #         raise ValueError(f"Error importing module '{self.module_name}': {e}")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    # def getFile(self) -> str:
-    #     """
-    #     Retrieves the file path where the class is defined.
-
-    #     Returns
-    #     -------
-    #     str
-    #         The file path if the class is found, otherwise raises an error.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If the class has not been loaded yet.
-    #     """
-    #     if not self.cls:
-    #         raise ValueError("Class not loaded. Use 'safeImport()' first.")
-    #     return inspect.getfile(self.cls)
-
-    # def hasClass(self) -> bool:
-    #     """
-    #     Checks whether the class object is available.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is loaded, False otherwise.
-    #     """
-    #     return self.cls is not None
-
-    # def hasMethod(self, method_name: str) -> bool:
-    #     """
-    #     Checks whether the specified method exists in the class.
-
-    #     Parameters
-    #     ----------
-    #     method_name : str
-    #         The name of the method to check.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the method exists, False otherwise.
-    #     """
-    #     return hasattr(self.cls, method_name) if self.cls else False
-
-    # def hasProperty(self, prop: str) -> bool:
-    #     """
-    #     Checks whether the specified property exists in the class.
-
-    #     Parameters
-    #     ----------
-    #     prop : str
-    #         The name of the property to check.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the property exists, False otherwise.
-    #     """
-    #     return hasattr(self.cls, prop) if self.cls else False
-
-    # def hasConstant(self, constant: str) -> bool:
-    #     """
-    #     Checks whether the specified constant exists in the class.
-
-    #     Parameters
-    #     ----------
-    #     constant : str
-    #         The name of the constant to check.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the constant exists, False otherwise.
-    #     """
-    #     return hasattr(self.cls, constant) if self.cls else False
-
-    # def getAttributes(self) -> List[str]:
-    #     """
-    #     Retrieves a list of all attributes (including methods and properties) of the class.
-
-    #     Returns
-    #     -------
-    #     list
-    #         A list of attribute names in the class.
-    #     """
-    #     return dir(self.cls) if self.cls else []
-
-    # def getConstructor(self):
-    #     """
-    #     Retrieves the constructor (__init__) of the class.
-
-    #     Returns
-    #     -------
-    #     function or None
-    #         The constructor method if available, otherwise None.
-    #     """
-    #     return self.cls.__init__ if self.cls else None
-
-    # def getDocComment(self) -> Optional[str]:
-    #     """
-    #     Retrieves the docstring of the class.
-
-    #     Returns
-    #     -------
-    #     str or None
-    #         The docstring of the class if available, otherwise None.
-    #     """
-    #     if not self.cls:
-    #         raise ValueError("Class not loaded. Use 'safeImport()' first.")
-    #     return self.cls.__doc__
-
-    # def getFileName(self, remove_extension: bool = False) -> str:
-    #     """
-    #     Retrieves the file name where the class is defined, the same as `get_file()`.
-
-    #     Parameters
-    #     ----------
-    #     remove_extension : bool, optional
-    #         If True, the file extension will be removed from the filename. Default is False.
-
-    #     Returns
-    #     -------
-    #     str
-    #         The file name of the class definition.
-    #     """
-    #     file_name = os.path.basename(self.getFile())
-    #     if remove_extension:
-    #         file_name = os.path.splitext(file_name)[0]
-    #     return file_name
-
-    # def getMethod(self, method_name: str):
-    #     """
-    #     Retrieves the specified method from the class.
-
-    #     Parameters
-    #     ----------
-    #     method_name : str
-    #         The name of the method to retrieve.
-
-    #     Returns
-    #     -------
-    #     function or None
-    #         The method if it exists, otherwise None.
-    #     """
-    #     return getattr(self.cls, method_name, None) if self.cls else None
-
-    # def getMethods(self) -> List[str]:
-    #     """
-    #     Retrieves a list of all methods in the class.
-
-    #     Returns
-    #     -------
-    #     list
-    #         A list of method names in the class.
-    #     """
-    #     return [method for method, _ in inspect.getmembers(self.cls, predicate=inspect.isfunction)] if self.cls else []
-
-    # def getName(self) -> str:
-    #     """
-    #     Retrieves the name of the class.
-
-    #     Returns
-    #     -------
-    #     str or None
-    #         The name of the class if available, otherwise None.
-    #     """
-    #     return self.cls.__name__ if self.cls else None
-
-    # def getParentClass(self) -> Optional[tuple]:
-    #     """
-    #     Retrieves the parent classes (base classes) of the class.
-
-    #     Returns
-    #     -------
-    #     tuple or None
-    #         A tuple of base classes if available, otherwise None.
-    #     """
-    #     return self.cls.__bases__ if self.cls else None
-
-    # def getProperties(self) -> List[str]:
-    #     """
-    #     Retrieves a list of all properties of the class.
-
-    #     Returns
-    #     -------
-    #     list
-    #         A list of property names in the class.
-    #     """
-    #     return [name for name, value in inspect.getmembers(self.cls, lambda x: isinstance(x, property))] if self.cls else []
-
-    # def getProperty(self, prop: str):
-    #     """
-    #     Retrieves the specified property from the class.
-
-    #     Parameters
-    #     ----------
-    #     prop : str
-    #         The name of the property to retrieve.
-
-    #     Returns
-    #     -------
-    #     property or None
-    #         The property if it exists, otherwise None.
-    #     """
-    #     return getattr(self.cls, prop, None) if self.cls else None
-
-    # def isAbstract(self) -> bool:
-    #     """
-    #     Checks whether the class is abstract.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is abstract, False otherwise.
-    #     """
-    #     return hasattr(self.cls, '__abstractmethods__') and bool(self.cls.__abstractmethods__) if self.cls else False
-
-    # def isEnum(self) -> bool:
-    #     """
-    #     Checks whether the class is an enumeration.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is a subclass of Enum, False otherwise.
-    #     """
-    #     return self.cls is not None and isinstance(self.cls, type) and issubclass(self.cls, Enum)
-
-    # def isSubclassOf(self, parent: type) -> bool:
-    #     """
-    #     Checks whether the class is a subclass of the specified parent class.
-
-    #     Parameters
-    #     ----------
-    #     parent : type
-    #         The parent class to check against.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is a subclass of the parent, False otherwise.
-    #     """
-    #     return self.cls is not None and issubclass(self.cls, parent)
-
-    # def isInstanceOf(self, instance: Any) -> bool:
-    #     """
-    #     Checks whether the class is an instance of the specified class.
-
-    #     Parameters
-    #     ----------
-    #     parent : type
-    #         The class to check against.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is a subclass of the parent, False otherwise.
-    #     """
-    #     return self.cls is not None and isinstance(instance, self.cls)
-
-    # def isIterable(self) -> bool:
-    #     """
-    #     Checks whether the class is iterable.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is iterable, False otherwise.
-    #     """
-    #     return hasattr(self.cls, '__iter__') if self.cls else False
-
-    # def isInstantiable(self) -> bool:
-    #     """
-    #     Checks whether the class can be instantiated.
-
-    #     Returns
-    #     -------
-    #     bool
-    #         True if the class is callable and not abstract, False otherwise.
-    #     """
-    #     return self.cls is not None and callable(self.cls) and not self.isAbstract()
-
-    # def newInstance(self, *args, **kwargs):
-    #     """
-    #     Creates a new instance of the class if it is instantiable.
-
-    #     Parameters
-    #     ----------
-    #     args : tuple
-    #         Arguments to pass to the class constructor.
-    #     kwargs : dict
-    #         Keyword arguments to pass to the class constructor.
-
-    #     Returns
-    #     -------
-    #     object
-    #         A new instance of the class.
-
-    #     Raises
-    #     ------
-    #     TypeError
-    #         If the class is not instantiable.
-    #     """
-    #     if self.isInstantiable():
-    #         return self.cls(*args, **kwargs)
-    #     raise TypeError(f"Cannot instantiate class '{self.classname}'. It may be abstract or not callable.")
-
-    # def __str__(self) -> str:
-    #     """
-    #     Returns a string representation of the Reflection instance.
-
-    #     Returns
-    #     -------
-    #     str
-    #         A string describing the class and module.
-    #     """
-    #     status = "loaded" if self.cls else "not loaded"
-    #     return f"<Orionis Reflection class '{self.classname}' in module '{self.module_name}' ({status})>"
+        _ensure_valid_module(module)
+        _ensure_valid_class_name(module, class_name)
+        return ReflexionModuleWithClassName(module, class_name)

orionis/luminate/support/inspection/reflexion_concrete.py

@@ -1,8 +1,7 @@
-from typing import Type, TypeVar
-import abc
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar
+import inspect
 
 T = TypeVar('T')
-ABC = TypeVar('ABC', bound=abc.ABC)
 
 class ReflexionConcrete:
     """A reflection object encapsulating a concrete class.
@@ -22,3 +21,256 @@ class ReflexionConcrete:
         """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.dist-info → orionis-0.211.0.dist-info}/METADATA

@@ -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.dist-info → orionis-0.211.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console.py,sha256=4gYWxf0fWYgJ4RKwARvnTPh06FL3GJ6SAZ7R2NzOICw,1342
-orionis/framework.py,sha256=ktf77HKAC_3ZhF5oKg7CiAVmLkW_QmL_xrrzI7grIKU,1469
+orionis/framework.py,sha256=fQ-g3NY9vLGmARML0s4UR0hYWEnxbuoim-HbOhJ-rYA,1469
 orionis/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/installer/manager.py,sha256=Li4TVziRXWfum02xNG4JHwbnLk-u8xzHjdqKz-D894k,2755
 orionis/installer/output.py,sha256=7O9qa2xtXMB_4ZvVi-Klneom9YazwygAd_4uYAoxhbU,8548
@@ -167,10 +167,10 @@ orionis/luminate/support/reflection.py,sha256=TbWZ_cer0PXrPlwCYFbUJRymlzYxXT0E4C
 orionis/luminate/support/std.py,sha256=TqrgMxF_i5ubYGT5LOvHCH7HOHNmI8CE1kG9pNoSniY,1390
 orionis/luminate/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/inspection/container_integrity.py,sha256=6d9FsGk-Rm1AXgqBS3Nww49dR7n1ptXTTNyGUuBHgNY,10111
-orionis/luminate/support/inspection/functions.py,sha256=XVDLdygONcfDNlH7CZ6muNdtYHLgNp5RybqC3smL4Y4,6400
-orionis/luminate/support/inspection/reflection.py,sha256=x_UHBY9pBSKgct13-u1WbhoONqLoGG60OpgoCsKE0AI,20368
+orionis/luminate/support/inspection/functions.py,sha256=4wDT7iNp-5l4vuHk0UsIxN9wakASJRD4V0KY24uMDzk,7227
+orionis/luminate/support/inspection/reflection.py,sha256=mOCamaKv1ED-Q60_01HMzsCAhoCFeDK7ZqYZ3iYepsM,7716
 orionis/luminate/support/inspection/reflexion_abstract.py,sha256=U_VAGQN0ZDMgjxYPhNrLxFt6F8_-8zXcA_B5djTV4GE,10731
-orionis/luminate/support/inspection/reflexion_concrete.py,sha256=0WOlLeTWLwMeAUReoaJetqlnT1_TxW_jMnbk_yXRR0g,549
+orionis/luminate/support/inspection/reflexion_concrete.py,sha256=1ISuy2L6Oser-EhmpuGALmbauh7Z-X8Rx1YYgt5CabQ,7543
 orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=ZuAFoSPkgbOFMIbVR0hvlkKsm1dIpY1_bsXxZxvXcmU,801
 orionis/luminate/support/inspection/reflexion_instance.py,sha256=LNAgw4sZvHT7UMiObHTGk7xgqpIeKYHAQRgRpuPfEas,10842
 orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=PI_VSH8baxjPgheOYc9tQAlLq9mjxGm5zCOr-bLVksg,9406
@@ -199,15 +199,17 @@ tests/example/test_example.py,sha256=8EYjl1b-J_479dmJdQoAcKCKr7JUydW7EmPQpeiF13Y
 tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/test_reflection_abstract.py,sha256=K78avxUlI_dYKofSvVcuaVLAz-CivWSe3RkhrO-IRcA,9185
-tests/support/inspection/test_reflection_instance.py,sha256=qwYu_y3wiZzhegrRo97r1bWxW2YGxDdnnU-Hq4lZtAE,6930
-tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RNLf9RfRtM2nTY6Yfc8rPibSEVZkl8Pw2w962vsragk,4048
+tests/support/inspection/test_reflection_concrete.py,sha256=dvO7dduJMCsioCxZ5i2WW6V5-3z5LR6gIgGvBGaQcNI,6542
+tests/support/inspection/test_reflection_instance.py,sha256=iwwf-QY-O3kR_HTHdATUnu9iXn6Nat7d8Y8Hxhwfpb0,6938
+tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RQkw2BYY8TLuk6h_9NIa_5JfRL7RG8004ro252t6YF8,4059
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/fakes/fake_reflection_abstract.py,sha256=7qtz44brfFzE4oNYi9kIsvdWP79nP2FnzSz-0bU__pg,5045
+tests/support/inspection/fakes/fake_reflection_concrete.py,sha256=j6gzsxE3xq5oJ30H_Hm1RsUwEY3jOYBu4sclxtD1ayo,1047
 tests/support/inspection/fakes/fake_reflection_instance.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
-orionis-0.210.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.210.0.dist-info/METADATA,sha256=lDNgDlBv95FLobuXCOJdgmXaXKt4SA5NkDmViO8yI1w,3003
-orionis-0.210.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.210.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.210.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.210.0.dist-info/RECORD,,
+orionis-0.211.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.211.0.dist-info/METADATA,sha256=Ib0VcpsiPdguGw9JroLhcBWsSoboYQRHUFUpVbUD1GU,3003
+orionis-0.211.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.211.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.211.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.211.0.dist-info/RECORD,,

tests/support/inspection/fakes/fake_reflection_concrete.py

@@ -0,0 +1,44 @@
+class BaseExample:
+    """Base class to test inheritance."""
+
+    def baseMethod(self) -> str:
+        return "Base method called"
+
+class FakeExample(BaseExample):
+    """This is a fake example class for testing reflection."""
+
+    class_attr: int = 42
+    another_attr = "hello"
+
+    def __init__(self, value: int = 10) -> None:
+        self.instance_attr = value
+
+    @property
+    def prop(self) -> int:
+        """A read-only property returning a fixed number."""
+        return 10
+
+    @property
+    def prop_with_getter(self) -> str:
+        return "read-only"
+
+    def method_one(self, x: int) -> int:
+        return x * 2
+
+    def method_two(self, a: str, b: str = "default") -> str:
+        return a + b
+
+    @staticmethod
+    def static_method() -> str:
+        return "I am static"
+
+    @staticmethod
+    def _private_static():
+        pass
+
+    @classmethod
+    def class_method(cls) -> str:
+        return f"I am class method of {cls.__name__}"
+
+    def _private_method(self):
+        pass

tests/support/inspection/test_reflection_concrete.py

@@ -0,0 +1,139 @@
+from orionis.luminate.support.inspection.reflection import Reflection
+from orionis.luminate.support.inspection.reflexion_concrete import ReflexionConcrete
+from orionis.luminate.test.test_case import TestCase
+from tests.support.inspection.fakes.fake_reflection_concrete import BaseExample, FakeExample
+
+class TestReflectionConcrete(TestCase):
+    """
+    Unit tests for the Reflection class.
+    """
+
+    def testReflectionConcreteExceptionValueError(self):
+        """Ensure Reflection.instance raises ValueError for invalid types."""
+        with self.assertRaises(ValueError):
+            Reflection.concrete(str)
+
+    def testReflectionConcrete(self):
+        """Verify Reflection.instance returns an instance of ReflexionInstance."""
+        self.assertIsInstance(Reflection.concrete(FakeExample), ReflexionConcrete)
+
+    def testReflectionConcreteGetClassName(self):
+        """Test getClassName method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getClassName(), "FakeExample")
+
+    def testReflectionConcreteGetClass(self):
+        """Test getClass method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getClass(), FakeExample)
+
+    def testReflectionConcreteGetModuleName(self):
+        """Test getModuleName method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getModuleName(), "tests.support.inspection.fakes.fake_reflection_concrete")
+
+    def testReflectionConcreteGetAttributes(self):
+        """Test getAttributes method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getAttributes(), {'class_attr': 42, 'another_attr': 'hello'})
+
+    def testReflectionConcreteGetMethods(self):
+        """Test getMethods method."""
+        reflection = Reflection.concrete(FakeExample)
+        expected_methods = [
+            'baseMethod',
+            'method_one',
+            'method_two',
+            'static_method',
+        ]
+        self.assertEqual(reflection.getMethods(), expected_methods)
+
+    def testReflectionConcreteGetStaticMethods(self):
+        """Test getStaticMethods method."""
+        reflection = Reflection.concrete(FakeExample)
+        expected_static_methods = [
+            'static_method'
+        ]
+        self.assertEqual(reflection.getStaticMethods(), expected_static_methods)
+
+    def testReflectionConcreteGetPropertyNames(self):
+        """Test getPropertyNames method."""
+        reflection = Reflection.concrete(FakeExample)
+        expected_properties = [
+            'prop',
+            'prop_with_getter',
+        ]
+        self.assertEqual(reflection.getPropertyNames(), expected_properties)
+
+    def testReflectionConcreteGetMethodSignature(self):
+        """Test getMethodSignature method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(str(reflection.getMethodSignature('method_one')), '(self, x: int) -> int')
+        self.assertEqual(str(reflection.getMethodSignature('method_two')), '(self, a: str, b: str = \'default\') -> str')
+        self.assertEqual(str(reflection.getMethodSignature('__init__')), '(self, value: int = 10) -> None')
+
+    def testReflectionConcreteGetPropertySignature(self):
+        """Test getPropertySignature method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(str(reflection.getPropertySignature('prop')), '(self) -> int')
+        self.assertEqual(str(reflection.getPropertySignature('prop_with_getter')), '(self) -> str')
+
+    def testReflectionConcreteGetDocstring(self):
+        """Test getDocstring method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertIn('This is a fake example class for testing reflection', reflection.getDocstring())
+
+    def testReflectionConcreteGetBaseClasses(self):
+        """Test getBaseClasses method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getBaseClasses(), (BaseExample,))
+
+    def testReflectionConcreteIsSubclassOf(self):
+        """Test isSubclassOf method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertTrue(reflection.isSubclassOf(BaseExample))
+        self.assertFalse(reflection.isSubclassOf(str))
+
+    def testReflectionConcreteGetSourceCode(self):
+        """Test getSourceCode method."""
+        reflection = Reflection.concrete(FakeExample)
+        source_code = reflection.getSourceCode()
+        self.assertIn('class FakeExample(BaseExample):', source_code)
+        self.assertIn('def method_one(self, x: int) -> int:', source_code)
+
+    def testReflectionConcreteGetFileLocation(self):
+        """Test getFileLocation method."""
+        reflection = Reflection.concrete(FakeExample)
+        file_location = reflection.getFileLocation()
+        self.assertIn('fake_reflection_concrete.py', file_location)
+        self.assertIn('tests\\support\\inspection\\fakes', file_location)
+
+    def testReflectionConcreteGetAnnotations(self):
+        """Test getAnnotations method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getAnnotations(), {'class_attr': int})
+
+    def testReflectionConcreteHasAttribute(self):
+        """Test hasAttribute method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertTrue(reflection.hasAttribute('class_attr'))
+        self.assertFalse(reflection.hasAttribute('non_existent_attr'))
+
+    def testReflectionConcreteGetAttribute(self):
+        """Test getAttribute method."""
+        reflection = Reflection.concrete(FakeExample)
+        self.assertEqual(reflection.getAttribute('class_attr'), 42)
+        with self.assertRaises(AttributeError):
+            reflection.getAttribute('non_existent_attr')
+
+    def testReflectionConcreteGetCallableMembers(self):
+        """Test getCallableMembers method."""
+        reflection = Reflection.concrete(FakeExample)
+        callable_members = reflection.getCallableMembers()
+        self.assertIn('_private_method', callable_members)
+        self.assertIn('_private_static', callable_members)
+        self.assertIn('baseMethod', callable_members)
+        self.assertIn('class_method', callable_members)
+        self.assertIn('method_one', callable_members)
+        self.assertIn('method_two', callable_members)
+        self.assertIn('static_method', callable_members)

tests/support/inspection/test_reflection_instance.py

@@ -3,7 +3,7 @@ from orionis.luminate.support.inspection.reflexion_instance import ReflexionInst
 from orionis.luminate.test.test_case import TestCase
 from tests.support.inspection.fakes.fake_reflection_instance import BaseFakeClass, FakeClass
 
-class TestReflection(TestCase):
+class TestReflectionInstance(TestCase):
     """
     Unit tests for the Reflection class.
     """

tests/support/inspection/test_reflection_instance_with_abstract.py

@@ -2,7 +2,7 @@ from orionis.luminate.support.inspection.reflexion_instance_with_abstract import
 from orionis.luminate.test.test_case import TestCase
 from tests.support.inspection.fakes.fake_reflection_instance_with_abstract import FakeDataProcessor, IDataProcessor
 
-class TestReflexionWithFakes(TestCase):
+class TestReflexionInstanceWithAbstract(TestCase):
 
     def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""