Get the next run of this job.
340573
public function generateNextJob(): self
    {
        $tokens = $this->getJobTokens();
        $tokens['token'] = $tokens['next_token'];
        $tokens['next_token'] = Uuid::uuid4()->toString();

        return new self($this->getName(), $this->getArguments(), $tokens);
    }
788342
def next(self, reward, ask_id, lbl):
        """"""
        # first run don't have reward, TODO exception on reward == -1 only once
        if reward == -1:
            return next(self.exp4p_gen)
        else:
            # TODO exception on reward in [0, 1]
            return self.exp4p_gen.send((reward, ask_id, lbl))
111627
def run_later(self, callable_, timeout, *args, **kwargs):
        

        self.lock.acquire()
        try:
            if self.die:
                raise RuntimeError('This timer has been shut down and '
                                   'does not accept new jobs.')

            job = TimerTask(callable_, *args, **kwargs)
            self._jobs.append((job, time.time() + timeout))
            self._jobs.sort(key=lambda j: j[1])  # sort on time
            self.lock.notify()

            return job
        finally:
            self.lock.release()
628046
private void fetchNext() {
		if (pendingUtc != null || done) {
			return;
		}

		DateValue dUtc = generateInstance();

		//check the exit condition
		if (dUtc == null || !condition.apply(dUtc)) {
			done = true;
			return;
		}

		pendingUtc = dUtc;
		yearGenerator.workDone();
	}
97311
def run_job(self):
        """"""
        try:
            self.load_parsers()
            self.load_filters()
            self.load_outputs()
            self.config_args()
            if self.args.list_parsers:
                self.list_parsers()
            if self.args.verbosemode: print('Loading input files')
            self.load_inputs()
            if self.args.verbosemode: print('Running parsers')
            self.run_parse()
            if self.args.verbosemode: print('Merging data')
            self.data_set['finalized_data'] = \
                    logdissect.utils.merge_logs(
                            self.data_set['data_set'], sort=True)
            if self.args.verbosemode: print('Running filters')
            self.run_filters()
            if self.args.verbosemode: print('Running output')
            self.run_output()
        except KeyboardInterrupt:
            sys.exit(1)
273316
def next(self):
        
        if not self._cache:
            self._cache = self._get_results()
            self._retrieved += len(self._cache)

        # If we don't have any other data to return, we just
        # stop the iteration.
        if not self._cache:
            raise StopIteration()

        # Consuming the cache and updating the "cursor"
        return self._cache.pop(0)
1048637
def next(self, *args):
        """"""
        self.initialize()
        self.future = asyncio.Future(loop=self.loop)
        self.handle = self.loop.call_at(self.get_next(), self.call_func, *args)
        return self.future
170703
def run(self):
        """"""
        try:
            while not self.stopped:
                scraperobj = jobs.get(False)
                self.setName(scraperobj.getName())
                try:
                    self.getStrips(scraperobj)
                finally:
                    jobs.task_done()
                    self.setName(self.origname)
        except Empty:
            pass
        except KeyboardInterrupt:
            thread.interrupt_main()
680859
def get_next(self, query, **options):
        """"""
        iterator = EventsPageIterator(self.client, '/events', query, options)
        result = iterator.next()
        return (result, iterator.sync)
1303624
def getNextJobID(self):  # type: () -> int
        
        with self.localBatch.jobIndexLock:
            jobID = self.localBatch.jobIndex
            self.localBatch.jobIndex += 1
        return jobID
1224001
public function run()
    {
        foreach ($this->jobs as $job) {
            $this->worker->run($job);
        }

        while ($this->worker->isRunning()) {
            // waiting for worker to finish
        }

        // allow chaining
        return $this;
    }
234262
def run(self):
        
        iterations = 0
        queue = self.queue.tick()
        while True:
            try:
                next(queue)
            except StopIteration:
                break

            iterations += 1
            sleep(self.sleep_time)
        return iterations
609628
def get(self, id):
        
        self.cur.execute("SELECT * FROM jobs WHERE hash=?", (id,))
        item = self.cur.fetchone()
        if item:
            return dict(zip(
                ("id", "description", "last-run", "next-run", "last-run-result"),
                item))

        return None
304274
async def next(self) -> Any:
        """"""
        item = await self.stream.next()
        if self.stream.at_eof():
            await self.release()
        return item
563229
def next(self):
        """"""
        if self.__tailable:
            return PymongoCursor.next(self)
        try:
            ret = PymongoCursor.next(self)
        except StopIteration:
            self.__fullcache = True
            raise
        self.__itercache.append(ret)
        return ret
1310017
def run_with_output(self, *args, **kwargs):
    """"""
    for job in self.jobs:
      job.run_with_output(*args, **kwargs)
1330336
def get_next_job_by_location(plugin_name, loc, verify_job=True, conn=None):
    
    return get_next_job(plugin_name, loc, verify_job=verify_job, conn=conn)