orionis 0.479.0__tar.gz → 0.481.0__tar.gz

{orionis-0.479.0/orionis.egg-info → orionis-0.481.0}/PKG-INFO

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

orionis-0.481.0/orionis/console/commands/scheduler_work.py

@@ -0,0 +1,88 @@
+import importlib
+import os
+from pathlib import Path
+from orionis.console.base.command import BaseCommand
+from orionis.console.contracts.schedule import ISchedule
+from orionis.console.exceptions import CLIOrionisRuntimeError
+from orionis.foundation.contracts.application import IApplication
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from datetime import datetime
+
+class ScheduleWorkCommand(BaseCommand):
+    """
+    Command class to display usage information for the Orionis CLI.
+    """
+
+    # Indicates whether timestamps will be shown in the command output
+    timestamps: bool = False
+
+    # Command signature and description
+    signature: str = "schedule:work"
+
+    # Command description
+    description: str = "Executes the scheduled tasks defined in the application."
+
+    async def handle(self, orionis: IApplication, console: Console) -> bool:
+
+        try:
+
+            # Obtener la ruta absoluta del scheduler desde la configuración de la aplicación
+            scheduler_path = orionis.path('console_scheduler')
+
+            # Obtener la base path desde la variable de entorno o desde la configuración local
+            base_path = Path(os.getcwd()).resolve()
+            scheduler_path = Path(scheduler_path).resolve()
+            rel_path = scheduler_path.relative_to(base_path)
+
+            # Reemplazar los separadores por puntos y quitar la extensión .py
+            module_name = ".".join(rel_path.with_suffix('').parts)
+
+            # Importar el módulo del scheduler
+            scheduler_module = importlib.import_module(module_name)
+
+            # Obtener la clase Scheduler del módulo importado
+            Scheduler = getattr(scheduler_module, "Scheduler", None)
+
+            # Check if the Scheduler class was found
+            if Scheduler is None:
+                raise CLIOrionisRuntimeError(f"Scheduler class not found in module {module_name}")
+
+            # Obtener el método tasks de la clase Scheduler
+            task_method = getattr(Scheduler, "tasks", None)
+
+            # Check if the method exists
+            if task_method is None:
+                raise CLIOrionisRuntimeError(f"Method 'tasks' not found in Scheduler class in module {module_name}")
+
+            # Crear una instancia de ISchedule
+            schedule_serice: ISchedule = orionis.make(ISchedule)
+
+            # Inicializar el metodo
+            task_method(schedule_serice)
+
+            # Display a professional start message for the scheduler worker
+            console.line()
+            start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            panel_content = Text.assemble(
+                (" Orionis Scheduler Worker ", "bold white on green"),
+                ("\n\n", ""),
+                ("The scheduled tasks worker has started successfully.\n", "white"),
+                (f"Started at: {start_time}\n", "dim"),
+                ("To stop the worker, press ", "white"),
+                ("Ctrl+C", "bold yellow"),
+                (".", "white")
+            )
+            console.print(
+                Panel(panel_content, border_style="green", padding=(1, 2))
+            )
+            console.line()
+
+            # Iniciar el scheduler
+            await schedule_serice.start()
+
+        except Exception as exc:
+
+            # Catch any unexpected exceptions and raise as a CLIOrionisRuntimeError
+            raise CLIOrionisRuntimeError(f"An unexpected error occurred while clearing the cache: {exc}")

{orionis-0.479.0 → orionis-0.481.0}/orionis/console/commands/test.py

@@ -1,6 +1,7 @@
 from orionis.app import Orionis
 from orionis.console.base.command import BaseCommand
 from orionis.console.exceptions import CLIOrionisRuntimeError
+from orionis.foundation.contracts.application import IApplication
 from orionis.test.contracts.kernel import ITestKernel
 
 class TestCommand(BaseCommand):
@@ -26,28 +27,34 @@ class TestCommand(BaseCommand):
     # Command description
     description: str = "Executes all automated tests using the configured test kernel for the Orionis application."
 
-    def handle(self) -> dict:
+    def handle(self, app: IApplication) -> dict:
         """
-        Executes the test command for the Orionis CLI.
+        Executes all automated tests using the configured test kernel.
 
-        This method initializes the Orionis application, retrieves the test kernel instance,
-        and runs the test suite using the kernel's handle method. If any exception occurs during
-        execution, it raises a CLIOrionisRuntimeError with the error details.
+        This method retrieves the test kernel instance from the application container
+        and executes the test suite by invoking the kernel's handle method. If any
+        exception occurs during execution, it raises a CLIOrionisRuntimeError with
+        the error details.
+
+        Parameters
+        ----------
+        app : IApplication
+            The Orionis application instance providing access to the service container.
 
         Returns
         -------
         dict
-            The result of the test execution, typically containing test results or status.
+            A dictionary containing the results of the test execution, such as test
+            statuses, counts, or other relevant information.
 
         Raises
         ------
         CLIOrionisRuntimeError
             If an unexpected error occurs during the execution of the test command.
         """
