iI
d Z ddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZd Z G d de ZdZ ed Z ed ZdZ d Z d
Z d Z d Z ddd
ddd dddd de
j! d Z"dddddZ#ddddddddddddd d d dd Z$ G d d! Z% G d" d#e% Z& G d$ d%e' Z( G d& d'e) Z* G d( d)e) Z+d* Z, G d+ d, Z-dS )-z%Core disk and file backed cache API.
Nc & | j dz | j z S )zBReturn full name of `func` by adding the module and function name..)
__module__ __qualname__)funcs n/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/diskcache/core.py full_namer s ?S 4#4 44 c e Zd ZdZd Zd ZdS )Constantz%Pretty display of immutable constant.c : t | |f S N)tuple__new__)clsnames r r zConstant.__new__ s }}S4'***r
c d| d z S )Nz%sr selfs r __repr__zConstant.__repr__" s d1g~ r
N)__name__r r __doc__r r r r
r r r s8 //+ + + r
r zcache.dbENOVALUNKNOWN least-recently-storedi @
i wali i )
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)z access_count = access_count + 1z8SELECT {fields} FROM Cache ORDER BY access_count LIMIT ?)noner zleast-recently-usedzleast-frequently-usedc V e Zd ZdZd
dZd Zd Zd ZefdZ dd Z
d
Z eefd Z d Z
dS )Diskz@Cache key and value serialization for SQLite database and files.r c 0 || _ || _ || _ dS )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__j s! $ * . r
c d}| | \ }}t | }|t j u rt j | |z S |t u r*t j | d |z S |t u r||z S |t u sJ t j t j d| |z S )zgCompute portable hash for `key`.
:param key: key to hash
:return: hash value
l utf-8z!d) puttypesqlite3Binaryzlibadler32strencodeintfloatstructpack)r keymaskdisk_key_
type_disk_keys r hashz Disk.hashv s hhsmm ! X
GN * *<))D0 0
c
!
!< 8 899D@ @
c
!
!d? " E))))< D( ; ;<#&&, ,
__C(CFFFF3FFFFFE!!9 <d.BCCCD )$//F>&))50 0r
c |r,t | t j u rt | n|S t 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
)rB rC rD rX rY loadioBytesIO)r rM raws r r4 zDisk.get sF 0!%cgn!>
3
"&--U";"; Hi KK 2;u#5#5sG D D D:i((DHd2 2
@Z
E22F"&--U";"; HiFC((H;;y(D99Dh4 4\%$2FGGGF6{{]**+tW^F-C-CCC&*mmC&?&?#) Irz&'9'94@@@6{{K4??r
Nc t j | \ }}t dd D ]}t j t
5 t
j | d d d n # 1 swxY w Y t ||| }n# t
$ r
|dk r Y nw xY w|5 d} |D ])}
| t |
z
} |
|
*| cd d d c S # 1 swxY w Y d S )Nr encodingr! r ) ro splitrangeclsuppressOSErrorosmakedirsopenri write) r ry r{ moder full_dirrP r/ writerr0 chunks r rl z Disk._write s hy)) !1b\\ EW%%
&
& H%%%
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
iAAA
B;;
% ( (ECJJ&DLL''''
s6 A$$A( +A( 0BBB 0CC "C c f |t k r,t | t j u rt | n|S |t
k r|r(t
t j | j | d S t
t j | j | d 5 }|
cddd S # 1 swxY w Y dS |t k rZt j | j | }t
|dd 5 }|
cddd S # 1 swxY w Y dS |t k r~|Vt
t j | j | d 5 }t j | cddd S # 1 swxY w Y dS t j t j | S dS )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
rbNrrh r )rj rB rC rD rX rm r ro joinr: rt rq rv rY ra rb rc )r r rk rw rt rz ry s r fetchz
Disk.fetch sK 8 #';;'.#@#@5<< >EEE"'$/8<>FFc @ t j t j d d d }t j |dd |dd }|dd dz }t j || }t j | j | }||fS )a Return filename and full-path tuple for file storage.
Filename will be a randomly generated 28 character hexadecimal string
with ".val" suffixed. Two levels of sub-directories will be used to
reduce the size of directories. On older filesystems, lookups in
directories with many files may be slow.
The default implementation ignores the `key` and `value` parameters.
In some scenarios, for example :meth:`Cache.push
`, 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@ Nr r z.val)codecsrH r urandomdecodero r r: )r rM rw hex_namesub_dirr rk ry s r rk z
Disk.filename s & =B 77>>wGG'(2A2,1
66|f$77D))GDOX66 ""r
c ~ t j | j | }t j | \ }}t j t 5 t j | ddd n # 1 swxY w Y t j t 5 t j | ddd dS # 1 swxY w Y dS )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)
ro r r: r r r r r remove
removedirs)r file_pathry r rP s r r z Disk.remove8 s' GDOY77 hy)) !
[
!
! ! ! Ii ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! [
!
! $ $ M( # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $s$ A,,A03A0B22B69B6)r r r )r r r r r> rR rA r4 r r| rl r rk r r r
r r8 r8 g s JJ
/
/
/
/D D D*1 1 14 0 0 0 &- 1@ 1@ 1@ 1@f 0 6 6 6@ #' # # # #4$ $ $ $ $r
r8 c P e Zd ZdZd fd Z fdZ fdZef fd Z fdZ xZ
S ) JSONDiskzCCache key and value using JSON serialization with zlib compression.r c J || _ t j |fi | dS )a Initialize 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> )r r= r kwargs __class__s r r> zJSONDisk.__init__Q s2 ---f-----r
c t j | d }t j || j }t
| S Nr@ )jsonrZ rH rE compressr r rA )r rM
json_bytesr^ r s r rA z JSONDisk.puta sH Z__++G44
}Z)<==ww{{4 r
c t || }t j t j | d S r )r r4 r loadsrE
decompressr )r rM rd r^ r s r r4 z JSONDisk.getf sB ww{{3$$z$/$//66w??@@@r
c |sAt j | d }t j || j }t
||| S )Nr@ rM )r rZ rH rE r r r r| )r rw rt rM r r s r r| zJSONDisk.storej sY C E**11'::JM*d.ABBEww}}UDc}222r
c t |||| }|s9t j t j | d }|S r )r r r r rE r r )r r rk rw rt r^ r s r r zJSONDisk.fetchp sS ww}}T8UD99 E:dod 3 3 : :7 C CDDD r
)r ) r r r r r> rA r4 r r| r
__classcell__)r s @r r r N s MM. . . . . . ! ! ! ! !
A A A A A &- 3 3 3 3 3 3 r
r c e Zd ZdZdS )TimeoutzDatabase timeout expired.Nr r r r r r
r r r w s ####r
r c e Zd ZdZdS )UnknownFileWarningz.Warning used by Cache.check for unknown files.Nr r r
r r r { s 8888r
r c e Zd ZdZdS )EmptyDirWarningz2Warning used by Cache.check for empty directories.Nr r r
r r r s <<<z args_to_key.. s1 NN%v:M:M:M:M:M:MNNr
r c $ i | ] \ }}|v ||
S r r )r rM valr s r
z args_to_key.. s) OOOxsCS=N=N#s=N=N=Nr
c 3 4 K | ]}t | V d S r rB )r r s r r z args_to_key.. s( //3T#YY//////r
c 3 : K | ]\ }}t | V d S r r )r rP rw s r r z args_to_key.. s, BBEeBBBBBBr
)r enumerateitemssorted)baseargsr typedr rM sorted_itemsitems ` r args_to_keyr s NNNNyNNN N ND
+
C
OOOO6<<>>OOO fllnn-- D 4KCC C u//$////// C 5BB\BBBBB BC Jr
c P e Zd ZdZddefdZed Zed Zed Z ed Z
ed Z ed
Z e
j d?d Ze
j d@d
ZdAdZd Zd Zd ZdBdZdCdZdAdZdDdZdDdZ dEdZd Zd?dZ d Z dFd Z dGd Z d?d Z dHd"Z! dId%Z" dId&Z#dJd'Z$ dKd)Z%dLd*Z&d+ Z'd, Z(d?d-Z)dCd.Z*d?d/Z+d?d0Z, dMd1Z-d?d2Z.dGd3Z/d4 Z0d5 Z1dNd6Z2d7 Z3d8 Z4d9 Z5d: Z6d; Z7d< Z8d= Z9e:d fd>Z;dS )OCachezDisk and file backed cache.N< c t |t sJ n%# t t f$ r t d dw xY w|t j d }t | }t j | }t j
| }|| _ d| _ t j | _ d| _ t j | sa t% j |d nJ# t( $ r=}|j t* j k r t/ |j d| j z dY d}~nd}~ww xY w| j } t3 |d }n# t6 j $ r i }Y nw xY wt: }| | | | t@ D ]} |! | d tE |# D ]2\ } }
| $ d r| % | |
d
3 |d d
|# D } ||fi | | _& |# D ]+\ } }
d} || | |
f | % | |
,t@ # D ]*\ } }
d} || | |
f | % | + |d \ \ | _' |d |d |d tP | j) d } | || |d |d |d |d |d | j* r| + n| , | - || _ | j. dS )zInitialize cache instance.
:param str directory: cache directory
:param float timeout: SQLite connection timeout
:param disk: Disk type or subclass for serialization
:param settings: any of DEFAULT_SETTINGS
z!disk must subclass diskcache.DiskNz
diskcache-)prefixr i z. sH
U~~g&&
GU
r
z-INSERT OR REPLACE INTO Settings VALUES (?, ?)z,INSERT OR IGNORE INTO Settings VALUES (?, ?)zPRAGMA page_sizezCREATE TABLE IF NOT EXISTS Cache ( rowid INTEGER PRIMARY KEY, key BLOB, raw INTEGER, store_time REAL, expire_time REAL, access_time REAL, access_count INTEGER DEFAULT 0, tag BLOB, size INTEGER DEFAULT 0, mode INTEGER DEFAULT 0, filename TEXT, value BLOB)zBCREATE UNIQUE INDEX IF NOT EXISTS Cache_key_raw ON Cache(key, raw)zCCREATE INDEX IF NOT EXISTS Cache_expire_time ON Cache (expire_time)r3 zCREATE TRIGGER IF NOT EXISTS Settings_count_insert AFTER INSERT ON Cache FOR EACH ROW BEGIN UPDATE Settings SET value = value + 1 WHERE key = "count"; ENDzCREATE TRIGGER IF NOT EXISTS Settings_count_delete AFTER DELETE ON Cache FOR EACH ROW BEGIN UPDATE Settings SET value = value - 1 WHERE key = "count"; ENDzCREATE TRIGGER IF NOT EXISTS Settings_size_insert AFTER INSERT ON Cache FOR EACH ROW BEGIN UPDATE Settings SET value = value + NEW.size WHERE key = "size"; ENDzCREATE TRIGGER IF NOT EXISTS Settings_size_update AFTER UPDATE ON Cache FOR EACH ROW BEGIN UPDATE Settings SET value = value + NEW.size - OLD.size WHERE key = "size"; ENDzCREATE TRIGGER IF NOT EXISTS Settings_size_delete AFTER DELETE ON Cache FOR EACH ROW BEGIN UPDATE Settings SET value = value - OLD.size WHERE key = "size"; END)/
issubclassr8 TypeErrorAssertionError
ValueErrortempfilemkdtemprG ro
expanduser
expandvarsr: _timeout threadinglocal_local_txn_idisdirr r r errnoEEXISTEnvironmentError
_sql_retrydictfetchallrC OperationalErrorDEFAULT_SETTINGScopyr METADATApopr r r reset_disk
_page_sizeEVICTION_POLICYr% r$ create_tag_indexdrop_tag_indexclose_sql)
r r= timeoutdisksettingserrorsqlcurrent_settingssetsrM rw r querys
r r> zCache.__init__ s L dD)) ) )) )>* L L L @AAt K L ( ===I NN M),, M),, #
o'' x ""
Iu----
;%,..* 46:oF /....
o " #566??AA ' " " " ! " $$&& $%%% H C HHS$ ! .. 5 5JC~~i((
5
3e
444
"jjll
T)..v..
**,, # #JCCE CU| $ $ $ JJsE " " " ""..** JCBE CU| $ $ $ JJsOOOO #$6 7 7 @ @ B B $/
#
45f= CJJJ
(
(
'
'
'
> " ! ! # # # # ! ! !
s2 "<C% %
D,/3D''D,7*E" "E65E6c | j S )zCache directory.)r: r s r r= zCache.directoryQ s r
c | j S )z+SQLite connection timeout value in seconds.)r r s r r z
Cache.timeoutV s } r
c | j S )z Disk used for serialization.)r r s r r z
Cache.disk[ s zr
c H t | j dd }t j }||k r | || j _ t | j dd }|t
j t j | j
t | j d x}| j _
d}| | }|D ]2\ }}| d r| ||d 3n# t j $ r Y nw xY w|S )Npidcon)r isolation_levelr r Fr )getattrr r getpidr r rC connectro r r: DBNAMEr r
executer r r r )r local_pidr r
selectr rM rw s r _conz
Cache._con` s/
DK55 ikk JJLLL !DKOdk5$// ;$+O00
$% % %
C$+/
=: ;;v..7799 #+ = =JC~~i00 =
3e
<<<= +
s .)D
D D c | j j S r )r r r s r r z
Cache._sql s
y r
c | j fd}|S )Nc
t j } | g|R i |S # t j $ rO}t | dk r t j |z
}|dk r t j d Y d }~nd }~ww xY wo)NTdatabase is lockedr MbP?)timerC r rG sleep) statementr r startexcdiffr s r _execute_with_retryz-Cache._sql_retry.._execute_with_retry s IKKE
&& 3y:4:::6::: / & & &3xx#777 9;;.Dbyy Ju%%%%%%%%
&
&s # BAA<<Br )r r r s @r r zCache._sql_retry s+ i & & & & & #"r
Fc # p K | | 5 dV ddd dS # 1 swxY w Y dS )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)r r# s r transactzCache.transact s 8 ^^%^
(
( EEE s +//c # K | j }g }| j j }t j }| j }||k rd}nC |d d}|| _ n,# t j $ r |rY *| || t d w xY w ||j fV |r | j |k sJ d | _ |d |D ]} | || d S # t $ r# |r | j |k sJ d | _ |d w xY w)NFTzBEGIN IMMEDIATECOMMITROLLBACK) r r r r get_identr rC r r append
BaseException)
r r# rk r filenames _disk_removetidtxn_idbeginr s
r r$ zCache._transact s} i z( !## &==EE
,
,C)*** E#&DL / , , , ! +$ X...!t+ , 'y'' ' ' '
|s**** # H
!
'
'# L&&&
'
'
|s**** # J s A A;%A;? B? ?-C,c ( t j }| j | \ }} |dn||z }
| j ||| \ } } }
}|
|| | |
|f}| ||
5 \ }} |d|| f }|r*|\ \ }} || | ||| n| || || | ||| ddd dS # 1 swxY w Y dS )a Set `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
Nr z;SELECT rowid, filename FROM Cache WHERE key = ? AND raw = ?T r r rA r| r$ r _row_update _row_insert_cull)r rM rw expirert tagr# nowdb_keyrd expire_timer0 r rk db_valuecolumnsr cleanuprowsrowid old_filenames r setz Cache.set s ( ikkjnnS)) $ndd#, )-)9)9%3)9)O)O&dHh T48D. ^^E8
,
, g3-
hjj
<+/(&% %%% W5555 c7;;; JJsC ) ) )! s :B DD D c 6 | ||d dS )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)rA r rM rw s r __setitem__zCache.__setitem__. s"
e4(((((r
c
R | j }|\ }}}}} }
|d|||d|||| |
|f
d S )NzUPDATE Cache SET store_time = ?, expire_time = ?, access_time = ?, access_count = ?, tag = ?, size = ?, mode = ?, filename = ?, value = ? WHERE rowid = ?r r ) r r? r8 r< r r: r7 r0 r rk rw s r r3 zCache._row_update9 sc i8?5 S$h
r
c T | j }|\ }}}} }
} |d|||||d||| |
| f d S )NzINSERT INTO Cache( key, raw, store_time, expire_time, access_time, access_count, tag, size, mode, filename, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)r r ) r rM rd r8 r< r r: r7 r0 r rk rw s r r4 zCache._row_insertV sf i8?5 S$h
9
r
c Z || j n|}|dk rd S d}|dz } ||||f }|rBd|dz z } || ||f |D ]\ }
||
|t | z }|dk rd S t | j d } | | | j k rd S | d| } || |f }|r9d| d| z }
||
|f |D ]\ }
||
d S d S )Nr zcSELECT %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? r5 fieldsr8 )r' r ri r r% volumer& format)r r8 r r= limitr' select_expired_templateselect_expiredr> delete_expiredrk
select_policyselect_filenamedeletes r r5 z Cache._cullm s (-
T__5
?? F
, 1:=s>C#455>>@@ D''1 N
Cj 1 2 2 2 #
"
" !!!! #d)) #JQ ((<=fE
DKKMMDO$C$C F'..jc.JJs?ZM22;;== "< $$G$==F
C
& & & #
"
" !!!! " "
"
"r
c r t j }| j | \ }}|dn||z }| | 5 \ }} |d||f }
|
r+|
\ \ } } | | |k r |d|| f ddd dS ddd n # 1 swxY w Y dS )a Touch `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)r r rA r$ r )
r rM r6 r# r8 r9 rd r: r rP r> r? old_expire_times
r touchz Cache.touch sD ikkjnnS)) $ndd#,
^^E
"
" hsA3-
hjj
.2+)% "*o.C.CCJ$e, " us AB,,B03B0c l t j }| j | \ }} |dn||z }
| j ||| \ } } }
}|
|| | |
|f}| ||
5 \ }} |d|| f }|rL|\ \ }}}|||k r ||
ddd dS || | ||| n| || || | ||| ddd dS # 1 swxY w Y dS )a Add `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
Nr zHSELECT rowid, filename, expire_time FROM Cache WHERE key = ? AND raw = ?FTr2 )r rM rw r6 rt r7 r# r8 r9 rd r: r0 r rk r; r< r r= r> r? r@ rU s r addz Cache.add s 2 ikkjnnS)) $ndd#, )-)9)9%3)9)O)O&dHh T48D
^^E8
,
, g3-
hjj
<<@97% "*o.C.CGH%%% %%% W5555 c7;;; JJsC ) ) )+ s :AD) AD))D-0D-r r c t j }| j | \ }}d}| | 5 \ } }
| |||f } | ss|t | ||z } d| j | d| z }
| ||||
| || |
| cddd S | \ \ }}}} |||k r}|t | ||z } d| j | d| z }
| |||
| || |
|
| | cddd S | |z
} d}
t | j d }| |
d| | z z
}
d
|
z } | ||| |f | cddd S # 1 swxY w Y dS ) a Increment 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 = ?NNNFr zstore_time = ?, value = ?r4 z, r8 #UPDATE Cache SET %s WHERE rowid = ?)
r r rA r$ r KeyErrorr| r4 r5 r3 r r% rL )r rM deltadefaultr# r8 r9 rd r r r= r> rw r< r? r: rk
update_columnr s r incrz
Cache.incr s 2 ikkjnnS))
)
^^E
"
" ) nsG3v}--6688D
?"3--' %&)9)95c *: * * c7;;;
3W--- ) ) ) ) ) ) ) ) 8< 4
2e[(E&;+<+<?"3--' %&)9)95c *: * * W555
3W---!!! 9) ) ) ) ) ) ) ) <
UNE1G +D,@ A% HM (4-"6"63"6"?"???:WDF CeU+ , , ,S) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) s! B G!BG/AGGGc 4 | || || S )a3 Decrement 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
)ra )r rM r^ r_ r# s r decrz
Cache.decrE s 8 yyufgu555r
c , | j | \ }}t | j d } d}
|r|r|ddf}n|s|r|df}| j s| }| |
||t
j f } | s|S | \ \ } }
}}}} | j |||| }nA# t $ r |cY S w xY wd}d}|
| 5 \ }} ||
||t
j f } | s | j r || |cddd S | \ \ } }
}}}} | j |||| }n0# t $ r# | j r || |cY cddd S w xY w| j r || t
j }d}| $ ||| | z | f ddd n # 1 swxY w Y |r|r||
|fS |r||
fS |r||fS |S )a Retrieve 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
r4 SELECT 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"r\ r[ ) r rA r r% r# r r r r IOErrorr$ rL )r rM r_ rt r: r7 r# r9 rd r` r r> r? db_expire_timedb_tagr rk r; rw cache_hit
cache_missr rP r8 r s r r4 z Cache.getc se 4 jnnS)) '(<=eD
< &3 & d+GG
&C & oG 3 J=#8 99Vfc49;;%?@@IIKKD
KO H
Fe^VT8X
((x4HH
K
M
&&
J(3s6FC#=>>GGII # (J"
J
J
J
J
J
J
J
J MUNFD(H# J , ,T8Xt L LEE # # # (J"NN%
J
J
J
J
J
J
J
J # ? #C NNNikk> ,C !5!5#!5!>!>>III7
J
J
J
J
J
J
J
J
J
J
J
J
J
J
J: 3 >62 2
>* *
6? "LsP B> > C
C
)A G4 G4
E+*G4+ F G4FAG44G8;G8c p | |t d }|t u rt | |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# r4 r r] rC s r __getitem__zCache.__getitem__ s5 fD99 F??3-- r
c r | |t d| }|t u rt | |S )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)r_ rt r# rm )r rM r# handles r rt z
Cache.read s9 #vDFF V 3--
r
c | j }| j | \ }}d} ||||t j f }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 > ?))r r rA r r bool)r rM r r9 rd r r> s r __contains__zCache.__contains__ sd ijnnS))
< s6FC566??AADzzr
c | j | \ }}d}|r|r|ddf}n|s|r|df}| | 5 \ } }
| |||t j f } | s|cddd S | \ \ } }
}}}} | d| f ddd n # 1 swxY w Y | j |||d }n/# t $ r" |cY || j | S S w xY w || j | n"# || j | w w xY w|r|r||
|fS |r||
fS |r||fS |S )a Remove 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
re N!DELETE FROM Cache WHERE rowid = ?F)r rA r$ r r r rf r )r rM r_ r: r7 r# r9 rd r r rP r> r? rg rh r rk r; rw s r r z Cache.pop sM , jnnS))
< $3 $ tT)GG
$C $ tmG
^^E
"
" ?hsA3vTY[[ 9::CCEED
? ? ? ? ? ? ? ? LP H
Fe^VT8X C3eX > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ,J$$T8XuEEEE NN#
!!(++++ $
#
!!(+++ #
!!(++++ $ 3 .&0 0
.( (
&= LsB 9B1
B11B58B5= C D( D'D( DD( ( ETc h | j | \ }}| | 5 \ }} |d||t j f }|st | |\ \ }} |d|f || ddd dS # 1 swxY w Y dS )a Delete 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 > ?)ru NT)r rA r$ r r r] )
r rM r# r9 rd r r= r> r? rk s
r __delitem__zCache.__delitem__8 s jnnS))
^^E
"
" nsG3@ dikk*
hjj
$ smm##'
eX C3eX > > > GH s A'B''B+.B+c T | || S # t $ r Y dS w xY w)a Delete 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)rw r] )r rM r# s r rS z Cache.deleteW sB ##Cu#55 5 55 s
''backc |d}d} n
|dz }|dz } t j }
d} |dn|
|z } | j || \ }
}}}| ||
|||f}ddd }d
|| z }| || 5 \ }} |||| | f }|rR|\ \ }|.t || d d z d }n|}|d
k r|d z
}n|dk sJ |d z }nd}|d || }n|}| || |
| | |
|| |cddd S # 1 swxY w Y dS )a Push `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
Nr I5 -000000000000000-999999999999999TDESCASC)ry frontzSSELECT key FROM Cache WHERE ? < key AND key < ? AND raw = ? ORDER BY key %s LIMIT 1-r ry r l @$ z {0}-{1:015d})
r r r| r$ r rI rfindrL r4 r5 )r rw r sider6 rt r7 r# min_keymax_keyr8 rd r: r0 r rk r; r< orderr r r= r> rM numr9 s r pushz
Cache.pushk s h >G%GG 11G 11Gikk $ndd#, )-)9)9%)F)F&dHh T48D %00
'
$K ^^E8
,
, g3v# 677@@BBD
& #% c399S>>A#5"8"8 9::CC C6>>1HCC 7????1HCC%!'..vs;; VS#w 7 7 7 JJsC ) ) )7 s >CEEErZ r c |d}d}n
|dz }|dz }ddd} d | | z }
|r|r|ddf}n|s|r|df} | | 5 \ } } | |
||f }
|
s|cddd S |
\ \ }}}}}}} | d |f |#|t j k r | | n
ddd n ddd n # 1 swxY w Y | j |||d }n,# t
$ r Y || j | w xY w || j | n"# || j | w w xY w |r |r||f||fS |r||f|fS |r||f|fS ||fS )
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
Nr r{ r| r} r r~ r ry SELECT rowid, key, expire_time, tag, mode, filename, value FROM Cache WHERE ? < key AND key < ? AND raw = 1 ORDER BY key %s LIMIT 1Tru F)r$ r r r r rf r r r r_ r r: r7 r# r r r r r r= r> r? rM db_expirerh r r r; rw s r pullz
Cache.pull s | >G%GG 11G 11G 00
'
$K $3 $ tT)GG
$C $ tmG
^^E** nsG 3v'9::CCEED ' & MYdH C;eXFFF ,TY[[1H1H
&
$
,
((tXuEE
#J%%d+++
#J%%d+++ #J%%d++++ $ 3 <F2 2
<* *
<' ': sB 'C??CC C$ D E
D+ E *D++E E+c d |d}d}n
|dz }|dz }ddd} d | | z }
|r|r|ddf}n|s|r|df} | | 5 \ } } | |
||f }
|
s|cddd S |
\ \ }}}}}}}|0|t j k r | d |f | | n
ddd n ddd n # 1 swxY w Y | j |||d }n# t
$ r Y w xY w |r |r||f||fS |r||f|fS |r||f|fS ||fS )
a Peek 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
Nr r{ r| r} r r~ r r Tru F)r$ r r r r rf r s r peekz
Cache.peekF sr t >G%GG 11G 11G 00
'
$K $3 $ tT)GG
$C $ tmG
^^E** nsG 3v'9::CCEED ' & MYdH !,TY[[1H1H ?%JJJ
&
"
((tXuEE
3 <F2 2
<* *
<' ': s* 'C??CC C$ D
DDc L d}d|| z } | | 5 \ }} || } | st d | \ \ }
} } }
}}}}|
0|
t j k r |d|
f || n
ddd n ddd n # 1 swxY w Y | j | | } | j |||d }n# t $ r Y w xY w |r |r||f|
|fS |r||f|
fS |r||f|fS ||fS )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
)r r~ zdSELECT rowid, key, raw, expire_time, tag, mode, filename, value FROM Cache ORDER BY rowid %s LIMIT 1Tzdictionary is emptyNru F)r$ r r] r r r4 r rf )r lastr: r7 r# r r r r= r> r? r9 rd r rh r r r; rM rw s r peekitemzCache.peekitem s 6
4 $K
"
^^E** nsG 3v;;//11D > &'< = == ! " % " $ !,TY[[1H1H ?%JJJ
/ * &+
4 *..--C
((tXuEE
3 <F2 2
<* *
<' ': s$ A2B00B47B4 C6 6
DDr c b t rt d fd}|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 t fnft j fd fd}|_ S )z3Decorator created by memoize() for callable `func`.Nc j | i |} |t d }|t u r* | i |}dk r ||d |S )z:Wrapper for callable to cache arguments and return values.Trl Nr )r7 r# )
__cache_key__r4 r rA ) r r rM r_ r6 r r r7 wrappers r r z1Cache.memoize..decorator..wrapperL s ,g+T.decorator..__cache_key__Y s "4vufEEEr
)r rr wrapsr )
r r r r r6 r r r r7 r s
` @@r decoratorz Cache.memoize..decoratorH s )- IdOO%%D7D
Xd^^
^
F
F
F
F
F
F
F %2G !Nr
)callabler )r r r r6 r7 r r s `````` r memoizez
Cache.memoize sb D D>> 7 566 6 0 r
c t j d 5 }| j } |d }t | dk s|d d dk r|D ]\ }t j | |r |d | | 5 \ }}t }d} || }|D ]\ }
} } t j | j
| }
| |
t j |
rIt j
|
}| |k r.d }|
|| f}t j ||z |r |d
||
f t j d |
z |r
|d |
f t j | j
D ]j\ }}fd
|D }t | |z
}|D ]A}
t |
v r d|
z }t j |t" |rt j |
Bkt j | j
D ]?\ }}|s7|s5dz }t j |t& |rt j @| d |d \ \ }| j |k r0d}t j || j |fz |r |d|df | d d} || \ \ } | j | k r0d}t j || j | fz |r |d| df ddd n # 1 swxY w Y |cddd S # 1 swxY w Y dS )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_checkr r okVACUUMzBSELECT rowid, size, filename FROM Cache WHERE filename IS NOT NULLz wrong file size: %s, %d != %dz)UPDATE Cache SET size = ? WHERE rowid = ?zfile not found: %sru c : g | ]}t j | S r )ro r )r rk dirpaths r
z Cache.check.. s% N N NHRWWh 7 7 N N Nr
zunknown file: %szempty directory: %sr/ z SELECT COUNT(key) FROM Cachez,Settings.count != COUNT(Cache.key); %d != %d+UPDATE Settings SET value = ? WHERE key = ?r0 z(SELECT COALESCE(SUM(size), 0) FROM Cachez*Settings.size != SUM(Cache.size); %d != %dz*UPDATE Settings SET value = ? WHERE key =?N)warningscatch_warningsr r ri warnr$ rA ro r r: rX existsrp r walkr r r r rmdirr r/ r0 )r fixr# warnsr r> messagerP r, r r? r0 rk ry real_sizer filespathsr dirsr/ select_sizer s @r checkz Cache.checkb s *
$D
1
1
1 m U)C 3/0099;;D4yyA~~at!3!3"& + +JW M'****
H
&& ]
(3 EE 2
s6{{++---1 K K)E4 " B BI MM),,,y++ !$&Jy$9$9 9,,&EG#,i#=D $M'D. 9 9 9 " " #%7%.$6!" !" !" ! M"6"BCCC K ?%JJJ *, )A)A 1 1%GQ N N N N N N NE JJ 2E%* 1 1 !Y.. $"4y"@
g/ABBB 1 Ii 0 0 01 -/GDO,D,D . .(GT5 .E ."7'"A
g??? . HW - - -
7### !c"@ A A J J L L %:&& LG M'TZ,?"?@@@ I "G ,
6""" H S - - 6 6 8 8
$9$$ JG M'TY,="=>>> H !6N u]
]
]
]
]
]
]
]
]
]
]
]
]
]
]
~ [m m m m m m m m m m m m m m m m m m s7 BM0 J-M M0M M0 M M00M47M4c V | j } |d | dd dS )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 Nr r r r s r r zCache.create_tag_index s6 i MNNN
;"""""r
c V | j } |d | dd dS )z`Drop tag index on cache database.
:raises Timeout: if database timeout occurs
z$DROP INDEX IF EXISTS Cache_tag_rowidr$ r Nr r s r r zCache.drop_tag_index s6 i 2333
;"""""r
c B d}|ddg}| ||d| S )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 ?r d r ) arg_indexr# _select_delete)r r7 r# r r s r evictz Cache.evict s6 (
&
Q}""641E"JJJr
c h d}d|pt j dg}| ||d| S )a Remove 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 ?r r r ) row_indexr# )r r )r r8 r# r r s r r6 z Cache.expire sB (
,
3%$)++s+""641E"JJJr
c t j }| | }t | j d }|dS | d| } | | j k r| | 5 \ }} ||d }|s
ddd n|t | z
}d| d| z } || d |D ]\ }
||
ddd n # 1 swxY w Y | | j k n # t $ r t | dw xY w|S ) a Cull 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
r5 Nr rk rI )r! rH r? ) r r6 r r% rL rK r& r$ r ri r ) r r# r8 r/ rQ rR r r= r> rS rk s r r5 z
Cache.cull2 s $ ikk C ((<=fE
1'..jc.JJ +++--$/11^^E** *nsG 366??AAD * * * * * * * SYY&E?'..g3.GGH C&&&'+ * * ))))** * * * * * * * * * * * * * * ++--$/11 + + +%..d * + s= 2E %D4 E A
D E DE D E Ec > d}ddg}| ||| S )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 ?r r r" r )r r# r r s r clearz Cache.cleari s2 &
&
3x""64u"===r
c d}d} | | 5 \ }} ||| }
|
s
d d d nw|t |
z
} ||d d |
D z |
D ] } | | ||< | | d d d d n # 1 swxY w Y n # t $ r t | d w xY w|S )Nr rH T,c 3 @ K | ]}t |d V dS )r N)rG )r rows r r z'Cache._select_delete.. s, )F)F##c!f++)F)F)F)F)F)Fr
)r$ r ri r r ) r r r r r r# r/ rS r r= r> r s r r zCache._select_delete s 8 +
)^^E** )nsG 3vt,,5577D ) ) ) ) ) ) ) SYY&EC)F)F)F)F)F!F!FFGGG # ) )*-i.Y B(((() ) ) ) ) ) ) ) ) ) ) ) ) ) ) )
) ) + + +%..d * + s; C %B8 C
A B8, C 8B<<C ?B< C C c # 0 K | j }d}| j j }|rd}d}nd}d} || }|r|\ \ }} ndS ||| V |||| ||f }
|
sdS |
D ]\ }} ||| V =)a Iterate 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
r z>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