orionis 0.543.0__tar.gz → 0.544.0__tar.gz

{orionis-0.543.0/orionis.egg-info → orionis-0.544.0}/PKG-INFO

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

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/args/argument.py

@@ -1,7 +1,7 @@
 import argparse
 from dataclasses import dataclass, field
 from typing import Any, Optional, List, Type, Union, Dict
-from orionis.console.args.enums.actions import ArgumentAction
+from orionis.console.enums.actions import ArgumentAction
 from orionis.console.exceptions.cli_orionis_value_error import CLIOrionisValueError
 
 @dataclass(kw_only=True, frozen=True, slots=True)

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/commands/help.py

@@ -18,7 +18,7 @@ class HelpCommand(BaseCommand):
     # Command description
     description: str = "Displays usage information, examples, and a list of available commands in the Orionis CLI."
 
-    def handle(self, reactor: IReactor) -> dict:
+    def handle(self, reactor: IReactor, console: Console) -> dict:
         """
         Displays usage information and a list of available commands for the Orionis CLI.
 
@@ -43,9 +43,6 @@ class HelpCommand(BaseCommand):
             # List of dicts with 'signature' and 'description'
             commands = reactor.info()
 
-            # Initialize the rich console for formatted output
-            console = Console()
-
             # Build the usage and commands help text
             usage = "[bold cyan]Usage:[/]\n  python -B <command> <params/flags>\n\n"
             usage += "[bold cyan]Example:[/]\n  python -B app:command --flag\n\n"

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/commands/scheduler_list.py

@@ -35,7 +35,7 @@ class ScheduleListCommand(BaseCommand):
     signature: str = "schedule:list"
 
     # Command description
-    description: str = "Executes the scheduled tasks defined in the application."
+    description: str = "Lists all scheduled jobs defined in the application."
 
     async def handle(self, app: IApplication, console: Console) -> bool:
         """

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/commands/version.py

@@ -27,7 +27,7 @@ class VersionCommand(BaseCommand):
     # Command description
     description: str = "Displays the current Orionis framework version and metadata, including author, Python requirements, documentation, and repository links."
 
-    def handle(self) -> str:
+    def handle(self, console: Console) -> str:
         """
         Executes the version command to display the current Orionis framework version and metadata.
 
@@ -51,8 +51,6 @@ class VersionCommand(BaseCommand):
             with the original exception message.
         """
         try:
-            # Initialize the console for rich output
-            console = Console()
 
             # Compose the main information strings using framework metadata
             title = f"[bold yellow]{framework.NAME.capitalize()} Framework[/bold yellow] [white]v{framework.VERSION}[/white]"

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/contracts/event.py

@@ -5,6 +5,7 @@ from orionis.console.entities.event import Event as EventEntity
 
 class IEvent(ABC):
 
