o ¼>hZã@søUdZddlmZddlmZmZddlmZmZm Z m Z mZmZer'ddl 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ú~/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/_threads/_threadworker.pyrs rÚTÚUc@s eZdZd dd„Zddd„Zd S)ÚSimpleQueueÚitemrÚreturnÚNonecCódS©Nr)ÚselfrrrrÚput!ózSimpleQueue.putcCrrr©rrrrÚget$r zSimpleQueue.getN)rrrr)rr)rrrrr"rrrrr ó rz/Callable[[Callable[[], T | U], U], Iterator[T]]Ú smartiterc@ó.eZdZdZddd„Zddd „Zddd„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. ÚstartThreadú(Callable[[Callable[[], object]], object]Úqueueú8SimpleQueue[Callable[[], object] | Literal[Stop.Thread]]cs(ˆ|_tƒ|_d‡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ÚworkIsÿz#ThreadWorker.__init__..workN©rr)Ú_qr Ú_hasQuit)rr'r)r.rr-rÚ__init__7szThreadWorker.__init__r,úCallable[[], None]rrcCs|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)r1Úcheckr0r)rr,rrrÚdoOó zThreadWorker.docCs|j ¡|j t¡dS)zT Reject all future work and stop the thread started by C{__init__}. N)r1Úsetr0rr+r!rrrÚquitXr6zThreadWorker.quitN)r'r(r)r*)r,r3rrr/©rrrÚ__doc__r2r5r8rrrrr&-s r&c@s eZdZd dd„Zd dd„ZdS)Ú SimpleLockrÚboolcCrrrr!rrrÚacquirecr zSimpleLock.acquirercCrrrr!rrrÚreleasefr zSimpleLock.releaseN)rr<r/)rrrr=r>rrrrr;br#r;c@r%)Ú LockWorkerzE An L{IWorker} implemented based on a mutual-exclusion lock. Úlockr;Úlocalúthreading.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)rr@rArrrr2ps zLockWorker.__init__r.r3rrcCs²|j}|j}|j ¡t|ddƒ}|durR|dusJdƒ‚g}|_| |¡| ¡z|r@| d¡ƒ|s.W| ¡d|_dSW| ¡d|_dS| ¡d|_w| |¡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) rDrErCr4ÚgetattrrFÚappendr=Úpopr>)rr.r@rArFrrrr5}s* ÿ ü ÿz LockWorker.docCs|j ¡d|_dS)z* Quit this L{LockWorker}. N)rCr7rDr!rrrr8—s zLockWorker.quitN)r@r;rArB)r.r3rrr/r9rrrrr?js r?) r:Ú __future__rÚenumrrÚtypingrrrrr r Ú threadingÚzope.interfacerÚ_conveniencer Ú _ithreadsrrrr+rrrÚ__annotations__Úiterr$r&r;r?rrrrÚs* 4