Removes all of the Processors for
        a particular transaction processor zeromq identity.

        Args:
            processor_identity (str): The zeromq identity of the transaction
                processor.
342621
def remove(self, processor_identity):
        
        with self._condition:
            processor_types = self._identities.get(processor_identity)
            if processor_types is None:
                LOGGER.warning("transaction processor with identity %s tried "
                               "to unregister but was not registered",
                               processor_identity)
                return
            for processor_type in processor_types:
                if processor_type not in self._processors:
                    LOGGER.warning("processor type %s not a known processor "
                                   "type but is associated with identity %s",
                                   processor_type,
                                   processor_identity)
                    continue
                self._processors[processor_type].remove_processor(
                    processor_identity=processor_identity)
                if not self._processors[processor_type]:
                    del self._processors[processor_type]
1314769
def delete(self):
        

        if self._hypervisor and self in self._hypervisor.devices:
            self._hypervisor.devices.remove(self)
        if self._hypervisor and not self._hypervisor.devices:
            yield from self._hypervisor.send('nio_bridge delete "{}"'.format(self._name))
551118
def remove_identity(cls, sh_db, ident_id):
        
        success = False
        try:
            api.delete_identity(sh_db, ident_id)
            logger.debug("Identity %s deleted", ident_id)
            success = True
        except Exception as e:
            logger.debug("Identity not deleted due to %s", str(e))

        return success
734820
def remove_programmer(programmer_id):
    

    log.debug('remove %s', programmer_id)
    lines = programmers_txt().lines()
    lines = filter(
        lambda x: not x.strip().startswith(programmer_id + '.'), lines)
    programmers_txt().write_lines(lines)
1215077
def remove_nio(self, nio):
        
        if self._hypervisor:
            yield from self._hypervisor.send('nio_bridge remove_nio "{name}" {nio}'.format(name=self._name, nio=nio))
        self._nios.remove(nio)
1237905
def _del_process(self, dwProcessId):
        
        try:
            aProcess = self.__processDict[dwProcessId]
            del self.__processDict[dwProcessId]
        except KeyError:
            aProcess = None
            msg = "Unknown process ID %d" % dwProcessId
            warnings.warn(msg, RuntimeWarning)
        if aProcess:
            aProcess.clear()
66273
def Delete(self):
		
		return(clc.v2.Requests(clc.v2.API.Call('DELETE','servers/%s/%s' % (self.alias,self.id),session=self.session),alias=self.alias,session=self.session))
1016461
def remove_data_flow(self, data_flow_id, destroy=True):
        
        if data_flow_id not in self._data_flows:
            raise AttributeError("The data_flow_id %s does not exist" % str(data_flow_id))

        self._data_flows[data_flow_id].parent = None
        return self._data_flows.pop(data_flow_id)
82528
def drop_all(self, queue_name):
        
        task_ids = self.conn.lrange(queue_name, 0, -1)

        for task_id in task_ids:
            self.conn.delete(task_id)

        self.conn.delete(queue_name)
1351954
def clear_queue(self, queue_type=None, queue_id=None, purge_all=False):
        
        if queue_id is None or not is_valid_identifier(queue_id):
            raise BadArgumentException('`queue_id` has an invalid value.')

        if queue_type is None or not is_valid_identifier(queue_type):
            raise BadArgumentException('`queue_type` has an invalid value.')

        response = {
            'status': 'Failure',
            'message': 'No queued calls found'
            }
        # remove from the primary sorted set
        primary_set = '{}:{}'.format(self._key_prefix, queue_type)
        queued_status = self._r.zrem(primary_set, queue_id)
        if queued_status:
            response.update({'status': 'Success', 
                    'message': 'Successfully removed all queued calls'})
        # do a full cleanup of reources
        # although this is not necessary as we don't remove resources 
        # while dequeue operation
        job_queue_list = '{}:{}:{}'.format(self._key_prefix, queue_type, queue_id)
        if queued_status and purge_all:
            job_list = self._r.lrange(job_queue_list, 0, -1)
            pipe = self._r.pipeline()
            # clear the payload data for job_uuid
            for job_uuid in job_list:
                if job_uuid is None:
                    continue
                payload_set = '{}:payload'.format(self._key_prefix)
                job_payload_key = '{}:{}:{}'.format(queue_type, queue_id, job_uuid)
                pipe.hdel(payload_set, job_payload_key)
            # clear jobrequest interval
            interval_set = '{}:interval'.format(self._key_prefix)
            job_interval_key = '{}:{}'.format(queue_type, queue_id)
            pipe.hdel(interval_set, job_interval_key)
            # clear job_queue_list
            pipe.delete(job_queue_list)
            pipe.execute()
            response.update({'status': 'Success', 
                    'message': 'Successfully removed all queued calls and purged related resources'})
        else:
            # always delete the job queue list
            self._r.delete(job_queue_list)
        return response
15450
private void deleteIdentifier(String ident) {
		if (!StringUtils.isBlank(ident)) {
			CoreUtils.getInstance().getDao().delete(getAppid(), new Sysprop(ident));
		}
	}
1171371
def syscall_clearremovequeue(queue, index):
    '''
    
    '''
    def _syscall(scheduler, processor):
        qes, qees = queue[index].clear()
        events = scheduler.queue.unblockqueue(queue[index])
        for e in events:
            scheduler.eventtree.remove(e)
        qes2, qees2 = queue.removeSubQueue(index)
        for e in qes:
            processor(e)
        for e in qes2:
            processor(e)
        for e in qees:
            processor(e)
        for e in qees2:
            processor(e)
    return _syscall
106539
public void remove(Identity oid)
    {
        //processQueue();
        if(oid != null)
        {
            removeTracedIdentity(oid);
            objectTable.remove(buildKey(oid));
            if(log.isDebugEnabled()) log.debug("Remove object " + oid);
        }
    }
338812
public void remove(Identity oid)
    {
        if (oid == null) return;

        ObjectCache cache = getCache(oid, null, METHOD_REMOVE);
        if (cache != null)
        {
            cache.remove(oid);
        }
    }
1242412
public void remove(Identity oid)
    {
        if(log.isDebugEnabled()) log.debug("Remove object " + oid);
        sessionCache.remove(oid);
        getApplicationCache().remove(oid);
    }
438165
def _disable_prometheus_process_collector(self) -> None:
        
        logger.info("Removing prometheus process collector")
        try:
            core.REGISTRY.unregister(PROCESS_COLLECTOR)
        except KeyError:
            logger.debug("PROCESS_COLLECTOR already removed from prometheus")
1310501
def clean_up(self):
        
        self.log.debug("Closing I2C bus for address: 0x%02X" % self.address)
        self.bus.close()