sqlspec 0.63.0__py3-none-any.whl → 0.63.1__py3-none-any.whl

sqlspec/service/__init__.py

@@ -0,0 +1,5 @@
+"""Slotted application service bases backed by the compiled service runtime."""
+
+from sqlspec.service._base import SQLSpecAsyncService, SQLSpecSyncService
+
+__all__ = ("SQLSpecAsyncService", "SQLSpecSyncService")

sqlspec/{service.py → service/_base.py}

@@ -1,26 +1,29 @@
 """Service base classes for SQLSpec application services."""
 
-import asyncio
-import sys
-from contextlib import AbstractAsyncContextManager, AbstractContextManager, AsyncExitStack, ExitStack, nullcontext
-from contextvars import ContextVar, Token
-from threading import get_ident
-from typing import TYPE_CHECKING, Any, Generic, Literal, cast, overload
-
-from mypy_extensions import mypyc_attr
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, nullcontext
+from typing import TYPE_CHECKING, Any, Generic, cast, overload
+
 from typing_extensions import TypeVar
 
 from sqlspec.core import OffsetPagination
-from sqlspec.core.filters import LimitOffsetFilter
 from sqlspec.driver._async import AsyncDriverAdapterBase
 from sqlspec.driver._sync import SyncDriverAdapterBase
-from sqlspec.exceptions import ImproperConfigurationError, NotFoundError
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.service._core import (
+    _async_exists,
+    _async_get_one,
+    _async_paginate,
+    _AsyncBeginTransactionContext,
+    _sync_exists,
+    _sync_get_one,
+    _sync_paginate,
+    _SyncBeginTransactionContext,
+    _transaction_session,
+    _TransactionState,
+)
 from sqlspec.typing import SchemaT
-from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
-    from types import TracebackType
-
     from sqlspec.builder import QueryBuilder
     from sqlspec.config import AsyncDatabaseConfig, NoPoolAsyncConfig, NoPoolSyncConfig, SyncDatabaseConfig
     from sqlspec.core.filters import StatementFilter
@@ -34,36 +37,7 @@ __all__ = ("SQLSpecAsyncService", "SQLSpecSyncService")
 AsyncDriverT = TypeVar("AsyncDriverT", bound=AsyncDriverAdapterBase, default=AsyncDriverAdapterBase)
 SyncDriverT = TypeVar("SyncDriverT", bound=SyncDriverAdapterBase, default=SyncDriverAdapterBase)
 
