o 0׾gx@sddlmZddlmZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddgZ$ddZ%efddZ&efddZ'GdddeZ(Gd ddeZ)Gd!d"d"e*Z+e+Z+Gd#dde*Z,zddl-Z.Wn e/yYdSwe$0d$dd%l1m2Z3dd&l4m5Z5dd'l-m6Z7d(d)Z8d*d+Z9Gd,d-d-e*Z:Gd.d$d$e.j;j<Zz<%s at 0x%x thread_ident=0x%x>) __class____name__id thread_ident)hubr[/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/threadpool.py _format_hub%s rcCd|jvr |jdjSdSN threading)modules _profile_hook_sysrrr_get_thread_profile-  r'cCr r!)r# _trace_hookr%rrr_get_thread_trace2r(r*c@seZdZdZdZejZee Z dZ dZ dZ dZddZeefddZd d Zed d Zeeefd dZefddZddZddZddZefddZdS)_WorkerGreenletTrNcCst||j|_tdrtdd}ntj}||_ |j |_ |j |_ |j|_|j|_||z t|jdWdS||)Nsysstderrr) RawGreenlet__init__r_hubris_module_patched get_originalr-r._stderr task_queue _task_queueallocate_cookie_task_queue_cookie_unregister_worker_idle_task_timeout_register_workerr_begin)self threadpoolr.rrrr0Ps     z_WorkerGreenlet.__init__cCs4||_||_d|j_z|WdSYdSNT)parent _thread_identgreenlet_tree_is_ignoredswitch)r=_get_c_get_tirrrr<osz_WorkerGreenlet._begincCs@|}|durd|_|dur|jdur|j||_dSdS)NzThreadPool Worker Hub)_get_hub_if_existsnameperiodic_monitoring_thread ignore_current_greenlet_blocking_hub_of_worker)r=rrrr__fixup_hub_before_blocks  z(_WorkerGreenlet.__fixup_hub_before_blockcCsR|dur'|j}|j}|j}|j}|j}td|||f|d|j}|dusdSdS)Nz File "%s", line %d, in %sfile)tb_frame tb_linenof_code co_filenameco_nameprinttb_next)tbr.flinenocofilenamerGrrr __print_tbsz_WorkerGreenlet.__print_tbcCs||||dSN setprofilesettrace)r=funcargskwargs thread_resultr&r'r*rrr_before_run_tasks z _WorkerGreenlet._before_run_taskcCs|d|ddSr[r\)r=r_r`rarbr&rrr_after_run_tasks z_WorkerGreenlet._after_run_taskc Cs|||||z9z |||i|Wn|||f|YW|||||~~~~dSW|||||~~~~dS|||||~~~~wr[)rcset handle_error _exc_inford)r=r_r`rarbrrr __run_tasks   z_WorkerGreenlet.__run_taskc Csxd}tj}|j}|jj}|j}|j}|jj}|j}zzh |z|||}Wnt y9YWW| | dSwz:z#|durYWWt |t sIdn|}|WW| | dS||Wnt|}Wt |t sodn|}|n t |t s|dn|}|wqty} ztd|| f|jd||d|jWYd} ~ nd} ~ wwW| | dS| | w)Nz1Failed to run worker thread. Task=%r Exception=%rrLr,)r-exc_info'_WorkerGreenlet__fixup_hub_before_blockr6getr8_WorkerGreenlet__run_task task_doner:rcleanuprF isinstancestrrepr ExceptionrSr4_WorkerGreenlet__print_tb) r=taskrjfixup_hub_before_blocktask_queue_gettask_queue_cookierun_tasktask_queue_doneidle_task_timeouterrrrunsZ    "z_WorkerGreenlet.runcCsJ|jdurd|_||dd|_d|_d|_|dur#|ddSdS)NcSdSr[r_rrrz)_WorkerGreenlet.cleanup..T)r1r9r6r8destroy)r= hub_of_workerrrrros   z_WorkerGreenlet.cleanupcCsdt||j||jfS)Nz>)rrAr1r=rrrr__repr__s z_WorkerGreenlet.__repr__)r __module__ __qualname__greenlet_tree_is_rootrAr-rjrg staticmethodr rFrJr1r8r:r0r rr<rkrtr'r*rcrdrmr}rorrrrrrr+7s.   - r+c@seZdZdZdZeZd0ddZddZd d Zd d Z d dZ e e e ddZ e fddZddZddZddZe eeddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/ZdS)1ra\ A pool of native worker threads. This can be useful for CPU intensive functions, or those that otherwise will not cooperate with gevent. The best functions to execute in a thread pool are small functions with a single purpose; ideally they release the CPython GIL. Such functions are extension functions implemented in C. It implements the same operations as a :class:`gevent.pool.Pool`, but using threads instead of greenlets. .. note:: The method :meth:`apply_async` will always return a new greenlet, bypassing the threadpool entirely. Most users will not need to create instances of this class. Instead, use the threadpool already associated with gevent's hub:: pool = gevent.get_hub().threadpool result = pool.spawn(lambda: "Some func").get() .. important:: It is only possible to use instances of this class from the thread running their hub. Typically that means from the thread that created them. Using the pattern shown above takes care of this. There is no gevent-provided way to have a single process-wide limit on the number of threads in various pools when doing that, however. The suggested way to use gevent and threadpools is to have a single gevent hub and its one threadpool (which is the default without doing any extra work). Only dispatch minimal blocking functions to the threadpool, functions that do not use the gevent hub. The `len` of instances of this class is the number of enqueued (unfinished) tasks. Just before a task starts running in a worker thread, the values of :func:`threading.setprofile` and :func:`threading.settrace` are consulted. Any values there are installed in that thread for the duration of the task (using :func:`sys.setprofile` and :func:`sys.settrace`, respectively). (Because worker threads are long-lived and outlast any given task, this arrangement lets the hook functions change between tasks, but does not let them see the bookkeeping done by the worker thread itself.) .. caution:: Instances of this class are only true if they have unfinished tasks. .. versionchanged:: 1.5a3 The undocumented ``apply_e`` function, deprecated since 1.1, was removed. .. versionchanged:: 20.12.0 Install the profile and trace functions in the worker thread while the worker thread is running the supplied task. .. versionchanged:: 22.08.0 Add the option to let idle threads expire and be removed from the pool after *idle_task_timeout* seconds (-1 for no timeout) ) r_maxsizemanagerpid fork_watcher&_available_worker_threads_greenlet_sem_worker_greenletsr5r:Nr,cCsp|durt}||_t|_d|_t|_d|_||_ t |_ d|_ t d||_|||jjdd|_dS)NrriF)ref)get_hubrosgetpidrrrr5rr:rerrrr _set_maxsizeloopfork)r=maxsizerr{rrrr0Is   zThreadPool.__init__cC|j|dSr[)raddr=workerrrrr;[zThreadPool._register_workercCrr[)rdiscardrrrrr9^rzThreadPool._unregister_workercCsdt|ts td|f|dkrtd|f||j}|jj|7_||_||jdS)Nzmaxsize must be integer: %rrz maxsize must not be negative: %r) rpr TypeError ValueErrorrrcounteradjust _start_notify)r=r differencerrrras  zThreadPool._set_maxsizecCs|jSr[)rr=rrr _get_maxsizemszThreadPool._get_maxsizea9 The maximum allowed number of worker threads. This is also (approximately) a limit on the number of tasks that can be queued without blocking the waiting greenlet. If this many tasks are already running, then the next greenlet that submits a task will block waiting for a task to finish. )doccCs*d|jjt|t||j|j||jfS)Nz/<%s at 0x%x tasks=%s size=%s maxsize=%s hub=%s>)rrrlensizerrrrrrrys zThreadPool.__repr__cCs|jjSr[)r5unfinished_tasksrrrr__len__szThreadPool.__len__cC t|jSr[)rrrrrr _get_size zThreadPool._get_sizecCs|dkr td|f||jkrtd||jf|jr!|jt|j|kr3|t|j|ks(|jjj }t|j|krtt|j||j j kr[|j dt|j||j j ksJt |jurbnt|t|dd}t|j|ks?|jr|j|jdS|jdS)Nrz'Size of the pool cannot be negative: %rz7Size of the pool cannot be bigger than maxsize: %r > %r皙?)rrrkillrr _add_threadrrapprox_timer_resolutionr5rputr rminrstart_on_forkstop)r=rdelayrrr _set_sizes,     zThreadPool._set_sizea. The number of running pooled worker threads. Setting this attribute will add or remove running worker threads, up to `maxsize`. Initially there are no pooled running worker threads, and threads are created on demand to satisfy concurrent requests up to `maxsize` threads. cCsvt}||jkr9tt}t|jD]}||j }t || |j |j q|j||jdSdSr[)rrrdictr-_current_frameslistrrlrArrorJ__dict__clearr5rr0r)r=rthread_ident_to_framerframerrrrs      zThreadPool._on_forkcCsFtd|jjj}|jjdkr!t|t|dd}|jjdksdSdS)z6Waits until all outstanding tasks have been completed.gMb@?rrrN)maxrrrr5rrrr=rrrrjoins  zThreadPool.joincCsd|_|jdS)Nr)rrcloserrrrrzThreadPool.killcCst|j|jkr&|jjt|jkr&|t|j|jkr&|jjt|jkst|j|j|jjkrD|jdt|j|j|jjks2|jrP|j|j dS|jdur\|j dSdSr[) rrrr5rrrrrrrrrrr _adjust_steps  zThreadPool._adjust_stepcCs@|jjj} |t|j|jkrdSt|t|dd}q)NTrr) rrrrrrrrrrrrr _adjust_waits zThreadPool._adjust_waitcCs8||jst|j|jkrt|j|_dSdSdSr[)rrrrrr spawnrrrrrrszThreadPool.adjustcCs||dSr[)r+rrrrrszThreadPool._add_threadcOs|jtkrt |j}|||jurnq t}|j}d}zt||j|j}| ||||f| W|S|durC| |)a Add a new task to the threadpool that will run ``func(*args, **kwargs)``. Waits until a slot is available. Creates a new native thread if necessary. This must only be called from the native thread that owns this object's hub. This is because creating the necessary data structures to communicate back to this thread isn't thread safe, so the hub must not be running something else. Also, ensuring the pool size stays correct only works within a single thread. :return: A :class:`gevent.event.AsyncResult`. :raises InvalidThreadUseError: If called from a different thread. .. versionchanged:: 1.5 Document the thread-safety requirements. riN) rrr racquirerr5rreleaserrdestroy_in_main_thread)r=r_r`ra semaphoreresultr5rbrrrrs*    zThreadPool.spawncCs t|juSr[)rrrrrr_apply_immediately*s zThreadPool._apply_immediatelycCs ||dSr[r)r=callbackrrrr_apply_async_cb_spawn2 z ThreadPool._apply_async_cb_spawncCdSr?rrrrr_apply_async_use_greenlet5sz$ThreadPool._apply_async_use_greenlet)Nr,)rrr__doc__ __slots__r+r0r;r9rrpropertyrrrrrrrrrrrrrrrrrrrrrrrs49     5 c@s0eZdZddZeZZddZddZeZdS) _FakeAsynccCr~r[rrrrrsend;z_FakeAsync.sendcCr)zfake out for 'receiver'Nr)r=rrrr__call__?rz_FakeAsync.__call__cCr)NFrrrrr__bool__Brz_FakeAsync.__bool__N) rrrrrrrr __nonzero__rrrrr9s rc@sPeZdZdZdZddZeddZddZd d Z d d Z d dZ ddZ dS)ra A one-time event for cross-thread communication. Uses a hub's "async" watcher capability; it must be constructed and destroyed in the thread running the hub (because creating, starting, and destroying async watchers isn't guaranteed to be thread safe). )rj async_watcher_call_when_readyvaluecontextrreceivercCsB||_||_d|_d|_d|_|j|_||_|j |j dS)Nr) rrrrrjrasync_rrr _on_async)r=rrcall_when_readyrrrr0Vs zThreadResult.__init__cCs|jr|jdSdS)Nri)rjrrrr exception`szThreadResult.exceptionc Cs|j}t|_||z>||jr"|jj|jg|jRd|_t|_d|_t|_| |Wt|_ d|_ |jrK|jd|jddf|_dSdSt|_ d|_ |jrb|jd|jddf|_w)Nrri) rrrrrrjrrfrrr)r=awrrrrds, zThreadResult._on_asynccCs6|j|jt|_d|_d|_t|_t|_dS)zK This must only be called from the thread running the hub. N)rrrrrrrrrrrrrs   z#ThreadResult.destroy_in_main_threadcCs||_|jdSr[)rrr)r=rrrrrerzThreadResult.setcCs||_||_|jdSr[)rrjrr)r=rrjrrrrfszThreadResult.handle_errorcCs |jduSr[)rrrrr successfulrzThreadResult.successfulN) rrrrrr0rrrrrerfrrrrrrIs    ThreadPoolExecutor)Timeout)Lazy)_basecfdd}|S)Nc s<~zWdStyjfdddYdSwr[)rsrprint_exceptionrfn future_proxyrrcbwraps  z_ignore_error..cbwrapr)rrrrrr _ignore_errors rcr)Ncs dSr[rrrrrrVrz_wrap..fr)rrrVrrr_wrapsrc@s|eZdZddZeddZeddZddZed d Z d d Z dddZ dddZ ddZ ddZddZddZd S) _FutureProxycCs ||_dSr[) asyncresult)r=rrrrr0rz_FutureProxy.__init__cCs*tds |rddl}|Std)Nr"r _condition)rr2doner" ConditionAttributeError)r=r"rrrrsz_FutureProxy._conditioncCs|j|jgSr[)rrawlink_FutureProxy__when_donerrrr_waiterssz_FutureProxy._waiterscCs6t|d}|D]}|r||q||qdS)Nr)getattrr add_result add_exception)r=rwaiterswrrr __when_dones   z_FutureProxy.__when_donecCs|rtjStjSr[)rcfbFINISHEDRUNNINGrrrr_statesz_FutureProxy._statecCr~r[rrrrrset_running_or_notify_cancelz)_FutureProxy.set_running_or_notify_cancelNcCs*z|jj|dWStytjwN)timeout)rrGTimeout concurrentfutures TimeoutErrorr=r rrrrs   z_FutureProxy.resultcCs2z |jj|d|jjWStytjwr )rrlrr r rrrrrrrs    z_FutureProxy.exceptioncCs*|r ||dS|jt||dS)z&Exceptions raised by *fn* are ignored.N)rrrrr=rrrradd_done_callbacks z_FutureProxy.add_done_callbackcCs|jt||dSr[)rrrrrrrrsz_FutureProxy.rawlinkcCrr[)rqrrrrr__str__rz_FutureProxy.__str__cCs t|j|Sr[)rr)r=rGrrr __getattr__rz_FutureProxy.__getattr__r[)rrrr0rrrrrrrrrrrrrrrrrrs       rcsBeZdZdZfddZddZd fdd ZeZd d ZZ S) ra A version of :class:`concurrent.futures.ThreadPoolExecutor` that always uses native threads, even when threading is monkey-patched. The ``Future`` objects returned from this object can be used with gevent waiting primitives like :func:`gevent.wait`. .. caution:: If threading is *not* monkey-patched, then the ``Future`` objects returned by this object are not guaranteed to work with :func:`~concurrent.futures.as_completed` and :func:`~concurrent.futures.wait`. The individual blocking methods like :meth:`~concurrent.futures.Future.result` and :meth:`~concurrent.futures.Future.exception` will always work. .. versionadded:: 1.2a1 This is a provisional API. cs&tt|j|i|t|j|_dS)a. Takes the same arguments as ``concurrent.futures.ThreadPoolExecuter``, which vary between Python versions. The first argument is always *max_workers*, the maximum number of threads to use. Most other arguments, while accepted, are ignored. N)superrr0r _max_workers _threadpool)r=r`rarrrr0szThreadPoolExecutor.__init__cOsZ|j |jr td|jj|g|Ri|}t|WdS1s&wYdS)Nz*cannot schedule new futures after shutdown)_shutdown_lock _shutdown RuntimeErrorrrr)r=rr`rafuturerrrsubmits $zThreadPoolExecutor.submitTc s>tt|j|fi|t|jdd}|r|jd|_dS)Nr)rrshutdownrrr)r=waitrarrrrr%s   zThreadPoolExecutor.shutdowncCr~r[rrrrr_adjust_thread_count0r z'ThreadPoolExecutor._adjust_thread_count)T) rrrrr0rrrr  __classcell__rrrrrs   )= __future__rrrrr-rr/geventrgevent._compatr gevent.eventrgevent.exceptionsr gevent.greenletr gevent._hub_localr gevent.hubr rr r gevent.lockr gevent.poolr gevent.utilrgevent._threadingrrrr__all__rr'r*r+robjectrrconcurrent.futuresr  ImportErrorappendgevent.timeoutrr  gevent._utilrrrrrrrrrrrrsb                      >GR       I