sg? dZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZdZGddeZdZedZedZdZd Zd Zd Zd Z ddd ddd dddd de jBd Z"dddddZ#dddddddddddddddddZ$Gd d!Z%Gd"d#e%Z&Gd$d%e'Z(Gd&d'e)Z*Gd(d)e)Z+d*Z,Gd+d,Z-y)-z%Core disk and file backed cache API. Nc:|jdz|jzS)zBReturn full name of `func` by adding the module and function name..) __module__ __qualname__)funcs A/var/www/html/venv/lib/python3.12/site-packages/diskcache/core.py full_namer s ??S 4#4#4 44ceZdZdZdZdZy)Constantz%Pretty display of immutable constant.c0tj||fSN)tuple__new__)clsnames rrzConstant.__new__s}}S4'**r cd|dzS)Nz%srselfs r__repr__zConstant.__repr__"sd1g~r N)__name__rr__doc__rrrr 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-usedcTeZdZdZd dZdZdZdZefdZ d dZ d Z eefd Z d Z y)Diskz@Cache key and value serialization for SQLite database and files.c.||_||_||_y)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 directoryr;r<s r__init__z Disk.__init__js$*.r c|d}|j|\}}t|}|tjurt j ||zS|t ur't j |jd|zS|tur||zS|tusJt j tjd||zS)zgCompute portable hash for `key`. :param key: key to hash :return: hash value lutf-8z!d) puttypesqlite3Binaryzlibadler32strencodeintfloatstructpack)rkeymaskdisk_key_ type_disk_keys rhashz Disk.hashvshhsm !X GNN *<<)D0 0 c !<< 89D@ @ c !d? " E) ))<< D( ;>#&, , _C(CF3FFE!9 <<d.B.BCD ))$/F>>&)50 0r c|r(t|tjur t|S|St j t j|S)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 )rBrCrDrXrYloadioBytesIO)rrMraws rr4zDisk.gets< !%cgnn!<5: E# E;;rzz#/ /r cft|}|j}|turt||ks|tur d|cxkrdks n|t ur dt d|fS|turyt||krdt dtj|fS|j||\}}|j|tj|dt|t|dfS|tur[|j||\}}|j|tj|ddt!j"|}|t$|dfS|r^t'j(|j*d} |j||\}}t-| d } |j|| d}|t|dfSt/j0||j2 } t| |krdt4dtj| fS|j||\}}|j|tj| dt| t4|dfS) 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 rTrUrNxbxUTF-8i@r rV)rBr;rGlenrIrJMODE_RAWrXrCrDfilename_writerbrc MODE_BINARYStringIOopgetsize MODE_TEXTftpartialreaditerrYrZr< MODE_PICKLE) rvaluertrM type_valuer;rk full_pathr0readeriteratorr_s rstorez Disk.stores%[ ** 3 3u: #=c!(EH5HHe#he+ + 5 5zM)(D'..*???&*mmC&?#) Irzz%'8$?5z;$>> 3 "&--U"; Hi KK 2;;u#5sG D::i(DHd2 2 ZZ E2F"&--U"; HiFC(H;;y(D9Dh4 4\\%$2F2FGF6{]*+tW^^F-CCC&*mmC&?#) Irzz&'94@6{K4??r Nctj|\}}tddD]}tjt 5t j|ddd t|||}|5d} |D]!} | t| z } |j| #| cdddcSy#1swYRxYw#t $r |dk(rYwxYw#1swYxYw)Nr encodingr!r) rosplitrangeclsuppressOSErrorosmakedirsopenriwrite) rryr{moderfull_dirrPr/writerr0chunks rrlz Disk._writeshhy) !1b\ EW% & H% & iA %(ECJ&DLL'(     & & B;     s*B( B40*C (B1 4CC C c:|tk(r(t|tjur t |S|S|t k(rp|r*t tj|j|dSt tj|j|d5}|jcdddS|tk(rHtj|j|}t |dd5}|jcdddS|tk(rs|It tj|j|d5}tj|cdddStjtj |Sy#1swYyxYw#1swYyxYw#1swYyxYw)aConvert 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 rbNrrhr)rjrBrCrDrXrmrrojoinr:rtrqrvrYrarbrc)rrrkrwrtrzrys rfetchz Disk.fetchsI 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) hexr@Nrrz.val)codecsrHrurandomdecoderorr:)rrMrwhex_namesub_dirrrkrys rrkz Disk.filenames&==B7>>wG''(2A,1 6|f$777D)GGDOOX6 ""r ctj|j|}tj|\}}t j t 5tj|dddt j t 5tj|dddy#1swYAxYw#1swYyxYw)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) rorr:rrrrrremove removedirs)r file_pathryrrPs rrz Disk.remove8sGGDOOY7 hhy) ! [[ ! ! IIi  ![[ ! $ MM( # $ $ ! ! $ $sB( B4(B14B=)rrr)rrrrr>rRrAr4rr|rlrrkrrr rr8r8gsBJ /D*14 0&-1@f06@#'#4$r r8cPeZdZdZdfd ZfdZfdZeffd ZfdZ xZ S)JSONDiskzCCache key and value using JSON serialization with zlib compression.c 4||_t||fi|y)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_levelsuperr>)rr=rkwargs __class__s rr>zJSONDisk.__init__Qs- -f-r ctj|jd}tj||j }t ||SNr@)jsonrZrHrEcompressrrrA)rrM json_bytesr^rs rrAz JSONDisk.putas@ZZ_++G4 }}Z)<)<=w{4  r ct|||}tjt j |j dSr)rr4rloadsrE decompressr)rrMrdr^rs rr4z JSONDisk.getfs6w{3$zz$//$/66w?@@r c|sDtj|jd}tj||j }t ||||S)Nr@rM)rrZrHrErrrr|)rrwrtrMrrs rr|zJSONDisk.storejsJE*11':JMM*d.A.ABEw}UDc}22r ct|||||}|s7tjt j |j d}|Sr)rrrrrErr)rrrkrwrtr^rs rrzJSONDisk.fetchpsAw}T8UD9::dood3::7CDD r )r) rrrrr>rAr4rr|r __classcell__)rs@rrrNs*M. ! A&-3 r rceZdZdZy)TimeoutzDatabase timeout expired.Nrrrrrr rrrws#r rceZdZdZy)UnknownFileWarningz.Warning used by Cache.check for unknown files.Nrrr rrr{s8r rceZdZdZy)EmptyDirWarningz2Warning used by Cache.check for empty directories.Nrrr rrrszargs_to_key..sN%v:MNs rc32K|]}t|ywrrB)rrs rrzargs_to_key..s/3T#Y/sc38K|]\}}t|ywrr)rrPrws rrzargs_to_key..sBEeB)r enumerateitemssorted) baseargsrtypedrrMval sorted_itemsitems ` r args_to_keyrs NyN ND + C +1<<>OxsCS=N#s(OOflln-   D 4KC   u/$///  5B\BB BC JPs B& B&c2eZdZdZddefdZedZedZedZ edZ ed Z ed Z e jd8d Ze jd9d Zd:d ZdZdZdZd;dZddZdZd8dZdZ d?dZd@dZd8dZ dAdZ! dBdZ" dBd Z#dCd!Z$ dDd"Z%dEd#Z&d$Z'd%Z(d8d&Z)dzCache.__init__s LdD) ))   (( =I N MM), MM), # oo'  xx "  Iu-oo "#56??A    $$& $% H C HHS$  !. 5JC~~i( 3e 4 5   #jjl U~~g& GUN  ).v. **, #JCCE U| $ JJsE " # #..* JCBE U| $ JJsO  !$$6 7 @ @ B $/      #   4 45f=   J  (   (   '   '   '  >>  ! ! #    !   A>* L@At K L" ;;%,,.* 46:ooF  / '' "!  "0 s<L&L/ N!N#L,/ N8AM??NN N c|jS)zCache directory.)r:rs rr=zCache.directoryQsr c|jS)z+SQLite connection timeout value in seconds.)rrs rrz Cache.timeoutVs}}r c|jS)zDisk used for serialization.)rrs rrz Cache.disk[szzr c`t|jdd}tj}||k7r!|j ||j_t|jdd}|t jtj|jt|jdx}|j_ d}|j|j}|D]+\}}|j!ds|j#||d-|S|S#t j$$rY|SwxYw)Npidcon)risolation_levelrrFr)getattrrrgetpidrrrCconnectrorr:DBNAMErrexecuterrrr)r local_pidrrselectrrMrws r_conz Cache._con`s  DKK5 iik   JJL!DKKOdkk5$/ ;$+OO0 $% C$++/ =:;;v.779#+=JC~~i0 3e <= s ++    s!DD-,D-c.|jjSr)rrrs rrz Cache._sqlsyy   r c*|jfd}|S)Nc tj} |g|i|S#tj$rK}t|dk7rtj|z }|dkDrtjdYd}~nd}~wwxYwo)Ndatabase is lockedrMbP?)timerCrrGsleep) statementrrstartexcdiffrs r_execute_with_retryz-Cache._sql_retry.._execute_with_retrysIIKE&y:4:6:://&3x#7799;.DbyJJu%% &s $BAA==Br)rrrs @rrzCache._sql_retrysii &#"r c#bK|j|5ddddy#1swYyxYww)a+Context 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 rtransactzCache.transacts-8^^%^ (     s/# /,/c#K|j}g}|jj}tj}|j }||k(rd}n |dd}||_ ||jf|r |j |k(sJd|_|d|D] } | || y#t j$r|rYq|||tdwxYw#t$r$|r |j |k(sJd|_|dwxYww)NFTzBEGIN IMMEDIATECOMMITROLLBACK) rrrr get_identrrCrrappend BaseException) rr!rkr filenames _disk_removetidtxn_idbeginrs rr"zCache._transacts&ii zz(( !!# &=E ,)* E#&DL 'y''' '||s***# H ! '# & ')//, +$X.!t+ , ||s***# J   sHADB)"D$C4)D D)C>DCD-DDctj}|jj|\}} |dn||z} |jj|||\} } } }| || | | |f}|j || 5\}}|d|| fj }|r#|\\}}|||j |||n|j|| |||j||| dddy#1swYyxYw)aSet `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 rrrAr|r"r _row_update _row_insert_cull)rrMrwexpirerttagr!nowdb_keyrd expire_timer0rrkdb_valuecolumnsrcleanuprowsrowid old_filenames rsetz Cache.sets (iikjjnnS) $nd#, )-)9)9%3)9)O&dHhT48D.^^E8 , g- hj  +/(&% %  W5  c7; JJsC )!   s 9A*C,,C5c,|j||dy)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?rrMrws r __setitem__zCache.__setitem__.s e4(r c T|j}|\}}}}} } |d|||d|||| | |f y)NzUPDATE Cache SET store_time = ?, expire_time = ?, access_time = ?, access_count = ?, tag = ?, size = ?, mode = ?, filename = ?, value = ? WHERE rowid = ?rr) rr=r6r:rr8r5r0rrkrws rr1zCache._row_update9sOii8?5 S$h    r cV|j}|\}}}} } } |d|||||d||| | | f y)NzINSERT INTO Cache( key, raw, store_time, expire_time, access_time, access_count, tag, size, mode, filename, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)rr) rrMrdr6r:rr8r5r0rrkrws rr2zCache._row_insertVsRii8?5 S$h  9    r c| |jn|}|dk(ryd}|dz}||||fj}|r8d|dzz} || ||f|D] \} || |t|z}|dk(ryt|jd} | |j |j kry| jd|} || |fj}|r2d| jd|z} || |f|D] \} || yy)NrzcSELECT %s FROM Cache WHERE expire_time IS NOT NULL AND expire_time < ? ORDER BY expire_time LIMIT ?rk%DELETE FROM Cache WHERE rowid IN (%s)r=r5fieldsr6)r'rrirr%volumer&format)rr6rr;limitr'select_expired_templateselect_expiredr<delete_expiredrk select_policyselect_filenamedeletes rr3z Cache._cullmsM(- T__5 ?   , 1:=>C#45>>@ D''1N j 1 2# " ! " #d) #JQ((<(<=fE  DKKMDOO$C '..jc.J?ZM2;;= <$$G$=F  &# " ! " r cHtj}|jj|\}}|dn||z}|j|5\}} |d||fj } | r#| \\} } | | |kDr|d|| f dddydddy#1swYyxYw)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)rrrAr"r) rrMr4r!r6r7rdr8rrPr<r=old_expire_times rtouchz Cache.touchsiikjjnnS) $nd#, ^^E " hsA- hj  .2+)%"*o.CJ$e,    "# "s 9BB!c$tj}|jj|\}} |dn||z} |jj|||\} } } }| || | | |f}|j || 5\}}|d|| fj }|r=|\\}}}|||kDr||  dddy|||j |||n|j|| |||j||| dddy#1swYyxYw)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 = ?FTr0)rrMrwr4rtr5r!r6r7rdr8r0rrkr9r:rr;r<r=r>rSs raddz Cache.adds.2iikjjnnS) $nd#, )-)9)9%3)9)O&dHhT48D ^^E8 , g- hj  <@97%"*o.CH%    %  W5  c7; JJsC )+   s97D9ADDcJtj}|jj|\}}d}|j|5\} } | |||fj } | se| t |||z} d|jj | d|z} |j|||| |j|| | | cdddS| \\}}}} |q||krl| t |||z} d|jj | d|z} |j||| |j|| | | || cdddS| |z } d} t|jd}|| d|j| zz } d | z}| ||| |f| cdddS#1swYyxYw) aIncrement 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 = ?r4z, r6#UPDATE Cache SET %s WHERE rowid = ?) rrrAr"rKeyErrorr|r2r3r1rr%rJ)rrMdeltadefaultr!r6r7rdrrr;r<rwr:r=r8rk update_columnrs rincrz Cache.incrs2iikjjnnS)  )  ^^E ") nsGv}-668D?"3-'%&)9)95c*:*  c7; 3W-) ) 8< 4 2e[(E&;+<?"3-'%&)9)95c*:*  W5 3W-!9) ) < UNE1G+D,@,@A%HM(4-"6"63"6"???:WDF eU+ ,S) ) ) sA:F A2FA FF"c,|j|| ||S)a3Decrement 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_)rrMr\r]r!s rdecrz Cache.decrEs8yyufgu55r c|jj|\}}t|jd} d} |r|r|ddf}n|s|r|df}|jsf| d|j | ||t j fj} | s|S| \\} } }}}} |jj||||}nd}d}|j|5\}}|| ||t j fj} | s|jr|||cdddS| \\} } }}}} |jj||||}|jr||t j }d}| ||| j|z| fddd|r|r fS|r fS|rfSS#t$r|cYSwxYw#t$r"|jr|||cYcdddSwxYw#1swY_xYw)aRetrieve 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 r4SELECT 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"rZrY) rrArr%r#rrrrIOErrorr"rJ)rrMr]rtr8r5r!r7rdr^rr<r=db_expire_timedb_tagrrkr9rw cache_hit cache_missrrPr6rs rr4z Cache.getcsF4jjnnS) '(<(<=eD  <  3d+G CoG=#899Vfc499;%?@IIKDKO H Fe^VT8X  ((x4HK M & J(36FC#=>GGIJ"  J JMUNFD(H# JJ,,T8XtLE?? Niik> ,!5!5#!5!>>I7 J: 3>62 2 >* * 6? "La  4#J"N% J J# J JsJF3AG2! G2-G A G23 GGG/#G2.G//G22G;c\|j|td}|tur t||S)zReturn corresponding value for `key` from cache. :param key: key matching item :return: corresponding value :raises KeyError: if key is not found Tr]r!r4rr[rAs r __getitem__zCache.__getitem__s.fD9 F?3-  r c^|j|td|}|tur t||S)aReturn 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)r]rtr!rk)rrMr!handles rrtz Cache.reads1#vDF V 3-  r c|j}|jj|\}}d}||||tjfj }t |S)zReturn `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 > ?))rrrArrbool)rrMrr7rdrr<s r __contains__zCache.__contains__s[iijjnnS)  <  6FC56??ADzr c|jj|\}}d}|r|r|ddf}n|s|r|df}|j|5\} } | |||tjfj } | s |cdddS| \\} } }}}}| d| fddd |jj d} ||jj| |r|r| fS|r| fS|r|fS|S#1swY^xYw#t $r#|cY|jj|SSwxYw#|jj|wwxYw)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 rcN!DELETE FROM Cache WHERE rowid = ?F)rrAr"rrrrdr)rrMr]r8r5r!r7rdrrrPr<r=rerfrrkr9rws rrz Cache.pops,jjnnS)  <  3tT)G CtmG ^^E " ?hsAvTYY[9:CCED  ? ? LP H Fe^VT8X 3eX > ? ,JJ$$T8XuEE # !!(+ 3.&0 0 .( ( &= L5 ? ? N# !!(+$  # !!(+$s63C3C3C?3C<? D+ D.*D++D.. ETc8|jj|\}}|j|5\}}|d||tjfj }|s t ||\\}} |d|f||  dddy#1swYyxYw)aDelete 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 > ?)rsNT)rrAr"rrr[) rrMr!r7rdrr;r<r=rks r __delitem__zCache.__delitem__8sjjnnS)  ^^E " nsG@diik*  hj sm##' eX 3eX > H    s ABBcH |j||S#t$rYywxYw)aDelete 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)rur[)rrMr!s rrQz Cache.deleteWs/ ##Cu#5 5  s  !!cf|d}d} n |dz}|dz} tj} d} |dn| |z} |jj||\} }}}| || |||f}ddd }d ||z}|j||5\}}|||| | fj }|rC|\\}|!t ||j d d zd}n|}|d k(r|d z }n|dk(sJ|d z}nd}|dj||}n|}|j|| | ||j| |||cdddS#1swYyxYw)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-rr}r~l@$z {0}-{1:015d}) rrr|r"rrIrfindrJr2r3)rrwrsider4rtr5r!min_keymax_keyr6rdr8r0rrkr9r:orderrrr;r<rMnumr7s rpushz Cache.pushksh >G%G11G11Giik$nd#, )-)9)9%)F&dHhT48D%0 ' $K  ^^E8 , gv#67@@BD #%c399S>A#5"89:CC6>1HC7?*?1HC%!'..vs;   VS#w 7 JJsC )7   s 9B$D''D0c|d}d}n |dz}|dz}ddd} d | |z} |r|r|ddf}n|s|r|df} |j|5\} } | | ||fj} | s |cdddS| \\}}}}}}}| d |f| |tjkr | |n dddn ddd |jj |||d } ||jj | |r |r||f||fS|r||f|fS|r||f|fS||fS#1swYhxYw#t $r#Y||jj |wxYw#||jj |wwxYw) a,Pull 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 Nrrxryrzr|r{r~r}SELECT rowid, key, expire_time, tag, mode, filename, value FROM Cache WHERE ? < key AND key < ? AND raw = 1 ORDER BY key %s LIMIT 1rsF)r"rrrrrdrrrr]rr8r5r!rrrrrr;r<r=rM db_expirerfrrr9rws rpullz Cache.pulls| >G%G11G11G0 ' $K  3tT)G CtmG^^E*nsGv'9:CCED& MYdH;eXF ,TYY[1H &$ , ((tXuE #JJ%%d+  3<F2 2 <* * <' ': E& #JJ%%d+  #JJ%%d+$s6 D.9D;D$D!$ E-EEE E3c(|d}d}n |dz}|dz}ddd} d | |z} |r|r|ddf}n|s|r|df} |j|5\} } | | ||fj} | s |cdddS| \\}}}}}}}|*|tjkr| d |f| |n dddn ddd |jj |||d } |r |r||f||fS|r||f|fS|r||f|fS||fS#1swYIxYw#t $rYwxYw) 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 Nrrxryrzr|r{rrrsF)r"rrrrrdrs rpeekz Cache.peekFst >G%G11G11G0 ' $K  3tT)G CtmG^^E*nsGv'9:CCED& MYdH!,TYY[1H?%J &"  ((tXuE  3<F2 2 <* * <' ': =$  s$ C9.9C9;D9D DDc d}d||z} |j|5\}}||j} | s td| \\} } } } }}}}| *| tjkr|d| f||n dddn ddd|jj | | } |jj |||d} |r |r||f| |fS|r||f| fS|r||f|fS||fS#1swYexYw#t$rYwxYw)aPeek 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 )r|r{zdSELECT rowid, key, raw, expire_time, tag, mode, filename, value FROM Cache ORDER BY rowid %s LIMIT 1zdictionary is emptyNrsF)r"rr[rrr4rrd)rlastr8r5r!rrrr;r<r=r7rdrrfrrr9rMrws rpeekitemzCache.peekitemse6  4 $K ^^E*nsGv;//1D&'<==  !"%"  $!,TYY[1H?%J /*&+4**..-C  ((tXuE  3<F2 2 <* * <' ': S:  sA!C-/C9-C69 DDcRtr tdfd}|S)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 tfnftjfd fd}|_S)z3Decorator created by memoize() for callable `func`.cj|i|}j|td}|tur%|i|}dkDrj||d|S)z:Wrapper for callable to cache arguments and return values.Trjr)r5r!) __cache_key__r4rr?) rrrMr_r4rrr5wrappers rrz1Cache.memoize..decorator..wrapperLsm,g++T.decorator..__cache_key__Ys"4vufEEr )r rrwrapsr) rrrrr4rrrr5rs ` @@r decoratorz Cache.memoize..decoratorHsF)-IdO%D7D XXd^   F%2G !Nr )callabler)rrrr4r5rrs`````` rmemoizez Cache.memoizes+D D>56 6  0r c tjd5}|j}|dj}t |dk7s |dddk7r|D]\}tj ||r|d|j |5\}}t}d} || j}|D]\} } } tj|j| } |j| tj| rGtj| }| |k7r,d }| || f}tj ||z|r |d || ftj d | z|s|d | ftj|jD]~\}}}|D cgc]} tj|| }} t||z }|D]B} t | vr d | z}tj |t"|s.tj$| Dtj|jD]C\}}}|r |r d|z}tj |t&|s/tj(|E|j+d|dj\\}|j,|k7r3d}tj ||j,|fz|r |d|df|j+dd}||j\\} |j.| k7r3d}tj ||j.| fz|r |d| dfddd|cdddScc} w#1swYxYw#1swYyxYw)a,Check 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_checkrrokVACUUMzBSELECT rowid, size, filename FROM Cache WHERE filename IS NOT NULLzwrong file size: %s, %d != %dz)UPDATE Cache SET size = ? WHERE rowid = ?zfile not found: %srszunknown file: %szempty directory: %sr/zSELECT COUNT(key) FROM Cachez,Settings.count != COUNT(Cache.key); %d != %d+UPDATE Settings SET value = ? WHERE key = ?r0z(SELECT COALESCE(SUM(size), 0) FROM Cachez*Settings.size != SUM(Cache.size); %d != %dz*UPDATE Settings SET value = ? WHERE key =?N)warningscatch_warningsrrriwarnr"r?rorr:rVexistsrprwalkr rrrrmdirrr/r0)rfixr!warnsrr<messagerPr*rr=r0rkry real_sizerdirpathfilespathsrdirsr/ select_sizes rcheckz Cache.checkbsf* $ $D 1m U))C/099;D4yA~at!3"&+JWMM'*+H &] (3 E 2 6{++--1K)E4 " BIMM),yy+$&JJy$9 9,&EG#,i#=D$MM'D.9" #%7%.$6!" !MM"6"BC?%J1K8*,)A 1%GQHMNHRWWWh7NENJ2E%*1 !Y.$"4y"@ g/ABIIi01 1 -/GGDOO,D.(GT5 E"7'"A g?HHW- . 7#!"@AJJL %::&LGMM'TZZ,?"?@I"G, 6"H  -668 $99$JGMM'TYY,="=>H!6Nu] ~[m m nOS] ] m m sWA5M4 CM(#6M(M# 6?M(6AM(8M(;!M(C3M( M4#M((M1 -M44M=cP|j}|d|jddy)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$rNrrrrs rrzCache.create_tag_indexs$ii MN ;"r cP|j}|d|jddy)z`Drop tag index on cache database. :raises Timeout: if database timeout occurs z$DROP INDEX IF EXISTS Cache_tag_rowidr$rNrrs rrzCache.drop_tag_indexs$ ii 23 ;"r c:d}|ddg}|j||d|S)aRemove 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)rr5r!rrs revictz Cache.evicts3( &  Q}""641E"JJr cfd}d|xstjdg}|j||d|S)aRemove 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!)rr)rr6r!rrs rr4z Cache.expires?( ,  3%$))+s+""641E"JJr cjtj}|j|}t|jd}|y|j d|} |j |j kDr|j|5\}}||dj}|s ddd|S|t|z }d|j d|z} || d|D] \} ||  ddd|j |j kDr|S#1swY)xYw#t$r t|dwxYw) aCull 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 r5NrrkrG)r!rFr=) rr4rr%rJrIr&r"rrir) rr!r6r/rOrPrr;r<rQrks rr5z Cache.cull2sF$iik C ((<(<=fE  '..jc.J +++-$//1^^E**nsG6??AD *$ SY&E?'..g3.GH&'+* )**++-$//1& %** +%.d * +s0.DDD)>D(%DDDD2c6d}ddg}|j|||S)aRemove 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!rrs rclearz Cache.clearis/& &  3x""64u"==r cpd}d} |j|5\}} |||j} | s ddd|S|t| z }||djd| Dz| D]} | |||<| | d ddd#1swY xYw#t$r t |dwxYw)NrrF,c38K|]}t|dyw)rN)rG)rrows rrz'Cache._select_delete..s)F##c!f+)Fr)r"rrirr) rrrrrr!r/rQrr;r<rs rrzCache._select_deletes8 +^^E* )nsGvt,557D )  SY&E)F)F!FFG#)*-i.YB() ) ) ) +%.d * +s.BBBA B BBBB5c#*K|j}d}|jj}|rd}d}nd}d}||j}|r|\\}} ny|||  |||| ||fj} | sy| D]\}} ||| 4w)aIterate 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