U -WjZã@søUdZddlmZddlmZmZddlmZmZm Z m Z mZmZerNddl Z ddlmZddlmZdd lmZGd d„deƒZejZedƒZed ƒZGdd„deeƒZded<eZeeƒGdd„dƒƒZGdd„deƒZeeƒGdd„dƒƒZdS)zE Implementation of an L{IWorker} based on native threads and queues. é)Úannotations)ÚEnumÚauto)Ú TYPE_CHECKINGÚCallableÚIteratorÚLiteralÚProtocolÚTypeVarN)Úimplementeré)ÚQuit)ÚIExclusiveWorkerc@seZdZeƒZdS)ÚStopN)Ú__name__Ú __module__Ú__qualname__rÚThread©rrúic:\users\psant\downloads\hotstarbackend\school\venv38\Lib\site-packages\twisted/_threads/_threadworker.pyrsrÚTÚUc@s*eZdZdddœdd„Zddœdd„Zd S) ÚSimpleQueuerÚNone)ÚitemÚreturncCsdS©Nr)ÚselfrrrrÚput!szSimpleQueue.put©rcCsdSrr©rrrrÚget$szSimpleQueue.getN)rrrrr!rrrrr srz/Callable[[Callable[[], T | U], U], Iterator[T]]Ú smartiterc@s>eZdZdZdddœdd„Zddd œd d„Zddœd d„ZdS)Ú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. z(Callable[[Callable[[], object]], object]z8SimpleQueue[Callable[[], object] | Literal[Stop.Thread]])ÚstartThreadÚqueuecs,ˆ|_tƒ|_ddœ‡fdd„}||ƒdS)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}. rrcstˆjtƒD] }|ƒqdSr)r"r!Ú StopThread)Útask©r%rrÚworkIsz#ThreadWorker.__init__..workN)Ú_qr Ú_hasQuit)rr$r%r)rr(rÚ__init__7szThreadWorker.__init__úCallable[[], None]r)r'rcCs|j ¡|j |¡dS)z Perform the given task on the thread owned by this L{ThreadWorker}. @param task: the function to call on a thread. N)r+Úcheckr*r)rr'rrrÚdoOs zThreadWorker.dorcCs|j ¡|j t¡dS)zT Reject all future work and stop the thread started by C{__init__}. N)r+Úsetr*rr&r rrrÚquitXs zThreadWorker.quitN©rrrÚ__doc__r,r/r1rrrrr#-s r#c@s(eZdZddœdd„Zddœdd„ZdS) Ú SimpleLockÚboolrcCsdSrrr rrrÚacquirecszSimpleLock.acquirercCsdSrrr rrrÚreleasefszSimpleLock.releaseN)rrrr6r7rrrrr4bsr4c@s>eZdZdZdddœdd„Zddd œd d„Zddœd d„ZdS)Ú LockWorkerzE An L{IWorker} implemented based on a mutual-exclusion lock. r4zthreading.local)ÚlockÚlocalcCstƒ|_||_||_dS)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)rr9r:rrrr,ps zLockWorker.__init__r-r)r)rcCsŽ|j}|j}|j ¡t|ddƒ}|dkr€|dk s:tdƒ‚g}|_| |¡| ¡z|rj| d¡ƒqXW5| ¡d|_Xn | |¡dS)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)r<r=r;r.ÚgetattrÚAssertionErrorr>Úappendr6r7Úpop)rr)r9r:r>rrrr/}s z LockWorker.dorcCs|j ¡d|_dS)z* Quit this L{LockWorker}. N)r;r0r<r rrrr1—s zLockWorker.quitNr2rrrrr8js r8) r3Ú __future__rÚenumrrÚtypingrrrrr r Ú threadingZzope.interfacerZ_conveniencer Z _ithreadsrrrr&rrrÚ__annotations__Úiterr"r#r4r8rrrrÚs( 4