Exemple #1
0
 def write(self):
     fn = self.filename
     with open(fn, "wb") as f:
         for song in self._list:
             if isinstance(song, string_types):
                 f.write(fsn2bytes(song, "utf-8") + b"\n")
             else:
                 f.write(fsn2bytes(song("~filename"), "utf-8") + b"\n")
     if self._last_fn != fn:
         self.__delete_file(self._last_fn)
         self._last_fn = fn
Exemple #2
0
    def send_message(cls, message):
        assert isinstance(message, fsnative)

        try:
            return fifo.write_fifo(cls._PATH, fsn2bytes(message, None))
        except EnvironmentError as e:
            raise RemoteError(e)
Exemple #3
0
def test_bytes2fsn():
    assert bytes2fsn(b"foo", "utf-8") == fsnative(u"foo")
    assert (bytes2fsn(fsn2bytes(fsnative(u"\u1234"), "utf-8"),
                      "utf-8") == fsnative(u"\u1234"))

    with pytest.raises(ValueError):
        bytes2fsn(b"\x00", "utf-8")

    with pytest.raises(ValueError):
        bytes2fsn(b"\x00\x00", "utf-16-le")

    with pytest.raises(TypeError):
        bytes2fsn(object(), "utf-8")

    with pytest.raises(TypeError):
        bytes2fsn(u"data", "utf-8")

    if os.name == "nt":
        with pytest.raises(ValueError):
            bytes2fsn(b"data", "notanencoding")
        with pytest.raises(ValueError):
            bytes2fsn(b"data", None)
        with pytest.raises(TypeError):
            bytes2fsn(b"data", object())

    assert bytes2fsn(b"foo", "utf-8") == bytes2fsn(b"foo")
Exemple #4
0
def fsn2glib(path):
    """Takes a fsnative path and returns a glib filename"""

    if PY2:
        return fsn2bytes(path, "utf-8")
    else:
        return path
Exemple #5
0
 def test_response(self):
     with temp_filename() as fn:
         mock = Mock(resp=bytes2fsn(b"resp", None))
         remote = QuodLibetUnixRemote(None, mock)
         remote._callback(b"\x00foo\x00" + fsn2bytes(fn, None) + b"\x00")
         self.assertEqual(mock.lines, [bytes2fsn(b"foo", None)])
         with open(fn, "rb") as h:
             self.assertEqual(h.read(), b"resp")
Exemple #6
0
def selection_set_songs(selection_data, songs):
    """Stores filenames of the passed songs in a Gtk.SelectionData"""

    filenames = []
    for filename in (song["~filename"] for song in songs):
        filenames.append(fsn2bytes(filename, "utf-8"))
    type_ = Gdk.atom_intern("text/x-quodlibet-songs", True)
    selection_data.set(type_, 8, b"\x00".join(filenames))
    def test_selection_set_songs(self):
        song = AudioFile()
        song["~filename"] = fsnative(u"foo")
        sel = MockSelData()
        qltk.selection_set_songs(sel, [song])
        assert sel.data == fsn2bytes(fsnative(u"foo"), "utf-8")

        assert qltk.selection_get_filenames(sel) == [fsnative(u"foo")]
Exemple #8
0
def get_devices_from_path(udev_ctx, path):
    """A list of device attribute dicts for the given device path and all its
    parents.

    Either returns a non empty list or raises EnvironmentError.
    """

    path = fsn2bytes(path2fsn(path), None)
    enum = udev.UdevEnumerate.new(udev_ctx)

    if not enum:
        raise EnvironmentError

    # only match the device we want
    if enum.add_match_property(b"DEVNAME", path) != 0:
        enum.unref()
        raise EnvironmentError

    # search for it
    if enum.scan_devices() != 0:
        enum.unref()
        raise EnvironmentError

    # take the first entry
    entry = enum.get_list_entry()
    if not entry:
        enum.unref()
        raise EnvironmentError
    sys_path = entry.get_name()
    enum.unref()

    device = udev.UdevDevice.new_from_syspath(udev_ctx, sys_path)
    if not device:
        raise EnvironmentError

    devices = []
    while device:
        devices.append(device)
        device = device.get_parent()

    device_attrs = []
    for device in devices:
        entry = device.get_properties_list_entry()
        if not entry:
            continue

        attrs = {}
        for e in entry:
            name = e.get_name()
            value = e.get_value()
            attrs[name] = escape_decode(value)
        device_attrs.append(attrs)

    # the first device owns its parents
    devices[0].unref()

    return device_attrs
