orionis 0.481.0__py3-none-any.whl → 0.483.0__py3-none-any.whl

orionis/console/commands/scheduler_list.py

@@ -0,0 +1,139 @@
+import importlib
+import os
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+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
+
+class ScheduleListCommand(BaseCommand):
+    """
+    Command class to display usage information for the Orionis CLI.
+
+    Methods
+    -------
+    handle(orionis: IApplication, console: Console) -> bool
+        Displays a table of scheduled tasks defined in the application.
+        Imports the scheduler module, retrieves scheduled jobs, and prints them
+        in a formatted table using the rich library.
+
+    Returns
+    -------
+    bool
+        Returns True if the scheduled jobs are listed successfully or if no jobs are found.
+        Raises CLIOrionisRuntimeError if an error occurs during execution.
+    """
+
+    # Indicates whether timestamps will be shown in the command output
+    timestamps: bool = False
+
+    # Command signature and description
+    signature: str = "schedule:list"
+
+    # Command description
+    description: str = "Executes the scheduled tasks defined in the application."
+
+    def handle(self, orionis: IApplication, console: Console) -> bool:
+        """
+        Displays a table of scheduled jobs defined in the application.
+
+        This method dynamically imports the scheduler module, retrieves the list of
+        scheduled jobs using the ISchedule service, and prints the jobs in a formatted
+        table. If no jobs are found, a message is displayed. Handles and reports errors
+        encountered during the process.
+
+        Parameters
+        ----------
+        orionis : IApplication
+            The application instance providing configuration and service resolution.
+        console : Console
+            The rich Console instance used for output.
+
+        Returns
+        -------
+        bool
+            Returns True if the scheduled jobs are listed successfully or if no jobs are found.
+            Raises CLIOrionisRuntimeError if an error occurs during execution.
+        """
+
+        try:
+
+            # Get the absolute path of the scheduler from the application configuration
+            scheduler_path = orionis.path('console_scheduler')
+
+            # Get the base path from the current working directory
+            base_path = Path(os.getcwd()).resolve()
+            scheduler_path = Path(scheduler_path).resolve()
+            rel_path = scheduler_path.relative_to(base_path)
+
+            # Convert the path to a module name (replace separators with dots, remove .py)
+            module_name = ".".join(rel_path.with_suffix('').parts)
+
+            # Dynamically import the scheduler module
+            scheduler_module = importlib.import_module(module_name)
+
+            # Retrieve the Scheduler class from the imported module
+            Scheduler = getattr(scheduler_module, "Scheduler", None)
+
+            # Raise an error if the Scheduler class is not found
+            if Scheduler is None:
+                raise CLIOrionisRuntimeError(f"Scheduler class not found in module {module_name}")
+
+            # Retrieve the 'tasks' method from the Scheduler class
+            task_method = getattr(Scheduler, "tasks", None)
+
+            # Raise an error if the 'tasks' method is not found
+            if task_method is None:
+                raise CLIOrionisRuntimeError(f"Method 'tasks' not found in Scheduler class in module {module_name}")
+
+            # Create an instance of ISchedule using the application container
+            schedule_serice: ISchedule = orionis.make(ISchedule)
+
+            # Initialize the scheduled tasks by calling the 'tasks' method
+            task_method(schedule_serice)
+
+            # Retrieve the list of scheduled jobs/events
+            list_tasks = schedule_serice.events()
+
+            # Display a message if no scheduled jobs are found
+            if not list_tasks:
+                console.line()
+                console.print(Panel("No scheduled jobs found.", border_style="green"))
+                console.line()
+                return True
+
+            # Create and configure a table to display scheduled jobs
+            table = Table(title="Scheduled Jobs", show_lines=True)
+            table.add_column("Signature", style="cyan", no_wrap=True)
+            table.add_column("Arguments", style="magenta")
+            table.add_column("Purpose", style="green")
+            table.add_column("Random Delay", style="yellow")
+            table.add_column("Start Date", style="white")
+            table.add_column("End Date", style="white")
+            table.add_column("Details", style="dim")
+
+            # Populate the table with job details
+            for job in list_tasks:
+                signature = str(job.get("signature", ""))
+                args = ", ".join(map(str, job.get("args", [])))
+                purpose = str(job.get("purpose", ""))
+                random_delay = str(job.get("random_delay", ""))
+                start_date = str(job.get("start_date", "")) if job.get("start_date") else "-"
+                end_date = str(job.get("end_date", "")) if job.get("end_date") else "-"
+                details = str(job.get("details", ""))
+
+                table.add_row(signature, args, purpose, random_delay, start_date, end_date, details)
+
+            # Print the table to the console
+            console.line()
+            console.print(table)
+            console.line()
+            return True
+
+        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/console/commands/scheduler_work.py

