orionis 0.315.0__py3-none-any.whl → 0.317.0__py3-none-any.whl

orionis/container/container.py

@@ -1,21 +1,147 @@
 from typing import Any, Callable
+from orionis.container.entities.binding import Binding
 from orionis.container.enums.lifetimes import Lifetime
 from orionis.container.exceptions.container_exception import OrionisContainerException
 from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
 from orionis.services.introspection.abstract.reflection_abstract import ReflectionAbstract
+from orionis.services.introspection.callables.reflection_callable import ReflectionCallable
 from orionis.services.introspection.concretes.reflection_concrete import ReflectionConcrete
 from orionis.services.introspection.instances.reflection_instance import ReflectionInstance
 from orionis.services.introspection.reflection import Reflection
+import inspect
+import threading
 
 class Container:
 
+    # Singleton instance of the container.
+    # This is a class variable that holds the single instance of the Container class.
+    _instance = None
+
+    # Lock for thread-safe singleton instantiation.
+    # This lock ensures that only one thread can create the instance at a time,
+    # preventing
+    _lock = threading.Lock()
+
+    # Class variable to track if the container has been initialized.
+    # This is used to ensure that the initialization logic runs only once,
+    # regardless of how many times the class is instantiated.
+    _initialized = False
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Creates and returns a singleton instance of the class.
+
+        This method implements the singleton pattern, ensuring that only one instance
+        of the class exists. If an instance does not exist, it acquires a lock to
+        ensure thread safety and creates the instance. Subsequent calls return the
+        existing instance.
+        Parameters
+        ----------
+        *args : tuple
+            Variable length argument list.
+        **kwargs : dict
+            Arbitrary keyword arguments.
+        Returns
+        -------
+        Container
+            The singleton instance of the class.
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(Container, cls).__new__(cls)
+        return cls._instance
+
     def __init__(self):
-        self.__transient = {}
-        self.__singleton = {}
-        self.__scoped = {}
-        self.__instance = {}
+        """
+        Initializes a new instance of the container.
+
+        This constructor sets up the internal dictionaries for bindings and aliases,
+        ensuring that these are only initialized once per class. The initialization
+        is guarded by the `_initialized` class attribute to prevent redundant setup.
+
+        Notes
+        -----
+        - The `__bindings` dictionary is used to store service bindings.
+        - The `__aliasses` dictionary is used to store service aliases.
+        - Initialization occurs only once per class, regardless of the number of instances.
+        """
+        if not self.__class__._initialized:
+            self.__bindings = {}
+            self.__aliasses = {}
+            self.__class__._initialized = True
+
+    def __dropService(
+        self,
+        abstract: Callable[..., Any] = None,
+        alias: str = None
+    ) -> None:
+        """
+        Drops a service from the container.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract type or interface to be removed.
+        alias : str, optional
+            The alias of the service to be removed. If not provided, the service will be removed by its abstract type.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service does not exist in the container.
+        """
+
+        # If abstract is provided
+        if abstract:
+
+            # Remove the abstract service from the bindings if it exists
+            if abstract in self.__bindings:
+                del self.__bindings[abstract]
+
+            # Remove the default alias (module + class name) from aliases if it exists
+            abs_alias = ReflectionAbstract(abstract).getModuleWithClassName()
+            if abs_alias in self.__aliasses:
+                del self.__aliasses[abs_alias]
 
-    def __ensureAliasType(self, value: Any) -> None:
+        # If a custom alias is provided
+        if alias:
+
+            # Remove it from the aliases dictionary if it exists
+            if alias in self.__aliasses:
+                del self.__aliasses[alias]
+
+            # Remove the binding associated with the alias
+            if alias in self.__bindings:
+                del self.__bindings[alias]
+
+    def __ensureIsCallable(
+        self,
+        value: Any
+    ) -> None:
+        """
+        Ensures that the provided value is callable.
+
+        Parameters
+        ----------
+        value : Any
+            The value to check.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the value is not callable.
+        """
+
+        if not callable(value):
+            raise OrionisContainerTypeError(
+                f"Expected a callable type, but got {type(value).__name__} instead."
+            )
+
+    def __ensureAliasType(
+        self,
+        value: Any
+    ) -> None:
         """
         Ensures that the provided value is a valid alias of type str and does not contain invalid characters.
 
@@ -49,7 +175,11 @@ class Container:
                 "Aliases must not contain whitespace or special symbols."
             )
 
-    def __ensureAbstractClass(self, abstract: Callable[..., Any], lifetime: str) -> None:
+    def __ensureAbstractClass(
+        self,
+        abstract: Callable[..., Any],
+        lifetime: str
+    ) -> None:
         """
         Ensures that the provided abstract is an abstract class.
 
@@ -72,7 +202,11 @@ class Container:
                 f"Unexpected error registering {lifetime} service: {e}"
             ) from e
 
-    def __ensureConcreteClass(self, concrete: Callable[..., Any], lifetime: str) -> None:
+    def __ensureConcreteClass(
+        self,
+        concrete: Callable[..., Any],
+        lifetime: str
+    ) -> None:
         """
         Ensures that the provided concrete is a concrete (non-abstract) class.
 
@@ -95,7 +229,11 @@ class Container:
                 f"Unexpected error registering {lifetime} service: {e}"
             ) from e
 
-    def __ensureIsSubclass(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
+    def __ensureIsSubclass(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any]
+    ) -> None:
         """
         Validates that the concrete class is a subclass of the provided abstract class.
 
