orionis 0.535.0__py3-none-any.whl → 0.537.0__py3-none-any.whl

orionis/console/contracts/event.py

@@ -5,24 +5,32 @@ from orionis.console.enums.event import Event as EventEntity
 
 class IEvent(ABC):
 
-    @abstractmethod
-    def toEntity(
-        self
-    ) -> EventEntity:
+    def misfireGraceTime(
+        self,
+        seconds: int = 60
+    ) -> 'IEvent':
         """
-        Retrieve the event details as an EventEntity instance.
+        Set the misfire grace time for the event.
 
-        This method gathers all relevant attributes of the current Event object,
-        such as its signature, arguments, purpose, random delay, start and end dates,
-        and trigger, and returns them encapsulated in an EventEntity object.
+        This method allows you to specify a grace period (in seconds) during which
+        a missed execution of the event can still be executed. If the event is not
+        executed within this time frame after its scheduled time, it will be skipped.
+
+        Parameters
+        ----------
+        seconds : int
+            The number of seconds to allow for a misfire grace period. Must be a positive integer.
 
         Returns
         -------
-        EventEntity
-            An EventEntity instance containing the event's signature, arguments,
-            purpose, random delay, start date, end date, and trigger.
+        Event
+            Returns the current instance of the Event to allow method chaining.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If the provided seconds is not a positive integer.
         """
