Return True if workflow is fully completed.
481940
def has_completed(self):
        """"""
        objects_in_db = WorkflowObjectModel.query.filter(
            WorkflowObjectModel.id_workflow == self.uuid,
            WorkflowObjectModel.id_parent == None,  # noqa
        ).filter(WorkflowObjectModel.status.in_([
            workflow_object_class.known_statuses.COMPLETED
        ])).count()
        return objects_in_db == len(list(self.objects))
664922
def is_complete(self):
        
        return all(
            [node.route_allocation() is not None for node in list(self._nodes.values()) if node != self._problem.depot()]
        )
1328376
def complete(self):
        
        if not self._techniques:
            return False
        if not any(tech._is_overriden('complete') for tech in self._techniques):
            return False
        return self.completion_mode(tech.complete(self) for tech in self._techniques if tech._is_overriden('complete'))
737995
def done(self):
        
        if self._done:
            return self._done

        if self._limit is None:
            self._done = False
        elif self.itemcount >= self._limit:
            self._done = True

        return self._done
299379
def valid_workflow(self):
        
        for ix, handler in enumerate(self.handlers[:-1]):
            next_input_type = self.handlers[ix + 1].input_type

            if (handler.output_type is not None and
                    next_input_type is not None):
                if handler.output_type != next_input_type:
                    return False

        return True
18363
def is_transfer_complete(self, relation_name):
    """"""
    phold = self.data_access.sql_writer.to_placeholder()
    return self.data_access.find_model(
      Relation,
      ("name = {0} and completed_at is not null".format(phold), [relation_name])) is not None
815235
def is_complete(self):
        
        return self._group != None and self._type != None \
            and self._kind != None and self._name != None and self._version != None
592530
public boolean isCompleted() {
    WorkingState state = getWorkingState();
    return state == WorkingState.SUCCESSFUL || state == WorkingState.COMMITTED || state == WorkingState.FAILED;
  }
682600
def is_complete(self) -> bool:
        
        if not self.actual:
            return False
        for parameter in self.parameters:
            if parameter["name"] != "self" and not parameter["type"]:
                return False
        return True
857515
def complete(self):
        """"""
        if None not in [v for v in self.squares]:
            return True
        if self.winner() is not None:
            return True
        return False
188992
private boolean isCurrentStageCompleted() {

		if (this.indexToCurrentExecutionStage >= this.stages.size()) {
			return true;
		}

		final ExecutionGraphIterator it = new ExecutionGraphIterator(this, this.indexToCurrentExecutionStage, true,
			true);
		while (it.hasNext()) {
			final ExecutionVertex vertex = it.next();
			if (vertex.getExecutionState() != ExecutionState.FINISHED) {
				return false;
			}
		}

		return true;
	}
1212697
def auth_complete(self):
        
        timeout = False
        auth_in_progress = False
        if self._connection.cbs:
            timeout, auth_in_progress = self._auth.handle_token()
            if timeout is None and auth_in_progress is None:
                _logger.debug("No work done.")
                return False
        if timeout:
            raise compat.TimeoutException("Authorization timeout.")
        if auth_in_progress:
            self._connection.work()
            return False
        return True
286769
public function complete()
    {
        $cfg = $this->form->cfg;
        $return = true;
        if ($cfg['onComplete'] == 'email') {
            $return = $this->email();
        } elseif ($cfg['onComplete'] == 'log') {
            $return = $this->log();
        } elseif (\is_callable($cfg['onComplete'])) {
            $return = \call_user_func($cfg['onComplete'], $this->form);
        }
        return $return;
    }
366377
def _check_stage_complete(self):
        

        try:

            for task in self._tasks:
                if task.state not in [states.DONE, states.FAILED]:
                    return False

            return True

        except Exception, ex:
            raise EnTKError(ex)
395319
static function isWorkflowRunning($workflow_key) {
        $status = self::STATUS_RUNNING;
        if (Util::isDevServer()) {
            $created_after = "-60 seconds";
        } else {
            $created_after = "-" . Moment::ONEHOUR . " seconds";
        }
        $data = DataStore::retrieveMostCurrentWorkflowJobByAgeAndStatus($workflow_key, $status, $created_after);
        $result = (bool)$data;
        return $result;
    }
41959
def complete(self):
        
        return self.valid and (self.access_token or self.refresh_token or self.type == 2)
436392
def is_unclaimed(work):
  """"""
  if work['is_completed']:
    return False
  cutoff_time = time.time() - MAX_PROCESSING_TIME
  if (work['claimed_worker_id'] and
      work['claimed_worker_start_time'] is not None
      and work['claimed_worker_start_time'] >= cutoff_time):
    return False
  return True