Return a :class:`~pyasn1.type.tagmap.TagMap` object mapping
            ASN.1 tags to ASN.1 objects contained within callee.
338702
def tagMap(self):
        "
        try:
            return self._tagMap

        except AttributeError:
            self._tagMap = tagmap.TagMap(
                {self.tagSet: self},
                {eoo.endOfOctets.tagSet: eoo.endOfOctets},
                self
            )

            return self._tagMap
505715
def tags(self):
        
        tags = self.definition.tags or {}
        return dict(self.context.tags, **tags)
410688
function Asn1Tag(tagClass, tagFormat, tagNumber) {
	this.tagClass = tagClass;
	this.tagFormat = tagFormat;
	this.tagNumber = tagNumber;
}
1356951
def tags(self, *names):
        
        if len(names) == 1 and isinstance(names[0], list):
            names = names[0]

        return TaggedCache(self, TagSet(self, names))
947201
def mapping_of(cls):
    """"""
    def mapper(data):
        if not isinstance(data, Mapping):
            raise TypeError(
                "data must be a mapping, not %s"
                % type(data).__name__)
        return {
            key: cls(value)
            for key, value in data.items()
        }
    return mapper
1059143
def tagged(self, *tag_slugs):
        
        if getattr(self.model, 'tags', None) is None:
            raise AttributeError("The {0} does not include TagsEntryMixin".format(self.model.__name__))

        if len(tag_slugs) == 1:
            return self.filter(tags__slug=tag_slugs[0])
        else:
            return self.filter(tags__slug__in=tag_slugs).distinct()
263837
def get_mapping(self, other):
        
        m = next(self._matcher(other).isomorphisms_iter(), None)
        if m:
            return {v: k for k, v in m.items()}
1064166
def encr_tags(self) -> dict:
        

        return {t: self._tags[t] for t in self.tags or {} if not t.startswith('~')} or None
243773
def partial_imap_1to1(func, si_func):
    
    @functools.wraps(si_func)
    def wrapper(input_):
        if not util_iter.isiterable(input_):
            return func(si_func(input_))
        else:
            return list(map(func, si_func(input_)))
    set_funcname(wrapper, util_str.get_callable_name(func) + '_mapper_' + get_funcname(si_func))
    return wrapper
820794
def map(self, callable):
        
        for k,v in self.iteritems():
            self[k] = callable(v)
108981
def get_label_mapping(train_labels):
    
    sorted_labels = np.sort(np.unique(train_labels))
    label_mapping = {}
    for i, label in enumerate(sorted_labels):
        label_mapping[label] = i
    logging.info('Label mapping:%s', format(label_mapping))
    return label_mapping
470779
def map(self, callback):
        
        return self.__class__(list(map(callback, self.items)))
1081717
public static function fromASN1(TaggedType $el): self
    {
        switch ($el->tag()) {
            // otherName
            case self::TAG_OTHER_NAME:
                return OtherName::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_SEQUENCE));
            // rfc822Name
            case self::TAG_RFC822_NAME:
                return RFC822Name::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_IA5_STRING));
            // dNSName
            case self::TAG_DNS_NAME:
                return DNSName::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_IA5_STRING));
            // x400Address
            case self::TAG_X400_ADDRESS:
                return X400Address::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_SEQUENCE));
            // directoryName
            case self::TAG_DIRECTORY_NAME:
                // because Name is a CHOICE, albeit having only one option,
                // explicit tagging must be used
                // (see X.680 07/2002 30.6.c)
                return DirectoryName::fromChosenASN1($el->asExplicit());
            // ediPartyName
            case self::TAG_EDI_PARTY_NAME:
                return EDIPartyName::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_SEQUENCE));
            // uniformResourceIdentifier
            case self::TAG_URI:
                return UniformResourceIdentifier::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_IA5_STRING));
            // iPAddress
            case self::TAG_IP_ADDRESS:
                return IPAddress::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_OCTET_STRING));
            // registeredID
            case self::TAG_REGISTERED_ID:
                return RegisteredID::fromChosenASN1(
                    $el->asImplicit(Element::TYPE_OBJECT_IDENTIFIER));
        }
        throw new \UnexpectedValueException(
            "GeneralName type " . $el->tag() . " not supported.");
    }
752488
private void getTagIdMapping(String tagId, String value, AbstractRenderAppender results)
    {
        if ((_javaScriptFeatures & CoreScriptFeature.ALLOCATE_LEGACY.value) == 0) {
            _javaScriptFeatures |= CoreScriptFeature.ALLOCATE_LEGACY.value;
            String s = getString("singleIdMappingTable", new Object[]{tagId, value});
            String meths = writeNetuiNameFunctions(null, true, false, false);
            if (meths != null)
                s += meths;
            writeScriptBlock(_req, results, s);
        }
        else {
            String s = getString("idMappingEntry", new Object[]{tagId, value});
            writeScriptBlock(_req, results, s);
        }
    }
541589
def map_from_module(self, module):
        
        maps = {}
        for name in dir(module):
            obj = getattr(module, name)
            try:
                if issubclass(obj, exceptions.HTTPException):
                    maps[name] = obj
            except TypeError as ter:
                pass
        self.mapping.update(maps)
799130
def get_tags(self, tagtype):
        '''  '''
        return [t for t in self.__tags if t.tagtype == tagtype]
46802
def _nodes_slots_to_slots_nodes(self, mapping):
        
        out = {}
        for node in mapping:
            for slot in node['slots']:
                out[str(slot)] = node['id']
        return out