orionis 0.522.0__py3-none-any.whl → 0.524.0__py3-none-any.whl

orionis/console/base/scheduler.py

@@ -18,171 +18,6 @@ class BaseScheduler(IBaseScheduler):
     # Finalize Global Scheduler at a specific time
     FINALIZE_AT: datetime = None
 
-    def pauseAt(self, timezone: str = None) -> datetime:
-        """
-        Retrieves the datetime at which the global scheduler should be paused.
-
-        This method returns the `PAUSE_AT` attribute as a timezone-aware datetime object.
-        If `PAUSE_AT` is not set (i.e., `None`), the method will return `None`.
-        If a timezone is provided, it converts the naive datetime to a timezone-aware
-        datetime using the specified timezone. If no timezone is provided, the naive
-        datetime is returned as is.
-
-        Parameters
-        ----------
-        timezone : str, optional
-            The name of the timezone to use for converting the naive datetime
-            to a timezone-aware datetime. For example, "UTC" or "America/New_York".
-            If not provided, the method returns the naive datetime.
-
-        Returns
-        -------
-        datetime or None
-            - A timezone-aware datetime object representing the pause time of the scheduler
-              if `PAUSE_AT` is set and a valid timezone is provided.
-            - A naive datetime object representing the pause time if `PAUSE_AT` is set
-              but no timezone is provided.
-            - `None` if `PAUSE_AT` is not set.
-
-        Notes
-        -----
-        - The `PAUSE_AT` attribute is expected to be a naive datetime object.
-        - The method uses the `pytz` library to localize the naive datetime to the specified timezone.
-        - If the `PAUSE_AT` attribute is `None`, the method will return `None` without performing any conversion.
-        """
-
-        # Retrieve the naive datetime value for the pause time
-        dt_naive = self.PAUSE_AT
-
-        # If no pause time is set, return None
-        if dt_naive is None:
-            return None
-
-        # If no timezone is provided, return the naive datetime as is
-        if timezone is None:
-            return dt_naive
-
-        # Import the pytz library for timezone handling
-        import pytz
-
-        # Get the specified timezone using pytz
-        # This will raise an exception if the timezone string is invalid
-        tz = pytz.timezone(timezone)
-
-        # Convert the naive datetime to a timezone-aware datetime
-        # This ensures the datetime is localized to the specified timezone
-        return tz.localize(dt_naive)
-
-    def resumeAt(self, timezone: str = None) -> datetime:
-        """
-        Retrieves the datetime at which the global scheduler should be resumed.
-
-        This method returns the `RESUME_AT` attribute as a timezone-aware datetime object.
-        If `RESUME_AT` is not set (i.e., `None`), the method will return `None`.
-        If a timezone is provided, it converts the naive datetime to a timezone-aware
-        datetime using the specified timezone. If no timezone is provided, the naive
-        datetime is returned as is.
-
-        Parameters
-        ----------
-        timezone : str, optional
-            The name of the timezone to use for converting the naive datetime
-            to a timezone-aware datetime. For example, "UTC" or "America/New_York".
-            If not provided, the method returns the naive datetime.
-
-        Returns
-        -------
-        datetime or None
-            - A timezone-aware datetime object representing the resume time of the scheduler
-              if `RESUME_AT` is set and a valid timezone is provided.
-            - A naive datetime object representing the resume time if `RESUME_AT` is set
-              but no timezone is provided.
-            - `None` if `RESUME_AT` is not set.
-
-        Notes
-        -----
-        - The `RESUME_AT` attribute is expected to be a naive datetime object.
-        - The method uses the `pytz` library to localize the naive datetime to the specified timezone.
-        - If the `RESUME_AT` attribute is `None`, the method will return `None` without performing any conversion.
-        """
-
-        # Retrieve the naive datetime value for the resume time
-        dt_naive = self.RESUME_AT
-
-        # If no resume time is set, return None
-        if dt_naive is None:
-            return None
-
-        # If no timezone is provided, return the naive datetime as is
-        if timezone is None:
-            return dt_naive
-
-        # Import the pytz library for timezone handling
-        import pytz
-
-        # Get the specified timezone using pytz
-        # This will raise an exception if the timezone string is invalid
-        tz = pytz.timezone(timezone)
-
-        # Convert the naive datetime to a timezone-aware datetime
-        # This ensures the datetime is localized to the specified timezone
-        return tz.localize(dt_naive)
-
-    def finalizeAt(self, timezone: str = None) -> datetime:
-        """
-        Retrieves the datetime at which the global scheduler should be finalized.
-
-        This method returns the `FINALIZE_AT` attribute as a timezone-aware datetime object.
-        If `FINALIZE_AT` is not set (i.e., `None`), the method will return `None`.
-        If a timezone is provided, it converts the naive datetime to a timezone-aware
-        datetime using the specified timezone. If no timezone is provided, the naive
-        datetime is returned as is.
-
-        Parameters
-        ----------
-        timezone : str, optional
-            The name of the timezone to use for converting the naive datetime
-            to a timezone-aware datetime. For example, "UTC" or "America/New_York".
-            If not provided, the method returns the naive datetime.
-
-        Returns
-        -------
-        datetime or None
-            - A timezone-aware datetime object representing the finalize time of the scheduler
-              if `FINALIZE_AT` is set and a valid timezone is provided.
-            - A naive datetime object representing the finalize time if `FINALIZE_AT` is set
-              but no timezone is provided.
-            - `None` if `FINALIZE_AT` is not set.
-
-        Notes
-        -----
-        - The `FINALIZE_AT` attribute is expected to be a naive datetime object.
-        - The method uses the `pytz` library to localize the naive datetime to the specified timezone.
-        - If the `FINALIZE_AT` attribute is `None`, the method will return `None` without performing any conversion.
-        """
-
-        # Retrieve the naive datetime value for the finalize time
-        dt_naive = self.FINALIZE_AT
-
-        # If no finalize time is set, return None
-        if dt_naive is None:
-            return None
-
-        # If no timezone is provided, return the naive datetime as is
-        if timezone is None:
-            return dt_naive
-
-        # Import the pytz library for timezone handling
-        import pytz
-
-        # Get the specified timezone using pytz
-        # This will raise an exception if the timezone string is invalid
-        tz = pytz.timezone(timezone)
-
-        # Convert the naive datetime to a timezone-aware datetime
-        # This ensures the datetime is localized to the specified timezone
-        return tz.localize(dt_naive)
-
     async def tasks(self, schedule: ISchedule):
         """
         Defines and registers scheduled tasks for the application.

orionis/console/commands/scheduler_work.py

@@ -110,21 +110,23 @@ class ScheduleWorkCommand(BaseCommand):
             if hasattr(scheduler, "onError") and callable(scheduler.onError):
                 schedule_service.setListener(ListeningEvent.SCHEDULER_ERROR, scheduler.onError)
 
+            # If the scheduler has FINALIZE_AT and it is not None
             if hasattr(scheduler, "FINALIZE_AT") and scheduler.FINALIZE_AT is not None:
                 if not isinstance(scheduler.FINALIZE_AT, datetime):
                     raise CLIOrionisRuntimeError("FINALIZE_AT must be a datetime instance.")
-                schedule_service.shutdownEverythingAt(scheduler.finalizeAt())
+                schedule_service.shutdownEverythingAt(scheduler.FINALIZE_AT)
 
+            # If the scheduler has RESUME_AT and it is not None
             if hasattr(scheduler, "RESUME_AT") and scheduler.RESUME_AT is not None:
                 if not isinstance(scheduler.RESUME_AT, datetime):
                     raise CLIOrionisRuntimeError("RESUME_AT must be a datetime instance.")
-                schedule_service.resumeEverythingAt(scheduler.resumeAt())
+                schedule_service.resumeEverythingAt(scheduler.RESUME_AT)
 
-            # Check if the scheduler has specific pause, resume, and finalize times
+            # If the scheduler has PAUSE_AT and it is not None
             if hasattr(scheduler, "PAUSE_AT") and scheduler.PAUSE_AT is not None:
                 if not isinstance(scheduler.PAUSE_AT, datetime):
                     raise CLIOrionisRuntimeError("PAUSE_AT must be a datetime instance.")
-                schedule_service.pauseEverythingAt(scheduler.pauseAt())
+                schedule_service.pauseEverythingAt(scheduler.PAUSE_AT)
 
             # Start the scheduler worker asynchronously
             await schedule_service.start()

orionis/console/tasks/schedule.py

@@ -1,7 +1,7 @@
 import asyncio
 from datetime import datetime
 import logging
-from typing import Dict, List, Optional, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Union
 import pytz
 from apscheduler.triggers.date import DateTrigger
 from apscheduler.events import (
@@ -30,7 +30,9 @@ from orionis.console.entities.job_executed import JobExecuted
 from orionis.console.entities.job_max_instances import JobMaxInstances
 from orionis.console.entities.job_missed import JobMissed
 from orionis.console.entities.job_modified import JobModified
+from orionis.console.entities.job_pause import JobPause
 from orionis.console.entities.job_removed import JobRemoved
+from orionis.console.entities.job_resume import JobResume
 from orionis.console.entities.job_submitted import JobSubmitted
 from orionis.console.entities.scheduler_paused import SchedulerPaused
 from orionis.console.entities.scheduler_resumed import SchedulerResumed
@@ -40,7 +42,6 @@ from orionis.console.enums.listener import ListeningEvent
 from orionis.console.enums.event import Event as EventEntity
 from orionis.console.exceptions import CLIOrionisRuntimeError
 from orionis.console.exceptions.cli_orionis_value_error import CLIOrionisValueError
-from orionis.console.output.contracts.console import IConsole
 from orionis.foundation.contracts.application import IApplication
 from orionis.services.log.contracts.log_service import ILogger
 
@@ -109,6 +110,9 @@ class Scheduler(ISchedule):
         # Initialize the listeners dictionary to manage event listeners.
         self.__listeners: Dict[str, callable] = {}
 
+        # Initialize set to track jobs paused by pauseEverythingAt
+        self.__paused_by_pause_everything: set = set()
+
         # Add this line to the existing __init__ method
         self._stop_event: Optional[asyncio.Event] = None
 
@@ -132,6 +136,9 @@ class Scheduler(ISchedule):
         tz = pytz.timezone(self.__app.config("app.timezone", "UTC"))
         now = datetime.now(tz)
 
+        # Log the timezone assignment for debugging purposes
+        self.__logger.info(f"Timezone assigned to the scheduler: {self.__app.config("app.timezone", "UTC")}")
+
         # Format the current time as a string
         return now.strftime("%Y-%m-%d %H:%M:%S")
 
@@ -312,8 +319,6 @@ class Scheduler(ISchedule):
         """
 
         self.__scheduler.add_listener(self.__startedListener, EVENT_SCHEDULER_STARTED)
