*i? SrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK r SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSr"SS\5rSr\"S5r\"S5rSrS rS rS rS r SSS SSS SSSS S\ RBS. r"SSSSS.r#SSSS.SSSS.SSSS.SSSS.S.r$"S S!5r%"S"S#\%5r&"S$S%\'5r("S&S'\)5r*"S(S)\)5r+S*r,"S+S,5r-g)-z%Core disk and file backed cache API. Nc:URS-UR-$)zBReturn full name of `func` by adding the module and function name..) __module__ __qualname__)funcs L/var/www/html/ai-backend/venv/lib/python3.13/site-packages/diskcache/core.py full_namer s ??S 4#4#4 44c$\rSrSrSrSrSrSrg)Constantz%Pretty display of immutable constant.c.[RX45$N)tuple__new__)clsnames rrConstant.__new__s}}S'**r cSUS-$)Nz%srselfs r__repr__Constant.__repr__"sd1g~r rN)__name__rr__firstlineno____doc__rr__static_attributes__rr rr r s/+r r zcache.dbENOVALUNKNOWNleast-recently-storedi@ i walii) statistics tag_indexeviction_policy size_limit cull_limitsqlite_auto_vacuumsqlite_cache_sizesqlite_journal_modesqlite_mmap_sizesqlite_synchronousdisk_min_file_sizedisk_pickle_protocol)countsizehitsmisses)initgetcullzACREATE INDEX IF NOT EXISTS Cache_store_time ON Cache (store_time)z6SELECT {fields} FROM Cache ORDER BY store_time LIMIT ?zCCREATE INDEX IF NOT EXISTS Cache_access_time ON Cache (access_time)zaccess_time = {now}z7SELECT {fields} FROM Cache ORDER BY access_time LIMIT ?zECREATE INDEX IF NOT EXISTS Cache_access_count ON Cache (access_count)zaccess_count = access_count + 1z8SELECT {fields} FROM Cache ORDER BY access_count LIMIT ?)noner%zleast-recently-usedzleast-frequently-usedcd\rSrSrSrSSjrSrSrSr\ 4Sjr SS jr S r \ \ 4S jr S rS rg)Diskgz@Cache key and value serialization for SQLite database and files.c(XlX lX0lg)zInitialize disk instance. :param str directory: directory path :param int min_file_size: minimum size for file use :param int pickle_protocol: pickle protocol for serialization N _directory min_file_sizepickle_protocol)r directoryrBrCs r__init__ Disk.__init__js$*.r cSnURU5up4[U5nU[RLa[R "U5U-$U[ La([R "URS55U-$U[LaX2-$U[Lde[R "[R"SU55U-$)zOCompute portable hash for `key`. :param key: key to hash :return: hash value lutf-8z!d) puttypesqlite3Binaryzlibadler32strencodeintfloatstructpack)rkeymaskdisk_key_ type_disk_keys rhash Disk.hashvshhsm X GNN *<<)D0 0 c !<< 89D@ @ c !? " E) ))<< D( ;>#&, , _C(CF3FFE!9 <<.B.BCD ))$/F>>&)50 0r cU(a)[U5[RLa [U5$U$[R "[ R"U55$)zConvert fields `key` and `raw` from Cache table to key. :param key: database key to convert :param bool raw: flag indicating raw database storage :return: corresponding Python key )rJrKrLrarbloadioBytesIO)rrUraws rr9Disk.gets< !%cgnn!<5: E# E;;rzz#/ /r cz[U5nURnU[La[U5U:d!U[LaSUs=::aS::d O U[ La S[ SU4$U[Laz[U5U:aS[ S[R"U54$URX15upgURU[R"U5S5 [U5[US4$U[La[URX15upgURU[R"U5SS5 [ R""U5nU[$US4$U(a\[&R("UR*S5n URX15upg[-U S 5n URXzS5nU[US4$[.R0"XR2S 9n [U 5U:aS[4S[R"U 54$URX15upgURU[R"U 5S5 [U 5[4US4$) a Convert `value` to fields size, mode, filename, and value for Cache table. :param value: value to convert :param bool read: True when value is file-like object :param key: key for item (default UNKNOWN) :return: (size, mode, filename, value) tuple for Cache table r]r^rNxbxUTF-8i@r r_)rJrBrOlenrQrRMODE_RAWrarKrLfilename_writerlrm MODE_BINARYStringIOopgetsize MODE_TEXTftpartialreaditerrbrcrC MODE_PICKLE) rvaluerrU type_valuerBrv full_pathr5readeriteratorrhs rstore Disk.stores%[ ** 3 3u: #=c!(EH5HHe#he+ + 5 5zM)(D'..*???&*mmC&?# Irzz%'8$?5z;$>> 3 "&--"; H KK 2;;u#5sG D::i(DHd2 2 ZZ E2F"&--"; HFC(H;;yD9Dh4 4\\%2F2FGF6{]*+tW^^F-CCC&*mmC&?# Irzz&'94@6{K4??r Nc[R"U5upV[SS5Hn[R"[ 5 [ R"U5 SSS5 [XUS9nU Sn UH"n U [U 5- n URU 5 M$ U sSSS5 s $ g!,(df  NV=f![ a US:XaeMf=f!,(df  M=f)Nr! encodingr&r) rzsplitrangeclsuppressOSErrorosmakedirsopenrtwrite) rrrmoderfull_dirrXr4writerr5chunks rrw Disk._writeshhy) 1b\EW% H%& iA%ECJ&DLL'& "%% B;   s*B)" B:.,C) B7 :CC C! cvU[:Xa)[U5[RLa [ U5$U$U[ :XawU(a+[ [R"URU5S5$[ [R"URU5S5nUR5sSSS5 $U[:XaF[R"URU5n[ USSS9nUR5sSSS5 $U[:XaxUcK[ [R"URU5S5n[R"U5sSSS5 $[R"[R "U55$g!,(df  g=f!,(df  g=f!,(df  g=f)a`Convert fields `mode`, `filename`, and `value` from Cache table to value. :param int mode: value mode raw, binary, text, or pickle :param str filename: filename of corresponding value :param value: database value :param bool read: when True, return an open file handle :return: corresponding Python value :raises: IOError if the value cannot be read rbNrrsr)rurJrKrLrarxrrzjoinrArr|rrbrkrlrm)rrrvrrrrs rfetch Disk.fetchs2 8 #';'..#@5< Ke K [ BGGDOOX>EE"''$//8`, the `key` or `value` may not be known when the item is stored in the cache. :param key: key for item (default UNKNOWN) :param value: value for item (default UNKNOWN) hexrHNr"r$z.val)codecsrPrurandomdecoderzrrA)rrUrhex_namesub_dirrrvrs rrv Disk.filenames~&==B7>>wG''(2A,1 6|f$777)GGDOOX6 ""r c[R"URU5n[R"U5up4[R "[ 5 [R"U5 SSS5 [R "[ 5 [R"U5 SSS5 g!,(df  NH=f!,(df  g=f)zRemove a file given by `file_path`. This method is cross-thread and cross-process safe. If an OSError occurs, it is suppressed. :param str file_path: relative path to file N) rzrrArrrrrremove removedirs)r file_pathrrrXs rr Disk.remove8s{GGDOOY7 hhy)  [[ ! IIi "[[ ! MM( #" !" !" !sB- B>- B;> C r@)rrr)rrrrrrErZrIr9r rrwrrvrrrr rr=r=gsBJ /D*14 0&-1@f06@#'#4$r r=cf^\rSrSrSrS U4SjjrU4SjrU4Sjr\4U4Sjjr U4Sjr Sr U=r $) JSONDiskiNzCCache key and value using JSON serialization with zlib compression.c 4>X l[TU]"U40UD6 g)aInitialize JSON disk instance. Keys and values are compressed using the zlib library. The `compress_level` is an integer from 0 to 9 controlling the level of compression; 1 is fastest and produces the least compression, 9 is slowest and produces the most compression, and 0 is no compression. :param str directory: directory path :param int compress_level: zlib compression level (default 1) :param kwargs: super class arguments N)compress_levelsuperrE)rrDrkwargs __class__s rrEJSONDisk.__init__Qs- -f-r c>[R"U5RS5n[R"X R 5n[ TU]U5$NrH)jsonrcrPrMcompressrrrI)rrU json_bytesrgrs rrI JSONDisk.putas>ZZ_++G4 }}Z)<)<=w{4  r c>[TU]X5n[R"[R "U5R S55$r)rr9rloadsrM decompressr)rrUrnrgrs rr9 JSONDisk.getfs4w{3$zz$//$/66w?@@r c>U(dE[R"U5RS5n[R"X@R 5n[ TU]XUS9$)NrHrU)rrcrPrMrrrr)rrrrUrrs rrJSONDisk.storejsFE*11':JMM*.A.ABEw}Uc}22r c>[TU]XX45nU(d9[R"[R "U5R S55nU$r)rrrrrMrr)rrrvrrrgrs rrJSONDisk.fetchps=w}TU9::dood3::7CDD r )r)r!) rrrrrrErIr9r rrr __classcell__)rs@rrrNs*M. ! A&-3 r rc\rSrSrSrSrg)TimeoutiwzDatabase timeout expired.rNrrrrrrrr rrrws#r rc\rSrSrSrSrg)UnknownFileWarningi{z.Warning used by Cache.check for unknown files.rNrrr rrr{s8r rc\rSrSrSrSrg)EmptyDirWarningiz2Warning used by Cache.check for empty directories.rNrrr rrrs# UHupUT;dM Uv M g7frr).0indexargignores r args_to_key..sN%v:Ms  rc38# UHn[U5v M g7frrJ)rrs rrrs/$3T#YY$sc3<# UHup[U5v M g7frr)rrXrs rrrsB\e\s)r enumerateitemssorted) baseargsrtypedrrUval sorted_itemsitems ` r args_to_keyrs NyN ND + C +1<<>O>xsS=N(#(>Oflln-  D 4KC!  u/$///  5B\BB BC JPs  B;B;ct\rSrSrSrSS\4Sjr\S5r\S5r \S5r \S 5r \S 5r \S 5r \RS:S j5r\RS;S j5rSSjrSS(jr+S:S)jr,S:S*jr-SHS+jr.S:S,jr/SBS-jr0S.r1S/r2SIS0jr3S1r4S2r5S3r6S4r7S5r8S6r9S7r:\;S4S8jr>  ! ! #    !   A>* L@At K L" ;;%,,.* 46:ooF  / '' "!  "0 sBL/2MN)/O O/M  N&AN!!N&)OOcUR$)zCache directory.)rArs rrDCache.directoryQsr cUR$)z+SQLite connection timeout value in seconds.)rrs rr Cache.timeoutVs}}r cUR$)zDisk used for serialization.)r rs rr Cache.disk[szzr cf[URSS5n[R"5nX:wa UR 5 X Rl[URSS5nUc[ R"[R"UR[5URSS9=o0Rl SnURU5R5nUH-upgUR!S5(dMUR#XgSS9 M/ U$U$![ R$a U$f=f)Npidcon)risolation_levelrrFr)getattrrrgetpidrr rKconnectrzrrADBNAMErr!executerrrr)r local_pidr r!selectrrUrs r_con Cache._con`s DKK5 iik   JJL!KKOdkk5$/ ;$+OO0 $% C++/ =:;;v.779#+JC~~i00 3e <#+ s ++    s!DD0/D0c.URR$r)r*r'rs rr Cache._sqlsyy   r c,^URmU4SjnU$)Nc>[R"5nT"U/UQ70UD6$![RaOn[U5S:wae[R"5U- nUS:ae[R"S5 SnAOSnAff=fMu)Ndatabase is lockedrMbP?)timerKrrOsleep) statementrrstartexcdiffrs r_execute_with_retry-Cache._sql_retry.._execute_with_retrysIIKE&y:4:6:://&3x#7799;.DbyJJu%% &s %BABBr)rr8rs @rrCache._sql_retrysii &#"r c#f# URUS9 Sv SSS5 g!,(df  g=f7f)aContext manager to perform a transaction by locking the cache. While the cache is locked, no other write operation is permitted. Transactions should therefore be as short as possible. Read and write operations performed in a transaction are atomic. Read operations may occur concurrent to a transaction. Transactions may be nested and may not be shared between threads. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). >>> cache = Cache() >>> with cache.transact(): # Atomically increment two keys. ... _ = cache.incr('total', 123.4) ... _ = cache.incr('count', 1) >>> with cache.transact(): # Atomically calculate average. ... average = cache['total'] / cache['count'] >>> average 123.4 :param bool retry: retry if database timeout occurs (default False) :return: context manager for use in `with` statement :raises Timeout: if database timeout occurs retryN) _transact)rr>s rtransactCache.transacts#8^^%^ ( ) ( (s1  1 .1c#># URn/nURRn[R"5nUR nXg:XaSnOU"S5 SnX`lX4R4v U(a!UR U:XdeSUlU"S5 UHn U cMU"U 5 M g![ Ra U(aMUbU"U5 [Sef=f![a* U(a!UR U:XdeSUlU"S5 ef=f7f)NFTzBEGIN IMMEDIATECOMMITROLLBACK) rr rr get_identrrKrrappend BaseException) rr>rvr filenames _disk_removetidtxn_idbeginrs rr?Cache._transactsii zz(( !!# =E ,)* E#&L '''' '||s***# H !# &")//, +$X.!t+ , ||s***# J   sHADB2"D$C&3.D% D2C# DC##D&4DDc[R"5nURRU5upUcSOXs-n URRX$US9uppXXX4nUR Xm5unnU"SX45R 5nU(a"UuunnU"U5 UR UX5 OURXX5 URUUU5 SSS5 g!,(df  g=f)aoSet `key` and `value` item in cache. When `read` is `True`, `value` should be a file-like object opened for reading in binary mode. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param value: value for item :param float expire: seconds until item expires (default None, no expiry) :param bool read: read value as bytes from file (default False) :param str tag: text to associate with key (default None) :param bool retry: retry if database timeout occurs (default False) :return: True if item was set :raises Timeout: if database timeout occurs Nrz;SELECT rowid, filename FROM Cache WHERE key = ? AND raw = ?T r2r rIrr?r _row_update _row_insert_cull)rrUrexpirertagr>nowdb_keyrn expire_timer5rrvdb_valuecolumnsrcleanuprowsrowid old_filenames rset Cache.sets(iikjjnnS) $nd#, )-)9)9%3)9)O&HTD.^^E ,g- hj  +/(&% %  5  c; JJsC )!- , ,s /A+C## C1c$URXSS9 g)zSet corresponding `value` for `key` in cache. :param key: key for item :param value: value for item :return: corresponding value :raises KeyError: if key is not found Tr=N)r^rrUrs r __setitem__Cache.__setitem__.s 4(r c NURnUupVpxpU"SUUUSUUUU U U4 5 g)NzUPDATE Cache SET store_time = ?, expire_time = ?, access_time = ?, access_count = ?, tag = ?, size = ?, mode = ?, filename = ?, value = ? WHERE rowid = ?rr:) rr\rUrYrrWrTr5rrvrs rrPCache._row_update9sIii8?5 $h    r cPURnUupgppU"SUUUUUSUUU U U 4 5 g)NzINSERT INTO Cache( key, raw, store_time, expire_time, access_time, access_count, tag, size, mode, filename, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)rr:) rrUrnrUrYrrWrTr5rrvrs rrQCache._row_insertVsLii8?5 $h  9    r c Uc UROUnUS:XagSnUS-nU"XqU45R5nU(a:SUS--n U"XU45 UH un U"U 5 M U[U5-nUS:Xag[URSn U bUR 5UR :agU RSUS9n U"X45R5nU(a0SU RSUS9-n U"X45 UH un U"U 5 M gg)NrzcSELECT %s FROM Cache WHERE expire_time IS NOT NULL AND expire_time < ? ORDER BY expire_time LIMIT ?rv%DELETE FROM Cache WHERE rowid IN (%s)r\r:fieldsrU)r,rrtr r*volumer+format)rrUrrZlimitr,select_expired_templateselect_expiredr[delete_expiredrv select_policyselect_filenamedeletes rrR Cache._cullms;(- T__5 ?   , 1:=>#45>>@ D''1N j 1 2# ! $ #d) #JQ((<(<=fE  DKKMDOO$C '..jc.J?M2;;= <$$G$=F  &# ! $ r cV[R"5nURRU5upVUcSOXB-nURU5upU"SXV45R 5n U (a"U uupU bX:aU"SX{45 SSS5 gSSS5 g!,(df  g=f)aTouch `key` in cache and update `expire` time. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param float expire: seconds until item expires (default None, no expiry) :param bool retry: retry if database timeout occurs (default False) :return: True if key was touched :raises Timeout: if database timeout occurs Nz>SELECT rowid, expire_time FROM Cache WHERE key = ? AND raw = ?z0UPDATE Cache SET expire_time = ? WHERE rowid = ?TF)r2r rIr?r) rrUrSr>rUrVrnrWrrXr[r\old_expire_times rtouch Cache.touchsiikjjnnS) $nd#, ^^E "hs- hj  .2+)%"*o.CJ$, # " ""## ""s ;B B(c [R"5nURRU5upUcSOXs-n URRX$US9uppXXX4nUR Xm5unnU"SX45R 5nU(a>UuunnnUbUU:aU"U 5 SSS5 gU"U5 UR UX5 OURXX5 URUUU5 SSS5 g!,(df  g=f)aAdd `key` and `value` item to cache. Similar to `set`, but only add to cache if key not present. Operation is atomic. Only one concurrent add operation for a given key will succeed. When `read` is `True`, `value` should be a file-like object opened for reading in binary mode. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param value: value for item :param float expire: seconds until the key expires (default None, no expiry) :param bool read: read value as bytes from file (default False) :param str tag: text to associate with key (default None) :param bool retry: retry if database timeout occurs (default False) :return: True if item was added :raises Timeout: if database timeout occurs NrzHSELECT rowid, filename, expire_time FROM Cache WHERE key = ? AND raw = ?FTrO)rrUrrSrrTr>rUrVrnrWr5rrvrXrYrrZr[r\r]rws radd Cache.adds 2iikjjnnS) $nd#, )-)9)9%3)9)O&HTD ^^E ,g- hj  <@97%"*o.CH% - , %  5  c; JJsC )+- , ,s/=C?5AC?? D c<[R"5nURRU5upgSnURU5upU "XU45R 5n U (d_Uc [ U5eX2-n SURR U SUS9-n URXgX]5 URXYU 5 U sSSS5 $U uupnn UblX:agUc [ U5eX2-n SURR U SUS9-n URXU 5 URXYU 5 U "U5 U sSSS5 $X- n Sn [URSnUbU SURUS 9-- n S U -nU "UX\U45 U sSSS5 $!,(df  g=f) aDIncrement value by delta for item with key. If key is missing and default is None then raise KeyError. Else if key is missing and default is not None then use default for value. Operation is atomic. All concurrent increment operations will be counted individually. Assumes value may be stored in a SQLite column. Most builds that target machines with 64-bit pointer widths will support 64-bit signed integers. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param int delta: amount to increment (default 1) :param int default: value if key is missing (default 0) :param bool retry: retry if database timeout occurs (default False) :return: new value for item :raises KeyError: if key is not found and default is None :raises Timeout: if database timeout occurs zOSELECT rowid, expire_time, filename, value FROM Cache WHERE key = ? AND raw = ?NNNFrzstore_time = ?, value = ?r9z, rU#UPDATE Cache SET %s WHERE rowid = ?) r2r rIr?rKeyErrorrrQrRrPr r*rm)rrUdeltadefaultr>rUrVrnr)rrZr[rrYr\rWrv update_columnrs rincr Cache.incrs2iikjjnnS)  )  ^^E "nsv}-668D?"3-'&)9)95c*:*  c; 3W-# "8< 4 2e(E&;+<?"3-'&)9)95c*:*  W5 3W-!9# "< NE1G+D,@,@A%HM(4-"6"63"6"???:WDF U+ ,S# " "sA7F A-F >AF  Fc(URX*X45$)aDecrement value by delta for item with key. If key is missing and default is None then raise KeyError. Else if key is missing and default is not None then use default for value. Operation is atomic. All concurrent decrement operations will be counted individually. Unlike Memcached, negative values are supported. Value may be decremented below zero. Assumes value may be stored in a SQLite column. Most builds that target machines with 64-bit pointer widths will support 64-bit signed integers. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param int delta: amount to decrement (default 1) :param int default: value if key is missing (default 0) :param bool retry: retry if database timeout occurs (default False) :return: new value for item :raises KeyError: if key is not found and default is None :raises Timeout: if database timeout occurs )r)rrUrrr>s rdecr Cache.decrEs8yyfg55r cURRU5upx[URSn Sn U(a U(aUSS4nOU(dU(aUS4nUR(djU cgUR XU[ R "545R5n U (dU$U uuppnnURRUUUU5nOSnSnURU5unnU"XU[ R "545R5n U (d$UR(aU"U5 UsSSS5 $U uuppnnURRUUUU5nUR(aU"U5 [ R "5nSnU bU"UU RUS9-U 45 SSS5 U(a U(aWW W4$U(aWW 4$U(aWW4$W$![a Us$f=f![a' UR(aU"U5 UssSSS5 $f=f!,(df  N=f)ayRetrieve value from cache. If `key` is missing, return `default`. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param default: value to return if key is missing (default None) :param bool read: if True, return file handle to value (default False) :param bool expire_time: if True, return expire_time in tuple (default False) :param bool tag: if True, return tag in tuple (default False) :param bool retry: retry if database timeout occurs (default False) :return: value for item or default if key not found :raises Timeout: if database timeout occurs r9SELECT rowid, expire_time, tag, mode, filename, value FROM Cache WHERE key = ? AND raw = ? AND (expire_time IS NULL OR expire_time > ?)Nz8UPDATE Settings SET value = value + 1 WHERE key = "hits"z:UPDATE Settings SET value = value + 1 WHERE key = "misses"rr) r rIr r*r(rr2rrIOErrorr?rm)rrUrrrWrTr>rVrnrr)r[r\db_expire_timedb_tagrrvrXr cache_hit cache_missrrXrUrs rr9 Cache.getcs%4jjnnS) '(<(<=eD  <  3d+G CoG=#899Vc499;%?@IIKDKO H FeV8X  ((x4HK M &(36C#=>GGIJ" '&MUF(H# JJ,,T8XtLE?? Niik> ,!5!5#!5!>>I7': 3>62 2 >* * 6? "La  4#J"N%'&#'&sJ8G/,AH5 H5H/A H5/ G>=G>%H2&H51H22H55 IcXURU[SS9nU[La [U5eU$)zReturn corresponding value for `key` from cache. :param key: key matching item :return: corresponding value :raises KeyError: if key is not found Trr>r9rrras r __getitem__Cache.__getitem__s.fD9 F?3-  r cZURU[SUS9nU[La [U5eU$)a|Return file handle value corresponding to `key` from cache. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key matching item :param bool retry: retry if database timeout occurs (default False) :return: file open for reading in binary mode :raises KeyError: if key is not found :raises Timeout: if database timeout occurs T)rrr>r)rrUr>handles rr Cache.reads1#vDF V 3-  r cURnURRU5up4SnU"XSU[R"545R 5n[ U5$)z{Return `True` if `key` matching item is found in cache. :param key: key matching item :return: True if key matching item z^SELECT rowid FROM Cache WHERE key = ? AND raw = ? AND (expire_time IS NULL OR expire_time > ?))rr rIr2rbool)rrUrrVrnr)r[s r __contains__Cache.__contains__sWiijjnnS)  <  6C56??ADzr cURRU5upgSnU(a U(aUSS4nOU(dU(aUS4nURU5upU "XU[R"545R 5n U (d UsSSS5 $U uuppnnU "SU 45 SSS5 URR WWWS5nUbURRU5 U(a U(aUW W4$U(aUW 4$U(aUW4$U$!,(df  Nw=f![ a$ UsWbURRU5 $$f=f!WbURRU5 ff=f)aRemove corresponding item for `key` from cache and return value. If `key` is missing, return `default`. Operation is atomic. Concurrent operations will be serialized. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key for item :param default: value to return if key is missing (default None) :param bool expire_time: if True, return expire_time in tuple (default False) :param bool tag: if True, return tag in tuple (default False) :param bool retry: retry if database timeout occurs (default False) :return: value for item or default if key not found :raises Timeout: if database timeout occurs rN!DELETE FROM Cache WHERE rowid = ?F)r rIr?r2rrrr)rrUrrWrTr>rVrnr)rrXr[r\rrrrvrXrs rr Cache.popsn,jjnnS)  <  3tT)G CtmG ^^E "hsvTYY[9:CCED # " LP H FeV8X 3eX ># ,JJ$$T8XuEE # !!(+ 3.&0 0 .( ( &= L5# " N# !!(+$  # !!(+$s67DD4D- D*- E9EEE!E?TcFURRU5up4URU5upVU"SX4[R"545R 5nU(d [ U5eUuupU"SU45 U"U 5 SSS5 g!,(df  g=f)aHDelete corresponding item for `key` from cache. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default `True`). :param key: key matching item :param bool retry: retry if database timeout occurs (default True) :raises KeyError: if key is not found :raises Timeout: if database timeout occurs zhSELECT rowid, filename FROM Cache WHERE key = ? AND raw = ? AND (expire_time IS NULL OR expire_time > ?)rNT)r rIr?r2rr) rrUr>rVrnrrZr[r\rvs r __delitem__Cache.__delitem__8sjjnnS)  ^^E "ns@diik*  hj sm##' e 3eX > H # " "s AB B cBURXS9$![a gf=f)aYDelete corresponding item for `key` from cache. Missing keys are ignored. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param key: key matching item :param bool retry: retry if database timeout occurs (default False) :return: True if item was deleted :raises Timeout: if database timeout occurs r=F)rr)rrUr>s rrt Cache.deleteWs- ##C#5 5  s  cxUcSnSn O US-nUS-n [R"5n Sn UcSOX-n URRX5upnnXXUU4nSSS .nS UU-nURX5unnU"UXU 45R 5nU(aFUuunUb![ UUR S 5S -S5nOUnUS :XaUS - nOUS:XdeUS -nOSnUbSRUU5nOUnURUXU5 URU UU5 UsSSS5 $!,(df  g=f)aPush `value` onto `side` of queue identified by `prefix` in cache. When prefix is None, integer keys are used. Otherwise, string keys are used in the format "prefix-integer". Integer starts at 500 trillion. Defaults to pushing value on back of queue. Set side to 'front' to push value on front of queue. Side must be one of 'back' or 'front'. Operation is atomic. Concurrent operations will be serialized. When `read` is `True`, `value` should be a file-like object opened for reading in binary mode. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). See also `Cache.pull`. >>> cache = Cache() >>> print(cache.push('first value')) 500000000000000 >>> cache.get(500000000000000) 'first value' >>> print(cache.push('second value')) 500000000000001 >>> print(cache.push('third value', side='front')) 499999999999999 >>> cache.push(1234, prefix='userids') 'userids-500000000000000' :param value: value for item :param str prefix: key prefix (default None, key is integer) :param str side: either 'back' or 'front' (default 'back') :param float expire: seconds until the key expires (default None, no expiry) :param bool read: read value as bytes from file (default False) :param str tag: text to associate with key (default None) :param bool retry: retry if database timeout occurs (default False) :return: key for item in cache :raises Timeout: if database timeout occurs NrI5-000000000000000-999999999999999TDESCASC)backfrontzSSELECT key FROM Cache WHERE ? < key AND key < ? AND raw = ? ORDER BY key %s LIMIT 1-r!rrl@$z {0}-{1:015d}) r2r rr?rrQrfindrmrQrR)rrrsiderSrrTr>min_keymax_keyrUrnrWr5rrvrXrYorderr)rrZr[rUnumrVs rpush Cache.pushkskh >G%G11G11Giik$nd#, )-)9)9%)F&HhT8D%0 ' $K  ^^E ,gv#67@@BD #%c399S>A#5"89:CC6>1HC7?*?1HC%!'..vs;   VSw 7 JJsC )7- , ,s 6B+D++ D9c\UcSnSnO US-nUS-nSSS.n S X-n U(a U(aUSS4nOU(dU(aUS4nURU5upU "XU45R5n U (d UsSSS5 $U uupnnnnnU "S U45 Ub"U[R"5:a U "U5 O SSS5 O SSS5 MURR UUUS 5nUbURR U5 U(aU(aUU4UU4$U(aUU4U4$U(aUU4U4$UU4$!,(df  N=f![ a& UcGM#URR U5 GMAf=f!UbURR U5 ff=f) aPull key and value item pair from `side` of queue in cache. When prefix is None, integer keys are used. Otherwise, string keys are used in the format "prefix-integer". Integer starts at 500 trillion. If queue is empty, return default. Defaults to pulling key and value item pairs from front of queue. Set side to 'back' to pull from back of queue. Side must be one of 'front' or 'back'. Operation is atomic. Concurrent operations will be serialized. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). See also `Cache.push` and `Cache.get`. >>> cache = Cache() >>> cache.pull() (None, None) >>> for letter in 'abc': ... print(cache.push(letter)) 500000000000000 500000000000001 500000000000002 >>> key, value = cache.pull() >>> print(key) 500000000000000 >>> value 'a' >>> _, value = cache.pull(side='back') >>> value 'c' >>> cache.push(1234, 'userids') 'userids-500000000000000' >>> _, value = cache.pull('userids') >>> value 1234 :param str prefix: key prefix (default None, key is integer) :param default: value to return if key is missing (default (None, None)) :param str side: either 'front' or 'back' (default 'front') :param bool expire_time: if True, return expire_time in tuple (default False) :param bool tag: if True, return tag in tuple (default False) :param bool retry: retry if database timeout occurs (default False) :return: key and value item pair or default if queue is empty :raises Timeout: if database timeout occurs NrrrrrrrrSELECT rowid, key, expire_time, tag, mode, filename, value FROM Cache WHERE ? < key AND key < ? AND raw = 1 ORDER BY key %s LIMIT 1rF)r?rr2r rrrrrrrrWrTr>rrrr)rrZr[r\rU db_expirerrrrXrs rpull Cache.pulls| >G%G11G11G0 ' K  3tT)G CtmG^^E*nsv'9:CCED& +*MYdH;eXF ,TYY[1H +*&+$ , ((tXuE #JJ%%d+  3<F2 2 <* * <' ': E+*& #JJ%%d+  #JJ%%d+$s6#E;EE E F!F FF !F+cUcSnSnO US-nUS-nSSS.n S X-n U(a U(aUSS4nOU(dU(aUS4nURU5upU "XU45R5n U (d UsSSS5 $U uupnnnnnUb,U[R"5:aU "S U45 U "U5 O SSS5 O SSS5 MURR UUUS 5nU(aU(aUU4UU4$U(aUU4U4$U(aUU4U4$UU4$!,(df  Nc=f![ a GMf=f) aPeek at key and value item pair from `side` of queue in cache. When prefix is None, integer keys are used. Otherwise, string keys are used in the format "prefix-integer". Integer starts at 500 trillion. If queue is empty, return default. Defaults to peeking at key and value item pairs from front of queue. Set side to 'back' to pull from back of queue. Side must be one of 'front' or 'back'. Expired items are deleted from cache. Operation is atomic. Concurrent operations will be serialized. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). See also `Cache.pull` and `Cache.push`. >>> cache = Cache() >>> for letter in 'abc': ... print(cache.push(letter)) 500000000000000 500000000000001 500000000000002 >>> key, value = cache.peek() >>> print(key) 500000000000000 >>> value 'a' >>> key, value = cache.peek(side='back') >>> print(key) 500000000000002 >>> value 'c' :param str prefix: key prefix (default None, key is integer) :param default: value to return if key is missing (default (None, None)) :param str side: either 'front' or 'back' (default 'front') :param bool expire_time: if True, return expire_time in tuple (default False) :param bool tag: if True, return tag in tuple (default False) :param bool retry: retry if database timeout occurs (default False) :return: key and value item pair or default if queue is empty :raises Timeout: if database timeout occurs NrrrrrrrrrF)r?rr2r rrrs rpeek Cache.peekFst >G%G11G11G0 ' K  3tT)G CtmG^^E*nsv'9:CCED& +*MYdH!,TYY[1H?%J +*&+"  ((tXuE  3<F2 2 <* * <' ': =+*$  s$#D';D'D8' D58 EEc RSnSXQ-nURU5upxU"U5R5n U (d [S5eU uun n n n nnnnU b,U [R"5:aU"SU 45 U"U5 O SSS5 O SSS5 MURR X5nURR UUUS5nU(a U(aUU4X4$U(aUU4U 4$U(aUU4U4$UU4$!,(df  N}=f![a GMf=f)a*Peek at key and value item pair in cache based on iteration order. Expired items are deleted from cache. Operation is atomic. Concurrent operations will be serialized. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). >>> cache = Cache() >>> for num, letter in enumerate('abc'): ... cache[letter] = num >>> cache.peekitem() ('c', 2) >>> cache.peekitem(last=False) ('a', 0) :param bool last: last item in iteration order (default True) :param bool expire_time: if True, return expire_time in tuple (default False) :param bool tag: if True, return tag in tuple (default False) :param bool retry: retry if database timeout occurs (default False) :return: key and value item pair :raises KeyError: if cache is empty :raises Timeout: if database timeout occurs )rrzdSELECT rowid, key, raw, expire_time, tag, mode, filename, value FROM Cache ORDER BY rowid %s LIMIT 1zdictionary is emptyNrF)r?rrr2r r9rr)rlastrWrTr>rr)rrZr[r\rVrnrrrrrXrUrs rpeekitemCache.peekitemsT6  4 K ^^E*nsv;//1D&'<==  !"%"  $!,TYY[1H?%J /+**&++4**..-C  ((tXuE  3<2 2 <* * <' ': S+*:  sA(D5D D D&%D&c^^^^^^^[T5(a [S5eUUUUUU4SjnU$)a Memoizing cache decorator. Decorator to wrap callable with memoizing function using cache. Repeated calls with the same arguments will lookup result in cache and avoid function evaluation. If name is set to None (default), the callable name will be determined automatically. When expire is set to zero, function results will not be set in the cache. Cache lookups still occur, however. Read :doc:`case-study-landing-page-caching` for example usage. If typed is set to True, function arguments of different types will be cached separately. For example, f(3) and f(3.0) will be treated as distinct calls with distinct results. The original underlying function is accessible through the __wrapped__ attribute. This is useful for introspection, for bypassing the cache, or for rewrapping the function with a different cache. >>> from diskcache import Cache >>> cache = Cache() >>> @cache.memoize(expire=1, tag='fib') ... def fibonacci(number): ... if number == 0: ... return 0 ... elif number == 1: ... return 1 ... else: ... return fibonacci(number - 1) + fibonacci(number - 2) >>> print(fibonacci(100)) 354224848179261915075 An additional `__cache_key__` attribute can be used to generate the cache key used for the given arguments. >>> key = fibonacci.__cache_key__(100) >>> print(cache[key]) 354224848179261915075 Remember to call memoize when decorating a callable. If you forget, then a TypeError will occur. Note the lack of parenthenses after memoize below: >>> @cache.memoize ... def test(): ... pass Traceback (most recent call last): ... TypeError: name cannot be callable :param cache: cache to store callable arguments and return values :param str name: name given for callable (default None, automatic) :param bool typed: cache different types separately (default False) :param float expire: seconds until arguments expire (default None, no expiry) :param str tag: text to associate with arguments (default None) :param set ignore: positional or keyword args to ignore (default ()) :return: callable decorator zname cannot be callablec>^^^Tc [T54OT4m[R"T5UUUUU4Sj5mUUU 4SjnUTlT$)z3Decorator created by memoize() for callable `func`.c>TR"U0UD6nTRU[SS9nU[La#T"U0UD6nTbTS:aTRX#TTSS9 U$)z:Wrapper for callable to cache arguments and return values.Trr)rTr>) __cache_key__r9rr^) rrrUrhrSrrrTwrappers rr1Cache.memoize..decorator..wrapperLsi++T[TXTT5$)z,Make key for cache given function arguments.)r)rrrrrs rr7Cache.memoize..decorator..__cache_key__Ys"4ufEEr )r r}wrapsr) rrrrrSrrrrTrs ` @@r decorator Cache.memoize..decoratorHsK)-IdO%D7D XXd^    F%2G !Nr )callabler)rrrrSrTrrs`````` rmemoize Cache.memoizes-D D>>56 6  0r c [R"SS9nURnU"S5R5n[ U5S:wd USSS:wa!UHun[R "U5 M U(aU"S5 UR U5upG[5nSn U"U 5R5nUHupn [R"URU 5n URU 5 [R"U 5(aL[R"U 5nX:wa/S nXU 4n[R "Xo-5 U(a U"S X45 M[R "S U -5 U(dMU"S U 45 M [R"UR5HunnnUV s/sHn [R"UU 5PM nn [U5U- nUHNn [ U ;aMS U -n[R "U["5 U(dM8[R$"U 5 MP M [R"UR5HXunnnU(aMU(aMSU-n[R "U[&5 U(dMB[R("U5 MZ UR+S5 U"S5R5uunUR,U:wa8Sn[R "X`R,U4-5 U(a U"SUS45 UR+S5 SnU"U5R5uun UR.U :wa8Sn[R "X`R.U 4-5 U(a U"SU S45 SSS5 UsSSS5 $s sn f!,(df  N=f!,(df  g=f)aCheck database and file system consistency. Intended for use in testing and post-mortem error analysis. While checking the Cache table for consistency, a writer lock is held on the database. The lock blocks other cache clients from writing to the database. For caches with many file references, the lock may be held for a long time. For example, local benchmarking shows that a cache with 1,000 file references takes ~60ms to check. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param bool fix: correct inconsistencies :param bool retry: retry if database timeout occurs (default False) :return: list of warnings :raises Timeout: if database timeout occurs T)recordzPRAGMA integrity_checkr!rokVACUUMzBSELECT rowid, size, filename FROM Cache WHERE filename IS NOT NULLzwrong file size: %s, %d != %dz)UPDATE Cache SET size = ? WHERE rowid = ?zfile not found: %srzunknown file: %szempty directory: %sr4zSELECT COUNT(key) FROM Cachez,Settings.count != COUNT(Cache.key); %d != %d+UPDATE Settings SET value = ? WHERE key = ?r5z(SELECT COALESCE(SUM(size), 0) FROM Cachez*Settings.size != SUM(Cache.size); %d != %dz*UPDATE Settings SET value = ? WHERE key =?N)warningscatch_warningsrrrtwarnr?r^rzrrAr{existsr{rwalkr&rrrrmdirrr4r5)rfixr>warnsrr[messagerXrHr)r\r5rvr real_sizerdirpathfilespathsrdirsr4 select_sizes rcheck Cache.checkbs2* $ $D 1U))C/099;D4yA~at!3"&JWMM'*#'H &(3 E 2 6{++--1)E " BIMM),yy++$&JJy$9 ,&EG#,#=D$MM'.9" #%7%.$6!" !MM"6"BCs?%J1.28*,)A%GQHMNHRWWWh7ENJ2E%* !Y.$"4y"@ g/AB3IIi0&+ *B -/GGDOO,D(GT5 DEE"7'"A g?3HHW- -E 7#!"@AJJL %::&LGMM'ZZ,?"?@I"G, 6"H  -668 $99$JGMM'YY,="=>H!6Nu'~[2 1nOS'&2 1sXA?O C$N:<9N:5!N5 AN: A N:.N:7%N: DN:" O 5N:: O O  OcPURnU"S5 URSS5 g)zCreate tag index on cache database. It is better to initialize cache with `tag_index=True` than use this. :raises Timeout: if database timeout occurs z?CREATE INDEX IF NOT EXISTS Cache_tag_rowid ON Cache(tag, rowid)r)r!Nrrrrs rr Cache.create_tag_indexs$ii MN ;"r cPURnU"S5 URSS5 g)zPDrop tag index on cache database. :raises Timeout: if database timeout occurs z$DROP INDEX IF EXISTS Cache_tag_rowidr)rNrrs rr Cache.drop_tag_indexs$ ii 23 ;"r c2SnUSS/nURX4SUS9$)a`Remove items with matching `tag` from cache. Removing items is an iterative process. In each iteration, a subset of items is removed. Concurrent writes may occur between iterations. If a :exc:`Timeout` occurs, the first element of the exception's `args` attribute will be the number of items removed before the exception occurred. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param str tag: tag identifying items :param bool retry: retry if database timeout occurs (default False) :return: count of rows removed :raises Timeout: if database timeout occurs zTSELECT rowid, filename FROM Cache WHERE tag = ? AND rowid > ? ORDER BY rowid LIMIT ?rdr!) arg_indexr>_select_delete)rrTr>r)rs revict Cache.evicts1( &  Q}""61E"JJr cjSnSU=(d [R"5S/nURX4SUS9$)asRemove expired items from cache. Removing items is an iterative process. In each iteration, a subset of items is removed. Concurrent writes may occur between iterations. If a :exc:`Timeout` occurs, the first element of the exception's `args` attribute will be the number of items removed before the exception occurred. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param float now: current time (default None, ``time.time()`` used) :param bool retry: retry if database timeout occurs (default False) :return: count of items removed :raises Timeout: if database timeout occurs zuSELECT rowid, expire_time, filename FROM Cache WHERE ? < expire_time AND expire_time < ? ORDER BY expire_time LIMIT ?rrr!) row_indexr>)r2r)rrUr>r)rs rrS Cache.expires=( ,  3%$))+s+""61E"JJr c~[R"5nURU5n[URSnUcgUR SUS9nUR 5UR :aURU5upgU"US5R5nU(d SSS5 U$U[U5- nSUR SUS9-n U"U S5 UH un U"U 5 M SSS5 UR 5UR :aMU$!,(df  N0=f![a [U5Sef=f) aJCull items from cache until volume is less than size limit. Removing items is an iterative process. In each iteration, a subset of items is removed. Concurrent writes may occur between iterations. If a :exc:`Timeout` occurs, the first element of the exception's `args` attribute will be the number of items removed before the exception occurred. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param bool retry: retry if database timeout occurs (default False) :return: count of items removed :raises Timeout: if database timeout occurs r:Nrrvrj)r&rir\) r2rSr r*rmrlr+r?rrtr) rr>rUr4rrrsrrZr[rtrvs rr: Cache.cull2s8$iik C ((<(<=fE  '..jc.J +++-$//1^^E*ns6??AD +$ SY&E?'..g3.GH&'+ )(,+++-$//1& %+* +%.d * +s0/D%"D#D%-=D*&D% D"D%%D<c.SnSS/nURX#US9$)a*Remove all items from cache. Removing items is an iterative process. In each iteration, a subset of items is removed. Concurrent writes may occur between iterations. If a :exc:`Timeout` occurs, the first element of the exception's `args` attribute will be the number of items removed before the exception occurred. Raises :exc:`Timeout` error when database timeout occurs and `retry` is `False` (default). :param bool retry: retry if database timeout occurs (default False) :return: count of rows removed :raises Timeout: if database timeout occurs zHSELECT rowid, filename FROM Cache WHERE rowid > ? ORDER BY rowid LIMIT ?rrr=r)rr>r)rs rclear Cache.clearis-& &  3x""6u"==r cSnSnURU5upU"X5R5n U (d SSS5 U$U[U 5- nU"USRSU 55-5 U Hn XX$'U "U S5 M SSS5 M!,(df  N=f![a [ U5Sef=f)Nrri,c3># UHn[US5v M g7f)rN)rO)rrows rr'Cache._select_delete..s)F##c!f++s)r?rrtrr) rr)rrrr>r4rtrrZr[rs rrCache._select_deletes8 +^^E*nsv,557D +  SY&E)F)F!FFG#*-.B( $+** +%.d * +s.B'!BB'A B B' B$ B''B>c#B# URnSnURRnU(aSnSnOSnSnU"U5R5nU(aUuupOgU"X5v U"XhXU45R5n U (dgU HupU"X5v M M87f)a5Iterate Cache keys in database sort order. >>> cache = Cache() >>> for key in [4, 1, 3, 0, 2]: ... cache[key] = key >>> list(cache.iterkeys()) [0, 1, 2, 3, 4] >>> list(cache.iterkeys(reverse=True)) [4, 3, 2, 1, 0] :param bool reverse: reverse sort order (default False) :return: iterator of Cache keys rz>SELECT key, raw FROM Cache ORDER BY key DESC, raw DESC LIMIT 1zcSELECT key, raw FROM Cache WHERE key = ? AND raw < ? OR key < ? ORDER BY key DESC, raw DESC LIMIT ?z