Run the task - compose full series + add to our results
760367
def run(self):
    
    empty = False
    while not empty:
      try:
        s = self.series.get()
        result_dict = itunes.get_rss_feed_data_from_series(s)
        self.storer.store(result_dict)
        self.logger.info('Retrieved and stored %s', str(s.id))
      except Exception as e: # pylint: disable=W0703
        print e
      finally:
        self.series.task_done()
        empty = self.series.empty()
1218409
def run(self):
        
        if not self._has_yielded and not self.task.local_workflow_require_branches:
            self._has_yielded = True

            yield list(self.task.get_branch_tasks().values())

        self._has_run = True
164924
function addTaskToFluence(task, done) {
        if (done) {
            done = "1"
        } else {
            done = "0"
        }
        const query = `INSERT INTO ${todoTable} VALUES ('${task}', ${done})`;
        session.request(query).result().then((r) => {
            console.log("task inserted")
        })
    }
675575
def run(self):
        
        for task in self.get_next_tasks(None):
            self.executor.add_task(task, None)
        while not self.executor.is_done():
            done_task_and_result = self.executor.wait_for_tasks()
            for task, task_result in done_task_and_result:
                self._add_sub_tasks_to_executor(task, task_result)
955037
def run_progress
      if counts_set? && total_count > 0
        sum = output.values_at(:success_count, :cancelled_count, :failed_count).reduce(:+)
        sum.to_f / total_count
      else
        0.1
      end
    end
32522
function () {
            each(this.series, function (serie) {
                serie.translate();
                if (serie.setTooltipPoints) {
                    serie.setTooltipPoints();
                }
                serie.render();
            });
        }
1082178
def _subtask_result(self, idx, value):
        """"""
        self._results[idx] = value
        if len(self._results) == self._num_tasks:
            self.set_result([
                self._results[i]
                for i in range(self._num_tasks)
            ])
1225970
def on_result(self, task, result):
        ''''''
        if not result:
            return
        if 'taskid' in task and 'project' in task and 'url' in task:
            logger.info('result %s:%s %s -> %.30r' % (
                task['project'], task['taskid'], task['url'], result))
            return self.resultdb.save(
                project=task['project'],
                taskid=task['taskid'],
                url=task['url'],
                result=result
            )
        else:
            logger.warning('result UNKNOW -> %.30r' % result)
            return
158546
def run(self):
        """"""
        self.aotask.StartTask()
        self.aotask.wait() # don't return until generation finished
        self.aotask.stop()
        self.aotask = None
666294
def send_result(self, type, task, result):
        ''''''
        if self.outqueue:
            try:
                self.outqueue.put((task, result))
            except Exception as e:
                logger.exception(e)
304858
def run_task(task_cls, task_data):
    
    task = instantiate(task_cls)
    task_callable = get_callable(task)
    return task_callable(TaskData(task_data))
11828
def _run(self):
        ''''''
      
        while self._is_running:
            yield from self._task()

        # Signal that the loop has finished.
        self._run_complete.set_result(True)
1086031
function(compose, project, run, opts) {

    // Get our compose files and build the pre opts
    var cmd = parseComposeOptions(compose, project, opts).concat([run]);

    // Get options
    cmd = cmd.concat(parseOptions(opts));

    // Add in a services arg if its there
    if (opts && opts.services) {
      _.forEach(opts.services, function(service) {
        cmd.push(service);
      });
    }

    // Add in a command arg if its there
    if (opts && opts.cmd) {
      if (typeof opts.cmd === 'string') {
        opts.cmd = [opts.cmd];
      }
      if (_.isArray(opts.entrypoint)) {
        cmd.push(kbox.util.shell.escSpaces(opts.cmd.join(' ')));
      }
      else {
        cmd = _.flatten(cmd.concat(opts.cmd));
      }
    }

    return cmd;

  }
761858
def execute_task(self, task, parent_result):
        
        task.before_run(parent_result)
        context = task.create_context(self.message_queue)
        pending_result = self.pool.apply_async(execute_task_async, (task.func, task.id, context))
        self.pending_results.append(pending_result)
107028
def run(self):
        """"""
        while True:
            self.running = True
            workunit = self._workq.get()
            if is_sentinel(workunit):
                # Got sentinel
                break

            # Run the job / sequence
            workunit.process()
        self.running = False
1335965
@Override
	public void run() {
		Collection<Writer> writers = new ArrayList<Writer>(1);

		while (true) {
			for (Task task : receiveTasks()) {
				if (task == Task.POISON) {
					close();
					return;
				} else {
					write(writers, task);
				}
			}

			flush(writers);
			writers.clear();

			try {
				sleep(MILLISECONDS_TO_SLEEP);
			} catch (InterruptedException ex) {
				// Ignore and continue
			}
		}
	}
1338418
def load_results(result_files, options, run_set_id=None, columns=None,
                 columns_relevant_for_diff=set()):
    """"""
    return parallel.map(
        load_result,
        result_files,
        itertools.repeat(options),
        itertools.repeat(run_set_id),
        itertools.repeat(columns),
        itertools.repeat(columns_relevant_for_diff))