-        self.__scheduler.add_listener(self.__pausedListener, EVENT_SCHEDULER_PAUSED)
-        self.__scheduler.add_listener(self.__resumedListener, EVENT_SCHEDULER_RESUMED)
         self.__scheduler.add_listener(self.__shutdownListener, EVENT_SCHEDULER_SHUTDOWN)
         self.__scheduler.add_listener(self.__errorListener, EVENT_JOB_ERROR)
         self.__scheduler.add_listener(self.__submittedListener, EVENT_JOB_SUBMITTED)
@@ -378,19 +383,36 @@ class Scheduler(ISchedule):
 
                         # Try to get the running event loop
                         try:
-                            loop = asyncio.get_running_loop()
-                            loop.create_task(listener(event_data, self))
+
+                            try:
+
+                                # Try to get the current running event loop
+                                loop = asyncio.get_running_loop()
+                                loop.create_task(listener(event_data, self))
+
+                            except RuntimeError:
+
+                                # If no event loop is running, create a new one
+                                loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(loop)
+                                loop.create_task(listener(event_data, self))
 
                         # If no event loop is running, log a warning instead of creating one
                         except RuntimeError:
 
+                            # Message indicating that the listener could not be invoked
+                            error_msg = f"Cannot run listener for '{scheduler_event}': no event loop running"
+
+                            # Log the error message
+                            self.__logger.error(error_msg)
+
                             # Raise an error to inform the caller that the listener could not be invoked
-                            raise CLIOrionisRuntimeError(
-                                f"Cannot run async listener for '{scheduler_event}': no event loop running"
-                            )
+                            raise CLIOrionisRuntimeError(error_msg)
 
                     # Otherwise, invoke the listener directly as a regular function
                     else:
+
+                        # Call the regular listener function directly
                         listener(event_data, self)
 
                 except Exception as e:
@@ -399,10 +421,14 @@ class Scheduler(ISchedule):
                     if isinstance(e, CLIOrionisRuntimeError):
                         raise e
 
+                    # Construct the error message
+                    error_msg = f"An error occurred while invoking the listener for event '{scheduler_event}': {str(e)}"
+
+                    # Log the error message
+                    self.__logger.error(error_msg)
+
                     # Raise a runtime error if listener invocation fails
