orionis 0.726.0__py3-none-any.whl → 0.727.0__py3-none-any.whl

orionis/console/commands/scheduler_work.py

@@ -99,6 +99,7 @@ class ScheduleWorkCommand(BaseCommand):
                 console.line()
                 console.print(Panel("No scheduled jobs found.", border_style="green"))
                 console.line()
+                return
 
             # If there are scheduled jobs and the scheduler has an onStarted method
             if rf_scheduler.hasMethod("onStarted"):

orionis/console/contracts/event.py

@@ -236,7 +236,7 @@ class IEvent(ABC):
         pass
 
     @abstractmethod
-    def everySecond(
+    def everySeconds(
         self,
         seconds: int
     ) -> bool:

orionis/console/contracts/schedule.py

@@ -187,7 +187,7 @@ class ISchedule(ABC):
         pass
 
     @abstractmethod
-    def pauseTask(self, signature: str) -> bool:
+    def pauseCommand(self, signature: str) -> bool:
         """
         Pause a scheduled job in the AsyncIO scheduler.
 
@@ -215,7 +215,7 @@ class ISchedule(ABC):
         pass
 
     @abstractmethod
-    def resumeTask(self, signature: str) -> bool:
+    def resumeCommand(self, signature: str) -> bool:
         """
         Resume a paused job in the AsyncIO scheduler.
 
@@ -243,7 +243,7 @@ class ISchedule(ABC):
         pass
 
     @abstractmethod
-    def removeTask(self, signature: str) -> bool:
+    def removeCommand(self, signature: str) -> bool:
         """
         Remove a scheduled job from the AsyncIO scheduler.
 

orionis/console/entities/event.py

@@ -73,4 +73,7 @@ class Event:
     max_instances: int = 1
 
     # Grace time in seconds for misfired events
-    misfire_grace_time: Optional[int] = None
+    misfire_grace_time: Optional[int] = None
+
+    # Whether to coalesce missed runs into a single run
+    coalesce: bool = True

orionis/console/fluent/event.py

@@ -83,7 +83,10 @@ class Event(IEvent):
         self.__max_instances: Optional[int] = 1
 
         # Initialize the misfire grace time attribute as None
-        self.__misfire_grace_time: Optional[int] = None
+        self.__misfire_grace_time: Optional[int] = 1
+
+        # Initialize the coalesce attribute as True
+        self.__coalesce: bool = True
 
     def toEntity( # NOSONAR
         self
@@ -141,9 +144,13 @@ class Event(IEvent):
             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):
+        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.")
 
+        # Validate that coalesce is a boolean if it is set
+        if self.__coalesce is not None and not isinstance(self.__coalesce, bool):
+            raise CLIOrionisValueError("Coalesce must be a boolean value.")
+
         # Construct and return an EventEntity with the current event's attributes
         return EventEntity(
             signature=self.__signature,
@@ -156,9 +163,39 @@ class Event(IEvent):
             details=self.__details,
             listener=self.__listener,
             max_instances=self.__max_instances,
-            misfire_grace_time=self.__misfire_grace_time
+            misfire_grace_time=self.__misfire_grace_time,
+            coalesce=self.__coalesce
         )
 
+    def coalesce(
+        self,
+        coalesce: bool = True
+    ) -> 'Event':
+        """
+        Set whether to coalesce missed event executions.
+
+        This method allows you to specify whether missed executions of the event
+        should be coalesced into a single execution when the scheduler is running
+        behind. If set to True, only the most recent missed execution will be run.
+        If set to False, all missed executions will be run in sequence.
+
+        Parameters
+        ----------
+        coalesce : bool
+            A boolean indicating whether to coalesce missed executions. Defaults to True.
+
+        Returns
+        -------
+        Event
+            Returns the current instance of the Event to allow method chaining.
+        """
+
+        # Set the internal coalesce attribute
+        self.__coalesce = coalesce
+
+        # Return self to support method chaining
+        return self
+
     def misfireGraceTime(
         self,
         seconds: int = 60
@@ -173,7 +210,7 @@ class Event(IEvent):
         Parameters
         ----------
         seconds : int
-            The number of seconds to allow for a misfire grace period. Must be a positive integer.
+            The number of seconds to allow for a misfire grace period. Must be a positive integer greater than zero.
 
         Returns
         -------
@@ -187,7 +224,7 @@ class Event(IEvent):
         """
 
         # Validate that the seconds parameter is a positive integer
-        if not isinstance(seconds, int) or seconds < 0:
+        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
@@ -448,9 +485,14 @@ class Event(IEvent):
         if not isinstance(date, datetime):
             raise CLIOrionisValueError("The date must be a datetime instance.")
 
+        # Ensure that random delay is not set for a one-time execution
+        if self.__random_delay > 0:
+            raise CLIOrionisValueError("Random delay cannot be applied to a one-time execution.")
+
         # Set both start and end dates to the specified date for a one-time execution
         self.__start_date = date
         self.__end_date = date
+        self.__max_instances = 1
 
         # Use a DateTrigger to schedule the event to run once at the specified date and time
         self.__trigger = DateTrigger(run_date=date)
@@ -461,7 +503,7 @@ class Event(IEvent):
         # Indicate that the scheduling was successful
         return True
 
-    def everySecond(
+    def everySeconds(
         self,
         seconds: int
     ) -> bool:
@@ -497,6 +539,10 @@ class Event(IEvent):
         if not isinstance(seconds, int) or seconds <= 0:
             raise CLIOrionisValueError(self.ERROR_MSG_INVALID_INTERVAL)
 
+        # Ensure that random delay is not set for second-based intervals.
+        if self.__random_delay > 0:
+            raise CLIOrionisValueError("Random delay (jitter) cannot be applied to second-based intervals.")
+
         # Configure the trigger to execute the event at the specified interval,
         # using any previously set start_date and end_date.
         self.__trigger = IntervalTrigger(
@@ -536,7 +582,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 5 seconds.
-        return self.everySecond(5)
+        return self.everySeconds(5)
 
     def everyTenSeconds(
         self
@@ -563,7 +609,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 10 seconds.
-        return self.everySecond(10)
+        return self.everySeconds(10)
 
     def everyFifteenSeconds(
         self
@@ -590,7 +636,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 15 seconds.
-        return self.everySecond(15)
+        return self.everySeconds(15)
 
     def everyTwentySeconds(
         self
@@ -613,7 +659,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 20 seconds.
-        return self.everySecond(20)
+        return self.everySeconds(20)
 
     def everyTwentyFiveSeconds(
         self
@@ -640,7 +686,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 25 seconds.
-        return self.everySecond(25)
+        return self.everySeconds(25)
 
     def everyThirtySeconds(
         self
@@ -667,7 +713,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 30 seconds.
-        return self.everySecond(30)
+        return self.everySeconds(30)
 
     def everyThirtyFiveSeconds(
         self
@@ -690,7 +736,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 35 seconds.
-        return self.everySecond(35)
+        return self.everySeconds(35)
 
     def everyFortySeconds(
         self
@@ -717,7 +763,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 40 seconds.
-        return self.everySecond(40)
+        return self.everySeconds(40)
 
     def everyFortyFiveSeconds(
         self
@@ -744,7 +790,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 45 seconds.
-        return self.everySecond(45)
+        return self.everySeconds(45)
 
     def everyFiftySeconds(
         self
@@ -771,7 +817,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 50 seconds.
-        return self.everySecond(50)
+        return self.everySeconds(50)
 
     def everyFiftyFiveSeconds(
         self
@@ -794,7 +840,7 @@ class Event(IEvent):
         """
 
         # Delegate scheduling to the everySecond method with an interval of 55 seconds.
-        return self.everySecond(55)
+        return self.everySeconds(55)
 
     def everyMinute(
         self,

orionis/console/tasks/schedule.py

@@ -1,7 +1,7 @@
 import asyncio
 from datetime import datetime
 import logging
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 from apscheduler.events import (
     EVENT_JOB_ERROR,
     EVENT_JOB_EXECUTED,
@@ -15,6 +15,9 @@ from apscheduler.events import (
     EVENT_SCHEDULER_STARTED,
 )
 from apscheduler.schedulers.asyncio import AsyncIOScheduler as APSAsyncIOScheduler
+from apscheduler.schedulers.base import BaseScheduler
+from apscheduler.schedulers.base import STATE_PAUSED, STATE_RUNNING
+from apscheduler.triggers.date import DateTrigger
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
@@ -77,7 +80,7 @@ class Schedule(ISchedule):
         """
 
         # List of operations that can be performed on the scheduler
-        self.__operations = [
+        self.__control_operations = [
             'schedule:pause',
             'schedule:resume',
             'schedule:shutdown'
@@ -94,6 +97,7 @@ class Schedule(ISchedule):
 
         # Initialize the AsyncIOScheduler with the configured timezone.
         self.__scheduler = APSAsyncIOScheduler(timezone=self.__tz)
+        self.__control_scheduler = APSAsyncIOScheduler(timezone=self.__tz)
 
         # Disable APScheduler's internal logging to avoid duplicate/conflicting logs.
         self.__disableLogging()
@@ -116,15 +120,15 @@ class Schedule(ISchedule):
         # Initialize the dictionary to manage event listeners.
         self.__listeners: Dict[str, callable] = {}
 
-        # Initialize a set to track jobs paused by pauseEverythingAt.
-        self.__pausedByPauseEverything: set = set()
-
         # Initialize the asyncio event used to signal scheduler shutdown.
         self._stopEvent: Optional[asyncio.Event] = None
 
         # Retrieve and initialize the catch instance for exception handling.
         self.__catch: ICatch = app.make(ICatch)
 
+        # Initialize the paused at timestamp
+        self.__paused_at: Optional[datetime] = None
+
     def __disableLogging(
         self
     ) -> None:
@@ -211,11 +215,6 @@ class Schedule(ISchedule):
         # Get the current time in the scheduler's configured timezone
         now = datetime.now(self.__tz)
 
-        # Log the timezone currently assigned to the scheduler for traceability
-        self.__logger.info(
-            f"Timezone assigned to the scheduler: {self.__app.config('app.timezone') or 'UTC'}"
-        )
-
         # Return the formatted current time string
         return now.strftime("%Y-%m-%d %H:%M:%S")
 
@@ -489,7 +488,7 @@ class Schedule(ISchedule):
         _misfire_grace_time = self.__getAttribute(data, 'misfire_grace_time', None)
 
         # Extract the job max_instances if available
-        _max_instances = self.__getAttribute(data, 'max_instances', 0)
+        _max_instances = self.__getAttribute(data, 'max_instances', 1)
 
         # Extract the job coalesce if available
         _coalesce = self.__getAttribute(data, 'coalesce', False)
@@ -775,6 +774,7 @@ class Schedule(ISchedule):
             ("\n\n", ""),                                                               # Add spacing
             ("The scheduled tasks worker has started successfully.\n", "white"),        # Main message
             (f"Started at: {now}\n", "dim"),                                            # Display the start time in dim text
+            (f"Timezone: {self.__tz.key}\n", "dim"),                                    # Display the configured timezone
             ("To stop the worker, press ", "white"),                                    # Instruction text
             ("Ctrl+C", "bold yellow"),                                                  # Highlight the key combination
             (".", "white")                                                              # End the instruction
@@ -800,6 +800,11 @@ class Schedule(ISchedule):
         # Log an informational message indicating that the scheduler has started
         self.__logger.info(f"Orionis Scheduler started successfully at: {now}.")
 
+        # Log the timezone currently assigned to the scheduler for traceability
+        self.__logger.info(
+            f"Timezone assigned to the scheduler: {self.__tz.key}."
+        )
+
     def __shutdownListener(
         self,
         event
@@ -878,9 +883,6 @@ class Schedule(ISchedule):
         event_exception = self.__getAttribute(event, 'exception', None)
         event_traceback = self.__getAttribute(event, 'traceback', None)
 
-        # Log an error message indicating that the job raised an exception
-        self.__logger.error(f"Task '{event_id}' raised an exception: {event_exception}")
-
         # Retrieve the job event data and update it with error details
         job_event_data = self.__getTaskFromSchedulerById(event_id)
         job_event_data.code = event_code
@@ -939,9 +941,6 @@ class Schedule(ISchedule):
         event_id = self.__getAttribute(event, 'job_id', None)
         event_code = self.__getAttribute(event, 'code', 0)
 
-        # Log an informational message indicating that the job has been submitted to the executor
-        self.__logger.info(f"Task '{event_id}' submitted to executor.")
-
         # Create an event entity for the submitted job, including its ID and code
         data_event = self.__getTaskFromSchedulerById(event_id, event_code)
 
@@ -983,9 +982,6 @@ class Schedule(ISchedule):
         event_id = self.__getAttribute(event, 'job_id', None)
         event_code = self.__getAttribute(event, 'code', 0)
 
-        # Log an informational message indicating that the job has been executed
-        self.__logger.info(f"Task '{event_id}' executed.")
-
         # Create an event entity for the executed job, including its ID and code
         data_event = self.__getTaskFromSchedulerById(event_id, event_code)
 
@@ -1025,15 +1021,9 @@ class Schedule(ISchedule):
 
         # Extract the job ID from the event object, or None if not present
         event_id = self.__getAttribute(event, 'job_id', None)
+
         # Extract the event code from the event object, defaulting to 0 if not present
         event_code = self.__getAttribute(event, 'code', 0)
-        # Extract the scheduled run time from the event object, or 'Unknown' if not present
-        event_scheduled_run_time = self.__getAttribute(event, 'scheduled_run_time', 'Unknown')
-
-        # Log a warning indicating that the job was missed and when it was scheduled to run
-        self.__logger.warning(
-            f"Task '{event_id}' was missed. It was scheduled to run at: {event_scheduled_run_time}."
-        )
 
         # Create an event entity for the missed job, including its ID and code
         data_event = self.__getTaskFromSchedulerById(event_id, event_code)
@@ -1077,9 +1067,6 @@ class Schedule(ISchedule):
         event_id = self.__getAttribute(event, 'job_id', None)
         event_code = self.__getAttribute(event, 'code', 0)
 
-        # Log an error message indicating that the job exceeded maximum concurrent instances
-        self.__logger.error(f"Task '{event_id}' exceeded maximum instances")
-
         # Create an event entity for the job that exceeded max instances
         data_event = self.__getTaskFromSchedulerById(event_id, event_code)
 
@@ -1120,27 +1107,109 @@ class Schedule(ISchedule):
         event_id = self.__getAttribute(event, 'job_id', None)
         event_code = self.__getAttribute(event, 'code', 0)
 
-        # Log the removal of the job
-        self.__logger.info(f"Task '{event_id}' has been removed.")
-
         # Create an event entity for the removed job
         data_event = self.__getTaskFromSchedulerById(event_id, event_code)
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         self.__taskCallableListener(data_event, ListeningEvent.JOB_ON_REMOVED)
 
+    def __triggerIsPast(
+        self,
+        signature: str,
+        entity: EventEntity
+    ) -> bool:
+        """
+        Determine if the trigger for a scheduled event is set to a date in the past.
+
+        This method checks whether the trigger associated with the given event entity is a
+        `DateTrigger` and, if so, compares its `run_date` to the current time in the scheduler's
+        configured timezone. If the trigger's run date is in the past, a warning is logged and
+        the method returns True, indicating that the event should be skipped.
+
+        Parameters
+        ----------
+        signature : str
+            The unique signature identifying the scheduled event.
+        entity : EventEntity
+            The event entity containing the trigger and scheduling information.
+
+        Returns
+        -------
+        bool
+            True if the event's trigger is a `DateTrigger` with a run date in the past; False otherwise.
+
+        Notes
+        -----
+        This method is used to prevent scheduling events that would immediately be considered expired.
+        """
+
+        # Check if the event's trigger is a DateTrigger and its run_date is in the past
+        if isinstance(entity.trigger, DateTrigger):
+            run_date = getattr(entity.trigger, 'run_date', None)
+            now = self.__getNow()
+
+            # If the run_date is set and is before the current time, log a warning and return True
+            if run_date is not None and run_date < now:
+                self.__logger.warning(
+                    f"Scheduled event '{signature}' has a run_date in the past ({run_date}); skipping."
+                )
+                return True
+
+        # Return False if the trigger is not a past DateTrigger
+        return False
+
+    def __eventToEntity(
+        self,
+        event
+    ) -> EventEntity:
+        """
+        Convert a scheduled event object to its corresponding EventEntity representation.
+
+        This method takes a scheduled event and transforms it into an `EventEntity` instance,
+        which encapsulates all relevant attributes required for internal tracking and management
+        within the scheduler. The conversion relies on the event implementing a `toEntity` method.
+
+        Parameters
+        ----------
+        event : Any
+            The scheduled event object to be converted. Must implement a `toEntity` method.
+
+        Returns
+        -------
+        EventEntity
+            An instance of `EventEntity` containing the extracted attributes from the event.
+
+        Raises
+        ------
+        CLIOrionisValueError
+            If the provided event does not implement a `toEntity` method.
+
+        Notes
+        -----
+        This method is used internally to standardize event objects for consistent handling
+        within the scheduler's job management system.
+        """
+
+        # Ensure the event has a toEntity method for conversion
+        if not hasattr(event, 'toEntity'):
+            raise CLIOrionisValueError("The event must have a 'toEntity' method for conversion.")
+
+        # Convert the event to its entity representation (EventEntity)
+        to_entity = getattr(event, 'toEntity')
+        return to_entity()
+
     def __loadEvents(
         self
     ) -> None:
         """
-        Load all scheduled events from the AsyncIOScheduler into the internal jobs list.
+        Synchronize and register all scheduled events with the AsyncIOScheduler.
 
-        This method synchronizes the internal jobs list (`self.__jobs`) with the events currently
-        registered in the AsyncIOScheduler. For each event in the internal events dictionary,
-        it converts the event to its entity representation, adds it to the jobs list, and schedules
-        it in the AsyncIOScheduler with the appropriate configuration. If a listener is associated
-        with the event, it is also registered. This ensures that all scheduled jobs are properly
-        tracked and managed by both the internal state and the scheduler.
+        This method updates the internal jobs list (`self.__jobs`) by converting each event in the internal
+        events dictionary to its corresponding entity representation. It then schedules these jobs in the
+        appropriate scheduler (control or main) based on their signature. Events with triggers set in the
+        past are skipped to prevent immediate expiration. Associated listeners are registered for each job
+        as needed. This ensures that all scheduled jobs are properly tracked and managed by both the internal
+        state and the scheduler.
 
         Parameters
         ----------
@@ -1149,65 +1218,51 @@ class Schedule(ISchedule):
         Returns
         -------
         None
-            This method does not return any value. It updates the internal jobs list and
-            registers jobs with the AsyncIOScheduler.
+            This method does not return any value. It updates the internal jobs list and registers jobs
+            with the AsyncIOScheduler.
 
         Raises
         ------
         CLIOrionisRuntimeError
-            If an error occurs while loading or scheduling an event, a runtime error is raised
-            with a descriptive message.
+            Raised if an error occurs while loading or scheduling an event.
 
         Notes
         -----
-        - Events are only loaded if the internal jobs list is empty.
-        - Each event must implement a `toEntity` method to be converted to an entity.
-        - Jobs are added to the scheduler with their respective configuration, and listeners
-          are registered if present.
+        - Events are loaded only if the internal jobs list is empty to avoid duplicate scheduling.
+        - Each event must implement a `toEntity` method for conversion.
+        - Jobs are added to the scheduler with their respective configuration, and listeners are registered if present.
         """
 
         # Only load events if the jobs list is empty to avoid duplicate scheduling
         if not self.__jobs:
 
+            # Lists to separate control jobs and custom jobs
+            control_jobs = []
+            custom_jobs = []
+
             # Iterate through all scheduled events in the internal events dictionary
             for signature, event in self.__events.items():
 
                 try:
 
-                    # Ensure the event has a toEntity method for conversion
-                    if not hasattr(event, 'toEntity'):
-                        continue
-
                     # Convert the event to its entity representation (EventEntity)
-                    to_entity = getattr(event, 'toEntity')
-                    entity: EventEntity = to_entity()
+                    entity = self.__eventToEntity(event)
+
+                    # Skip loading events with a DateTrigger set in the past
+                    if self.__triggerIsPast(signature, entity):
+                        continue
 
                     # Add the job entity to the internal jobs list
                     self.__jobs.append(entity)
 
-                    # Helper function to create a job function that calls the reactor
-                    def create_job_func(cmd, args_list):
-                        return lambda: self.__reactor.call(cmd, args_list)
-
-                    # Add the job to the AsyncIOScheduler with the specified configuration
-                    self.__scheduler.add_job(
-                        func=create_job_func(signature, list(entity.args)),
-                        trigger=entity.trigger,
-                        id=signature,
-                        name=signature,
-                        replace_existing=True,
-                        max_instances=entity.max_instances,
-                        misfire_grace_time=entity.misfire_grace_time
-                    )
-
-                    # If the event entity has an associated listener, register it
-                    if entity.listener:
-                        self.setListener(signature, entity.listener)
-
-                    # Log the successful loading of the scheduled event for debugging
-                    self.__logger.debug(f"Scheduled event '{signature}' loaded successfully.")
+                    # Determine which scheduler to use based on the job signature
+                    if signature in self.__control_operations:
+                        control_jobs.append((signature, entity))
+                    else:
+                        custom_jobs.append((signature, entity))
 
                 except Exception as e:
+
                     # Construct an error message for failed event loading
                     error_msg = f"Failed to load scheduled event '{signature}': {str(e)}"
 
@@ -1217,6 +1272,72 @@ class Schedule(ISchedule):
                     # Raise a runtime error to signal failure in loading the scheduled event
                     raise CLIOrionisRuntimeError(error_msg)
 
+            # Register control jobs with the control scheduler
+            self.__loadJobs(self.__control_scheduler, control_jobs)
+
+            # Register custom jobs with the main scheduler
+            self.__loadJobs(self.__scheduler, custom_jobs)
+
+            # Log the successful loading of the scheduled events for debugging
+            self.__logger.debug(f"Scheduled events loaded successfully: {len(self.__jobs)} jobs.")
+
+    def __loadJobs(
+        self,
+        scheduler: BaseScheduler,
+        events: List[Tuple[str, EventEntity]]
+    ) -> None:
+        """
+        Load and register jobs into the specified scheduler.
+
+        This method iterates over a list of event tuples, each containing a job signature and its corresponding
+        EventEntity. For each event, it creates a job function that invokes the reactor with the provided command
+        and arguments, then adds the job to the given scheduler with the appropriate configuration. If the event
+        entity has an associated listener, the listener is registered for the job.
+
+        Parameters
+        ----------
+        scheduler : BaseScheduler
+            The scheduler instance (either control or main) where jobs will be registered.
+        events : List[Tuple[str, EventEntity]]
+            A list of tuples, each containing a job signature and its corresponding EventEntity.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It registers jobs and listeners with the scheduler.
+
+        Notes
+        -----
+        - The job function is created as a lambda that calls the reactor with the command and arguments.
+        - Jobs are added with configuration options such as trigger, ID, name, max instances, misfire grace time, and coalesce.
+        - If an event entity has a listener, it is registered using the setListener method.
+        """
+
+        # Helper function to create a job function that calls the reactor with the given command and arguments
+        def create_job_func(cmd, args_list):
+
+            # Returns a lambda that executes the reactor call for the specified command and arguments
+            return lambda: self.__reactor.call(cmd, args_list)
+
+        # Iterate over each event tuple and add the job to the scheduler
+        for signature, entity in events:
+
+            # Add the job to the scheduler with the specified configuration
+            scheduler.add_job(
+                func=create_job_func(signature, list(entity.args)),
+                trigger=entity.trigger,
+                id=signature,
+                name=f"{signature}({', '.join(map(str, entity.args))})",
+                replace_existing=True,
+                max_instances=entity.max_instances,
+                misfire_grace_time=entity.misfire_grace_time,
+                coalesce=entity.coalesce
+            )
+
+            # If the event entity has an associated listener, register it
+            if entity.listener:
+                self.setListener(signature, entity.listener)
+
     def __raiseException(
         self,
         exception: BaseException
@@ -1319,7 +1440,6 @@ class Schedule(ISchedule):
 
         # Register the listener for the specified event in the internal listeners dictionary
         self.__listeners[event] = listener
-        print(self.__listeners)
 
     def pause(
         self
@@ -1350,9 +1470,6 @@ class Schedule(ISchedule):
         # Only pause jobs if the scheduler is currently running
         if self.isRunning():
 
-            # Clear the set of previously paused jobs to avoid stale entries
-            self.__pausedByPauseEverything.clear()
-
             # Retrieve all jobs currently managed by the scheduler
             all_jobs = self.__scheduler.get_jobs()
 
@@ -1360,22 +1477,14 @@ class Schedule(ISchedule):
             for job in all_jobs:
 
                 try:
+
                     # Get the job ID safely
                     job_id = self.__getAttribute(job, 'id', None)
 
                     # Skip jobs without a valid user-defined ID (ignore system/operation jobs)
-                    if not job_id or not isinstance(job_id, str) or job_id.strip() == "" or job_id in self.__operations:
+                    if not job_id or not isinstance(job_id, str) or job_id.strip() == "":
                         continue
 
-                    # Pause the job in the scheduler
-                    self.__scheduler.pause_job(job_id)
-
-                    # Track the paused job's ID
-                    self.__pausedByPauseEverything.add(job_id)
-
-                    # Get the current time in the configured timezone for logging
-                    now = self.__getCurrentTime()
-
                     # Retrieve event data for the paused job
                     event_data = self.__getTaskFromSchedulerById(job_id)
 
@@ -1385,9 +1494,6 @@ class Schedule(ISchedule):
                         ListeningEvent.JOB_ON_PAUSED
                     )
 
-                    # Log the pause action for this job
-                    self.__logger.info(f"Task '{job_id}' paused successfully at {now}.")
-
                 except Exception as e:
 
                     # Handle any errors that occur while pausing a job
@@ -1399,8 +1505,17 @@ class Schedule(ISchedule):
                 time=self.__getNow()
             ), ListeningEvent.SCHEDULER_PAUSED)
 
+            # Get the current time in the configured timezone for logging
+            now = self.__getCurrentTime()
+
+            # Clear the set of previously paused jobs to avoid stale entries
+            self.__scheduler.pause()
+
+            # Store the timestamp when the scheduler was paused
+            self.__paused_at = self.__getNow()
+
             # Log that all tasks have been paused
-            self.__logger.info("All tasks have been paused.")
+            self.__logger.info(f"Orionis Scheduler paused all tasks successfully at: {now}.")
 
     def resume(
         self
@@ -1429,55 +1544,44 @@ class Schedule(ISchedule):
         """
 
         # Only resume jobs if the scheduler is currently running
-        if self.isRunning():
-
-            # Resume only jobs that were paused by the pause method
-            if self.__pausedByPauseEverything:
-
-                # Iterate through the set of paused job IDs and resume each one
-                for job_id in self.__pausedByPauseEverything:
-
-                    try:
-
-                        # Resume the job in the scheduler
-                        self.__scheduler.resume_job(job_id)
-
-                        # Retrieve event data for the resumed job
-                        event_data = self.__getTaskFromSchedulerById(job_id)
+        if self.isPaused():
 
-                        # Invoke the listener for the resumed job event
-                        self.__taskCallableListener(
-                            event_data,
-                            ListeningEvent.JOB_ON_RESUMED
-                        )
+            # Execute the global callable listener after all jobs are resumed
+            self.__globalCallableListener(SchedulerResumed(
+                code=EVENT_SCHEDULER_RESUMED,
+                time=self.__getNow()
+            ), ListeningEvent.SCHEDULER_RESUMED)
 
-                        # Log an informational message indicating that the job has been resumed
-                        self.__logger.info(f"Task '{job_id}' has been resumed.")
+            # Get the current time in the configured timezone for logging
+            now = self.__getCurrentTime()
 
-                    except Exception as e:
+            # Cuando resumes:
+            resumed_at = self.__getNow()
 
-                        # Handle any errors that occur while resuming a job
-                        self.__raiseException(e)
+            # Resume main scheduler
+            self.__scheduler.resume()
 
-                # Clear the set after resuming all jobs to avoid stale entries
-                self.__pausedByPauseEverything.clear()
+            # Iterate through all jobs to check for missed executions
+            for job in self.__scheduler.get_jobs():
 
-                # Execute the global callable listener after all jobs are resumed
-                self.__globalCallableListener(SchedulerResumed(
-                    code=EVENT_SCHEDULER_RESUMED,
-                    time=self.__getNow()
-                ), ListeningEvent.SCHEDULER_RESUMED)
+                # If the job was supposed to run while paused, trigger the missed event
+                if job.next_run_time and self.__paused_at <= job.next_run_time < resumed_at:
 
-                # Get the current time in the configured timezone for logging
-                now = self.__getCurrentTime()
+                    # Retrieve event data for the missed job
+                    event_data = self.__getTaskFromSchedulerById(job.id)
 
-                # Log an informational message indicating that the scheduler has been resumed
-                self.__logger.info(f"Orionis Scheduler resumed successfully at {now}.")
+                    # Invoke the listener for the missed job event
+                    self.__taskCallableListener(
+                        event_data,
+                        ListeningEvent.JOB_ON_MISSED
+                    )
 
-                # Log that all previously paused jobs have been resumed
-                self.__logger.info("All previously task have been resumed.")
+            # Log an informational message indicating that the scheduler has been resumed
+            self.__logger.info(f"Orionis Scheduler resumed all tasks successfully at: {now}.")
 
-    async def start(self) -> None:
+    async def start(
+        self
+    ) -> None:
         """
         Start the AsyncIO scheduler instance and keep it running.
 
@@ -1514,6 +1618,7 @@ class Schedule(ISchedule):
             # Start the scheduler if it is not already running
             if not self.isRunning():
                 self.__scheduler.start()
+                self.__control_scheduler.start()
 
             # Log that the scheduler is now active and waiting for events
             self.__logger.info("Orionis Scheduler is now active and waiting for events...")
@@ -1553,7 +1658,10 @@ class Schedule(ISchedule):
             # Raise a runtime error for any other issues during startup
             raise CLIOrionisRuntimeError(f"Failed to start the scheduler: {str(e)}") from e
 
-    async def shutdown(self, wait: bool = True) -> None:
+    async def shutdown(
+        self,
+        wait: bool = True
+    ) -> None:
         """
         Shut down the AsyncIO scheduler instance asynchronously.
 
@@ -1587,15 +1695,13 @@ class Schedule(ISchedule):
 
         # If the scheduler is not running, there's nothing to shut down
         if not self.isRunning():
-            self.__logger.info("The scheduler is already stopped. No shutdown action is required.")
             return
 
         try:
-            # Log the shutdown process
-            self.__logger.info(f"Starting Orionis Scheduler shutdown process (wait={wait})...")
 
             # Shut down the AsyncIOScheduler
             self.__scheduler.shutdown(wait=wait)
+            self.__control_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():
@@ -1605,10 +1711,14 @@ class Schedule(ISchedule):
             if wait:
                 await asyncio.sleep(0.1)
 
+            # Get the current time in the configured timezone for logging
+            now = self.__getCurrentTime()
+
             # Log the successful shutdown
-            self.__logger.info("Orionis Scheduler has been shut down successfully.")
+            self.__logger.info(f"Orionis Scheduler has been shut down successfully at: {now}.")
 
         except Exception as e:
+
             # Handle exceptions that may occur during shutdown
             self.__raiseException(
                 CLIOrionisRuntimeError(
@@ -1616,7 +1726,10 @@ class Schedule(ISchedule):
                 )
             )
 
-    def pauseTask(self, signature: str) -> bool:
+    def pauseCommand(
+        self,
+        signature: str
+    ) -> bool:
         """
         Pause a scheduled job in the AsyncIO scheduler.
 
@@ -1652,9 +1765,19 @@ class Schedule(ISchedule):
             self.__raiseException(CLIOrionisValueError(self.SIGNATURE_REQUIRED_ERROR))
 
         try:
+
             # Attempt to pause the job with the given signature
             self.__scheduler.pause_job(signature)
 
+            # Retrieve event data for the paused job
+            event_data = self.__getTaskFromSchedulerById(signature)
+
+            # Invoke the listener for the paused job event
+            self.__taskCallableListener(
+                event_data,
+                ListeningEvent.JOB_ON_PAUSED
+            )
+
             # Log the successful pausing of the job
             self.__logger.info(f"Pause '{signature}' has been paused.")
 
@@ -1666,7 +1789,10 @@ class Schedule(ISchedule):
             # Return False if the job could not be paused (e.g., it does not exist or another error occurred)
             return False
 
-    def resumeTask(self, signature: str) -> bool:
+    def resumeCommand(
+        self,
+        signature: str
+    ) -> bool:
         """
         Resume a paused job in the AsyncIO scheduler.
 
@@ -1706,6 +1832,15 @@ class Schedule(ISchedule):
             # Attempt to resume the job with the given signature
             self.__scheduler.resume_job(signature)
 
+            # Retrieve event data for the resumed job
+            event_data = self.__getTaskFromSchedulerById(signature)
+
+            # Invoke the listener for the resumed job event
+            self.__taskCallableListener(
+                event_data,
+                ListeningEvent.JOB_ON_RESUMED
+            )
+
             # Log the successful resumption of the job
             self.__logger.info(f"Task '{signature}' has been resumed.")
 
@@ -1717,7 +1852,10 @@ class Schedule(ISchedule):
             # Return False if the job could not be resumed (e.g., it does not exist or another error occurred)
             return False
 
-    def removeTask(self, signature: str) -> bool:
+    def removeCommand(
+        self,
+        signature: str
+    ) -> bool:
         """
         Remove a scheduled job from the AsyncIO scheduler by its signature.
 
@@ -1775,7 +1913,9 @@ class Schedule(ISchedule):
             # Return False if the job could not be removed (e.g., it does not exist or another error occurred)
             return False
 
-    def events(self) -> List[Dict]:
+    def events(
+        self
+    ) -> List[Dict]:
         """
         Retrieve a list of all scheduled jobs managed by the scheduler.
 
@@ -1909,7 +2049,9 @@ class Schedule(ISchedule):
         # Return None if no job with the given signature is found
         return None
 
-    def isRunning(self) -> bool:
+    def isRunning(
+        self
+    ) -> bool:
         """
         Check if the scheduler is currently running.
 
@@ -1924,9 +2066,11 @@ class Schedule(ISchedule):
         """
 
         # Return True if the scheduler is running, otherwise False
-        return self.__scheduler.running
+        return self.__scheduler.running and self.__scheduler.state == STATE_RUNNING
 
-    def isPaused(self) -> bool:
+    def isPaused(
+        self
+    ) -> bool:
         """
         Check if the scheduler is currently paused.
 
@@ -1942,9 +2086,11 @@ class Schedule(ISchedule):
         """
 
         # The scheduler is considered paused if there are any jobs in the paused set
-        return len(self.__pausedByPauseEverything) > 0
+        return self.__scheduler.running and self.__scheduler.state == STATE_PAUSED
 
-    def forceStop(self) -> None:
+    def forceStop(
+        self
+    ) -> None:
         """
         Forcefully stop the scheduler immediately, bypassing graceful shutdown.
 
@@ -1969,12 +2115,15 @@ class Schedule(ISchedule):
         # If the scheduler is currently running, shut it down immediately without waiting for jobs to finish
         if self.__scheduler.running:
             self.__scheduler.shutdown(wait=False)
+            self.__control_scheduler.shutdown(wait=False)
 
         # If the stop event exists and has not already been set, signal it to interrupt the main loop
         if self._stop_event and not self._stop_event.is_set():
             self._stop_event.set()
 
-    def stop(self) -> None:
+    def stop(
+        self
+    ) -> None:
         """
         Signal the scheduler to stop synchronously by setting the internal stop event.
 

orionis/metadata/framework.py

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

{orionis-0.726.0.dist-info → orionis-0.727.0.dist-info}/METADATA

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

{orionis-0.726.0.dist-info → orionis-0.727.0.dist-info}/RECORD

@@ -15,7 +15,7 @@ orionis/console/commands/help.py,sha256=VFIn3UqQm4pxwjfSQohVwKNpc7F-6XRcwSZQwDSL
 orionis/console/commands/log_clear.py,sha256=OI1j_myCYUOMI-SfnN-NH-6BYzzWKXOKIEb55vFTXq4,4045
 orionis/console/commands/make_command.py,sha256=WHE2J78fuY9RHScCOn9R_2KjkiayYJHFlm-Mp-k8X-o,5956
 orionis/console/commands/scheduler_list.py,sha256=7Ug0eoqusIOsmHaiakm3-JYAK8VNIypOtKMcSzn-AL0,4544
-orionis/console/commands/scheduler_work.py,sha256=NV-WhJwY4Lv_x6UO2FcWikA1HFFK-PmJWm-oHQPs0fg,5573
+orionis/console/commands/scheduler_work.py,sha256=dDW9XTjGb-5ABuhPYjfd1rfO7xLDhgYu5nd6nToiYFE,5597
 orionis/console/commands/test.py,sha256=G3pveONRbeWTcVwaHat3wTAhxMm4g_BwhJhIejq6V0Y,3518
 orionis/console/commands/version.py,sha256=u5_8CfnEVdS3VSME8rbP6o3Z0XFZ30nSz8uHdahBAoY,4766
 orionis/console/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,12 +25,12 @@ orionis/console/contracts/cli_request.py,sha256=Q5eiOitdZve-33e5dqO_O-Fha5I1u4u7
 orionis/console/contracts/command.py,sha256=Wvm62hw2gDIPNmoEUFyhKUERjZ6wnAbI-UDY_5gJE24,3626
 orionis/console/contracts/console.py,sha256=TuoyCLInhp5ztlyJ82rBsw_1Ki3_fOnF_gtaWUxSW1M,14253
 orionis/console/contracts/dumper.py,sha256=h8ScHF31Q3oOdEe5_EyozOD8OGcLvkMG4KkJwa3ANX8,4538
-orionis/console/contracts/event.py,sha256=KQESAycPzBE3xoDTnbYLz_XXg-7dwrybYKbaJjgkCMY,119842
+orionis/console/contracts/event.py,sha256=cdnao4tqVhIr24X1uFzFfzZ4wdN1OZcKS1sKcX33abU,119843
 orionis/console/contracts/executor.py,sha256=JAzK64_5HfIGm3_BwsUv7-ZeC2Y-3mpxOByHaXwuy9A,4278
 orionis/console/contracts/kernel.py,sha256=mh4LlhEYHh3FuGZZQ0GBhD6ZLa5YQvaNj2r01IIHI5Y,826
 orionis/console/contracts/progress_bar.py,sha256=NYebL2h-vg2t2H6IhJjuC37gglRkpT-MW71wbJtpLNg,1784
 orionis/console/contracts/reactor.py,sha256=iT6ShoCutAWEeJzOf_PK7CGXi9TgrOD5tewHFVQ2NQw,6075
-orionis/console/contracts/schedule.py,sha256=xtXgp4BPhvhg3YSM4mrIdbyoBdr4OJBi1gBM_kJN5UQ,13694
+orionis/console/contracts/schedule.py,sha256=NaVOUpuE08X5rm9-oXyNs6r3LbOg7B_rIz-k4r7y4Qk,13703
 orionis/console/contracts/schedule_event_listener.py,sha256=h06qsBxuEMD3KLSyu0JXdUDHlQW19BX9lA09Qrh2QXg,3818
 orionis/console/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/core/reactor.py,sha256=qctLns-f5eB9Air7Qi4hvX5KB5A7SsHeV8M5zYJEiPA,44286
@@ -40,7 +40,7 @@ orionis/console/dynamic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 orionis/console/dynamic/progress_bar.py,sha256=58wne7E_QZb_uN9jjqQ_V28Ci19SVNhCQQ4zzXCiOu0,2872
 orionis/console/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/entities/command.py,sha256=NPdyG4U3JtDMOS7Em2_AklNyyuoTnKxyGseMWrADlc4,1571
-orionis/console/entities/event.py,sha256=44exJIBMB8v_Dixv2qgatl2ln-Tmv7g2b63oetsJFHc,3015
+orionis/console/entities/event.py,sha256=ri7BVjBhpPlxUt-gmJObuhB2gqVQ-vTXUyPy2iv2Aj0,3101
 orionis/console/entities/event_job.py,sha256=b8fbloHnf7qYtQ0W4d7MWw0jj4l07B0RtS3UkMJwE0M,4292
 orionis/console/entities/scheduler_error.py,sha256=VzwSK8DloX-tFlBLWX93sEV4oO0Qo9rheNjiOEjdNyE,1413
 orionis/console/entities/scheduler_event_data.py,sha256=s9zYvLYO4O91l_9Qncx688QjcsjrIjXI8xsXqK2ZlHI,785
@@ -56,7 +56,7 @@ orionis/console/exceptions/__init__.py,sha256=rY9PE85TO_HpI5cfGWbZSDzk5aOUjErqBZ
 orionis/console/exceptions/cli_exceptions.py,sha256=nk3EGkRheDbw8vrxKgUxkAAPA6gPpO2dE5nDeVHJHA0,3580
 orionis/console/fluent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/fluent/command.py,sha256=0jyhB45LIjDS7nkjNhkkvEXEzdOBmT49qKIooYY_DbI,8261
-orionis/console/fluent/event.py,sha256=N1MqKdXwmsHx3KES07DVCLVrdwaIMWYAtzUzQmsfsAI,166739
+orionis/console/fluent/event.py,sha256=lw0lYRhHxyflA7JE4ZLye6rjEOGUmLFMO9e9btwWfNM,168532
 orionis/console/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/output/console.py,sha256=xRZXSZiVqlyc1L16MBUV1M3TUHQwrWSFYUtisivm8U8,24423
 orionis/console/output/executor.py,sha256=uQjFPOlyZLFj9pcyYPugCqxwJog0AJgK1OcmQH2ELbw,7314
@@ -65,7 +65,7 @@ orionis/console/request/cli_request.py,sha256=sH7Q2MpMIasiPiEPBeGhExnbfpSic98vQd
 orionis/console/stubs/command.stub,sha256=ABQ2eFxJ0u0DvTfmoO_DdECkBy-rie-woG62G2Gxw8Y,805
 orionis/console/stubs/listener.stub,sha256=DbX-ghx2-vb73kzQ6L20lyg5vSKn58jSLTwFuwNQU9k,4331
 orionis/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/tasks/schedule.py,sha256=Mkc7JuaL2udP-G1ScU6PduJaVJ99DOi_SxYn_b_1bwo,88064
+orionis/console/tasks/schedule.py,sha256=R2mkjp7zFSnhlaBWDrdzcQsHmj8cdOUNyx2_73tzWx0,92762
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/container.py,sha256=LaGFSzDH2YjmWzdiV-r8Z9xs9fyFGJnsanRsEStqHp8,114033
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -207,7 +207,7 @@ orionis/foundation/providers/scheduler_provider.py,sha256=IrPQJwvQVLRm5Qnz0Cxon4
 orionis/foundation/providers/testing_provider.py,sha256=eI1p2lUlxl25b5Z487O4nmqLE31CTDb4c3Q21xFadkE,1615
 orionis/foundation/providers/workers_provider.py,sha256=GdHENYV_yGyqmHJHn0DCyWmWId5xWjD48e6Zq2PGCWY,1674
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=p9NK8n3fiDSCWLnUO9Me42erVCeXD8UH8YasgGZhynM,4720
+orionis/metadata/framework.py,sha256=nfWN_AFm6d2eQFvlJzxl1uswTO-wwXT7brAA27gKiEw,4720
 orionis/metadata/package.py,sha256=s1JeGJPwdVh4jO3IOfmpwMuJ_oX6Vf9NL7jgPEQNf5Y,16050
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -402,8 +402,8 @@ orionis/test/validators/workers.py,sha256=HcZ3cnrk6u7cvM1xZpn_lsglHAq69_jx9RcTSv
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=arysoswhkV2vUd2aVMZRPpmH317jaWbgjDpQ_AWQ5AE,5663
 orionis/test/view/report.stub,sha256=QLqqCdRoENr3ECiritRB3DO_MOjRQvgBh5jxZ3Hs1r0,28189
-orionis-0.726.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
-orionis-0.726.0.dist-info/METADATA,sha256=2Z0YFtOcU6B04z5lkRaCfFwLlwmFP_roXbo9KazNr6M,4962
-orionis-0.726.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.726.0.dist-info/top_level.txt,sha256=lyXi6jArpqJ-0zzNqd_uwsH-z9TCEBVBL-pC3Ekv7hU,8
-orionis-0.726.0.dist-info/RECORD,,
+orionis-0.727.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.727.0.dist-info/METADATA,sha256=SqjKGk5oqSuIgDXwexcEWVR_ie_IARUEVjM9OgmCsus,4962
+orionis-0.727.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.727.0.dist-info/top_level.txt,sha256=lyXi6jArpqJ-0zzNqd_uwsH-z9TCEBVBL-pC3Ekv7hU,8
+orionis-0.727.0.dist-info/RECORD,,