Python util.tagsplit函数代码示例

    def Menu(self, header, browser, library):
        songs = self.get_selected_songs()
        if not songs: return

        can_filter = browser.can_filter

        menu = browser.Menu(songs, self, library)

        def Filter(t):
            # Translators: The substituted string is the name of the
            # selected column (a translated tag name).
            b = qltk.MenuItem(
                _("_Filter on %s") % util.tag(t, True), gtk.STOCK_INDEX)
            b.connect_object('activate', self.__filter_on, t, songs, browser)
            return b

        header = util.tagsplit(header)[0]

        if can_filter("artist") or can_filter("album") or can_filter(header):
            menu.preseparate()

        if can_filter("artist"):
            menu.prepend(Filter("artist"))
        if can_filter("album"):
            menu.prepend(Filter("album"))
        if (header not in ["artist", "album"] and can_filter(header)):
            menu.prepend(Filter(header))

        ratings = RatingsMenuItem(songs, library)
        menu.preseparate()
        menu.prepend(ratings)
        menu.show_all()
        return menu

def get_sort_tag(tag):
    """Returns a tag that can be used for sorting for the given column tag.

    Returns '' if the default sort key should be used.
    """

    replace_order = {
        "~#track": "",
        "~#disc": "",
        "~length": "~#length"
    }

    if tag == "~title~version":
        tag = "title"
    elif tag == "~album~discsubtitle":
        tag = "album"

    if tag.startswith("<"):
        for key, value in replace_order.iteritems():
            tag = tag.replace("<%s>" % key, "<%s>" % value)
        tag = Pattern(tag).format
    else:
        tags = util.tagsplit(tag)
        sort_tags = []
        for tag in tags:
            tag = replace_order.get(tag, tag)
            tag = TAG_TO_SORT.get(tag, tag)
            if tag not in sort_tags:
                sort_tags.append(tag)
        if len(sort_tags) > 1:
            tag = "~" + "~".join(sort_tags)

    return tag

 def __tag(self, node, scope, qscope, tags, queries, text_formatter):
     text = []
     if isinstance(node, TextNode):
         if text_formatter:
             text.append("a(_format(%r))" % node.text)
         else:
             text.append("a(%r)" % node.text)
     elif isinstance(node, ConditionNode):
         var = self.__get_query(text, scope, qscope, node.expr, queries)
         ic = self.__tag(node.ifcase, dict(scope), dict(qscope), tags, queries, text_formatter)
         ec = self.__tag(node.elsecase, dict(scope), dict(qscope), tags, queries, text_formatter)
         if not ic and not ec:
             text.pop(-1)
         elif ic:
             text.append("if %s:" % var)
             text.extend(ic)
             if ec:
                 text.append("else:")
                 text.extend(ec)
         else:
             text.append("if not %s:" % var)
             text.extend(ec)
     elif isinstance(node, TagNode):
         tags.extend(util.tagsplit(node.tag))
         var = self.__get_value(text, scope, node.tag)
         text.append("a(%s)" % var)
     elif isinstance(node, PatternNode):
         for child in node.children:
             for line in self.__tag(child, scope, qscope, tags, queries, text_formatter):
                 text.append("  " + line)
     return text

    def __get_sort_tag(self, tag):
        replace_order = {
            "~#track": "",
            "~#disc": "",
            "~length": "~#length"
        }

        if tag == "~title~version":
            tag = "title"
        elif tag == "~album~discsubtitle":
            tag = "album"

        if tag.startswith("<"):
            for key, value in replace_order.iteritems():
                tag = tag.replace("<%s>" % key, "<%s>" % value)
            tag = Pattern(tag).format
        else:
            tags = util.tagsplit(tag)
            sort_tags = []
            for tag in tags:
                tag = replace_order.get(tag, tag)
                tag = TAG_TO_SORT.get(tag, tag)
                if tag not in sort_tags:
                    sort_tags.append(tag)
            if len(sort_tags) > 1:
                tag = "~" + "~".join(sort_tags)

        return tag

 def __cols_changed(self, view, browser):
     for header in view.get_columns():
         tag = header.header_name
         for t in util.tagsplit(tag):
             if t in browser.headers:
                 header.set_visible(True)
                 break
         else: header.set_visible(False)

