orionis 0.295.0__py3-none-any.whl → 0.297.0__py3-none-any.whl

orionis/metadata/framework.py

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

orionis/services/introspection/dependencies/contracts/reflect_dependencies.py

@@ -4,40 +4,46 @@ from orionis.services.introspection.dependencies.entities.method_dependencies im
 
 class IReflectDependencies(ABC):
     """
-    This class is used to reflect dependencies of a given object.
-    """
+    Interface for reflecting dependencies of a given object.
 
-    def __init__(self, obj):
-        self.__obj = obj
+    This interface provides methods to retrieve both resolved and unresolved
+    dependencies from the constructor and methods of a class.
+    """
 
     @abstractmethod
     def getConstructorDependencies(self) -> ClassDependency:
         """
-        Get the resolved and unresolved dependencies from the constructor of the instance's class.
+        Retrieve dependencies from the constructor of the instance's class.
 
         Returns
         -------
         ClassDependency
-            A structured representation of the constructor dependencies, containing:
-            - resolved: Dictionary of resolved dependencies with their names and values.
-            - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
+            Structured representation of the constructor dependencies.
+
+            - resolved : dict
+                Dictionary of resolved dependencies with their names and values.
+            - unresolved : list
+                List of unresolved dependencies (parameter names without default values or annotations).
         """
         pass
 
     def getMethodDependencies(self, method_name: str) -> MethodDependency:
         """
-        Get the resolved and unresolved dependencies from a method of the instance's class.
+        Retrieve dependencies from a method of the instance's class.
 
         Parameters
         ----------
         method_name : str
-            The name of the method to inspect
+            Name of the method to inspect.
 
         Returns
         -------
         MethodDependency
-            A structured representation of the method dependencies, containing:
-            - resolved: Dictionary of resolved dependencies with their names and values.
-            - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
+            Structured representation of the method dependencies.
+
+            - resolved : dict
+                Dictionary of resolved dependencies with their names and values.
+            - unresolved : list
+                List of unresolved dependencies (parameter names without default values or annotations).
         """
         pass

orionis/services/introspection/dependencies/entities/class_dependencies.py

@@ -1,19 +1,28 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
 from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
 class ClassDependency:
     """
     Represents the dependencies of a class, separating resolved and unresolved dependencies.
 
-    Attributes:
-        resolved (Dict[ResolvedDependency, Any]):
-            A dictionary mapping resolved dependency descriptors to their corresponding resolved instances or values.
-            All keys must be ResolvedDependency instances.
-        unresolved (List[str]):
-            A list of dependency names or identifiers that could not be resolved.
-            Must contain only strings.
+    Parameters
+    ----------
+    resolved : Dict[ResolvedDependency, Any]
+        A dictionary mapping resolved dependency descriptors to their corresponding resolved instances or values.
+        All keys must be ResolvedDependency instances.
+    unresolved : List[str]
+        A list of dependency names or identifiers that could not be resolved.
+        Must contain only strings.
+
+    Attributes
+    ----------
+    resolved : Dict[ResolvedDependency, Any]
+        Dictionary of resolved dependencies.
+    unresolved : List[str]
+        List of unresolved dependency names.
     """
     resolved: Dict[ResolvedDependency, Any]
     unresolved: List[str]
@@ -22,20 +31,23 @@ class ClassDependency:
         """
         Validates types of attributes during initialization.
 
-        Raises:
-            TypeError: If types don't match the expected:
+        Raises
+        ------
+        ReflectionTypeError
+            If types don't match the expected:
                 - resolved: Dict[ResolvedDependency, Any]
                 - unresolved: List[str]
-            ValueError: If resolved contains None keys or unresolved contains empty strings
+        ValueError
+            If resolved contains None keys or unresolved contains empty strings.
         """
         # Validate 'resolved' is a dict with ResolvedDependency keys
         if not isinstance(self.resolved, dict):
-            raise TypeError(
+            raise ReflectionTypeError(
                 f"'resolved' must be a dict, got {type(self.resolved).__name__}"
             )
 
         # Validate 'unresolved' is a list of non-empty strings
         if not isinstance(self.unresolved, list):
-            raise TypeError(
+            raise ReflectionTypeError(
                 f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
             )

orionis/services/introspection/dependencies/entities/method_dependencies.py

@@ -1,20 +1,30 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
 from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
 class MethodDependency:
     """
     Represents the dependencies of a method, separating resolved and unresolved dependencies.
 
