id
int64 0
843k
| repository_name
stringlengths 7
55
| file_path
stringlengths 9
332
| class_name
stringlengths 3
290
| human_written_code
stringlengths 12
4.36M
| class_skeleton
stringlengths 19
2.2M
| total_program_units
int64 1
9.57k
| total_doc_str
int64 0
4.2k
| AvgCountLine
float64 0
7.89k
| AvgCountLineBlank
float64 0
300
| AvgCountLineCode
float64 0
7.89k
| AvgCountLineComment
float64 0
7.89k
| AvgCyclomatic
float64 0
130
| CommentToCodeRatio
float64 0
176
| CountClassBase
float64 0
48
| CountClassCoupled
float64 0
589
| CountClassCoupledModified
float64 0
581
| CountClassDerived
float64 0
5.37k
| CountDeclInstanceMethod
float64 0
4.2k
| CountDeclInstanceVariable
float64 0
299
| CountDeclMethod
float64 0
4.2k
| CountDeclMethodAll
float64 0
4.2k
| CountLine
float64 1
115k
| CountLineBlank
float64 0
9.01k
| CountLineCode
float64 0
94.4k
| CountLineCodeDecl
float64 0
46.1k
| CountLineCodeExe
float64 0
91.3k
| CountLineComment
float64 0
27k
| CountStmt
float64 1
93.2k
| CountStmtDecl
float64 0
46.1k
| CountStmtExe
float64 0
90.2k
| MaxCyclomatic
float64 0
759
| MaxInheritanceTree
float64 0
16
| MaxNesting
float64 0
34
| SumCyclomatic
float64 0
6k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
146,948 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.error
|
class error(IOError):
pass
|
class error(IOError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 3 | 0 | 0 | 0 | 0 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 1 | 0 | 0 |
146,949 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.MP4Tags
|
class MP4Tags(DictProxy, Metadata):
r"""Dictionary containing Apple iTunes metadata list key/values.
Keys are four byte identifiers, except for freeform ('----')
keys. Values are usually unicode strings, but some atoms have a
special structure:
Text values (multiple values per key are supported):
* '\\xa9nam' -- track title
* '\\xa9alb' -- album
* '\\xa9ART' -- artist
* 'aART' -- album artist
* '\\xa9wrt' -- composer
* '\\xa9day' -- year
* '\\xa9cmt' -- comment
* 'desc' -- description (usually used in podcasts)
* 'purd' -- purchase date
* '\\xa9grp' -- grouping
* '\\xa9gen' -- genre
* '\\xa9lyr' -- lyrics
* 'purl' -- podcast URL
* 'egid' -- podcast episode GUID
* 'catg' -- podcast category
* 'keyw' -- podcast keywords
* '\\xa9too' -- encoded by
* 'cprt' -- copyright
* 'soal' -- album sort order
* 'soaa' -- album artist sort order
* 'soar' -- artist sort order
* 'sonm' -- title sort order
* 'soco' -- composer sort order
* 'sosn' -- show sort order
* 'tvsh' -- show name
Boolean values:
* 'cpil' -- part of a compilation
* 'pgap' -- part of a gapless album
* 'pcst' -- podcast (iTunes reads this only on import)
Tuples of ints (multiple values per key are supported):
* 'trkn' -- track number, total tracks
* 'disk' -- disc number, total discs
Others:
* 'tmpo' -- tempo/BPM, 16 bit int
* 'covr' -- cover artwork, list of MP4Cover objects (which are
tagged strs)
* 'gnre' -- ID3v1 genre. Not supported, use '\\xa9gen' instead.
The freeform '----' frames use a key in the format '----:mean:name'
where 'mean' is usually 'com.apple.iTunes' and 'name' is a unique
identifier for this frame. The value is a str, but is probably
text that can be decoded as UTF-8. Multiple values per key are
supported.
MP4 tag data cannot exist outside of the structure of an MP4 file,
so this class should not be manually instantiated.
Unknown non-text tags are removed.
"""
def load(self, atoms, fileobj):
try:
ilst = atoms[b"moov.udta.meta.ilst"]
except KeyError as key:
raise MP4MetadataError(key)
for atom in ilst.children:
fileobj.seek(atom.offset + 8)
data = fileobj.read(atom.length - 8)
if len(data) != (atom.length - 8):
raise MP4MetadataError("Not enough data")
if atom.name in self.__atoms:
info = self.__atoms[atom.name]
info[0](self, atom, data, *info[2:])
else:
# unknown atom, try as text and skip if it fails
# FIXME: keep them somehow
try:
self.__parse_text(atom, data)
except MP4MetadataError:
continue
@classmethod
def _can_load(cls, atoms):
return b"moov.udta.meta.ilst" in atoms
@staticmethod
def __get_sort_stats(item):
(key, v) = item
# iTunes always writes the tags in order of "relevance", try
# to copy it as closely as possible.
order = [b"\xa9nam", b"\xa9ART", b"\xa9wrt", b"\xa9alb",
b"\xa9gen", b"gnre", b"trkn", b"disk",
b"\xa9day", b"cpil", b"pgap", b"pcst", b"tmpo",
b"\xa9too", b"----", b"covr", b"\xa9lyr"]
order = dict(zip(order, range(len(order))))
last = len(order)
# If there's no key-based way to distinguish, order by length.
# If there's still no way, go by string comparison on the
# values, so we at least have something determinstic.
try:
length = len(v)
except TypeError:
length = 0
return (order.get(key[:4], last), length, v)
def save(self, filename):
"""Save the metadata to the given filename."""
values = []
items = sorted(self.items(), key=MP4Tags.__get_sort_stats )
for key, value in items:
info = self.__atoms.get(key[:4], (None, type(self).__render_text))
try:
values.append(info[1](self, key, value, *info[2:]))
except (TypeError, ValueError) as s:
reraise(MP4MetadataValueError, s, sys.exc_info()[2])
data = Atom.render(b"ilst", b"".join(values))
# Find the old atoms.
fileobj = open(filename, "rb+")
try:
atoms = Atoms(fileobj)
try:
path = atoms.path(b"moov", b"udta", b"meta", b"ilst")
except KeyError:
self.__save_new(fileobj, atoms, data)
else:
self.__save_existing(fileobj, atoms, path, data)
finally:
fileobj.close()
def __pad_ilst(self, data, length=None):
if length is None:
length = ((len(data) + 1023) & ~1023) - len(data)
return Atom.render(b"free", b"\x00" * length)
def __save_new(self, fileobj, atoms, ilst):
hdlr = Atom.render(b"hdlr", b"\x00" * 8 + b"mdirappl" + b"\x00" * 9)
meta = Atom.render(
b"meta", b"\x00\x00\x00\x00" + hdlr + ilst + self.__pad_ilst(ilst))
try:
path = atoms.path(b"moov", b"udta")
except KeyError:
# moov.udta not found -- create one
path = atoms.path(b"moov")
meta = Atom.render(b"udta", meta)
offset = path[-1].offset + 8
insert_bytes(fileobj, len(meta), offset)
fileobj.seek(offset)
fileobj.write(meta)
self.__update_parents(fileobj, path, len(meta))
self.__update_offsets(fileobj, atoms, len(meta), offset)
def __save_existing(self, fileobj, atoms, path, data):
# Replace the old ilst atom.
ilst = path.pop()
offset = ilst.offset
length = ilst.length
# Check for padding "free" atoms
meta = path[-1]
index = meta.children.index(ilst)
try:
prev = meta.children[index-1]
if prev.name == b"free":
offset = prev.offset
length += prev.length
except IndexError:
pass
try:
next = meta.children[index+1]
if next.name == b"free":
length += next.length
except IndexError:
pass
delta = len(data) - length
if delta > 0 or (delta < 0 and delta > -8):
data += self.__pad_ilst(data)
delta = len(data) - length
insert_bytes(fileobj, delta, offset)
elif delta < 0:
data += self.__pad_ilst(data, -delta - 8)
delta = 0
fileobj.seek(offset)
fileobj.write(data)
self.__update_parents(fileobj, path, delta)
self.__update_offsets(fileobj, atoms, delta, offset)
def __update_parents(self, fileobj, path, delta):
"""Update all parent atoms with the new size."""
for atom in path:
fileobj.seek(atom.offset)
size = cdata.uint_be(fileobj.read(4))
if size == 1: # 64bit
# skip name (4B) and read size (8B)
size = cdata.ulonglong_be(fileobj.read(12)[4:])
fileobj.seek(atom.offset + 8)
fileobj.write(cdata.to_ulonglong_be(size + delta))
else: # 32bit
fileobj.seek(atom.offset)
fileobj.write(cdata.to_uint_be(size + delta))
def __update_offset_table(self, fileobj, fmt, atom, delta, offset):
"""Update offset table in the specified atom."""
if atom.offset > offset:
atom.offset += delta
fileobj.seek(atom.offset + 12)
data = fileobj.read(atom.length - 12)
fmt = fmt % cdata.uint_be(data[:4])
offsets = struct.unpack(fmt, data[4:])
offsets = [o + (0, delta)[offset < o] for o in offsets]
fileobj.seek(atom.offset + 16)
fileobj.write(struct.pack(fmt, *offsets))
def __update_tfhd(self, fileobj, atom, delta, offset):
if atom.offset > offset:
atom.offset += delta
fileobj.seek(atom.offset + 9)
data = fileobj.read(atom.length - 9)
flags = cdata.uint_be(b"\x00" + data[:3])
if flags & 1:
o = cdata.ulonglong_be(data[7:15])
if o > offset:
o += delta
fileobj.seek(atom.offset + 16)
fileobj.write(cdata.to_ulonglong_be(o))
def __update_offsets(self, fileobj, atoms, delta, offset):
"""Update offset tables in all 'stco' and 'co64' atoms."""
if delta == 0:
return
moov = atoms[b"moov"]
for atom in moov.findall(b'stco', True):
self.__update_offset_table(fileobj, ">%dI", atom, delta, offset)
for atom in moov.findall(b'co64', True):
self.__update_offset_table(fileobj, ">%dQ", atom, delta, offset)
try:
for atom in atoms[b"moof"].findall(b'tfhd', True):
self.__update_tfhd(fileobj, atom, delta, offset)
except KeyError:
pass
def __parse_data(self, atom, data):
pos = 0
while pos < atom.length - 8:
length, name, flags = struct.unpack(">I4sI", data[pos:pos+12])
if name != b"data":
raise MP4MetadataError(
"unexpected atom %r inside %r" % (name, atom.name))
yield flags, data[pos+16:pos+length]
pos += length
def __render_data(self, key, flags, value):
return Atom.render(key, b''.join(
Atom.render(b"data", struct.pack(">2I", flags, 0) + data)
for data in value))
def __parse_freeform(self, atom, data):
length = cdata.uint_be(data[:4])
mean = data[12:length]
pos = length
length = cdata.uint_be(data[pos:pos+4])
name = data[pos+12:pos+length]
pos += length
value = []
while pos < atom.length - 8:
length, atom_name = struct.unpack(">I4s", data[pos:pos+8])
if atom_name != b"data":
raise MP4MetadataError(
"unexpected atom %r inside %r" % (atom_name, atom.name))
version = ord(data[pos+8:pos+8+1])
if version != 0:
raise MP4MetadataError("Unsupported version: %r" % version)
flags = struct.unpack(">I", b"\x00" + data[pos+9:pos+12])[0]
value.append(MP4FreeForm(data[pos+16:pos+length],
dataformat=flags))
pos += length
if value:
self[atom.name + b":" + mean + b":" + name] = value
def __render_freeform(self, key, value):
mean, name = key.split(b":", 2)[1:]
mean = struct.pack(">I4sI", len(mean) + 12, b"mean", 0) + mean
name = struct.pack(">I4sI", len(name) + 12, b"name", 0) + name
if isinstance(value, bytes):
value = [value]
data = b""
for v in value:
flags = MP4FreeForm.FORMAT_TEXT
if isinstance(v, MP4FreeForm):
flags = v.dataformat
data += struct.pack(">I4s2I", len(v) + 16, b"data", flags, 0)
data += v
return Atom.render(b"----", mean + name + data)
def __parse_pair(self, atom, data):
self[atom.name] = [struct.unpack(">2H", d[2:6]) for
flags, d in self.__parse_data(atom, data)]
def __render_pair(self, key, value):
data = []
for (track, total) in value:
if 0 <= track < 1 << 16 and 0 <= total < 1 << 16:
data.append(struct.pack(">4H", 0, track, total, 0))
else:
raise MP4MetadataValueError(
"invalid numeric pair %r" % ((track, total),))
return self.__render_data(key, 0, data)
def __render_pair_no_trailing(self, key, value):
data = []
for (track, total) in value:
if 0 <= track < 1 << 16 and 0 <= total < 1 << 16:
data.append(struct.pack(">3H", 0, track, total))
else:
raise MP4MetadataValueError(
"invalid numeric pair %r" % ((track, total),))
return self.__render_data(key, 0, data)
def __parse_genre(self, atom, data):
# Translate to a freeform genre.
genre = cdata.short_be(data[16:18])
if b"\xa9gen" not in self:
try:
self[b"\xa9gen"] = [GENRES[genre - 1]]
except IndexError:
pass
def __parse_tempo(self, atom, data):
self[atom.name] = [cdata.ushort_be(value[1]) for
value in self.__parse_data(atom, data)]
def __render_tempo(self, key, value):
try:
if not isinstance(value, list):
raise TypeError
if len(value) == 0:
return self.__render_data(key, 0x15, b"")
if min(value) < 0 or max(value) >= 2**16:
raise MP4MetadataValueError(
"invalid 16 bit integers: %r" % value)
except TypeError:
raise MP4MetadataValueError(
"tmpo must be a list of 16 bit integers")
values = [cdata.to_ushort_be(v) for v in value]
return self.__render_data(key, 0x15, values)
def __parse_bool(self, atom, data):
try:
self[atom.name] = bool(ord(data[16:17]))
except TypeError:
self[atom.name] = False
def __render_bool(self, key, value):
return self.__render_data(key, 0x15, [chr_(bool(value))])
def __parse_cover(self, atom, data):
self[atom.name] = []
pos = 0
while pos < atom.length - 8:
length, name, imageformat = struct.unpack(">I4sI",
data[pos:pos+12])
if name != b"data":
if name == b"name":
pos += length
continue
raise MP4MetadataError(
"unexpected atom %r inside 'covr'" % name)
if imageformat not in (MP4Cover.FORMAT_JPEG, MP4Cover.FORMAT_PNG):
imageformat = MP4Cover.FORMAT_JPEG
cover = MP4Cover(data[pos+16:pos+length], imageformat)
self[atom.name].append(cover)
pos += length
def __render_cover(self, key, value):
atom_data = []
for cover in value:
try:
imageformat = cover.imageformat
except AttributeError:
imageformat = MP4Cover.FORMAT_JPEG
atom_data.append(Atom.render(
b"data", struct.pack(">2I", imageformat, 0) + cover))
return Atom.render(key, b"".join(atom_data))
def __parse_text(self, atom, data, expected_flags=1):
value = [text.decode('utf-8', 'replace') for flags, text
in self.__parse_data(atom, data)
if flags == expected_flags]
if value:
self[atom.name] = value
def __render_text(self, key, value, flags=1):
if isinstance(value, (text_type, bytes)):
value = [value]
return self.__render_data(
key, flags, [utf8(v) for v in value])
def delete(self, filename):
"""Remove the metadata from the given filename."""
self.clear()
self.save(filename)
__atoms = {
b"----": (__parse_freeform, __render_freeform),
b"trkn": (__parse_pair, __render_pair),
b"disk": (__parse_pair, __render_pair_no_trailing),
b"gnre": (__parse_genre, None),
b"tmpo": (__parse_tempo, __render_tempo),
b"cpil": (__parse_bool, __render_bool),
b"pgap": (__parse_bool, __render_bool),
b"pcst": (__parse_bool, __render_bool),
b"covr": (__parse_cover, __render_cover),
b"purl": (__parse_text, __render_text, 0),
b"egid": (__parse_text, __render_text, 0),
}
# the text atoms we know about which should make loading fail if parsing
# any of them fails
for name in [b"\xa9nam", b"\xa9alb", b"\xa9ART", b"aART", b"\xa9wrt", b"\xa9day",
b"\xa9cmt", b"desc", b"purd", b"\xa9grp", b"\xa9gen", b"\xa9lyr",
b"catg", b"keyw", b"\xa9too", b"cprt", b"soal", b"soaa", b"soar",
b"sonm", b"soco", b"sosn", b"tvsh"]:
__atoms[name] = (__parse_text, __render_text)
def pprint(self):
values = []
for key, value in iteritems(self):
if key == b"covr":
values.append("%r=%s" % (key, ", ".join(
[("[%d bytes of data]" % len(data)) for data in value])))
elif isinstance(value, list):
values.append("%r=%s" % (key, " / ".join(map(text_type, value))))
else:
values.append("%r=%s" % (key, value))
return "\n".join(values)
|
class MP4Tags(DictProxy, Metadata):
'''Dictionary containing Apple iTunes metadata list key/values.
Keys are four byte identifiers, except for freeform ('----')
keys. Values are usually unicode strings, but some atoms have a
special structure:
Text values (multiple values per key are supported):
* '\\xa9nam' -- track title
* '\\xa9alb' -- album
* '\\xa9ART' -- artist
* 'aART' -- album artist
* '\\xa9wrt' -- composer
* '\\xa9day' -- year
* '\\xa9cmt' -- comment
* 'desc' -- description (usually used in podcasts)
* 'purd' -- purchase date
* '\\xa9grp' -- grouping
* '\\xa9gen' -- genre
* '\\xa9lyr' -- lyrics
* 'purl' -- podcast URL
* 'egid' -- podcast episode GUID
* 'catg' -- podcast category
* 'keyw' -- podcast keywords
* '\\xa9too' -- encoded by
* 'cprt' -- copyright
* 'soal' -- album sort order
* 'soaa' -- album artist sort order
* 'soar' -- artist sort order
* 'sonm' -- title sort order
* 'soco' -- composer sort order
* 'sosn' -- show sort order
* 'tvsh' -- show name
Boolean values:
* 'cpil' -- part of a compilation
* 'pgap' -- part of a gapless album
* 'pcst' -- podcast (iTunes reads this only on import)
Tuples of ints (multiple values per key are supported):
* 'trkn' -- track number, total tracks
* 'disk' -- disc number, total discs
Others:
* 'tmpo' -- tempo/BPM, 16 bit int
* 'covr' -- cover artwork, list of MP4Cover objects (which are
tagged strs)
* 'gnre' -- ID3v1 genre. Not supported, use '\\xa9gen' instead.
The freeform '----' frames use a key in the format '----:mean:name'
where 'mean' is usually 'com.apple.iTunes' and 'name' is a unique
identifier for this frame. The value is a str, but is probably
text that can be decoded as UTF-8. Multiple values per key are
supported.
MP4 tag data cannot exist outside of the structure of an MP4 file,
so this class should not be manually instantiated.
Unknown non-text tags are removed.
'''
def load(self, atoms, fileobj):
pass
@classmethod
def _can_load(cls, atoms):
pass
@staticmethod
def __get_sort_stats(item):
pass
def save(self, filename):
'''Save the metadata to the given filename.'''
pass
def __pad_ilst(self, data, length=None):
pass
def __save_new(self, fileobj, atoms, ilst):
pass
def __save_existing(self, fileobj, atoms, path, data):
pass
def __update_parents(self, fileobj, path, delta):
'''Update all parent atoms with the new size.'''
pass
def __update_offset_table(self, fileobj, fmt, atom, delta, offset):
'''Update offset table in the specified atom.'''
pass
def __update_tfhd(self, fileobj, atom, delta, offset):
pass
def __update_offsets(self, fileobj, atoms, delta, offset):
'''Update offset tables in all 'stco' and 'co64' atoms.'''
pass
def __parse_data(self, atom, data):
pass
def __render_data(self, key, flags, value):
pass
def __parse_freeform(self, atom, data):
pass
def __render_freeform(self, key, value):
pass
def __parse_pair(self, atom, data):
pass
def __render_pair(self, key, value):
pass
def __render_pair_no_trailing(self, key, value):
pass
def __parse_genre(self, atom, data):
pass
def __parse_tempo(self, atom, data):
pass
def __render_tempo(self, key, value):
pass
def __parse_bool(self, atom, data):
pass
def __render_bool(self, key, value):
pass
def __parse_cover(self, atom, data):
pass
def __render_cover(self, key, value):
pass
def __parse_text(self, atom, data, expected_flags=1):
pass
def __render_text(self, key, value, flags=1):
pass
def delete(self, filename):
'''Remove the metadata from the given filename.'''
pass
def pprint(self):
pass
| 32 | 6 | 12 | 0 | 10 | 1 | 3 | 0.23 | 2 | 20 | 7 | 0 | 27 | 0 | 29 | 39 | 453 | 58 | 324 | 102 | 292 | 73 | 277 | 97 | 247 | 7 | 2 | 3 | 88 |
146,950 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.MP4Info
|
class MP4Info(StreamInfo):
"""MPEG-4 stream information.
Attributes:
* bitrate -- bitrate in bits per second, as an int
* length -- file length in seconds, as a float
* channels -- number of audio channels
* sample_rate -- audio sampling rate in Hz
* bits_per_sample -- bits per sample
"""
bitrate = 0
channels = 0
sample_rate = 0
bits_per_sample = 0
def __init__(self, atoms, fileobj):
for trak in list(atoms[b"moov"].findall(b"trak")):
hdlr = trak[b"mdia", b"hdlr"]
fileobj.seek(hdlr.offset)
data = fileobj.read(hdlr.length)
if data[16:20] == b"soun":
break
else:
raise MP4StreamInfoError("track has no audio data")
mdhd = trak[b"mdia", b"mdhd"]
fileobj.seek(mdhd.offset)
data = fileobj.read(mdhd.length)
if ord(data[8:9]) == 0:
offset = 20
fmt = ">2I"
else:
offset = 28
fmt = ">IQ"
end = offset + struct.calcsize(fmt)
unit, length = struct.unpack(fmt, data[offset:end])
self.length = float(length) / unit
try:
atom = trak[b"mdia", b"minf", b"stbl", b"stsd"]
fileobj.seek(atom.offset)
data = fileobj.read(atom.length)
if data[20:24] == b"mp4a":
length = cdata.uint_be(data[16:20])
(self.channels, self.bits_per_sample, _,
self.sample_rate) = struct.unpack(">3HI", data[40:50])
# ES descriptor type
if data[56:60] == b"esds" and ord(data[64:65]) == 0x03:
pos = 65
# skip extended descriptor type tag, length, ES ID
# and stream priority
if data[pos:pos+3] == b"\x80\x80\x80":
pos += 3
pos += 4
# decoder config descriptor type
if ord(data[pos:pos+1]) == 0x04:
pos += 1
# skip extended descriptor type tag, length,
# object type ID, stream type, buffer size
# and maximum bitrate
if data[pos:pos+3] == b"\x80\x80\x80":
pos += 3
pos += 10
# average bitrate
self.bitrate = cdata.uint_be(data[pos:pos+4])
except (ValueError, KeyError):
# stsd atoms are optional
pass
def pprint(self):
return "MPEG-4 audio, %.2f seconds, %d bps" % (
self.length, self.bitrate)
|
class MP4Info(StreamInfo):
'''MPEG-4 stream information.
Attributes:
* bitrate -- bitrate in bits per second, as an int
* length -- file length in seconds, as a float
* channels -- number of audio channels
* sample_rate -- audio sampling rate in Hz
* bits_per_sample -- bits per sample
'''
def __init__(self, atoms, fileobj):
pass
def pprint(self):
pass
| 3 | 1 | 28 | 1 | 23 | 5 | 6 | 0.34 | 1 | 6 | 2 | 0 | 2 | 1 | 2 | 3 | 74 | 7 | 50 | 19 | 47 | 17 | 47 | 19 | 44 | 10 | 2 | 5 | 11 |
146,951 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.MP4FreeForm
|
class MP4FreeForm(bytes):
"""A freeform value.
Attributes:
* dataformat -- format of the data (either FORMAT_TEXT or FORMAT_DATA)
"""
FORMAT_DATA = 0x0
FORMAT_TEXT = 0x1
def __new__(cls, data, *args, **kwargs):
return bytes.__new__(cls, data)
def __init__(self, data, dataformat=FORMAT_TEXT):
self.dataformat = dataformat
|
class MP4FreeForm(bytes):
'''A freeform value.
Attributes:
* dataformat -- format of the data (either FORMAT_TEXT or FORMAT_DATA)
'''
def __new__(cls, data, *args, **kwargs):
pass
def __init__(self, data, dataformat=FORMAT_TEXT):
pass
| 3 | 1 | 2 | 0 | 2 | 0 | 1 | 0.57 | 1 | 0 | 0 | 0 | 2 | 1 | 2 | 59 | 16 | 5 | 7 | 6 | 4 | 4 | 7 | 6 | 4 | 1 | 2 | 0 | 2 |
146,952 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.MP4Cover
|
class MP4Cover(bytes):
"""A cover artwork.
Attributes:
* imageformat -- format of the image (either FORMAT_JPEG or FORMAT_PNG)
"""
FORMAT_JPEG = 0x0D
FORMAT_PNG = 0x0E
def __new__(cls, data, *args, **kwargs):
return bytes.__new__(cls, data)
def __init__(self, data, imageformat=FORMAT_JPEG):
self.imageformat = imageformat
try:
self.format
except AttributeError:
self.format = imageformat
|
class MP4Cover(bytes):
'''A cover artwork.
Attributes:
* imageformat -- format of the image (either FORMAT_JPEG or FORMAT_PNG)
'''
def __new__(cls, data, *args, **kwargs):
pass
def __init__(self, data, imageformat=FORMAT_JPEG):
pass
| 3 | 1 | 4 | 0 | 4 | 0 | 2 | 0.36 | 1 | 1 | 0 | 0 | 2 | 2 | 2 | 59 | 19 | 4 | 11 | 7 | 8 | 4 | 11 | 7 | 8 | 2 | 2 | 1 | 3 |
146,953 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.CRM
|
class CRM(Frame):
"""Encrypted meta frame"""
_framespec = [Latin1TextSpec('owner'), Latin1TextSpec('desc'),
BinaryDataSpec('data')]
def __eq__(self, other):
return self.data == other
__hash__ = Frame.__hash__
|
class CRM(Frame):
'''Encrypted meta frame'''
def __eq__(self, other):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.17 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 14 | 8 | 1 | 6 | 4 | 4 | 1 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
146,954 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.COMR
|
class COMR(FrameOpt):
"""Commercial frame."""
_framespec = [
EncodingSpec('encoding'),
Latin1TextSpec('price'),
StringSpec('valid_until', 8),
Latin1TextSpec('contact'),
ByteSpec('format'),
EncodedTextSpec('seller'),
EncodedTextSpec('desc'),
]
_optionalspec = [
Latin1TextSpec('mime'),
BinaryDataSpec('logo'),
]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self._writeData())
def __eq__(self, other):
return self._writeData() == other._writeData()
__hash__ = FrameOpt.__hash__
|
class COMR(FrameOpt):
'''Commercial frame.'''
@property
def HashKey(self):
pass
def __eq__(self, other):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.05 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 19 | 26 | 5 | 20 | 7 | 16 | 1 | 8 | 6 | 5 | 1 | 3 | 0 | 2 |
146,955 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.COMM
|
class COMM(TextFrame):
"""User comment.
User comment frames have a descrption, like TXXX, and also a three
letter ISO language code in the 'lang' attribute.
"""
_framespec = [
EncodingSpec('encoding'),
StringSpec('lang', 3),
EncodedTextSpec('desc'),
MultiSpec('text', EncodedTextSpec('text'), sep=u'\u0000'),
]
@property
def HashKey(self):
return '%s:%s:%r' % (self.FrameID, self.desc, self.lang)
def _pprint(self):
return "%s=%r=%s" % (self.desc, self.lang, " / ".join(self.text))
|
class COMM(TextFrame):
'''User comment.
User comment frames have a descrption, like TXXX, and also a three
letter ISO language code in the 'lang' attribute.
'''
@property
def HashKey(self):
pass
def _pprint(self):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.33 | 1 | 0 | 0 | 1 | 2 | 0 | 2 | 23 | 20 | 4 | 12 | 5 | 8 | 4 | 6 | 4 | 3 | 1 | 3 | 0 | 2 |
146,956 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.BinaryFrame
|
class BinaryFrame(Frame):
"""Binary data
The 'data' attribute contains the raw byte string.
"""
_framespec = [BinaryDataSpec('data')]
def __eq__(self, other):
return self.data == other
__hash__ = Frame.__hash__
|
class BinaryFrame(Frame):
'''Binary data
The 'data' attribute contains the raw byte string.
'''
def __eq__(self, other):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.6 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 14 | 12 | 4 | 5 | 4 | 3 | 3 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
146,957 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.ASPI
|
class ASPI(Frame):
"""Audio seek point index.
Attributes: S, L, N, b, and Fi. For the meaning of these, see
the ID3v2.4 specification. Fi is a list of integers.
"""
_framespec = [
SizedIntegerSpec("S", 4),
SizedIntegerSpec("L", 4),
SizedIntegerSpec("N", 2),
ByteSpec("b"),
ASPIIndexSpec("Fi"),
]
def __eq__(self, other):
return self.Fi == other
__hash__ = Frame.__hash__
|
class ASPI(Frame):
'''Audio seek point index.
Attributes: S, L, N, b, and Fi. For the meaning of these, see
the ID3v2.4 specification. Fi is a list of integers.
'''
def __eq__(self, other):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.36 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 14 | 18 | 3 | 11 | 4 | 9 | 4 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
146,958 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.APIC
|
class APIC(Frame):
"""Attached (or linked) Picture.
Attributes:
* encoding -- text encoding for the description
* mime -- a MIME type (e.g. image/jpeg) or '-->' if the data is a URI
* type -- the source of the image (3 is the album front cover)
* desc -- a text description of the image
* data -- raw image data, as a byte string
Mutagen will automatically compress large images when saving tags.
"""
_framespec = [
EncodingSpec('encoding'),
Latin1TextSpec('mime'),
ByteSpec('type'),
EncodedTextSpec('desc'),
BinaryDataSpec('data'),
]
def __eq__(self, other):
return self.data == other
__hash__ = Frame.__hash__
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.desc)
def _pprint(self):
return "%s (%s, %d bytes)" % (
self.desc, self.mime, len(self.data))
|
class APIC(Frame):
'''Attached (or linked) Picture.
Attributes:
* encoding -- text encoding for the description
* mime -- a MIME type (e.g. image/jpeg) or '-->' if the data is a URI
* type -- the source of the image (3 is the album front cover)
* desc -- a text description of the image
* data -- raw image data, as a byte string
Mutagen will automatically compress large images when saving tags.
'''
def __eq__(self, other):
pass
@property
def HashKey(self):
pass
def _pprint(self):
pass
| 5 | 1 | 2 | 0 | 2 | 0 | 1 | 0.53 | 1 | 0 | 0 | 1 | 3 | 0 | 3 | 16 | 34 | 8 | 17 | 7 | 12 | 9 | 9 | 6 | 5 | 1 | 2 | 0 | 3 |
146,959 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.AENC
|
class AENC(FrameOpt):
"""Audio encryption.
Attributes:
* owner -- key identifying this encryption type
* preview_start -- unencrypted data block offset
* preview_length -- number of unencrypted blocks
* data -- data required for decryption (optional)
Mutagen cannot decrypt files.
"""
_framespec = [
Latin1TextSpec('owner'),
SizedIntegerSpec('preview_start', 2),
SizedIntegerSpec('preview_length', 2),
]
_optionalspec = [BinaryDataSpec('data')]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.owner)
def __bytes__(self):
return self.owner.encode('utf-8')
def __str__(self):
return self.owner
def __eq__(self, other):
return self.owner == other
__hash__ = FrameOpt.__hash__
|
class AENC(FrameOpt):
'''Audio encryption.
Attributes:
* owner -- key identifying this encryption type
* preview_start -- unencrypted data block offset
* preview_length -- number of unencrypted blocks
* data -- data required for decryption (optional)
Mutagen cannot decrypt files.
'''
@property
def HashKey(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
| 6 | 1 | 2 | 0 | 2 | 0 | 1 | 0.47 | 1 | 0 | 0 | 1 | 4 | 0 | 4 | 21 | 35 | 10 | 17 | 9 | 11 | 8 | 12 | 8 | 7 | 1 | 3 | 0 | 4 |
146,960 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.MP4
|
class MP4(FileType):
"""An MPEG-4 audio file, probably containing AAC.
If more than one track is present in the file, the first is used.
Only audio ('soun') tracks will be read.
:ivar info: :class:`MP4Info`
:ivar tags: :class:`MP4Tags`
"""
MP4Tags = MP4Tags
_mimes = ["audio/mp4", "audio/x-m4a", "audio/mpeg4", "audio/aac"]
def load(self, filename):
self.filename = filename
fileobj = open(filename, "rb")
try:
atoms = Atoms(fileobj)
# ftyp is always the first atom in a valid MP4 file
if not atoms.atoms or atoms.atoms[0].name != b"ftyp":
raise error("Not a MP4 file")
try:
self.info = MP4Info(atoms, fileobj)
except error:
raise
except Exception as err:
reraise(MP4StreamInfoError, err, sys.exc_info()[2])
if not MP4Tags._can_load(atoms):
self.tags = None
else:
try:
self.tags = self.MP4Tags(atoms, fileobj)
except error:
raise
except Exception as err:
reraise(MP4MetadataError, err, sys.exc_info()[2])
finally:
fileobj.close()
def add_tags(self):
if self.tags is None:
self.tags = self.MP4Tags()
else:
raise error("an MP4 tag already exists")
@staticmethod
def score(filename, fileobj, header_data):
return (b"ftyp" in header_data) + (b"mp4" in header_data)
|
class MP4(FileType):
'''An MPEG-4 audio file, probably containing AAC.
If more than one track is present in the file, the first is used.
Only audio ('soun') tracks will be read.
:ivar info: :class:`MP4Info`
:ivar tags: :class:`MP4Tags`
'''
def load(self, filename):
pass
def add_tags(self):
pass
@staticmethod
def score(filename, fileobj, header_data):
pass
| 5 | 1 | 12 | 1 | 10 | 0 | 3 | 0.2 | 1 | 6 | 5 | 1 | 2 | 3 | 3 | 16 | 52 | 10 | 35 | 13 | 30 | 7 | 31 | 11 | 27 | 7 | 2 | 3 | 10 |
146,961 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.FrameOpt
|
class FrameOpt(Frame):
"""A frame with optional parts.
Some ID3 frames have optional data; this class extends Frame to
provide support for those parts.
"""
_optionalspec = []
def __init__(self, *args, **kwargs):
super(FrameOpt, self).__init__(*args, **kwargs)
for spec in self._optionalspec:
if spec.name in kwargs:
validated = spec.validate(self, kwargs[spec.name])
setattr(self, spec.name, validated)
else:
break
def _readData(self, data):
odata = data
for reader in self._framespec:
if len(data):
value, data = reader.read(self, data)
else:
raise ID3JunkFrameError
setattr(self, reader.name, value)
if data:
for reader in self._optionalspec:
if len(data):
value, data = reader.read(self, data)
else:
break
setattr(self, reader.name, value)
if data.strip(b'\x00'):
warn('Leftover data: %s: %r (from %r)' % (
type(self).__name__, data, odata),
ID3Warning)
def _writeData(self):
data = []
for writer in self._framespec:
data.append(writer.write(self, getattr(self, writer.name)))
for writer in self._optionalspec:
try:
data.append(writer.write(self, getattr(self, writer.name)))
except AttributeError:
break
return b''.join(data)
def __repr__(self):
kw = []
for attr in self._framespec:
kw.append('%s=%r' % (attr.name, getattr(self, attr.name)))
for attr in self._optionalspec:
if hasattr(self, attr.name):
kw.append('%s=%r' % (attr.name, getattr(self, attr.name)))
return '%s(%s)' % (type(self).__name__, ', '.join(kw))
|
class FrameOpt(Frame):
'''A frame with optional parts.
Some ID3 frames have optional data; this class extends Frame to
provide support for those parts.
'''
def __init__(self, *args, **kwargs):
pass
def _readData(self, data):
pass
def _writeData(self):
pass
def __repr__(self):
pass
| 5 | 1 | 11 | 0 | 11 | 0 | 5 | 0.09 | 1 | 5 | 2 | 6 | 4 | 0 | 4 | 17 | 57 | 6 | 47 | 15 | 42 | 4 | 42 | 15 | 37 | 7 | 2 | 3 | 18 |
146,962 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/wavpack.py
|
mutagen.wavpack._WavPackHeader
|
class _WavPackHeader(object):
def __init__(self, block_size, version, track_no, index_no, total_samples,
block_index, block_samples, flags, crc):
self.block_size = block_size
self.version = version
self.track_no = track_no
self.index_no = index_no
self.total_samples = total_samples
self.block_index = block_index
self.block_samples = block_samples
self.flags = flags
self.crc = crc
@classmethod
def from_fileobj(cls, fileobj):
"""A new _WavPackHeader or raises WavPackHeaderError"""
header = fileobj.read(32)
if len(header) != 32 or not header.startswith(b"wvpk"):
raise WavPackHeaderError("not a WavPack header: %r" % header)
block_size = cdata.uint_le(header[4:8])
version = cdata.ushort_le(header[8:10])
track_no = ord(header[10:11])
index_no = ord(header[11:12])
samples = cdata.uint_le(header[12:16])
if samples == 2**32 - 1:
samples = -1
block_index = cdata.uint_le(header[16:20])
block_samples = cdata.uint_le(header[20:24])
flags = cdata.uint_le(header[24:28])
crc = cdata.uint_le(header[28:32])
return _WavPackHeader(block_size, version, track_no, index_no,
samples, block_index, block_samples, flags, crc)
|
class _WavPackHeader(object):
def __init__(self, block_size, version, track_no, index_no, total_samples,
block_index, block_samples, flags, crc):
pass
@classmethod
def from_fileobj(cls, fileobj):
'''A new _WavPackHeader or raises WavPackHeaderError'''
pass
| 4 | 1 | 17 | 2 | 14 | 1 | 2 | 0.03 | 1 | 2 | 2 | 0 | 1 | 9 | 2 | 2 | 37 | 6 | 30 | 24 | 25 | 1 | 27 | 22 | 24 | 3 | 1 | 1 | 4 |
146,963 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/wavpack.py
|
mutagen.wavpack.WavPackInfo
|
class WavPackInfo(StreamInfo):
"""WavPack stream information.
Attributes:
* channels - number of audio channels (1 or 2)
* length - file length in seconds, as a float
* sample_rate - audio sampling rate in Hz
* version - WavPack stream version
"""
def __init__(self, fileobj):
try:
header = _WavPackHeader.from_fileobj(fileobj)
except WavPackHeaderError:
raise WavPackHeaderError("not a WavPack file")
self.version = header.version
self.channels = bool(header.flags & 4) or 2
self.sample_rate = RATES[(header.flags >> 23) & 0xF]
if header.total_samples == -1 or header.block_index != 0:
# TODO: we could make this faster by using the tag size
# and search backwards for the last block, then do
# last.block_index + last.block_samples - initial.block_index
samples = header.block_samples
while 1:
fileobj.seek(header.block_size - 32 + 8, 1)
try:
header = _WavPackHeader.from_fileobj(fileobj)
except WavPackHeaderError:
break
samples += header.block_samples
else:
samples = header.total_samples
self.length = float(samples) / self.sample_rate
def pprint(self):
return "WavPack, %.2f seconds, %d Hz" % (self.length, self.sample_rate)
|
class WavPackInfo(StreamInfo):
'''WavPack stream information.
Attributes:
* channels - number of audio channels (1 or 2)
* length - file length in seconds, as a float
* sample_rate - audio sampling rate in Hz
* version - WavPack stream version
'''
def __init__(self, fileobj):
pass
def pprint(self):
pass
| 3 | 1 | 14 | 2 | 11 | 2 | 3 | 0.43 | 1 | 4 | 2 | 0 | 2 | 4 | 2 | 3 | 40 | 7 | 23 | 9 | 20 | 10 | 22 | 9 | 19 | 5 | 2 | 3 | 6 |
146,964 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/wavpack.py
|
mutagen.wavpack.WavPack
|
class WavPack(APEv2File):
_Info = WavPackInfo
_mimes = ["audio/x-wavpack"]
@staticmethod
def score(filename, fileobj, header):
return header.startswith(b"wvpk") * 2
|
class WavPack(APEv2File):
@staticmethod
def score(filename, fileobj, header):
pass
| 3 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 17 | 7 | 1 | 6 | 5 | 3 | 0 | 5 | 4 | 3 | 1 | 3 | 0 | 1 |
146,965 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.BitPaddedInt
|
class BitPaddedInt(int, _BitPaddedMixin):
def __new__(cls, value, bits=7, bigendian=True):
mask = (1 << (bits)) - 1
numeric_value = 0
shift = 0
if isinstance(value, integer_types):
while value:
numeric_value += (value & mask) << shift
value >>= 8
shift += bits
elif isinstance(value, bytes):
if bigendian:
value = reversed(value)
for byte in bytearray(value):
numeric_value += (byte & mask) << shift
shift += bits
else:
raise TypeError
if isinstance(numeric_value, int):
self = int.__new__(BitPaddedInt, numeric_value)
else:
self = long_.__new__(BitPaddedLong, numeric_value)
self.bits = bits
self.bigendian = bigendian
return self
|
class BitPaddedInt(int, _BitPaddedMixin):
def __new__(cls, value, bits=7, bigendian=True):
pass
| 2 | 0 | 28 | 4 | 24 | 0 | 7 | 0 | 2 | 5 | 1 | 0 | 1 | 0 | 1 | 59 | 30 | 5 | 25 | 7 | 23 | 0 | 22 | 7 | 20 | 7 | 2 | 2 | 7 |
146,966 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.BitPaddedLong
|
class BitPaddedLong(long_, _BitPaddedMixin):
pass
|
class BitPaddedLong(long_, _BitPaddedMixin):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 3 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 2 | 0 | 0 |
146,967 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.ID3BadCompressedData
|
class ID3BadCompressedData(error, ValueError):
pass
|
class ID3BadCompressedData(error, ValueError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 4 | 0 | 0 |
146,968 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.ID3BadUnsynchData
|
class ID3BadUnsynchData(error, ValueError):
pass
|
class ID3BadUnsynchData(error, ValueError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 4 | 0 | 0 |
146,969 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.ID3JunkFrameError
|
class ID3JunkFrameError(error, ValueError):
pass
|
class ID3JunkFrameError(error, ValueError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 4 | 0 | 0 |
146,970 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.ID3TagError
|
class ID3TagError(error, ValueError):
pass
|
class ID3TagError(error, ValueError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 4 | 0 | 0 |
146,971 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.ID3Warning
|
class ID3Warning(error, UserWarning):
pass
|
class ID3Warning(error, UserWarning):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 12 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 5 | 0 | 0 |
146,972 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util._BitPaddedMixin
|
class _BitPaddedMixin(object):
def as_str(self, width=4, minwidth=4):
return self.to_str(self, self.bits, self.bigendian, width, minwidth)
@staticmethod
def to_str(value, bits=7, bigendian=True, width=4, minwidth=4):
mask = (1 << bits) - 1
if width != -1:
index = 0
bytes_ = bytearray(width)
try:
while value:
bytes_[index] = value & mask
value >>= bits
index += 1
except IndexError:
raise ValueError('Value too wide (>%d bytes)' % width)
else:
# PCNT and POPM use growing integers
# of at least 4 bytes (=minwidth) as counters.
bytes_ = bytearray()
append = bytes_.append
while value:
append(value & mask)
value >>= bits
bytes_ = bytes_.ljust(minwidth, b"\x00")
if bigendian:
bytes_.reverse()
return bytes(bytes_)
@staticmethod
def has_valid_padding(value, bits=7):
"""Whether the padding bits are all zero"""
assert bits <= 8
mask = (((1 << (8 - bits)) - 1) << bits)
if isinstance(value, integer_types):
while value:
if value & mask:
return False
value >>= 8
elif isinstance(value, bytes):
for byte in bytearray(value):
if byte & mask:
return False
else:
raise TypeError
return True
|
class _BitPaddedMixin(object):
def as_str(self, width=4, minwidth=4):
pass
@staticmethod
def to_str(value, bits=7, bigendian=True, width=4, minwidth=4):
pass
@staticmethod
def has_valid_padding(value, bits=7):
'''Whether the padding bits are all zero'''
pass
| 6 | 1 | 16 | 2 | 13 | 1 | 5 | 0.07 | 1 | 5 | 0 | 2 | 1 | 0 | 3 | 3 | 54 | 9 | 42 | 12 | 36 | 3 | 37 | 10 | 33 | 7 | 1 | 3 | 14 |
146,973 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3util.py
|
mutagen._id3util.unsynch
|
class unsynch(object):
@staticmethod
def decode(value):
fragments = [bytearray(x) for x in value.split(b'\xff')]
if not fragments[-1]:
raise ValueError('string ended unsafe')
for f in (fragments[1:] if not fragments[0] else fragments):
if (not f) or (f[0] >= 0xE0):
raise ValueError('invalid sync-safe string')
if f[0] == 0:
del f[0]
return b'\xff'.join(map(bytes, fragments))
@staticmethod
def encode(value):
fragments = [bytearray(x) for x in value.split(b'\xff')]
for f in (fragments[1:] if not fragments[0] else fragments):
if (not f) or (f[0] >= 0xE0) or (f[0] == 0):
f[0:0] = b'\x00'
return b'\xff'.join(map(bytes, fragments))
|
class unsynch(object):
@staticmethod
def decode(value):
pass
@staticmethod
def encode(value):
pass
| 5 | 0 | 11 | 3 | 8 | 0 | 5 | 0 | 1 | 4 | 0 | 0 | 0 | 0 | 2 | 2 | 25 | 6 | 19 | 9 | 14 | 0 | 17 | 7 | 14 | 6 | 1 | 2 | 10 |
146,974 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.PairedTextFrame
|
class PairedTextFrame(Frame):
"""Paired text strings.
Some ID3 frames pair text strings, to associate names with a more
specific involvement in the song. The 'people' attribute of these
frames contains a list of pairs::
[['trumpet', 'Miles Davis'], ['bass', 'Paul Chambers']]
Like text frames, these frames also have an encoding attribute.
"""
_framespec = [
EncodingSpec('encoding'),
MultiSpec('people',
EncodedTextSpec('involvement'),
EncodedTextSpec('person'))
]
def __eq__(self, other):
return self.people == other
__hash__ = Frame.__hash__
|
class PairedTextFrame(Frame):
'''Paired text strings.
Some ID3 frames pair text strings, to associate names with a more
specific involvement in the song. The 'people' attribute of these
frames contains a list of pairs::
[['trumpet', 'Miles Davis'], ['bass', 'Paul Chambers']]
Like text frames, these frames also have an encoding attribute.
'''
def __eq__(self, other):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.7 | 1 | 0 | 0 | 2 | 1 | 0 | 1 | 14 | 23 | 6 | 10 | 4 | 8 | 7 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
146,975 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.PRIV
|
class PRIV(Frame):
"""Private frame."""
_framespec = [
Latin1TextSpec('owner'),
BinaryDataSpec('data'),
]
@property
def HashKey(self):
return '%s:%s:%s' % (
self.FrameID, self.owner, self.data.decode('latin1'))
def __bytes__(self):
return self.data
def __eq__(self, other):
return self.data == other
def _pprint(self):
isascii = ord_(max(self.data)) < 128
if isascii:
return "%s=%s" % (self.owner, self.data)
else:
return "%s (%d bytes)" % (self.owner, len(self.data))
__hash__ = Frame.__hash__
|
class PRIV(Frame):
'''Private frame.'''
@property
def HashKey(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def _pprint(self):
pass
| 6 | 1 | 3 | 0 | 3 | 0 | 1 | 0.05 | 1 | 0 | 0 | 0 | 4 | 0 | 4 | 17 | 27 | 6 | 20 | 9 | 14 | 1 | 14 | 8 | 9 | 2 | 2 | 1 | 5 |
146,976 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.POSS
|
class POSS(Frame):
"""Position synchronisation frame
Attribute:
* format -- format of the position attribute (frames or milliseconds)
* position -- current position of the file
"""
_framespec = [
ByteSpec('format'),
IntegerSpec('position'),
]
def __pos__(self):
return self.position
def __eq__(self, other):
return self.position == other
__hash__ = Frame.__hash__
|
class POSS(Frame):
'''Position synchronisation frame
Attribute:
* format -- format of the position attribute (frames or milliseconds)
* position -- current position of the file
'''
def __pos__(self):
pass
def __eq__(self, other):
pass
| 3 | 1 | 2 | 0 | 2 | 0 | 1 | 0.5 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 15 | 21 | 6 | 10 | 5 | 7 | 5 | 7 | 5 | 4 | 1 | 2 | 0 | 2 |
146,977 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.USLT
|
class USLT(Frame):
"""Unsynchronised lyrics/text transcription.
Lyrics have a three letter ISO language code ('lang'), a
description ('desc'), and a block of plain text ('text').
"""
_framespec = [
EncodingSpec('encoding'),
StringSpec('lang', 3),
EncodedTextSpec('desc'),
EncodedTextSpec('text'),
]
@property
def HashKey(self):
return '%s:%s:%r' % (self.FrameID, self.desc, self.lang)
def __bytes__(self):
return self.text.encode('utf-8')
def __str__(self):
return self.text
def __eq__(self, other):
return self.text == other
__hash__ = Frame.__hash__
|
class USLT(Frame):
'''Unsynchronised lyrics/text transcription.
Lyrics have a three letter ISO language code ('lang'), a
description ('desc'), and a block of plain text ('text').
'''
@property
def HashKey(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
| 6 | 1 | 2 | 0 | 2 | 0 | 1 | 0.24 | 1 | 0 | 0 | 1 | 4 | 0 | 4 | 17 | 28 | 7 | 17 | 8 | 11 | 4 | 11 | 7 | 6 | 1 | 2 | 0 | 4 |
146,978 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.POPM
|
class POPM(FrameOpt):
"""Popularimeter.
This frame keys a rating (out of 255) and a play count to an email
address.
Attributes:
* email -- email this POPM frame is for
* rating -- rating from 0 to 255
* count -- number of times the files has been played (optional)
"""
_framespec = [
Latin1TextSpec('email'),
ByteSpec('rating'),
]
_optionalspec = [IntegerSpec('count')]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.email)
def __eq__(self, other):
return self.rating == other
__hash__ = FrameOpt.__hash__
def __pos__(self):
return self.rating
def _pprint(self):
return "%s=%r %r/255" % (
self.email, getattr(self, 'count', None), self.rating)
|
class POPM(FrameOpt):
'''Popularimeter.
This frame keys a rating (out of 255) and a play count to an email
address.
Attributes:
* email -- email this POPM frame is for
* rating -- rating from 0 to 255
* count -- number of times the files has been played (optional)
'''
@property
def HashKey(self):
pass
def __eq__(self, other):
pass
def __pos__(self):
pass
def _pprint(self):
pass
| 6 | 1 | 2 | 0 | 2 | 0 | 1 | 0.47 | 1 | 0 | 0 | 1 | 4 | 0 | 4 | 21 | 35 | 10 | 17 | 9 | 11 | 8 | 12 | 8 | 7 | 1 | 3 | 0 | 4 |
146,979 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.PCNT
|
class PCNT(Frame):
"""Play counter.
The 'count' attribute contains the (recorded) number of times this
file has been played.
This frame is basically obsoleted by POPM.
"""
_framespec = [IntegerSpec('count')]
def __eq__(self, other):
return self.count == other
__hash__ = Frame.__hash__
def __pos__(self):
return self.count
def _pprint(self):
return text_type(self.count)
|
class PCNT(Frame):
'''Play counter.
The 'count' attribute contains the (recorded) number of times this
file has been played.
This frame is basically obsoleted by POPM.
'''
def __eq__(self, other):
pass
def __pos__(self):
pass
def _pprint(self):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.56 | 1 | 0 | 0 | 1 | 3 | 0 | 3 | 16 | 21 | 7 | 9 | 6 | 5 | 5 | 9 | 6 | 5 | 1 | 2 | 0 | 3 |
146,980 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggflac.py
|
mutagen.oggflac.OggFLACVComment
|
class OggFLACVComment(VCFLACDict):
def __init__(self, data, info, *args, **kwargs):
super(OggFLACVComment, self).__init__()
self.load(data, info, *args, **kwargs)
def load(self, data, info, errors='replace'):
# data should be pointing at the start of an Ogg page, after
# the first FLAC page.
pages = []
complete = False
while not complete:
page = OggPage(data)
if page.serial == info.serial:
pages.append(page)
complete = page.complete or (len(page.packets) > 1)
comment = cBytesIO(OggPage.to_packets(pages)[0][4:])
super(OggFLACVComment, self).load(comment, errors=errors)
def _inject(self, fileobj):
"""Write tag data into the FLAC Vorbis comment packet/page."""
# Ogg FLAC has no convenient data marker like Vorbis, but the
# second packet - and second page - must be the comment data.
fileobj.seek(0)
page = OggPage(fileobj)
while not page.packets[0].startswith(b"\x7FFLAC"):
page = OggPage(fileobj)
first_page = page
while not (page.sequence == 1 and page.serial == first_page.serial):
page = OggPage(fileobj)
old_pages = [page]
while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
page = OggPage(fileobj)
if page.serial == first_page.serial:
old_pages.append(page)
packets = OggPage.to_packets(old_pages, strict=False)
# Set the new comment block.
data = self.write()
data = packets[0][:1] + struct.pack(">I", len(data))[-3:] + data
packets[0] = data
new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
OggPage.replace(fileobj, old_pages, new_pages)
|
class OggFLACVComment(VCFLACDict):
def __init__(self, data, info, *args, **kwargs):
pass
def load(self, data, info, errors='replace'):
pass
def _inject(self, fileobj):
'''Write tag data into the FLAC Vorbis comment packet/page.'''
pass
| 4 | 1 | 15 | 2 | 11 | 2 | 3 | 0.18 | 1 | 2 | 1 | 0 | 3 | 0 | 3 | 28 | 47 | 8 | 33 | 14 | 29 | 6 | 33 | 14 | 29 | 5 | 3 | 2 | 9 |
146,981 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggflac.py
|
mutagen.oggflac.OggFLACStreamInfo
|
class OggFLACStreamInfo(StreamInfo):
"""Ogg FLAC general header and stream info.
This encompasses the Ogg wrapper for the FLAC STREAMINFO metadata
block, as well as the Ogg codec setup that precedes it.
Attributes (in addition to StreamInfo's):
* packets -- number of metadata packets
* serial -- Ogg logical stream serial number
"""
packets = 0
serial = 0
def load(self, data):
# Ogg expects file objects that don't raise on read
if isinstance(data, StrictFileObject):
data = data._fileobj
page = OggPage(data)
while not page.packets[0].startswith(b"\x7FFLAC"):
page = OggPage(data)
major, minor, self.packets, flac = struct.unpack(
">BBH4s", page.packets[0][5:13])
if flac != b"fLaC":
raise OggFLACHeaderError("invalid FLAC marker (%r)" % flac)
elif (major, minor) != (1, 0):
raise OggFLACHeaderError(
"unknown mapping version: %d.%d" % (major, minor))
self.serial = page.serial
# Skip over the block header.
stringobj = StrictFileObject(cBytesIO(page.packets[0][17:]))
super(OggFLACStreamInfo, self).load(stringobj)
def _post_tags(self, fileobj):
if self.length:
return
page = OggPage.find_last(fileobj, self.serial)
self.length = page.position / float(self.sample_rate)
def pprint(self):
return u"Ogg " + super(OggFLACStreamInfo, self).pprint()
|
class OggFLACStreamInfo(StreamInfo):
'''Ogg FLAC general header and stream info.
This encompasses the Ogg wrapper for the FLAC STREAMINFO metadata
block, as well as the Ogg codec setup that precedes it.
Attributes (in addition to StreamInfo's):
* packets -- number of metadata packets
* serial -- Ogg logical stream serial number
'''
def load(self, data):
pass
def _post_tags(self, fileobj):
pass
def pprint(self):
pass
| 4 | 1 | 9 | 1 | 8 | 1 | 3 | 0.35 | 1 | 5 | 3 | 0 | 3 | 1 | 3 | 13 | 44 | 9 | 26 | 11 | 22 | 9 | 23 | 11 | 19 | 5 | 3 | 1 | 8 |
146,982 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.OWNE
|
class OWNE(Frame):
"""Ownership frame."""
_framespec = [
EncodingSpec('encoding'),
Latin1TextSpec('price'),
StringSpec('date', 8),
EncodedTextSpec('seller'),
]
def __bytes__(self):
return self.seller.encode('utf-8')
def __str__(self):
return self.seller
def __eq__(self, other):
return self.seller == other
__hash__ = Frame.__hash__
|
class OWNE(Frame):
'''Ownership frame.'''
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.07 | 1 | 0 | 0 | 0 | 3 | 0 | 3 | 16 | 20 | 5 | 14 | 6 | 10 | 1 | 9 | 6 | 5 | 1 | 2 | 0 | 3 |
146,983 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.NumericTextFrame
|
class NumericTextFrame(TextFrame):
"""Numerical text strings.
The numeric value of these frames can be gotten with unary plus, e.g.::
frame = TLEN('12345')
length = +frame
"""
_framespec = [
EncodingSpec('encoding'),
MultiSpec('text', EncodedNumericTextSpec('text'), sep=u'\u0000'),
]
def __pos__(self):
"""Return the numerical value of the string."""
return int(self.text[0])
|
class NumericTextFrame(TextFrame):
'''Numerical text strings.
The numeric value of these frames can be gotten with unary plus, e.g.::
frame = TLEN('12345')
length = +frame
'''
def __pos__(self):
'''Return the numerical value of the string.'''
pass
| 2 | 2 | 3 | 0 | 2 | 1 | 1 | 0.86 | 1 | 1 | 0 | 7 | 1 | 0 | 1 | 22 | 17 | 4 | 7 | 3 | 5 | 6 | 4 | 3 | 2 | 1 | 3 | 0 | 1 |
146,984 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.NumericPartTextFrame
|
class NumericPartTextFrame(TextFrame):
"""Multivalue numerical text strings.
These strings indicate 'part (e.g. track) X of Y', and unary plus
returns the first value::
frame = TRCK('4/15')
track = +frame # track == 4
"""
_framespec = [
EncodingSpec('encoding'),
MultiSpec('text', EncodedNumericPartTextSpec('text'), sep=u'\u0000'),
]
def __pos__(self):
return int(self.text[0].split("/")[0])
|
class NumericPartTextFrame(TextFrame):
'''Multivalue numerical text strings.
These strings indicate 'part (e.g. track) X of Y', and unary plus
returns the first value::
frame = TRCK('4/15')
track = +frame # track == 4
'''
def __pos__(self):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.86 | 1 | 1 | 0 | 2 | 1 | 0 | 1 | 22 | 17 | 4 | 7 | 3 | 5 | 6 | 4 | 3 | 2 | 1 | 3 | 0 | 1 |
146,985 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.MLLT
|
class MLLT(Frame):
"""MPEG location lookup table.
This frame's attributes may be changed in the future based on
feedback from real-world use.
"""
_framespec = [
SizedIntegerSpec('frames', 2),
SizedIntegerSpec('bytes', 3),
SizedIntegerSpec('milliseconds', 3),
ByteSpec('bits_for_bytes'),
ByteSpec('bits_for_milliseconds'),
BinaryDataSpec('data'),
]
def __eq__(self, other):
return self.data == other
__hash__ = Frame.__hash__
|
class MLLT(Frame):
'''MPEG location lookup table.
This frame's attributes may be changed in the future based on
feedback from real-world use.
'''
def __eq__(self, other):
pass
| 2 | 1 | 2 | 0 | 2 | 0 | 1 | 0.33 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 14 | 20 | 4 | 12 | 4 | 10 | 4 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
146,986 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.LNK
|
class LNK(LINK):
"""Linked information"""
_framespec = [StringSpec('frameid', 3), Latin1TextSpec('url')]
_optionalspec = [BinaryDataSpec('data')]
|
class LNK(LINK):
'''Linked information'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0.33 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 19 | 4 | 0 | 3 | 3 | 2 | 1 | 3 | 3 | 2 | 0 | 4 | 0 | 0 |
146,987 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.LINK
|
class LINK(FrameOpt):
"""Linked information.
Attributes:
* frameid -- the ID of the linked frame
* url -- the location of the linked frame
* data -- further ID information for the frame
"""
_framespec = [
StringSpec('frameid', 4),
Latin1TextSpec('url'),
]
_optionalspec = [BinaryDataSpec('data')]
@property
def HashKey(self):
try:
return "%s:%s:%s:%r" % (
self.FrameID, self.frameid, self.url, self.data)
except AttributeError:
return "%s:%s:%s" % (self.FrameID, self.frameid, self.url)
def __eq__(self, other):
try:
return (self.frameid, self.url, self.data) == other
except AttributeError:
return (self.frameid, self.url) == other
__hash__ = FrameOpt.__hash__
|
class LINK(FrameOpt):
'''Linked information.
Attributes:
* frameid -- the ID of the linked frame
* url -- the location of the linked frame
* data -- further ID information for the frame
'''
@property
def HashKey(self):
pass
def __eq__(self, other):
pass
| 4 | 1 | 6 | 0 | 6 | 0 | 2 | 0.32 | 1 | 1 | 0 | 1 | 2 | 0 | 2 | 19 | 32 | 7 | 19 | 7 | 15 | 6 | 14 | 6 | 11 | 2 | 3 | 1 | 4 |
146,988 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.GRID
|
class GRID(FrameOpt):
"""Group identification registration."""
_framespec = [
Latin1TextSpec('owner'),
ByteSpec('group'),
]
_optionalspec = [BinaryDataSpec('data')]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.group)
def __pos__(self):
return self.group
def __bytes__(self):
return self.owner.encode('utf-8')
def __str__(self):
return self.owner
def __eq__(self, other):
return self.owner == other or self.group == other
__hash__ = FrameOpt.__hash__
|
class GRID(FrameOpt):
'''Group identification registration.'''
@property
def HashKey(self):
pass
def __pos__(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
| 7 | 1 | 2 | 0 | 2 | 0 | 1 | 0.06 | 1 | 0 | 0 | 0 | 5 | 0 | 5 | 22 | 27 | 8 | 18 | 10 | 11 | 1 | 14 | 9 | 8 | 1 | 3 | 0 | 5 |
146,989 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/trueaudio.py
|
mutagen.trueaudio.TrueAudioInfo
|
class TrueAudioInfo(StreamInfo):
"""True Audio stream information.
Attributes:
* length - audio length, in seconds
* sample_rate - audio sample rate, in Hz
"""
def __init__(self, fileobj, offset):
fileobj.seek(offset or 0)
header = fileobj.read(18)
if len(header) != 18 or not header.startswith(b"TTA"):
raise TrueAudioHeaderError("TTA header not found")
self.sample_rate = cdata.int_le(header[10:14])
samples = cdata.uint_le(header[14:18])
self.length = float(samples) / self.sample_rate
def pprint(self):
return "True Audio, %.2f seconds, %d Hz." % (
self.length, self.sample_rate)
|
class TrueAudioInfo(StreamInfo):
'''True Audio stream information.
Attributes:
* length - audio length, in seconds
* sample_rate - audio sample rate, in Hz
'''
def __init__(self, fileobj, offset):
pass
def pprint(self):
pass
| 3 | 1 | 6 | 0 | 6 | 0 | 2 | 0.42 | 1 | 3 | 2 | 0 | 2 | 2 | 2 | 3 | 21 | 4 | 12 | 7 | 9 | 5 | 11 | 7 | 8 | 2 | 2 | 1 | 3 |
146,990 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/trueaudio.py
|
mutagen.trueaudio.error
|
class error(RuntimeError):
pass
|
class error(RuntimeError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 4 | 0 | 0 |
146,991 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.PIC
|
class PIC(APIC):
"""Attached Picture.
The 'mime' attribute of an ID3v2.2 attached picture must be either
'PNG' or 'JPG'.
"""
_framespec = [EncodingSpec('encoding'), StringSpec('mime', 3),
ByteSpec('type'), EncodedTextSpec('desc'),
BinaryDataSpec('data')]
|
class PIC(APIC):
'''Attached Picture.
The 'mime' attribute of an ID3v2.2 attached picture must be either
'PNG' or 'JPG'.
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 16 | 9 | 1 | 4 | 2 | 3 | 4 | 2 | 2 | 1 | 0 | 3 | 0 | 0 |
146,992 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3specs.py
|
mutagen._id3specs.VolumeAdjustmentsSpec
|
class VolumeAdjustmentsSpec(Spec):
# Not to be confused with VolumeAdjustmentSpec.
def read(self, frame, data):
adjustments = {}
while len(data) >= 4:
freq, adj = struct.unpack(">Hh", data[:4])
data = data[4:]
freq /= 2.0
adj /= 512.0
adjustments[freq] = adj
adjustments = sorted(adjustments.items())
return adjustments, data
def write(self, frame, value):
return b''.join(struct.pack(">Hh", int(freq * 2), int(adj * 512))
for (freq, adj) in sorted(value))
def validate(self, frame, value):
return value
|
class VolumeAdjustmentsSpec(Spec):
def read(self, frame, data):
pass
def write(self, frame, value):
pass
def validate(self, frame, value):
pass
| 4 | 0 | 5 | 0 | 5 | 0 | 1 | 0.06 | 1 | 1 | 0 | 0 | 3 | 0 | 3 | 6 | 19 | 2 | 16 | 6 | 12 | 1 | 15 | 6 | 11 | 2 | 2 | 1 | 4 |
146,993 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.OddWrites
|
class OddWrites(TestCase):
silence = join('tests', 'data', 'silence-44-s.mp3')
newsilence = join('tests', 'data', 'silence-written.mp3')
def setUp(self):
shutil.copy(self.silence, self.newsilence)
def test_toemptyfile(self):
os.unlink(self.newsilence)
open(self.newsilence, "wb").close()
ID3(self.silence).save(self.newsilence)
def test_tononfile(self):
os.unlink(self.newsilence)
ID3(self.silence).save(self.newsilence)
def test_1bfile(self):
os.unlink(self.newsilence)
f = open(self.newsilence, "wb")
f.write(b'!')
f.close()
ID3(self.silence).save(self.newsilence)
self.assert_(os.path.getsize(self.newsilence) > 1)
self.assertEquals(open(self.newsilence, "rb").read()[-1], b'!'[0])
def tearDown(self):
try: os.unlink(self.newsilence)
except OSError: pass
|
class OddWrites(TestCase):
def setUp(self):
pass
def test_toemptyfile(self):
pass
def test_tononfile(self):
pass
def test_1bfile(self):
pass
def tearDown(self):
pass
| 6 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 5 | 0 | 5 | 80 | 27 | 4 | 23 | 9 | 17 | 0 | 25 | 9 | 19 | 2 | 3 | 1 | 6 |
146,994 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.USER
|
class USER(Frame):
"""Terms of use.
Attributes:
* encoding -- text encoding
* lang -- ISO three letter language code
* text -- licensing terms for the audio
"""
_framespec = [
EncodingSpec('encoding'),
StringSpec('lang', 3),
EncodedTextSpec('text'),
]
@property
def HashKey(self):
return '%s:%r' % (self.FrameID, self.lang)
def __bytes__(self):
return self.text.encode('utf-8')
def __str__(self):
return self.text
def __eq__(self, other):
return self.text == other
__hash__ = Frame.__hash__
def _pprint(self):
return "%r=%s" % (self.lang, self.text)
|
class USER(Frame):
'''Terms of use.
Attributes:
* encoding -- text encoding
* lang -- ISO three letter language code
* text -- licensing terms for the audio
'''
@property
def HashKey(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
def _pprint(self):
pass
| 7 | 1 | 2 | 0 | 2 | 0 | 1 | 0.33 | 1 | 0 | 0 | 0 | 5 | 0 | 5 | 18 | 33 | 9 | 18 | 9 | 11 | 6 | 13 | 8 | 7 | 1 | 2 | 0 | 5 |
146,995 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__util.py
|
tests.test__util.Tcdata
|
class Tcdata(TestCase):
ZERO = b"\x00\x00\x00\x00"
LEONE = b"\x01\x00\x00\x00"
BEONE = b"\x00\x00\x00\x01"
NEGONE = b"\xff\xff\xff\xff"
def test_int_le(self):
self.failUnlessEqual(cdata.int_le(self.ZERO), 0)
self.failUnlessEqual(cdata.int_le(self.LEONE), 1)
self.failUnlessEqual(cdata.int_le(self.BEONE), 16777216)
self.failUnlessEqual(cdata.int_le(self.NEGONE), -1)
def test_uint_le(self):
self.failUnlessEqual(cdata.uint_le(self.ZERO), 0)
self.failUnlessEqual(cdata.uint_le(self.LEONE), 1)
self.failUnlessEqual(cdata.uint_le(self.BEONE), 16777216)
self.failUnlessEqual(cdata.uint_le(self.NEGONE), 2**32-1)
def test_longlong_le(self):
self.failUnlessEqual(cdata.longlong_le(self.ZERO * 2), 0)
self.failUnlessEqual(cdata.longlong_le(self.LEONE + self.ZERO), 1)
self.failUnlessEqual(cdata.longlong_le(self.NEGONE * 2), -1)
def test_ulonglong_le(self):
self.failUnlessEqual(cdata.ulonglong_le(self.ZERO * 2), 0)
self.failUnlessEqual(cdata.ulonglong_le(self.LEONE + self.ZERO), 1)
self.failUnlessEqual(cdata.ulonglong_le(self.NEGONE * 2), 2**64-1)
def test_invalid_lengths(self):
self.failUnlessRaises(cdata.error, cdata.int_le, b"")
self.failUnlessRaises(cdata.error, cdata.longlong_le, b"")
self.failUnlessRaises(cdata.error, cdata.uint_le, b"")
self.failUnlessRaises(cdata.error, cdata.ulonglong_le, b"")
def test_test(self):
self.failUnless(cdata.test_bit((1), 0))
self.failIf(cdata.test_bit(1, 1))
self.failUnless(cdata.test_bit(2, 1))
self.failIf(cdata.test_bit(2, 0))
v = (1 << 12) + (1 << 5) + 1
self.failUnless(cdata.test_bit(v, 0))
self.failUnless(cdata.test_bit(v, 5))
self.failUnless(cdata.test_bit(v, 12))
self.failIf(cdata.test_bit(v, 3))
self.failIf(cdata.test_bit(v, 8))
self.failIf(cdata.test_bit(v, 13))
|
class Tcdata(TestCase):
def test_int_le(self):
pass
def test_uint_le(self):
pass
def test_longlong_le(self):
pass
def test_ulonglong_le(self):
pass
def test_invalid_lengths(self):
pass
def test_test(self):
pass
| 7 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 6 | 0 | 6 | 81 | 49 | 9 | 40 | 12 | 33 | 0 | 40 | 12 | 33 | 1 | 3 | 0 | 6 |
146,996 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__util.py
|
tests.test__util.FileHandling
|
class FileHandling(TestCase):
def file(self, contents):
import tempfile
temp = tempfile.TemporaryFile()
temp.write(contents)
temp.flush()
temp.seek(0)
return temp
def read(self, fobj):
fobj.seek(0, 0)
return fobj.read()
def test_insert_into_empty(self):
o = self.file(b'')
insert_bytes(o, 8, 0)
self.assertEquals(b'\x00' * 8, self.read(o))
def test_insert_before_one(self):
o = self.file(b'a')
insert_bytes(o, 8, 0)
self.assertEquals(b'a' + b'\x00' * 7 + b'a', self.read(o))
def test_insert_after_one(self):
o = self.file(b'a')
insert_bytes(o, 8, 1)
self.assertEquals(b'a' + b'\x00' * 8, self.read(o))
def test_smaller_than_file_middle(self):
o = self.file(b'abcdefghij')
insert_bytes(o, 4, 4)
self.assertEquals(b'abcdefghefghij', self.read(o))
def test_smaller_than_file_to_end(self):
o = self.file(b'abcdefghij')
insert_bytes(o, 4, 6)
self.assertEquals(b'abcdefghijghij', self.read(o))
def test_smaller_than_file_across_end(self):
o = self.file(b'abcdefghij')
insert_bytes(o, 4, 8)
self.assertEquals(b'abcdefghij\x00\x00ij', self.read(o))
def test_smaller_than_file_at_end(self):
o = self.file(b'abcdefghij')
insert_bytes(o, 3, 10)
self.assertEquals(b'abcdefghij\x00\x00\x00', self.read(o))
def test_smaller_than_file_at_beginning(self):
o = self.file(b'abcdefghij')
insert_bytes(o, 3, 0)
self.assertEquals(b'abcabcdefghij', self.read(o))
def test_zero(self):
o = self.file(b'abcdefghij')
self.assertRaises((AssertionError, ValueError), insert_bytes, o, 0, 1)
def test_negative(self):
o = self.file(b'abcdefghij')
self.assertRaises((AssertionError, ValueError), insert_bytes, o, 8, -1)
def test_delete_one(self):
o = self.file(b'a')
delete_bytes(o, 1, 0)
self.assertEquals(b'', self.read(o))
def test_delete_first_of_two(self):
o = self.file(b'ab')
delete_bytes(o, 1, 0)
self.assertEquals(b'b', self.read(o))
def test_delete_second_of_two(self):
o = self.file(b'ab')
delete_bytes(o, 1, 1)
self.assertEquals(b'a', self.read(o))
def test_delete_third_of_two(self):
o = self.file(b'ab')
self.assertRaises(AssertionError, delete_bytes, o, 1, 2)
def test_delete_middle(self):
o = self.file(b'abcdefg')
delete_bytes(o, 3, 2)
self.assertEquals(b'abfg', self.read(o))
def test_delete_across_end(self):
o = self.file(b'abcdefg')
self.assertRaises(AssertionError, delete_bytes, o, 4, 8)
def test_delete_zero(self):
o = self.file(b'abcdefg')
self.assertRaises(AssertionError, delete_bytes, o, 0, 3)
def test_delete_negative(self):
o = self.file(b'abcdefg')
self.assertRaises(AssertionError, delete_bytes, o, 4, -8)
def test_insert_6106_79_51760(self):
# This appears to be due to ANSI C limitations in read/write on rb+
# files. The problematic behavior only showed up in our mmap fallback
# code for transfers of this or similar sizes.
data = u''.join(map(text_type, range(12574))) # 51760 bytes
data = data.encode("ascii")
o = self.file(data)
insert_bytes(o, 6106, 79)
self.failUnless(data[:6106+79] + data[79:] == self.read(o))
def test_delete_6106_79_51760(self):
# This appears to be due to ANSI C limitations in read/write on rb+
# files. The problematic behavior only showed up in our mmap fallback
# code for transfers of this or similar sizes.
data = u''.join(map(text_type, range(12574))) # 51760 bytes
data = data.encode("ascii")
o = self.file(data[:6106+79] + data[79:])
delete_bytes(o, 6106, 79)
self.failUnless(data == self.read(o))
# Generate a bunch of random insertions, apply them, delete them,
# and make sure everything is still correct.
#
# The num_runs and num_changes values are tuned to take about 10s
# on my laptop, or about 30 seconds since we we have 3 variations
# on insert/delete_bytes brokenness. If I ever get a faster
# laptop, it's probably a good idea to increase them. :)
def test_many_changes(self, num_runs=5, num_changes=300,
min_change_size=500, max_change_size=1000,
min_buffer_size=1, max_buffer_size=2000):
self.failUnless(min_buffer_size < min_change_size and
max_buffer_size > max_change_size and
min_change_size < max_change_size and
min_buffer_size < max_buffer_size,
"Given testing parameters make this test useless")
for j in range(num_runs):
data = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" * 1024
fobj = self.file(data)
filesize = len(data)
# Generate the list of changes to apply
changes = []
for i in range(num_changes):
change_size = random.randrange(min_change_size, max_change_size)
change_offset = random.randrange(0, filesize)
filesize += change_size
changes.append((change_offset, change_size))
# Apply the changes, and make sure they all took.
for offset, size in changes:
buffer_size = random.randrange(min_buffer_size, max_buffer_size)
insert_bytes(fobj, size, offset, BUFFER_SIZE=buffer_size)
fobj.seek(0)
self.failIfEqual(fobj.read(len(data)), data)
fobj.seek(0, 2)
self.failUnlessEqual(fobj.tell(), filesize)
# Then, undo them.
changes.reverse()
for offset, size in changes:
buffer_size = random.randrange(min_buffer_size, max_buffer_size)
delete_bytes(fobj, size, offset, BUFFER_SIZE=buffer_size)
fobj.seek(0)
self.failUnless(fobj.read() == data)
|
class FileHandling(TestCase):
def file(self, contents):
pass
def read(self, fobj):
pass
def test_insert_into_empty(self):
pass
def test_insert_before_one(self):
pass
def test_insert_after_one(self):
pass
def test_smaller_than_file_middle(self):
pass
def test_smaller_than_file_to_end(self):
pass
def test_smaller_than_file_across_end(self):
pass
def test_smaller_than_file_at_end(self):
pass
def test_smaller_than_file_at_beginning(self):
pass
def test_zero(self):
pass
def test_negative(self):
pass
def test_delete_one(self):
pass
def test_delete_first_of_two(self):
pass
def test_delete_second_of_two(self):
pass
def test_delete_third_of_two(self):
pass
def test_delete_middle(self):
pass
def test_delete_across_end(self):
pass
def test_delete_zero(self):
pass
def test_delete_negative(self):
pass
def test_insert_6106_79_51760(self):
pass
def test_delete_6106_79_51760(self):
pass
def test_many_changes(self, num_runs=5, num_changes=300,
min_change_size=500, max_change_size=1000,
min_buffer_size=1, max_buffer_size=2000):
pass
| 24 | 0 | 6 | 0 | 5 | 0 | 1 | 0.15 | 1 | 4 | 0 | 0 | 23 | 0 | 23 | 98 | 160 | 24 | 120 | 60 | 93 | 18 | 114 | 58 | 89 | 5 | 3 | 2 | 27 |
146,997 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3specs.py
|
tests.test__id3specs.TestUnsynch
|
class TestUnsynch(TestCase):
def test_unsync_encode(self):
from mutagen.id3 import unsynch as un
for d in (b'\xff\xff\xff\xff', b'\xff\xf0\x0f\x00', b'\xff\x00\x0f\xf0'):
self.assertEquals(d, un.decode(un.encode(d)))
self.assertNotEqual(d, un.encode(d))
self.assertEquals(b'\xff\x44', un.encode(b'\xff\x44'))
self.assertEquals(b'\xff\x00\x00', un.encode(b'\xff\x00'))
def test_unsync_decode(self):
from mutagen.id3 import unsynch as un
self.assertRaises(ValueError, un.decode, b'\xff\xff\xff\xff')
self.assertRaises(ValueError, un.decode, b'\xff\xf0\x0f\x00')
self.assertRaises(ValueError, un.decode, b'\xff\xe0')
self.assertRaises(ValueError, un.decode, b'\xff')
self.assertEquals(b'\xff\x44', un.decode(b'\xff\x44'))
|
class TestUnsynch(TestCase):
def test_unsync_encode(self):
pass
def test_unsync_decode(self):
pass
| 3 | 0 | 7 | 0 | 7 | 0 | 2 | 0 | 1 | 2 | 1 | 0 | 2 | 0 | 2 | 77 | 17 | 2 | 15 | 6 | 10 | 0 | 15 | 6 | 10 | 2 | 3 | 1 | 3 |
146,998 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3specs.py
|
tests.test__id3specs.SpecValidateChecks
|
class SpecValidateChecks(TestCase):
def test_volumeadjustmentspec(self):
from mutagen.id3 import VolumeAdjustmentSpec
s = VolumeAdjustmentSpec('gain')
self.assertRaises(ValueError, s.validate, None, 65)
def test_volumepeakspec(self):
from mutagen.id3 import VolumePeakSpec
s = VolumePeakSpec('peak')
self.assertRaises(ValueError, s.validate, None, 2)
def test_bytespec(self):
from mutagen.id3 import ByteSpec
s = ByteSpec('byte')
self.assertRaises(ValueError, s.validate, None, 1000)
|
class SpecValidateChecks(TestCase):
def test_volumeadjustmentspec(self):
pass
def test_volumepeakspec(self):
pass
def test_bytespec(self):
pass
| 4 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 4 | 3 | 0 | 3 | 0 | 3 | 78 | 16 | 3 | 13 | 10 | 6 | 0 | 13 | 10 | 6 | 1 | 3 | 0 | 3 |
146,999 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3specs.py
|
tests.test__id3specs.SpecSanityChecks
|
class SpecSanityChecks(TestCase):
def test_bytespec(self):
from mutagen.id3 import ByteSpec
s = ByteSpec('name')
self.assertEquals((97, b'bcdefg'), s.read(None, b'abcdefg'))
self.assertEquals(b'a', s.write(None, 97))
self.assertRaises(TypeError, s.write, None, b'abc')
self.assertRaises(TypeError, s.write, None, None)
def test_encodingspec(self):
from mutagen.id3 import EncodingSpec
s = EncodingSpec('name')
self.assertEquals((0, b'abcdefg'), s.read(None, b'abcdefg'))
self.assertEquals((3, b'abcdefg'), s.read(None, b'\x03abcdefg'))
self.assertEquals(b'\x00', s.write(None, 0))
self.assertRaises(TypeError, s.write, None, b'abc')
self.assertRaises(TypeError, s.write, None, None)
def test_stringspec(self):
from mutagen.id3 import StringSpec
s = StringSpec('name', 3)
self.assertEquals(('abc', b'defg'), s.read(None, b'abcdefg'))
self.assertEquals(b'abc', s.write(None, 'abcdefg'))
self.assertEquals(b'\x00\x00\x00', s.write(None, None))
self.assertEquals(b'\x00\x00\x00', s.write(None, '\x00'))
self.assertEquals(b'a\x00\x00', s.write(None, 'a'))
def test_binarydataspec(self):
from mutagen.id3 import BinaryDataSpec
s = BinaryDataSpec('name')
self.assertEquals((b'abcdefg', b''), s.read(None, b'abcdefg'))
self.assertEquals(b'', s.write(None, None))
self.assertEquals(b'43', s.write(None, 43))
self.assertEquals(b'abc', s.write(None, b'abc'))
def test_encodedtextspec(self):
from mutagen.id3 import EncodedTextSpec, Frame
s = EncodedTextSpec('name')
f = Frame(); f.encoding = 0
self.assertEquals((u'abcd', b'fg'), s.read(f, b'abcd\x00fg'))
self.assertEquals(b'abcdefg\x00', s.write(f, u'abcdefg'))
self.assertRaises(AttributeError, s.write, f, None)
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_volumeadjustmentspec(self):
from mutagen.id3 import VolumeAdjustmentSpec
s = VolumeAdjustmentSpec('gain')
self.assertEquals((0.0, b''), s.read(None, b'\x00\x00'))
self.assertEquals((2.0, b''), s.read(None, b'\x04\x00'))
self.assertEquals((-2.0, b''), s.read(None, b'\xfc\x00'))
self.assertEquals(b'\x00\x00', s.write(None, 0.0))
self.assertEquals(b'\x04\x00', s.write(None, 2.0))
self.assertEquals(b'\xfc\x00', s.write(None, -2.0))
def test_synchronizedtextspec(self):
from mutagen.id3 import SynchronizedTextSpec, Frame
s = SynchronizedTextSpec('name')
f = Frame()
values = [(u"A", 100), (u"\xe4xy", 0), (u"", 42), (u"", 0)]
# utf-16
f.encoding = 1
self.assertEqual(s.read(f, s.write(f, values)), (values, b""))
self.assertEquals(
s.write(f, [(u"A", 100)]), b"\xff\xfeA\x00\x00\x00\x00\x00\x00d")
# utf-16be
f.encoding = 2
self.assertEqual(s.read(f, s.write(f, values)), (values, b""))
self.assertEquals(
s.write(f, [(u"A", 100)]), b"\x00A\x00\x00\x00\x00\x00d")
# utf-8
f.encoding = 3
self.assertEqual(s.read(f, s.write(f, values)), (values, b""))
self.assertEquals(s.write(f, [(u"A", 100)]), b"A\x00\x00\x00\x00d")
|
class SpecSanityChecks(TestCase):
def test_bytespec(self):
pass
def test_encodingspec(self):
pass
def test_stringspec(self):
pass
def test_binarydataspec(self):
pass
def test_encodedtextspec(self):
pass
def test_timestampspec(self):
pass
def test_volumeadjustmentspec(self):
pass
def test_synchronizedtextspec(self):
pass
| 9 | 0 | 10 | 1 | 10 | 0 | 1 | 0.04 | 1 | 13 | 10 | 0 | 8 | 0 | 8 | 83 | 92 | 12 | 77 | 29 | 60 | 3 | 75 | 29 | 58 | 2 | 3 | 1 | 9 |
147,000 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3specs.py
|
tests.test__id3specs.NoHashSpec
|
class NoHashSpec(TestCase):
def test_spec(self):
from mutagen.id3 import Spec
self.failUnlessRaises(TypeError, {}.__setitem__, Spec("foo"), None)
|
class NoHashSpec(TestCase):
def test_spec(self):
pass
| 2 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 1 | 0 | 1 | 76 | 5 | 1 | 4 | 3 | 1 | 0 | 4 | 3 | 1 | 1 | 3 | 0 | 1 |
147,001 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3specs.py
|
tests.test__id3specs.BitPaddedIntTest
|
class BitPaddedIntTest(TestCase):
def test_zero(self):
self.assertEquals(BitPaddedInt(b'\x00\x00\x00\x00'), 0)
def test_1(self):
self.assertEquals(BitPaddedInt(b'\x00\x00\x00\x01'), 1)
def test_1l(self):
self.assertEquals(BitPaddedInt(b'\x01\x00\x00\x00', bigendian=False), 1)
def test_129(self):
self.assertEquals(BitPaddedInt(b'\x00\x00\x01\x01'), 0x81)
def test_129b(self):
self.assertEquals(BitPaddedInt(b'\x00\x00\x01\x81'), 0x81)
def test_65(self):
self.assertEquals(BitPaddedInt(b'\x00\x00\x01\x81', 6), 0x41)
def test_32b(self):
self.assertEquals(BitPaddedInt(b'\xFF\xFF\xFF\xFF', bits=8),
0xFFFFFFFF)
def test_32bi(self):
self.assertEquals(BitPaddedInt(0xFFFFFFFF, bits=8), 0xFFFFFFFF)
def test_s32b(self):
self.assertEquals(BitPaddedInt(b'\xFF\xFF\xFF\xFF', bits=8).as_str(),
b'\xFF\xFF\xFF\xFF')
def test_s0(self):
self.assertEquals(BitPaddedInt.to_str(0), b'\x00\x00\x00\x00')
def test_s1(self):
self.assertEquals(BitPaddedInt.to_str(1), b'\x00\x00\x00\x01')
def test_s1l(self):
self.assertEquals(
BitPaddedInt.to_str(1, bigendian=False), b'\x01\x00\x00\x00')
def test_s129(self):
self.assertEquals(BitPaddedInt.to_str(129), b'\x00\x00\x01\x01')
def test_s65(self):
self.assertEquals(BitPaddedInt.to_str(0x41, 6), b'\x00\x00\x01\x01')
def test_w129(self):
self.assertEquals(BitPaddedInt.to_str(129, width=2), b'\x01\x01')
def test_w129l(self):
self.assertEquals(
BitPaddedInt.to_str(129, width=2, bigendian=False), b'\x01\x01')
def test_wsmall(self):
self.assertRaises(ValueError, BitPaddedInt.to_str, 129, width=1)
def test_str_int_init(self):
from struct import pack
self.assertEquals(BitPaddedInt(238).as_str(),
BitPaddedInt(pack('>L', 238)).as_str())
def test_varwidth(self):
self.assertEquals(len(BitPaddedInt.to_str(100)), 4)
self.assertEquals(len(BitPaddedInt.to_str(100, width=-1)), 4)
self.assertEquals(len(BitPaddedInt.to_str(2**32, width=-1)), 5)
def test_minwidth(self):
self.assertEquals(
len(BitPaddedInt.to_str(100, width=-1, minwidth=6)), 6)
def test_inval_input(self):
self.assertRaises(TypeError, BitPaddedInt, None)
if PY2:
def test_promote_long(self):
l = BitPaddedInt(sys.maxint ** 2)
self.assertTrue(isinstance(l, long))
self.assertEqual(BitPaddedInt(l.as_str(width=-1)), l)
def test_has_valid_padding(self):
self.failUnless(BitPaddedInt.has_valid_padding(b"\xff\xff", bits=8))
self.failIf(BitPaddedInt.has_valid_padding(b"\xff"))
self.failIf(BitPaddedInt.has_valid_padding(b"\x00\xff"))
self.failUnless(BitPaddedInt.has_valid_padding(b"\x7f\x7f"))
self.failIf(BitPaddedInt.has_valid_padding(b"\x7f", bits=6))
self.failIf(BitPaddedInt.has_valid_padding(b"\x9f", bits=6))
self.failUnless(BitPaddedInt.has_valid_padding(b"\x3f", bits=6))
self.failUnless(BitPaddedInt.has_valid_padding(0xff, bits=8))
self.failIf(BitPaddedInt.has_valid_padding(0xff))
self.failIf(BitPaddedInt.has_valid_padding(0xff << 8))
self.failUnless(BitPaddedInt.has_valid_padding(0x7f << 8))
self.failIf(BitPaddedInt.has_valid_padding(0x9f << 32, bits=6))
self.failUnless(BitPaddedInt.has_valid_padding(0x3f << 16, bits=6))
|
class BitPaddedIntTest(TestCase):
def test_zero(self):
pass
def test_1(self):
pass
def test_1l(self):
pass
def test_129(self):
pass
def test_129b(self):
pass
def test_65(self):
pass
def test_32b(self):
pass
def test_32bi(self):
pass
def test_s32b(self):
pass
def test_s0(self):
pass
def test_s1(self):
pass
def test_s1l(self):
pass
def test_s129(self):
pass
def test_s65(self):
pass
def test_w129(self):
pass
def test_w129l(self):
pass
def test_wsmall(self):
pass
def test_str_int_init(self):
pass
def test_varwidth(self):
pass
def test_minwidth(self):
pass
def test_inval_input(self):
pass
def test_promote_long(self):
pass
def test_has_valid_padding(self):
pass
| 24 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 3 | 1 | 0 | 23 | 0 | 23 | 98 | 95 | 24 | 71 | 26 | 46 | 0 | 65 | 26 | 40 | 1 | 3 | 1 | 23 |
147,002 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.TimeStampTextFrame
|
class TimeStampTextFrame(TestCase):
from mutagen.id3 import TimeStampTextFrame as Frame
Frame = Frame
def test_compare_to_unicode(self):
frame = self.Frame(encoding=0, text=[u'1987', u'1988'])
self.failUnlessEqual(frame, text_type(frame))
|
class TimeStampTextFrame(TestCase):
def test_compare_to_unicode(self):
pass
| 2 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 76 | 8 | 2 | 6 | 4 | 3 | 0 | 6 | 4 | 3 | 1 | 3 | 0 | 1 |
147,003 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.TimeStamp
|
class TimeStamp(TestCase):
from mutagen.id3 import ID3TimeStamp as Stamp
Stamp = Stamp
def test_Y(self):
s = self.Stamp('1234')
self.assertEquals(s.year, 1234)
self.assertEquals(s.text, '1234')
def test_yM(self):
s = self.Stamp('1234-56')
self.assertEquals(s.year, 1234)
self.assertEquals(s.month, 56)
self.assertEquals(s.text, '1234-56')
def test_ymD(self):
s = self.Stamp('1234-56-78')
self.assertEquals(s.year, 1234)
self.assertEquals(s.month, 56)
self.assertEquals(s.day, 78)
self.assertEquals(s.text, '1234-56-78')
def test_ymdH(self):
s = self.Stamp('1234-56-78T12')
self.assertEquals(s.year, 1234)
self.assertEquals(s.month, 56)
self.assertEquals(s.day, 78)
self.assertEquals(s.hour, 12)
self.assertEquals(s.text, '1234-56-78 12')
def test_ymdhM(self):
s = self.Stamp('1234-56-78T12:34')
self.assertEquals(s.year, 1234)
self.assertEquals(s.month, 56)
self.assertEquals(s.day, 78)
self.assertEquals(s.hour, 12)
self.assertEquals(s.minute, 34)
self.assertEquals(s.text, '1234-56-78 12:34')
def test_ymdhmS(self):
s = self.Stamp('1234-56-78T12:34:56')
self.assertEquals(s.year, 1234)
self.assertEquals(s.month, 56)
self.assertEquals(s.day, 78)
self.assertEquals(s.hour, 12)
self.assertEquals(s.minute, 34)
self.assertEquals(s.second, 56)
self.assertEquals(s.text, '1234-56-78 12:34:56')
def test_Ymdhms(self):
s = self.Stamp('1234-56-78T12:34:56')
s.month = None
self.assertEquals(s.text, '1234')
def test_alternate_reprs(self):
s = self.Stamp('1234-56.78 12:34:56')
self.assertEquals(s.text, '1234-56-78 12:34:56')
def test_order(self):
s = self.Stamp('1234')
t = self.Stamp('1233-12')
u = self.Stamp('1234-01')
self.assert_(t < s < u)
self.assert_(u > s > t)
|
class TimeStamp(TestCase):
def test_Y(self):
pass
def test_yM(self):
pass
def test_ymD(self):
pass
def test_ymdH(self):
pass
def test_ymdhM(self):
pass
def test_ymdhmS(self):
pass
def test_Ymdhms(self):
pass
def test_alternate_reprs(self):
pass
def test_order(self):
pass
| 10 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 9 | 0 | 9 | 84 | 66 | 11 | 55 | 22 | 44 | 0 | 55 | 22 | 44 | 1 | 3 | 0 | 9 |
147,004 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.TTextFrame
|
class TTextFrame(TestCase):
def test_list_iface(self):
from mutagen.id3 import TextFrame
frame = TextFrame()
frame.append("a")
frame.extend(["b", "c"])
self.assertEqual(frame.text, ["a", "b", "c"])
|
class TTextFrame(TestCase):
def test_list_iface(self):
pass
| 2 | 0 | 7 | 1 | 6 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 76 | 9 | 2 | 7 | 4 | 4 | 0 | 7 | 4 | 4 | 1 | 3 | 0 | 1 |
147,005 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.TRVA2
|
class TRVA2(TestCase):
def test_basic(self):
from mutagen.id3 import RVA2
r = RVA2(gain=1, channel=1, peak=1)
self.assertEqual(r, r)
self.assertNotEqual(r, 42)
|
class TRVA2(TestCase):
def test_basic(self):
pass
| 2 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 76 | 7 | 1 | 6 | 4 | 3 | 0 | 6 | 4 | 3 | 1 | 3 | 0 | 1 |
147,006 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.NoHashFrame
|
class NoHashFrame(TestCase):
def test_frame(self):
from mutagen.id3 import TIT1
self.failUnlessRaises(
TypeError, {}.__setitem__, TIT1(encoding=0, text="foo"), None)
|
class NoHashFrame(TestCase):
def test_frame(self):
pass
| 2 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 1 | 0 | 1 | 76 | 6 | 1 | 5 | 3 | 2 | 0 | 4 | 3 | 1 | 1 | 3 | 0 | 1 |
147,007 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.Genres
|
class Genres(TestCase):
from mutagen.id3 import TCON
TCON = TCON
from mutagen._constants import GENRES
GENRES = GENRES
def _g(self, s): return self.TCON(encoding=0, text=s).genres
def test_empty(self): self.assertEquals(self._g(""), [])
def test_num(self):
for i in range(len(self.GENRES)):
self.assertEquals(self._g("%02d" % i), [self.GENRES[i]])
def test_parened_num(self):
for i in range(len(self.GENRES)):
self.assertEquals(self._g("(%02d)" % i), [self.GENRES[i]])
def test_unknown(self):
self.assertEquals(self._g("(255)"), ["Unknown"])
self.assertEquals(self._g("199"), ["Unknown"])
self.assertNotEqual(self._g("256"), ["Unknown"])
def test_parened_multi(self):
self.assertEquals(self._g("(00)(02)"), ["Blues", "Country"])
def test_coverremix(self):
self.assertEquals(self._g("CR"), ["Cover"])
self.assertEquals(self._g("(CR)"), ["Cover"])
self.assertEquals(self._g("RX"), ["Remix"])
self.assertEquals(self._g("(RX)"), ["Remix"])
def test_parened_text(self):
self.assertEquals(
self._g("(00)(02)Real Folk Blues"),
["Blues", "Country", "Real Folk Blues"])
def test_escape(self):
self.assertEquals(self._g("(0)((A genre)"), ["Blues", "(A genre)"])
self.assertEquals(self._g("(10)((20)"), ["New Age", "(20)"])
def test_nullsep(self):
self.assertEquals(self._g("0\x00A genre"), ["Blues", "A genre"])
def test_nullsep_empty(self):
self.assertEquals(self._g("\x000\x00A genre"), ["Blues", "A genre"])
def test_crazy(self):
self.assertEquals(
self._g("(20)(CR)\x0030\x00\x00Another\x00(51)Hooray"),
['Alternative', 'Cover', 'Fusion', 'Another',
'Techno-Industrial', 'Hooray'])
def test_repeat(self):
self.assertEquals(self._g("(20)Alternative"), ["Alternative"])
self.assertEquals(
self._g("(20)\x00Alternative"), ["Alternative", "Alternative"])
def test_set_genre(self):
gen = self.TCON(encoding=0, text="")
self.assertEquals(gen.genres, [])
gen.genres = ["a genre", "another"]
self.assertEquals(gen.genres, ["a genre", "another"])
def test_set_string(self):
gen = self.TCON(encoding=0, text="")
gen.genres = "foo"
self.assertEquals(gen.genres, ["foo"])
def test_nodoubledecode(self):
gen = self.TCON(encoding=1, text=u"(255)genre")
gen.genres = gen.genres
self.assertEquals(gen.genres, [u"Unknown", u"genre"])
|
class Genres(TestCase):
def _g(self, s):
pass
def test_empty(self):
pass
def test_num(self):
pass
def test_parened_num(self):
pass
def test_unknown(self):
pass
def test_parened_multi(self):
pass
def test_coverremix(self):
pass
def test_parened_text(self):
pass
def test_escape(self):
pass
def test_nullsep(self):
pass
def test_nullsep_empty(self):
pass
def test_crazy(self):
pass
def test_repeat(self):
pass
def test_set_genre(self):
pass
def test_set_string(self):
pass
def test_nodoubledecode(self):
pass
| 17 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 16 | 0 | 16 | 91 | 74 | 17 | 57 | 24 | 40 | 0 | 53 | 24 | 34 | 2 | 3 | 1 | 18 |
147,008 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.FrameSanityChecks
|
class FrameSanityChecks(TestCase):
def test_TF(self):
from mutagen.id3 import TextFrame
self.assert_(isinstance(TextFrame(encoding=0, text='text'), TextFrame))
def test_UF(self):
from mutagen.id3 import UrlFrame
self.assert_(isinstance(UrlFrame('url'), UrlFrame))
def test_WXXX(self):
from mutagen.id3 import WXXX
self.assert_(isinstance(WXXX(url='durl'), WXXX))
def test_NTF(self):
from mutagen.id3 import NumericTextFrame
self.assert_(isinstance(NumericTextFrame(encoding=0, text='1'), NumericTextFrame))
def test_NTPF(self):
from mutagen.id3 import NumericPartTextFrame
self.assert_(
isinstance(NumericPartTextFrame(encoding=0, text='1/2'), NumericPartTextFrame))
def test_MTF(self):
from mutagen.id3 import TextFrame
self.assert_(isinstance(TextFrame(encoding=0, text=['a','b']), TextFrame))
def test_TXXX(self):
from mutagen.id3 import TXXX
self.assert_(isinstance(TXXX(encoding=0, desc='d',text='text'), TXXX))
def test_22_uses_direct_ints(self):
data = b'TT1\x00\x00\x83\x00' + (b'123456789abcdef' * 16)
tag = list(_22._ID3__read_frames(data, Frames_2_2))[0]
self.assertEquals(data[7:7+0x82].decode('latin1'), tag.text[0])
def test_frame_too_small(self):
self.assertEquals([], list(_24._ID3__read_frames(b'012345678', Frames)))
self.assertEquals([], list(_23._ID3__read_frames(b'012345678', Frames)))
self.assertEquals([], list(_22._ID3__read_frames(b'01234', Frames_2_2)))
self.assertEquals(
[], list(_22._ID3__read_frames(b'TT1'+b'\x00'*3, Frames_2_2)))
def test_unknown_22_frame(self):
data = b'XYZ\x00\x00\x01\x00'
self.assertEquals([data], list(_22._ID3__read_frames(data, {})))
def test_zlib_latin1(self):
from mutagen.id3 import TPE1
tag = TPE1.fromData(_24, 0x9, b'\x00\x00\x00\x0f'
b'x\x9cc(\xc9\xc8,V\x00\xa2D\xfd\x92\xd4\xe2\x12\x00&\x7f\x05%')
self.assertEquals(tag.encoding, 0)
self.assertEquals(tag, ['this is a/test'])
def test_datalen_but_not_compressed(self):
from mutagen.id3 import TPE1
tag = TPE1.fromData(_24, 0x01, b'\x00\x00\x00\x06\x00A test')
self.assertEquals(tag.encoding, 0)
self.assertEquals(tag, ['A test'])
def test_utf8(self):
from mutagen.id3 import TPE1
tag = TPE1.fromData(_23, 0x00, b'\x03this is a test')
self.assertEquals(tag.encoding, 3)
self.assertEquals(tag, 'this is a test')
def test_zlib_utf16(self):
from mutagen.id3 import TPE1
data = (b'\x00\x00\x00\x1fx\x9cc\xfc\xff\xaf\x84!\x83!\x93\xa1\x98A'
b'\x01J&2\xe83\x940\xa4\x02\xd9%\x0c\x00\x87\xc6\x07#')
tag = TPE1.fromData(_23, 0x80, data)
self.assertEquals(tag.encoding, 1)
self.assertEquals(tag, ['this is a/test'])
tag = TPE1.fromData(_24, 0x08, data)
self.assertEquals(tag.encoding, 1)
self.assertEquals(tag, ['this is a/test'])
def test_load_write(self):
from mutagen.id3 import TPE1, Frames
artists= [s.decode('utf8') for s in
[b'\xc2\xb5', b'\xe6\x97\xa5\xe6\x9c\xac']]
artist = TPE1(encoding=3, text=artists)
id3 = ID3()
tag = list(id3._ID3__read_frames(
id3._ID3__save_frame(artist), Frames))[0]
self.assertEquals('TPE1', type(tag).__name__)
self.assertEquals(artist.text, tag.text)
def test_22_to_24(self):
from mutagen.id3 import TT1
id3 = ID3()
tt1 = TT1(encoding=0, text=u'whatcha staring at?')
id3.loaded_frame(tt1)
tit1 = id3['TIT1']
self.assertEquals(tt1.encoding, tit1.encoding)
self.assertEquals(tt1.text, tit1.text)
self.assert_('TT1' not in id3)
def test_single_TXYZ(self):
from mutagen.id3 import TIT2
self.assertEquals(TIT2(encoding=0, text="a").HashKey, TIT2(encoding=0, text="b").HashKey)
def test_multi_TXXX(self):
from mutagen.id3 import TXXX
self.assertEquals(TXXX(encoding=0, text="a").HashKey, TXXX(encoding=0, text="b").HashKey)
self.assertNotEquals(TXXX(encoding=0, desc="a").HashKey, TXXX(encoding=0, desc="b").HashKey)
def test_multi_WXXX(self):
from mutagen.id3 import WXXX
self.assertEquals(WXXX(encoding=0, text="a").HashKey, WXXX(encoding=0, text="b").HashKey)
self.assertNotEquals(WXXX(encoding=0, desc="a").HashKey, WXXX(encoding=0, desc="b").HashKey)
def test_multi_COMM(self):
from mutagen.id3 import COMM
self.assertEquals(COMM(encoding=0, text="a").HashKey, COMM(encoding=0, text="b").HashKey)
self.assertNotEquals(COMM(encoding=0, desc="a").HashKey, COMM(encoding=0, desc="b").HashKey)
self.assertNotEquals(
COMM(lang="abc").HashKey, COMM(lang="def").HashKey)
def test_multi_RVA2(self):
from mutagen.id3 import RVA2
self.assertEquals(RVA2(gain=1).HashKey, RVA2(gain=2).HashKey)
self.assertNotEquals(RVA2(desc="a").HashKey, RVA2(desc="b").HashKey)
def test_multi_APIC(self):
from mutagen.id3 import APIC
self.assertEquals(APIC(data=b'1').HashKey, APIC(data=b'2').HashKey)
self.assertNotEquals(APIC(encoding=0, desc="a").HashKey, APIC(encoding=0, desc="b").HashKey)
def test_multi_POPM(self):
from mutagen.id3 import POPM
self.assertEquals(POPM(count=1).HashKey, POPM(count=2).HashKey)
self.assertNotEquals(POPM(email="a").HashKey, POPM(email="b").HashKey)
def test_multi_GEOB(self):
from mutagen.id3 import GEOB
self.assertEquals(GEOB(data=b'1').HashKey, GEOB(data=b'2').HashKey)
self.assertNotEquals(GEOB(encoding=0, desc="a").HashKey, GEOB(encoding=0, desc="b").HashKey)
def test_multi_UFID(self):
from mutagen.id3 import UFID
self.assertEquals(UFID(data=b'1').HashKey, UFID(data=b'2').HashKey)
self.assertNotEquals(UFID(owner="a").HashKey, UFID(owner="b").HashKey)
def test_multi_USER(self):
from mutagen.id3 import USER
self.assertEquals(USER(encoding=0, text="a").HashKey, USER(encoding=0, text="b").HashKey)
self.assertNotEquals(
USER(lang="abc").HashKey, USER(lang="def").HashKey)
|
class FrameSanityChecks(TestCase):
def test_TF(self):
pass
def test_UF(self):
pass
def test_WXXX(self):
pass
def test_NTF(self):
pass
def test_NTPF(self):
pass
def test_MTF(self):
pass
def test_TXXX(self):
pass
def test_22_uses_direct_ints(self):
pass
def test_frame_too_small(self):
pass
def test_unknown_22_frame(self):
pass
def test_zlib_latin1(self):
pass
def test_datalen_but_not_compressed(self):
pass
def test_utf8(self):
pass
def test_zlib_utf16(self):
pass
def test_load_write(self):
pass
def test_22_to_24(self):
pass
def test_single_TXYZ(self):
pass
def test_multi_TXXX(self):
pass
def test_multi_WXXX(self):
pass
def test_multi_COMM(self):
pass
def test_multi_RVA2(self):
pass
def test_multi_APIC(self):
pass
def test_multi_POPM(self):
pass
def test_multi_GEOB(self):
pass
def test_multi_UFID(self):
pass
def test_multi_USER(self):
pass
| 27 | 0 | 5 | 0 | 5 | 0 | 1 | 0.01 | 1 | 19 | 17 | 0 | 26 | 0 | 26 | 101 | 152 | 29 | 123 | 65 | 73 | 1 | 115 | 65 | 65 | 1 | 3 | 0 | 26 |
147,009 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TSOP
|
class TSOP(TextFrame):
"Perfomer Sort Order key"
|
class TSOP(TextFrame):
'''Perfomer Sort Order key'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 21 | 2 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 | 3 | 0 | 0 |
147,010 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TXXX
|
class TXXX(TextFrame):
"""User-defined text data.
TXXX frames have a 'desc' attribute which is set to any Unicode
value (though the encoding of the text and the description must be
the same). Many taggers use this frame to store freeform keys.
"""
_framespec = [
EncodingSpec('encoding'),
EncodedTextSpec('desc'),
MultiSpec('text', EncodedTextSpec('text'), sep=u'\u0000'),
]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.desc)
def _pprint(self):
return "%s=%s" % (self.desc, " / ".join(self.text))
|
class TXXX(TextFrame):
'''User-defined text data.
TXXX frames have a 'desc' attribute which is set to any Unicode
value (though the encoding of the text and the description must be
the same). Many taggers use this frame to store freeform keys.
'''
@property
def HashKey(self):
pass
def _pprint(self):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.45 | 1 | 0 | 0 | 1 | 2 | 0 | 2 | 23 | 20 | 4 | 11 | 5 | 7 | 5 | 6 | 4 | 3 | 1 | 3 | 0 | 2 |
147,011 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TextFrame
|
class TextFrame(Frame):
"""Text strings.
Text frames support casts to unicode or str objects, as well as
list-like indexing, extend, and append.
Iterating over a TextFrame iterates over its strings, not its
characters.
Text frames have a 'text' attribute which is the list of strings,
and an 'encoding' attribute; 0 for ISO-8859 1, 1 UTF-16, 2 for
UTF-16BE, and 3 for UTF-8. If you don't want to worry about
encodings, just set it to 3.
"""
_framespec = [
EncodingSpec('encoding'),
MultiSpec('text', EncodedTextSpec('text'), sep=u'\u0000'),
]
def __bytes__(self):
return text_type(self).encode('utf-8')
def __str__(self):
return u'\u0000'.join(self.text)
def __eq__(self, other):
if isinstance(other, bytes):
return bytes(self) == other
elif isinstance(other, text_type):
return text_type(self) == other
return self.text == other
__hash__ = Frame.__hash__
def __getitem__(self, item):
return self.text[item]
def __iter__(self):
return iter(self.text)
def append(self, value):
"""Append a string."""
return self.text.append(value)
def extend(self, value):
"""Extend the list by appending all strings from the given list."""
return self.text.extend(value)
def _pprint(self):
return " / ".join(self.text)
|
class TextFrame(Frame):
'''Text strings.
Text frames support casts to unicode or str objects, as well as
list-like indexing, extend, and append.
Iterating over a TextFrame iterates over its strings, not its
characters.
Text frames have a 'text' attribute which is the list of strings,
and an 'encoding' attribute; 0 for ISO-8859 1, 1 UTF-16, 2 for
UTF-16BE, and 3 for UTF-8. If you don't want to worry about
encodings, just set it to 3.
'''
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
def __getitem__(self, item):
pass
def __iter__(self):
pass
def append(self, value):
'''Append a string.'''
pass
def extend(self, value):
'''Extend the list by appending all strings from the given list.'''
pass
def _pprint(self):
pass
| 9 | 3 | 3 | 0 | 3 | 0 | 1 | 0.46 | 1 | 1 | 0 | 45 | 8 | 0 | 8 | 21 | 53 | 15 | 26 | 11 | 17 | 12 | 22 | 11 | 13 | 3 | 2 | 1 | 10 |
147,012 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TimeStampTextFrame
|
class TimeStampTextFrame(TextFrame):
"""A list of time stamps.
The 'text' attribute in this frame is a list of ID3TimeStamp
objects, not a list of strings.
"""
_framespec = [
EncodingSpec('encoding'),
MultiSpec('text', TimeStampSpec('stamp'), sep=u','),
]
def __bytes__(self):
return text_type(self).encode('utf-8')
def __str__(self):
return u','.join([stamp.text for stamp in self.text])
def _pprint(self):
return u" / ".join([stamp.text for stamp in self.text])
|
class TimeStampTextFrame(TextFrame):
'''A list of time stamps.
The 'text' attribute in this frame is a list of ID3TimeStamp
objects, not a list of strings.
'''
def __bytes__(self):
pass
def __str__(self):
pass
def _pprint(self):
pass
| 4 | 1 | 2 | 0 | 2 | 0 | 1 | 0.36 | 1 | 0 | 0 | 5 | 3 | 0 | 3 | 24 | 20 | 5 | 11 | 5 | 7 | 4 | 8 | 5 | 4 | 1 | 3 | 0 | 3 |
147,013 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.UFID
|
class UFID(Frame):
"""Unique file identifier.
Attributes:
* owner -- format/type of identifier
* data -- identifier
"""
_framespec = [
Latin1TextSpec('owner'),
BinaryDataSpec('data'),
]
@property
def HashKey(self):
return '%s:%s' % (self.FrameID, self.owner)
def __eq__(s, o):
if isinstance(o, UFI):
return s.owner == o.owner and s.data == o.data
else:
return s.data == o
__hash__ = Frame.__hash__
def _pprint(self):
isascii = ord_(max(self.data)) < 128
if isascii:
return "%s=%s" % (self.owner, self.data)
else:
return "%s (%d bytes)" % (self.owner, len(self.data))
|
class UFID(Frame):
'''Unique file identifier.
Attributes:
* owner -- format/type of identifier
* data -- identifier
'''
@property
def HashKey(self):
pass
def __eq__(s, o):
pass
def _pprint(self):
pass
| 5 | 1 | 4 | 0 | 4 | 0 | 2 | 0.25 | 1 | 1 | 1 | 1 | 3 | 0 | 3 | 16 | 32 | 7 | 20 | 8 | 15 | 5 | 14 | 7 | 10 | 2 | 2 | 1 | 5 |
147,014 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.ULT
|
class ULT(USLT):
"Unsychronised lyrics/text transcription"
|
class ULT(USLT):
'''Unsychronised lyrics/text transcription'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 17 | 2 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 | 3 | 0 | 0 |
147,015 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__id3frames.py
|
tests.test__id3frames.FrameIDValidate
|
class FrameIDValidate(TestCase):
def test_valid(self):
from mutagen.id3 import is_valid_frame_id
self.failUnless(is_valid_frame_id("APIC"))
self.failUnless(is_valid_frame_id("TPE2"))
def test_invalid(self):
from mutagen.id3 import is_valid_frame_id
self.failIf(is_valid_frame_id("MP3e"))
self.failIf(is_valid_frame_id("+ABC"))
|
class FrameIDValidate(TestCase):
def test_valid(self):
pass
def test_invalid(self):
pass
| 3 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 77 | 11 | 2 | 9 | 5 | 4 | 0 | 9 | 5 | 4 | 1 | 3 | 0 | 2 |
147,016 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TModuleImportAll
|
class TModuleImportAll(TestCase):
def test_all(self):
import mutagen
files = os.listdir(mutagen.__path__[0])
modules = [os.path.splitext(f)[0] for f in files]
modules = [f for f in modules if not f.startswith("_")]
for module in modules:
mod = getattr(__import__("mutagen." + module), module)
for attr in getattr(mod, "__all__", []):
getattr(mod, attr)
|
class TModuleImportAll(TestCase):
def test_all(self):
pass
| 2 | 0 | 10 | 1 | 9 | 0 | 3 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 76 | 12 | 2 | 10 | 8 | 7 | 0 | 10 | 8 | 7 | 3 | 3 | 2 | 3 |
147,017 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TMetadata
|
class TMetadata(TestCase):
class FakeMeta(Metadata):
def __init__(self): pass
def test_virtual_constructor(self):
self.failUnlessRaises(NotImplementedError, Metadata, "filename")
def test_load(self):
m = Metadata()
self.failUnlessRaises(NotImplementedError, m.load, "filename")
def test_virtual_save(self):
self.failUnlessRaises(NotImplementedError, self.FakeMeta().save)
self.failUnlessRaises(
NotImplementedError, self.FakeMeta().save, "filename")
def test_virtual_delete(self):
self.failUnlessRaises(NotImplementedError, self.FakeMeta().delete)
self.failUnlessRaises(
NotImplementedError, self.FakeMeta().delete, "filename")
|
class TMetadata(TestCase):
class FakeMeta(Metadata):
def __init__(self):
pass
def test_virtual_constructor(self):
pass
def test_load(self):
pass
def test_virtual_save(self):
pass
def test_virtual_delete(self):
pass
| 7 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 3 | 2 | 0 | 4 | 0 | 4 | 79 | 21 | 5 | 16 | 8 | 10 | 0 | 15 | 8 | 8 | 1 | 3 | 0 | 5 |
147,018 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TFileUpperExt
|
class TFileUpperExt(TestCase):
FILES = [(os.path.join(b"tests", b"data", b"empty.ofr"), OptimFROG),
(os.path.join(b"tests", b"data", b"sv5_header.mpc"), Musepack),
(os.path.join(b"tests", b"data", b"silence-3.wma"), ASF),
(os.path.join(b"tests", b"data", b"truncated-64bit.mp4"), MP4),
(os.path.join(b"tests", b"data", b"silence-44-s.flac"), FLAC),
]
def setUp(self):
checks = []
for (original, instance) in self.FILES:
ext = os.path.splitext(original)[1]
suffix = ext.decode('ascii').upper()
fd, filename = mkstemp(suffix=suffix)
os.close(fd)
shutil.copy(original, filename)
checks.append((filename, instance))
self.checks = checks
def test_case_insensitive_ext(self):
for (path, instance) in self.checks:
if isinstance(path, bytes):
path = path.decode("ascii")
self.failUnless(
isinstance(File(path, options=[instance]), instance))
path = path.encode("ascii")
self.failUnless(
isinstance(File(path, options=[instance]), instance))
def tearDown(self):
for (path, instance) in self.checks:
os.unlink(path)
|
class TFileUpperExt(TestCase):
def setUp(self):
pass
def test_case_insensitive_ext(self):
pass
def tearDown(self):
pass
| 4 | 0 | 7 | 0 | 7 | 0 | 2 | 0 | 1 | 1 | 0 | 0 | 3 | 1 | 3 | 78 | 32 | 3 | 29 | 13 | 25 | 0 | 22 | 13 | 18 | 3 | 3 | 2 | 7 |
147,019 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TFileType
|
class TFileType(TestCase):
def setUp(self):
self.vorbis = File(os.path.join("tests", "data", "empty.ogg"))
def test_delitem_not_there(self):
self.failUnlessRaises(KeyError, self.vorbis.__delitem__, "foobar")
def test_add_tags(self):
self.failUnlessRaises(NotImplementedError, FileType().add_tags)
def test_delitem(self):
self.vorbis["foobar"] = "quux"
del(self.vorbis["foobar"])
self.failIf("quux" in self.vorbis)
|
class TFileType(TestCase):
def setUp(self):
pass
def test_delitem_not_there(self):
pass
def test_add_tags(self):
pass
def test_delitem_not_there(self):
pass
| 5 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 3 | 1 | 0 | 4 | 1 | 4 | 79 | 15 | 4 | 11 | 6 | 6 | 0 | 11 | 6 | 6 | 1 | 3 | 0 | 4 |
147,020 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFFile
|
class TASFFile(TestCase):
def test_not_my_file(self):
self.failUnlessRaises(
ASFHeaderError, ASF,
os.path.join("tests", "data", "empty.ogg"))
self.failUnlessRaises(
ASFHeaderError, ASF,
os.path.join("tests", "data", "click.mpc"))
|
class TASFFile(TestCase):
def test_not_my_file(self):
pass
| 2 | 0 | 7 | 0 | 7 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 1 | 0 | 1 | 76 | 9 | 1 | 8 | 2 | 6 | 0 | 4 | 2 | 2 | 1 | 3 | 0 | 1 |
147,021 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASF
|
class TASF(TestCase):
def setUp(self):
fd, self.filename = mkstemp(suffix='wma')
os.close(fd)
shutil.copy(self.original, self.filename)
self.audio = ASF(self.filename)
def tearDown(self):
os.unlink(self.filename)
def test_pprint(self):
self.failUnless(self.audio.pprint())
def set_key(self, key, value, result=None, expected=True):
self.audio[key] = value
self.audio.save()
self.audio = ASF(self.audio.filename)
self.failUnless(key in self.audio)
self.failUnless(key in self.audio.tags)
self.failUnless(key in self.audio.tags.keys())
self.failUnless(key in self.audio.tags.as_dict().keys())
newvalue = self.audio[key]
if isinstance(newvalue, list):
for a, b in zip(sorted(newvalue), sorted(result or value)):
self.failUnlessEqual(a, b)
else:
self.failUnlessEqual(self.audio[key], result or value)
def test_contains(self):
self.failUnlessEqual("notatag" in self.audio.tags, False)
def test_inval_type(self):
self.failUnlessRaises(ValueError, ASFValue, "", 4242)
def test_repr(self):
repr(ASFValue(u"foo", UNICODE, stream=1, language=2))
def test_auto_guuid(self):
value = ASFValue(b'\x9eZl}\x89\xa2\xb5D\xb8\xa30\xfe', GUID)
self.set_key(u"WM/WMCollectionGroupID", value, [value])
def test_auto_unicode(self):
self.set_key(u"WM/AlbumTitle", u"foo",
[ASFValue(u"foo", UNICODE)])
def test_auto_unicode_list(self):
self.set_key(u"WM/AlbumTitle", [u"foo", u"bar"],
[ASFValue(u"foo", UNICODE), ASFValue(u"bar", UNICODE)])
def test_word(self):
self.set_key(u"WM/Track", ASFValue(24, WORD), [ASFValue(24, WORD)])
def test_auto_word(self):
self.set_key(u"WM/Track", 12,
[ASFValue(12, DWORD)])
def test_auto_word_list(self):
self.set_key(u"WM/Track", [12, 13],
[ASFValue(12, WORD), ASFValue(13, WORD)])
def test_auto_dword(self):
self.set_key(u"WM/Track", 12,
[ASFValue(12, DWORD)])
def test_auto_dword_list(self):
self.set_key(u"WM/Track", [12, 13],
[ASFValue(12, DWORD), ASFValue(13, DWORD)])
def test_auto_qword(self):
self.set_key(u"WM/Track", 12,
[ASFValue(12, QWORD)])
def test_auto_qword_list(self):
self.set_key(u"WM/Track", [12, 13],
[ASFValue(12, QWORD), ASFValue(13, QWORD)])
def test_auto_bool(self):
self.set_key(u"IsVBR", True,
[ASFValue(True, BOOL)])
def test_auto_bool_list(self):
self.set_key(u"IsVBR", [True, False],
[ASFValue(True, BOOL), ASFValue(False, BOOL)])
def test_basic_tags(self):
self.set_key("Title", "Wheeee", ["Wheeee"])
self.set_key("Author", "Whoooo", ["Whoooo"])
self.set_key("Copyright", "Whaaaa", ["Whaaaa"])
self.set_key("Description", "Wii", ["Wii"])
self.set_key("Rating", "5", ["5"])
def test_stream(self):
self.audio["QL/OneHasStream"] = [
ASFValue("Whee", UNICODE, stream=2),
ASFValue("Whee", UNICODE),
]
self.audio["QL/AllHaveStream"] = [
ASFValue("Whee", UNICODE, stream=1),
ASFValue("Whee", UNICODE, stream=2),
]
self.audio["QL/NoStream"] = ASFValue("Whee", UNICODE)
self.audio.save()
self.audio = ASF(self.audio.filename)
self.failUnlessEqual(self.audio["QL/NoStream"][0].stream, None)
self.failUnlessEqual(self.audio["QL/OneHasStream"][0].stream, 2)
self.failUnlessEqual(self.audio["QL/OneHasStream"][1].stream, None)
self.failUnlessEqual(self.audio["QL/AllHaveStream"][0].stream, 1)
self.failUnlessEqual(self.audio["QL/AllHaveStream"][1].stream, 2)
def test_language(self):
self.failIf("QL/OneHasLang" in self.audio)
self.failIf("QL/AllHaveLang" in self.audio)
self.audio["QL/OneHasLang"] = [
ASFValue("Whee", UNICODE, language=2),
ASFValue("Whee", UNICODE),
]
self.audio["QL/AllHaveLang"] = [
ASFValue("Whee", UNICODE, language=1),
ASFValue("Whee", UNICODE, language=2),
]
self.audio["QL/NoLang"] = ASFValue("Whee", UNICODE)
self.audio.save()
self.audio = ASF(self.audio.filename)
self.failUnlessEqual(self.audio["QL/NoLang"][0].language, None)
self.failUnlessEqual(self.audio["QL/OneHasLang"][0].language, 2)
self.failUnlessEqual(self.audio["QL/OneHasLang"][1].language, None)
self.failUnlessEqual(self.audio["QL/AllHaveLang"][0].language, 1)
self.failUnlessEqual(self.audio["QL/AllHaveLang"][1].language, 2)
def test_lang_and_stream_mix(self):
self.audio["QL/Mix"] = [
ASFValue("Whee", UNICODE, stream=1),
ASFValue("Whee", UNICODE, language=2),
ASFValue("Whee", UNICODE, stream=3, language=4),
ASFValue("Whee", UNICODE),
]
self.audio.save()
self.audio = ASF(self.audio.filename)
self.failUnlessEqual(self.audio["QL/Mix"][0].language, None)
self.failUnlessEqual(self.audio["QL/Mix"][0].stream, 1)
self.failUnlessEqual(self.audio["QL/Mix"][1].language, 2)
self.failUnlessEqual(self.audio["QL/Mix"][1].stream, 0)
self.failUnlessEqual(self.audio["QL/Mix"][2].language, 4)
self.failUnlessEqual(self.audio["QL/Mix"][2].stream, 3)
self.failUnlessEqual(self.audio["QL/Mix"][3].language, None)
self.failUnlessEqual(self.audio["QL/Mix"][3].stream, None)
def test_data_size(self):
v = ASFValue("", UNICODE, data=b'4\xd8\x1e\xdd\x00\x00')
self.failUnlessEqual(v.data_size(), len(v._render()))
|
class TASF(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_pprint(self):
pass
def set_key(self, key, value, result=None, expected=True):
pass
def test_contains(self):
pass
def test_inval_type(self):
pass
def test_repr(self):
pass
def test_auto_guuid(self):
pass
def test_auto_unicode(self):
pass
def test_auto_unicode_list(self):
pass
def test_word(self):
pass
def test_auto_word(self):
pass
def test_auto_word_list(self):
pass
def test_auto_dword(self):
pass
def test_auto_dword_list(self):
pass
def test_auto_qword(self):
pass
def test_auto_qword_list(self):
pass
def test_auto_bool(self):
pass
def test_auto_bool_list(self):
pass
def test_basic_tags(self):
pass
def test_stream(self):
pass
def test_language(self):
pass
def test_lang_and_stream_mix(self):
pass
def test_data_size(self):
pass
| 25 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 4 | 1 | 3 | 24 | 2 | 24 | 99 | 151 | 24 | 127 | 31 | 102 | 0 | 99 | 31 | 74 | 3 | 3 | 2 | 26 |
147,022 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.Tis_valid_apev2_key
|
class Tis_valid_apev2_key(TestCase):
def test_yes(self):
for key in ["foo", "Foo", " f ~~~"]:
self.failUnless(is_valid_apev2_key(key))
def test_no(self):
for key in ["\x11hi", "ffoo\xFF", u"\u1234", "a", "", "foo" * 100]:
self.failIf(is_valid_apev2_key(key))
if PY3:
def test_py3(self):
self.assertRaises(TypeError, is_valid_apev2_key, b"abc")
|
class Tis_valid_apev2_key(TestCase):
def test_yes(self):
pass
def test_no(self):
pass
def test_py3(self):
pass
| 4 | 0 | 3 | 0 | 3 | 0 | 2 | 0 | 1 | 1 | 0 | 0 | 3 | 0 | 3 | 78 | 13 | 3 | 10 | 6 | 6 | 0 | 10 | 6 | 6 | 2 | 3 | 1 | 5 |
147,023 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEv2WithLyrics2
|
class TAPEv2WithLyrics2(TestCase):
def setUp(self):
self.tag = mutagen.apev2.APEv2(LYRICS2)
def test_values(self):
self.failUnlessEqual(self.tag["MP3GAIN_MINMAX"], "000,179")
self.failUnlessEqual(self.tag["REPLAYGAIN_TRACK_GAIN"], "-4.080000 dB")
self.failUnlessEqual(self.tag["REPLAYGAIN_TRACK_PEAK"], "1.008101")
|
class TAPEv2WithLyrics2(TestCase):
def setUp(self):
pass
def test_values(self):
pass
| 3 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 2 | 1 | 2 | 77 | 9 | 2 | 7 | 4 | 4 | 0 | 7 | 4 | 4 | 1 | 3 | 0 | 2 |
147,024 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEExtValue
|
class TAPEExtValue(TestCase):
from mutagen.apev2 import APEExtValue as EV
EV = EV
def setUp(self):
self.sample = "http://foo"
self.value = mutagen.apev2.APEValue(
self.sample, mutagen.apev2.EXTERNAL)
def test_type(self):
self.failUnless(isinstance(self.value, self.EV))
def test_const(self):
self.failUnlessEqual(self.sample, self.value)
def test_repr(self):
repr(self.value)
if PY3:
def test_py3(self):
self.assertRaises(
TypeError, mutagen.apev2.APEValue, b"abc",
mutagen.apev2.EXTERNAL)
def test_pprint(self):
self.value.pprint()
|
class TAPEExtValue(TestCase):
def setUp(self):
pass
def test_type(self):
pass
def test_const(self):
pass
def test_repr(self):
pass
def test_py3(self):
pass
def test_pprint(self):
pass
| 7 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 6 | 2 | 6 | 81 | 27 | 7 | 20 | 10 | 12 | 0 | 17 | 10 | 9 | 1 | 3 | 1 | 6 |
147,025 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEBinaryValue
|
class TAPEBinaryValue(TestCase):
from mutagen.apev2 import APEBinaryValue as BV
BV = BV
def setUp(self):
self.sample = b"\x12\x45\xde"
self.value = mutagen.apev2.APEValue(self.sample,mutagen.apev2.BINARY)
def test_type(self):
self.failUnless(isinstance(self.value, self.BV))
def test_const(self):
self.failUnlessEqual(self.sample, bytes(self.value))
def test_repr(self):
repr(self.value)
def test_pprint(self):
self.value.pprint()
def test_type(self):
self.assertRaises(TypeError,
mutagen.apev2.APEValue, u"abc", mutagen.apev2.BINARY)
|
class TAPEBinaryValue(TestCase):
def setUp(self):
pass
def test_type(self):
pass
def test_const(self):
pass
def test_repr(self):
pass
def test_pprint(self):
pass
def test_type(self):
pass
| 7 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 2 | 0 | 0 | 6 | 2 | 6 | 81 | 24 | 7 | 17 | 10 | 9 | 0 | 16 | 10 | 8 | 1 | 3 | 0 | 6 |
147,026 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_aiff.py
|
tests.test_aiff.TIFFFile
|
class TIFFFile(TestCase):
has_tags = os.path.join(b'tests', b'data', b'with-id3.aif')
no_tags = os.path.join(b'tests', b'data', b'8k-1ch-1s-silence.aif')
def setUp(self):
self.file_1 = open(self.has_tags, 'rb')
self.iff_1 = IFFFile(self.file_1)
self.file_2 = open(self.no_tags, 'rb')
self.iff_2 = IFFFile(self.file_2)
fd_1, tmp_1_name = mkstemp(suffix='.aif')
shutil.copy(self.has_tags, tmp_1_name)
self.file_1_tmp = open(tmp_1_name, 'rb+')
self.iff_1_tmp = IFFFile(self.file_1_tmp)
fd_2, tmp_2_name = mkstemp(suffix='.aif')
shutil.copy(self.no_tags, tmp_2_name)
self.file_2_tmp = open(tmp_2_name, 'rb+')
self.iff_2_tmp = IFFFile(self.file_2_tmp)
def test_has_chunks(self):
self.failUnless(u'FORM' in self.iff_1)
self.failUnless(u'COMM' in self.iff_1)
self.failUnless(u'SSND' in self.iff_1)
self.failUnless(u'ID3' in self.iff_1)
self.failUnless(u'FORM' in self.iff_2)
self.failUnless(u'COMM' in self.iff_2)
self.failUnless(u'SSND' in self.iff_2)
def test_is_chunks(self):
self.failUnless(isinstance(self.iff_1[u'FORM'], IFFChunk))
self.failUnless(isinstance(self.iff_1[u'COMM'], IFFChunk))
self.failUnless(isinstance(self.iff_1[u'SSND'], IFFChunk))
self.failUnless(isinstance(self.iff_1[u'ID3'], IFFChunk))
def test_chunk_size(self):
self.failUnlessEqual(self.iff_1[u'FORM'].size, 17096)
self.failUnlessEqual(self.iff_2[u'FORM'].size, 16054)
def test_chunk_data_size(self):
self.failUnlessEqual(self.iff_1[u'FORM'].data_size, 17088)
self.failUnlessEqual(self.iff_2[u'FORM'].data_size, 16046)
def test_FORM_chunk_resize(self):
self.iff_1_tmp[u'FORM'].resize(17000)
self.failUnlessEqual(IFFFile(self.file_1_tmp)[u'FORM'].data_size, 17000)
self.iff_2_tmp[u'FORM'].resize(0)
self.failUnlessEqual(IFFFile(self.file_2_tmp)[u'FORM'].data_size, 0)
def test_child_chunk_resize(self):
self.iff_1_tmp['ID3'].resize(128)
self.failUnlessEqual(IFFFile(self.file_1_tmp)['ID3'].data_size, 128)
self.failUnlessEqual(IFFFile(self.file_1_tmp)['FORM'].data_size, 16182)
def test_chunk_delete(self):
del self.iff_1_tmp['ID3']
self.failIf('ID3' in self.iff_1_tmp)
self.failIf('ID3' in IFFFile(self.file_1_tmp))
self.failUnlessEqual(IFFFile(self.file_1_tmp)['FORM'].size, 16054)
del self.iff_2_tmp['SSND']
self.failIf('SSND' in self.iff_2_tmp)
self.failIf('SSND' in IFFFile(self.file_2_tmp))
self.failUnlessEqual(IFFFile(self.file_2_tmp)['FORM'].size, 38)
def test_insert_chunk(self):
self.iff_2_tmp.insert_chunk('ID3')
new_iff = IFFFile(self.file_2_tmp)
self.failUnless('ID3' in new_iff)
self.failUnless(isinstance(new_iff['ID3'], IFFChunk))
self.failUnlessEqual(new_iff['FORM'].size, 16062)
self.failUnlessEqual(new_iff['FORM'].data_size, 16054)
self.failUnlessEqual(new_iff['ID3'].size, 8)
self.failUnlessEqual(new_iff['ID3'].data_size, 0)
def tearDown(self):
self.file_1.close()
self.file_2.close()
self.file_1_tmp.close()
self.file_2_tmp.close()
|
class TIFFFile(TestCase):
def setUp(self):
pass
def test_has_chunks(self):
pass
def test_is_chunks(self):
pass
def test_chunk_size(self):
pass
def test_chunk_data_size(self):
pass
def test_FORM_chunk_resize(self):
pass
def test_child_chunk_resize(self):
pass
def test_chunk_delete(self):
pass
def test_insert_chunk(self):
pass
def tearDown(self):
pass
| 11 | 0 | 7 | 0 | 6 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 10 | 8 | 10 | 85 | 81 | 14 | 67 | 24 | 56 | 0 | 67 | 24 | 56 | 1 | 3 | 0 | 10 |
147,027 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_aiff.py
|
tests.test_aiff.TAIFFInfo
|
class TAIFFInfo(TestCase):
def test_empty(self):
fileobj = cBytesIO(b"")
self.failUnlessRaises(IOError, AIFFInfo, fileobj)
|
class TAIFFInfo(TestCase):
def test_empty(self):
pass
| 2 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 76 | 5 | 1 | 4 | 3 | 2 | 0 | 4 | 3 | 2 | 1 | 3 | 0 | 1 |
147,028 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_aiff.py
|
tests.test_aiff.TAIFF
|
class TAIFF(TestCase):
silence_1 = os.path.join(b'tests', b'data', b'11k-1ch-2s-silence.aif')
silence_2 = os.path.join(b'tests', b'data', b'48k-2ch-s16-silence.aif')
silence_3 = os.path.join(b'tests', b'data', b'8k-1ch-1s-silence.aif')
silence_4 = os.path.join(b'tests', b'data', b'8k-1ch-3.5s-silence.aif')
silence_5 = os.path.join(b'tests', b'data', b'8k-4ch-1s-silence.aif')
has_tags = os.path.join(b'tests', b'data', b'with-id3.aif')
no_tags = os.path.join(b'tests', b'data', b'8k-1ch-1s-silence.aif')
def setUp(self):
fd, self.filename_1 = mkstemp(suffix='.aif')
os.close(fd)
shutil.copy(self.has_tags, self.filename_1)
fd, self.filename_2 = mkstemp(suffix='.aif')
os.close(fd)
shutil.copy(self.no_tags, self.filename_2)
self.aiff_tmp_id3 = AIFF(self.filename_1)
self.aiff_tmp_no_id3 = AIFF(self.filename_2)
self.aiff_1 = AIFF(self.silence_1)
self.aiff_2 = AIFF(self.silence_2)
self.aiff_3 = AIFF(self.silence_3)
self.aiff_4 = AIFF(self.silence_4)
self.aiff_5 = AIFF(self.silence_5)
def test_channels(self):
self.failUnlessEqual(self.aiff_1.info.channels, 1)
self.failUnlessEqual(self.aiff_2.info.channels, 2)
self.failUnlessEqual(self.aiff_3.info.channels, 1)
self.failUnlessEqual(self.aiff_4.info.channels, 1)
self.failUnlessEqual(self.aiff_5.info.channels, 4)
def test_length(self):
self.failUnlessEqual(self.aiff_1.info.length, 2)
self.failUnlessEqual(self.aiff_2.info.length, 0.1)
self.failUnlessEqual(self.aiff_3.info.length, 1)
self.failUnlessEqual(self.aiff_4.info.length, 3.5)
self.failUnlessEqual(self.aiff_5.info.length, 1)
def test_bitrate(self):
self.failUnlessEqual(self.aiff_1.info.bitrate, 176400)
self.failUnlessEqual(self.aiff_2.info.bitrate, 1536000)
self.failUnlessEqual(self.aiff_3.info.bitrate, 128000)
self.failUnlessEqual(self.aiff_4.info.bitrate, 128000)
self.failUnlessEqual(self.aiff_5.info.bitrate, 512000)
def test_sample_rate(self):
self.failUnlessEqual(self.aiff_1.info.sample_rate, 11025)
self.failUnlessEqual(self.aiff_2.info.sample_rate, 48000)
self.failUnlessEqual(self.aiff_3.info.sample_rate, 8000)
self.failUnlessEqual(self.aiff_4.info.sample_rate, 8000)
self.failUnlessEqual(self.aiff_5.info.sample_rate, 8000)
def test_sample_size(self):
self.failUnlessEqual(self.aiff_1.info.sample_size, 16)
self.failUnlessEqual(self.aiff_2.info.sample_size, 16)
self.failUnlessEqual(self.aiff_3.info.sample_size, 16)
self.failUnlessEqual(self.aiff_4.info.sample_size, 16)
self.failUnlessEqual(self.aiff_5.info.sample_size, 16)
def test_notaiff(self):
self.failUnlessRaises(
AIFFError, AIFF, os.path.join('tests', 'data', 'empty.ofr'))
def test_pprint(self):
self.failUnless(self.aiff_1.pprint())
self.failUnless(self.aiff_tmp_id3.pprint())
def test_delete(self):
self.aiff_tmp_id3.delete()
self.failIf(self.aiff_tmp_id3.tags)
self.failUnless(AIFF(self.filename_1).tags is None)
def test_module_delete(self):
delete(self.filename_1)
self.failUnless(AIFF(self.filename_1).tags is None)
def test_module_double_delete(self):
delete(self.filename_1)
delete(self.filename_1)
def test_pprint_no_tags(self):
self.aiff_tmp_id3.tags = None
self.failUnless(self.aiff_tmp_id3.pprint())
def test_save_no_tags(self):
self.aiff_tmp_id3.tags = None
self.failUnlessRaises(ValueError, self.aiff_tmp_id3.save)
def test_add_tags_already_there(self):
self.failUnless(self.aiff_tmp_id3.tags)
self.failUnlessRaises(Exception, self.aiff_tmp_id3.add_tags)
def test_mime(self):
self.failUnless("audio/aiff" in self.aiff_1.mime)
self.failUnless("audio/x-aiff" in self.aiff_1.mime)
def test_loaded_tags(self):
self.failUnless(self.aiff_tmp_id3["TIT2"] == "AIFF title")
def test_roundtrip(self):
self.failUnlessEqual(self.aiff_tmp_id3["TIT2"], ["AIFF title"])
self.aiff_tmp_id3.save()
new = AIFF(self.aiff_tmp_id3.filename)
self.failUnlessEqual(new["TIT2"], ["AIFF title"])
def test_save_tags(self):
from mutagen._id3frames import TIT1
tags = self.aiff_tmp_id3.tags
tags.add(TIT1(encoding=3, text="foobar"))
tags.save()
new = AIFF(self.aiff_tmp_id3.filename)
self.failUnlessEqual(new["TIT1"], ["foobar"])
def test_save_with_ID3_chunk(self):
from mutagen._id3frames import TIT1
self.aiff_tmp_id3["TIT1"] = TIT1(encoding=3, text="foobar")
self.aiff_tmp_id3.save()
self.failUnless(AIFF(self.filename_1)["TIT1"] == "foobar")
self.failUnless(self.aiff_tmp_id3["TIT2"] == "AIFF title")
def test_save_without_ID3_chunk(self):
from mutagen._id3frames import TIT1
self.aiff_tmp_no_id3["TIT1"] = TIT1(encoding=3, text="foobar")
self.aiff_tmp_no_id3.save()
self.failUnless(AIFF(self.filename_2)["TIT1"] == "foobar")
def tearDown(self):
os.unlink(self.filename_1)
os.unlink(self.filename_2)
|
class TAIFF(TestCase):
def setUp(self):
pass
def test_channels(self):
pass
def test_length(self):
pass
def test_bitrate(self):
pass
def test_sample_rate(self):
pass
def test_sample_size(self):
pass
def test_notaiff(self):
pass
def test_pprint(self):
pass
def test_delete(self):
pass
def test_module_delete(self):
pass
def test_module_double_delete(self):
pass
def test_pprint_no_tags(self):
pass
def test_save_no_tags(self):
pass
def test_add_tags_already_there(self):
pass
def test_mime(self):
pass
def test_loaded_tags(self):
pass
def test_roundtrip(self):
pass
def test_save_tags(self):
pass
def test_save_with_ID3_chunk(self):
pass
def test_save_without_ID3_chunk(self):
pass
def tearDown(self):
pass
| 22 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 4 | 2 | 0 | 21 | 9 | 21 | 96 | 134 | 26 | 108 | 44 | 83 | 0 | 107 | 44 | 82 | 1 | 3 | 0 | 21 |
147,029 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__vorbis.py
|
tests.test__vorbis.Tistag
|
class Tistag(TestCase):
def test_empty(self):
self.failIf(istag(""))
def test_tilde(self):
self.failIf(istag("ti~tle"))
def test_equals(self):
self.failIf(istag("ti=tle"))
def test_less(self):
self.failIf(istag("ti\x19tle"))
def test_greater(self):
self.failIf(istag("ti\xa0tle"))
def test_simple(self):
self.failUnless(istag("title"))
def test_space(self):
self.failUnless(istag("ti tle"))
def test_ugly(self):
self.failUnless(istag("!{}[]-_()*&"))
def test_unicode(self):
self.failUnless(istag(u"ti tle"))
if PY3:
def test_py3(self):
self.failUnlessRaises(ValueError, istag, b"abc")
|
class Tistag(TestCase):
def test_empty(self):
pass
def test_tilde(self):
pass
def test_equals(self):
pass
def test_less(self):
pass
def test_greater(self):
pass
def test_simple(self):
pass
def test_space(self):
pass
def test_ugly(self):
pass
def test_unicode(self):
pass
def test_py3(self):
pass
| 11 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 10 | 0 | 10 | 85 | 32 | 10 | 22 | 11 | 11 | 0 | 22 | 11 | 11 | 1 | 3 | 1 | 10 |
147,030 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__vorbis.py
|
tests.test__vorbis.TVCommentDict
|
class TVCommentDict(TestCase):
Kind = VCommentDict
def setUp(self):
self.c = self.Kind()
self.c["artist"] = ["mu", "piman"]
self.c["title"] = u"more fakes"
def test_correct_len(self):
self.failUnlessEqual(len(self.c), 3)
def test_keys(self):
self.failUnless("artist" in self.c.keys())
self.failUnless("title" in self.c.keys())
def test_values(self):
self.failUnless(["mu", "piman"] in self.c.values())
self.failUnless(["more fakes"] in self.c.values())
def test_items(self):
self.failUnless(("artist", ["mu", "piman"]) in self.c.items())
self.failUnless(("title", ["more fakes"]) in self.c.items())
def test_equal(self):
self.failUnlessEqual(self.c, self.c)
def test_get(self):
self.failUnlessEqual(self.c["artist"], ["mu", "piman"])
self.failUnlessEqual(self.c["title"], ["more fakes"])
def test_set(self):
self.c["woo"] = "bar"
self.failUnlessEqual(self.c["woo"], ["bar"])
def test_del(self):
del(self.c["title"])
self.failUnlessRaises(KeyError, self.c.__getitem__, "title")
def test_contains(self):
self.failIf("foo" in self.c)
self.failUnless("title" in self.c)
def test_get_case(self):
self.failUnlessEqual(self.c["ARTIST"], ["mu", "piman"])
def test_set_case(self):
self.c["TITLE"] = "another fake"
self.failUnlessEqual(self.c["title"], ["another fake"])
def test_set_preserve_case(self):
del(self.c["title"])
self.c["TiTlE"] = "blah"
self.failUnless(("TiTlE", "blah") in list(self.c._internal))
self.failUnless("title" in self.c)
def test_contains_case(self):
self.failUnless("TITLE" in self.c)
def test_del_case(self):
del(self.c["TITLE"])
self.failUnlessRaises(KeyError, self.c.__getitem__, "title")
def test_get_failure(self):
self.failUnlessRaises(KeyError, self.c.__getitem__, "woo")
def test_del_failure(self):
self.failUnlessRaises(KeyError, self.c.__delitem__, "woo")
def test_roundtrip(self):
self.failUnlessEqual(self.c, self.Kind(self.c.write()))
def test_roundtrip_vc(self):
self.failUnlessEqual(self.c, VComment(self.c.write()))
def test_case_items_426(self):
self.c.append(("WOO", "bar"))
self.failUnless(("woo", ["bar"]) in self.c.items())
def test_empty(self):
self.c = self.Kind()
self.failIf(list(self.c.keys()))
self.failIf(list(self.c.values()))
self.failIf(list(self.c.items()))
def test_as_dict(self):
d = self.c.as_dict()
self.failUnless("artist" in d)
self.failUnless("title" in d)
self.failUnlessEqual(d["artist"], self.c["artist"])
self.failUnlessEqual(d["title"], self.c["title"])
def test_bad_key(self):
self.failUnlessRaises(ValueError, self.c.get, u"\u1234")
self.failUnlessRaises(
ValueError, self.c.__setitem__, u"\u1234", "foo")
self.failUnlessRaises(
ValueError, self.c.__delitem__, u"\u1234")
if PY3:
def test_py3_bad_key(self):
self.failUnlessRaises(ValueError, self.c.get, b"a")
self.failUnlessRaises(
ValueError, self.c.__setitem__, b"a", "foo")
self.failUnlessRaises(
ValueError, self.c.__delitem__, b"a")
def test_duplicate_keys(self):
self.c = self.Kind()
keys = ("key", "Key", "KEY")
for key in keys:
self.c.append((key, "value"))
self.failUnlessEqual(len(list(self.c.keys())), 1)
self.failUnlessEqual(len(self.c.as_dict()), 1)
|
class TVCommentDict(TestCase):
def setUp(self):
pass
def test_correct_len(self):
pass
def test_keys(self):
pass
def test_values(self):
pass
def test_items(self):
pass
def test_equal(self):
pass
def test_get(self):
pass
def test_set(self):
pass
def test_del(self):
pass
def test_contains(self):
pass
def test_get_case(self):
pass
def test_set_case(self):
pass
def test_set_preserve_case(self):
pass
def test_contains_case(self):
pass
def test_del_case(self):
pass
def test_get_failure(self):
pass
def test_del_failure(self):
pass
def test_roundtrip(self):
pass
def test_roundtrip_vc(self):
pass
def test_case_items_426(self):
pass
def test_empty(self):
pass
def test_as_dict(self):
pass
def test_bad_key(self):
pass
def test_py3_bad_key(self):
pass
def test_duplicate_keys(self):
pass
| 26 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 4 | 1 | 0 | 25 | 1 | 25 | 100 | 115 | 27 | 88 | 31 | 62 | 0 | 84 | 31 | 58 | 2 | 3 | 1 | 26 |
147,031 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__vorbis.py
|
tests.test__vorbis.TVComment
|
class TVComment(TestCase):
Kind = VComment
def setUp(self):
self.c = VComment()
self.c.append(("artist", u"piman"))
self.c.append(("artist", u"mu"))
self.c.append(("title", u"more fakes"))
def test_invalid_init(self):
self.failUnlessRaises(TypeError, VComment, [])
def test_equal(self):
self.failUnlessEqual(self.c, self.c)
def test_not_header(self):
self.failUnlessRaises(IOError, VComment, b"foo")
def test_unset_framing_bit(self):
self.failUnlessRaises(
IOError, VComment, b"\x00\x00\x00\x00" * 2 + b"\x00")
def test_empty_valid(self):
self.failIf(VComment(b"\x00\x00\x00\x00" * 2 + b"\x01"))
def test_validate(self):
self.failUnless(self.c.validate())
def test_validate_broken_key(self):
self.c.append((1, u"valid"))
self.failUnlessRaises(ValueError, self.c.validate)
self.failUnlessRaises(ValueError, self.c.write)
def test_validate_broken_value(self):
self.c.append((u"valid", 1))
self.failUnlessRaises(ValueError, self.c.validate)
self.failUnlessRaises(ValueError, self.c.write)
def test_validate_nonunicode_value(self):
self.c.append((u"valid", b"wt\xff"))
self.failUnlessRaises(ValueError, self.c.validate)
self.failUnlessRaises(ValueError, self.c.write)
def test_vendor_default(self):
self.failUnless(self.c.vendor.startswith(u"Mutagen"))
def test_vendor_set(self):
self.c.vendor = u"Not Mutagen"
self.failUnless(self.c.write()[4:].startswith(b"Not Mutagen"))
def test_vendor_invalid(self):
self.c.vendor = b"\xffNot Mutagen"
self.failUnlessRaises(ValueError, self.c.validate)
self.failUnlessRaises(ValueError, self.c.write)
def test_invalid_format_strict(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x03\x00\x00'
b'\x00abc\x01')
self.failUnlessRaises(IOError, VComment, data, errors='strict')
def test_invalid_format_replace(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x03\x00\x00'
b'\x00abc\x01')
comment = VComment(data)
self.failUnlessEqual(u"abc", comment[0][1])
def test_python_key_value_type(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x03\x00\x00'
b'\x00abc\x01')
comment = VComment(data)
self.assertTrue(isinstance(comment[0][0], type('')))
self.assertTrue(isinstance(comment[0][1], text_type))
if PY3:
def test_python3_strict_str(self):
comment = VComment()
comment.append((u"abc", u"test"))
comment.validate()
comment[0] = (u"abc", b"test")
self.failUnlessRaises(ValueError, comment.validate)
comment[0] = (b"abc", u"test")
self.failUnlessRaises(ValueError, comment.validate)
def test_invalid_format_ignore(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x03\x00\x00'
b'\x00abc\x01')
comment = VComment(data, errors='ignore')
self.failIf(len(comment))
# Slightly different test data than above, we want the tag name
# to be valid UTF-8 but not valid ASCII.
def test_invalid_tag_strict(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x04\x00\x00'
b'\x00\xc2\xaa=c\x01')
self.failUnlessRaises(IOError, VComment, data, errors='strict')
def test_invalid_tag_replace(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x04\x00\x00'
b'\x00\xc2\xaa=c\x01')
comment = VComment(data)
self.failUnlessEqual(u"?=c", comment.pprint())
def test_invalid_tag_ignore(self):
data = (b'\x07\x00\x00\x00Mutagen\x01\x00\x00\x00\x04\x00\x00'
b'\x00\xc2\xaa=c\x01')
comment = VComment(data, errors='ignore')
self.failIf(len(comment))
def test_roundtrip(self):
self.assertReallyEqual(self.c, VComment(self.c.write()))
|
class TVComment(TestCase):
def setUp(self):
pass
def test_invalid_init(self):
pass
def test_equal(self):
pass
def test_not_header(self):
pass
def test_unset_framing_bit(self):
pass
def test_empty_valid(self):
pass
def test_validate(self):
pass
def test_validate_broken_key(self):
pass
def test_validate_broken_value(self):
pass
def test_validate_nonunicode_value(self):
pass
def test_vendor_default(self):
pass
def test_vendor_set(self):
pass
def test_vendor_invalid(self):
pass
def test_invalid_format_strict(self):
pass
def test_invalid_format_replace(self):
pass
def test_python_key_value_type(self):
pass
def test_python3_strict_str(self):
pass
def test_invalid_format_ignore(self):
pass
def test_invalid_tag_strict(self):
pass
def test_invalid_tag_replace(self):
pass
def test_invalid_tag_ignore(self):
pass
def test_roundtrip(self):
pass
| 23 | 0 | 4 | 0 | 4 | 0 | 1 | 0.02 | 1 | 4 | 1 | 1 | 22 | 1 | 22 | 97 | 110 | 22 | 86 | 38 | 63 | 2 | 78 | 38 | 55 | 1 | 3 | 1 | 22 |
147,032 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__util.py
|
tests.test__util.Tutf8
|
class Tutf8(TestCase):
def test_str(self):
value = utf8(b"1234")
self.failUnlessEqual(value, b"1234")
self.failUnless(isinstance(value, bytes))
def test_bad_str(self):
value = utf8(b"\xab\xde")
# Two '?' symbols.
self.failUnlessEqual(value, b"\xef\xbf\xbd\xef\xbf\xbd")
self.failUnless(isinstance(value, bytes))
def test_low_unicode(self):
value = utf8(u"1234")
self.failUnlessEqual(value, b"1234")
self.failUnless(isinstance(value, bytes))
def test_high_unicode(self):
value = utf8(u"\u1234")
self.failUnlessEqual(value, b'\xe1\x88\xb4')
self.failUnless(isinstance(value, bytes))
def test_invalid(self):
self.failUnlessRaises(TypeError, utf8, 1234)
|
class Tutf8(TestCase):
def test_str(self):
pass
def test_bad_str(self):
pass
def test_low_unicode(self):
pass
def test_high_unicode(self):
pass
def test_invalid(self):
pass
| 6 | 0 | 4 | 0 | 4 | 0 | 1 | 0.05 | 1 | 2 | 0 | 0 | 5 | 0 | 5 | 80 | 25 | 5 | 19 | 10 | 13 | 1 | 19 | 10 | 13 | 1 | 3 | 0 | 5 |
147,033 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggtheora.py
|
mutagen.oggtheora.OggTheoraCommentDict
|
class OggTheoraCommentDict(VCommentDict):
"""Theora comments embedded in an Ogg bitstream."""
def __init__(self, fileobj, info):
pages = []
complete = False
while not complete:
page = OggPage(fileobj)
if page.serial == info.serial:
pages.append(page)
complete = page.complete or (len(page.packets) > 1)
data = OggPage.to_packets(pages)[0][7:]
super(OggTheoraCommentDict, self).__init__(data + b"\x01")
def _inject(self, fileobj):
"""Write tag data into the Theora comment packet/page."""
fileobj.seek(0)
page = OggPage(fileobj)
while not page.packets[0].startswith(b"\x81theora"):
page = OggPage(fileobj)
old_pages = [page]
while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
page = OggPage(fileobj)
if page.serial == old_pages[0].serial:
old_pages.append(page)
packets = OggPage.to_packets(old_pages, strict=False)
packets[0] = b"\x81theora" + self.write(framing=False)
new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
OggPage.replace(fileobj, old_pages, new_pages)
|
class OggTheoraCommentDict(VCommentDict):
'''Theora comments embedded in an Ogg bitstream.'''
def __init__(self, fileobj, info):
pass
def _inject(self, fileobj):
'''Write tag data into the Theora comment packet/page.'''
pass
| 3 | 2 | 15 | 3 | 12 | 1 | 4 | 0.08 | 1 | 2 | 1 | 0 | 2 | 0 | 2 | 25 | 34 | 7 | 25 | 11 | 22 | 2 | 25 | 11 | 22 | 4 | 2 | 2 | 7 |
147,034 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggtheora.py
|
mutagen.oggtheora.OggTheoraInfo
|
class OggTheoraInfo(StreamInfo):
"""Ogg Theora stream information.
Attributes:
* length - file length in seconds, as a float
* fps - video frames per second, as a float
"""
length = 0
def __init__(self, fileobj):
page = OggPage(fileobj)
while not page.packets[0].startswith(b"\x80theora"):
page = OggPage(fileobj)
if not page.first:
raise OggTheoraHeaderError(
"page has ID header, but doesn't start a stream")
data = page.packets[0]
vmaj, vmin = struct.unpack("2B", data[7:9])
if (vmaj, vmin) != (3, 2):
raise OggTheoraHeaderError(
"found Theora version %d.%d != 3.2" % (vmaj, vmin))
fps_num, fps_den = struct.unpack(">2I", data[22:30])
self.fps = fps_num / float(fps_den)
self.bitrate = cdata.uint_be(b"\x00" + data[37:40])
self.granule_shift = (cdata.ushort_be(data[40:42]) >> 5) & 0x1F
self.serial = page.serial
def _post_tags(self, fileobj):
page = OggPage.find_last(fileobj, self.serial)
position = page.position
mask = (1 << self.granule_shift) - 1
frames = (position >> self.granule_shift) + (position & mask)
self.length = frames / float(self.fps)
def pprint(self):
return "Ogg Theora, %.2f seconds, %d bps" % (self.length, self.bitrate)
|
class OggTheoraInfo(StreamInfo):
'''Ogg Theora stream information.
Attributes:
* length - file length in seconds, as a float
* fps - video frames per second, as a float
'''
def __init__(self, fileobj):
pass
def _post_tags(self, fileobj):
pass
def pprint(self):
pass
| 4 | 1 | 8 | 0 | 8 | 0 | 2 | 0.19 | 1 | 4 | 3 | 0 | 3 | 4 | 3 | 4 | 38 | 6 | 27 | 17 | 23 | 5 | 25 | 17 | 21 | 4 | 2 | 1 | 6 |
147,035 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggvorbis.py
|
mutagen.oggvorbis.OggVCommentDict
|
class OggVCommentDict(VCommentDict):
"""Vorbis comments embedded in an Ogg bitstream."""
def __init__(self, fileobj, info):
pages = []
complete = False
while not complete:
page = OggPage(fileobj)
if page.serial == info.serial:
pages.append(page)
complete = page.complete or (len(page.packets) > 1)
data = OggPage.to_packets(pages)[0][7:] # Strip off "\x03vorbis".
super(OggVCommentDict, self).__init__(data)
def _inject(self, fileobj):
"""Write tag data into the Vorbis comment packet/page."""
# Find the old pages in the file; we'll need to remove them,
# plus grab any stray setup packet data out of them.
fileobj.seek(0)
page = OggPage(fileobj)
while not page.packets[0].startswith(b"\x03vorbis"):
page = OggPage(fileobj)
old_pages = [page]
while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
page = OggPage(fileobj)
if page.serial == old_pages[0].serial:
old_pages.append(page)
packets = OggPage.to_packets(old_pages, strict=False)
# Set the new comment packet.
packets[0] = b"\x03vorbis" + self.write()
new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
OggPage.replace(fileobj, old_pages, new_pages)
|
class OggVCommentDict(VCommentDict):
'''Vorbis comments embedded in an Ogg bitstream.'''
def __init__(self, fileobj, info):
pass
def _inject(self, fileobj):
'''Write tag data into the Vorbis comment packet/page.'''
pass
| 3 | 2 | 17 | 3 | 12 | 3 | 4 | 0.24 | 1 | 2 | 1 | 0 | 2 | 0 | 2 | 25 | 37 | 7 | 25 | 11 | 22 | 6 | 25 | 11 | 22 | 4 | 2 | 2 | 7 |
147,036 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TFile
|
class TFile(TestCase):
def test_bad(self):
try: self.failUnless(File(devnull) is None)
except (OSError, IOError):
print("WARNING: Unable to open %s." % devnull)
self.failUnless(File(__file__) is None)
def test_empty(self):
filename = os.path.join("tests", "data", "empty")
open(filename, "wb").close()
try: self.failUnless(File(filename) is None)
finally: os.unlink(filename)
def test_not_file(self):
self.failUnlessRaises(EnvironmentError, File, "/dev/doesnotexist")
def test_no_options(self):
for filename in ["empty.ogg", "empty.oggflac", "silence-44-s.mp3"]:
filename = os.path.join("tests", "data", "empty.ogg")
self.failIf(File(filename, options=[]))
def test_oggvorbis(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.ogg")), OggVorbis))
def test_oggflac(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.oggflac")), OggFLAC))
def test_oggspeex(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.spx")), OggSpeex))
def test_oggtheora(self):
self.failUnless(isinstance(File(
os.path.join("tests", "data", "sample.oggtheora")), OggTheora))
def test_oggopus(self):
self.failUnless(isinstance(File(
os.path.join("tests", "data", "example.opus")), OggOpus))
def test_mp3(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "bad-xing.mp3")), MP3))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "xing.mp3")), MP3))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-44-s.mp3")), MP3))
def test_easy_mp3(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-44-s.mp3"), easy=True),
EasyMP3))
def test_flac(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-44-s.flac")), FLAC))
def test_musepack(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "click.mpc")), Musepack))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "sv4_header.mpc")), Musepack))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "sv5_header.mpc")), Musepack))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "sv8_header.mpc")), Musepack))
def test_monkeysaudio(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "mac-399.ape")), MonkeysAudio))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "mac-396.ape")), MonkeysAudio))
def test_apev2(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "oldtag.apev2")), APEv2File))
def test_tta(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.tta")), TrueAudio))
def test_easy_tta(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.tta"), easy=True),
EasyTrueAudio))
def test_wavpack(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-44-s.wv")), WavPack))
def test_mp4(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "has-tags.m4a")), MP4))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "no-tags.m4a")), MP4))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "no-tags.3g2")), MP4))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "truncated-64bit.mp4")), MP4))
def test_optimfrog(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.ofr")), OptimFROG))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "empty.ofs")), OptimFROG))
def test_asf(self):
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-1.wma")), ASF))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-2.wma")), ASF))
self.failUnless(isinstance(
File(os.path.join("tests", "data", "silence-3.wma")), ASF))
def test_aiff(self):
data_path = os.path.join("tests", "data")
self.failUnless(isinstance(
File(os.path.join(data_path, "with-id3.aif")), AIFF))
self.failUnless(isinstance(
File(os.path.join(data_path, "11k-1ch-2s-silence.aif")), AIFF))
self.failUnless(isinstance(
File(os.path.join(data_path, "48k-2ch-s16-silence.aif")), AIFF))
self.failUnless(isinstance(
File(os.path.join(data_path, "8k-1ch-1s-silence.aif")), AIFF))
self.failUnless(isinstance(
File(os.path.join(data_path, "8k-1ch-3.5s-silence.aif")), AIFF))
self.failUnless(isinstance(
File(os.path.join(data_path, "8k-4ch-1s-silence.aif")), AIFF))
def test_id3_indicates_mp3_not_tta(self):
header = b"ID3 the rest of this is garbage"
fileobj = cBytesIO(header)
filename = "not-identifiable.ext"
self.failUnless(TrueAudio.score(filename, fileobj, header) <
MP3.score(filename, fileobj, header))
|
class TFile(TestCase):
def test_bad(self):
pass
def test_empty(self):
pass
def test_not_file(self):
pass
def test_no_options(self):
pass
def test_oggvorbis(self):
pass
def test_oggflac(self):
pass
def test_oggspeex(self):
pass
def test_oggtheora(self):
pass
def test_oggopus(self):
pass
def test_mp3(self):
pass
def test_easy_mp3(self):
pass
def test_flac(self):
pass
def test_musepack(self):
pass
def test_monkeysaudio(self):
pass
def test_apev2(self):
pass
def test_tta(self):
pass
def test_easy_tta(self):
pass
def test_wavpack(self):
pass
def test_mp4(self):
pass
def test_optimfrog(self):
pass
def test_asf(self):
pass
def test_aiff(self):
pass
def test_id3_indicates_mp3_not_tta(self):
pass
| 24 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 19 | 18 | 0 | 23 | 0 | 23 | 98 | 137 | 23 | 114 | 30 | 90 | 0 | 78 | 30 | 54 | 2 | 3 | 1 | 25 |
147,037 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggvorbis.py
|
mutagen.oggvorbis.OggVorbis
|
class OggVorbis(OggFileType):
"""An Ogg Vorbis file."""
_Info = OggVorbisInfo
_Tags = OggVCommentDict
_Error = OggVorbisHeaderError
_mimes = ["audio/vorbis", "audio/x-vorbis"]
@staticmethod
def score(filename, fileobj, header):
return (header.startswith(b"OggS") * (b"\x01vorbis" in header))
|
class OggVorbis(OggFileType):
'''An Ogg Vorbis file.'''
@staticmethod
def score(filename, fileobj, header):
pass
| 3 | 1 | 2 | 0 | 2 | 0 | 1 | 0.13 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 17 | 11 | 2 | 8 | 7 | 5 | 1 | 7 | 6 | 5 | 1 | 3 | 0 | 1 |
147,038 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test__util.py
|
tests.test__util.Tdecode_terminated
|
class Tdecode_terminated(TestCase):
def test_all(self):
values = [u"", u"", u"\xe4", u"abc", u"", u""]
for codec in ["utf8", "utf-8", "utf-16", "latin-1", "utf-16be"]:
# NULL without the BOM
term = u"\x00".encode(codec)[-2:]
data = b"".join(v.encode(codec) + term for v in values)
for v in values:
dec, data = decode_terminated(data, codec)
self.assertEqual(dec, v)
self.assertEqual(data, b"")
def test_invalid(self):
# invalid
self.assertRaises(
UnicodeDecodeError, decode_terminated, b"\xff", "utf-8")
# truncated
self.assertRaises(
UnicodeDecodeError, decode_terminated, b"\xff\xfe\x00", "utf-16")
# not null terminated
self.assertRaises(ValueError, decode_terminated, b"abc", "utf-8")
# invalid encoding
self.assertRaises(LookupError, decode_terminated, b"abc", "foobar")
def test_lax(self):
# missing termination
self.assertEqual(
decode_terminated(b"abc", "utf-8", strict=False), (u"abc", b""))
# missing termination and truncated data
truncated = u"\xe4\xe4".encode("utf-8")[:-1]
self.assertRaises(
UnicodeDecodeError, decode_terminated,
truncated, "utf-8", strict=False)
|
class Tdecode_terminated(TestCase):
def test_all(self):
pass
def test_invalid(self):
pass
def test_lax(self):
pass
| 4 | 0 | 11 | 1 | 8 | 2 | 2 | 0.29 | 1 | 3 | 0 | 0 | 3 | 0 | 3 | 78 | 37 | 6 | 24 | 10 | 20 | 7 | 19 | 10 | 15 | 3 | 3 | 2 | 5 |
147,039 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/optimfrog.py
|
mutagen.optimfrog.OptimFROG
|
class OptimFROG(APEv2File):
_Info = OptimFROGInfo
@staticmethod
def score(filename, fileobj, header):
filename = filename.lower()
return (header.startswith(b"OFR") + endswith(filename, b".ofr") +
endswith(filename, b".ofs"))
|
class OptimFROG(APEv2File):
@staticmethod
def score(filename, fileobj, header):
pass
| 3 | 0 | 5 | 1 | 4 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 17 | 9 | 2 | 7 | 4 | 4 | 0 | 5 | 3 | 3 | 1 | 3 | 0 | 1 |
147,040 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/optimfrog.py
|
mutagen.optimfrog.OptimFROGInfo
|
class OptimFROGInfo(StreamInfo):
"""OptimFROG stream information.
Attributes:
* channels - number of audio channels
* length - file length in seconds, as a float
* sample_rate - audio sampling rate in Hz
"""
def __init__(self, fileobj):
header = fileobj.read(76)
if (len(header) != 76 or not header.startswith(b"OFR ") or
struct.unpack("<I", header[4:8])[0] not in [12, 15]):
raise OptimFROGHeaderError("not an OptimFROG file")
(total_samples, total_samples_high, sample_type, self.channels,
self.sample_rate) = struct.unpack("<IHBBI", header[8:20])
total_samples += total_samples_high << 32
self.channels += 1
if self.sample_rate:
self.length = float(total_samples) / (self.channels *
self.sample_rate)
else:
self.length = 0.0
def pprint(self):
return "OptimFROG, %.2f seconds, %d Hz" % (self.length,
self.sample_rate)
|
class OptimFROGInfo(StreamInfo):
'''OptimFROG stream information.
Attributes:
* channels - number of audio channels
* length - file length in seconds, as a float
* sample_rate - audio sampling rate in Hz
'''
def __init__(self, fileobj):
pass
def pprint(self):
pass
| 3 | 1 | 9 | 0 | 9 | 0 | 2 | 0.33 | 1 | 2 | 1 | 0 | 2 | 3 | 2 | 3 | 28 | 4 | 18 | 7 | 15 | 6 | 13 | 6 | 10 | 3 | 2 | 1 | 4 |
147,041 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/trueaudio.py
|
mutagen.trueaudio.EasyTrueAudio
|
class EasyTrueAudio(TrueAudio):
"""Like MP3, but uses EasyID3 for tags.
:ivar info: :class:`TrueAudioInfo`
:ivar tags: :class:`EasyID3 <mutagen.easyid3.EasyID3>`
"""
from mutagen.easyid3 import EasyID3 as ID3
ID3 = ID3
|
class EasyTrueAudio(TrueAudio):
'''Like MP3, but uses EasyID3 for tags.
:ivar info: :class:`TrueAudioInfo`
:ivar tags: :class:`EasyID3 <mutagen.easyid3.EasyID3>`
'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1.33 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 17 | 9 | 2 | 3 | 2 | 1 | 4 | 3 | 2 | 1 | 0 | 4 | 0 | 0 |
147,042 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/trueaudio.py
|
mutagen.trueaudio.TrueAudio
|
class TrueAudio(ID3FileType):
"""A True Audio file.
:ivar info: :class:`TrueAudioInfo`
:ivar tags: :class:`ID3 <mutagen.id3.ID3>`
"""
_Info = TrueAudioInfo
_mimes = ["audio/x-tta"]
@staticmethod
def score(filename, fileobj, header):
filename = filename.lower()
return (header.startswith(b"ID3") + header.startswith(b"TTA") +
endswith(filename, b".tta") * 2)
|
class TrueAudio(ID3FileType):
'''A True Audio file.
:ivar info: :class:`TrueAudioInfo`
:ivar tags: :class:`ID3 <mutagen.id3.ID3>`
'''
@staticmethod
def score(filename, fileobj, header):
pass
| 3 | 1 | 5 | 1 | 4 | 0 | 1 | 0.5 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 17 | 16 | 4 | 8 | 5 | 5 | 4 | 6 | 4 | 4 | 1 | 3 | 0 | 1 |
147,043 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/trueaudio.py
|
mutagen.trueaudio.TrueAudioHeaderError
|
class TrueAudioHeaderError(error, IOError):
pass
|
class TrueAudioHeaderError(error, IOError):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 11 | 2 | 0 | 2 | 1 | 1 | 0 | 2 | 1 | 1 | 0 | 5 | 0 | 0 |
147,044 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEInvalidItemCount
|
class TAPEInvalidItemCount(TestCase):
# http://code.google.com/p/mutagen/issues/detail?id=145
def test_load(self):
x = mutagen.apev2.APEv2(INVAL_ITEM_COUNT)
self.failUnlessEqual(len(x.keys()), 17)
|
class TAPEInvalidItemCount(TestCase):
def test_load(self):
pass
| 2 | 0 | 3 | 0 | 3 | 0 | 1 | 0.25 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 76 | 6 | 1 | 4 | 3 | 2 | 1 | 4 | 3 | 2 | 1 | 3 | 0 | 1 |
147,045 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPETextValue
|
class TAPETextValue(TestCase):
from mutagen.apev2 import APETextValue as TV
TV = TV
def setUp(self):
self.sample = ["foo", "bar", "baz"]
self.value = mutagen.apev2.APEValue(
"\0".join(self.sample), mutagen.apev2.TEXT)
def test_type(self):
self.failUnless(isinstance(self.value, self.TV))
def test_list(self):
self.failUnlessEqual(self.sample, list(self.value))
def test_setitem_list(self):
self.value[2] = self.sample[2] = 'quux'
self.test_list()
self.test_getitem()
self.value[2] = self.sample[2] = 'baz'
def test_getitem(self):
for i in range(len(self.value)):
self.failUnlessEqual(self.sample[i], self.value[i])
if PY3:
def test_py3(self):
self.assertRaises(TypeError, self.value.__setitem__, 2, b"abc")
self.assertRaises(
TypeError, mutagen.apev2.APEValue, b"abc", mutagen.apev2.TEXT)
def test_repr(self):
repr(self.value)
|
class TAPETextValue(TestCase):
def setUp(self):
pass
def test_type(self):
pass
def test_list(self):
pass
def test_setitem_list(self):
pass
def test_getitem(self):
pass
def test_py3(self):
pass
def test_repr(self):
pass
| 8 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 3 | 0 | 0 | 7 | 2 | 7 | 82 | 34 | 8 | 26 | 12 | 17 | 0 | 24 | 12 | 15 | 2 | 3 | 1 | 8 |
147,046 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEWriter
|
class TAPEWriter(TestCase):
offset = 0
def setUp(self):
shutil.copy(SAMPLE, SAMPLE + ".new")
shutil.copy(BROKEN, BROKEN + ".new")
tag = mutagen.apev2.APEv2()
self.values = {"artist": "Joe Wreschnig\0unittest",
"album": "Mutagen tests",
"title": "Not really a song"}
for k, v in self.values.items():
tag[k] = v
tag.save(SAMPLE + ".new")
tag.save(SAMPLE + ".justtag")
tag.save(SAMPLE + ".tag_at_start")
fileobj = open(SAMPLE + ".tag_at_start", "ab")
fileobj.write(b"tag garbage" * 1000)
fileobj.close()
self.tag = mutagen.apev2.APEv2(SAMPLE + ".new")
def test_changed(self):
size = os.path.getsize(SAMPLE + ".new")
self.tag.save()
self.failUnlessEqual(
os.path.getsize(SAMPLE + ".new"), size - self.offset)
def test_fix_broken(self):
# Clean up garbage from a bug in pre-Mutagen APEv2.
# This also tests removing ID3v1 tags on writes.
self.failIfEqual(os.path.getsize(OLD), os.path.getsize(BROKEN))
tag = mutagen.apev2.APEv2(BROKEN)
tag.save(BROKEN + ".new")
self.failUnlessEqual(
os.path.getsize(OLD), os.path.getsize(BROKEN+".new"))
def test_readback(self):
for k, v in self.tag.items():
self.failUnlessEqual(str(v), self.values[k])
def test_size(self):
self.failUnlessEqual(
os.path.getsize(SAMPLE + ".new"),
os.path.getsize(SAMPLE) + os.path.getsize(SAMPLE + ".justtag"))
def test_delete(self):
mutagen.apev2.delete(SAMPLE + ".justtag")
tag = mutagen.apev2.APEv2(SAMPLE + ".new")
tag.delete()
self.failUnlessEqual(os.path.getsize(SAMPLE + ".justtag"), self.offset)
self.failUnlessEqual(os.path.getsize(SAMPLE) + self.offset,
os.path.getsize(SAMPLE + ".new"))
self.failIf(tag)
def test_empty(self):
self.failUnlessRaises(
IOError, mutagen.apev2.APEv2,
os.path.join("tests", "data", "emptyfile.mp3"))
def test_tag_at_start(self):
filename = SAMPLE + ".tag_at_start"
tag = mutagen.apev2.APEv2(filename)
self.failUnlessEqual(tag["album"], "Mutagen tests")
def test_tag_at_start_write(self):
filename = SAMPLE + ".tag_at_start"
tag = mutagen.apev2.APEv2(filename)
tag.save()
tag = mutagen.apev2.APEv2(filename)
self.failUnlessEqual(tag["album"], "Mutagen tests")
self.failUnlessEqual(
os.path.getsize(SAMPLE + ".justtag"),
os.path.getsize(filename) - (len("tag garbage") * 1000))
def test_tag_at_start_delete(self):
filename = SAMPLE + ".tag_at_start"
tag = mutagen.apev2.APEv2(filename)
tag.delete()
self.failUnlessRaises(IOError, mutagen.apev2.APEv2, filename)
self.failUnlessEqual(
os.path.getsize(filename), len("tag garbage") * 1000)
def test_case_preservation(self):
mutagen.apev2.delete(SAMPLE + ".justtag")
tag = mutagen.apev2.APEv2(SAMPLE + ".new")
tag["FoObaR"] = "Quux"
tag.save()
tag = mutagen.apev2.APEv2(SAMPLE + ".new")
self.failUnless("FoObaR" in list(tag.keys()))
self.failIf("foobar" in list(tag.keys()))
def test_unicode_key(self):
# http://code.google.com/p/mutagen/issues/detail?id=123
tag = mutagen.apev2.APEv2(SAMPLE + ".new")
tag["abc"] = u'\xf6\xe4\xfc'
tag[u"cba"] = u"abc"
tag.save()
def tearDown(self):
os.unlink(SAMPLE + ".new")
os.unlink(BROKEN + ".new")
os.unlink(SAMPLE + ".justtag")
os.unlink(SAMPLE + ".tag_at_start")
|
class TAPEWriter(TestCase):
def setUp(self):
pass
def test_changed(self):
pass
def test_fix_broken(self):
pass
def test_readback(self):
pass
def test_size(self):
pass
def test_delete(self):
pass
def test_empty(self):
pass
def test_tag_at_start(self):
pass
def test_tag_at_start_write(self):
pass
def test_tag_at_start_delete(self):
pass
def test_case_preservation(self):
pass
def test_unicode_key(self):
pass
def tearDown(self):
pass
| 14 | 0 | 7 | 0 | 6 | 0 | 1 | 0.03 | 1 | 3 | 1 | 1 | 13 | 2 | 13 | 88 | 102 | 13 | 86 | 32 | 72 | 3 | 74 | 32 | 60 | 2 | 3 | 1 | 15 |
147,047 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEv2
|
class TAPEv2(TestCase):
def setUp(self):
fd, self.filename = mkstemp(".apev2")
os.close(fd)
shutil.copy(OLD, self.filename)
self.audio = APEv2(self.filename)
def test_invalid_key(self):
self.failUnlessRaises(
KeyError, self.audio.__setitem__, u"\u1234", "foo")
def test_guess_text(self):
from mutagen.apev2 import APETextValue
self.audio["test"] = u"foobar"
self.failUnlessEqual(self.audio["test"], "foobar")
self.failUnless(isinstance(self.audio["test"], APETextValue))
def test_guess_text_list(self):
from mutagen.apev2 import APETextValue
self.audio["test"] = [u"foobar", "quuxbarz"]
self.failUnlessEqual(self.audio["test"], u"foobar\x00quuxbarz")
self.failUnless(isinstance(self.audio["test"], APETextValue))
def test_guess_utf8(self):
from mutagen.apev2 import APETextValue, APEBinaryValue
self.audio["test"] = b"foobar"
if PY3:
self.failUnlessEqual(self.audio["test"], b"foobar")
self.failUnless(isinstance(self.audio["test"], APEBinaryValue))
else:
self.failUnlessEqual(self.audio["test"], "foobar")
self.failUnless(isinstance(self.audio["test"], APETextValue))
def test_guess_not_utf8(self):
from mutagen.apev2 import APEBinaryValue
self.audio["test"] = b"\xa4woo"
self.failUnless(isinstance(self.audio["test"], APEBinaryValue))
self.failUnlessEqual(4, len(self.audio["test"]))
def test_bad_value_type(self):
from mutagen.apev2 import APEValue
self.failUnlessRaises(ValueError, APEValue, "foo", 99)
def test_module_delete_empty(self):
from mutagen.apev2 import delete
delete(os.path.join("tests", "data", "emptyfile.mp3"))
def test_invalid(self):
self.failUnlessRaises(IOError, mutagen.apev2.APEv2, "dne")
def test_no_tag(self):
self.failUnlessRaises(IOError, mutagen.apev2.APEv2,
os.path.join("tests", "data", "empty.mp3"))
def test_cases(self):
self.failUnlessEqual(self.audio["artist"], self.audio["ARTIST"])
self.failUnless("artist" in self.audio)
self.failUnless("artisT" in self.audio)
def test_keys(self):
self.failUnless("Track" in self.audio.keys())
self.failUnless("AnArtist" in self.audio.values())
self.failUnlessEqual(
list(self.audio.items()), list(zip(self.audio.keys(), self.audio.values())))
def test_key_type(self):
key = list(self.audio.keys())[0]
if PY3:
self.assertTrue(isinstance(key, text_type))
else:
self.assertTrue(isinstance(key, bytes))
def test_invalid_keys(self):
self.failUnlessRaises(KeyError, self.audio.__getitem__, "\x00")
self.failUnlessRaises(KeyError, self.audio.__setitem__, "\x00", "")
self.failUnlessRaises(KeyError, self.audio.__delitem__, "\x00")
def test_dictlike(self):
self.failUnless(self.audio.get("track"))
self.failUnless(self.audio.get("Track"))
def test_del(self):
s = self.audio["artist"]
del(self.audio["artist"])
self.failIf("artist" in self.audio)
self.failUnlessRaises(KeyError, self.audio.__getitem__, "artist")
self.audio["Artist"] = s
self.failUnlessEqual(self.audio["artist"], "AnArtist")
def test_values(self):
self.failUnlessEqual(self.audio["artist"], self.audio["artist"])
self.failUnless(self.audio["artist"] < self.audio["title"])
self.failUnlessEqual(self.audio["artist"], "AnArtist")
self.failUnlessEqual(self.audio["title"], "Some Music")
self.failUnlessEqual(self.audio["album"], "A test case")
self.failUnlessEqual("07", self.audio["track"])
self.failIfEqual(self.audio["album"], "A test Case")
def test_pprint(self):
self.failUnless(self.audio.pprint())
def tearDown(self):
os.unlink(self.filename)
|
class TAPEv2(TestCase):
def setUp(self):
pass
def test_invalid_key(self):
pass
def test_guess_text(self):
pass
def test_guess_text_list(self):
pass
def test_guess_utf8(self):
pass
def test_guess_not_utf8(self):
pass
def test_bad_value_type(self):
pass
def test_module_delete_empty(self):
pass
def test_invalid_key(self):
pass
def test_no_tag(self):
pass
def test_cases(self):
pass
def test_keys(self):
pass
def test_key_type(self):
pass
def test_invalid_keys(self):
pass
def test_dictlike(self):
pass
def test_del(self):
pass
def test_values(self):
pass
def test_pprint(self):
pass
def tearDown(self):
pass
| 20 | 0 | 5 | 0 | 4 | 0 | 1 | 0 | 1 | 8 | 3 | 1 | 19 | 2 | 19 | 94 | 106 | 21 | 85 | 30 | 59 | 0 | 80 | 30 | 54 | 2 | 3 | 1 | 21 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.