sqlspec 0.63.0__tar.gz → 0.63.1__tar.gz

{sqlspec-0.63.0 → sqlspec-0.63.1}/.pre-commit-config.yaml

@@ -36,7 +36,7 @@ repos:
         exclude: "test*|tools"
         args: ["--use-tuple"]
   - repo: https://github.com/ariebovenberg/slotscheck
-    rev: v0.21.0b1
+    rev: v0.21.0
     hooks:
       - id: slotscheck
         exclude: "docs|.github"

{sqlspec-0.63.0 → sqlspec-0.63.1}/PKG-INFO

@@ -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 → sqlspec-0.63.1}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.63.0"
+version = "0.63.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -267,7 +267,7 @@ include = [
   "sqlspec/storage/backends/local.py",             # Local storage backend
   "sqlspec/storage/backends/obstore.py",           # obstore backend import surface
   "sqlspec/storage/_utils.py",                     # Storage optional dependency import helpers
-  "sqlspec/service.py",                            # Service base classes
+  "sqlspec/service/_core.py",                       # Compiled query and transaction helpers for Python service bases
   "sqlspec/data_dictionary/**/*.py",               # Data dictionary registry, loader, and dialect helpers
   "sqlspec/extensions/prometheus/_observer.py",    # Prometheus statement observer
   "sqlspec/extensions/fastapi/providers.py",       # FastAPI filter provider helpers
@@ -329,7 +329,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.63.0"
+current_version = "0.63.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

sqlspec-0.63.1/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-0.63.0/sqlspec/service.py → sqlspec-0.63.1/sqlspec/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