o >h*@sdZddlmZddlmZmZddlmZmZm Z m Z m Z ddl m Z mZmZddlmZddlmZmZddlmZdd lmZdd lmZe d Ze d ZGd ddeZGdddeZe Z!GdddZ"dS)z twisted.python.threadpool: a pool of threads to which we dispatch tasks. In most cases you can just use C{reactor.callInThread} and friends instead of creating a thread pool directly. ) annotations)Threadcurrent_thread)AnyCallableListOptionalTypeVar) ParamSpecProtocol TypedDict)pool)contextlog) deprecated)Failure)Version_P_Rc@seZdZdddZdS)_SupportsQsizereturnintcCsdSNselfrry/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/python/threadpool.pyqsizesz_SupportsQsize.qsizeNrr__name__ __module__ __qualname__rrrrrrsrc@seZdZUded<ded<dS)_StaterminmaxN)r r!r"__annotations__rrrrr#"s  r#c@s eZdZdZdZdZdZdZdZe Z e e e dddd d d eZe eZ dBdCddZedDddZedEddZedEddZedFddZeZdGdd ZdGd!d"ZdHd$d%ZdGd&d'ZdId*d+ZdJd,d-ZdKd4d5ZdLd9d:ZdGd;d<Z dMdNd>d?Z!dGd@dAZ"dS)O ThreadPoola This class (hopefully) generalizes the functionality of a pool of threads to which work can be dispatched. L{callInThread} and L{stop} should only be called from a single thread. @ivar started: Whether or not the thread pool is currently running. @type started: L{bool} @ivar threads: List of workers currently running in this thread pool. @type threads: L{list} @ivar _pool: A hook for testing. @type _pool: callable compatible with L{_pool} FNTwistedrzthreading.current_thread)version replacement minthreadsr maxthreadsname Optional[str]csf|dksJd||ksJd|_|_|_g_dfd d }dfd d }||_dS)ac Create a new threadpool. @param minthreads: minimum number of threads in the pool @type minthreads: L{int} @param maxthreads: maximum number of threads in the pool @type maxthreads: L{int} @param name: The name to give this threadpool; visible in log messages. @type name: native L{str} rminimum is negativeminimum is greater than maximumarkwrrcs(j|di|}j||S)Nr1) threadFactory _generateNamethreadsappend)r5r6threadrrrtrackingThreadFactory`s z2ThreadPool.__init__..trackingThreadFactoryrcsjsdSjS)Nr)startedr%rrrr currentLimitgsz)ThreadPool.__init__..currentLimitN)r5rr6rrrr)r$r%r1r9_pool_team)rr/r0r1r<r>rrr__init__JszThreadPool.__init__rcCs|j}|j|jS)a For legacy compatibility purposes, return a total number of workers. @return: the current number of workers, both idle and busy (but not those that have been quit by L{ThreadPool.adjustPoolsize}) @rtype: L{int} )r@ statisticsidleWorkerCountbusyWorkerCount)rstatsrrrworkersns zThreadPool.workers list[None]cCdg|jjS)z For legacy compatibility purposes, return the number of busy workers as expressed by a list the length of that number. @return: the number of workers currently processing a work item. @rtype: L{list} of L{None} N)r@rBrDrrrrworkingzs zThreadPool.workingcCrH)a, For legacy compatibility purposes, return the number of idle workers as expressed by a list the length of that number. @return: the number of workers currently alive (with an allocated thread) but waiting for new work. @rtype: L{list} of L{None} N)r@rBrCrrrrwaiterss zThreadPool.waitersrcsGfddd}|S)z For legacy compatibility purposes, return an object with a C{qsize} method that indicates the amount of work not yet allocated to a worker. @return: an object with a C{qsize} method. cseZdZdfdd ZdS)z$ThreadPool._queue..NotAQueuerrcs jjS)a Pretend to be a Python threading Queue and return the number of as-yet-unconsumed tasks. @return: the amount of backlogged work not yet dispatched to a worker. @rtype: L{int} )r@rBbackloggedWorkCount)qrrrrs z*ThreadPool._queue..NotAQueue.qsizeNrrrrrr NotAQueuesrMr)rrMrrr_queues  zThreadPool._queueNonecCs8d|_d|_||jj}|r|j|dSdS)z' Start the threadpool. FTN)joinedr=adjustPoolsizer@rBrKgrow)rbacklogrrrstarts zThreadPool.startcC|jddS)z Increase the number of available workers for the thread pool by 1, up to the maximum allowed by L{ThreadPool.max}. r,N)r@rRrrrr startAWorkerzThreadPool.startAWorkerstrcCsd|jpt|d|jS)z Generate a name for a new pool thread. @return: A distinctive name for the thread. @rtype: native L{str} z PoolThread--)r1idrFrrrrr8szThreadPool._generateNamecCrU)zn Decrease the number of available workers by 1, by quitting one as soon as it's idle. r,N)r@shrinkrrrr stopAWorkerrWzThreadPool.stopAWorkerstater#cCs"t|d|t||j|jdS)N__dict__)setattrr'rAr$r%)rr]rrr __setstate__s zThreadPool.__setstate__cCst|j|jdS)N)r$r%)r#r$r%rrrr __getstate__szThreadPool.__getstate__funcCallable[_P, object]args_P.argsr6 _P.kwargscOs|jd|g|Ri|dS)a Call a callable object in a separate thread. @param func: callable object to be called in separate thread @param args: positional arguments to be passed to C{func} @param kw: keyword args to be passed to C{func} N)callInThreadWithCallback)rrbrdr6rrr callInThreads zThreadPool.callInThreadonResult&Optional[Callable[[bool, _R], object]]Callable[_P, _R]csR|jrdStjjdd fdd fdd_|_|jdS) a$ Call a callable object in a separate thread and call C{onResult} with the return value, or a L{twisted.python.failure.Failure} if the callable raises an exception. The callable is allowed to block, but the C{onResult} function must not block and should perform as little work as possible. A typical action for C{onResult} for a threadpool used with a Twisted reactor would be to schedule a L{twisted.internet.defer.Deferred} to fire in the main reactor thread using C{.callFromThread}. Note that C{onResult} is called inside the separate thread, not inside the reactor thread. @param onResult: a callable with the signature C{(success, result)}. If the callable returns normally, C{onResult} is called with C{(True, result)} where C{result} is the return value of the callable. If the callable throws an exception, C{onResult} is called with C{(False, failure)}. Optionally, C{onResult} may be L{None}, in which case it is not called at all. @param func: callable object to be called in separate thread @param args: positional arguments to be passed to C{func} @param kw: keyword arguments to be passed to C{func} NrrOcsjz}d}Wntyt}d}Ynwd_jdur*||d_dS|s3t|dSdS)NTF)theWork BaseExceptionrrirerr)resultok) inContextrrrr s    z6ThreadPool.callInThreadWithCallback..inContextcstjgRiSr)rcallr)rdctxrbr6rrsz5ThreadPool.callInThreadWithCallback..rrO) rPrtheContextTrackercurrentContextcontextsrmrir@do)rrirbrdr6r)rdrtrbrrr6rrgs$z#ThreadPool.callInThreadWithCallbackcCs.d|_d|_|j|jD]}|qdS)z9 Shutdown the threads in the threadpool. TFN)rPr=r@quitr9join)rr;rrrstop$s    zThreadPool.stop Optional[int]cCs|dur|j}|dur|j}|dksJd||ksJd||_||_|js)dS|j|jkr9|j|j|j|j|jkrK|j|j|jdSdS)z Adjust the number of available threads by setting C{min} and C{max} to new values. @param minthreads: The new value for L{ThreadPool.min}. @param maxthreads: The new value for L{ThreadPool.max}. Nrr3r4)r$r%r=rFr@r[rR)rr/r0rrrrQ.s   zThreadPool.adjustPoolsizecCs:td|jtd|jtd|jdS)zw Dump some plain-text informational messages to the log about the state of this L{ThreadPool}. z waiters: z workers: ztotal: N)rmsgrJrIr9rrrr dumpStatsMszThreadPool.dumpStats)r(r)N)r/rr0rr1r2r)rrG)rrrv)rrX)r]r#rrO)rr#)rbrcrdrer6rfrrO) rirjrbrkrdrer6rfrrO)NN)r/r~r0r~rrO)#r r!r"__doc__r$r%rPr=r1rr7 staticmethodrrr currentThreadr?rApropertyrFrIrJrNrLrTrVr8r\r`rarhrgr}rQrrrrrr'*sP  $           A r'N)#r __future__r threadingrrtypingrrrrr typing_extensionsr r r twisted._threadsr r?twisted.pythonrrtwisted.python.deprecatertwisted.python.failurertwisted.python.versionsrrrrr#object WorkerStopr'rrrrs