orionis 0.401.0__tar.gz → 0.403.0__tar.gz

{orionis-0.401.0/orionis.egg-info → orionis-0.403.0}/PKG-INFO

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

{orionis-0.401.0 → orionis-0.403.0}/orionis/container/providers/service_provider.py

@@ -1,5 +1,5 @@
-from orionis.container.contracts.container import IContainer
 from orionis.container.contracts.service_provider import IServiceProvider
+from orionis.foundation.contracts.application import IApplication
 
 class ServiceProvider(IServiceProvider):
     """
@@ -11,7 +11,7 @@ class ServiceProvider(IServiceProvider):
 
     Parameters
     ----------
-    app : IContainer
+    app : IApplication
         The application container instance to which services will be registered.
 
     Notes
@@ -20,13 +20,13 @@ class ServiceProvider(IServiceProvider):
     the `register` method at minimum.
     """
 
-    def __init__(self, app: IContainer) -> None:
+    def __init__(self, app: IApplication) -> None:
         """
         Initialize the service provider with the application container.
 
         Parameters
         ----------
-        app : IContainer
+        app : IApplication
             The application container instance.
         """
         self.app = app

{orionis-0.401.0 → orionis-0.403.0}/orionis/foundation/application.py

@@ -18,6 +18,7 @@ from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.foundation.contracts.application import IApplication
 from orionis.foundation.contracts.config import IConfig
 from orionis.foundation.exceptions import OrionisTypeError, OrionisRuntimeError
+from orionis.foundation.providers.logger_provider import LoggerProvider
 
 class Application(Container, IApplication):
     """
@@ -116,7 +117,8 @@ class Application(Container, IApplication):
             DumperProvider,
             PathResolverProvider,
             ProgressBarProvider,
-            WorkersProvider
+            WorkersProvider,
+            LoggerProvider
         ]
 
         # Register each core provider
@@ -1031,7 +1033,7 @@ class Application(Container, IApplication):
         """
 
         # Ensure the application is booted before accessing configuration
-        if not self.__booted:
+        if not self.__config:
             raise RuntimeError("Application must be booted before accessing configuration. Call create() first.")
 
         # If key is None, raise an error to prevent ambiguity

orionis-0.403.0/orionis/foundation/config/base.py

@@ -0,0 +1,112 @@
+from dataclasses import asdict, fields
+from dataclasses import MISSING
+
+class BaseConfigEntity:
+
+    def toDict(self) -> dict:
+        """
+        Converts the current instance into a dictionary representation.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the current instance.
+        """
+        return asdict(self)
+
+    def getFields(self):
+        """
+        Retrieves a list of field information for the current dataclass instance.
+
+        Returns
+        -------
+        list
+            A list of dictionaries, each containing details about a field:
+            - name (str): The name of the field.
+            - type (type): The type of the field.
+            - default: The default value of the field, if specified; otherwise, the value from metadata or None.
+            - metadata (mapping): The metadata associated with the field.
+        """
+        # Dictionary to hold field information
+        __fields = []
+
+        # Iterate over the fields of the dataclass
+        # and extract relevant information
+        for field in fields(self):
+
+            # Get the field name
+            __name = field.name
+
+            # Get the field type with better handling for complex types
+            __type = getattr(field.type, '__name__', None)
+
+            # If the type is None, handle it
+            if __type is None:
+
+                # Handle generic types, unions, and other complex annotations
+                type_str = str(field.type)
+
+                # Clean up typing module references
+                type_str = type_str.replace('typing.', '')
+
+                # Handle Union types (e.g., "Channels | dict" or "Union[Channels, dict]")
+                if '|' in type_str or 'Union[' in type_str:
+
+                    # Extract individual types from Union
+                    if 'Union[' in type_str:
+
+                        # Handle typing.Union format
+                        inner = type_str.replace('Union[', '').replace(']', '')
+                        types = [t.strip() for t in inner.split(',')]
+
+                    else:
+                        # Handle | format (Python 3.10+)
+                        types = [t.strip() for t in type_str.split('|')]
+
+                    # Get class names for custom types
+                    clean_types = []
+                    for t in types:
+                        if '.' in t:
+                            clean_types.append(t.split('.')[-1])
+                        else:
+                            clean_types.append(t)
+
+                    # Join cleaned types with ' | '
+                    __type = ' | '.join(clean_types)
+
+                else:
+
+                    # Handle other complex types
+                    if '.' in type_str:
+                        __type = type_str.split('.')[-1]
+                    else:
+                        __type = type_str
+
+            # Extract metadata, default value, and type
+            __metadata = dict(field.metadata) or {}
+
+            # Extract the default value, if specified
+            __default = None
+
+            # Field has a direct default value
+            if field.default is not MISSING:
+                __default = field.default
+
+            # Field has a default factory (like list, dict, etc.)
+            elif field.default_factory is not MISSING:
+                __default = f"<factory: {field.default_factory.__name__}>"
+
+            # No default found, check metadata for custom default
+            else:
+                __default = __metadata.get('default', None)
+
+            # Append the field information to the list
+            __fields.append({
+                "name": __name,
+                "type": __type,
+                "default": __default,
+                "metadata": __metadata
+            })
+
+        # Return the list of field information
+        return __fields

