sqlite-anyio 0.2.7__tar.gz → 0.2.9__tar.gz

{sqlite_anyio-0.2.7 → sqlite_anyio-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sqlite-anyio
-Version: 0.2.7
+Version: 0.2.9
 Summary: Asynchronous client for SQLite using AnyIO
 Author: Alex Grönholm, David Brochart
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>, David Brochart <david.brochart@gmail.com>
@@ -35,7 +35,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: anyio>=4.0,<5.0
+Requires-Dist: anyio>=4.14,<5.0
 Requires-Dist: typing-extensions>=4.15.0
 Requires-Python: >=3.10
 Project-URL: Source, https://github.com/davidbrochart/sqlite-anyio

{sqlite_anyio-0.2.7 → sqlite_anyio-0.2.9}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 name = "sqlite-anyio"
 description = "Asynchronous client for SQLite using AnyIO"
 readme = "README.md"
-version = "0.2.7"
+version = "0.2.9"
 authors = [
     {name = "Alex Grönholm", email = "alex.gronholm@nextday.fi"},
     {name = "David Brochart", email = "david.brochart@gmail.com"},
@@ -28,7 +28,7 @@ classifiers = [
 ]
 requires-python = ">= 3.10"
 dependencies = [
-    "anyio >=4.0,<5.0",
+    "anyio >=4.14,<5.0",
     "typing-extensions >=4.15.0",
 ]
 

{sqlite_anyio-0.2.7 → sqlite_anyio-0.2.9}/src/sqlite_anyio/sqlite.py

@@ -4,18 +4,86 @@ __all__ = ["connect", "Connection", "Cursor"]
 
 import sqlite3
 import sys
+import threading
 from collections.abc import Callable, Sequence
-from functools import partial, update_wrapper
+from functools import partial
 from logging import Logger, getLogger
 from types import TracebackType
-from typing import Any
+from typing import Any, TypeVar
 
-from anyio import CapacityLimiter, to_thread
+import anyio
+from anyio import to_thread, from_thread
 
 if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self  # pragma: nocover
+    from typing import Self, TypeVarTuple, Unpack
+else:  # pragma: nocover
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import Self, TypeVarTuple, Unpack
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+async def _interruptible_dispatch(
+    self: Connection | Cursor,
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT]
+) -> T_Retval:
+    if isinstance(self, Connection):
+        real_connection = self._real_connection
+    elif isinstance(self, Cursor):
+        real_connection = self._real_cursor.connection
+    else:  # pragma: nocover
+        raise AssertionError("Unknown type:", self)
+
+    ev = anyio.Event()
+    lock = threading.Lock()
+    need_interrupt = False
+
+    async def cancel_detector() -> None:
+        try:
+            await ev.wait()
+        except anyio.get_cancelled_exc_class():
+            # Block progress in the thread while checking this flag.
+            # Our guard_interrupt thread only ever holds the lock briefly,
+            # so there's no risk of blocking the event loop.
+            with lock:
+                # Due to race conditions, the first calls to interrupt may be
+                # ignored. This race is quick so this loop should not cycle much.
+                while need_interrupt:
+                    real_connection.interrupt()
+                    await anyio.lowlevel.cancel_shielded_checkpoint()
+            # we do NOT re-raise the cancellation so that the task group
+            # does not swallow our retval. If a Cancelled is to propagate,
+            # it should come out of to_thread.run_sync
+
+    def guard_interrupt() -> T_Retval:
+        nonlocal need_interrupt
+
+        with lock:
+            from_thread.check_cancelled()
+            need_interrupt = True
+        try:
+            return func(*args)
+        except sqlite3.OperationalError as e:
+            if str(e) == "interrupted":
+                from_thread.check_cancelled()
+            raise
+        finally:
+            need_interrupt = False
+
+    try:
+        async with anyio.create_task_group() as g:
+            g.start_soon(cancel_detector)
+            retval = await to_thread.run_sync(guard_interrupt, limiter=self._limiter)
+            ev.set()
+    except BaseExceptionGroup as eg:
+        if len(eg.exceptions) == 1:
+            if isinstance(eg.exceptions[0], Exception):
+                raise eg.exceptions[0]
+        raise  # pragma: nocover (would be an internal error that should fail other tests)
+
+    return retval
 
 
 class Connection:
@@ -28,7 +96,7 @@ class Connection:
         self._real_connection = _real_connection
         self._exception_handler = _exception_handler
         self._log = _log or getLogger(__name__)
-        self._limiter = CapacityLimiter(1)
+        self._limiter = anyio.CapacityLimiter(1)
 
     async def __aenter__(self) -> Self:
         return self
@@ -40,38 +108,32 @@ class Connection:
         exc_tb: TracebackType | None,
     ) -> bool | None:
         if exc_val is None:
-            await self.commit()  # type: ignore[call-arg]
+            await self.commit()
             return None
 
         assert exc_type is not None
         assert exc_val is not None
         assert exc_tb is not None