@@ -122,7 +260,11 @@ class Container:
                 "Please ensure that the concrete class is a subclass of the specified abstract class."
             )
 
-    def __ensureIsNotSubclass(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
+    def __ensureIsNotSubclass(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any]
+    ) -> None:
         """
         Validates that the concrete class is NOT a subclass of the provided abstract class.
 
@@ -148,7 +290,10 @@ class Container:
                 "Please ensure that the concrete class is not a subclass of the specified abstract class."
             )
 
-    def __ensureInstance(self, instance: Any) -> None:
+    def __ensureInstance(
+        self,
+        instance: Any
+    ) -> None:
         """
         Ensures that the provided object is a valid instance.
 
@@ -175,7 +320,13 @@ class Container:
                 f"Error registering instance: {e}"
             ) from e
 
-    def __ensureImplementation(self, *, abstract: Callable[..., Any] = None, concrete: Callable[..., Any] = None, instance: Any = None) -> None:
+    def __ensureImplementation(
+        self,
+        *,
+        abstract: Callable[..., Any] = None,
+        concrete: Callable[..., Any] = None,
+        instance: Any = None
+    ) -> None:
         """
         Ensures that a concrete class or instance implements all abstract methods defined in an abstract class.
 
@@ -229,7 +380,14 @@ class Container:
                 "Please ensure that all abstract methods are implemented."
             )
 
-    def transient(self, abstract: Callable[..., Any], concrete: Callable[..., Any], alias: str = None, enforce_decoupling: bool = False) -> bool:
+    def transient(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
         """
         Registers a service with a transient lifetime.
 
@@ -267,11 +425,12 @@ class Container:
         # Ensure that concrete is a concrete class
         self.__ensureConcreteClass(concrete, Lifetime.TRANSIENT)
 
+        # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            # Ensure that concrete is NOT a subclass of abstract
             self.__ensureIsNotSubclass(abstract, concrete)
+
+        # Validate that concrete is a subclass of abstract
         else:
-            # Validate that concrete is a subclass of abstract
             self.__ensureIsSubclass(abstract, concrete)
 
         # Ensure implementation
@@ -284,20 +443,37 @@ class Container:
         if alias:
             self.__ensureAliasType(alias)
 
+        # Extract the module and class name for the alias
+        else:
+            rf_asbtract = ReflectionAbstract(abstract)
+            alias = rf_asbtract.getModuleWithClassName()
+
+        # If the service is already registered, drop it
+        self.__dropService(abstract, alias)
+
         # Register the service with transient lifetime
-        self.__transient[abstract] = concrete
+        self.__bindings[abstract] = Binding(
+            contract = abstract,
+            concrete = concrete,
+            lifetime = Lifetime.TRANSIENT,
+            enforce_decoupling = enforce_decoupling,
+            alias = alias
+        )
 
-        # If an alias is provided, register it as well
-        if alias:
-            self.__transient[alias] = concrete
-        elif hasattr(abstract, '__name__'):
-            alias = abstract.__name__
-            self.__transient[alias] = concrete
+        # Register the alias
+        self.__aliasses[alias] = self.__bindings[abstract]
 
         # Return True to indicate successful registration
         return True
 
