+ j~sTa0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIH t H t ^RI H t ^RI Ht^RIHt^RIHtHt^RIHt^R IHtHtHtHtHt^R IHt^R IHt^R I H!t!H"t"H#t#H$t$^R I%H&t&]'d^RI'H(t(H)t)^RIH*t*]!4t+R],R&]PZ!4s.R],R&]/!4t0R],R&!RR]14t2!RR]2R7t3!RR]Ph4t5RRlt6] !RR 44t7] !R!R"44t8R#R$lt9]Pt!]94]!]34R.t;R#)%z]Cross-process and cross-host reader/writer lock over a generation log of immutable snapshots.) annotationsN)contextmanagersuppress) dataclass)isfinite)Path) TYPE_CHECKINGFinal)WeakValueDictionary)AcquireReturnProxy _canonical_ensure_current_process_register_fork_class_register_fork_object)Timeout)LeaseCompromise) GenerationLogLedgerMode Participant)OsFiles)Callable Generator)CompromiseReasonz2Final[WeakValueDictionary[int, SoftReadWriteLock]]_ALL_INSTANCESthreading.Lock_ALL_INSTANCES_LOCKzFinal[set[Path]]_SINGLETONS_UNDER_CONSTRUCTIONc da]tRt^'t$R]R&R]R&RRRRRRR R R R R RR /RV3RlllltRtV;t#) _SoftRWMeta,WeakValueDictionary[Path, SoftReadWriteLock] _instanceszthreading.RLock_instances_lockblockingT is_singletonheartbeat_interval>@stale_thresholdN poll_interval? on_compromisec<V^8dQhRRRRRRRRRRR R R RR R RR/ #) lock_filestr | os.PathLike[str]timeoutfloatr#boolr$r%r' float | Noner(r*(Callable[[LeaseCompromise], None] | NonereturnSoftReadWriteLock)formats"X/home/luca/screen-checking/.venv/lib/python3.14/site-packages/filelock/_soft_rw/_sync.py __annotate___SoftRWMeta.__annotate__+spBB)BB  B  B"B&BB@B Bc <\4Vf/MRV/p V'g\SV`!VV3RVRVRVRVRV/V B#\V4P 4p VP ;_uu_4VP PV 4p V fV \9dRV: 2p \V 4h\P!4p \PV 4\SV`!VV3RVRVRVRVRV/V Bp \PV 4\P!4V 8wdRp \V 4hWP V &MV PV8wgV PV8wd.R V P R V P R V R V 2p \!V 4hVe#V P"V8wdR V: 2p \!V 4h\%WVV4V uuRRR4# \PT 4i;i +'giR#;i) Nr*r#r$r%r'r(z2Singleton lock construction is already active for zOLock construction cannot continue after fork; construct a new lock in the childz$Singleton lock created with timeout=z , blocking=z, cannot be changed to timeout=zCSingleton lock created with a different on_compromise callback for )r super__call__rresolver"r!getr RuntimeErrorosgetpidadddiscardr/r# ValueError_on_compromise_validate_intervals)clsr-r/r#r$r%r'r(r*extra normalizedinstancemsgconstruction_pid __class__s&&&$$$$$$ r8r>_SoftRWMeta.__call__+s; !#+/=1Q7# " *  $6  !0 ,   )_,,.  ~~))*5H!??Nym\C&s++#%99; .22:> G$w/! "* &2  ,>  )8 '4   H3:::F99;"22kC&s++-5z*!!W,0A0AX0M:8;K;K:LKX`XiXiWjk55__static_attributes__ __classcell__rOs@r8rr'se<<$$B  B " B%)B)-B $BCGBBBr;rc ]tRt^pt$Rt]!4tR]R&]P!4t R5RRRRRRR R R R R R /RRlllt ] RRl4t ]RRl4t]RRl4t]R6RR /RRlll4t]R6RR /RRlll4tR6RR /RRllltR6RR /RRlllt] R5RR/RRlll4tR R!ltR"R#/R$R%lltR&R'ltR(R)ltR*R+ltR,R-ltR.R/ltR0R1ltR2R3ltR4t R #)7r5a Cross-process and cross-host reader/writer lock for shared filesystems. Use this class instead of :class:`~filelock.ReadWriteLock` when the lock file lives on a network filesystem (NFS, Lustre, HPC cluster shared storage). ``ReadWriteLock`` is backed by SQLite and cannot run on NFS because SQLite's ``fcntl`` locking is unreliable there. The lock's state is a log of immutable snapshots under ``foo.lock.rw/gen/``, each naming the writer and the readers holding the lock at generation ``N``. Every acquire, release, and eviction publishes the next snapshot with one atomic no-replace hard link, so no transition can be left half done by a crash on any host. Each participant also keeps ``foo.lock.rw/holders/``, a record whose nonce a daemon heartbeat thread rewrites every ``heartbeat_interval`` seconds. A contender evicts a member whose record has not changed for ``stale_threshold`` seconds of the contender's own monotonic clock; no clock is ever compared across hosts, so skew between hosts or against the file server cannot make a live holder look dead. Writer acquire is writer-preferring: a writer enters the snapshot as soon as no live writer is named, which blocks any new reader, then waits for the named readers to leave. Writer starvation is impossible. An expired holder is not fenced by the lock: a process paused past ``stale_threshold`` resumes believing it holds the lock until its next heartbeat reports the loss through ``on_compromise``. :attr:`generation` is a monotonic fencing token for the protected resource: a store that rejects writes carrying a lower generation than the highest it has accepted refuses such a holder. Reentrancy, upgrade/downgrade rules, thread pinning, and singleton caching by resolved path match :class:`~filelock.ReadWriteLock`. Forking invalidates the inherited instance in the child so the child cannot double-own the lock with its parent; ``release()`` on that instance is a no-op, and the child must construct a new instance if it needs a lock. Trust boundary: protects against same-UID non-cooperating processes (one host or cross-host) and same-host different-UID users via ``0o600`` / ``0o700`` permissions. Does not protect against root compromise or multi-tenant mounts where hostile co-tenants share the UID. :param lock_file: path to the lock file; the protocol directory lives next to it as ``.rw`` :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately on contention :param is_singleton: if ``True``, reuse existing instances for the same resolved path :param heartbeat_interval: seconds between heartbeat refreshes; default 30 s :param stale_threshold: seconds a holder record may stay unchanged before a contender evicts it; defaults to ``3 * heartbeat_interval``, matching etcd's ``LeaseKeepAlive`` convention :param poll_interval: seconds between acquire retries under contention; default 0.25 s :param on_compromise: called from the heartbeat thread with a :class:`~filelock.LeaseCompromise` when the hold is lost: a peer evicted it, or refreshes failed for long enough that a peer could have .. versionadded:: 3.27.0 .. versionchanged:: 3.33.0 The on-disk protocol is a generation log; earlier releases cannot share a lock path with this one. r r!r#Tr$r%r&r'Nr(r)r*c<V^8dQhRRRRRRRRRRR R R RR R RR/ #)r,r-r.r/r0r#r1r$r%r'r2r(r*r3r4Noner6)r7s"r8r9SoftReadWriteLock.__annotate__se#$#$)#$#$  #$  #$"#$&#$#$@#$ #$r;c \P!4Vn\WVV4p\P!V4VnW nW0nWPnW`n Wpn \VP 4 R2Vn \VP 4Vn\\ P"4Vn\'VPVP VP4VnWn\-\.P0!4\.P0!4R7VnRVnRVnRVn\:;_uu_4V\<\?V4&RRR4\AV4R# +'giL;i)z.rwinternal transactionNF)!rBrC _creator_pidrHfspathr-r/r#r%r'r(r _rootr_filesrtime monotonic_ledgerr_logrG_Locks threadingLock_locks_hold _compromise_closedrridr) selfr-r/r#r$r%r'r(r*s &&&$$$$$$r8__init__SoftReadWriteLock.__init__sIIK-.@S`a ii 2% & );&5$1#4>>2337 dnn- dnn- !$++t~~tzzJ +inn&6INNDTU #' 37" '+N2d8 $!d#! s E.. E> cV^8dQhRR/#r,r4r]r6)r7s"r8r9r^s///r;c \P!4s\4Vn\P !4Vn\P4R#N) rlrmrr r!RLockr"rclear)rIs&r8_reset_class_after_fork)SoftReadWriteLock._reset_class_after_forks6(nn.,.'oo/&,,.r;cV^8dQhRR/#)r,r4 int | Noner6)r7s"r8r9r^s U UJ Ur;c VPP;_uu_4VPfRMVPPPuuRRR4# +'giR#;i)a The generation at which the current hold was granted, or ``None`` when no lock is held. Generations are monotonic across all participants and hosts, so this is a fencing token: pass it to the protected resource and have the resource reject any operation carrying a lower generation than the highest it has accepted. That refuses a holder that paused past ``stale_threshold``, was evicted, and resumed. .. versionadded:: 3.33.0 N)rnraro participant generationrss&r8rSoftReadWriteLock.generationsA[[ ! ! !::-44::3I3I3T3T" ! ! !s 0A A+ cV^8dQhRR/#)r,r4zLeaseCompromise | Noner6)r7s"r8r9r^s $ $2 $r;c VPP;_uu_4VPuuRRR4# +'giR#;i)a How the current hold was lost, or ``None`` while it stands. Set by the heartbeat thread once a peer has evicted this holder or refreshes have failed for long enough that a peer could have. The holder should stop using the protected resource when it is set. .. versionadded:: 3.33.0 N)rnrarprs&r8 compromiseSoftReadWriteLock.compromises,[[ ! ! !##" ! ! !s 6 A c$V^8dQhRRRRRR/#r,r/r2r# bool | Noner4zGenerator[None]r6)r7s"r8r9r^s";Zir;c# "VPWR7RxVP4R# TP4i;i5i)a Context manager that acquires and releases a shared read lock. Falls back to instance defaults for *timeout* and *blocking* when ``None``. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :raises RuntimeError: if a write lock is already held on this instance :raises Timeout: if the lock cannot be acquired within *timeout* seconds r#N) acquire_readreleasersr/r#s&&$r8 read_lockSoftReadWriteLock.read_locks2 '5   LLNDLLNA,A>Ac$V^8dQhRRRRRR/#rr6)r7s"r8r9r^s",Kr;c# "VPWR7RxVP4R# TP4i;i5i)a Context manager that acquires and releases an exclusive write lock. Falls back to instance defaults for *timeout* and *blocking* when ``None``. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default :raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread :raises Timeout: if the lock cannot be acquired within *timeout* seconds rN) acquire_writerrs&&$r8 write_lockSoftReadWriteLock.write_locks2 76   LLNDLLNrc$V^8dQhRRRRRR/#r,r/r2r#rr4r r6)r7s"r8r9r^s'AALAkA]oAr;c (VPRWR7#)u Acquire a shared read lock. If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acquire a read lock while holding a write lock raises :class:`RuntimeError` (downgrade not allowed). On the 0→1 transition the reader publishes its holder record, enters the next snapshot once no live writer is named, and starts a daemon heartbeat thread that rewrites the record's nonce every ``heartbeat_interval`` seconds so peers on other hosts do not evict it. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable; ``None`` uses the instance default :returns: a proxy that can be used as a context manager to release the lock :raises RuntimeError: if a write lock is already held on this instance, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises SoftFileLockProtocolError: if a snapshot cannot be read without risking overlap, or the filesystem refuses the no-replace hard links the protocol commits with readr_acquirers&&$r8rSoftReadWriteLock.acquire_reads0}}VW}@@r;c$V^8dQhRRRRRR/#rr6)r7s"r8r9r^4s'BB\B{B^pBr;c (VPRWR7#)a Acquire an exclusive write lock. If this instance already holds a write lock from the same thread, the lock level is incremented (reentrant). Attempting to acquire a write lock while holding a read lock raises :class:`RuntimeError` (upgrade not allowed). Write locks are pinned to the acquiring thread: a different thread trying to re-enter also raises :class:`RuntimeError`. A writer enters the next snapshot as its writer as soon as no live writer is named, which blocks every new reader on every host, then waits for the readers that snapshot names to leave. Writer starvation is impossible: new readers see the named writer and wait behind it. :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable; ``None`` uses the instance default :returns: a proxy that can be used as a context manager to release the lock :raises RuntimeError: if a read lock is already held, if a write lock is held by a different thread, if this instance was invalidated by :func:`os.fork`, or if :meth:`close` was called :raises Timeout: if the lock cannot be acquired within *timeout* seconds :raises SoftFileLockProtocolError: if a snapshot cannot be read without risking overlap, or the filesystem refuses the no-replace hard links the protocol commits with writerrrs&&$r8rSoftReadWriteLock.acquire_write4s6}}Wg}AAr;c(V^8dQhRRRRRRRR/#) r,r-r.r/r0r#r1r4r5r6)r7s"r8r9r^Rs2::)::  :  :r;c V!WVR7#)a Return the singleton :class:`SoftReadWriteLock` for *lock_file*. :param lock_file: path to the lock file; the protocol directory lives next to it as ``.rw`` :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable :returns: the singleton lock instance :raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values rr6)rIr-r/r#s&&&$r8get_lockSoftReadWriteLock.get_lockQs(999r;cV^8dQhRR/#rwr6)r7s"r8r9r^gs   t  r;c VP\P!48wdR#VPRR7VPP ;_uu_4RVnRRR4R# +'giR#;i)u Release any held lock and mark the instance closed. Idempotent. After calling this method the instance can no longer acquire locks — subsequent acquires raise :class:`RuntimeError`. A fork-invalidated instance is closed without raising. NTforce)rcrBrCrrnrarqrs&r8closeSoftReadWriteLock.closegsO    +  4  [[ ! ! !DL" ! ! !s A)) A: rFc V^8dQhRRRR/#)r,rr1r4r]r6)r7s"r8r9r^ts%!%!%!%!r;c VP\P!48wdR#VPP;_uu_4VP pVf;V'd RRR4R#RVP R\V4 R2p\V4hV'd ^Vn MV;P^,un VP^8d RRR4R#RVnRRR4XPP4VP\P!4Jd.VPPVP R,R7VP"P%4R# +'giL;i)a4 Release one level of the current lock. When the lock level reaches zero the heartbeat thread is stopped, the participant is committed out of the next snapshot, and its holder record is removed. On a fork-invalidated instance (that is, the child of a :func:`os.fork` call made while the parent held a lock) this method is a no-op so inherited ``with`` blocks can unwind cleanly in the child. :param force: if ``True``, release the lock completely regardless of the current lock level :raises RuntimeError: if no lock is currently held and *force* is ``False`` NzCannot release a lock on (lock id: z) that is not heldg?)r/)rcrBrCrnraror-rrrAlevelheartbeat_stopsetheartbeat_threadrlcurrent_threadjoinr%rleave)rsrholdrMs&$ r8rSoftReadWriteLock.releasets    +  [[ ! ! !::D| " ! 2$..1ARPTXJVhi"3''  a zzA~" !DJ"$ !  (@(@(B B  ! ! & &t/F/F/L & M  +" !s$E*E*).E*3E*E** E: c(V^8dQhRRRRRRRR/#) r,moderr/r2r#rr4r r6)r7s"r8r9r^s2 . . . .  .  .r;c VP\P!48wdRVP R2p\ V4hVf VP MTpVf VP MTpVPP;_uu_4VP'dRVP R2p\ V4hVPeVPV4uuRRR4#RRR4\P!4pV'g(VPPPRR7pMUVR8Xd(VPPPRR7pM'VPPPRVR7pV'g\!VP4RhVP#WWSR7VPPP%4# +'giL;i TPPP%4i;i) zSoftReadWriteLock on z4 was invalidated by fork(); construct a new instanceNz has been closedFrT)r#r/rR)rcrBrCr-rAr/r#rnrarqro_validate_reentrantrg perf_counterrbacquirer_do_acquire_innerr)rsrr/r#rMstartacquireds&&&$ r8rSoftReadWriteLock._acquires    +)$..)99mnCs# #")/$,,w$,$44==( [[ ! ! !|||-dnn-==MN"3''zz%//5 " !& "!!#{{..666FH ]{{..666EH{{..66g6VH$..)t 3 .))$)R KK # # + + -'" !& KK # # + + -sA GG$ G! $&H c ,V^8dQhRRRRRRRRRR /#) r,rreffective_timeoutr0rr#r1r4r r6)r7s"r8r9r^s<>->->-!>- >-  >- >-r;c aa a SPP;_uu_4SPeSPV4uuRRR4#RRR4VR 8XdRMW2,p\ SP SP VSP\PSPSPR7o S P4SPS PWTR7\&P(!4p\+^TTR8Xd\&P,!4MRS \/T T T3RlSP0TR\3S4R 2R7T\P!4R7o RpSPP;_uu_4S SnRSnS P6P94RRR4TeS P%4Th\;SR 7# +'giEL;i \dF\!\"4;_uu_4S P%4RRR4h +'gih;ii;i \dpRSnTpRp?LRp?ii;i +'giL;i) N)r'clockledgerlog)deadliner#rc(<SPSS4#ry)_refresh)rrrssr85SoftReadWriteLock._do_acquire_inner..s k4 @r;zfilelock-heartbeat-x)refreshinterval stop_eventname)rrwrite_thread_idrrr last_refreshlockrR)rnrarorrrfrer'rgrhrirjpublish _wait_foradvance BaseExceptionrOSErrorrrlEvent_Hold get_ident_HeartbeatThreadr%rrrprrr ) rsrrrr#rr start_errorerrorrrs f&&&$ @@r8r#SoftReadWriteLock._do_acquire_inners[[ ! ! !zz%//5" !%"-248Q! KK JJ  00..<<     NN;..N U__& 59W_I//1$#-@00%*2d8A,7  &)  $-1 [[ ! ! !DJ#D  $%%++- "  "     !t,,m" ! !  '""!!## #"   @! $! #  $ " !s_G G.I"I G+ ."H>H*! H>* H: 5 H> I II"II"" I2 c V^8dQhRRRR/#)r,rrr4r r6)r7s"r8r9r^s---1C-r;c  VPpVfQhVPV8wdGVR8XdRMRpVR8XdRMRpRV RVP R\V4 RV R V R 2 p\ V4hVR8Xd\\ P !4;qbP8wd7R VP R\V4 R V R VP 2p\ V4hV;P^, un\VR7#)Nrr downgradeupgradezCannot acquire z lock on rz): already holding a z lock (z not allowed)zCannot acquire write lock on z) from thread z while it is held by thread r) rorr-rrrArlrrrr )rsrropposite directionrMcurs&& r8r%SoftReadWriteLock._validate_reentrantszz 99 "&&.wfH'+v~ 9I!$y0@ BtH:V%%-Jgi[ O s# # 7?y':':'< <AUAUU//?{2d8*U"e#?@T@T?UW s# # a !t,,r;c(V^8dQhRRRRRRRR/#) r, predicateCallable[[], bool]rr2r#r1r4r]r6)r7s"r8r9r^s2""%" "  "  "r;c JV!4'g\P!4pV'g\VP4hVeWB8d\VP4hVPpVe\ V\ W$, R44p\P!V4KR#)Ng)rgrrr-r(minmaxsleep)rsrrr#now sleep_fors&&$$ r8rSoftReadWriteLock._wait_fors{++##%Cdnn--#dnn--**I# 3x~s+CD JJy !r;c$V^8dQhRRRRRR/#)r,rrrrr4r1r6)r7s"r8r9r^#s!Kur;c ^VP4wr4VR8Xd\P!4VnR#VR8XdVP VRR4R#\P!4VP, VP VP , 8dVP VRV4R#R#)okTlostevictedNFzrefresh-failed) heartbeatrgrhr_report_compromiser'r%)rsrroutcomers&&& r8rSoftReadWriteLock._refresh#s %..0 d? $ 0D  f   # #D)T : >> d// /43G3G$JaJa3a a  # #D*:E Br;c(V^8dQhRRRRRRRR/#) r,rrreasonrrzOSError | Noner4r]r6)r7s"r8r9r^4s* , ,u ,6F ,~ ,bf ,r;c  VVPP;_uu_4VPVJd RRR4R#\VPVP P W#R7pW@nRRR4VPeVPX4R#R# +'giL3;i)N)r-tokenrr) rnrarorr-rrrprG)rsrrrrs&&&& r8r$SoftReadWriteLock._report_compromise4s [[ ! ! !zz%" !)..0@0@0F0FvJ *  "    *    + +" !sB2B B( cV^8dQhRR/#rwr6)r7s"r8r9r^@sDr;c \\P!4\P!4R7VnRVnR#)r`N)rkrlrmrnrors&r8_reset_after_fork_in_child,SoftReadWriteLock._reset_after_fork_in_child@s%inn&6INNDTU  r;)rqrprcrfrorirnrjrGrer#r%r-r(r'r/rQry)!rSrTrUrV__doc__r r!rWrlrzr"rt classmethodr|propertyrrrrrrrrrrrrrrrrrrXr6r;r8r5r5psi2h@S?TJ<Too'O#$  #$ " #$%)#$)-#$ $#$CG#$#$J// U U $ $QU&RV&ATXAA4BUYBB::  ::*  %!u%!N .D>-@-("$" ,r;r5) metaclassc:a]tRtRtRV3RlltRRltRtV;t#)riEc ,V^8dQhRRRRRRRRR R /#) r,rrrr0rthreading.Eventrstrr4r]r6)r7s"r8r9_HeartbeatThread.__annotate__Fs< & &# & &$ &  &  &r;c N<\SV`VRR7WnW nW0nR#)T)rdaemonN)r=rtr _interval _stop_event)rsrrrrrOs&&&&&r8rt_HeartbeatThread.__init__Fs' d40 !%r;cV^8dQhRR/#rwr6)r7s"r8r9rRsTr;c VPPVP4'g5VP4'dKCVPP 4R#R#ry)rwaitrrrrs&r8run_HeartbeatThread.runRsB""''77==??  $$&8r;)rrr)rSrTrUrVrtrrXrYrZs@r8rrEs & &r;rc(V^8dQhRRRRRRRR/#)r,r%r0r'r2r(r4r6)r7s"r8r9r9Ys*ELafkpr;cF\V4'dV^8:dRV 2p\V4hVf V^,p\V4'dW8:dRV RV 2p\V4h\V4'dV^8:dRV 2p\V4hW!8dRV RV 2p\V4hV#)z4heartbeat_interval must be positive and finite, got z0stale_threshold must exceed heartbeat_interval (z) and be finite, got z/poll_interval must be positive and finite, got z-poll_interval must be below stale_threshold (z), got )rrF)r%r'r(rMs&&& r8rHrHYs & ' '+=+BDEWDXYo,q0 O $ $(M>?Q>RS""1!2 4 o M " "mq&8? Oo'=o=NgVcUdeo r;c,]tRtRt$R]R&R]R&RtR#)rkiorrarbr6N)rSrTrUrVrWrXr6r;r8rkrkosr;rkcb]tRtRt$RtR]R&R]R&R]R&R ]R &R ]R &R ]R&R]R&RtR#)riuzYEverything that exists only while a lock is held; ``None`` when the instance has no lock.intrrrrrrrrrrrr0rr6N)rSrTrUrVrrWrXr6r;r8rrus-c J J&&##r;rcV^8dQhRR/#rwr6)r7s"r8r9r9s)))r;c\\P44F5p\\4;_uu_4VP RR7RRR4K7 R# +'giKL;i)TrN)listrvaluesr Exceptionr)rLs r8_cleanup_all_instancesr&sH..01 i   4  (! 2 s A A* )<__conditional_annotations__r __future__ratexitrBrlrg contextlibrr dataclassesrmathrpathlibrtypingrr weakrefr filelock._apir r r rrfilelock._errorrfilelock._leaser _protocolrrrr_storagercollections.abcrrrrrWrmrrrtyperr5ThreadrrHrkrr&register__all__)r's@r8r:s c"  /!''$+??30EXEZBZ&/nn&6^6365 08F$FRR+Rjy''(,          ) &'&' r;