@@ -1,18 +1,41 @@
 import importlib
 import os
+from datetime import datetime
 from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
 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.
+    Executes the scheduled tasks defined in the application's scheduler.
+
+    This command dynamically loads the scheduler module specified in the application's configuration,
+    retrieves the `Scheduler` class and its `tasks` method, registers the scheduled tasks with the
+    ISchedule service, and starts the scheduler worker. It provides user feedback via the console and
+    handles errors by raising CLIOrionisRuntimeError exceptions.
+
+    Parameters
+    ----------
+    orionis : IApplication
+        The application instance providing configuration and service resolution.
+    console : Console
+        The Rich console instance used for displaying output to the user.
+
+    Returns
+    -------
+    bool
+        Returns True if the scheduler worker starts successfully. If an error occurs during the process,
+        a CLIOrionisRuntimeError is raised.
+
+    Raises
+    ------
+    CLIOrionisRuntimeError
+        If the scheduler module, class, or tasks method cannot be found, or if any unexpected error occurs.
     """
 
     # Indicates whether timestamps will be shown in the command output
@@ -25,44 +48,66 @@ class ScheduleWorkCommand(BaseCommand):
     description: str = "Executes the scheduled tasks defined in the application."
 
     async def handle(self, orionis: IApplication, console: Console) -> bool:
-
+        """
+        Executes the scheduled tasks defined in the application's scheduler.
+
+        This method dynamically loads the scheduler module specified in the application's configuration,
+        retrieves the `Scheduler` class and its `tasks` method, registers the scheduled tasks with the
+        ISchedule service, and starts the scheduler worker. It provides user feedback via the console and
+        handles errors by raising CLIOrionisRuntimeError exceptions.
+
+        Parameters
+        ----------
+        orionis : IApplication
+            The application instance providing configuration and service resolution.
+        console : Console
+            The Rich console instance used for displaying output to the user.
+
+        Returns
+        -------
+        bool
+            Returns True if the scheduler worker starts successfully. If an error occurs during the process,
+            a CLIOrionisRuntimeError is raised.
+
+        Raises
+        ------
+        CLIOrionisRuntimeError
+            If the scheduler module, class, or tasks method cannot be found, or if any unexpected error occurs.
+        """
         try:
-
-            # Obtener la ruta absoluta del scheduler desde la configuración de la aplicación
+            # Get the absolute path to the scheduler module from the application configuration
             scheduler_path = orionis.path('console_scheduler')
 
-            # Obtener la base path desde la variable de entorno o desde la configuración local
+            # Resolve the base path (current working directory)
             base_path = Path(os.getcwd()).resolve()
             scheduler_path = Path(scheduler_path).resolve()
+
+            # Compute the relative path from the base path to the scheduler module
             rel_path = scheduler_path.relative_to(base_path)
 
-            # Reemplazar los separadores por puntos y quitar la extensión .py
+            # Convert the relative path to a Python module name (dot notation, no .py extension)
             module_name = ".".join(rel_path.with_suffix('').parts)
 
-            # Importar el módulo del scheduler
+            # Dynamically import the scheduler module
             scheduler_module = importlib.import_module(module_name)
 
-            # Obtener la clase Scheduler del módulo importado
+            # Retrieve the Scheduler class from the imported module
             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
+            # Retrieve the 'tasks' method from the Scheduler class
             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
+            # Create an instance of the ISchedule service
             schedule_serice: ISchedule = orionis.make(ISchedule)
 
-            # Inicializar el metodo
+            # Register scheduled tasks using the Scheduler's tasks method
             task_method(schedule_serice)
 
-            # Display a professional start message for the scheduler worker
+            # Display a start message for the scheduler worker
             console.line()
             start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
             panel_content = Text.assemble(
@@ -79,10 +124,10 @@ class ScheduleWorkCommand(BaseCommand):
             )
             console.line()
 
-            # Iniciar el scheduler
+            # Start the scheduler worker asynchronously
             await schedule_serice.start()
+            return True
 
         except Exception as exc:
-
-            # Catch any unexpected exceptions and raise as a CLIOrionisRuntimeError
+            # Raise any unexpected exceptions as CLIOrionisRuntimeError
             raise CLIOrionisRuntimeError(f"An unexpected error occurred while clearing the cache: {exc}")

orionis/console/core/reactor.py

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

orionis/metadata/framework.py

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

orionis/services/log/handlers/filename.py

@@ -1,6 +1,5 @@
 import os
-from datetime import datetime
-from pathlib import Path
+from datetime import datetime, timedelta
 
 class FileNameLogger:
 
@@ -18,7 +17,6 @@ class FileNameLogger:
         ValueError
             If the provided path is not a non-empty string.
         """
-
         # Validate that the path is a non-empty string
         if not isinstance(path, str) or not path:
             raise ValueError("The 'path' parameter must be a non-empty string.")
