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

orionis/foundation/config/filesystems/entitites/aws.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 S3:
+class S3(BaseEntity):
     """
     Represents an AWS S3 storage configuration.
 
@@ -28,64 +29,64 @@ class S3:
     """
 
     key: str = field(
-        default="",
-        metadata={
+        default = "",
+        metadata = {
             "description": "AWS access key ID.",
             "default": ""
         }
     )
 
     secret: str = field(
-        default="",
-        metadata={
+        default = "",
+        metadata = {
             "description": "AWS secret access key.",
             "default": ""
         }
     )
 
     region: str = field(
-        default="us-east-1",
-        metadata={
+        default = "us-east-1",
+        metadata = {
             "description": "AWS region where the bucket is located.",
             "default": "us-east-1"
         }
     )
 
     bucket: str = field(
-        default="",
-        metadata={
+        default = "",
+        metadata = {
             "description": "The S3 bucket name.",
             "default": ""
         }
     )
 
     url: Optional[str] = field(
-        default=None,
-        metadata={
+        default = None,
+        metadata = {
             "description": "The URL endpoint for accessing the S3 bucket.",
             "default": None
         }
     )
 
     endpoint: Optional[str] = field(
-        default=None,
-        metadata={
+        default = None,
+        metadata = {
             "description": "The AWS S3 endpoint URL.",
             "default": None
         }
     )
 
     use_path_style_endpoint: bool = field(
-        default=False,
-        metadata={
+        default = False,
+        metadata = {
             "description": "Whether to use a path-style endpoint.",
             "default": False
         }
     )
 
     throw: bool = field(
-        default=False,
-        metadata={
+        default = False,
+        metadata = {
             "description": "Whether to raise an exception on errors.",
             "default": False
         }
@@ -101,56 +102,34 @@ class S3:
         Ensures that all required attributes are of the correct type and, where applicable, are non-empty.
         """
 
+        # Validate `key` attribute
         if not isinstance(self.key, str):
             raise OrionisIntegrityException("The 'key' attribute must be a string.")
 
+        # Validate `secret` attribute
         if not isinstance(self.secret, str):
             raise OrionisIntegrityException("The 'secret' attribute must be a string.")
 
+        # Validate `region` attribute
         if not isinstance(self.region, str) or not self.region:
             raise OrionisIntegrityException("The 'region' attribute must be a non-empty string.")
 
+        # Validate `bucket` attribute
         if not isinstance(self.bucket, str):
             raise OrionisIntegrityException("The 'bucket' attribute must be a string.")
 
+        # Validate `url` attribute
         if self.url is not None and not isinstance(self.url, str):
             raise OrionisIntegrityException("The 'url' attribute must be a string or None.")
 
+        # Validate `endpoint` attribute
         if self.endpoint is not None and not isinstance(self.endpoint, str):
             raise OrionisIntegrityException("The 'endpoint' attribute must be a string or None.")
 
+        # Validate `use_path_style_endpoint` attribute
         if not isinstance(self.use_path_style_endpoint, bool):
             raise OrionisIntegrityException("The 'use_path_style_endpoint' attribute must be a boolean.")
 
+        # Validate `throw` attribute
         if not isinstance(self.throw, bool):
-            raise OrionisIntegrityException("The 'throw' attribute must be a boolean.")
-
-    def toDict(self) -> dict:
-        """
-        Convert the object to a dictionary representation.
-        Returns:
-            dict: A dictionary representation of the Dataclass object.
-        """
-        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 'throw' attribute must be a boolean.")

orionis/foundation/config/filesystems/entitites/disks.py

@@ -1,11 +1,12 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.filesystems.entitites.aws import S3
 from orionis.foundation.config.filesystems.entitites.public import Public
 from orionis.foundation.config.filesystems.entitites.local import Local
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Disks:
+class Disks(BaseEntity):
     """
     Represents the configuration for different filesystem disks.
     Attributes:
@@ -18,27 +19,27 @@ class Disks:
             Converts the Disks object into a dictionary representation.
     """
 
-    local : Local = field(
-        default_factory=Local,
+    local : Local | dict = field(
+        default_factory = lambda: Local(),
         metadata={
             "description": "The absolute or relative path where local files are stored.",
-            "default": "Local()",
+            "default": Local().toDict()
         }
     )
 
-    public : Public = field(
-        default_factory=Public,
+    public : Public | dict = field(
+        default_factory = lambda: Public(),
         metadata={
             "description": "The absolute or relative path where public files are stored.",
-            "default": "Public()",
+            "default": Public().toDict()
         }
     )
 
-    aws : S3 = field(
-        default_factory=S3,
+    aws : S3 | dict = field(
+        default_factory = lambda: S3(),
         metadata={
             "description": "The configuration for AWS S3 storage.",
-            "default": "S3()",
+            "default": S3().toDict()
         }
     )
 
@@ -50,41 +51,20 @@ class Disks:
             ValueError: If the 'path' is empty after conversion.
         """
 
-        if not isinstance(self.local, Local):
-            raise OrionisIntegrityException("The 'local' attribute must be a Local object.")
+        # Validate the 'local' attribute
+        if not isinstance(self.local, (Local, dict)):
+            raise OrionisIntegrityException("The 'local' attribute must be a Local object or a dictionary.")
+        if isinstance(self.local, dict):
+            self.local = Local(**self.local)
 
-        if not isinstance(self.public, Public):
-            raise OrionisIntegrityException("The 'public' attribute must be a Public object.")
+        # Validate the 'public' attribute
+        if not isinstance(self.public, (Public, dict)):
+            raise OrionisIntegrityException("The 'public' attribute must be a Public object or a dictionary.")
+        if isinstance(self.public, dict):
+            self.public = Public(**self.public)
 
-        if not isinstance(self.aws, S3):
-            raise OrionisIntegrityException("The 'aws' attribute must be a S3 object.")
-
-    def toDict(self) -> dict:
-        """
-        Convert the object to a dictionary representation.
-        Returns:
-            dict: A dictionary representation of the Dataclass object.
-        """
-        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 the 'aws' attribute
+        if not isinstance(self.aws, (S3, dict)):
+            raise OrionisIntegrityException("The 'aws' attribute must be an S3 object or a dictionary.")
+        if isinstance(self.aws, dict):
+            self.aws = S3(**self.aws)

orionis/foundation/config/filesystems/entitites/filesystems.py

@@ -1,9 +1,10 @@
-from dataclasses import dataclass, field, asdict, fields
+from dataclasses import dataclass, field, fields
 from orionis.foundation.config.filesystems.entitites.disks import Disks
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Filesystems:
+class Filesystems(BaseEntity):
     """
     Represents the filesystems configuration.
 
@@ -16,18 +17,18 @@ class Filesystems:
     """
 
     default: str = field(
-        default="local",
-        metadata={
+        default = "local",
+        metadata = {
             "description": "The default filesystem disk to use.",
             "default": "local",
         }
     )
 
-    disks: Disks = field(
-        default_factory=Disks,
+    disks: Disks | dict = field(
+        default_factory = lambda: Disks(),
         metadata={
             "description": "A collection of available filesystem disks.",
-            "default": "Disks()",
+            "default": Disks().toDict()
         }
     )
 
@@ -35,41 +36,18 @@ class Filesystems:
         """
         Validates the types of the attributes after initialization.
         """
+
+        # Validate the 'default' property
         options = [f.name for f in fields(Disks)]
         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.disks, Disks):
+        # Validate the 'disks' property
+        if not isinstance(self.disks, (Disks, dict)):
             raise OrionisIntegrityException(
-                "The 'disks' property must be an instance of Disks."
+                "The 'disks' property must be an instance of Disks or a dictionary."
             )
-
-    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.disks, dict):
+            self.disks = Disks(**self.disks)

orionis/foundation/config/filesystems/entitites/local.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 Local:
+class Local(BaseEntity):
     """
     Represents a local filesystem configuration.
 
@@ -12,8 +13,8 @@ class Local:
         The absolute or relative path where local files are stored.
     """
     path: str = field(
-        default="storage/app/private",
-        metadata={
+        default = "storage/app/private",
+        metadata = {
             "description": "The absolute or relative path where local files are stored.",
             "default": "storage/app/private",
         }
@@ -22,40 +23,13 @@ class Local:
     def __post_init__(self):
         """
         Post-initialization method to ensure the 'path' attribute is a non-empty string.
+
         - Raises:
             ValueError: If the 'path' is empty.
         """
+
+        # Validate the 'path' attribute
         if not isinstance(self.path, str):
             raise OrionisIntegrityException("The 'path' attribute must be a string.")
         if not self.path.strip():
-            raise OrionisIntegrityException("The 'path' attribute cannot be empty.")
-
-    def toDict(self) -> dict:
-        """
-        Convert the object to a dictionary representation.
-        Returns:
-            dict: A dictionary representation of the Dataclass object.
-        """
-        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 cannot be empty.")

orionis/foundation/config/filesystems/entitites/public.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 Public:
+class Public(BaseEntity):
     """
     Represents a local filesystem configuration.
 
@@ -12,63 +13,35 @@ class Public:
         The absolute or relative path where public files are stored.
     """
     path: str = field(
-        default="storage/app/public",
-        metadata={
+        default = "storage/app/public",
+        metadata = {
             "description": "The absolute or relative path where public files are stored.",
-            "default": "storage/app/public",
+            "default": "storage/app/public"
         }
     )
 
     url: str = field(
-        default="static",
-        metadata={
+        default = "static",
+        metadata = {
             "description": "The URL where the public files can be accessed.",
-            "default": "static",
+            "default": "static"
         }
     )
 
     def __post_init__(self):
         """
         Post-initialization method to ensure the 'path' attribute is a non-empty string.
-        - Raises:
+
+        Raises:
             OrionisIntegrityException: If any of the attributes are not of the expected type or are empty.
         """
 
+        # Validate the 'path' attribute
         if not isinstance(self.path, str):
             raise OrionisIntegrityException("The 'path' attribute must be a string.")
 
+        # Validate the 'url' attribute
         if not isinstance(self.url, str):
             raise OrionisIntegrityException("The 'url' attribute must be a string.")
-
         if not self.path.strip() or not self.url.strip():
-            raise OrionisIntegrityException("The 'path' and 'url' attributes cannot be empty.")
-
-    def toDict(self) -> dict:
-        """
-        Convert the object to a dictionary representation.
-        Returns:
-            dict: A dictionary representation of the Dataclass object.
-        """
-        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' and 'url' attributes cannot be empty.")