Remove a specific subject by its identifier.
335430
def delete_subject(self, subject_id):
        
        # subject_id could be a path such as '/role/analyst' so quote
        uri = self._get_subject_uri(guid=subject_id)
        return self.service._delete(uri)
393680
def remove(self, idx):
        
        data = {}
        for k in self.data:
            data[k] = np.delete(self.data[k], idx)
        return self._return(data=data)
1152489
def set_remove(parent, idx, value):
  """"""
  lst = get_child(parent, idx)
  if value in lst:
    lst.remove(value)
82041
def remove(h, i):
    """"""
    n = h.size() - 1
    if n != i:
        h.swap(i, n)
        down(h, i, n)
        up(h, i)

    return h.pop()
135744
def remove(self, identifier: Union[DataObjectReplica, int]):
        
        if isinstance(identifier, int):
            self._remove_by_number(identifier)
        elif isinstance(identifier, DataObjectReplica):
            self._remove_by_object(identifier)
        else:
            raise TypeError("Can only remove by number or by object reference: `%s` given" % type(identifier))
1181503
def delete_object(self, id):
        """"""
        return self.request(
            "{0}/{1}".format(self.version, id), method="DELETE"
        )
1090760
def drop_column(self, name):
        
        name = self._normalize_identifier(name)
        del self._columns[name]

        return self
698897
def raise_on_changed_subject_identifier(self):
        
        if self.id and self.subject_identifier_is_set():
            with transaction.atomic():
                obj = self.__class__.objects.get(pk=self.id)
                if obj.subject_identifier != self.subject_identifier_as_pk.hex:
                    if self.subject_identifier != obj.subject_identifier:
                        raise RegisteredSubjectError(
                            'Subject identifier cannot be changed for '
                            'existing registered subject. Got {} <> {}.'.format(
                                self.subject_identifier, obj.subject_identifier))
215270
def pop(self, name: str, default: Any=_sentinel) -> Any:
        """"""
        if default is _sentinel:
            return self.__dict__.pop(name)
        else:
            return self.__dict__.pop(name, default)
535089
def _delete(self, identifier=None):
        
        assert identifier is not None, 'identifier argument can not be None.'
        writer = self.index.writer()
        writer.delete_by_term('identifier', identifier)
        writer.commit()
584860
def removeIndividual(self):
        
        self._openRepo()
        dataset = self._repo.getDatasetByName(self._args.datasetName)
        individual = dataset.getIndividualByName(self._args.individualName)

        def func():
            self._updateRepo(self._repo.removeIndividual, individual)
        self._confirmDelete("Individual", individual.getLocalId(), func)
1261950
def _remove(self, obj):
        """"""
        for idx, item in enumerate(self._queue):
            if item == obj:
                del self._queue[idx]
                break
518239
def remove(self, key):
        """"""
        item = self.item_finder.pop(key)
        item[-1] = None
        self.removed_count += 1
431265
def remove(self, func):
        """"""
        if not self.data['name'].startswith(self.prefix):
            return
        parent = self.get_parent(self.get_log())
        _, sink_path, _ = self.get_sink()
        client = self.session.client(
            'logging', 'v2', '%s.sinks' % (parent.split('/', 1)[0]))
        try:
            client.execute_command(
                'delete', {'sinkName': sink_path})
        except HttpError as e:
            if e.resp.status != 404:
                raise
19693
def remove(self, iid):
        '''
            
        '''
        for index in iid:
            target = Target.getTarget(index)

            target.delete()
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
15450
private void deleteIdentifier(String ident) {
		if (!StringUtils.isBlank(ident)) {
			CoreUtils.getInstance().getDao().delete(getAppid(), new Sysprop(ident));
		}
	}