@@ -26,26 +24,31 @@ class FileNameLogger:
         # Store the stripped path as a private instance variable
         self.__path = path.strip()
 
-    def generate(self) -> str:
+    def __splitDirectory(
+        self
+    ) -> tuple[str, str, str]:
         """
-        Generate a new log file path with a timestamp prefix.
+        Split the original file path into directory, file name, and extension.
 
-        The method constructs a new file path by prefixing the original file name
-        with a timestamp in the format 'YYYYMMDD_HHMMSS'. It also ensures that the
-        directory for the log file exists, creating it if necessary.
+        This private method processes the stored file path, separating it into its
+        directory path, base file name (without extension), and file extension. It
+        also ensures that the directory exists, creating it if necessary.
 
         Returns
         -------
-        str
-            The full path to the log file with a timestamped file name.
+        tuple of str
+            A tuple containing:
+            - The directory path as a string.
+            - The base file name (without extension) as a string.
+            - The file extension (including the dot) as a string.
 
         Notes
         -----
-        - The timestamp is generated using the current date and time.
-        - The directory for the log file is created if it does not exist.
+        - The method handles both forward slash ('/') and backslash ('\\') as path separators.
+        - If the directory does not exist, it will be created.
         """
 
-        # Split the original path into components based on the separator
+        # Determine the path separator and split the path into components
         if '/' in self.__path:
             parts = self.__path.split('/')
         elif '\\' in self.__path:
@@ -53,22 +56,471 @@ class FileNameLogger:
         else:
             parts = self.__path.split(os.sep)
 
-        # Extract the base file name and its extension
+        # Extract the base file name and its extension from the last component
         filename, ext = os.path.splitext(parts[-1])
 
         # Reconstruct the directory path (excluding the file name)
         path = os.path.join(*parts[:-1]) if len(parts) > 1 else ''
 