orionis-0.403.0/orionis/foundation/config/logging/entities/channels.py

@@ -0,0 +1,155 @@
+from dataclasses import dataclass, field
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.entities.monthly import Monthly
+from orionis.foundation.config.logging.entities.chunked import Chunked
+from orionis.foundation.config.logging.entities.daily import Daily
+from orionis.foundation.config.logging.entities.hourly import Hourly
+from orionis.foundation.config.logging.entities.stack import Stack
+from orionis.foundation.config.logging.entities.weekly import Weekly
+from orionis.foundation.exceptions import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Channels(BaseConfigEntity):
+    """
+    Represents the different logging channels available.
+    """
+
+    stack: Stack | dict = field(
+        default_factory = lambda: Stack(),
+        metadata={
+            "description": "Configuration for stack log channel.",
+            "default": lambda : Stack().toDict()
+        }
+    )
+
+    hourly: Hourly | dict = field(
+        default_factory = lambda: Hourly(),
+        metadata={
+            "description": "Configuration for hourly log rotation.",
+            "default": lambda: Hourly().toDict()
+        }
+    )
+
+    daily: Daily | dict = field(
+        default_factory = lambda: Daily(),
+        metadata={
+            "description": "Configuration for daily log rotation.",
+            "default": lambda: Daily().toDict()
+        }
+    )
+
+    weekly: Weekly | dict = field(
+        default_factory = lambda: Weekly(),
+        metadata={
+            "description": "Configuration for weekly log rotation.",
+            "default": lambda: Weekly().toDict()
+        }
+    )
+
+    monthly: Monthly | dict= field(
+        default_factory = lambda: Monthly(),
+        metadata={
+            "description": "Configuration for monthly log rotation.",
+            "default": lambda: Monthly().toDict()
+        }
+    )
+
+    chunked: Chunked | dict = field(
+        default_factory = lambda: Chunked(),
+        metadata={
+            "description": "Configuration for chunked log file storage.",
+            "default": lambda: Chunked().toDict()
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to validate the types of log rotation properties.
+        Ensures that the following instance attributes are of the correct types:
+        - `stack` must be an instance of `Stack`
+        - `hourly` must be an instance of `Hourly`
+        - `daily` must be an instance of `Daily`
+        - `weekly` must be an instance of `Weekly`
+        - `monthly` must be an instance of `Monthly`
+        - `chunked` must be an instance of `Chunked`
+        Raises:
+            OrionisIntegrityException: If any of the properties are not instances of their expected classes.
+        """
+
+        if not isinstance(self.stack, Stack):
+            if isinstance(self.stack, dict):
+                try:
+                    self.stack = Stack(**self.stack)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid stack configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'stack' property must be an instance of Stack or a dictionary."
+                )
+
+        if not isinstance(self.hourly, Hourly):
+            if isinstance(self.hourly, dict):
+                try:
+                    self.hourly = Hourly(**self.hourly)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid hourly configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'hourly' property must be an instance of Hourly or a dictionary."
+                )
+
+        if not isinstance(self.daily, Daily):
+            if isinstance(self.daily, dict):
+                try:
+                    self.daily = Daily(**self.daily)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid daily configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'daily' property must be an instance of Daily or a dictionary."
+                )
+
+        if not isinstance(self.weekly, Weekly):
+            if isinstance(self.weekly, dict):
+                try:
+                    self.weekly = Weekly(**self.weekly)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid weekly configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'weekly' property must be an instance of Weekly or a dictionary."
+                )
+
+        if not isinstance(self.monthly, Monthly):
+            if isinstance(self.monthly, dict):
+                try:
+                    self.monthly = Monthly(**self.monthly)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid monthly configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'monthly' property must be an instance of Monthly or a dictionary."
+                )
+
+        if not isinstance(self.chunked, Chunked):
+            if isinstance(self.chunked, dict):
+                try:
+                    self.chunked = Chunked(**self.chunked)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid chunked configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'chunked' property must be an instance of Chunked or a dictionary."
+                )

orionis-0.403.0/orionis/foundation/config/logging/entities/chunked.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass, field
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.validators import IsValidPath, IsValidLevel
+from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.foundation.config.logging.enums import Level
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Chunked(BaseConfigEntity):
+    """
+    Configuration for chunked log file rotation.
+
+    This class defines the configuration for managing log files by splitting them into chunks
+    based on file size and limiting the number of retained log files. This prevents log files
+    from growing indefinitely and helps manage disk usage.
+
+    Attributes
+    ----------
+    path : str
+        Filesystem path where chunked log files are stored.
+    level : int | str | Level
+        Logging level for the log file. Accepts an integer, string, or Level enum.
+    mb_size : int
+        Maximum size (in megabytes) of a single log file before a new chunk is created.
+    files : int
+        Maximum number of log files to retain. Older files are deleted when this limit is exceeded.
+    """
+
+    path: str = field(
+        default = 'storage/log/application.log',
+        metadata = {
+            "description": "The file path where the log is stored.",
+            "default": "storage/log/application.log",
+        },
+    )
+
+    level: int | str | Level = field(
+        default = Level.INFO,
+        metadata = {
+            "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
+            "default": Level.INFO,
+        },
+    )
+
+    mb_size: int = field(
+        default = 10,
+        metadata={
+            "description": "Maximum size (in MB) of a log file before chunking.",
+            "default": 10,
+        },
+    )
+
+    files: int = field(
+        default = 5,
+        metadata={
+            "description": "Maximum number of log files to retain.",
+            "default": 5,
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Performs validation and normalization of configuration fields.
+
+        - path: Validates that the path is correct using the IsValidPath validator.
+        - level: Validates that the log level is correct using the IsValidLevel validator.
+        - mb_size: Checks that it is an integer between 1 and 1000 (MB).
+        - files: Checks that it is a positive integer greater than 0.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If any of the configuration values are invalid.
+        """
+
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
+
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
+
+        # Validate 'mb_size'
+        if not isinstance(self.mb_size, int):
+            raise OrionisIntegrityException(
+                f"'mb_size' must be an integer in MB, got {type(self.mb_size).__name__}."
+            )
+        if self.mb_size < 1 or self.mb_size > 1000:
+            raise OrionisIntegrityException(
+                f"'mb_size' must be between 1 and 1000 MB, got {self.mb_size}."
+            )
+
+        # Validate 'files'
+        if not isinstance(self.files, int) or self.files < 1:
+            raise OrionisIntegrityException(
+                f"'files' must be a positive integer greater than 0, got {self.files} ({type(self.files).__name__})."
+            )

orionis-0.403.0/orionis/foundation/config/logging/entities/daily.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from datetime import datetime, time
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.validators import IsValidPath, IsValidLevel
+from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.foundation.config.logging.enums import Level
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Daily(BaseConfigEntity):
+    """
+    Represents the configuration for daily log file rotation.
+
+    Attributes:
+        path (str): The file path where the log is stored.
+        level (int | str | Level): The logging level (e.g., 'info', 'error', 'debug').
+        retention_days (int): The number of days to retain log files before deletion.
+        at (time): The time of day when the log rotation should occur.
+    """
+
+    path: str = field(
+        default = 'storage/log/application.log',
+        metadata = {
+            "description": "The file path where the log is stored.",
+            "default": "storage/log/application.log",
+        },
+    )
+
+    level: int | str | Level = field(
+        default = Level.INFO,
+        metadata = {
+            "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
+            "default": Level.INFO,
+        },
+    )
+
+    retention_days: int = field(
+        default = 7,
+        metadata = {
+            "description": "The number of days to retain log files before deletion.",
+            "default": 7,
+        },
+    )
+
+    at: time | str = field(
+        default = time(0, 0).strftime("%H:%M"),
+        metadata={
+            "description": "The time of day when the log rotation should occur.",
+            "default": time(0, 0).strftime("%H:%M"),
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Validates and normalizes the attributes after dataclass initialization.
+
+        Raises:
+            OrionisIntegrityException: If any attribute is invalid.
+        """
+
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
+
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
+
+        # Validate 'retention_days'
+        if not isinstance(self.retention_days, int):
+            raise OrionisIntegrityException(
+                f"'retention_days' must be an integer, got {type(self.retention_days).__name__}."
+            )
+        if not (1 <= self.retention_days <= 90):
+            raise OrionisIntegrityException(
+                f"'retention_days' must be between 1 and 90, got {self.retention_days}."
+            )
+
+        # Validate 'at' must be a time instance or a valid "HH:MM" string
+        if not isinstance(self.at, (time, str)):
+            raise OrionisIntegrityException(
+                f"'at' must be a datetime.time instance or a 'HH:MM' string, got {type(self.at).__name__}."
+            )
+
+        # Validate and normalize 'at'
+        if isinstance(self.at, str):
+            try:
+                parsed_time = datetime.strptime(self.at, "%H:%M").time()
+                self.at = parsed_time
+            except ValueError:
+                raise OrionisIntegrityException(
+                    f"'at' must be a valid time string in 'HH:MM' format, got '{self.at}'."
+                )
+        elif not isinstance(self.at, time):
+            raise OrionisIntegrityException(
+                f"'at' must be a datetime.time instance or a 'HH:MM' string, got {type(self.at).__name__}."
+            )
+
+        # Normalize 'at' to "HH:MM" format
+        self.at = self.at.strftime("%H:%M")

orionis-0.403.0/orionis/foundation/config/logging/entities/hourly.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.validators import IsValidLevel, IsValidPath
+from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.foundation.config.logging.enums import Level
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Hourly(BaseConfigEntity):
+    """
+    Represents the configuration for hourly log file management.
+
+    Attributes:
+        path (str): The file path where the log is stored.
+        level (int | str | Level): The logging level (e.g., 'info', 'error', 'debug').
+        retention_hours (int): The number of hours to retain log files before deletion.
+    """
+
+    path: str = field(
+        default = 'storage/log/application.log',
+        metadata = {
+            "description": "The file path where the log is stored.",
+            "default": "storage/log/application.log",
+        },
+    )
+
+    level: int | str | Level = field(
+        default = Level.INFO,
+        metadata = {
+            "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
+            "default": Level.INFO,
+        },
+    )
+
+    retention_hours: int = field(
+        default = 24,
+        metadata = {
+            "description": "The number of hours to retain log files before deletion.",
+            "default": 24,
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Validates the attributes after dataclass initialization.
+
+        Raises:
+            OrionisIntegrityException: If any attribute is invalid.
+                - 'path' must be a non-empty string.
+                - 'level' must be an int, str, or Level enum, and a valid value.
+                - 'retention_hours' must be an integer between 1 and 168.
+        """
+
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
+
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
+
+        # Validate 'retention_hours'
+        if not isinstance(self.retention_hours, int) or self.retention_hours < 0:
+            raise OrionisIntegrityException(
+                f"File cache configuration error: 'retention_hours' must be a non-negative integer, got {self.retention_hours}."
+            )
+        if self.retention_hours < 1 or self.retention_hours > 168:
+            raise OrionisIntegrityException(
+                f"File cache configuration error: 'retention_hours' must be between 1 and 168, got {self.retention_hours}."
+            )

orionis-0.403.0/orionis/foundation/config/logging/entities/logging.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, field, fields
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.entities.channels import Channels
+from orionis.foundation.exceptions import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Logging(BaseConfigEntity):
+    """
+    Represents the logging system configuration.
+
+    Attributes
+    ----------
+    default : str
+        The default logging channel to use.
+    channels : Channels
+        A collection of available logging channels.
+    """
+    default: str = field(
+        default="stack",
+        metadata={
+            "description": "The default logging channel to use.",
+            "default": "stack"
+        }
+    )
+
+    channels: Channels | dict = field(
+        default_factory = lambda: Channels(),
+        metadata={
+            "description": "A collection of available logging channels.",
+            "default": lambda: Channels().toDict()
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the logging configuration after dataclass initialization by ensuring
+        the default channel and channels configuration are properly formatted and valid.
+        Parameters
+        ----------
+        None
+        Raises
+        ------
+        OrionisIntegrityException
+            If the default channel is not a string or doesn't match available channel options.
+        OrionisIntegrityException
+            If the channels configuration is malformed or cannot be converted to a Channels instance.
+        OrionisIntegrityException
+            If the channels property is not a Channels instance or a dictionary.
+        Notes
+        -----
+        This method performs the following validations:
+        - Ensures 'default' is a string matching available channel options from Channels fields
+        """
+
+        options = [field.name for field in fields(Channels)]
+        if not isinstance(self.default, str) or self.default not in options:
+            raise OrionisIntegrityException(
+                f"The 'default' property must be a string and match one of the available options ({options})."
+            )
+
+        if not isinstance(self.channels, Channels):
+            if isinstance(self.channels, dict):
+                try:
+                    self.channels = Channels(**self.channels)
+                except TypeError as e:
+                    raise OrionisIntegrityException(
+                        f"Invalid channels configuration: {e}"
+                    )
+            else:
+                raise OrionisIntegrityException(
+                    "The 'channels' property must be an instance of Channels or a dictionary."
+                )