orionis 0.449.0__py3-none-any.whl → 0.451.0__py3-none-any.whl

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

@@ -1,61 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List
-from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
-from orionis.services.introspection.exceptions import ReflectionTypeError
-
-@dataclass(frozen=True, kw_only=True)
-class ClassDependency:
-    """
-    Represents the dependencies of a class, distinguishing between resolved and unresolved dependencies.
-
-    Parameters
-    ----------
-    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 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 the types of the 'resolved' and 'unresolved' attributes after initialization.
-
-        Raises
-        ------
-        ReflectionTypeError
-            If 'resolved' is not a dict or 'unresolved' is not a list.
-        ValueError
-            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(
-                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 ReflectionTypeError(
-                f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
-            )

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

@@ -1,67 +0,0 @@
-from dataclasses import dataclass
-from typing import Type, Any
-from orionis.services.introspection.exceptions import ReflectionTypeError
-
-@dataclass(frozen=True, kw_only=True)
-class KnownDependency:
-    """
-    Represents a fully resolved dependency with complete type information.
-
-    Parameters
-    ----------
-    module_name : str
-        Name of the module where the dependency is defined. Must be a non-empty string without spaces.
-    class_name : str
-        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. Must not be None.
-    full_class_path : str
-        Full import path to the class (e.g., 'package.module.ClassName'). Must match the 'module_name.class_name' pattern.
-
-    Raises
-    ------
-    ReflectionTypeError
-        If any of the fields have an incorrect type.
-    ValueError
-        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):
-        """
-        Validates all fields during initialization.
-
-        Raises
-        ------
-        ReflectionTypeError
-            If any field has an incorrect type.
-        ValueError
-            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__}")
-
-        # Validate class_name
-        if not isinstance(self.class_name, str):
-            raise ReflectionTypeError(f"class_name must be str, got {type(self.class_name).__name__}")
-
-        # 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__}")

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

@@ -1,61 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List
-from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
-from orionis.services.introspection.exceptions import ReflectionTypeError
-
-@dataclass(frozen=True, kw_only=True)
-class MethodDependency:
-    """
-    Represents the dependencies of a method, distinguishing between resolved and unresolved dependencies.
-
-    Parameters
-    ----------
-    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 `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.
-
-    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 the types and values of the attributes after initialization.
-
-        Raises
-        ------
-        ReflectionTypeError
-            If `resolved` is not a dictionary or `unresolved` is not a list.
-        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 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 ReflectionTypeError(
-                f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
-            )

tests/container/resolver/test_resolver.py

@@ -1,62 +0,0 @@
-import inspect
-from orionis.container.contracts.resolver import IResolver
-from orionis.container.resolver.resolver import Resolver
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestResolverMethods(AsyncTestCase):
-
-    async def testMethodsExist(self):
-        """
-        Validates the implementation and structure of the `Resolver` class.
-
-        This test checks that the `Resolver` class:
-            - Implements all required methods.
-            - Inherits from the `IResolver` interface.
-            - Has main public methods (`resolve`, `resolveType`, `resolveSignature`) that are synchronous.
-
-        Parameters
-        ----------
-        self : TestResolverMethods
-            The test case instance.
-
-        Returns
-        -------
-        None
-            The method does not return any value. Assertions are used to validate the class structure.
-        """
-
-        # List of required method names that must be implemented by Resolver
-        required_methods = [
-            "__init__",
-            "resolve",
-            "resolveType",
-            "resolveSignature",
-            "_Resolver__resolveTransient",
-            "_Resolver__resolveSingleton",
-            "_Resolver__resolveScoped",
-            "_Resolver__instantiateConcreteWithArgs",
-            "_Resolver__instantiateCallableWithArgs",
-            "_Resolver__instantiateConcreteReflective",
-            "_Resolver__instantiateCallableReflective",
-            "_Resolver__resolveDependencies",
-        ]
-
-        # Check that each required method exists in Resolver
-        for method in required_methods:
-            self.assertTrue(
-                hasattr(Resolver, method),
-                f"Resolver must implement the method '{method}'"
-            )
-
-        # Ensure Resolver inherits from IResolver
-        self.assertTrue(
-            issubclass(Resolver, IResolver),
-            "Resolver must inherit from IResolver"
-        )
-
-        # Verify that main public methods are not asynchronous
-        for method in ["resolve", "resolveType", "resolveSignature"]:
-            self.assertFalse(
-                inspect.iscoroutinefunction(getattr(Resolver, method)),
-                f"The method '{method}' must not be async"
-            )