-        try:
 
-            # Initialize the Orionis application instance
-            app = Orionis()
+        # Attempt to execute the test suite using the test kernel
+        try:
 
             # Retrieve the test kernel instance from the application container
             kernel: ITestKernel = app.make(ITestKernel)

{orionis-0.479.0 → orionis-0.481.0}/orionis/console/core/reactor.py

@@ -21,7 +21,7 @@ class Reactor(IReactor):
 
     def __init__(
         self,
-        app: Optional[IApplication] = None
+        app: IApplication
     ):
         """
         Initializes a new Reactor instance for command discovery and management.
@@ -56,7 +56,7 @@ class Reactor(IReactor):
         """
 
         # Initialize the application instance, using provided app or creating new Orionis instance
-        self.__app = app or Orionis()
+        self.__app = app
 
         # Set the project root directory to current working directory for module path resolution
         self.__root: str = str(Path.cwd())
@@ -111,6 +111,7 @@ class Reactor(IReactor):
         from orionis.console.commands.publisher import PublisherCommand
         from orionis.console.commands.workflow import WorkFlowGithubCommand
         from orionis.console.commands.cache import CacheClearCommand
+        from orionis.console.commands.scheduler_work import ScheduleWorkCommand
 
         # List of core command classes to load (extend this list as more core commands are added)
         core_commands = [
@@ -119,7 +120,8 @@ class Reactor(IReactor):
             TestCommand,
             PublisherCommand,
             WorkFlowGithubCommand,
-            CacheClearCommand
+            CacheClearCommand,
+            ScheduleWorkCommand
         ]
 
         # Iterate through the core command classes and register them

{orionis-0.479.0 → orionis-0.481.0}/orionis/console/kernel.py

@@ -38,7 +38,7 @@ class KernelCLI(IKernelCLI):
 
         # Retrieve and initialize the reactor instance from the application container.
         # The reactor is responsible for dispatching CLI commands.
-        self.__reactor: IReactor = app.make('x-orionis.console.core.reactor', app)
+        self.__reactor: IReactor = app.make('x-orionis.console.core.reactor')
 
         # Retrieve and initialize the console instance for command output and error handling.
         self.__console: IConsole = app.make('x-orionis.console.output.console')

orionis-0.481.0/orionis/console/tasks/exception_report.py

@@ -0,0 +1,94 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.traceback import Traceback
+
+class ScheduleErrorReporter:
+    """Handles and displays errors and warnings with rich formatting using the Rich library.
+
+    This class provides methods to output formatted error and warning messages to the console,
+    enhancing readability and debugging using the Rich library's features.
+
+    Attributes
+    ----------
+    console : Console
+        Rich Console object used for rendering formatted output to the terminal.
+    """
+
+    def __init__(self):
+        """
+        Initialize the ErrorReporter instance.
+
+        This constructor creates a new Console object from the Rich library and assigns it to the 'console' attribute,
+        which is used for rendering formatted output to the terminal.
+
+        Returns
+        -------
+        None
+            This constructor does not return any value.
+        """
+        self.console = Console()
+
+    def reportException(self, job_id: str, exception: Exception, traceback: str = None):
+        """
+        Display a formatted error message for an exception that occurred during a job execution.
+
+        This method prints a visually enhanced error panel to the console, including the job identifier and the exception message.
+        If a traceback string is provided, it is rendered below the error panel for detailed debugging information.
+
+        Parameters
+        ----------
+        job_id : str
+            The identifier of the job where the exception occurred.
+        exception : Exception
+            The exception instance that was raised.
+        traceback : str, optional
+            The string representation of the traceback. If provided, it will be displayed after the error message.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It outputs formatted error information to the console.
+        """
+        title = f"[bold red]Job Execution Error[/bold red]"
+        message = Text.assemble(
+            ("An exception occurred during the execution of job ", "white"),
+            (f"'{job_id}'", "bold cyan"),
+            (":\n", "white"),
+            (f"{type(exception).__name__}: {exception}", "red")
+        )
+
+        self.console.print(Panel(message, title=title, border_style="red", padding=(1, 2)))
+        if traceback:
+            tb = Traceback.from_string(traceback)
+            self.console.print(tb)
+        self.console.line()
+
+
+    def reportMissed(self, job_id: str, scheduled_time):
+        """
+        Display a formatted warning message for a missed job execution.
+
+        This method prints a warning panel to the console, indicating that a scheduled job was missed and showing its scheduled time.
+
+        Parameters
+        ----------
+        job_id : str
+            The identifier of the missed job.
+        scheduled_time : Any
+            The time the job was scheduled to run.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It outputs a warning message to the console.
+        """
+        title = f"[bold yellow]Missed Scheduled Job[/bold yellow]"
+        msg = Text.assemble(
+            ("The scheduled job ", "white"),
+            (f"'{job_id}'", "bold cyan"),
+            (" was not executed as planned.\nScheduled time: ", "white"),
+            (f"{scheduled_time}", "bold green")
+        )
+        self.console.print(Panel(msg, title=title, border_style="yellow", padding=(1, 2)))
+        self.console.line()