-        pass
 
     @abstractmethod
     def purpose(

orionis/console/enums/event.py

@@ -60,4 +60,10 @@ class Event:
     details: Optional[str] = None
 
     # Optional listener that implements IScheduleEventListener
-    listener: Optional[IScheduleEventListener] = None
+    listener: Optional[IScheduleEventListener] = None
+
+    # Maximum number of concurrent instances allowed for the event
+    max_instances: int = 1
+
+    # Grace time in seconds for misfired events
+    misfire_grace_time : Optional[int] = None

orionis/console/tasks/event.py

@@ -77,6 +77,9 @@ class Event(IEvent):
         # Initialize the maximum instances attribute as None
         self.__max_instances: Optional[int] = None
 
+        # Initialize the misfire grace time attribute as None
+        self.__misfire_grace_time: Optional[int] = None
+
     def toEntity(
         self
     ) -> EventEntity:
@@ -128,6 +131,14 @@ class Event(IEvent):
         if self.__listener is not None and not issubclass(self.__listener, IScheduleEventListener):
             raise CLIOrionisValueError("Listener must implement IScheduleEventListener interface or be None.")
 
+        # Validate that max_instances is a positive integer if it is set
+        if self.__max_instances is not None and (not isinstance(self.__max_instances, int) or self.__max_instances <= 0):
+            raise CLIOrionisValueError("Max instances must be a positive integer or None.")
+
+        # Validate that misfire_grace_time is a positive integer if it is set
+        if self.__misfire_grace_time is not None and (not isinstance(self.__misfire_grace_time, int) or self.__misfire_grace_time <= 0):
+            raise CLIOrionisValueError("Misfire grace time must be a positive integer or None.")
+
         # Construct and return an EventEntity with the current event's attributes
         return EventEntity(
             signature=self.__signature,
@@ -138,9 +149,48 @@ class Event(IEvent):
             end_date=self.__end_date,
             trigger=self.__trigger,
             details=self.__details,
-            listener=self.__listener
+            listener=self.__listener,
+            max_instances=self.__max_instances,
+            misfire_grace_time=self.__misfire_grace_time
         )
 
+    def misfireGraceTime(
+        self,
+        seconds: int = 60
+    ) -> 'Event':
+        """
+        Set the misfire grace time for the event.
+
+        This method allows you to specify a grace period (in seconds) during which
+        a missed execution of the event can still be executed. If the event is not
+        executed within this time frame after its scheduled time, it will be skipped.
+
+        Parameters
+        ----------
+        seconds : int
+            The number of seconds to allow for a misfire grace period. Must be a positive integer.
+
+        Returns
+        -------
+        Event
+            Returns the current instance of the Event to allow method chaining.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If the provided seconds is not a positive integer.
+        """
+
+        # Validate that the seconds parameter is a positive integer
+        if not isinstance(seconds, int) or seconds <= 0:
+            raise CLIOrionisValueError("Misfire grace time must be a positive integer.")
+
+        # Set the internal misfire grace time attribute
+        self.__misfire_grace_time = seconds
+
+        # Return self to support method chaining
+        return self
+
     def purpose(
         self,
         purpose: str

orionis/console/tasks/schedule.py

@@ -482,8 +482,8 @@ class Schedule(ISchedule):
                 # Invoke the listener, handling both coroutine and regular functions
                 try:
 
-                    # Use Coroutine to handle both sync and async listeners
-                    Coroutine(listener).invoke(event_data, self)
+                    # Execute coroutine listeners using container's invoke method
+                    self.__app.invoke(listener, event_data, self)
 
                 except BaseException as e:
 
@@ -550,26 +550,13 @@ class Schedule(ISchedule):
 
                 # Initialize the listener if it's a class
                 if isinstance(listener, type):
-                    listener = listener()
+                    listener = self.__app.make(listener)
 
                 # Check if the listener has a method corresponding to the event type
                 if hasattr(listener, scheduler_event) and callable(getattr(listener, scheduler_event)):
 
-                    # Retrieve the method from the listener
-                    listener_method = getattr(listener, scheduler_event)
-
                     # Invoke the listener method, handling both coroutine and regular functions
-                    try:
-
-                        # Use Coroutine to handle both sync and async listener methods
-                        Coroutine(listener_method).invoke(event_data, self)
-
-                    except Exception as e:
-
-                        # Construct and log error message
-                        error_msg = f"An error occurred while invoking the listener_method for event '{scheduler_event}': {str(e)}"
-                        self.__logger.error(error_msg)
-                        raise CLIOrionisRuntimeError(error_msg) from e
+                    self.__app.call(listener, scheduler_event, event_data, self)
 
                 else:
 
@@ -707,7 +694,7 @@ class Schedule(ISchedule):
             and listener invocation for the job error event.
         """
         # Log an error message indicating that the job raised an exception
-        self.__logger.error(f"Task {event.job_id} raised an exception: {event.exception}")
+        self.__logger.error(f"Task '{event.job_id}' raised an exception: {event.exception}")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         job_event_data = self.__getTaskFromSchedulerById(event.job_id)
@@ -758,7 +745,7 @@ class Schedule(ISchedule):
         """
 
         # Log an informational message indicating that the job has been submitted
-        self.__logger.info(f"Task {event.job_id} submitted to executor.")
+        self.__logger.info(f"Task '{event.job_id}' submitted to executor.")
 
         # Create entity for job submitted event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -793,7 +780,7 @@ class Schedule(ISchedule):
         """
 
         # Log an informational message indicating that the job has been executed
-        self.__logger.info(f"Task {event.job_id} executed.")
+        self.__logger.info(f"Task '{event.job_id}' executed.")
 
         # Create entity for job executed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -828,7 +815,7 @@ class Schedule(ISchedule):
         """
 
         # Log a warning indicating that the job was missed
-        self.__logger.warning(f"Task {event.job_id} was missed. It was scheduled to run at {event.scheduled_run_time}.")
+        self.__logger.warning(f"Task '{event.job_id}' was missed. It was scheduled to run at {event.scheduled_run_time}.")
 
         # Create entity for job missed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -863,7 +850,7 @@ class Schedule(ISchedule):
         """
 
         # Log an error message indicating that the job exceeded maximum instances
-        self.__logger.error(f"Task {event.job_id} exceeded maximum instances")
+        self.__logger.error(f"Task '{event.job_id}' exceeded maximum instances")
 
         # Create entity for job max instances event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -897,7 +884,7 @@ class Schedule(ISchedule):
         """
 
         # Log the removal of the job
-        self.__logger.info(f"Task {event.job_id} has been removed.")
+        self.__logger.info(f"Task '{event.job_id}' has been removed.")
 
         # Create entity for job removed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -944,7 +931,9 @@ class Schedule(ISchedule):
                         trigger=entity.trigger,
                         id=signature,
                         name=signature,
-                        replace_existing=True
+                        replace_existing=True,
+                        max_instances=entity.max_instances,
+                        misfire_grace_time=entity.misfire_grace_time
                     )
 
                     # If a listener is associated with the event, register it

orionis/container/container.py

@@ -17,6 +17,8 @@ from orionis.services.introspection.callables.reflection import ReflectionCallab
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
 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.services.introspection.instances.reflection import ReflectionInstance
 
 class Container(IContainer):
 
@@ -206,9 +208,72 @@ class Container(IContainer):
 
         try:
 
-            # Check if the callable is a coroutine function
-            result = fn(*args, **kwargs)
-            return self.__handleSyncAsyncResult(result)
+            # Count the total number of provided arguments
+            total_provided_args = len(args) + len(kwargs)
+
+            # Inspect the callable to determine its signature and parameters
+            dependencies = ReflectDependencies(fn).getCallableDependencies()
+            total_dependencies = len(dependencies.resolved) + len(dependencies.unresolved)
+
+            # If the callable does not require any dependencies, invoke directly
+            if total_dependencies == 0:
+                result = fn(*args, **kwargs)
+                return self.__handleSyncAsyncResult(result)
+
+            # If enough arguments are provided, invoke directly
+            if total_provided_args >= total_dependencies:
+                result = fn(*args, **kwargs)
+                return self.__handleSyncAsyncResult(result)
+
+            # If not enough arguments are provided, attempt to resolve missing dependencies
+            if total_provided_args < total_dependencies:
+
+                # New lists to hold the final arguments to pass to the callable
+                n_args = []
+                n_kwargs = {}
+
+                # Iterate through the function's required arguments in order
+                args_index = 0
+
+                # Iterate over all dependencies in the order they were defined
+                for name, dep in dependencies.ordered.items():
+
+                    # Check if the argument was provided positionally and hasn't been used yet
+                    if args_index < len(args) and name not in kwargs:
+
+                        # Add the positional argument to the new list
+                        n_args.append(args[args_index])
+
+                        # Move to the next positional argument
+                        args_index += 1
+
+                    # Check if the argument was provided as a keyword argument
+                    elif name in kwargs:
+
+                        # Add the keyword argument to the new dictionary
+                        n_kwargs[name] = kwargs[name]
+
+                        # Remove the argument from the original kwargs to avoid duplication
+                        del kwargs[name]
+
+                    # If not provided, attempt to resolve it from the container
+                    else:
+
+                        n_kwargs[name] = self.__resolveSingleDependency(
+                            getattr(fn, '__name__', str(fn)),
+                            name,
+                            dep
+                        )
+
+                # Add any remaining positional arguments that weren't mapped to specific parameters
+                n_args.extend(args[args_index:])
+
+                # Add any remaining keyword arguments that weren't processed
+                n_kwargs.update(kwargs)
+
+                # Invoke the function with the resolved arguments
+                result = fn(*n_args, **n_kwargs)
+                return self.__handleSyncAsyncResult(result)
 
         except TypeError as e:
 
@@ -219,8 +284,9 @@ class Container(IContainer):
 
             # Raise a more informative exception with the function name and signature
             raise OrionisContainerException(
-                f"Failed to invoke function [{function_name}] with the provided arguments: {e}\n"
-                f"Expected function signature: [{signature}]"
+                f"Failed to invoke function [{function_name}] with the provided arguments: {e}. "
+                f"Note that this may include a reference to the same 'self' object.\n"
+                f"Expected function signature: {function_name}{signature}"
             ) from e
 
     def transient(
@@ -2360,6 +2426,79 @@ class Container(IContainer):
                 f"Method '{method_name}' not found or not callable on instance '{type(instance).__name__}'."
             )
 
+    def invoke(
+        self,
+        fn: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Invokes a callable with automatic dependency injection and sync/async handling.
+
+        Parameters
+        ----------
+        fn : Callable
+            The callable to invoke.
+        *args : tuple
+            Positional arguments to pass to the callable.
+        **kwargs : dict
+            Keyword arguments to pass to the callable.
+
+        Returns
+        -------
+        Any
+            The result of the callable invocation.
+        """
+
+        # Validate that fn is indeed callable
+        if not callable(fn):
+            raise OrionisContainerException(
+                f"Provided fn '{getattr(fn, '__name__', str(fn))}' is not callable."
+            )
+
+        # Execute the callable with appropriate handling
+        return self.__executeMethod(fn, *args, **kwargs)
+
+    async def invokeAsync(
+        self,
+        fn: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Async version of invoke for when you're in an async context and need to await the result.
+
+        Parameters
+        ----------
+        fn : Callable
+            The callable to invoke.
+        *args : tuple
+            Positional arguments to pass to the callable.
+        **kwargs : dict
+            Keyword arguments to pass to the callable.
+
+        Returns
+        -------
+        Any
+            The result of the callable invocation, properly awaited if async.
+        """
+
+        # Validate that fn is indeed callable
+        if not callable(fn):
+            raise OrionisContainerException(
+                f"Provided fn '{getattr(fn, '__name__', str(fn))}' is not callable."
+            )
+
+        # Execute the callable with appropriate handling
+        result = self.__executeMethod(fn, *args, **kwargs)
+
+        # If the result is a coroutine, await it
+        if asyncio.iscoroutine(result):
+            return await result
+
+        # Otherwise, return the result directly
+        return result
+
     def __executeMethod(
         self,
         method: Callable,

orionis/container/contracts/container.py

@@ -449,3 +449,55 @@ class IContainer(ABC):
             The result of the method call, properly awaited if async.
         """
         pass
+
+    @abstractmethod
+    def invoke(
+        self,
+        fn: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Invokes a callable with automatic dependency injection and sync/async handling.
+
+        Parameters
+        ----------
+        fn : Callable
+            The callable to invoke.
+        *args : tuple
+            Positional arguments to pass to the callable.
+        **kwargs : dict
+            Keyword arguments to pass to the callable.
+
+        Returns
+        -------
+        Any
+            The result of the callable invocation.
+        """
+        pass
+
+    @abstractmethod
+    async def invokeAsync(
+        self,
+        fn: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Async version of invoke for when you're in an async context and need to await the result.
+
+        Parameters
+        ----------
+        fn : Callable
+            The callable to invoke.
+        *args : tuple
+            Positional arguments to pass to the callable.
+        **kwargs : dict
+            Keyword arguments to pass to the callable.
+
+        Returns
+        -------
+        Any
+            The result of the callable invocation, properly awaited if async.
+        """
+        pass

orionis/failure/base/handler.py

@@ -13,7 +13,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         # Example: OrionisContainerException
     ]
 
-    async def destructureException(self, e: BaseException) -> Throwable:
+    async def destructureException(self, exception: BaseException) -> Throwable:
         """
         Converts an exception into a structured `Throwable` object containing detailed information.
 
@@ -35,13 +35,13 @@ class BaseExceptionHandler(IBaseExceptionHandler):
 
         # Create and return a Throwable object with detailed exception information
         return Throwable(
-            classtype=type(e),                              # The class/type of the exception
-            message=str(e),                                 # The exception message as a string
-            args=e.args,                                    # The arguments passed to the exception
-            traceback=getattr(e, '__traceback__', None)     # The traceback object, if available
+            classtype=type(exception),                              # The class/type of the exception
+            message=str(exception),                                 # The exception message as a string
+            args=exception.args,                                    # The arguments passed to the exception
+            traceback=getattr(exception, '__traceback__', None)     # The traceback object, if available
         )
 
-    async def shouldIgnoreException(self, e: BaseException) -> bool:
+    async def shouldIgnoreException(self, exception: BaseException) -> bool:
         """
         Determines if the exception should be ignored (not handled) by the handler.
 
@@ -57,11 +57,11 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         """
 
         # Ensure the provided object is an exception
-        if not isinstance(e, BaseException):
-            raise TypeError(f"Expected BaseException, got {type(e).__name__}")
+        if not isinstance(exception, BaseException):
+            raise TypeError(f"Expected BaseException, got {type(exception).__name__}")
 
         # Convert the exception into a structured Throwable object
-        throwable = await self.destructureException(e)
+        throwable = await self.destructureException(exception)
 
         # Check if the exception type is in the list of exceptions to ignore
         return hasattr(self, 'dont_catch') and throwable.classtype in self.dont_catch

orionis/failure/catch.py

@@ -1,17 +1,12 @@
 from typing import Any
 from orionis.console.kernel import KernelCLI
-from orionis.console.output.contracts.console import IConsole
 from orionis.console.tasks.schedule import Schedule
 from orionis.failure.contracts.catch import ICatch
 from orionis.failure.contracts.handler import IBaseExceptionHandler
 from orionis.foundation.contracts.application import IApplication
-from orionis.services.asynchrony.coroutines import Coroutine
-from orionis.services.log.contracts.log_service import ILogger
-import asyncio
 
 class Catch(ICatch):
 
-
     def __init__(self, app: IApplication) -> None:
         """
         Initializes the Catch handler with application services for console output and logging.
@@ -40,11 +35,8 @@ class Catch(ICatch):
         error reporting and output.
         """
 
-        # Retrieve the console output service from the application container
-        self.__console: IConsole = app.make('x-orionis.console.output.console')
-
-        # Retrieve the logger service from the application container
-        self.__logger: ILogger = app.make('x-orionis.services.log.log_service')
+        # Store the application instance
+        self.__app: IApplication = app
 
         # Retrieve the console output service from the application container
         self.__exception_handler: IBaseExceptionHandler = app.getExceptionHandler()
@@ -76,89 +68,15 @@ class Catch(ICatch):
         If a valid kernel is provided, the exception details are rendered to the CLI.
         """
 
-        async def handle():
-            """
-            Handles exceptions asynchronously using the provided exception handler.
-
-            This method performs the following steps:
-            1. Determines if the exception should be ignored by invoking the `shouldIgnoreException` method
-               of the exception handler. This method supports both coroutine and regular functions.
-            2. Reports the exception using the `report` method of the exception handler. This method
-               also supports both coroutine and regular functions.
-            3. If the kernel is of type `KernelCLI` or `Any`, it attempts to render the exception
-               for the CLI using the `renderCLI` method of the exception handler. This method supports
-               both coroutine and regular functions.
-
-            Parameters
-            ----------
-            None
-
-            Returns
-            -------
-            Any or None
-            The result of the `renderCLI` method if applicable, otherwise `None`.
-
-            Notes
-            -----
-            - The `self.__exception_handler` is expected to have the methods `shouldIgnoreException`,
-              `report`, and `renderCLI`.
-            - The `self.__logger` is passed to the `report` and `renderCLI` methods for logging purposes.
-            - The `self.__console` is passed to the `renderCLI` method for CLI rendering.
-            """
-
-            # Check if the `shouldIgnoreException` method is a coroutine function
-            if asyncio.iscoroutinefunction(self.__exception_handler.shouldIgnoreException):
-
-                # If it is, await its result to determine if the exception should be ignored
-                if await self.__exception_handler.shouldIgnoreException(e):
-                    return
-
-            else:
-
-                # If it is not a coroutine, call it directly
-                if self.__exception_handler.shouldIgnoreException(e):
-                    return
-
-            # Check if the `report` method is a coroutine function
-            if asyncio.iscoroutinefunction(self.__exception_handler.report):
-
-                # If it is, await its execution to report the exception
-                await self.__exception_handler.report(
-                    exception=e,
-                    log=self.__logger
-                )
-
-            else:
-
-                # If it is not a coroutine, call it directly
-                self.__exception_handler.report(
-                    exception=e,
-                    log=self.__logger
-                )
-
-            # Check if the kernel is of type `KernelCLI` or `Any`
-            if isinstance(kernel, KernelCLI) or isinstance(kernel, Schedule):
-
-                # Check if the `renderCLI` method is a coroutine function
-                if asyncio.iscoroutinefunction(self.__exception_handler.renderCLI):
-
-                    # If it is, await its execution to render the exception for the CLI
-                    return await self.__exception_handler.renderCLI(
-                        request=request,
-                        exception=e,
-                        log=self.__logger,
-                        console=self.__console
-                    )
-
-                else:
-
-                    # If it is not a coroutine, call it directly
-                    return self.__exception_handler.renderCLI(
-                        request=request,
-                        exception=e,
-                        log=self.__logger,
-                        console=self.__console
-                    )
-
-        # Execute the exception handling logic using the Coroutine wrapper
-        Coroutine(handle()).run()
+        # If there is no exception handler, return early
+        if self.__app.call(self.__exception_handler, 'shouldIgnoreException', exception=e):
+            return
+
+        # Report the exception using the exception handler and logger
+        self.__app.call(self.__exception_handler, 'report', exception=e)
+
+        # Check if the kernel is of type `KernelCLI` or `Any`
+        if isinstance(kernel, KernelCLI) or isinstance(kernel, Schedule):
+
+            # Render the exception details to the CLI using the exception handler
+            self.__app.call(self.__exception_handler, 'renderCLI', request=request, exception=e)

orionis/failure/entities/throwable.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-@dataclass(kw_only=True)
+@dataclass(kw_only=True, frozen=True)
 class Throwable:
     """
     Represents a throwable entity (such as an exception or error) within the framework.

orionis/foundation/application.py

@@ -469,10 +469,10 @@ class Application(Container, IApplication):
         if self.__exception_handler is None:
 
             # Return the default exception handler instance
-            return BaseExceptionHandler()
+            return self.make(BaseExceptionHandler)
 
         # Instantiate and return the registered exception handler
-        return self.__exception_handler()
+        return self.make(self.__exception_handler)
 
     def setScheduler(
         self,

orionis/metadata/framework.py

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

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

@@ -43,6 +43,9 @@ class ResolveArguments(BaseEntity):
     # Unresolved dependencies as a dictionary of names to Argument instances
     unresolved: Dict[str, Argument]
 
+    # All dependencies in the order they were defined
+    ordered: Dict[str, Argument]
+
     def __post_init__(self):
         """
         Validates the types and contents of the resolved and unresolved attributes.
@@ -79,4 +82,11 @@ class ResolveArguments(BaseEntity):
         if not isinstance(self.unresolved, dict):
             raise ReflectionTypeError(
                 f"'unresolved' must be a dict, got {type(self.unresolved).__name__}"
+            )
+
+        # Validate that the 'ordered' attribute is a dictionary type
+        # This ensures that all dependencies maintain the same structure as resolved ones
+        if not isinstance(self.ordered, dict):
+            raise ReflectionTypeError(
+                f"'ordered' must be a dict, got {type(self.ordered).__name__}"
             )

orionis/services/introspection/dependencies/reflection.py

@@ -121,6 +121,7 @@ class ReflectDependencies(IReflectDependencies):
         # Initialize dictionaries to store categorized dependencies
         resolved_dependencies: Dict[str, Argument] = {}
         unresolved_dependencies: Dict[str, Argument] = {}
+        ordered_dependencies: Dict[str, Argument] = {}
 
         # Iterate through all parameters in the signature
         for param_name, param in signature.parameters.items():
@@ -140,6 +141,7 @@ class ReflectDependencies(IReflectDependencies):
                     type=Any,
                     full_class_path=None,
                 )
+                ordered_dependencies[param_name] = unresolved_dependencies[param_name]
                 continue
 
             # Case 2: Parameters with default values
@@ -153,6 +155,7 @@ class ReflectDependencies(IReflectDependencies):
                     full_class_path=f"{type(param.default).__module__}.{type(param.default).__name__}",
                     default=param.default
                 )
+                ordered_dependencies[param_name] = resolved_dependencies[param_name]
                 continue
 
             # Case 3: Parameters with type annotations
@@ -168,6 +171,7 @@ class ReflectDependencies(IReflectDependencies):
                         type=param.annotation,
                         full_class_path=f"{param.annotation.__module__}.{param.annotation.__name__}"
                     )
+                    ordered_dependencies[param_name] = unresolved_dependencies[param_name]
                 else:
                     # Non-builtin types with annotations are considered resolved
                     # as they can be instantiated by the dependency injection system
@@ -178,12 +182,14 @@ class ReflectDependencies(IReflectDependencies):
                         type=param.annotation,
                         full_class_path=f"{param.annotation.__module__}.{param.annotation.__name__}"
                     )
+                    ordered_dependencies[param_name] = resolved_dependencies[param_name]
                 continue
 
         # Return the categorized dependencies
         return ResolveArguments(
             resolved=resolved_dependencies,
-            unresolved=unresolved_dependencies
+            unresolved=unresolved_dependencies,
+            ordered=ordered_dependencies
         )
 
     def getConstructorDependencies(self) -> ResolveArguments:

{orionis-0.535.0.dist-info → orionis-0.537.0.dist-info}/METADATA

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

{orionis-0.535.0.dist-info → orionis-0.537.0.dist-info}/RECORD

@@ -22,7 +22,7 @@ orionis/console/commands/version.py,sha256=SUuNDJ40f2uq69OQUmPQXJKaa9Bm_iVRDPmBd
 orionis/console/commands/workflow.py,sha256=NYOmjTSvm2o6AE4h9LSTZMFSYPQreNmEJtronyOxaYk,2451
 orionis/console/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/contracts/command.py,sha256=vmAJD0yMQ5-AD_s9_xCFEAl64sKk65z7U2E196dALQM,5760
-orionis/console/contracts/event.py,sha256=zaOkbRNKpU6U_cIEFic84C3WIcD8kCIyX9hc50jN8N0,119797
+orionis/console/contracts/event.py,sha256=GEgpmsyVGKJYi0LwvEklTm7aAHqsqUprtC2p6qq0eZU,120005
 orionis/console/contracts/kernel.py,sha256=mh4LlhEYHh3FuGZZQ0GBhD6ZLa5YQvaNj2r01IIHI5Y,826
 orionis/console/contracts/reactor.py,sha256=Xeq7Zrw6WE5MV_XOQfiQEchAFbb6-0TjLpjWOxYW--g,4554
 orionis/console/contracts/schedule.py,sha256=17cfPYtLo-jqF8FxYOhh4epJZnxw5mMPuLGaWoUwxL4,12171
@@ -65,7 +65,7 @@ orionis/console/entities/scheduler_shutdown.py,sha256=vRFXUt3hxKueaT6M4335HFL3NO
 orionis/console/entities/scheduler_started.py,sha256=U0pduaFhWrEUJQws81jTjDmTp4Kxfy6ontq8rQN4Y6I,910
 orionis/console/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/enums/command.py,sha256=lCfVp2vnDojJN2gjdVxE_XU3mRjZZgOIxPfBVQYo9w4,1278
-orionis/console/enums/event.py,sha256=G_6QEagrjtQ81dgkVhTTc2M2YuhnnKRkRSjd2i8m3OQ,2808
+orionis/console/enums/event.py,sha256=xyJfJQmXnZ_c-zPZx3_pzKm54R-kKyJkQzIercv556w,3004
 orionis/console/enums/listener.py,sha256=bDHDOkKQFEfEmZyiisZj37ozr8Hs7_lKvm_3uYjvEpw,2988
 orionis/console/exceptions/__init__.py,sha256=0qlHNuHMVZO87M-rP8lThUUyljRM1jSFNikaxSCjSbw,366
 orionis/console/exceptions/cli_exception.py,sha256=HsZ_vSeNiJWQ0gznVFNcIdhM0Bj_vkSRVBJs0wMjEKY,1141
@@ -82,16 +82,16 @@ orionis/console/output/enums/__init__.py,sha256=LAaAxg-DpArCjf_jqZ0_9s3p8899gntD
 orionis/console/output/enums/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
 orionis/console/request/cli_request.py,sha256=7-sgYmNUCipuHLVAwWLJiHv0cJCDmsM1Lu9s2D8RIII,1498
 orionis/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/tasks/event.py,sha256=l4J-HEPaj1mxB_PYQMgG9dRHUe01wUag8fKLLnR2N2M,164395
+orionis/console/tasks/event.py,sha256=yE64gWAWaaz-mlWk5LIKDh4HYO14iwRfdYfwFh7Wktk,166479
 orionis/console/tasks/listener.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/tasks/schedule.py,sha256=lou90LaOWw4_tw2ONrplVOEUI9A5esKspFL900EIUBI,82842
+orionis/console/tasks/schedule.py,sha256=7aUDyRKvvLMnWHZccqvSYr9oZYFcl4hzsh5amd3X_E4,82392
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/container/container.py,sha256=aF_b6lTUpG4YCo9yFJEzsntTdIzgMMXFW5LyWqAJVBQ,87987
+orionis/container/container.py,sha256=262gahG9L_72QovlHP7cF5QhFX4HTolwcYrVo86HcVg,93196
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/context/manager.py,sha256=I08K_jKXSKmrq18Pv33qYyMKIlAovVOwIgmfiVm-J7c,2971
 orionis/container/context/scope.py,sha256=p_oCzR7dDz-5ZAd16ab4vfLc3gBf34CaN0f4iR9D0bQ,1155
 orionis/container/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/container/contracts/container.py,sha256=l-wVi6KMLL4I55JSHnNqykiaZSZO9ea6BDSzCKsysak,14217
+orionis/container/contracts/container.py,sha256=r-HpuMUbkI19lNTisgxB2lbvvt0YFA4xsEDVLCPDrys,15507
 orionis/container/contracts/service_provider.py,sha256=TJtwFoPYvw3hvBSfIEO3-httq8iszaRQh1IjCKfDyVM,1016
 orionis/container/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/entities/binding.py,sha256=sY0ioHbRcjp9TSQjfrFHxkO3vRn_VOrbHK62_QEGe1U,3717
@@ -117,16 +117,16 @@ orionis/container/validators/is_subclass.py,sha256=4sBaGLoRs8nUhuWjlP0VJqyTwVHYq
 orionis/container/validators/is_valid_alias.py,sha256=4uAYcq8xov7jZbXnpKpjNkxcZtlTNnL5RRctVPMwJes,1424
 orionis/container/validators/lifetime.py,sha256=IQ43fDNrxYHMlZH2zlYDJnlkLO_eS4U7Fs3UJgQBidI,1844
 orionis/failure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/failure/catch.py,sha256=kmw2mbkGrFNw9s8jrr2NdJeGlbJVvXQQSlnjltwC4oM,6819
+orionis/failure/catch.py,sha256=XpPISy-83grGYP1PSScrF7jyogpvOjDjbz-11iop2FQ,3286
 orionis/failure/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/failure/base/handler.py,sha256=a7fQJMWVjALwFiITRsMYg3s7WSO6zcbmq171iQRWy48,4867
+orionis/failure/base/handler.py,sha256=6QU2XHpJgH2hhGBANvioJBz16Aoi9Xy6QEF1PJBGLDQ,4939
 orionis/failure/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/failure/contracts/catch.py,sha256=e2wM1p6VxbvAjgWm-MwoM9p2ystSsyBu8Qnt6Ehr6Vc,1179
 orionis/failure/contracts/handler.py,sha256=drNE8iu8RUHi3TgKn-lUEIfVsZeGsMTUecTZOfay19E,2240
 orionis/failure/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/failure/entities/throwable.py,sha256=ogys062uhim5QMYU62ezlnumRAnYQlUf_vZvQY47S3U,1227
+orionis/failure/entities/throwable.py,sha256=1zD-awcuAyEtlR-L7V7ZIfPSF4GpXkf-neL5sXul7dc,1240
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/application.py,sha256=RwMRjRp9kkKRbDsz_lAN4NYadCuaDbmDnccWKl8aKng,86488
+orionis/foundation/application.py,sha256=_I8EAPcsRmGdmG9ajdSHovwny_tsELXWwvej6WZQj0A,86506
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=vbzduprRCNyYeR2nnMaqc1uKXw6PTzAY2jVfXNQKN8I,9691
 orionis/foundation/config/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -242,7 +242,7 @@ orionis/foundation/providers/scheduler_provider.py,sha256=1do4B09bU_6xbFHHVYYTGM
 orionis/foundation/providers/testing_provider.py,sha256=SrJRpdvcblx9WvX7x9Y3zc7OQfiTf7la0HAJrm2ESlE,3725
 orionis/foundation/providers/workers_provider.py,sha256=oa_2NIDH6UxZrtuGkkoo_zEoNIMGgJ46vg5CCgAm7wI,3926
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=uWTlWqt2g9tvRAk56GneEvJAcpVopbXX5L67RJzuXX8,4109
+orionis/metadata/framework.py,sha256=_yk_F1NMdYLo-ucW1aLKfOQd_AXew-3YEx-XHDhR8sY,4109
 orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -298,12 +298,12 @@ orionis/services/introspection/concretes/contracts/reflection.py,sha256=LwEAgdN_
 orionis/services/introspection/dataclass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/dataclass/attributes.py,sha256=VGBUxH40PxUE8J4TBBYdSqwTO0xwYYmIS6BITgff-cE,1695
 orionis/services/introspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/dependencies/reflection.py,sha256=VEe3cY6LTpOW3dm0IFECTHh7F_9_X-siTAeQc2XRQeM,13451
+orionis/services/introspection/dependencies/reflection.py,sha256=3aQl541JkohRcoZFxQGiGPz3CnBMK8gmcRwO9XiLSY0,13906
 orionis/services/introspection/dependencies/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/dependencies/contracts/reflection.py,sha256=DhkAmsl8fxNr3L1kCSpVmTZx9YBejq2kYcfUrCWG8o0,5364
 orionis/services/introspection/dependencies/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/dependencies/entities/argument.py,sha256=o30iMSghV8CFBWmnM__8_IOnOGrCLZfRUIQGD2GVl_g,4188
-orionis/services/introspection/dependencies/entities/resolve_argument.py,sha256=GxlW-JwoJwYO1TWH4aqJ982Y4mTiU69GEU3GlevDWtM,3373
+orionis/services/introspection/dependencies/entities/resolve_argument.py,sha256=einKDEIp9NjBUfc9_ulmkwzAv7sRuxS3lM_FE3zFN-s,3810
 orionis/services/introspection/exceptions/__init__.py,sha256=oe7uzaGwjeMgz62ZTeNn6ersCApOVv3PXFlUw0vYLQM,234
 orionis/services/introspection/exceptions/attribute.py,sha256=_JerTjfhikYwC2FKJV8XbVZqiZdLcBt7WGtw8r6vkqo,473
 orionis/services/introspection/exceptions/type.py,sha256=73DB8JoTbxd7LNMnZKXf4jJ8OzLyC0HPXgDo5pffkYY,466
@@ -420,7 +420,7 @@ orionis/test/validators/web_report.py,sha256=n9BfzOZz6aEiNTypXcwuWbFRG0OdHNSmCNu
 orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnIfJYgc,1206
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=f-zNhtKSg9R5Njqujbg2l2amAs2-mRVESneLIkWOZjU,4082
-orionis-0.535.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.537.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/test_manager.py,sha256=wOwXpl9rHNfTTexa9GBKYMwK0_-KSQPbI-AEyGNkmAE,1356
@@ -566,8 +566,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=WPo5GxTP6xE-Dw3X1vZoqOMpb6HhokjNSbgDsDRDvy4,16588
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=tnnMBwS0iKUIbogLvu-7Rii50G6Koddp3XT4wgdFEYM,1050
-orionis-0.535.0.dist-info/METADATA,sha256=fgBBQFe8aw1uvm0D0Wr1yobSyOoPlEzaiEaylQpTSd0,4801
-orionis-0.535.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.535.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.535.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.535.0.dist-info/RECORD,,
+orionis-0.537.0.dist-info/METADATA,sha256=XK4A6ii-FE63V5-792FaTkZt6wsrkq-SREBrzuvazwU,4801
+orionis-0.537.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.537.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.537.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.537.0.dist-info/RECORD,,