orionis 0.452.0__tar.gz → 0.454.0__tar.gz

{orionis-0.452.0/orionis.egg-info → orionis-0.454.0}/PKG-INFO

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

{orionis-0.452.0 → orionis-0.454.0}/orionis/console/commands/version.py

@@ -1,6 +1,8 @@
 from orionis.console.base.command import BaseCommand
 from orionis.console.exceptions import CLIOrionisRuntimeError
-from orionis.metadata.framework import VERSION
+from rich.console import Console
+from rich.panel import Panel
+from orionis.metadata import framework
 
 class VersionCommand(BaseCommand):
     """
@@ -8,6 +10,7 @@ class VersionCommand(BaseCommand):
 
     This command prints the version number of the framework in use.
     """
+    timestamps: bool = False
 
     signature: str = "version"
 
@@ -39,7 +42,32 @@ class VersionCommand(BaseCommand):
 
         # Print the Orionis framework version in a bold, success style
         try:
-            self.textSuccessBold(f"Orionis Framework v{VERSION}")
+
+            # Initialize the console for rich output
+            console = Console()
+
+            # Compose the main info
+            title = f"[bold yellow]{framework.NAME.capitalize()} Framework[/bold yellow] [white]v{framework.VERSION}[/white]"
+            author = f"[bold]Author:[/bold] {framework.AUTHOR}  |  [bold]Email:[/bold] {framework.AUTHOR_EMAIL}"
+            desc = f"[italic]{framework.DESCRIPTION}[/italic]"
+            python_req = f"[bold]Python Requires:[/bold] {framework.PYTHON_REQUIRES}"
+            docs = f"[bold]Docs:[/bold] [underline blue]{framework.DOCS}[/underline blue]"
+            repo = f"[bold]Repo:[/bold] [underline blue]{framework.FRAMEWORK}[/underline blue]"
+
+            body = "\n".join([desc, "", author, python_req, docs, repo, ""])
+
+            panel = Panel(
+                body,
+                title=title,
+                border_style="bold yellow",
+                padding=(1, 6),
+                expand=False,
+                subtitle="[bold yellow]Orionis CLI[/bold yellow]",
+                subtitle_align="right"
+            )
+            console.line()
+            console.print(panel)
+            console.line()
 
         # Raise a custom runtime error if any exception occurs
         except Exception as e:

{orionis-0.452.0 → orionis-0.454.0}/orionis/console/core/reactor.py

@@ -1,7 +1,8 @@
 import argparse
 import os
-from pathlib import Path
+import re
 import time
+from pathlib import Path
 from typing import List, Optional
 from orionis.app import Orionis
 from orionis.console.args.argument import CLIArgument
@@ -11,7 +12,7 @@ from orionis.console.output.contracts.console import IConsole
 from orionis.console.output.contracts.executor import IExecutor
 from orionis.foundation.contracts.application import IApplication
 from orionis.services.introspection.modules.reflection import ReflectionModule
-import re
+from orionis.services.log.contracts.log_service import ILogger
 
 class Reactor:
 
@@ -63,12 +64,64 @@ class Reactor:
         # Automatically discover and load command classes from the console commands directory
         self.__loadCommands(str(self.__app.path('console_commands')), self.__root)
 
+        # Load core command classes provided by the Orionis framework
+        self.__loadCoreCommands()
+
         # Initialize the executor for command output management
         self.__executer: IExecutor = self.__app.make('x-orionis.console.output.executor')
 
         # Initialize the console for command output
         self.__console: IConsole = self.__app.make('x-orionis.console.output.console')
 