{orionis-0.479.0 → orionis-0.481.0}/orionis/console/tasks/schedule.py

@@ -2,19 +2,25 @@ import asyncio
 import logging
 from typing import Dict, List, Optional
 import pytz
+from apscheduler.events import EVENT_JOB_MISSED, EVENT_JOB_ERROR
 from apscheduler.schedulers.asyncio import AsyncIOScheduler as APSAsyncIOScheduler
-from orionis.app import Orionis
 from orionis.console.contracts.reactor import IReactor
 from orionis.console.contracts.schedule import ISchedule
 from orionis.console.exceptions import CLIOrionisRuntimeError
+from orionis.console.output.contracts.console import IConsole
 from orionis.console.tasks.event import Event
+from orionis.console.tasks.exception_report import ScheduleErrorReporter
+from orionis.foundation.contracts.application import IApplication
 from orionis.services.log.contracts.log_service import ILogger
 
 class Scheduler(ISchedule):
 
     def __init__(
         self,
-        reactor: IReactor
+        reactor: IReactor,
+        app: IApplication,
+        console: IConsole,
+        error_reporter: ScheduleErrorReporter
     ) -> None:
         """
         Initialize a new instance of the Scheduler class.
@@ -37,7 +43,13 @@ class Scheduler(ISchedule):
         """
 
         # Store the application instance for configuration access.
