sqlspec 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sqlspec/adapters/asyncpg/config.py

@@ -1,12 +1,9 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from asyncpg import Record
 from asyncpg import create_pool as asyncpg_create_pool
-from asyncpg.connection import Connection
 from asyncpg.pool import Pool, PoolConnectionProxy
 from typing_extensions import TypeAlias
 
@@ -19,6 +16,8 @@ if TYPE_CHECKING:
     from asyncio import AbstractEventLoop  # pyright: ignore[reportAttributeAccessIssue]
     from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine
 
+    from asyncpg.connection import Connection
+
 
 __all__ = (
     "AsyncPgConfig",
@@ -28,7 +27,7 @@ __all__ = (
 
 T = TypeVar("T")
 
-PgConnection: TypeAlias = Union[Connection, PoolConnectionProxy]
+PgConnection: TypeAlias = "Union[Connection, PoolConnectionProxy]"  # pyright: ignore[reportMissingTypeArgument]
 
 
 @dataclass
@@ -41,57 +40,57 @@ class AsyncPgPoolConfig(GenericPoolConfig):
     dsn: str
     """Connection arguments specified using as a single string in the following format: ``postgres://user:pass@host:port/database?option=value``
     """
-    connect_kwargs: dict[Any, Any] | None | EmptyType = Empty
+    connect_kwargs: "Optional[Union[dict[Any, Any], EmptyType]]" = Empty
     """A dictionary of arguments which will be passed directly to the ``connect()`` method as keyword arguments.
     """
-    connection_class: type[Connection] | None | EmptyType = Empty
+    connection_class: "Optional[Union[type[Connection], EmptyType]]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """The class to use for connections. Must be a subclass of Connection
     """
-    record_class: type[Record] | EmptyType = Empty
+    record_class: "Union[type[Record], EmptyType]" = Empty
     """If specified, the class to use for records returned by queries on the connections in this pool. Must be a subclass of Record."""
 
-    min_size: int | EmptyType = Empty
+    min_size: "Union[int, EmptyType]" = Empty
     """The number of connections to keep open inside the connection pool."""
-    max_size: int | EmptyType = Empty
+    max_size: "Union[int, EmptyType]" = Empty
     """The number of connections to allow in connection pool “overflow”, that is connections that can be opened above
     and beyond the pool_size setting, which defaults to 10."""
 
-    max_queries: int | EmptyType = Empty
+    max_queries: "Union[int, EmptyType]" = Empty
     """Number of queries after a connection is closed and replaced with a new connection.
     """
-    max_inactive_connection_lifetime: float | EmptyType = Empty
+    max_inactive_connection_lifetime: "Union[float, EmptyType]" = Empty
     """Number of seconds after which inactive connections in the pool will be closed. Pass 0 to disable this mechanism."""
 
-    setup: Coroutine[None, type[Connection], Any] | EmptyType = Empty
+    setup: "Union[Coroutine[None, type[Connection], Any], EmptyType]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """A coroutine to prepare a connection right before it is returned from Pool.acquire(). An example use case would be to automatically set up notifications listeners for all connections of a pool."""
-    init: Coroutine[None, type[Connection], Any] | EmptyType = Empty
+    init: "Union[Coroutine[None, type[Connection], Any], EmptyType]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """A coroutine to prepare a connection right before it is returned from Pool.acquire(). An example use case would be to automatically set up notifications listeners for all connections of a pool."""
 
-    loop: AbstractEventLoop | EmptyType = Empty
+    loop: "Union[AbstractEventLoop, EmptyType]" = Empty
     """An asyncio event loop instance. If None, the default event loop will be used."""
 
 
 @dataclass
-class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):
+class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):  # pyright: ignore[reportMissingTypeArgument]
     """Asyncpg Configuration."""
 
-    pool_config: AsyncPgPoolConfig | None = None
+    pool_config: "Optional[AsyncPgPoolConfig]" = None
     """Asyncpg Pool configuration"""
-    json_deserializer: Callable[[str], Any] = decode_json
+    json_deserializer: "Callable[[str], Any]" = decode_json
     """For dialects that support the :class:`JSON <sqlalchemy.types.JSON>` datatype, this is a Python callable that will
     convert a JSON string to a Python object. By default, this is set to SQLSpec's
     :attr:`decode_json() <sqlspec._serialization.decode_json>` function."""
-    json_serializer: Callable[[Any], str] = encode_json
+    json_serializer: "Callable[[Any], str]" = encode_json
     """For dialects that support the JSON datatype, this is a Python callable that will render a given object as JSON.
     By default, SQLSpec's :attr:`encode_json() <sqlspec._serialization.encode_json>` is used."""
-    pool_instance: Pool | None = None
+    pool_instance: "Optional[Pool[Any]]" = None
     """Optional pool to use.
 
     If set, the plugin will use the provided pool rather than instantiate one.
     """
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
@@ -103,7 +102,7 @@ class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    async def create_pool(self) -> Pool:
+    async def create_pool(self) -> "Pool":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -125,21 +124,21 @@ class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):
             )
         return self.pool_instance
 
