Return True if all dependencies are in State.DONE
322176
def has_resolved_dependencies(self):
        """"""
        for dependency in self.dependencies:
            if dependency.state != Task.State.DONE:
                return False

        return True
527738
def check_dependee_build(self, depender, dependee, dependee_id):
		
		shutit_global.shutit_global_object.yield_to_draw()
		cfg = self.cfg
		# If depender is installed or will be installed, so must the dependee
		if not (cfg[dependee.module_id]['shutit.core.module.build'] or
		        self.is_to_be_built_or_is_installed(dependee)):
			return 'depender module id:\n\n[' + depender.module_id + ']\n\nis configured: "build:yes" or is already built but dependee module_id:\n\n[' + dependee_id + ']\n\n is not configured: "build:yes"'
		return ''
910611
function isModuleInstalledGlobally(name, fn) {
  var cmd = 'npm ls --global --json --depth=0';
  exec(cmd, function(err, stdout) {
    if (err) {
      return fn(err);
    }

    var data = JSON.parse(stdout);
    var installed = data.dependencies[name];
    fn(null, installed !== undefined);
  });
}
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
749654
function _areBatchRequirementsMet(batch_ops, completed_ops) {
  var dependencies = common.flatMap(batch_ops, function(op) {
    return OP_DEPENDENCIES[op] || [];
  });
  for (var i = 0; i < dependencies.length; i++) {
    var required_dep = dependencies[i];
    if (batch_ops.indexOf(required_dep) === -1 &&
        completed_ops.indexOf(required_dep) === -1) {
      return false;
    }
  }
  return true;
}
32348
def check_state(self, state):
        

        if state.addr == self.function.addr:
            arch = state.arch
            if self._check_arguments(arch, state):
                return True

        return False
29835
def _finalized(self):
        
        return \
            len(self._finalized_dependencies) >= self.dependency_count \
            and len(self._enqueued_dependencies) >= self.dependency_count
1081795
public boolean isModified()
  {
    for (int i = _dependencyList.size() - 1; i >= 0; i--) {
      Dependency dependency = _dependencyList.get(i);

      if (dependency.isModified()) {
        return true;
      }
    }

    return false;
  }
1298253
public boolean isPresolved() {
        // Check if the tool has added unsolved dependencies to this instance that need further resolution.
        boolean unsolvedDependenciesExist = getDirectDeps().stream().anyMatch(d -> !getTransientDeps(d).isEmpty());
        return !unsolvedDependenciesExist;
    }
1105847
def wait_for(*dependencies)
      return nil if @serial
      return nil if dependencies.empty?

      dep_set = dependencies.to_set
      until dep_set & solved == dep_set
        sleep 1
        @solver_thread.join unless @solver_thread.alive?
      end
    end
606001
def check_dependencies(specs)
      missing = check_app_requirement(specs)

      present = exclude_specs(installed, specs)
      future = present + specs

      check_all_dependencies(specs, future, missing)
    end
738177
def check(projects):
    """"""
    log = logging.getLogger('ciu')
    log.info('{0} top-level projects to check'.format(len(projects)))
    print('Finding and checking dependencies ...')
    blockers = dependencies.blockers(projects)

    print('')
    for line in message(blockers):
        print(line)

    print('')
    for line in pprint_blockers(blockers):
        print(' ', line)

    return len(blockers) == 0
1111022
def dependency_ran(self, test):
        """"""
        for d in (self.test_name(i) for i in dependencies[test]):
            if d not in self.ok_results:
                return "Required test '{}' did not run (does it exist?)".format(d)
        return None
1261536
def needs(self):
        """"""
        result = []
        for dep in self.dependencies:
            module = dep.split(".")[0].lower()
            if module not in result:
                result.append(module)

        return result
578132
def is_empty(self):
        
        for family in self.iter_package_families():
            for pkg in self.iter_packages(family):
                return False

        return True
1374730
def is_correct(self):
        
        state = True

        # Internal checks before executing inherited function...
        loop = self.no_loop_in_parents("host_name", "dependent_host_name")
        if loop:
            msg = "Loop detected while checking host dependencies"
            self.add_error(msg)
            state = False
            for item in self:
                for elem in loop:
                    if elem == item.host_name:
                        msg = "Host %s is parent host_name in dependency defined in %s" % (
                            item.host_name_string, item.imported_from
                        )
                        self.add_error(msg)
                    elif elem == item.dependent_host_name:
                        msg = "Host %s is child host_name in dependency defined in %s" % (
                            item.dependent_host_name_string, item.imported_from
                        )
                        self.add_error(msg)

        return super(Hostdependencies, self).is_correct() and state
1284927
def is_complete(self):
        """"""

        return all(p.name in self.values for p in self.parameters if p.required)