Return all tags found in the value stream.

    Returns:
      A `{tagType: ['list', 'of', 'tags']}` dictionary.
814
def Tags(self):
    
    return {
        TENSORS: list(self.tensors_by_tag.keys()),
        # Use a heuristic: if the metagraph is available, but
        # graph is not, then we assume the metagraph contains the graph.
        GRAPH: self._graph is not None,
        META_GRAPH: self._meta_graph is not None,
        RUN_METADATA: list(self._tagged_metadata.keys())
    }
916544
def tags(self):
        
        tags = self.attrs.get('RepoTags')
        if tags is None:
            tags = []
        return [tag for tag in tags if tag != '<none>:<none>']
875227
def Tags(self):
    
    return {
        IMAGES: self.images.Keys(),
        AUDIO: self.audios.Keys(),
        HISTOGRAMS: self.histograms.Keys(),
        SCALARS: self.scalars.Keys(),
        COMPRESSED_HISTOGRAMS: self.compressed_histograms.Keys(),
        TENSORS: self.tensors.Keys(),
        # Use a heuristic: if the metagraph is available, but
        # graph is not, then we assume the metagraph contains the graph.
        GRAPH: self._graph is not None,
        META_GRAPH: self._meta_graph is not None,
        RUN_METADATA: list(self._tagged_metadata.keys())
    }
1149523
def as_dict(self):
        
        tags_dict = dict(self)
        tags_dict['@module'] = self.__class__.__module__
        tags_dict['@class'] = self.__class__.__name__
        return tags_dict
706823
def find_tags(self, tokens, **kwargs):
        
        # ["The", "cat", "purs"] => [["The", "DT"], ["cat", "NN"], ["purs", "VB"]]
        return find_tags(tokens,
                    lexicon = kwargs.get(   "lexicon", self.lexicon or {}),
                      model = kwargs.get(     "model", self.model),
                 morphology = kwargs.get("morphology", self.morphology),
                    context = kwargs.get(   "context", self.context),
                   entities = kwargs.get(  "entities", self.entities),
                   language = kwargs.get(  "language", self.language),
                    default = kwargs.get(   "default", self.default),
                        map = kwargs.get(       "map", None))
651221
def get_tagvalues(self, tagnames, tagidxs):
        
        values = tuple(getattr(self, tagname)[tagidx + 1]
                       for tagidx, tagname in zip(tagidxs, tagnames))
        return values
18911
def list_tags(self):
        
        from highton.models.tag import Tag
        return fields.ListField(
            name=self.ENDPOINT,
            init_class=Tag
        ).decode(
            self.element_from_string(
                self._get_request(
                    endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Tag.ENDPOINT,
                ).text
            )
        )
242957
function findAll(tags, key) {
  return tags
    .filter(function(tag) {
      return tag && tag.type === key
    })
    .map(function(tag) {
      return tag.string
    })
}
258448
def get_all_tags(self):
        
        db = Database(path=self.path)
        return [t for t in db.get_all_tags()]
150607
def tags(self):
		'''

		'''
		q = meta.Session.query(_tag.Tag)
		q = q.join(TagSemanticTag)
		q = q.filter_by(tag_id=self.id)
#		q = q.filter_by(state='active')
		q = q.order_by(_tag.Tag.name)
		tags = q.all()
		return tags
1368848
def tags( self ):
        
        item  = self.item(self.count() - 1)
        count = self.count()
        if ( item is self._createItem ):
            count -= 1
        
        return [nativestring(self.item(row).text()) for row in range(count)]
1065613
def list_tags():
    '''
    
    '''
    ret = set()
    for item in six.itervalues(images()):
        if not item.get('RepoTags'):
            continue
        ret.update(set(item['RepoTags']))
    return sorted(ret)
728918
public Collection<String> getAllTags() {
		return wrappedSubmit(new Callable<Collection<String>>() {

			@Override
			public Collection<String> call() throws Exception {
				Collection<String> allTags = new HashSet<String>();
				ObjectMapper mapper = new ObjectMapper();
				List<XmlTag> xmltags = new ArrayList<XmlTag>();
				try {xmltags = mapper.readValue(
										service.path(resourceTags)
										.accept(MediaType.APPLICATION_JSON)
										.get(String.class)	
									,new TypeReference<List<XmlTag>>(){});
				} catch (JsonParseException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (JsonMappingException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ClientHandlerException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				for (XmlTag xmltag : xmltags) {
					allTags.add(xmltag.getName());
				}
				return allTags;
			}
		});
	}
226432
def clear_tags(self) -> dict:
        

        return {t: self.tags[t] for t in (self.tags or {}) if t.startswith('~')} or None
277159
def pos_tags(self):
    
    tagged_words = []
    for word,t in self.pos_tagger.annotate(self.words):
      word.pos_tag = t
      tagged_words.append((word, t))
    return tagged_words
897267
def all_tags(self):
        """"""
        tags = set()
        for post in self:
            tags.update(post.tags)
        return list(tags)
799130
def get_tags(self, tagtype):
        '''  '''
        return [t for t in self.__tags if t.tagtype == tagtype]