+        # Initialize the logger service for logging command execution details
+        self.__logger: ILogger = self.__app.make('x-orionis.services.log.log_service')
+
+    def __loadCoreCommands(self) -> None:
+        """
+        Loads and registers core command classes provided by the Orionis framework.
+
+        This method is responsible for discovering and registering core command classes
+        that are bundled with the Orionis framework itself (such as version, help, etc.).
+        These commands are essential for the framework's operation and are made available
+        to the command registry so they can be executed like any other user-defined command.
+
+        The method imports the required core command classes, validates their structure,
+        and registers them in the internal command registry. Each command is checked for
+        required attributes such as `timestamps`, `signature`, `description`, and `arguments`
+        to ensure proper integration and discoverability.
+
+        Returns
+        -------
+        None
+            This method does not return any value. All discovered core commands are
+            registered internally in the reactor's command registry for later lookup
+            and execution.
+        """
+
+        # Import the core command class for version
+        from orionis.console.commands.version import VersionCommand
+
+        # List of core command classes to load (extend this list as more core commands are added)
+        core_commands = [VersionCommand]
+
+        # Iterate through the core command classes and register them
+        for obj in core_commands:
+
+            # Validate and extract required command attributes
+            timestamp = self.__ensureTimestamps(obj)
+            signature = self.__ensureSignature(obj)
+            description = self.__ensureDescription(obj)
+            args = self.__ensureArguments(obj)
+
+            # Register the command in the internal registry with all its metadata
+            self.__commands[signature] = {
+                "class": obj,
+                "timestamps": timestamp,
+                "signature": signature,
+                "description": description,
+                "args": args
+            }
+
     def __loadCommands(self, commands_path: str, root_path: str) -> None:
         """
         Loads command classes from Python files in the specified commands directory.
@@ -418,10 +471,13 @@ class Reactor:
             output =  self.__app.call(command_instance, 'handle')
 
             # Log the command execution completion with DONE state
+            elapsed_time = round(time.perf_counter() - start_time, 2)
             if timestamps:
-                elapsed_time = round(time.perf_counter() - start_time, 2)
                 self.__executer.done(program=signature, time=f"{elapsed_time}s")
 
+            # Log the command execution success
+            self.__logger.info(f"Command '{signature}' executed successfully in ({elapsed_time}) seconds.")
+
             # If the command has a return value or output, return it
             if output is not None:
                 return output
@@ -431,7 +487,10 @@ class Reactor:
             # Display the error message in the console
             self.__console.error(f"An error occurred while executing command '{signature}': {e}", timestamp=False)
 
+            # Log the error in the logger service
+            self.__logger.error(f"Command '{signature}' execution failed: {e}")
+
             # Log the command execution failure with ERROR state
+            elapsed_time = round(time.perf_counter() - start_time, 2)
             if timestamps:
-                elapsed_time = round(time.perf_counter() - start_time, 2)
-                self.__executer.fail(program=signature, time=f"{elapsed_time}s")
+                self.__executer.fail(program=signature, time=f"{elapsed_time}s")

{orionis-0.452.0 → orionis-0.454.0}/orionis/foundation/application.py

@@ -20,7 +20,7 @@ from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.foundation.contracts.application import IApplication
 from orionis.foundation.exceptions import OrionisTypeError, OrionisRuntimeError, OrionisValueError
 from orionis.foundation.providers.logger_provider import LoggerProvider
-from orionis.services.log.contracts.log_service import ILoggerService
+from orionis.services.log.contracts.log_service import ILogger
 
 class Application(Container, IApplication):
     """
@@ -1931,7 +1931,7 @@ class Application(Container, IApplication):
             self.__loadFrameworksKernel()
 
             # Retrieve logger and console instances from the container
-            logger: ILoggerService = self.make('x-orionis.services.log.log_service')
+            logger: ILogger = self.make('x-orionis.services.log.log_service')
 
             # Calculate elapsed time in milliseconds since application start
             elapsed_ms = (time.time_ns() - self.startAt) // 1_000_000

{orionis-0.452.0 → orionis-0.454.0}/orionis/foundation/providers/logger_provider.py

@@ -1,6 +1,6 @@
 from orionis.container.providers.service_provider import ServiceProvider
-from orionis.services.log.contracts.log_service import ILoggerService
-from orionis.services.log.log_service import LoggerService
+from orionis.services.log.contracts.log_service import ILogger
+from orionis.services.log.log_service import Logger
 
 class LoggerProvider(ServiceProvider):
     """
@@ -8,7 +8,7 @@ class LoggerProvider(ServiceProvider):
 
     The LoggerProvider is responsible for registering and configuring the logging
     service implementation in the application's dependency injection container.
-    It binds the concrete LoggerService to the ILoggerService interface, enabling
+    It binds the concrete Logger to the ILogger interface, enabling
     application-wide access to structured logging capabilities.
 
     This provider handles the initialization of the logging service with the
@@ -32,7 +32,7 @@ class LoggerProvider(ServiceProvider):
         """
         Register the logging service in the application container.
 
-        This method binds the `LoggerService` implementation to the `ILoggerService`
+        This method binds the `Logger` implementation to the `ILogger`
         contract within the application's dependency injection container. The service
         is initialized with the application's logging configuration and registered
         with a specific alias for internal framework identification.
