orionis 0.436.0__py3-none-any.whl → 0.438.0__py3-none-any.whl

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

@@ -4,46 +4,49 @@ from orionis.services.introspection.dependencies.entities.method_dependencies im
 
 class IReflectDependencies(ABC):
     """
-    Interface for reflecting dependencies of a given object.
+    Abstract interface for reflecting on class and method dependencies.
 
-    This interface provides methods to retrieve both resolved and unresolved
-    dependencies from the constructor and methods of a class.
+    This interface defines methods for retrieving dependency information from
+    the constructor and methods of a class, distinguishing between resolved and
+    unresolved dependencies.
     """
 
     @abstractmethod
     def getConstructorDependencies(self) -> ClassDependency:
         """
-        Retrieve dependencies from the constructor of the instance's class.
+        Retrieve dependency information from the class constructor.
 
         Returns
         -------
         ClassDependency
-            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).
+            An object containing details about the constructor's dependencies.
+            The object includes:
+                - resolved : dict
+                    Mapping of dependency names to their resolved values.
+                - unresolved : list
+                    List of dependency names that are unresolved (i.e., lacking
+                    default values or type annotations).
         """
         pass
 
     def getMethodDependencies(self, method_name: str) -> MethodDependency:
         """
-        Retrieve dependencies from a method of the instance's class.
+        Retrieve dependency information from a specified method.
 
         Parameters
         ----------
         method_name : str
-            Name of the method to inspect.
+            The name of the method whose dependencies are to be inspected.
 
         Returns
         -------
         MethodDependency
-            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).
+            An object containing details about the method's dependencies.
+            The object includes:
+                - resolved : dict
+                    Mapping of dependency names to their resolved values.
+                - unresolved : list
+                    List of dependency names that are unresolved (i.e., lacking
+                    default values or type annotations).
         """
         pass

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

@@ -6,42 +6,41 @@ from orionis.services.introspection.exceptions import ReflectionTypeError
 @dataclass(frozen=True, kw_only=True)
 class CallableDependency:
     """
-    Represents the dependencies of a callable, separating resolved and unresolved dependencies.
+    Represents the resolved and unresolved dependencies of a callable.
 
-    Parameters
+    Attributes
     ----------
     resolved : Dict[KnownDependency, Any]
-        A dictionary mapping resolved dependency descriptors to their corresponding
-        resolved instances or values for the method. All keys must be KnownDependency instances.
+        Dictionary mapping KnownDependency instances to their resolved values.
     unresolved : List[str]
-        A list of method parameter names or dependency identifiers that could not be resolved.
-        Must contain only non-empty strings.
+        List of parameter names or dependency identifiers that could not be resolved.
 
     Raises
     ------
     ReflectionTypeError
-        If types don't match the expected:
-            - resolved: Dict[KnownDependency, Any]
-            - unresolved: List[str]
+        If `resolved` is not a dictionary or `unresolved` is not a list.
     ValueError
-        If resolved contains None keys or unresolved contains empty strings
+        If `resolved` contains None keys or `unresolved` contains empty strings.
     """
+
+    # Resolved dependencies mapped to their values
     resolved: Dict[KnownDependency, Any]
+
+    # Unresolved dependencies as a list of parameter names
     unresolved: List[str]
 
     def __post_init__(self):
         """
-        Validates types and values of attributes during initialization.
+        Validates the types and values of the attributes after initialization.
 
         Raises
         ------
         ReflectionTypeError
-            If types don't match the expected:
-                - resolved: Dict[KnownDependency, Any]
-                - unresolved: List[str]
+            If `resolved` is not a dictionary or `unresolved` is not a list.
         ValueError
-            If resolved contains None keys or unresolved contains empty strings
+            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 ReflectionTypeError(
@@ -52,4 +51,4 @@ class CallableDependency:
         if not isinstance(self.unresolved, list):
             raise ReflectionTypeError(
                 f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
-            )
+            )

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

@@ -6,40 +6,48 @@ from orionis.services.introspection.exceptions import ReflectionTypeError
 @dataclass(frozen=True, kw_only=True)
 class ClassDependency:
     """
-    Represents the dependencies of a class, separating resolved and unresolved dependencies.
+    Represents the dependencies of a class, distinguishing between resolved and unresolved dependencies.
 
     Parameters
     ----------
-    resolved : Dict[KnownDependency, Any]
-        A dictionary mapping resolved dependency descriptors to their corresponding resolved instances or values.
-        All keys must be KnownDependency instances.
-    unresolved : List[str]
-        A list of dependency names or identifiers that could not be resolved.
-        Must contain only strings.
+    resolved : dict of KnownDependency to Any
+        Dictionary mapping KnownDependency instances to their resolved values or instances.
+    unresolved : list of str
+        List of dependency names or identifiers that could not be resolved.
 
     Attributes
     ----------
