o e6@sdZddlmZddlmZddlmZddlZddlmZddlmZddl m Z dd l m Z dd l m Z dd lmZdd lmZed jed<dded<e jed<e jed<e jed<gdZGdddeZGdddeZd0ddZd1ddZea ddZ!d d!Z"d2d"d#Z#de dfd$d%Z$de fd&d'Z%de e fd(d)Z&de e fd*d+Z'd,d-Z(e(dd.l m)Z)e)e*d/dS)3z{ A collection of primitives used by the hub, and suitable for compilation with Cython because of their frequency of use. )absolute_import)division)print_functionN)InvalidSwitchError)ConcurrentObjectUseError)_greenlet_primitives)_waiter)_NONE)get_hub_noargs)TimeoutZgreenlet getcurrentcCsdSNrrrFD:\Projects\ConvertPro\env\Lib\site-packages\gevent/_hub_primitives.pysr greenlet_initWaiterMultipleWaiterSwitchOutGreenletWithLoop)WaitOperationsGreenletiwait_on_objectswait_on_objects wait_read wait_writewait_readwritec@s6eZdZddZddZddZd dd Zd d Zd S)rcCsXt|}||j|z|}||ur tdt||||fW|dS|w)z Wait until the *watcher* (which must not be started) is ready. The current greenlet will be unscheduled during this time. zCInvalid switch into %s: got %r (expected %r; waiting on %r with %r)N)rstartswitchgetrr stop)selfwatcherwaiterresultrrrwait.s  zWaitOperationsGreenlet.waitcGs`g}|D]}|dur q|jdur|q||q|r*|j|j||||dS||dSr )callbackcloseappendloop run_callback_cancel_waits_then)rwatchersexc_kindthen then_argsdeferredr rrrcancel_waits_close_and_thenEs    z2WaitOperationsGreenlet.cancel_waits_close_and_thencCs$|D] }|||dq||dS)NT) _cancel_wait)rr*r+r,r-r rrrr)Ss z)WaitOperationsGreenlet._cancel_waits_thenFcCsB|durdS|jdur|j|j|||dS|r|dSdS)a Cancel an in-progress call to :meth:`wait` by throwing the given *error* in the waiting greenlet. .. versionchanged:: 1.3a1 Added the *close_watcher* parameter. If true, the watcher will be closed after the exception is thrown. The watcher should then be discarded. Closing the watcher is important to release native resources. .. versionchanged:: 1.3a2 Allow the *watcher* to be ``None``. No action is taken in that case. N)r$r'r(r0r%)rr error close_watcherrrr cancel_waitXs   z"WaitOperationsGreenlet.cancel_waitcCsF|j}|j}|r ||rt|dd}|dur!||dSdSdS)N__self__)activer$r%getattrthrow)rr r1r2r5cbZgletrrrr0qs z#WaitOperationsGreenlet._cancel_waitN)F)__name__ __module__ __qualname__r#r/r)r3r0rrrrr,s   rc@sHeZdZddZddZddZddZeZd d Zd d Z d dZ dS) _WaitIteratorcCs\||_t||_|jj|_||_||_d|_d|_|dur$t ||_ dSt |t ||_ dS)NF) _hubrrr_switch_timeout_objects_timer_begunlenmin_count)robjectshubtimeoutcountrrr__init__s  *z_WaitIterator.__init__cCs`|jrdSd|_|jD]}||jq |jdur.|jjj|jdd|_|j |j|dSdS)NT)priority) rBr@Zrawlinkr>r?r=r'timerrAr)robjrrr_begins  z_WaitIterator._begincC|Sr rrrrr__iter__z_WaitIterator.__iter__cCsp||jdkr|t|jd8_z|j}|j||ur-|t|WS|)Nr)rOrE_cleanup StopIterationrrclear)ritemrrr__next__s   z_WaitIterator.__next__cCsj|jdur |jd|_|j}d|_|D]}t|dd}|dur2z||jWqtYqqdS)Nrunlink)rAr%r@r6r> traceback print_exc)rZobjsZaobjrZrrrrUs    z_WaitIterator._cleanupcCrPr rrQrrr __enter__rSz_WaitIterator.__enter__cCs |dSr )rU)rtypvaluetbrrr__exit__s z_WaitIterator.__exit__N) r9r:r;rJrOrRrYnextrUr]rarrrrr<s r<cCs*t}|dur|j|dgSt||||S)a Iteratively yield *objects* as they are ready, until all (or *count*) are ready or *timeout* expired. If you will only be consuming a portion of the *objects*, you should do so inside a ``with`` block on this object to avoid leaking resources:: with gevent.iwait((a, b, c)) as it: for i in it: if i is a: break :param objects: A sequence (supporting :func:`len`) containing objects implementing the wait protocol (rawlink() and unlink()). :keyword int count: If not `None`, then a number specifying the maximum number of objects to wait for. If ``None`` (the default), all objects are waited for. :keyword float timeout: If given, specifies a maximum number of seconds to wait. If the timeout expires before the desired waited-for objects are available, then this method returns immediately. .. seealso:: :func:`wait` .. versionchanged:: 1.1a1 Add the *count* parameter. .. versionchanged:: 1.1a2 No longer raise :exc:`LoopExit` if our caller switches greenlets in between items yielded by this function. .. versionchanged:: 1.4 Add support to use the returned object as a context manager. NrH)get_hubjoinr<rFrHrIrGrrrrs!rcCs*|dur t}|j|dStt|||S)af Wait for *objects* to become ready or for event loop to finish. If *objects* is provided, it must be a list containing objects implementing the wait protocol (rawlink() and unlink() methods): - :class:`gevent.Greenlet` instance - :class:`gevent.event.Event` instance - :class:`gevent.lock.Semaphore` instance - :class:`gevent.subprocess.Popen` instance If *objects* is ``None`` (the default), ``wait()`` blocks until the current event loop has nothing to do (or until *timeout* passes): - all greenlets have finished - all servers were stopped - all event loop watchers were stopped. If *count* is ``None`` (the default), wait for all *objects* to become ready. If *count* is a number, wait for (up to) *count* objects to become ready. (For example, if count is ``1`` then the function exits when any object in the list is ready). If *timeout* is provided, it specifies the maximum number of seconds ``wait()`` will block. Returns the list of ready objects, in the order in which they were ready. .. seealso:: :func:`iwait` Nrc)rdrelistrrfrrrrs" rcCs|adSr )_timeout_error)errrset_default_timeout_error#srjcCs|jdur td|jf|durt}|dur||dSt||tus*|dur,|ntd}|||WddS1sDwYdS)Nz3This socket is already used by another greenlet: %rz timed out)r$rrdr#r Z_start_new_or_dummyr rhr rH timeout_excrGrrr_primitive_wait's$   "rmcCs:|dus|dur tdt||j|dur|nt|jdS)Nz6The socket has already been closed by another greenlet)rrmrHr rG)socketr rlrrrwait_on_socket=s rocCst||||dS)a wait(watcher, timeout=None, [timeout_exc=None]) -> None Block the current greenlet until *watcher* is ready. If *timeout* is non-negative, then *timeout_exc* is raised after *timeout* second has passed. If :func:`cancel_wait` is called on *watcher* by another greenlet, raise an exception in this blocking greenlet (``socket.error(EBADF, 'File descriptor was closed in another greenlet')`` by default). :param watcher: An event loop watcher, most commonly an IO watcher obtained from :meth:`gevent.core.loop.io` :keyword timeout_exc: The exception to raise if the timeout expires. By default, a :class:`socket.timeout` exception is raised. If you pass a value for this keyword, it is interpreted as for :class:`gevent.timeout.Timeout`. :raises ~gevent.hub.ConcurrentObjectUseError: If the *watcher* is already started. N)rmrkrrrwait_on_watcherFsrpcCs8t}|j|d}z t||||W|S|w)a wait_read(fileno, timeout=None, [timeout_exc=None]) -> None Block the current greenlet until *fileno* is ready to read. For the meaning of the other parameters and possible exceptions, see :func:`wait`. .. seealso:: :func:`cancel_wait` rTrdr'iorpr%)filenorHrlrGrrrrrras  rcC8t}|j|d}z t||||W|S|w)a wait_write(fileno, timeout=None, [timeout_exc=None]) -> None Block the current greenlet until *fileno* is ready to write. For the meaning of the other parameters and possible exceptions, see :func:`wait`. .. deprecated:: 1.1 The keyword argument *event* is ignored. Applications should not pass this parameter. In the future, doing so will become an error. .. seealso:: :func:`cancel_wait` rqrsrHrleventrGrrrrrrts rcCrt)a wait_readwrite(fileno, timeout=None, [timeout_exc=None]) -> None Block the current greenlet until *fileno* is ready to read or write. For the meaning of the other parameters and possible exceptions, see :func:`wait`. .. deprecated:: 1.1 The keyword argument *event* is ignored. Applications should not pass this parameter. In the future, doing so will become an error. .. seealso:: :func:`cancel_wait` rqrvrrrrs rcCs tdSr )rrrrr_inits ry)import_c_accelzgevent.__hub_primitives)NN)NNNr )+__doc__ __future__rrrr[Zgevent.exceptionsrrZgeventrrZ gevent._utilr Zgevent._hub_localr rdZgevent.timeoutr __import__r localsrrr__all__robjectr<rr ExceptionrhrjrmrorprrrryrzglobalsrrrrsD              W P ''