Remove a Consumer tag.

            If no tag is specified, all all tags will be removed.

        :param str|None tag: Consumer tag.
        :return:
15460
def remove_consumer_tag(self, tag=None):
        
        if tag is not None:
            if tag in self._consumer_tags:
                self._consumer_tags.remove(tag)
        else:
            self._consumer_tags = []
599943
async def xgroup_del_consumer(self, name: str, group: str, consumer: str) -> int:
        
        return await self.execute_command('XGROUP DELCONSUMER', name, group, consumer)
818530
def cancel(self, consumer_tag=None):
		
		if not consumer_tag:
			if not hasattr(self, "consumer_tag"):
				return
			consumer_tag = self.consumer_tag
		self.channel.basic_cancel(consumer_tag)
1079565
def delete(self, tag, params={}, **options): 
        
        path = "/tags/%s" % (tag)
        return self.client.delete(path, params, **options)
129810
def delete(self, filething=None):
        

        self.tags.clear()
        self.save(filething, padding=lambda x: 0)
929431
def clear(self, tag=None):
        
        if tag is None:
            del self.jobs[:]
        else:
            self.jobs[:] = (job for job in self.jobs if tag not in job.tags)
914606
def remove_tag(self, task, params={}, **options): 
        
        path = "/tasks/%s/removeTag" % (task)
        return self.client.post(path, params, **options)
1206366
def _consume_add_and_get_tag(self, consume_rpc_result):
        
        consumer_tag = consume_rpc_result['consumer_tag']
        self._channel.add_consumer_tag(consumer_tag)
        return consumer_tag
340423
def removeTags(dom):
    
    # python 2 / 3 shill
    try:
        string_type = basestring
    except NameError:
        string_type = str

    # initialize stack with proper value (based on dom parameter)
    element_stack = None
    if type(dom) in [list, tuple]:
        element_stack = dom
    elif isinstance(dom, HTMLElement):
        element_stack = dom.childs if dom.isTag() else [dom]
    elif isinstance(dom, string_type):
        element_stack = parseString(dom).childs
    else:
        element_stack = dom

    # remove all tags
    output = ""
    while element_stack:
        el = element_stack.pop(0)

        if not (el.isTag() or el.isComment() or not el.getTagName()):
            output += el.__str__()

        if el.childs:
            element_stack = el.childs + element_stack

    return output
1144582
def delete_tag(self, tag_id):
        
        from highton.models.tag import Tag

        self._delete_request(
            endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Tag.ENDPOINT + '/' + str(tag_id),
        )
939255
def takeTag( self, tag ):
        
        for row in range(self.count() - 1):
            item = self.item(row)
            if ( item and item.text() == tag ):
                self.takeItem(row)
                if ( not self.signalsBlocked() ):
                    self.tagRemoved.emit(tag)
                return item
        return None
141174
def remove_tag_all(self, resource_type, resource_id, **_params):
        """"""
        return self.delete(self.tags_path % (resource_type, resource_id))
251407
def del_tag(
            self,
            tag):
        

        if tag.replace("@", "") not in self.tags:
            return

        self.refresh
        oldContent = self.to_string(indentLevel=1)
        newTags = []
        newTags[:] = [n for n in newTags if tag not in n]
        self.tags = newTags
        newContent = self.to_string(indentLevel=1)

        # ADD DIRECTLY TO CONTENT IF THE PROJECT IS BEING ADDED SPECIFICALLY TO
        # THIS OBJECT
        self.parent._update_document_tree(
            oldContent=oldContent,
            newContent=newContent
        )

        self.refresh
        return None
192685
def remove_tag(self, tag):
        """"""

        if isinstance(tag, Tag):
            tag = tag.get_name()

        params = self._get_params()
        params["tag"] = tag

        self._request(self.ws_prefix + ".removeTag", False, params)
520732
def job_remove_tags(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/removeTags' % object_id, input_params, always_retry=always_retry, **kwargs)
824587
def untag(name, tag_name):
    

    with LOCK:
        by_tag = TAGS.get(tag_name, None)
        if not by_tag:
            return False
        try:
            by_tag.remove(name)

            # remove the tag if no associations left
            if not by_tag:
                TAGS.pop(tag_name)

            return True
        except KeyError:
            return False
226432
def clear_tags(self) -> dict:
        

        return {t: self.tags[t] for t in (self.tags or {}) if t.startswith('~')} or None