def wait(self, timeout=None): """pause the current coroutine until this event is set if :meth:`set` method has been called, this method will not block at all. otherwise it will block until :meth:`set` method is called :param timeout: the maximum amount of time to block in seconds. the default of ``None`` allows indefinite blocking. :type timeout: number or None :returns: ``True`` if a timeout was provided and was hit, otherwise ``False`` """ if self._is_set: return False current = compat.getcurrent() # the waiting greenlet waketime = None if timeout is None else time.time() + timeout if timeout is not None: scheduler.schedule_at(waketime, current) self._waiters.append(current) scheduler.state.mainloop.switch() if timeout is not None: timedout = not scheduler._remove_from_timedout(waketime, current) if timedout: self._waiters.remove(current) return timedout return False
def wait(self, timeout=None): """wait to be woken up by the condition :raises: `RuntimeError` if the underlying lock hasn't been :meth:`acquired <Lock.acquire>` """ if not self._is_owned(): raise RuntimeError("cannot wait on un-acquired lock") current = compat.getcurrent() waketime = None if timeout is None else time.time() + timeout if timeout is not None: scheduler.schedule_at(waketime, current) self._waiters.append((current, waketime)) self._lock.release() scheduler.state.mainloop.switch() self._lock.acquire() if timeout is not None: timedout = not scheduler._remove_from_timedout(waketime, current) if timedout: self._waiters.remove((current, waketime)) return timedout return False
def put(self, item, blocking=True, timeout=None): """put an item into the queue if the queue was instantiated with a nonzero `maxsize` and that size has already been reached, this method will block until another greenlet :meth:`get`\ s an item out :param item: the object to put into the queue, can be any type :param blocking: whether to block if the queue is already :meth:`full` (default ``True``) :type blocking: bool :param timeout: the maximum time in seconds to block waiting. with the default of ``None``, it can wait indefinitely. this is unused if `blocking` is ``False``. :type timeout: int, float or None :raises: :class:`Full` if the queue is :meth:`full` and `blocking` is ``False``, or if `timeout` expires. """ if self.full(): if not blocking: raise Full() current = compat.getcurrent() waketime = None if timeout is None else time.time() + timeout if timeout is not None: scheduler.schedule_at(waketime, current) self._waiters.append((current, waketime)) scheduler.state.mainloop.switch() if timeout is not None: if not scheduler._remove_from_timedout(waketime, current): self._waiters.remove((current, waketime)) raise Full() if self._waiters and not self.full(): scheduler.schedule(self._waiters.popleft()[0]) if not self._open_tasks: self._jobs_done.clear() self._open_tasks += 1 self._put(item)
def get(self, blocking=True, timeout=None): """get an item out of the queue this method will block if `blocking` is ``True`` (default) and the queue is :meth:`empty` :param blocking: whether to block if there is no data yet available (default ``True``) :type blocking: bool :param timeout: the maximum time in seconds to block waiting for data. with the default of ``None``, can wait indefinitely. this is unused if `blocking` is ``False``. :type timeout: int, float or None :raises: :class:`Empty` if there is no data in the queue and blocking is ``False``, or `timeout` expires :returns: something that was previously :meth:`put` in the queue """ if not self._data: if not blocking: raise Empty() current = compat.getcurrent() waketime = None if timeout is None else time.time() + timeout if timeout is not None: scheduler.schedule_at(waketime, current) self._waiters.append((current, waketime)) scheduler.state.mainloop.switch() if timeout is not None: if not scheduler._remove_from_timedout(waketime, current): self._waiters.remove((current, waketime)) raise Empty() if self.full() and self._waiters: scheduler.schedule(self._waiters.popleft()[0]) return self._get()