-    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[Pool]:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[Pool]":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Create a pool instance.
 
         Returns:
             A Pool instance.
         """
-        return self.create_pool()
+        return self.create_pool()  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[PoolConnectionProxy, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[PoolConnectionProxy, None]":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Create a connection instance.
 
         Returns:
             A connection instance.
         """
-        db_pool = await self.provide_pool(*args, **kwargs)
-        async with db_pool.acquire() as connection:
+        db_pool = await self.provide_pool(*args, **kwargs)  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+        async with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownVariableType]
             yield connection

sqlspec/adapters/duckdb/config.py

@@ -1,10 +1,9 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Union, cast
 
 from duckdb import DuckDBPyConnection
+from typing_extensions import NotRequired, TypedDict
 
 from sqlspec.base import NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
@@ -17,8 +16,7 @@ if TYPE_CHECKING:
 __all__ = ("DuckDBConfig", "ExtensionConfig")
 
 
-@dataclass
-class ExtensionConfig:
+class ExtensionConfig(TypedDict):
     """Configuration for a DuckDB extension.
 
     This class provides configuration options for DuckDB extensions, including installation
@@ -29,41 +27,17 @@ class ExtensionConfig:
 
     name: str
     """The name of the extension to install"""
-    config: dict[str, Any] | None = None
+    config: "NotRequired[dict[str, Any]]"
     """Optional configuration settings to apply after installation"""
-    force_install: bool = False
+    force_install: "NotRequired[bool]"
     """Whether to force reinstall if already present"""
-    repository: str | None = None
+    repository: "NotRequired[str]"
     """Optional repository name to install from"""
-    repository_url: str | None = None
+    repository_url: "NotRequired[str]"
     """Optional repository URL to install from"""
-    version: str | None = None
+    version: "NotRequired[str]"
     """Optional version of the extension to install"""
 
-    @classmethod
-    def from_dict(cls, name: str, config: dict[str, Any] | bool | None = None) -> ExtensionConfig:
-        """Create an ExtensionConfig from a configuration dictionary.
-
-        Args:
-            name: The name of the extension
-            config: Configuration dictionary that may contain settings
-
-        Returns:
-            A new ExtensionConfig instance
-        """
-        if config is None:
-            return cls(name=name)
-
-        if not isinstance(config, dict):
-            config = {"force_install": bool(config)}
-
-        install_args = {
-            key: config.pop(key)
-            for key in ["force_install", "repository", "repository_url", "version", "config", "name"]
-            if key in config
-        }
-        return cls(name=name, **install_args)
-
 
 @dataclass
 class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
@@ -75,28 +49,24 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
     For details see: https://duckdb.org/docs/api/python/overview#connection-options
     """
 
-    database: str | EmptyType = Empty
+    database: "Union[str, EmptyType]" = Empty
     """The path to the database file to be opened. Pass ":memory:" to open a connection to a database that resides in RAM instead of on disk. If not specified, an in-memory database will be created."""
 