-        # Generate a timestamp prefix for the file name
-        prefix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        # Ensure the directory exists; create it if it does not
+        if not os.path.isdir(path):
+            os.makedirs(path, exist_ok=True)
+
+        # Return the directory path, file name, and extension as a tuple
+        return path, filename, ext
+
+    def __listFilesInDirectory(
+        self,
+        directory: str
+    ) -> list[str]:
+        """
+        List all files in the specified directory.
+
+        This private method retrieves all files in the given directory, returning
+        their names as a list. It does not include subdirectories or hidden files.
+
+        Parameters
+        ----------
+        directory : str
+            The path to the directory from which to list files.
+
+        Returns
+        -------
+        list of dict
+            A list of dictionaries, each containing:
+
+        Notes
+        -----
+        - The method does not check for file types; it returns all files regardless of extension.
+        - If the directory does not exist, an empty list is returned.
+        """
+
+        # Check if the directory exists; if not, return an empty list
+        if not os.path.isdir(directory):
+            return []
+
+        # List all files in the directory and return their names
+        files = []
+        for f in os.listdir(directory):
+            if os.path.isfile(os.path.join(directory, f)):
+                files.append({
+                    'name': f,
+                    'path': os.path.join(directory, f),
+                    'size': os.path.getsize(os.path.join(directory, f)),
+                    'modified': datetime.fromtimestamp(os.path.getmtime(os.path.join(directory, f)))
+                })
+
+        # Return the list of file names
+        return files
+
+    def __stack(
+        self,
+        path: str,
+        filename: str,
+        ext: str
+    ) -> str:
+        """
+        Construct the log file path for the 'stack' channel.
+
+        This private method generates the full file path for a log file when the
+        'stack' channel is specified. It combines the provided directory path,
+        base file name, and file extension to create the complete file path.
+
+        Parameters
+        ----------
+        path : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
+
+        Returns
+        -------
+        str
+            The full file path for the log file in the specified directory.
+
+        Notes
+        -----
+        - This method does not modify or create any directories; it only constructs the path.
+        - The resulting path is platform-independent.
+        """
+
+        # Join the directory path, file name, and extension to form the full file path
+        return os.path.join(path, f"{filename}{ext}")
+
+    def __hourly(
+        self,
+        directory: str,
+        filename: str,
+        ext: str
+    ) -> str:
+        """
+        Construct the log file path for the 'hourly' channel.
+
+        This private method generates the full file path for a log file when the
+        'hourly' channel is specified. If a log file has already been created within
+        the last hour, it returns its path; otherwise, it creates a new file name
+        with a timestamp.
 
-        # Build the full file path with the timestamped file name
-        full_path = os.path.join(path, f"{prefix}_{filename}{ext}")
+        Parameters
+        ----------
+        directory : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
+
+        Returns
+        -------
+        str
+            The full file path for the log file in the specified directory.
+        """
+
+        now = datetime.now()
+        one_hour_ago = now - timedelta(hours=1)
+        files = self.__listFilesInDirectory(directory)
+
+        # Find the most recent file created within the last hour
+        recent_file = None
+        for file in sorted(files, key=lambda x: x['modified'], reverse=True):
+            if file['modified'] >= one_hour_ago and 'hourly' in file['name']:
+                recent_file = file['path']
+                break
+
+        # If a recent file is found, return its path
+        if recent_file:
+            return recent_file
+
+        # No recent file found, create a new one with timestamp
+        timestamp = now.strftime("%Y%m%d_%H%M%S")
+
+        # Ensure the filename starts with 'hourly_' if not already present
+        if 'hourly' not in filename:
+            filename = f"hourly_{filename}"
+
+        # Construct the new file name with the timestamp prefix
+        new_filename = f"{timestamp}_{filename}{ext}"
+        return os.path.join(directory, new_filename)
+
+    def __daily(
+        self,
+        directory: str,
+        filename: str,
+        ext: str
+    ) -> str:
+        """
+        Construct the log file path for the 'daily' channel.
+
+        This private method generates the full file path for a log file when the
+        'daily' channel is specified. If a log file has already been created for
+        the current day, it returns its path; otherwise, it creates a new file name
+        with the current date and a high-resolution timestamp to ensure uniqueness.
+
+        Parameters
+        ----------
+        directory : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
 
-        # Ensure the log directory exists; create it if it does not
-        log_dir = Path(full_path).parent
-        if not log_dir.exists():
-            log_dir.mkdir(parents=True, exist_ok=True)
+        Returns
+        -------
+        str
+            The full file path for the log file in the specified directory. If a log
+            file for the current day already exists, its path is returned; otherwise,
+            a new file path is generated with the current date and a unique timestamp.
+
+        Notes
+        -----
+        - The method checks for existing log files for the current day and reuses them if found.
+        - If no such file exists, a new file name is generated using the current date and a Unix timestamp.
+        - The resulting path is platform-independent.
+        """
+
+        # Get the current date in YYYY_MM_DD format
+        date = datetime.now().strftime("%Y_%m_%d")
+
+        # List all files in the target directory
+        files = self.__listFilesInDirectory(directory)
+
+        # Search for the most recent file created today
+        recent_file = None
+        for file in sorted(files, key=lambda x: x['modified'], reverse=True):
+            if str(file['name']).startswith(date) and 'daily' in file['name']:
+                recent_file = file['path']
+                break
+
+        # If a file for today exists, return its path
+        if recent_file:
+            return recent_file
+
+        # Prefix the filename with 'daily_' if not already present
+        if 'daily' not in filename:
+            filename = f"daily_{filename}"
+
+        # Generate a unique filename using the current date and Unix timestamp
+        unix_time = int(datetime.now().timestamp())
+        new_filename = f"{date}_{unix_time}_{filename}{ext}"
+        return os.path.join(directory, new_filename)
+
+    def __weekly(
+        self,
+        directory: str,
+        filename: str,
+        ext: str
+    ) -> str:
+        """
+        Construct the log file path for the 'weekly' channel.
+
+        This private method generates the full file path for a log file when the
+        'weekly' channel is specified. If a log file has already been created for
+        the current week, it returns its path; otherwise, it creates a new file name
+        with the current year, ISO week number, and a Unix timestamp to ensure uniqueness.
+
+        Parameters
+        ----------
+        directory : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
 
-        # Return the full path to the timestamped log file
-        return full_path
+        Returns
+        -------
+        str
+            The full file path for the log file in the specified directory. If a log
+            file for the current week already exists, its path is returned; otherwise,
+            a new file path is generated using the current year, ISO week number, and a unique timestamp.
+
+        Notes
+        -----
+        - The method checks for existing log files for the current week and reuses them if found.
+        - If no such file exists, a new file name is generated using the current year, ISO week number, and Unix timestamp.
+        - The resulting path is platform-independent.
+        """
+
+        # Get the current week number and year using ISO calendar
+        now = datetime.now()
+        year, week_num, _ = now.isocalendar()
+        week = f"{year}_W{week_num:02d}"
+
+        # List all files in the target directory
+        files = self.__listFilesInDirectory(directory)
+
+        # Search for the most recent file created this week with 'weekly' in its name
+        recent_file = None
+        for file in sorted(files, key=lambda x: x['modified'], reverse=True):
+            if str(file['name']).startswith(week) and 'weekly' in file['name']:
+                recent_file = file['path']
+                break
+
+        # If a file for this week exists, return its path
+        if recent_file:
+            return recent_file
+
+        # Prefix the filename with 'weekly_' if not already present
+        if 'weekly' not in filename:
+            filename = f"weekly_{filename}"
+
+        # Generate a unique filename using the current year, week, and Unix timestamp
+        unix_time = int(datetime.now().timestamp())
+        new_filename = f"{week}_{unix_time}_{filename}{ext}"
+
+        # Return the full path to the new weekly log file
+        return os.path.join(directory, new_filename)
+
+    def __monthly(
+        self,
+        directory: str,
+        filename: str,
+        ext: str
+    ) -> str:
+        """
+        Construct the log file path for the 'monthly' channel.
+
+        This private method generates the full file path for a log file when the
+        'monthly' channel is specified. If a log file has already been created for
+        the current month, it returns its path; otherwise, it creates a new file name
+        with the current year, month, and a Unix timestamp to ensure uniqueness.
+
+        Parameters
+        ----------
+        directory : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
+
+        Returns
+        -------
+        str
+            The full file path for the log file in the specified directory. If a log
+            file for the current month already exists, its path is returned; otherwise,
+            a new file path is generated using the current year, month, and a unique timestamp.
+
+        Notes
+        -----
+        - The method checks for existing log files for the current month and reuses them if found.
+        - If no such file exists, a new file name is generated using the current year, month, and Unix timestamp.
+        - The resulting path is platform-independent.
+        """
+
+        # Get the current year and month
+        now = datetime.now()
+        year = now.year
+        month = now.month
+        month_str = f"{year}_M{month:02d}"
+
+        # List all files in the target directory
+        files = self.__listFilesInDirectory(directory)
+
+        # Search for the most recent file created this month with 'monthly' in its name
+        recent_file = None
+        for file in sorted(files, key=lambda x: x['modified'], reverse=True):
+            if str(file['name']).startswith(month_str) and 'monthly' in file['name']:
+                recent_file = file['path']
+                break
+
+        # If a file for this month exists, return its path
+        if recent_file:
+            return recent_file
+
+        # Prefix the filename with 'monthly_' if not already present
+        if 'monthly' not in filename:
+            filename = f"monthly_{filename}"
+
+        # Generate a unique filename using the current year, month, and Unix timestamp
+        unix_time = int(datetime.now().timestamp())
+        new_filename = f"{month_str}_{unix_time}_{filename}{ext}"
+
+        # Return the full path to the new monthly log file
+        return os.path.join(directory, new_filename)
+
+    def __chunked(
+        self,
+        directory: str,
+        filename: str,
+        ext: str,
+        max_bytes: int = 5242880
+    ) -> str:
+        """
+        Construct the log file path for the 'chunked' channel.
+
+        This private method generates the full file path for a log file when the
+        'chunked' channel is specified. It checks for the most recent log file
+        in the specified directory with 'chunked' in its name and a size less than
+        the specified maximum number of bytes. If such a file exists, its path is
+        returned. Otherwise, a new file name is generated using the current Unix
+        timestamp and the 'chunked_' prefix.
+
+        Parameters
+        ----------
+        directory : str
+            The directory path where the log file should be stored.
+        filename : str
+            The base name of the log file (without extension).
+        ext : str
+            The file extension, including the dot (e.g., '.log').
+        max_bytes : int, optional
+            The maximum allowed size in bytes for a chunked log file. Default is 5 MB (5242880 bytes).
+
+        Returns
+        -------
+        str
+            The full file path for the chunked log file in the specified directory.
+            If a suitable file exists (with 'chunked' in its name and size less than
+            `max_bytes`), its path is returned. Otherwise, a new file path is generated
+            with a unique timestamp and returned.
+
+        Notes
+        -----
+        - The method checks for existing chunked log files and reuses them if their size
+          is below the specified threshold.
+        - If no such file exists, a new file name is generated using the current Unix timestamp.
+        - The resulting path is platform-independent.
+        """
+
+        # List all files in the target directory
+        files = self.__listFilesInDirectory(directory)
+
+        # Search for the most recent file with 'chunked' in its name and size less than max_bytes
+        recent_file = None
+        for file in sorted(files, key=lambda x: x['modified'], reverse=True):
+            if 'chunked' in file['name'] and file['size'] < max_bytes:
+                recent_file = file['path']
+                break
+
+        # If a suitable chunked file exists, return its path
+        if recent_file:
+            return recent_file
+
+        # Prefix the filename with 'chunked_' if not already present
+        if 'chunked' not in filename:
+            filename = f"chunked_{filename}"
+
+        # Generate a unique filename using the current Unix timestamp
+        unix_time = int(datetime.now().timestamp())
+        new_filename = f"{unix_time}_{filename}{ext}"
+
+        # Return the full path to the new chunked log file
+        return os.path.join(directory, new_filename)
+
+    def generate(self, channel: str, max_bytes: int = 5242880) -> str:
+        """
+        Generate the appropriate log file path based on the specified channel.
+
+        This method determines the log file naming strategy according to the given
+        channel type. It delegates the file path construction to the corresponding
+        private method for each channel. For the 'chunked' channel, the maximum
+        allowed file size can be specified.
+
+        Parameters
+        ----------
+        channel : str
+            The log channel type. Supported values are:
+            'stack', 'hourly', 'daily', 'weekly', 'monthly', 'chunked'.
+        max_bytes : int, optional
+            The maximum allowed size in bytes for a chunked log file. Only used
+            when `channel` is 'chunked'. Default is 5 MB (5242880 bytes).
+
+        Returns
+        -------
+        str
+            The full file path for the log file according to the specified channel.
+
+        Raises
+        ------
+        ValueError
+            If the provided channel is not supported.
+
+        Notes
+        -----
+        - The method uses the original file path provided during initialization.
+        - For all channels except 'chunked', `max_bytes` is ignored.
+        - The resulting file path is platform-independent.
+        """
+
+        # Select the appropriate file path generation strategy based on the channel
+        if channel == 'stack':
+            return self.__stack(*self.__splitDirectory())
+        elif channel == 'hourly':
+            return self.__hourly(*self.__splitDirectory())
+        elif channel == 'daily':
+            return self.__daily(*self.__splitDirectory())
+        elif channel == 'weekly':
+            return self.__weekly(*self.__splitDirectory())
+        elif channel == 'monthly':
+            return self.__monthly(*self.__splitDirectory())
+        elif channel == 'chunked':
+            return self.__chunked(*self.__splitDirectory(), max_bytes=max_bytes)
+        else:
+            raise ValueError(
+                f"Unknown channel: {channel}. Supported channels are: "
+                "'stack', 'hourly', 'daily', 'weekly', 'monthly', 'chunked'."
+            )

