Merge pull request #7 from davidbrochart/wraps

Fix mypy

Author: davidbrochart

sqlite_anyio/sqlite.py

@@ -4,7 +4,7 @@
 
 import sqlite3
 from collections.abc import Callable, Sequence
-from functools import partial, wraps
+from functools import partial, update_wrapper
 from logging import Logger, getLogger
 from types import TracebackType
 from typing import Any
@@ -46,18 +46,21 @@ async def __aexit__(
             exception_handled = self._exception_handler(exc_type, exc_val, exc_tb, self._log)
         return exception_handled
 
-    @wraps(sqlite3.Connection.close)
     async def close(self):
         return await to_thread.run_sync(self._real_connection.close, limiter=self._limiter)
 
-    @wraps(sqlite3.Connection.commit)
+    update_wrapper(close, sqlite3.Connection.close)
+
     async def commit(self):
         return await to_thread.run_sync(self._real_connection.commit, limiter=self._limiter)
 
-    @wraps(sqlite3.Connection.rollback)
+    update_wrapper(commit, sqlite3.Connection.commit)
+
     async def rollback(self):
         return await to_thread.run_sync(self._real_connection.rollback, limiter=self._limiter)
 
+    update_wrapper(rollback, sqlite3.Connection.rollback)
+
     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)
         return Cursor(real_cursor, self._limiter)
@@ -80,37 +83,44 @@ def rowcount(self) -> int:
     def arraysize(self) -> int:
         return self._real_cursor.arraysize
 
-    @wraps(sqlite3.Cursor.close)
     async def close(self) -> None:
         await to_thread.run_sync(self._real_cursor.close, limiter=self._limiter)
 
-    @wraps(sqlite3.Cursor.execute)
+    update_wrapper(close, sqlite3.Cursor.close)
+
     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)
 
-    @wraps(sqlite3.Cursor.executemany)
+    update_wrapper(execute, sqlite3.Cursor.execute)
+
     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)
 
-    @wraps(sqlite3.Cursor.executescript)
+    update_wrapper(executemany, sqlite3.Cursor.executemany)
+
     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)
 
-    @wraps(sqlite3.Cursor.fetchone)
+    update_wrapper(executescript, sqlite3.Cursor.executescript)
+
     async def fetchone(self) -> tuple[Any, ...] | None:
         return await to_thread.run_sync(self._real_cursor.fetchone, limiter=self._limiter)
 
-    @wraps(sqlite3.Cursor.fetchmany)
+    update_wrapper(fetchone, sqlite3.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)
 
-    @wraps(sqlite3.Cursor.fetchall)
+    update_wrapper(fetchmany, sqlite3.Cursor.fetchmany)
+
     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)
+
 
 async def connect(
     database: str,

tests/test_context_manager.py

@@ -5,11 +5,8 @@
 import sqlite_anyio
 
 
-pytestmark = pytest.mark.anyio
-
-
-async def test_context_manager_commit():
-    mem_uri = "file:mem0?mode=memory&cache=shared"
+async def test_context_manager_commit(anyio_backend):
+    mem_uri = f"file:{anyio_backend}_mem0?mode=memory&cache=shared"
     acon0 = await sqlite_anyio.connect(mem_uri, uri=True)
     acur0 = await acon0.cursor()
     async with acon0:
@@ -22,8 +19,8 @@ async def test_context_manager_commit():
     assert await acur1.fetchone() == ("Python",)
 
 
-async def test_context_manager_rollback():
-    mem_uri = "file:mem1?mode=memory&cache=shared"
+async def test_context_manager_rollback(anyio_backend):
+    mem_uri = f"file:{anyio_backend}_mem1?mode=memory&cache=shared"
     acon0 = await sqlite_anyio.connect(mem_uri, uri=True)
     acur0 = await acon0.cursor()
     with pytest.raises(RuntimeError):
@@ -38,9 +35,9 @@ async def test_context_manager_rollback():
     assert await acur1.fetchone() is None
 
 
-async def test_exception_logger(caplog):
+async def test_exception_logger(anyio_backend, caplog):
     caplog.set_level(logging.INFO)
-    mem_uri = "file:mem2?mode=memory&cache=shared"
+    mem_uri = f"file:{anyio_backend}_mem2?mode=memory&cache=shared"
     log = logging.getLogger("logger")
     acon0 = await sqlite_anyio.connect(mem_uri, uri=True, exception_handler=sqlite_anyio.exception_logger, log=log)
     acur0 = await acon0.cursor()