return the actual lists of entries tagged with
421957
def entries(self):
        """"""
        Tags = Query()
        tag = self.table.get(Tags.name == self.name)
        posts = tag['post_ids']

        for id in posts:
            post = self.db.posts.get(doc_id=id)
            if not post:  # pragma: no coverage
                raise ValueError("No post found for doc_id %s" % id)
            yield Entry(os.path.join(CONFIG['content_root'], post['filename']), id)
469121
def as_list(self):
        """"""
        go_id = self.go_term.id
        
        qual_str = '|'.join(self.qualifier)
        db_ref_str = '|'.join(self.db_ref)
        taxon_str = '|'.join(self.taxon)

        # with_from is currently left as a string
        # with_from = '|'.join()
        with_from_str = self.with_from or ''
        db_name_str = self.db_name or ''
        db_syn_str = '|'.join(self.db_syn)
        ext_str = '|'.join(self.ext)
        product_id_str = self.product_id or ''

        l = [
            self.db,
            self.db_id,
            self.db_symbol,
            qual_str,
            go_id,
            db_ref_str,
            self.ev_code,
            with_from_str,
            self.aspect,
            db_name_str,
            db_syn_str,
            self.db_type,
            taxon_str,
            self.date,
            self.assigned_by,
            ext_str,
            product_id_str,
        ]
        return l
853065
def tags(self):
        
        return dict([(t, self._catalog.tags.get(t, t)) for t in self._asset.get("tags", [])])
280323
def get_tags(self):
    """"""
    return sorted([frozenset(meta_graph.meta_info_def.tags)
                   for meta_graph in self.meta_graphs])
197962
def tagNames(self):
        
        return self.store.query(_TagName, _TagName.catalog == self).getColumn("name")
443710
def listTagged(self, *args, **kwargs):
        
        data = yield self.call('listTagged', *args, **kwargs)
        builds = []
        for bdata in data:
            build = Build.fromDict(bdata)
            build.connection = self
            builds.append(build)
        defer.returnValue(builds)
1083143
def list_tags(userdata):
        
        macros = re.findall('@(.*?)@', userdata)
        logging.info('List of available macros:')
        for macro in macros:
            logging.info('\t%r', macro)
1340982
def tags(self):
        
        ret = {}
        for typ in _meta_fields_twig:
            if typ in ['uniqueid', 'plugin', 'feedback', 'fitting', 'history', 'twig', 'uniquetwig']:
                continue

            k = '{}s'.format(typ)
            ret[k] = getattr(self, k)

        return ret
722378
def related_to(self, entry, live_only=False):
        
        filters = {'tag__in': entry.tags}

        if live_only:
            filters.update({'entry__live': True})

        return self.filter(**filters).exclude(entry=entry)
157637
def __get_tags(vm_):
    '''
    
    '''
    t = config.get_cloud_config_value(
        'tags', vm_, __opts__,
        default='[]', search_global=False)
    # Consider warning the user that the tags in the cloud profile
    # could not be interpreted, bad formatting?
    try:
        tags = literal_eval(t)
    except Exception:  # pylint: disable=W0703
        tags = None
    if not tags or not isinstance(tags, list):
        tags = None
    return tags
920892
async def post_entry_tags(self, entry, tags):
        
        params = {'access_token': self.token, 'tags': []}
        if len(tags) > 0 and isinstance(tags, list):
            params['tags'] = ', '.join(tags)
        path = '/api/entries/{entry}/tags.{ext}'.format(
            entry=entry, ext=self.format)
        return await self.query(path, "post", **params)
1248331
def get_tags(self):
        
        j, _ = self.datacenter.request('GET', self.path + '/tags')
        return j
610877
def tagged(self, tag):
        """"""
        return PostCollection([p for p in self if unicode(tag) in p.tags])
106117
def tags(self):
        
        tags = self.fields['tags']
        return [(t, v) for t in tags for v in tags[t]]
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
            )
        )
1051581
def find_tags(self):
        """"""
        listing = self.context.capture('hg', 'tags')
        for line in listing.splitlines():
            tokens = line.split()
            if len(tokens) >= 2 and ':' in tokens[1]:
                revision_number, revision_id = tokens[1].split(':')
                yield Revision(
                    repository=self,
                    revision_id=revision_id,
                    revision_number=int(revision_number),
                    tag=tokens[0],
                )
439320
def get_tags(self, intersection=False):
        
        tags = set(list(self._tags))
        if intersection:
            for m in self.get_messages().keys():
                tags = tags.intersection(set(m.get_tags()))
        return tags