orionis/services/log/handlers/size_rotating.py

@@ -25,5 +25,8 @@ class PrefixedSizeRotatingFileHandler(RotatingFileHandler):
         The timestamp prefix helps in identifying the creation time of each rotated log file.
         """
 
+        # Import Application to access configuration settings
+        from orionis.support.facades.application import Application
+
         # Generate the new filename using FileNameLogger, which adds a timestamp prefix.
-        return FileNameLogger(default_name).generate()
+        return FileNameLogger(default_name).generate('chunked', Application.config('logging.channels.chunked.mb_size', 5))

orionis/services/log/handlers/timed_rotating.py

@@ -25,5 +25,8 @@ class PrefixedTimedRotatingFileHandler(TimedRotatingFileHandler):
         The timestamp prefix helps in organizing and distinguishing rotated log files.
         """
 
-        # Use FileNameLogger to generate a new filename with a timestamp prefix
-        return FileNameLogger(default_name).generate()
+        # Import Application to access configuration settings
+        from orionis.support.facades.application import Application
+
+        # Generate the new filename using FileNameLogger, which adds a timestamp prefix.
+        return FileNameLogger(default_name).generate(Application.config('logging.default', 'stack'))

orionis/services/log/log_service.py

@@ -110,9 +110,6 @@ class Logger(ILogger):
             # Get the configuration object for the selected channel
             config_channels = getattr(self.__config.channels, channel)
 