Exemple #9
0
def set_current_dir(path):
    """Set the current chooser directory.

    Args:
        path (fsnative)
    """

    assert isinstance(path, fsnative)
    data = fsn2bytes(path, "utf-8")
    config.setbytes("memory", "chooser_dir", data)
Exemple #10
0
    def _on_selection_changed(self, tree_selection):
        model, rows = tree_selection.get_selected_rows()
        selected_paths = [model[row][0] for row in rows]

        if selected_paths:
            data = fsn2bytes("\n".join(selected_paths), "utf-8")
        else:
            data = b""

        config.setbytes("browsers", "filesystem", data)
Exemple #11
0
    def test_main(self):
        v = fsnative(u"foo")
        self.assertTrue(isinstance(v, fsnative))

        v2 = glib2fsn(fsn2glib(v))
        self.assertTrue(isinstance(v2, fsnative))
        self.assertEqual(v, v2)

        v3 = bytes2fsn(fsn2bytes(v, "utf-8"), "utf-8")
        self.assertTrue(isinstance(v3, fsnative))
        self.assertEqual(v, v3)
 def test_parse_onesong(self):
     with temp_filename() as name:
         with open(name, "wb") as af:
             target = self.prefix
             target += fsn2bytes(get_data_path("silence-44-s.ogg"), "utf-8")
             af.write(target)
         with open(name, "rb") as f:
             pl = self.Parse(f, name)
     self.failUnlessEqual(len(pl), 1)
     self.failUnlessEqual(pl[0]("title"), "Silence")
     pl.delete()
 def test_parse_onesong(self):
     h, name = mkstemp()
     os.close(h)
     with open(name, "wb") as f:
         target = self.prefix
         target += fsn2bytes(get_data_path("silence-44-s.ogg"), "utf-8")
         f.write(target)
     list = self.Parse(name)
     os.unlink(name)
     self.failUnlessEqual(len(list), 1)
     self.failUnlessEqual(list[0]("title"), "Silence")
     list.delete()
Exemple #14
0
 def __write(self, widget, model):
     filenames = [row[0]["~filename"] for row in model]
     try:
         with open(QUEUE, "wb") as f:
             for filename in filenames:
                 try:
                     line = fsn2bytes(filename, "utf-8")
                 except ValueError:
                     print_exc()
                     continue
                 f.write(line + b"\n")
     except EnvironmentError:
         print_exc()
Exemple #15
0
def set_scan_dirs(dirs):
    """Saves a list of fs paths which should be scanned

    Args:
        list
    """

    assert all(isinstance(d, fsnative) for d in dirs)

    if is_windows():
        joined = fsnative(u":").join(dirs)
    else:
        joined = join_escape(dirs, fsnative(u":"))
    config.setbytes("settings", "scan", fsn2bytes(joined, "utf-8"))
Exemple #16
0
def _py3_to_py2(items):
    is_win = is_windows()

    new_list = []
    for i in items:
        inst = dict.__new__(i.__class__)
        for key, value in i.items():
            if key in ("~filename", "~mountpoint") and not is_win:
                value = fsn2bytes(value, None)
            try:
                key = key.encode("ascii")
            except UnicodeEncodeError:
                pass
            dict.__setitem__(inst, key, value)
        new_list.append(inst)
    return new_list
Exemple #17
0
def _normalize_darwin_path(filename, canonicalise=False):

    filename = path2fsn(filename)

    if canonicalise:
        filename = os.path.realpath(filename)
    filename = os.path.normpath(filename)

    data = fsn2bytes(filename, "utf-8")
    decoded = data.decode("utf-8", "quodlibet-osx-path-decode")

    try:
        return bytes2fsn(
            NSString.fileSystemRepresentation(decoded), "utf-8")
    except ValueError:
        return filename
