orionis 0.523.0__py3-none-any.whl → 0.525.0__py3-none-any.whl

orionis/console/base/scheduler_event_listener.py

@@ -1,12 +1,5 @@
 from orionis.console.contracts.schedule_event_listener import IScheduleEventListener
-from orionis.console.entities.job_error import JobError
-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_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.event_job import EventJob
 
 class BaseScheduleEventListener(IScheduleEventListener):
     """
@@ -17,119 +10,155 @@ class BaseScheduleEventListener(IScheduleEventListener):
     specific behavior for each event type.
     """
 
-    async def before(self, event: JobSubmitted, schedule):
+    async def before(self, event: EventJob, schedule):
         """
         Called before processing a job submission event.
 
         Parameters
         ----------
-        event : JobSubmitted
-            The job submission event.
+        event : EventJob
+            The job submission event containing details about the job.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for pre-job submission logic
 
-    async def after(self, event: JobExecuted, schedule):
+    async def after(self, event: EventJob, schedule):
         """
         Called after processing a job execution event.
 
         Parameters
         ----------
-        event : JobExecuted
-            The job execution event.
+        event : EventJob
+            The job execution event containing details about the job.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for post-job execution logic
 
-    async def onSuccess(self, event: JobExecuted, schedule):
+    async def onSuccess(self, event: EventJob, schedule):
         """
         Called when a job is successfully executed.
 
         Parameters
         ----------
-        event : JobExecuted
-            The successful job execution event.
+        event : EventJob
+            The successful job execution event containing details about the job.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle successful job execution
 
-    async def onFailure(self, event: JobError, schedule):
+    async def onFailure(self, event: EventJob, schedule):
         """
         Called when a job execution fails.
 
         Parameters
         ----------
-        event : JobError
-            The job error event.
+        event : EventJob
+            The job error event containing details about the failure.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle job execution failure
 
-    async def onMissed(self, event: JobMissed, schedule):
+    async def onMissed(self, event: EventJob, schedule):
         """
         Called when a job execution is missed.
 
         Parameters
         ----------
-        event : JobMissed
-            The missed job event.
+        event : EventJob
+            The missed job event containing details about the missed execution.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle missed job execution
 
-    async def onMaxInstances(self, event: JobMaxInstances, schedule):
+    async def onMaxInstances(self, event: EventJob, schedule):
         """
         Called when a job exceeds the maximum allowed instances.
 
         Parameters
         ----------
-        event : JobMaxInstances
-            The max instances event.
+        event : EventJob
+            The max instances event containing details about the job.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the job.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle max instances exceeded
 
-    async def onPaused(self, event: JobPause, schedule):
+    async def onPaused(self, event: EventJob, schedule):
         """
         Called when the scheduler is paused.
 
         Parameters
         ----------
-        event : JobPause
-            The pause event.
+        event : EventJob
+            The pause event containing details about the scheduler state.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the jobs.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle scheduler pause
 
-    async def onResumed(self, event: JobResume, schedule):
+    async def onResumed(self, event: EventJob, schedule):
         """
         Called when the scheduler is resumed.
 
         Parameters
         ----------
-        event : JobResume
-            The resume event.
+        event : EventJob
+            The resume event containing details about the scheduler state.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the jobs.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle scheduler resume
 
-    async def onRemoved(self, event: JobRemoved, schedule):
+    async def onRemoved(self, event: EventJob, schedule):
         """
         Called when a job is removed from the scheduler.
 
         Parameters
         ----------
-        event : JobRemoved
-            The job removal event.
+        event : EventJob
+            The job removal event containing details about the removed job.
         schedule : ISchedule
-            The associated schedule.
+            The associated schedule instance managing the jobs.
+
+        Returns
+        -------
+        None
         """
-        pass
+        pass  # Placeholder for logic to handle job removal

orionis/console/contracts/schedule_event_listener.py

@@ -1,12 +1,6 @@
 from abc import ABC, abstractmethod
