orionis 0.252.0__py3-none-any.whl → 0.265.0__py3-none-any.whl

orionis/luminate/foundation/config/database/enums/pgsql_charsets.py

@@ -0,0 +1,90 @@
+from enum import Enum
+
+class PGSQLCharset(Enum):
+    """
+    Enumeration of supported PostgreSQL character encodings.
+    Each member of this enum represents a valid encoding name that can be used in PostgreSQL databases.
+    These encodings determine how text data is stored and interpreted in the database.
+    Members:
+        BIG5: Traditional Chinese encoding.
+        EUC_CN: Extended Unix Code for Simplified Chinese.
+        EUC_JP: Extended Unix Code for Japanese.
+        EUC_KR: Extended Unix Code for Korean.
+        EUC_TW: Extended Unix Code for Traditional Chinese.
+        GB18030: Chinese National Standard encoding.
+        GBK: Extended Guobiao encoding for Simplified Chinese.
+        ISO_8859_5: ISO 8859-5 Cyrillic encoding.
+        ISO_8859_6: ISO 8859-6 Arabic encoding.
+        ISO_8859_7: ISO 8859-7 Greek encoding.
+        ISO_8859_8: ISO 8859-8 Hebrew encoding.
+        JOHAB: Korean Johab encoding.
+        KOI8R: KOI8-R Russian encoding.
+        KOI8U: KOI8-U Ukrainian encoding.
+        LATIN1: ISO 8859-1 Western European encoding.
+        LATIN2: ISO 8859-2 Central European encoding.
+        LATIN3: ISO 8859-3 South European encoding.
+        LATIN4: ISO 8859-4 North European encoding.
+        LATIN5: ISO 8859-9 Turkish encoding.
+        LATIN6: ISO 8859-10 Nordic encoding.
+        LATIN7: ISO 8859-13 Baltic Rim encoding.
+        LATIN8: ISO 8859-14 Celtic encoding.
+        LATIN9: ISO 8859-15 Western European encoding with Euro.
+        LATIN10: ISO 8859-16 South-Eastern European encoding.
+        MULE_INTERNAL: Mule internal encoding.
+        SJIS: Shift JIS Japanese encoding.
+        SQL_ASCII: No encoding; raw bytes.
+        UHC: Unified Hangul Code for Korean.
+        UTF8: Unicode UTF-8 encoding.
+        WIN866: Windows code page 866 (Cyrillic).
+        WIN874: Windows code page 874 (Thai).
+        WIN1250: Windows code page 1250 (Central European).
+        WIN1251: Windows code page 1251 (Cyrillic).
+        WIN1252: Windows code page 1252 (Western European).
+        WIN1253: Windows code page 1253 (Greek).
+        WIN1254: Windows code page 1254 (Turkish).
+        WIN1255: Windows code page 1255 (Hebrew).
+        WIN1256: Windows code page 1256 (Arabic).
+        WIN1257: Windows code page 1257 (Baltic).
+        WIN1258: Windows code page 1258 (Vietnamese).
+    """
+
+    BIG5 = "BIG5"
+    EUC_CN = "EUC_CN"
+    EUC_JP = "EUC_JP"
+    EUC_KR = "EUC_KR"
+    EUC_TW = "EUC_TW"
+    GB18030 = "GB18030"
+    GBK = "GBK"
+    ISO_8859_5 = "ISO_8859_5"
+    ISO_8859_6 = "ISO_8859_6"
+    ISO_8859_7 = "ISO_8859_7"
+    ISO_8859_8 = "ISO_8859_8"
+    JOHAB = "JOHAB"
+    KOI8R = "KOI8R"
+    KOI8U = "KOI8U"
+    LATIN1 = "LATIN1"
+    LATIN2 = "LATIN2"
+    LATIN3 = "LATIN3"
+    LATIN4 = "LATIN4"
+    LATIN5 = "LATIN5"
+    LATIN6 = "LATIN6"
+    LATIN7 = "LATIN7"
+    LATIN8 = "LATIN8"
+    LATIN9 = "LATIN9"
+    LATIN10 = "LATIN10"
+    MULE_INTERNAL = "MULE_INTERNAL"
+    SJIS = "SJIS"
+    SQL_ASCII = "SQL_ASCII"
+    UHC = "UHC"
+    UTF8 = "UTF8"
+    WIN866 = "WIN866"
+    WIN874 = "WIN874"
+    WIN1250 = "WIN1250"
+    WIN1251 = "WIN1251"
+    WIN1252 = "WIN1252"
+    WIN1253 = "WIN1253"
+    WIN1254 = "WIN1254"
+    WIN1255 = "WIN1255"
+    WIN1256 = "WIN1256"
+    WIN1257 = "WIN1257"
+    WIN1258 = "WIN1258"

