def delete_frames(deletes, filenames):

    try:
        deletes = frame_from_fsnative(deletes)
    except ValueError as err:
        print_(text_type(err), file=sys.stderr)

    frames = deletes.split(",")

    for filename in filenames:
        with _sig.block():
            if verbose:
                print_(u"deleting %s from" % deletes, filename,
                       file=sys.stderr)
            try:
                id3 = mutagen.id3.ID3(filename)
            except mutagen.id3.ID3NoHeaderError:
                if verbose:
                    print_(u"No ID3 header found; skipping.", file=sys.stderr)
            except Exception as err:
                print_(text_type(err), file=sys.stderr)
                raise SystemExit(1)
            else:
                for frame in frames:
                    id3.delall(frame)
                id3.save()

 def call2(self, *args):
     for arg in args:
         self.assertTrue(isinstance(arg, fsnative))
     old_stdout = sys.stdout
     old_stderr = sys.stderr
     try:
         out = StringIO()
         err = StringIO()
         sys.stdout = out
         sys.stderr = err
         try:
             ret = self._main([fsnative(self.TOOL_NAME)] + list(args))
         except SystemExit as e:
             ret = e.code
         ret = ret or 0
         out_val = out.getvalue()
         err_val = err.getvalue()
         if os.name == "nt" and PY2:
             encoding = getattr(sys.stdout, "encoding", None) or "mbcs"
             out_val = text_type(out_val, encoding)
             err_val = text_type(err_val, encoding)
         return (ret, out_val, err_val)
     finally:
         sys.stdout = old_stdout
         sys.stderr = old_stderr

    def update_to_v24(self):
        """Convert older tags into an ID3v2.4 tag.

        This updates old ID3v2 frames to ID3v2.4 ones (e.g. TYER to
        TDRC). If you intend to save tags, you must call this function
        at some point; it is called by default when loading the tag.
        """

        self.__update_common()

        # TDAT, TYER, and TIME have been turned into TDRC.
        try:
            date = text_type(self.get("TYER", ""))
            if date.strip(u"\x00"):
                self.pop("TYER")
                dat = text_type(self.get("TDAT", ""))
                if dat.strip("\x00"):
                    self.pop("TDAT")
                    date = "%s-%s-%s" % (date, dat[2:], dat[:2])
                    time = text_type(self.get("TIME", ""))
                    if time.strip("\x00"):
                        self.pop("TIME")
                        date += "T%s:%s:00" % (time[:2], time[2:])
                if "TDRC" not in self:
                    self.add(TDRC(encoding=0, text=date))
        except UnicodeDecodeError:
            # Old ID3 tags have *lots* of Unicode problems, so if TYER
            # is bad, just chuck the frames.
            pass

        # TORY can be the first part of a TDOR.
        if "TORY" in self:
            f = self.pop("TORY")
            if "TDOR" not in self:
                try:
                    self.add(TDOR(encoding=0, text=str(f)))
                except UnicodeDecodeError:
                    pass

        # IPLS is now TIPL.
        if "IPLS" in self:
            f = self.pop("IPLS")
            if "TIPL" not in self:
                self.add(TIPL(encoding=f.encoding, people=f.people))

        # These can't be trivially translated to any ID3v2.4 tags, or
        # should have been removed already.
        for key in ["RVAD", "EQUA", "TRDA", "TSIZ", "TDAT", "TIME"]:
            if key in self:
                del(self[key])

        # Recurse into chapters
        for f in self.getall("CHAP"):
            f.sub_frames.update_to_v24()
        for f in self.getall("CTOC"):
            f.sub_frames.update_to_v24()

 def test_ASFGUIDAttribute_dunder(self):
     attr = ASFGUIDAttribute(data=b"\xff")
     self.assertEqual(bytes(attr), b"\xff")
     if PY3:
         self.assertEqual(text_type(attr), u"b'\\xff'")
         self.assertEqual(repr(attr), "ASFGUIDAttribute(b'\\xff')")
     else:
         self.assertEqual(text_type(attr), u"'\\xff'")
         self.assertEqual(repr(attr), "ASFGUIDAttribute('\\xff')")
     self.assertRaises(TypeError, int, attr)

