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

tests/services/introspection/dependencies/test_reflect_dependencies.py

@@ -1,11 +1,7 @@
 import asyncio
-from orionis.services.introspection.dependencies.entities.callable_dependencies import CallableDependency
-from orionis.services.introspection.dependencies.reflection import (
-    ReflectDependencies,
-    ClassDependency,
-    MethodDependency,
-    KnownDependency
-)
+from orionis.services.introspection.dependencies.entities.argument import Argument
+from orionis.services.introspection.dependencies.entities.resolve_argument import ResolveArguments
+from orionis.services.introspection.dependencies.reflection import ReflectDependencies
 from orionis.test.cases.asynchronous import AsyncTestCase
 from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
 from tests.services.introspection.dependencies.mocks.mock_user_controller import UserController
@@ -47,134 +43,215 @@ class TestReflectDependencies(AsyncTestCase):
         """
         Retrieves and validates the constructor dependencies for the UserController class using the ReflectDependencies utility.
 
+        This test method verifies the correct functioning of dependency introspection for class constructors.
+        It ensures that the ReflectDependencies class can properly analyze and resolve constructor parameters,
+        returning them in the expected format with correct type information and metadata.
+
         Parameters
         ----------
         self : TestReflectDependencies
-            The test case instance.
+            The test case instance containing the test context and assertion methods.
 
         Returns
         -------
         None
+            This test method does not return any value. It performs assertions to validate the dependency
+            resolution functionality and will raise AssertionError if any validation fails.
 
         Notes
         -----
-        This test ensures that:
-            - The returned constructor dependencies are an instance of ClassDependency.
-            - The list of unresolved dependencies is empty.
-            - The 'user_repository' dependency is resolved as an instance of KnownDependency.
-            - The resolved dependency for 'user_repository' has the expected module name, class name, full class path, and type (FakeUser).
+        This test validates the following aspects of constructor dependency resolution:
+            - The returned constructor dependencies are an instance of ResolveArguments.
+            - The unresolved dependencies dictionary is properly structured.
+            - The 'user_repository' dependency is resolved as an instance of Argument.
+            - The resolved dependency for 'user_repository' contains accurate metadata including
+              module name, class name, full class path, and type reference (FakeUser).
         """
 
+        # Initialize the ReflectDependencies utility with the UserController class
         depend = ReflectDependencies(UserController)
+
+        # Retrieve constructor dependencies for analysis
         constructor_dependencies = depend.getConstructorDependencies()
 
-        # Check Instance of ClassDependency
-        self.assertIsInstance(constructor_dependencies, ClassDependency)
+        # Validate that the result is an instance of ResolveArguments
+        self.assertIsInstance(constructor_dependencies, ResolveArguments)
 
-        self.assertEqual(constructor_dependencies.unresolved, [])
+        # Verify that unresolved dependencies are returned as a dictionary structure
+        self.assertIsInstance(constructor_dependencies.unresolved, dict)
 
-        # Check Instance of KnownDependency
+        # Extract the 'user_repository' dependency from resolved dependencies
         dep_user_repository = constructor_dependencies.resolved.get('user_repository')
-        self.assertIsInstance(dep_user_repository, KnownDependency)
 
-        # Check resolved dependencies for 'user_repository'
-        dependencies:KnownDependency = dep_user_repository
+        # Validate that the dependency is properly resolved as an Argument instance
+        self.assertIsInstance(dep_user_repository, Argument)
+
+        # Perform detailed validation of the resolved dependency metadata
+        dependencies: Argument = dep_user_repository
+
+        # Verify the module name matches the expected mock module
         self.assertEqual(dependencies.module_name, 'tests.services.introspection.dependencies.mocks.mock_user')
+
+        # Verify the class name matches the expected FakeUser class
         self.assertEqual(dependencies.class_name, 'FakeUser')