def header_tag_split(header):
    """Split a pattern or a tied tag into separate tags"""

    if "<" in header:
        try:
            return list(Pattern(header).tags)
        except ValueError:
            return []
    else:
        return util.tagsplit(header)

 def get(self, key, default="", connector=" - "):
     if key[:1] == "~" and '~' in key[1:]:
         return connector.join(map(self.get, util.tagsplit(key)))
     elif key[:1] == "~" and key[-4:-3] == ":":
         func = key[-3:]
         key = key[:-4]
         return "%s<%s>" % (util.tag(key), func)
     elif key in self:
         return self[key]
     return util.tag(key)

 def list_separate(self, key):
     """For tied tags return the list union of the display,sort values
        otherwise just do list_sort
     """
     if key[:1] == "~" and "~" in key[1:]: # tied tag
         vals = [self.list_sort(tag) for tag in util.tagsplit(key)]
         r = [j for i in vals for j in i]
         return r
     else:
         return self.list_sort(key)

 def __hide_headers(self, activator=None):
     for column in self.songlist.get_columns():
         if self.browser.headers is None:
             column.set_visible(True)
         else:
             for tag in util.tagsplit(column.header_name):
                 if tag in self.browser.headers:
                     column.set_visible(True)
                     break
             else: column.set_visible(False)

    def __init__(self, row_pattern):
        parts = re.split(r"(?<!\\):", row_pattern)
        parts = list(map(lambda p: p.replace(r"\:", ":"), parts))

        is_numeric = lambda s: s[:2] == "~#" and "~" not in s[2:]
        is_pattern = lambda s: '<' in s
        f_round = lambda s: (isinstance(s, float) and "%.2f" % s) or s

        disp = (len(parts) >= 2 and parts[1]) or r"[i](<~#tracks>)[/i]"
        cat = parts[0]

        if is_pattern(cat):
            title = util.pattern(cat, esc=True, markup=True)
            try:
                pc = XMLFromPattern(cat)
            except ValueError:
                pc = XMLFromPattern("")
            tags = pc.tags
            format = pc.format_list
            has_markup = True
        else:
            title = util.tag(cat)
            tags = util.tagsplit(cat)
            has_markup = False
            if is_numeric(cat):

                def format(song):
                    v = text_type(f_round(song(cat)))
                    return [(v, v)]
            else:
                format = lambda song: song.list_separate(cat)

        if is_pattern(disp):
            try:
                pd = XMLFromPattern(disp)
            except ValueError:
                pd = XMLFromPattern("")
            format_display = pd.format
        else:
            if is_numeric(disp):
                format_display = lambda coll: text_type(f_round(coll(disp)))
            else:
                format_display = lambda coll: util.escape(coll.comma(disp))

        self.title = title
        self.tags = set(tags)
        self.format = format
        self.format_display = format_display
        self.has_markup = has_markup

 def list_separate(self, key, connector=" - "):
     """Similar to list, but will return a list of all combinations
     for tied tags instead of one comma separated string"""
     if key[:1] == "~" and "~" in key[1:]:
         vals = \
             filter(None,
             map(lambda x: isinstance(x, basestring) and x or str(x),
             map(lambda x: (isinstance(x, float) and "%.2f" % x) or x,
             (self(tag) for tag in util.tagsplit(key)))))
         vals = (val.split("\n") for val in vals)
         r = [[]]
         for x in vals:
             r = [i + [y] for y in x for i in r]
         return map(connector.join, r)
     else:
         return self.list(key)

 def get(self, key, default=u"", connector=u" - "):
     if not self.songs:
         return default
     if key[:1] == "~" and "~" in key[1:]:
         if not isinstance(default, basestring): return default
         keys = util.tagsplit(key)
         v = map(self.__get_cached_value, keys)
         def default_funct(x):
             if x is None: return default
             return x
         v = map(default_funct , v)
         v = map(lambda x: (isinstance(x, float) and "%.2f" % x) or x, v)
         v = map(lambda x: isinstance(x, basestring) and x or str(x), v)
         return  connector.join(filter(None, v)) or default
     else:
         value = self.__get_cached_value(key)
         if value is None:
             return default
         return value

    def list_separate(self, key, connector=" - "):
        """Similar to list, but will return a list of all combinations
        for tied tags instead of one comma separated string.

        In case of tied tags the result will be unicode, otherwise
        it returns the same as list()
        """

        if key[:1] == "~" and "~" in key[1:]:
            vals = []
            for v in map(self.__call__, util.tagsplit(key)):
                v = decode_value(key, v)
                if v:
                    vals.append(v.split("\n"))
            r = [[]]
            for x in vals:
                r = [i + [y] for y in x for i in r]
            return map(connector.join, r)
        else:
            return self.list(key)

    def set_all_column_headers(cls, headers):
        config.set("settings", "headers", " ".join(headers))
        try: headers.remove("~current")
        except ValueError: pass
        cls.headers = headers
        for listview in cls.instances():
            listview.set_column_headers(headers)

        star = list(Query.STAR)
        for header in headers:
            if "<" in header:
                try:
                    tags = Pattern(header).tags
                except ValueError:
                    continue
            else:
                tags = util.tagsplit(header)
            for tag in tags:
                if not tag.startswith("~#") and tag not in star:
                    star.append(tag)
        SongList.star = star

 def __tag(self, node, scope, tags):
     text = []
     if isinstance(node, TextNode):
         text.append('a("%s")' % self.__escape(node.text))
     elif isinstance(node, ConditionNode):
         tag = self.__put_tag(text, scope, node.tag)
         ic = self.__pattern(node.ifcase, dict(scope), tags)
         ec = self.__pattern(node.elsecase, dict(scope), tags)
         if not ic and not ec:
             text.pop(-1)
         elif ic:
             text.append('if %s:' % scope[tag])
             text.extend(ic)
             if ec:
                 text.append('else:')
                 text.extend(ec)
         else:
             text.append('if not %s:' % scope[tag])
             text.extend(ec)
     elif isinstance(node, TagNode):
         tags.update(util.tagsplit(node.tag))
         tag = self.__put_tag(text, scope, node.tag)
         text.append('a(%s)' % scope[tag])
     return text