sqlspec 0.65.0__py3-none-any.whl → 0.66.0__py3-none-any.whl

sqlspec/adapters/arrow_odbc/driver.py

@@ -574,7 +574,7 @@ def _inline_mssql_pagination_parameters(
 
     if not consumed:
         return sql, parameters
-    for position, value in reversed(replacements):
+    for position, value in replacements[::-1]:
         sql = sql[:position] + value + sql[position + 1 :]
     return sql, [value for index, value in enumerate(parameters) if index not in consumed]
 

sqlspec/adapters/spanner/__init__.py

@@ -1,13 +1,26 @@
 """Google Cloud Spanner Adapter."""
 
+from sqlspec.adapters.spanner._typing import (
+    SpannerAsyncConnection,
+    SpannerAsyncCursor,
+    SpannerSyncConnection,
+    SpannerSyncCursor,
+)
 from sqlspec.adapters.spanner.config import (
+    SpannerAsyncConfig,
     SpannerConnectionParams,
     SpannerDriverFeatures,
     SpannerPoolParams,
     SpannerSyncConfig,
     build_connection_config,
 )
-from sqlspec.adapters.spanner.driver import SpannerSyncDriver
+from sqlspec.adapters.spanner.core import default_statement_config
+from sqlspec.adapters.spanner.driver import (
+    SpannerAsyncDriver,
+    SpannerAsyncExceptionHandler,
+    SpannerSyncDriver,
+    SpannerSyncExceptionHandler,
+)
 from sqlspec.adapters.spanner.type_converter import (
     bytes_to_spanner,
     coerce_params_for_spanner,
@@ -19,14 +32,23 @@ from sqlspec.adapters.spanner.type_converter import (
 )
 
 __all__ = (
+    "SpannerAsyncConfig",
+    "SpannerAsyncConnection",
+    "SpannerAsyncCursor",
+    "SpannerAsyncDriver",
+    "SpannerAsyncExceptionHandler",
     "SpannerConnectionParams",
     "SpannerDriverFeatures",
     "SpannerPoolParams",
     "SpannerSyncConfig",
+    "SpannerSyncConnection",
+    "SpannerSyncCursor",
     "SpannerSyncDriver",
+    "SpannerSyncExceptionHandler",
     "build_connection_config",
     "bytes_to_spanner",
     "coerce_params_for_spanner",
+    "default_statement_config",
     "infer_spanner_param_types",
     "spanner_json",
     "spanner_to_bytes",

sqlspec/adapters/spanner/_typing.py

@@ -18,8 +18,12 @@ class _UnavailableSpannerTransaction:
     """Fallback Spanner transaction class when google-cloud-spanner is unavailable."""
 
 
+class _UnavailableSpannerAsyncTransaction:
+    """Fallback Spanner async transaction class when google-cloud-spanner is unavailable."""
+
+
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Awaitable, Callable
     from types import TracebackType
     from typing import TypeAlias
 
@@ -37,6 +41,22 @@ if TYPE_CHECKING:
     from google.cloud.spanner_v1 import ExecuteSqlRequest as SpannerExecuteSqlRequest
     from google.cloud.spanner_v1 import RequestOptions as SpannerRequestOptions
     from google.cloud.spanner_v1 import param_types as spanner_param_types
+    from google.cloud.spanner_v1._async.batch import Batch as SpannerAsyncBatch
+    from google.cloud.spanner_v1._async.batch import MutationGroups as SpannerAsyncMutationGroups
+    from google.cloud.spanner_v1._async.client import Client as SpannerAsyncClient
+    from google.cloud.spanner_v1._async.database import Database as SpannerAsyncDatabase
+    from google.cloud.spanner_v1._async.database import SnapshotCheckout as SpannerAsyncSnapshotCheckout
+    from google.cloud.spanner_v1._async.database_sessions_manager import TransactionType as SpannerAsyncTransactionType
+    from google.cloud.spanner_v1._async.pool import AbstractSessionPool as SpannerAsyncAbstractSessionPool
+    from google.cloud.spanner_v1._async.pool import BurstyPool as SpannerAsyncBurstyPool
+    from google.cloud.spanner_v1._async.pool import FixedSizePool as SpannerAsyncFixedSizePool
+    from google.cloud.spanner_v1._async.pool import PingingPool as SpannerAsyncPingingPool
+    from google.cloud.spanner_v1._async.pool import TransactionPingingPool as SpannerAsyncTransactionPingingPool
+    from google.cloud.spanner_v1._async.session import Session as SpannerAsyncSession
+    from google.cloud.spanner_v1._async.snapshot import Snapshot as SpannerAsyncSnapshot
+    from google.cloud.spanner_v1._async.streamed import StreamedResultSet as SpannerAsyncStreamedResultSet
+    from google.cloud.spanner_v1._async.transaction import Transaction as _SpannerAsyncTransaction
+    from google.cloud.spanner_v1.data_types import Interval as SpannerInterval
     from google.cloud.spanner_v1.data_types import JsonObject as SpannerJsonObject
     from google.cloud.spanner_v1.database import Database as SpannerDatabase
     from google.cloud.spanner_v1.database import SnapshotCheckout
@@ -45,21 +65,27 @@ if TYPE_CHECKING:
     from google.cloud.spanner_v1.pool import BurstyPool as SpannerBurstyPool
     from google.cloud.spanner_v1.pool import FixedSizePool as SpannerFixedSizePool
     from google.cloud.spanner_v1.pool import PingingPool as SpannerPingingPool
+    from google.cloud.spanner_v1.pool import TransactionPingingPool as SpannerTransactionPingingPool
     from google.cloud.spanner_v1.snapshot import Snapshot
     from google.cloud.spanner_v1.transaction import DefaultTransactionOptions as SpannerDefaultTransactionOptions
     from google.cloud.spanner_v1.transaction import Transaction as _SpannerTransaction
     from google.cloud.spanner_v1.types.type import TypeCode as SpannerTypeCode
 
-    from sqlspec.adapters.spanner.driver import SpannerSyncDriver
+    from sqlspec.adapters.spanner.driver import SpannerAsyncDriver, SpannerSyncDriver
     from sqlspec.core import StatementConfig
 
-    SpannerConnection: TypeAlias = Snapshot | SnapshotCheckout | _SpannerTransaction
+    SpannerSyncConnection: TypeAlias = Snapshot | SnapshotCheckout | _SpannerTransaction
+    SpannerAsyncConnection: TypeAlias = (
+        SpannerAsyncSnapshot | SpannerAsyncSnapshotCheckout | _SpannerAsyncTransaction | SpannerAsyncBatch
+    )
     SpannerGoogleAPICallError: TypeAlias = _SpannerGoogleAPICallError
     SpannerTransaction: TypeAlias = _SpannerTransaction
+    SpannerAsyncTransaction: TypeAlias = _SpannerAsyncTransaction
 
 
 if not TYPE_CHECKING:
-    SpannerConnection = Any
+    SpannerSyncConnection = Any
+    SpannerAsyncConnection = Any
     SpannerGoogleAPICallError = (
         import_optional_attr("google.api_core.exceptions", "GoogleAPICallError")
         or _UnavailableSpannerGoogleAPICallError
@@ -67,15 +93,35 @@ if not TYPE_CHECKING:
     SpannerTransaction = (
         import_optional_attr("google.cloud.spanner_v1.transaction", "Transaction") or _UnavailableSpannerTransaction
     )
+    SpannerAsyncTransaction = (
+        import_optional_attr("google.cloud.spanner_v1._async.transaction", "Transaction")
+        or _UnavailableSpannerAsyncTransaction
+    )
 
 
 __all__ = (
     "SpannerAbstractSessionPool",
+    "SpannerAsyncAbstractSessionPool",
+    "SpannerAsyncBatch",
+    "SpannerAsyncBurstyPool",
+    "SpannerAsyncClient",
+    "SpannerAsyncConnection",
+    "SpannerAsyncCursor",
+    "SpannerAsyncDatabase",
+    "SpannerAsyncFixedSizePool",
+    "SpannerAsyncMutationGroups",
+    "SpannerAsyncPingingPool",
+    "SpannerAsyncSession",
+    "SpannerAsyncSessionContext",
+    "SpannerAsyncSnapshot",
+    "SpannerAsyncStreamedResultSet",
+    "SpannerAsyncTransaction",
+    "SpannerAsyncTransactionPingingPool",
+    "SpannerAsyncTransactionType",
     "SpannerBurstyPool",
     "SpannerClient",
     "SpannerClientInfo",
     "SpannerClientOptions",
-    "SpannerConnection",
     "SpannerCredentials",
     "SpannerDatabase",
     "SpannerDatabaseDialect",
@@ -85,14 +131,17 @@ __all__ = (
     "SpannerExecuteSqlRequest",
     "SpannerFixedSizePool",
     "SpannerGoogleAPICallError",
+    "SpannerInterval",
     "SpannerJsonObject",
     "SpannerNotFound",
     "SpannerPingingPool",
     "SpannerRequestOptions",
     "SpannerRetry",
-    "SpannerSessionContext",
+    "SpannerSyncConnection",
     "SpannerSyncCursor",
+    "SpannerSyncSessionContext",
     "SpannerTransaction",
+    "SpannerTransactionPingingPool",
     "SpannerTransactionType",
     "SpannerTypeCode",
     "spanner_exceptions",
@@ -105,31 +154,40 @@ class SpannerSyncCursor:
 
     __slots__ = ("connection",)
 
-    def __init__(self, connection: "SpannerConnection") -> None:
+    def __init__(self, connection: "SpannerSyncConnection") -> None:
         self.connection = connection
 
-    def __enter__(self) -> "SpannerConnection":
+    def __enter__(self) -> "SpannerSyncConnection":
         return self.connection
 
     def __exit__(self, *_: Any) -> None:
         return None
 
 
-class SpannerSessionContext:
-    """Sync context manager for Spanner sessions.
+class SpannerAsyncCursor:
+    """Async context manager that yields the active Spanner async connection."""
+
+    __slots__ = ("connection",)
 
-    This class is intentionally excluded from mypyc compilation to avoid ABI
-    boundary issues. It receives callables from uncompiled config classes and
-    instantiates compiled Driver objects, acting as a bridge between compiled
-    and uncompiled code.
+    def __init__(self, connection: "SpannerAsyncConnection") -> None:
+        self.connection = connection
+
+    async def __aenter__(self) -> "SpannerAsyncConnection":
+        return self.connection
+
+    async def __aexit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
+    ) -> None:
+        return None
 
-    Note: This context manager receives a pre-configured connection context
-    that already has the transaction flag set. The config.provide_session()
-    creates the connection context with the appropriate transaction setting.
 
-    Uses callable-based connection management to decouple from config implementation.
+class SpannerSyncSessionContext:
+    """Sync context manager for Spanner sessions.
 
-    Spanner requires exception info in release_connection for commit/rollback decisions.
+    Excluded from mypyc compilation: it receives callables from uncompiled
+    config classes and instantiates compiled driver objects. The release
+    callable receives exception details so the connection context can commit
+    or roll back the active transaction.
     """
 
     __slots__ = (
@@ -171,15 +229,87 @@ class SpannerSessionContext:
         self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
     ) -> "bool | None":
         if self._connection is not None:
-            self._release_connection(self._connection, exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)
+            connection = self._driver.connection if self._driver is not None else self._connection
+            self._release_connection(connection, exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)
+            self._connection = None
+            self._driver = None
+        return None
+
+
+class SpannerAsyncSessionContext:
+    """Async context manager for Spanner sessions.
+
+    Excluded from mypyc compilation: it receives callables from uncompiled
+    config classes and instantiates compiled driver objects. The release
+    callable receives exception details so the connection context can commit
+    or roll back the active transaction.
+    """
+
+    __slots__ = (
+        "_acquire_connection",
+        "_connection",
+        "_driver",
+        "_driver_features",
+        "_prepare_driver",
+        "_release_connection",
+        "_statement_config",
+    )
+
+    def __init__(
+        self,
+        acquire_connection: "Callable[[], Awaitable[Any]]",
+        release_connection: "Callable[..., Awaitable[Any]]",
+        statement_config: "StatementConfig",
+        driver_features: "dict[str, Any]",
+        prepare_driver: "Callable[[SpannerAsyncDriver], SpannerAsyncDriver]",
+    ) -> None:
+        self._acquire_connection = acquire_connection
+        self._release_connection = release_connection
+        self._statement_config = statement_config
+        self._driver_features = driver_features
+        self._prepare_driver = prepare_driver
+        self._connection: Any = None
+        self._driver: SpannerAsyncDriver | None = None
+
+    async def __aenter__(self) -> "SpannerAsyncDriver":
+        from sqlspec.adapters.spanner.driver import SpannerAsyncDriver
+
+        self._connection = await self._acquire_connection()
+        self._driver = SpannerAsyncDriver(
+            connection=self._connection, statement_config=self._statement_config, driver_features=self._driver_features
+        )
+        return self._prepare_driver(self._driver)
+
+    async def __aexit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
+    ) -> "bool | None":
+        if self._connection is not None:
+            connection = self._driver.connection if self._driver is not None else self._connection
+            await self._release_connection(connection, exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)
             self._connection = None
+            self._driver = None
         return None
 
 
 _LAZY_DRIVER_EXPORTS: dict[str, tuple[str, str]] = {
+    "SpannerAsyncTransactionType": ("google.cloud.spanner_v1._async.database_sessions_manager", "TransactionType"),
+    "SpannerInterval": ("google.cloud.spanner_v1.data_types", "Interval"),
+    "SpannerAsyncAbstractSessionPool": ("google.cloud.spanner_v1._async.pool", "AbstractSessionPool"),
+    "SpannerAsyncBatch": ("google.cloud.spanner_v1._async.batch", "Batch"),
+    "SpannerAsyncBurstyPool": ("google.cloud.spanner_v1._async.pool", "BurstyPool"),
+    "SpannerAsyncClient": ("google.cloud.spanner_v1._async.client", "Client"),
+    "SpannerAsyncDatabase": ("google.cloud.spanner_v1._async.database", "Database"),
+    "SpannerAsyncFixedSizePool": ("google.cloud.spanner_v1._async.pool", "FixedSizePool"),
+    "SpannerAsyncMutationGroups": ("google.cloud.spanner_v1._async.batch", "MutationGroups"),
+    "SpannerAsyncPingingPool": ("google.cloud.spanner_v1._async.pool", "PingingPool"),
+    "SpannerAsyncSession": ("google.cloud.spanner_v1._async.session", "Session"),
+    "SpannerAsyncSnapshot": ("google.cloud.spanner_v1._async.snapshot", "Snapshot"),
+    "SpannerAsyncStreamedResultSet": ("google.cloud.spanner_v1._async.streamed", "StreamedResultSet"),
+    "SpannerAsyncTransactionPingingPool": ("google.cloud.spanner_v1._async.pool", "TransactionPingingPool"),
     "SpannerBurstyPool": ("google.cloud.spanner_v1.pool", "BurstyPool"),
     "SpannerFixedSizePool": ("google.cloud.spanner_v1.pool", "FixedSizePool"),
     "SpannerPingingPool": ("google.cloud.spanner_v1.pool", "PingingPool"),
+    "SpannerTransactionPingingPool": ("google.cloud.spanner_v1.pool", "TransactionPingingPool"),
     "spanner_exceptions": ("google.api_core", "exceptions"),
     "SpannerNotFound": ("google.api_core.exceptions", "NotFound"),
     "SpannerClient": ("google.cloud.spanner_v1", "Client"),

sqlspec/adapters/spanner/adk/__init__.py

@@ -3,8 +3,17 @@
 from sqlspec.adapters.spanner.adk.store import (
     SpannerADKConfig,
     SpannerADKRetentionConfig,
+    SpannerAsyncADKMemoryStore,
+    SpannerAsyncADKStore,
     SpannerSyncADKMemoryStore,
     SpannerSyncADKStore,
 )
 
-__all__ = ("SpannerADKConfig", "SpannerADKRetentionConfig", "SpannerSyncADKMemoryStore", "SpannerSyncADKStore")
+__all__ = (
+    "SpannerADKConfig",
+    "SpannerADKRetentionConfig",
+    "SpannerAsyncADKMemoryStore",
+    "SpannerAsyncADKStore",
+    "SpannerSyncADKMemoryStore",
+    "SpannerSyncADKStore",
+)