-from orionis.console.entities.job_error import JobError
-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_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.event_job import EventJob
 
 class IScheduleEventListener(ABC):
     """
@@ -14,273 +8,163 @@ class IScheduleEventListener(ABC):
     """
 
     @abstractmethod
-    async def before(self, event: JobSubmitted, schedule):
+    async def before(self, event: EventJob, schedule):
         """
-        Hook method called before the main event handling logic.
-
-        This method is invoked prior to processing the event, allowing for any
-        pre-processing or setup tasks to be performed. It can be overridden to
-        implement custom logic that should execute before the event is handled.
+        Called before processing a job submission event.
 
         Parameters
         ----------
-        event : JobSubmitted
-            The event object that is about to be processed. This contains
-            information about the job submission.
+        event : EventJob
+            The job submission event containing details about the job.
         schedule : ISchedule
-            The schedule object associated with the event. This provides
-            context about the scheduling system.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value.
-
-        Notes
-        -----
-        Override this method to define actions or checks that should occur
-        before the event is processed.
         """
-
-        # This is an abstract method, so it does not contain any implementation.
-        # Subclasses must override this method to provide specific behavior.
         pass
 
     @abstractmethod
-    async def after(self, event: JobExecuted, schedule):
+    async def after(self, event: EventJob, schedule):
         """
-        Hook method called after an event is processed.
-
-        This method is invoked once the event processing is complete, allowing
-        for any post-processing or cleanup tasks to be performed. It can be
-        overridden to implement custom logic that should execute after the
-        event is handled.
+        Called after processing a job execution event.
 
         Parameters
         ----------
-        event : JobExecuted
-            The event object that was processed. This contains information
-            about the job execution, such as its status and metadata.
+        event : EventJob
+            The job execution event containing details about the job.
         schedule : ISchedule
-            The schedule object associated with the event. This provides
-            context about the scheduling system and its state.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value.
-
-        Notes
-        -----
-        Override this method to define actions or checks that should occur
-        after the event is processed, such as logging, resource cleanup, or
-        triggering subsequent tasks.
         """
-
-        # This is an abstract method, so it does not contain any implementation.
-        # Subclasses must override this method to provide specific behavior.
         pass
 
     @abstractmethod
-    async def onFailure(self, event: JobError, schedule):
+    async def onSuccess(self, event: EventJob, schedule):
         """
-        Handle the event when a failure occurs during event processing.
-
-        This method is invoked whenever an error or failure occurs during the
-        processing of an event. It allows for custom error handling logic to be
-        implemented, such as logging the error, notifying relevant parties, or
-        performing cleanup tasks. Subclasses should override this method to
-        define specific actions to take in response to failures.
+        Called when a job is successfully executed.
 
         Parameters
         ----------
-        event : JobError
-            The event object containing detailed information about the failure,
-            including the error message, stack trace, and any relevant metadata.
+        event : EventJob
+            The successful job execution event containing details about the job.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the failure.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the failure.
-
-        Notes
-        -----
-        Override this method to implement specific error handling logic that
-        aligns with the application's requirements.
         """
-
-        # This is an abstract method, so it does not contain any implementation.
-        # Subclasses must override this method to provide specific behavior.
         pass
 
     @abstractmethod
-    async def onMissed(self, event: JobMissed, schedule):
+    async def onFailure(self, event: EventJob, schedule):
         """
-        Handle the event triggered when an expected job execution is missed.
-
-        This method is invoked whenever a scheduled job is missed, allowing for
-        custom handling logic to be implemented. Subclasses should override this
-        method to define specific actions to take in response to missed events,
-        such as logging, notifications, or corrective measures.
+        Called when a job execution fails.
 
         Parameters
         ----------
-        event : JobMissed
-            The event object containing details about the missed job, including
-            its metadata and the reason it was missed.
+        event : EventJob
+            The job error event containing details about the failure.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the missed event.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the missed event.
-
-        Notes
-        -----
-        Override this method to implement specific logic that aligns with the
-        application's requirements for handling missed job executions.
         """
