orionis 0.404.0__py3-none-any.whl → 0.406.0__py3-none-any.whl

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

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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
@@ -9,56 +9,56 @@ 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):
+class Channels(BaseEntity):
     """
     Represents the different logging channels available.
     """
 
     stack: Stack | dict = field(
         default_factory = lambda: Stack(),
-        metadata={
+        metadata = {
             "description": "Configuration for stack log channel.",
-            "default": lambda : Stack().toDict()
+            "default": Stack().toDict()
         }
     )
 
     hourly: Hourly | dict = field(
         default_factory = lambda: Hourly(),
-        metadata={
+        metadata = {
             "description": "Configuration for hourly log rotation.",
-            "default": lambda: Hourly().toDict()
+            "default": Hourly().toDict()
         }
     )
 
     daily: Daily | dict = field(
         default_factory = lambda: Daily(),
-        metadata={
+        metadata = {
             "description": "Configuration for daily log rotation.",
-            "default": lambda: Daily().toDict()
+            "default": Daily().toDict()
         }
     )
 
     weekly: Weekly | dict = field(
         default_factory = lambda: Weekly(),
-        metadata={
+        metadata = {
             "description": "Configuration for weekly log rotation.",
-            "default": lambda: Weekly().toDict()
+            "default": Weekly().toDict()
         }
     )
 
     monthly: Monthly | dict= field(
         default_factory = lambda: Monthly(),
-        metadata={
+        metadata = {
             "description": "Configuration for monthly log rotation.",
-            "default": lambda: Monthly().toDict()
+            "default": Monthly().toDict()
         }
     )
 
     chunked: Chunked | dict = field(
         default_factory = lambda: Chunked(),
-        metadata={
+        metadata = {
             "description": "Configuration for chunked log file storage.",
-            "default": lambda: Chunked().toDict()
+            "default": Chunked().toDict()
         }
     )
 
@@ -76,80 +76,50 @@ class Channels(BaseConfigEntity):
             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."
-                )
+        # Validate `stack` attribute
+        if not isinstance(self.stack, (Stack, dict)):
+            raise OrionisIntegrityException(
+                "The 'stack' property must be an instance of Stack or a dictionary."
+            )
+        if isinstance(self.stack, dict):
+            self.stack = Stack(**self.stack)
 
-        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."
-                )
+        # Validate `hourly` attribute
+        if not isinstance(self.hourly, (Hourly, dict)):
+            raise OrionisIntegrityException(
+                "The 'hourly' property must be an instance of Hourly or a dictionary."
+            )
+        if isinstance(self.hourly, dict):
+            self.hourly = Hourly(**self.hourly)
 
-        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."
-                )
+        # Validate `daily` attribute
+        if not isinstance(self.daily, (Daily, dict)):
+            raise OrionisIntegrityException(
+                "The 'daily' property must be an instance of Daily or a dictionary."
+            )
+        if isinstance(self.daily, dict):
+            self.daily = Daily(**self.daily)
 
-        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."
-                )
+        # Validate `weekly` attribute
+        if not isinstance(self.weekly, (Weekly, dict)):
+            raise OrionisIntegrityException(
+                "The 'weekly' property must be an instance of Weekly or a dictionary."
+            )
+        if isinstance(self.weekly, dict):
+            self.weekly = Weekly(**self.weekly)
 
-        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."
-                )
+        # Validate `monthly` attribute
+        if not isinstance(self.monthly, (Monthly, dict)):
+            raise OrionisIntegrityException(
+                "The 'monthly' property must be an instance of Monthly or a dictionary."
+            )
+        if isinstance(self.monthly, dict):
+            self.monthly = Monthly(**self.monthly)
 
-        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."
-                )
+        # Validate `chunked` attribute
+        if not isinstance(self.chunked, (Chunked, dict)):
+            raise OrionisIntegrityException(
+                "The 'chunked' property must be an instance of Chunked or a dictionary."
+            )
+        if isinstance(self.chunked, dict):
+            self.chunked = Chunked(**self.chunked)

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