def list_tags_raw(filenames):
    for filename in filenames:
        print_("Raw IDv2 tag info for", filename)
        try:
            id3 = mutagen.id3.ID3(filename, translate=False)
        except mutagen.id3.ID3NoHeaderError:
            print_(u"No ID3 header found; skipping.")
        except Exception as err:
            print_(text_type(err), file=sys.stderr)
            raise SystemExit(1)
        else:
            for frame in id3.values():
                print_(text_type(repr(frame)))

 def test_types(self):
     if PY3:
         self.assertRaises(TypeError, ID3TimeStamp, b"blah")
     self.assertEquals(
         text_type(ID3TimeStamp(u"2000-01-01")), u"2000-01-01")
     self.assertEquals(
         bytes(ID3TimeStamp(u"2000-01-01")), b"2000-01-01")

    def __setitem__(self, key, values):
        """Set a key's value or values.

        Setting a value overwrites all old ones. The value may be a
        list of Unicode or UTF-8 strings, or a single Unicode or UTF-8
        string.

        """
        if not isinstance(values, list):
            values = [values]
        try:
            del(self[key])
        except KeyError:
            pass
        for value in values:
            if key in _standard_attribute_names:
                value = text_type(value)
            elif not isinstance(value, ASFBaseAttribute):
                if isinstance(value, string_types):
                    value = ASFUnicodeAttribute(value)
                elif isinstance(value, bool):
                    value = ASFBoolAttribute(value)
                elif isinstance(value, int):
                    value = ASFDWordAttribute(value)
                elif isinstance(value, long):
                    value = ASFQWordAttribute(value)
            self.append((key, value))

 def test_ASFByteArrayAttribute_dunder(self):
     attr = ASFByteArrayAttribute(data=b"\xff")
     self.assertEqual(bytes(attr), b"\xff")
     self.assertEqual(text_type(attr), u"[binary data (1 bytes)]")
     if PY3:
         self.assertEqual(repr(attr), r"ASFByteArrayAttribute(b'\xff')")
     else:
         self.assertEqual(repr(attr), r"ASFByteArrayAttribute('\xff')")
     self.assertRaises(TypeError, int, attr)

