Hoh%^ddlmZddlZddlZddlZddlmZmZddlm Z ddl m Z m Z m Z mZmZmZddlmZmZmZgdZGd d eZGd d Zej0Gd dZGddZej0GddZGddZGddZGddZy)) annotationsN) OrderedDictdeque) ContextVar)CallableDequeDictOptionalProtocolUnion)Domain PartialResultResolver)CacheCachingResolverLruS3FifoSievec\eZdZdZej ddZej ddZy)rzCache() Cache abstract protocol. The :class:`CachingResolver` will look values up, merge what was returned (possibly nothing) with what it got from its actual parser, and *re-set the result*. cy)z6Adds or replace ``value`` to the cache at key ``key``.Nselfkeyvalues m/var/www/html/wine-match-dev/backend/winematch-backend/venv/lib/python3.12/site-packages/ua_parser/caching.py __setitem__zCache.__setitem__$ cy)z5Returns a partial result for ``key`` if there is any.Nrrrs r __getitem__zCache.__getitem__)rr NrstrrrreturnNonerr%r&zOptional[PartialResult])__name__ __module__ __qualname____doc__abcabstractmethodrr#rr rrrs;      r rc(eZdZdZddZddZddZy) ra Cache following a least-recently used replacement policy: when there is no more room in the cache, whichever entry was last seen the least recently is removed. Simple LRUs are generally outdated and to avoid as they have relatively low hit rates for modern caches (at lower sizes). The main use case here is if the workload can lead to the cache being full of popular items then all of them being replaced at once: :class:`S3Fifo` and :class:`Sieve` are FIFO-based caches and have worst-case O(n) eviction. cb||_t|_tj|_yN)maxsizercache threadingLocklockrr2s r__init__z Lru.__init__<s  6Am NN$ r c|j5|jj|}|r|jj||cdddS#1swYyxYwr1)r6r3get move_to_endrres rr#zLru.__getitem__AsH YY  s#A &&s+    s :AAc|j5t|j|jk\r*||jvr|jj d||j|<dddy#1swYyxYw)NF)last)r6lenr3r2popitemrs rrzLru.__setitem__Hs_ YY $4::$,,.3djj3H """.#DJJsO $ $ $s AA22A;Nr2intr(r$)r)r*r+r,r8r#rrr rrr/s % $r rc4eZdZUgdZded<ded<ded<y) CacheEntry)freqrrr%rrrrCrFNr)r*r+ __slots____annotations__rr rrErEOs(I H  Ir rEc8eZdZdZddZd dZd dZd dZd dZy) raBFIFO-based quick-demotion lazy-promotion cache [S3-FIFO]_. Experimentally provides excellent hit rate at lower cache sizes, for a relatively simple and efficient implementation. Notably excellent at handling "one hit wonders", aka entries seen only once during a work-set (or reasonable work window). c||_i|_tdt|dz |_t |_||jz |_t |_t |_ tj|_ y)Nr ) r2indexmaxrC small_targetrsmall main_targetmainghostr4r5r6r7s rr8zS3Fifo.__init__`sd 8: 3w|#45(- "T%6%66',w !& NN$ r c|jj|x}r;t|tur*t |j dzd|_|j Sy)Nr )rMr:typerEminrFrr<s rr#zS3Fifo.__getitem__jsG$ $A $$q'Z*?!Q'AF77Nr c"|j5|jj|x}r"t|tur||_ dddyt |jt |jz|jk\rzt |j|jkr|jt |jt |jz|jk\r|jt ||d}t|jj|tur|jj|n|jj|||j|<dddy#1swYyxYwNr)r6rMr:rVrErr@rPrRr2rQ _evict_small _evict_mainr% appendleft)rrrr=entrys rrzS3Fifo.__setitem__rs" YY $ZZ^^C(((d1g.C $ $ 4::TYY/4<<?tyy>D$4$44%%'tzz?S^3t||C$$&sAq)EDJJNN3'(C/ $$U+ %%e,#DJJsO' $ $ $s7F D/FFc |jj}|jr1|xjdzc_|jj|n|j|j =yp)Nr )rRpoprFr\rMr)rr=s rr[zS3Fifo._evict_mainsR Avv!  $$Q'JJquu%r cb|jr"|jj}|jr#d|_|jj |n|j x}|j |j <|jj |t|j|jkDrg|jj}|j j||ur |j |=t|j|jkDrgy|jr!yyrY) rPr`rFrRr\rrMrSr@rQr:)rr=gs rrZzS3Fifo._evict_smallsjj  Avv $$Q'()-DJJquu% %%a($**o(8(88 (Azz~~a(A- JJqM$**o(8(88jjr NrBr()rr%r]rr&r'r&r') r)r*r+r,r8r#rr[rZrr rrrWs %$, r rc:eZdZUdZded<ded<ded<ded <y ) SieveNode)rnextrvisitedr%rrrboolrgzOptional[SieveNode]rfNrGrr rreres3I H  M r rec0eZdZdZddZddZd dZd dZy) raFIFO-based quick-demotion cache [SIEVE]_. Simpler FIFO-based cache, cousin of :class:`S3Fifo`. Experimentally slightly lower hit rates than :class:`S3Fifo` (if way superior to LRU still), but much more compact (~50% lower memory overhead at larger cache sizes, up to 100% at very small cache sizes). Can be an interesting candidate when trying to save on memory, although the contained entries will generally be much larger than the cache itself. c||_i|_d|_d|_d|_d|_t j|_yr1) r2r3headtailhandprevr4r5r6r7s rr8zSieve.__init__s: +- )- )- )- )- NN$ r cd|jj|x}rd|_|jSy)NT)r3r:rgr)rrr^s rr#zSieve.__getitem__s.JJNN3' '5 ' EM;; r c|j5|jj|x}r||_ dddyt |j|j k\r|j t||ddx}|j|<|jr||j_ ||_|j||_ dddy#1swYyxYwNF) r6r3r:rr@r2_evictrerkrfrl)rrrr=nodes rrzSieve.__setitem__s YY !JJNN3''q' ! ! 4::$,,. %.sE5$%G GD4::c?yy!% DIyy    ! ! !s&C BC  Cc|jr|j|j}}n|jd}}|rK|jr?d|_|jr|j|}}n|jd}}|r |jr?|sy|j|_||_|j |j =|js||_|r|j|_y|j|_yrq)rmrnrlrgrfr3rrk)robjpobjs rrrz Sieve._evicts 99 499C 4CckkCKxxHHcT IItT ckk HH  JJsww xxDI DIDIr N)r2rCr&r'r(r$rc)r)r*r+r,r8r#rrrrr rrrs %! !r rc:eZdZdZddZeddZd dZd dZy) LocaladThread local cache decorator. Takes a cache factory and lazily instantiates a cache for each thread it's accessed from. This means the cache capacity and memory consumption is figuratively multiplied by however many threads the cache is used from, but those threads don't share their caching, and thus don't contend on cache use. c2td|_||_y)Nz local-cache)rcvfactory)rr{s rr8zLocal.__init__s%/ %> r c|jjd}|+|j}|jj||Sr1)rzr:r{set)rcs rr3z Local.caches8 GGKK  9 A GGKKNr c |j|Sr1r3r"s rr#zLocal.__getitem__szz#r c"||j|<yr1rrs rrzLocal.__setitem__s 3r N)r{zCallable[[], Cache]r&r')r&rr(r$) r)r*r+r,r8propertyr3r#rrr rrxrxs* r rxc eZdZdZddZddZy)raA wrapper resolver which takes an underlying concrete :class:`Cache` for the actual caching and cache strategy. This resolver only interacts with the :class:`Cache` and delegates to the wrapped resolver in case of lookup failure. :class:`CachingParser` will set entries back in the cache when filling them up, it does not update results in place (and can't really, they're immutable). c ||_||_yr1)parserr3)rresolverr3s rr8zCachingResolver.__init__"s ( ! r c|j|}|r ||jvr|S||jz}|j||}|rot||j|jz|jxs |j|j xs |j |j xs |j }||j|<|S)N)stringdomains user_agentosdevice)r3rrrrrr)ruarr^r]s r__call__zCachingResolver.__call__&s 2 %--'  ~ %G KKG $   1 ++;q||88#qtt||/qxx A 2r N)rrr3r)rr%rrr&r)r)r*r+r,r8rrr rrrs "r r) __future__rr- dataclassesr4 collectionsrr contextvarsrtypingrrr r r r corerrr__all__rr dataclassrErrerrxrrr rrs" *"21  H &$$@ HHV I!I!X  <##r