VhZXUdZddlmZddlmZmZddlmZmZm Z m Z m Z m Z erddl Z ddlmZddlmZdd lmZGd d eZej*Ze d Ze d ZGdde eZded<eZeeGddZGdde ZeeGddZy)zE Implementation of an L{IWorker} based on native threads and queues. ) annotations)Enumauto) TYPE_CHECKINGCallableIteratorLiteralProtocolTypeVarN) implementer)Quit)IExclusiveWorkerceZdZeZy)StopN)__name__ __module__ __qualname__rThreadN/home/dcms/DCMS/lib/python3.12/site-packages/twisted/_threads/_threadworker.pyrrs VFrrTUceZdZddZddZy) SimpleQueuecyNr)selfitems rputzSimpleQueue.put! rcyrrrs rgetzSimpleQueue.get$r"rN)r rreturnNone)r&r)rrrr!r%rrrrr   rrz/Callable[[Callable[[], T | U], U], Iterator[T]] smartiterc0eZdZdZ ddZddZddZy) 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. cN|_t|_dfd }||y)aX 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}. cRtjtD] }| yr)r)r% StopThread)taskqueues rworkz#ThreadWorker.__init__..workIs"!%))Z8  rNr&r')_qr_hasQuit)r startThreadr0r1s ` r__init__zThreadWorker.__init__7s$   Drcn|jj|jj|y)z Perform the given task on the thread owned by this L{ThreadWorker}. @param task: the function to call on a thread. N)r4checkr3r!)rr/s rdozThreadWorker.doOs$   Drcv|jj|jjty)zT Reject all future work and stop the thread started by C{__init__}. N)r4setr3r!r.r$s rquitzThreadWorker.quitXs$   JrN)r5z(Callable[[Callable[[], object]], object]r0z8SimpleQueue[Callable[[], object] | Literal[Stop.Thread]])r/Callable[[], None]r&r'r2rrr__doc__r6r9r<rrrr+r+-s)=H0 rr+ceZdZddZddZy) SimpleLockcyrrr$s racquirezSimpleLock.acquirecr"rcyrrr$s rreleasezSimpleLock.releasefr"rN)r&boolr2)rrrrCrErrrrArAbr(rrAc(eZdZdZddZddZddZy) LockWorkerzE An L{IWorker} implemented based on a mutual-exclusion lock. c>t|_||_||_y)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)rlocklocals rr6zLockWorker.__init__psV (,  rc|j}|j}|jjt |dd}|g|Jdgx}|_|j ||j |r|jd|r|jd|_y|j |y#|jd|_wxYw)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()r) rKrLrJr8getattrrPappendrCpoprE)rr1rMrNrPs rr9z LockWorker.do}szz  %D1 ?# C%C C#&( (Gem NN4 LLN %"GKKN$  $ NN4   $ s 6B;;CcF|jjd|_y)z* Quit this L{LockWorker}. N)rJr;rKr$s rr<zLockWorker.quits  rN)rMrArNzthreading.local)r1r=r&r'r2r>rrrrHrHjs !4rrH) r? __future__renumrrtypingrrrr r r threadingzope.interfacer _conveniencer _ithreadsrrrr.rrr__annotations__iterr)r+rArHrrrr^s #PP&'4[[  CL CL (1+  ;:   1 1 1 h   111r