orionis 0.657.0__tar.gz → 0.659.0__tar.gz

{orionis-0.657.0/orionis.egg-info → orionis-0.659.0}/PKG-INFO

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

{orionis-0.657.0 → orionis-0.659.0}/orionis/container/container.py

@@ -3,7 +3,7 @@ import asyncio
 import inspect
 import threading
 import typing
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Union
 from orionis.container.context.manager import ScopeManager
 from orionis.container.context.scope import ScopedContext
 from orionis.container.contracts.container import IContainer
@@ -11,11 +11,6 @@ from orionis.container.entities.binding import Binding
 from orionis.container.enums.lifetimes import Lifetime
 from orionis.container.exceptions import OrionisContainerException
 from orionis.container.exceptions.container import OrionisContainerTypeError
-from orionis.container.validators import (
-    IsCallable,
-    IsValidAlias,
-    LifetimeValidator
-)
 from orionis.services.introspection.abstract.reflection import ReflectionAbstract
 from orionis.services.introspection.callables.reflection import ReflectionCallable
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
@@ -35,7 +30,9 @@ class Container(IContainer):
     # This lock ensures that only one thread can create or access instances at a time
     _lock = threading.RLock()  # RLock allows reentrant locking
 
-    def __new__(cls) -> 'Container':
+    def __new__(
+        cls
+    ) -> 'Container':
         """
         Creates and returns a singleton instance for each specific class.
 
@@ -79,7 +76,9 @@ class Container(IContainer):
             # Return the newly created instance
             return instance
 
-    def __init__(self) -> None:
+    def __init__(
+        self
+    ) -> None:
         """
         Initializes the internal state of the container instance.
 
@@ -113,7 +112,7 @@ class Container(IContainer):
             self.__singleton_cache = {}   # Caches singleton instances
 
             # Mark this instance as initialized to prevent re-initialization
