+ jZta0t$Rt^RIHt^RIHtHt^RIHtH t H t H t H t H t ]'d^RIt^RIHt^RIHt^RIHt!RR ]4t]P,t] !R 4t] !R 4t!R R ] ],4tR]R&]t]!]4!RR44t!RR] 4t]!]4!RR44t R#)zE Implementation of an L{IWorker} based on native threads and queues. ) annotations)Enumauto) TYPE_CHECKINGCallableIteratorLiteralProtocolTypeVarN) implementer)Quit)IExclusiveWorkerc$]tRt^t]!4tRtR#)StopN)__name__ __module__ __qualname____firstlineno__rThread__static_attributes__r@/usr/lib/python3/dist-packages/twisted/_threads/_threadworker.pyrrs VFrrTUc.]tRt^ tRRltRRltRtR#) SimpleQueuec V^8dQhRRRR/#)itemrreturnNoner)formats"r __annotate__SimpleQueue.__annotate__!s   d rc R#Nr)selfrs&&rputSimpleQueue.put! rcV^8dQhRR/#)rr rr)r"s"rr#r$$s  Q rc R#r&rr's&rgetSimpleQueue.get$r*rrN)rrrrr(r.rrrrrr    rrz/Callable[[Callable[[], T | U], U], Iterator[T]] smartiterc>]tRt^-tRtRRltRRltRRltRtR #) ThreadWorkerz An L{IExclusiveWorker} implemented based on a single thread and a queue. This worker ensures exclusivity (i.e. it is an L{IExclusiveWorker} and not an L{IWorker}) by performing all of the work passed to C{do} on the I{same} thread. c V^8dQhRRRR/#)r startThreadz(Callable[[Callable[[], object]], object]queuez8SimpleQueue[Callable[[], object] | Literal[Stop.Thread]]r)r"s"rr#ThreadWorker.__annotate__7s=Hrc VaSVn\4VnRV3RllpV!V4R#)a  Create a L{ThreadWorker} with a function to start a thread and a queue to use to communicate with that thread. @param startThread: a callable that takes a callable to run in another thread. @param queue: A L{Queue} to use to give tasks to the thread created by C{startThread}. cV^8dQhRR/#rr r!r)r"s"rr#+ThreadWorker.__init__..__annotate__Is  d rcX<\SP\4F pV!4K R#r&)r1r. StopThread)taskr6s rwork#ThreadWorker.__init__..workIs!%))Z89rN)_qr _hasQuit)r'r5r6r?s&&f r__init__ThreadWorker.__init__7s)    Drc V^8dQhRRRR/#)rr>Callable[[], None]r r!r)r"s"rr#r7Os)drc pVPP4VPPV4R#)zu Perform the given task on the thread owned by this L{ThreadWorker}. @param task: the function to call on a thread. N)rBcheckrAr()r'r>s&&rdoThreadWorker.doOs$   DrcV^8dQhRR/#r:r)r"s"rr#r7Xs  d rc xVPP4VPP\4R#)zD Reject all future work and stop the thread started by C{__init__}. N)rBsetrAr(r=r-s&rquitThreadWorker.quitXs$   Jr)rBrAN rrrr__doc__rCrIrNrrrrr3r3-s0  rr3c.]tRt^btRRltRRltRtR#) SimpleLockcV^8dQhRR/#)rr boolr)r"s"rr#SimpleLock.__annotate__c   rc R#r&rr-s&racquireSimpleLock.acquirecr*rcV^8dQhRR/#r:r)r"s"rr#rVfrWrc R#r&rr-s&rreleaseSimpleLock.releasefr*rrN)rrrrrYr]rrrrrSrSbr0rrSc>]tRt^jtRtRRltRRltRRltRtR #) LockWorkerz= An L{IWorker} implemented based on a mutual-exclusion lock. c V^8dQhRRRR/#)rlockrSlocalzthreading.localr)r"s"rr#LockWorker.__annotate__ps  Z  rc <\4VnWnW nR#)z @param lock: A mutual-exclusion lock, with C{acquire} and C{release} methods. @type lock: L{threading.Lock} @param local: Local storage. @type local: L{threading.local} N)r _quit_lock_local)r'rbrcs&&&rrCLockWorker.__init__psV (,  rc V^8dQhRRRR/#)rr?rFr r!r)r"s"rr#rd}s!!)!d!rc VPpVPpVPP4\ VRR4pVfpVfQR4h.;qCnVP V4VP4V'dVP^4!4K VP4RVnR#VP V4R# TP4RTni;i)z Do the given work on this thread, with the mutex acquired. If this is called re-entrantly, return and wait for the outer invocation to do the work. @param work: the work to do with the lock held. workingNzLockWorker used after quit()) rgrhrfrHgetattrrlappendrYpopr])r'r?rbrcrls&& rrI LockWorker.do}szz  %D1 ?# C%C C#&( (Gm NN4 LLN %KKN$  $ NN4   $ s9CCCcV^8dQhRR/#r:r)r"s"rr#rdsdrc HVPP4RVnR#)z Quit this L{LockWorker}. N)rfrMrgr-s&rrNLockWorker.quits  r)rhrgrfNrPrrrr`r`js !4rr`)!__conditional_annotations__rQ __future__renumrrtypingrrrrr r threadingzope.interfacer _conveniencer _ithreadsr rrr=rrr__annotations__iterr1r3rSr`)rts@rr~s #PP&'4[[  CL CL (1+  ;:   1 1 1 h   111r