+
+        # Verify the full class path is correctly constructed
         self.assertEqual(dependencies.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_user.FakeUser')
+
+        # Verify the type reference points to the actual FakeUser class
         self.assertEqual(dependencies.type, FakeUser)
 
     async def testReflectionDependenciesGetMethodDependencies(self):
         """
-        Retrieves and validates the dependencies for the 'createUserWithPermissions' method of the UserController class
-        using the ReflectDependencies utility.
+        Test the retrieval and validation of method dependencies for the UserController class.
 
-        This test ensures that:
-            - The returned object is an instance of MethodDependency.
-            - The unresolved dependencies list is empty.
-            - The 'user_permissions' dependency is resolved as a KnownDependency with the expected module name,
-              class name, full class path, and type (FakeUserWithPermissions).
-            - The 'permissions' dependency is resolved as a KnownDependency with the expected module name,
-              class name, full class path, and type (list[str]).
+        This test method validates the ReflectDependencies utility's ability to introspect and resolve
+        dependencies for a specific method ('createUserWithPermissions') within a target class.
+        It ensures that all method parameters are correctly identified, resolved, and contain
+        accurate metadata including module information, class names, and type references.
+
+        The test performs comprehensive validation of:
+            - The returned dependency resolution object structure and type
+            - The absence of unresolved dependencies when all parameters can be resolved
+            - The correct resolution of complex type dependencies (custom classes)
+            - The accurate resolution of built-in type dependencies (generic types with parameters)
+            - The proper extraction of module paths, class names, and full qualified paths
+            - The correct type reference mapping for both custom and built-in types
 
         Parameters
         ----------
         self : TestReflectDependencies
-            The test case instance.
+            The test case instance containing assertion methods and test context.
 
         Returns
         -------
         None
+            This method performs assertions and does not return any value. Test failure
+            will raise AssertionError if any validation fails.
+
+        Notes
+        -----
+        This test specifically validates two types of dependencies:
+            - Custom class dependencies (FakeUserWithPermissions) with full module path resolution
+            - Built-in generic type dependencies (list[str]) with proper type parameter handling
+
+        The test ensures that the ReflectDependencies utility correctly handles both
+        user-defined classes and Python built-in generic types when analyzing method signatures.
         """
 
+        # Initialize the ReflectDependencies utility with UserController as the target class
         depend = ReflectDependencies(UserController)
+
+        # Retrieve method dependencies for the 'createUserWithPermissions' method
         method_dependencies = depend.getMethodDependencies('createUserWithPermissions')
 
-        # Check Instance of MethodDependency
-        self.assertIsInstance(method_dependencies, MethodDependency)
+        # Validate that the result is an instance of ResolveArguments (dependency resolution container)
+        self.assertIsInstance(method_dependencies, ResolveArguments)
 
-        # Check unresolved dependencies
-        self.assertEqual(method_dependencies.unresolved, [])
+        # Verify that unresolved dependencies are returned as a dictionary structure
+        self.assertIsInstance(method_dependencies.unresolved, dict)
 
-        # Check Instance of KnownDependency for 'user_permissions'
-        dep_user_permissions:KnownDependency = method_dependencies.resolved.get('user_permissions')
-        self.assertIsInstance(dep_user_permissions, KnownDependency)
+        # Extract and validate the 'user_permissions' dependency from resolved dependencies
+        dep_user_permissions: Argument = method_dependencies.resolved.get('user_permissions')
 
-        # Check resolved dependencies for 'user_permissions'
+        # Ensure the dependency is properly resolved as an Argument instance
+        self.assertIsInstance(dep_user_permissions, Argument)
+
+        # Validate the module name for the custom FakeUserWithPermissions class
         self.assertEqual(dep_user_permissions.module_name, 'tests.services.introspection.dependencies.mocks.mock_users_permissions')
+
+        # Validate the class name extraction for the custom class
         self.assertEqual(dep_user_permissions.class_name, 'FakeUserWithPermissions')
+
+        # Validate the full qualified class path construction
         self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.introspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
+
+        # Validate the type reference points to the actual FakeUserWithPermissions class
         self.assertEqual(dep_user_permissions.type, FakeUserWithPermissions)
 
-        # Check Instance of KnownDependency for 'permissions'
-        dep_permissions:KnownDependency = method_dependencies.resolved.get('permissions')
-        self.assertIsInstance(dep_permissions, KnownDependency)
+        # Extract and validate the 'permissions' dependency (built-in generic type)
+        dep_permissions: Argument = method_dependencies.resolved.get('permissions')
 
-        # Check resolved dependencies for 'permissions'
+        # Ensure the built-in type dependency is properly resolved as an Argument instance
+        self.assertIsInstance(dep_permissions, Argument)
+
+        # Validate the module name for built-in types (should be 'builtins')
         self.assertEqual(dep_permissions.module_name, 'builtins')
+
+        # Validate the base class name for the generic list type
         self.assertEqual(dep_permissions.class_name, 'list')
+
+        # Validate the full qualified path for built-in types
         self.assertEqual(dep_permissions.full_class_path, 'builtins.list')
+
+        # Validate the type reference includes generic type parameters (list[str])
         self.assertEqual(dep_permissions.type, list[str])
 
     async def testReflectionDependenciesGetCallableDependencies(self):
         """
-        Tests the `getCallableDependencies` method of the `ReflectDependencies` class for a given asynchronous function.
+        Test the retrieval and validation of callable dependencies for a standalone asynchronous function.
+
+        This test method validates the ReflectDependencies utility's ability to introspect and resolve
+        dependencies for a standalone callable function (not bound to a class). It ensures that function
+        parameters with default values are correctly identified and resolved, and that the dependency
+        resolution process handles callable introspection appropriately.
+
+        The test performs comprehensive validation of:
+            - The returned dependency resolution object structure and type
+            - The absence of unresolved dependencies when all parameters have default values
+            - The correct resolution of parameters with default values to their actual default values
+            - The proper handling of built-in type annotations (int) for function parameters
+            - The validation that resolved dependencies contain the expected default values
 
         Parameters
         ----------
         self : TestReflectDependencies
-            The test case instance.
+            The test case instance containing assertion methods and test context.
 
         Returns
         -------
         None
+            This method performs assertions and does not return any value. Test failure
+            will raise AssertionError if any validation fails.
 
         Notes
         -----
-        This test checks that:
-            - The returned dependencies are an instance of `CallableDependency`.
-            - There are no unresolved dependencies.
-            - The 'x' and 'y' parameters are resolved to their default integer values (3 and 4, respectively).
+        This test specifically validates callable dependency resolution for:
+            - Asynchronous functions with type-annotated parameters
+            - Parameters with default values (integers in this case)
+            - The correct mapping of parameter names to their default values
+
+        The test ensures that the ReflectDependencies utility correctly handles standalone
+        callable functions and resolves their parameters to appropriate default values
+        when those defaults are provided in the function signature.
         """
 
+        # Define a sample asynchronous function with default parameter values for testing
         async def fake_function(x: int = 3, y: int = 4) -> int:
             """Asynchronously adds two integers with a short delay."""
             await asyncio.sleep(0.1)
             return x + y
 
-        depend = ReflectDependencies()
-        callable_dependencies = depend.getCallableDependencies(fake_function)
+        # Initialize the ReflectDependencies utility with the callable function as target
+        depend = ReflectDependencies(fake_function)
 
-        # Check Instance of MethodDependency
-        self.assertIsInstance(callable_dependencies, CallableDependency)
+        # Retrieve callable dependencies for analysis
+        callable_dependencies = depend.getCallableDependencies()
 
-        # Check unresolved dependencies
-        self.assertEqual(callable_dependencies.unresolved, [])
+        # Validate that the result is an instance of ResolveArguments (dependency resolution container)
+        self.assertIsInstance(callable_dependencies, ResolveArguments)
 
-        # Check Instance of KnownDependency for 'x'
-        dep_x:KnownDependency = callable_dependencies.resolved.get('x')
+        # Verify that unresolved dependencies are returned as a dictionary structure
+        self.assertIsInstance(callable_dependencies.unresolved, dict)
+
+        # Extract and validate the 'x' parameter dependency from resolved dependencies
+        dep_x: Argument = callable_dependencies.resolved.get('x')
+
+        # Verify that the 'x' parameter resolves to its default value of 3
         self.assertEqual(dep_x, 3)
 
-        # Check Instance of KnownDependency for 'y'
-        dep_y:KnownDependency = callable_dependencies.resolved.get('y')
+        # Extract and validate the 'y' parameter dependency from resolved dependencies
+        dep_y: Argument = callable_dependencies.resolved.get('y')
+
+        # Verify that the 'y' parameter resolves to its default value of 4
         self.assertEqual(dep_y, 4)

tests/services/introspection/reflection/test_reflection_abstract.py

@@ -1,5 +1,6 @@
 from orionis.services.introspection.abstract.reflection import ReflectionAbstract
-from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
+from orionis.services.introspection.dependencies.entities.argument import Argument
+from orionis.services.introspection.dependencies.entities.resolve_argument import ResolveArguments
 from tests.services.introspection.reflection.mock.fake_reflect_instance import AbstractFakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
@@ -987,11 +988,11 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
         Assertions
         ----------
-        Should return a ClassDependency instance with constructor dependencies.
+        Should return a ResolveArguments instance with constructor dependencies.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         dependencies = reflect.getConstructorDependencies()
-        self.assertIsInstance(dependencies, ClassDependency)
+        self.assertIsInstance(dependencies, ResolveArguments)
 
     async def testGetMethodDependencies(self):
         """
@@ -1005,7 +1006,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         Should return method dependencies with correct parameter types and metadata.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
-        method_deps = reflect.getMethodDependencies('instanceSyncMethod')
+        method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
         self.assertIn('x', method_deps.resolved)
         self.assertIn('y', method_deps.resolved)
         self.assertEqual(method_deps.resolved['x'].class_name, 'int')

tests/services/introspection/reflection/test_reflection_callable.py

@@ -1,5 +1,5 @@
 from orionis.services.introspection.callables.reflection import ReflectionCallable
-from orionis.services.introspection.dependencies.entities.callable_dependencies import CallableDependency
+from orionis.services.introspection.dependencies.entities.resolve_argument import ResolveArguments
 from orionis.test.cases.asynchronous import AsyncTestCase
 from orionis.services.introspection.exceptions import ReflectionTypeError
 
@@ -189,7 +189,7 @@ class TestReflectionCallable(AsyncTestCase):
         """
         Test retrieval of callable dependencies from ReflectionCallable.
 
-        Checks that getDependencies() returns a CallableDependency object with
+        Checks that getDependencies() returns a ResolveArguments object with
         'resolved' and 'unresolved' attributes for the wrapped function.
 
         Returns
@@ -201,6 +201,6 @@ class TestReflectionCallable(AsyncTestCase):
             return a + b
         rc = ReflectionCallable(sample_function)
         deps = rc.getDependencies()
-        self.assertIsInstance(deps, CallableDependency)
+        self.assertIsInstance(deps, ResolveArguments)
         self.assertTrue(hasattr(deps, "resolved"))
         self.assertTrue(hasattr(deps, "unresolved"))

tests/services/introspection/reflection/test_reflection_concrete.py

@@ -1,5 +1,5 @@
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
-from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
+from orionis.services.introspection.dependencies.entities.resolve_argument import ResolveArguments
 from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.test.cases.asynchronous import AsyncTestCase
 
@@ -931,11 +931,11 @@ class TestServiceReflectionConcrete(AsyncTestCase):
         Returns
         -------
         None
-            Asserts that the returned dependencies are a ClassDependency object.
+            Asserts that the returned dependencies are a ResolveArguments object.
         """
         reflect = ReflectionConcrete(FakeClass)
         dependencies = reflect.getConstructorDependencies()
-        self.assertIsInstance(dependencies, ClassDependency)
+        self.assertIsInstance(dependencies, ResolveArguments)
 
     async def testGetMethodDependencies(self):
         """
@@ -947,7 +947,7 @@ class TestServiceReflectionConcrete(AsyncTestCase):
             Asserts that the returned dependencies for 'instanceSyncMethod' are as expected.
         """
         reflect = ReflectionConcrete(FakeClass)
-        method_deps = reflect.getMethodDependencies('instanceSyncMethod')
+        method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
         self.assertIn('x', method_deps.resolved)
         self.assertIn('y', method_deps.resolved)
         self.assertEqual(method_deps.resolved['x'].class_name, 'int')

tests/services/introspection/reflection/test_reflection_instance.py

@@ -1,4 +1,4 @@
-from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
+from orionis.services.introspection.dependencies.entities.resolve_argument import ResolveArguments
 from tests.services.introspection.reflection.mock.fake_reflect_instance import FakeClass
 from orionis.services.introspection.instances.reflection import ReflectionInstance
 from orionis.test.cases.asynchronous import AsyncTestCase
@@ -1201,16 +1201,16 @@ class TestServiceReflectionInstance(AsyncTestCase):
         Test ReflectionInstance.getConstructorDependencies() method functionality.
 
         Verifies that the getConstructorDependencies method returns an instance
-        of ClassDependency containing the constructor dependencies of the wrapped
+        of ResolveArguments containing the constructor dependencies of the wrapped
         instance's class. Tests dependency analysis for class constructors.
 
         Assertions
         ----------
-        - Returned value is an instance of ClassDependency
+        - Returned value is an instance of ResolveArguments
         """
         reflect = ReflectionInstance(FakeClass())
         dependencies = reflect.getConstructorDependencies()
-        self.assertIsInstance(dependencies, ClassDependency)
+        self.assertIsInstance(dependencies, ResolveArguments)
 
     async def testGetMethodDependencies(self):
         """
@@ -1228,7 +1228,7 @@ class TestServiceReflectionInstance(AsyncTestCase):
         - No unresolved dependencies exist
         """
         reflect = ReflectionInstance(FakeClass())
-        method_deps = reflect.getMethodDependencies('instanceSyncMethod')
+        method_deps: ResolveArguments = reflect.getMethodDependencies('instanceSyncMethod')
         self.assertIn('x', method_deps.resolved)
         self.assertIn('y', method_deps.resolved)
         self.assertEqual(method_deps.resolved['x'].class_name, 'int')

orionis/console/args/parser.py

@@ -1,40 +0,0 @@
-import argparse
-
-class ArgumentPaser():
-
-    def __init__(self):
-        self.__parser = argparse.ArgumentParser()
-
-    def addArgument(self, name: str, **kwargs):
-        """
-        Add an argument to the parser.
-
-        Parameters
-        ----------
-        name : str
-            The name of the argument to add.
-        kwargs : dict
-            Additional keyword arguments for the argument configuration.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        self.__parser.add_argument(name, **kwargs)
-
-    def parse(self, args=None):
-        """
-        Parse the command-line arguments.
-
-        Parameters
-        ----------
-        args : list, optional
-            A list of arguments to parse. If None, uses sys.argv by default.
-
-        Returns
-        -------
-        Namespace
-            An object containing the parsed arguments as attributes.
-        """
-        return self.__parser.parse_args(args)

orionis/container/contracts/resolver.py

@@ -1,115 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable
-from orionis.container.contracts.container import IContainer
-from orionis.container.entities.binding import Binding
-from orionis.services.introspection.dependencies.entities.method_dependencies import MethodDependency
-
-class IResolver(ABC):
-    """
-    Interface for dependency resolution in the container system.
-
-    This interface defines the contract for resolvers that handle
-    dependency injection and instance creation based on bindings.
-    """
-
-    @abstractmethod
-    def __init__(self, container: IContainer) -> None:
-        """
-        Initialize the resolver with a container reference.
-
-        Parameters
-        ----------
-        container : IContainer
-            The container instance that this resolver will use to resolve dependencies.
-        """
-        pass
-
-    @abstractmethod
-    def resolve(
-        self,
-        binding: Binding,
-        *args,
-        **kwargs
-    ) -> Any:
-        """
-        Resolves an instance from a binding.
-
-        This method resolves an instance based on the binding's lifetime and type.
-        It delegates to specific resolution methods based on the lifetime (transient, singleton, or scoped).
-
-        Parameters
-        ----------
-        binding : Binding
-            The binding to resolve.
-        *args : tuple
-            Additional positional arguments to pass to the constructor.
-        **kwargs : dict
-            Additional keyword arguments to pass to the constructor.
-
-        Returns
-        -------
-        Any
-            The resolved instance.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the binding is not an instance of Binding or if resolution fails.
-        """
-        pass
-
-    @abstractmethod
-    def resolveType(
-        self,
-        type_: Callable[..., Any],
-        *args,
-        **kwargs
-    ) -> Any:
-        """
-        Forces resolution of a type whether it's registered in the container or not.
-
-        Parameters
-        ----------
-        type_ : Callable[..., Any]
-            The type or callable to resolve.
-        *args : tuple
-            Positional arguments to pass to the constructor/callable.
-        **kwargs : dict
-            Keyword arguments to pass to the constructor/callable.
-
-        Returns
-        -------
-        Any
-            The resolved instance.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the type cannot be resolved.
-        """
-        pass
-
-    @abstractmethod
-    def resolveSignature(
-        self,
-        signature: MethodDependency
-    ) -> dict:
-        """
-        Resolves dependencies defined in a method signature.
-
-        Parameters
-        ----------
-        signature : MethodDependency
-            The method dependency information to resolve.
-
-        Returns
-        -------
-        dict
-            A dictionary of resolved parameter values.
-
-        Raises
-        ------
-        OrionisContainerException
-            If any dependencies cannot be resolved.
-        """
-        pass