-            self.__initialized = True
+            self.__initialized = True # NOSONAR
 
     def __handleSyncAsyncResult(
         self,
@@ -445,6 +444,7 @@ class Container(IContainer):
 
         # If an alias is provided, validate and use it directly
         if alias:
+
             # Check for None, empty string, or whitespace-only alias
             if alias is None or alias == "" or str(alias).isspace():
                 raise OrionisContainerTypeError(
@@ -970,68 +970,76 @@ class Container(IContainer):
 
     def callable(
         self,
-        alias: str,
         fn: Callable[..., Any],
         *,
-        lifetime: Lifetime = Lifetime.TRANSIENT
+        alias: str
     ) -> Optional[bool]:
         """
-        Registers a function or factory under a given alias.
+        Registers a function or factory under a given alias with transient lifetime.
+
+        This method registers a callable (function or factory) in the container and associates it with a unique alias.
+        The registered function will be resolved with transient lifetime, meaning a new result is produced each time it is invoked.
+        The alias is validated for uniqueness and correctness, and any previous registration under the same alias is removed.
 
         Parameters
         ----------
-        alias : str
-            The alias to register the function under.
         fn : Callable[..., Any]
-            The function or factory to register.
-        lifetime : Lifetime, optional
-            The lifetime of the function registration (default is TRANSIENT).
+            The function or factory to register. Must be a valid Python callable.
+        alias : str
+            The alias to register the function under. Must be a non-empty, valid string.
 
         Returns
         -------
-        bool
-            True if the function was registered successfully.
+        bool or None
+            Returns True if the function was registered successfully.
+            Returns None if registration fails due to an exception.
 
         Raises
         ------
         OrionisContainerTypeError
             If the alias is invalid or the function is not callable.
         OrionisContainerException
-            If the lifetime is not allowed for the function signature.
-        """
+            If an unexpected error occurs during registration.
 
-        # Normalize and validate the lifetime parameter
-        lifetime = LifetimeValidator(lifetime)
+        Notes
+        -----
+        - The function is registered with transient lifetime, so each invocation produces a new result.
+        - If a service is already registered under the same alias, it is removed before registering the new function.
+        - The alias is validated for uniqueness and correctness.
+        """
 
-        # Ensure that the alias is a valid string
-        IsValidAlias(alias)
+        try:
+            # Validate and normalize the alias using the internal alias key generator
+            alias = self.__makeAliasKey(lambda: None, alias)
 
-        # Validate that the function is callable
-        IsCallable(fn)
+            # Ensure the provided fn is actually callable
+            if not callable(fn):
+                raise OrionisContainerTypeError(
+                    f"Expected a callable type, but got {type(fn).__name__} instead."
+                )
 
-        # Inspect the function signature
-        params: ResolveArguments = ReflectionCallable(fn).getDependencies()
+            # Remove any existing registration under this alias
+            self.drop(None, alias)
 
-        # 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."
+            # Register the function in the bindings dictionary with transient lifetime
+            self.__bindings[alias] = Binding(
+                function=fn,
+                lifetime=Lifetime.TRANSIENT,
+                alias=alias
             )
 
-        # If the service is already registered, drop it
-        self.drop(None, alias)
+            # Register the alias for lookup in the aliases dictionary
+            self.__aliases[alias] = self.__bindings[alias]
 
-        # Register the function with the specified alias and lifetime
-        self.__bindings[alias] = Binding(
-            function=fn,
-            lifetime=lifetime,
-            alias=alias
-        )
+            # Return True to indicate successful registration
+            return True
 
-        # Register the function as a binding
-        self.__aliases[alias] = self.__bindings[alias]
+        except Exception as e:
 
-        return True
+            # Raise a container exception with details if registration fails
+            raise OrionisContainerException(
+                f"Unexpected error registering callable: {e}"
+            ) from e
 
     def bound(
         self,
@@ -1129,7 +1137,7 @@ class Container(IContainer):
         # Return None if no binding is found for the requested abstract type or alias
         return None
 
-    def __validateBinding(
+    def __validateBinding( # NOSONAR
         self,
         binding: Binding,
         requested_key: Any
@@ -1205,7 +1213,7 @@ class Container(IContainer):
         # Additional validations based on binding type
         self.__validateBindingByType(binding, requested_key)
 
-    def __validateBindingByType(
+    def __validateBindingByType( # NOSONAR
         self,
         binding: Binding,
         requested_key: Any
@@ -1272,7 +1280,7 @@ class Container(IContainer):
                     f"Invalid alias in binding for '{requested_key}': alias cannot be empty"
                 )
 
-    def drop(
+    def drop( # NOSONAR
         self,
         abstract: Callable[..., Any] = None,
         alias: str = None
@@ -1888,7 +1896,8 @@ class Container(IContainer):
 
             # If there are unresolved dependencies, raise an exception
             if dependencies.unresolved:
-                unresolved_args = [name for name in dependencies.unresolved.keys()]
+                unresolved_args = list(dependencies.unresolved.keys())
+
                 raise OrionisContainerException(
                     f"Cannot invoke callable '{getattr(fn, '__name__', str(fn))}' because the following required arguments are missing: [{', '.join(unresolved_args)}]."
                 )
@@ -2046,7 +2055,8 @@ class Container(IContainer):
 
             # Check for unresolved dependencies
             if dependencies.unresolved:
-                unresolved_args = [name for name in dependencies.unresolved.keys()]
+                unresolved_args = list(dependencies.unresolved.keys())
+
                 raise OrionisContainerException(
                     f"Cannot resolve '{name}' because the following required arguments are missing: [{', '.join(unresolved_args)}]."
                 )
@@ -2070,7 +2080,7 @@ class Container(IContainer):
                 f"Error resolving dependencies for '{name}': {str(e)}"
             ) from e
 
-    def __resolveSingleDependency(
+    def __resolveSingleDependency( # NOSONAR
         self,
         name: str,
         param_name: str,
@@ -2228,12 +2238,7 @@ class Container(IContainer):
         try:
 
             # If explicit arguments are provided, attempt direct instantiation or invocation
-            if args or kwargs:
-                if isinstance(type_, type):
-                    # Instantiate the class directly with provided arguments
-                    return type_(*args, **kwargs)
-                elif callable(type_):
-                    # Invoke the callable directly with provided arguments
+            if args or kwargs and callable(type_):
                     return type_(*args, **kwargs)
 
             # Attempt auto-resolution for eligible types
@@ -2958,4 +2963,4 @@ class Container(IContainer):
             except TypeError:
                 raise OrionisContainerException(
                     f"Failed to call method '{method.__name__}': {reflection_error}"
-                ) from reflection_error
+                ) from reflection_error

{orionis-0.657.0 → orionis-0.659.0}/orionis/metadata/framework.py

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

{orionis-0.657.0 → orionis-0.659.0/orionis.egg-info}/PKG-INFO

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