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

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.481.0"
+VERSION = "0.482.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.482.0.dist-info}/METADATA

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

@@ -199,7 +199,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=_5YbwWTtix0nrC_iOD_3NIidY-aj0jZHYz4I8YgV7ME,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 +270,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 +291,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 +371,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.482.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 +518,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.482.0.dist-info/METADATA,sha256=G2omW6axkClb2bZufamTZKGAw4zPQPxlI-QGmAzf_VE,4801
+orionis-0.482.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.482.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.482.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.482.0.dist-info/RECORD,,