Find what's missing
436356
def missing_requirements(self, specifiers):
        
        for specifier in specifiers:
            try:
                pkg_resources.require(specifier)
            except pkg_resources.DistributionNotFound:
                yield specifier
1305255
def _missing_(cls, value):
        """"""
        if not (isinstance(value, int) and 0 <= value <= 1):
            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
        extend_enum(cls, 'Unassigned [%d]' % value, value)
        return cls(value)
        super()._missing_(value)
601518
def missing_input_files(self):
        
        missing = self.check_input_files(return_found=False)
        ret_dict = {}
        for miss_file in missing:
            ret_dict[miss_file] = [self.linkname]
        return ret_dict
1292023
def find_missing(spec_names)
      unless defined? @originals then
        @originals = {}
        each do |full_name, spec|
          @originals[spec.original_name] = spec
        end
      end

      spec_names.find_all { |full_name|
        @originals[full_name].nil?
      }
    end
280336
def unfinished_items(self):
    """"""
    return [(key, stat) for key, stat in self._statuses.items() if stat not in self.DONE_STATES]
916787
def get_missing_services(self, services):
        
        required_services = set(services)
        provided_services = set(self._services.keys())
        missing_services = required_services.difference(provided_services)

        return sorted(missing_services)
668951
def find_nir_file_with_missing_depth(video_file_list, depth_file_list):
        ""
        new_video_list = []
        new_depth_list = []
        for fname in video_file_list:
            try:
                depth_file = Kinect.depth_file_for_nir_file(fname, depth_file_list)                
                new_video_list.append(fname)
                new_depth_list.append(depth_file)
            except IndexError: # Missing file
                pass
                
        # Purge bad files
        bad_nir = [f for f in video_file_list if f not in new_video_list]
        bad_depth = [f for f in depth_file_list if f not in new_depth_list]
        
        return (new_video_list, new_depth_list, bad_nir, bad_depth)
174613
def find_missing_modules():
    
    missing_modules = []

    for module in MODULES:
        try:
            __import__(module[1])
        except ImportError:
            missing_modules.append(module)
    return missing_modules
9397
def find_missing_dependencies(self, requirement):
        
        known_dependencies = self.find_known_dependencies(requirement)
        if known_dependencies:
            installed_packages = self.find_installed_packages()
            logger.debug("Checking for missing dependencies of %s ..", requirement.name)
            missing_dependencies = sorted(set(known_dependencies).difference(installed_packages))
            if missing_dependencies:
                logger.debug("Found %s: %s",
                             pluralize(len(missing_dependencies), "missing dependency", "missing dependencies"),
                             concatenate(missing_dependencies))
            else:
                logger.info("All known dependencies are already installed.")
            return missing_dependencies
95358
function (list, value, missingIsFalse) {
				if (list === "*") return true;
				return list.length > 0 ? list.indexOf(value) != -1 : !missingIsFalse;
			}
742068
def remove_missing(self, data, return_bool="any"):
        

        if return_bool == "any":
            bool_sel = self._find_missing(data,return_bool="any")
        elif return_bool == "all":
            bool_sel = self._find_missing(data,return_bool="all")

        return data[~bool_sel]
201646
function findMissing(manifest, request, host, fn) {
  request
    .post(host + '/manifest/diff')
    .send({manifest: JSON.stringify(manifest)})
    .end(function(err, res) {
      if (err) return fn(err);
      if (res.error) return fn(res.error);
      fn(null, res.body);
    });
}
1273139
function selectMissing(missing, manifest, fn) {
  fn(null, manifest.filter(function(file) {
    return file && ~missing.indexOf(file.hash);
  }));
}
810326
def get_missing_bins(original, trimmed):
    

    original_diag = np.diag(original)
    trimmed_diag = np.diag(trimmed)
    index = []
    m = min(original.shape)
    for j in range(min(trimmed.shape)):
        k = 0
        while original_diag[j + k] != trimmed_diag[j] and k < 2 * m:
            k += 1
        index.append(k + j)
    return np.array(index)
526420
function mustContain(object = {}, ...keys) {
  let missingKeys = [];
  let promise;
  keys.forEach((key) => {
    if (object[key] === undefined) {
      missingKeys.push(key);
    }
  });
  if (missingKeys.length === 0) {
    missingKeys = undefined;
    promise = Promise.resolve();
  } else {
    promise = Promise.reject(
      new Error(`Missing keys ${missingKeys.join(', ')}`)
    );
  }

  return {
    missingKeys,
    promise,
  };
}
313131
private function checkMissingIngredients(): callable
    {
        return function (): void {
            /**
             * @var Chef $this
             */
            if (empty($this->missingIngredients)) {
                return;
            }

            throw new \RuntimeException(
                'Error, missing some ingredients : '
                . implode(', ', \array_keys($this->missingIngredients))
            );
        };
    }
274036
def get_missing_options(self):
		
		return [option.name for option in self._options.values() if option.required and option.value is None]