-
-        # Abstract method: Subclasses must provide an implementation for this.
         pass
 
     @abstractmethod
-    async def onMaxInstances(self, event: JobMaxInstances, schedule):
+    async def onMissed(self, event: EventJob, schedule):
         """
-        Handle the event triggered when a job exceeds the maximum allowed instances.
-
-        This method is invoked whenever a job attempts to run but is blocked
-        because it has reached its maximum number of concurrent instances.
-        Subclasses should override this method to define specific actions to
-        take in response to this event, such as logging, notifications, or
-        implementing backoff strategies.
+        Called when a job execution is missed.
 
         Parameters
         ----------
-        event : JobMaxInstances
-            The event object containing details about the job that exceeded
-            its maximum instances, including its metadata and the configured limit.
+        event : EventJob
+            The missed job event containing details about the missed execution.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the event.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the max instances event.
-
-        Notes
-        -----
-        Override this method to implement specific logic that aligns with the
-        application's requirements for handling jobs that exceed their maximum instances.
         """
-
-        # Abstract method: Subclasses must provide an implementation for this.
         pass
 
     @abstractmethod
-    async def onPaused(self, event: JobPause, schedule):
+    async def onMaxInstances(self, event: EventJob, schedule):
         """
-        Handle the event triggered when the scheduler is paused.
-
-        This method is invoked whenever the scheduler is paused, allowing for
-        custom handling logic to be implemented. Subclasses should override this
-        method to define specific actions to take in response to the pause event,
-        such as logging, notifications, or resource management.
+        Called when a job exceeds the maximum allowed instances.
 
         Parameters
         ----------
-        event : JobPause
-            The event object containing details about the pause event.
+        event : EventJob
+            The max instances event containing details about the job.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the pause event.
+            The associated schedule instance managing the job.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the pause event.
-
-        Notes
-        -----
-        Override this method to implement specific logic that aligns with the
-        application's requirements for handling scheduler pause events.
         """
-
-        # Abstract method: Subclasses must provide an implementation for this.
         pass
 
     @abstractmethod
-    async def onResumed(self, event: JobResume, schedule):
+    async def onPaused(self, event: EventJob, schedule):
         """
-        Handle the event triggered when the scheduler is resumed.
-
-        This method is invoked whenever the scheduler is resumed, allowing for
-        custom handling logic to be implemented. Subclasses should override this
-        method to define specific actions to take in response to the resume event,
-        such as logging, notifications, or resource management.
+        Called when the scheduler is paused.
 
         Parameters
         ----------
-        event : JobResume
-            The event object containing details about the resume event.
+        event : EventJob
+            The pause event containing details about the scheduler state.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the resume event.
+            The associated schedule instance managing the jobs.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the resume event.
-
-        Notes
-        -----
-        Override this method to implement specific logic that aligns with the
-        application's requirements for handling scheduler resume events.
         """
-
-        # Abstract method: Subclasses must provide an implementation for this.
         pass
 
     @abstractmethod
-    async def onRemoved(self, event: JobRemoved, schedule):
+    async def onResumed(self, event: EventJob, schedule):
         """
-        Handle the event triggered when a job is removed from the scheduler.
-
-        This method is invoked whenever a job is removed, allowing for custom
-        handling logic to be implemented. Subclasses should override this method
-        to define specific actions to take in response to the job removal event,
-        such as logging, notifications, or resource cleanup.
+        Called when the scheduler is resumed.
 
         Parameters
         ----------
-        event : JobRemoved
-            The event object containing details about the removed job.
+        event : EventJob
+            The resume event containing details about the scheduler state.
         schedule : ISchedule
-            The schedule object associated with the event, providing context
-            about the scheduling system and its state at the time of the job removal.
+            The associated schedule instance managing the jobs.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for handling
-            side effects or performing actions in response to the job removal event.
+        """
+        pass
 
