o j(@sdZddlZddlZehdZedhZehdZehdZdddZGd d d Z Gd d d Z Gd ddZ GdddZ ddZ ddZddZdS)a/ Async wrappers for py-lmdb via :func:`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') N>Z max_readerspathZ max_key_sizeflagsid>valuekeyitem> iterprev_dupiterprev_nodupiternextiternext_nodup iternext_dupiterprevcCs t||S)zWrap an :class:`lmdb.Environment` for async use. *executor* is passed to :meth:`loop.run_in_executor`. ``None`` (the default) uses the loop's default executor. )AsyncEnvironment)envexecutorrI/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/lmdb/aio.pywrap6s rc@s4eZdZdZdZddZddZddZd d Zd S) _AsyncContextWrapperzWraps 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 _coro_resultcCs||_d|_dSNr)selfcororrr__init__J z_AsyncContextWrapper.__init__cCs |jSr)r __await__rrrrrNs z_AsyncContextWrapper.__await__cs|jIdH|_|jSrrrrrr __aenter__Qsz_AsyncContextWrapper.__aenter__cs|j|||IdHSr)r __aexit__)rexc_typeexc_valexc_tbrrrr Usz_AsyncContextWrapper.__aexit__N) __name__ __module__ __qualname____doc__ __slots__rrrr rrrrr?s rc@>eZdZdZdZdddZddZdd Zd d Zd d Z dS)ruAsync wrapper for :py:class:`lmdb.Environment`. Created by :py:func:`wrap`. All methods of the underlying :py:class:`~lmdb.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. _env _executorNcCs||_||_dSrr*)rrrrrrrhrzAsyncEnvironment.__init__c|SrrrrrrrnzAsyncEnvironment.__aenter__c|jdSr)r+closerZ_excrrrr qzAsyncEnvironment.__aexit__cfdd}t|S)a4Start a new transaction, returning an :py:class:`AsyncTransaction`. Accepts the same arguments as :py:meth:`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') csBt}|jtjjjgRiIdH}t|jSr) asyncioget_running_looprun_in_executorr, functoolspartialr+beginAsyncTransaction)looptxnargskwargsrrr_begins z&AsyncEnvironment.begin.._beginr)rr>r?r@rr=rr9vs zAsyncEnvironment.begincCs0t|j|}t|s |S|tvr|St||jSr)getattrr+callable _ENV_SYNC _async_methodr,rnameattrrrr __getattr__s  zAsyncEnvironment.__getattr__r) r$r%r&r'r(rrr r9rIrrrrrYs  rc@r))r:uAsync wrapper for :py:class:`lmdb.Transaction`. All methods of the underlying :py:class:`~lmdb.Transaction` are available. Most are dispatched to an executor; ``id()`` is called directly. An :py:class:`asyncio.Lock` serializes all operations dispatched through this transaction, including operations on its cursors. This makes :py:func:`asyncio.gather` safe on the same transaction. Supports ``async with`` — write transactions are committed on clean exit and aborted on exception. )_txnr,_lockNcCs||_||_t|_dSr)rJr,r4LockrK)rr<rrrrrszAsyncTransaction.__init__cr-rrrrrrrr.zAsyncTransaction.__aenter__c s|j4IdH/|r|jnt}||j|jjIdHWdIdHdSWdIdHdS1IdHs=wYdSr)rKrJabortr4r5r6r,commit)rr!Z_exc_valZ_exc_tbr;rrrr s .zAsyncTransaction.__aexit__cr3)a;Open a cursor, returning an :py:class:`AsyncCursor`. Accepts the same arguments as :py:meth:`lmdb.Transaction.cursor`. Can be used with ``await`` or ``async with``:: async with txn.cursor() as cur: await cur.first() items = await cur.iternext() c sj4IdH%t}|jtjjjgRiIdH}WdIdHn 1IdHs3wYt |jjSr) rKr4r5r6r,r7r8rJcursor AsyncCursor)r;curr=rr_cursors (z(AsyncTransaction.cursor.._cursorrA)rr>r?rRrr=rrOs zAsyncTransaction.cursorcCs4t|j|}t|s |S|tvr|St||j|jSr)rBrJrC _TXN_SYNC_async_method_lockedr,rKrFrrrrIs zAsyncTransaction.__getattr__r) r$r%r&r'r(rrr rOrIrrrrr:s  r:c@sfeZdZdZdZdddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZdS)rPuAsync wrapper for :py:class:`lmdb.Cursor`. All methods of the underlying :py:class:`~lmdb.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 :py:class:`asyncio.Lock`. Supports ``async with`` — the cursor is closed on exit. )rRr,rKNcCs||_||_|p t|_dSr)rRr,r4rLrK)rrOrlockrrrrszAsyncCursor.__init__cr-rrrrrrrr.zAsyncCursor.__aenter__cr/r)rRr0r1rrrr r2zAsyncCursor.__aexit__ct|jj||j|jIdHSr)_collect_lockedrRr r,rKrkwrrrr  zAsyncCursor.iternextcrVr)rWrRr r,rKrXrrrr rZzAsyncCursor.iternext_dupcrVr)rWrRr r,rKrXrrrr rZzAsyncCursor.iternext_nodupcrVr)rWrRr r,rKrXrrrr rZzAsyncCursor.iterprevcrVr)rWrRrr,rKrXrrrrrZzAsyncCursor.iterprev_dupcrVr)rWrRr r,rKrXrrrr rZzAsyncCursor.iterprev_nodupcCsRt|j|}t|s |S|tvr|S|tvr!tt|i|j|j St ||j|j Sr) rBrRrC _CURSOR_SYNC _CURSOR_ITERSr7r8rWr,rKrTrFrrrrIs zAsyncCursor.__getattr__)NN)r$r%r&r'r(rrr r r r r rr rIrrrrrPs  rPcstfdd}|S)z>Return a coroutine function that calls *method* in *executor*.cs0t}|tjg|Ri|IdHSrr4r5r6r7r8r>r?r;rmethodrrwrapper"s  z_async_method..wrapperr7wraps)r`rrarr_rrE srEcstfdd}|S)z6Like :func:`_async_method`, but acquires *lock* first.c sl4IdH"t}|tjg|Ri|IdHWdIdHS1IdHs/wYdSrr]r^rrUr`rrra.s0z%_async_method_locked..wrapperrb)r`rrUrarrdrrT,srTc sft}fdd}|4IdH|||IdHWdIdHS1IdHs,wYdS)z:Call an iterator method in the executor and return a list.cstdiS)Nr)listr iter_methodr?rr_consume=sz!_collect_locked.._consumeN)r4r5r6)rgr?rrUr;rhrrfrrW9s 0rWr)r'r4r7 frozensetrDrSr[r\rrrr:rPrErTrWrrrrs      :CJ