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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sqlite-anyio
-Version: 0.2.9
+Version: 0.2.10
 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.14,<5.0
+Requires-Dist: anyio>=4.0,<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.9 → sqlite_anyio-0.2.10}/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.9"
+version = "0.2.10"
 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.14,<5.0",
+    "anyio >=4.0,<5.0",
     "typing-extensions >=4.15.0",
 ]
 

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

@@ -4,86 +4,18 @@ __all__ = ["connect", "Connection", "Cursor"]
 
 import sqlite3
 import sys
-import threading
 from collections.abc import Callable, Sequence
 from functools import partial
 from logging import Logger, getLogger
 from types import TracebackType
-from typing import Any, TypeVar
+from typing import Any
 
-import anyio
-from anyio import to_thread, from_thread
+from anyio import CapacityLimiter, to_thread
 
 if sys.version_info >= (3, 11):
-    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
+    from typing import Self
+else:
+    from typing_extensions import Self  # pragma: nocover
 
 
 class Connection:
@@ -96,7 +28,7 @@ class Connection:
         self._real_connection = _real_connection
         self._exception_handler = _exception_handler
         self._log = _log or getLogger(__name__)
-        self._limiter = anyio.CapacityLimiter(1)
+        self._limiter = CapacityLimiter(1)
 
     async def __aenter__(self) -> Self:
         return self
@@ -121,19 +53,17 @@ class Connection:
         return exception_handled
 
     async def execute(self, sql: str, parameters: Sequence[Any] = (), /) -> Cursor:
-        real_cursor = await _interruptible_dispatch(self, self._real_connection.execute, sql, parameters)
+        real_cursor = await to_thread.run_sync(self._real_connection.execute, sql, parameters, limiter=self._limiter)
         return Cursor(real_cursor, self._limiter, self._exception_handler, self._log)
 
     async def close(self) -> None:
-        with anyio.CancelScope(shield=True):
-            await to_thread.run_sync(self._real_connection.close, limiter=self._limiter)
+        await to_thread.run_sync(self._real_connection.close, limiter=self._limiter)
 
     async def commit(self) -> None:
-        await _interruptible_dispatch(self, self._real_connection.commit)
+        await to_thread.run_sync(self._real_connection.commit, limiter=self._limiter)
 
     async def rollback(self) -> None:
-        with anyio.CancelScope(shield=True):
-            await to_thread.run_sync(self._real_connection.rollback, limiter=self._limiter)
+        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)
@@ -144,7 +74,7 @@ class Cursor:
     def __init__(
         self,
         real_cursor: sqlite3.Cursor,
-        limiter: anyio.CapacityLimiter,
+        limiter: CapacityLimiter,
         _exception_handler: Callable[[type[BaseException], BaseException, TracebackType, Logger], bool] | None,
         _log: Logger,
     ) -> None:
@@ -187,29 +117,28 @@ class Cursor:
         return exception_handled
 
     async def close(self) -> None:
-        with anyio.CancelScope(shield=True):
-            await to_thread.run_sync(self._real_cursor.close, limiter=self._limiter)
+        await to_thread.run_sync(self._real_cursor.close, limiter=self._limiter)
 
     async def execute(self, sql: str, parameters: Sequence[Any] = (), /) -> Cursor:
-        await _interruptible_dispatch(self, self._real_cursor.execute, sql, parameters)
+        await to_thread.run_sync(self._real_cursor.execute, sql, parameters, limiter=self._limiter)
         return self
 
     async def executemany(self, sql: str, parameters: Sequence[Any], /) -> Cursor:
-        await _interruptible_dispatch(self, self._real_cursor.executemany, sql, parameters)
+        await to_thread.run_sync(self._real_cursor.executemany, sql, parameters, limiter=self._limiter)
         return self
 
     async def executescript(self, sql_script: str, /) -> Cursor:
-        await _interruptible_dispatch(self, self._real_cursor.executescript, sql_script)
+        await to_thread.run_sync(self._real_cursor.executescript, sql_script, limiter=self._limiter)
         return self
 
     async def fetchone(self) -> tuple[Any, ...] | None:
-        return await _interruptible_dispatch(self, self._real_cursor.fetchone)
+        return await to_thread.run_sync(self._real_cursor.fetchone, limiter=self._limiter)
 
     async def fetchmany(self, size: int) -> list[tuple[Any, ...]]:
-        return await _interruptible_dispatch(self, self._real_cursor.fetchmany, size)
+        return await to_thread.run_sync(self._real_cursor.fetchmany, size, limiter=self._limiter)
 
     async def fetchall(self) -> list[tuple[Any, ...]]:
-        return await _interruptible_dispatch(self, self._real_cursor.fetchall)
+        return await to_thread.run_sync(self._real_cursor.fetchall, limiter=self._limiter)
 
 
 async def connect(