Fix asyncio, fix paramstyle

Author: antoineleclair

src/dqlitedbapi/aio/__init__.py

@@ -3,7 +3,19 @@
 from dqlitedbapi.aio.connection import AsyncConnection
 from dqlitedbapi.aio.cursor import AsyncCursor
 
+# PEP 249 module-level attributes (required by SQLAlchemy dialect initialization)
+apilevel = "2.0"
+threadsafety = 1  # Threads may share the module, but not connections
+paramstyle = "qmark"  # Question mark style: WHERE name=?
+
+# SQLite compatibility attributes (for SQLAlchemy)
+sqlite_version_info = (3, 35, 0)
+sqlite_version = "3.35.0"
+
 __all__ = [
+    "apilevel",
+    "threadsafety",
+    "paramstyle",
     "aconnect",
     "AsyncConnection",
     "AsyncCursor",

src/dqlitedbapi/connection.py

@@ -1,6 +1,7 @@
 """PEP 249 Connection implementation for dqlite."""
 
 import asyncio
+import threading
 from typing import Any
 
 from dqliteclient import DqliteConnection
@@ -31,17 +32,30 @@ def __init__(
         self._async_conn: DqliteConnection | None = None
         self._closed = False
         self._loop: asyncio.AbstractEventLoop | None = None
+        self._thread: threading.Thread | None = None
 
-    def _get_loop(self) -> asyncio.AbstractEventLoop:
-        if self._loop is None:
-            try:
-                self._loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                self._loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(self._loop)
+    def _ensure_loop(self) -> asyncio.AbstractEventLoop:
+        """Ensure a dedicated event loop is running in a background thread.
+
+        This allows sync methods to work even when called from within
+        an already-running async context (e.g. uvicorn).
+        """
+        if self._loop is None or self._loop.is_closed():
+            self._loop = asyncio.new_event_loop()
+            self._thread = threading.Thread(target=self._loop.run_forever, daemon=True)
+            self._thread.start()
         return self._loop
 
+    def _run_sync(self, coro: Any) -> Any:
+        """Run an async coroutine from sync code.
+
+        Submits the coroutine to the dedicated background event loop
+        and blocks until the result is available.
+        """
+        loop = self._ensure_loop()
+        future = asyncio.run_coroutine_threadsafe(coro, loop)
+        return future.result()
+
     async def _get_async_connection(self) -> DqliteConnection:
         """Get or create the underlying async connection."""
         if self._closed:
@@ -64,9 +78,15 @@ async def _get_async_connection(self) -> DqliteConnection:
     def close(self) -> None:
         """Close the connection."""
         if self._async_conn is not None:
-            loop = self._get_loop()
-            loop.run_until_complete(self._async_conn.close())
+            self._run_sync(self._async_conn.close())
             self._async_conn = None
+        if self._loop is not None and not self._loop.is_closed():
+            self._loop.call_soon_threadsafe(self._loop.stop)
+            if self._thread is not None:
+                self._thread.join(timeout=5)
+            self._loop.close()
+            self._loop = None
+            self._thread = None
         self._closed = True
 
     def commit(self) -> None:
@@ -75,8 +95,7 @@ def commit(self) -> None:
             raise InterfaceError("Connection is closed")
 
         if self._async_conn is not None:
-            loop = self._get_loop()
-            loop.run_until_complete(self._commit_async())
+            self._run_sync(self._commit_async())
 
     async def _commit_async(self) -> None:
         """Async implementation of commit."""
@@ -89,8 +108,7 @@ def rollback(self) -> None:
             raise InterfaceError("Connection is closed")
 
         if self._async_conn is not None:
-            loop = self._get_loop()
-            loop.run_until_complete(self._rollback_async())
+            self._run_sync(self._rollback_async())
 
     async def _rollback_async(self) -> None:
         """Async implementation of rollback."""

src/dqlitedbapi/cursor.py

@@ -1,6 +1,5 @@
 """PEP 249 Cursor implementation for dqlite."""
 
-import asyncio
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any
 
@@ -62,16 +61,11 @@ def _check_closed(self) -> None:
         if self._closed:
             raise InterfaceError("Cursor is closed")
 
-    def _get_loop(self) -> asyncio.AbstractEventLoop:
-        # Use the connection's event loop for consistency
-        return self._connection._get_loop()
-
     def execute(self, operation: str, parameters: Sequence[Any] | None = None) -> "Cursor":
         """Execute a database operation (query or command)."""
         self._check_closed()
 
-        loop = self._get_loop()
-        loop.run_until_complete(self._execute_async(operation, parameters))
+        self._connection._run_sync(self._execute_async(operation, parameters))
         return self
 
     async def _execute_async(self, operation: str, parameters: Sequence[Any] | None = None) -> None:
@@ -104,8 +98,7 @@ def executemany(self, operation: str, seq_of_parameters: Sequence[Sequence[Any]]
         """Execute a database operation multiple times."""
         self._check_closed()
 
-        loop = self._get_loop()
-        loop.run_until_complete(self._executemany_async(operation, seq_of_parameters))
+        self._connection._run_sync(self._executemany_async(operation, seq_of_parameters))
         return self
 
     async def _executemany_async(