Delete a tag from the node.
324489
async def delTag(self, tag, init=False):
        '''
        
        '''
        path = s_chop.tagpath(tag)

        name = '.'.join(path)

        if self.isrunt:
            raise s_exc.IsRuntForm(mesg='Cannot delete tags from runt nodes.',
                                   form=self.form.full, tag=tag)

        curv = self.tags.pop(name, s_common.novalu)
        if curv is s_common.novalu:
            return False

        pref = name + '.'

        subtags = [(len(t), t) for t in self.tags.keys() if t.startswith(pref)]
        subtags.sort(reverse=True)

        removed = []

        for sublen, subtag in subtags:
            valu = self.tags.pop(subtag, None)
            removed.append((subtag, valu))

        removed.append((name, curv))

        info = {'univ': True}
        sops = [('prop:del', (self.buid, self.form.name, '#' + t, info)) for (t, v) in removed]

        # fire all the splices
        splices = [self.snap.splice('tag:del', ndef=self.ndef, tag=t, valu=v) for (t, v) in removed]
        await self.snap.stor(sops, splices)

        # fire all the handlers / triggers
        [await self.snap.core.runTagDel(self, t, v) for (t, v) in removed]
318124
def delete_node(self, name):
        

        name = self._validate_name(name)
        if name in self.nodes:
            del self.nodes[name]
728546
private void removeNode(Node node)
	{
		result.remove(node);

		for (Edge edge : node.getUpstream())
		{
			result.remove(edge);
		}

		for (Edge edge : node.getDownstream())
		{
			result.remove(edge);
		}
	}
1175396
def delete(self, tag, **kwds):
        
        return self._client.post("/tag/%s/delete.json" %
                                 self._quote_url(self._extract_id(tag)),
                                 **kwds)["result"]
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
312744
def remove_tag(tag_name, string):
    
    if not string:
        return string
    pattern = re.compile('</?' + tag_name + '.*?>')
    string = pattern.sub('', string)
    return string
180712
public function clearTag(string $tag): void
    {
        $keys = $this->getTagItems($tag);

        foreach ($keys as $key) {
            $this->unlink($key);
        }

        $this->rm($this->getTagKey($tag));
    }
1373247
public function removeTag(Tag $tag)
    {
        if ($this->tags->contains($tag)) {
            $this->tags->removeElement($tag);
            return true;
        }
        return false;
    }
822412
function clean($tag) {
		if (isset($this->_tags[$tag])) {
			foreach ($this->_tags[$tag] as $k) { /** @var string $k */
				unset($this->_data[$k]);
			}
			unset($this->_tags[$tag]);
		}
	}
745157
function remove(node) {
    var next = node.nextSibling || node.parentNode;

    node.parentNode.removeChild(node);

    return next;
}
525188
function() {
			var tag = this.tag;

			if (!tag) { return false; }

			this.unbind();
			if (tag.parentNode) { tag.parentNode.removeChild(tag); }

			delete this.tag;
			return true;
		}
124846
def delete_tag_from_job(user, job_id, tag_id):
    """"""

    _JJT = models.JOIN_JOBS_TAGS
    job = v1_utils.verify_existence_and_get(job_id, _TABLE)
    if not user.is_in_team(job['team_id']):
        raise dci_exc.Unauthorized()
    v1_utils.verify_existence_and_get(tag_id, models.TAGS)

    query = _JJT.delete().where(sql.and_(_JJT.c.tag_id == tag_id,
                                         _JJT.c.job_id == job_id))

    try:
        flask.g.db_conn.execute(query)
    except sa_exc.IntegrityError:
        raise dci_exc.DCICreationConflict('tag', 'tag_id')

    return flask.Response(None, 204, content_type='application/json')
662551
def remove_tag(self, *tag: str):
        
        LOGGER.info('removing tag(s) from repo: %s', tag)

        self.repo.delete_tag(*tag)
1249229
def delete_tags(sender, **kwargs):
    
    try:
        obj = kwargs.get('instance')
        tags = Tag.get_tags(obj)
        tags.delete()
    except AttributeError:
        pass
215322
def delete_tags(name, tags, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    if exists(name, region, key, keyid, profile):
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        ret = _remove_tags(conn, name, tags)
        return ret
    else:
        return False
390008
def _handle_tag_removeobject(self):
        """"""
        obj = _make_object("RemoveObject")
        obj.CharacterId = unpack_ui16(self._src)
        obj.Depth = unpack_ui16(self._src)
        return obj
655640
def remove_tag(self, tag):
        

        tags = self.get_tags()
        tags.remove(tag)

        post_data = TAGS_TEMPLATE.format(connectware_id=self.get_connectware_id(),
                                         tags=escape(",".join(tags)))
        self._conn.put('/ws/DeviceCore', post_data)

        # Invalidate cache
        self._device_json = None