*iySrSSKrSSKJr SSKJrJrJrJ r J r SSK J r SSK Jr SSKJrJr S r"S S \ 5r"S S \5rg)zPersistent Data Types N) OrderedDict) ItemsViewKeysViewMutableMappingSequence ValuesView)contextmanager)rmtree)ENOVALCachec^U4SjnSRTR5UlSnURU5UlU$)z,Make compare method with Sequence semantics.c>[U[5(d[$[U5n[U5nX#:wa(T[R LagT[R Lag[X5HupEXE:wdM T"XE5s $ T"X#5$)z&Compare method for deque and sequence.FT) isinstancerNotImplementedlenopeqnezip)selfthatlen_selflen_thatalphabetaseq_ops R/var/www/html/ai-backend/venv/lib/python3.13/site-packages/diskcache/persistent.pycompare_make_compare..comparesw$))! !t9t9  t?KE}e**+h))z__{0}__z/Return True if and only if deque is {0} `that`.)format__name____doc__)rdocrdoc_strs` r _make_comparer's;*(!''8G?GnnS)GO Nr!c4\rSrSrSrS+Sjr\S,Sj5r\S5r \S5r \S5r \ RS 5r S r S rS rS rSr\"\R(S5r\"\R,S5r\"\R0S5r\"\R4S5r\"\R8S5r\"\R<S5rSr Sr!Sr"Sr#Sr$Sr%Sr&\&r'Sr(\(r)Sr*\*r+Sr,Sr-S r.\.r/S!r0S"r1S#r2S$r3\3r4S%r5\5r6S&r7S'r8S-S(jr9Sr:\;S)5r>> deque = Deque() >>> deque += range(5) >>> list(deque) [0, 1, 2, 3, 4] >>> for value in range(5): ... deque.appendleft(-value) >>> len(deque) 10 >>> list(deque) [-4, -3, -2, -1, 0, 0, 1, 2, 3, 4] >>> deque.pop() 4 >>> deque.popleft() -4 >>> deque.reverse() >>> list(deque) [3, 2, 1, 0, 0, -1, -2, -3] Ncn[USS9UlUc [S5OUUlUR U5 g)zInitialize deque instance. If directory is None then temporary directory created. The directory will *not* be automatically removed. :param iterable: iterable of items to append to deque :param directory: deque directory (default None) noneeviction_policyNinf)r _cachefloat_maxlen_extend)riterable directorymaxlens r__init__Deque.__init__Ns/Iv> '-~uU|6  Xr!cURU5nXlUc [S5OUUlUR U5 U$)a Initialize deque using `cache`. >>> cache = Cache() >>> deque = Deque.fromcache(cache, [5, 6, 7, 8]) >>> deque.cache is cache True >>> len(deque) 4 >>> 7 in deque True >>> deque.popleft() 5 :param Cache cache: cache to use :param iterable: iterable of items :return: initialized Deque r/)__new__r0r1r2r3)clscacher4r6rs r fromcacheDeque.fromcache\s9*{{3 '-~uU|6  X r!cUR$)zCache used by deque.r0rs rr< Deque.cachew{{r!c.URR$)z%Directory path where deque is stored.r0r5rAs rr5Deque.directory|{{$$$r!cUR$)zMax length of the deque.)r2rAs rr6 Deque.maxlens||r!c&XlURRSS9 [UR5UR:a5UR 5 [UR5UR:aM5SSS5 g!,(df  g=f)zSet max length of the deque. Pops items from left while length greater than max. >>> deque = Deque() >>> deque.extendleft('abcde') >>> deque.maxlen = 3 >>> list(deque) ['c', 'd', 'e'] :param value: max length TretryN)r2r0transactr_popleftrvalues rr6rIs_ [[ ! ! ! -dkk"T\\1 dkk"T\\1. - -s AB Bc[U5nUS:aHX:a [S5eURR5HnUS:Xa U"U5s $US-nM OLX*:a [S5eUS- nURRSS9HnUS:Xa U"U5s $US- nM [S5e![a Mf=f![a MFf=f)Nrzdeque index out of ranger Treverse)r IndexErrorr0iterkeysKeyError)rindexfuncrkeys r_index Deque._indexst9 A:  !;<<{{++-A:!#Cy(  .y  !;<< QJE{{++D+9A:!#Cy(  :344#$! !$! !s$B1C1 B?>B? CCcLURXRR5$)aodeque.__getitem__(index) <==> deque[index] Return corresponding item for `index` in deque. See also `Deque.peekleft` and `Deque.peek` for indexing deque at index ``0`` or ``-1``. >>> deque = Deque() >>> deque.extend('abcde') >>> deque[1] 'b' >>> deque[-2] 'd' :param int index: index of item :return: corresponding item :raises IndexError: if index out of range )rZr0 __getitem__rrWs rr]Deque.__getitem__s({{5++"9"9::r!c8^^UU4SjnTRX5 g)aMdeque.__setitem__(index, value) <==> deque[index] = value Store `value` in deque at `index`. >>> deque = Deque() >>> deque.extend([None] * 3) >>> deque[0] = 'a' >>> deque[1] = 'b' >>> deque[-1] = 'c' >>> ''.join(deque) 'abc' :param int index: index of value :param value: value to store :raises IndexError: if index out of range c<>TRRUT5$N)r0 __setitem__)rYrrPs r _set_value%Deque.__setitem__.._set_values;;**36 6r!N)rZ)rrWrPrds` ` rrcDeque.__setitem__s& 7 E&r!cNURXRR5 g)adeque.__delitem__(index) <==> del deque[index] Delete item in deque at `index`. >>> deque = Deque() >>> deque.extend([None] * 3) >>> del deque[0] >>> del deque[1] >>> del deque[-1] >>> len(deque) 0 :param int index: index of item :raises IndexError: if index out of range N)rZr0 __delitem__r^s rrhDeque.__delitem__s" E;;223r!cb[U5RnSRXR5$)zZdeque.__repr__() <==> repr(deque) Return string with printable representation of deque. z{0}(directory={1!r})typer#r"r5rnames r__repr__Deque.__repr__s( Dz""%,,T>>BBr!zequal toz not equal toz less thanz greater thanzless than or equal tozgreater than or equal toc(URU5 U$)zdeque.__iadd__(iterable) <==> deque += iterable Extend back side of deque with items from iterable. :param iterable: iterable of items to append to deque :return: deque with added items )r3)rr4s r__iadd__Deque.__iadd__ s X r!c## URnUR5H nXv M g![a Mf=f7f)zQdeque.__iter__() <==> iter(deque) Return iterator of deque from front to back. Nr0rUrVrr0rYs r__iter__Deque.__iter__sA ??$C k!%  s ?.? <?<?c,[UR5$)z:deque.__len__() <==> len(deque) Return length of deque. rr0rAs r__len__ Deque.__len__# 4;;r!c## URnURSS9H nXv M g![a Mf=f7f)zdeque.__reversed__() <==> reversed(deque) Return iterator of deque from back to front. >>> deque = Deque() >>> deque.extend('abcd') >>> iterator = reversed(deque) >>> next(iterator) 'd' >>> list(iterator) ['c', 'b', 'a'] TrRNrurvs r __reversed__Deque.__reversed__+sE??4?0C k!1  s>-> ;>;>c2URUR4$rbr5r6rAs r __getstate__Deque.__getstate__As~~t{{**r!c*Uup#URX#S9 g)Nrr7)rstater5r6s r __setstate__Deque.__setstate__Ds!  9r!cURRSS9 URRUSS9 [UR5UR:aUR 5 SSS5 g!,(df  g=f)zAdd `value` to back of deque. >>> deque = Deque() >>> deque.append('a') >>> deque.append('b') >>> deque.append('c') >>> list(deque) ['a', 'b', 'c'] :param value: value to add to back of deque TrKN)r0rMpushrr2rNrOs rappend Deque.appendHsZ[[ ! ! ! - KK  U$  /4;;$,,. . - -s AA11 A?cURRSS9 URRUSSS9 [UR5UR:aUR 5 SSS5 g!,(df  g=f)zAdd `value` to front of deque. >>> deque = Deque() >>> deque.appendleft('a') >>> deque.appendleft('b') >>> deque.appendleft('c') >>> list(deque) ['c', 'b', 'a'] :param value: value to add to front of deque TrKfront)siderLN)r0rMrrr2_poprOs r appendleftDeque.appendleft\s\[[ ! ! ! - KK  U  =4;;$,,. . - -s AA22 Bc6URRSS9 g)zqRemove all elements from deque. >>> deque = Deque('abc') >>> len(deque) 3 >>> deque.clear() >>> list(deque) [] TrKNr0clearrAs rr Deque.clearp %r!cN[U5nU"URURS9$)z.Copy deque with same directory and max length.r)rlr5r6)rTypeSelfs rcopy Deque.copys :$..EEr!c.^[U4SjU55$)aReturn number of occurrences of `value` in deque. >>> deque = Deque() >>> deque += [num for num in range(1, 5) for _ in range(num)] >>> deque.count(0) 0 >>> deque.count(1) 1 >>> deque.count(4) 4 :param value: value to count in deque :return: count of items equal to value in deque c38># UHnTU:XdM Sv M g7f)r N).0itemrPs r Deque.count..s7$11s  )sumrOs `rcount Deque.counts 7777r!c8UHnURU5 M g)z]Extend back side of deque with values from `iterable`. :param iterable: iterable of values N)_appendrr4rPs rextend Deque.extends E LL r!c8UHnURU5 M g)zExtend front side of deque with value from `iterable`. >>> deque = Deque() >>> deque.extendleft('abc') >>> list(deque) ['c', 'b', 'a'] :param iterable: iterable of values N) _appendleftrs r extendleftDeque.extendleftsE   U #r!cxS[4nURRUSSS9up#U[La [S5eU$)aSPeek at value at back of deque. Faster than indexing deque at -1. If deque is empty then raise IndexError. >>> deque = Deque() >>> deque.peek() Traceback (most recent call last): ... IndexError: peek from an empty deque >>> deque += 'abc' >>> deque.peek() 'c' :return: value at back of deque :raises IndexError: if deque is empty NbackTdefaultrrLpeek from an empty dequer r0peekrTrr_rPs rr Deque.peeksB(,;;##G&#M F?78 8 r!cxS[4nURRUSSS9up#U[La [S5eU$)a\Peek at value at front of deque. Faster than indexing deque at 0. If deque is empty then raise IndexError. >>> deque = Deque() >>> deque.peekleft() Traceback (most recent call last): ... IndexError: peek from an empty deque >>> deque += 'abc' >>> deque.peekleft() 'a' :return: value at front of deque :raises IndexError: if deque is empty NrTrrrrs rpeekleftDeque.peekleftsB(,;;##G'#N F?78 8 r!cxS[4nURRUSSS9up#U[La [S5eU$)aJRemove and return value at back of deque. If deque is empty then raise IndexError. >>> deque = Deque() >>> deque += 'ab' >>> deque.pop() 'b' >>> deque.pop() 'a' >>> deque.pop() Traceback (most recent call last): ... IndexError: pop from an empty deque :return: value at back of deque :raises IndexError: if deque is empty NrTrpop from an empty dequer r0pullrTrs rpop Deque.popsB(,;;##G&#M F?67 7 r!cvS[4nURRUSS9up#U[La [S5eU$)a.Remove and return value at front of deque. >>> deque = Deque() >>> deque += 'ab' >>> deque.popleft() 'a' >>> deque.popleft() 'b' >>> deque.popleft() Traceback (most recent call last): ... IndexError: pop from an empty deque :return: value at front of deque :raises IndexError: if deque is empty NTrrLrrrs rpopleft Deque.poplefts@$,;;##G4#@ F?67 7 r!cURnUR5HnX#nX:XaX# gM [S5e![a M.f=f![a M?f=f)aqRemove first occurrence of `value` in deque. >>> deque = Deque() >>> deque += 'aab' >>> deque.remove('a') >>> list(deque) ['a', 'b'] >>> deque.remove('b') >>> list(deque) ['a'] >>> deque.remove('c') Traceback (most recent call last): ... ValueError: deque.remove(value): value not in deque :param value: value to remove :raises ValueError: if value not in deque Nz'deque.remove(value): value not in deque)r0rUrV ValueError)rrPr0rYrs rremove Deque.removesz(??$C {=!"K ! %BCC $! !   s A> A  A  AAc[[U5S9nUR5 URU5 URnUR R 5 A[U5 g)zuReverse deque in place. >>> deque = Deque() >>> deque += 'abc' >>> deque.reverse() >>> list(deque) ['c', 'b', 'a'] )r4N)r)reversed_clearr3r5r0closer )rtempr5s rrS Deque.reverse>sK htn-  TNN   yr!c[U[5(d#[U5Rn[ SU-5e[ U5nU(dgUS:a9X-n[ U5H%nUR5nURU5 M' gUS-nX-n[ U5H%nUR5nURU5 M' g![a  gf=f![a  gf=f)aRotate deque right by `steps`. If steps is negative then rotate left. >>> deque = Deque() >>> deque += range(5) >>> deque.rotate(2) >>> list(deque) [3, 4, 0, 1, 2] >>> deque.rotate(-1) >>> list(deque) [4, 0, 1, 2, 3] :param int steps: number of steps to rotate (default 1) z!integer argument expected, got %sNr) rintrlr# TypeErrorrrangerrrTrNr)rsteps type_namerrrPs rrotate Deque.rotateVs"%%%U ,,I?)KL Lt9  A:  E5\, IIKE$$U+ " RKE  E5\( MMOELL' """s$%C #C CC C('C(c#z# URRSS9 Sv SSS5 g!,(df  g=f7f)aContext manager to perform a transaction by locking the deque. While the deque 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. >>> from diskcache import Deque >>> deque = Deque() >>> deque += range(5) >>> with deque.transact(): # Atomically rotate elements. ... value = deque.pop() ... deque.appendleft(value) >>> list(deque) [4, 0, 1, 2, 3] :return: context manager for use in `with` statement TrKNr0rMrAs rrMDeque.transacts*.[[ ! ! ! - . - -;* ; 8;)r0r2)rNN)rN)r )>r# __module__ __qualname____firstlineno__r$r7 classmethodr=propertyr<r5r6setterrZr]rcrhror'rr__eq__r__ne__lt__lt__gt__gt__le__le__ge__ge__rrrwr{rrrrrrrrrrrrr3rrrrrrrNrrSr__hash__r rM__static_attributes__rr!rr)r)1s8 4%% ]]  &5<;,'04&C255* -F 255. 1F 255+ .F 255. 1F 255"9 :F 255"< =F   ,+: $G$K &FF 8$ G $444 D0H#DJ0.(`Hr!r)c\rSrSrSrSr\Rr\ S5r \ S5r \ S5r SrSrS rS S jrS!S jr\4S jrS!SjrS"SjrS#SjrSrSrSrSrSrSrSrS rSr Sr!Sr"Sr#S$Sjr$\%S5r&Sr'Sr(g )%IndexiaPersistent mutable mapping with insertion order iteration. Items are serialized to disk. Index may be initialized from directory path where items are stored. Hashing protocol is not used. Keys are looked up by their serialized format. See ``diskcache.Disk`` for details. >>> index = Index() >>> index.update([('a', 1), ('b', 2), ('c', 3)]) >>> index['a'] 1 >>> list(index) ['a', 'b', 'c'] >>> len(index) 3 >>> del index['b'] >>> index.popitem() ('c', 3) cU(a)[US[[45(a USnUSSnOU(a UScUSSnSn[USS9UlUR "U0UD6 g)akInitialize index in directory and update items. Optional first argument may be string specifying directory where items are stored. When None or not given, temporary directory is created. >>> index = Index({'a': 1, 'b': 2, 'c': 3}) >>> len(index) 3 >>> directory = index.directory >>> inventory = Index(directory, d=4) >>> inventory['b'] 2 >>> len(inventory) 4 rr Nr,r-)rbytesstrr r0_update)rargskwargsr5s rr7Index.__init__si" JtAw 55QI8DQABxIIv>  d%f%r!cXURU5nXlUR"U0UD6 U$)aaInitialize index using `cache` and update items. >>> cache = Cache() >>> index = Index.fromcache(cache, {'a': 1, 'b': 2, 'c': 3}) >>> index.cache is cache True >>> len(index) 3 >>> 'b' in index True >>> index['c'] 3 :param Cache cache: cache to use :param args: mapping or sequence of items :param kwargs: mapping of items :return: initialized Index )r:r0r)r;r<rrrs rr=Index.fromcaches-,{{3  d%f% r!cUR$)zCache used by index.r@rAs rr< Index.cacherCr!c.URR$)z&Directory path where items are stored.rErAs rr5Index.directoryrGr!c URU$)ajindex.__getitem__(key) <==> index[key] Return corresponding value for `key` in index. >>> index = Index() >>> index.update({'a': 1, 'b': 2}) >>> index['a'] 1 >>> index['b'] 2 >>> index['c'] Traceback (most recent call last): ... KeyError: 'c' :param key: key for item :return: value for item in index with given key :raises KeyError: if key is not found r@rrYs rr]Index.__getitem__s*{{3r!c X RU'g)zindex.__setitem__(key, value) <==> index[key] = value Set `key` and `value` item in index. >>> index = Index() >>> index['a'] = 1 >>> index[0] = None >>> len(index) 2 :param key: key for item :param value: value for item Nr@)rrYrPs rrcIndex.__setitem__s! Cr!cURU g)aXindex.__delitem__(key) <==> del index[key] Delete corresponding item for `key` from index. >>> index = Index() >>> index.update({'a': 1, 'b': 2}) >>> del index['a'] >>> del index['b'] >>> len(index) 0 >>> del index['c'] Traceback (most recent call last): ... KeyError: 'c' :param key: key for item :raises KeyError: if key is not found Nr@rs rrhIndex.__delitem__$s( KK r!NcjURnX1$![a URXSS9 Of=fM')aSet and get value for `key` in index using `default`. If `key` is not in index then set corresponding value to `default`. If `key` is in index then ignore `default` and return existing value. >>> index = Index() >>> index.setdefault('a', 0) 0 >>> index.setdefault('a', 1) 0 :param key: key for item :param default: value if key is missing (default None) :return: value for item in index with given key TrK)r0rVadd)rrYrr0s r setdefaultIndex.setdefault:sA" 5{" 5 3t 4 5s 00c6URRUSS9$)ahPeek at key and value item pair in index based on iteration order. >>> index = Index() >>> for num, letter in enumerate('xyz'): ... index[letter] = num >>> index.peekitem() ('z', 2) >>> index.peekitem(last=False) ('x', 0) :param bool last: last item in iteration order (default True) :return: key and value item pair :raises KeyError: if cache is empty TrK)r0peekitem)rlasts rr Index.peekitemRs {{##D#55r!cfURnURXSS9nU[La [U5eU$)a"Remove corresponding item for `key` from index and return value. If `key` is missing then return `default`. If `default` is `ENOVAL` then raise KeyError. >>> index = Index({'a': 1, 'b': 2}) >>> index.pop('a') 1 >>> index.pop('b') 2 >>> index.pop('c', default=3) 3 >>> index.pop('d') Traceback (most recent call last): ... KeyError: 'd' :param key: key for item :param default: return value if key is missing (default ENOVAL) :return: value for item if key is found else default :raises KeyError: if key is not found and default is ENOVAL Tr)r0rr rV)rrYrr0rPs rr Index.popds50 3t < F?3-  r!cURnURSS9 URUS9up4X# SSS5 X44$!,(df  WW4$=f)aJRemove and return item pair. Item pairs are returned in last-in-first-out (LIFO) order if last is True else first-in-first-out (FIFO) order. LIFO order imitates a stack and FIFO order imitates a queue. >>> index = Index() >>> index.update([('a', 1), ('b', 2), ('c', 3)]) >>> index.popitem() ('c', 3) >>> index.popitem(last=False) ('a', 1) >>> index.popitem() ('b', 2) >>> index.popitem() Traceback (most recent call last): ... KeyError: 'dictionary is empty' :param bool last: pop last item pair (default True) :return: key and value item pair :raises KeyError: if index is empty TrK)r N)r0rMr )rr r0rYrPs rpopitem Index.popitemsV4 __4_ (d3JC )z ) (Ezs ; A c8URRXUSS9$)a>Push `value` onto `side` of queue in index identified by `prefix`. 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'. See also `Index.pull`. >>> index = Index() >>> print(index.push('apples')) 500000000000000 >>> print(index.push('beans')) 500000000000001 >>> print(index.push('cherries', side='front')) 499999999999999 >>> index[500000000000001] 'beans' >>> index.push('dates', prefix='fruit') 'fruit-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') :return: key for item in cache TrK)r0r)rrPprefixrs rr Index.pushs :{{t4@@r!c8URRXUSS9$)aPull key and value item pair from `side` of queue in index. 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'. See also `Index.push`. >>> index = Index() >>> for letter in 'abc': ... print(index.push(letter)) 500000000000000 500000000000001 500000000000002 >>> key, value = index.pull() >>> print(key) 500000000000000 >>> value 'a' >>> _, value = index.pull(side='back') >>> value 'c' >>> index.pull(prefix='fruit') (None, None) :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') :return: key and value item pair or default if queue is empty TrK)r0r)rrrrs rr Index.pulls!L{{TBBr!c6URRSS9 g)zRemove all items from index. >>> index = Index({'a': 0, 'b': 1, 'c': 2}) >>> len(index) 3 >>> index.clear() >>> dict(index) {} TrKNrrAs rr Index.clearrr!c,[UR5$)zVindex.__iter__() <==> iter(index) Return iterator of index keys in insertion order. )iterr0rAs rrwIndex.__iter__s DKK  r!c,[UR5$)aindex.__reversed__() <==> reversed(index) Return iterator of index keys in reversed insertion order. >>> index = Index() >>> index.update([('a', 1), ('b', 2), ('c', 3)]) >>> iterator = reversed(index) >>> next(iterator) 'c' >>> list(iterator) ['b', 'a'] )rr0rAs rrIndex.__reversed__s $$r!c,[UR5$)z:index.__len__() <==> len(index) Return length of index. rzrAs rr{ Index.__len__r}r!c[U5$)zSet-like object providing a view of index keys. >>> index = Index() >>> index.update({'a': 1, 'b': 2, 'c': 3}) >>> keys_view = index.keys() >>> 'b' in keys_view True :return: keys view )rrAs rkeys Index.keyss~r!c[U5$)zSet-like object providing a view of index values. >>> index = Index() >>> index.update({'a': 1, 'b': 2, 'c': 3}) >>> values_view = index.values() >>> 2 in values_view True :return: values view )rrAs rvalues Index.values&s$r!c[U5$)zSet-like object providing a view of index items. >>> index = Index() >>> index.update({'a': 1, 'b': 2, 'c': 3}) >>> items_view = index.items() >>> ('b', 2) in items_view True :return: items view )rrAs ritems Index.items4sr!cUR$rb)r5rAs rrIndex.__getstate__Ds ~~r!c&URU5 grbr)rrs rrIndex.__setstate__Gs er!c^^[T5[T5:wag[T[[45(a:U4SjT5nU4SjT5n[ X#5n[ SU55(+$[ UU4SjT55$)aindex.__eq__(other) <==> index == other Compare equality for index and `other`. Comparison to another index or ordered dictionary is order-sensitive. Comparison to all other mappings is order-insensitive. >>> index = Index() >>> pairs = [('a', 1), ('b', 2), ('c', 3)] >>> index.update(pairs) >>> from collections import OrderedDict >>> od = OrderedDict(pairs) >>> index == od True >>> index == {'c': 3, 'b': 2, 'a': 1} True :param other: other mapping in equality comparison :return: True if index equals other Fc30># UH oTU4v M g7frbr)rrYrs rrIndex.__eq__..ds6#49%c30># UH oTU4v M g7frbr)rrYothers rrr0es7#%*%r1c3N# UHuupup4X:g=(d X$:gv M g7frbr)rabxys rrr0gs$H%16+QV+%s#%c3\># UH!nTUTRU[5:Hv M# g7frb)getr )rrYr3rs rrr0is%KdstCyEIIc6$::ds),)rrrrranyall)rr3rrpairss`` rr Index.__eq__Jsm, t9E " ee[1 2 266E77D$EH%HHH HKdKK Kr!c X:X+$)aindex.__ne__(other) <==> index != other Compare inequality for index and `other`. Comparison to another index or ordered dictionary is order-sensitive. Comparison to all other mappings is order-insensitive. >>> index = Index() >>> index.update([('a', 1), ('b', 2), ('c', 3)]) >>> from collections import OrderedDict >>> od = OrderedDict([('c', 3), ('b', 2), ('a', 1)]) >>> index != od True >>> index != {'a': 1, 'b': 2} True :param other: other mapping in inequality comparison :return: True if index does not equal other r)rr3s rr Index.__ne__ks *  r!c6URRXUS9$)aMemoizing 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. 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 Index >>> mapping = Index() >>> @mapping.memoize() ... 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(mapping[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: >>> @mapping.memoize ... def test(): ... pass Traceback (most recent call last): ... TypeError: name cannot be callable :param str name: name given for callable (default None, automatic) :param bool typed: cache different types separately (default False) :param set ignore: positional or keyword args to ignore (default ()) :return: callable decorator )ignore)r0memoize)rrntypedrBs rrC Index.memoizesn{{""4v">>r!c#z# URRSS9 Sv SSS5 g!,(df  g=f7f)aContext manager to perform a transaction by locking the index. While the index 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. >>> from diskcache import Index >>> mapping = Index() >>> with mapping.transact(): # Atomically increment two keys. ... mapping['total'] = mapping.get('total', 0) + 123.4 ... mapping['count'] = mapping.get('count', 0) + 1 >>> with mapping.transact(): # Atomically calculate average. ... average = mapping['total'] / mapping['count'] >>> average 123.4 :return: context manager for use in `with` statement TrKNrrAs rrMIndex.transacts*0[[ ! ! ! - . - -rcb[U5RnSRXR5$)zZindex.__repr__() <==> repr(index) Return string with printable representation of index. z {0}({1!r})rkrms rroIndex.__repr__s( Dz""""488r!r@rb)T)Nr)N)NNr)NFr))r#rrrr$r7rupdaterrr=rr<r5r]rcrhrr r rrrrrrwrr{r"r%r(rrrrrrCr rMrorrr!rrrs,&6##G4%% .!",506$ &< DA>&CP &!%      HLB!.7?r49r!r)r$operatorr collectionsrcollections.abcrrrrr contextlibr shutilr corer r r'r)rrr!rrQsI#&