dqlite-dbapi 0.1.2__tar.gz → 0.1.3__tar.gz

{dqlite_dbapi-0.1.2 → dqlite_dbapi-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dqlite-dbapi
-Version: 0.1.2
+Version: 0.1.3
 Summary: PEP 249 (DB-API 2.0) compliant interface for dqlite
 Project-URL: Homepage, https://github.com/letsdiscodev/python-dqlite-dbapi
 Project-URL: Repository, https://github.com/letsdiscodev/python-dqlite-dbapi

{dqlite_dbapi-0.1.2 → dqlite_dbapi-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dqlite-dbapi"
-version = "0.1.2"
+version = "0.1.3"
 description = "PEP 249 (DB-API 2.0) compliant interface for dqlite"
 readme = "README.md"
 requires-python = ">=3.13"

{dqlite_dbapi-0.1.2 → dqlite_dbapi-0.1.3}/src/dqlitedbapi/__init__.py

@@ -76,7 +76,7 @@ __all__ = [
     "ROWID",
 ]
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 
 def connect(

dqlite_dbapi-0.1.3/src/dqlitedbapi/aio/__init__.py

@@ -0,0 +1,95 @@
+"""Async PEP 249-style interface for dqlite."""
+
+from dqlitedbapi.aio.connection import AsyncConnection
+from dqlitedbapi.aio.cursor import AsyncCursor
+from dqlitedbapi.exceptions import (
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+)
+
+# 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__ = [
+    # Module attributes
+    "apilevel",
+    "threadsafety",
+    "paramstyle",
+    # Functions
+    "connect",
+    "aconnect",
+    # Classes
+    "AsyncConnection",
+    "AsyncCursor",
+    # Exceptions
+    "Warning",
+    "Error",
+    "InterfaceError",
+    "DatabaseError",
+    "DataError",
+    "OperationalError",
+    "IntegrityError",
+    "InternalError",
+    "ProgrammingError",
+    "NotSupportedError",
+]
+
+
+def connect(
+    address: str,
+    *,
+    database: str = "default",
+    timeout: float = 10.0,
+) -> AsyncConnection:
+    """Create a dqlite connection (connects lazily on first use).
+
+    This is a sync function that returns an AsyncConnection without
+    establishing the TCP connection yet. SQLAlchemy requires connect()
+    to be sync; the actual connection is made when the first query runs.
+
+    Args:
+        address: Node address in "host:port" format
+        database: Database name to open
+        timeout: Connection timeout in seconds
+
+    Returns:
+        An AsyncConnection object
+    """
+    return AsyncConnection(address, database=database, timeout=timeout)
+
+
+async def aconnect(
+    address: str,
+    *,
+    database: str = "default",
+    timeout: float = 10.0,
+) -> AsyncConnection:
+    """Connect to a dqlite database asynchronously.
+
+    Unlike connect(), this awaits the TCP connection before returning.
+
+    Args:
+        address: Node address in "host:port" format
+        database: Database name to open
+        timeout: Connection timeout in seconds
+
+    Returns:
+        A connected AsyncConnection object
+    """
+    conn = AsyncConnection(address, database=database, timeout=timeout)
+    await conn.connect()
+    return conn

{dqlite_dbapi-0.1.2 → dqlite_dbapi-0.1.3}/src/dqlitedbapi/aio/connection.py

@@ -30,24 +30,28 @@ class AsyncConnection:
         self._async_conn: DqliteConnection | None = None
         self._closed = False
 
-    async def connect(self) -> None:
-        """Establish the connection."""
+    async def _ensure_connection(self) -> DqliteConnection:
+        """Ensure the underlying connection is established."""
         if self._closed:
             raise InterfaceError("Connection is closed")
 
-        if self._async_conn is not None:
-            return
-
-        self._async_conn = DqliteConnection(
-            self._address,
-            database=self._database,
-            timeout=self._timeout,
-        )
-        try:
-            await self._async_conn.connect()
-        except Exception as e:
-            self._async_conn = None
-            raise OperationalError(f"Failed to connect: {e}") from e
+        if self._async_conn is None:
+            self._async_conn = DqliteConnection(
+                self._address,
+                database=self._database,
+                timeout=self._timeout,
+            )
+            try:
+                await self._async_conn.connect()
+            except Exception as e:
+                self._async_conn = None
+                raise OperationalError(f"Failed to connect: {e}") from e
+
+        return self._async_conn
+
+    async def connect(self) -> None:
+        """Establish the connection."""
+        await self._ensure_connection()
 
     async def close(self) -> None:
         """Close the connection."""
@@ -72,8 +76,12 @@ class AsyncConnection:
         if self._async_conn is not None:
             await self._async_conn.execute("ROLLBACK")
 
-    async def cursor(self) -> AsyncCursor:
-        """Return a new AsyncCursor object."""
+    def cursor(self) -> AsyncCursor:
+        """Return a new AsyncCursor object.
+
+        This is intentionally sync — SQLAlchemy calls cursor() from
+        sync context within its greenlet-based async adapter.
+        """
         if self._closed:
             raise InterfaceError("Connection is closed")
         return AsyncCursor(self)

{dqlite_dbapi-0.1.2 → dqlite_dbapi-0.1.3}/src/dqlitedbapi/aio/cursor.py

@@ -58,10 +58,7 @@ class AsyncCursor:
         """Execute a database operation (query or command)."""
         self._check_closed()
 
-        conn = self._connection._async_conn
-        if conn is None:
-            raise InterfaceError("Connection is not open")
-
+        conn = await self._connection._ensure_connection()
         params = list(parameters) if parameters else None
 
         # Determine if this is a query that returns rows

dqlite_dbapi-0.1.2/src/dqlitedbapi/aio/__init__.py

@@ -1,43 +0,0 @@
-"""Async PEP 249-style interface for dqlite."""
-
-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",
-]
-
-
-async def aconnect(
-    address: str,
-    *,
-    database: str = "default",
-    timeout: float = 10.0,
-) -> AsyncConnection:
-    """Connect to a dqlite database asynchronously.
-
-    Args:
-        address: Node address in "host:port" format
-        database: Database name to open
-        timeout: Connection timeout in seconds
-
-    Returns:
-        An AsyncConnection object
-    """
-    conn = AsyncConnection(address, database=database, timeout=timeout)
-    await conn.connect()
-    return conn