-            # Generate the log file path using the FileNameLogger utility
-            path: str = FileNameLogger(getattr(config_channels, 'path')).generate()
-
             # Determine the logging level (default to DEBUG if not specified)
             level: Level | int = getattr(config_channels, 'level', 10)
             level = level if isinstance(level, int) else level.value
@@ -122,7 +119,7 @@ class Logger(ILogger):
                 # Simple file handler for stack channel
                 handlers = [
                     logging.FileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel),
                         encoding="utf-8"
                     )
                 ]
@@ -131,7 +128,7 @@ class Logger(ILogger):
                 # Rotating file handler for hourly logs
                 handlers = [
                     PrefixedTimedRotatingFileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel),
                         when="h",
                         interval=1,
                         backupCount=getattr(config_channels, 'retention_hours', 24),
@@ -144,7 +141,7 @@ class Logger(ILogger):
                 # Rotating file handler for daily logs
                 handlers = [
                     PrefixedTimedRotatingFileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel),
                         when="d",
                         interval=1,
                         backupCount=getattr(config_channels, 'retention_days', 7),
@@ -158,7 +155,7 @@ class Logger(ILogger):
                 # Rotating file handler for weekly logs
                 handlers = [
                     PrefixedTimedRotatingFileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel),
                         when="w0",
                         interval=1,
                         backupCount=getattr(config_channels, 'retention_weeks', 4),
@@ -171,7 +168,7 @@ class Logger(ILogger):
                 # Rotating file handler for monthly logs
                 handlers = [
                     PrefixedTimedRotatingFileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel),
                         when="midnight",
                         interval=30,
                         backupCount=getattr(config_channels, 'retention_months', 4),