-    read_only: bool | EmptyType = Empty
+    read_only: "Union[bool, EmptyType]" = Empty
     """If True, the database will be opened in read-only mode. This is required if multiple processes want to access the same database file at the same time."""
 
-    config: dict[str, Any] | EmptyType = Empty
+    config: "Union[dict[str, Any], EmptyType]" = Empty
     """A dictionary of configuration options to be passed to DuckDB. These can include settings like 'access_mode', 'max_memory', 'threads', etc.
 
     For details see: https://duckdb.org/docs/api/python/overview#connection-options
     """
 
-    extensions: Sequence[ExtensionConfig] | EmptyType = Empty
+    extensions: "Union[Sequence[ExtensionConfig], ExtensionConfig, EmptyType]" = Empty
     """A sequence of extension configurations to install and configure upon connection creation."""
 
     def __post_init__(self) -> None:
         """Post-initialization validation and processing.
 
-        This method handles merging extension configurations from both the extensions field
-        and the config dictionary, if present. The config['extensions'] field can be either:
-        - A dictionary mapping extension names to their configurations
-        - A list of extension names (which will be installed with force_install=True)
 
         Raises:
             ImproperConfigurationError: If there are duplicate extension configurations.
@@ -106,56 +76,81 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
 
         if self.extensions is Empty:
             self.extensions = []
+        if isinstance(self.extensions, dict):
+            self.extensions = [self.extensions]
         # this is purely for mypy
         assert isinstance(self.config, dict)  # noqa: S101
         assert isinstance(self.extensions, list)  # noqa: S101
+        config_exts: list[ExtensionConfig] = self.config.pop("extensions", [])
+        if not isinstance(config_exts, list):  # pyright: ignore[reportUnnecessaryIsInstance]
+            config_exts = [config_exts]  # type: ignore[unreachable]
 
-        _e = self.config.pop("extensions", {})
-        if not isinstance(_e, (dict, list, tuple)):
+        try:
+            if (
+                len(set({ext["name"] for ext in config_exts}).intersection({ext["name"] for ext in self.extensions}))
+                > 0
+            ):  # pyright: ignore[ reportUnknownArgumentType]
+                msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed.  Please use only one method to configure extensions."
+                raise ImproperConfigurationError(msg)
+        except (KeyError, TypeError) as e:
             msg = "When configuring extensions in the 'config' dictionary, the value must be a dictionary or sequence of extension names"
-            raise ImproperConfigurationError(msg)
-        if not isinstance(_e, dict):
-            _e = {str(ext): {"force_install": False} for ext in _e}  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
+            raise ImproperConfigurationError(msg) from e
+        self.extensions.extend(config_exts)
 
-        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:  # pyright: ignore[ reportUnknownArgumentType]
-            msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed"
-            raise ImproperConfigurationError(msg)
+    def _configure_connection(self, connection: "DuckDBPyConnection") -> None:
+        """Configure the connection.
 
-        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+        Args:
+            connection: The DuckDB connection to configure.
+        """
+        for config in cast("list[str]", self.config):
+            connection.execute(config)
 
-    def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
+    def _configure_extensions(self, connection: "DuckDBPyConnection") -> None:
         """Configure extensions for the connection.
 
         Args:
             connection: The DuckDB connection to configure extensions for.
 