-                    raise CLIOrionisRuntimeError(
-                        f"An error occurred while invoking the listener for event '{scheduler_event}': {str(e)}"
-                    )
+                    raise CLIOrionisRuntimeError(error_msg)
 
     def __taskCallableListener(
         self,
@@ -472,19 +498,36 @@ class Scheduler(ISchedule):
 
                             # Try to get the running event loop
                             try:
-                                loop = asyncio.get_running_loop()
-                                loop.create_task(listener_method(event_data, self))
+
+                                try:
+
+                                    # Try to get the current running event loop
+                                    loop = asyncio.get_running_loop()
+                                    loop.create_task(listener_method(event_data, self))
+
+                                except RuntimeError:
+
+                                    # If no event loop is running, create a new one
+                                    loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(loop)
+                                    loop.create_task(listener_method(event_data, self))
 
                             # If no event loop is running, log a warning
                             except RuntimeError:
 
+                                # Construct the error message
+                                error_msg = f"Cannot run async listener for '{scheduler_event}' on job '{event_data.job_id}': no event loop running"
+
+                                # Log the error message
+                                self.__logger.error(error_msg)
+
                                 # Raise an error to inform the caller that the listener could not be invoked
-                                raise CLIOrionisRuntimeError(
-                                    f"Cannot run async listener for '{scheduler_event}' on job '{event_data.job_id}': no event loop running"
-                                )
+                                raise CLIOrionisRuntimeError(error_msg)
 
                         # Call the regular listener method directly
                         else:
+
+                            # Invoke the listener method directly
                             listener_method(event_data, self)
 
                     except Exception as e:
@@ -493,10 +536,14 @@ class Scheduler(ISchedule):
                         if isinstance(e, CLIOrionisRuntimeError):
                             raise e
 
+                        # Construct the error message
+                        error_msg = (f"An error occurred while invoking the listener for event '{scheduler_event}' on job '{event_data.job_id}': {str(e)}")
+
+                        # Log the error message
+                        self.__logger.error(error_msg)
+
                         # Raise a runtime error if listener invocation fails
-                        raise CLIOrionisRuntimeError(
-                            f"An error occurred while invoking the listener for event '{scheduler_event}' on job '{event_data.job_id}': {str(e)}"
-                        )
+                        raise CLIOrionisRuntimeError(error_msg)
 
     def __startedListener(
         self,
@@ -526,9 +573,6 @@ class Scheduler(ISchedule):
         # Get the current time in the configured timezone
         now = self.__getCurrentTime()
 
-        # Log an informational message indicating that the scheduler has started
-        self.__logger.info(f"Orionis Scheduler started successfully at {now}.")
-
         # Display a start message for the scheduler worker on the rich console
         # Add a blank line for better formatting
         self.__rich_console.line()
@@ -553,79 +597,8 @@ class Scheduler(ISchedule):
         # Check if a listener is registered for the scheduler started event
         self.__globalCallableListener(event, ListeningEvent.SCHEDULER_STARTED)
 
-    def __pausedListener(
-        self,
-        event: SchedulerPaused
-    ) -> None:
-        """
-        Handle the scheduler paused event for logging and invoking registered listeners.
-
-        This method is triggered when the scheduler is paused. It logs an informational
-        message indicating that the scheduler has been paused successfully and displays
-        a formatted message on the rich console. If a listener is registered for the
-        scheduler paused event, it invokes the listener with the event details.
-
-        Parameters
-        ----------
-        event : SchedulerPaused
-            An event object containing details about the scheduler paused event.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs logging, displays
-            a message on the console, and invokes any registered listener for the
-            scheduler paused event.
-        """
-
-        # Get the current time in the configured timezone
-        now = self.__getCurrentTime()
-
-        # Create a paused message
-        message = f"Orionis Scheduler paused successfully at {now}."
-
-        # Log an informational message indicating that the scheduler has been paused
-        self.__logger.info(message)
-
-        # Check if a listener is registered for the scheduler paused event
-        self.__globalCallableListener(event, ListeningEvent.SCHEDULER_PAUSED)
-
-    def __resumedListener(
-        self,
-        event: SchedulerResumed
-    ) -> None:
-        """
-        Handle the scheduler resumed event for logging and invoking registered listeners.
-
-        This method is triggered when the scheduler resumes from a paused state. It logs an informational
-        message indicating that the scheduler has resumed successfully and displays a formatted message
-        on the rich console. If a listener is registered for the scheduler resumed event, it invokes
-        the listener with the event details.
-
-        Parameters
-        ----------
-        event : SchedulerResumed
-            An event object containing details about the scheduler resumed event.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs logging, displays
-            a message on the console, and invokes any registered listener for the
-            scheduler resumed event.
-        """
-
-        # Get the current time in the configured timezone
-        now = self.__getCurrentTime()
-
-        # Create a resumed message
-        message = f"Orionis Scheduler resumed successfully at {now}."
-
-        # Log an informational message indicating that the scheduler has resumed
-        self.__logger.info(message)
-
-        # Check if a listener is registered for the scheduler resumed event
-        self.__globalCallableListener(event, ListeningEvent.SCHEDULER_RESUMED)
+        # Log an informational message indicating that the scheduler has started
+        self.__logger.info(f"Orionis Scheduler started successfully at {now}.")
 
     def __shutdownListener(
         self,
@@ -655,15 +628,12 @@ class Scheduler(ISchedule):
         # Get the current time in the configured timezone
         now = self.__getCurrentTime()
 
-        # Create a shutdown message
-        message = f"Orionis Scheduler shut down successfully at {now}."
-
-        # Log an informational message indicating that the scheduler has shut down
-        self.__logger.info(message)
-
         # Check if a listener is registered for the scheduler shutdown event
         self.__globalCallableListener(event, ListeningEvent.SCHEDULER_SHUTDOWN)
 
+        # Log an informational message indicating that the scheduler has shut down
+        self.__logger.info(f"Orionis Scheduler shut down successfully at {now}.")
+
     def __errorListener(
         self,
         event: JobError
@@ -689,11 +659,8 @@ class Scheduler(ISchedule):
             and listener invocation for the job error event.
         """
 
-        # Create an error message
-        message = f"Task {event.job_id} raised an exception: {event.exception}"
-
         # Log an error message indicating that the job raised an exception
-        self.__logger.error(message)
+        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
         self.__taskCallableListener(event, ListeningEvent.JOB_ON_FAILURE)
@@ -726,11 +693,8 @@ class Scheduler(ISchedule):
             and listener invocation for the job submission event.
         """
 
-        # Create a submission message
-        message = f"Task {event.job_id} submitted to executor."
-
         # Log an informational message indicating that the job has been submitted
-        self.__logger.info(message)
+        self.__logger.info(f"Task {event.job_id} submitted to executor.")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(event, ListeningEvent.JOB_BEFORE)
@@ -761,11 +725,8 @@ class Scheduler(ISchedule):
             and listener invocation for the job execution event.
         """
 
-        # Create an execution message
-        message = f"Task {event.job_id} executed."
-
         # Log an informational message indicating that the job has been executed
-        self.__logger.info(message)
+        self.__logger.info(f"Task {event.job_id} executed.")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(event, ListeningEvent.JOB_AFTER)
@@ -796,11 +757,8 @@ class Scheduler(ISchedule):
             and listener invocation for the missed job event.
         """
 
-        # Create a missed job message
-        message = f"Task {event.job_id} was missed. It was scheduled to run at {event.scheduled_run_time}."
-
         # Log a warning indicating that the job was missed
-        self.__logger.warning(message)
+        self.__logger.warning(f"Task {event.job_id} was missed. It was scheduled to run at {event.scheduled_run_time}.")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(event, ListeningEvent.JOB_ON_MISSED)
@@ -831,11 +789,8 @@ class Scheduler(ISchedule):
             and listener invocation for the job max instances event.
         """
 
-        # Create a max instances error message
-        message = f"Task {event.job_id} exceeded maximum instances"
-
         # Log an error message indicating that the job exceeded maximum instances
-        self.__logger.error(message)
+        self.__logger.error(f"Task {event.job_id} exceeded maximum instances")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(event, ListeningEvent.JOB_ON_MAXINSTANCES)
@@ -866,16 +821,12 @@ class Scheduler(ISchedule):
             and listener invocation for the job modified event.
         """
 
-        # Create a modified message
-        message = f"Task {event.job_id} has been modified."
-
-        # Log an informational message indicating that the job has been modified
-        self.__logger.info(message)
-
         # If a listener is registered for this job ID, invoke the listener with the event details
         if event.next_run_time is None:
+            self.__logger.info(f"Task {event.job_id} has been paused.")
             self.__taskCallableListener(event, ListeningEvent.JOB_ON_PAUSED)
         else:
+            self.__logger.info(f"Task {event.job_id} has been resumed.")
             self.__taskCallableListener(event, ListeningEvent.JOB_ON_RESUMED)
 
     def __removedListener(
@@ -903,11 +854,8 @@ class Scheduler(ISchedule):
             listener for the job removal event.
         """
 
-        # Create a message indicating that the job has been removed
-        message = f"Task {event.job_id} has been removed."
-
         # Log the removal of the job
-        self.__logger.info(message)
+        self.__logger.info(f"Task {event.job_id} has been removed.")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(event, ListeningEvent.JOB_ON_REMOVED)
@@ -958,12 +906,19 @@ class Scheduler(ISchedule):
                     if entity.listener:
                         self.setListener(signature, entity.listener)
 
+                    # Log the successful loading of the scheduled event
+                    self.__logger.debug(f"Scheduled event '{signature}' loaded successfully.")
+
                 except Exception as e:
 
+                    # Construct the error message
+                    error_msg = f"Failed to load scheduled event '{signature}': {str(e)}"
+
+                    # Log the error message
+                    self.__logger.error(error_msg)
+
                     # Raise a runtime error if loading the scheduled event fails
-                    raise CLIOrionisRuntimeError(
-                        f"Failed to load scheduled event '{signature}': {str(e)}"
-                    ) from e
+                    raise CLIOrionisRuntimeError(error_msg)
 
     def setListener(
         self,
@@ -1015,6 +970,53 @@ class Scheduler(ISchedule):
         # Register the listener for the specified event in the internal listeners dictionary
         self.__listeners[event] = listener
 
+    def wrapAsyncFunction(
+        self,
+        func: Callable[..., Awaitable[Any]]
+    ) -> Callable[..., Any]:
+        """
+        Wrap an asynchronous function to be called in a synchronous context.
+
+        This method takes an asynchronous function (a coroutine) and returns a synchronous
+        wrapper function that can be called in a non-async context. The wrapper function
+        ensures that the asynchronous function is executed within the appropriate event loop.
+
+        Parameters
+        ----------
+        func : Callable[..., Awaitable[Any]]
+            The asynchronous function (coroutine) to be wrapped. This function should be
+            defined using the `async def` syntax and return an awaitable object.
+
+        Returns
+        -------
+        Callable[..., Any]
+            A synchronous wrapper function that can be called in a non-async context.
+            When invoked, this wrapper will execute the original asynchronous function
+            within the appropriate event loop.
+
+        Raises
+        ------
+        ValueError
+            If the provided `func` is not an asynchronous function (coroutine).
+        """
+
+        # Define a synchronous wrapper function
+        def sync_wrapper(*args, **kwargs) -> Any:
+            try:
+                # Try to get the current event loop
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # If the loop is already running, create a task for the coroutine
+                    return asyncio.create_task(func(*args, **kwargs))
+                else:
+                    # If the loop is not running, run the coroutine until complete
+                    return loop.run_until_complete(func(*args, **kwargs))
+            except RuntimeError:
+                # If no event loop exists, create a new one and run the coroutine
+                return asyncio.run(func(*args, **kwargs))
+
+        return sync_wrapper
+
     def pauseEverythingAt(
         self,
         at: datetime
@@ -1050,21 +1052,68 @@ class Scheduler(ISchedule):
         if not isinstance(at, datetime):
             raise ValueError("The 'at' parameter must be a datetime object.")
 
-        # Define a function to pause the scheduler
-        def schedule_pause():
+        # Define an async function to pause the scheduler
+        async def schedule_pause():
+
+            # Only pause jobs if the scheduler is currently running
             if self.isRunning():
-                self.__scheduler.pause()
+
+                # Clear the set of previously paused jobs
+                self.__paused_by_pause_everything.clear()
+
+                # Get all jobs from the scheduler
+                all_jobs = self.__scheduler.get_jobs()
+
+                # Filter out system jobs (pause, resume, shutdown tasks)
+                system_job_ids = {
+                    "scheduler_pause_at",
+                    "scheduler_resume_at",
+                    "scheduler_shutdown_at"
+                }
+
+                # Pause only user jobs, not system jobs
+                for job in all_jobs:
+
+                    # Pause the job only if it is not a system job
+                    if job.id not in system_job_ids:
+
+                        # Pause the job and add its ID to the set of paused jobs
+                        try:
+
+                            # Pause the job in the scheduler
+                            self.__scheduler.pause_job(job.id)
+                            self.__paused_by_pause_everything.add(job.id)
+
+                            # Execute the task callable listener
+                            self.__globalCallableListener(SchedulerPaused(EVENT_SCHEDULER_PAUSED), ListeningEvent.SCHEDULER_PAUSED)
+
+                            # Get the current time in the configured timezone
+                            now = self.__getCurrentTime()
+
+                            # Log an informational message indicating that the scheduler has resumed
+                            self.__logger.info(f"Orionis Scheduler resumed successfully at {now}.")
+
+                        except Exception as e:
+
+                            # Log a warning if pausing a job fails, but continue with others
+                            self.__logger.warning(f"Failed to pause job '{job.id}': {str(e)}")
+
+                # Log that all user jobs have been paused
+                self.__logger.info("All user jobs have been paused. System jobs remain active.")
 
         try:
+
             # Remove any existing pause job to avoid conflicts
             try:
                 self.__scheduler.remove_job("scheduler_pause_at")
+
+            # If the job doesn't exist, it's fine to proceed
             except:
-                pass  # If the job doesn't exist, it's fine to proceed
+                pass
 
             # Add a job to the scheduler to pause it at the specified datetime
             self.__scheduler.add_job(
-                func=schedule_pause,                            # Function to pause the scheduler
+                func=self.wrapAsyncFunction(schedule_pause),    # Function to pause the scheduler
                 trigger=DateTrigger(run_date=at),               # Trigger type is 'date' for one-time execution
                 id="scheduler_pause_at",                        # Unique job ID for pausing the scheduler
                 name="Pause Scheduler",                         # Descriptive name for the job
@@ -1114,22 +1163,57 @@ class Scheduler(ISchedule):
         if not isinstance(at, datetime):
             raise ValueError("The 'at' parameter must be a datetime object.")
 
-        # Define a function to resume the scheduler
-        def schedule_resume():
+        # Define an async function to resume the scheduler
+        async def schedule_resume():
+
+            # Only resume jobs if the scheduler is currently running
             if self.isRunning():
-                self.__scheduler.resume()
+
+                # Resume only jobs that were paused by pauseEverythingAt
+                if self.__paused_by_pause_everything:
+
+                    # Iterate through the set of paused job IDs and resume each one
+                    for job_id in list(self.__paused_by_pause_everything):
+
+                        try:
+
+                            # Resume the job and log the action
+                            self.__scheduler.resume_job(job_id)
+                            self.__logger.info(f"User job '{job_id}' has been resumed.")
+
+                            # Execute the task callable listener
+                            self.__globalCallableListener(SchedulerResumed(EVENT_SCHEDULER_RESUMED), ListeningEvent.SCHEDULER_RESUMED)
+
+                            # Get the current time in the configured timezone
+                            now = self.__getCurrentTime()
+
+                            # Log an informational message indicating that the scheduler has been paused
+                            self.__logger.info(f"Orionis Scheduler paused successfully at {now}.")
+
+                        except Exception as e:
+
+                            # Log a warning if resuming a job fails, but continue with others
+                            self.__logger.warning(f"Failed to resume job '{job_id}': {str(e)}")
+
+                    # Clear the set after resuming all jobs
+                    self.__paused_by_pause_everything.clear()
+
+                    # Log that all previously paused jobs have been resumed
+                    self.__logger.info("All previously paused user jobs have been resumed.")
 
         try:
 
             # Remove any existing resume job to avoid conflicts
             try:
                 self.__scheduler.remove_job("scheduler_resume_at")
+
+            # If the job doesn't exist, it's fine to proceed
             except:
-                pass  # If the job doesn't exist, it's fine to proceed
+                pass
 
             # Add a job to the scheduler to resume it at the specified datetime
             self.__scheduler.add_job(
-                func=schedule_resume,                           # Function to resume the scheduler
+                func=self.wrapAsyncFunction(schedule_resume),   # Function to resume the scheduler
                 trigger=DateTrigger(run_date=at),               # Trigger type is 'date' for one-time execution
                 id="scheduler_resume_at",                       # Unique job ID for resuming the scheduler
                 name="Resume Scheduler",                        # Descriptive name for the job
@@ -1190,8 +1274,13 @@ class Scheduler(ISchedule):
 
         # Define a function to shut down the scheduler
         def schedule_shutdown():
+
+            # Only shut down the scheduler if it is currently running
             if self.isRunning():
+
+                # Execute the shutdown process
                 self.__scheduler.shutdown(wait=wait)
+
                 # Signal the stop event to break the wait in start()
                 if self._stop_event and not self._stop_event.is_set():
                     self._stop_event.set()
@@ -1201,12 +1290,14 @@ class Scheduler(ISchedule):
             # Remove any existing shutdown job to avoid conflicts
             try:
                 self.__scheduler.remove_job("scheduler_shutdown_at")
+
+            # If the job doesn't exist, it's fine to proceed
             except:
-                pass  # If the job doesn't exist, it's fine to proceed
+                pass
 
             # Add a job to the scheduler to shut it down at the specified datetime
             self.__scheduler.add_job(
-                func=schedule_shutdown,                        # Function to shut down the scheduler
+                func=schedule_shutdown,                         # Function to shut down the scheduler
                 trigger=DateTrigger(run_date=at),               # Trigger type is 'date' for one-time execution
                 id="scheduler_shutdown_at",                     # Unique job ID for shutting down the scheduler
                 name="Shutdown Scheduler",                      # Descriptive name for the job
@@ -1260,7 +1351,7 @@ class Scheduler(ISchedule):
                 self.__scheduler.start()
 
             # Log that the scheduler is now active and waiting for events
-            self.__logger.info("Scheduler is now active and waiting for events...")
+            self.__logger.info("Orionis Scheduler is now active and waiting for events...")
 
             try:
                 # Wait for the stop event to be set, which signals a shutdown
@@ -1565,8 +1656,18 @@ class Scheduler(ISchedule):
             False if no pause job was found or an error occurred during the cancellation process.
         """
         try:
+
+            # Remove any listener associated with the pause event
+            listener = ListeningEvent.SCHEDULER_PAUSED.value
+            if listener in self.__listeners:
+                del self.__listeners[listener]
+
             # Attempt to remove the pause job with the specific ID
-            self.__scheduler.remove_job("scheduler_pause_at")
+            # if it exists
+            try:
+                self.__scheduler.remove_job("scheduler_pause_at")
+            finally:
+                pass
 
             # Log the successful cancellation of the pause operation
             self.__logger.info("Scheduled pause operation cancelled.")
@@ -1593,8 +1694,18 @@ class Scheduler(ISchedule):
             False if no resume job was found or an error occurred during the cancellation process.
         """
         try:
+
+            # Remove any listener associated with the resume event
+            listener = ListeningEvent.SCHEDULER_RESUMED.value
+            if listener in self.__listeners:
+                del self.__listeners[listener]
+
             # Attempt to remove the resume job with the specific ID
-            self.__scheduler.remove_job("scheduler_resume_at")
+            # if it exists
+            try:
+                self.__scheduler.remove_job("scheduler_resume_at")
+            finally:
+                pass
 
             # Log the successful cancellation of the resume operation
             self.__logger.info("Scheduled resume operation cancelled.")
@@ -1622,8 +1733,18 @@ class Scheduler(ISchedule):
             False if no shutdown job was found or an error occurred during the cancellation process.
         """
         try:
+
+            # Remove any listener associated with the shutdown event
+            listener = ListeningEvent.SCHEDULER_SHUTDOWN.value
+            if listener in self.__listeners:
+                del self.__listeners[listener]
+
             # Attempt to remove the shutdown job with the specific ID
-            self.__scheduler.remove_job("scheduler_shutdown_at")
+            # if it exists
+            try:
+                self.__scheduler.remove_job("scheduler_shutdown_at")
+            finally:
+                pass
 
             # Log the successful cancellation of the shutdown operation
             self.__logger.info("Scheduled shutdown operation cancelled.")
@@ -1653,27 +1774,6 @@ class Scheduler(ISchedule):
         # Return the running state of the scheduler
         return self.__scheduler.running
 
-    async def waitUntilStopped(self) -> None:
-        """
-        Wait for the scheduler to stop gracefully.
-
-        This method blocks the execution until the scheduler is stopped. It waits for the
-        internal stop event to be set, which signals that the scheduler has been shut down.
-        This is useful for ensuring that the scheduler completes its operations before
-        proceeding with other tasks.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It waits until the scheduler is stopped.
-        """
-
-        # Check if the stop event is initialized
-        if self._stop_event:
-
-            # Wait for the stop event to be set, signaling the scheduler has stopped
-            await self._stop_event.wait()
-
     def forceStop(self) -> None:
         """
         Forcefully stop the scheduler immediately without waiting for jobs to complete.
@@ -1718,6 +1818,7 @@ class Scheduler(ISchedule):
 
         # Check if the stop event exists and has not already been set
         if self._stop_event and not self._stop_event.is_set():
+
             # Get the current asyncio event loop
             loop = asyncio.get_event_loop()
 

orionis/foundation/application.py

@@ -626,62 +626,89 @@ class Application(Container, IApplication):
         configuration system.
         """
 
+        # Convert dataclass instances to dictionaries
+        from orionis.services.introspection.dataclass.attributes import attributes
+
         # Load app configurator
+        if (isinstance(app, type) and issubclass(app, App)):
+            app = attributes(app)
         if not isinstance(app, (App, dict)):
             raise OrionisTypeError(f"Expected App instance or dict, got {type(app).__name__}")
         self.loadConfigApp(app)
 
         # Load auth configurator
+        if (isinstance(auth, type) and issubclass(auth, Auth)):
+            auth = attributes(auth)
         if not isinstance(auth, (Auth, dict)):
             raise OrionisTypeError(f"Expected Auth instance or dict, got {type(auth).__name__}")
         self.loadConfigAuth(auth)
 
         # Load cache configurator
+        if (isinstance(cache, type) and issubclass(cache, Cache)):
+            cache = attributes(cache)
         if not isinstance(cache, (Cache, dict)):
             raise OrionisTypeError(f"Expected Cache instance or dict, got {type(cache).__name__}")
         self.loadConfigCache(cache)
 
         # Load cors configurator
+        if (isinstance(cors, type) and issubclass(cors, Cors)):
+            cors = attributes(cors)
         if not isinstance(cors, (Cors, dict)):
             raise OrionisTypeError(f"Expected Cors instance or dict, got {type(cors).__name__}")
         self.loadConfigCors(cors)
 
         # Load database configurator
+        if (isinstance(database, type) and issubclass(database, Database)):
+            database = attributes(database)
         if not isinstance(database, (Database, dict)):
             raise OrionisTypeError(f"Expected Database instance or dict, got {type(database).__name__}")
         self.loadConfigDatabase(database)
 
         # Load filesystems configurator
+        if (isinstance(filesystems, type) and issubclass(filesystems, Filesystems)):
+            filesystems = attributes(filesystems)
         if not isinstance(filesystems, (Filesystems, dict)):
             raise OrionisTypeError(f"Expected Filesystems instance or dict, got {type(filesystems).__name__}")
         self.loadConfigFilesystems(filesystems)
 
         # Load logging configurator
+        if (isinstance(logging, type) and issubclass(logging, Logging)):
+            logging = attributes(logging)
         if not isinstance(logging, (Logging, dict)):
             raise OrionisTypeError(f"Expected Logging instance or dict, got {type(logging).__name__}")
         self.loadConfigLogging(logging)
 
         # Load mail configurator
+        if (isinstance(mail, type) and issubclass(mail, Mail)):
+            mail = attributes(mail)
         if not isinstance(mail, (Mail, dict)):
             raise OrionisTypeError(f"Expected Mail instance or dict, got {type(mail).__name__}")
         self.loadConfigMail(mail)
 
         # Load paths configurator
+        if (isinstance(path, type) and issubclass(path, Paths)):
+            path = attributes(path)
         if not isinstance(path, (Paths, dict)):
             raise OrionisTypeError(f"Expected Paths instance or dict, got {type(path).__name__}")
         self.loadPaths(path)
 
         # Load queue configurator
+        if (isinstance(queue, type) and issubclass(queue, Queue)):
+            queue = attributes(queue)
         if not isinstance(queue, (Queue, dict)):
             raise OrionisTypeError(f"Expected Queue instance or dict, got {type(queue).__name__}")
         self.loadConfigQueue(queue)
 
         # Load session configurator
+        if (isinstance(session, type) and issubclass(session, Session)):
+            session = attributes(session)
         if not isinstance(session, (Session, dict)):
             raise OrionisTypeError(f"Expected Session instance or dict, got {type(session).__name__}")
         self.loadConfigSession(session)
 
         # Load testing configurator
+        if (isinstance(testing, type) and issubclass(testing, Testing)):
+            testing = attributes(testing)
         if not isinstance(testing, (Testing, dict)):
             raise OrionisTypeError(f"Expected Testing instance or dict, got {type(testing).__name__}")
         self.loadConfigTesting(testing)
@@ -767,7 +794,9 @@ class Application(Container, IApplication):
 
         # If app is a dict, convert it to App instance
         if isinstance(app, dict):
-            app = App(**app)
+            app = App(**app).toDict()
+        elif isinstance(app, App):
+            app = app.toDict()
 
         # Store the configuration
         self.__configurators['app'] = app
@@ -853,7 +882,9 @@ class Application(Container, IApplication):
 
         # If auth is a dict, convert it to Auth instance
         if isinstance(auth, dict):
-            auth = Auth(**auth)
+            auth = Auth(**auth).toDict()
+        elif isinstance(auth, Auth):
+            auth = auth.toDict()
 
         # Store the configuration
         self.__configurators['auth'] = auth
@@ -939,7 +970,9 @@ class Application(Container, IApplication):
 
         # If cache is a dict, convert it to Cache instance
         if isinstance(cache, dict):
-            cache = Cache(**cache)
+            cache = Cache(**cache).toDict()
+        elif isinstance(cache, Cache):
+            cache = cache.toDict()
 
         # Store the configuration
         self.__configurators['cache'] = cache
@@ -1025,7 +1058,9 @@ class Application(Container, IApplication):
 
         # If cors is a dict, convert it to Cors instance
         if isinstance(cors, dict):
-            cors = Cors(**cors)
+            cors = Cors(**cors).toDict()
+        elif isinstance(cors, Cors):
+            cors = cors.toDict()
 
         # Store the configuration
         self.__configurators['cors'] = cors
@@ -1111,7 +1146,9 @@ class Application(Container, IApplication):
 
         # If database is a dict, convert it to Database instance
         if isinstance(database, dict):
-            database = Database(**database)
+            database = Database(**database).toDict()
+        elif isinstance(database, Database):
+            database = database.toDict()
 
         # Store the configuration
         self.__configurators['database'] = database
@@ -1197,7 +1234,9 @@ class Application(Container, IApplication):
 
         # If filesystems is a dict, convert it to Filesystems instance
         if isinstance(filesystems, dict):
-            filesystems = Filesystems(**filesystems)
+            filesystems = Filesystems(**filesystems).toDict()
+        elif isinstance(filesystems, Filesystems):
+            filesystems = filesystems.toDict()
 
         # Store the configuration
         self.__configurators['filesystems'] = filesystems
@@ -1283,7 +1322,9 @@ class Application(Container, IApplication):
 
         # If logging is a dict, convert it to Logging instance
         if isinstance(logging, dict):
-            logging = Logging(**logging)
+            logging = Logging(**logging).toDict()
+        elif isinstance(logging, Logging):
+            logging = logging.toDict()
 
         # Store the configuration
         self.__configurators['logging'] = logging
@@ -1369,7 +1410,9 @@ class Application(Container, IApplication):
 
         # If mail is a dict, convert it to Mail instance
         if isinstance(mail, dict):
-            mail = Mail(**mail)
+            mail = Mail(**mail).toDict()
+        elif isinstance(mail, Mail):
+            mail = mail.toDict()
 
         # Store the configuration
         self.__configurators['mail'] = mail
@@ -1558,7 +1601,12 @@ class Application(Container, IApplication):
             paths.update({
                 'root': self.__bootstrap_base_path or str(Path.cwd().resolve())
             })
-            paths = Paths(**paths)
+            paths = Paths(**paths).toDict()
+        elif isinstance(paths, Paths):
+            paths = paths.toDict()
+            paths.update({
+                'root': self.__bootstrap_base_path or str(Path.cwd().resolve())
+            })
 
         # Store the configuration
         self.__configurators['path'] = paths
@@ -1690,7 +1738,9 @@ class Application(Container, IApplication):
 
         # If queue is a dict, convert it to Queue instance
         if isinstance(queue, dict):
-            queue = Queue(**queue)
+            queue = Queue(**queue).toDict()
+        elif isinstance(queue, Queue):
+            queue = queue.toDict()
 
         # Store the configuration
         self.__configurators['queue'] = queue
@@ -1776,7 +1826,9 @@ class Application(Container, IApplication):
 
         # If session is a dict, convert it to Session instance
         if isinstance(session, dict):
-            session = Session(**session)
+            session = Session(**session).toDict()
+        elif isinstance(session, Session):
+            session = session.toDict()
 
         # Store the configuration
         self.__configurators['session'] = session
@@ -1862,7 +1914,9 @@ class Application(Container, IApplication):
 
         # If testing is a dict, convert it to Testing instance
         if isinstance(testing, dict):
-            testing = Testing(**testing)
+            testing = Testing(**testing).toDict()
+        elif isinstance(testing, Testing):
+            testing = testing.toDict()
 
         # Store the configuration
         self.__configurators['testing'] = testing

orionis/foundation/config/session/entities/session.py

@@ -92,6 +92,8 @@ class Session(BaseEntity):
         """
 
         # Validate secret_key
+        if self.secret_key is None:
+            self.secret_key = SecretKey.random()
         if not isinstance(self.secret_key, str) or not self.secret_key.strip():
             raise OrionisIntegrityException("Session secret_key must be a non-empty string")
 

orionis/metadata/framework.py

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

orionis/services/introspection/dataclass/attributes.py

@@ -0,0 +1,30 @@
+class DataclassValues:
+
+    def __call__(self, dataclass_type: type) -> dict:
+        """
+        Extract attributes and their values from a given dataclass type.
+
+        This method retrieves all attributes defined in the provided dataclass type,
+        excluding special attributes (those whose names start with '__'). It returns
+        a dictionary where the keys are the attribute names and the values are the
+        corresponding attribute values.
+
+        Parameters
+        ----------
+        dataclass_type : type
+            The dataclass type from which to extract attributes.
+
+        Returns
+        -------
+        dict
+            A dictionary containing attribute names as keys and their corresponding
+            values as values. Special attributes (those starting with '__') are excluded.
+        """
+
+        # Retrieve all attributes from the dataclass type's __dict__ attribute
+        # Exclude special attributes (names starting with '__')
+        values = {k: v for k, v in dataclass_type.__dict__.items() if not k.startswith("__")}
+        return values
+
+# Instantiate the DataclassValues callable
+attributes = DataclassValues()

{orionis-0.522.0.dist-info → orionis-0.524.0.dist-info}/METADATA

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

{orionis-0.522.0.dist-info → orionis-0.524.0.dist-info}/RECORD

@@ -8,14 +8,14 @@ orionis/console/args/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 orionis/console/args/enums/actions.py,sha256=S3T-vWS6DJSGtANrq3od3-90iYAjPvJwaOZ2V02y34c,1222
 orionis/console/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/base/command.py,sha256=OM4xqVgpv_1RZVyVG8BzOHl1sP9FT5mPUwZjMil8IRg,6637
-orionis/console/base/scheduler.py,sha256=LFzWUFk07LrcpKFL7sS7exHzTkxFRd1DPDSqDSpRcOk,15157
+orionis/console/base/scheduler.py,sha256=w86p-4KjfMqMcGlQBsmiBASpzv33M-PWLbgYza7Um9g,8030
 orionis/console/base/scheduler_event_listener.py,sha256=5qWPmf6jmiRwUz6U1ZvpQCG5eovOpeCl0KAb8kKDkfU,3905
 orionis/console/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/commands/cache.py,sha256=8DsYoRzSBLn0P9qkGVItRbo0R6snWBDBg0_Xa7tmVhs,2322
 orionis/console/commands/help.py,sha256=zfSw0pYaOnFN-_Ozdn4veBQDYMgSSDY10nPDCi-7tTY,3199
 orionis/console/commands/publisher.py,sha256=FUg-EUzK7LLXsla10ZUZro8V0Z5S-KjmsaSdRHSSGbA,21381
 orionis/console/commands/scheduler_list.py,sha256=A2N_mEXEJDHO8DX2TDrL1ROeeRhFSkWD3rCw64Hrf0o,4763
-orionis/console/commands/scheduler_work.py,sha256=FHBQ8Ajs1zacuQFXaG-KLVRy07m9FqwyJRNVmp7cDg0,6337
+orionis/console/commands/scheduler_work.py,sha256=mzSFes8Wl1gCf253tNYClij0abT5HlpW1QZVFrU5EXo,6445
 orionis/console/commands/test.py,sha256=-EmQwFwMBuby3OI9HwqMIwuJzd2CGbWbOqmwrR25sOE,2402
 orionis/console/commands/version.py,sha256=SUuNDJ40f2uq69OQUmPQXJKaa9Bm_iVRDPmBd7zc1Yc,3658
 orionis/console/commands/workflow.py,sha256=NYOmjTSvm2o6AE4h9LSTZMFSYPQreNmEJtronyOxaYk,2451
@@ -81,7 +81,7 @@ orionis/console/request/cli_request.py,sha256=7-sgYmNUCipuHLVAwWLJiHv0cJCDmsM1Lu
 orionis/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/tasks/event.py,sha256=l4J-HEPaj1mxB_PYQMgG9dRHUe01wUag8fKLLnR2N2M,164395
 orionis/console/tasks/listener.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/tasks/schedule.py,sha256=Lpm_P0Brw8XHiqA-Me9SMevNlo0CzUf-rrt2PKTFW_I,72389
+orionis/console/tasks/schedule.py,sha256=gaH9YSoYDQOTTktEaFyk5OIFUQz-jtkpzQJfKHs6hf4,77213
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/container.py,sha256=aF_b6lTUpG4YCo9yFJEzsntTdIzgMMXFW5LyWqAJVBQ,87987
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -123,7 +123,7 @@ orionis/failure/contracts/handler.py,sha256=4N9yMkMgdhtHbRGAyCtuTx3GmkPP74vhqdRL
 orionis/failure/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/failure/entities/throwable.py,sha256=ogys062uhim5QMYU62ezlnumRAnYQlUf_vZvQY47S3U,1227
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/application.py,sha256=GmfLnpWuhX_6d1gzUk1v7jy_R72XpLJdA-hEOrXQn_Q,83792
+orionis/foundation/application.py,sha256=OOe10s0Dpo3uC4L3xrhjRitaZo7ukaFJaRSJcpdl0cA,86448
 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
@@ -204,7 +204,7 @@ orionis/foundation/config/roots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 orionis/foundation/config/roots/paths.py,sha256=qQpghBFyF6hdtrt88sLX-4uqrq0frvaQrcDl0fmsTGU,10565
 orionis/foundation/config/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/session/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/config/session/entities/session.py,sha256=sJoD-_CiwUR88tva-rO22bagG3RTcHXrQGWbq4B5joM,5998
+orionis/foundation/config/session/entities/session.py,sha256=G3dRlzDCsL5_2A2ZKpge2Jwcu6N-YVsum09pWk9oHDc,6085
 orionis/foundation/config/session/enums/__init__.py,sha256=bvjCUkQbSfKB0J8V1BwOHSjOyZn6xhOmamH3urhoKCA,84
 orionis/foundation/config/session/enums/same_site_policy.py,sha256=Oo05CJ-5keJWzfflylodyBquofsXqThQPcnar2-ChCw,645
 orionis/foundation/config/session/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -239,7 +239,7 @@ orionis/foundation/providers/scheduler_provider.py,sha256=72SoixFog9IOE9Ve9Xcfw6
 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=LNUd5w9wDJVTDwfg_BIGNlRYyyCu3UpQnvpmOQsMlIQ,4109
+orionis/metadata/framework.py,sha256=TVYmpZeUzyz9k7416c1ZPMT-vPrPgTbht4x1iJwTmu4,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
@@ -292,6 +292,8 @@ orionis/services/introspection/concretes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 orionis/services/introspection/concretes/reflection.py,sha256=5DkNr6gUYdccSo7htzILoV38OAJCwLz-jLXViqZg6eY,55916
 orionis/services/introspection/concretes/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/concretes/contracts/reflection.py,sha256=LwEAgdN_WLCfS9b8pnFRVfN0PTRK4Br9qngu5km5aIk,24955
+orionis/services/introspection/dataclass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/services/introspection/dataclass/attributes.py,sha256=Z847Gya_0hdiK7eNCI8-tE1o2KtkxSKVcGxXYj94r_A,1186
 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/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -415,7 +417,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.522.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.524.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
@@ -561,8 +563,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.522.0.dist-info/METADATA,sha256=tcvGNIB23Yo-X3d9ClTaZfP9tChX79uyxXZPstmEyhs,4801
-orionis-0.522.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.522.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.522.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.522.0.dist-info/RECORD,,
+orionis-0.524.0.dist-info/METADATA,sha256=YIVkp5NLpvcgxHQzPTGxREf3MOnCRs65C-f4QkJPAuI,4801
+orionis-0.524.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.524.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.524.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.524.0.dist-info/RECORD,,