sqlspec 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

sqlspec/adapters/oracledb/config/__init__.py

@@ -1,9 +0,0 @@
-from sqlspec.adapters.oracledb.config._asyncio import OracleAsyncConfig, OracleAsyncPoolConfig
-from sqlspec.adapters.oracledb.config._sync import OracleSyncConfig, OracleSyncPoolConfig
-
-__all__ = (
-    "OracleAsyncConfig",
-    "OracleAsyncPoolConfig",
-    "OracleSyncConfig",
-    "OracleSyncPoolConfig",
-)

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -1,186 +0,0 @@
-from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional, cast
-
-from oracledb import create_pool_async as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
-
-from sqlspec.adapters.oracledb.config._common import OracleGenericPoolConfig
-from sqlspec.adapters.oracledb.driver import OracleAsyncConnection, OracleAsyncDriver
-from sqlspec.base import AsyncDatabaseConfig
-from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.typing import dataclass_to_dict
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Awaitable
-
-    from oracledb.pool import AsyncConnectionPool
-
-
-__all__ = (
-    "OracleAsyncConfig",
-    "OracleAsyncPoolConfig",
-)
-
-
-@dataclass
-class OracleAsyncPoolConfig(OracleGenericPoolConfig["OracleAsyncConnection", "AsyncConnectionPool"]):
-    """Async Oracle Pool Config"""
-
-
-@dataclass
-class OracleAsyncConfig(AsyncDatabaseConfig["OracleAsyncConnection", "AsyncConnectionPool", "OracleAsyncDriver"]):
-    """Oracle Async database Configuration.
-
-    This class provides the base configuration for Oracle database connections, extending
-    the generic database configuration with Oracle-specific settings. It supports both
-    thin and thick modes of the python-oracledb driver.([1](https://python-oracledb.readthedocs.io/en/latest/index.html))
-
-    The configuration supports all standard Oracle connection parameters and can be used
-    with both synchronous and asynchronous connections. It includes support for features
-    like Oracle Wallet, external authentication, connection pooling, and advanced security
-    options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
-    """
-
-    pool_config: "Optional[OracleAsyncPoolConfig]" = None
-    """Oracle Pool configuration"""
-    pool_instance: "Optional[AsyncConnectionPool]" = None
-    """Optional pool to use.
-
-    If set, the plugin will use the provided pool rather than instantiate one.
-    """
-    connection_type: "type[OracleAsyncConnection]" = field(init=False, default_factory=lambda: OracleAsyncConnection)
-    """Connection class to use.
-
-    Defaults to :class:`AsyncConnection`.
-    """
-    driver_type: "type[OracleAsyncDriver]" = field(init=False, default_factory=lambda: OracleAsyncDriver)  # type: ignore[type-abstract,unused-ignore]
-    """Driver class to use.
-
-    Defaults to :class:`OracleAsyncDriver`.
-    """
-
-    @property
-    def connection_config_dict(self) -> "dict[str, Any]":
-        """Return the connection configuration as a dict.
-
-        Returns:
-            A string keyed dict of config kwargs for the oracledb.connect function.
-
-        Raises:
-            ImproperConfigurationError: If the connection configuration is not provided.
-        """
-        if self.pool_config:
-            # Filter out pool-specific parameters
-            pool_only_params = {
-                "min",
-                "max",
-                "increment",
-                "timeout",
-                "wait_timeout",
-                "max_lifetime_session",
-                "session_callback",
-            }
-            return dataclass_to_dict(
-                self.pool_config,
-                exclude_empty=True,
-                convert_nested=False,
-                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
-            )
-        msg = "You must provide a 'pool_config' for this adapter."
-        raise ImproperConfigurationError(msg)
-
-    @property
-    def pool_config_dict(self) -> "dict[str, Any]":
-        """Return the pool configuration as a dict.
-
-        Raises:
-            ImproperConfigurationError: If no pool_config is provided but a pool_instance
-
-        Returns:
-            A string keyed dict of config kwargs for the Asyncpg :func:`create_pool <oracledb.pool.create_pool>`
-            function.
-        """
-        if self.pool_config is not None:
-            return dataclass_to_dict(
-                self.pool_config,
-                exclude_empty=True,
-                convert_nested=False,
-                exclude={"pool_instance", "connection_type", "driver_type"},
-            )
-        msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
-        raise ImproperConfigurationError(msg)
-
-    async def create_connection(self) -> "OracleAsyncConnection":
-        """Create and return a new oracledb async connection from the pool.
-
-        Returns:
-            An AsyncConnection instance.
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be created.
-        """
-        try:
-            pool = await self.provide_pool()
-            return cast("OracleAsyncConnection", await pool.acquire())  # type: ignore[no-any-return,unused-ignore]
-        except Exception as e:
-            msg = f"Could not configure the Oracle async connection. Error: {e!s}"
-            raise ImproperConfigurationError(msg) from e
-
-    async def create_pool(self) -> "AsyncConnectionPool":
-        """Return a pool. If none exists yet, create one.
-
-        Raises:
-            ImproperConfigurationError: If neither pool_config nor pool_instance are provided,
-                or if the pool could not be configured.
-
-        Returns:
-            Getter that returns the pool instance used by the plugin.
-        """
-        if self.pool_instance is not None:
-            return self.pool_instance
-
-        if self.pool_config is None:
-            msg = "One of 'pool_config' or 'pool_instance' must be provided."
-            raise ImproperConfigurationError(msg)
-
-        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."  # type: ignore[unreachable]
-            raise ImproperConfigurationError(msg)
-        return self.pool_instance
-
-    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[AsyncConnectionPool]":
-        """Create a pool instance.
-
-        Returns:
-            A Pool instance.
-        """
-        return self.create_pool()
-
-    @asynccontextmanager
-    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[OracleAsyncConnection, None]":
-        """Create a connection instance.
-
-        Yields:
-            AsyncConnection: A connection instance.
-        """
-        db_pool = await self.provide_pool(*args, **kwargs)
-        async with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
-            yield connection
-
-    @asynccontextmanager
-    async def provide_session(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[OracleAsyncDriver, None]":
-        """Create and provide a database session.
-
-        Yields:
-            OracleAsyncDriver: A driver instance with an active connection.
-        """
-        async with self.provide_connection(*args, **kwargs) as connection:
-            yield self.driver_type(connection)
-
-    async def close_pool(self) -> None:
-        """Close the connection pool."""
-        if self.pool_instance is not None:
-            await self.pool_instance.close()
-            self.pool_instance = None

sqlspec/adapters/oracledb/config/_common.py

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

sqlspec/adapters/oracledb/config/_sync.py

@@ -1,186 +0,0 @@
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional
-
-from oracledb import create_pool as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
-
-from sqlspec.adapters.oracledb.config._common import OracleGenericPoolConfig
-from sqlspec.adapters.oracledb.driver import OracleSyncConnection, OracleSyncDriver
-from sqlspec.base import SyncDatabaseConfig
-from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.typing import dataclass_to_dict
-
-if TYPE_CHECKING:
-    from collections.abc import Generator
-
-    from oracledb.pool import ConnectionPool
-
-
-__all__ = (
-    "OracleSyncConfig",
-    "OracleSyncPoolConfig",
-)
-
-
-@dataclass
-class OracleSyncPoolConfig(OracleGenericPoolConfig["OracleSyncConnection", "ConnectionPool"]):
-    """Sync Oracle Pool Config"""
-
-
-@dataclass
-class OracleSyncConfig(SyncDatabaseConfig["OracleSyncConnection", "ConnectionPool", "OracleSyncDriver"]):
-    """Oracle Sync database Configuration.
-
-    This class provides the base configuration for Oracle database connections, extending
-    the generic database configuration with Oracle-specific settings. It supports both
-    thin and thick modes of the python-oracledb driver.([1](https://python-oracledb.readthedocs.io/en/latest/index.html))
-
-    The configuration supports all standard Oracle connection parameters and can be used
-    with both synchronous and asynchronous connections. It includes support for features
-    like Oracle Wallet, external authentication, connection pooling, and advanced security
-    options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
-    """
-
-    pool_config: "Optional[OracleSyncPoolConfig]" = None
-    """Oracle Pool configuration"""
-    pool_instance: "Optional[ConnectionPool]" = None
-    """Optional pool to use.
-
-    If set, the plugin will use the provided pool rather than instantiate one.
-    """
-    connection_type: "type[OracleSyncConnection]" = field(init=False, default_factory=lambda: OracleSyncConnection)  # pyright: ignore
-    """Connection class to use.
-
-    Defaults to :class:`Connection`.
-    """
-    driver_type: "type[OracleSyncDriver]" = field(init=False, default_factory=lambda: OracleSyncDriver)  # type: ignore[type-abstract,unused-ignore]
-    """Driver class to use.
-
-    Defaults to :class:`OracleSyncDriver`.
-    """
-
-    @property
-    def connection_config_dict(self) -> "dict[str, Any]":
-        """Return the connection configuration as a dict.
-
-        Returns:
-            A string keyed dict of config kwargs for the oracledb.connect function.
-
-        Raises:
-            ImproperConfigurationError: If the connection configuration is not provided.
-        """
-        if self.pool_config:
-            # Filter out pool-specific parameters
-            pool_only_params = {
-                "min",
-                "max",
-                "increment",
-                "timeout",
-                "wait_timeout",
-                "max_lifetime_session",
-                "session_callback",
-            }
-            return dataclass_to_dict(
-                self.pool_config,
-                exclude_empty=True,
-                convert_nested=False,
-                exclude=pool_only_params.union({"pool_instance", "connection_type", "driver_type"}),
-            )
-        msg = "You must provide a 'pool_config' for this adapter."
-        raise ImproperConfigurationError(msg)
-
-    @property
-    def pool_config_dict(self) -> "dict[str, Any]":
-        """Return the pool configuration as a dict.
-
-        Raises:
-            ImproperConfigurationError: If no pool_config is provided but a pool_instance
-
-        Returns:
-            A string keyed dict of config kwargs for the Asyncpg :func:`create_pool <oracledb.pool.create_pool>`
-            function.
-        """
-        if self.pool_config:
-            return dataclass_to_dict(
-                self.pool_config,
-                exclude_empty=True,
-                convert_nested=False,
-                exclude={"pool_instance", "connection_type", "driver_type"},
-            )
-        msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
-        raise ImproperConfigurationError(msg)
-
-    def create_connection(self) -> "OracleSyncConnection":
-        """Create and return a new oracledb connection from the pool.
-
-        Returns:
-            A Connection instance.
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be created.
-        """
-        try:
-            pool = self.provide_pool()
-            return pool.acquire()
-        except Exception as e:
-            msg = f"Could not configure the Oracle connection. Error: {e!s}"
-            raise ImproperConfigurationError(msg) from e
-
-    def create_pool(self) -> "ConnectionPool":
-        """Return a pool. If none exists yet, create one.
-
-        Raises:
-            ImproperConfigurationError: If neither pool_config nor pool_instance is provided,
-                or if the pool could not be configured.
-
-        Returns:
-            Getter that returns the pool instance used by the plugin.
-        """
-        if self.pool_instance is not None:
-            return self.pool_instance
-
-        if self.pool_config is None:
-            msg = "One of 'pool_config' or 'pool_instance' must be provided."
-            raise ImproperConfigurationError(msg)
-
-        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."  # type: ignore[unreachable]
-            raise ImproperConfigurationError(msg)
-        return self.pool_instance
-
-    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "ConnectionPool":
-        """Create a pool instance.
-
-        Returns:
-            A Pool instance.
-        """
-        return self.create_pool()
-
-    @contextmanager
-    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[OracleSyncConnection, None, None]":
-        """Create a connection instance.
-
-        Yields:
-            Connection: A connection instance from the pool.
-        """
-        db_pool = self.provide_pool(*args, **kwargs)
-        with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
-            yield connection
-
-    @contextmanager
-    def provide_session(self, *args: "Any", **kwargs: "Any") -> "Generator[OracleSyncDriver, None, None]":
-        """Create and provide a database session.
-
-        Yields:
-            OracleSyncDriver: A driver instance with an active connection.
-        """
-        with self.provide_connection(*args, **kwargs) as connection:
-            yield self.driver_type(connection)
-
-    def close_pool(self) -> None:
-        """Close the connection pool."""
-        if self.pool_instance is not None:
-            self.pool_instance.close()
-            self.pool_instance = None

sqlspec/adapters/psycopg/config/__init__.py

@@ -1,19 +0,0 @@
-from sqlspec.adapters.psycopg.config._async import PsycopgAsyncConfig, PsycopgAsyncPoolConfig
-from sqlspec.adapters.psycopg.config._sync import PsycopgSyncConfig, PsycopgSyncPoolConfig
-from sqlspec.adapters.psycopg.driver import (
-    PsycopgAsyncConnection,
-    PsycopgAsyncDriver,
-    PsycopgSyncConnection,
-    PsycopgSyncDriver,
-)
-
-__all__ = (
-    "PsycopgAsyncConfig",
-    "PsycopgAsyncConnection",
-    "PsycopgAsyncDriver",
-    "PsycopgAsyncPoolConfig",
-    "PsycopgSyncConfig",
-    "PsycopgSyncConnection",
-    "PsycopgSyncDriver",
-    "PsycopgSyncPoolConfig",
-)