orionis 0.511.0__py3-none-any.whl → 0.513.0__py3-none-any.whl

orionis/console/contracts/schedule.py

@@ -4,6 +4,40 @@ from orionis.console.tasks.event import Event
 
 class ISchedule(ABC):
 
+    @abstractmethod
+    def _setListener(
+        self,
+        event: str,
+        listener: callable
+    ) -> None:
+        """
+        Register a listener callback for a specific scheduler event.
+
+        This method allows the registration of a callable listener function that will be
+        invoked when the specified scheduler event occurs. The event can be one of the
+        predefined global events or a specific job ID. The listener must be a callable
+        function that accepts a single argument, which will be the event object.
+
+        Parameters
+        ----------
+        event : str
+            The name of the event to listen for. This can be a global event name (e.g., 'scheduler_started')
+            or a specific job ID.
+        listener : callable
+            A callable function that will be invoked when the specified event occurs.
+            The function should accept one parameter, which will be the event object.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It registers the listener for the specified event.
+
+        Raises
+        ------
+        ValueError
+            If the event name is not a non-empty string or if the listener is not callable.
+        """
+
     @abstractmethod
     def command(
         self,

orionis/console/contracts/schedule_event_listener.py

@@ -0,0 +1,320 @@
+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
+
+class IScheduleEventListener(ABC):
+    """
+    Interface for event listeners that handle various stages of event processing.
+    """
+
+    @abstractmethod
+    async def before(self, event: JobSubmitted, 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.
+
+        Parameters
+        ----------
+        event : JobSubmitted
+            The event object that is about to be processed. This contains
+            information about the job submission.
+        schedule : ISchedule
+            The schedule object associated with the event. This provides
+            context about the scheduling system.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobExecuted
+            The event object that was processed. This contains information
+            about the job execution, such as its status and metadata.
+        schedule : ISchedule
+            The schedule object associated with the event. This provides
+            context about the scheduling system and its state.
+
+        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 onSuccess(self, event: JobExecuted, schedule):
+        """
+        Handle actions to be performed when an event is successfully processed.
+
+        This method is invoked after an event is processed successfully, allowing
+        for any follow-up actions, such as logging, notifications, or triggering
+        dependent tasks. Subclasses should override this method to define custom
+        behavior for handling successful event processing.
+
+        Parameters
+        ----------
+        event : JobExecuted
+            The event object containing details about the successfully executed job,
+            such as its status, metadata, and execution results.
+        schedule : ISchedule
+            The schedule object associated with the event, providing context about
+            the scheduling system and its state.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Override this method to implement specific actions or checks that should
+        occur after an event is successfully 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 onFailure(self, event: JobError, 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.
+
+        Parameters
+        ----------
+        event : JobError
+            The event object containing detailed information about the failure,
+            including the error message, stack trace, and any relevant metadata.
+        schedule : ISchedule
+            The schedule object associated with the event, providing context
+            about the scheduling system and its state at the time of the failure.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobMissed
+            The event object containing details about the missed job, including
+            its metadata and the reason it was missed.
+        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.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobMaxInstances
+            The event object containing details about the job that exceeded
+            its maximum instances, including its metadata and the configured limit.
+        schedule : ISchedule
+            The schedule object associated with the event, providing context
+            about the scheduling system and its state at the time of the event.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobPause
+            The event object containing details about the pause event.
+        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.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobResume
+            The event object containing details about the resume event.
+        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.
+
+        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):
+        """
+        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.
+
+        Parameters
+        ----------
+        event : JobRemoved
+            The event object containing details about the removed job.
+        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.
+
+        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.
+
+        Notes
+        -----
+        Override this method to implement specific logic that aligns with the
+        application's requirements for handling job removal events.
+        """
+
+        # Abstract method: Subclasses must provide an implementation for this.
+        pass

orionis/console/contracts/scheduler.py

@@ -0,0 +1,140 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from orionis.console.contracts.schedule import ISchedule
+
+class IBaseScheduler(ABC):
+
+    # Pause Global Scheduler at a specific time
+    PAUSE_AT: datetime = None
+
+    # Resume Global Scheduler at a specific time
+    RESUME_AT: datetime = None
+
+    # Finalize Global Scheduler at a specific time
+    FINALIZE_AT: datetime = None
+
+    @abstractmethod
+    def tasks(self, schedule: ISchedule):
+        """
+        Defines and registers scheduled tasks for the application.
+
+        Parameters
+        ----------
+        schedule : ISchedule
+            The schedule object used to define and register scheduled commands. 
+            This object provides methods to add tasks to the scheduler.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It is intended to be overridden
+            by subclasses to specify scheduled tasks.
+
+        Notes
+        -----
+        This method serves as a contract for subclasses to implement task registration
+        logic. Subclasses should use the provided `schedule` object to define and
+        register tasks that the scheduler will execute.
+        """
+        # Abstract method to be implemented by subclasses for task registration
+        pass
+
+    @abstractmethod
+    def onStarted(self):
+        """
+        Called when the scheduler is started.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Subclasses should override this method to implement custom behavior that
+        should occur when the scheduler starts running. This can include initializing
+        resources or logging the start event.
+        """
+        # Abstract method to define behavior when the scheduler starts
+        pass
+
+    @abstractmethod
+    def onPaused(self):
+        """
+        Called when the scheduler is paused.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Subclasses should override this method to define custom behavior that occurs
+        when the scheduler enters a paused state. This can include saving the current
+        state or logging the pause event.
+        """
+        # Abstract method to define behavior when the scheduler is paused
+        pass
+
+    @abstractmethod
+    def onResumed(self):
+        """
+        Called when the scheduler is resumed from a paused state.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Subclasses should override this method to implement any actions that need to
+        occur when the scheduler resumes operation. This can include restoring the
+        state or logging the resume event.
+        """
+        # Abstract method to define behavior when the scheduler is resumed
+        pass
+
+    @abstractmethod
+    def onFinalized(self):
+        """
+        Called when the scheduler has completed its execution and is being finalized.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Subclasses can override this method to perform any necessary cleanup or
+        finalization tasks, such as releasing resources or logging the finalization
+        event.
+        """
+        # Abstract method to define behavior when the scheduler is finalized
+        pass
+
+    @abstractmethod
+    def onError(self, error: Exception):
+        """
+        Handles errors that occur within the scheduler.
+
+        Parameters
+        ----------
+        error : Exception
+            The exception instance representing the error that occurred.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Subclasses can override this method to implement custom error handling logic
+        for the scheduler. This can include logging the error, notifying stakeholders,
+        or attempting to recover from the error.
+        """
+        # Abstract method to define behavior for handling errors in the scheduler
+        pass

orionis/console/core/reactor.py

@@ -4,7 +4,7 @@ import re
 from typing import Any, List, Optional
 from orionis.console.args.argument import CLIArgument
 from orionis.console.base.command import BaseCommand
-from orionis.console.base.contracts.command import IBaseCommand
+from orionis.console.contracts.command import IBaseCommand
 from orionis.console.contracts.reactor import IReactor
 from orionis.console.enums.command import Command
 from orionis.console.exceptions import CLIOrionisValueError

orionis/console/entities/all_jobs_removed.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from orionis.console.entities.scheduler_event_data import SchedulerEventData
+
+@dataclass(kw_only=True)
+class AllJobsRemoved(SchedulerEventData):
+    """
+    Represents an event triggered when all jobs are removed from a specific job store.
+
+    This event is typically used to notify that a job store has been cleared of all its jobs.
+
+    Attributes
+    ----------
+    jobstore : str
+        The alias or identifier of the job store from which all jobs were removed.
+
+    Returns
+    -------
+    None
+        This class does not return a value; it is used to encapsulate event data.
+    """
+
+    # The alias of the job store from which jobs were removed
+    jobstore: str

orionis/console/entities/executor_added.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from orionis.console.entities.scheduler_event_data import SchedulerEventData
+
+@dataclass(kw_only=True)
+class ExecutorAdded(SchedulerEventData):
+    """
+    Represents an event triggered when an executor is added to the system.
+
+    This event is used to notify that a new executor has been successfully added.
+
+    Attributes
+    ----------
+    alias : str
+        The unique alias or identifier of the added executor.
+
+    Returns
+    -------
+    ExecutorAdded
+        An instance of the ExecutorAdded event containing the alias of the added executor.
+    """
+
+    # The alias of the added executor, used to uniquely identify it
+    alias: str

orionis/console/entities/executor_removed.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from orionis.console.entities.scheduler_event_data import SchedulerEventData
+
+@dataclass(kw_only=True)
+class ExecutorRemoved(SchedulerEventData):
+    """
+    Represents an event triggered when an executor is removed.
+
+    This event is used to notify the system that a specific executor, identified 
+    by its alias, has been removed from the scheduler.
+
+    Attributes
+    ----------
+    alias : str
+        The alias (unique identifier) of the removed executor.
+
+    Returns
+    -------
+    None
+        This class does not return a value; it is used as a data structure 
+        to encapsulate event information.
+    """
+
+    # The alias of the removed executor
+    alias: str

orionis/console/entities/job_added.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from orionis.console.entities.job_event_data import JobEventData
+
+@dataclass(kw_only=True)
+class JobAdded(JobEventData):
+    """
+    Represents an event triggered when a job is added to a job store.
+
+    This class extends the `JobEventData` base class, inheriting its attributes
+    and functionality. It is used to encapsulate data related to the addition
+    of a job in the system.
+
+    Attributes
+    ----------
+    Inherits all attributes from the `JobEventData` base class.
+
+    Returns
+    -------
+    JobAdded
+        An instance of the `JobAdded` class containing data about the added job.
+    """
+
+    # This class currently does not define additional attributes or methods.
+    # It serves as a specialized event type for job addition events.

orionis/console/entities/job_error.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from datetime import datetime
+from orionis.console.entities.job_event_data import JobEventData
+
+@dataclass(kw_only=True)
+class JobError(JobEventData):
+    """
+    Represents an event triggered when a job raises an exception during execution.
+
+    This class is used to encapsulate information about an error that occurred
+    during the execution of a scheduled job, including the time the job was
+    scheduled to run, the exception raised, and the traceback details.
+
+    Attributes
+    ----------
+    scheduled_run_time : datetime
+        The datetime when the job was scheduled to run.
+    exception : Exception
+        The exception instance raised by the job during execution.
+    traceback : str
+        The traceback string providing details about where the exception occurred.
+
+    Returns
+    -------
+    JobError
+        An instance of the `JobError` class containing details about the job error event.
+    """
+    # The time the job was scheduled to run
+    scheduled_run_time: datetime
+
+    # The exception raised during the job's execution
+    exception: Exception
+
+    # The traceback string providing details about the exception
+    traceback: str

orionis/console/entities/job_event_data.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Optional
+from orionis.console.entities.scheduler_event_data import SchedulerEventData
+
+@dataclass(kw_only=True)
+class JobEventData(SchedulerEventData):
+    """
+    Represents the base class for events related to jobs in the scheduler system.
+
+    This class extends `SchedulerEventData` and provides additional attributes
+    specific to job-related events, such as the job's identifier and the job store
+    where it resides.
+
+    Attributes
+    ----------
+    code : int
+        A numeric code that uniquely identifies the type of event within the
+        scheduler system. (Inherited from `SchedulerEventData`)
+    alias : str, optional
+        An optional string providing additional context or identifying specific
+        components (e.g., executors or job stores) related to the event.
+        (Inherited from `SchedulerEventData`)
+    job_id : str
+        The unique identifier of the job associated with the event.
+    jobstore : str, optional
+        The name of the job store where the job is located. If not specified,
+        it defaults to `None`.
+
+    Returns
+    -------
+    JobEventData
+        An instance of the `JobEventData` class containing information about
+        the job-related event.
+    """
+
+    # The unique identifier of the job
+    job_id: str
+
+    # The name of the job store where the job resides (optional)
+    jobstore: Optional[str] = None