Python util.format_rating函数代码示例

 def test_blank_lengths(self):
     """Check that there are no unsuspected edge-cases
     for various rating precisions"""
     for self.r.number in [1, 5, 4, 3, 2]:
         steps = self.r.number
         self.failUnlessEqual(len(util.format_rating(1)), steps)
         self.failUnlessEqual(len(util.format_rating(0)), steps)
         self.failUnlessEqual(len(util.format_rating(0.5)), steps)
         self.failUnlessEqual(len(util.format_rating(1 / 3.0)), steps)

 def __init__(self, *args, **kwargs):
     super(RatingColumn, self).__init__("~rating", *args, **kwargs)
     self.set_expand(False)
     self.set_resizable(False)
     width = self._cell_width(util.format_rating(1.0))
     self.set_fixed_width(width)
     self.set_min_width(width)

    def __init__(self, songs, library, label=_("_Rating")):
        super(RatingsMenuItem, self).__init__(label=label, use_underline=True)
        self._songs = songs
        image = Gtk.Image.new_from_icon_name(Icons.FAVORITE, Gtk.IconSize.MENU)
        image.show()
        self.set_image(image)

        submenu = Gtk.Menu()
        self.set_submenu(submenu)
        self._rating_menu_items = []
        for i in RATINGS.all:
            text = "%0.2f\t%s" % (i, util.format_rating(i))
            itm = Gtk.CheckMenuItem(label=text)
            itm.rating = i
            submenu.append(itm)
            handler = itm.connect(
                'toggled', self._on_rating_change, i, library)
            self._rating_menu_items.append((itm, handler))
        reset = Gtk.MenuItem(label=_("_Remove Rating"), use_underline=True)
        reset.connect('activate', self._on_rating_remove, library)
        self._select_ratings()

        submenu.append(SeparatorMenuItem())
        submenu.append(reset)
        submenu.show_all()

 def __init__(self, songs, library, label=_("_Rating")):
     super(RatingsMenuItem, self).__init__(label)
     submenu = gtk.Menu()
     self.set_submenu(submenu)
     for i in range(0, int(1.0 / util.RATING_PRECISION) + 1):
         i *= util.RATING_PRECISION
         itm = gtk.MenuItem("%0.2f\t%s" % (i, util.format_rating(i)))
         submenu.append(itm)
         itm.connect_object('activate', self.set_rating, i, songs, library)
     submenu.show_all()

    def _cdf(self, column, cell, model, iter_, user_data):
        song = model.get_value(iter_)
        rating = song.get("~#rating")
        default = config.RATINGS.default

        if not self._needs_update((rating, default)):
            return

        cell.set_sensitive(rating is not None)
        value = rating if rating is not None else default
        cell.set_property('text', util.format_rating(value))

    def test_numeric_funcs_text(self):
        songs = NUMERIC_SONGS
        album = Album(songs[0])
        album.songs = set(songs)

        self.assertEqual(album("~length:sum"), "0:12")
        self.assertEqual(album("~length:min"), "0:01")
        self.assertEqual(album("~long-length:min"), "1 second")
        self.assertEqual(album("~tracks:min"), "6 tracks")
        self.assertEqual(album("~discs:min"), "2 discs")
        self.assertEqual(album("~rating:min"), format_rating(0.1))
        self.assertEqual(album("~filesize:min"), "0 B")

 def test_blank_values(self):
     self.r.number = 5
     self.r.blank_symbol = "0"
     self.r.full_symbol = "1"
     # Easy ones first
     self.failUnlessEqual(util.format_rating(0.0), "00000")
     self.failUnlessEqual(util.format_rating(0.2), "10000")
     self.failUnlessEqual(util.format_rating(0.8), "11110")
     self.failUnlessEqual(util.format_rating(1.0), "11111")
     # A bit arbitrary, but standard behaviour
     self.failUnlessEqual(util.format_rating(0.5), "11100")
     # Test rounding down...
     self.failUnlessEqual(util.format_rating(0.6), "11100")
     # Test rounding up...
     self.failUnlessEqual(util.format_rating(0.9), "11111")
     # You never know...
     self.failUnlessEqual(util.format_rating(3.0), "11111")
     self.failUnlessEqual(util.format_rating(-0.5), "00000")

 def __init__(self, songs, library, label=_("_Rating")):
     super(RatingsMenuItem, self).__init__(label=label, use_underline=True)
     submenu = Gtk.Menu()
     self.set_submenu(submenu)
     for i in RATINGS.all:
         itm = Gtk.MenuItem(label="%0.2f\t%s" % (i, util.format_rating(i)))
         submenu.append(itm)
         connect_obj(itm, 'activate', self.set_rating, i, songs, library)
     reset = Gtk.MenuItem(label=_("_Remove rating"), use_underline=True)
     connect_obj(reset, 'activate', self.remove_rating, songs, library)
     submenu.append(SeparatorMenuItem())
     submenu.append(reset)
     submenu.show_all()

    def __init__(self, parent, action_title, count, value):
        assert count > 1

        title = (_("Are you sure you want to change the "
                   "rating of all %d songs?") % count)
        desc = (_("The saved ratings will be removed") if value is None
                else _("The rating of all selected songs will be changed to "
                       "'%s'") % util.format_rating(value))

        super(ConfirmRateMultipleDialog, self).__init__(
            Gtk.MessageType.WARNING, parent, title, desc, Gtk.ButtonsType.NONE)

        self.add_button(_("_Cancel"), Gtk.ResponseType.CANCEL)
        self.add_button(action_title, Gtk.ResponseType.YES)

    def __init__(self, songs, library, label=_("_Rating")):
        super(RatingsMenuItem, self).__init__(label=label, use_underline=True)
        self.set_songs(songs)

        submenu = Gtk.Menu()
        self.set_submenu(submenu)
        for i in RATINGS.all:
            itm = Gtk.MenuItem(label="%0.2f\t%s" % (i, util.format_rating(i)))
            submenu.append(itm)
            itm.connect('activate', self._on_rating_change, i, library)
        reset = Gtk.MenuItem(label=_("_Remove Rating"), use_underline=True)
        reset.connect('activate', self._on_rating_remove, library)

        submenu.append(SeparatorMenuItem())
        submenu.append(reset)
        submenu.show_all()

    def __init__(self, browser):
        if self.is_not_unique():
            return
        super(Preferences, self).__init__()
        self.set_border_width(12)
        self.set_title(_("Album List Preferences"))
        self.set_default_size(420, 380)
        self.set_transient_for(qltk.get_top_parent(browser))
        # Do this config-driven setup at instance-time
        self._PREVIEW_ITEM["~rating"] = format_rating(0.75)

        box = Gtk.VBox(spacing=6)
        vbox = Gtk.VBox(spacing=6)
        cb = ConfigCheckButton(
            _("Show album _covers"), "browsers", "album_covers")
        cb.set_active(config.getboolean("browsers", "album_covers"))
        cb.connect('toggled', lambda s: browser.toggle_covers())
        vbox.pack_start(cb, False, True, 0)

        cb = ConfigCheckButton(
            _("Inline _search includes people"),
            "browsers", "album_substrings")
        cb.set_active(config.getboolean("browsers", "album_substrings"))
        vbox.pack_start(cb, False, True, 0)
        f = qltk.Frame(_("Options"), child=vbox)
        box.pack_start(f, False, True, 12)

        display_frame = self.edit_display_pane(browser, _("Album Display"))
        box.pack_start(display_frame, True, True, 0)

        main_box = Gtk.VBox(spacing=12)
        close = Button(_("_Close"), Icons.WINDOW_CLOSE)
        close.connect('clicked', lambda *x: self.destroy())
        b = Gtk.HButtonBox()
        b.set_layout(Gtk.ButtonBoxStyle.END)
        b.pack_start(close, True, True, 0)

        main_box.pack_start(box, True, True, 0)
        self.use_header_bar()

        if not self.has_close_button():
            main_box.pack_start(b, False, True, 0)
        self.add(main_box)

        close.grab_focus()
        self.show_all()

    def __button_press(self, view, event, librarian):
        if event.button != 1: return
        x, y = map(int, [event.x, event.y])
        try: path, col, cellx, celly = view.get_path_at_pos(x, y)
        except TypeError: return True
        if event.window != self.get_bin_window(): return False
        if col.header_name == "~#rating":
            if not config.getboolean("browsers", "rating_click"): return

            song = view.get_model()[path][0]
            l = gtk.Label()
            l.set_text(util.format_rating(util.RATING_PRECISION))
            width = l.size_request()[0]
            l.destroy()
            count = int(float(cellx - 5) / width) + 1
            rating = max(0.0, min(1.0, count * util.RATING_PRECISION))
            if (rating <= util.RATING_PRECISION and
                song("~#rating") == util.RATING_PRECISION): rating = 0
            self.__set_rating(rating, [song], librarian)

    def __call__(self, key, default=u"", connector=" - ", joiner=', '):
        """Return the value(s) for a key, synthesizing if necessary.
        Multiple values for a key are delimited by newlines.

        A default value may be given (like `dict.get`);
        the default default is an empty unicode string
        (even if the tag is numeric).

        If a tied tag ('a~b') is requested, the `connector` keyword
        argument may be used to specify what it is tied with.
        In case the tied tag contains numeric and file path tags, the result
        will still be a unicode string.
        The `joiner` keyword specifies how multiple *values* will be joined
        within that tied tag output, e.g.
            ~people~title = "Kanye West, Jay Z - New Day"

        For details on tied tags, see the documentation for `util.tagsplit`.
        """

        if key[:1] == "~":
            key = key[1:]
            if "~" in key:
                real_key = "~" + key
                values = []
                sub_tags = util.tagsplit(real_key)
                # If it's genuinely a tied tag (not ~~people etc), we want
                # to delimit the multi-values separately from the tying
                j = joiner if len(sub_tags) > 1 else "\n"
                for t in sub_tags:
                    vs = [decode_value(real_key, v) for v in (self.list(t))]
                    v = j.join(vs)
                    if v:
                        values.append(v)
                return connector.join(values) or default
            elif key == "#track":
                try:
                    return int(self["tracknumber"].split("/")[0])
                except (ValueError, TypeError, KeyError):
                    return default
            elif key == "#disc":
                try:
                    return int(self["discnumber"].split("/")[0])
                except (ValueError, TypeError, KeyError):
                    return default
            elif key == "length":
                length = self.get("~#length")
                if length is None:
                    return default
                else:
                    return util.format_time_display(length)
            elif key == "#rating":
                return dict.get(self, "~" + key, config.RATINGS.default)
            elif key == "rating":
                return util.format_rating(self("~#rating"))
            elif key == "people":
                return "\n".join(self.list_unique(PEOPLE)) or default
            elif key == "people:real":
                # Issue 1034: Allow removal of V.A. if others exist.
                unique = self.list_unique(PEOPLE)
                # Order is important, for (unlikely case): multiple removals
                for val in VARIOUS_ARTISTS_VALUES:
                    if len(unique) > 1 and val in unique:
                        unique.remove(val)
                return "\n".join(unique) or default
            elif key == "people:roles":
                return (self._role_call("performer", PEOPLE)
                        or default)
            elif key == "peoplesort":
                return ("\n".join(self.list_unique(PEOPLE_SORT)) or
                        self("~people", default, connector))
            elif key == "peoplesort:roles":
                # Ignores non-sort tags if there are any sort tags (e.g. just
                # returns "B" for {artist=A, performersort=B}).
                # TODO: figure out the "correct" behavior for mixed sort tags
                return (self._role_call("performersort", PEOPLE_SORT)
                        or self("~peoplesort", default, connector))
            elif key in ("performers", "performer"):
                return self._prefixvalue("performer") or default
            elif key in ("performerssort", "performersort"):
                return (self._prefixvalue("performersort") or
                        self("~" + key[-4:], default, connector))
            elif key in ("performers:roles", "performer:roles"):
                return (self._role_call("performer") or default)
            elif key in ("performerssort:roles", "performersort:roles"):
                return (self._role_call("performersort")
                        or self("~" + key.replace("sort", ""), default,
                                connector))
            elif key == "basename":
                return os.path.basename(self["~filename"]) or self["~filename"]
            elif key == "dirname":
                return os.path.dirname(self["~filename"]) or self["~filename"]
            elif key == "uri":
                try:
                    return self["~uri"]
                except KeyError:
                    return fsn2uri(self["~filename"])
            elif key == "format":
                return self.get("~format", text_type(self.format))
            elif key == "codec":
                codec = self.get("~codec")
#.........这里部分代码省略.........

 def test_rating_length(self):
     config.RATINGS.number = 4
     for i in range(0, int(1 / self.r.precision + 1)):
         self.failUnlessEqual(
             i, len(util.format_rating(i * self.r.precision, blank=False)))

 def test_full(self):
     self.failUnlessEqual(
         len(util.format_rating(1, blank=False)),
         int(1 / self.r.precision))