-        Raises:
-            ImproperConfigurationError: If extension installation or configuration fails.
+
         """
         if self.extensions is Empty:
             return
 
         for extension in cast("list[ExtensionConfig]", self.extensions):
-            try:
-                if extension.force_install:
-                    connection.install_extension(
-                        extension=extension.name,
-                        force_install=extension.force_install,
-                        repository=extension.repository,
-                        repository_url=extension.repository_url,
-                        version=extension.version,
-                    )
-                connection.load_extension(extension.name)
-
-                if extension.config:
-                    for key, value in extension.config.items():
-                        connection.execute(f"SET {key}={value}")
-            except Exception as e:
-                msg = f"Failed to configure extension {extension.name}. Error: {e!s}"
-                raise ImproperConfigurationError(msg) from e
+            self._configure_extension(connection, extension)
+
+    @staticmethod
+    def _configure_extension(connection: "DuckDBPyConnection", extension: ExtensionConfig) -> None:
+        """Configure a single extension for the connection.
+
+        Args:
+            connection: The DuckDB connection to configure extension for.
+            extension: The extension configuration to apply.
+
+        Raises:
+            ImproperConfigurationError: If extension installation or configuration fails.
+        """
+        try:
+            if extension.get("force_install"):
+                connection.install_extension(
+                    extension=extension["name"],
+                    force_install=extension.get("force_install", False),
+                    repository=extension.get("repository"),
+                    repository_url=extension.get("repository_url"),
+                    version=extension.get("version"),
+                )
+            connection.load_extension(extension["name"])
+
+            if extension.get("config"):
+                for key, value in extension.get("config", {}).items():
+                    connection.execute(f"SET {key}={value}")
+        except Exception as e:
+            msg = f"Failed to configure extension {extension['name']}. Error: {e!s}"
+            raise ImproperConfigurationError(msg) from e
 
     @property
-    def connection_config_dict(self) -> dict[str, Any]:
+    def connection_config_dict(self) -> "dict[str, Any]":
         """Return the connection configuration as a dict.
 
         Returns:
@@ -166,7 +161,7 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
             config["database"] = ":memory:"
         return config
 
-    def create_connection(self) -> DuckDBPyConnection:
+    def create_connection(self) -> "DuckDBPyConnection":
         """Create and return a new database connection with configured extensions.
 
         Returns:
@@ -180,20 +175,21 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
         try:
             connection = duckdb.connect(**self.connection_config_dict)  # pyright: ignore[reportUnknownMemberType]
             self._configure_extensions(connection)
-            return connection
+            self._configure_connection(connection)
         except Exception as e:
             msg = f"Could not configure the DuckDB connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
+        else:
+            return connection
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[DuckDBPyConnection, None, None]:
+    def provide_connection(self, *args: Any, **kwargs: Any) -> "Generator[DuckDBPyConnection, None, None]":
         """Create and provide a database connection.
 
         Yields:
             A DuckDB connection instance.
 
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
+
         """
         connection = self.create_connection()
         try:

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -1,8 +1,6 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 from oracledb import create_pool_async as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import AsyncConnection
@@ -17,7 +15,7 @@ from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
-    from typing import Any
+
 
 __all__ = (
     "OracleAsyncDatabaseConfig",
@@ -44,16 +42,16 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
     options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
     """
 
-    pool_config: OracleAsyncPoolConfig | None = None
+    pool_config: "Optional[OracleAsyncPoolConfig]" = None
     """Oracle Pool configuration"""
-    pool_instance: AsyncConnectionPool | None = None
+    pool_instance: "Optional[AsyncConnectionPool]" = None
     """Optional pool to use.
 
     If set, the plugin will use the provided pool rather than instantiate one.
     """
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
@@ -65,7 +63,7 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    async def create_pool(self) -> AsyncConnectionPool:
+    async def create_pool(self) -> "AsyncConnectionPool":
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -81,11 +79,11 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
         pool_config = self.pool_config_dict
         self.pool_instance = oracledb_create_pool(**pool_config)
         if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
-            msg = "Could not configure the 'pool_instance'. Please check your configuration."
+            msg = "Could not configure the 'pool_instance'. Please check your configuration."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[AsyncConnectionPool]:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[AsyncConnectionPool]":
         """Create a pool instance.
 
         Returns:
@@ -94,7 +92,7 @@ class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnec
         return self.create_pool()
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[AsyncConnection, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[AsyncConnection, None]":
         """Create a connection instance.
 
         Returns:

sqlspec/adapters/oracledb/config/_common.py

@@ -1,7 +1,5 @@
-from __future__ import annotations
-
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar
+from typing import TYPE_CHECKING, Generic, TypeVar, Union
 
 from oracledb import ConnectionPool
 
@@ -24,8 +22,8 @@ __all__ = ("OracleGenericPoolConfig",)
 
 T = TypeVar("T")
 
