def __remove(self, iters, smodel):
        def song_at(itr):
            return smodel[smodel.get_path(itr)][0]

        def remove_from_model(iters, smodel):
            for it in iters:
                smodel.remove(it)

        model, iter = self.__selected_playlists()
        if iter:
            playlist = model[iter][0]
            # A {iter: song} dict, exhausting `iters` once.
            removals = {iter_remove: song_at(iter_remove)
                        for iter_remove in iters}
            if not removals:
                print_w("No songs selected to remove")
                return
            if self._query is None or not self.get_filter_text():
                # Calling playlist.remove_songs(songs) won't remove the
                # right ones if there are duplicates
                remove_from_model(removals.keys(), smodel)
                self.__rebuild_playlist_from_songs_model(playlist, smodel)
                # Emit manually
                self.library.emit('changed', removals.values())
            else:
                playlist.remove_songs(removals.values(), True)
                remove_from_model(iters, smodel)
            print_d("Removed %d song(s) from %s" % (len(removals), playlist))
            self.changed(playlist)
            self.activate()

 def _set_status(self, text):
     print_d("Setting status to \"%s\"..." % text)
     result, mid = self.client.publish(self.topic, text)
     if result != mqtt.MQTT_ERR_SUCCESS:
         print_w("Couldn't publish to %s at %s:%d (%s)"
                 % (self.topic, self.host, self.port, result))
     self.status = text

def init():
    global device_manager
    if not dbus: return
    device_manager = None

    print_d(_("Initializing device backend."))
    try_text = _("Trying '%s'")

    #DKD maintainers will change the naming of dbus, app stuff
    #in january 2010 or so (already changed in trunk), so try both
    if device_manager is None:
        print_d(try_text % "DeviceKit Disks")
        try: device_manager = DKD(("DeviceKit", "Disks"))
        except (LookupError, dbus.DBusException): pass

    if device_manager is None:
        print_d(try_text % "UDisks")
        try: device_manager = DKD(("UDisks",))
        except (LookupError, dbus.DBusException): pass

    if device_manager is None:
        print_d(try_text % "HAL")
        try: device_manager = HAL()
        except (LookupError, dbus.DBusException): pass

    if device_manager is None:
        print_w(_("Couldn't connect to a device backend."))
    else:
        print_d(_("Device backend initialized."))

    return device_manager

 def run(self, songs):
     """
     Runs this command on `songs`,
     splitting into multiple calls if necessary
     """
     args = []
     if self.parameter:
         value = GetStringDialog(None, _("Input value"),
                                 _("Value for %s?") % self.parameter).run()
         self.command = self.command.format(**{self.parameter: value})
         print_d("Actual command=%s" % self.command)
     for song in songs:
         arg = str(self.__pat.format(song))
         if not arg:
             print_w("Couldn't build shell command using \"%s\"."
                     "Check your pattern?" % self.pattern)
             break
         if not self.unique:
             args.append(arg)
         elif arg not in args:
             args.append(arg)
     max = int((self.max_args or 10000))
     com_words = self.command.split(" ")
     while args:
         print_d("Running %s with %d substituted arg(s) (of %d%s total)..."
                 % (self.command, min(max, len(args)), len(args),
                    " unique" if self.unique else ""))
         util.spawn(com_words + args[:max])
         args = args[max:]

    def __request(self, line, raw=False, want_reply=True):
        """
        Send a request to the server, if connected, and return its response
        """
        line = line.strip()

        if not (self.is_connected or line.split()[0] == 'login'):
            print_d("Can't do '%s' - not connected" % line.split()[0], self)
            return None

        if self._debug:
            print_(">>>> \"%s\"" % line)
        try:
            self.telnet.write(line + "\n")
            if not want_reply:
                return None
            raw_response = self.telnet.read_until("\n").strip()
        except socket.error as e:
            print_w("Couldn't communicate with squeezebox (%s)" % e)
            self.failures += 1
            if self.failures >= self._MAX_FAILURES:
                print_w("Too many Squeezebox failures. Disconnecting")
                self.is_connected = False
            return None
        response = raw_response if raw else urllib.unquote(raw_response)
        if self._debug:
            print_("<<<< \"%s\"" % (response,))
        return response[len(line) - 1:] if line.endswith("?")\
            else response[len(line) + 1:]