-logger = get_logger("sqlspec.service")
-
-
-def _execution_owner() -> tuple[int, object]:
-    try:
-        task = asyncio.current_task()
-    except RuntimeError:
-        task = None
-    return get_ident(), task
-
-
-def _owner_identity(owner: tuple[int, object]) -> tuple[int, int]:
-    return owner[0], id(owner[1])
-
-
-class _TransactionState:
-    __slots__ = ("driver", "origin", "owner")
-
-    def __init__(self, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> None:
-        self.driver: AsyncDriverAdapterBase | SyncDriverAdapterBase | None = driver
-        self.owner = _execution_owner()
-        self.origin = _owner_identity(self.owner)
 
-
-_TRANSACTIONS: ContextVar[dict[object, _TransactionState] | None] = ContextVar(
-    "sqlspec_service_transactions", default=None
-)
-
-
-@mypyc_attr(allow_interpreted_subclasses=True)
 class SQLSpecAsyncService(Generic[AsyncDriverT]):
     """Base class for asynchronous SQLSpec services.
 
@@ -194,27 +168,9 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         Returns:
             An OffsetPagination instance containing items and total count.
         """
-        async with self.provide_session(session) as driver:
-            limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters)
-
-            items, total = await driver.select_with_total(
-                statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
-            )
-
-            if schema_type is None:
-                return OffsetPagination(
-                    items=cast("list[dict[str, Any]]", items),
-                    limit=limit_offset.limit if limit_offset is not None else len(items),
-                    offset=limit_offset.offset if limit_offset is not None else 0,
-                    total=total,
-                )
-
-            return OffsetPagination(
-                items=cast("list[SchemaT]", items),
-                limit=limit_offset.limit if limit_offset is not None else len(items),
-                offset=limit_offset.offset if limit_offset is not None else 0,
-                total=total,
-            )
+        return await _async_paginate(
+            self.provide_session(session), statement, parameters, schema_type, count_with_window, kwargs
+        )
 
     @overload
     async def get_one(
@@ -283,11 +239,9 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         Raises:
             NotFoundError: If the query returns zero rows.
         """
-        async with self.provide_session(session) as driver:
-            result = await driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs)
-            if result is None:
-                raise NotFoundError(error_message or "Record not found")
-            return result
+        return await _async_get_one(
+            self.provide_session(session), statement, parameters, schema_type, error_message, kwargs
+        )
 
     async def exists(
         self,
@@ -308,8 +262,7 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         Returns:
             True if at least one row exists, False otherwise.
         """
-        async with self.provide_session(session) as driver:
-            return await driver.select_one_or_none(statement, *parameters, **kwargs) is not None
+        return await _async_exists(self.provide_session(session), statement, parameters, kwargs)
 
     async def begin(self, *, session: AsyncDriverT | None = None) -> None:
         """Begin a database transaction on the underlying session.
@@ -346,7 +299,6 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         return _AsyncBeginTransactionContext(self)
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
 class SQLSpecSyncService(Generic[SyncDriverT]):
     """Base class for synchronous SQLSpec services.
 
@@ -477,27 +429,9 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
         Returns:
             An OffsetPagination instance containing items and total count.
         """
-        with self.provide_session(session) as driver:
-            limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters)
-
-            items, total = driver.select_with_total(
-                statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
-            )
-
-            if schema_type is None:
-                return OffsetPagination(
-                    items=cast("list[dict[str, Any]]", items),
-                    limit=limit_offset.limit if limit_offset is not None else len(items),
-                    offset=limit_offset.offset if limit_offset is not None else 0,
-                    total=total,
-                )
-
-            return OffsetPagination(
-                items=cast("list[SchemaT]", items),
-                limit=limit_offset.limit if limit_offset is not None else len(items),
-                offset=limit_offset.offset if limit_offset is not None else 0,
-                total=total,
-            )
+        return _sync_paginate(
+            self.provide_session(session), statement, parameters, schema_type, count_with_window, kwargs
+        )
 
     @overload
     def get_one(
@@ -566,11 +500,7 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
         Raises:
             NotFoundError: If the query returns zero rows.
         """
-        with self.provide_session(session) as driver:
-            result = driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs)
-            if result is None:
-                raise NotFoundError(error_message or "Record not found")
-            return result
+        return _sync_get_one(self.provide_session(session), statement, parameters, schema_type, error_message, kwargs)
 
     def exists(
         self,
@@ -591,8 +521,7 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
         Returns:
             True if at least one row exists, False otherwise.
         """
-        with self.provide_session(session) as driver:
-            return driver.select_one_or_none(statement, *parameters, **kwargs) is not None
+        return _sync_exists(self.provide_session(session), statement, parameters, kwargs)
 
     def begin(self, *, session: SyncDriverT | None = None) -> None:
         """Begin a database transaction on the underlying session.
@@ -627,251 +556,3 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
             The underlying driver session bound to the active transaction.
         """
         return _SyncBeginTransactionContext(self)
-
-
-def _active_transaction(key: object) -> _TransactionState | None:
-    state = (_TRANSACTIONS.get() or {}).get(key)
-    if state is None:
-        return None
-    if state.driver is None:
-        if state.origin == _owner_identity(_execution_owner()):
-            _discard_transaction(state)
-            return None
-        msg = "The inherited service transaction is no longer active."
-        raise ImproperConfigurationError(msg)
-    if state.owner != _execution_owner():
-        msg = "A service transaction cannot be implicitly reused by another task or thread; pass session= explicitly."
-        raise ImproperConfigurationError(msg)
-    return state
-
-
-def _live_transaction(key: object) -> _TransactionState | None:
-    current = _TRANSACTIONS.get()
-    state = None if current is None else current.get(key)
-    if state is None:
-        return None
-    if state.driver is None:
-        _discard_transaction(state)
-        return None
-    return _active_transaction(key)
-
-
-def _discard_transaction(state: _TransactionState) -> None:
-    current = _TRANSACTIONS.get()
-    if current is not None and any(value is state for value in current.values()):
-        _TRANSACTIONS.set({key: value for key, value in current.items() if value is not state} or None)
-
-
-def _session_transaction(state: _TransactionState | None) -> _TransactionState | None:
-    if state is None or state.driver is None:
-        return None
-    if state.owner != _execution_owner():
-        msg = (
-            "A service transaction is active in another task or thread; nested begin_transaction() blocks must "
-            "run in the task or thread that entered the outer block."
-        )
-        raise ImproperConfigurationError(msg)
-    return state
-
-
-def _connection_in_transaction(driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> bool:
-    try:
-        return driver._connection_in_transaction()
-    except NotImplementedError:
-        return False
-
-
-def _transaction_session(key: object) -> AsyncDriverAdapterBase | SyncDriverAdapterBase | None:
-    state = _active_transaction(key)
-    return None if state is None else state.driver
-
-
-def _bind_transaction(
-    key: object, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase
-) -> tuple[_TransactionState, Token[dict[object, _TransactionState] | None]]:
-    state = _TransactionState(driver)
-    token = _TRANSACTIONS.set({**(_TRANSACTIONS.get() or {}), key: state})
-    return state, token
-
-
-def _release_transaction(state: _TransactionState, token: Token[dict[object, _TransactionState] | None]) -> None:
-    state.driver = None
-    state.owner = (0, None)
-    try:
-        _TRANSACTIONS.reset(token)
-    except ValueError:
-        _discard_transaction(state)
-
-
-class _AsyncBeginTransactionContext(Generic[AsyncDriverT]):
-    __slots__ = ("_nested", "_service", "_stack", "_state")
-
-    def __init__(self, service: "SQLSpecAsyncService[AsyncDriverT]") -> None:
-        self._service = service
-        self._stack: AsyncExitStack | None = None
-        self._state: _TransactionState | None = None
-        self._nested: Any = None
-
-    async def __aenter__(self) -> AsyncDriverT:
-        service = self._service
-        if service._config is None:
-            active = _session_transaction(service._transaction_state)
-            session = service.session
-            if active is not None or session._transaction_depth > 0:
-                nested = session.transaction()
-                await nested.__aenter__()
-                self._nested = nested
-                return session
-            if not _connection_in_transaction(session):
-                await service.begin()
-            session._transaction_depth += 1
-            state = _TransactionState(session)
-            service._transaction_state = state
-            self._state = state
-            return session
-        key = service._transaction_key
-        live = _live_transaction(key)
-        if live is not None:
-            driver = cast("AsyncDriverT", live.driver)
-            nested = driver.transaction()
-            await nested.__aenter__()
-            self._nested = nested
-            return driver
-        stack = AsyncExitStack()
-        try:
-            driver = await stack.enter_async_context(service.provide_session())
-            await stack.enter_async_context(driver.transaction())
-            state, token = _bind_transaction(key, driver)
-            stack.callback(_release_transaction, state, token)
-        except BaseException:
-            await stack.__aexit__(*sys.exc_info())
-            raise
-        self._stack = stack
-        self._state = state
-        return driver
-
-    async def __aexit__(
-        self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None"
-    ) -> "Literal[False]":
-        service = self._service
-        nested = self._nested
-        state = self._state
-        stack = self._stack
-        self._nested = None
-        self._state = None
-        self._stack = None
-        if nested is not None:
-            await nested.__aexit__(exc_type, exc, traceback)
-            return False
-        if stack is not None:
-            await stack.__aexit__(exc_type, exc, traceback)
-            return False
-        if state is None:
-            return False
-        session = cast("AsyncDriverAdapterBase", state.driver)
-        try:
-            if exc_type is not None:
-                await service.rollback()
-                return False
-            try:
-                await service.commit()
-            except BaseException:
-                try:
-                    await service.rollback()
-                except Exception:
-                    logger.debug("Rollback after a failed commit also failed", exc_info=True)
-                raise
-            return False
-        finally:
-            if session._transaction_depth > 0:
-                session._transaction_depth -= 1
-            state.driver = None
-            if service._transaction_state is state:
-                service._transaction_state = None
-
-
-class _SyncBeginTransactionContext(Generic[SyncDriverT]):
-    __slots__ = ("_nested", "_service", "_stack", "_state")
-
-    def __init__(self, service: "SQLSpecSyncService[SyncDriverT]") -> None:
-        self._service = service
-        self._stack: ExitStack | None = None
-        self._state: _TransactionState | None = None
-        self._nested: Any = None
-
-    def __enter__(self) -> SyncDriverT:
-        service = self._service
-        if service._config is None:
-            active = _session_transaction(service._transaction_state)
-            session = service.session
-            if active is not None or session._transaction_depth > 0:
-                nested = session.transaction()
-                nested.__enter__()
-                self._nested = nested
-                return session
-            if not _connection_in_transaction(session):
-                service.begin()
-            session._transaction_depth += 1
-            state = _TransactionState(session)
-            service._transaction_state = state
-            self._state = state
-            return session
-        key = service._transaction_key
-        live = _live_transaction(key)
-        if live is not None:
-            driver = cast("SyncDriverT", live.driver)
-            nested = driver.transaction()
-            nested.__enter__()
-            self._nested = nested
-            return driver
-        stack = ExitStack()
-        try:
-            driver = stack.enter_context(service.provide_session())
-            stack.enter_context(driver.transaction())
-            state, token = _bind_transaction(key, driver)
-            stack.callback(_release_transaction, state, token)
-        except BaseException:
-            stack.__exit__(*sys.exc_info())
-            raise
-        self._stack = stack
-        self._state = state
-        return driver
-
-    def __exit__(
-        self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None"
-    ) -> "Literal[False]":
-        service = self._service
-        nested = self._nested
-        state = self._state
-        stack = self._stack
-        self._nested = None
-        self._state = None
-        self._stack = None
-        if nested is not None:
-            nested.__exit__(exc_type, exc, traceback)
-            return False
-        if stack is not None:
-            stack.__exit__(exc_type, exc, traceback)
-            return False
-        if state is None:
-            return False
-        session = cast("SyncDriverAdapterBase", state.driver)
-        try:
-            if exc_type is not None:
-                service.rollback()
-                return False
-            try:
-                service.commit()
-            except BaseException:
-                try:
-                    service.rollback()
-                except Exception:
-                    logger.debug("Rollback after a failed commit also failed", exc_info=True)
-                raise
-            return False
-        finally:
-            if session._transaction_depth > 0:
-                session._transaction_depth -= 1
-            state.driver = None
-            if service._transaction_state is state:
-                service._transaction_state = None

sqlspec/service/_core.py

@@ -0,0 +1,423 @@
+"""Compiled query and transaction runtime for the Python service bases."""
+
+import asyncio
+import sys
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, AsyncExitStack, ExitStack
+from contextvars import ContextVar, Token
+from threading import get_ident
+from typing import TYPE_CHECKING, Any, Generic, Literal, cast
+
+from typing_extensions import TypeVar
+
+from sqlspec.core import OffsetPagination
+from sqlspec.core.filters import LimitOffsetFilter
+from sqlspec.driver._async import AsyncDriverAdapterBase
+from sqlspec.driver._sync import SyncDriverAdapterBase
+from sqlspec.exceptions import ImproperConfigurationError, NotFoundError
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from sqlspec.builder import QueryBuilder
+    from sqlspec.core.filters import StatementFilter
+    from sqlspec.core.statement import Statement
+    from sqlspec.service import SQLSpecAsyncService, SQLSpecSyncService
+    from sqlspec.typing import SchemaT, StatementParameters
+
+AsyncDriverT = TypeVar("AsyncDriverT", bound=AsyncDriverAdapterBase, default=AsyncDriverAdapterBase)
+SyncDriverT = TypeVar("SyncDriverT", bound=SyncDriverAdapterBase, default=SyncDriverAdapterBase)
+
+logger = get_logger("sqlspec.service")
+
+
+def _execution_owner() -> tuple[int, object]:
+    try:
+        task = asyncio.current_task()
+    except RuntimeError:
+        task = None
+    return get_ident(), task
+
+
+def _owner_identity(owner: tuple[int, object]) -> tuple[int, int]:
+    return owner[0], id(owner[1])
+
+
+class _TransactionState:
+    __slots__ = ("driver", "origin", "owner")
+
+    def __init__(self, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> None:
+        self.driver: AsyncDriverAdapterBase | SyncDriverAdapterBase | None = driver
+        self.owner = _execution_owner()
+        self.origin = _owner_identity(self.owner)
+
+
+_TRANSACTIONS: ContextVar[dict[object, _TransactionState] | None] = ContextVar(
+    "sqlspec_service_transactions", default=None
+)
+
+
+async def _async_paginate(
+    context: AbstractAsyncContextManager[AsyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    schema_type: "type[SchemaT] | None",
+    count_with_window: bool,
+    kwargs: dict[str, Any],
+) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]":
+    """Execute the async service paginate operation in the supplied session context."""
+    async with context as driver:
+        limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters)
+
+        items, total = await driver.select_with_total(
+            statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
+        )
+
+        if schema_type is None:
+            return OffsetPagination(
+                items=cast("list[dict[str, Any]]", items),
+                limit=limit_offset.limit if limit_offset is not None else len(items),
+                offset=limit_offset.offset if limit_offset is not None else 0,
+                total=total,
+            )
+
+        return OffsetPagination(
+            items=cast("list[SchemaT]", items),
+            limit=limit_offset.limit if limit_offset is not None else len(items),
+            offset=limit_offset.offset if limit_offset is not None else 0,
+            total=total,
+        )
+
+
+async def _async_get_one(
+    context: AbstractAsyncContextManager[AsyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    schema_type: "type[SchemaT] | None",
+    error_message: str | None,
+    kwargs: dict[str, Any],
+) -> "SchemaT | dict[str, Any]":
+    """Execute the async service get_one operation in the supplied session context."""
+    async with context as driver:
+        result = await driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs)
+        if result is None:
+            raise NotFoundError(error_message or "Record not found")
+        return result
+
+
+async def _async_exists(
+    context: AbstractAsyncContextManager[AsyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    kwargs: dict[str, Any],
+) -> bool:
+    """Execute the async service exists operation in the supplied session context."""
+    async with context as driver:
+        return await driver.select_one_or_none(statement, *parameters, **kwargs) is not None
+
+
+def _sync_paginate(
+    context: AbstractContextManager[SyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    schema_type: "type[SchemaT] | None",
+    count_with_window: bool,
+    kwargs: dict[str, Any],
+) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]":
+    """Execute the sync service paginate operation in the supplied session context."""
+    with context as driver:
+        limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters)
+
+        items, total = driver.select_with_total(
+            statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
+        )
+
+        if schema_type is None:
+            return OffsetPagination(
+                items=cast("list[dict[str, Any]]", items),
+                limit=limit_offset.limit if limit_offset is not None else len(items),
+                offset=limit_offset.offset if limit_offset is not None else 0,
+                total=total,
+            )
+
+        return OffsetPagination(
+            items=cast("list[SchemaT]", items),
+            limit=limit_offset.limit if limit_offset is not None else len(items),
+            offset=limit_offset.offset if limit_offset is not None else 0,
+            total=total,
+        )
+
+
+def _sync_get_one(
+    context: AbstractContextManager[SyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    schema_type: "type[SchemaT] | None",
+    error_message: str | None,
+    kwargs: dict[str, Any],
+) -> "SchemaT | dict[str, Any]":
+    """Execute the sync service get_one operation in the supplied session context."""
+    with context as driver:
+        result = driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs)
+        if result is None:
+            raise NotFoundError(error_message or "Record not found")
+        return result
+
+
+def _sync_exists(
+    context: AbstractContextManager[SyncDriverAdapterBase],
+    statement: "Statement | QueryBuilder",
+    parameters: "tuple[StatementParameters | StatementFilter, ...]",
+    kwargs: dict[str, Any],
+) -> bool:
+    """Execute the sync service exists operation in the supplied session context."""
+    with context as driver:
+        return driver.select_one_or_none(statement, *parameters, **kwargs) is not None
+
+
+def _active_transaction(key: object) -> _TransactionState | None:
+    state = (_TRANSACTIONS.get() or {}).get(key)
+    if state is None:
+        return None
+    if state.driver is None:
+        if state.origin == _owner_identity(_execution_owner()):
+            _discard_transaction(state)
+            return None
+        msg = "The inherited service transaction is no longer active."
+        raise ImproperConfigurationError(msg)
+    if state.owner != _execution_owner():
+        msg = "A service transaction cannot be implicitly reused by another task or thread; pass session= explicitly."
+        raise ImproperConfigurationError(msg)
+    return state
+
+
+def _live_transaction(key: object) -> _TransactionState | None:
+    current = _TRANSACTIONS.get()
+    state = None if current is None else current.get(key)
+    if state is None:
+        return None
+    if state.driver is None:
+        _discard_transaction(state)
+        return None
+    return _active_transaction(key)
+
+
+def _discard_transaction(state: _TransactionState) -> None:
+    current = _TRANSACTIONS.get()
+    if current is not None and any(value is state for value in current.values()):
+        _TRANSACTIONS.set({key: value for key, value in current.items() if value is not state} or None)
+
+
+def _session_transaction(state: _TransactionState | None) -> _TransactionState | None:
+    if state is None or state.driver is None:
+        return None
+    if state.owner != _execution_owner():
+        msg = (
+            "A service transaction is active in another task or thread; nested begin_transaction() blocks must "
+            "run in the task or thread that entered the outer block."
+        )
+        raise ImproperConfigurationError(msg)
+    return state
+
+
+def _connection_in_transaction(driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> bool:
+    try:
+        return driver._connection_in_transaction()
+    except NotImplementedError:
+        return False
+
+
+def _transaction_session(key: object) -> AsyncDriverAdapterBase | SyncDriverAdapterBase | None:
+    state = _active_transaction(key)
+    return None if state is None else state.driver
+
+
+def _bind_transaction(
+    key: object, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase
+) -> tuple[_TransactionState, Token[dict[object, _TransactionState] | None]]:
+    state = _TransactionState(driver)
+    token = _TRANSACTIONS.set({**(_TRANSACTIONS.get() or {}), key: state})
+    return state, token
+
+
+def _release_transaction(state: _TransactionState, token: Token[dict[object, _TransactionState] | None]) -> None:
+    state.driver = None
+    state.owner = (0, None)
+    try:
+        _TRANSACTIONS.reset(token)
+    except ValueError:
+        _discard_transaction(state)
+
+
+class _AsyncBeginTransactionContext(Generic[AsyncDriverT]):
+    __slots__ = ("_nested", "_service", "_stack", "_state")
+
+    def __init__(self, service: "SQLSpecAsyncService[AsyncDriverT]") -> None:
+        self._service = service
+        self._stack: AsyncExitStack | None = None
+        self._state: _TransactionState | None = None
+        self._nested: Any = None
+
+    async def __aenter__(self) -> AsyncDriverT:
+        service = self._service
+        if service._config is None:
+            active = _session_transaction(service._transaction_state)
+            session = service.session
+            if active is not None or session._transaction_depth > 0:
+                nested = session.transaction()
+                await nested.__aenter__()
+                self._nested = nested
+                return session
+            if not _connection_in_transaction(session):
+                await service.begin()
+            session._transaction_depth += 1
+            state = _TransactionState(session)
+            service._transaction_state = state
+            self._state = state
+            return session
+        key = service._transaction_key
+        live = _live_transaction(key)
+        if live is not None:
+            driver = cast("AsyncDriverT", live.driver)
+            nested = driver.transaction()
+            await nested.__aenter__()
+            self._nested = nested
+            return driver
+        stack = AsyncExitStack()
+        try:
+            driver = await stack.enter_async_context(service.provide_session())
+            await stack.enter_async_context(driver.transaction())
+            state, token = _bind_transaction(key, driver)
+            stack.callback(_release_transaction, state, token)
+        except BaseException:
+            await stack.__aexit__(*sys.exc_info())
+            raise
+        self._stack = stack
+        self._state = state
+        return driver
+
+    async def __aexit__(
+        self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None"
+    ) -> "Literal[False]":
+        service = self._service
+        nested = self._nested
+        state = self._state
+        stack = self._stack
+        self._nested = None
+        self._state = None
+        self._stack = None
+        if nested is not None:
+            await nested.__aexit__(exc_type, exc, traceback)
+            return False
+        if stack is not None:
+            await stack.__aexit__(exc_type, exc, traceback)
+            return False
+        if state is None:
+            return False
+        session = cast("AsyncDriverAdapterBase", state.driver)
+        try:
+            if exc_type is not None:
+                await service.rollback()
+                return False
+            try:
+                await service.commit()
+            except BaseException:
+                try:
+                    await service.rollback()
+                except Exception:
+                    logger.debug("Rollback after a failed commit also failed", exc_info=True)
+                raise
+            return False
+        finally:
+            if session._transaction_depth > 0:
+                session._transaction_depth -= 1
+            state.driver = None
+            if service._transaction_state is state:
+                service._transaction_state = None
+
+
+class _SyncBeginTransactionContext(Generic[SyncDriverT]):
+    __slots__ = ("_nested", "_service", "_stack", "_state")
+
+    def __init__(self, service: "SQLSpecSyncService[SyncDriverT]") -> None:
+        self._service = service
+        self._stack: ExitStack | None = None
+        self._state: _TransactionState | None = None
+        self._nested: Any = None
+
+    def __enter__(self) -> SyncDriverT:
+        service = self._service
+        if service._config is None:
+            active = _session_transaction(service._transaction_state)
+            session = service.session
+            if active is not None or session._transaction_depth > 0:
+                nested = session.transaction()
+                nested.__enter__()
+                self._nested = nested
+                return session
+            if not _connection_in_transaction(session):
+                service.begin()
+            session._transaction_depth += 1
+            state = _TransactionState(session)
+            service._transaction_state = state
+            self._state = state
+            return session
+        key = service._transaction_key
+        live = _live_transaction(key)
+        if live is not None:
+            driver = cast("SyncDriverT", live.driver)
+            nested = driver.transaction()
+            nested.__enter__()
+            self._nested = nested
+            return driver
+        stack = ExitStack()
+        try:
+            driver = stack.enter_context(service.provide_session())
+            stack.enter_context(driver.transaction())
+            state, token = _bind_transaction(key, driver)
+            stack.callback(_release_transaction, state, token)
+        except BaseException:
+            stack.__exit__(*sys.exc_info())
+            raise
+        self._stack = stack
+        self._state = state
+        return driver
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None"
+    ) -> "Literal[False]":
+        service = self._service
+        nested = self._nested
+        state = self._state
+        stack = self._stack
+        self._nested = None
+        self._state = None
+        self._stack = None
+        if nested is not None:
+            nested.__exit__(exc_type, exc, traceback)
+            return False
+        if stack is not None:
+            stack.__exit__(exc_type, exc, traceback)
+            return False
+        if state is None:
+            return False
+        session = cast("SyncDriverAdapterBase", state.driver)
+        try:
+            if exc_type is not None:
+                service.rollback()
+                return False
+            try:
+                service.commit()
+            except BaseException:
+                try:
+                    service.rollback()
+                except Exception:
+                    logger.debug("Rollback after a failed commit also failed", exc_info=True)
+                raise
+            return False
+        finally:
+            if session._transaction_depth > 0:
+                session._transaction_depth -= 1
+            state.driver = None
+            if service._transaction_state is state:
+                service._transaction_state = None

{sqlspec-0.63.0.dist-info → sqlspec-0.63.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sqlspec
-Version: 0.63.0
+Version: 0.63.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.63.0.dist-info → sqlspec-0.63.1.dist-info}/RECORD

@@ -9,7 +9,6 @@ sqlspec/exceptions.py,sha256=RjCfh90cUJuh4wmAgSzb6KvKhCMknM6a--Xsffq8OkM,16194
 sqlspec/loader.py,sha256=CsyQrkRplxmMLVKW1WeGMKUlGZftk_JyW-wrP8CAexo,65609
 sqlspec/protocols.py,sha256=Yyag7aGdyUi6JDSDJwbt-rMrooy3ezQ1PjsJm0UVjgE,33966
 sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/service.py,sha256=GeHviEoJxWraMnIvONGbcsUvYcZBcWJWoNqdU5Hvnvg,33295
 sqlspec/typing.py,sha256=L3AhW4Xr0uYuaIlghGzcgznwEto8UGy6Qbnb9yrf6-k,6380
 sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/adapters/adbc/__init__.py,sha256=iwWnfPYTR0c0uFQZAKbeVt0-W-9soyuhSd7On8QomEo,410
@@ -635,6 +634,9 @@ sqlspec/observability/_formatters/_aws.py,sha256=ZVIc3s2JI7Gpgwcpa3NtXVZf2GSDMaj
 sqlspec/observability/_formatters/_azure.py,sha256=Om13FLalqhtlDJjVUdHQnTzDBP0cVdJp3TXlCraF0mM,2498
 sqlspec/observability/_formatters/_base.py,sha256=a0Th_NkyAB0iBH61tXHyvVZPrj4RMLJ9_ADvCpuzMgo,1202
 sqlspec/observability/_formatters/_gcp.py,sha256=Nek2Nt8kqJ4fDy6qwPcHUMPITtDa6xLQA6VxotmCeFk,4067
+sqlspec/service/__init__.py,sha256=aRsQimIvairp_rUJPNevlRpCKAr17FClxKYwyQanLhY,212
+sqlspec/service/_base.py,sha256=6Lqp8Mq394p61uIK20rbwmHdk65424ArHomx2HerZ-Y,20992
+sqlspec/service/_core.py,sha256=l-G57o3iV-ZIfqEz7AFDZxP4ICEAam_Dfh8SHpEcckc,16211
 sqlspec/storage/__init__.py,sha256=KXu6tW_7WCM-djHPXPSgmiUPROxsCxO1W4G17tUdnU8,1281
 sqlspec/storage/_arrow_payload.py,sha256=kAt7ciGlFZFeuWFF4ddkSPrKWIZ2MQc3y2PRvjqnPnM,2738
 sqlspec/storage/_arrow_stream.py,sha256=pwjTfpiAKyPB9LGyx6anGUl5TKj0qdFwZAjlajHl6Dw,2117
@@ -669,8 +671,8 @@ sqlspec/utils/serializers/__init__.py,sha256=X99t8YMHVGmKwrqPxumnSXu4JMJL8SpKoU7
 sqlspec/utils/serializers/_json.py,sha256=5PBan5kHoDAGqbOqT33SdEK17VZzNjzZKneWI_BnDzY,18136
 sqlspec/utils/serializers/_numpy.py,sha256=_LllCtVn_gyLrRG2naHM7Unjtpot86BPTvGPlZuAGRw,1742
 sqlspec/utils/serializers/_schema.py,sha256=kN8lW8GJa08yMi_qN_x8A7XpO7V6aAaoYqKq72rxaCk,11416
-sqlspec-0.63.0.dist-info/METADATA,sha256=T_grrYdnBYEpkWH1jqybZMwwtcbkGcLD9OAKQFoOnik,9080
-sqlspec-0.63.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-sqlspec-0.63.0.dist-info/entry_points.txt,sha256=Odw9xs3HsdFEuJXZ_GE0iemkXwkPQzn1w16PuIYDpqc,459
-sqlspec-0.63.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.63.0.dist-info/RECORD,,
+sqlspec-0.63.1.dist-info/METADATA,sha256=wdAq669tcEN-ef6HgWYOfDuHE088KHXaP3ipj31WeTY,9080
+sqlspec-0.63.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sqlspec-0.63.1.dist-info/entry_points.txt,sha256=Odw9xs3HsdFEuJXZ_GE0iemkXwkPQzn1w16PuIYDpqc,459
+sqlspec-0.63.1.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.63.1.dist-info/RECORD,,