-ConnectionT = TypeVar("ConnectionT", bound="Connection | AsyncConnection")
-PoolT = TypeVar("PoolT", bound="ConnectionPool | AsyncConnectionPool")
+ConnectionT = TypeVar("ConnectionT", bound="Union[Connection, AsyncConnection]")
+PoolT = TypeVar("PoolT", bound="Union[ConnectionPool, AsyncConnectionPool]")
 
 
 @dataclass
@@ -37,97 +35,97 @@ class OracleGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
     settings.([1](https://python-oracledb.readthedocs.io/en/latest/api_manual/module.html))
     """
 
-    conn_class: type[ConnectionT] | EmptyType = Empty
+    conn_class: "Union[type[ConnectionT], EmptyType]" = Empty
     """The connection class to use (Connection or AsyncConnection)"""
-    dsn: str | EmptyType = Empty
+    dsn: "Union[str, EmptyType]" = Empty
     """Connection string for the database   """
-    pool: PoolT | EmptyType = Empty
+    pool: "Union[PoolT, EmptyType]" = Empty
     """Existing pool instance to use"""
-    params: ConnectParams | EmptyType = Empty
+    params: "Union[ConnectParams, EmptyType]" = Empty
     """Connection parameters object"""
-    user: str | EmptyType = Empty
+    user: "Union[str, EmptyType]" = Empty
     """Username for database authentication"""
-    proxy_user: str | EmptyType = Empty
+    proxy_user: "Union[str, EmptyType]" = Empty
     """Name of the proxy user to connect through"""
-    password: str | EmptyType = Empty
+    password: "Union[str, EmptyType]" = Empty
     """Password for database authentication"""
-    newpassword: str | EmptyType = Empty
+    newpassword: "Union[str, EmptyType]" = Empty
     """New password for password change operations"""
-    wallet_password: str | EmptyType = Empty
+    wallet_password: "Union[str, EmptyType]" = Empty
     """Password for accessing Oracle Wallet"""
-    access_token: str | tuple[str, ...] | Callable[[], str] | EmptyType = Empty
+    access_token: "Union[str, tuple[str, ...], Callable[[], str], EmptyType]" = Empty
     """Token for token-based authentication"""
-    host: str | EmptyType = Empty
+    host: "Union[str, EmptyType]" = Empty
     """Database server hostname"""
-    port: int | EmptyType = Empty
+    port: "Union[int, EmptyType]" = Empty
     """Database server port number"""
-    protocol: str | EmptyType = Empty
+    protocol: "Union[str, EmptyType]" = Empty
     """Network protocol (TCP or TCPS)"""
-    https_proxy: str | EmptyType = Empty
+    https_proxy: "Union[str, EmptyType]" = Empty
     """HTTPS proxy server address"""
-    https_proxy_port: int | EmptyType = Empty
+    https_proxy_port: "Union[int, EmptyType]" = Empty
     """HTTPS proxy server port"""
-    service_name: str | EmptyType = Empty
+    service_name: "Union[str, EmptyType]" = Empty
     """Oracle service name"""
-    sid: str | EmptyType = Empty
+    sid: "Union[str, EmptyType]" = Empty
     """Oracle System ID (SID)"""
-    server_type: str | EmptyType = Empty
+    server_type: "Union[str, EmptyType]" = Empty
     """Server type (dedicated, shared, pooled, or drcp)"""
-    cclass: str | EmptyType = Empty
+    cclass: "Union[str, EmptyType]" = Empty
     """Connection class for database resident connection pooling"""
-    purity: Purity | EmptyType = Empty
+    purity: "Union[Purity, EmptyType]" = Empty
     """Session purity (NEW, SELF, or DEFAULT)"""
-    expire_time: int | EmptyType = Empty
+    expire_time: "Union[int, EmptyType]" = Empty
     """Time in minutes after which idle connections are closed"""
-    retry_count: int | EmptyType = Empty
+    retry_count: "Union[int, EmptyType]" = Empty
     """Number of attempts to connect"""
-    retry_delay: int | EmptyType = Empty
+    retry_delay: "Union[int, EmptyType]" = Empty
     """Time in seconds between connection attempts"""
-    tcp_connect_timeout: float | EmptyType = Empty
+    tcp_connect_timeout: "Union[float, EmptyType]" = Empty
     """Timeout for establishing TCP connections"""
-    ssl_server_dn_match: bool | EmptyType = Empty
+    ssl_server_dn_match: "Union[bool, EmptyType]" = Empty
     """If True, verify server certificate DN"""
-    ssl_server_cert_dn: str | EmptyType = Empty
+    ssl_server_cert_dn: "Union[str, EmptyType]" = Empty
     """Expected server certificate DN"""
-    wallet_location: str | EmptyType = Empty
+    wallet_location: "Union[str, EmptyType]" = Empty
     """Location of Oracle Wallet"""
-    events: bool | EmptyType = Empty
+    events: "Union[bool, EmptyType]" = Empty
     """If True, enables Oracle events for FAN and RLB"""
-    externalauth: bool | EmptyType = Empty
+    externalauth: "Union[bool, EmptyType]" = Empty
     """If True, uses external authentication"""
-    mode: AuthMode | EmptyType = Empty
+    mode: "Union[AuthMode, EmptyType]" = Empty
     """Session mode (SYSDBA, SYSOPER, etc.)"""
-    disable_oob: bool | EmptyType = Empty
+    disable_oob: "Union[bool, EmptyType]" = Empty
     """If True, disables Oracle out-of-band breaks"""
-    stmtcachesize: int | EmptyType = Empty
+    stmtcachesize: "Union[int, EmptyType]" = Empty
     """Size of the statement cache"""
-    edition: str | EmptyType = Empty
+    edition: "Union[str, EmptyType]" = Empty
     """Edition name for edition-based redefinition"""
-    tag: str | EmptyType = Empty
+    tag: "Union[str, EmptyType]" = Empty
     """Connection pool tag"""
-    matchanytag: bool | EmptyType = Empty
+    matchanytag: "Union[bool, EmptyType]" = Empty
     """If True, allows connections with different tags"""
-    config_dir: str | EmptyType = Empty
+    config_dir: "Union[str, EmptyType]" = Empty
     """Directory containing Oracle configuration files"""
-    appcontext: list[str] | EmptyType = Empty
+    appcontext: "Union[list[str], EmptyType]" = Empty
     """Application context list"""
-    shardingkey: list[str] | EmptyType = Empty
+    shardingkey: "Union[list[str], EmptyType]" = Empty
     """Sharding key list"""
-    supershardingkey: list[str] | EmptyType = Empty
+    supershardingkey: "Union[list[str], EmptyType]" = Empty
     """Super sharding key list"""
-    debug_jdwp: str | EmptyType = Empty
+    debug_jdwp: "Union[str, EmptyType]" = Empty
     """JDWP debugging string"""
-    connection_id_prefix: str | EmptyType = Empty
+    connection_id_prefix: "Union[str, EmptyType]" = Empty
     """Prefix for connection identifiers"""
-    ssl_context: Any | EmptyType = Empty
+    ssl_context: "Union[Any, EmptyType]" = Empty
     """SSL context for TCPS connections"""
-    sdu: int | EmptyType = Empty
+    sdu: "Union[int, EmptyType]" = Empty
     """Session data unit size"""
-    pool_boundary: str | EmptyType = Empty
+    pool_boundary: "Union[str, EmptyType]" = Empty
     """Connection pool boundary (statement or transaction)"""
-    use_tcp_fast_open: bool | EmptyType = Empty
+    use_tcp_fast_open: "Union[bool, EmptyType]" = Empty
     """If True, enables TCP Fast Open"""
-    ssl_version: ssl.TLSVersion | EmptyType = Empty
+    ssl_version: "Union[ssl.TLSVersion, EmptyType]" = Empty
     """SSL/TLS protocol version"""
-    handle: int | EmptyType = Empty
+    handle: "Union[int, EmptyType]" = Empty
     """Oracle service context handle"""