Python config.set函数代码示例

 def test_get_columns_migrated(self):
     self.failIf(config.get("settings", "headers", None))
     columns = "~album,~#replaygain_track_gain,foobar"
     config.set("settings", "columns", columns)
     self.failUnlessEqual(get_columns(),
                          ["~album", "~#replaygain_track_gain", "foobar"])
     self.failIf(config.get("settings", "headers", None))

def finish_first_session(app_name):
    """Call on shutdown so that is_first_session() works"""

    from quodlibet import config
    from quodlibet import const

    config.set("memory", "%s_last_active_version" % app_name, const.VERSION)

    def test_moveart_multi_source(self):
        self.reset_environment()
        config.set("rename", "move_art", True)
        config.set("albumart", "search_filenames", "*.jpg")

        source, target = \
            self.source_target(self.root_path, 'artist', 'album')
        source2, target2 = \
            self.source_target(self.root_path, 'artist', 'album2')

        self.filenames = ['art.jpg']
        self.art_set(source)
        self.filenames = ['art2.jpg']
        self.art_set(source2)

        song_files, songs = self.song_set(source)
        song_files2, songs2 = self.song_set(source2)

        self.renamer.add_songs(songs + songs2)

        # avoid audio file clashes
        pattern = os.path.join(target, '[<album>] artist - <title>')
        self.renamer.rename(pattern, songs + songs2)

        # album art sets merged
        count_expected = 2
        self.moveart_set()
        target_files = glob.glob(os.path.join(target, '*.jpg'))
        count_target = len(target_files)
        self.failUnlessEqual(count_target, count_expected)

    def test_get_cover_many_prefer_embedded(self):
        # embed one cover, move one to the other dir
        MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1))
        os.unlink(self.cover1)
        self.external_cover = os.path.join(self.dir2, "cover.png")
        shutil.move(self.cover2, self.external_cover)

        # move one audio file in each dir
        shutil.move(self.file1, self.dir1)
        self.file1 = os.path.join(self.dir1, os.path.basename(self.file1))
        shutil.move(self.file2, self.dir2)
        self.file2 = os.path.join(self.dir2, os.path.basename(self.file2))

        song1 = MP3File(self.file1)
        song2 = MP3File(self.file2)

        # each should find a cover
        self.failUnless(self.is_embedded(self.manager.get_cover(song1)))
        self.failIf(self.is_embedded(self.manager.get_cover(song2)))

        cover_for = self.manager.get_cover_many
        # both settings should search both songs before giving up
        config.set("albumart", "prefer_embedded", True)
        self.failUnless(self.is_embedded(cover_for([song1, song2])))
        self.failUnless(self.is_embedded(cover_for([song2, song1])))

        config.set("albumart", "prefer_embedded", False)
        self.failIf(self.is_embedded(cover_for([song1, song2])))
        self.failIf(self.is_embedded(cover_for([song2, song1])))

    def __changed_entry(self, entry, cbs, label):
        text = entry.get_text()
        if text[0:1] == "<" and text[-1:] == ">":
            parts = text[1:-1].split("~")
            for cb in cbs:
                if parts and parts[0] == cb.tag:
                    parts.pop(0)
            if parts:
                for cb in cbs:
                    cb.set_inconsistent(True)
            else:
                parts = text[1:-1].split("~")
                for cb in cbs:
                    cb.set_inconsistent(False)
                    cb.set_active(cb.tag in parts)
        else:
            for cb in cbs:
                cb.set_inconsistent(True)

        if app.player.info is None:
            text = _("Not playing")
        else:
            text = Pattern(entry.get_text()) % app.player.info
        label.set_text(text)
        label.get_parent().set_tooltip_text(text)
        config.set("plugins", "icon_tooltip", entry.get_text())

 def set_band(adj, idx):
     rounded = int(adj.get_value() * 2) / 2.0
     adj.set_value(rounded)
     levels[idx] = rounded
     config.set('plugins', 'equalizer_levels',
                ','.join(str(lv) for lv in levels))
     self.apply()

 def setUp(self):
     self.mod = self.modules[DownloadCoverArt.PLUGIN_ID]
     self.songs = [A_SONG]
     config.add_section(PluginManager.CONFIG_SECTION)
     config.set(PluginManager.CONFIG_SECTION,
                '%s_preview_size' % DownloadCoverArt.PLUGIN_ID,
                200)

 def test_default_email_rating(self):
     self.song["~#rating"] = 0.2
     self.song.write()
     song = type(self.song)(self.filename)
     config.set("editing", "save_email", "[email protected]")
     config.set("editing", "save_email", const.EMAIL)
     self.failUnlessEqual(song["~#rating"], 0.2)

 def __changed_and_signal_library(self, entry, section, name):
     config.set(section, name, str(entry.get_value()))
     print_d("Signalling \"changed\" to entire library. Hold tight...")
     # Cache over clicks
     self._songs = self._songs or app.library.values()
     copool.add(emit_signal, self._songs, funcid="library changed",
                name=_("Updating for new ratings"))

 def __visible(self, cb, prop, menu, clear):
     value = self.get_property('visible')
     config.set("memory", "queue", str(value))
     menu.set_active(value)
     self.set_expanded(not self.model.is_empty())
     cb.set_property('visible', self.get_expanded())
     clear.set_property('visible', self.get_expanded())

 def test_glob(self):
     config.set("albumart", "force_filename", str(True))
     config.set("albumart", "filename", "foo.*")
     for fn in ["foo.jpg", "foo.png"]:
         f = self.add_file(fn)
         assert path_equal(
             os.path.abspath(self._find_cover(self.song).name), f)

 def test_dont_save(self):
     config.set("editing", "save_to_songs", "false")
     self.song["~#rating"] = 1.0
     self.song.write()
     song = type(self.song)(self.filename)
     config.set("editing", "save_to_songs", "true")
     self.failUnlessEqual(song("~#rating"), const.DEFAULT_RATING)

 def bool_changed(widget):
     """Boolean setting changed."""
     if widget.get_active():
         setattr(self.configuration, widget.get_name(), True)
     else:
         setattr(self.configuration, widget.get_name(), False)
     config.set("plugins", "autoqueue_%s" % widget.get_name(), widget.get_active() and "true" or "false")

    def setUp(self):
        config.init()
        config.set("player", "gst_pipeline", "fakesink")
        config.set("settings", "xine_driver", "none")
        module = player.init_backend(self.NAME)
        lib = library.init()
        self.player = module.init(lib.librarian)
        source = PlaylistModel()
        source.set(FILES)

        self.events = []

        def start_end_handler(player, song, *args):
            self.events.append((args[-1], song))

        self.player.connect("song-started", start_end_handler, "started")
        self.player.connect("song-ended", start_end_handler, "ended")

        self.player.setup(source, None, 0)

        self.signals = []

        def handler(type_, *args):
            self.signals.append(type_)
        connect_obj(self.player, "unpaused", handler, "unpaused")
        connect_obj(self.player, "paused", handler, "paused")

 def test_restore(self):
     config.set("browsers", "query_text", "foo")
     self.bar.restore()
     self.failUnlessEqual(self.bar._get_text(), "foo")
     self.bar.finalize(True)
     self._wait()
     self.failUnlessEqual(self.emit_count, 0)