# h3SSKJr SSKrSSKJr SSKrSSKJ r "SS\5r "SS\ 5r g!\a SSKJr N/f=f) wrapsN)MutableMapping)Lockcl^\rSrSrSrSU4SjjrSrSrSrSr Sr S r S r S r S rS rSrU=r$)_ExpiringMapping _index_c>[[U] "U0UD6 UbUO0UlX lX0lUc[ 5UlgUUlg)amItems in this mapping can have individual shelf life, just like food items in your refrigerator have their different shelf life determined by each food, not by the refrigerator. Expired items will be automatically evicted. The clean-up will be done at each time when adding a new item, or when looping or counting the entire mapping. (This is better than being done indecisively by a background thread, which might not always happen before your accessing the mapping.) This implementation uses no dependency other than Python standard library. :param MutableMapping mapping: A dict-like key-value mapping, which needs to support __setitem__(), __getitem__(), __delitem__(), get(), pop(). The default mapping is an in-memory dict. You could potentially supply a file-based dict-like object, too. This implementation deliberately avoid mapping.__iter__(), which could be slow on a file-based mapping. :param int capacity: How many items this mapping will hold. When you attempt to add new item into a full mapping, it will automatically delete the item that is expiring soonest. The default value is None, which means there is no capacity limit. :param int expires_in: How many seconds an item would expire and be purged from this mapping. Also known as time-to-live (TTL). You can also use :func:`~set()` to provide per-item expires_in value. :param Lock lock: A locking mechanism with context manager interface. If no lock is provided, a threading.Lock will be used. But you may want to supply a different lock, if your customized mapping is being shared differently. N)superr__init___mapping _capacity _expires_inr_lock)selfmappingcapacity expires_inlockargskwargs __class__s G/var/www/html/env/lib/python3.13/site-packages/msal/individual_cache.pyr _ExpiringMapping.__init__sGT .??#*#6B !%#|TV  c~XR:Xa.[SRXRR55eg)Nz"key {} is a reserved keyword in {})_INDEX ValueErrorformatr__name__)rkeys r _validate_key_ExpiringMapping._validate_key>s9 ++ AHH^^,,./ / rctUR URXU5 SSS5 g!,(df  g=f)aIt sets the key-value pair into this mapping, with its per-item expires_in. It will take O(logN) time, because it will run some maintenance. This worse-than-constant time is acceptable, because in a cache scenario, __setitem__() would only be called during a cache miss, which would already incur an expensive target function call anyway. By the way, most other methods of this mapping still have O(1) constant time. N)r_set)rr"valuers rset_ExpiringMapping.setCs#ZZ IIc* -ZZs) 7c6URU5 URRUR/045upEUR XE5 [ [ R "55nXc-nXvU/nX;n UR=(a [U5UR:n U (a.U (a'URU[R"XH55 O[R"XH5 Xv/XQ'X RU'XE4URUR'gN) r#rgetr _maintenanceinttimerlen_drop_indexed_entryheapq heappushpopheappush) rr"r'rsequence timestampsnow expires_atentry is_new_itemis_beyond_capacitys rr&_ExpiringMapping._setTs 3#}}00r2hG (/$))+% #&+ !^^QJ4>>0Q -  $ $Z1B1B81S T NN8 +%+ " c%-%9 dkk"rc[[R"55nU(aKUSupEnXSs=::aU:aO OO3URX!S5 [R"U5 U(aMKUR bn[ U5UR :aTURX!S5 [R"U5 UR b[ U5UR :aMRgggg)z5It will modify input sequence and timestamps in-placerN)r.r/r1r2heappoprr0)rr5r6r7r8 created_atr"s rr-_ExpiringMapping._maintenancegs$))+*21+ 'JC-:-  $ $Z! = MM( # h nn(S_t~~-M  $ $Z! = MM( #nn(S_t~~-M(-M(rcUup4nX4/URU5:Xa/URRUS5 URUS5 gg)zGFor an entry came from index, drop it from timestamps and self._mappingN)r,rpop)rr6r9r8r?r"s rr1$_ExpiringMapping._drop_indexed_entrytsG&+#   #z~~c': : MM  c4 ( NN3 % ;rcURc [S5eUR URXUR5 SSS5 g!,(df  g=f)zImplements the __setitem__(). Same characteristic as :func:`~set()`, but use class-wide expires_in which was specified by :func:`~__init__()`. Nz5Need a numeric value for expires_in during __init__())rrrr&)rr"r's r __setitem___ExpiringMapping.__setitem__{sA    #TU U ZZ IIc$"2"2 3ZZs A  Ac,URU5 UR URRUR/045up#X1upE[ [ R "55nXVs=::aU:dtO URRUS5 URUS5 X#4URUR'[SRUXd:a S55eS55eURUsSSS5 $!,(df  g=f)CIf the item you requested already expires, KeyError will be raised.Nz{} {}expiredzcreated in the future?) r#rrr,rr.r/rBKeyErrorr )rr"r5r6r8r?r7s r __getitem___ExpiringMapping.__getitem__s 3 ZZ#'==#4#4T[[2r(#K H%/_ "Jdiik"C1z1 !!#t,sD)-5-A dkk*w~~!$!2I 8P ==%ZZs CD Dc6URU5 UR URRUS5 URR UR /045up#X1 X#4URUR 'SSS5 g!,(df  g=f)rHN)r#rrrBr,r)rr"r5r6s r __delitem___ExpiringMapping.__delitem__sp 3 ZZ MM  c4 (#'==#4#4T[[2r(#K H)1)=DMM$++ & ZZs A#B  BcUR URRUR/045upUR X5 X4URUR'[ U5sSSS5 $!,(df  g=f)z6Drop all expired items and return the remaining lengthN)rrr,rr-r0rr5r6s r__len___ExpiringMapping.__len__s^ ZZ#'==#4#4T[[2r(#K H   h 3)1)=DMM$++ &z? ZZs A A77 BcUR URRUR/045upUR X5 X4URUR'SSS5 [ W5$!,(df  N=f)zDDrop all expired items and return an iterator of the remaining itemsN)rrr,rr-iterrQs r__iter___ExpiringMapping.__iter__sg ZZ#'==#4#4T[[2r(#K H   h 3)1)=DMM$++ &J Zs AA66 B)rrrr)NNNN)r! __module__ __qualname____firstlineno__rr r#r(r&r-r1rErKrNrRrV__static_attributes__ __classcell__)rs@rrr sE F.6`/ .":& $& 4&$>#  rrc$\rSrSrSSjrSrSrg)_IndividualCacheNcJUbUO0UlU=(d SUlX0lg)a6Constructs a cache decorator that allows item-by-item control on how to cache the return value of the decorated function. :param MutableMapping mapping: The cached items will be stored inside. You'd want to use a ExpiringMapping if you plan to utilize the ``expires_in`` behavior. If nothing is provided, an in-memory dict will be used, but it will provide no expiry functionality. .. note:: When using this class as a decorator, your mapping needs to be available at "compile" time, so it would typically be a global-, module- or class-level mapping:: module_mapping = {} @IndividualCache(mapping=module_mapping, ...) def foo(): ... If you want to use a mapping available only at run-time, you have to manually decorate your function at run-time, too:: def foo(): ... def bar(runtime_mapping): foo = IndividualCache(mapping=runtime_mapping...)(foo) :param callable key_maker: A callable which should have signature as ``lambda function, args, kwargs: "return a string as key"``. If key_maker happens to return ``None``, the cache will be bypassed, the underlying function will be invoked directly, and the invoke result will not be cached either. :param callable expires_in: The default value is ``None``, which means the content being cached has no per-item expiry, and will subject to the underlying mapping's global expiry time. It can be an integer indicating how many seconds the result will be cached. In particular, if the value is 0, it means the result expires after zero second (i.e. immediately), therefore the result will *not* be cached. (Mind the difference between ``expires_in=0`` and ``expires_in=None``.) Or it can be a callable with the signature as ``lambda function=function, args=args, kwargs=kwargs, result=result: 123`` to calculate the expiry on the fly. Its return value will be interpreted in the same way as above. Nc:UU[UR554$r+)tupleitems)functionrrs r+_IndividualCache.__init__..s   &,,. ! Hr)r _key_makerr)rr key_makerrs rr _IndividualCache.__init__s,t$+#6B #)&rc4^^[T5UU4Sj5nU$)Nc>TRTX5nUcT"U0UD6$[[R"55nTRU$![a Of=fT"U0UD6n[ TR 5(aTR TUUUS9O TR nUS:XaU$UcUTRU'U$TRRX$U5 U$)N)rdrrresultr)rgr.r/rrJcallablerr()rrr"r7r'rrdrs rwrapper*_IndividualCache.__call__..wrappers//(D9C{000diik"C }}S))    d-f-Ed..// ))! * 6:5E5E  Q !%* c"L !!#j9LsA AAr)rrdrns`` r__call___IndividualCache.__call__s x   :r)rrgr)NNN)r!rXrYrZr rpr[rrr^r^s C&J rr^) functoolsrr/collections.abcr ImportError collectionsr2 threadingrrobjectr^rrrrrysM +. e ~e Pjvj]+*+s3 AA