-        await self.rollback()  # type: ignore[call-arg]
+        await self.rollback()
         exception_handled = False
         if self._exception_handler is not None:
             exception_handled = self._exception_handler(exc_type, exc_val, exc_tb, self._log)
         return exception_handled
 
     async def execute(self, sql: str, parameters: Sequence[Any] = (), /) -> Cursor:
-        real_cursor = await to_thread.run_sync(self._real_connection.execute, sql, parameters, limiter=self._limiter)
+        real_cursor = await _interruptible_dispatch(self, self._real_connection.execute, sql, parameters)
         return Cursor(real_cursor, self._limiter, self._exception_handler, self._log)
 
-    update_wrapper(execute, sqlite3.Connection.execute)
-
-    async def close(self):
-        return await to_thread.run_sync(self._real_connection.close, limiter=self._limiter)
-
-    update_wrapper(close, sqlite3.Connection.close)
-
-    async def commit(self):
-        return await to_thread.run_sync(self._real_connection.commit, limiter=self._limiter)
-
-    update_wrapper(commit, sqlite3.Connection.commit)
+    async def close(self) -> None:
+        with anyio.CancelScope(shield=True):
+            await to_thread.run_sync(self._real_connection.close, limiter=self._limiter)
 
-    async def rollback(self):
-        return await to_thread.run_sync(self._real_connection.rollback, limiter=self._limiter)
+    async def commit(self) -> None:
+        await _interruptible_dispatch(self, self._real_connection.commit)
 
-    update_wrapper(rollback, sqlite3.Connection.rollback)
+    async def rollback(self) -> None:
+        with anyio.CancelScope(shield=True):
+            await to_thread.run_sync(self._real_connection.rollback, limiter=self._limiter)
 
     async def cursor(self, factory: Callable[[sqlite3.Connection], sqlite3.Cursor] = sqlite3.Cursor) -> Cursor:
         real_cursor = await to_thread.run_sync(self._real_connection.cursor, factory, limiter=self._limiter)
@@ -82,7 +144,7 @@ class Cursor:
     def __init__(
         self,
         real_cursor: sqlite3.Cursor,
-        limiter: CapacityLimiter,
+        limiter: anyio.CapacityLimiter,
         _exception_handler: Callable[[type[BaseException], BaseException, TracebackType, Logger], bool] | None,
         _log: Logger,
     ) -> None:
@@ -125,42 +187,29 @@ class Cursor:
         return exception_handled
 
     async def close(self) -> None:
-        await to_thread.run_sync(self._real_cursor.close, limiter=self._limiter)
-
-    update_wrapper(close, sqlite3.Cursor.close)
+        with anyio.CancelScope(shield=True):
+            await to_thread.run_sync(self._real_cursor.close, limiter=self._limiter)
 
     async def execute(self, sql: str, parameters: Sequence[Any] = (), /) -> Cursor:
-        real_cursor = await to_thread.run_sync(self._real_cursor.execute, sql, parameters, limiter=self._limiter)
-        return Cursor(real_cursor, self._limiter, self._exception_handler, self._log)
-
-    update_wrapper(execute, sqlite3.Cursor.execute)
+        await _interruptible_dispatch(self, self._real_cursor.execute, sql, parameters)
+        return self
 
     async def executemany(self, sql: str, parameters: Sequence[Any], /) -> Cursor:
-        real_cursor = await to_thread.run_sync(self._real_cursor.executemany, sql, parameters, limiter=self._limiter)
-        return Cursor(real_cursor, self._limiter, self._exception_handler, self._log)
-
-    update_wrapper(executemany, sqlite3.Cursor.executemany)
+        await _interruptible_dispatch(self, self._real_cursor.executemany, sql, parameters)
+        return self
 
     async def executescript(self, sql_script: str, /) -> Cursor:
-        real_cursor = await to_thread.run_sync(self._real_cursor.executescript, sql_script, limiter=self._limiter)
-        return Cursor(real_cursor, self._limiter, self._exception_handler, self._log)
-
-    update_wrapper(executescript, sqlite3.Cursor.executescript)
+        await _interruptible_dispatch(self, self._real_cursor.executescript, sql_script)
+        return self
 
     async def fetchone(self) -> tuple[Any, ...] | None:
-        return await to_thread.run_sync(self._real_cursor.fetchone, limiter=self._limiter)
-
-    update_wrapper(fetchone, sqlite3.Cursor.fetchone)
+        return await _interruptible_dispatch(self, self._real_cursor.fetchone)
 
     async def fetchmany(self, size: int) -> list[tuple[Any, ...]]:
-        return await to_thread.run_sync(self._real_cursor.fetchmany, size, limiter=self._limiter)
-
-    update_wrapper(fetchmany, sqlite3.Cursor.fetchmany)
+        return await _interruptible_dispatch(self, self._real_cursor.fetchmany, size)
 
     async def fetchall(self) -> list[tuple[Any, ...]]:
-        return await to_thread.run_sync(self._real_cursor.fetchall, limiter=self._limiter)
-
-    update_wrapper(fetchall, sqlite3.Cursor.fetchall)
+        return await _interruptible_dispatch(self, self._real_cursor.fetchall)
 
 
 async def connect(