orionis 0.210.0__py3-none-any.whl → 0.213.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.213.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)