@@ -1,11 +1,11 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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):
+class Chunked(BaseEntity):
     """
     Configuration for chunked log file rotation.
 
@@ -26,34 +26,34 @@ class Chunked(BaseConfigEntity):
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/chunked.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/chunked.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
     mb_size: int = field(
         default = 10,
-        metadata={
+        metadata = {
             "description": "Maximum size (in MB) of a log file before chunking.",
-            "default": 10,
+            "default": 10
         },
     )
 
     files: int = field(
         default = 5,
-        metadata={
+        metadata = {
             "description": "Maximum number of log files to retain.",
-            "default": 5,
+            "default": 5
         },
     )
 
@@ -78,6 +78,14 @@ class Chunked(BaseConfigEntity):
         # Validate 'level' using the IsValidLevel validator
         IsValidLevel(self.level)
 
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level
+
         # Validate 'mb_size'
         if not isinstance(self.mb_size, int):
             raise OrionisIntegrityException(

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

@@ -1,12 +1,12 @@
 from dataclasses import dataclass, field
 from datetime import datetime, time
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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):
+class Daily(BaseEntity):
     """
     Represents the configuration for daily log file rotation.
 
@@ -18,18 +18,18 @@ class Daily(BaseConfigEntity):
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/daily.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/daily.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
@@ -37,15 +37,15 @@ class Daily(BaseConfigEntity):
         default = 7,
         metadata = {
             "description": "The number of days to retain log files before deletion.",
-            "default": 7,
+            "default": 7
         },
     )
 
     at: time | str = field(
         default = time(0, 0).strftime("%H:%M"),
-        metadata={
+        metadata = {
             "description": "The time of day when the log rotation should occur.",
-            "default": time(0, 0).strftime("%H:%M"),
+            "default": time(0, 0).strftime("%H:%M")
         },
     )
 
@@ -63,6 +63,14 @@ class Daily(BaseConfigEntity):
         # Validate 'level' using the IsValidLevel validator
         IsValidLevel(self.level)
 
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level
+
         # Validate 'retention_days'
         if not isinstance(self.retention_days, int):
             raise OrionisIntegrityException(

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

@@ -1,11 +1,11 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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):
+class Hourly(BaseEntity):
     """
     Represents the configuration for hourly log file management.
 
@@ -16,18 +16,18 @@ class Hourly(BaseConfigEntity):
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/hourly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/hourly.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
@@ -35,7 +35,7 @@ class Hourly(BaseConfigEntity):
         default = 24,
         metadata = {
             "description": "The number of hours to retain log files before deletion.",
-            "default": 24,
+            "default": 24
         },
     )
 
@@ -56,6 +56,14 @@ class Hourly(BaseConfigEntity):
         # Validate 'level' using the IsValidLevel validator
         IsValidLevel(self.level)
 
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level
+
         # Validate 'retention_hours'
         if not isinstance(self.retention_hours, int) or self.retention_hours < 0:
             raise OrionisIntegrityException(

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

@@ -1,10 +1,10 @@
 from dataclasses import dataclass, field, fields
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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):
+class Logging(BaseEntity):
     """
     Represents the logging system configuration.
 
@@ -16,8 +16,8 @@ class Logging(BaseConfigEntity):
         A collection of available logging channels.
     """
     default: str = field(
-        default="stack",
-        metadata={
+        default = "stack",
+        metadata = {
             "description": "The default logging channel to use.",
             "default": "stack"
         }
@@ -25,9 +25,9 @@ class Logging(BaseConfigEntity):
 
     channels: Channels | dict = field(
         default_factory = lambda: Channels(),
-        metadata={
+        metadata = {
             "description": "A collection of available logging channels.",
-            "default": lambda: Channels().toDict()
+            "default": Channels().toDict()
         }
     )
 
@@ -58,15 +58,9 @@ class Logging(BaseConfigEntity):
                 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."
-                )
+        if not isinstance(self.channels, (Channels, dict)):
+            raise OrionisIntegrityException(
+                "The 'channels' property must be an instance of Channels or a dictionary."
+            )
+        if isinstance(self.channels, dict):
+            self.channels = Channels(**self.channels)

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

@@ -1,11 +1,11 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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(BaseConfigEntity):
+class Monthly(BaseEntity):
     """
     Configuration entity for monthly log file management.
 
@@ -16,26 +16,26 @@ class Monthly(BaseConfigEntity):
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/monthly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/monthly.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
     retention_months: int = field(
         default = 4,
-        metadata={
+        metadata = {
             "description": "The number of months to retain log files before deletion.",
-            "default": 4,
+            "default": 4
         },
     )
 
@@ -55,6 +55,14 @@ class Monthly(BaseConfigEntity):
         # Validate 'level' using the IsValidLevel validator
         IsValidLevel(self.level)
 
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level
+
         # Validate 'retention_months'
         if not isinstance(self.retention_months, int):
             raise OrionisIntegrityException(

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

@@ -1,27 +1,27 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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(BaseConfigEntity):
+class Stack(BaseEntity):
     """
     Represents the configuration for a logging stack, including the log file path and logging level.
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/stack.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/stack.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
@@ -37,4 +37,12 @@ class Stack(BaseConfigEntity):
         IsValidPath(self.path)
 
         # Validate 'level' using the IsValidLevel validator
-        IsValidLevel(self.level)
+        IsValidLevel(self.level)
+
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level

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

@@ -1,11 +1,11 @@
 from dataclasses import dataclass, field
-from orionis.foundation.config.base import BaseConfigEntity
+from orionis.support.entities.base import BaseEntity
 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 Weekly(BaseConfigEntity):
+class Weekly(BaseEntity):
     """
     Configuration entity for weekly log file management.
 
@@ -16,18 +16,18 @@ class Weekly(BaseConfigEntity):
     """
 
     path: str = field(
-        default = 'storage/log/application.log',
+        default = 'storage/log/weekly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/application.log",
+            "default": "storage/log/weekly.log"
         },
     )
 
     level: int | str | Level = field(
-        default = Level.INFO,
+        default = Level.INFO.value,
         metadata = {
             "description": "The logging level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).",
-            "default": Level.INFO,
+            "default": Level.INFO.value
         },
     )
 
@@ -35,7 +35,7 @@ class Weekly(BaseConfigEntity):
         default = 4,
         metadata = {
             "description": "The number of weeks to retain log files before deletion.",
-            "default": 4,
+            "default": 4
         },
     )
 
@@ -57,6 +57,14 @@ class Weekly(BaseConfigEntity):
         # Validate 'level' using the IsValidLevel validator
         IsValidLevel(self.level)
 
+        # Assign the level value.
+        if isinstance(self.level, Level):
+            self.level = self.level.value
+        elif isinstance(self.level, str):
+            self.level = Level[self.level.strip().upper()].value
+        elif isinstance(self.level, int):
+            self.level = self.level
+
         # Validate 'retention_weeks'
         if not isinstance(self.retention_weeks, int):
             raise OrionisIntegrityException(

orionis/foundation/config/logging/validators/path.py

@@ -18,6 +18,8 @@ class __IsValidPath:
     def __call__(self, value: Any) -> None:
         """
         Validates that the provided value is a non-empty string representing a file path.
+        This method checks if the value is a string and not empty. It also ensures that the string ends with '.log',
+        indicating that it is a log file path.
 
         Args:
             value (Any): The value to validate as a file path.
@@ -29,6 +31,10 @@ class __IsValidPath:
             raise OrionisIntegrityException(
                 f"File cache configuration error: 'path' must be a non-empty string, got {repr(value)}."
             )
+        if not value.endswith('.log'):
+            raise OrionisIntegrityException(
+                f"File cache configuration error: 'path' must end with '.log', got {repr(value)}."
+            )
 
 # Exported singleton instance
 IsValidPath = __IsValidPath()