orionis 0.401.0__py3-none-any.whl → 0.402.0__py3-none-any.whl

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

@@ -1,10 +1,12 @@
-from dataclasses import asdict, dataclass, field, fields
-from datetime import time
+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:
+class Daily(BaseConfigEntity):
     """
     Represents the configuration for daily log file rotation.
 
@@ -16,34 +18,34 @@ class Daily:
     """
 
     path: str = field(
-        default='storage/log/application.log',
-        metadata={
+        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., 'info', 'error', 'debug').",
+        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={
+        default = 7,
+        metadata = {
             "description": "The number of days to retain log files before deletion.",
             "default": 7,
         },
     )
 
-    at: time = field(
-        default=time(0, 0),
+    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),
+            "default": time(0, 0).strftime("%H:%M"),
         },
     )
 
@@ -54,82 +56,42 @@ class Daily:
         Raises:
             OrionisIntegrityException: If any attribute is invalid.
         """
-        # Validate 'path'
-        if not isinstance(self.path, str) or not self.path.strip():
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'path' must be a non-empty string, got {repr(self.path)}."
-            )
 
-        # Validate 'level'
-        valid_level_types = (int, str, Level)
-        if not isinstance(self.level, valid_level_types):
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'level' must be int, str, or Level enum, got {type(self.level).__name__}."
-            )
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
 
-        # Normalize 'level' to int
-        if isinstance(self.level, str):
-            _value = self.level.strip().upper()
-            if not _value:
-                raise OrionisIntegrityException(
-                    "File cache configuration error: 'level' string cannot be empty."
-                )
-            if _value not in Level.__members__:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {list(Level.__members__.keys())}, got '{self.level}'."
-                )
-            self.level = Level[_value].value
-        elif isinstance(self.level, int):
-            valid_values = [level.value for level in Level]
-            if self.level not in valid_values:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {valid_values}, got '{self.level}'."
-                )
-        elif isinstance(self.level, Level):
-            self.level = self.level.value
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
 
         # Validate 'retention_days'
-        if not isinstance(self.retention_days, int) or self.retention_days < 1 or self.retention_days > 90:
+        if not isinstance(self.retention_days, int):
             raise OrionisIntegrityException(
-                f"File cache configuration error: 'retention_days' must be a positive integer between 1 and 90, got {repr(self.retention_days)}."
+                f"'retention_days' must be an integer, got {type(self.retention_days).__name__}."
             )
-
-        # Validate 'at'
-        if not isinstance(self.at, time):
+        if not (1 <= self.retention_days <= 90):
             raise OrionisIntegrityException(
-                f"File cache configuration error: 'at' must be a datetime.time instance, got {type(self.at).__name__}."
+                f"'retention_days' must be between 1 and 90, got {self.retention_days}."
             )
 
-        # Convert 'at' to "HH:MM:SS" string format
-        self.at = self.at.strftime("%H:%M:%S")
-
-    def toDict(self) -> dict:
-        """
-        Converts the Daily object to a dictionary representation.
-
-        Returns:
-            dict: A dictionary containing the dataclass fields and their values.
-        """
-        return asdict(self)
+        # 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__}."
+            )
 
-    def getFields(self):
-        """
-        Retrieves a list of field information for the current dataclass instance.
+        # 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__}."
+            )
 
-        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.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+        # Normalize 'at' to "HH:MM" format
+        self.at = self.at.strftime("%H:%M")

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

@@ -1,9 +1,11 @@
-from dataclasses import asdict, dataclass, field, fields
+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:
+class Hourly(BaseConfigEntity):
     """
     Represents the configuration for hourly log file management.
 
@@ -14,24 +16,24 @@ class Hourly:
     """
 
     path: str = field(
-        default='storage/log/application.log',
-        metadata={
+        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., 'info', 'error', 'debug').",
+        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={
+        default = 24,
+        metadata = {
             "description": "The number of hours to retain log files before deletion.",
             "default": 24,
         },
@@ -47,38 +49,12 @@ class Hourly:
                 - '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'
-        if not isinstance(self.path, str) or not self.path.strip():
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'path' must be a non-empty string, got {repr(self.path)}."
-            )
 
-        # Validate 'level'
-        valid_level_types = (int, str, Level)
-        if not isinstance(self.level, valid_level_types):
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'level' must be int, str, or Level enum, got {type(self.level).__name__}."
-            )
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
 
