Python compat.itervalues函数代码示例

 def masked(self, item):
     """Return true if the item is in the library but masked."""
     try:
         point = item.mountpoint
     except AttributeError:
         # Checking a key.
         for point in itervalues(self._masked):
             if item in point:
                 return True
     else:
         # Checking a full item.
         return item in itervalues(self._masked.get(point, {}))

    def __invoke(self, librarian, event, *args):
        args = list(args)
        if args and args[0]:
            if isinstance(args[0], dict):
                args[0] = SongWrapper(args[0])
            elif isinstance(args[0], (set, list)):
                args[0] = ListWrapper(args[0])
        for plugin in itervalues(self.__plugins):
            method_name = 'plugin_on_' + event.replace('-', '_')
            handler = getattr(plugin, method_name, None)

            def overridden(obj, name):
                return name in type(obj).__dict__

            if overridden(plugin, method_name):
                try:
                    handler(*args)
                except Exception:
                    print_e("Error during %s on %s" %
                            (method_name, type(plugin)))
                    util.print_exc()

        if event not in ["removed", "changed"] and args:
            from quodlibet import app
            songs = args[0]
            if not isinstance(songs, (set, list)):
                songs = [songs]
            songs = filter(None, songs)
            check_wrapper_changed(librarian, app.window, songs)

 def __contains__(self, item):
     """Check if a key or item is in the library."""
     for library in itervalues(self.libraries):
         if item in library:
             return True
     else:
         return False

    def __init__(self, library, users):
        DBusIntrospectable.__init__(self)
        DBusProperty.__init__(self)
        MediaObject.__init__(self, None)
        MediaItem.__init__(self, optional=SUPPORTED_SONG_PROPERTIES)

        bus = dbus.SessionBus()
        self.ref = dbus.service.BusName(BUS_NAME, bus)
        dbus.service.FallbackObject.__init__(self, bus, self.PATH)

        self.__library = library
        self.__map = dict((id(v), v) for v in itervalues(self.__library))
        self.__reverse = dict((v, k) for k, v in iteritems(self.__map))

        self.__song = DummySongObject(self)

        self.__users = users

        signals = [
            ("changed", self.__songs_changed),
            ("removed", self.__songs_removed),
            ("added", self.__songs_added),
        ]
        self.__sigs = map(
            lambda x: self.__library.connect(x[0], x[1]), signals)

    def __update(self, songs, total, model, save, revert):
        if songs is None:
            songs = [e.song for e in itervalues(model)]
        else:
            songs = list(songs)

        def sort_key(song):
            return song("~#track", 0), song("~basename"), song
        songs.sort(key=sort_key)

        model.clear()
        total.set_value(len(songs))

        for song in songs:
            if not song.can_change("tracknumber"):
                self.set_sensitive(False)
                break
        else:
            self.set_sensitive(True)

        for song in songs:
            model.append([Entry(song)])

        save.set_sensitive(False)
        revert.set_sensitive(False)

 def Query(self, text):
     if text is not None:
         query = Query(text, star=SongList.star)
         if query.is_parsable:
             return [self.__dict(s) for s in itervalues(self.library)
                     if query.search(s)]
     return None

    def __save_files(self, parent, model, library):
        win = WritingWindow(parent, len(model))
        was_changed = set()
        all_done = False
        for entry in itervalues(model):
            song, track = entry.song, entry.tracknumber
            if song.get("tracknumber") == track:
                win.step()
                continue
            if not song.valid():
                win.hide()
                dialog = OverwriteWarning(self, song)
                resp = dialog.run()
                win.show()
                if resp != OverwriteWarning.RESPONSE_SAVE:
                    break
            song["tracknumber"] = track
            try:
                song.write()
            except AudioFileError:
                util.print_exc()
                WriteFailedError(self, song).run()
                library.reload(song, changed=was_changed)
                break
            was_changed.add(song)
            if win.step():
                break
        else:
            all_done = True

        library.changed(was_changed)
        win.destroy()
        self.save.set_sensitive(not all_done)
        self.revert.set_sensitive(not all_done)

    def changed(self, items):
        """Triage the items and inform their real libraries."""

        for library in itervalues(self.libraries):
            in_library = set(item for item in items if item in library)
            if in_library:
                library._changed(in_library)

    def changed(self, items):
        """Alert other users that these items have changed.

        This causes a 'changed' signal. If a librarian is available
        this function will call its changed method instead, and all
        libraries that librarian manages may fire a 'changed' signal.

        The item list may be filtered to those items actually in the
        library. If a librarian is available, it will handle the
        filtering instead. That means if this method is delegated to
        the librarian, this library's changed signal may not fire, but
        another's might.
        """

        if not items:
            return
        if self.librarian and self in itervalues(self.librarian.libraries):
            print_d("Changing %d items via librarian." % len(items), self)
            self.librarian.changed(items)
        else:
            items = {item for item in items if item in self}
            if not items:
                return
            print_d("Changing %d items directly." % len(items), self)
            self._changed(items)

    def rename(self, song, newname, changed=None):
        """Rename the song in all libraries it belongs to.

        The 'changed' signal will fire for any library the song is in
        except if a set() is passed as changed.
        """
        # This needs to poke around inside the library directly.  If
        # it uses add/remove to handle the songs it fires incorrect
        # signals. If it uses the library's rename method, it breaks
        # the call for future libraries because the item's key has
        # changed. So, it needs to reimplement the method.
        re_add = []
        print_d("Renaming %r to %r" % (song.key, newname), self)
        for library in itervalues(self.libraries):
            try:
                del library._contents[song.key]
            except KeyError:
                pass
            else:
                re_add.append(library)
        song.rename(newname)
        for library in re_add:
            library._contents[song.key] = song
            if changed is None:
                library._changed({song})
            else:
                print_d("Delaying changed signal for %r." % library, self)
                changed.add(song)

    def _plugins(self):
        """All registered plugins"""

        plugins = []
        for module in itervalues(self.__modules):
            for plugin in module.plugins:
                plugins.append(plugin)
        return plugins

 def test_values(self):
     items = []
     for i in range(20):
         items.append(self.Fake(i))
         items[-1].key = i + 100
     self.library.add(items)
     self.failUnlessEqual(sorted(self.library.values()), list(range(20)))
     self.failUnlessEqual(
         sorted(itervalues(self.library)), list(range(20)))

 def mask(self, point):
     print_d("Masking %r." % point, self)
     removed = {}
     for item in itervalues(self):
         if item.mountpoint == point:
             removed[item.key] = item
     if removed:
         self.remove(removed.values())
         self._masked.setdefault(point, {}).update(removed)

 def __getitem__(self, key):
     """Find a item given its key."""
     for library in itervalues(self.libraries):
         try:
             return library[key]
         except KeyError:
             pass
     else:
         raise KeyError(key)

 def _get_all(sub, found=None):
     if found is None:
         found = set()
     if isinstance(sub, list):
         found.update(sub)
         return found
     for v in itervalues(sub):
         _get_all(v, found)
     return found