-    resolved : Dict[KnownDependency, Any]
-        Dictionary of resolved dependencies.
-    unresolved : List[str]
-        List of unresolved dependency names.
+    resolved : dict of KnownDependency to Any
+        The resolved dependencies for the class.
+    unresolved : list of str
+        The unresolved dependency names or identifiers.
+
+    Raises
+    ------
+    ReflectionTypeError
+        If 'resolved' is not a dictionary with KnownDependency keys or 'unresolved' is not a list.
+    ValueError
+        If 'resolved' contains None keys or 'unresolved' contains empty strings.
     """
+
+    # Resolved dependencies mapped to their values
     resolved: Dict[KnownDependency, Any]
+
+    # Unresolved dependencies as a list of parameter names
     unresolved: List[str]
 
     def __post_init__(self):
         """
-        Validates types of attributes during initialization.
+        Validates the types of the 'resolved' and 'unresolved' attributes after initialization.
 
         Raises
         ------
         ReflectionTypeError
-            If types don't match the expected:
-                - resolved: Dict[KnownDependency, Any]
-                - unresolved: List[str]
+            If 'resolved' is not a dict or 'unresolved' is not a list.
         ValueError
-            If resolved contains None keys or unresolved contains empty strings.
+            If 'resolved' contains None keys or 'unresolved' contains empty strings.
         """
+
         # Validate 'resolved' is a dict with KnownDependency keys
         if not isinstance(self.resolved, dict):
             raise ReflectionTypeError(

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

@@ -10,27 +10,32 @@ class KnownDependency:
     Parameters
     ----------
     module_name : str
-        The name of the module where the dependency is defined.
-        Must be a non-empty string without spaces.
+        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.
+        Name of the class or type being resolved. Must be a valid Python identifier.
     type : Type
-        The actual Python type object of the resolved dependency.
+        The actual Python type object of the resolved dependency. Must not be None.
     full_class_path : str
-        The full import path to the class (e.g., 'package.module.ClassName').
-        Must match 'module_name.class_name' pattern.
+        Full import path to the class (e.g., 'package.module.ClassName'). Must match the 'module_name.class_name' pattern.
 
     Raises
     ------
     ReflectionTypeError
-        If any field has incorrect type.
+        If any of the fields have an incorrect type.
     ValueError
-        If string fields are empty or don't meet format requirements.
+        If string fields are empty or do not meet format requirements, or if 'type' is None.
     """
+
+    # Module name where the dependency is defined
     module_name: str
+
+    # Class name or type being resolved
     class_name: str
+
+    # The actual Python type object of the resolved dependency
     type: Type[Any]
+
+    # Full import path to the class
     full_class_path: str
 
     def __post_init__(self):
@@ -40,10 +45,11 @@ class KnownDependency:
         Raises
         ------
         ReflectionTypeError
-            If any field has incorrect type.
+            If any field has an incorrect type.
         ValueError
-            If string fields are empty or don't meet format requirements.
+            If string fields are empty or do not meet format requirements, or if 'type' is None.
         """
+
         # Validate module_name
         if not isinstance(self.module_name, str):
             raise ReflectionTypeError(f"module_name must be str, got {type(self.module_name).__name__}")
@@ -52,10 +58,10 @@ class KnownDependency:
         if not isinstance(self.class_name, str):
             raise ReflectionTypeError(f"class_name must be str, got {type(self.class_name).__name__}")
 
-        # Validate type
+        # Validate type is not None
         if self.type is None:
             raise ValueError("The 'type' field must not be None. Please provide a valid Python type object for the dependency.")
 
         # Validate full_class_path
         if not isinstance(self.full_class_path, str):
-            raise ReflectionTypeError(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/entities/method_dependencies.py

@@ -6,42 +6,48 @@ from orionis.services.introspection.exceptions import ReflectionTypeError
 @dataclass(frozen=True, kw_only=True)
 class MethodDependency:
     """
-    Represents the dependencies of a method, separating resolved and unresolved dependencies.
+    Represents the dependencies of a method, distinguishing between resolved and unresolved dependencies.
 
     Parameters
     ----------
-    resolved : Dict[KnownDependency, Any]
-        A dictionary mapping resolved dependency descriptors to their corresponding
-        resolved instances or values for the method. All keys must be KnownDependency instances.
-    unresolved : List[str]
-        A list of method parameter names or dependency identifiers that could not be resolved.
-        Must contain only non-empty strings.
+    resolved : dict of KnownDependency to Any
+        Dictionary mapping each resolved KnownDependency to its corresponding instance or value.
+    unresolved : list of str
+        List of parameter names or dependency identifiers that could not be resolved.
 
     Raises
     ------
     ReflectionTypeError
-        If types don't match the expected:
-            - resolved: Dict[KnownDependency, Any]
-            - unresolved: List[str]
+        If `resolved` is not a dictionary with KnownDependency keys, or if `unresolved` is not a list of strings.
     ValueError