-        if isinstance(self.level, str):
-            _value = self.level.strip().upper()
-            if not _value:
-                raise OrionisIntegrityException(
-                    "File cache configuration error: 'level' string cannot be empty."
-                )
-            if _value not in Level.__members__:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {list(Level.__members__.keys())}, got '{self.level}'."
-                )
-            self.level = Level[_value].value
-        elif isinstance(self.level, int):
-            valid_values = [level.value for level in Level]
-            if self.level not in valid_values:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {valid_values}, got '{self.level}'."
-                )
-        elif isinstance(self.level, Level):
-            self.level = self.level.value
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
 
         # Validate 'retention_hours'
         if not isinstance(self.retention_hours, int) or self.retention_hours < 0:
@@ -88,35 +64,4 @@ class Hourly:
         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}."
-            )
-
-    def toDict(self) -> dict:
-        """
-        Converts the Hourly object to a dictionary representation.
-
-        Returns:
-            dict: A dictionary containing all the dataclass fields and their values.
-        """
-        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.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+            )

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

@@ -1,9 +1,10 @@
-from dataclasses import dataclass, field, asdict, fields
+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:
+class Logging(BaseConfigEntity):
     """
     Represents the logging system configuration.
 
@@ -18,21 +19,39 @@ class Logging:
         default="stack",
         metadata={
             "description": "The default logging channel to use.",
-            "default": "stack",
+            "default": "stack"
         }
     )
-    channels: Channels = field(
-        default_factory=Channels,
+
+    channels: Channels | dict = field(
+        default_factory = lambda: Channels(),
         metadata={
             "description": "A collection of available logging channels.",
-            "default": "Channels()",
+            "default": lambda: Channels().toDict()
         }
     )
 
     def __post_init__(self):
         """
-        Validates the types of the attributes after initialization.
+        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(
@@ -40,34 +59,14 @@ class Logging:
             )
 
         if not isinstance(self.channels, Channels):
-            raise OrionisIntegrityException(
-                "The 'channels' property must be an instance of Channels."
-            )
-
-    def toDict(self) -> dict:
-        """
-        Converts the current instance into a dictionary representation.
-        """
-        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.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+            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."
+                )

orionis/foundation/config/logging/entities/monthly.py

