force : bool
        keep : bool
        machine_tags : typing.Sequence[str]
        Returns -> typing.Sequence[~DestroyMachineResult]
510379
async def DestroyMachineWithParams(self, force, keep, machine_tags):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='MachineManager',
                   request='DestroyMachineWithParams',
                   version=5,
                   params=_params)
        _params['force'] = force
        _params['keep'] = keep
        _params['machine-tags'] = machine_tags
        reply = await self.rpc(msg)
        return reply
1366095
def ensure_proc_terminate(proc):
    
    if isinstance(proc, list):
        for p in proc:
            ensure_proc_terminate(p)
        return

    def stop_proc_by_weak_ref(ref):
        proc = ref()
        if proc is None:
            return
        if not proc.is_alive():
            return
        proc.terminate()
        proc.join()

    assert isinstance(proc, mp.Process)
    atexit.register(stop_proc_by_weak_ref, weakref.ref(proc))
1254295
def affects(self, reglist):
        
        if isinstance(reglist, str):
            reglist = [reglist]

        reglist = single_registers(reglist)

        return len([x for x in self.destroys if x in reglist]) > 0
813357
def delete(name, force=False):
    '''
    
    '''
    ret = {}

    if name not in list_nictags():
        return True

    cmd = 'nictagadm delete {0}{1}'.format("-f " if force else "", name)
    res = __salt__['cmd.run_all'](cmd)

    if res['retcode'] == 0:
        return True
    else:
        return {'Error': 'failed to delete nictag.' if 'stderr' not in res and res['stderr'] == '' else res['stderr']}
306822
def terminate
      @mtx.synchronize do
        return false if not @running
        Message.new(TERM).send_to(self)
        await_handler_death
        true
      end
    rescue IO::EAGAINWaitWritable
      # same as in #<<
      retry
    end
1144212
public synchronized int cancelByTag(String tagToCancel) {
        int i = 0;
        if (taskList.containsKey(tagToCancel)) {
            removeDoneTasks();

            for (Future<BlurWorker.Result> future : taskList.get(tagToCancel)) {
                BuilderUtil.logVerbose(Dali.getConfig().logTag, "Canceling task with tag " + tagToCancel, Dali.getConfig().debugMode);
                future.cancel(true);
                i++;
            }

            //remove all canceled tasks
            Iterator<Future<BlurWorker.Result>> iter = taskList.get(tagToCancel).iterator();
            while (iter.hasNext()) {
                if (iter.next().isCancelled()) {
                    iter.remove();
                }
            }
        }
        return i;
    }
438426
async def DestroyMachines(self, force, machine_names):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Client',
                   request='DestroyMachines',
                   version=1,
                   params=_params)
        _params['force'] = force
        _params['machine-names'] = machine_names
        reply = await self.rpc(msg)
        return reply
303516
def remove_tag(tag)

      # it's a bit convoluted... trying to cope with potential inconsistencies
      #
      # normally, it should only be a tags.pop(), but since user have
      # access to the workitem and its fields... better be safe than sorry

      tags = (h.fields['__tags__'] || [])

      if index = tags.rindex(tag)
        tags.delete_at(index)
      end

      h.fields['__left_tag__'] = tag
    end
256497
def remove(self, force=False):
        
        if force:
            _fs, filename = opener.parse(self.uri)
            _fs.remove(filename)
        self.uri = None
190101
def destroy(self, force=False):
        
        if force:
            super(UnmanagedLXC, self).destroy()
        else:
            raise UnmanagedLXCError('Destroying an unmanaged LXC might not '
                'work. To continue please call this method with force=True')
23442
def delete_tag(self, tag_name, **kwargs):
        
        resp = self._delete(self._u(self._TAG_ENDPOINT_SUFFIX, tag_name),
                            **kwargs)
        resp.raise_for_status()
        # successful delete returns 204, which has no associated json
        return resp
179852
def destroy(force = false)
      delete_bucket
      true
    rescue Error::BucketNotEmpty
      if force
        objects.destroy_all
        retry
      else
        raise
      end
    end
1279681
async def delete_entry_tag(self, entry, tag):
        
        params = {'access_token': self.token}
        url = '/api/entries/{entry}/tags/{tag}.{ext}'.format(
            entry=entry, tag=tag, ext=self.format)
        return await self.query(url, "delete", **params)
1369127
def delete_tag(self, tag):
        
        j, r = self.datacenter.request('DELETE', self.path + '/tags/' + tag)
        r.raise_for_status()
349145
def close(self, force=False) -> None:
        
        self.fp.close = self._close
        if self._manual_opened or force:
            self.fp.close()
661961
def stop(self, force=False):
		
		if self._initialized:
			self.send(C1218TerminateRequest())
			data = self.recv()
			if data == b'\x00' or force:
				self._initialized = False
				self._toggle_bit = False
				return True
		return False
395497
def remove_tag(self, tag, value, silent_fail=False):
        
        try:
            self.tags.remove((tag, value))
        except ValueError as err:
            if not silent_fail:
                raise err