def update(options, filenames):
    encoding = options.encoding or getpreferredencoding()
    verbose = options.verbose
    noupdate = options.noupdate
    force_v1 = options.force_v1
    remove_v1 = options.remove_v1

    def conv(uni):
        return uni.encode('iso-8859-1').decode(encoding)

    for filename in filenames:
        with _sig.block():
            if verbose != "quiet":
                print_(u"Updating", filename)

            if has_id3v1(filename) and not noupdate and force_v1:
                mutagen.id3.delete(filename, False, True)

            try:
                id3 = mutagen.id3.ID3(filename)
            except mutagen.id3.ID3NoHeaderError:
                if verbose != "quiet":
                    print_(u"No ID3 header found; skipping...")
                continue
            except Exception as err:
                print_(text_type(err), file=sys.stderr)
                continue

            for tag in filter(lambda t: t.startswith(("T", "COMM")), id3):
                frame = id3[tag]
                if isinstance(frame, mutagen.id3.TimeStampTextFrame):
                    # non-unicode fields
                    continue
                try:
                    text = frame.text
                except AttributeError:
                    continue
                try:
                    text = [conv(x) for x in frame.text]
                except (UnicodeError, LookupError):
                    continue
                else:
                    frame.text = text
                    if not text or min(map(isascii, text)):
                        frame.encoding = 3
                    else:
                        frame.encoding = 1

            if verbose == "debug":
                print_(id3.pprint())

            if not noupdate:
                if remove_v1:
                    id3.save(filename, v1=False)
                else:
                    id3.save(filename)

    def test_ASFUnicodeAttribute_dunder(self):
        attr = ASFUnicodeAttribute(u"foo")

        self.assertEqual(bytes(attr), b"f\x00o\x00o\x00")
        self.assertEqual(text_type(attr), u"foo")
        if PY3:
            self.assertEqual(repr(attr), "ASFUnicodeAttribute('foo')")
        else:
            self.assertEqual(repr(attr), "ASFUnicodeAttribute(u'foo')")
        self.assertRaises(TypeError, int, attr)

    def test_basic(self):
        d = os.path.dirname(self.filename)
        p = os.path.join(d, fsn(u"%(stream)d.%(ext)s"))
        res, out = self.call(fsn(u"--pattern"), p, self.filename)
        self.failIf(res)
        self.failIf(out)

        for stream in [1002429366, 1806412655]:
            stream_path = os.path.join(
                d, fsn(text_type(stream)) + fsn(u".ogg"))
            self.failUnless(os.path.exists(stream_path))
            os.unlink(stream_path)

    def test_conv_basic(self):
        from mutagen.id3 import TALB

        for codec in CODECS:
            f = ID3(self.filename)
            f.add(TALB(text=[AMBIGUOUS.decode("latin-1")], encoding=0))
            f.save()
            res, out = self.call(
                fsn(u"-d"), fsn(u"-e"), fsn(text_type(codec)), self.filename)
            f = ID3(self.filename)
            self.failUnlessEqual(f["TALB"].encoding, 1)
            self.failUnlessEqual(f["TALB"].text[0], AMBIGUOUS.decode(codec))

 def test_timestampspec(self):
     from mutagen.id3 import TimeStampSpec, Frame, ID3TimeStamp
     s = TimeStampSpec('name')
     f = Frame(); f.encoding = 0
     self.assertEquals((ID3TimeStamp('ab'), b'fg'), s.read(f, b'ab\x00fg'))
     self.assertEquals((ID3TimeStamp('1234'), b''), s.read(f, b'1234\x00'))
     self.assertEquals(b'1234\x00', s.write(f, ID3TimeStamp('1234')))
     self.assertRaises(AttributeError, s.write, f, None)
     if PY3:
         self.assertRaises(TypeError, ID3TimeStamp, b"blah")
     self.assertEquals(
         text_type(ID3TimeStamp(u"2000-01-01")),  u"2000-01-01")
     self.assertEquals(
         bytes(ID3TimeStamp(u"2000-01-01")), b"2000-01-01")

    def test_ASFUnicodeAttribute(self):
        if PY3:
            self.assertRaises(TypeError, ASFUnicodeAttribute, b"\xff")
        else:
            self.assertRaises(ValueError, ASFUnicodeAttribute, b"\xff")
            val = u'\xf6\xe4\xfc'
            self.assertEqual(ASFUnicodeAttribute(val.encode("utf-8")), val)

        self.assertRaises(ASFError, ASFUnicodeAttribute, data=b"\x00")
        self.assertEqual(ASFUnicodeAttribute(u"foo").value, u"foo")
        self.assertEqual(
            bytes(ASFUnicodeAttribute(u"foo")), b"f\x00o\x00o\x00")
        self.assertEqual(
            text_type(ASFUnicodeAttribute(u"foo")), u"foo")

    def description(self):
        """string or None if unknown"""

        name = None
        try:
            name = self._TYPE_NAMES[self.audioObjectType]
        except IndexError:
            pass
        if name is None:
            return
        if self.sbrPresentFlag == 1:
            name += "+SBR"
        if self.psPresentFlag == 1:
            name += "+PS"
        return text_type(name)

    def test_comm(self):
        from mutagen.id3 import COMM

        for codec in CODECS:
            f = ID3(self.filename)
            frame = COMM(desc="", lang="eng", encoding=0,
                         text=[AMBIGUOUS.decode("latin-1")])
            f.add(frame)
            f.save()
            res, out = self.call(
                fsn(u"-d"), fsn(u"-e"), fsn(text_type(codec)), self.filename)
            f = ID3(self.filename)
            new_frame = f[frame.HashKey]
            self.failUnlessEqual(new_frame.encoding, 1)
            self.failUnlessEqual(new_frame.text[0], AMBIGUOUS.decode(codec))

def main(argv):
    from mutagen import File

    parser = OptionParser()
    parser.add_option("--no-flac", help="Compatibility; does nothing.")
    parser.add_option("--no-mp3", help="Compatibility; does nothing.")
    parser.add_option("--no-apev2", help="Compatibility; does nothing.")

    (options, args) = parser.parse_args(argv[1:])
    if not args:
        raise SystemExit(parser.print_help() or 1)

    for filename in args:
        print_(u"--", filename)
        try:
            print_(u"-", File(filename).pprint())
        except AttributeError:
            print_(u"- Unknown file type")
        except Exception as err:
            print_(text_type(err))
        print_(u"")

 def test_fileobj_name(self):
     with tempfile.TemporaryFile(mode="rb") as h:
         self.assertEqual(fileobj_name(h), text_type(h.name))

 def test_compare_to_unicode(self):
     frame = self.Frame(encoding=0, text=[u'1987', u'1988'])
     self.failUnlessEqual(frame, text_type(frame))

 def __str__(self):
     return text_type(self.value)