orionis 0.532.0__tar.gz → 0.533.0__tar.gz

{orionis-0.532.0/orionis.egg-info → orionis-0.533.0}/PKG-INFO

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

orionis-0.533.0/orionis/console/commands/make_listener.py

@@ -0,0 +1,57 @@
+from orionis.console.base.command import BaseCommand
+from orionis.console.contracts.reactor import IReactor
+from orionis.console.exceptions import CLIOrionisRuntimeError
+from rich.console import Console
+from rich.panel import Panel
+
+class MakeListenerCommand(BaseCommand):
+    """
+    Este comando se encarga de crear los listener tando para CLI como para otro tipo de Eventos.
+    """
+
+    # Indicates whether timestamps will be shown in the command output
+    timestamps: bool = False
+
+    # Command signature and description
+    signature: str = "make:listener"
+
+    # Command description
+    description: str = "Displays usage information, examples, and a list of available commands in the Orionis CLI."
+
+    def handle(self) -> dict:
+        """
+        Displays usage information and a list of available commands for the Orionis CLI.
+
+        Parameters
+        ----------
+        reactor : IReactor
+            The reactor instance providing command metadata via the `info()` method.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the list of available commands, each with its signature and description.
+
+        Raises
+        ------
+        CLIOrionisRuntimeError
+            If an unexpected error occurs during help information generation or display.
+        """
+        try:
+
+            # Solicitar el nombre del listener al usuario
+            ans = self.choice(
+                question="Tipo de Listener",
+                choices=[
+                    "Listener para eventos CLI",
+                    "Listener para eventos de Schedule",
+                ],
+                default_index=0
+            )
+
+            print(ans)
+
+        except Exception as e:
+
+            # Raise a custom runtime error if any exception occurs
+            raise CLIOrionisRuntimeError(f"An unexpected error occurred: {e}") from e

{orionis-0.532.0 → orionis-0.533.0}/orionis/console/core/reactor.py

@@ -114,6 +114,7 @@ class Reactor(IReactor):
         from orionis.console.commands.cache import CacheClearCommand
         from orionis.console.commands.scheduler_work import ScheduleWorkCommand
         from orionis.console.commands.scheduler_list import ScheduleListCommand
+        from orionis.console.commands.make_listener import MakeListenerCommand
 
         # List of core command classes to load (extend this list as more core commands are added)
         core_commands = [
@@ -124,7 +125,8 @@ class Reactor(IReactor):
             WorkFlowGithubCommand,
             CacheClearCommand,
             ScheduleWorkCommand,
-            ScheduleListCommand
+            ScheduleListCommand,
+            MakeListenerCommand
         ]
 
         # Iterate through the core command classes and register them

{orionis-0.532.0 → orionis-0.533.0}/orionis/failure/base/handler.py

@@ -8,12 +8,12 @@ from orionis.services.log.contracts.log_service import ILogger
 class BaseExceptionHandler(IBaseExceptionHandler):
 
     # Exceptions that should not be caught by the handler
