i2h SrSSKJr SSKJr SSKrSSKrSSKrSSKrSSKr\RS:Hr \ (aSSK r SSK r SSKrSSKJr /SQr\/SQ- r\"\ S \5r\"\ S \5r\"S S 5r\"S S 5r\"5R35r\R6"5rSrSrSr\R@"5(dSSK!r!\(a \RDO S/SS/S///S.r#S\RDS;r$\$(a\\- r\!RJ"5r&\&RO\5 \&RQ\SS\#S\#S\#S\#S\#SS9r)\&RUS5S 5r+"S!S"\,5r-"S#S$\-5r."S%S&\-5r/"S'S(\-5r0"S)S*\-5r1"S+S,\-5r2"S-S.\-5r3"S/S0\-5r4"S1S2\-5r5"S3S4\-5r6"S5S6\-5r7"S7S8\-5r8"S9S:\-5r9"S;S<\-5r:"S=S>\-5r;"S?S@\-5r<"SASB\-5r="SCSD\-5r>"SESF\-5r?"SGSH\-5r@"SISJ\-5rA"SKSL\-5rB"SMSN\-5rC"SOSP\-5rD"SQSR\-5rE"SSST\-5rF\R@"5(dk0rG\H"\I"5R55HIrK\R"\K5(dM\M"\K\-5(dM,\K\-LdM3\K\G\"\)\KR5'MK CKSUrO"SVSW\P5rQ\Q"5rRSXrSSYrTSZrUS[rVSeS\jrW"S]S^\P5rX"S_S`\P5rY\XrZ"SaSb\P5r["ScSd\P5r\g!\ a SSKr GNf=f!\ a SrGN"f=f)fzh CPython/CFFI wrapper for OpenLDAP's "Lightning" MDB database. Please see https://lmdb.readthedocs.io/ )absolute_import)with_statementNwin32)_config)Cursor Environment Transaction _Databaseenable_drop_gilversion) BadDbiError BadRslotError BadTxnErrorBadValsizeErrorCorruptedErrorCursorFullError DbsFullError DiskErrorErrorIncompatibleError InvalidErrorInvalidParameterErrorKeyExistsError LockError MapFullErrorMapResizedError MemoryError NotFoundError PageFullErrorPageNotFoundError PanicErrorReadersFullError ReadonlyError TlsFullError TxnFullErrorVersionMismatchErrorunicodebytes07550111az typedef int mode_t; typedef ... MDB_env; typedef struct MDB_txn MDB_txn; typedef struct MDB_cursor MDB_cursor; typedef unsigned int MDB_dbi; enum MDB_cursor_op { MDB_FIRST, MDB_FIRST_DUP, MDB_GET_BOTH, MDB_GET_BOTH_RANGE, MDB_GET_CURRENT, MDB_GET_MULTIPLE, MDB_LAST, MDB_LAST_DUP, MDB_NEXT, MDB_NEXT_DUP, MDB_NEXT_MULTIPLE, MDB_NEXT_NODUP, MDB_PREV, MDB_PREV_DUP, MDB_PREV_NODUP, MDB_SET, MDB_SET_KEY, MDB_SET_RANGE, ... }; typedef enum MDB_cursor_op MDB_cursor_op; struct MDB_val { size_t mv_size; void *mv_data; ...; }; typedef struct MDB_val MDB_val; struct MDB_stat { unsigned int ms_psize; unsigned int ms_depth; size_t ms_branch_pages; size_t ms_leaf_pages; size_t ms_overflow_pages; size_t ms_entries; ...; }; typedef struct MDB_stat MDB_stat; struct MDB_envinfo { void *me_mapaddr; size_t me_mapsize; size_t me_last_pgno; size_t me_last_txnid; unsigned int me_maxreaders; unsigned int me_numreaders; ...; }; typedef struct MDB_envinfo MDB_envinfo; typedef int (*MDB_cmp_func)(const MDB_val *a, const MDB_val *b); typedef void (*MDB_rel_func)(MDB_val *item, void *oldptr, void *newptr, void *relctx); char *mdb_strerror(int err); int mdb_env_create(MDB_env **env); int mdb_env_open(MDB_env *env, const char *path, unsigned int flags, mode_t mode); int mdb_env_copy2(MDB_env *env, const char *path, int flags); int mdb_env_copyfd2(MDB_env *env, int fd, int flags); int mdb_env_stat(MDB_env *env, MDB_stat *stat); int mdb_env_info(MDB_env *env, MDB_envinfo *stat); int mdb_env_get_maxkeysize(MDB_env *env); int mdb_env_sync(MDB_env *env, int force); void mdb_env_close(MDB_env *env); int mdb_env_set_flags(MDB_env *env, unsigned int flags, int onoff); int mdb_env_get_flags(MDB_env *env, unsigned int *flags); int mdb_env_get_path(MDB_env *env, const char **path); int mdb_env_set_mapsize(MDB_env *env, size_t size); int mdb_env_set_maxreaders(MDB_env *env, unsigned int readers); int mdb_env_get_maxreaders(MDB_env *env, unsigned int *readers); int mdb_env_set_maxdbs(MDB_env *env, MDB_dbi dbs); int mdb_txn_begin(MDB_env *env, MDB_txn *parent, unsigned int flags, MDB_txn **txn); int mdb_txn_commit(MDB_txn *txn); void mdb_txn_reset(MDB_txn *txn); int mdb_txn_renew(MDB_txn *txn); void mdb_txn_abort(MDB_txn *txn); size_t mdb_txn_id(MDB_txn *txn); int mdb_dbi_open(MDB_txn *txn, const char *name, unsigned int flags, MDB_dbi *dbi); int mdb_stat(MDB_txn *txn, MDB_dbi dbi, MDB_stat *stat); int mdb_drop(MDB_txn *txn, MDB_dbi dbi, int del_); int mdb_get(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data); int mdb_cursor_open(MDB_txn *txn, MDB_dbi dbi, MDB_cursor **cursor); void mdb_cursor_close(MDB_cursor *cursor); int mdb_cursor_del(MDB_cursor *cursor, unsigned int flags); int mdb_cursor_count(MDB_cursor *cursor, size_t *countp); int mdb_cursor_get(MDB_cursor *cursor, MDB_val *key, MDB_val*data, int op); typedef int (MDB_msg_func)(const char *msg, void *ctx); int mdb_reader_list(MDB_env *env, MDB_msg_func *func, void *ctx); int mdb_reader_check(MDB_env *env, int *dead); int mdb_dbi_flags(MDB_txn *txn, MDB_dbi dbi, unsigned int *flags); #define MDB_VERSION_MAJOR ... #define MDB_VERSION_MINOR ... #define MDB_VERSION_PATCH ... #define EACCES ... #define EAGAIN ... #define EINVAL ... #define ENOMEM ... #define ENOSPC ... #define MDB_BAD_RSLOT ... #define MDB_BAD_DBI ... #define MDB_BAD_TXN ... #define MDB_BAD_VALSIZE ... #define MDB_CORRUPTED ... #define MDB_CURSOR_FULL ... #define MDB_DBS_FULL ... #define MDB_INCOMPATIBLE ... #define MDB_INVALID ... #define MDB_KEYEXIST ... #define MDB_MAP_FULL ... #define MDB_MAP_RESIZED ... #define MDB_NOTFOUND ... #define MDB_PAGE_FULL ... #define MDB_PAGE_NOTFOUND ... #define MDB_PANIC ... #define MDB_READERS_FULL ... #define MDB_TLS_FULL ... #define MDB_TXN_FULL ... #define MDB_VERSION_MISMATCH ... #define MDB_APPEND ... #define MDB_APPENDDUP ... #define MDB_CP_COMPACT ... #define MDB_CREATE ... #define MDB_DUPFIXED ... #define MDB_DUPSORT ... #define MDB_INTEGERDUP ... #define MDB_INTEGERKEY ... #define MDB_MAPASYNC ... #define MDB_NODUPDATA ... #define MDB_NOLOCK ... #define MDB_NOMEMINIT ... #define MDB_NOMETASYNC ... #define MDB_NOOVERWRITE ... #define MDB_NORDAHEAD ... #define MDB_NOSUBDIR ... #define MDB_NOSYNC ... #define MDB_NOTLS ... #define MDB_RDONLY ... #define MDB_REVERSEKEY ... #define MDB_WRITEMAP ... // Helpers below inline MDB_vals. Avoids key alloc/dup on CPython, where // CFFI will use PyString_AS_STRING when passed as an argument. static int pymdb_del(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, char *val_s, size_t vallen); static int pymdb_put(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, char *val_s, size_t vallen, unsigned int flags); static int pymdb_get(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, MDB_val *val_out); static int pymdb_cursor_get(MDB_cursor *cursor, char *key_s, size_t key_len, char *data_s, size_t data_len, MDB_val *key, MDB_val *data, int op); static int pymdb_cursor_put(MDB_cursor *cursor, char *key_s, size_t keylen, char *val_s, size_t vallen, int flags); // Prefaults a range static void preload(int rc, void *x, size_t size); z int mdb_env_copy3(MDB_env *env, const char *path, unsigned int flags, MDB_txn *txn); int mdb_env_copyfd3(MDB_env *env, int fd, unsigned int flags, MDB_txn *txn); a #include #include "lmdb.h" #include "preload.h" // Helpers below inline MDB_vals. Avoids key alloc/dup on CPython, where // CFFI will use PyString_AS_STRING when passed as an argument. static int pymdb_get(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, MDB_val *val_out) { MDB_val key = {keylen, key_s}; int rc = mdb_get(txn, dbi, &key, val_out); return rc; } static int pymdb_put(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, char *val_s, size_t vallen, unsigned int flags) { MDB_val key = {keylen, key_s}; MDB_val val = {vallen, val_s}; return mdb_put(txn, dbi, &key, &val, flags); } static int pymdb_del(MDB_txn *txn, MDB_dbi dbi, char *key_s, size_t keylen, char *val_s, size_t vallen) { MDB_val key = {keylen, key_s}; MDB_val val = {vallen, val_s}; MDB_val *valptr; if(vallen == 0) { valptr = NULL; } else { valptr = &val; } return mdb_del(txn, dbi, &key, valptr); } static int pymdb_cursor_get(MDB_cursor *cursor, char *key_s, size_t key_len, char *data_s, size_t data_len, MDB_val *key, MDB_val *data, int op) { MDB_val tmp_key = {key_len, key_s}; MDB_val tmp_data = {data_len, data_s}; int rc = mdb_cursor_get(cursor, &tmp_key, &tmp_data, op); if(! rc) { *key = tmp_key; *data = tmp_data; } return rc; } static int pymdb_cursor_put(MDB_cursor *cursor, char *key_s, size_t keylen, char *val_s, size_t vallen, int flags) { MDB_val tmpkey = {keylen, key_s}; MDB_val tmpval = {vallen, val_s}; return mdb_cursor_put(cursor, &tmpkey, &tmpval, flags); } z-wz lib/mdb.cz lib/midl.clib)extra_compile_args extra_sourcesextra_include_dirsextra_library_dirs librariesz-DHAVE_PATCHED_LMDB=1r- lmdb_cffilmdbr.r/r1r0) modulename ext_packagesourcesr- include_dirsr1 library_dirszint(char *, void *)c[RR[R U5R 55 g)zJmdb_msg_func() callback. Appends `s` to _callbacks.msg_func list. r) _callbacksmsg_funcappend_ffistringdecode)s_s I/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/lmdb/cffi.py _msg_funcrC}s, ""4;;q>#8#8#:;c"\rSrSrSrSSjrSrg)rizfRaised when an LMDB-related error occurs, and no more specific :py:class:`lmdb.Error` subclass exists.cXlX l[R[R U55UlUnU(a1U<SUR <3n[USS5nU(a USU<S3- n[RX5 g)Nz: MDB_HINTz ()) whatcoder=r>_lib mdb_strerrorreasongetattr Exception__init__)selfrIrJmsghints rBrPError.__init__si  kk$"3"3D"9:  "DKK0C4T2D$((4%rD)rJrMrIN)r)__name__ __module__ __qualname____firstlineno____doc__rP__static_attributes__rDrBrrs / &rDrc\rSrSrSrSrSrg)rizKey/data pair already exists. MDB_KEYEXISTr[NrUrVrWrXrYMDB_NAMErZr[rDrBrrs 'HrDrc\rSrSrSrSrSrg)rizNo matching key/data pair found. Normally py-lmdb indicates a missing key by returning ``None``, or a user-supplied default value, however LMDB may return this error where py-lmdb does not know to convert it into a non-exceptional return. MDB_NOTFOUNDr[Nr^r[rDrBrrs HrDrc\rSrSrSrSrSrg)r izRequest page not found.MDB_PAGE_NOTFOUNDr[Nr^r[rDrBr r s !"HrDr c\rSrSrSrSrSrg)riz#Located page was of the wrong type. MDB_CORRUPTEDr[Nr^r[rDrBrrs -HrDrc\rSrSrSrSrSrg)r!izUpdate of meta page failed. MDB_PANICr[Nr^r[rDrBr!r!s %HrDr!c\rSrSrSrSrSrg)r&iz&Database environment version mismatch.MDB_VERSION_MISMATCHr[Nr^r[rDrBr&r&s 0%HrDr&c\rSrSrSrSrSrg)rizFile is not an MDB file. MDB_INVALIDr[Nr^r[rDrBrrs "HrDrc \rSrSrSrSrSrSrg)riz$Environment map_size= limit reached. MDB_MAP_FULLz4Please use a larger Environment(map_size=) parameterr[NrUrVrWrXrYr_rGrZr[rDrBrrs.HEHrDrc \rSrSrSrSrSrSrg)riz#Environment max_dbs= limit reached. MDB_DBS_FULLz3Please use a larger Environment(max_dbs=) parameterr[Nrnr[rDrBrrs-HDHrDrc \rSrSrSrSrSrSrg)r"iz'Environment max_readers= limit reached.MDB_READERS_FULLz7Please use a larger Environment(max_readers=) parameterr[Nrnr[rDrBr"r"s1!HHHrDr"c\rSrSrSrSrSrg)r$iz HrDrc\rSrSrSrSrSrg)riz3Operation and DB incompatible, or DB flags changed.MDB_INCOMPATIBLEr[Nr^r[rDrBrrs =!HrDrc\rSrSrSrSrSrg)riz'Invalid reuse of reader locktable slot. MDB_BAD_RSLOTr[Nr^r[rDrBrrs 1HrDrc\rSrSrSrSrSrg)r iz+The specified DBI was changed unexpectedly. MDB_BAD_DBIr[Nr^r[rDrBr r s 5HrDr c\rSrSrSrSrSrg)riz0Transaction cannot recover - it must be aborted. MDB_BAD_TXNr[Nr^r[rDrBrrs :HrDrc\rSrSrSrSrSrg)riz7Too big key/data, key is empty, or wrong DUPFIXED size.MDB_BAD_VALSIZEr[Nr^r[rDrBrrs A HrDrc\rSrSrSrSrSrg)r#iz3An attempt was made to modify a read-only database.EACCESr[Nr^r[rDrBr#r#s =HrDr#c\rSrSrSrSrSrg)riz#An invalid parameter was specified.EINVALr[Nr^r[rDrBrrs -HrDrc\rSrSrSrSrSrg)riz.The environment was locked by another process.EAGAINr[Nr^r[rDrBrrs 8HrDrc\rSrSrSrSrSrg)rizOut of memory.ENOMEMr[Nr^r[rDrBrrs HrDrc\rSrSrSrSrSrg)rizNo more disk space.ENOSPCr[Nr^r[rDrBrrs HrDrcB[RU[5"X5$)z~Lookup and instantiate the correct exception class for the error code `rc`, using :py:class:`Error` if no better class exists.) _error_mapgetr)rIrcs rB_errorrs >>"e $T ..rDc*\rSrSrSrSrSrSrSrg)-Some_LMDB_Resource_That_Was_Deleted_Or_Closedi a"We need this because CFFI on PyPy treats None as cffi.NULL, instead of throwing an exception it feeds LMDB null pointers. That means simply replacing native handles with None during _invalidate() will cause NULL pointer dereferences. Instead use this class, and its weird name to cause a TypeError, with a very obvious string in the exception text. The only alternatives to this are inserting a check around every single use of a native handle to ensure the handle is still valid prior to calling LMDB, or doing no crash-safety checking at all. cgNrr[rQs rB __nonzero__9Some_LMDB_Resource_That_Was_Deleted_Or_Closed.__nonzero__srDcg)NFr[rs rB__bool__6Some_LMDB_Resource_That_Was_Deleted_Or_Closed.__bool__srDcg)Nz>r[rs rB__repr__6Some_LMDB_Resource_That_Was_Deleted_Or_Closed.__repr__sOrDr[N) rUrVrWrXrYrrrrZr[rDrBrr s PrDrcV[RURUR5$)z0Convert a MDB_val cdata to a CFFI buffer object.r=buffermv_datamv_sizemvs rB_mvbufr"s ;;rzz2:: ..rDc\[RURUR5SS$)z(Convert a MDB_val cdata to Python bytes.Nrrs rB_mvstrr&s ;;rzz2:: .q 11rDcZ[RSURUR5 gr)rKpreloadrrrs rBrr*sLLBJJ +rDcg)z Deprecated.Nr[r[rDrBr r -srDcU(a>[R[R[R[(aS4$S4$[R[R[R4$)a Return a tuple of integers `(major, minor, patch)` describing the LMDB library version that the binding is linked against. The version of the binding itself is available from ``lmdb.__version__``. `subpatch`: If true, returns a 4 integer tuple consisting of the same plus an extra integer that represents any patches applied by py-lmdb itself (0 representing no patches). r)rKMDB_VERSION_MAJORMDB_VERSION_MINORMDB_VERSION_PATCH_have_patched_lmdb)subpatchs rBr r 0sj&&&&&&''0 0./0 0  " "  " "  " " $$rDc\rSrSrSrSSSSSS\SSSSSSSS4S jrS rS rS r S r S r S r S r SrSrSrSSjrSSjrS SjrSrSrSrSrSrSrSrSrS!SjrS"SjrSrg )#riGa  Structure for a database environment. An environment may contain multiple databases, all residing in the same shared-memory map and underlying disk file. To write to the environment a :py:class:`Transaction` must be created. One simultaneous write transaction is allowed, however there is no limit on the number of read transactions even when a write transaction exists. This class is aliased to `lmdb.open`. It is a serious error to have open the same LMDB file in the same process at the same time. Failure to heed this may lead to data corruption and interpreter crash. Equivalent to `mdb_env_open() `_ `path`: Location of directory (if `subdir=True`) or file prefix to store the database. `map_size`: Maximum size database may grow to; used to size the memory mapping. If database grows larger than ``map_size``, an exception will be raised and the user must close and reopen :py:class:`Environment`. On 64-bit there is no penalty for making this huge (say 1TB). Must be <2GB on 32-bit. .. note:: **The default map size is set low to encourage a crash**, so users can figure out a good value before learning about this option too late. `subdir`: If ``True``, `path` refers to a subdirectory to store the data and lock files in, otherwise it refers to a filename prefix. `readonly`: If ``True``, disallow any write operations. Note the lock file is still modified. If specified, the ``write`` flag to :py:meth:`begin` or :py:class:`Transaction` is ignored. `metasync`: If ``False``, flush system buffers to disk only once per transaction, omit the metadata flush. Defer that until the system flushes files to disk, or next commit or :py:meth:`sync`. This optimization maintains database integrity, but a system crash may undo the last committed transaction. I.e. it preserves the ACI (atomicity, consistency, isolation) but not D (durability) database property. `sync`: If ``False``, don't flush system buffers to disk when committing a transaction. This optimization means a system crash can corrupt the database or lose the last transactions if buffers are not yet flushed to disk. The risk is governed by how often the system flushes dirty buffers to disk and how often :py:meth:`sync` is called. However, if the filesystem preserves write order and `writemap=False`, transactions exhibit ACI (atomicity, consistency, isolation) properties and only lose D (durability). I.e. database integrity is maintained, but a system crash may undo the final transactions. Note that `sync=False, writemap=True` leaves the system with no hint for when to write transactions to disk, unless :py:meth:`sync` is called. `map_async=True, writemap=True` may be preferable. `mode`: File creation mode. `create`: If ``False``, do not create the directory `path` if it is missing. `readahead`: If ``False``, LMDB will disable the OS filesystem readahead mechanism, which may improve random read performance when a database is larger than RAM. `writemap`: If ``True``, use a writeable memory map unless `readonly=True`. This is faster and uses fewer mallocs, but loses protection from application bugs like wild pointer writes and other bad updates into the database. Incompatible with nested transactions. Processes with and without `writemap` on the same environment do not cooperate well. `meminit`: If ``False`` LMDB will not zero-initialize buffers prior to writing them to disk. This improves performance but may cause old heap data to be written saved in the unused portion of the buffer. Do not use this option if your application manipulates confidential data (e.g. plaintext passwords) in memory. This option is only meaningful when `writemap=False`; new pages are always zero-initialized when `writemap=True`. `map_async`: When ``writemap=True``, use asynchronous flushes to disk. As with ``sync=False``, a system crash can then corrupt the database or lose the last transactions. Calling :py:meth:`sync` ensures on-disk database integrity until next commit. `max_readers`: Maximum number of simultaneous read transactions. Can only be set by the first process to open an environment, as it affects the size of the lock file and shared memory area. Attempts to simultaneously start more than this many *read* transactions will fail. `max_dbs`: Maximum number of databases available. If 0, assume environment will be used as a single database. `max_spare_txns`: Read-only transactions to cache after becoming unused. Caching transactions avoids two allocations, one lock and linear scan of the shared environment per invocation of :py:meth:`begin`, :py:class:`Transaction`, :py:meth:`get`, :py:meth:`gets`, or :py:meth:`cursor`. Should match the process's maximum expected concurrent transactions (e.g. thread count). `lock`: If ``False``, don't do any locking. If concurrent access is anticipated, the caller must manage all concurrency itself. For proper operation the caller must enforce single-writer semantics, and must ensure that no readers are using old transactions while a writer is active. The simplest approach is to use an exclusive lock so that no readers may be active at all when a writer begins. iTF~rrc ,Xl/Ul[RS5n[R U5nU(a [ SU5eUSUl[5Ul SUl URU5 [RURU 5nU(a [ SU5e[RURU5nU(a [ SU5eU (a%U(aU(d[R"X5 [R&nU(dU[R(-nU(aU[R*-nX@lU(dU[R.-nU(dU[R0-nU(aU[R2-nU (dU[R4-nU (aU[R6-nU (dU[R8-nU(dU[R:-n[=U[>5(a$URA[BRD"55n[RGURUUU[H)-5nU(a [ UU5eURK[M5S9n[OUUSSSSSSSS 9 Ul(SSS5 SURP0Ul)g![ a*nUR"["R$:waeSnAGNSnAff=f!,(df  NY=f) Nz MDB_env **mdb_env_createrFmdb_env_set_maxreadersmdb_env_set_maxdbs)dbT) envtxnname reverse_keydupsortcreate integerkey integerdupdupfixed)*_max_spare_txns _spare_txnsr=newrKrr_envset_deps_creating_db_in_readonly set_mapsizerrosmkdirEnvironmentErrorerrnoEEXIST MDB_NOTLS MDB_NOSUBDIR MDB_RDONLYreadonlyMDB_NOMETASYNC MDB_NOSYNC MDB_MAPASYNC MDB_NORDAHEAD MDB_WRITEMAP MDB_NOMEMINIT MDB_NOLOCK isinstance UnicodeTypeencodesysgetfilesystemencoding mdb_env_openO_0111beginobjectr _db_dbs)rQpathmap_sizesubdirrmetasyncsync map_asyncmoder readaheadwritemapmeminit max_readersmax_dbsmax_spare_txnslockenvppreflagsrs rBrPEnvironment.__init__s_ .&   ' )2. .!H U (-% "  ( (K @ 126 6  $ $TYY 8 -r2 2 fX $  T&& &E  T__ $E  T(( (E T__ $E  T&& &E T'' 'E  T&& &E T'' 'E T__ $E dK ( (;;s88:;D   tyy$tvg~ F r" " ZZ68Z $ !   DH%488$ [$ 77ell*+ @% $s$8KL LK==L LcU$Nr[rs rB __enter__Environment.__enter__ rDc$UR5 grcloserQ_1_2_3s rB__exit__Environment.__exit__  rDc$UR5 grrrs rB__del__Environment.__del__r rDNcj[RURU5nU(a [SU5eg)aChange the maximum size of the map file. This function will fail if any transactions are active in the current process. `map_size`: The new size in bytes. Equivalent to `mdb_env_set_mapsize() `_ Warning: There's a data race in the underlying library that may cause catastrophic loss of data if you use this method. You are safe if one of the following are true: * Only one process accessing a particular LMDB file ever calls this method. * You use locking external to this library to ensure that only one process accessing the current LMDB file can be inside this function. mdb_env_set_mapsizeN)rKrrr)rQrrs rBrEnvironment.set_mapsize's0* % %dii : .3 3 rDcUR(Ga1UR(aLUR(a;URR5R5 UR(aM;SUlUR(aQUR(a@[ R URR55 UR(aM@SUlUR(aURR5 SUlSUl [ RUR5 [Ulgg)zClose the environment, invalidating any open iterators, cursors, and transactions. Repeat calls to :py:meth:`close` have no effect. Equivalent to `mdb_env_close() `_ N) rrpop _invalidaterrK mdb_txn_abortrclearr mdb_env_close_invalidrs rBrEnvironment.close@s 999zzjjJJNN$002jjjDJ&&&&t'7'7';';'=>&&&#D yy !DIDH   tyy ) DI# rDc[RS5n[RURU5nU(a [ SU5e[R US5R[R"55$)zDirectory path or file name prefix where this environment is stored. Equivalent to `mdb_env_get_path() `_ zchar **mdb_env_get_pathr) r=rrKrrrr>r?rr)rQrrs rBrEnvironment.pathZs`xx "  " "499d 3 +R0 0{{47#**3+D+D+FGGrDcU(a[ROSnU(a[(d [S5eU(aU(d [S5eUR [ R "55n[(aV[RURXTU(a URO[R5nU(a [SU5eg[RURXT5nU(a [SU5eg)aMake a consistent copy of the environment in the given destination directory. `compact`: If ``True``, perform compaction while copying: omit free pages and sequentially renumber all pages in output. This option consumes more CPU and runs more slowly than the default, but may produce a smaller output database. `txn`: If provided, the backup will be taken from the database with respect to that transaction, otherwise a temporary read-only transaction will be created. Note: this parameter being non-None is not available if the module was built with LMDB_PURE. Note: this parameter may be set only if compact=True. Equivalent to `mdb_env_copy2() or mdb_env_copy3() `_ r:Non-patched LMDB doesn't support transaction with env.copy.txn argument only compatible with compact=True mdb_env_copy3 mdb_env_copy2N)rKMDB_CP_COMPACTr TypeErrorrrrrr_txnr=NULLrr )rQrcompactrrencodedrs rBcopyEnvironment.copygs((/##A ))XY Y uLM M++c779:  ##DIIw3sxxTXT]T]^B_b11##DIIw>B_b11rDc U(a[(d [S5e[(a[R"U5nU(a[ R OSnU(aU(d [S5e[(aV[ RURXU(a URO[R5nU(a [SU5eg[ RURX5nU(a [SU5eg)aCopy a consistent version of the environment to file descriptor `fd`. `compact`: If ``True``, perform compaction while copying: omit free pages and sequentially renumber all pages in output. This option consumes more CPU and runs more slowly than the default, but may produce a smaller output database. `txn`: If provided, the backup will be taken from the database with respect to that transaction, otherwise a temporary read-only transaction will be created. Note: this parameter being non-None is not available if the module was built with LMDB_PURE. Equivalent to `mdb_env_copyfd2() or mdb_env_copyfd3 `_ rrrmdb_env_copyfd3mdb_env_copyfd2N)rr"is_win32msvcrt get_osfhandlerKr!r*rr#r=r$rr+)rQfdr%rrrs rBcopyfdEnvironment.copyfds& ))XY Y 8%%b)B'.##A uLM M  %%diiCHHQUQZQZ[B.33%%dii;B.33rDcj[RURU5nU(a [SU5eg)aRFlush the data buffers to disk. Equivalent to `mdb_env_sync() `_ Data is always written to disk when :py:meth:`Transaction.commit` is called, but the operating system may keep it buffered. MDB always flushes the OS buffers upon commit as well, unless the environment was opened with `sync=False` or `metasync=False`. `force`: If ``True``, force a synchronous flush. Otherwise if the environment was opened with `sync=False` the flushes will be omitted, and with `map_async=True` they will be asynchronous. mdb_env_syncN)rKr3rr)rQforcers rBrEnvironment.syncs/   tyy% 0 , , rDcURURURURURUR S.$)z&Convert a MDB_stat to a dict. )psizedepth branch_pages leaf_pagesoverflow_pagesentries)ms_psizems_depthms_branch_pages ms_leaf_pagesms_overflow_pages ms_entries)rQsts rB _convert_statEnvironment._convert_stats>[[[[..** 22}}   rDc[RS5n[RURU5nU(a [ SU5eUR U5$)astat() Return some environment statistics for the default database as a dict: +--------------------+---------------------------------------+ | ``psize`` | Size of a database page in bytes. | +--------------------+---------------------------------------+ | ``depth`` | Height of the B-tree. | +--------------------+---------------------------------------+ | ``branch_pages`` | Number of internal (non-leaf) pages. | +--------------------+---------------------------------------+ | ``leaf_pages`` | Number of leaf pages. | +--------------------+---------------------------------------+ | ``overflow_pages`` | Number of overflow pages. | +--------------------+---------------------------------------+ | ``entries`` | Number of data items. | +--------------------+---------------------------------------+ Equivalent to `mdb_env_stat() `_ MDB_stat * mdb_env_stat)r=rrKrHrrrD)rQrCrs rBstatEnvironment.statsI,XXl #   tyy" - , ,!!"%%rDcV[RS5n[RURU5nU(a [ SU5e[ [RSUR55URURURURURS.$)azReturn some nice environment information as a dict: +--------------------+---------------------------------------------+ | ``map_addr`` | Address of database map in RAM. | +--------------------+---------------------------------------------+ | ``map_size`` | Size of database map in RAM. | +--------------------+---------------------------------------------+ | ``last_pgno`` | ID of last used page. | +--------------------+---------------------------------------------+ | ``last_txnid`` | ID of last committed transaction. | +--------------------+---------------------------------------------+ | ``max_readers`` | Number of reader slots allocated in the | | | lock file. Equivalent to the value of | | | `maxreaders=` specified by the first | | | process opening the Environment. | +--------------------+---------------------------------------------+ | ``num_readers`` | Maximum number of reader slots in | | | simultaneous use since the lock file was | | | initialized. | +--------------------+---------------------------------------------+ Equivalent to `mdb_env_info() `_ z MDB_envinfo * mdb_env_infolong)map_addrr last_pgno last_txnidr num_readers)r=rrKrLrrintcast me_mapaddr me_mapsize me_last_pgno me_last_txnid me_maxreaders me_numreaders)rQinfors rBrZEnvironment.infos2xx(   tyy$ / , ,DIIfdoo>?**,,----   rDc Z[RSS5n[RURU5nU(a [ SU5eUSnU[R -(+[U[R-5U[R-(+U[R-(+[U[R-5U[R-(+[U[R-5U[R-(+U[R-(+S. $)z\Return a dict describing Environment constructor flags used to instantiate this environment.unsigned int[]rmdb_env_get_flagsr) rrrrrrrrr)r=rrKr^rrrboolrrrrrrrr)rQflags_rrs rBrEnvironment.flagss*A.  # #DIIv 6 ,b1 1q  4#4#445UT__45"T%8%88901ed&7&778#d&8&889UT%6%667!D$6$66701  rDc@[RUR5$)zzReturn the maximum size in bytes of a record's key part. This matches the ``MDB_MAXKEYSIZE`` constant set at compile time.)rKmdb_env_get_maxkeysizerrs rB max_key_sizeEnvironment.max_key_size(s**49955rDc[RSS5n[RURU5nU(a [ SU5eUS$)zReturn the maximum number of readers specified during open of the environment by the first process. This is the same as `max_readers=` specified to the constructor if this process was the first to open the environment.r]rmdb_env_get_maxreadersr)r=rrKrgrr)rQreaders_rs rBrEnvironment.max_readers-sF 88,a0  ( (H = 126 6{rDc/[l[RUR[ [ R5nU(a [SU5e[5R[R5[?$![?f=f)zYReturn a multi line Unicode string describing the current state of the reader lock table.mdb_reader_list) r:r;rKrkrrCr=r$rrjoinrQrs rBreadersEnvironment.readers8sa!  $%%diiDIIFB.33=%%j&9&9:# #s A,BBc[RSS5n[RURU5nU(a [ SU5eUS$)zSearch the reader lock table for stale entries, for example due to a crashed process. Returns the number of stale entries that were cleared. zint[]rmdb_reader_checkr)r=rrKrqrr)rQreapedrs rB reader_checkEnvironment.reader_checkDsE'1%  " "499f 5 +R0 0ayrDc "[U[5(a [S5eUc.U(dU(dU(dU(dU(a [S5eURR U5n U (aU $U(aSnU(aSnU(a[ XXXEXgU5 n OESUlURUR(+S9n[ XXXEXgU5 n SSS5 SUlXRU'U $!,(df  N%=f!SUlf=f)a Open a database, returning an instance of :py:class:`_Database`. Repeat :py:meth:`Environment.open_db` calls for the same name will return the same handle. As a special case, the main database is always open. Equivalent to `mdb_dbi_open() `_ Named databases are implemented by *storing a special descriptor in the main database*. All databases in an environment *share the same file*. Because the descriptor is present in the main database, attempts to create a named database will fail if a key matching the database's name already exists. Furthermore *the key is visible to lookups and enumerations*. If your main database keyspace conflicts with the names you use for named databases, then move the contents of your main database to another named database. :: >>> env = lmdb.open('/tmp/test', max_dbs=2) >>> with env.begin(write=True) as txn: ... txn.put('somename', 'somedata') >>> # Error: database cannot share name of existing key! >>> subdb = env.open_db('somename') A newly created database will not exist if the transaction that created it aborted, nor if another process deleted it. The handle resides in the shared environment, it is not owned by the current transaction or process. Only one thread should call this function; it is not mutex-protected in a read-only transaction. The `dupsort`, `integerkey`, `integerdup`, and `dupfixed` parameters are ignored if the database already exists. The state of those settings are persistent and immutable per database. See :py:meth:`_Database.flags` to view the state of those options for an opened database. A consequence of the immutability of these flags is that the default non-named database will never have these flags set. Preexisting transactions, other than the current transaction and any parents, must not use the new handle, nor must their children. `key`: Bytestring database name. If ``None``, indicates the main database should be returned, otherwise indicates a named database should be created inside the main database. In other words, *a key representing the database will be visible in the main database, and the database name cannot conflict with any existing key.* `txn`: Transaction used to create the database if it does not exist. If unspecified, a temporarily write transaction is used. Do not call :py:meth:`open_db` from inside an existing transaction without supplying it here. Note the passed transaction must have `write=True`. `reverse_key`: If ``True``, keys are compared from right to left (e.g. DNS names). `dupsort`: Duplicate keys may be used in the database. (Or, from another perspective, keys may have multiple data items, stored in sorted order.) By default keys must be unique and may have only a single data item. `create`: If ``True``, create the database if it doesn't exist, otherwise raise an exception. `integerkey`: If ``True``, indicates keys in the database are C unsigned or ``size_t`` integers encoded in native byte order. Keys must all be either unsigned or ``size_t``, they cannot be mixed in a single database. `integerdup`: If ``True``, values in the database are C unsigned or ``size_t`` integers encoded in native byte order. Implies `dupsort` and `dupfixed` are ``True``. `dupfixed`: If ``True``, values for each key in database are of fixed size, allowing each additional duplicate value for a key to be stored without a header indicating its size. Implies `dupsort` is ``True``. zkey must be bytesNz&May not set flags on the main databaseT)writeF) rrr" ValueErrorrrr rrr) rQkeyrrrrrrrrs rBopen_dbEnvironment.open_dbNsz c; ' '/0 0 ;K7jJ'EF F YY]]3  I H G 4c%8=B 604-ZZ$--&7Z8C"4c#-8EB916- # 9816-s$ %DC4D4 D>D Dc[XX#U5$)z)Shortcut for :py:class:`lmdb.Transaction`)r )rQrparentrvbufferss rBrEnvironment.begins4VG<`_ `env`: Environment the transaction should be on. `db`: Default named database to operate on. If unspecified, defaults to the environment's main database. Can be overridden on a per-call basis below. `parent`: ``None``, or a parent transaction (see lmdb.h). `write`: Transactions are read-only by default. To modify the database, you must pass `write=True`. This flag is ignored if :py:class:`Environment` was opened with ``readonly=True``. `buffers`: If ``True``, indicates :py:func:`buffer` objects should be yielded instead of bytestrings. This setting applies to the :py:class:`Transaction` instance itself and any :py:class:`Cursors ` created within the transaction. This feature significantly improves performance, since MDB has a zero-copy design, but it requires care when manipulating the returned buffer objects. The benefit of this facility is diminished when using small keys and values. NFrcURRU5 XlU=(d URUlURUl[ R S5Ul[ R S5UlU(a[O[Ul [5UlU(a.X0l URnURRU5 O[ RnU(aUR (aSn[#U[$R&5e[ R S5n[$R)URUSU5n U (a [#SU 5eUSUlSUlgUR,(a[.eUR0R35UlU=R4S- sl[$R7UR5n U (aUR(a;URR35R95 UR(aM;[$R;UR5 [<UlUR95 [#SU 5eg![.af [ R S5n[$R>n [$R)URXjU5n U (a [#SU 5eUSUlgf=f) N MDB_val *z1Cannot start write transaction with read-only envz MDB_txn **r mdb_txn_beginTr mdb_txn_renew) rrrrrr=r_key_valrr_to_pyr_parentr#r$rrrKrr_writer IndexErrorrrrrrrrr) rQrrr|rvr} parent_txnrRtxnpprrs rBrPTransaction.__init__Is d=HH HH[) HH[) 'fV U !LJ LL  T "J ||IS$++..HH\*E##DIIz1eDB_b11aDIDK %//$$OO//1 ##q(#'' 2** (446***&&tyy1 (DI$$& "55  %.'' :eL "55!!H  %s>B;J;AJA-K21K2cUR(aUR5 URRR U5 SUl[ Ulgr)r#abortrrdiscardrrrrs rBrTransaction._invalidate{s6 99 JJL t$  rDc$UR5 gr)rrs rBr Transaction.__del__r rDcU$rr[rs rBrTransaction.__enter__rrDcTU(aUR5 gUR5 gr)rcommit)rQexc_type exc_value tracebacks rBrTransaction.__exit__s  JJL KKMrDc@[RUR5$)zid() Return the transaction's ID. This returns the identifier associated with this transaction. For a read-only transaction, this corresponds to the snapshot being read; concurrent readers will frequently have the same transaction ID. )rK mdb_txn_idr#rs rBidTransaction.idstyy))rDc[RS5n[RURUR U5nU(a [ SU5eURRU5$)zstat(db) Return statistics like :py:meth:`Environment.stat`, except for a single DBI. `db` must be a database handle returned by :py:meth:`open_db`. rGmdb_stat) r=rrKrr#rrrrD)rQrrCrs rBrITransaction.statsQ XXl # ]]499bggr 2 R( (xx%%b))rDcUR(a;URR5R5 UR(aM;[R UR UR U5nU=RS- slU(a [SU5eURURR;a"URRUR gg)aDelete all keys in a named database and optionally delete the named database itself. Deleting the named database causes it to become unavailable, and invalidates existing cursors. Equivalent to `mdb_drop() `_ rmdb_dropN) rrrrKrr#r _mutationsrrrr)rQrdeleters rBdropTransaction.dropshh HHLLN & & (hhh ]]499bggv 6 1 R( ( 88txx}} $ bhh' %rDcJURRS:a[RUR5 URR R UR5 UR=RS-sl[UlUR5 gg)NrrTF) rrrK mdb_txn_resetr#rr<rrrs rB _cache_spareTransaction._cache_sparesr 88 # #a '   tyy ) HH ' ' 2 HH $ $ ) $ DI    rDcUR(a;URR5R5 UR(aM;UR(dUR 5(dN[ R UR5n[UlU(a [SU5eUR5 gg)zCommit the pending transaction. Equivalent to `mdb_txn_commit() `_ mdb_txn_commitN) rrrrrrKrr#rrrms rBrTransaction.commits jj JJNN  ( ( *jjj ;;d//11$$TYY/B DI-r22     2rDcUR(aUR(a;URR5R5 UR(aM;UR(dUR 5(d=[ RUR5n[UlU(a [SU5eUR5 gg)aAAbort the pending transaction. Repeat calls to :py:meth:`abort` have no effect after a previously successful :py:meth:`commit` or :py:meth:`abort`, or after the associated :py:class:`Environment` has been closed. Equivalent to `mdb_txn_abort() `_ rN) r#rrrrrrKrrrrms rBrTransaction.aborts 99**  ,,.***{{$"3"3"5"5'' 2$  "55     rDcZ[RURU=(d URRU[ U5UR 5nU(a"U[R:XaU$[SU5e[UR 5 URUR 5$)a Fetch the first value matching `key`, returning `default` if `key` does not exist. A cursor must be used to fetch all values for a key in a `dupsort=True` database. Equivalent to `mdb_get() `_ mdb_cursor_get) rK pymdb_getr#rrrrrarrr)rQrxdefaultrrs rBrTransaction.getsz^^DIIdhh'<'<S4996 T&&&)2. . {{499%%rDc SnU(dU[R-nU(dU[R-nU(aU[R-n[R UR U=(d UR RU[U5U[U5U5nU=RS- sl U(a!U[R:Xag[SU5eg)aStore a record, returning ``True`` if it was written, or ``False`` to indicate the key was already present and `overwrite=False`. On success, the cursor is positioned on the new record. Equivalent to `mdb_put() `_ `key`: Bytestring key to store. `value`: Bytestring value to store. `dupdata`: If ``False`` and database was opened with `dupsort=True`, will return ``False`` if the key already has that value. In other words, this only affects the return value. `overwrite`: If ``False``, do not overwrite any existing matching key. If False and writing to a dupsort=True database, this will not add a value to the key and this function will return ``False``. `append`: If ``True``, append the pair to the end of the database without comparing its order first. Appending a key that is not greater than the highest existing key will fail and return ``False``. `db`: Named database to operate on. If unspecified, defaults to the database given to the :py:class:`Transaction` constructor. rrFmdb_putT) rK MDB_NODUPDATAMDB_NOOVERWRITE MDB_APPEND pymdb_putr#rrrrr]r) rQrxvaluedupdata overwriter<rrrs rBputTransaction.putsD T'' 'E T)) )E  T__ $E ^^DIIdhh'<'<S5#e*eE 1 T&&&B' 'rDc[U=(d URU5nURX5sSSS5 $!,(df  g=f)zUse a temporary cursor to invoke :py:meth:`Cursor.replace`. `db`: Named database to operate on. If unspecified, defaults to the database given to the :py:class:`Transaction` constructor. N)rrreplace)rQrxrrcurss rBrTransaction.replace-s0BN$((D )T<<+* ) ) ; A c[U=(d URU5nURU5sSSS5 $!,(df  g=f)zUse a temporary cursor to invoke :py:meth:`Cursor.pop`. `db`: Named database to operate on. If unspecified, defaults to the database given to the :py:class:`Transaction` constructor. N)rrr)rQrxrrs rBrTransaction.pop7s/BN$((D )T88C=* ) )rc 6Uc[n[RURU=(d URR U[ U5U[ U55nU=RS- slU(a!U[R:Xag[SU5eg)aDelete a key from the database. Equivalent to `mdb_del() `_ `key`: The key to delete. value: If the database was opened with dupsort=True and value is not the empty bytestring, then delete elements matching only this `(key, value)` pair, otherwise all values for key are deleted. Returns True if at least one key was deleted. rFmdb_delT) EMPTY_BYTESrK pymdb_delr#rrrrrar)rQrxrrrs rBrTransaction.deleteAsu =E ^^DIIdhh'<'<S5#e*> 1 T&&&B' 'rDc@[U=(d URU5$)z&Shortcut for ``lmdb.Cursor(db, self)``)rr)rQrs rBcursorTransaction.cursor]sbnDHHd++rD) rrrrrrr#rrrr)T)NN)TTFNr)rUrVrWrXrYrrr#rrrrPrr rrrrIrrrrrrrrrrrrZr[rDrBr r s.d D DG FJ0%d * *(" &&$DI1f,!!,8,rDr c>\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS.S jr\rS/SjrS0SjrS.SjrS/SjrS0SjrSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"S r#S1S"jr$S2S#jr%S$r&S%r'S3S&jr(S'r)S4S(jr*S4S)jr+S*r,S+r-S,r.S-r/g!)5riba Structure for navigating a database. Equivalent to `mdb_cursor_open() `_ `db`: :py:class:`_Database` to navigate. `txn`: :py:class:`Transaction` to navigate. As a convenience, :py:meth:`Transaction.cursor` can be used to quickly return a cursor: :: >>> env = lmdb.open('/tmp/foo') >>> child_db = env.open_db('child_db') >>> with env.begin() as txn: ... cursor = txn.cursor() # Cursor on main database. ... cursor2 = txn.cursor(child_db) # Cursor on child database. Cursors start in an unpositioned state. If :py:meth:`iternext` or :py:meth:`iterprev` are used in this state, iteration proceeds from the start or end respectively. Iterators directly position using the cursor, meaning strange behavior results when multiple iterators exist on the same cursor. .. note:: From the perspective of the Python binding, cursors return to an 'unpositioned' state once any scanning or seeking method (e.g. :py:meth:`next`, :py:meth:`prev_nodup`, :py:meth:`set_range`) returns ``False`` or raises an exception. This is primarily to ensure safe, consistent semantics in the face of any error condition. When the Cursor returns to an unpositioned state, its :py:meth:`key` and :py:meth:`value` return empty strings to indicate there is no active position, although internally the LMDB cursor may still have a valid position. This may lead to slightly surprising behaviour when iterating the values for a `dupsort=True` database's keys, since methods such as :py:meth:`iternext_dup` will cause Cursor to appear unpositioned, despite it returning ``False`` only to indicate there are no more values for the current key. In that case, simply calling :py:meth:`next` would cause iteration to resume at the next available key. This behaviour may change in future. Iterator methods such as :py:meth:`iternext` and :py:meth:`iterprev` accept `keys` and `values` arguments. If both are ``True``, then the value of :py:meth:`item` is yielded on each iteration. If only `keys` is ``True``, :py:meth:`key` is yielded, otherwise only :py:meth:`value` is yielded. Prior to iteration, a cursor can be positioned anywhere in the database: :: >>> with env.begin() as txn: ... cursor = txn.cursor() ... if not cursor.set_range('5'): # Position at first key >= '5'. ... print('Not found!') ... else: ... for key, value in cursor: # Iterate from first key >= '5'. ... print((key, value)) Iteration is not required to navigate, and sometimes results in ugly or inefficient code. In cases where the iteration order is not obvious, or is related to the data being read, use of :py:meth:`set_key`, :py:meth:`set_range`, :py:meth:`key`, :py:meth:`value`, and :py:meth:`item` may be preferable: :: >>> # Record the path from a child to the root of a tree. >>> path = ['child14123'] >>> while path[-1] != 'root': ... assert cursor.set_key(path[-1]), \ ... 'Tree is broken! Path: %s' % (path,) ... path.append(cursor.value()) cNURRU5 URRU5 XlX lURUlUR Ul[ RS5Ul[ RS5Ul SUl URUl [ RS5nSUl [RUR URU5nU(a [SU5eUSUl UR Ulg)NrFz MDB_cursor **mdb_cursor_openr)rrrrrr#r=rrr_validr_currKrrr_last_mutation)rQrrcurpprs rBrPCursor.__init__s  T dGG HH HH[) HH[)  jj )  ! !$))TYY > *B/ /!H "nnrDc<UR(a[RUR5 URRR U5 UR RR U5 [Ul[Ul[Ul ggr) rrKmdb_cursor_closerrrrrrr#rs rBrCursor._invalidatesa 99  ! !$)) , GGMM ! !$ ' HHNN " "4 ( DI DI DI rDc$UR5 grrrs rBr Cursor.__del__ rDc$UR5 g)z3Close the cursor, freeing its associated resources.Nrrs rBr Cursor.closes rDcU$rr[rs rBrCursor.__enter__rrDc$UR5 grrrs rBrCursor.__exit__rrDcURURR:waUR[R 5 UR UR5$)zReturn the current key.)rrr _cursor_getrKMDB_GET_CURRENTrrrs rBrx Cursor.keysC   $(("5"5 5   T11 2{{499%%rDcURURR:waUR[R 5 [ UR5 URUR5$)zReturn the current value.) rrrrrKrrrrrs rBr Cursor.valuesO   $(("5"5 5   T11 2 {{499%%rDcURURR:waUR[R 5 [ UR5 URUR5URUR54$)z'Return the current `(key, value)` pair.) rrrrrKrrrrrrs rBitem Cursor.itemsa   $(("5"5 5   T11 2 {{499%t{{499'===rDc## U(d URnO U(d URnO URnURnURnUR nSnUR (a>U"5v [RXVXq5nU(+UlUR (aM>U(aCSURl SUR l U[R:wa [SU5egg7fNrr) rxrrrrrrrKrrrar) rQopkeysvaluesrcurrxvalrs rB_iter Cursor._iters((C**C))Ciiiiii kk%K$$Ss7B &DKkkk  !DII  !DII T&&&-r22' s B(C7,A C7cUR(dUR5 UR[RX5$)aReturn a forward iterator that yields the current element before calling :py:meth:`next`, repeating until the end of the database is reached. As a convenience, :py:class:`Cursor` implements the iterator protocol by automatically returning a forward iterator when invoked: :: >>> # Equivalent: >>> it = iter(cursor) >>> it = cursor.iternext(keys=True, values=True) If the cursor is not yet positioned, it is moved to the first key in the database, otherwise iteration proceeds from the current position. )rfirstrrKMDB_NEXTrQr rs rBiternextCursor.iternexts){{ JJLzz$--66rDcBUR[RX5$)aReturn a forward iterator that yields the current value ("duplicate") of the current key before calling :py:meth:`next_dup`, repeating until the last value of the current key is reached. Only meaningful for databases opened with `dupsort=True`. .. code-block:: python if not cursor.set_key("foo"): print("No values found for 'foo'") else: for idx, data in enumerate(cursor.iternext_dup()): print("%d'th value for 'foo': %s" % (idx, data)) )rrK MDB_NEXT_DUPrs rB iternext_dupCursor.iternext_dup%szz$++T::rDcUR(dUR5 UR[RX5$)aReturn a forward iterator that yields the current value ("duplicate") of the current key before calling :py:meth:`next_nodup`, repeating until the end of the database is reached. Only meaningful for databases opened with `dupsort=True`. If the cursor is not yet positioned, it is moved to the first key in the database, otherwise iteration proceeds from the current position. .. code-block:: python for key in cursor.iternext_nodup(): print("Key '%s' has %d values" % (key, cursor.count())) )rrrrKMDB_NEXT_NODUPrs rBiternext_nodupCursor.iternext_nodup6s+{{ JJLzz$--t<>> with env.begin() as txn: ... for i, (key, value) in enumerate(txn.cursor().iterprev()): ... print('%dth last item is (%r, %r)' % (1+i, key, value)) )rlastrrKMDB_PREVrs rBiterprevCursor.iterprevIs){{ IIKzz$--66rDcBUR[RX5$)zReturn a reverse iterator that yields the current value ("duplicate") of the current key before calling :py:meth:`prev_dup`, repeating until the first value of the current key is reached. Only meaningful for databases opened with `dupsort=True`. )rrK MDB_PREV_DUPrs rB iterprev_dupCursor.iterprev_dupZszz$++T::rDcUR(dUR5 UR[RX5$)a{Return a reverse iterator that yields the current value ("duplicate") of the current key before calling :py:meth:`prev_nodup`, repeating until the start of the database is reached. If the cursor is not yet positioned, it is moved to the last key in the database, otherwise iteration proceeds from the current position. Only meaningful for databases opened with `dupsort=True`. )rr"rrKMDB_PREV_NODUPrs rBiterprev_nodupCursor.iterprev_nodupcs+{{ IIKzz$--t<`_ with `MDB_FIRST `_ )rrK MDB_FIRSTrs rBr Cursor.firsts//rDc@UR[R5$)aMove to the first value ("duplicate") for the current key, returning ``True`` on success or ``False`` if the database is empty. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_FIRST_DUP `_ )rrK MDB_FIRST_DUPrs rB first_dupCursor.first_dups 2 233rDc@UR[R5$)aMove to the last key in the database, returning ``True`` on success or ``False`` if the database is empty. If the database was opened with `dupsort=True` and the key contains duplicates, the cursor is positioned on the last value ("duplicate"). Equivalent to `mdb_cursor_get() `_ with `MDB_LAST `_ )rrKMDB_LASTrs rBr" Cursor.lasts ..rDc@UR[R5$)aMove to the last value ("duplicate") for the current key, returning ``True`` on success or ``False`` if the database is empty. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_LAST_DUP `_ )rrK MDB_LAST_DUPrs rBlast_dupCursor.last_dup 1 122rDc@UR[R5$)aMove to the previous element, returning ``True`` on success or ``False`` if there is no previous item. For databases opened with `dupsort=True`, moves to the previous data item ("duplicate") for the current key if one exists, otherwise moves to the previous key. Equivalent to `mdb_cursor_get() `_ with `MDB_PREV `_ )rrKr#rs rBprev Cursor.prev ..rDc@UR[R5$)aMove to the previous value ("duplicate") of the current key, returning ``True`` on success or ``False`` if there is no previous value. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_PREV_DUP `_ )rrKr'rs rBprev_dupCursor.prev_dups 1 122rDc@UR[R5$)aMove to the last value ("duplicate") of the previous key, returning ``True`` on success or ``False`` if there is no previous key. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_PREV_NODUP `_ )rrKr+rs rB prev_nodupCursor.prev_nodup 3 344rDc@UR[R5$)aMove to the next element, returning ``True`` on success or ``False`` if there is no next element. For databases opened with `dupsort=True`, moves to the next value ("duplicate") for the current key if one exists, otherwise moves to the first value of the next key. Equivalent to `mdb_cursor_get() `_ with `MDB_NEXT `_ )rrKrrs rBnext Cursor.nextrHrDc@UR[R5$)aMove to the next value ("duplicate") of the current key, returning ``True`` on success or ``False`` if there is no next value. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_NEXT_DUP `_ )rrKrrs rBnext_dupCursor.next_duprDrDc@UR[R5$)aMove to the first value ("duplicate") of the next key, returning ``True`` on success or ``False`` if there is no next key. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_NEXT_NODUP `_ )rrKrrs rB next_nodupCursor.next_noduprOrDcLUR[RU[5$)aSeek exactly to `key`, returning ``True`` on success or ``False`` if the exact key was not found. It is an error to :py:meth:`set_key` the empty bytestring. For databases opened with `dupsort=True`, moves to the first value ("duplicate") for the key. Equivalent to `mdb_cursor_get() `_ with `MDB_SET_KEY `_ )r4rK MDB_SET_KEYrrQrxs rBset_keyCursor.set_keys""4#3#3S+FFrDcBUR[RX5$)aSeek exactly to `(key, value)`, returning ``True`` on success or ``False`` if the exact key and value was not found. It is an error to :py:meth:`set_key` the empty bytestring. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_GET_BOTH `_ )r4rK MDB_GET_BOTH)rQrxrs rB set_key_dupCursor.set_key_dup!s""4#4#4cAArDNczUR[RU[5(aUR 5$U$)zrEquivalent to :py:meth:`set_key()`, except :py:meth:`value` is returned when `key` is found, otherwise `default`. )r4rKrZrr)rQrxrs rBr Cursor.get/s0   t//k B B::< rDc^^ ^ T(aTS:a [S5eT(dU(aU(d [S5eU(aT(d [S5eT(a![Rn[RnO [Rn[R n[ 5n[5nUGH;m URT 5(dMUR(dM/URU5 [UR5 URUR5m URUR5m T(afUU U 4Sj[S[!T 5T55n U(aU HupUR#X-5 M O1U HupUR%X45 M OUR%T T 45 U(aURU5 OGM'UR(aGM GM> U(a ['U5$U$)aXReturns an iterable of `(key, value)` 2-tuples containing results for each key in the iterable `keys`. `keys`: Iterable to read keys from. `dupdata`: If ``True`` and database was opened with `dupsort=True`, read all duplicate values for each matching key. `dupfixed_bytes`: If database was opened with `dupsort=True` and `dupfixed=True`, accepts the size of each value, in bytes, and applies an optimization reducing the number of database lookups. `keyfixed`: If `dupfixed_bytes` is set and database key size is fixed, setting keyfixed=True will result in this function returning a memoryview to the results as a structured array of bytes. The structured array can be instantiated by passing the memoryview buffer to NumPy: .. code-block:: python key_bytes, val_bytes = 4, 8 dtype = np.dtype([(f'S{key_bytes}', f'S{val_bytes}}')]) arr = np.frombuffer( cur.getmulti(keys, dupdata=True, dupfixed_bytes=val_bytes, keyfixed=True) ) rz*dupfixed_bytes must be a positive integer.z1dupdata is required for dupfixed_bytes/key_bytes.z)dupfixed_bytes is required for key_bytes.c36># UHnTTXT-4v M g7frr[).0idupfixed_bytesrxrs rB "Cursor.getmulti..ps(I%G!#aN(:";<%Gs)rrKMDB_GET_MULTIPLEMDB_NEXT_MULTIPLErr bytearraylistr\rrrrrrrangerextendr< memoryview)rQr rrhkeyfixedget_opnext_opalstgenr3r/rxrs ` @@rBgetmultiCursor.getmulti7s}@ nq0EF F'LM M nDE E **F,,G))F''G KfC||C  kkk$$V,DII&++dii0C++dii0C%I%*1c#h%GI$(+ !),), # A6 2), C:.((1-kkk4 a= JrDczU(dUR5$UR[RU[5$)aSeek to the first key greater than or equal to `key`, returning ``True`` on success, or ``False`` to indicate key was past end of database. Behaves like :py:meth:`first` if `key` is the empty bytestring. For databases opened with `dupsort=True`, moves to the first value ("duplicate") for the key. Equivalent to `mdb_cursor_get() `_ with `MDB_SET_RANGE `_ )rr4rK MDB_SET_RANGErr[s rB set_rangeCursor.set_ranges.::< ""4#5#5sKHHrDcUR[RX5nUR[R5 U$)aSeek to the first key/value pair greater than or equal to `key`, returning ``True`` on success, or ``False`` to indicate that `value` was past the last value of `key` or that `(key, value)` was past the end end of database. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_get() `_ with `MDB_GET_BOTH_RANGE `_ )r4rKMDB_GET_BOTH_RANGErr)rQrxrrs rB set_range_dupCursor.set_range_dups7 !8!8# E --. rDcJURnU(aU(a[ROSn[RURU5nUR =R S- slU(a [SU5eUR[R5 US:HnU$)aDelete the current element and move to the next, returning ``True`` on success or ``False`` if the database was empty. If `dupdata` is ``True``, delete all values ("duplicates") for the current key, otherwise delete only the currently positioned value. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_del() `_ rrmdb_cursor_del) rrKrrrrrrrr)rQrr/rrs rBr Cursor.deletes} KK *1D&&qE$$TYY6B HH  1 $ -r22   T11 2aArDc[RS5n[RURU5nU(a [ SU5eUS$)zReturn the number of values ("duplicates") for the current key. Only meaningful for databases opened with `dupsort=True`. Equivalent to `mdb_cursor_count() `_ zsize_t *mdb_cursor_countr)r=rrKrrr)rQcountprs rBcount Cursor.countsC*%  " "499f 5 +R0 0ayrDc pSnU(dU[R-nU(dU[R-nU(a]URRR [R -(aU[R-nOU[R-n[RURU[U5U[U5U5nUR=RS- sl U(a!U[R:Xag[SU5eUR[R 5 g)afStore a record, returning ``True`` if it was written, or ``False`` to indicate the key was already present and `overwrite=False`. On success, the cursor is positioned on the key. Equivalent to `mdb_cursor_put() `_ `key`: Bytestring key to store. `val`: Bytestring value to store. `dupdata`: If ``False`` and database was opened with `dupsort=True`, will return ``False`` if the key already has that value. In other words, this only affects the return value. `overwrite`: If ``False``, do not overwrite the value for the key if it exists, just return ``False``. For databases opened with `dupsort=True`, ``False`` will always be returned if a duplicate key/value pair is inserted, regardless of the setting for `overwrite`. `append`: If ``True``, append the pair to the end of the database without comparing its order first. Appending a key that is not greater than the highest existing key will fail and return ``False``. rrFmdb_cursor_putTrKrrrrrr MDB_APPENDDUPrpymdb_cursor_putrrrr]rrr)rQrxrrrr<rrs rBr Cursor.puts> T'' 'E T)) )E xx||""T%5%55+++(  " "499c3s8S#c(E R q  T&&&)2. . --.rDc SnU(dU[R-nU(dU[R-nU(a]URRR [R -(aU[R-nOU[R-nSnSnUHup[RURU[U5U [U 5U5n UR=RS- sl US- nU (dMhU [R:XaUS- nM[SU 5e UR[R 5 XfU- 4$)aInvoke :py:meth:`put` for each `(key, value)` 2-tuple from the iterable `items`. Elements must be exactly 2-tuples, they may not be of any other type, or tuple subclass. Returns a tuple `(consumed, added)`, where `consumed` is the number of elements read from the iterable, and `added` is the number of new entries added to the database. `added` may be less than `consumed` when `overwrite=False`. `items`: Iterable to read records from. `dupdata`: If ``True`` and database was opened with `dupsort=True`, add pair as a duplicate if the given key already exists. Otherwise overwrite any existing matching key. `overwrite`: If ``False``, do not overwrite the value for the key if it exists, just return ``False``. For databases opened with `dupsort=True`, ``False`` will always be returned if a duplicate key/value pair is inserted, regardless of the setting for `overwrite`. `append`: If ``True``, append records to the end of the database without comparing their order first. Appending a key that is not greater than the highest existing key will cause corruption. rrrr) rQitemsrrr<raddedskippedrxrrs rBputmultiCursor.putmulti s< T'' 'E T)) )E xx||""T%5%55+++(JC&&tyy#s3x',c%j%AB HH  1 $  QJEr***qLG !1266  --.go%%rDc URR[R-(a{UR [R U[ 5(a<[UR5 [UR5nURS5 OSnURX5 U$[Rn[U5n[RURXU[U5U5nUR =R"S- slU(dgU[R$:wa ['SU5eUR)[R*5 [UR5 [UR5n[RURXU[U5S5nUR =R"S- slU(a ['SU5eUR)[R*5 U$)aStore a record, returning its previous value if one existed. Returns ``None`` if no previous value existed. This uses the best available mechanism to minimize the cost of a `set-and-return-previous` operation. For databases opened with `dupsort=True`, only the first data element ("duplicate") is returned if it existed, all data elements are removed and the new `(key, data)` pair is inserted. `key`: Bytestring key to store. `value`: Bytestring value to store. TNrrr)rrrKrr4rZrrrrrrrrrrrrr]rrr)rQrxroldrkeylenrs rBrCursor.replace: si 77>>D,, ,""4#3#3S+FF "TYY' D! HHS J$$S  " "499c3C% P q   "" ")2. . --. TYY  " "499c3C! L q  )2. . --. rDcUR[RU[5(a[ UR 5 [ UR 5n[RURS5nUR=RS- sl U(a [SU5eUR[R5 U$g)aYFetch a record's value then delete it. Returns ``None`` if no previous value existed. This uses the best available mechanism to minimize the cost of a `delete-and-return-previous` operation. For databases opened with `dupsort=True`, the first data element ("duplicate") for the key will be popped. `key`: Bytestring key to delete. rrrN)r4rKrZrrrrrrrrrrr)rQrxrrs rBr Cursor.popg s   t//k B B DII #C$$TYY2B HH  1 $ -r22   T11 2J CrDcU(dU(dUR5nOURU5nU(a'U(dUR5 UR5$U(d [ S5$UR 5$)zWHelper for centidb. Please do not rely on this interface, it may be removed in future. r[)rr|r"r$iterr)rQr3reversefounds rB _iter_fromCursor._iter_from| sUJJLENN1%E  ==? "Bx==? "rD) rrrrrr#rrrr)TT)FT)TFr)FNFr)TTF)0rUrVrWrXrYrPrr rrrrxrrrr__iter__rrr$r(r,rr4rr;r"rBrFrJrMrQrTrWr\r`rrxr|rrrrrrrrrZr[rDrBrrbsSh-*!&&>307$H;"=&7"; =   0 4 / 3 / 3 5 / 3 5 G BM^I$&, 1f6&p+Z*#rDrr)]rY __future__rrrinspectrr threadingplatformr,r- __builtin__ ImportErrorbuiltinsr3r__all__rNstrr BytesTyperRrrrrlocalr: _CFFI_CDEF_CFFI_CDEF_PATCHED _CFFI_VERIFY _reading_docscffiCONFIG _config_varsrFFIr=cdefverifyrKcallbackrCrOrrrr rr!r&rrrr"r$r%rrrrrr rrr#rrrrrrnglobalsrobjisclass issubclassr_rrrrrrrr r rr openr rr[rDrBrs. '%   <<7 " #    >k9c2 K# . VQ VQm""$ __  s h < | &-7>>#f%|4$g  3L1GNNCW4XX(( 88:DIIj ;;|"-#)+O<*67K*L$01E$F!-k!:$01E$F  HD ]]()* &I &UE##U&5&5F5F E5E IuI 5=5= !e!E!e!""E%%!e!EE%  JGI$$&' ??3  JsE$:$:s%?O69JwtS\\2 3( / PFP& 9 :/2,$.E =&E =P99vR,&R,j i #Vi #m1#"# Gs#MM$ M! M!$M0/M0