-        self.__app = Orionis()
+        self.__app = app
+
+        # Store the console instance for output operations.
+        self.__console = console
+
+        # Store the error reporter instance for handling exceptions.
+        self.__error_reporter = error_reporter
 
         # Initialize AsyncIOScheduler instance with timezone configuration.
         self.__scheduler: APSAsyncIOScheduler = APSAsyncIOScheduler(
@@ -46,8 +58,11 @@ class Scheduler(ISchedule):
 
         # Clear the APScheduler logger to prevent conflicts with other loggers.
         # This is necessary to avoid duplicate log messages or conflicts with other logging configurations.
-        logging.getLogger("apscheduler").handlers.clear()
-        logging.getLogger("apscheduler").propagate = False
+        for name in ["apscheduler", "apscheduler.scheduler", "apscheduler.executors.default"]:
+            logger = logging.getLogger(name)
+            logger.handlers.clear()
+            logger.propagate = False
+            logger.disabled = True
 
         # Initialize the logger from the application instance.
         self.__logger: ILogger = self.__app.make('x-orionis.services.log.log_service')
@@ -64,9 +79,52 @@ class Scheduler(ISchedule):
         # Initialize the jobs list to keep track of all scheduled jobs.
         self.__jobs: List[dict] = []
 
+        # Add a listener to the scheduler to capture job events such as missed jobs or errors.
+        self.__scheduler.add_listener(self.__listener, EVENT_JOB_MISSED | EVENT_JOB_ERROR)
+
         # Log the initialization of the Scheduler.
         self.__logger.info("Orionis scheduler initialized.")
 
+    def __listener(self, event):
+        """
+        Handle job events by logging errors and missed jobs.
+
+        This method acts as a listener for job events emitted by the scheduler. It processes
+        two main types of events: job execution errors and missed job executions. When a job
+        raises an exception during execution, the method logs the error and delegates reporting
+        to the error reporter. If a job is missed (i.e., not executed at its scheduled time),
+        the method logs a warning and notifies the error reporter accordingly.
+
+        Parameters
+        ----------
+        event : apscheduler.events.JobEvent
+            The job event object containing information about the job execution, such as
+            job_id, exception, traceback, code, and scheduled_run_time.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs logging and error reporting
+            based on the event type.
+        """
+
+        # If the event contains an exception, log the error and report it
+        if event.exception:
+            self.__logger.error(f"Job {event.job_id} raised an exception: {event.exception}")
+            self.__error_reporter.reportException(
+                job_id=event.job_id,
+                exception=event.exception,
+                traceback=event.traceback
+            )
+
+        # If the event indicates a missed job, log a warning and report it
+        elif event.code == EVENT_JOB_MISSED:
+            self.__logger.warning(f"Job {event.job_id} was missed, scheduled for {event.scheduled_run_time}")
+            self.__error_reporter.reportMissed(
+                job_id=event.job_id,
+                scheduled_time=event.scheduled_run_time
+            )
+
     def __getCommands(
         self
     ) -> dict:
@@ -285,14 +343,10 @@ class Scheduler(ISchedule):
 
             # Keep the event loop alive to process scheduled jobs
             try:
-
-                # Wait for the scheduler to start and keep it running
-                while True:
+                while self.__scheduler.running and self.__scheduler.get_jobs():
                     await asyncio.sleep(1)
-
-            except KeyboardInterrupt:
-
-                # Handle graceful shutdown on keyboard interrupt
+            except (KeyboardInterrupt, asyncio.CancelledError):
+                # Handle graceful shutdown on keyboard interrupt or cancellation
                 await self.shutdown()
 
         except Exception as e:

{orionis-0.479.0 → orionis-0.481.0}/orionis/container/container.py

@@ -511,35 +511,46 @@ class Container(IContainer):
         registered in the container under both the abstract and the alias.
         """
 
-        # Ensure that the abstract is an abstract class
-        IsAbstractClass(abstract, f"Instance {Lifetime.SINGLETON}")
+        # Validate the enforce_decoupling parameter
+        if isinstance(enforce_decoupling, bool):
 
-        # Ensure that the instance is a valid instance
-        IsInstance(instance)
+            # Ensure that the abstract is an abstract class
+            IsAbstractClass(abstract, f"Instance {Lifetime.SINGLETON}")
 
-        # Ensure that instance is NOT a subclass of abstract
-        if enforce_decoupling:
-            IsNotSubclass(abstract, instance.__class__)
+            # Ensure that the instance is a valid instance
+            IsInstance(instance)
 
-        # Validate that instance is a subclass of abstract
-        else:
-            IsSubclass(abstract, instance.__class__)
+            # Ensure that instance is NOT a subclass of abstract
+            if enforce_decoupling:
+                IsNotSubclass(abstract, instance.__class__)
 
-        # Ensure implementation
-        ImplementsAbstractMethods(
-            abstract=abstract,
-            instance=instance
-        )
+            # Validate that instance is a subclass of abstract
+            else:
+                IsSubclass(abstract, instance.__class__)
+
+            # Ensure implementation
+            ImplementsAbstractMethods(
+                abstract=abstract,
+                instance=instance
+            )
+
+            # Ensure that the alias is a valid string if provided
+            if alias:
+                IsValidAlias(alias)
+            else:
+                rf_asbtract = ReflectionAbstract(abstract)
+                alias = rf_asbtract.getModuleWithClassName()
+
+            # If the service is already registered, drop it
+            self.drop(abstract, alias)
 
-        # Ensure that the alias is a valid string if provided
-        if alias:
-            IsValidAlias(alias)
         else:
-            rf_asbtract = ReflectionAbstract(abstract)
-            alias = rf_asbtract.getModuleWithClassName()
 
-        # If the service is already registered, drop it
-        self.drop(abstract, alias)
+            # Drop the existing alias if it exists
+            self.drop(alias=alias)
+
+            # If enforce_decoupling is not a boolean, set it to False
+            enforce_decoupling = False
 
         # Register the instance with the abstract type
         self.__bindings[abstract] = Binding(

{orionis-0.479.0 → orionis-0.481.0}/orionis/container/facades/facade.py

@@ -1,6 +1,7 @@
 from typing import Any
+from orionis.app import Orionis
 from orionis.container.exceptions import OrionisContainerAttributeError, OrionisContainerException
-from orionis.foundation.application import Application, IApplication
+from orionis.foundation.application import IApplication
 from typing import TypeVar, Any
 
 T = TypeVar('T')
@@ -34,7 +35,7 @@ class FacadeMeta(type):
 class Facade(metaclass=FacadeMeta):
 
     # Application instance to resolve services
-    _app: IApplication = Application()
+    _app: IApplication = Orionis()
 
     @classmethod
     def getFacadeAccessor(cls) -> str:

{orionis-0.479.0 → orionis-0.481.0}/orionis/foundation/application.py

@@ -150,8 +150,8 @@ class Application(Container, IApplication):
         }
 
         # Register each kernel instance
-        for kernel_name, kernel_cls in core_kernels.items():
-            self.instance(kernel_name, kernel_cls(self))
+        for abstract, concrete in core_kernels.items():
+            self.instance(abstract, concrete(self))
 
     def __loadFrameworkProviders(
         self
@@ -181,6 +181,7 @@ class Application(Container, IApplication):
         from orionis.foundation.providers.executor_provider import ConsoleExecuteProvider
         from orionis.foundation.providers.reactor_provider import ReactorProvider
         from orionis.foundation.providers.performance_counter_provider import PerformanceCounterProvider
+        from orionis.foundation.providers.scheduler_provider import ScheduleProvider
 
         # Core framework providers
         core_providers = [
@@ -193,7 +194,8 @@ class Application(Container, IApplication):
             InspirationalProvider,
             ConsoleExecuteProvider,
             ReactorProvider,
-            PerformanceCounterProvider
+            PerformanceCounterProvider,
+            ScheduleProvider
         ]
 
         # Register each core provider
@@ -1812,7 +1814,7 @@ class Application(Container, IApplication):
         self,
         key: str = None,
         default: Any = None
-    ) -> Any:
+    ) -> str:
         """
         Retrieve application path configuration values using dot notation.
 
@@ -1832,7 +1834,7 @@ class Application(Container, IApplication):
 
         Returns
         -------
-        Any
+        str
             The path configuration value corresponding to the given key, the entire
             paths dictionary if key is None, or the default value if the key is
             not found.
@@ -1923,6 +1925,9 @@ class Application(Container, IApplication):
         # Check if already booted
         if not self.__booted:
 
+            # Register the application instance in the container
+            self.instance(IApplication, self, alias="x-orionis.foundation.application", enforce_decoupling='X-ORIONIS')
+
             # Load configuration if not already set
             self.__loadConfig()
 

{orionis-0.479.0 → orionis-0.481.0}/orionis/foundation/config/roots/paths.py

@@ -254,7 +254,6 @@ class Paths(BaseEntity):
         }
     )
 