def _load_items(filename):
    """Load items from disk.

    In case of an error returns default or an empty list.
    """

    try:
        with open(filename, "rb") as fp:
            data = fp.read()
    except EnvironmentError:
        print_w("Couldn't load library file from: %r" % filename)
        return []

    try:
        items = load_audio_files(data)
    except SerializationError:
        # there are too many ways this could fail
        util.print_exc()

        # move the broken file out of the way
        try:
            shutil.copy(filename, filename + ".not-valid")
        except EnvironmentError:
            util.print_exc()

        return []

    return items

    def __init__(self, dkd_name):
        self.__bus = ".".join(dkd_name)
        self.__path = "/".join(dkd_name)
        super(DKD, self).__init__("org.freedesktop.%s" % self.__bus)

        error = False

        try:
            udev.init()
        except OSError:
            print_w(_("%s: Could not find %s.") % (self.__bus, libudev))
            error = True
        else:
            self.__udev = udev.Udev.new()

        if self.__get_mpi_dir() is None:
            print_w(_("%s: Could not find %s.")
                    % (self.__bus, "media-player-info"))
            error = True

        if error:
            raise LookupError

        interface = "org.freedesktop.%s" % self.__bus
        path = "/org/freedesktop/%s" % self.__path
        obj = self._system_bus.get_object(interface, path)
        self.__interface = dbus.Interface(obj, interface)

        self.__interface.connect_to_signal('DeviceAdded', self.__device_added)
        self.__interface.connect_to_signal('DeviceRemoved',
            self.__device_removed)

def init():
    global device_manager
    if not dbus:
        return
    device_manager = None

    print_d(_("Initializing device backend."))
    try_text = _("Trying '%s'")

    if device_manager is None:
        print_d(try_text % "UDisks2")
        try:
            device_manager = UDisks2Manager()
        except (LookupError, dbus.DBusException):
            pass

    if device_manager is None:
        print_d(try_text % "UDisks1")
        try:
            device_manager = UDisks1Manager()
        except (LookupError, dbus.DBusException):
            pass

    if device_manager is None:
        print_w(_("Couldn't connect to a device backend."))
    else:
        print_d(_("Device backend initialized."))

    return device_manager

    def __init__(self):
        bus_name = "org.freedesktop.UDisks"
        interface = "org.freedesktop.UDisks"
        path = "/org/freedesktop/UDisks"

        super(UDisks1Manager, self).__init__(bus_name)

        error = False

        try:
            udev.init()
        except OSError:
            print_w("UDisks: " + _("Could not find '%s'.") % "libudev")
            error = True
        else:
            self.__udev = udev.Udev.new()

        if get_mpi_dir() is None:
            print_w("UDisks: " + _("Could not find '%s'.")
                    % "media-player-info")
            error = True

        if error:
            raise LookupError

        obj = self._system_bus.get_object(bus_name, path)
        self.__interface = dbus.Interface(obj, interface)

        self.__devices = {}
        self.__interface.connect_to_signal('DeviceAdded', self.__device_added)
        self.__interface.connect_to_signal('DeviceRemoved',
            self.__device_removed)

 def __init__(self, orders, base_cls):
     assert issubclass(base_cls, Order)
     super(PluggableOrders, self).__init__(orders)
     self.base_cls = base_cls
     if PluginManager.instance:
         PluginManager.instance.register_handler(self)
     else:
         print_w("No plugin manager found")

 def process_IN_CREATE(self, event):
     if not event.dir:
         self._log(event)
         # Just remember that they've been created, will process later
         path = os.path.join(event.path, event.name)
         if os.path.exists(path):
             self._being_created.add(path)
         else:
             print_w("Couldn't find %s" % path)

 def query_with_refresh(self, text, sort=None, star=STAR):
     """Queries Soundcloud for some (more) relevant results, then filters"""
     current = self._contents.values()
     try:
         query = SoundcloudQuery(text, star=star)
         self.client.get_tracks(query.terms)
     except SoundcloudQuery.error as e:
         print_w("Couldn't filter for query '%s' (%s)" % (text, e))
         return current
     filtered = query.filter(current)
     print_d("Filtered %d results to %d" % (len(current), len(filtered)))
     return filtered

 def try_connecting(self):
     try:
         self.enabled()
         msg = (_("Connected to broker at %(host)s:%(port)d")
                % {'host': self.host, 'port': self.port})
         Message(Gtk.MessageType.INFO, app.window, "Success", msg).run()
     except IOError as e:
         template = _("Couldn't connect to %(host)s:%(port)d (%(msg)s)")
         msg = template % {'host': self.host, 'port': self.port, 'msg': e}
         print_w(msg)
         ErrorMessage(app.window, _("Connection error"), msg).run()
     yield

    def __get_media_player_id(self, devpath):
        """DKD is for high-level device stuff. The info if the device is
        a media player and what protocol/formats it supports can only
        be retrieved through libudev"""
        try:
            dev = get_device_from_path(self.__udev, devpath)
        except Exception:
            print_w("Failed to retrieve udev properties for %r" % devpath)
            util.print_exc()
            return

        try: return dev["ID_MEDIA_PLAYER"]
        except KeyError: return None