@@ -1,9 +1,11 @@
-from dataclasses import asdict, dataclass, field, fields
+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 Monthly:
+class Monthly(BaseConfigEntity):
     """
     Configuration entity for monthly log file management.
 
@@ -14,23 +16,23 @@ class Monthly:
     """
 
     path: str = field(
-        default='storage/log/application.log',
-        metadata={
+        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., 'info', 'error', 'debug').",
+        default = Level.INFO,
+        metadata = {
+            "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
             "default": Level.INFO,
         },
     )
 
     retention_months: int = field(
-        default=4,
+        default = 4,
         metadata={
             "description": "The number of months to retain log files before deletion.",
             "default": 4,
@@ -47,76 +49,18 @@ class Monthly:
                 - 'level' must be an int, str, or Level enum, and a valid logging level.
                 - 'retention_months' must be an integer between 1 and 12 (inclusive).
         """
-        # Validate 'path'
-        if not isinstance(self.path, str) or not self.path.strip():
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'path' must be a non-empty string, got {repr(self.path)}."
-            )
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
 
-        # Validate 'level'
-        valid_level_types = (int, str, Level)
-        if not isinstance(self.level, valid_level_types):
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'level' must be int, str, or Level enum, got {type(self.level).__name__}."
-            )
-
-        if isinstance(self.level, str):
-            _value = self.level.strip().upper()
-            if not _value:
-                raise OrionisIntegrityException(
-                    "File cache configuration error: 'level' string cannot be empty."
-                )
-            if _value not in Level.__members__:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {list(Level.__members__.keys())}, got '{self.level}'."
-                )
-            self.level = Level[_value].value
-        elif isinstance(self.level, int):
-            valid_values = [level.value for level in Level]
-            if self.level not in valid_values:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {valid_values}, got '{self.level}'."
-                )
-        elif isinstance(self.level, Level):
-            self.level = self.level.value
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)
 
         # Validate 'retention_months'
-        if not isinstance(self.retention_months, int) or self.retention_months < 0:
+        if not isinstance(self.retention_months, int):
             raise OrionisIntegrityException(
-                f"File cache configuration error: 'retention_months' must be a non-negative integer, got {self.retention_months}."
+                f"Invalid type for 'retention_months': expected int, got {type(self.retention_months).__name__}."
             )
-        if self.retention_months < 1 or self.retention_months > 12:
+        if not (1 <= self.retention_months <= 12):
             raise OrionisIntegrityException(
-                f"File cache configuration error: 'retention_months' must be between 1 and 12, got {self.retention_months}."
-            )
-
-    def toDict(self) -> dict:
-        """
-        Converts the Monthly object to a dictionary representation.
-
-        Returns:
-            dict: A dictionary containing all dataclass fields and their values.
-        """
-        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.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+                f"'retention_months' must be an integer between 1 and 12 (inclusive), got {self.retention_months}."
+            )

orionis/foundation/config/logging/entities/stack.py

@@ -1,25 +1,26 @@
-from dataclasses import asdict, dataclass, field, fields
-from orionis.foundation.exceptions import OrionisIntegrityException
+from dataclasses import dataclass, field
+from orionis.foundation.config.base import BaseConfigEntity
+from orionis.foundation.config.logging.validators import IsValidLevel, IsValidPath
 from orionis.foundation.config.logging.enums import Level
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Stack:
+class Stack(BaseConfigEntity):
     """
     Represents the configuration for a logging stack, including the log file path and logging level.
     """
 
     path: str = field(
-        default='storage/log/application.log',
-        metadata={
+        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., 'info', 'error', 'debug').",
+        default = Level.INFO,
+        metadata = {
+            "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
             "default": Level.INFO,
         },
     )
@@ -31,66 +32,9 @@ class Stack:
         Raises:
             OrionisIntegrityException: If 'path' is not a non-empty string, or if 'level' is not a valid type or value.
         """
-        # Validate 'path'
-        if not isinstance(self.path, str) or not self.path.strip():
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'path' must be a non-empty string, got {repr(self.path)}."
-            )
 
-        # Validate 'level'
-        valid_level_types = (int, str, Level)
-        if not isinstance(self.level, valid_level_types):
-            raise OrionisIntegrityException(
-                f"File cache configuration error: 'level' must be int, str, or Level enum, got {type(self.level).__name__}."
-            )
+        # Validate 'path' using the IsValidPath validator
+        IsValidPath(self.path)
 
-        if isinstance(self.level, str):
-            _value = self.level.strip().upper()
-            if not _value:
-                raise OrionisIntegrityException(
-                    "File cache configuration error: 'level' string cannot be empty."
-                )
-            if _value not in Level.__members__:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {list(Level.__members__.keys())}, got '{self.level}'."
-                )
-            self.level = Level[_value].value
-        elif isinstance(self.level, int):
-            valid_values = [level.value for level in Level]
-            if self.level not in valid_values:
-                raise OrionisIntegrityException(
-                    f"File cache configuration error: 'level' must be one of {valid_values}, got '{self.level}'."
-                )
-        elif isinstance(self.level, Level):
-            self.level = self.level.value
-
-    def toDict(self) -> dict:
-        """
-        Converts the Stack instance to a dictionary representation.
-
-        Returns:
-            dict: A dictionary containing all fields of the Stack 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.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+        # Validate 'level' using the IsValidLevel validator
+        IsValidLevel(self.level)