o 0׾g@sdZddlmZmZddlmZddlZddlZddl m Z ddl m Z ddl m Z ddl m Zgd Zdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z"ddlm#Z$ddlm%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+e+j,Z-e+j.Z/ddl0m1Z1ddl0m2Z2ddl3m4Z4e5ej6Z7e7Z8ddZ9d/d!d"Z:d0d#d$Z;e fd%d&Zd1d)d*Z?Gd+d,d,e)Z@e%e@Gd-d.d.e=ZAdS)2z Event-loop hub. )absolute_importprint_function)partialN)greenlet) getcurrent) GreenletExit)error) rr spawn_rawsleepkillsignalreinitget_hubHubWaiter)config)thread_mod_name)reraise) readproperty)Lazy)gmctime IdentRegistry)r)get_loop)set_hub)set_loop)get_hub_if_exists)get_hub_noargs)set_default_hub_class)TrackedRawGreenlet)WaitOperationsGreenlet)_hub_primitives)LoopExit) HubDestroyed)rcOst|stdt}|j}tjrtnt}|r.t|g|Ri|}|||}| |j n|||}|j |j g|R|j|_|S)a Create a new :class:`greenlet.greenlet` object and schedule it to run ``function(*args, **kwargs)``. This returns a raw :class:`~greenlet.greenlet` which does not have all the useful methods that :class:`gevent.Greenlet` has. Typically, applications should prefer :func:`~gevent.spawn`, but this method may occasionally be useful as an optimization if there are many greenlets involved. .. versionchanged:: 1.1a3 Verify that ``function`` is callable, raising a TypeError if not. Previously, the spawned greenlet would have failed the first time it was switched to. .. versionchanged:: 1.1b1 If *function* is not callable, immediately raise a :exc:`TypeError` instead of spawning a greenlet that will raise an uncaught TypeError. .. versionchanged:: 1.1rc2 Accept keyword arguments for ``function`` as previously (incorrectly) documented. Note that this may incur an additional expense. .. versionchanged:: 1.3a2 Populate the ``spawning_greenlet`` and ``spawn_tree_locals`` attributes of the returned greenlet. .. versionchanged:: 1.3b1 *Only* populate ``spawning_greenlet`` and ``spawn_tree_locals`` if ``GEVENT_TRACK_GREENLET_TREE`` is enabled (the default). If not enabled, those attributes will not be set. .. versionchanged:: 1.5a3 The returned greenlet always has a *loop* attribute matching the current hub's loop. This helps it work better with more gevent APIs. zfunction must be callable) callable TypeError_get_hub_noargsloop GEVENT_CONFIGtrack_greenlet_treer RawGreenlet_functools_partial run_callbackswitch)functionargskwargshubr'factorygr4T/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/hub.pyr Fs$  r TcCs|t}|j}|dkrt|}||jd|dS|j||d}|||WddS1s7wYdS)a Put the current greenlet to sleep for at least *seconds*. *seconds* may be specified as an integer, or a float if fractional seconds are desired. .. tip:: In the current implementation, a value of 0 (the default) means to yield execution to any other runnable greenlets, but this greenlet may be scheduled again before the event loop cycles (in an extreme case, a greenlet that repeatedly sleeps with 0 can prevent greenlets that are ready to do I/O from being scheduled for some (small) period of time); a value greater than 0, on the other hand, will delay running this greenlet until the next iteration of the loop. If *ref* is False, the greenlet running ``sleep()`` will not prevent :func:`gevent.wait` from exiting. .. versionchanged:: 1.3a1 Sleeping with a value of 0 will now be bounded to approximately block the loop for no longer than :func:`gevent.getswitchinterval`. .. seealso:: :func:`idle` rNref) r&r'rr,r-gettimer update_nowwait)secondsr7r1r'waitertr4r4r5r s  "r cCsJt}|j}|r||_||WddS1swYdS)aO Cause the calling greenlet to wait until the event loop is idle. Idle is defined as having no other events of the same or higher *priority* pending. That is, as long as sockets, timeouts or even signals of the same or higher priority are being processed, the loop is not idle. .. seealso:: :func:`sleep` N)r&r'idlepriorityr;)r@r1watcherr4r4r5r?s   "r?cCs<|jst|dr|j|dddStj|j|dSdS)a% Kill greenlet asynchronously. The current greenlet is not unscheduled. .. note:: The method :meth:`Greenlet.kill` method does the same and more (and the same caveats listed there apply here). However, the MAIN greenlet - the one that exists initially - does not have a ``kill()`` method, and neither do any created with :func:`spawn_raw`, so you have to use this function. .. caution:: Use care when killing greenlets. If they are not prepared for exceptions, this could result in corrupted state. .. versionchanged:: 1.1a2 If the ``greenlet`` has a :meth:`kill ` method, calls it. This prevents a greenlet from being switched to for the first time after it's been killed but not yet executed. r F) exceptionblockN)deadhasattrr r&r'r,throw)rrBr4r4r5r s  r c@sFeZdZdZdZddZeddddZdd Zd d Z d d Z dS)r a signal_handler(signalnum, handler, *args, **kwargs) -> object Call the *handler* with the *args* and *kwargs* when the process receives the signal *signalnum*. The *handler* will be run in a new greenlet when the signal is delivered. This returns an object with the useful method ``cancel``, which, when called, will prevent future deliveries of *signalnum* from calling *handler*. It's best to keep the returned object alive until you call ``cancel``. .. note:: This may not operate correctly with ``SIGCHLD`` if libev child watchers are used (as they are by default with `gevent.os.fork`). See :mod:`gevent.signal` for a more general purpose solution. .. versionchanged:: 1.2a1 The ``handler`` argument is required to be callable at construction time. .. versionchanged:: 20.5.1 The ``cancel`` method now properly cleans up all native resources, and drops references to all the arguments of this function. NcOsvt|stdt|_|jjj|dd|_||_||_||_ |j dur2ddl m }|t |_ ||_ |j|jdS)Nz signal handler must be callable.Fr6r)Greenlet)r$r%r&r1r'r rAhandlerr/r0greenlet_classgeventrGtypestart_start)self signalnumrHr/r0rGr4r4r5__init__s   zsignal.__init__cCs|jjSN)rAr7rNr4r4r5szsignal.cCst|jd|S)Nr7)setattrrA)rNnvr4r4r5rSscCsF|jdur|j|jd|_d|_d|_d|_d|_d|_dSrQ)rAstopcloserHr/r0r1rIrRr4r4r5cancels    z signal.cancelcCs@z ||j}|WdS|jjdgtRYdSrQ)rIhandler-r1 handle_errorsys _exc_info)rNrr4r4r5rM"s  z signal._startcCs@z |j|ji|jWdS|jjdgtRYdSrQ)rHr/r0r1rZr[exc_inforRr4r4r5rY*sz signal.handle) __name__ __module__ __qualname____doc__rIrPpropertyr7rXrMrYr4r4r4r5r s! r cCsT|durtn|}|durdS|j|j|j|jfD] }t|dddqdS)a reinit() -> None Prepare the gevent hub to run in a new (forked) process. This should be called *immediately* after :func:`os.fork` in the child process. This is done automatically by :func:`gevent.os.fork` or if the :mod:`os` module has been monkey-patched. If this function is not called in a forked process, symptoms may include hanging of functions like :func:`socket.getaddrinfo`, and the hub's threadpool is unlikely to work. .. note:: Registered fork watchers may or may not run before this function (and thus ``gevent.os.fork``) return. If they have not run, they will run "soon", after an iteration of the event loop. You can force this by inserting a few small (but non-zero) calls to :func:`sleep` after fork returns. (As of gevent 1.1 and before, fork watchers will not have run, but this may change in the future.) .. note:: This function may be removed in a future major release if the fork process can be more smoothly managed. .. warning:: See remarks in :func:`gevent.os.fork` about greenlets and event loop watchers in the child process. N_on_forkcSsdSrQr4r4r4r4r5rSiszreinit..)_get_hubr'r _threadpool _resolverperiodic_monitoring_threadgetattr)r1objr4r4r5r 1s r c@s.eZdZdZeeefZeefZ dZ dZ dZ dZ dZd6ddZedd Zed d Zed d ZeddZddZddZddZd7ddZeddZddZddZddZd7d d!Zd7d"d#Z ed$d%Z!d&d'Z"d(d)Z#d*d+Z$ee"e#e$d,Z%ed-d.Z&d/d0Z'd1d2Z(d3d4Z)ee'e(e)d5Z*dS)8ra A greenlet that runs the event loop. It is created automatically by :func:`get_hub`. .. rubric:: Switching Every time this greenlet (i.e., the event loop) is switched *to*, if the current greenlet has a ``switch_out`` method, it will be called. This allows a greenlet to take some cleanup actions before yielding control. This method should not call any gevent blocking functions. NrcCst|ddt|_t|dr|durtd||_n$tdur&t|_n|dur1|jtkr1d}|dur8|j }|j ||d|_d|_ d|_ t j|_tjd7_tj|_dS)NrunzUnexpected argument: defaultF)flagsdefault)r rPget_thread_ident thread_identrEr%r'rMAIN_THREAD_IDENTbackend loop_classrfrer(format_contextr _hub_counter minimal_ident)rNr'rnr4r4r5rPs$    z Hub.__init__cCstSrQrrRr4r4r5ident_registryzHub.ident_registrycCtjSrQ)r(r'rRr4r4r5rtryzHub.loop_classcCrzrQ)r( libev_backendrRr4r4r5rsryz Hub.backendcCs |jtkS)zW Is this the hub for the main thread? .. versionadded:: 1.3b1 )rqrrrRr4r4r5main_hubs z Hub.main_hubc Cs|jdurd}n$z|j}Wnty+}zt|p t|p d}WYd}~nd}~wwd|jj|jt||f}|j durE|d|j 7}|j durQ|d|j 7}|dt |j f7}|dS)N destroyedrz<%s %r at 0x%x %sz resolver=%rz threadpool=%rz thread_ident=%s>) r'_format Exceptionstrrepr __class__r^nameidrfrehexrq)rNinfoexresultr4r4r5__repr__s(    z Hub.__repr__cCs8|||fdkrt\}}}t|tr||}|||fS)N)NNN)r[r] isinstancer)rNr>vtbr4r4r5_normalize_exceptions   zHub._normalize_exceptioncCsn||||\}}}|turt|||t||js"||||||dus,t||jr5||||dSdS)a$ Called by the event loop when an error occurs. The default action is to print the exception to the :attr:`exception stream `. The arguments ``type``, ``value``, and ``tb`` are the standard tuple as returned by :func:`sys.exc_info`. (Note that when this is called, it may not be safe to call :func:`sys.exc_info`.) Errors that are :attr:`not errors ` are not printed. Errors that are :attr:`system errors ` are passed to :meth:`handle_system_error` after being printed. Applications can set a property on the hub instance with this same signature to override the error handling provided by this class. This is an advanced usage and requires great care. This function *must not* raise any exceptions. :param context: If this is ``None``, indicates a system error that should generally result in exiting the loop and being thrown to the parent greenlet. N)rr#r issubclass NOT_ERRORprint_exception SYSTEM_ERRORhandle_system_error)rNcontextrKvaluerr4r4r5rZs  zHub.handle_errorcCst}||us||jus|jdur|j|||dSd}z |j|j}Wn tj|jdYz|j|||W|durF| dSdS|durQ| ww)a Called from `handle_error` when the exception type is determined to be a :attr:`system error `. System errors cause the exception to be raised in the main greenlet (the parent of this hub). .. versionchanged:: 20.5.1 Allow passing the traceback to associate with the exception if it is rethrown into the main greenlet. Nfile) rparentr'rFr,r- traceback print_excexception_streamrV)rNrKrrcurrentcbr4r4r5r!s   zHub.handle_system_errorcCs&trtjnd}t|jdkr|j}|S)z The stream to which exceptions will be written. Defaults to ``sys.stderr`` unless assigned. Assigning a false (None) value disables printing exceptions. .. versionadded:: 1.2a1 NFileObjectThread)r[stderrrKr^io)rNrr4r4r5r>szHub.exception_streamcCs|j}|sdS||||\}}}|dur|d|jn tj||||d~z|t||dur7dndWnY|durot|ts`z| |}Wntj |jdt |}Y|d|t |ddfdSdS)Nz%s r  z%s failed with %s r^rB) rrwriter^rrrrrrurrrh)rNrr>rr errstreamr4r4r5rQs,   zHub.print_exceptioncCsx|tus Jd| |j}||_z |Wd|_nd|_wg}t|dr-|}d}|jt d||d}q)a Entry-point to running the loop. This method is called automatically when the hub greenlet is scheduled; do not call it directly. :raises gevent.exceptions.LoopExit: If the loop finishes running. This means that there are no other scheduled greenlets, and no active watchers or servers. In some situations, this indicates a programming error. zDo not call Hub.run() directlyroNdebugz"This operation would block forever) r start_periodic_monitoring_threadr' error_handlerrlrErrrFr")rNr'rr4r4r5rlws$    zHub.runcCsb|jdur.tjr.ddlm}ddlm}ddlm}|||_|jr'|j |||j|jS)Nr)PeriodicMonitoringThread)!PeriodicMonitorThreadStartedEvent)notify_and_call_entry_points) rgr(monitor_threadgevent._monitorr gevent.eventsrrr|install_monitor_memory_usage)rNrrrr4r4r5rs     z$Hub.start_periodic_monitoring_threadcCst|jus Jd|jrdSt|}|dur&|jj|dd}||jdz3z|Wnt yGYW~~|durD| | ~dSwW~~|durW| | ~dS~~|durh| | ~w)a8 Wait for the event loop to finish. Exits only when there are no more spawned greenlets, started servers, active timeouts or watchers. .. caution:: This doesn't clean up all resources associated with the hub. For that, see :meth:`destroy`. :param float timeout: If *timeout* is provided, wait no longer than the specified number of seconds. :return: `True` if this method returns because the loop finished execution. Or `False` if the timeout expired. z$only possible from the MAIN greenletTNFr6) rrrDrr'r9rLr-r8r"rVrW)rNtimeoutr=r4r4r5joinsB   zHub.joincCs|dur |jj }|jdur|jd|_|jdur"|j|`|jdur.|j|`z |t|Wnt y@Yn t yHYnw|r[t |jurUt d|j nt |jd|_t|urntddSdS)a Destroy this hub and clean up its resources. If you manually create hubs, or you use a hub or the gevent blocking API from multiple native threads, you *should* call this method before disposing of the hub object reference. Ideally, this should be called from the same thread running the hub, but it can be called from other threads after that thread has exited. Once this is done, it is impossible to continue running the hub. Attempts to use the blocking gevent API with pre-existing objects from this native thread and bound to this hub will fail. .. versionchanged:: 20.5.1 Attempt to ensure that Python stack frames and greenlets referenced by this hub are cleaned up. This guarantees that switching to the hub again is not safe after this. (It was never safe, but it's even less safe.) Note that this only works if the hub is destroyed in the same thread it is running in. If the hub is destroyed by a different thread after a ``fork()``, for example, expect some garbage to leak. N)r'rnrgr rfrWrerFr#r" GreenletErrorrrdestroyrdr)rN destroy_loopr4r4r5rs6               z Hub.destroycCrzrQ)r(resolverrRr4r4r5resolver_classCryzHub.resolver_classcCs|jdur |j|d|_|jS)N)r1)rfrrRr4r4r5 _get_resolverGs zHub._get_resolvercC ||_dSrQrfrNrr4r4r5 _set_resolverL zHub._set_resolvercC d|_dSrQrrRr4r4r5 _del_resolverOrzHub._del_resolverz The DNS resolver that the socket functions will use. .. seealso:: :doc:`/dns` cCrzrQ)r( threadpoolrRr4r4r5threadpool_classZryzHub.threadpool_classcCs&|jdur|j|j|tjd|_|jS)N)r1idle_task_timeout)rerthreadpool_sizer(threadpool_idle_task_timeoutrRr4r4r5_get_threadpool^s zHub._get_threadpoolcCrrQrerr4r4r5_set_threadpoolhrzHub._set_threadpoolcCrrQrrRr4r4r5_del_threadpoolkrzHub._del_threadpoola The threadpool associated with this hub. Usually this is a :class:`gevent.threadpool.ThreadPool`, but you :attr:`can customize that `. Use this object to schedule blocking (non-cooperative) operations in a different thread to prevent them from halting the event loop. )NNrQ)+r^r_r`raKeyboardInterrupt SystemExit SystemErrorrrrrrgrqrrvrPrrxrbrtrsr|rrrZrrrrrlrrrrrrrrrrrrrr4r4r4r5rusZ       & &:  4J   rc@s$eZdZddgZddZddZdS) linkproxycallbackricCs||_||_dSrQrri)rNrrir4r4r5rPs zlinkproxy.__init__cGs$|j}|j}d|_d|_||dSrQr)rNr/rrir4r4r5__call__s  zlinkproxy.__call__N)r^r_r` __slots__rPrr4r4r4r5rs r)rT)rrQ)Bra __future__rr functoolsrr+r[rrr*rrrr__all__gevent._configrr(gevent._compatrr gevent._utilrrr gevent._identrgevent._hub_localrrrrrrdrr&rgevent._greenlet_primitivesrgevent._hub_primitivesr rJr!wait_on_objectsr;iwait_on_objectsiwaitgevent.exceptionsr"r#gevent._waiterr __import__ get_identrprrr r r?r objectr r rrr4r4r4r5s^                          ; (  XD