orionis/luminate/foundation/config/database/enums/pgsql_collations.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+class PGSQLCollation(Enum):
+    """
+    Enumeration of common collations in PostgreSQL.
+    PostgreSQL supports collations based on the operating system and locales.
+    The names may vary depending on the system, but some common ones are listed here.
+    Attributes:
+        C: 'C' - Binary collation, fast, based on byte order.
+        POSIX: 'POSIX' - Similar to 'C', binary order.
+        EN_US: 'en_US' - English (United States), case-sensitive.
+        EN_US_UTF8: 'en_US.utf8' - English (United States), UTF-8 encoding.
+        ES_ES: 'es_ES' - Spanish (Spain).
+        ES_ES_UTF8: 'es_ES.utf8' - Spanish (Spain), UTF-8 encoding.
+        DE_DE: 'de_DE' - German (Germany).
+        DE_DE_UTF8: 'de_DE.utf8' - German (Germany), UTF-8 encoding.
+    """
+
+    C = "C"
+    POSIX = "POSIX"
+    EN_US = "en_US"
+    EN_US_UTF8 = "en_US.utf8"
+    ES_ES = "es_ES"
+    ES_ES_UTF8 = "es_ES.utf8"
+    DE_DE = "de_DE"
+    DE_DE_UTF8 = "de_DE.utf8"

orionis/luminate/foundation/config/database/enums/pgsql_mode.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+class PGSQLSSLMode(Enum):
+    """
+    SSL modes for PostgreSQL connections.
+    Corresponds to the 'sslmode' parameter in libpq.
+
+    Official values documented at:
+    https://www.postgresql.org/docs/current/libpq-ssl.html
+
+    - DISABLE: No SSL (not secure)
+    - ALLOW: Attempts SSL, silently falls back if unavailable
+    - PREFER: Uses SSL if available (common default)
+    - REQUIRE: Requires SSL (no certificate validation)
+    - VERIFY_CA: Validates the server certificate against the CA
+    - VERIFY_FULL: Validates both the certificate and the host name (most secure)
+    """
+
+    DISABLE = "disable"          # No SSL (not secure)
+    ALLOW = "allow"              # Attempts SSL, silently falls back if unavailable
+    PREFER = "prefer"            # Uses SSL if available (common default)
+    REQUIRE = "require"          # Requires SSL (no certificate validation)
+    VERIFY_CA = "verify-ca"      # Validates the server certificate against the CA
+    VERIFY_FULL = "verify-full"  # Validates both the certificate and the host name (most secure)

orionis/luminate/foundation/config/database/enums/sqlite_foreign_key.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class SQLiteForeignKey(Enum):
+    """
+    Enumeration for representing the state of foreign key constraints in SQLite.
+    Attributes:
+        ON (str): Enables foreign key constraint enforcement.
+        OFF (str): Disables foreign key constraint enforcement.
+    """
+
+    ON = "ON"       # Enables foreign key constraint enforcement
+    OFF = "OFF"     # Disables foreign key constraint enforcement