def init_devices():
    global devices

    load_pyc = os.name == 'nt'
    modules = load_dir_modules(dirname(__file__),
                               package=__package__,
                               load_compiled=load_pyc)

    for mod in modules:
        try: devices.extend(mod.devices)
        except AttributeError:
            print_w("%r doesn't contain any devices." % mod.__name__)

    devices.sort()

    def save(self, filename=None):
        """Save the library to the given filename, or the default if `None`"""

        if filename is None:
            filename = self.filename

        print_d("Saving contents to %r." % filename, self)

        try:
            dump_items(filename, self.get_content())
        except EnvironmentError:
            print_w("Couldn't save library to path: %r" % filename)
        else:
            self.dirty = False

def init_devices():
    global devices

    load_pyc = util.is_windows() or util.is_osx()
    modules = load_dir_modules(dirname(__file__),
                               package=__package__,
                               load_compiled=load_pyc)

    for mod in modules:
        try:
            devices.extend(mod.devices)
        except AttributeError:
            print_w("%r doesn't contain any devices." % mod.__name__)

    devices.sort(key=lambda d: repr(d))

    def __search_thread(self, engine, query, replace):
        """Creates searching threads which call the callback function after
        they are finished"""

        clean_query = self.__cleanup_query(query, replace)
        result = []
        try:
            result = engine().start(clean_query, self.overall_limit)
        except Exception:
            print_w("[AlbumArt] %s: %r" % (engine.__name__, query))
            print_exc()

        self.finished += 1
        #progress is between 0..1
        progress = float(self.finished) / len(self.engine_list)
        GLib.idle_add(self.callback, result, progress)

    def _get_saved_commands(cls):
        filename = cls.COMS_FILE
        print_d("Loading saved commands from '%s'..." % filename)
        coms = None
        try:
            with open(filename, "r", encoding="utf-8") as f:
                coms = JSONObjectDict.from_json(Command, f.read())
        except (IOError, ValueError) as e:
            print_w("Couldn't parse saved commands (%s)" % e)

        # Failing all else...
        if not coms:
            print_d("No commands found in %s. Using defaults." % filename)
            coms = {c.name: c for c in cls.DEFAULT_COMS}
        print_d("Loaded commands: %s" % coms.keys())
        return coms

def MusicFile(filename):
    """Returns a AudioFile instance or None"""

    lower = filename.lower()
    for ext in _extensions:
        if lower.endswith(ext):
            try:
                return _infos[ext](filename)
            except:
                print_w("Error loading %r" % filename)
                if const.DEBUG:
                    util.print_exc()
                return
    else:
        print_w("Unknown file extension %r" % filename)
        return