@@ -182,9 +179,10 @@ class Logger(ILogger):
 
             elif channel == "chunked":
                 # Size-based rotating file handler for chunked logs
+                max_bytes = getattr(config_channels, 'mb_size', 10) * 1024 * 1024
                 handlers = [
                     PrefixedSizeRotatingFileHandler(
-                        filename=path,
+                        filename=FileNameLogger(getattr(config_channels, 'path')).generate(channel, max_bytes),
                         maxBytes=getattr(config_channels, 'mb_size', 10) * 1024 * 1024,
                         backupCount=getattr(config_channels, 'files', 5),
                         encoding="utf-8"

orionis/support/facades/application.py

@@ -0,0 +1,23 @@
+from orionis.container.facades.facade import Facade
+
+class Application(Facade):
+
+    @classmethod
+    def getFacadeAccessor(cls) -> str:
+        """
+        Get the registered service container binding key for the console component.
+
+        This method returns the specific binding key that is used to resolve the
+        console output service from the dependency injection container. The facade
+        pattern uses this key to locate and instantiate the underlying console
+        service implementation.
+
+        Returns
+        -------
+        str
+            The string identifier 'x-orionis.services.log.log_service' used as the
+            binding key to resolve the console service from the service container.
+        """
+
+        # Return the predefined binding key for the console output service
+        return "x-orionis.services.log.log_service"

{orionis-0.481.0.dist-info → orionis-0.483.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.481.0
+Version: 0.483.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.dist-info → orionis-0.483.0.dist-info}/RECORD

@@ -14,7 +14,8 @@ orionis/console/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 orionis/console/commands/cache.py,sha256=8DsYoRzSBLn0P9qkGVItRbo0R6snWBDBg0_Xa7tmVhs,2322
 orionis/console/commands/help.py,sha256=ooPoenP08ArMAWiL89_oUGD9l1Faen2QjLTG90i4zCQ,3187
 orionis/console/commands/publisher.py,sha256=FUg-EUzK7LLXsla10ZUZro8V0Z5S-KjmsaSdRHSSGbA,21381
-orionis/console/commands/scheduler_work.py,sha256=768TntiL2dguqJ2BlMVR7zEx_xlE71CCDsZ57ZXu9As,3573
+orionis/console/commands/scheduler_list.py,sha256=SXaD1XJFV1bbyjlDuQhlHz2y1kW-VVCxQxuKJMtQRtA,5956
+orionis/console/commands/scheduler_work.py,sha256=cymbGHaLmwv2WtEenZTtm7iNVfs8gG8_oWXU18Jtzd0,5746
 orionis/console/commands/test.py,sha256=_Tb-I9vabiqhqGeLfRbV5Y1LEVCdhZhBAwoEQZCzQuM,2435
 orionis/console/commands/version.py,sha256=SUuNDJ40f2uq69OQUmPQXJKaa9Bm_iVRDPmBd7zc1Yc,3658
 orionis/console/commands/workflow.py,sha256=NYOmjTSvm2o6AE4h9LSTZMFSYPQreNmEJtronyOxaYk,2451
@@ -24,7 +25,7 @@ orionis/console/contracts/kernel.py,sha256=mh4LlhEYHh3FuGZZQ0GBhD6ZLa5YQvaNj2r01
 orionis/console/contracts/reactor.py,sha256=Xeq7Zrw6WE5MV_XOQfiQEchAFbb6-0TjLpjWOxYW--g,4554
 orionis/console/contracts/schedule.py,sha256=eGjcOH7kgdf0fWDZRfOFUQsIx4E8G38ayX5JwpkpN8E,4977
 orionis/console/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/core/reactor.py,sha256=v_y3LDydBeKmtCfA0rIi8Nicy38DEfflp_zwx2OM7NQ,30257
+orionis/console/core/reactor.py,sha256=XE4VvUPnOSQ_qmkLMYEDfwKaqDZyFxCiVtoSJVqpk_M,30372
 orionis/console/dumper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/dumper/dump.py,sha256=CATERiQ6XuIrKQsDaWcVxzTtlAJI9qLJX44fQxEX8ws,22443
 orionis/console/dumper/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -199,7 +200,7 @@ orionis/foundation/providers/scheduler_provider.py,sha256=72SoixFog9IOE9Ve9Xcfw6
 orionis/foundation/providers/testing_provider.py,sha256=SrJRpdvcblx9WvX7x9Y3zc7OQfiTf7la0HAJrm2ESlE,3725
 orionis/foundation/providers/workers_provider.py,sha256=oa_2NIDH6UxZrtuGkkoo_zEoNIMGgJ46vg5CCgAm7wI,3926
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=2WrjUXc9K8IXUNZ9LsjyebMtSH23bttsYzs91v36bto,4109
+orionis/metadata/framework.py,sha256=Omguwj98GlVjFh8nCMjYoLHSqVMJ57Duo0GXurO-QLk,4109
 orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -270,15 +271,15 @@ orionis/services/introspection/modules/contracts/reflection.py,sha256=YLqKg5Ehad
 orionis/services/introspection/objects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/objects/types.py,sha256=vNKWc2b7K-X7B2X8RCimgAWQqbQlVT-aL24nUB8t_yQ,6343
 orionis/services/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/log/log_service.py,sha256=PY8a7DB-kCOlwtG85J_ASQIPRw0_aRGBiqlyQho0Gxw,11316
+orionis/services/log/log_service.py,sha256=y1ysxZ7MuO2NuJXGnPVp1xXsJf6TVkOiMdd-ZvgbwQI,11620
 orionis/services/log/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/log/contracts/log_service.py,sha256=YVWkK5z6-3jyJv6aT8fbp53nQBF8jlD-aHGKqFYPdAM,1692
 orionis/services/log/exceptions/__init__.py,sha256=PPn_LBV3U-0Yi69ZLDQmlkbmlL1iLTleLw-s88Ipg9o,84
 orionis/services/log/exceptions/runtime.py,sha256=LnaK0w0WlgxtZ9Zjn9RYIgp6fbQZmXZ_1fy9dkuA2jQ,468
 orionis/services/log/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/log/handlers/filename.py,sha256=XKkq4Gq7N2m8F3xtyUIevTQLMaYSLJ3wC04Irs45VcE,2481
-orionis/services/log/handlers/size_rotating.py,sha256=SLg7r-XW1NWyVxN8wJxeI8jhypzdXw_jq2zg5uy3iaQ,1131
-orionis/services/log/handlers/timed_rotating.py,sha256=UJicPwHcIVl2FPRPjuiKwH3-zuiPG1YV7UYLLMPm4To,1128
+orionis/services/log/handlers/filename.py,sha256=722mnk075vvq02MtpKaDWzLHEUd3sQyhL0a6xd0vLeA,20122
+orionis/services/log/handlers/size_rotating.py,sha256=O0rE2LkS4nfjsOjcOXL0aG1csOuK2RKGeRdBlYJ6qTs,1333
+orionis/services/log/handlers/timed_rotating.py,sha256=XM72DFwKcE0AU4oiCvhy2FXxteZ7HtxpGaxisv504nY,1317
 orionis/services/system/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/system/imports.py,sha256=aSXG9879ur91d6OsqV2DUYWmmwbwFHX8CHb99cPfFcU,7057
 orionis/services/system/workers.py,sha256=EfGxU_w42xRnZ1yslsui3wVG8pfe__V3GYGEIyo8JxQ,3144
@@ -291,6 +292,7 @@ orionis/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/support/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/support/entities/base.py,sha256=kVx9YWZjYS6C9MraarU7U12OeT5enBp5XqizrQm4RQs,4801
 orionis/support/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/support/facades/application.py,sha256=GxB6TzsCSyDEHlvJJr-WVrppJvuolXCcV1vZ0tq_H6E,883
 orionis/support/facades/console.py,sha256=Yhpgv0FpwyOXP4IMgTtDw0_nkcu-J_9nhZRPwJCetCg,875
 orionis/support/facades/dumper.py,sha256=qQPoMbkXExv6UaByoDCyJA-gt5SA1oQtym2TwpihtoI,794
 orionis/support/facades/executor.py,sha256=fRBQ447WpL2T42Ys02k_DJNqukFFk8-bbNFz4GEbRfI,931
@@ -370,7 +372,7 @@ orionis/test/validators/web_report.py,sha256=n9BfzOZz6aEiNTypXcwuWbFRG0OdHNSmCNu
 orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnIfJYgc,1206
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=f-zNhtKSg9R5Njqujbg2l2amAs2-mRVESneLIkWOZjU,4082
-orionis-0.481.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.483.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -517,8 +519,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=WPo5GxTP6xE-Dw3X1vZoqOMpb6HhokjNSbgDsDRDvy4,16588
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=tnnMBwS0iKUIbogLvu-7Rii50G6Koddp3XT4wgdFEYM,1050
-orionis-0.481.0.dist-info/METADATA,sha256=7qzA9IFx_3LhMmuAN45WaCaPhPy_zMtKF-4s5BvyU3c,4801
-orionis-0.481.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.481.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.481.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.481.0.dist-info/RECORD,,
+orionis-0.483.0.dist-info/METADATA,sha256=3XeBNGAmPP22h8aO4LHXJ9ynNTdYmmYjWQzrzLe5KhA,4801
+orionis-0.483.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.483.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.483.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.483.0.dist-info/RECORD,,