-    Attributes:
-        resolved (Dict[ResolvedDependency, Any]):
-            A dictionary mapping resolved dependency descriptors to their corresponding
-            resolved instances or values for the method.
-            All keys must be ResolvedDependency instances.
-        unresolved (List[str]):
-            A list of method parameter names or dependency identifiers that could not be resolved.
-            Must contain only non-empty strings.
+    Parameters
+    ----------
+    resolved : Dict[ResolvedDependency, Any]
+        A dictionary mapping resolved dependency descriptors to their corresponding
+        resolved instances or values for the method. All keys must be ResolvedDependency instances.
+    unresolved : List[str]
+        A list of method parameter names or dependency identifiers that could not be resolved.
+        Must contain only non-empty strings.
+
+    Raises
+    ------
+    ReflectionTypeError
+        If types don't match the expected:
+            - resolved: Dict[ResolvedDependency, Any]
+            - unresolved: List[str]
+    ValueError
+        If resolved contains None keys or unresolved contains empty strings
     """
     resolved: Dict[ResolvedDependency, Any]
     unresolved: List[str]
@@ -23,20 +33,23 @@ class MethodDependency:
         """
         Validates types and values of attributes during initialization.
 
-        Raises:
-            TypeError: If types don't match the expected:
+        Raises
+        ------
+        ReflectionTypeError
+            If types don't match the expected:
                 - resolved: Dict[ResolvedDependency, Any]
                 - unresolved: List[str]
-            ValueError: If resolved contains None keys or unresolved contains empty strings
+        ValueError
+            If resolved contains None keys or unresolved contains empty strings
         """
         # Validate 'resolved' is a dict with proper key types
         if not isinstance(self.resolved, dict):
-            raise TypeError(
+            raise ReflectionTypeError(
                 f"'resolved' must be a dict, got {type(self.resolved).__name__}"
             )
 
         # Validate 'unresolved' is a list of valid parameter names
         if not isinstance(self.unresolved, list):
-            raise TypeError(
+            raise ReflectionTypeError(
                 f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
             )

orionis/services/introspection/dependencies/entities/resolved_dependencies.py

@@ -1,23 +1,33 @@
 from dataclasses import dataclass
 from typing import Type, Any
 
+from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
+
 @dataclass(frozen=True, kw_only=True)
 class ResolvedDependency:
     """
     Represents a fully resolved dependency with complete type information.
 
-    Attributes:
-        module_name (str):
-            The name of the module where the dependency is defined.
-            Must be a non-empty string without spaces.
-        class_name (str):
-            The name of the class/type being resolved.
-            Must be a valid Python identifier.
-        type (Type):
-            The actual Python type object of the resolved dependency.
-        full_class_path (str):
-            The full import path to the class (e.g., 'package.module.ClassName').
-            Must match 'module_name.class_name' pattern.
+    Parameters
+    ----------
+    module_name : str
+        The name of the module where the dependency is defined.
+        Must be a non-empty string without spaces.
+    class_name : str
+        The name of the class/type being resolved.
+        Must be a valid Python identifier.
+    type : Type
+        The actual Python type object of the resolved dependency.
+    full_class_path : str
+        The full import path to the class (e.g., 'package.module.ClassName').
+        Must match 'module_name.class_name' pattern.
+
+    Raises
+    ------
+    ReflectionTypeError
+        If any field has incorrect type.
+    ValueError
+        If string fields are empty or don't meet format requirements.
     """
     module_name: str
     class_name: str
@@ -28,17 +38,20 @@ class ResolvedDependency:
         """
         Validates all fields during initialization.
 
-        Raises:
-            TypeError: If any field has incorrect type.
-            ValueError: If string fields are empty or don't meet format requirements.
+        Raises
+        ------
+        ReflectionTypeError
+            If any field has incorrect type.
+        ValueError
+            If string fields are empty or don't meet format requirements.
         """
         # Validate module_name
         if not isinstance(self.module_name, str):
-            raise TypeError(f"module_name must be str, got {type(self.module_name).__name__}")
+            raise ReflectionTypeError(f"module_name must be str, got {type(self.module_name).__name__}")
 
         # Validate class_name
         if not isinstance(self.class_name, str):
-            raise TypeError(f"class_name must be str, got {type(self.class_name).__name__}")
+            raise ReflectionTypeError(f"class_name must be str, got {type(self.class_name).__name__}")
 
         # Validate type
         if self.type is None:
@@ -46,4 +59,4 @@ class ResolvedDependency:
 
         # Validate full_class_path
         if not isinstance(self.full_class_path, str):
-            raise TypeError(f"full_class_path must be str, got {type(self.full_class_path).__name__}")
+            raise ReflectionTypeError(f"full_class_path must be str, got {type(self.full_class_path).__name__}")

orionis/services/introspection/dependencies/reflect_dependencies.py

@@ -4,6 +4,7 @@ from orionis.services.introspection.dependencies.contracts.reflect_dependencies
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
 from orionis.services.introspection.dependencies.entities.method_dependencies import MethodDependency
 from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.exceptions.reflection_value_error import ReflectionValueError
 
 class ReflectDependencies(IReflectDependencies):
     """
