orionis 0.253.0__py3-none-any.whl → 0.266.0__py3-none-any.whl

orionis/luminate/foundation/config/database/entities/pgsql.py

@@ -0,0 +1,189 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.database.enums.pgsql_charsets import PGSQLCharset
+from orionis.luminate.foundation.config.database.enums.pgsql_mode import PGSQLSSLMode
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.services.environment.env import Env
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class PGSQL:
+    """
+    Pgsql database configuration entity.
+    Attributes:
+        driver (str): Database driver type. Default: "pgsql".
+        host (str): Database host. Default: value of the environment variable DB_HOST or "127.0.0.1".
+        port (str): Database port. Default: value of the environment variable DB_PORT or "5432".
+        database (str): Database name. Default: value of the environment variable DB_DATABASE or "orionis".
+        username (str): Database user. Default: value of the environment variable DB_USERNAME or "root".
+        password (str): Database password. Default: value of the environment variable DB_PASSWORD or "".
+        charset (str): Database charset. Default: value of the environment variable DB_CHARSET or "utf8".
+        prefix (str): Table prefix. Default: "".
+        prefix_indexes (bool): Whether to prefix indexes. Default: True.
+        search_path (str): PostgreSQL schema search_path. Default: "public".
+        sslmode (str): Connection SSL mode. Default: "prefer".
+    """
+
+    driver: str = field(
+        default="pgsql",
+        metadata={
+            "description": "Database driver type",
+            "default": "pgsql"
+        }
+    )
+
+    host: str = field(
+        default_factory=lambda: Env.get("DB_HOST", "127.0.0.1"),
+        metadata={
+            "description": "Database host",
+            "default": "127.0.0.1"
+        }
+    )
+
+    port: str = field(
+        default_factory=lambda: Env.get("DB_PORT", "5432"),
+        metadata={
+            "description": "Database port",
+            "default": "5432"
+        }
+    )
+
+    database: str = field(
+        default_factory=lambda: Env.get("DB_DATABASE", "orionis"),
+        metadata={
+            "description": "Database name",
+            "default": "orionis"
+        }
+    )
+
+    username: str = field(
+        default_factory=lambda: Env.get("DB_USERNAME", "root"),
+        metadata={
+            "description": "Database user",
+            "default": "root"
+        }
+    )
+
+    password: str = field(
+        default_factory=lambda: Env.get("DB_PASSWORD", ""),
+        metadata={
+            "description": "Database password",
+            "default": ""
+        }
+    )
+
+    charset: str | PGSQLCharset = field(
+        default_factory=lambda: Env.get("DB_CHARSET", PGSQLCharset.UTF8),
+        metadata={
+            "description": "Database charset",
+            "default": "utf8"
+        }
+    )
+
+    prefix: str = field(
+        default="",
+        metadata={
+            "description": "Table prefix",
+            "default": ""
+        }
+    )
+
+    prefix_indexes: bool = field(
+        default=True,
+        metadata={
+            "description": "Whether to prefix indexes",
+            "default": True
+        }
+    )
+
+    search_path: str = field(
+        default="public",
+        metadata={
+            "description": "PostgreSQL schema search_path",
+            "default": "public"
+        }
+    )
+
+    sslmode: str | PGSQLSSLMode = field(
+        default=PGSQLSSLMode.PREFER,
+        metadata={
+            "description": "Connection SSL mode",
+            "default": PGSQLSSLMode.PREFER
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Validates the initialization of the database entity attributes after object creation.
+
+        Raises:
+            OrionisIntegrityException: If any of the following conditions are not met:
+                - 'driver' is a non-empty string.
+                - 'url' is either None or a non-empty string.
+                - 'host' is a non-empty string.
+                - 'port' is a numeric string.
+                - 'database' is a non-empty string.
+                - 'username' is a non-empty string.
+                - 'password' is a string.
+                - 'charset' is a non-empty string.
+                - 'prefix' is a string.
+                - 'prefix_indexes' is a boolean.
+                - 'search_path' is a non-empty string.
+                - 'sslmode' is a non-empty string.
+        """
+
+        if not isinstance(self.driver, str) or not self.driver:
+            raise OrionisIntegrityException(f"The 'driver' attribute must be a non-empty string. Received: {self.driver!r}")
+
+        if not isinstance(self.host, str) or not self.host.strip():
+            raise OrionisIntegrityException(f"The 'host' attribute must be a non-empty string. Received: {self.host!r}")
+
+        if not isinstance(self.port, str) or not self.port.isdigit():
+            raise OrionisIntegrityException(f"The 'port' attribute must be a numeric string. Received: {self.port!r}")
+
+        if not isinstance(self.database, str) or not self.database.strip():
+            raise OrionisIntegrityException(f"The 'database' attribute must be a non-empty string. Received: {self.database!r}")
+
+        if not isinstance(self.username, str) or not self.username.strip():
+            raise OrionisIntegrityException(f"The 'username' attribute must be a non-empty string. Received: {self.username!r}")
+
+        if not isinstance(self.password, str):
+            raise OrionisIntegrityException(f"The 'password' attribute must be a string. Received: {self.password!r}")
+
+        options_charset = PGSQLCharset._member_names_
+        if isinstance(self.charset, str):
+            _value = self.charset.upper().strip()
+            if _value not in options_charset:
+                raise OrionisIntegrityException(f"The 'charset' attribute must be a valid option {str(PGSQLCharset._member_names_)}")
+            else:
+                self.charset = PGSQLCharset[_value].value
+        else:
+            self.charset = self.charset.value
+
+        if not isinstance(self.prefix, str):
+            raise OrionisIntegrityException(f"The 'prefix' attribute must be a string. Received: {self.prefix!r}")
+
+        if not isinstance(self.prefix_indexes, bool):
+            raise OrionisIntegrityException(f"The 'prefix_indexes' attribute must be boolean. Received: {self.prefix_indexes!r}")
+
+        if not isinstance(self.search_path, str) or not self.search_path.strip():
+            raise OrionisIntegrityException(f"The 'search_path' attribute must be a non-empty string. Received: {self.search_path!r}")
+
+        if not isinstance(self.sslmode, (str, PGSQLSSLMode)):
+            raise OrionisIntegrityException(f"The 'sslmode' attribute must be a string or PGSQLSSLMode. Received: {self.sslmode!r}")
+
+        options_sslmode = PGSQLSSLMode._member_names_
+        if isinstance(self.sslmode, str):
+            _value = self.sslmode.upper().strip()
+            if _value not in options_sslmode:
+                raise OrionisIntegrityException(f"The 'sslmode' attribute must be a valid option {str(PGSQLSSLMode._member_names_)}")
+            else:
+                self.sslmode = PGSQLSSLMode[_value].value
+        else:
+            self.sslmode = self.sslmode.value
+
+    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/database/entities/sqlite.py

@@ -0,0 +1,178 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.database.enums.sqlite_foreign_key import SQLiteForeignKey
+from orionis.luminate.foundation.config.database.enums.sqlite_journal import SQLiteJournalMode
+from orionis.luminate.foundation.config.database.enums.sqlite_synchronous import SQLiteSynchronous
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.services.environment.env import Env
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class SQLite:
+    """
+    Data class to represent the SQLite database configuration.
+
+    Attributes
+    ----------
+    driver : str
+        The database driver being used, e.g., 'sqlite'.
+    url : str
+        The URL for connecting to the database.
+    database : str
+        The path to the SQLite database file.
+    prefix : str
+        Prefix for table names.
+    foreign_key_constraints : bool
+        Whether foreign key constraints are enabled.
+    busy_timeout : Optional[int]
+        The timeout period (in milliseconds) before retrying a locked database.
+    journal_mode : Optional[str]
+        The journal mode used for transactions.
+    synchronous : Optional[str]
+        The synchronization level for the database.
+    """
+
+    driver: str = field(
+        default='sqlite',
+        metadata={
+            "description": "The database driver being used.",
+            "example": "sqlite",
+        },
+    )
+
+    url: str = field(
+        default_factory=lambda: Env.get('DB_URL', 'sqlite:///' + Env.get('DB_DATABASE', 'database/database.sqlite')),
+        metadata={
+            "description": "The URL for connecting to the database.",
+            "example": "sqlite:///database/database.sqlite",
+        },
+    )
+
+    database: str = field(
+        default_factory=lambda: Env.get('DB_DATABASE', 'database.sqlite'),
+        metadata={
+            "description": "The path to the SQLite database file.",
+            "example": "database.sqlite",
+        },
+    )
+
+    prefix: str = field(
+        default_factory=lambda: Env.get('DB_PREFIX', ''),
+        metadata={
+            "description": "Prefix for table names.",
+            "example": "",
+        },
+    )
+
+    foreign_key_constraints: bool | SQLiteForeignKey = field(
+        default_factory=lambda: Env.get('DB_FOREIGN_KEYS', SQLiteForeignKey.OFF),
+        metadata={
+            "description": "Whether foreign key constraints are enabled.",
+            "example": 'OFF',
+        },
+    )
+
+    busy_timeout: int = field(
+        default_factory=lambda: Env.get('DB_BUSY_TIMEOUT', 5000),
+        metadata={
+            "description": "The timeout period (in milliseconds) before retrying a locked database.",
+            "example": 5000,
+        },
+    )
+
+    journal_mode: str | SQLiteJournalMode = field(
+        default_factory=lambda: Env.get('DB_JOURNAL_MODE', SQLiteJournalMode.DELETE),
+        metadata={
+            "description": "The journal mode used for transactions.",
+            "example": "DELETE",
+        },
+    )
+
+    synchronous: str | SQLiteSynchronous = field(
+        default_factory=lambda: Env.get('DB_SYNCHRONOUS', SQLiteSynchronous.NORMAL),
+        metadata={
+            "description": "The synchronization level for the database.",
+            "example": "NORMAL",
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization validation for SQLite database configuration fields.
+        This method ensures that all configuration attributes are of the correct type and meet required constraints:
+        - `driver`: Must be a non-empty string (e.g., 'sqlite').
+        - `url`: Must be a non-empty string (e.g., 'sqlite:///database/database.sqlite').
+        - `database`: Must be a non-empty string representing the database file path.
+        - `prefix`: Must be a string (can be empty).
+        - `foreign_key_constraints`: Must be a boolean (True or False).
+        - `busy_timeout`: If provided, must be a non-negative integer (milliseconds) or None.
+        - `journal_mode`: If provided, must be a string or None (e.g., 'WAL', 'DELETE').
+        - `synchronous`: If provided, must be a string or None (e.g., 'FULL', 'NORMAL', 'OFF').
+        Raises:
+            OrionisIntegrityException: If any attribute fails its validation check.
+        """
+
+        # Validate driver
+        if not isinstance(self.driver, str) or not self.driver.strip():
+            raise OrionisIntegrityException("Invalid 'driver': must be a non-empty string (e.g., 'sqlite').")
+
+        # Validate url
+        if not isinstance(self.url, str) or not self.url.strip():
+            raise OrionisIntegrityException("Invalid 'url': must be a non-empty string (e.g., 'sqlite:///database/database.sqlite').")
+
+        # Validate database
+        if not isinstance(self.database, str) or not self.database.strip():
+            raise OrionisIntegrityException(f"Invalid 'database': must be a non-empty string representing the database file path.")
+
+        # Validate prefix
+        if not isinstance(self.prefix, str):
+            raise OrionisIntegrityException("Invalid 'prefix': must be a string (can be empty).")
+
+        # Validate foreign_key_constraints
+        options_foreign_keys = SQLiteForeignKey._member_names_
+        if isinstance(self.foreign_key_constraints, str):
+            _value = self.foreign_key_constraints.upper().strip()
+            if _value not in options_foreign_keys:
+                raise OrionisIntegrityException(
+                    f"The 'foreign_key_constraints' attribute must be a valid option {str(SQLiteForeignKey._member_names_)}"
+                )
+            else:
+                self.foreign_key_constraints = SQLiteForeignKey[_value].value
+        else:
+            self.foreign_key_constraints = self.foreign_key_constraints.value
+
+        # Validate busy_timeout
+        if self.busy_timeout is not None and (not isinstance(self.busy_timeout, int) or self.busy_timeout < 0):
+            raise OrionisIntegrityException("Invalid 'busy_timeout': must be a non-negative integer (milliseconds) or None.")
+
+        # Validate journal_mode
+        options_journal_mode = SQLiteJournalMode._member_names_
+        if isinstance(self.journal_mode, str):
+            _value = self.journal_mode.upper().strip()
+            if _value not in options_journal_mode:
+                raise OrionisIntegrityException(
+                    f"The 'journal_mode' attribute must be a valid option {str(SQLiteJournalMode._member_names_)}"
+                )
+            else:
+                self.journal_mode = SQLiteJournalMode[_value].value
+        else:
+            self.journal_mode = self.journal_mode.value
+
+        # Validate synchronous
+        options_synchronous = SQLiteSynchronous._member_names_
+        if isinstance(self.synchronous, str):
+            _value = self.synchronous.upper().strip()
+            if _value not in options_synchronous:
+                raise OrionisIntegrityException(
+                    f"The 'synchronous' attribute must be a valid option {str(SQLiteSynchronous._member_names_)}"
+                )
+            else:
+                self.synchronous = SQLiteSynchronous[_value].value
+        else:
+            self.synchronous = self.synchronous.value
+
+    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/database/enums/mysql_charsets.py

@@ -0,0 +1,92 @@
+from enum import Enum
+
+class MySQLCharset(Enum):
+    """
+    Enumeration of supported MySQL character sets.
+    Each member of this enum represents a valid character set name that can be used in MySQL database configurations.
+    These character sets determine how text is stored and compared in the database.
+    Attributes:
+        ARMSCII8: Armenian Standard Code for Information Interchange, 8-bit.
+        ASCII: US ASCII.
+        BIG5: Big5 Traditional Chinese.
+        BINARY: Binary pseudo charset.
+        CP1250: Windows Central European.
+        CP1251: Windows Cyrillic.
+        CP1256: Windows Arabic.
+        CP1257: Windows Baltic.
+        CP850: DOS West European.
+        CP852: DOS Central European.
+        CP866: DOS Russian.
+        CP932: SJIS for Windows Japanese.
+        DEC8: DEC West European.
+        EUCJPMS: UJIS for Windows Japanese.
+        EUCKR: EUC-KR Korean.
+        GB2312: GB2312 Simplified Chinese.
+        GBK: GBK Simplified Chinese.
+        GEOSTD8: GEOSTD8 Georgian.
+        GREEK: ISO 8859-7 Greek.
+        HEBREW: ISO 8859-8 Hebrew.
+        HP8: HP West European.
+        KEYBCS2: DOS Kamenicky Czech-Slovak.
+        KOI8R: KOI8-R Relcom Russian.
+        KOI8U: KOI8-U Ukrainian.
+        LATIN1: cp1252 West European.
+        LATIN2: ISO 8859-2 Central European.
+        LATIN5: ISO 8859-9 Turkish.
+        LATIN7: ISO 8859-13 Baltic.
+        MACCE: Mac Central European.
+        MACROMAN: Mac West European.
+        SJIS: Shift-JIS Japanese.
+        SWE7: 7bit Swedish.
+        TIS620: TIS620 Thai.
+        UCS2: UCS-2 Unicode.
+        UJIS: EUC-JP Japanese.
+        UTF16: UTF-16 Unicode.
+        UTF16LE: UTF-16LE Unicode.
+        UTF32: UTF-32 Unicode.
+        UTF8: UTF-8 Unicode.
+        UTF8MB3: UTF-8 Unicode (3-byte).
+        UTF8MB4: UTF-8 Unicode (4-byte).
+    """
+
+    ARMSCII8 = "armscii8"
+    ASCII = "ascii"
+    BIG5 = "big5"
+    BINARY = "binary"
+    CP1250 = "cp1250"
+    CP1251 = "cp1251"
+    CP1256 = "cp1256"
+    CP1257 = "cp1257"
+    CP850 = "cp850"
+    CP852 = "cp852"
+    CP866 = "cp866"
+    CP932 = "cp932"
+    DEC8 = "dec8"
+    EUCJPMS = "eucjpms"
+    EUCKR = "euckr"
+    GB2312 = "gb2312"
+    GBK = "gbk"
+    GEOSTD8 = "geostd8"
+    GREEK = "greek"
+    HEBREW = "hebrew"
+    HP8 = "hp8"
+    KEYBCS2 = "keybcs2"
+    KOI8R = "koi8r"
+    KOI8U = "koi8u"
+    LATIN1 = "latin1"
+    LATIN2 = "latin2"
+    LATIN5 = "latin5"
+    LATIN7 = "latin7"
+    MACCE = "macce"
+    MACROMAN = "macroman"
+    SJIS = "sjis"
+    SWE7 = "swe7"
+    TIS620 = "tis620"
+    UCS2 = "ucs2"
+    UJIS = "ujis"
+    UTF16 = "utf16"
+    UTF16LE = "utf16le"
+    UTF32 = "utf32"
+    UTF8 = "utf8"
+    UTF8MB3 = "utf8mb3"
+    UTF8MB4 = "utf8mb4"

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

@@ -0,0 +1,53 @@
+from enum import Enum
+
+class MySQLCollation(Enum):
+    """
+    Enumeration of common MySQL collations.
+    This enum provides a set of string constants representing various MySQL collations,
+    including those for UTF-8, UTF-8MB4, Latin1, ASCII, UCS2, UTF16, and UTF32 character sets.
+    Each member corresponds to a specific collation name as used in MySQL databases.
+    Attributes:
+        UTF8_GENERAL_CI: 'utf8_general_ci' - UTF-8, case-insensitive, general collation.
+        UTF8_UNICODE_CI: 'utf8_unicode_ci' - UTF-8, case-insensitive, Unicode collation.
+        UTF8_BIN: 'utf8_bin' - UTF-8, binary collation.
+        UTF8MB4_GENERAL_CI: 'utf8mb4_general_ci' - UTF-8MB4, case-insensitive, general collation.
+        UTF8MB4_UNICODE_CI: 'utf8mb4_unicode_ci' - UTF-8MB4, case-insensitive, Unicode collation.
+        UTF8MB4_BIN: 'utf8mb4_bin' - UTF-8MB4, binary collation.
+        LATIN1_SWEDISH_CI: 'latin1_swedish_ci' - Latin1, case-insensitive, Swedish collation.
+        LATIN1_GENERAL_CI: 'latin1_general_ci' - Latin1, case-insensitive, general collation.
+        LATIN1_BIN: 'latin1_bin' - Latin1, binary collation.
+        ASCII_GENERAL_CI: 'ascii_general_ci' - ASCII, case-insensitive, general collation.
+        ASCII_BIN: 'ascii_bin' - ASCII, binary collation.
+        UCS2_GENERAL_CI: 'ucs2_general_ci' - UCS2, case-insensitive, general collation.
+        UCS2_UNICODE_CI: 'ucs2_unicode_ci' - UCS2, case-insensitive, Unicode collation.
+        UCS2_BIN: 'ucs2_bin' - UCS2, binary collation.
+        UTF16_GENERAL_CI: 'utf16_general_ci' - UTF-16, case-insensitive, general collation.
+        UTF16_UNICODE_CI: 'utf16_unicode_ci' - UTF-16, case-insensitive, Unicode collation.
+        UTF16_BIN: 'utf16_bin' - UTF-16, binary collation.
+        UTF32_GENERAL_CI: 'utf32_general_ci' - UTF-32, case-insensitive, general collation.
+        UTF32_UNICODE_CI: 'utf32_unicode_ci' - UTF-32, case-insensitive, Unicode collation.
+        UTF32_BIN: 'utf32_bin' - UTF-32, binary collation.
+    Methods:
+        list(): Returns a list of all collation string values defined in the enumeration.
+    """
+
+    UTF8_GENERAL_CI = "utf8_general_ci"
+    UTF8_UNICODE_CI = "utf8_unicode_ci"
+    UTF8_BIN = "utf8_bin"
+    UTF8MB4_GENERAL_CI = "utf8mb4_general_ci"
+    UTF8MB4_UNICODE_CI = "utf8mb4_unicode_ci"
+    UTF8MB4_BIN = "utf8mb4_bin"
+    LATIN1_SWEDISH_CI = "latin1_swedish_ci"
+    LATIN1_GENERAL_CI = "latin1_general_ci"
+    LATIN1_BIN = "latin1_bin"
+    ASCII_GENERAL_CI = "ascii_general_ci"
+    ASCII_BIN = "ascii_bin"
+    UCS2_GENERAL_CI = "ucs2_general_ci"
+    UCS2_UNICODE_CI = "ucs2_unicode_ci"
+    UCS2_BIN = "ucs2_bin"
+    UTF16_GENERAL_CI = "utf16_general_ci"
+    UTF16_UNICODE_CI = "utf16_unicode_ci"
+    UTF16_BIN = "utf16_bin"
+    UTF32_GENERAL_CI = "utf32_general_ci"
+    UTF32_UNICODE_CI = "utf32_unicode_ci"
+    UTF32_BIN = "utf32_bin"

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

@@ -0,0 +1,18 @@
+from enum import Enum
+
+class MySQLEngine(Enum):
+    """
+    Enumeration of supported MySQL storage engines.
+
+    Attributes:
+        INNODB: Default transactional storage engine, supports ACID compliance and foreign keys.
+        MYISAM: Legacy non-transactional storage engine, faster for read-heavy workloads but lacks transaction support.
+        MEMORY: Stores all data in RAM for fast access, data is lost on server restart.
+        NDB: Clustered storage engine designed for distributed MySQL setups.
+
+    Use this enum to specify the desired storage engine when configuring MySQL database tables.
+    """
+    INNODB = "InnoDB"      # Default engine (transactional)
+    MYISAM = "MyISAM"      # Legacy engine (non-transactional)
+    MEMORY = "MEMORY"      # In-memory storage
+    NDB = "NDB"            # Clustered storage engine

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

@@ -0,0 +1,44 @@
+from enum import Enum
+
+class OracleEncoding(Enum):
+    """
+    Enumeration of common Oracle database character encodings.
+
+    Each member represents a specific Oracle encoding name, typically used for database character set configuration.
+    The enum values correspond to Oracle's official encoding identifiers.
+
+    Members:
+        AL32UTF8: Unicode UTF-8 (recommended)
+        AR8MSWIN1256: Arabic Windows
+        JA16EUC: Japanese EUC
+        JA16SJIS: Japanese Shift-JIS
+        KO16MSWIN949: Korean Windows
+        TH8TISASCII: Thai
+        TR8MSWIN1254: Turkish Windows
+        WE8ISO8859P1: Western European ISO
+        WE8MSWIN1252: Western European Windows
+        ZHS16GBK: Simplified Chinese GBK
+        ZHT16BIG5: Traditional Chinese Big5
+        ZHT32EUC: Traditional Chinese EUC
+        CL8MSWIN1251: Cyrillic Windows
+        EE8MSWIN1250: Central European Windows
+        EL8MSWIN1253: Greek Windows
+        IW8MSWIN1255: Hebrew Windows
+    """
+
+    AL32UTF8 = "AL32UTF8"              # Unicode UTF-8 (recomendado)
+    AR8MSWIN1256 = "AR8MSWIN1256"      # Arabic Windows
+    JA16EUC = "JA16EUC"                # Japanese EUC
+    JA16SJIS = "JA16SJIS"              # Japanese Shift-JIS
+    KO16MSWIN949 = "KO16MSWIN949"      # Korean Windows
+    TH8TISASCII = "TH8TISASCII"        # Thai
+    TR8MSWIN1254 = "TR8MSWIN1254"      # Turkish Windows
+    WE8ISO8859P1 = "WE8ISO8859P1"      # Western European ISO
+    WE8MSWIN1252 = "WE8MSWIN1252"      # Western European Windows
+    ZHS16GBK = "ZHS16GBK"              # Simplified Chinese GBK
+    ZHT16BIG5 = "ZHT16BIG5"            # Traditional Chinese Big5
+    ZHT32EUC = "ZHT32EUC"              # Traditional Chinese EUC
+    CL8MSWIN1251 = "CL8MSWIN1251"      # Cyrillic Windows
+    EE8MSWIN1250 = "EE8MSWIN1250"      # Central European Windows
+    EL8MSWIN1253 = "EL8MSWIN1253"      # Greek Windows
+    IW8MSWIN1255 = "IW8MSWIN1255"      # Hebrew Windows

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

@@ -0,0 +1,31 @@
+from enum import Enum
+
+class OracleNencoding(Enum):
+    """
+    Represents a specific type of Oracle encoding for NCHAR and NVARCHAR2 data types.
+
+    This class inherits from OracleEncoding and can be extended to implement
+    custom behaviors or properties related to Oracle's national character set encoding.
+
+    Attributes:
+        Inherits all attributes from OracleEncoding.
+
+    Methods:
+        Inherits all methods from OracleEncoding.
+    """
+    AL32UTF8 = "AL32UTF8"              # Unicode UTF-8 (recomendado)
+    AR8MSWIN1256 = "AR8MSWIN1256"      # Arabic Windows
+    JA16EUC = "JA16EUC"                # Japanese EUC
+    JA16SJIS = "JA16SJIS"              # Japanese Shift-JIS
+    KO16MSWIN949 = "KO16MSWIN949"      # Korean Windows
+    TH8TISASCII = "TH8TISASCII"        # Thai
+    TR8MSWIN1254 = "TR8MSWIN1254"      # Turkish Windows
+    WE8ISO8859P1 = "WE8ISO8859P1"      # Western European ISO
+    WE8MSWIN1252 = "WE8MSWIN1252"      # Western European Windows
+    ZHS16GBK = "ZHS16GBK"              # Simplified Chinese GBK
+    ZHT16BIG5 = "ZHT16BIG5"            # Traditional Chinese Big5
+    ZHT32EUC = "ZHT32EUC"              # Traditional Chinese EUC
+    CL8MSWIN1251 = "CL8MSWIN1251"      # Cyrillic Windows
+    EE8MSWIN1250 = "EE8MSWIN1250"      # Central European Windows
+    EL8MSWIN1253 = "EL8MSWIN1253"      # Greek Windows
+    IW8MSWIN1255 = "IW8MSWIN1255"      # Hebrew Windows