B H/\2@sdZddlmZddlmZddlmZddlZddlmZddlmZddl m Z dd l m Z dd l m Z dd lmZdd lmZed jed<dded<e jed<e jed<e jed<ddddddgZGdddeZGdddeZd/ddZd0ddZea d d!Z!d"d#Z"d1d$d%Z#de dfd&d'Z$de fd(dZ%de e fd)dZ&de e fd*dZ'd+d,Z(e(dd-l m)Z)e)e*d.dS)2z{ 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 getcurrentcCsdS)Nr r r 5lib/python3.7/site-packages/gevent/_hub_primitives.pysr greenlet_initWaiterMultipleWaiterSwitchOutGreenletWithLoopWaitOperationsGreenletiwait_on_objectswait_on_objects wait_read wait_writewait_readwritec@s&eZdZddZd ddZddZdS) rcCsNt|}||j|z(|}||k r|j}|j}|r||r:t|dd}|dk r:||dS)N__self__)activer"r%getattrthrow)rrr&r'r*cbZgletr r rr$Ts z#WaitOperationsGreenlet._cancel_waitN)F)__name__ __module__ __qualname__r!r(r$r r r rr,s c@sHeZdZddZddZddZddZeZd d Zd d Z d dZ dS) _WaitIteratorcCsV||_t||_|jj|_||_||_d|_d|_|dkrBt |n t |t ||_ dS)NF) _hubrrr_switch_timeout_objects_timer_begunlenmin_count)robjectshubtimeoutcountr r r__init__ds  z_WaitIterator.__init__cCs`|jr dSd|_x|jD]}||jqW|jdk r\|jjj|jdd|_|j |j|dS)NT)Zpriority) r7r5Zrawlinkr3r4r2r#Ztimerr6r)robjr r r_beginss  z_WaitIterator._begincCs|S)Nr )rr r r__iter__sz_WaitIterator.__iter__cCsx||jdkr |t|jd8_y.|j}|j||krZ|t|S|YnXdS)Nr)rBr:_cleanup StopIterationrrclear)ritemr r r__next__s   z_WaitIterator.__next__cCsp|jdk r|jd|_|j}d|_xD|D]<}t|dd}|dk r,y||jWq,tYq,Xq,WdS)Nr unlink)r6r%r5r+r3 traceback print_exc)rZobjsZaobjrJr r rrEs    z_WaitIterator._cleanupcCs|S)Nr )rr r r __enter__sz_WaitIterator.__enter__cCs |dS)N)rE)rtypvaluetbr r r__exit__sz_WaitIterator.__exit__N) r.r/r0r?rBrCrInextrErMrQr r r rr1bsr1cCs*t}|dkr|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. N)r=)get_hubjoinr1)r;r=r>r<r r rrs!cCs*|dkrt}|j|dStt|||S)ax 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` N)r=)rSrTlistr)r;r=r>r<r r rrs" cCs|adS)N)_timeout_error)er r rset_default_timeout_errorsrXc Cs|jdk rtd|jf|dkr(t}|dkr>||dSt||tk sT|dkrX|ntd}|||WdQRXdS)Nz3This socket is already used by another greenlet: %rz timed out)r"rrSr!r Z_start_new_or_dummyr rV)rr= timeout_excr<r r r_primitive_waits    rZcCs:|dks|dkrtdt||j|dk r,|nt|jdS)Nz6The socket has already been closed by another greenlet)rrZr=r r<)ZsocketrrYr r rwait_on_sockets r[cCst||||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 *io* by another greenlet, raise an exception in this blocking greenlet (``socket.error(EBADF, 'File descriptor was closed in another greenlet')`` by default). :param io: 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)rZ)rr=rYr<r r rwait_on_watcher%sr\cCs2t}|j|d}zt||||S|XdS)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` rDN)rSr#ior\r%)filenor=rYr<r]r r rr@s cCs2t}|j|d}zt||||S|XdS)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` N)rSr#r]r\r%)r^r=rYeventr<r]r r rrSs cCs2t}|j|d}zt||||S|XdS)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` N)rSr#r]r\r%)r^r=rYr`r<r]r r rrks cCs tdS)N)rr r r r_initsrb)import_c_accelzgevent.__hub_primitives)NN)NNN)N)+__doc__Z __future__rrrrKZgevent.exceptionsrrZgeventrrZ gevent._utilr Zgevent._hub_localr rSZgevent.timeoutr __import__r localsrrr__all__robjectr1rr ExceptionrVrXrZr[r\rrrrbrcglobalsr r r r sL             6P ' '