Get the tags and reference numbers of all the vgroup
        members.

        Args::

          no argument

        Returns::

          list of (tag,ref) tuples, one for each vgroup member

        C library equivalent : Vgettagrefs
322458
def tagrefs(self):
        
        n = self._nmembers
        ret = []
        if n:
            tags = _C.array_int32(n)
            refs = _C.array_int32(n)
            k = _C.Vgettagrefs(self._id, tags, refs, n)
            _checkErr('tagrefs', k, "error getting tags and refs")
            for m in xrange(k):
                ret.append((tags[m], refs[m]))

        return ret
443607
def get_context_tags(self):
        
        self.assert_open()
        if self.has_context_tags:
            tags = self.handle[self.global_key + 'context_tags'].attrs.items()
            return {key: _clean(value) for key, value in tags}
        return {}
1372723
def contrib_xref(contrib_tag, ref_type):
    
    aff_tags = []
    for child_tag in contrib_tag:
        if (child_tag and child_tag.name and child_tag.name == "xref"
            and child_tag.get('ref-type') and child_tag.get('ref-type') == ref_type):
            aff_tags.append(child_tag)
    return aff_tags
995430
def get_tag(self, tagtype):
        ''' '''
        for tag in self.__tags:
            if tag.tagtype == tagtype:
                return tag
        return None
922179
def _gettags(self, codes=None, lock=None):
        """"""
        tags = []
        for tag in self.tags.values():
            code = tag.code
            if not codes or code in codes:
                tags.append((code, tag))
        return tags
663556
def get_all_tags(image_name, branch=None):
    
    try:
        return get_all_tags_no_auth(image_name, branch)
    except AuthException:
        return get_all_tags_with_auth(image_name, branch)
907439
def list_tag(path = Dir.pwd)
      res = {}
      cg  = MiniGit::Capturing.new(path)
      unless (cg.tag :list => true).empty?
        # git show-ref --tags
        a = (cg.show_ref :tags => true).split("\n")
        res = Hash[ a.collect { |item| item.split(' refs/tags/') } ].invert
      end
      res
    end
1027791
def _get_all_tags(conn, load_balancer_names=None):
    '''
    
    '''
    params = {}
    if load_balancer_names:
        conn.build_list_params(params, load_balancer_names,
                               'LoadBalancerNames.member.%d')

    tags = conn.get_object(
        'DescribeTags',
        params,
        __utils__['boto_elb_tag.get_tag_descriptions'](),
        verb='POST'
    )
    if tags[load_balancer_names]:
        return tags[load_balancer_names]
    else:
        return None
1370187
def count_by_tag(stack, descriptor):
    
    ec2_conn = boto.ec2.connection.EC2Connection()
    resses = ec2_conn.get_all_instances(
                    filters={
                        'tag:stack': stack,
                        'tag:descriptor': descriptor
                    })
    instance_list_raw = list()
    [[instance_list_raw.append(x) for x in res.instances] for res in resses]
    instance_list = [x for x in instance_list_raw if state_filter(x)]
    instances = len(instance_list)
    return instances
641505
def tags(self):
        
        tag_list = self.spec.get('tag', [])
        if isinstance(tag_list, (list, set, tuple)):
            return list(tag_list)
        return [tag_list]
169491
def tags(self):
        ''''''
        return itertools.product(
            self.py_version.split('.'),
            self.abi.split('.'),
            self.platform.split('.'),
        )
938019
def reffinder(sectionObj):
    
    text = sectionObj['text']
    reftags = [x for x in refTagRegEx.finditer(text)]
    if reftags:
        references = []
        for tag in reftags:
            references.append(int(tag.group(1)))

        sectionObj['references'] = references

        text = refTagRegEx.sub('', text)
        sectionObj['text'] = text

    return sectionObj
840610
def get_predicate_indices(tags: List[str]) -> List[int]:
    
    return [ind for ind, tag in enumerate(tags) if 'V' in tag]
1289438
def find_tags(self, tag_name, **attribute_filter):
        
        all_tags = [
            self.find_tags_from_xml(
                i, tag_name, **attribute_filter
            )
            for i in self.xml
        ]
        return [tag for tag_list in all_tags for tag in tag_list]
380239
def git_tags() -> str:
    
    try:
        subprocess.check_call(['git', 'fetch', '--tags'])
    except CalledProcessError:
        pass

    cmd = ['git', 'tag', '--list', '--sort=-v:refname']
    rv = subprocess.check_output(cmd).decode('utf-8')

    if rv == '':
        raise NoGitTagsException('No Git tags are present in current repo.')

    return rv
317906
def _get_group_no(self, tag_name):
        

        if tag_name in self.full:
            return self.groups.index(self.full[tag_name]["parent"])
        else:
            return len(self.groups)
1330300
def get_all_client_tags(self, params=None):
        
        return self._iterate_through_pages(
            get_function=self.get_client_tags_per_page,
            resource=CLIENT_TAGS,
            **{'params': params}
        )