@@ -67,16 +68,16 @@ class ReflectDependencies(IReflectDependencies):
 
         Raises
         ------
-        ValueError
+        ReflectionValueError
             If the signature cannot be inspected.
         """
         if not callable(target):
-            raise ValueError(f"Target {target} is not callable and cannot have a signature.")
+            raise ReflectionValueError(f"Target {target} is not callable and cannot have a signature.")
 
         try:
             return inspect.signature(target)
-        except (ValueError, TypeError) as e:
-            raise ValueError(f"Unable to inspect signature of {target}: {str(e)}")
+        except (ReflectionValueError, TypeError, Exception) as e:
+            raise ReflectionValueError(f"Unable to inspect signature of {target}: {str(e)}")
 
     def getConstructorDependencies(self) -> ClassDependency:
         """

orionis/services/introspection/exceptions/reflection_attribute_error.py

@@ -0,0 +1,26 @@
+class ReflectionAttributeError(Exception):
+    """
+    Base class for all reflection-related exceptions.
+    """
+
+    def __init__(self, msg: str):
+        """
+        Initialize the exception with a custom error message.
+
+        Parameters
+        ----------
+        msg : str
+            The error message describing the exception.
+        """
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the exception, including the class name and the first argument.
+
+        Returns
+        -------
+        str
+            A formatted string with the exception class name and the first argument.
+        """
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/services/introspection/exceptions/reflection_type_error.py

@@ -0,0 +1,26 @@
+class ReflectionTypeError(Exception):
+    """
+    Base class for all reflection-related exceptions.
+    """
+
+    def __init__(self, msg: str):
+        """
+        Initialize the exception with a custom error message.
+
+        Parameters
+        ----------
+        msg : str
+            The error message describing the exception.
+        """
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the exception, including the class name and the first argument.
+
+        Returns
+        -------
+        str
+            A formatted string with the exception class name and the first argument.
+        """
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/services/introspection/exceptions/reflection_value_error.py

@@ -0,0 +1,26 @@
+class ReflectionValueError(Exception):
+    """
+    Base class for all reflection-related exceptions.
+    """
+
+    def __init__(self, msg: str):
+        """
+        Initialize the exception with a custom error message.
+
+        Parameters
+        ----------
+        msg : str
+            The error message describing the exception.
+        """
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of the exception, including the class name and the first argument.
+
+        Returns
+        -------
+        str
+            A formatted string with the exception class name and the first argument.
+        """
+        return f"{self.__class__.__name__}: {self.args[0]}"

orionis/services/introspection/instances/entities/class_attributes.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Any, Dict
+
+@dataclass(frozen=True, kw_only=True)
+class ClassAttributes:
+    """
+    Represents the attributes of a class instance.
+
+    Parameters
+    ----------
+    public : dict of str to Any
+        Public attributes of the class instance.
+    private : dict of str to Any
+        Private attributes of the class instance.
+    protected : dict of str to Any
+        Protected attributes of the class instance.
+    """
+    public: Dict[str, Any]
+    private: Dict[str, Any]
+    protected: Dict[str, Any]

orionis/services/introspection/instances/entities/class_method.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import List
+
+@dataclass(frozen=False, kw_only=True)
+class ClassMethod:
+    """
+    Represents the methods of a class instance.
+
+    Attributes
+    ----------
+    public : List[str]
+        List of public method names.
+    private : List[str]
+        List of private method names.
+    protected : List[str]
+        List of protected method names.
+    static : List[str]
+        List of static method names.
+    asynchronous : List[str]
+        List of asynchronous method names.
+    synchronous : List[str]
+        List of synchronous method names.
+    class_methods : List[str]
+        List of class method names.
+    asynchronous_static : List[str]
+        List of asynchronous static method names.
+    synchronous_static : List[str]
+        List of synchronous static method names.
+    magic : List[str]
+        List of magic method names.
+    """
+    public: List[str]
+    private: List[str]
+    protected: List[str]
+    static: List[str]
+    asynchronous: List[str]
+    synchronous: List[str]
+    class_methods: List[str]
+    asynchronous_static: List[str]
+    synchronous_static: List[str]
+    magic: List[str]

orionis/services/introspection/instances/entities/class_property.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+import inspect
+from typing import Any
+
+@dataclass(frozen=True, kw_only=True)
+class ClassProperty:
+    """
+    Represents a property of a class with its metadata.
+
+    Parameters
+    ----------
+    name : str
+        The name of the property.
+    value : Any
+        The value assigned to the property.
+    signature : inspect.Signature
+        The signature of the property, typically used for callable properties.
+    doc : str
+        The documentation string associated with the property.
+    """
+    name: str
+    value: Any
+    signature: inspect.Signature
+    doc: str