-        Notes
-        -----
-        Override this method to implement specific logic that aligns with the
-        application's requirements for handling job removal events.
+    @abstractmethod
+    async def onRemoved(self, event: EventJob, schedule):
         """
+        Called when a job is removed from the scheduler.
 
-        # Abstract method: Subclasses must provide an implementation for this.
+        Parameters
+        ----------
+        event : EventJob
+            The job removal event containing details about the removed job.
+        schedule : ISchedule
+            The associated schedule instance managing the jobs.
+
+        Returns
+        -------
+        None
+        """
         pass

orionis/console/entities/event_job.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, Dict, Optional, Tuple
+
+@dataclass(kw_only=True)
+class EventJob:
+    """
+    Represents the main properties of a job in APScheduler.
+
+    Attributes
+    ----------
+    id : str
+        Unique identifier for the job.
+    name : Optional[str]
+        Human-readable name for the job. Can be None if not specified.
+    func : Callable[..., Any]
+        The function or coroutine to be executed by the job.
+    args : Tuple[Any, ...]
+        Positional arguments to be passed to the function.
+    trigger : Any
+        The trigger that determines the job's execution schedule
+        (e.g., IntervalTrigger, CronTrigger, etc.).
+    executor : str
+        Alias of the executor that will run the job.
+    jobstore : str
+        Alias of the job store where the job is stored.
+    misfire_grace_time : Optional[int]
+        Grace period in seconds for handling missed executions.
+        If None, no grace period is applied.
+    max_instances : int
+        Maximum number of concurrent instances of the job allowed.
+    coalesce : bool
+        Whether to merge pending executions into a single execution.
+    next_run_time : Optional[datetime]
+        The next scheduled execution time of the job. Can be None if the job is paused or unscheduled.
+
+    Returns
+    -------
+    None
+        This class is a data container and does not return any value.
+    """
+    id: str
+    code: int = 0
+    name: Optional[str] = None
+    func: Callable[..., Any] = None
+    args: Tuple[Any, ...] = ()
+    trigger: Any = None
+    executor: str = 'default'
+    jobstore: str = 'default'
+    misfire_grace_time: Optional[int] = None
+    max_instances: int = 1
+    coalesce: bool = False
+    next_run_time: Optional[datetime] = None
+    exception: Optional[BaseException] = None
+    traceback: Optional[str] = None
+    retval: Optional[Any] = None
+    purpose: Optional[str] = None
+    start_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None
+    details: Optional[str] = None

orionis/console/entities/scheduler_error.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Optional
+from orionis.console.entities.scheduler_event_data import SchedulerEventData
+
+@dataclass(kw_only=True)
+class SchedulerError(SchedulerEventData):
+    """
+    Represents an event triggered when the scheduler is paused.
+
+    This class is a data structure that inherits from `SchedulerEventData` 
+    and is used to encapsulate information related to the scheduler pause event.
+
+    Attributes
+    ----------
+    (Inherited from SchedulerEventData)
+    """
+
+    exception: Optional[BaseException] = None  # Exception that caused the scheduler error
+    traceback: Optional[str] = None  # Traceback information related to the scheduler error

orionis/console/entities/scheduler_event_data.py

@@ -16,9 +16,6 @@ class SchedulerEventData:
     code : int
         A numeric code that uniquely identifies the type of event within the
         scheduler system.
-    alias : str, optional
-        An optional string providing additional context or identifying specific
-        components (e.g., executors or job stores) related to the event.
 
     Returns
     -------
@@ -26,8 +23,6 @@ class SchedulerEventData:
         An instance of the `SchedulerEventData` class containing the event code
         and optional alias.
     """
+
     # Numeric code representing the type of event
     code: int
-
-    # Optional alias for additional context about the event
-    alias: Optional[str] = None

orionis/console/entities/scheduler_paused.py

@@ -13,5 +13,5 @@ class SchedulerPaused(SchedulerEventData):
     ----------
     (Inherited from SchedulerEventData)
     """
-    # No additional attributes or methods are defined here, as this class 
-    # serves as a specialized event marker for when the scheduler is paused.
+
+    time: str  # Time when the scheduler was paused