zlmdb._lmdb_vendor.aio

Async wrappers for py-lmdb via asyncio.loop.run_in_executor().

Usage:

import lmdb
import lmdb.aio

env = lmdb.open('/tmp/mydb')
aenv = lmdb.aio.wrap(env)

async with aenv.begin(write=True) as txn:
    await txn.put(b'key', b'value')
    val = await txn.get(b'key')

Classes

AsyncCursor	Async wrapper for lmdb.Cursor.
AsyncEnvironment	Async wrapper for lmdb.Environment.
AsyncTransaction	Async wrapper for lmdb.Transaction.
_AsyncContextWrapper	Wraps a coroutine so it can be used as both await and async with.

Functions

_async_method(sync)	Return a coroutine method that calls sync in the executor.
_async_method_locked(sync)	Like _async_method(), but acquires self._lock first.
_collect_locked(sync)	Like _async_method_locked(), but sync returns an iterator
_sync_method(sync)	Return a method that calls sync directly, without an executor.
wrap(env[, executor])	Wrap an lmdb.Environment for async use.

Module Contents

class AsyncCursor(cursor, executor=None, lock=None)

Async wrapper for lmdb.Cursor.

All methods of the underlying Cursor are available. Most are dispatched to an executor; key(), value(), and item() are called directly.

Iterator methods (iternext(), iterprev(), etc.) are consumed in the executor and returned as a list.

Shares the parent transaction’s asyncio.Lock.

Supports async with — the cursor is closed on exit.

_WRAPS = '_cursor'

async __aenter__()

async __aexit__(*_exc)

__getattr__(name)

__slots__ = ('_cursor', '_executor', '_lock')

_cursor

_executor = None

_lock

close

count

delete

first

first_dup

get

getmulti

item

iternext

iternext_dup

iternext_nodup

iterprev

iterprev_dup

iterprev_nodup

key

last

last_dup

next

next_dup

next_nodup

pop

prev

prev_dup

prev_nodup

put

putmulti

replace

set_key

set_key_dup

set_range

set_range_dup

value

class AsyncEnvironment(env, executor=None)

Async wrapper for lmdb.Environment.

Created by wrap(). All methods of the underlying Environment are available and are dispatched to an executor, except for the low-overhead accessors path(), max_key_size(), max_readers(), and flags(), which are called directly.

Supports async with for lifetime management — the environment is closed on exit.

_WRAPS = '_env'

async __aenter__()

async __aexit__(*_exc)

__getattr__(name)

__slots__ = ('_env', '_executor')

_env

_executor = None

begin(*args, **kwargs)

Start a new transaction, returning an AsyncTransaction.

Accepts the same arguments as lmdb.Environment.begin(). Can be used with await or async with:

async with aenv.begin(write=True) as txn:
    await txn.put(b'key', b'value')

close

copy

copyfd

dbs

flags

info

max_key_size

max_readers

open_db

path

reader_check

readers

set_mapsize

stat

sync

class AsyncTransaction(txn, executor=None)

Async wrapper for lmdb.Transaction.

All methods of the underlying Transaction are available. Most are dispatched to an executor; id() is called directly.

An asyncio.Lock serializes all operations dispatched through this transaction, including operations on its cursors. This makes asyncio.gather() safe on the same transaction.

Supports async with — write transactions are committed on clean exit and aborted on exception.

_WRAPS = '_txn'

async __aenter__()

async __aexit__(exc_type, _exc_val, _exc_tb)

__getattr__(name)

__slots__ = ('_txn', '_executor', '_lock')

_executor = None

_lock

_txn

abort

commit

cursor(*args, **kwargs)

Open a cursor, returning an AsyncCursor.

Accepts the same arguments as lmdb.Transaction.cursor(). Can be used with await or async with:

async with txn.cursor() as cur:
    await cur.first()
    items = await cur.iternext()

delete

drop

get

id

pop

put

replace

stat

class _AsyncContextWrapper(coro)

Wraps a coroutine so it can be used as both await and async with.

Supports:

txn = await aenv.begin(write=True)      # just await
async with aenv.begin(write=True) as txn:  # context manager

async __aenter__()

async __aexit__(exc_type, exc_val, exc_tb)

__await__()

__slots__ = ('_coro', '_result')

_coro

_result = None

_async_method(sync)

Return a coroutine method that calls sync in the executor.

_async_method_locked(sync)

Like _async_method(), but acquires self._lock first.

_collect_locked(sync)

Like _async_method_locked(), but sync returns an iterator consumed in the executor and returned as a list.

_sync_method(sync)

Return a method that calls sync directly, without an executor.

wrap(env, executor=None)

Wrap an lmdb.Environment for async use.

executor is passed to loop.run_in_executor(). None (the default) uses the loop’s default executor.