list(context, verbose)

    List all tags.

    >>> dcictl tag-list

    :param boolean verbose: Display verbose output
9179
def list(context, verbose):
    
    result = tag.list(context)
    utils.format_output(result, context.format, verbose=verbose)
322330
def tags(self):
        
        # See also. Sentence.__repr__().
        ch, I,O,B = self.chunk, INSIDE+"-", OUTSIDE, BEGIN+"-"
        tags = [OUTSIDE for i in range(len(self.sentence.token))]
        for i, tag in enumerate(self.sentence.token): # Default: [WORD, POS, CHUNK, PNP, RELATION, ANCHOR, LEMMA]
            if tag == WORD:
                tags[i] = encode_entities(self.string)
            elif tag == POS and self.type:
                tags[i] = self.type
            elif tag == CHUNK and ch and ch.type:
                tags[i] = (self == ch[0] and B or I) + ch.type
            elif tag == PNP and self.pnp:
                tags[i] = (self == self.pnp[0] and B or I) + "PNP"
            elif tag == REL and ch and len(ch.relations) > 0:
                tags[i] = ["-".join([str(x) for x in [ch.type]+list(reversed(r)) if x]) for r in ch.relations]
                tags[i] = "*".join(tags[i])
            elif tag == ANCHOR and ch:
                tags[i] = ch.anchor_id or OUTSIDE
            elif tag == LEMMA:
                tags[i] = encode_entities(self.lemma or "")
            elif tag in self.custom_tags:
                tags[i] = self.custom_tags.get(tag) or OUTSIDE
        return tags
686740
def clause_texts(self):
        
        if not self.is_tagged(CLAUSES):
            self.tag_clauses()
        return self.texts(CLAUSES)
1214321
def find_output_with_tag(self, tag):
        
        # Enforce upper case
        tag = tag.upper()
        return FileList([i for i in self if tag in i.tags])
1105462
def verbose(self, msg, *args, **kw):
        """"""
        if self.isEnabledFor(VERBOSE):
            self._log(VERBOSE, msg, args, **kw)
343508
def list_nodes_with_tag(tag):
    """"""
    lib.print_nodes(lib.get_nodes_with_tag(tag, env.chef_environment,
                                           littlechef.include_guests))
164774
def _ListTags(self):
    """"""
    all_tags = []
    self._cursor.execute('SELECT DISTINCT tag FROM log2timeline')

    # This cleans up the messy SQL return.
    tag_row = self._cursor.fetchone()
    while tag_row:
      tag_string = tag_row[0]
      if tag_string:
        tags = tag_string.split(',')
        for tag in tags:
          if tag not in all_tags:
            all_tags.append(tag)
      tag_row = self._cursor.fetchone()
    # TODO: make this method an iterator.
    return all_tags
327151
def list_tags():
    
    codes = _AutoCodes()
    grouped = set([(k, '/{0}'.format(k), codes[k], codes['/{0}'.format(k)]) for k in codes if not k.startswith('/')])

    # Add half-tags like /all.
    found = [c for r in grouped for c in r[:2]]
    missing = set([('', r[0], None, r[1]) if r[0].startswith('/') else (r[0], '', r[1], None)
                   for r in _AutoCodes().items() if r[0] not in found])
    grouped |= missing

    # Sort.
    payload = sorted([i for i in grouped if i[2] is None], key=lambda x: x[3])  # /all /fg /bg
    grouped -= set(payload)
    payload.extend(sorted([i for i in grouped if i[2] < 10], key=lambda x: x[2]))  # b i u flash
    grouped -= set(payload)
    payload.extend(sorted([i for i in grouped if i[0].startswith('auto')], key=lambda x: x[2]))  # auto colors
    grouped -= set(payload)
    payload.extend(sorted([i for i in grouped if not i[0].startswith('hi')], key=lambda x: x[2]))  # dark colors
    grouped -= set(payload)
    payload.extend(sorted(grouped, key=lambda x: x[2]))  # light colors
    return tuple(payload)
1020018
def listItem(node):
    
    o = nodes.list_item()
    for n in MarkDown(node):
        o += n
    return o
933214
def git_list_tags(repo_dir, with_messages=False):
    """"""
    command = ['git', 'tag', '-l']
    if with_messages:
        command.append('-n1')
    raw = execute_git_command(command, repo_dir=repo_dir).splitlines()
    output = [l.strip() for l in raw if l.strip()]
    if with_messages:
        output = [tuple(j.strip() for j in line.split(None, 1))
                  for line in output]
    return output
281231
def tags(self):
        
        result = []
        a = javabridge.call(self.jobject, "getTags", "()Lweka/core/Tag;]")
        length = javabridge.get_env().get_array_length(a)
        wrapped = javabridge.get_env().get_object_array_elements(a)
        for i in range(length):
            result.append(Tag(javabridge.get_env().get_string(wrapped[i])))
        return result
1259999
def list(self, limit=None, marker=None, name=None, visibility=None,
            member_status=None, owner=None, tag=None, status=None,
            size_min=None, size_max=None, sort_key=None, sort_dir=None,
            return_raw=False):
        
        uri = "/%s" % self.uri_base
        qs = utils.dict_to_qs(dict(limit=limit, marker=marker, name=name,
                visibility=visibility, member_status=member_status,
                owner=owner, tag=tag, status=status, size_min=size_min,
                size_max=size_max, sort_key=sort_key, sort_dir=sort_dir))
        if qs:
            uri = "%s?%s" % (uri, qs)
        return self._list(uri, return_raw=return_raw)
1340656
def list(self, include_claimed=False, echo=False, marker=None, limit=None):
        
        return self._iterate_list(include_claimed=include_claimed, echo=echo,
                marker=marker, limit=limit)
527351
def tag_list(self, other_model=None, queryset=None):
        
        from taggit.models import Tag
        return Tag.objects.filter(id__in=self._taglist(other_model, queryset))
976424
def parse_verbosity(self, args):
    '''

    '''

    flags = []

    if args.silent is True:
       flags.append('--silent')
    elif args.quiet is True:
        flags.append('--quiet')
    elif args.debug is True:
       flags.append('--debug')
    elif args.verbose is True:
       flags.append('-' + 'v' * args.verbose)

    return flags
827142
def verbose(self):
        
        enabled = self.lib.iperf_get_verbose(self._test)

        if enabled:
            self._verbose = True
        else:
            self._verbose = False

        return self._verbose
22100
def tag_verb_chains(self):
        
        if not self.is_tagged(CLAUSES):
            self.tag_clauses()
        if self.__verbchain_detector is None:
            self.__verbchain_detector = load_default_verbchain_detector()
        sentences = self.divide()
        verbchains = []
        for sentence in sentences:
            chains = self.__verbchain_detector.detectVerbChainsFromSent( sentence )
            for chain in chains:
                # 1) Get spans for all words of the phrase
                word_spans = [ ( sentence[idx][START], sentence[idx][END] ) \
                                 for idx in sorted( chain[PHRASE] ) ]
                # 2) Assign to the chain
                chain[START] = [ span[0] for span in word_spans ]
                chain[END]   = [ span[1] for span in word_spans ]
            verbchains.extend(chains)
        self[VERB_CHAINS] = verbchains
        return self