waiting for some processing to happen
779428
function NotReady(message, code_id) {
    Error.call(this);
    this.message = message || "resource is not ready yet";
    this.code_id = code_id || null;
    this.statusCode = 423;
}
855035
def wait_until_available(resource):
  """'"""
  while True:
    resource.load()
    if resource.state == 'available':
      break
    time.sleep(RETRY_INTERVAL_SEC)
1363793
public function wait(): void
    {
        while (!$this->stream->eof()) {
            $frame = $this->readFrame();

            if (null !== $frame) {
                if (!\is_array($frame)) {
                    $frame = [$frame];
                }

                foreach ($this->onNewFrameCallables as $newFrameCallable) {
                    \call_user_func_array($newFrameCallable, $frame);
                }
            }
        }
    }
498125
def wait(self, allowed_methods=None):
        """"""
        method_sig, args, content = self.connection._wait_method(
            self.channel_id, allowed_methods)

        return self.dispatch_method(method_sig, args, content)
99378
def wait_locally(self):
        """"""
        try: self.thread.join(sys.maxint) # maxint timeout so that we can Ctrl-C them
        except KeyboardInterrupt: print "Stopped waiting on job '%s'" % self.kwargs['job_name']
356285
def wait_until_finished(self):
        """"""
        try:
            self.thread.join()
        except KeyboardInterrupt:
            self._logger.debug('Keyboard interrupt detected, stopping driver.')
            self._active = False
            self._wake_queue()
582394
def wait(self):
        ''' '''
        self._done_event.wait(MAXINT)
        return self._status, self._exception
412555
public function wait()
    {
        curl_multi_exec($this->mh, $active); // Start requests.
        do {
            // if cURL handle is running, use curl_multi_select()
            // otherwise, just sleep until nearest time
            $this->scheduler->isEmpty()
                ? $this->delayer->sleep()
                : curl_multi_select($this->mh, $this->options['interval']) < 0
                  && usleep($this->options['interval'] * 1000000);
            curl_multi_exec($this->mh, $active);
            $this->scheduler->consume();
            $this->delayer->consume();
        } while (!$this->haltException && (!$this->scheduler->isEmpty() || !$this->delayer->isEmpty()));
        if ($this->haltException) {
            throw $this->haltException;
        }
    }
1174548
async def _wait_execute(self, address, command, args, kw):
        """"""
        conn = await self.acquire(command, args)
        try:
            return (await conn.execute(command, *args, **kw))
        finally:
            self.release(conn)
520090
def wait(*args)
      pattern = args.pop
      unless pattern
        raise ArgumentError, 'Please provide condition to wait for'
      end

      run(*args) do |out, _|
        raise if out =~ /#{pattern}/
      end
    rescue ExitError
      # noop
    end
1318818
def send_wait(self,text):
	""""""
	self.send(text)
	time.sleep(len(text)*PiLite.COLS_PER_CHAR*self.speed/1000.0)
397738
def wait(self, *args, **kwargs):
        """"""
        if _debug: IOCB._debug("wait(%d) %r %r", self.ioID, args, kwargs)

        # waiting from a non-daemon thread could be trouble
        return self.ioComplete.wait(*args, **kwargs)
199103
def wait_event(self, filter: Callable[[T_Event], bool] = None) -> Awaitable[T_Event]:
        """"""
        return wait_event([self], filter)
540892
def _wait_for_file(cls, filename, timeout=FAIL_WAIT_SEC, want_content=True):
    """"""
    def file_waiter():
      return os.path.exists(filename) and (not want_content or os.path.getsize(filename))

    action_msg = 'file {} to appear'.format(filename)
    return cls._deadline_until(file_waiter, action_msg, timeout=timeout)
1244480
def start_waiting(self):
        
        if not self.waiting:
            self.waiting = True
            wait_msg = "Waiting for project to become ready for {}".format(self.msg_verb)
            self.progress_bar.show_waiting(wait_msg)
105075
def wait(self):
        """"""
        self._returncode = self.process.wait()
        try:
            self.process.stderr.close()
        except:
            pass
        self.set_status(self.S_DONE, "status set to Done")

        return self._returncode
1251382
public void waitForPendingFutures() {
        // Wait inbox to become empty:
        Log.v(Log.TAG_BATCHER, "%s: waitForPendingFutures is called ...", this);

        while (true) {
            ScheduledFuture future;
            synchronized (mutex) {
                while (!inbox.isEmpty()) {
                    try {
                        Log.v(Log.TAG_BATCHER, "%s: waitForPendingFutures, inbox size: %d",
                                this, inbox.size());
                        mutex.wait(300);
                    } catch (InterruptedException e) {
                    }
                }
                future = pendingFuture;
            }

            // Wait till ongoing computation completes:
            if (future != null && !future.isDone() && !future.isCancelled()) {
                try {
                    future.get();
                } catch (Exception e) {
                    Log.e(Log.TAG_BATCHER, "%s: Error while waiting for pending futures", e, this);
                }
            }

            synchronized (mutex) {
                if (inbox.isEmpty())
                    break;
            }
        }

        Log.v(Log.TAG_BATCHER, "%s: waitForPendingFutures done", this);
    }