+    @abstractmethod
     def misfireGraceTime(
         self,
         seconds: int = 60
@@ -31,6 +32,7 @@ class IEvent(ABC):
         CLIOrionisValueError
             If the provided seconds is not a positive integer.
         """
+        pass
 
     @abstractmethod
     def purpose(

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/core/reactor.py

@@ -2,7 +2,7 @@ import argparse
 import os
 from pathlib import Path
 import re
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Type
 from orionis.console.args.argument import CLIArgument
 from orionis.console.base.command import BaseCommand
 from orionis.console.contracts.base_command import IBaseCommand
@@ -154,25 +154,30 @@ class Reactor(IReactor):
 
         # List all .py files in the routes directory and subdirectories
         for current_directory, _, files in os.walk(routes_path):
+
+            # Iterate through each file in the current directory
             for file in files:
 
                 # Only process Python files
                 if file.endswith('.py'):
+
+                    # Construct the full file path
                     file_path = os.path.join(current_directory, file)
 
-                    # Read file content to check for 'Reactor.command'
+                    # Read file content to check for Reactor.command usage
                     try:
 
+                        # Open and read the file content
                         with open(file_path, 'r', encoding='utf-8') as f:
                             content = f.read()
 
-                        # Check if the file contains 'Reactor.command'
-                        if 'Reactor.command' in content:
+                        # Check if the file contains a Reactor.command definition
+                        if 'from orionis.support.facades.reactor import Reactor' in content:
 
                             # Sanitize the module path for import
                             pre_module = current_directory.replace(root_path, '')\
-                                                      .replace(os.sep, '.')\
-                                                      .lstrip('.')
+                                                          .replace(os.sep, '.')\
+                                                          .lstrip('.')
 
                             # Remove virtual environment paths
                             pre_module = re.sub(r'[^.]*\.(?:Lib|lib)\.(?:python[^.]*\.)?site-packages\.?', '', pre_module)
@@ -208,6 +213,7 @@ class Reactor(IReactor):
         # Iterate through all fluent command definitions
         for f_command in self.__fluent_commands:
 
+            # Validate and extract required command attributes
             signature, command_entity = f_command.get()
 
             # Build the arguments dictionary from the CLIArgument instances
@@ -223,9 +229,12 @@ class Reactor(IReactor):
                 exit_on_error=True,
                 prog=signature
             )
+
+            # Iterate through each CLIArgument and add it to the ArgumentParser
             for arg in required_args:
                 arg.addToParser(arg_parser)
 
+            # Register the command in the internal registry with all its metadata
             self.__commands[signature] = Command(
                 obj=command_entity.obj,
                 method=command_entity.method,
@@ -631,7 +640,7 @@ class Reactor(IReactor):
     def command(
         self,
         signature: str,
-        handler: Any
+        handler: List[Any]
     ) -> ICommand:
         """
         Define a new command using a fluent interface.
@@ -647,10 +656,10 @@ class Reactor(IReactor):
             The unique signature identifier for the command. Must follow naming conventions
             (alphanumeric characters, underscores, colons, cannot start/end with underscore
             or colon, cannot start with a number).
-        handler : Any
-            The function or callable that will be executed when the command is invoked.
-            This should be a valid function that accepts parameters matching the command's
-            defined arguments.
+        handler : List[Any]
+            A list containing the class and optionally the method name. The first element
+            should be a class, and the second element (if provided) should be a string
+            representing the method name.
 
         Returns
         -------
@@ -661,7 +670,7 @@ class Reactor(IReactor):
         Raises
         ------
         TypeError
-            If the signature is not a string or if the handler is not callable.
+            If the signature is not a string or if the handler is not a valid list.
         ValueError
             If the signature does not meet the required naming conventions.
         """
@@ -669,6 +678,14 @@ class Reactor(IReactor):
         # Import the FluentCommand class here to avoid circular imports
         from orionis.console.fluent.command import Command as FluentCommand
 
+        # Validate the handler parameter
+        if len(handler) < 1 or not isinstance(handler, list):
+            raise TypeError("Handler must be a list with at least one element (the callable).")
+
+        # Ensure the first element is a class
+        if not hasattr(handler[0], '__call__') or not hasattr(handler[0], '__name__'):
+            raise TypeError("The first element of handler must be a class.")
+
         # Create a new FluentCommand instance with the provided signature and handler
         f_command = FluentCommand(
             signature=signature,

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/kernel.py

@@ -91,27 +91,5 @@ class KernelCLI(IKernelCLI):
 
         except BaseException as e:
 
-            # Extract command name for error handling, with fallback for edge cases
-            command = args[0] if args and len(args) > 0 else "__unknown__"
-
-            # Prepare command arguments as dictionary for CLIRequest
-            command_args = {}
-            if args and len(args) > 1:
-                for arg in args[1:]:
-                    if '=' in arg:
-                        key, value = arg.split('=', 1)
-                        # Remove -- prefix if present
-                        if key.startswith('--'):
-                            key = key[2:]
-                        command_args[key] = value
-                    else:
-                        # If it's a flag (starts with --) or just a flag name, set flag=flag
-                        if arg.startswith('--'):
-                            flag_name = arg[2:]  # Remove --
-                            command_args[flag_name] = flag_name
-                        else:
-                            # For regular arguments without =, set arg=arg
-                            command_args[arg] = arg
-
             # Catch any exceptions that occur during command handling
-            self.__catch.exception(self, CLIRequest(command, command_args), e)
+            self.__catch.exception(self, CLIRequest.fromList(args), e)

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/output/console.py

@@ -2,8 +2,8 @@ import datetime
 import getpass
 import os
 import sys
-from orionis.console.output.enums import ANSIColors
 from orionis.console.contracts.console import IConsole
+from orionis.console.enums.styles import ANSIColors
 
 class Console(IConsole):
     """

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/output/executor.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from orionis.console.contracts.executor import IExecutor
-from orionis.console.output.enums.styles import ANSIColors
+from orionis.console.enums.styles import ANSIColors
 
 class Executor(IExecutor):
 

{orionis-0.543.0 → orionis-0.544.0}/orionis/console/request/cli_request.py

@@ -1,9 +1,103 @@
-from typing import Any
+from typing import Any, List
 from orionis.console.contracts.cli_request import ICLIRequest
 from orionis.console.exceptions.cli_orionis_value_error import CLIOrionisValueError
 
 class CLIRequest(ICLIRequest):
 
+    @classmethod
+    def fromList(cls, args: List[str]) -> 'CLIRequest':
+        """
+        Create a CLIRequest instance from a list of command line arguments.
+
+        This class method provides a convenient way to construct a CLIRequest object
+        directly from a list of command line arguments, such as those typically
+        received from sys.argv. It parses the arguments according to common CLI
+        conventions and extracts the command name and associated parameters.
+
+        Parameters
+        ----------
+        args : list
+            A list of command line arguments where the first element is expected
+            to be the command name, and subsequent elements are command arguments
+            in the format '--key=value', '--flag', or 'value'. Empty lists are
+            handled gracefully with fallback behavior.
+
+        Returns
+        -------
+        CLIRequest
+            A new CLIRequest instance initialized with the parsed command name
+            and arguments dictionary extracted from the input list.
+
+        Examples
+        --------
+        >>> args = ['migrate', '--database=production', '--force', 'users']
+        >>> request = CLIRequest.fromList(args)
+        >>> request.command()
+        'migrate'
+        >>> request.argument('database')
+        'production'
+        >>> request.argument('force')
+        'force'
+
+        Notes
+        -----
+        The parsing logic follows these conventions:
+        - First argument is always treated as the command name
+        - Arguments with '=' are split into key-value pairs
+        - Arguments starting with '--' have the prefix removed
+        - Flag arguments (--flag) are stored with the flag name as both key and value
+        - Regular arguments without '=' are stored with the argument as both key and value
+        - Empty or single-element lists result in default command names and empty arguments
+        """
+
+        # Validate that args is a list
+        if not isinstance(args, list):
+            raise CLIOrionisValueError(
+                f"Failed to create CLIRequest from list: expected list, got {type(args).__module__}.{type(args).__name__}."
+            )
+
+        # Extract command name with defensive programming for edge cases
+        # Use fallback command name for empty lists or malformed input
+        command = args[0] if args and len(args) > 0 else "__unknown__"
+
+        # Initialize command arguments dictionary for storing parsed parameters
+        command_args = {}
+
+        # Process command arguments if any exist beyond the command name
+        if args and len(args) > 1:
+
+            # Iterate over each argument provided after the command name
+            for arg in args[1:]:
+
+                # Handle arguments in key=value format
+                if '=' in arg:
+
+                    # Handle key=value format arguments
+                    key, value = arg.split('=', 1)  # Split only on first '=' to preserve values with '='
+
+                    # Normalize key by removing common CLI prefixes
+                    if key.startswith('--'):
+                        key = key[2:]  # Remove double-dash prefix
+
+                    command_args[key] = value
+
+                else:
+
+                    # Handle flag-style arguments and standalone values
+                    if arg.startswith('--'):
+
+                        # Extract flag name by removing prefix and store as flag=flag
+                        flag_name = arg[2:]
+                        command_args[flag_name] = flag_name
+
+                    else:
+
+                        # For regular arguments without '=', store as arg=arg
+                        command_args[arg] = arg
+
+        # Create and return a new CLIRequest instance with parsed command and arguments
+        return cls(command, command_args)
+
     def __init__(
         self,
         command: str,

{orionis-0.543.0 → orionis-0.544.0}/orionis/failure/base/handler.py

@@ -116,11 +116,8 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         # Convert the exception into a structured Throwable object
         throwable = await self.destructureException(exception)
 
-        # Convert the request arguments to a string for logging
-        string_args = ', '.join(request.all().keys()) if request.all() else 'No arguments'
-
         # Log the CLI error message with arguments
-        log.error(f"CLI Error: {throwable.message} (Args: {string_args})")
+        log.error(f"CLI Error: {throwable.message} (Args: {repr(request.all())})")
 
         # Output the exception traceback to the console
         console.newLine()

{orionis-0.543.0 → orionis-0.544.0}/orionis/metadata/framework.py

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

{orionis-0.543.0 → orionis-0.544.0}/orionis/services/file/contracts/directory.py

@@ -28,6 +28,30 @@ class IDirectory(ABC):
         """
         pass
 
+    @abstractmethod
+    def consoleCommands(self) -> Path:
+        """
+        Get the console commands directory path.
+
+        Returns
+        -------
+        Path
+            The path to the console commands directory.
+        """
+        pass
+
+    @abstractmethod
+    def consoleListeners(self) -> Path:
+        """
+        Get the console listeners directory path.
+
+        Returns
+        -------
+        Path
+            The path to the console listeners directory.
+        """
+        pass
+
     @abstractmethod
     def controllers(self) -> Path:
         """

{orionis-0.543.0 → orionis-0.544.0}/orionis/services/file/directory.py

@@ -48,6 +48,28 @@ class Directory(IDirectory):
         """
         return Path(self.__app.path('console'))
 
+    def consoleCommands(self) -> Path:
+        """
+        Get the console commands directory path.
+
+        Returns
+        -------
+        Path
+            The path to the console commands directory.
+        """
+        return Path(self.__app.path('console')) / 'commands'
+
+    def consoleListeners(self) -> Path:
+        """
+        Get the console listeners directory path.
+
+        Returns
+        -------
+        Path
+            The path to the console listeners directory.
+        """
+        return Path(self.__app.path('console')) / 'listeners'
+
     def controllers(self) -> Path:
         """
         Get the controllers directory path.

orionis-0.544.0/orionis/support/facades/application.pyi

@@ -0,0 +1,42 @@
+from orionis.container.contracts.container import IContainer
+from orionis.foundation.contracts.application import IApplication
+
+class Application(IApplication, IContainer):
+    """
+    Application facade that provides a unified interface for application and container functionality.
+
+    This class serves as the main application facade, combining the capabilities of both
+    IApplication and IContainer interfaces. It acts as the central point for managing
+    application lifecycle, service registration, dependency injection, and other
+    core application concerns.
+
+    The Application facade provides comprehensive access to:
+    - Application configuration and environment settings management
+    - Service container for dependency injection and service resolution
+    - Application lifecycle management (bootstrap, startup, shutdown)
+    - HTTP routing and middleware pipeline handling
+    - Event dispatching, listening, and subscription management
+    - Centralized logging, error handling, and exception management
+    - Database connections and ORM integration
+    - Cache management and session handling
+    - Authentication and authorization services
+
+    This facade implements the Facade design pattern to provide a simplified interface
+    to the complex subsystems of the Orionis framework, making it easier for developers
+    to interact with core application functionality without dealing with internal
+    implementation details.
+
+    Notes
+    -----
+    This is a type stub file (.pyi) that defines the interface contract for the
+    Application facade implementation. The actual implementation should be found
+    in the corresponding .py file.
+
+    The class inherits from both IApplication and IContainer interfaces, ensuring
+    it provides all methods required for application management and dependency
+    injection container functionality.
+    """
+
+    # Type stub class - no implementation needed in .pyi files
+    # The actual implementation will be provided in the corresponding .py file
+    pass

orionis-0.544.0/orionis/support/facades/console.pyi

@@ -0,0 +1,37 @@
+from orionis.console.contracts.console import IConsole
+
+class Console(IConsole):
+    """
+    Console facade class that implements the IConsole interface.
+
+    This class serves as a facade for console operations, providing a simplified
+    and unified interface for console-related functionality. It inherits from the
+    IConsole interface and implements all required console interface methods to
+    handle various console operations.
+
+    The Console facade provides functionality for:
+    - Command line input and output operations
+    - Console text formatting and styling
+    - Progress indicators and status message display
+    - Error and warning message handling
+    - Interactive console features and user prompts
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    None
+        This is a class definition that does not return a value.
+
+    Notes
+    -----
+    This class acts as a facade pattern implementation, abstracting the complexity
+    of underlying console operations and providing a clean, consistent API for
+    console interactions throughout the application.
+    """
+
+    # Placeholder implementation - concrete methods should be implemented
+    # to fulfill the IConsole interface contract
+    pass

orionis-0.544.0/orionis/support/facades/directory.pyi

@@ -0,0 +1,16 @@
+from orionis.services.file.contracts.directory import IDirectory
+
+class Directory(IDirectory):
+    """
+    A facade class that provides a simplified interface for directory operations.
+
+    This class implements the IDirectory interface and serves as a facade to abstract
+    directory-related functionality, providing a clean and consistent API for
+    directory management operations.
+
+    Notes
+    -----
+    This is a facade implementation that delegates directory operations to underlying
+    services while maintaining a simple interface for client code.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/dumper.pyi

@@ -0,0 +1,16 @@
+from orionis.console.contracts.dump import IDebug
+
+class Dumper(IDebug):
+    """
+    A facade class that implements the IDebug interface for debugging operations.
+
+    This class serves as a simplified interface to debugging functionality,
+    providing a convenient way to access debug operations throughout the
+    application without directly instantiating debug components.
+
+    Returns
+    -------
+    None
+        This is a class definition and does not return a value.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/executor.pyi

@@ -0,0 +1,18 @@
+from orionis.console.contracts.executor import IExecutor
+
+class ConsoleExecutor(IExecutor):
+    """
+    Console executor implementation that provides command execution capabilities.
+
+    This class implements the IExecutor interface to handle console-based
+    command execution operations within the Orionis framework.
+
+    Inherits from IExecutor interface which defines the contract for
+    command execution functionality.
+
+    Returns
+    -------
+    None
+        This is a class definition, no return value.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/inspire.pyi

@@ -0,0 +1,21 @@
+from orionis.services.inspirational.contracts.inspire import IInspire
+
+class Inspire(IInspire):
+    """
+    Facade class for inspirational services.
+
+    This class provides a simplified interface to access inspirational content
+    and motivational resources through the IInspire contract implementation.
+    It acts as a facade pattern to hide the complexity of the underlying
+    inspirational service infrastructure.
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    None
+        This is a class definition, not a method.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/logger.pyi

@@ -0,0 +1,22 @@
+from orionis.services.log.contracts.log_service import ILogger
+
+class Log(ILogger):
+    """
+    Log facade class that provides a simplified interface to the logging service.
+
+    This class acts as a facade for the underlying logging implementation,
+    providing static-like access to logging functionality throughout the application.
+    It implements the ILogger interface to ensure consistent logging behavior.
+
+    Parameters
+    ----------
+    None
+        This class is designed to be used as a facade and typically doesn't
+        require direct instantiation parameters.
+
+    Returns
+    -------
+    None
+        This is a class definition, not a method.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/performance_counter.pyi

@@ -0,0 +1,17 @@
+from orionis.support.performance.contracts.counter import IPerformanceCounter
+
+class PerformanceCounter(IPerformanceCounter):
+    """
+    Facade class for performance counter operations.
+
+    This class provides a simplified interface to the performance counter
+    functionality by implementing the IPerformanceCounter contract.
+    It acts as a facade pattern implementation to hide the complexity
+    of the underlying performance monitoring system.
+
+    Returns
+    -------
+    None
+        This is a class definition and does not return a value.
+    """
+    pass

orionis-0.544.0/orionis/support/facades/progress_bar.pyi

@@ -0,0 +1,20 @@
+from orionis.console.contracts.progress_bar import IProgressBar
+
+class ProgressBar(IProgressBar):
+    """
+    A facade class that provides a simplified interface to progress bar functionality.
+
+    This class implements the IProgressBar interface and serves as a wrapper
+    around the underlying progress bar implementation, providing a consistent
+    API for displaying and managing progress indicators in console applications.
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    None
+        This is a class definition, not a method.
+    """
+    pass