Exemple #18
0
    def _callback(self, data):
        try:
            messages = list(fifo.split_message(data))
        except ValueError:
            print_w("invalid message: %r" % data)
            return

        for command, path in messages:
            command = bytes2fsn(command, None)
            response = self._cmd_registry.handle_line(self._app, command)
            if path is not None:
                path = bytes2fsn(path, None)
                with open(path, "wb") as h:
                    if response is not None:
                        assert isinstance(response, fsnative)
                        h.write(fsn2bytes(response, None))
Exemple #19
0
def export_metadata(songs, target_path):
    """Raises OSError/IOError"""

    with open(target_path, 'wb') as out:
        for song in songs:
            out.write(fsn2bytes(song('~basename'), "utf-8"))
            out.write(os.linesep.encode("utf-8"))

            for key in sorted(song.keys()):
                if key.startswith('~'):
                    continue
                for val in song.list(key):
                    line = '%s=%s' % (key, val)
                    out.write(line.encode("utf-8"))
                    out.write(os.linesep.encode("utf-8"))
            out.write(os.linesep.encode("utf-8"))
Exemple #20
0
def write_fifo(fifo_path, data):
    """Writes the data to the FIFO and returns a response.

    Args:
        fifo_path (pathlike)
        data (bytes)
    Returns:
        bytes
    Raises:
        EnvironmentError: In case of timeout and other errors
    """

    assert isinstance(data, bytes)

    fd, filename = mkstemp()
    try:
        os.close(fd)
        os.unlink(filename)
        # mkfifo fails if the file exists, so this is safe.
        os.mkfifo(filename, 0o600)

        _write_fifo(
            fifo_path,
            b"\x00" + data + b"\x00" + fsn2bytes(filename, None) + b"\x00")

        try:
            signal.signal(signal.SIGALRM, lambda: "" + 2)
            signal.alarm(FIFO_TIMEOUT)
            with open(filename, "rb") as h:
                signal.signal(signal.SIGALRM, signal.SIG_IGN)
                return h.read()
        except TypeError:
            # In case the main instance deadlocks we can write to it, but
            # reading will time out. Assume it is broken and delete the
            # fifo.
            try:
                os.unlink(fifo_path)
            except OSError:
                pass
            raise EnvironmentError("timeout")
    finally:
        try:
            os.unlink(filename)
        except EnvironmentError:
            pass
Exemple #21
0
def parse_command(line):
    """Parses a MPD command (without trailing newline)

    Returns (command, [arguments]) or raises ParseError in case of an error.
    """

    assert isinstance(line, bytes)

    parts = re.split(b"[ \\t]+", line, maxsplit=1)
    if not parts:
        raise ParseError("empty command")
    command = parts[0]

    if len(parts) > 1:
        lex = shlex.shlex(bytes2fsn(parts[1], "utf-8"), posix=True)
        lex.whitespace_split = True
        lex.commenters = ""
        lex.quotes = "\""
        lex.whitespace = " \t"
        args = [fsn2bytes(a, "utf-8") for a in lex]
    else:
        args = []

    try:
        command = command.decode("utf-8")
    except ValueError as e:
        raise ParseError(e)

    dec_args = []
    for arg in args:
        try:
            arg = arg.decode("utf-8")
        except ValueError as e:
            raise ParseError(e)
        dec_args.append(arg)

    return command, dec_args
Exemple #22
0
def fsnative2glib(path):
    if PY2:
        return fsn2bytes(path, "utf-8")
    else:
        return path
Exemple #23
0
 def send_message(cls, message):
     data = fsn2bytes(path2fsn(message), "utf-8")
     try:
         winpipe.write_pipe(cls._NAME, data)
     except EnvironmentError as e:
         raise RemoteError(e)
Exemple #24
0
def fsnative2bytes(path):
    return fsn2bytes(path, "utf-8")