jP<UdZddlmZgdZddlZddlZddlZddlmZddl m Z ddl m Z ddlmZdd lmZmZmZmZmZmZmZdd lmZdd lmZmZmZmZdd lm Z erdd l!m"Z"m#Z#m$Z$ddl m%Z%ddl&m'Z'ddl(m)Z)edZ*dZ+de,d<Gdde-Z.e dGddee*Z/GddZ0e GddZ1GddZ2eZ3d e,d!<eZ4d"e,d#<d/d$Z5d0d%Z6d1d&Z7d2d'Z8d3d(Z9d2d)Z: d4d*Z;d5d+Zgd.Z?y)8zKSeparate caller cancellation from backend task and executor-future results.) annotations)asyncio collectionszconcurrent.futureszfilelock._errorN)deque)Future) dataclass)Lock) TYPE_CHECKINGFinalGenericLiteralNoReturnTypeVarcast)WeakKeyDictionary)_append_exception_context_fork_transition_raise_chained_errors_resolve_read_write_timeout)Timeout)AsyncGenerator AwaitableCallable)Executor) ReadWriteLock)SoftReadWriteLock_Tz Final[int]_TASKS_THREAD_IDc eZdZy) _AsyncTransitionUnavailableErrorN)__name__ __module__ __qualname__\/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/filelock/_async.pyr r 'sr%r T)frozenc*eZdZUdZded<dZded<y)_BackendOutcomeNz _T | NonevaluezBaseException | Noneerror)r!r"r#r*__annotations__r+r$r%r&r)r)+sE9"&E &r%r)ceZdZdZd dZej d dZej d dZ ddZ ddZ ddZ d dZ d d Z y )_AsyncTransitionGatea  First-in, first-out admission for the calls that transition one lock context. Each call queues a ticket, and the head of the queue holds the gate. A call that gives up removes its own ticket, so abandoned calls do not pile up behind a long holder. c@t|_t|_yN)r _queue_lockr_queueselfs r&__init__z_AsyncTransitionGate.__init__9s(,z_AsyncTransitionGate._joinxsQ    ( KK  v &4;;1$!!$' ( ( (s AAA$c|j5 |jj||j dddy#t$r YdddywxYw#1swYyxYwr0)r1r2remove ValueError_settle_head_lockedrBs r&rAz_AsyncTransitionGate._leave~sh    '  ""6*  $ $ &  ' '   ' '  ' 's-AAA A AAAA#cf|j5|jdddy#1swYyxYwr0)r1r\r3s r&rPz!_AsyncTransitionGate._settle_heads,    '  $ $ & ' ' 's'0c|jr2|jdx}js|jdyyy)Nr)r2r?rX)r4heads r&r\z(_AsyncTransitionGate._settle_head_lockeds4 ;; A 6<<> OOD ! ?;r%NreturnNone)raAsyncGenerator[None]) r8boolr9Callable[[], bool] | Noner: float | Noner;floatrarc) rCConcurrentFuture[None]r8rdr9rer:rfr;rgrarbrCrhrarb)r!r"r#__doc__r5 contextlibasynccontextmanagerrDrGr@r>rArPr\r$r%r&r.r.1sD## $ ##  0        $ . &   0       0( ''"r%r.ceZdZUdZded<y) _TaskHoldz One task's hold, as the nesting count per wrapper it entered through. A task's hold ends when its last wrapper level is released or closed. Closing one wrapper ends only the levels taken through it. zdict[object, int]depthsN)r!r"r#rjr,r$r%r&rnrns r%rnceZdZdZddZ ddZ ddZ ddZ ddZ ddZ dd  dd Z dd Z dd Z dd Z y) _TaskOwnersal Per-task ownership in front of a sync reader/writer lock that tracks threads. An async wrapper runs each call on an executor thread, and that thread does not identify the calling task. Waiting writers block new readers so a stream of readers cannot starve them. A thread lock guards the table because tasks on different event loops share it. The table stands for one backend level, taken once for all tasks. Sync code can end that level directly, with ``close()`` or a forced release on a shared singleton. The next admission then forgets the holds instead of letting more tasks join them. cht|_d|_i|_d|_d|_i|_y)NFr)r _lock_mode_holds_transitioning_waiting_writers_waitersr3s r&r5z_TaskOwners.__init__s2"&& 6: =? # !=? r%c Kt}t||}|r|dkrdntj|z} d} t |j |||||| x} t r |r| "tj| k\r t||dk(r.| s,d} |j5|xjdz c_ ddd| dn| tjz } tjtj| f| d{|j| t |j |||||| x} t r| r:|j5|xjdzc_ |jddd| d k(ry || d n td | tjz d{|j#||t%|di iy#1swY)xYw7#|j| wxYw#1swYxYw#| rG|j5|xjdzc_ |jdddw#1swYwxYwwxYw7#t $r|j#d wxYww)N)r8rF)viajoinablewaiting_writerwriteTrUrIheldgmoderorholds) _current_taskrrLrM isinstance_admitr=rrsrwrrOrK_forget_notifymax BaseException_finish_transitionrn) r4rrJr8 lock_filerzenterr{taskr:r| admissionrOs r&acquirez_TaskOwners.acquireso-gI'7Q;4D'H%;G, G6AG,G*G, 8HI>&H9I>.I6I7I;"I>G'" G,,G??HH I>I&I  I I II>II;;I>c |j5|j4|js(|s!|jj d|_|jj |x}m|j|k7r(d|d|d|dk(rdndd|dk(rdndd }t ||jj |d d z|j|< dddy |j|z } |jsg|dk(r6|jdk(r'| s%t|d i |j|< dddy |js |dk(s| sd|c|_|_ dddy|jcdddS#1swYyxYw)NzCannot acquire z lock on z: already holding a readr}z lock ( downgradeupgradez not allowed)rrUr~rTr) rsrtrvruclearget RuntimeErrorrorwrn_ticket) r4rrrrzr{r|rDmsg writers_aheads r&rz_TaskOwners._admits{ZZ "zz%d.A.A(* !!#!  --:::%)$y CW&*fn7&AB+/6>KyIX 's++#';;??3#:Q#> C  " " !11NBM&&6>djjF&:=(1#q(BDKK%!) " "*{{}6:D3D'"/ " "0<<>1 " " "sCE3A E3.#E3E33E<cVKt}|j5|jj|x}||jvr|r dddyd|d}t ||s3|j|dkDr!|j|xxdzcc< dddy|jj |} |jr dddy|j|=|jr dddyd|_|j} ddd|s#|jdd|d}t | t|d{} |jd| | y#1swYcxYw7'#t$r/ j|<|j|r nd||iwxYww)NzCannot release a lock on z3 that is not held by this task through this wrapperrUTrz that is not held by this taskr) rrsrurrorpoprvrtr_drain_cancellationr) r4forcerrzleave still_heldrrDrremovedr cancellations r&releasez_TaskOwners.releases ZZ  --6#T[[:P  2) &DKK   # #4PTVZ| # \   svF)/E  F)=E  F)(E ? F)E " F)+E >2F)1E.E,E. F) E)%F),E..8F&&F)cKd}t|j|x}trZ tt j |d{|j|t|j|x}trZ|\}}| |7|r0 t|d{xs|}|jdn||jd||y7#tj $r }|}Yd}~d}~wwxYw#|j|wxYw7n#t$r|j|r|nd|wxYww)a End the holds taken through *via*, or every hold when it is ``None``, as one transition. Leaves the backend through *leave* when that ends the last hold, and always when *via* is ``None``. Arrivals wait while it runs, so none joins a hold the backend is letting go of. A transition already under way is waited out first: a task entering through *via* must not get a hold after the wrapper is gone. A cancellation is raised once the holds are settled. Nrr) r_drop_holds_viar=_wait_until_donerrKCancelledErrorrrrr) r4rzrrrsettledr+rdroppeds r&retirez_TaskOwners.retire0s?7; D$8$8$==?OP &&w':':7'CDDD W% D$8$8$==?OP g ;4+  %8%AAQ\  # # # .    # # # .  #  $#E)) %$  % W% B  ''Z\TtSZ'[ s|$D?!CC C 2D?D?D$D%D-,D?CC:.C50C=5C::C==DD?D'D<<D?cV|j5|jr|jcdddS|0t|j}|jj nwi}t |jjD]O\}}|jj|dx}%t||i||<|jrC|j|=Q|jr| d|fcdddS|j}|duxs|du|_||fcdddS#1swYyxYw)Nr) rsrvrdictrurlistitemsrorrnrt)r4rzrrrDcountrs r&rz_TaskOwners._drop_holds_viaVs ZZ !""||~ ! !{t{{+ !!#"&t{{'8'8':";2JD$!%d!;;H(1#u(F #{{ $ D 1 2 {{sW} ! !::D"&d"2"AcTkD =# ! ! !s#DA;D/D D7DD(N)rcN|j5d|c|_|_|c|ra|jD]N\}}|jj |t ijj|jP|jdddy#1swYyxYw)NFr) rsrvrtrru setdefaultrnroupdater)r4rrrrDs r&rz_TaskOwners._finish_transitionnsZZ .3T +D E"'++-bJD$KK**4"1EFMMTTUYU`U`ab LLN    s BBB$c8t}d|j|<|Sr0)r=rxrBs r&rz_TaskOwners._ticketxs)9); $ f r%c~|j5|jj|ddddy#1swYyxYwr0)rsrxrrBs r&rz_TaskOwners._forget~s2 ZZ , MM  fd + , , ,s3<c\|jic}|_|D]}|jdyr0)rxrX)r4waitersrCs r&rz_TaskOwners._notifys1!% $F   d # $r%r`)rLiteral['read', 'write']rJrgr8rdrstrrzobjectrz"Callable[[float], Awaitable[None]]r{Callable[[], bool]rarb)rasyncio.Task[object]rrrrrzrr{rr|rdraz1Literal['held', 'enter'] | ConcurrentFuture[None]) rrdrrrzrr3Callable[[], asyncio.Future[_BackendOutcome[None]]]rrrarb)rz object | Nonerrrrrarb)rzrrazftuple[Literal['read', 'write'] | None, dict[asyncio.Task[object], _TaskHold]] | ConcurrentFuture[None])rzLiteral['read', 'write'] | Nonerz,dict[asyncio.Task[object], _TaskHold] | Nonerarb)rarhri)r!r"r#rjr5rrrrrrrrrr$r%r&rqrqsk?-U&-U -U  -U  -U-U2-U%-U -U^"""""'"" ""  ""%"""" ;""H** *  * C *'* *X$ $C $ ' $  $L! ! o!2os6?k  ,$r%rqzHFinal[WeakKeyDictionary[ReadWriteLock | SoftReadWriteLock, _TaskOwners]] _TASK_OWNERSz Final[Lock]_TASK_OWNERS_LOCKct5t5tj|x}t x}t|<|cdddcdddS#1swYnxYwdddy#1swYyxYw)zNSingleton wrappers share one sync lock, so they must share its task holds too.N)rrrrrq) sync_lockownerss r&_task_owners_forrsd  ."&&y1 1F :/:} wxYw)Nz;the executor shut down before running the lock backend callr+)rrrr)rrX)callrrrs r&settlez _run_in_executor..settlesQ >[[]F 6" %% >PC$<+<=F  >s%*AA)r#asyncio.Future[_BackendOutcome[_T]]rarb) create_futurerun_in_executor _capture_calladd_done_callback)loopexecutorfuncrrs @r&_run_in_executorrs<483E3E3GG# =$7II&Q Nr%cj t|S#t$r}t|cYd}~Sd}~wwxYwN)r*rr)r)rr+s r&rrs/,TV,, ,U++,s 2 -22c|jx}%||ur!|jx} t||||_||_t|yr0)rrr)rr+rcancellation_contexts r&rrsQ$$$1g\6Q$0$<$< < I %g/C D#*  $E% r%c|K t|d{S7 #t$r}t|cYd}~Sd}~wwxYwwrr) awaitabler+s r&_capture_awaitablers4,9_55_ ,U++,s0< < 9 49<9<) rr.r r)rrrrrrrr)rz!ReadWriteLock | SoftReadWriteLockrarq)rar)rz%asyncio.Future[_BackendOutcome[None]]razasyncio.CancelledError | None)rrrar)rzasyncio.Future[_T]rarb)rzasyncio.AbstractEventLooprzExecutor | NonerCallable[[], _T]rar)rrra_BackendOutcome[_T])rzasyncio.CancelledErrorr+rrar)rz Awaitable[_T]rar)@rj __future__r__lazy_modules__rrkrLrrconcurrent.futuresrr= dataclassesr threadingr typingr r r r rrrweakrefr filelock._apirrrrfilelock._errorrcollections.abcrrrrfilelock._read_writerfilelock._soft_rwrrrr, Exceptionr r)r.rnrqrrrrrrrrrrrr__all__r$r%r&rsDQ"V 9!RRR% $CC+23 T] !*  y  $'gbk'' \"\"~  i$i$XZkYl Vl!%;' "&  #/>FV(&, !, r%