@@ -50,12 +50,12 @@ class LoggerProvider(ServiceProvider):
         # Retrieve logging configuration from application config
         logging_config = self.app.config('logging')
 
-        # Create LoggerService instance with the retrieved configuration
-        logger_service = LoggerService(logging_config)
+        # Create Logger instance with the retrieved configuration
+        logger_service = Logger(logging_config)
 
         # Register the service instance in the container with interface binding and alias
         self.app.instance(
-            ILoggerService,                             # Interface contract
+            ILogger,                             # Interface contract
             logger_service,                             # Concrete implementation instance
             alias="x-orionis.services.log.log_service"  # Internal framework alias
         )

{orionis-0.452.0 → orionis-0.454.0}/orionis/metadata/framework.py

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

{orionis-0.452.0 → orionis-0.454.0}/orionis/services/log/contracts/log_service.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-class ILoggerService(ABC):
+class ILogger(ABC):
 
     @abstractmethod
     def info(self, message: str) -> None:

{orionis-0.452.0 → orionis-0.454.0}/orionis/services/log/log_service.py

@@ -1,12 +1,12 @@
 from orionis.foundation.config.logging.entities.logging import Logging
 from orionis.foundation.config.logging.enums import Level
-from orionis.services.log.contracts.log_service import ILoggerService
+from orionis.services.log.contracts.log_service import ILogger
 from orionis.services.log.exceptions import LoggerRuntimeError
 from orionis.services.log.handlers.filename import FileNameLogger
 from orionis.services.log.handlers.size_rotating import PrefixedSizeRotatingFileHandler
 from orionis.services.log.handlers.timed_rotating import PrefixedTimedRotatingFileHandler
 
-class LoggerService(ILoggerService):
+class Logger(ILogger):
 
     def __init__(
         self,
@@ -14,7 +14,7 @@ class LoggerService(ILoggerService):
         **kwargs
     ):
         """
-        Initializes the LoggerService instance with the provided logging configuration.
+        Initializes the Logger instance with the provided logging configuration.
 
         This constructor sets up the logger configuration using either a `Logging` object,
         a configuration dictionary, or keyword arguments. It validates the input and

{orionis-0.452.0 → orionis-0.454.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.452.0 → orionis-0.454.0}/tests/services/log/test_log.py

@@ -1,52 +1,52 @@
-from orionis.services.log.log_service import LoggerService
+from orionis.services.log.log_service import Logger
 from orionis.support.facades.logger import Log
 from orionis.test.cases.asynchronous import AsyncTestCase
 
-class TestLoggerService(AsyncTestCase):
+class TestLogger(AsyncTestCase):
 
     async def testHasInfoMethod(self):
         """
-        Checks if the LoggerService class has an 'info' method.
+        Checks if the Logger class has an 'info' method.
 
         Returns
         -------
         None
             This test passes if the 'info' method exists, otherwise it fails.
         """
-        self.assertTrue(hasattr(LoggerService, "info"))
+        self.assertTrue(hasattr(Logger, "info"))
 
     async def testHasErrorMethod(self):
         """
-        Checks if the LoggerService class has an 'error' method.
+        Checks if the Logger class has an 'error' method.
 
         Returns
         -------
         None
             This test passes if the 'error' method exists, otherwise it fails.
         """
-        self.assertTrue(hasattr(LoggerService, "error"))
+        self.assertTrue(hasattr(Logger, "error"))
 
     async def testHasWarningMethod(self):
         """
-        Checks if the LoggerService class has a 'warning' method.
+        Checks if the Logger class has a 'warning' method.
 
         Returns
         -------
         None
             This test passes if the 'warning' method exists, otherwise it fails.
         """
-        self.assertTrue(hasattr(LoggerService, "warning"))
+        self.assertTrue(hasattr(Logger, "warning"))
 
     async def testHasDebugMethod(self):
         """
-        Checks if the LoggerService class has a 'debug' method.
+        Checks if the Logger class has a 'debug' method.
 
         Returns
         -------
         None
             This test passes if the 'debug' method exists, otherwise it fails.
         """
-        self.assertTrue(hasattr(LoggerService, "debug"))
+        self.assertTrue(hasattr(Logger, "debug"))
 
     async def testLoggerWritesInfo(self):
         """