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

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.")

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

@@ -1,9 +1,10 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field, fields
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.mail.entities.mailers import Mailers
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Mail:
+class Mail(BaseEntity):
     """
     Represents the mail configuration entity.
     Attributes:
@@ -18,13 +19,19 @@ class Mail:
     """
 
     default: str = field(
-        default="smtp",
-        metadata={"description": "The default mailer transport to use."}
+        default = "smtp",
+        metadata = {
+            "description": "The default mailer transport to use.",
+            "default": "smtp",
+        }
     )
 
-    mailers: Mailers = field(
-        default_factory=Mailers,
-        metadata={"description": "The available mail transport configurations."}
+    mailers: Mailers | dict = field(
+        default_factory = lambda: Mailers(),
+        metadata = {
+            "description": "The available mail transport configurations.",
+            "default": Mailers().toDict()
+        }
     )
 
     def __post_init__(self):
@@ -37,42 +44,17 @@ class Mail:
             OrionisIntegrityException: If 'default' is not a valid string option or if 'mailers' is not a Mailers object.
         """
 
+        # Validate 'default' attribute
         options = [f.name for f in fields(Mailers)]
         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.mailers, Mailers):
-            raise OrionisIntegrityException("The 'mailers' attribute must be a Mailers object.")
-
-    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
+        # Validate 'mailers' attribute
+        if not isinstance(self.mailers, (Mailers, dict)):
+            raise OrionisIntegrityException(
+                "The 'mailers' property must be an instance of Mailers or a dictionary."
+            )
+        if isinstance(self.mailers, dict):
+            self.mailers = Mailers(**self.mailers)

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

@@ -1,15 +1,18 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.mail.entities.file import File
 from orionis.foundation.config.mail.entities.smtp import Smtp
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Mailers:
+class Mailers(BaseEntity):
     """
     Represents the mail transport configurations for the application.
+
     Attributes:
         smtp (Smtp): The SMTP configuration used for sending emails.
         file (File): The file-based mail transport configuration.
+
     Methods:
         __post_init__():
             Validates that the 'smtp' and 'file' attributes are instances of their respective classes.
@@ -19,14 +22,20 @@ class Mailers:
             Serializes the Mailers instance to a dictionary.
     """
 
-    smtp: Smtp = field(
-        default_factory=Smtp,
-        metadata={"description": "The SMTP configuration used for sending emails."}
+    smtp: Smtp | dict = field(
+        default_factory = lambda: Smtp(),
+        metadata = {
+            "description": "The SMTP configuration used for sending emails.",
+            "default": Smtp().toDict()
+        }
     )
 
-    file: File = field(
-        default_factory=File,
-        metadata={"description": "The file-based mail transport configuration."}
+    file: File | dict = field(
+        default_factory = lambda: File(),
+        metadata = {
+            "description": "The file-based mail transport configuration.",
+            "default": File().toDict()
+        }
     )
 
     def __post_init__(self):
@@ -34,43 +43,19 @@ class Mailers:
         Post-initialization method to validate attribute types.
 
         Ensures that the 'smtp' attribute is an instance of the Smtp class and the 'file' attribute is an instance of the File class.
+
         Raises:
             OrionisIntegrityException: If 'smtp' is not a Smtp object or 'file' is not a File object.
         """
 
-        if not isinstance(self.smtp, Smtp):
-            raise OrionisIntegrityException("The 'smtp' attribute must be a Smtp object.")
-
-        if not isinstance(self.file, File):
-            raise OrionisIntegrityException("The 'file' attribute must be a File object.")
-
-    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
+        # Validate `smtp` attribute
+        if not isinstance(self.smtp, (Smtp, dict)):
+            raise OrionisIntegrityException("The 'smtp' attribute must be a Smtp object or a dictionary.")
+        if isinstance(self.smtp, dict):
+            self.smtp = Smtp(**self.smtp)
+
+        # Validate `file` attribute
+        if not isinstance(self.file, (File, dict)):
+            raise OrionisIntegrityException("The 'file' attribute must be a File object or a dictionary.")
+        if isinstance(self.file, dict):
+            self.file = File(**self.file)

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

@@ -1,9 +1,10 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from typing import Optional
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Smtp:
+class Smtp(BaseEntity):
     """
     Represents the configuration for an SMTP (Simple Mail Transfer Protocol) server.
     Attributes:
@@ -26,38 +27,59 @@ class Smtp:
     """
 
     url: str = field(
-        default="smtp.mailtrap.io",
-        metadata={"description": "The full URL for the SMTP service."}
+        default = "smtp.mailtrap.io",
+        metadata = {
+            "description": "The full URL for the SMTP service.",
+            "default": "smtp.mailtrap.io"
+        }
     )
 
     host: str = field(
-        default="smtp.mailtrap.io",
-        metadata={"description": "The hostname of the SMTP server."}
+        default = "smtp.mailtrap.io",
+        metadata = {
+            "description": "The hostname of the SMTP server.",
+            "default": "smtp.mailtrap.io"
+        }
     )
 
     port: int = field(
-        default=587,
-        metadata={"description": "The port number used for SMTP communication."}
+        default = 587,
+        metadata = {
+            "description": "The port number used for SMTP communication.",
+            "default": 587
+        }
     )
 
     encryption: str = field(
-        default="TLS",
-        metadata={"description": "The encryption type used for secure communication."}
+        default = "TLS",
+        metadata = {
+            "description": "The encryption type used for secure communication.",
+            "default": "TLS"
+        }
     )
 
     username: str = field(
-        default="",
-        metadata={"description": "The username for authentication with the SMTP server."}
+        default = "",
+        metadata = {
+            "description": "The username for authentication with the SMTP server.",
+            "default": ""
+        }
     )
 
     password: str = field(
-        default="",
-        metadata={"description": "The password for authentication with the SMTP server."}
+        default = "",
+        metadata = {
+            "description": "The password for authentication with the SMTP server.",
+            "default": ""
+        }
     )
 
     timeout: Optional[int] = field(
-        default=None,
-        metadata={"description": "The connection timeout duration in seconds."}
+        default = None,
+        metadata = {
+            "description": "The connection timeout duration in seconds.",
+            "default": None
+        }
     )
 
     def __post_init__(self):
@@ -73,54 +95,31 @@ class Smtp:
         Raises:
             OrionisIntegrityException: If any attribute fails its validation check.
         """
+
+        # Validate `url` attribute
         if not isinstance(self.url, str):
             raise OrionisIntegrityException("The 'url' attribute must be a string.")
 
+        # Validate `host` attribute
         if not isinstance(self.host, str):
             raise OrionisIntegrityException("The 'host' attribute must be a string.")
 
+        # Validate `port` attribute
         if not isinstance(self.port, int) or self.port < 0:
             raise OrionisIntegrityException("The 'port' attribute must be a non-negative integer.")
 
+        # Validate `encryption` attribute
         if not isinstance(self.encryption, str):
             raise OrionisIntegrityException("The 'encryption' attribute must be a string.")
 
+        # Validate `username` attribute
         if not isinstance(self.username, str):
             raise OrionisIntegrityException("The 'username' attribute must be a string.")
 
+        # Validate `password` attribute
         if not isinstance(self.password, str):
             raise OrionisIntegrityException("The 'password' attribute must be a string.")
 
+        # Validate `timeout` attribute
         if self.timeout is not None and (not isinstance(self.timeout, int) or self.timeout < 0):
-            raise OrionisIntegrityException("The 'timeout' attribute must be a non-negative integer or None.")
-
-    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 'timeout' attribute must be a non-negative integer or None.")

orionis/foundation/config/queue/entities/brokers.py

@@ -1,15 +1,18 @@
 
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.queue.entities.database import Database
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Brokers:
+class Brokers(BaseEntity):
     """
     Represents the configuration for queue brokers.
+
     Attributes:
         sync (bool): Indicates if the sync broker is enabled. Defaults to True.
         database (Database): The configuration for the database-backed queue. Defaults to a new Database instance.
+
     Methods:
         __post_init__():
             Validates and normalizes the properties after initialization.
@@ -17,61 +20,36 @@ class Brokers:
     """
 
     sync: bool = field(
-        default=True,
-        metadata={
+        default = True,
+        metadata = {
             "description": "Indicates if the sync broker is enabled.",
             "default": True
         }
     )
 
-    database: Database = field(
-        default_factory=Database,
-        metadata={
+    database: Database | dict = field(
+        default_factory = lambda: Database(),
+        metadata = {
             "description": "The configuration for the database-backed queue.",
-            "default": "Database()"
+            "default": Database().toDict()
         }
     )
 
     def __post_init__(self):
         """
         Post-initialization validation for the Brokers entity.
+
         Validates and normalizes the following properties:
         - sync: Must be a boolean.
         - database: Must be an instance of the Database class.
         """
+
+        # Validate 'sync' property
         if not isinstance(self.sync, bool):
             raise OrionisIntegrityException("sync must be a boolean.")
 
-        if not isinstance(self.database, Database):
-            raise OrionisIntegrityException("database must be an instance of the Database class.")
-
-    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
+        # Validate 'database' property
+        if not isinstance(self.database, (Database, dict)):
+            raise OrionisIntegrityException("database must be an instance of the Database class or a dictionary.")
+        if isinstance(self.database, dict):
+            self.database = Database(**self.database)

orionis/foundation/config/queue/entities/database.py

@@ -1,18 +1,21 @@
 
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.queue.enums import Strategy
+from orionis.support.entities.base import BaseEntity
 import re
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Database:
+class Database(BaseEntity):
     """
     Represents the configuration entity for a database-backed queue.
+
     Attributes:
         table (str): The name of the table used for the queue. Must match the pattern `[a-z_][a-z_]*` (lowercase letters or underscores only, no numbers).
         queue (str): The name of the queue. Must contain only ASCII characters.
         retry_after (int): The time in seconds to wait before retrying a failed job. Must be a positive integer.
         strategy (str | Strategy): The strategy used for the queue. Options are FIFO, LIFO, or PRIORITY. Can be provided as a string (case-insensitive) or as a `Strategy` enum member.
+
     Methods:
         __post_init__():
             Validates and normalizes the entity's properties after initialization.
@@ -23,49 +26,52 @@ class Database:
     """
 
     table: str = field(
-        default="jobs",
-        metadata={
+        default = "jobs",
+        metadata = {
             "description": "The name of the table used for the queue.",
-            "default": "jobs",
+            "default": "jobs"
         }
     )
 
     queue: str = field(
-        default="default",
-        metadata={
+        default = "default",
+        metadata = {
             "description": "The name of the queue.",
-            "default": "default",
+            "default": "default"
         }
     )
 
     retry_after: int = field(
-        default=90,
-        metadata={
+        default = 90,
+        metadata = {
             "description": "The time in seconds to wait before retrying a failed job.",
-            "default": 90,
+            "default": 90
         }
     )
 
     strategy : str | Strategy = field(
-        default=Strategy.FIFO,
-        metadata={
+        default = Strategy.FIFO.value,
+        metadata = {
             "description": "The strategy used for the queue. Options are FIFO, LIFO, or PRIORITY.",
-            "default": "Strategy.FIFO",
+            "default": Strategy.FIFO.value
         }
     )
 
     def __post_init__(self):
         """
         Post-initialization validation for the entity.
+
         Validates and normalizes the following properties:
         - `table`: Must be a string matching the pattern `[a-z_][a-z_]*` (lowercase letters or underscores only, no numbers).
         - `queue`: Must be a string containing only ASCII characters.
         - `retry_after`: Must be a positive integer.
         - `strategy`: Must be either a string (matching a valid `Strategy` member name, case-insensitive) or an instance of `Strategy`. Converts the value to the corresponding `Strategy` enum value.
+
         Raises:
             OrionisIntegrityException: If any property fails validation.
         """
 
+        # Validate `table` attribute
         if not isinstance(self.table, str):
             raise OrionisIntegrityException("The 'table' property must be a string.")
         if not re.fullmatch(r'[a-z_][a-z_]*', self.table):
@@ -73,6 +79,7 @@ class Database:
                 "The 'table' property must be a valid table name: start with a lowercase letter or underscore, contain only lowercase letters or underscores (no numbers allowed)."
             )
 
+        # Validate `queue` attribute
         if not isinstance(self.queue, str):
             raise OrionisIntegrityException("The 'queue' property must be a string.")
         try:
@@ -80,9 +87,11 @@ class Database:
         except UnicodeEncodeError:
             raise OrionisIntegrityException("The 'queue' property must contain only ASCII characters (no UTF-8 or non-ASCII allowed).")
 
+        # Validate `retry_after` attribute
         if not isinstance(self.retry_after, int) or self.retry_after <= 0:
             raise OrionisIntegrityException("The 'retry_after' property must be a positive integer.")
 
+        # Validate `strategy` attribute
         if not isinstance(self.strategy, (str, Strategy)):
             raise OrionisIntegrityException("The 'strategy' property must be a string or an instance of Strategy.")
         if isinstance(self.strategy, str):
@@ -95,35 +104,4 @@ class Database:
             else:
                 self.strategy = Strategy[_value].value
         else:
-            self.strategy = self.strategy.value
-
-    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
+            self.strategy = self.strategy.value