-    dont_cathc: List[type[BaseException]] = [
+    dont_catch: List[type[BaseException]] = [
         # Add specific exceptions that should not be caught
         # Example: OrionisContainerException
     ]
 
-    def destructureException(self, e: BaseException) -> Throwable:
+    async def destructureException(self, e: BaseException) -> Throwable:
         """
         Converts an exception into a structured `Throwable` object containing detailed information.
 
@@ -41,7 +41,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             traceback=getattr(e, '__traceback__', None)     # The traceback object, if available
         )
 
-    def shouldIgnoreException(self, e: BaseException) -> bool:
+    async def shouldIgnoreException(self, e: BaseException) -> bool:
         """
         Determines if the exception should be ignored (not handled) by the handler.
 
@@ -61,12 +61,12 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             raise TypeError(f"Expected BaseException, got {type(e).__name__}")
 
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(e)
+        throwable = await self.destructureException(e)
 
         # Check if the exception type is in the list of exceptions to ignore
-        return hasattr(self, 'dont_cathc') and throwable.classtype in self.dont_cathc
+        return hasattr(self, 'dont_catch') and throwable.classtype in self.dont_catch
 
-    def report(self, exception: BaseException, log: ILogger) -> Any:
+    async def report(self, exception: BaseException, log: ILogger) -> Any:
         """
         Report or log an exception.
 
@@ -84,7 +84,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             raise TypeError(f"Expected BaseException, got {type(exception).__name__}")
 
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(exception)
+        throwable = await self.destructureException(exception)
 
         # Log the exception details
         log.error(f"[{throwable.classtype.__name__}] {throwable.message}")
@@ -92,7 +92,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         # Return the structured exception
         return throwable
 
-    def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
+    async def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
         """
         Render the exception message for CLI output.
 
@@ -109,11 +109,15 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         if not isinstance(exception, BaseException):
             raise TypeError(f"Expected BaseException, got {type(exception).__name__}")
 
+        # Ensure the request is a CLIRequest
+        if not isinstance(request, CLIRequest):
+            raise TypeError(f"Expected CLIRequest, got {type(request).__name__}")
+
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(exception)
+        throwable = await self.destructureException(exception)
 
-        args = request.args if isinstance(request, CLIRequest) and request.args else []
-        string_args = ' '.join(args)
+        # Convert the request arguments to a string for logging
+        string_args = ' '.join(request.args)
 
         # Log the CLI error message with arguments
         log.error(f"CLI Error: {throwable.message} (Args: {string_args})")

orionis-0.533.0/orionis/failure/catch.py

@@ -0,0 +1,162 @@
+from typing import Any
+from orionis.console.kernel import KernelCLI
+from orionis.console.output.contracts.console import IConsole
+from orionis.failure.contracts.catch import ICatch
+from orionis.failure.contracts.handler import IBaseExceptionHandler
+from orionis.foundation.contracts.application import IApplication
+from orionis.services.log.contracts.log_service import ILogger
+import asyncio
+
+class Catch(ICatch):
+
+
+    def __init__(self, app: IApplication) -> None:
+        """
+        Initializes the Catch handler with application services for console output and logging.
+
+        Parameters
+        ----------
+        app : IApplication
+            The application instance used to resolve required services.
+
+        Attributes
+        ----------
+        console : IConsole
+            Console output service obtained from the application for displaying messages and exceptions.
+        logger : ILogger
+            Logger service obtained from the application for logging errors and exceptions.
+
+        Returns
+        -------
+        None
+            This constructor does not return any value.
+
+        Notes
+        -----
+        The constructor retrieves the console and logger services from the application container
+        using their respective service keys. These services are used throughout the class for
+        error reporting and output.
+        """
+
+        # Retrieve the console output service from the application container
+        self.__console: IConsole = app.make('x-orionis.console.output.console')
+
+        # Retrieve the logger service from the application container
+        self.__logger: ILogger = app.make('x-orionis.services.log.log_service')
+
+        # Retrieve the console output service from the application container
+        self.__exception_handler: IBaseExceptionHandler = app.getExceptionHandler()
+
+    def exception(self, kernel: Any, request: Any, e: BaseException) -> None:
+        """
+        Handles and reports exceptions that occur during CLI execution.
+
+        This method reports the provided exception using the application's exception handler and logger.
+        If a kernel instance is provided, it also renders the exception details to the CLI for user visibility.
+
+        Parameters
+        ----------
+        kernel : Any
+            The kernel instance associated with the CLI, or None if not available.
+        request : Any
+            The request or arguments associated with the CLI command.
+        e : BaseException
+            The exception instance to be handled.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs side effects such as logging and output.
+
+        Notes
+        -----
+        The exception is always reported using the exception handler and logger.
+        If a valid kernel is provided, the exception details are rendered to the CLI.
+        """
+
+        async def handle():
+            """
+            Handles exceptions asynchronously using the provided exception handler.
+
+            This method performs the following steps:
+            1. Determines if the exception should be ignored by invoking the `shouldIgnoreException` method
+               of the exception handler. This method supports both coroutine and regular functions.
+            2. Reports the exception using the `report` method of the exception handler. This method
+               also supports both coroutine and regular functions.
+            3. If the kernel is of type `KernelCLI` or `Any`, it attempts to render the exception
+               for the CLI using the `renderCLI` method of the exception handler. This method supports
+               both coroutine and regular functions.
+
+            Parameters
+            ----------
+            None
+
+            Returns
+            -------
+            Any or None
+            The result of the `renderCLI` method if applicable, otherwise `None`.
+
+            Notes
+            -----
+            - The `self.__exception_handler` is expected to have the methods `shouldIgnoreException`,
+              `report`, and `renderCLI`.
+            - The `self.__logger` is passed to the `report` and `renderCLI` methods for logging purposes.
+            - The `self.__console` is passed to the `renderCLI` method for CLI rendering.
+            """
+
+            # Check if the `shouldIgnoreException` method is a coroutine function
+            if asyncio.iscoroutinefunction(self.__exception_handler.shouldIgnoreException):
+
+                # If it is, await its result to determine if the exception should be ignored
+                if await self.__exception_handler.shouldIgnoreException(e):
+                    return
+
+            else:
+
+                # If it is not a coroutine, call it directly
+                if self.__exception_handler.shouldIgnoreException(e):
+                    return
+
+            # Check if the `report` method is a coroutine function
+            if asyncio.iscoroutinefunction(self.__exception_handler.report):
+
+                # If it is, await its execution to report the exception
+                await self.__exception_handler.report(
+                    exception=e,
+                    log=self.__logger
+                )
+
+            else:
+
+                # If it is not a coroutine, call it directly
+                self.__exception_handler.report(
+                    exception=e,
+                    log=self.__logger
+                )
+
+            # Check if the kernel is of type `KernelCLI` or `Any`
+            if isinstance(kernel, KernelCLI) or isinstance(kernel, Any):
+
+                # Check if the `renderCLI` method is a coroutine function
+                if asyncio.iscoroutinefunction(self.__exception_handler.renderCLI):
+
+                    # If it is, await its execution to render the exception for the CLI
+                    return await self.__exception_handler.renderCLI(
+                        request=request,
+                        exception=e,
+                        log=self.__logger,
+                        console=self.__console
+                    )
+
+                else:
+
+                    # If it is not a coroutine, call it directly
+                    return self.__exception_handler.renderCLI(
+                        request=request,
+                        exception=e,
+                        log=self.__logger,
+                        console=self.__console
+                    )
+
+        # Run the handler
+        asyncio.run(handle())

{orionis-0.532.0 → orionis-0.533.0}/orionis/failure/contracts/handler.py

@@ -7,7 +7,7 @@ from orionis.services.log.contracts.log_service import ILogger
 class IBaseExceptionHandler:
 
     @abstractmethod
-    def destructureException(self, e: BaseException):
+    async def destructureException(self, e: BaseException):
         """
         Converts an exception into a structured `Throwable` object containing detailed information.
 
@@ -29,7 +29,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def shouldIgnoreException(self, e: BaseException) -> bool:
+    async def shouldIgnoreException(self, e: BaseException) -> bool:
         """
         Determines if the exception should be ignored (not handled) by the handler.
 
@@ -46,7 +46,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def report (self, exception: BaseException, log: ILogger) -> Any:
+    async def report (self, exception: BaseException, log: ILogger) -> Any:
         """
         Report or log an exception.
 
@@ -62,7 +62,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
+    async def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
         """
         Render the exception message for CLI output.
 

{orionis-0.532.0 → orionis-0.533.0}/orionis/metadata/framework.py

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

{orionis-0.532.0 → orionis-0.533.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.532.0 → orionis-0.533.0}/orionis.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ orionis/console/base/scheduler_event_listener.py
 orionis/console/commands/__init__.py
 orionis/console/commands/cache.py
 orionis/console/commands/help.py
+orionis/console/commands/make_listener.py
 orionis/console/commands/publisher.py
 orionis/console/commands/scheduler_list.py
 orionis/console/commands/scheduler_work.py

orionis-0.532.0/orionis/failure/catch.py

@@ -1,94 +0,0 @@
-from typing import Any
-from orionis.console.kernel import KernelCLI
-from orionis.console.output.contracts.console import IConsole
-from orionis.console.tasks.schedule import Schedule
-from orionis.failure.contracts.catch import ICatch
-from orionis.failure.contracts.handler import IBaseExceptionHandler
-from orionis.foundation.contracts.application import IApplication
-from orionis.services.log.contracts.log_service import ILogger
-
-class Catch(ICatch):
-
-
-    def __init__(self, app: IApplication) -> None:
-        """
-        Initializes the Catch handler with application services for console output and logging.
-
-        Parameters
-        ----------
-        app : IApplication
-            The application instance used to resolve required services.
-
-        Attributes
-        ----------
-        console : IConsole
-            Console output service obtained from the application for displaying messages and exceptions.
-        logger : ILogger
-            Logger service obtained from the application for logging errors and exceptions.
-
-        Returns
-        -------
-        None
-            This constructor does not return any value.
-
-        Notes
-        -----
-        The constructor retrieves the console and logger services from the application container
-        using their respective service keys. These services are used throughout the class for
-        error reporting and output.
-        """
-
-        # Retrieve the console output service from the application container
-        self.__console: IConsole = app.make('x-orionis.console.output.console')
-
-        # Retrieve the logger service from the application container
-        self.__logger: ILogger = app.make('x-orionis.services.log.log_service')
-
-        # Retrieve the console output service from the application container
-        self.__exception_handler: IBaseExceptionHandler = app.getExceptionHandler()
-
-    def exception(self, kernel: Any, request: Any, e: BaseException) -> None:
-        """
-        Handles and reports exceptions that occur during CLI execution.
-
-        This method reports the provided exception using the application's exception handler and logger.
-        If a kernel instance is provided, it also renders the exception details to the CLI for user visibility.
-
-        Parameters
-        ----------
-        kernel : Any
-            The kernel instance associated with the CLI, or None if not available.
-        request : Any
-            The request or arguments associated with the CLI command.
-        e : BaseException
-            The exception instance to be handled.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs side effects such as logging and output.
-
-        Notes
-        -----
-        The exception is always reported using the exception handler and logger.
-        If a valid kernel is provided, the exception details are rendered to the CLI.
-        """
-
-        # Check if the exception should be ignored by the handler
-        if self.__exception_handler.shouldIgnoreException(e):
-            return
-
-        # Report the exception using the application's exception handler and logger
-        self.__exception_handler.report(
-            exception=e,
-            log=self.__logger
-        )
-
-        # If a kernel is provided, render the exception details to the CLI
-        if isinstance(kernel, KernelCLI) or isinstance(kernel, Schedule):
-            return self.__exception_handler.renderCLI(
-                request=request,
-                exception=e,
-                log=self.__logger,
-                console=self.__console
-            )