orionis/luminate/foundation/config/database/enums/sqlite_journal.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class SQLiteJournalMode(Enum):
+    """
+    Enumeration of SQLite journal modes.
+    SQLite uses different journal modes to control how transactions are logged and how database integrity is maintained. 
+    Each mode offers a trade-off between performance, durability, and concurrency.
+    Members:
+        DELETE:   (Default) The journal file is deleted at the end of each transaction.
+        TRUNCATE: The journal file is truncated to zero bytes instead of being deleted.
+        PERSIST:  The journal file is retained but marked as inactive after a transaction.
+        MEMORY:   The journal is kept in volatile memory, offering faster performance but less safety.
+        WAL:      Write-Ahead Logging mode, which can improve concurrency and performance.
+        OFF:      Disables journaling entirely, providing no protection against failures.
+    """
+
+    DELETE = "DELETE"      # (Default) The journal file is deleted at the end of the transaction.
+    TRUNCATE = "TRUNCATE"  # Empties (truncates) the journal file to zero bytes instead of deleting it.
+    PERSIST = "PERSIST"    # Keeps the journal file but marks it as inactive.
+    MEMORY = "MEMORY"      # Keeps the journal in memory (faster, less safe).
+    WAL = "WAL"            # Uses Write-Ahead Logging, improves concurrency and performance in many cases.
+    OFF = "OFF"            # Disables journaling (risky: no protection against failures).

orionis/luminate/foundation/config/database/enums/sqlite_synchronous.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class SQLiteSynchronous(Enum):
+    """
+    Enum representing the possible values for SQLite's synchronous setting.
+    Attributes:
+        FULL: Provides maximum data integrity and durability, but is the slowest option.
+        NORMAL: Offers a balance between data safety and performance.
+        OFF: Maximizes speed, but data may be lost in the event of a crash.
+    These values correspond to the SQLite PRAGMA synchronous settings:
+    https://www.sqlite.org/pragma.html#pragma_synchronous
+    """
+
+    FULL = "FULL"      # Greater safety, slower
+    NORMAL = "NORMAL"  # Balance between safety and performance
+    OFF = "OFF"        # Greater speed, less safe in case of failures

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