-        If resolved contains None keys or unresolved contains empty strings
+        If `resolved` contains None keys or `unresolved` contains empty strings.
+
+    Attributes
+    ----------
+    resolved : dict of KnownDependency to Any
+        The resolved dependencies for the method.
+    unresolved : list of str
+        The unresolved dependencies for the method.
     """
+
+    # Resolved dependencies mapped to their values
     resolved: Dict[KnownDependency, Any]
+
+    # Unresolved dependencies as a list of parameter names
     unresolved: List[str]
 
     def __post_init__(self):
         """
-        Validates types and values of attributes during initialization.
+        Validates the types and values of the attributes after initialization.
 
         Raises
         ------
         ReflectionTypeError
-            If types don't match the expected:
-                - resolved: Dict[KnownDependency, Any]
-                - unresolved: List[str]
+            If `resolved` is not a dictionary or `unresolved` is not a list.
         ValueError
-            If resolved contains None keys or unresolved contains empty strings
+            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 ReflectionTypeError(

orionis/services/introspection/dependencies/reflection.py

@@ -8,9 +8,6 @@ from orionis.services.introspection.dependencies.entities.known_dependencies imp
 from orionis.services.introspection.exceptions import ReflectionValueError
 
 class ReflectDependencies(IReflectDependencies):
-    """
-    This class is used to reflect dependencies of a given object.
-    """
 
     def __init__(self, target = None):
         """

orionis/services/introspection/instances/reflection.py

@@ -524,6 +524,7 @@ class ReflectionInstance(IReflectionInstance):
         ReflectionAttributeError
             If the attribute is not callable or already exists as a method
         """
+
         # Ensure the name is a valid method name with regular expression
         if not isinstance(name, str) or not name.isidentifier() or keyword.iskeyword(name):
             raise ReflectionAttributeError(f"Invalid method name '{name}'. Must be a valid Python identifier and not a keyword.")
@@ -577,8 +578,12 @@ class ReflectionInstance(IReflectionInstance):
         ReflectionAttributeError
             If the method does not exist or is not callable
         """
+
+        # Handle private method name mangling
         if not self.hasMethod(name):
             raise ReflectionAttributeError(f"Method '{name}' does not exist on '{self.getClassName()}'.")
+
+        # Delete the method from the instance's class
         delattr(self._instance.__class__, name)
 
     def getMethodSignature(self, name: str) -> inspect.Signature:
@@ -1558,16 +1563,21 @@ class ReflectionInstance(IReflectionInstance):
 
     def getConstructorDependencies(self) -> ClassDependency:
         """
-        Get the resolved and unresolved dependencies from the constructor of the instance's class.
-
-
+        Retrieves the resolved and unresolved dependencies from the constructor (__init__) 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).
+            An object representing the constructor dependencies, including:
+            - resolved : dict
+                Dictionary of resolved dependencies with their names and values.
+            - unresolved : list
+                List of unresolved dependencies (parameter names without default values or annotations).
+
+        Notes
+        -----
+        This method uses the ReflectDependencies utility to analyze the constructor of the class
+        associated with the current instance and extract its dependencies.
         """
         return ReflectDependencies(self._instance.__class__).getConstructorDependencies()
 

orionis/services/log/contracts/log_service.py

@@ -17,6 +17,7 @@ class ILoggerService(ABC):
         None
             This method does not return any value.
         """
+
         # To be implemented by subclasses
         pass
 
@@ -35,6 +36,7 @@ class ILoggerService(ABC):
         None
             This method does not return any value.
         """
+
         # To be implemented by subclasses
         pass
 
@@ -53,6 +55,7 @@ class ILoggerService(ABC):
         None
             This method does not return any value.
         """
+
         # To be implemented by subclasses
         pass
 
@@ -71,5 +74,6 @@ class ILoggerService(ABC):
         None
             This method does not return any value.
         """
+
         # To be implemented by subclasses
         pass

orionis/services/log/handlers/filename.py

@@ -18,6 +18,7 @@ class FileNameLogger:
         ValueError
             If the provided path is not a non-empty string.
         """
+
         # Validate that the path is a non-empty string
         if not isinstance(path, str) or not path:
             raise ValueError("The 'path' parameter must be a non-empty string.")
@@ -43,6 +44,7 @@ class FileNameLogger:
         - The timestamp is generated using the current date and time.
         - The directory for the log file is created if it does not exist.
         """
+
         # Split the original path into components based on the separator
         if '/' in self.__path:
             parts = self.__path.split('/')

orionis/services/paths/contracts/resolver.py

@@ -1,9 +1,6 @@
 from abc import ABC, abstractmethod
 
 class IResolver(ABC):
-    """
-    Interface for a utility class that resolves file and directory paths relative to a base path.
-    """
 
     @abstractmethod
     def relativePath(self, relative_path: str) -> 'IResolver':

orionis/services/paths/resolver.py

@@ -7,9 +7,6 @@ from orionis.services.paths.exceptions import (
 )
 
 class Resolver(IResolver):
-    """
-    A utility class for resolving file and directory paths relative to the project's root directory.
-    """
 
     def __init__(self, root_path: str = None):
         """

{orionis-0.436.0.dist-info → orionis-0.438.0.dist-info}/METADATA

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