Delete a saved taskset result.
511855
def delete_taskset(self, taskset_id):
        """"""
        s = self.restore_taskset(taskset_id)
        if s:
            s.delete()
1298614
def stop(self):
        """"""
        with self._lock_c:
            for task in self.taskset:
                try:
                    task.stop()

                except TaskError as e:
                    # Task does not have a way to stop it.
                    # TODO: notify who?
                    pass
818911
def delete_by_query!(query, params = nil, request_options = {})
      res = delete_by_query(query, params, request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options) if res
      res
    end
985760
def deleteSelected(self):
        ''
        ndeleted = self.deleteBy(self.isSelected)
        nselected = len(self._selectedRows)
        self._selectedRows.clear()
        if ndeleted != nselected:
            error('expected %s' % nselected)
493124
def task_delete(self, **kw):
        
        def validate(task):
            if task['status'] == Status.DELETED:
                raise ValueError("Task is already deleted.")

        return self._task_change_status(Status.DELETED, validate, **kw)
1063889
def cancelPendingResultsFor( self, params ):
        """"""
        
        # grab the result job ids
        jobs = self.pendingResultsFor(params)
        
        if len(jobs) > 0:
            # abort in the cluster
            self._abortJobs(jobs)
            
            # cancel in the notebook                  
            self.notebook().cancelPendingResultsFor(params)
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
14109
def delete_cached(task_id, broker=None):
    
    if not broker:
        broker = get_broker()
    return broker.cache.delete('{}:{}'.format(broker.list_key, task_id))
767407
def _cleanup(self):
        """"""
        if self.todolist.exists():
            try:
                saved_todo = iter(open(self.todolist, encoding="utf-8"))
                int(next(saved_todo).strip())
                for line in saved_todo:
                    _, serial = line.strip().split()
                    int(serial)
            except (StopIteration, ValueError):
                # The todo list was inconsistent. This may happen if we get
                # killed e.g. by the timeout wrapper. Just remove it - we'll
                # just have to do whatever happened since the last successful
                # sync.
                logger.info("Removing inconsistent todo list.")
                self.todolist.unlink()
847371
private void cleanup(boolean atStartup) {
        boolean allTasksIdle = false;
        while (!allTasksIdle) {
            int activeCount = 0;
            for (Task task: taskDao.listTasks()) {
                if (!task.getState().equals(Task.IDLE)) {
                    activeCount++;
                    if (!task.getState().equals(Task.CANCELING)) {
                        logger.info("Auto-canceling task " + task.getId() + " (" + task.getName() + ")");
                        taskDao.setTaskState(task.getId(), Task.CANCELING);
                        task.setState(Task.CANCELING);
                    }
                    if (atStartup) {
                        // We're cleaning up after an unclean shutdown.
                        // Since the TaskRunner isn't actually running, we make
                        // the direct call here to clean up the state in the
                        // database, marking it as canceled.
                        taskCanceled(task);
                    } else {
                        // In the normal case, the TaskRunner is running in a
                        // separate thread and we just need to request that
                        // it cancel at the next available opportunity.
                        cancelTask(task);
                    }
                }
            }
            if (activeCount == 0 || atStartup) {
                allTasksIdle = true;
            } else {
                logger.info("Waiting for " + activeCount + " task(s) to go idle.");
                sleepSeconds(1);
            }
        }
    }
940104
def trim(self):
        """"""
        for key, value in list(iteritems(self.counters)):
            if value.empty():
                del self.counters[key]
647842
def delete(self):
        """"""
        for alternative in self.alternatives:
            alternative.delete()
        self.reset_winner()
        self.redis.srem('experiments', self.name)
        self.redis.delete(self.name)
        self.increment_version()
16485
protected function cleanupResult () : void
    {
        // Reset state
        if ($this->_State > 2) : 
            $this->_State = 2;
        endif;

            //////

        // Clean pairwise
        $this->_Pairwise = null;

        // Algos
        $this->_Calculator = null;
    }
209251
public void removeAll(TaskAttemptID taskId) throws IOException {
    String toBeDeleted =
      TaskTracker.getIntermediateOutputDir(jobId.toString(), taskId.toString());
    if (asyncDiskService != null) {
      asyncDiskService.moveAndDeleteFromEachVolume(toBeDeleted);
      LOG.info("Move and then delete map ouput " +
               toBeDeleted + " for task " + taskId);
      return;
    }
    LOG.info("Delete map ouput " + toBeDeleted + " for task " + taskId);
    conf.deleteLocalFiles(toBeDeleted);
  }
895182
def delete(self, rid, raise_on_error=True):
        
        return self.ds.delete(rid, raise_on_error)
1228408
def delete(dataset):
    """"""
    
    config = ApiConfig()
    client = ApiClient(config.host, config.app_id, config.app_secret)
    client.check_correct_host()
    client.delete(dataset)
    return ('Dataset {} has been deleted successfully'.format(dataset))
99659
def pop_result(self, key):
        """"""
        self.pending_callbacks.remove(key)
        return self.results.pop(key)