@@ -0,0 +1,134 @@
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class S3:
+    """
+    Represents an AWS S3 storage configuration.
+
+    Attributes
+    ----------
+    driver : str
+        The storage driver (default: 's3').
+    key : str
+        AWS access key ID.
+    secret : str
+        AWS secret access key.
+    region : str
+        AWS region where the bucket is located.
+    bucket : str
+        The S3 bucket name.
+    url : Optional[str], default=None
+        The URL endpoint for accessing the S3 bucket.
+    endpoint : Optional[str], default=None
+        The AWS S3 endpoint URL.
+    use_path_style_endpoint : bool, default=False
+        Whether to use a path-style endpoint.
+    """
+
+    key: str = field(
+        default="",
+        metadata={
+            "description": "AWS access key ID.",
+            "default": ""
+        }
+    )
+
+    secret: str = field(
+        default="",
+        metadata={
+            "description": "AWS secret access key.",
+            "default": ""
+        }
+    )
+
+    region: str = field(
+        default="us-east-1",
+        metadata={
+            "description": "AWS region where the bucket is located.",
+            "default": "us-east-1"
+        }
+    )
+
+    bucket: str = field(
+        default="",
+        metadata={
+            "description": "The S3 bucket name.",
+            "default": ""
+        }
+    )
+
+    url: Optional[str] = field(
+        default=None,
+        metadata={
+            "description": "The URL endpoint for accessing the S3 bucket.",
+            "default": None
+        }
+    )
+
+    endpoint: Optional[str] = field(
+        default=None,
+        metadata={
+            "description": "The AWS S3 endpoint URL.",
+            "default": None
+        }
+    )
+
+    use_path_style_endpoint: bool = field(
+        default=False,
+        metadata={
+            "description": "Whether to use a path-style endpoint.",
+            "default": False
+        }
+    )
+
+    throw: bool = field(
+        default=False,
+        metadata={
+            "description": "Whether to raise an exception on errors.",
+            "default": False
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the initialization of the AWS filesystem entity attributes.
+
+        Raises:
+            OrionisIntegrityException: If any attribute is of the wrong type or empty.
+
+        Ensures that all required attributes are of the correct type and, where applicable, are non-empty.
+        """
+
+        if not isinstance(self.key, str):
+            raise OrionisIntegrityException("The 'key' attribute must be a string.")
+
+        if not isinstance(self.secret, str):
+            raise OrionisIntegrityException("The 'secret' attribute must be a string.")
+
+        if not isinstance(self.region, str) or not self.region:
+            raise OrionisIntegrityException("The 'region' attribute must be a non-empty string.")
+
+        if not isinstance(self.bucket, str):
+            raise OrionisIntegrityException("The 'bucket' attribute must be a string.")
+
+        if self.url is not None and not isinstance(self.url, str):
+            raise OrionisIntegrityException("The 'url' attribute must be a string or None.")
+
+        if self.endpoint is not None and not isinstance(self.endpoint, str):
+            raise OrionisIntegrityException("The 'endpoint' attribute must be a string or None.")
+
+        if not isinstance(self.use_path_style_endpoint, bool):
+            raise OrionisIntegrityException("The 'use_path_style_endpoint' attribute must be a boolean.")
+
+        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)

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

@@ -0,0 +1,68 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.filesystems.entitites.aws import S3
+from orionis.luminate.foundation.config.filesystems.entitites.public import Public
+from orionis.luminate.foundation.config.filesystems.entitites.local import Local
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Disks:
+    """
+    Represents the configuration for different filesystem disks.
+    Attributes:
+        local (Local): The disk configuration for local file storage.
+        public (Public): The disk configuration for public file storage.
+    Methods:
+        __post_init__():
+            Ensures the 'path' attribute is a non-empty Path object and of the correct type.
+        toDict() -> dict:
+            Converts the Disks object into a dictionary representation.
+    """
+
+    local : Local = field(
+        default_factory=Local,
+        metadata={
+            "description": "The absolute or relative path where local files are stored.",
+            "default": "Local()",
+        }
+    )
+
+    public : Public = field(
+        default_factory=Public,
+        metadata={
+            "description": "The absolute or relative path where public files are stored.",
+            "default": "Public()",
+        }
+    )
+
+    aws : S3 = field(
+        default_factory=S3,
+        metadata={
+            "description": "The configuration for AWS S3 storage.",
+            "default": "S3()",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to ensure the 'path' attribute is a non-empty Path object.
+        - Converts 'path' to a Path instance if it is not already.
+        - Raises:
+            ValueError: If the 'path' is empty after conversion.
+        """
+
+        if not isinstance(self.local, Local):
+            raise OrionisIntegrityException("The 'local' attribute must be a Local object.")
+
+        if not isinstance(self.public, Public):
+            raise OrionisIntegrityException("The 'public' attribute must be a Public object.")
+
+        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)

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

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field, asdict, fields
+from orionis.luminate.foundation.config.filesystems.entitites.disks import Disks
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Filesystems:
+    """
+    Represents the filesystems configuration.
+
+    Attributes
+    ----------
+    default : str
+        The default filesystem disk to use.
+    disks : Disks
+        A collection of available filesystem disks.
+    """
+
+    default: str = field(
+        default="local",
+        metadata={
+            "description": "The default filesystem disk to use.",
+            "default": "local",
+        }
+    )
+
+    disks: Disks = field(
+        default_factory=Disks,
+        metadata={
+            "description": "A collection of available filesystem disks.",
+            "default": "Disks()",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the types of the attributes after initialization.
+        """
+        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):
+            raise OrionisIntegrityException(
+                "The 'disks' property must be an instance of Disks."
+            )
+
+    def toDict(self) -> dict:
+        """
+        Converts the current instance into a dictionary representation.
+        """
+        return asdict(self)

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

@@ -0,0 +1,39 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Local:
+    """
+    Represents a local filesystem configuration.
+
+    Attributes
+    ----------
+    path : str
+        The absolute or relative path where local files are stored.
+    """
+    path: str = field(
+        default="storage/app/private",
+        metadata={
+            "description": "The absolute or relative path where local files are stored.",
+            "default": "storage/app/private",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to ensure the 'path' attribute is a non-empty string.
+        - Raises:
+            ValueError: If the 'path' is empty.
+        """
+        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)

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

@@ -0,0 +1,52 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Public:
+    """
+    Represents a local filesystem configuration.
+
+    Attributes
+    ----------
+    path : str
+        The absolute or relative path where public files are stored.
+    """
+    path: str = field(
+        default="storage/app/public",
+        metadata={
+            "description": "The absolute or relative path where public files are stored.",
+            "default": "storage/app/public",
+        }
+    )
+
+    url: str = field(
+        default="static",
+        metadata={
+            "description": "The URL where the public files can be accessed.",
+            "default": "static",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to ensure the 'path' attribute is a non-empty string.
+        - Raises:
+            OrionisIntegrityException: If any of the attributes are not of the expected type or are empty.
+        """
+
+        if not isinstance(self.path, str):
+            raise OrionisIntegrityException("The 'path' attribute must be a string.")
+
+        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)

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

@@ -0,0 +1,115 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.logging.entities.monthly import Monthly
+from orionis.luminate.foundation.config.logging.entities.chunked import Chunked
+from orionis.luminate.foundation.config.logging.entities.daily import Daily
+from orionis.luminate.foundation.config.logging.entities.hourly import Hourly
+from orionis.luminate.foundation.config.logging.entities.stack import Stack
+from orionis.luminate.foundation.config.logging.entities.weekly import Weekly
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Channels:
+    """
+    Represents the different logging channels available.
+    """
+
+    stack: Stack = field(
+        default_factory=Stack,
+        metadata={
+            "description": "Configuration for stack log channel.",
+            "default": "Stack()",
+        }
+    )
+
+    hourly: Hourly = field(
+        default_factory=Hourly,
+        metadata={
+            "description": "Configuration for hourly log rotation.",
+            "default": "Hourly()",
+        }
+    )
+
+    daily: Daily = field(
+        default_factory=Daily,
+        metadata={
+            "description": "Configuration for daily log rotation.",
+            "default": "Daily()",
+        }
+    )
+
+    weekly: Weekly = field(
+        default_factory=Weekly,
+        metadata={
+            "description": "Configuration for weekly log rotation.",
+            "default": "Weekly()",
+        }
+    )
+
+    monthly: Monthly = field(
+        default_factory=Monthly,
+        metadata={
+            "description": "Configuration for monthly log rotation.",
+            "default": "Monthly()",
+        }
+    )
+
+    chunked: Chunked = field(
+        default_factory=Chunked,
+        metadata={
+            "description": "Configuration for chunked log file storage.",
+            "default": "Chunked()",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to validate the types of log rotation properties.
+        Ensures that the following instance attributes are of the correct types:
+        - `stack` must be an instance of `Stack`
+        - `hourly` must be an instance of `Hourly`
+        - `daily` must be an instance of `Daily`
+        - `weekly` must be an instance of `Weekly`
+        - `monthly` must be an instance of `Monthly`
+        - `chunked` must be an instance of `Chunked`
+        Raises:
+            OrionisIntegrityException: If any of the properties are not instances of their expected classes.
+        """
+
+        if not isinstance(self.stack, Stack):
+            raise OrionisIntegrityException(
+                "The 'stack' property must be an instance of Stack."
+            )
+
+        if not isinstance(self.hourly, Hourly):
+            raise OrionisIntegrityException(
+                "The 'hourly' property must be an instance of Hourly."
+            )
+
+        if not isinstance(self.daily, Daily):
+            raise OrionisIntegrityException(
+                "The 'daily' property must be an instance of Daily."
+            )
+
+        if not isinstance(self.weekly, Weekly):
+            raise OrionisIntegrityException(
+                "The 'weekly' property must be an instance of Weekly."
+            )
+
+        if not isinstance(self.monthly, Monthly):
+            raise OrionisIntegrityException(
+                "The 'monthly' property must be an instance of Monthly."
+            )
+
+        if not isinstance(self.chunked, Chunked):
+            raise OrionisIntegrityException(
+                "The 'chunked' property must be an instance of Chunked."
+            )
+
+    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)