orionis 0.405.0__py3-none-any.whl → 0.407.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.
 
@@ -29,31 +29,31 @@ class Chunked(BaseConfigEntity):
         default = 'storage/log/chunked.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/chunked.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
         },
     )
 

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.
 
@@ -21,15 +21,15 @@ class Daily(BaseConfigEntity):
         default = 'storage/log/daily.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/daily.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")
         },
     )
 

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.
 
@@ -19,15 +19,15 @@ class Hourly(BaseConfigEntity):
         default = 'storage/log/hourly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/hourly.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
         },
     )
 

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.
 
@@ -19,23 +19,23 @@ class Monthly(BaseConfigEntity):
         default = 'storage/log/monthly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/monthly.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
         },
     )
 

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

@@ -1,10 +1,10 @@
 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.
     """
@@ -13,15 +13,15 @@ class Stack(BaseConfigEntity):
         default = 'storage/log/stack.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/stack.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
         },
     )
 

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.
 
@@ -19,15 +19,15 @@ class Weekly(BaseConfigEntity):
         default = 'storage/log/weekly.log',
         metadata = {
             "description": "The file path where the log is stored.",
-            "default": "storage/log/weekly.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
         },
     )
 

orionis/foundation/config/mail/entities/file.py

@@ -1,8 +1,9 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class File:
+class File(BaseEntity):
     """
     Represents a file configuration entity for storing outgoing emails.
     Attributes:
@@ -17,8 +18,11 @@ class File:
     """
 
     path: str = field(
-        default="storage/mail",
-        metadata={"description": "The file path where outgoing emails are stored."}
+        default = "storage/mail",
+        metadata = {
+            "description": "The file path where outgoing emails are stored.",
+            "default": "storage/mail",
+        }
     )
 
     def __post_init__(self):
@@ -29,35 +33,4 @@ class File:
             OrionisIntegrityException: If 'path' is not a non-empty string.
         """
         if not isinstance(self.path, str) or self.path.strip() == "":
-            raise OrionisIntegrityException("The 'path' attribute must be a non-empty string.")
-
-    def toDict(self) -> dict:
-        """
-        Converts the current instance into a dictionary representation.
-
-        Returns:
-            dict: A dictionary containing all the fields of the 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
+            raise OrionisIntegrityException("The 'path' attribute must be a non-empty string.")