Deletes all pipelines
		Args:
			returns		OK for overall success or last error code, resp data.
170287
def delete_all_pipelines(self):
		'''
		'''
		code, data = self.get_pipeline()
		if code == requests.codes.ok:
			for pl_data in data:
				c, d = self.delete_pipeline(pl_data['pipelineKey'])
				if c != requests.codes.ok:
					code = c
					data = d
		return code, data
762945
def _cleanup(self, kill, verbose):
        
        if kill:
            removed_indices = self.g.prune()

            self.nout -= len(removed_indices)

            if verbose and removed_indices:
                print('Removing %s' % removed_indices)

            for j in removed_indices:
                self.inv_map.pop(j[0])
1175414
def clean_cache_upstream(self):
        
        logger.info('Cleaning cache for the entire upstream pipeline')
        for step in self.all_upstream_steps.values():
            logger.info('Step {}, cleaning cache'.format(step.name))
            step.output = None
        return self
805656
def cleanup(self):
        
        if getattr(self._finalizer, "detach", None) and self._finalizer.detach():
            if os.path.exists(self.path):
                try:
                    rmtree(self.path)
                except OSError:
                    pass
                else:
                    self.path = None
485955
def cleanup(self):
        
        try:
            self.unload_lime()
        except AttributeError as ex:
            pass
        self.tunnel.cleanup()
        self.shell.cleanup()
183475
def clearReqVars(self):
        
        self.errorMsg = None
        self.payload = None
        self.url = None
        self.resp = None
        self.res = None
        self.method = None
        self.printErrors = None
74731
def clear(self) -> None:
        
        r = self.__api.delete('containers')
        if r.status_code != 204:
            self.__api.handle_erroneous_response(r)
1099667
def delete_raw(self):
        
        return client.delete(
            self.path(which='self'),
            **self._server_config.get_client_kwargs()
        )
1294477
def delete(path, dryrun=False, recursive=True, verbose=None, print_exists=True,
           ignore_errors=True):
    
    if verbose is None:
        verbose = VERBOSE
        if not QUIET:
            verbose = 1
    if verbose > 0:
        print('[util_path] Deleting path=%r' % path)
    exists_flag = exists(path)
    link_flag = islink(path)
    if not exists_flag and not link_flag:
        if print_exists and verbose:
            print('..does not exist!')
        flag = False
    else:
        rmargs = dict(verbose=verbose > 1, ignore_errors=ignore_errors,
                      dryrun=dryrun)
        if islink(path):
            os.unlink(path)
            flag = True
        elif isdir(path):
            # First remove everything in the directory
            flag = remove_files_in_dir(path, recursive=recursive, **rmargs)
            # Then remove the directory itself
            flag = flag and remove_dirs(path, **rmargs)
        elif isfile(path):
            flag = remove_file(path, **rmargs)
        else:
            raise ValueError('Unknown type of path=%r' % (path,))
        if verbose > 0:
            print('[util_path] Finished deleting path=%r' % path)
    return flag
125522
def clear(self, match="*", count=1000):
        
        cursor = '0'
        pipe = self._client.pipeline(transaction=False)
        while cursor != 0:
            cursor, keys = self.scan(cursor=cursor, match=match, count=count)
            if keys:
                pipe.delete(*keys)
        pipe.hdel(self._bucket_key, self.key_prefix)
        pipe.execute()
        return True
414383
def delete(self, name):
    '''
    
    '''
    keys = self._client.keys('%s%s:*'%(self._prefix,name))

    pipe = self._client.pipeline(transaction=False)
    for key in keys:
      pipe.delete( key )
    pipe.execute()

    # Could be not technically the exact number of keys deleted, but is a close
    # enough approximation
    return len(keys)
1072287
def cleanup(self, force=False, delete=False):
        
        # TODO: this method could be part of API, like:
        try:
            self.stop()
        except subprocess.CalledProcessError as stop:
            logger.debug("unable to stop container via stop", stop)
            if not force:
                raise stop
            try:
                self.kill()
            except subprocess.CalledProcessError as kill:
                logger.debug("unable to stop container via kill", kill)
                pass
        if delete:
            self.delete(force=force)
1325577
def reset_files(self):
        
        confirm = self.no_confirm

        path = SavepathParser.get_base_path(
            SavepathParser.get_abs_path_static(
                self.cfg.section("Files")["local_data_directory"],
                os.path.dirname(self.cfg_file_path)
            )
        )

        print("""
Cleanup files:
    This will delete {path} and all its contents.
""".format(path=path))

        if not confirm:
            confirm = 'yes' in builtins.input(
                """
    Do you really want to do this? Write 'yes' to confirm: {yes}"""
                    .format(yes='yes' if confirm else ''))

        if not confirm:
            print("Did not type yes. Thus aborting.")
            return

        print("Removing: {}".format(path))

        try:
            shutil.rmtree(path)
        except OSError as error:
            if not os.path.exists(path):
                self.log.error("%s does not exist.", path)
            self.log.error(error)
329307
private function deleteAllCompiled()
    {
        $env = array("dev", "prod");
        Output::displayAsSuccess("Hey, I delete compiled for all environment", "none");
        for ($i = 0; $i < count($env); $i++) {
            $this->callDelCreaServer($env[$i]);
        }
        if (in_array("--noexit", $this->options["options"])) {
            Output::displayAsEndSuccess("Compiled was deleted for all environment.", "none");
        } else {
            Output::displayAsNormal("Compiled was deleted for all environment.");
        }
    }
329669
def cleanup_services(self):
        
        services = self.list_services()

        for service in services:
            if service.namespace in self.managed_namespaces:
                service.delete()
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
1289070
def delete(self):
        
        result = gen.Task(self._redis_client.delete, self._key)
        raise gen.Return(bool(result))