-    def singleton(self, abstract: Callable[..., Any], concrete: Callable[..., Any], alias: str = None, enforce_decoupling: bool = False) -> bool:
+    def singleton(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
         """
         Registers a service with a singleton lifetime.
 
@@ -334,11 +510,12 @@ class Container:
         # Ensure that concrete is a concrete class
         self.__ensureConcreteClass(concrete, Lifetime.SINGLETON)
 
+        # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            # Ensure that concrete is NOT a subclass of abstract
             self.__ensureIsNotSubclass(abstract, concrete)
+
+        # Validate that concrete is a subclass of abstract
         else:
-            # Validate that concrete is a subclass of abstract
             self.__ensureIsSubclass(abstract, concrete)
 
         # Ensure implementation
@@ -350,21 +527,36 @@ class Container:
         # Ensure that the alias is a valid string if provided
         if alias:
             self.__ensureAliasType(alias)
+        else:
+            rf_asbtract = ReflectionAbstract(abstract)
+            alias = rf_asbtract.getModuleWithClassName()
+
+        # If the service is already registered, drop it
+        self.__dropService(abstract, alias)
 
         # Register the service with singleton lifetime
-        self.__singleton[abstract] = concrete
+        self.__bindings[abstract] = Binding(
+            contract = abstract,
+            concrete = concrete,
+            lifetime = Lifetime.SINGLETON,
+            enforce_decoupling = enforce_decoupling,
+            alias = alias
+        )
 
-        # If an alias is provided, register it as well
-        if alias:
-            self.__singleton[alias] = concrete
-        elif hasattr(abstract, '__name__'):
-            alias = abstract.__name__
-            self.__singleton[alias] = concrete
+        # Register the alias
+        self.__aliasses[alias] = self.__bindings[abstract]
 
         # Return True to indicate successful registration
         return True
 
-    def scoped(self, abstract: Callable[..., Any], concrete: Callable[..., Any], alias: str = None, enforce_decoupling: bool = False) -> bool:
+    def scoped(
+        self,
+        abstract: Callable[..., Any],
+        concrete: Callable[..., Any],
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
         """
         Registers a service with a scoped lifetime.
 
@@ -401,11 +593,12 @@ class Container:
         # Ensure that concrete is a concrete class
         self.__ensureConcreteClass(concrete, Lifetime.SCOPED)
 
+        # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            # Ensure that concrete is NOT a subclass of abstract
             self.__ensureIsNotSubclass(abstract, concrete)
+
+        # Validate that concrete is a subclass of abstract
         else:
-            # Validate that concrete is a subclass of abstract
             self.__ensureIsSubclass(abstract, concrete)
 
         # Ensure implementation
@@ -417,21 +610,36 @@ class Container:
         # Ensure that the alias is a valid string if provided
         if alias:
             self.__ensureAliasType(alias)
+        else:
+            rf_asbtract = ReflectionAbstract(abstract)
+            alias = rf_asbtract.getModuleWithClassName()
+
+        # If the service is already registered, drop it
+        self.__dropService(abstract, alias)
 
         # Register the service with scoped lifetime
-        self.__scoped[abstract] = concrete
+        self.__bindings[abstract] = Binding(
+            contract = abstract,
+            concrete = concrete,
+            lifetime = Lifetime.SCOPED,
+            enforce_decoupling = enforce_decoupling,
+            alias = alias
+        )
 
-        # If an alias is provided, register it as well
-        if alias:
-            self.__scoped[alias] = concrete
-        elif hasattr(abstract, '__name__'):
-            alias = abstract.__name__
-            self.__scoped[alias] = concrete
+        # Register the alias
+        self.__aliasses[alias] = self.__bindings[abstract]
 
         # Return True to indicate successful registration
         return True
 
-    def instance(self, abstract: Callable[..., Any], instance: Any, alias: str = None, enforce_decoupling: bool = False) -> bool:
+    def instance(
+        self,
+        abstract: Callable[..., Any],
+        instance: Any,
+        *,
+        alias: str = None,
+        enforce_decoupling: bool = False
+    ) -> bool:
         """
         Registers an instance of a class or interface in the container.
         Parameters
@@ -466,11 +674,12 @@ class Container:
         # Ensure that the instance is a valid instance
         self.__ensureInstance(instance)
 
+        # Ensure that instance is NOT a subclass of abstract
         if enforce_decoupling:
-            # Ensure that instance is NOT a subclass of abstract
             self.__ensureIsNotSubclass(abstract, instance.__class__)
+
+        # Validate that instance is a subclass of abstract
         else:
-            # Validate that instance is a subclass of abstract
             self.__ensureIsSubclass(abstract, instance.__class__)
 
         # Ensure implementation
@@ -482,19 +691,165 @@ class Container:
         # Ensure that the alias is a valid string if provided
         if alias:
             self.__ensureAliasType(alias)
+        else:
+            rf_asbtract = ReflectionAbstract(abstract)
+            alias = rf_asbtract.getModuleWithClassName()
+
+        # If the service is already registered, drop it
+        self.__dropService(abstract, alias)
 
         # Register the instance with the abstract type
-        self.__instance[abstract] = instance
+        self.__bindings[abstract] = Binding(
+            contract = abstract,
+            instance = instance,
+            lifetime = Lifetime.SINGLETON,
+            enforce_decoupling = enforce_decoupling,
+            alias = alias
+        )
 
-        # If an alias is provided, register it as well
-        if alias:
-            self.__instance[alias] = instance
-        elif hasattr(abstract, '__name__'):
-            alias = abstract.__name__
-            self.__instance[alias] = instance
+        # Register the alias
+        self.__aliasses[alias] = self.__bindings[abstract]
 
         # Return True to indicate successful registration
         return True
 
-    def bind(self, concrete_instance_or_function, lifetime: str = Lifetime.TRANSIENT, alias: str = None) -> None:
-        pass
+    def function(
+        self,
+        alias: str,
+        function: Callable[..., Any],
+        *,
+        lifetime: Lifetime = Lifetime.TRANSIENT
+    ) -> bool:
+        """
+        Registers a function or factory under a given alias.
+
+        Parameters
+        ----------
+        alias : str
+            The alias to register the function under.
+        function : Callable[..., Any]
+            The function or factory to register.
+        lifetime : Lifetime, optional
+            The lifetime of the function registration (default is TRANSIENT).
+
+        Returns
+        -------
+        bool
+            True if the function was registered successfully.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the alias is invalid or the function is not callable.
+        OrionisContainerException
+            If the lifetime is not allowed for the function signature.
+        """
+        # Normalize and validate the lifetime parameter
+        if not isinstance(lifetime, Lifetime):
+            if isinstance(lifetime, str):
+                lifetime_key = lifetime.strip().upper()
+                if lifetime_key in Lifetime.__members__:
+                    lifetime = Lifetime[lifetime_key]
+                else:
+                    valid = ', '.join(Lifetime.__members__.keys())
+                    raise OrionisContainerTypeError(
+                        f"Invalid lifetime '{lifetime}'. Valid options are: {valid}."
+                    )
+            else:
+                raise OrionisContainerTypeError(
+                    f"Lifetime must be of type str or Lifetime enum, got {type(lifetime).__name__}."
+                )
+
+        # Ensure that the alias is a valid string
+        self.__ensureAliasType(alias)
+
+        # Validate that the function is callable
+        self.__ensureIsCallable(function)
+
+        # Inspect the function signature
+        params = ReflectionCallable(function).getDependencies()
+
+        # If the function requires arguments, only allow TRANSIENT
+        if (len(params.resolved) + len(params.unresolved)) > 0 and lifetime != Lifetime.TRANSIENT:
+            raise OrionisContainerException(
+                "Functions that require arguments can only be registered with a TRANSIENT lifetime."
+            )
+
+        # If the service is already registered, drop it
+        self.__dropService(None, alias)
+
+        # Register the function with the specified alias and lifetime
+        self.__bindings[alias] = Binding(
+            function=function,
+            lifetime=lifetime,
+            alias=alias
+        )
+
+        # Register the function as a binding
+        self.__aliasses[alias] = self.__bindings[alias]
+
+        return True
+
+    def bound(
+        self,
+        abstract_or_alias: Any,
+    ) -> bool:
+        """
+        Checks if a service (by abstract type or alias) is registered in the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Any
+            The abstract class, interface, or alias (str) to check for registration.
+
+        Returns
+        -------
+        bool
+            True if the service is registered (either as an abstract type or alias), False otherwise.
+
+        Notes
+        -----
+        This method allows you to verify whether a service has been registered in the container,
+        either by its abstract type or by its alias. It supports both class-based and string-based lookups.
+        """
+        return (
+            abstract_or_alias in self.__bindings
+            or abstract_or_alias in self.__aliasses
+        )
+
+    def make(
+        self,
+        abstract_or_alias: Any,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Resolves and returns an instance of the requested service.
+
+        Parameters
+        ----------
+        abstract_or_alias : Any
+            The abstract class, interface, or alias (str) to resolve.
+        *args : tuple
+            Positional arguments to pass to the constructor of the resolved service.
+        **kwargs : dict
+            Keyword arguments to pass to the constructor of the resolved service.
+
+        Returns
+        -------
+        Any
+            An instance of the requested service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the requested service is not registered in the container.
+        """
+        if not self.bound(abstract_or_alias):
+            raise OrionisContainerException(
+                f"The requested service '{abstract_or_alias}' is not registered in the container."
+            )
+
+        binding = self.__bindings.get(abstract_or_alias) or self.__aliasses.get(abstract_or_alias)
+
+        print(binding)

orionis/container/entities/binding.py

@@ -0,0 +1,124 @@
+from dataclasses import asdict, dataclass, field, fields
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Binding:
+
+    contract: type = field(
+        default=None,
+        metadata={
+            "description": "Contrato de la clase concreta a inyectar.",
+            "default": None
+        }
+    )
+
+    concrete: type = field(
+        default=None,
+        metadata={
+            "description": "Clase concreta que implementa el contrato.",
+            "default": None
+        }
+    )
+
+    instance: object = field(
+        default=None,
+        metadata={
+            "description": "Instancia concreta de la clase, si se proporciona.",
+            "default": None
+        }
+    )
+
+    function: callable = field(
+        default=None,
+        metadata={
+            "description": "Función que se invoca para crear la instancia.",
+            "default": None
+        }
+    )
+
+    lifetime: Lifetime = field(
+        default=Lifetime.TRANSIENT,
+        metadata={
+            "description": "Tiempo de vida de la instancia.",
+            "default": Lifetime.TRANSIENT
+        }
+    )
+
+    enforce_decoupling: bool = field(
+        default=False,
+        metadata={
+            "description": "Indica si se debe forzar el desacoplamiento entre contrato y concreta.",
+            "default": False
+        }
+    )
+
+    alias: str = field(
+        default=None,
+        metadata={
+            "description": "Alias para resolver la dependencia desde el contenedor.",
+            "default": None
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Performs type validation of instance attributes after initialization.
+
+        Parameters
+        ----------
+        None
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If 'lifetime' is not an instance of `Lifetime` (when not None).
+        OrionisContainerTypeError
+            If 'enforce_decoupling' is not of type `bool`.
+        OrionisContainerTypeError
+            If 'alias' is not of type `str` or `None`.
+        """
+        if self.lifetime is not None and not isinstance(self.lifetime, Lifetime):
+            raise OrionisContainerTypeError(
+                f"The 'lifetime' attribute must be an instance of 'Lifetime', but received type '{type(self.lifetime).__name__}'."
+            )
+
+        if not isinstance(self.enforce_decoupling, bool):
+            raise OrionisContainerTypeError(
+                f"The 'enforce_decoupling' attribute must be of type 'bool', but received type '{type(self.enforce_decoupling).__name__}'."
+            )
+
+        if self.alias is not None and not isinstance(self.alias, str):
+            raise OrionisContainerTypeError(
+                f"The 'alias' attribute must be of type 'str' or 'None', but received type '{type(self.alias).__name__}'."
+            )
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)
+
+    def getFields(self):
+        """
+        Retrieves a list of field information for the current dataclass instance.
+
+        Returns:
+            list: A list of dictionaries, each containing details about a field:
+                - name (str): The name of the field.
+                - type (type): The type of the field.
+                - default: The default value of the field, if specified; otherwise, the value from metadata or None.
+                - metadata (mapping): The metadata associated with the field.
+        """
+        __fields = []
+        for field in fields(self):
+            __metadata = dict(field.metadata) or {}
+            __fields.append({
+                "name": field.name,
+                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
+                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
+                "metadata": __metadata
+            })
+        return __fields

orionis/metadata/framework.py

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

orionis/services/introspection/callables/reflection_callable.py

@@ -0,0 +1,147 @@
+import inspect
+from orionis.services.asynchrony.coroutines import Coroutine
+from orionis.services.introspection.dependencies.entities.method_dependencies import MethodDependency as CallableDependency
+from orionis.services.introspection.dependencies.reflect_dependencies import ReflectDependencies
+from orionis.services.introspection.exceptions.reflection_attribute_error import ReflectionAttributeError
+from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
+import asyncio
+
+class ReflectionCallable:
+
+    def __init__(self, fn: callable) -> None:
+        """
+        Parameters
+        ----------
+        fn : callable
+            The function, method, or lambda to be wrapped.
+        Raises
+        ------
+        ReflectionTypeError
+            If `fn` is not a function, method, or lambda.
+        Notes
+        -----
+        This constructor initializes the ReflectionCallable with the provided callable object.
+        It ensures that the input is a valid function, method, or lambda, and raises an error otherwise.
+        """
+        if not (inspect.isfunction(fn) or inspect.ismethod(fn) or (callable(fn) and hasattr(fn, "__code__"))):
+            raise ReflectionTypeError(f"Expected a function, method, or lambda, got {type(fn).__name__}")
+        self.__function = fn
+
+    def getCallable(self) -> callable:
+        """
+        Retrieve the callable function associated with this instance.
+        Returns
+        -------
+        callable
+            The function object encapsulated by this instance.
+        """
+        return self.__function
+
+    def getName(self) -> str:
+        """
+        Returns
+        -------
+        str
+            The name of the function.
+        """
+        return self.__function.__name__
+
+    def getModuleName(self) -> str:
+        """
+        Get the name of the module where the underlying function is defined.
+        Returns
+        -------
+        str
+            The name of the module in which the function was originally declared.
+        """
+        return self.__function.__module__
+
+    def getModuleWithCallableName(self) -> str:
+        """
+        Get the fully qualified name of the callable, including its module.
+        Returns
+        -------
+        str
+            A string consisting of the module name and the callable name, separated by a dot.
+        """
+        return f"{self.getModuleName()}.{self.getName()}"
+
+    def getDocstring(self) -> str:
+        """
+        Retrieve the docstring of the callable function.
+        Returns
+        -------
+        str
+            The docstring associated with the function. Returns an empty string if no docstring is present.
+        """
+        return self.__function.__doc__ or ""
+
+    def getSourceCode(self) -> str:
+        """
+        Retrieve the source code of the wrapped callable.
+        Returns
+        -------
+        str
+            The source code of the callable function as a string. If the source code
+            cannot be retrieved, a ReflectionAttributeError is raised.
+        Raises
+        ------
+        ReflectionAttributeError
+            If the source code cannot be obtained due to an OSError.
+        """
+        try:
+            return inspect.getsource(self.__function)
+        except OSError as e:
+            raise ReflectionAttributeError(f"Could not retrieve source code: {e}")
+
+    def getFile(self) -> str:
+        """
+        Retrieve the filename where the underlying callable function is defined.
+        Returns
+        -------
+        str
+            The absolute path to the source file containing the callable.
+        Raises
+        ------
+        TypeError
+            If the underlying object is a built-in function or method, or if its source file cannot be determined.
+        """
+        return inspect.getfile(self.__function)
+
+    def call(self, *args, **kwargs):
+        """
+        Call the wrapped function with the provided arguments.
+        If the wrapped function is asynchronous, it will be executed using `asyncio.run`.
+        Parameters
+        ----------
+        *args : tuple
+            Positional arguments to pass to the function.
+        **kwargs : dict
+            Keyword arguments to pass to the function.
+        Returns
+        -------
+        Any
+            The result returned by the function call.
+        Raises
+        ------
+        Exception
+            Propagates any exception raised by the called function.
+        """
+        if inspect.iscoroutinefunction(self.__function):
+            return Coroutine(self.__function(*args, **kwargs)).run()
+        return self.__function(*args, **kwargs)
+
+    def getDependencies(self) -> CallableDependency:
+        """
+        Analyzes the callable associated with this instance and retrieves its dependencies.
+        CallableDependency
+            An object containing information about the callable's dependencies, including:
+            - resolved: dict
+                A dictionary mapping parameter names to their resolved values (e.g., default values or injected dependencies).
+            - unresolved: list of str
+                A list of parameter names that could not be resolved (i.e., parameters without default values or missing annotations).
+        Notes
+        -----
+        This method leverages the `ReflectDependencies` utility to inspect the callable and determine which dependencies are satisfied and which remain unresolved.
+        """
+        return ReflectDependencies().getCallableDependencies(self.__function)

orionis/services/introspection/dependencies/reflect_dependencies.py

@@ -11,16 +11,16 @@ class ReflectDependencies(IReflectDependencies):
     This class is used to reflect dependencies of a given object.
     """
 
-    def __init__(self, obj):
+    def __init__(self, target = None):
         """
         Initializes the ReflectDependencies instance with the given object.
 
         Parameters
         ----------
-        obj : Any
+        target : Any
             The object whose dependencies are to be reflected.
         """
-        self.__obj = obj
+        self.__target = target
 
     def __paramSkip(self, param_name: str, param: inspect.Parameter) -> bool:
         """
@@ -43,7 +43,7 @@ class ReflectDependencies(IReflectDependencies):
             return True
 
         # Skip 'self' in class methods or instance methods
-        if param_name == 'self' and isinstance(self.__obj, type):
+        if param_name == 'self' and isinstance(self.__target, type):
             return True
 
         # Skip special parameters like *args and **kwargs
@@ -90,7 +90,7 @@ class ReflectDependencies(IReflectDependencies):
             - resolved: Dictionary of resolved dependencies with their names and values.
             - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
         """
-        signature = self.__inspectSignature(self.__obj.__init__)
+        signature = self.__inspectSignature(self.__target.__init__)
         resolved_dependencies: Dict[str, Any] = {}
         unresolved_dependencies: List[str] = []
 
@@ -141,7 +141,58 @@ class ReflectDependencies(IReflectDependencies):
             - resolved: Dictionary of resolved dependencies with their names and values.
             - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
         """
-        signature = self.__inspectSignature(getattr(self.__obj, method_name))
+        signature = self.__inspectSignature(getattr(self.__target, method_name))
+        resolved_dependencies: Dict[str, Any] = {}
+        unresolved_dependencies: List[str] = []
+
+        for param_name, param in signature.parameters.items():
+
+            # Skip parameters that are not relevant for dependency resolution
+            if self.__paramSkip(param_name, param):
+                continue
+
+            # Add to the list of unresolved dependencies if it has no default value or annotation
+            if param.annotation is param.empty and param.default is param.empty:
+                unresolved_dependencies.append(param_name)
+                continue
+
+            # Parameters with default values
+            if param.default is not param.empty:
+                resolved_dependencies[param_name] = param.default
+                continue
+
+            # If the parameter has an annotation, it is added to the list of resolved dependencies
+            if param.annotation is not param.empty:
+                module_path = param.annotation.__module__
+                resolved_dependencies[param_name] = ResolvedDependency(
+                    module_name=module_path,
+                    class_name=param.annotation.__name__,
+                    type=param.annotation,
+                    full_class_path=f"{module_path}.{param.annotation.__name__}"
+                )
+
+        return MethodDependency(
+            resolved=resolved_dependencies,
+            unresolved=unresolved_dependencies
+        )
+
+    def getCallableDependencies(self, fn: callable) -> MethodDependency:
+        """
+        Get the resolved and unresolved dependencies from a callable function.
+
+        Parameters
+        ----------
+        fn : callable
+            The function to inspect.
+
+        Returns
+        -------
+        MethodDependency
+            A structured representation of the callable dependencies, containing:
+            - resolved: Dictionary of resolved dependencies with their names and values.
+            - unresolved: List of unresolved dependencies (parameter names without default values or annotations).
+        """
+        signature = inspect.signature(fn)
         resolved_dependencies: Dict[str, Any] = {}
         unresolved_dependencies: List[str] = []
 

{orionis-0.315.0.dist-info → orionis-0.317.0.dist-info}/METADATA

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

{orionis-0.315.0.dist-info → orionis-0.317.0.dist-info}/RECORD

@@ -135,7 +135,8 @@ orionis/console/output/console.py,sha256=TE_Hl720ADd82dbERFSWhkoQRukDQZmETSw4nkw
 orionis/console/output/executor.py,sha256=bdvkzW2-buy0BPpy2r5qUGrRFW2Ay6k-5rSeHb0gQ3o,3352
 orionis/console/output/progress_bar.py,sha256=vFy582z6VJS46LV6tuyrmr9qvdVeTEtw3hyNcEHezeg,3088
 orionis/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
-orionis/container/container.py,sha256=bUpUV_4_Zi5vpj7R86glNVB0iLQk67qXJAe1uEfhgKM,19474
+orionis/container/container.py,sha256=BPBO0i1EgL-9g9sgDotrInM2UiuDMT7TNDRHDdrQCZo,30121
+orionis/container/entities/binding.py,sha256=Qp6Lf4XUDp2NjqXDAC2lzvhOFQWiBDKiGFcKfwb4axw,4342
 orionis/container/enums/lifetimes.py,sha256=RqQmugMIB1Ev_j_vFLcWorndm-to7xg4stQ7yKFDdDw,190
 orionis/container/exceptions/container_exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
 orionis/container/exceptions/type_error_exception.py,sha256=cYuvoXVOgRYj3tZPfK341aUERkf33-buOiI2eXxcrAw,470
@@ -231,7 +232,7 @@ orionis/foundation/contracts/config.py,sha256=Rpz6U6t8OXHO9JJKSTnCimytXE-tfCB-1i
 orionis/foundation/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/exceptions/integrity.py,sha256=mc4pL1UMoYRHEmphnpW2oGk5URhu7DJRREyzHaV-cs8,472
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=WZcHmEO3h3dERaYQeoVsndh99qrFHz6vNPlYjApsZ-w,4960
+orionis/metadata/framework.py,sha256=IhaXribsZwgUQ1ZD4sXOCEanSM6ZfeiOASiDyOpzViA,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -257,6 +258,8 @@ orionis/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 orionis/services/introspection/reflection.py,sha256=6z4VkDICohMIkm9jEd7nmFABwVuU7SBoTFaH3tq4PGk,10897
 orionis/services/introspection/abstract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/abstract/reflection_abstract.py,sha256=SPK2X11VvGORxxPOYloaD6hPAvky--obRU4CO1DE4zM,43865
+orionis/services/introspection/callables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/services/introspection/callables/reflection_callable.py,sha256=AWTw9T9DGpCscwvrqYtYAYdTeoJqIHzdRDS29Sb5cSI,5667
 orionis/services/introspection/concretes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/concretes/reflection_concrete.py,sha256=1GxD-y8LPGL6kI4Y3XbeLcFjR5Y8cOqbVEPCtPnsuYA,50982
 orionis/services/introspection/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -266,7 +269,7 @@ orionis/services/introspection/contracts/reflection_concrete.py,sha256=9ZQjJpZwv
 orionis/services/introspection/contracts/reflection_instance.py,sha256=D9sH-uOSZ_E7luAfbjI_ML6kfxuO5MtvLk6037iQJ7o,20936
 orionis/services/introspection/contracts/reflection_module.py,sha256=YLqKg5EhaddUBrytMHX1-uz9mNsRISK1iVyG_iUiVYA,9666
 orionis/services/introspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/dependencies/reflect_dependencies.py,sha256=TsOtFPKROOSSKYgW1AHUP46RcGyvGAd3XU5vnUHGJfQ,7132
+orionis/services/introspection/dependencies/reflect_dependencies.py,sha256=xjY9RRBbALfifoefUuHu2EU5XUNdV9zKFaJ9-x7TP2I,9303
 orionis/services/introspection/dependencies/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/dependencies/entities/class_dependencies.py,sha256=pALvV_duAvDYmNp7PJYWkpIIQYmqWxuc_RGruEckfPA,2063
 orionis/services/introspection/dependencies/entities/method_dependencies.py,sha256=FDwroILMPhqPxaxisPVEeKeLUg57GNQ4tQfWjGMh40E,2194
@@ -340,7 +343,7 @@ orionis/test/suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 orionis/test/suite/test_unit.py,sha256=MWgW8dRCRyT1XZ5LsbXQ7-KVPReasoXwzEEL1EWWfE4,52190
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=jXZkbITBknbUwm_mD8bcTiwLDvsFkrO9qrf0ZgPwqxc,4903
-orionis-0.315.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.317.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=kvWgiW3ADEZf718dGsMPtDh_rmOSx1ypEInKm7_6ZPQ,601
@@ -411,13 +414,14 @@ tests/services/environment/test_services_environment.py,sha256=fdkjwbY-aDEA1FT-9
 tests/services/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/test_reflection.py,sha256=ZApQeaDxYLsrfGN6UqEDPbyNzocMV9CURflQ35YMfqk,13678
 tests/services/inspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/inspection/dependencies/test_reflect_dependencies.py,sha256=z0C9KkhV27Y7jKpLSCN9XCmHbjJDCPbBb7NkRFs3oMI,5803
+tests/services/inspection/dependencies/test_reflect_dependencies.py,sha256=xjcbfWlCT-QuI0wDgXbbsfvWG5phvrvPcfMOwmUnpHQ,7279
 tests/services/inspection/dependencies/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/dependencies/mocks/mock_user.py,sha256=RxATxe0-Vm4HfX5jKz9Tny42E2fmrdtEN6ZEntbqRL8,912
 tests/services/inspection/dependencies/mocks/mock_user_controller.py,sha256=P3sOUXVZ55auudwiNtvNCEQuTz0cgAZjvhicLZ4xaz4,1208
 tests/services/inspection/dependencies/mocks/mock_users_permissions.py,sha256=oENXbS2qmQUudYSmnhB8fgHBqXZdbplplB-Y2nbx4hw,1388
 tests/services/inspection/reflection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/reflection/test_reflection_abstract.py,sha256=MbGDfCDkfj8wVJcyAlwV6na98JLzbGaYa3QjXR1alL8,27395
+tests/services/inspection/reflection/test_reflection_callable.py,sha256=GBZL9oIwfBDfhQ3VXVrZDkdwoTkymMqLfFQSBCSs8pE,7021
 tests/services/inspection/reflection/test_reflection_concrete.py,sha256=5-iQh1whfpBa47jBWwtg-MIk6ysg92my5J9JdrTBm5E,44622
 tests/services/inspection/reflection/test_reflection_instance.py,sha256=ZCFTLY_KtLAIq58PuDWak-T1c2PcCKiwTOdI9EDubww,46281
 tests/services/inspection/reflection/test_reflection_module.py,sha256=Cl-3kWoJMQ2ufOO4VP6M28Tk6kmY4OhVEoW_b0wqw7Y,19849
@@ -440,8 +444,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=yeVwl-VcwkWSQYyxZu
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=MrGK3ZimedL0b5Ydu69Dg8Iul017AzLTm7VPxpXlpfU,4315
 tests/testing/test_testing_unit.py,sha256=DjLBtvVn8B1KlVJNNkstBT8_csA1yeaMqnGrbanN_J4,7438
-orionis-0.315.0.dist-info/METADATA,sha256=0NOqOKXInnuQHsnUh77kdS3DM3oZcqZjRn6uq6lloD8,4772
-orionis-0.315.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.315.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.315.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.315.0.dist-info/RECORD,,
+orionis-0.317.0.dist-info/METADATA,sha256=ArEDpHbIszs0kFP63nOxlOuuEJygJsbjqGR8xCRQ9gM,4772
+orionis-0.317.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.317.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.317.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.317.0.dist-info/RECORD,,

tests/services/inspection/dependencies/test_reflect_dependencies.py

@@ -1,3 +1,4 @@
+import asyncio
 from orionis.services.introspection.dependencies.reflect_dependencies import (
     ReflectDependencies,
     ClassDependency,
@@ -91,4 +92,36 @@ class TestReflectDependencies(TestCase):
         self.assertEqual(dep_permissions.module_name, 'builtins')
         self.assertEqual(dep_permissions.class_name, 'list')
         self.assertEqual(dep_permissions.full_class_path, 'builtins.list')
-        self.assertEqual(dep_permissions.type, list[str])
+        self.assertEqual(dep_permissions.type, list[str])
+
+    async def testReflectionDependenciesGetCallableDependencies(self):
+        """
+        Tests the `getCallableDependencies` method of the `ReflectDependencies` class for a callable function.
+        This test verifies:
+            - The returned dependencies are an instance of `MethodDependency`.
+            - There are no unresolved dependencies.
+            - The 'x' and 'y' parameters are correctly resolved as instances of `ResolvedDependency` with the expected
+              module name, class name, full class path, and type (`int`).
+        """
+
+        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)
+
+        # Check Instance of MethodDependency
+        self.assertIsInstance(callable_dependencies, MethodDependency)
+
+        # Check unresolved dependencies
+        self.assertEqual(callable_dependencies.unresolved, [])
+
+        # Check Instance of ResolvedDependency for 'x'
+        dep_x:ResolvedDependency = callable_dependencies.resolved.get('x')
+        self.assertEqual(dep_x, 3)
+
+        # Check Instance of ResolvedDependency for 'y'
+        dep_y:ResolvedDependency = callable_dependencies.resolved.get('y')
+        self.assertEqual(dep_y, 4)

tests/services/inspection/reflection/test_reflection_callable.py

@@ -0,0 +1,157 @@
+from orionis.services.introspection.callables.reflection_callable import ReflectionCallable
+from orionis.unittesting import TestCase
+from orionis.services.introspection.exceptions.reflection_type_error import ReflectionTypeError
+from orionis.services.introspection.exceptions.reflection_attribute_error import ReflectionAttributeError
+from orionis.services.introspection.dependencies.entities.method_dependencies import MethodDependency as CallableDependency
+from orionis.services.introspection.dependencies.reflect_dependencies import ReflectDependencies
+
+class TestReflectionCallable(TestCase):
+
+    async def testInitValidFunction(self):
+        """
+        Tests that a ReflectionCallable object can be correctly initialized with a valid function.
+        Verifies that the callable stored in the ReflectionCallable instance matches the original function.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        self.assertEqual(rc.getCallable(), sample_function)
+
+    async def testInitInvalid(self):
+        """
+        Test that initializing ReflectionCallable with an invalid argument (e.g., an integer)
+        raises a ReflectionTypeError.
+        """
+        with self.assertRaises(ReflectionTypeError):
+            ReflectionCallable(123)
+
+    async def testGetName(self):
+        """
+        Tests that the ReflectionCallable.getName() method correctly returns the name of the provided function.
+
+        This test defines a sample function, wraps it with ReflectionCallable, and asserts that getName()
+        returns the function's name as a string.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        self.assertEqual(rc.getName(), "sample_function")
+
+    async def testGetModuleName(self):
+        """
+        Tests that the getModuleName method of ReflectionCallable returns the correct module name
+        for a given function. It verifies that the module name returned matches the __module__ attribute
+        of the sample function.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        self.assertEqual(rc.getModuleName(), sample_function.__module__)
+
+    async def testGetModuleWithCallableName(self):
+        """
+        Tests that the `getModuleWithCallableName` method of the `ReflectionCallable` class
+        correctly returns the fully qualified name of a given callable, including its module
+        and function name.
+
+        The test defines a sample function, wraps it with `ReflectionCallable`, and asserts
+        that the returned string matches the expected format: "<module>.<function_name>".
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        expected = f"{sample_function.__module__}.sample_function"
+        self.assertEqual(rc.getModuleWithCallableName(), expected)
+
+    async def testGetDocstring(self):
+        """
+        Tests that the getDocstring method of ReflectionCallable correctly retrieves the docstring from a given function.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        self.assertIn("Sample docstring", rc.getDocstring())
+
+    async def testGetSourceCode(self):
+        """
+        Tests that the getSourceCode method of ReflectionCallable correctly retrieves
+        the source code of a given function. Verifies that the returned code contains
+        the function definition for 'sample_function'.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        code = rc.getSourceCode()
+        self.assertIn("def sample_function", code)
+
+    async def testGetSourceCodeError(self):
+        """
+        Test that ReflectionCallable.getSourceCode() raises a ReflectionTypeError
+        when called on a built-in function (e.g., len) that does not have accessible source code.
+        """
+        with self.assertRaises(ReflectionTypeError):
+            rc = ReflectionCallable(len)
+            rc.getSourceCode()
+
+    async def testGetFile(self):
+        """
+        Tests that the getFile() method of the ReflectionCallable class returns the correct file path
+        for a given callable. Verifies that the returned file path ends with '.py', indicating it is a
+        Python source file.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        file_path = rc.getFile()
+        self.assertTrue(file_path.endswith(".py"))
+
+    async def testCallSync(self):
+        """
+        Tests the synchronous call functionality of the ReflectionCallable class.
+
+        This test defines a sample function with one required and one optional argument,
+        wraps it with ReflectionCallable, and asserts that calling it with specific arguments
+        returns the expected result.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        self.assertEqual(rc.call(1, 2), 3)
+
+    async def testCallAsync(self):
+        """
+        Tests the ReflectionCallable's ability to call an asynchronous function synchronously.
+
+        This test defines an asynchronous function `sample_async_function` that takes two arguments and returns their sum.
+        It then wraps this function with `ReflectionCallable` and asserts that calling it with arguments (1, 2) returns 3.
+        """
+        async def sample_async_function(a, b=2):
+            """Async docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_async_function)
+        self.assertEqual(await rc.call(1, 2), 3)
+
+    async def testGetDependencies(self):
+        """
+        Tests the getDependencies method of the ReflectionCallable class.
+
+        This test defines a sample function with one required and one default argument,
+        creates a ReflectionCallable instance for it, and retrieves its dependencies.
+        It then asserts that the returned dependencies object has both 'resolved' and
+        'unresolved' attributes.
+        """
+        def sample_function(a, b=2):
+            """Sample docstring."""
+            return a + b
+        rc = ReflectionCallable(sample_function)
+        deps = rc.getDependencies()
+        self.assertTrue(hasattr(deps, "resolved"))
+        self.assertTrue(hasattr(deps, "unresolved"))