nomosdb 0.16.0__tar.gz

nomosdb-0.16.0/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2024 DingBo and NomosDB Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

nomosdb-0.16.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: nomosdb
+Version: 0.16.0
+Summary: Python driver for NomosDB, the graph database: Bolt, transactions, cluster routing, asyncio
+Author: DingBo
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/cndingbo2030/nomosdb
+Project-URL: Documentation, https://github.com/cndingbo2030/nomosdb/blob/main/docs/sdk/python.md
+Project-URL: Source, https://github.com/cndingbo2030/nomosdb/tree/main/nomosdb-python
+Project-URL: Changelog, https://github.com/cndingbo2030/nomosdb/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/cndingbo2030/nomosdb/issues
+Keywords: graph database,nomosdb,bolt,cypher,neo4j
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8.0; extra == "async"
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3.0; extra == "pandas"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: aiohttp>=3.8.0; extra == "dev"
+Requires-Dist: neo4j>=5; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# nomosdb — the Python driver for NomosDB
+
+The official Python driver for [NomosDB](https://github.com/cndingbo2030/nomosdb), a graph database you query in Cypher (NomosDB calls its dialect DQL).
+
+- Native **Bolt 5.0–5.4**, the protocol the Neo4j drivers use.
+- **Transactions** that commit or roll back as a whole.
+- **Managed transactions** that are retried on conflicts and leader changes.
+- **Cluster routing** with causal consistency.
+- **asyncio**.
+- Pure Python, no dependencies, Python 3.9+.
+
+```bash
+pip install nomosdb
+```
+
+## Quick start
+
+```python
+import nomosdb
+
+driver = nomosdb.driver("bolt://localhost:7687", auth=("nomosdb", "secret"))
+
+with driver.session() as session:
+    # one statement, committed on its own; records stream in batches
+    for record in session.run("MATCH (p:Person) WHERE p.age > $min RETURN p.name AS name", min=30):
+        print(record["name"])
+
+    # a managed transaction: on a transient failure the whole function runs again
+    def transfer(tx, a, b, amount):
+        tx.run("MATCH (x:Account {id: $a}) SET x.balance = x.balance - $n", a=a, n=amount)
+        tx.run("MATCH (x:Account {id: $b}) SET x.balance = x.balance + $n", b=b, n=amount)
+
+    session.execute_write(transfer, 1, 2, 10)
+
+    # an explicit transaction
+    with session.begin_transaction() as tx:
+        tx.run("CREATE (:Person {name: $name})", name="Ann")
+        tx.commit()   # leaving the block without commit() rolls back
+
+    # bulk loading: one retried transaction per batch, the batch as $rows
+    session.write_batch("UNWIND $rows AS r CREATE (:Person {name: r.name})",
+                        ({"name": f"p{i}"} for i in range(100_000)), batch_size=5000)
+
+driver.close()
+```
+
+### asyncio
+
+```python
+import asyncio
+import nomosdb
+
+async def main():
+    async with nomosdb.async_driver("bolt://localhost:7687", auth=("nomosdb", "secret")) as driver:
+        async with driver.session() as session:
+            result = await session.run("MATCH (p:Person) RETURN p.name AS name")
+            async for record in result:
+                print(record["name"])
+
+asyncio.run(main())
+```
+
+Every method of the blocking API exists in the async one under the same name. The async version adds `await`, `async with` and `async for`.
+
+## URIs
+
+| URI | Meaning |
+|-----|---------|
+| `bolt://host:7687` | One server. |
+| `bolt+s://host:7687` | One server over TLS, with the certificate verified (system CAs, or `trusted_certificates="ca.pem"`). |
+| `bolt+ssc://host:7687` | One server over TLS, accepting a self-signed certificate. |
+| `nomosdb://host:7687` | A cluster. `neo4j://` is also accepted. |
+| `nomosdb+s://`, `nomosdb+ssc://` | A cluster over TLS. |
+
+With a cluster URI, the driver asks any member for the routing table. Writes go to the leader and reads are spread over the members. Each session passes its bookmark to the next transaction, so a read sees the session's earlier writes on whichever member serves it.
+
+## Results
+
+`session.run()` and `tx.run()` return a `Result`. You can iterate it, or call one of these methods:
+
+- `single()`: the one record, or `None`.
+- `data()`: a list of dicts.
+- `value()`: the first column.
+- `to_list()`: all records.
+- `peek()`: the next record without consuming it.
+- `consume()`: skips the remaining records and returns the `ResultSummary` (`counters.nodes_created` and the other counters, `query_type`, `bookmark`).
+
+A `Record` reads by name or by position: `record["name"]`, `record[0]`, `record.data()`.
+
+Nodes, relationships and paths come back as `nomosdb.graph.Node`, `Relationship` and `Path`. You read their properties like a dict, and they also have `labels`, `type`, `start_node`, `end_node` and `element_id`.
+
+## Errors
+
+| Exception | When |
+|-----------|------|
+| `ClientError` | The statement is wrong: syntax, a missing parameter, a constraint. `code` holds the server's `Neo.ClientError.*` code. |
+| `TransientError` | A write conflict or a lock timeout. Managed transactions retry it. |
+| `AuthError` | Wrong credentials, or a role that is too low. |
+| `ServiceUnavailable`, `SessionExpired` | No server is reachable, or a connection broke. Managed transactions retry these. |
+| `TransactionCommitUnknown` | The connection broke after COMMIT was sent, so the transaction may have committed. It is never retried automatically. |
+
+## Driver options
+
+`nomosdb.driver(uri, auth, **options)` accepts these options:
+
+| Option | Default | Meaning |
+|--------|---------|---------|
+| `max_connection_pool_size` | 100 | Most connections kept per server. |
+| `connection_timeout` | 30 s | Limit on TCP connect, TLS and Bolt handshake. |
+| `connection_acquisition_timeout` | 60 s | How long to wait for a free pooled connection. |
+| `max_transaction_retry_time` | 30 s | How long managed transactions keep retrying. |
+| `fetch_size` | 1000 | Records per batch. |
+| `trusted_certificates` | system CAs | CA file for `+s` URIs. |
+| `user_agent` | `nomosdb-python/<version>` | Sent to the server. |
+
+## The earlier client
+
+The 0.1 API still works:
+
+- `NomosDB(uri).query()` returns rows as dicts.
+- The ORM (`@node_class`, `Model.objects.filter(...)`) works as before.
+
+With a `bolt://` URI these use the driver above, so `db.session().begin_transaction()` is a real transaction.
+
+With `http://`, each statement commits on its own, and `begin_transaction()` raises `TransactionError`. It no longer returns an object that only looked like a transaction.
+
+## Development
+
+```bash
+cd nomosdb-python
+python tools/unasync.py              # after editing nomosdb/_async/: regenerates nomosdb/_sync/
+NOMOSDB_SERVER=../build/tools/nomosdb-server NOMOSDB_CERTS=../build/tools/nomosdb-certs python -m pytest tests
+```
+
+The tests start real `nomosdb-server` processes: a single server, a TLS server and a three-member cluster.
+
+License: Apache-2.0.

nomosdb-0.16.0/README.md

@@ -0,0 +1,137 @@
+# nomosdb — the Python driver for NomosDB
+
+The official Python driver for [NomosDB](https://github.com/cndingbo2030/nomosdb), a graph database you query in Cypher (NomosDB calls its dialect DQL).
+
+- Native **Bolt 5.0–5.4**, the protocol the Neo4j drivers use.
+- **Transactions** that commit or roll back as a whole.
+- **Managed transactions** that are retried on conflicts and leader changes.
+- **Cluster routing** with causal consistency.
+- **asyncio**.
+- Pure Python, no dependencies, Python 3.9+.
+
+```bash
+pip install nomosdb
+```
+
+## Quick start
+
+```python
+import nomosdb
+
+driver = nomosdb.driver("bolt://localhost:7687", auth=("nomosdb", "secret"))
+
+with driver.session() as session:
+    # one statement, committed on its own; records stream in batches
+    for record in session.run("MATCH (p:Person) WHERE p.age > $min RETURN p.name AS name", min=30):
+        print(record["name"])
+
+    # a managed transaction: on a transient failure the whole function runs again
+    def transfer(tx, a, b, amount):
+        tx.run("MATCH (x:Account {id: $a}) SET x.balance = x.balance - $n", a=a, n=amount)
+        tx.run("MATCH (x:Account {id: $b}) SET x.balance = x.balance + $n", b=b, n=amount)
+
+    session.execute_write(transfer, 1, 2, 10)
+
+    # an explicit transaction
+    with session.begin_transaction() as tx:
+        tx.run("CREATE (:Person {name: $name})", name="Ann")
+        tx.commit()   # leaving the block without commit() rolls back
+
+    # bulk loading: one retried transaction per batch, the batch as $rows
+    session.write_batch("UNWIND $rows AS r CREATE (:Person {name: r.name})",
+                        ({"name": f"p{i}"} for i in range(100_000)), batch_size=5000)
+
+driver.close()
+```
+
+### asyncio
+
+```python
+import asyncio
+import nomosdb
+
+async def main():
+    async with nomosdb.async_driver("bolt://localhost:7687", auth=("nomosdb", "secret")) as driver:
+        async with driver.session() as session:
+            result = await session.run("MATCH (p:Person) RETURN p.name AS name")
+            async for record in result:
+                print(record["name"])
+
+asyncio.run(main())
+```
+
+Every method of the blocking API exists in the async one under the same name. The async version adds `await`, `async with` and `async for`.
+
+## URIs
+
+| URI | Meaning |
+|-----|---------|
+| `bolt://host:7687` | One server. |
+| `bolt+s://host:7687` | One server over TLS, with the certificate verified (system CAs, or `trusted_certificates="ca.pem"`). |
+| `bolt+ssc://host:7687` | One server over TLS, accepting a self-signed certificate. |
+| `nomosdb://host:7687` | A cluster. `neo4j://` is also accepted. |
+| `nomosdb+s://`, `nomosdb+ssc://` | A cluster over TLS. |
+
+With a cluster URI, the driver asks any member for the routing table. Writes go to the leader and reads are spread over the members. Each session passes its bookmark to the next transaction, so a read sees the session's earlier writes on whichever member serves it.
+
+## Results
+
+`session.run()` and `tx.run()` return a `Result`. You can iterate it, or call one of these methods:
+
+- `single()`: the one record, or `None`.
+- `data()`: a list of dicts.
+- `value()`: the first column.
+- `to_list()`: all records.
+- `peek()`: the next record without consuming it.
+- `consume()`: skips the remaining records and returns the `ResultSummary` (`counters.nodes_created` and the other counters, `query_type`, `bookmark`).
+
+A `Record` reads by name or by position: `record["name"]`, `record[0]`, `record.data()`.
+
+Nodes, relationships and paths come back as `nomosdb.graph.Node`, `Relationship` and `Path`. You read their properties like a dict, and they also have `labels`, `type`, `start_node`, `end_node` and `element_id`.
+
+## Errors
+
+| Exception | When |
+|-----------|------|
+| `ClientError` | The statement is wrong: syntax, a missing parameter, a constraint. `code` holds the server's `Neo.ClientError.*` code. |
+| `TransientError` | A write conflict or a lock timeout. Managed transactions retry it. |
+| `AuthError` | Wrong credentials, or a role that is too low. |
+| `ServiceUnavailable`, `SessionExpired` | No server is reachable, or a connection broke. Managed transactions retry these. |
+| `TransactionCommitUnknown` | The connection broke after COMMIT was sent, so the transaction may have committed. It is never retried automatically. |
+
+## Driver options
+
+`nomosdb.driver(uri, auth, **options)` accepts these options:
+
+| Option | Default | Meaning |
+|--------|---------|---------|
+| `max_connection_pool_size` | 100 | Most connections kept per server. |
+| `connection_timeout` | 30 s | Limit on TCP connect, TLS and Bolt handshake. |
+| `connection_acquisition_timeout` | 60 s | How long to wait for a free pooled connection. |
+| `max_transaction_retry_time` | 30 s | How long managed transactions keep retrying. |
+| `fetch_size` | 1000 | Records per batch. |
+| `trusted_certificates` | system CAs | CA file for `+s` URIs. |
+| `user_agent` | `nomosdb-python/<version>` | Sent to the server. |
+
+## The earlier client
+
+The 0.1 API still works:
+
+- `NomosDB(uri).query()` returns rows as dicts.
+- The ORM (`@node_class`, `Model.objects.filter(...)`) works as before.
+
+With a `bolt://` URI these use the driver above, so `db.session().begin_transaction()` is a real transaction.
+
+With `http://`, each statement commits on its own, and `begin_transaction()` raises `TransactionError`. It no longer returns an object that only looked like a transaction.
+
+## Development
+
+```bash
+cd nomosdb-python
+python tools/unasync.py              # after editing nomosdb/_async/: regenerates nomosdb/_sync/
+NOMOSDB_SERVER=../build/tools/nomosdb-server NOMOSDB_CERTS=../build/tools/nomosdb-certs python -m pytest tests
+```
+
+The tests start real `nomosdb-server` processes: a single server, a TLS server and a three-member cluster.
+
+License: Apache-2.0.

nomosdb-0.16.0/nomosdb/__init__.py

@@ -0,0 +1,59 @@
+"""
+NomosDB Python driver.
+
+Bolt (recommended): real transactions, retries, cluster routing, asyncio.
+
+    >>> import nomosdb
+    >>> drv = nomosdb.driver("bolt://localhost:7687", auth=("nomosdb", "secret"))
+    >>> with drv.session() as s:
+    ...     for rec in s.run("MATCH (p:Person) RETURN p.name AS name LIMIT 10"):
+    ...         print(rec["name"])
+    >>> drv.close()
+
+The earlier client stays available: NomosDB("bolt://...") or NomosDB("http://...")
+with query() returning dict rows, and the ORM.
+"""
+
+from ._async.driver import AsyncDriver, async_driver
+from ._async.work import AsyncManagedTransaction, AsyncResult, AsyncSession, AsyncTransaction
+from ._common import READ_ACCESS, WRITE_ACCESS, Record, ResultSummary, SummaryCounters
+from ._sync.driver import Driver, driver
+from ._sync.work import ManagedTransaction, Result, Session, Transaction
+from ._version import __version__
+from .client import NomosDB
+from .connection import Result as QueryResult
+from .exceptions import (
+    AuthError,
+    AuthenticationError,
+    ClientError,
+    ConfigurationError,
+    ConnectionPoolFull,
+    DatabaseError,
+    NomosConnectionError,
+    NomosDBError,
+    NotALeader,
+    ProtocolError,
+    QueryException,
+    ResultConsumedError,
+    ResultNotSingleError,
+    ServerError,
+    ServiceUnavailable,
+    SessionExpired,
+    TransactionCommitUnknown,
+    TransactionError,
+    TransientError,
+)
+from .orm import Entity, Node, Relationship, node_class, relationship_class
+
+__all__ = [
+    "driver", "async_driver", "Driver", "AsyncDriver",
+    "Session", "AsyncSession", "Transaction", "AsyncTransaction",
+    "ManagedTransaction", "AsyncManagedTransaction", "Result", "AsyncResult",
+    "Record", "ResultSummary", "SummaryCounters", "READ_ACCESS", "WRITE_ACCESS",
+    "NomosDB", "QueryResult", "Node", "Relationship", "Entity", "node_class", "relationship_class",
+    "NomosDBError", "NomosConnectionError", "ConnectionPoolFull", "QueryException", "TransactionError",
+    "AuthenticationError", "ProtocolError", "ConfigurationError", "ServerError", "ClientError",
+    "TransientError", "DatabaseError", "AuthError", "NotALeader", "ServiceUnavailable", "SessionExpired",
+    "TransactionCommitUnknown", "ResultConsumedError", "ResultNotSingleError",
+    "__version__",
+]

nomosdb-0.16.0/nomosdb/_async/connection.py

@@ -0,0 +1,126 @@
+"""One Bolt connection: handshake, authentication, pipelined requests."""
+
+from typing import Optional, Tuple
+
+from .._bolt import HANDSHAKE, Dechunker, Protocol, Response, parse_version
+from .._common import Address, Config
+from .._io import AsyncBoltSocket, monotonic
+from ..exceptions import ServerError, ServiceUnavailable, SessionExpired
+
+
+class AsyncConnection:
+    def __init__(self, sock: AsyncBoltSocket, address: Address, version: Tuple[int, int]):
+        self._sock = sock
+        self.address = address
+        self.protocol = Protocol(version)
+        self._dechunker = Dechunker()
+        self._inbox: list = []
+        self.server_agent = ""
+        self.connection_id = ""
+        self.defunct = False
+        self.closed = False
+        self.last_used = monotonic()
+
+    @classmethod
+    async def open(cls, address: Address, config: Config) -> "AsyncConnection":
+        sock = await AsyncBoltSocket.connect(address, config.ssl_context, config.connection_timeout)
+        try:
+            await sock.sendall(HANDSHAKE)
+            answer = b""
+            while len(answer) < 4:
+                part = await sock.recv(config.connection_timeout)
+                if not part:
+                    raise ServiceUnavailable(f"{address[0]}:{address[1]} closed the connection during the Bolt handshake "
+                                             "(is it the Bolt port? nomosdb-server listens for Bolt on 7687)")
+                answer += part
+            conn = cls(sock, address, parse_version(answer[:4]))
+            if len(answer) > 4:
+                conn._inbox.extend(conn._dechunker.feed(answer[4:]))
+            hello = conn.protocol.hello(config.user_agent, config.auth, config.routing_context)
+            await conn.send_all()
+            await conn.fetch_all()
+        except BaseException as e:
+            await sock.close()
+            if isinstance(e, OSError):
+                raise ServiceUnavailable(f"{address[0]}:{address[1]} did not complete the Bolt handshake "
+                                         f"(is it the Bolt port? nomosdb-server listens for Bolt on 7687): {e}") from None
+            raise
+        conn.server_agent = str(hello.metadata.get("server", ""))
+        conn.connection_id = str(hello.metadata.get("connection_id", ""))
+        return conn
+
+    # -- I/O
+    async def send_all(self) -> None:
+        data = self.protocol.take_outbox()
+        if not data:
+            return
+        try:
+            await self._sock.sendall(data)
+        except OSError as e:
+            await self._broken(e)
+
+    async def fetch_message(self) -> None:
+        """Reads until at least one answer has been handled."""
+        while not self._inbox:
+            try:
+                data = await self._sock.recv()
+            except OSError as e:
+                await self._broken(e)
+            if not data:
+                await self._broken(None)
+            self._inbox.extend(self._dechunker.feed(data))
+        tag, fields = self._inbox.pop(0)
+        self.protocol.handle(tag, fields)
+
+    async def fetch_all(self) -> None:
+        """Reads the answers to every request sent; raises the first failure."""
+        error: Optional[ServerError] = None
+        while self.protocol.pending:
+            r = self.protocol.pending[0]
+            while not r.done:
+                await self.fetch_message()
+            if r.error is not None and error is None:
+                error = r.error
+        if error is not None:
+            raise error
+
+    async def wait(self, r: Response) -> Response:
+        """Sends what is queued and reads until r is answered; raises its failure."""
+        await self.send_all()
+        while not r.done:
+            await self.fetch_message()
+        if r.error is not None:
+            raise r.error
+        return r
+
+    async def _broken(self, e: Optional[BaseException]) -> None:
+        self.defunct = True
+        await self._sock.close()
+        why = f": {e}" if e else ""
+        raise SessionExpired(f"the connection to {self.address[0]}:{self.address[1]} broke{why}")
+
+    # -- state
+    async def reset(self) -> None:
+        """Back to READY: ends a transaction or a failure."""
+        r = self.protocol.reset(Response("RESET"))
+        await self.wait(r)
+        await self.fetch_all()
+
+    @property
+    def ready(self) -> bool:
+        return not (self.defunct or self.closed or self.protocol.pending or self.protocol.failed)
+
+    async def close(self) -> None:
+        if self.closed:
+            return
+        self.closed = True
+        if not self.defunct:
+            try:
+                self.protocol.goodbye()
+                await self._sock.sendall(self.protocol.take_outbox())
+            except OSError:
+                pass
+        await self._sock.close()
+
+    def __repr__(self) -> str:
+        return f"<AsyncConnection {self.address[0]}:{self.address[1]} bolt/{self.protocol.version[0]}.{self.protocol.version[1]}>"

nomosdb-0.16.0/nomosdb/_async/driver.py

@@ -0,0 +1,75 @@
+"""The driver: configuration, the connection pool, sessions."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from .._common import READ_ACCESS, WRITE_ACCESS, Config, Record, ResultSummary
+from ..exceptions import ConfigurationError
+from .pool import AsyncDirectPool, AsyncRoutingPool
+from .work import AsyncManagedTransaction, AsyncSession
+
+
+class AsyncDriver:
+    """Holds the connection pool of one server or cluster. Thread safe (the blocking
+    Driver) / task safe (AsyncDriver); sessions are not."""
+
+    def __init__(self, uri: str, auth: Any = None, **config: Any):
+        self._config = Config(uri, auth, **config)
+        self._pool = AsyncRoutingPool(self._config) if self._config.routing else AsyncDirectPool(self._config)
+
+    @property
+    def encrypted(self) -> bool:
+        return self._config.ssl_context is not None
+
+    def session(self, default_access_mode: str = WRITE_ACCESS, bookmarks: Optional[List[str]] = None,
+                fetch_size: Optional[int] = None, database: Optional[str] = None) -> AsyncSession:
+        return AsyncSession(self._pool, self._config, default_access_mode, bookmarks, fetch_size, database)
+
+    async def verify_connectivity(self) -> None:
+        """Raises unless a server answers and accepts the credentials."""
+        conn = await self._pool.acquire(READ_ACCESS, [])
+        await self._pool.release(conn)
+
+    async def get_server_info(self) -> Dict[str, Any]:
+        conn = await self._pool.acquire(READ_ACCESS, [])
+        try:
+            return {"address": conn.address, "agent": conn.server_agent,
+                    "protocol_version": conn.protocol.version, "connection_id": conn.connection_id}
+        finally:
+            await self._pool.release(conn)
+
+    async def execute_query(self, query: str, parameters: Optional[Dict[str, Any]] = None, routing: str = "w",
+                            bookmarks: Optional[List[str]] = None,
+                            **kwparameters: Any) -> Tuple[List[Record], ResultSummary, List[str]]:
+        """Runs one statement in a retried transaction and returns (records, summary, keys)."""
+        if routing not in ("r", "w"):
+            raise ConfigurationError("routing is 'r' (a reader) or 'w' (the leader)")
+        params = {**(parameters or {}), **kwparameters}
+
+        async def work(tx: AsyncManagedTransaction) -> Tuple[List[Record], ResultSummary, List[str]]:
+            res = await tx.run(query, params)
+            records = await res.to_list()
+            return records, await res.consume(), await res.keys()
+
+        async with self.session(bookmarks=bookmarks) as s:
+            if routing == "r":
+                return await s.execute_read(work)
+            return await s.execute_write(work)
+
+    async def close(self) -> None:
+        await self._pool.close()
+
+    async def __aenter__(self) -> "AsyncDriver":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+
+def async_driver(uri: str, auth: Any = None, **config: Any) -> AsyncDriver:
+    """A driver for bolt://host:7687 (one server) or nomosdb://host:7687 (a cluster),
+    with +s (TLS, verified) or +ssc (TLS, self-signed) for encryption.
+
+    auth is (user, password). Options: max_connection_pool_size, connection_timeout,
+    connection_acquisition_timeout, max_transaction_retry_time, fetch_size,
+    trusted_certificates (a CA file for +s), user_agent."""
+    return AsyncDriver(uri, auth, **config)