-
     def __post_init__(self) -> None:
         super().__post_init__()
         """

{orionis-0.479.0 → orionis-0.481.0}/orionis/foundation/contracts/application.py

@@ -705,7 +705,7 @@ class IApplication(IContainer):
         pass
 
     @abstractmethod
-    def path(self, key: str = None, default: Any = None) -> Any:
+    def path(self, key: str = None, default: Any = None) -> str:
         """
         Retrieve path configuration values using dot notation access.
 
@@ -723,7 +723,7 @@ class IApplication(IContainer):
 
         Returns
         -------
-        Any
+        str
             The path value associated with the key, the entire paths configuration
             object if no key is provided, or the default value if the key is not found.
         """

orionis-0.481.0/orionis/foundation/providers/scheduler_provider.py

@@ -0,0 +1,51 @@
+from orionis.console.contracts.schedule import ISchedule
+from orionis.console.tasks.schedule import Scheduler
+from orionis.container.providers.service_provider import ServiceProvider
+
+class ScheduleProvider(ServiceProvider):
+    """
+    Service provider responsible for registering and bootstrapping the application's scheduling system.
+
+    The ScheduleProvider binds the ISchedule interface to the Scheduler implementation as a singleton
+    within the application's service container. It also provides an alias for convenient access.
+    Override the `boot` method to configure and register scheduled tasks or jobs required by the application.
+
+    Methods
+    -------
+    register() :
+        Registers the Scheduler as a singleton service and binds it to the ISchedule interface.
+    boot() :
+        Initializes and configures scheduled tasks; intended to be overridden for custom jobs.
+    """
+
+    def register(self) -> None:
+        """
+        Register the Scheduler as a singleton service in the application container.
+
+        This method binds the ISchedule interface to the Scheduler implementation,
+        making it available as a singleton throughout the application's lifecycle.
+        An alias "x-orionis.console.contracts.schedule" is also provided for
+        convenient access.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        # Bind Scheduler as a singleton to the ISchedule interface with an alias
+        self.app.singleton(ISchedule, Scheduler, alias="x-orionis.console.contracts.schedule")
+
+    def boot(self) -> None:
+        """
+        Initialize and configure any scheduled tasks or jobs required by the application.
+
+        This method is called automatically during the application's bootstrapping process.
+        Override this method to register custom scheduled tasks.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        # No scheduled tasks are registered by default; override to add custom jobs
+        pass

{orionis-0.479.0 → orionis-0.481.0}/orionis/metadata/framework.py

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