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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
147,048 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEv2File
|
class TAPEv2File(TestCase):
def setUp(self):
self.audio = APEv2File("tests/data/click.mpc")
def test_add_tags(self):
self.failUnless(self.audio.tags is None)
self.audio.add_tags()
self.failUnless(self.audio.tags is not None)
self.failUnlessRaises(ValueError, self.audio.add_tags)
def test_unknown_info(self):
info = self.audio.info
info.pprint()
|
class TAPEv2File(TestCase):
def setUp(self):
pass
def test_add_tags(self):
pass
def test_unknown_info(self):
pass
| 4 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 3 | 1 | 3 | 78 | 14 | 3 | 11 | 6 | 7 | 0 | 11 | 6 | 7 | 1 | 3 | 0 | 3 |
147,049 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_apev2.py
|
tests.test_apev2.TAPEv2ThenID3v1Writer
|
class TAPEv2ThenID3v1Writer(TAPEWriter):
offset = 128
def setUp(self):
super(TAPEv2ThenID3v1Writer, self).setUp()
f = open(SAMPLE + ".new", "ab+")
f.write(b"TAG" + b"\x00" * 125)
f.close()
f = open(BROKEN + ".new", "ab+")
f.write(b"TAG" + b"\x00" * 125)
f.close()
f = open(SAMPLE + ".justtag", "ab+")
f.write(b"TAG" + b"\x00" * 125)
f.close()
def test_tag_at_start_write(self):
pass
|
class TAPEv2ThenID3v1Writer(TAPEWriter):
def setUp(self):
pass
def test_tag_at_start_write(self):
pass
| 3 | 0 | 7 | 0 | 7 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 2 | 0 | 2 | 90 | 17 | 2 | 15 | 5 | 12 | 0 | 15 | 5 | 12 | 1 | 4 | 0 | 2 |
147,050 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggvorbis.py
|
mutagen.oggvorbis.OggVorbisInfo
|
class OggVorbisInfo(StreamInfo):
"""Ogg Vorbis stream information.
Attributes:
* length - file length in seconds, as a float
* bitrate - nominal ('average') bitrate in bits per second, as an int
"""
length = 0
def __init__(self, fileobj):
page = OggPage(fileobj)
while not page.packets[0].startswith(b"\x01vorbis"):
page = OggPage(fileobj)
if not page.first:
raise OggVorbisHeaderError(
"page has ID header, but doesn't start a stream")
(self.channels, self.sample_rate, max_bitrate, nominal_bitrate,
min_bitrate) = struct.unpack("<B4i", page.packets[0][11:28])
self.serial = page.serial
max_bitrate = max(0, max_bitrate)
min_bitrate = max(0, min_bitrate)
nominal_bitrate = max(0, nominal_bitrate)
if nominal_bitrate == 0:
self.bitrate = (max_bitrate + min_bitrate) // 2
elif max_bitrate and max_bitrate < nominal_bitrate:
# If the max bitrate is less than the nominal, we know
# the nominal is wrong.
self.bitrate = max_bitrate
elif min_bitrate > nominal_bitrate:
self.bitrate = min_bitrate
else:
self.bitrate = nominal_bitrate
def _post_tags(self, fileobj):
page = OggPage.find_last(fileobj, self.serial)
self.length = page.position / float(self.sample_rate)
def pprint(self):
return u"Ogg Vorbis, %.2f seconds, %d bps" % (self.length, self.bitrate)
|
class OggVorbisInfo(StreamInfo):
'''Ogg Vorbis stream information.
Attributes:
* length - file length in seconds, as a float
* bitrate - nominal ('average') bitrate in bits per second, as an int
'''
def __init__(self, fileobj):
pass
def _post_tags(self, fileobj):
pass
def pprint(self):
pass
| 4 | 1 | 10 | 1 | 9 | 1 | 3 | 0.25 | 1 | 3 | 2 | 0 | 3 | 4 | 3 | 4 | 43 | 8 | 28 | 11 | 24 | 7 | 23 | 10 | 19 | 6 | 2 | 1 | 8 |
147,051 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFTags1
|
class TASFTags1(TASF):
original = os.path.join("tests", "data", "silence-1.wma")
|
class TASFTags1(TASF):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 99 | 2 | 0 | 2 | 2 | 1 | 0 | 2 | 2 | 1 | 0 | 4 | 0 | 0 |
147,052 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFTags2
|
class TASFTags2(TASF):
original = os.path.join("tests", "data", "silence-2.wma")
|
class TASFTags2(TASF):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 99 | 2 | 0 | 2 | 2 | 1 | 0 | 2 | 2 | 1 | 0 | 4 | 0 | 0 |
147,053 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFTags3
|
class TASFTags3(TASF):
original = os.path.join("tests", "data", "silence-3.wma")
|
class TASFTags3(TASF):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 99 | 2 | 0 | 2 | 2 | 1 | 0 | 2 | 2 | 1 | 0 | 4 | 0 | 0 |
147,054 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TVCFLACDict
|
class TVCFLACDict(TVComment):
Kind = VCFLACDict
def test_roundtrip_vc(self):
self.failUnlessEqual(self.c, self.Kind(self.c.write() + b"\x01"))
|
class TVCFLACDict(TVComment):
def test_roundtrip_vc(self):
pass
| 2 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 98 | 6 | 2 | 4 | 3 | 2 | 0 | 4 | 3 | 2 | 1 | 4 | 0 | 1 |
147,055 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.Tto_int_be
|
class Tto_int_be(TestCase):
def test_empty(self):
self.failUnlessEqual(to_int_be(b""), 0)
def test_0(self):
self.failUnlessEqual(to_int_be(b"\x00"), 0)
def test_1(self):
self.failUnlessEqual(to_int_be(b"\x01"), 1)
def test_256(self):
self.failUnlessEqual(to_int_be(b"\x01\x00"), 256)
def test_long(self):
self.failUnlessEqual(to_int_be(b"\x01\x00\x00\x00\x00"), 2**32)
|
class Tto_int_be(TestCase):
def test_empty(self):
pass
def test_0(self):
pass
def test_1(self):
pass
def test_256(self):
pass
def test_long(self):
pass
| 6 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 5 | 0 | 5 | 80 | 16 | 5 | 11 | 6 | 5 | 0 | 11 | 6 | 5 | 1 | 3 | 0 | 5 |
147,056 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.BadPOPM
|
class BadPOPM(TestCase):
filename = join('tests', 'data', 'bad-POPM-frame.mp3')
newfilename = join('tests', 'data', 'bad-POPM-frame-written.mp3')
def setUp(self):
shutil.copy(self.filename, self.newfilename)
def tearDown(self):
try: os.unlink(self.newfilename)
except EnvironmentError: pass
def test_read_popm_long_counter(self):
f = ID3(self.newfilename)
self.failUnless("POPM:Windows Media Player 9 Series" in f)
popm = f["POPM:Windows Media Player 9 Series"]
self.assertEquals(popm.rating, 255)
self.assertEquals(popm.count, 2709193061)
def test_write_popm_long_counter(self):
from mutagen.id3 import POPM
f = ID3(self.newfilename)
f.add(POPM(email="foo@example.com", rating=125, count=2**32+1))
f.save()
f = ID3(self.newfilename)
self.failUnless("POPM:foo@example.com" in f)
self.failUnless("POPM:Windows Media Player 9 Series" in f)
popm = f["POPM:foo@example.com"]
self.assertEquals(popm.rating, 125)
self.assertEquals(popm.count, 2**32+1)
|
class BadPOPM(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_read_popm_long_counter(self):
pass
def test_write_popm_long_counter(self):
pass
| 5 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 4 | 0 | 4 | 79 | 30 | 5 | 25 | 12 | 19 | 0 | 27 | 12 | 21 | 2 | 3 | 1 | 5 |
147,057 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.BadTYER
|
class BadTYER(TestCase):
filename = join('tests', 'data', 'bad-TYER-frame.mp3')
def setUp(self):
self.audio = ID3(self.filename)
def test_no_year(self):
self.failIf("TYER" in self.audio)
def test_has_title(self):
self.failUnless("TIT2" in self.audio)
def tearDown(self):
del(self.audio)
|
class BadTYER(TestCase):
def setUp(self):
pass
def test_no_year(self):
pass
def test_has_title(self):
pass
def tearDown(self):
pass
| 5 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 4 | 1 | 4 | 79 | 15 | 5 | 10 | 7 | 5 | 0 | 10 | 7 | 5 | 1 | 3 | 0 | 4 |
147,058 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.BrokenButParsed
|
class BrokenButParsed(TestCase):
def test_missing_encoding(self):
from mutagen.id3 import TIT2
tag = TIT2.fromData(_23, 0x00, b'a test')
self.assertEquals(0, tag.encoding)
self.assertEquals('a test', tag)
self.assertEquals(['a test'], tag)
self.assertEquals(['a test'], tag.text)
def test_zerolength_framedata(self):
from mutagen.id3 import Frames
id3 = ID3()
tail = b'\x00' * 6
for head in b'WOAR TENC TCOP TOPE WXXX'.split():
data = head + tail
self.assertEquals(
0, len(list(id3._ID3__read_frames(data, Frames))))
def test_lengthone_utf16(self):
from mutagen.id3 import TPE1
tpe1 = TPE1.fromData(_24, 0, b'\x01\x00')
self.assertEquals(u'', tpe1)
tpe1 = TPE1.fromData(_24, 0, b'\x01\x00\x00\x00\x00')
self.assertEquals([u'', u''], tpe1)
def test_utf16_wrongnullterm(self):
# issue 169
from mutagen.id3 import TPE1
tpe1 = TPE1.fromData(
_24, 0, b'\x01\xff\xfeH\x00e\x00l\x00l\x00o\x00\x00')
self.assertEquals(tpe1, [u'Hello'])
def test_fake_zlib_pedantic(self):
from mutagen.id3 import TPE1, Frame, ID3BadCompressedData
id3 = ID3()
id3.PEDANTIC = True
self.assertRaises(ID3BadCompressedData, TPE1.fromData, id3,
Frame.FLAG24_COMPRESS, b'\x03abcdefg')
def test_zlib_bpi(self):
from mutagen.id3 import TPE1
id3 = ID3()
tpe1 = TPE1(encoding=0, text="a" * (0xFFFF - 2))
data = id3._ID3__save_frame(tpe1)
datalen_size = data[4 + 4 + 2:4 + 4 + 2 + 4]
self.failIf(
max(datalen_size) >= b'\x80'[0], "data is not syncsafe: %r" % data)
def test_fake_zlib_nopedantic(self):
from mutagen.id3 import TPE1, Frame
id3 = ID3()
id3.PEDANTIC = False
tpe1 = TPE1.fromData(id3, Frame.FLAG24_COMPRESS, b'\x03abcdefg')
self.assertEquals(u'abcdefg', tpe1)
def test_ql_0_12_missing_uncompressed_size(self):
from mutagen.id3 import TPE1
tag = TPE1.fromData(_24, 0x08, b'x\x9cc\xfc\xff\xaf\x84!\x83!\x93'
b'\xa1\x98A\x01J&2\xe83\x940\xa4\x02\xd9%\x0c\x00\x87\xc6\x07#')
self.assertEquals(tag.encoding, 1)
self.assertEquals(tag, ['this is a/test'])
def test_zlib_latin1_missing_datalen(self):
from mutagen.id3 import TPE1
tag = TPE1.fromData(_24, 0x8, 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_detect_23_ints_in_24_frames(self):
from mutagen.id3 import Frames
head = b'TIT1\x00\x00\x01\x00\x00\x00\x00'
tail = b'TPE1\x00\x00\x00\x04\x00\x00Yay!'
tagsgood = list(_24._ID3__read_frames(head + b'a'*127 + tail, Frames))
tagsbad = list(_24._ID3__read_frames(head + b'a'*255 + tail, Frames))
self.assertEquals(2, len(tagsgood))
self.assertEquals(2, len(tagsbad))
self.assertEquals('a'*127, tagsgood[0])
self.assertEquals('a'*255, tagsbad[0])
self.assertEquals('Yay!', tagsgood[1])
self.assertEquals('Yay!', tagsbad[1])
tagsgood = list(_24._ID3__read_frames(head + b'a'*127, Frames))
tagsbad = list(_24._ID3__read_frames(head + b'a'*255, Frames))
self.assertEquals(1, len(tagsgood))
self.assertEquals(1, len(tagsbad))
self.assertEquals('a'*127, tagsgood[0])
self.assertEquals('a'*255, tagsbad[0])
|
class BrokenButParsed(TestCase):
def test_missing_encoding(self):
pass
def test_zerolength_framedata(self):
pass
def test_lengthone_utf16(self):
pass
def test_utf16_wrongnullterm(self):
pass
def test_fake_zlib_pedantic(self):
pass
def test_zlib_bpi(self):
pass
def test_fake_zlib_nopedantic(self):
pass
def test_ql_0_12_missing_uncompressed_size(self):
pass
def test_zlib_latin1_missing_datalen(self):
pass
def test_detect_23_ints_in_24_frames(self):
pass
| 11 | 0 | 8 | 0 | 8 | 0 | 1 | 0.03 | 1 | 6 | 5 | 0 | 10 | 0 | 10 | 85 | 90 | 12 | 77 | 41 | 56 | 2 | 71 | 41 | 50 | 2 | 3 | 1 | 11 |
147,059 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.BrokenDiscarded
|
class BrokenDiscarded(TestCase):
def test_empty(self):
from mutagen.id3 import TPE1, ID3JunkFrameError
self.assertRaises(ID3JunkFrameError, TPE1.fromData, _24, 0x00, b'')
def test_wacky_truncated_RVA2(self):
from mutagen.id3 import RVA2, ID3JunkFrameError
data = b'\x01{\xf0\x10\xff\xff\x00'
self.assertRaises(ID3JunkFrameError, RVA2.fromData, _24, 0x00, data)
def test_bad_number_of_bits_RVA2(self):
from mutagen.id3 import RVA2, ID3JunkFrameError
data = b'\x00\x00\x01\xe6\xfc\x10{\xd7'
self.assertRaises(ID3JunkFrameError, RVA2.fromData, _24, 0x00, data)
def test_drops_truncated_frames(self):
from mutagen.id3 import Frames
id3 = ID3()
tail = b'\x00\x00\x00\x03\x00\x00' b'\x01\x02\x03'
for head in b'RVA2 TXXX APIC'.split():
data = head + tail
self.assertEquals(
0, len(list(id3._ID3__read_frames(data, Frames))))
def test_drops_nonalphanum_frames(self):
from mutagen.id3 import Frames
id3 = ID3()
tail = b'\x00\x00\x00\x03\x00\x00' b'\x01\x02\x03'
for head in [b'\x06\xaf\xfe\x20', b'ABC\x00', b'A ']:
data = head + tail
self.assertEquals(
0, len(list(id3._ID3__read_frames(data, Frames))))
def test_bad_unicodedecode(self):
from mutagen.id3 import COMM, ID3JunkFrameError
# 7 bytes of "UTF16" data.
data = b'\x01\x00\x00\x00\xff\xfe\x00\xff\xfeh\x00'
self.assertRaises(ID3JunkFrameError, COMM.fromData, _24, 0x00, data)
|
class BrokenDiscarded(TestCase):
def test_empty(self):
pass
def test_wacky_truncated_RVA2(self):
pass
def test_bad_number_of_bits_RVA2(self):
pass
def test_drops_truncated_frames(self):
pass
def test_drops_nonalphanum_frames(self):
pass
def test_bad_unicodedecode(self):
pass
| 7 | 0 | 5 | 0 | 5 | 0 | 1 | 0.03 | 1 | 6 | 5 | 0 | 6 | 0 | 6 | 81 | 39 | 6 | 32 | 24 | 19 | 1 | 30 | 24 | 17 | 2 | 3 | 1 | 8 |
147,060 |
LordSputnik/mutagen
|
LordSputnik_mutagen/setup.py
|
setup.build_sphinx
|
class build_sphinx(Command):
description = "build sphinx documentation"
user_options = [
("build-dir=", "d", "build directory"),
]
def initialize_options(self):
self.build_dir = None
def finalize_options(self):
self.build_dir = self.build_dir or "build"
def run(self):
docs = "docs"
target = os.path.join(self.build_dir, "sphinx")
self.spawn(["sphinx-build", "-b", "html", "-n", docs, target])
|
class build_sphinx(Command):
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
pass
| 4 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 3 | 1 | 3 | 33 | 16 | 3 | 13 | 9 | 9 | 0 | 11 | 9 | 7 | 1 | 1 | 0 | 3 |
147,061 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/tests/__init__.py
|
tests.unit.MockMMap
|
class MockMMap(object):
def __init__(self, *args, **kwargs):
pass
def move(self, dest, src, count):
raise ValueError
def close(self):
pass
|
class MockMMap(object):
def __init__(self, *args, **kwargs):
pass
def move(self, dest, src, count):
pass
def close(self):
pass
| 4 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 3 | 0 | 3 | 3 | 9 | 2 | 7 | 4 | 3 | 0 | 7 | 4 | 3 | 1 | 1 | 0 | 3 |
147,062 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3GetSetDel
|
class ID3GetSetDel(TestCase):
def setUp(self):
self.i = ID3()
self.i["BLAH"] = 1
self.i["QUUX"] = 2
self.i["FOOB:ar"] = 3
self.i["FOOB:az"] = 4
def test_getnormal(self):
self.assertEquals(self.i.getall("BLAH"), [1])
self.assertEquals(self.i.getall("QUUX"), [2])
self.assertEquals(self.i.getall("FOOB:ar"), [3])
self.assertEquals(self.i.getall("FOOB:az"), [4])
def test_getlist(self):
self.assert_(self.i.getall("FOOB") in [[3, 4], [4, 3]])
def test_delnormal(self):
self.assert_("BLAH" in self.i)
self.i.delall("BLAH")
self.assert_("BLAH" not in self.i)
def test_delone(self):
self.i.delall("FOOB:ar")
self.assertEquals(self.i.getall("FOOB"), [4])
def test_delall(self):
self.assert_("FOOB:ar" in self.i)
self.assert_("FOOB:az" in self.i)
self.i.delall("FOOB")
self.assert_("FOOB:ar" not in self.i)
self.assert_("FOOB:az" not in self.i)
def test_setone(self):
class TEST(object): HashKey = "FOOB:ar"
t = TEST()
self.i.setall("FOOB", [t])
self.assertEquals(self.i["FOOB:ar"], t)
self.assertEquals(self.i.getall("FOOB"), [t])
def test_settwo(self):
class TEST(object): HashKey = "FOOB:ar"
t = TEST()
t2 = TEST(); t2.HashKey = "FOOB:az"
self.i.setall("FOOB", [t, t2])
self.assertEquals(self.i["FOOB:ar"], t)
self.assertEquals(self.i["FOOB:az"], t2)
self.assert_(self.i.getall("FOOB") in [[t, t2], [t2, t]])
|
class ID3GetSetDel(TestCase):
def setUp(self):
pass
def test_getnormal(self):
pass
def test_getlist(self):
pass
def test_delnormal(self):
pass
def test_delone(self):
pass
def test_delall(self):
pass
def test_setone(self):
pass
class TEST(object):
def test_settwo(self):
pass
class TEST(object):
| 11 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 3 | 3 | 0 | 8 | 1 | 8 | 83 | 49 | 8 | 41 | 15 | 32 | 0 | 44 | 17 | 33 | 1 | 3 | 0 | 8 |
147,063 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/tests/test_mp4.py
|
tests.test_mp4.TAtom.test_render_too_big.TooBig
|
class TooBig(bytes):
def __len__(self):
return 1 << 32
|
class TooBig(bytes):
def __len__(self):
pass
| 2 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 58 | 3 | 0 | 3 | 2 | 1 | 0 | 3 | 2 | 1 | 1 | 2 | 0 | 1 |
147,064 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3Tags.test_23_multiframe_hack.ID3hack
|
class ID3hack(ID3):
"Override 'correct' behavior with desired behavior"
def loaded_frame(self, tag):
if tag.HashKey in self:
self[tag.HashKey].extend(tag[:])
else:
self[tag.HashKey] = tag
|
class ID3hack(ID3):
'''Override 'correct' behavior with desired behavior'''
def loaded_frame(self, tag):
pass
| 2 | 1 | 3 | 0 | 3 | 0 | 2 | 0.25 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 32 | 5 | 0 | 4 | 2 | 2 | 1 | 5 | 2 | 3 | 2 | 3 | 1 | 2 |
147,065 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/tests/test___init__.py
|
tests.test___init__.TMetadata.FakeMeta
|
class FakeMeta(Metadata):
def __init__(self): pass
|
class FakeMeta(Metadata):
def __init__(self):
pass
| 2 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 5 | 2 | 0 | 2 | 2 | 1 | 0 | 3 | 2 | 1 | 1 | 2 | 0 | 1 |
147,066 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TStreamInfo
|
class TStreamInfo(TestCase):
data = (b'\x12\x00\x12\x00\x00\x00\x0e\x005\xea\n\xc4H\xf0\x00\xca0'
b'\x14(\x90\xf9\xe1)2\x13\x01\xd4\xa7\xa9\x11!8\xab\x91')
data_invalid = len(data) * b'\x00'
def setUp(self):
self.i = StreamInfo(self.data)
def test_invalid(self):
# http://code.google.com/p/mutagen/issues/detail?id=117
self.failUnlessRaises(error, StreamInfo, self.data_invalid)
def test_blocksize(self):
self.failUnlessEqual(self.i.max_blocksize, 4608)
self.failUnlessEqual(self.i.min_blocksize, 4608)
self.failUnless(self.i.min_blocksize <= self.i.max_blocksize)
def test_framesize(self):
self.failUnlessEqual(self.i.min_framesize, 14)
self.failUnlessEqual(self.i.max_framesize, 13802)
self.failUnless(self.i.min_framesize <= self.i.max_framesize)
def test_sample_rate(self):
self.failUnlessEqual(self.i.sample_rate, 44100)
def test_channels(self):
self.failUnlessEqual(self.i.channels, 5)
def test_bps(self):
self.failUnlessEqual(self.i.bits_per_sample, 16)
def test_length(self):
self.failUnlessAlmostEqual(self.i.length, 300.5, 1)
def test_total_samples(self):
self.failUnlessEqual(self.i.total_samples, 13250580)
def test_md5_signature(self):
self.failUnlessEqual(self.i.md5_signature,
int("2890f9e129321301d4a7a9112138ab91", 16))
def test_eq(self):
self.failUnlessEqual(self.i, self.i)
def test_roundtrip(self):
self.failUnlessEqual(StreamInfo(self.i.write()), self.i)
|
class TStreamInfo(TestCase):
def setUp(self):
pass
def test_invalid(self):
pass
def test_blocksize(self):
pass
def test_framesize(self):
pass
def test_sample_rate(self):
pass
def test_channels(self):
pass
def test_bps(self):
pass
def test_length(self):
pass
def test_total_samples(self):
pass
def test_md5_signature(self):
pass
def test_eq(self):
pass
def test_roundtrip(self):
pass
| 13 | 0 | 3 | 0 | 2 | 0 | 1 | 0.03 | 1 | 3 | 2 | 0 | 12 | 1 | 12 | 87 | 47 | 13 | 33 | 16 | 20 | 1 | 31 | 16 | 18 | 1 | 3 | 0 | 12 |
147,067 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/mutagen/id3.py
|
mutagen.id3.ID3FileType._Info
|
class _Info(mutagen.StreamInfo):
length = 0
def __init__(self, fileobj, offset):
pass
@staticmethod
def pprint():
return "Unknown format with ID3 tag"
|
class _Info(mutagen.StreamInfo):
def __init__(self, fileobj, offset):
pass
@staticmethod
def pprint():
pass
| 4 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 2 | 3 | 9 | 2 | 7 | 5 | 3 | 0 | 6 | 4 | 3 | 1 | 2 | 0 | 2 |
147,068 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3GetSetDel.test_settwo.TEST
|
class TEST(object): HashKey = "FOOB:ar"
|
class TEST(object):
pass
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 2 | 2 | 1 | 0 | 1 | 0 | 0 |
147,069 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3Loading
|
class ID3Loading(TestCase):
empty = join('tests', 'data', 'emptyfile.mp3')
silence = join('tests', 'data', 'silence-44-s.mp3')
unsynch = join('tests', 'data', 'id3v23_unsynch.id3')
def test_empty_file(self):
name = self.empty
self.assertRaises(ValueError, ID3, filename=name)
#from_name = ID3(name)
#obj = open(name, 'rb')
#from_obj = ID3(fileobj=obj)
#self.assertEquals(from_name, from_explicit_name)
#self.assertEquals(from_name, from_obj)
def test_nonexistent_file(self):
name = join('tests', 'data', 'does', 'not', 'exist')
self.assertRaises(EnvironmentError, ID3, name)
def test_header_empty(self):
id3 = ID3()
id3._fileobj = open(self.empty, 'rb')
self.assertRaises(EOFError, id3._load_header)
def test_header_silence(self):
id3 = ID3()
id3._fileobj = open(self.silence, 'rb')
id3._load_header()
self.assertEquals(id3.version, (2,3,0))
self.assertEquals(id3.size, 1314)
def test_header_2_4_invalid_flags(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x04\x00\x1f\x00\x00\x00\x00')
self.assertRaises(ValueError, id3._load_header)
def test_header_2_4_unsynch_size(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x04\x00\x10\x00\x00\x00\xFF')
self.assertRaises(ValueError, id3._load_header)
def test_header_2_4_allow_footer(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x04\x00\x10\x00\x00\x00\x00')
id3._load_header()
def test_header_2_3_invalid_flags(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x03\x00\x1f\x00\x00\x00\x00')
self.assertRaises(ValueError, id3._load_header)
id3._fileobj = cBytesIO(b'ID3\x03\x00\x0f\x00\x00\x00\x00')
self.assertRaises(ValueError, id3._load_header)
def test_header_2_2(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x02\x00\x00\x00\x00\x00\x00')
id3._load_header()
self.assertEquals(id3.version, (2,2,0))
def test_header_2_1(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x01\x00\x00\x00\x00\x00\x00')
self.assertRaises(NotImplementedError, id3._load_header)
def test_header_too_small(self):
id3 = ID3()
id3._fileobj = cBytesIO(b'ID3\x01\x00\x00\x00\x00\x00')
self.assertRaises(EOFError, id3._load_header)
def test_header_2_4_extended(self):
id3 = ID3()
id3._fileobj = cBytesIO(
b'ID3\x04\x00\x40\x00\x00\x00\x00\x00\x00\x00\x05\x5a')
id3._load_header()
self.assertEquals(id3._ID3__extsize, 1)
self.assertEquals(id3._ID3__extdata, b'\x5a')
def test_header_2_4_extended_unsynch_size(self):
id3 = ID3()
id3._fileobj = cBytesIO(
b'ID3\x04\x00\x40\x00\x00\x00\x00\x00\x00\x00\xFF\x5a')
self.assertRaises(ValueError, id3._load_header)
def test_header_2_4_extended_but_not(self):
id3 = ID3()
id3._fileobj = cBytesIO(
b'ID3\x04\x00\x40\x00\x00\x00\x00TIT1\x00\x00\x00\x01a')
id3._load_header()
self.assertEquals(id3._ID3__extsize, 0)
self.assertEquals(id3._ID3__extdata, b'')
def test_header_2_4_extended_but_not_but_not_tag(self):
id3 = ID3()
id3._fileobj = cBytesIO(
b'ID3\x04\x00\x40\x00\x00\x00\x00TIT9')
self.failUnlessRaises(EOFError, id3._load_header)
def test_header_2_3_extended(self):
id3 = ID3()
id3._fileobj = cBytesIO(
b'ID3\x03\x00\x40\x00\x00\x00\x00\x00\x00\x00\x06'
b'\x00\x00\x56\x78\x9a\xbc')
id3._load_header()
self.assertEquals(id3._ID3__extsize, 6)
self.assertEquals(id3._ID3__extdata, b'\x00\x00\x56\x78\x9a\xbc')
def test_unsynch(self):
id3 = ID3()
id3.version = (2,4,0)
id3._ID3__flags = 0x80
badsync = b'\x00\xff\x00ab\x00'
self.assertEquals(
id3._ID3__load_framedata(Frames["TPE2"], 0, badsync), [u"\xffab"])
id3._ID3__flags = 0x00
self.assertEquals(id3._ID3__load_framedata(
Frames["TPE2"], 0x02, badsync), [u"\xffab"])
tag = id3._ID3__load_framedata(Frames["TPE2"], 0, badsync)
self.assertEquals(tag, [u"\xff", u"ab"])
def test_load_v23_unsynch(self):
id3 = ID3(self.unsynch)
self.assertEquals(id3["TPE1"], ["Nina Simone"])
def test_insane__ID3__fullread(self):
id3 = ID3()
id3._ID3__filesize = 0
self.assertRaises(ValueError, id3._ID3__fullread, -3)
self.assertRaises(EOFError, id3._ID3__fullread, 3)
|
class ID3Loading(TestCase):
def test_empty_file(self):
pass
def test_nonexistent_file(self):
pass
def test_header_empty(self):
pass
def test_header_silence(self):
pass
def test_header_2_4_invalid_flags(self):
pass
def test_header_2_4_unsynch_size(self):
pass
def test_header_2_4_allow_footer(self):
pass
def test_header_2_3_invalid_flags(self):
pass
def test_header_2_2(self):
pass
def test_header_2_1(self):
pass
def test_header_too_small(self):
pass
def test_header_2_4_extended(self):
pass
def test_header_2_4_extended_unsynch_size(self):
pass
def test_header_2_4_extended_but_not(self):
pass
def test_header_2_4_extended_but_not_but_not_tag(self):
pass
def test_header_2_3_extended(self):
pass
def test_unsynch(self):
pass
def test_load_v23_unsynch(self):
pass
def test_insane__ID3__fullread(self):
pass
| 20 | 0 | 5 | 0 | 5 | 0 | 1 | 0.05 | 1 | 4 | 1 | 0 | 19 | 0 | 19 | 94 | 128 | 20 | 103 | 44 | 83 | 5 | 95 | 44 | 75 | 1 | 3 | 0 | 19 |
147,070 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3Tags
|
class ID3Tags(TestCase):
def setUp(self):
self.silence = join('tests', 'data', 'silence-44-s.mp3')
def test_None(self):
id3 = ID3(self.silence, known_frames={})
self.assertEquals(0, len(id3.keys()))
self.assertEquals(9, len(id3.unknown_frames))
def test_has_docs(self):
for Kind in (list(Frames.values()) + list(Frames_2_2.values())):
self.failUnless(Kind.__doc__, "%s has no docstring" % Kind)
def test_23(self):
id3 = ID3(self.silence)
self.assertEquals(8, len(id3.keys()))
self.assertEquals(0, len(id3.unknown_frames))
self.assertEquals('Quod Libet Test Data', id3['TALB'])
self.assertEquals('Silence', str(id3['TCON']))
self.assertEquals('Silence', str(id3['TIT1']))
self.assertEquals('Silence', str(id3['TIT2']))
self.assertEquals(3000, +id3['TLEN'])
self.assertNotEquals(['piman','jzig'], id3['TPE1'])
self.assertEquals('02/10', id3['TRCK'])
self.assertEquals(2, +id3['TRCK'])
self.assertEquals('2004', id3['TDRC'])
def test_23_multiframe_hack(self):
class ID3hack(ID3):
"Override 'correct' behavior with desired behavior"
def loaded_frame(self, tag):
if tag.HashKey in self: self[tag.HashKey].extend(tag[:])
else: self[tag.HashKey] = tag
id3 = ID3hack(self.silence)
self.assertEquals(8, len(id3.keys()))
self.assertEquals(0, len(id3.unknown_frames))
self.assertEquals('Quod Libet Test Data', id3['TALB'])
self.assertEquals('Silence', str(id3['TCON']))
self.assertEquals('Silence', str(id3['TIT1']))
self.assertEquals('Silence', str(id3['TIT2']))
self.assertEquals(3000, +id3['TLEN'])
self.assertEquals(['piman','jzig'], id3['TPE1'])
self.assertEquals('02/10', id3['TRCK'])
self.assertEquals(2, +id3['TRCK'])
self.assertEquals('2004', id3['TDRC'])
def test_badencoding(self):
self.assertRaises(IndexError, Frames["TPE1"].fromData, _24, 0, b"\x09ab")
self.assertRaises(ValueError, Frames["TPE1"], encoding=9, text="ab")
def test_badsync(self):
self.assertRaises(
ValueError, Frames["TPE1"].fromData, _24, 0x02, b"\x00\xff\xfe")
def test_noencrypt(self):
self.assertRaises(
NotImplementedError, Frames["TPE1"].fromData, _24, 0x04, b"\x00")
self.assertRaises(
NotImplementedError, Frames["TPE1"].fromData, _23, 0x40, b"\x00")
def test_badcompress(self):
self.assertRaises(
ValueError, Frames["TPE1"].fromData, _24, 0x08, b"\x00\x00\x00\x00#")
self.assertRaises(
ValueError, Frames["TPE1"].fromData, _23, 0x80, b"\x00\x00\x00\x00#")
def test_junkframe(self):
self.assertRaises(ValueError, Frames["TPE1"].fromData, _24, 0, b"")
def test_bad_sylt(self):
self.assertRaises(
ID3JunkFrameError, Frames["SYLT"].fromData, _24, 0x0,
b"\x00eng\x01description\x00foobar")
self.assertRaises(
ID3JunkFrameError, Frames["SYLT"].fromData, _24, 0x0,
b"\x00eng\x01description\x00foobar\x00\xFF\xFF\xFF")
def test_extradata(self):
from mutagen.id3 import RVRB, RBUF
self.assertRaises(ID3Warning,
RVRB()._readData, b'L1R1BBFFFFPP#xyz')
self.assertRaises(ID3Warning,
RBUF()._readData, b'\x00\x01\x00\x01\x00\x00\x00\x00#xyz')
|
class ID3Tags(TestCase):
def setUp(self):
pass
def test_None(self):
pass
def test_has_docs(self):
pass
def test_23(self):
pass
def test_23_multiframe_hack(self):
pass
class ID3hack(ID3):
'''Override 'correct' behavior with desired behavior'''
def loaded_frame(self, tag):
pass
def test_badencoding(self):
pass
def test_badsync(self):
pass
def test_noencrypt(self):
pass
def test_badcompress(self):
pass
def test_junkframe(self):
pass
def test_bad_sylt(self):
pass
def test_extradata(self):
pass
| 15 | 1 | 6 | 0 | 6 | 0 | 1 | 0.07 | 1 | 11 | 6 | 0 | 12 | 1 | 12 | 87 | 85 | 13 | 71 | 21 | 55 | 5 | 61 | 21 | 45 | 2 | 3 | 1 | 15 |
147,071 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.ID3v1Tags
|
class ID3v1Tags(TestCase):
def setUp(self):
self.silence = join('tests', 'data', 'silence-44-s-v1.mp3')
self.id3 = ID3(self.silence)
def test_album(self):
self.assertEquals('Quod Libet Test Data', self.id3['TALB'])
def test_genre(self):
self.assertEquals('Darkwave', self.id3['TCON'].genres[0])
def test_title(self):
self.assertEquals('Silence', str(self.id3['TIT2']))
def test_artist(self):
self.assertEquals(['piman'], self.id3['TPE1'])
def test_track(self):
self.assertEquals('2', self.id3['TRCK'])
self.assertEquals(2, +self.id3['TRCK'])
def test_year(self):
self.assertEquals('2004', self.id3['TDRC'])
def test_v1_not_v11(self):
from mutagen.id3 import MakeID3v1, ParseID3v1, TRCK
self.id3["TRCK"] = TRCK(encoding=0, text="32")
tag = MakeID3v1(self.id3)
self.failUnless(32, ParseID3v1(tag)["TRCK"])
del(self.id3["TRCK"])
tag = MakeID3v1(self.id3)
tag = tag[:125] + b' ' + chr_(ord_(tag[-1]))
self.failIf("TRCK" in ParseID3v1(tag))
def test_nulls(self):
from mutagen.id3 import ParseID3v1
artist = (b'abcd\00fg' + b'\x00' * 30)[:30]
title = (b'hijklmn\x00p' + b'\x00' * 30)[:30]
album = (b'qrst\x00v' + b'\x00' * 30)[:30]
cmt = (b'wxyz' + b'\x00' * 29)[:29]
year = (b'1224' + b'\x00' * 4)[:4]
s = b'TAG' + title + artist + album + year + cmt + b'\x03\x01'
tags = ParseID3v1(s)
self.assertEquals(b'abcd'.decode('latin1'), tags['TPE1'])
self.assertEquals(b'hijklmn'.decode('latin1'), tags['TIT2'])
self.assertEquals(b'qrst'.decode('latin1'), tags['TALB'])
def test_nonascii(self):
from mutagen.id3 import ParseID3v1
s = u'TAG%(title)30s%(artist)30s%(album)30s%(year)4s%(cmt)29s\x03\x01'
s = s % dict(artist=u'abcd\xe9fg', title=u'hijklmn\xf3p',
album=u'qrst\xfcv', cmt='wxyz', year='1234')
tags = ParseID3v1(s.encode("latin-1"))
self.assertEquals(b'abcd\xe9fg'.decode('latin1'), tags['TPE1'])
self.assertEquals(b'hijklmn\xf3p'.decode('latin1'), tags['TIT2'])
self.assertEquals(b'qrst\xfcv'.decode('latin1'), tags['TALB'])
self.assertEquals('wxyz', tags['COMM'])
self.assertEquals("3", tags['TRCK'])
self.assertEquals("1234", str(tags['TDRC']))
def test_roundtrip(self):
from mutagen.id3 import ParseID3v1, MakeID3v1
frames = {}
for key in ["TIT2", "TALB", "TPE1", "TDRC"]:
frames[key] = self.id3[key]
self.assertEquals(ParseID3v1(MakeID3v1(frames)), frames)
def test_make_from_empty(self):
from mutagen.id3 import MakeID3v1, TCON, COMM
empty = b'TAG' + b'\x00' * 124 + b'\xff'
self.assertEquals(MakeID3v1({}), empty)
self.assertEquals(MakeID3v1({'TCON': TCON()}), empty)
self.assertEquals(
MakeID3v1({'COMM': COMM(encoding=0, text="")}), empty)
def test_make_v1_from_tyer(self):
from mutagen.id3 import ParseID3v1, MakeID3v1, TYER, TDRC
self.assertEquals(
MakeID3v1({"TDRC": TDRC(encoding=0, text="2010-10-10")}),
MakeID3v1({"TYER": TYER(encoding=0, text="2010")}))
self.assertEquals(
ParseID3v1(MakeID3v1({"TDRC": TDRC(encoding=0, text="2010-10-10")})),
ParseID3v1(MakeID3v1({"TYER": TYER(encoding=0, text="2010")})))
def test_invalid(self):
from mutagen.id3 import ParseID3v1
self.failUnless(ParseID3v1(b"") is None)
def test_invalid_track(self):
from mutagen.id3 import ParseID3v1, MakeID3v1, TRCK
tag = {}
tag["TRCK"] = TRCK(encoding=0, text="not a number")
v1tag = MakeID3v1(tag)
self.failIf("TRCK" in ParseID3v1(v1tag))
def test_v1_genre(self):
from mutagen.id3 import ParseID3v1, MakeID3v1, TCON
tag = {}
tag["TCON"] = TCON(encoding=0, text="Pop")
v1tag = MakeID3v1(tag)
self.failUnlessEqual(ParseID3v1(v1tag)["TCON"].genres, ["Pop"])
|
class ID3v1Tags(TestCase):
def setUp(self):
pass
def test_album(self):
pass
def test_genre(self):
pass
def test_title(self):
pass
def test_artist(self):
pass
def test_track(self):
pass
def test_year(self):
pass
def test_v1_not_v11(self):
pass
def test_nulls(self):
pass
def test_nonascii(self):
pass
def test_roundtrip(self):
pass
def test_make_from_empty(self):
pass
def test_make_v1_from_tyer(self):
pass
def test_invalid(self):
pass
def test_invalid_track(self):
pass
def test_v1_genre(self):
pass
| 17 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 8 | 6 | 0 | 16 | 2 | 16 | 91 | 97 | 11 | 86 | 45 | 60 | 0 | 80 | 45 | 54 | 2 | 3 | 1 | 17 |
147,072 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.Issue21
|
class Issue21(TestCase):
# Files with bad extended header flags failed to read tags.
# Ensure the extended header is turned off, and the frames are
# read.
def setUp(self):
self.id3 = ID3(join('tests', 'data', 'issue_21.id3'))
def test_no_ext(self):
self.failIf(self.id3.f_extended)
def test_has_tags(self):
self.failUnless("TIT2" in self.id3)
self.failUnless("TALB" in self.id3)
def test_tit2_value(self):
self.failUnlessEqual(self.id3["TIT2"].text, [u"Punk To Funk"])
|
class Issue21(TestCase):
def setUp(self):
pass
def test_no_ext(self):
pass
def test_has_tags(self):
pass
def test_tit2_value(self):
pass
| 5 | 0 | 2 | 0 | 2 | 0 | 1 | 0.3 | 1 | 1 | 1 | 0 | 4 | 1 | 4 | 79 | 17 | 4 | 10 | 6 | 5 | 3 | 10 | 6 | 5 | 1 | 3 | 0 | 4 |
147,073 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.Issue69_BadV1Year
|
class Issue69_BadV1Year(TestCase):
def test_missing_year(self):
from mutagen.id3 import ParseID3v1
tag = ParseID3v1(b'ABCTAGhello world\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff')
self.failUnlessEqual(tag["TIT2"], "hello world")
def test_short_year(self):
from mutagen.id3 import ParseID3v1
tag = ParseID3v1(b'XTAGhello world\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x001\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff')
self.failUnlessEqual(tag["TIT2"], "hello world")
self.failUnlessEqual(tag["TDRC"], "0001")
def test_none(self):
from mutagen.id3 import ParseID3v1, MakeID3v1
s = MakeID3v1(dict())
self.failUnlessEqual(len(s), 128)
tag = ParseID3v1(s)
self.failIf("TDRC" in tag)
def test_empty(self):
from mutagen.id3 import ParseID3v1, MakeID3v1
s = MakeID3v1(dict(TDRC=""))
self.failUnlessEqual(len(s), 128)
tag = ParseID3v1(s)
self.failIf("TDRC" in tag)
def test_short(self):
from mutagen.id3 import ParseID3v1, MakeID3v1
s = MakeID3v1(dict(TDRC="1"))
self.failUnlessEqual(len(s), 128)
tag = ParseID3v1(s)
self.failUnlessEqual(tag["TDRC"], "0001")
def test_long(self):
from mutagen.id3 import ParseID3v1, MakeID3v1
s = MakeID3v1(dict(TDRC="123456789"))
self.failUnlessEqual(len(s), 128)
tag = ParseID3v1(s)
self.failUnlessEqual(tag["TDRC"], "1234")
|
class Issue69_BadV1Year(TestCase):
def test_missing_year(self):
pass
def test_short_year(self):
pass
def test_none(self):
pass
def test_empty(self):
pass
def test_short_year(self):
pass
def test_long(self):
pass
| 7 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 6 | 0 | 6 | 81 | 40 | 6 | 34 | 23 | 21 | 0 | 34 | 23 | 21 | 1 | 3 | 0 | 6 |
147,074 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggopus.py
|
mutagen.oggopus.OggOpusInfo
|
class OggOpusInfo(StreamInfo):
"""Ogg Opus stream information.
Attributes:
* length - file length in seconds, as a float
* channels - number of channels
"""
length = 0
def __init__(self, fileobj):
page = OggPage(fileobj)
while not page.packets[0].startswith(b"OpusHead"):
page = OggPage(fileobj)
self.serial = page.serial
if not page.first:
raise OggOpusHeaderError(
"page has ID header, but doesn't start a stream")
(version, self.channels, pre_skip, orig_sample_rate, output_gain,
channel_map) = struct.unpack("<BBHIhB", page.packets[0][8:19])
self.__pre_skip = pre_skip
# only the higher 4 bits change on incombatible changes
major, minor = version >> 4, version & 0xF
if major != 0:
raise OggOpusHeaderError("version %r unsupported" % major)
def _post_tags(self, fileobj):
page = OggPage.find_last(fileobj, self.serial)
self.length = (page.position - self.__pre_skip) / float(48000)
def pprint(self):
return u"Ogg Opus, %.2f seconds" % (self.length)
|
class OggOpusInfo(StreamInfo):
'''Ogg Opus stream information.
Attributes:
* length - file length in seconds, as a float
* channels - number of channels
'''
def __init__(self, fileobj):
pass
def _post_tags(self, fileobj):
pass
def pprint(self):
pass
| 4 | 1 | 8 | 2 | 6 | 0 | 2 | 0.29 | 1 | 3 | 2 | 0 | 3 | 3 | 3 | 4 | 38 | 11 | 21 | 12 | 17 | 6 | 19 | 11 | 15 | 4 | 2 | 1 | 6 |
147,075 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggopus.py
|
mutagen.oggopus.OggOpusVComment
|
class OggOpusVComment(VCommentDict):
"""Opus comments embedded in an Ogg bitstream."""
def __get_comment_pages(self, fileobj, info):
# find the first tags page with the right serial
page = OggPage(fileobj)
while ((info.serial != page.serial) or
not page.packets[0].startswith(b'OpusTags')):
page = OggPage(fileobj)
# get all comment pages
pages = [page]
while not (pages[-1].complete or len(pages[-1].packets) > 1):
page = OggPage(fileobj)
if page.serial == pages[0].serial:
pages.append(page)
return pages
def __init__(self, fileobj, info):
pages = self.__get_comment_pages(fileobj, info)
data = OggPage.to_packets(pages)[0][8:] # Strip OpusTags
super(OggOpusVComment, self).__init__(data, framing=False)
def _inject(self, fileobj):
fileobj.seek(0)
info = OggOpusInfo(fileobj)
old_pages = self.__get_comment_pages(fileobj, info)
packets = OggPage.to_packets(old_pages)
packets[0] = b"OpusTags" + self.write(framing=False)
new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
OggPage.replace(fileobj, old_pages, new_pages)
|
class OggOpusVComment(VCommentDict):
'''Opus comments embedded in an Ogg bitstream.'''
def __get_comment_pages(self, fileobj, info):
pass
def __init__(self, fileobj, info):
pass
def _inject(self, fileobj):
pass
| 4 | 1 | 9 | 1 | 8 | 1 | 2 | 0.17 | 1 | 3 | 2 | 0 | 3 | 0 | 3 | 26 | 33 | 6 | 24 | 12 | 20 | 4 | 23 | 12 | 19 | 4 | 2 | 2 | 6 |
147,076 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggspeex.py
|
mutagen.oggspeex.OggSpeex
|
class OggSpeex(OggFileType):
"""An Ogg Speex file."""
_Info = OggSpeexInfo
_Tags = OggSpeexVComment
_Error = OggSpeexHeaderError
_mimes = ["audio/x-speex"]
@staticmethod
def score(filename, fileobj, header):
return (header.startswith(b"OggS") * (b"Speex " in header))
|
class OggSpeex(OggFileType):
'''An Ogg Speex 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,077 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggspeex.py
|
mutagen.oggspeex.OggSpeexInfo
|
class OggSpeexInfo(StreamInfo):
"""Ogg Speex stream information.
Attributes:
* bitrate - nominal bitrate in bits per second
* channels - number of channels
* length - file length in seconds, as a float
The reference encoder does not set the bitrate; in this case,
the bitrate will be 0.
"""
length = 0
def __init__(self, fileobj):
page = OggPage(fileobj)
while not page.packets[0].startswith(b"Speex "):
page = OggPage(fileobj)
if not page.first:
raise OggSpeexHeaderError(
"page has ID header, but doesn't start a stream")
self.sample_rate = cdata.uint_le(page.packets[0][36:40])
self.channels = cdata.uint_le(page.packets[0][48:52])
self.bitrate = max(0, cdata.int_le(page.packets[0][52:56]))
self.serial = page.serial
def _post_tags(self, fileobj):
page = OggPage.find_last(fileobj, self.serial)
self.length = page.position / float(self.sample_rate)
def pprint(self):
return u"Ogg Speex, %.2f seconds" % self.length
|
class OggSpeexInfo(StreamInfo):
'''Ogg Speex stream information.
Attributes:
* bitrate - nominal bitrate in bits per second
* channels - number of channels
* length - file length in seconds, as a float
The reference encoder does not set the bitrate; in this case,
the bitrate will be 0.
'''
def __init__(self, fileobj):
pass
def _post_tags(self, fileobj):
pass
def pprint(self):
pass
| 4 | 1 | 5 | 0 | 5 | 0 | 2 | 0.44 | 1 | 4 | 3 | 0 | 3 | 4 | 3 | 4 | 33 | 7 | 18 | 11 | 14 | 8 | 17 | 11 | 13 | 3 | 2 | 1 | 5 |
147,078 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggspeex.py
|
mutagen.oggspeex.OggSpeexVComment
|
class OggSpeexVComment(VCommentDict):
"""Speex 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] + b"\x01"
super(OggSpeexVComment, self).__init__(data, framing=False)
def _inject(self, fileobj):
"""Write tag data into the Speex comment packet/page."""
fileobj.seek(0)
# Find the first header page, with the stream info.
# Use it to get the serial number.
page = OggPage(fileobj)
while not page.packets[0].startswith(b"Speex "):
page = OggPage(fileobj)
# Look for the next page with that serial number, it'll start
# the comment packet.
serial = page.serial
page = OggPage(fileobj)
while page.serial != serial:
page = OggPage(fileobj)
# Then find all the pages with the comment packet.
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] = self.write(framing=False)
new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
OggPage.replace(fileobj, old_pages, new_pages)
|
class OggSpeexVComment(VCommentDict):
'''Speex comments embedded in an Ogg bitstream.'''
def __init__(self, fileobj, info):
pass
def _inject(self, fileobj):
'''Write tag data into the Speex comment packet/page.'''
pass
| 3 | 2 | 21 | 4 | 14 | 4 | 4 | 0.28 | 1 | 2 | 1 | 0 | 2 | 0 | 2 | 25 | 46 | 9 | 29 | 12 | 26 | 8 | 29 | 12 | 26 | 5 | 2 | 2 | 8 |
147,079 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggtheora.py
|
mutagen.oggtheora.OggTheora
|
class OggTheora(OggFileType):
"""An Ogg Theora file."""
_Info = OggTheoraInfo
_Tags = OggTheoraCommentDict
_Error = OggTheoraHeaderError
_mimes = ["video/x-theora"]
@staticmethod
def score(filename, fileobj, header):
return (header.startswith(b"OggS") *
((b"\x80theora" in header) + (b"\x81theora" in header)))
|
class OggTheora(OggFileType):
'''An Ogg Theora file.'''
@staticmethod
def score(filename, fileobj, header):
pass
| 3 | 1 | 3 | 0 | 3 | 0 | 1 | 0.11 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 17 | 12 | 2 | 9 | 7 | 6 | 1 | 7 | 6 | 5 | 1 | 3 | 0 | 1 |
147,080 |
LordSputnik/mutagen
|
/Users/umroot/Documents/PhD_works/PhD-Core-Contents/Class-level-dataset-curation/data/git_repos_for_analysis/LordSputnik_mutagen/mutagen/apev2.py
|
mutagen.apev2.APEv2File._Info
|
class _Info(StreamInfo):
length = 0
bitrate = 0
def __init__(self, fileobj):
pass
@staticmethod
def pprint():
return u"Unknown format with APEv2 tag."
|
class _Info(StreamInfo):
def __init__(self, fileobj):
pass
@staticmethod
def pprint():
pass
| 4 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 2 | 3 | 10 | 2 | 8 | 6 | 4 | 0 | 7 | 5 | 4 | 1 | 2 | 0 | 2 |
147,081 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_id3.py
|
tests.test_id3.Issue97_UpgradeUnknown23
|
class Issue97_UpgradeUnknown23(TestCase):
SILENCE = os.path.join("tests", "data", "97-unknown-23-update.mp3")
def setUp(self):
from tempfile import mkstemp
fd, self.filename = mkstemp(suffix='.mp3')
os.close(fd)
shutil.copy(self.SILENCE, self.filename)
def test_unknown(self):
from mutagen.id3 import TPE1
orig = ID3(self.filename)
self.failUnlessEqual(orig.version, (2, 3, 0))
# load a 2.3 file and pretend we don't support TIT2
unknown = ID3(self.filename, known_frames={"TPE1": TPE1},
translate=False)
# TIT2 ends up in unknown_frames
self.failUnlessEqual(unknown.unknown_frames[0][:4], b"TIT2")
# frame should be different now
orig_unknown = unknown.unknown_frames[0]
unknown.update_to_v24()
self.failIfEqual(unknown.unknown_frames[0], orig_unknown)
# save as 2.4
unknown.save()
# load again with support for TIT2, all should be there again
new = ID3(self.filename)
self.failUnlessEqual(new.version, (2, 4, 0))
self.failUnlessEqual(new["TIT2"].text, orig["TIT2"].text)
self.failUnlessEqual(new["TPE1"].text, orig["TPE1"].text)
def test_double_update(self):
from mutagen.id3 import TPE1
unknown = ID3(self.filename, known_frames={"TPE1": TPE1})
# Make sure the data doesn't get updated again
unknown.update_to_v24()
unknown.unknown_frames = ["foobar"]
unknown.update_to_v24()
self.failUnless(unknown.unknown_frames)
def test_unkown_invalid(self):
f = ID3(self.filename, translate=False)
f.unknown_frames = [b"foobar", b"\xff"*50]
# throw away invalid frames
f.update_to_v24()
self.failIf(f.unknown_frames)
def tearDown(self):
os.unlink(self.filename)
|
class Issue97_UpgradeUnknown23(TestCase):
def setUp(self):
pass
def test_unknown(self):
pass
def test_double_update(self):
pass
def test_unkown_invalid(self):
pass
def tearDown(self):
pass
| 6 | 0 | 9 | 1 | 7 | 1 | 1 | 0.19 | 1 | 2 | 2 | 0 | 5 | 1 | 5 | 80 | 52 | 9 | 36 | 17 | 27 | 7 | 35 | 17 | 26 | 1 | 3 | 0 | 5 |
147,082 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TSeekTable
|
class TSeekTable(TestCase):
SAMPLE = os.path.join("tests", "data", "silence-44-s.flac")
def setUp(self):
self.flac = FLAC(self.SAMPLE)
self.st = self.flac.seektable
def test_seektable(self):
self.failUnlessEqual(self.st.seekpoints,
[(0, 0, 4608),
(41472, 11852, 4608),
(50688, 14484, 4608),
(87552, 25022, 4608),
(105984, 30284, 4608),
(0xFFFFFFFFFFFFFFFF, 0, 0)])
def test_eq(self):
self.failUnlessEqual(self.st, self.st)
def test_neq(self):
self.failIfEqual(self.st, 12)
def test_repr(self):
repr(self.st)
def test_roundtrip(self):
self.failUnlessEqual(SeekTable(self.st.write()), self.st)
|
class TSeekTable(TestCase):
def setUp(self):
pass
def test_seektable(self):
pass
def test_eq(self):
pass
def test_neq(self):
pass
def test_repr(self):
pass
def test_roundtrip(self):
pass
| 7 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 6 | 2 | 6 | 81 | 27 | 6 | 21 | 10 | 14 | 0 | 15 | 10 | 8 | 1 | 3 | 0 | 6 |
147,083 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TMetadataBlock
|
class TMetadataBlock(TestCase):
def test_empty(self):
self.failUnlessEqual(MetadataBlock(b"").write(), b"")
def test_not_empty(self):
self.failUnlessEqual(MetadataBlock(b"foobar").write(), b"foobar")
def test_change(self):
b = MetadataBlock(b"foobar")
b.data = b"quux"
self.failUnlessEqual(b.write(), b"quux")
def test_writeblocks(self):
blocks = [Padding(b"\x00" * 20), Padding(b"\x00" * 30)]
self.failUnlessEqual(len(MetadataBlock.writeblocks(blocks)), 58)
def test_ctr_garbage(self):
self.failUnlessRaises(TypeError, StreamInfo, 12)
def test_group_padding(self):
blocks = [Padding(b"\x00" * 20), Padding(b"\x00" * 30),
MetadataBlock(b"foobar")]
blocks[-1].code = 0
length1 = len(MetadataBlock.writeblocks(blocks))
MetadataBlock.group_padding(blocks)
length2 = len(MetadataBlock.writeblocks(blocks))
self.failUnlessEqual(length1, length2)
self.failUnlessEqual(len(blocks), 2)
|
class TMetadataBlock(TestCase):
def test_empty(self):
pass
def test_not_empty(self):
pass
def test_change(self):
pass
def test_writeblocks(self):
pass
def test_ctr_garbage(self):
pass
def test_group_padding(self):
pass
| 7 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 4 | 3 | 0 | 6 | 0 | 6 | 81 | 29 | 6 | 23 | 12 | 16 | 0 | 22 | 12 | 15 | 1 | 3 | 0 | 6 |
147,084 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFUpdateSize
|
class TASFUpdateSize(TestCase):
original = os.path.join("tests", "data", "silence-1.wma")
def setUp(self):
fd, self.filename = mkstemp(suffix='wma')
os.close(fd)
shutil.copy(self.original, self.filename)
audio = ASF(self.filename)
audio["large_value1"] = "#"*50000
audio.save()
def tearDown(self):
os.unlink(self.filename)
def test_multiple_delete(self):
audio = ASF(self.filename)
for tag in audio.keys():
del(audio[tag])
audio.save()
|
class TASFUpdateSize(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_multiple_delete(self):
pass
| 4 | 0 | 5 | 0 | 5 | 0 | 1 | 0.06 | 1 | 1 | 1 | 0 | 3 | 1 | 3 | 78 | 20 | 4 | 16 | 9 | 12 | 1 | 16 | 9 | 12 | 2 | 3 | 1 | 4 |
147,085 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFInfo
|
class TASFInfo(TestCase):
def setUp(self):
# WMA 9.1 64kbps CBR 48khz
self.wma1 = ASF(os.path.join("tests", "data", "silence-1.wma"))
# WMA 9.1 Professional 192kbps VBR 44khz
self.wma2 = ASF(os.path.join("tests", "data", "silence-2.wma"))
# WMA 9.1 Lossless 44khz
self.wma3 = ASF(os.path.join("tests", "data", "silence-3.wma"))
def test_length(self):
self.failUnlessAlmostEqual(self.wma1.info.length, 3.7, 1)
self.failUnlessAlmostEqual(self.wma2.info.length, 3.7, 1)
self.failUnlessAlmostEqual(self.wma3.info.length, 3.7, 1)
def test_bitrate(self):
self.failUnlessEqual(self.wma1.info.bitrate // 1000, 64)
self.failUnlessEqual(self.wma2.info.bitrate // 1000, 38)
self.failUnlessEqual(self.wma3.info.bitrate // 1000, 58)
def test_sample_rate(self):
self.failUnlessEqual(self.wma1.info.sample_rate, 48000)
self.failUnlessEqual(self.wma2.info.sample_rate, 44100)
self.failUnlessEqual(self.wma3.info.sample_rate, 44100)
def test_channels(self):
self.failUnlessEqual(self.wma1.info.channels, 2)
self.failUnlessEqual(self.wma2.info.channels, 2)
self.failUnlessEqual(self.wma3.info.channels, 2)
|
class TASFInfo(TestCase):
def setUp(self):
pass
def test_length(self):
pass
def test_bitrate(self):
pass
def test_sample_rate(self):
pass
def test_channels(self):
pass
| 6 | 0 | 5 | 0 | 4 | 1 | 1 | 0.14 | 1 | 1 | 1 | 0 | 5 | 3 | 5 | 80 | 29 | 5 | 21 | 9 | 15 | 3 | 21 | 9 | 15 | 1 | 3 | 0 | 5 |
147,086 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFIssue29
|
class TASFIssue29(TestCase):
original = os.path.join("tests", "data", "issue_29.wma")
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_issue_29_description(self):
self.audio["Description"] = "Hello"
self.audio.save()
audio = ASF(self.filename)
self.failUnless("Description" in audio)
self.failUnlessEqual(audio["Description"], ["Hello"])
del(audio["Description"])
self.failIf("Description" in audio)
audio.save()
audio = ASF(self.filename)
self.failIf("Description" in audio)
|
class TASFIssue29(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_issue_29_description(self):
pass
| 4 | 0 | 6 | 0 | 6 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 3 | 2 | 3 | 78 | 22 | 2 | 20 | 8 | 16 | 0 | 20 | 8 | 16 | 1 | 3 | 0 | 3 |
147,087 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_asf.py
|
tests.test_asf.TASFLargeValue
|
class TASFLargeValue(TestCase):
original = os.path.join("tests", "data", "silence-1.wma")
def setUp(self):
fd, self.filename = mkstemp(suffix='wma')
os.close(fd)
shutil.copy(self.original, self.filename)
def tearDown(self):
os.unlink(self.filename)
def test_save_small_bytearray(self):
audio = ASF(self.filename)
audio["QL/LargeObject"] = [ASFValue(b"." * 0xFFFF, BYTEARRAY)]
audio.save()
self.failIf("QL/LargeObject" not in audio.to_extended_content_description)
self.failIf("QL/LargeObject" in audio.to_metadata)
self.failIf("QL/LargeObject" in dict(audio.to_metadata_library))
def test_save_large_bytearray(self):
audio = ASF(self.filename)
audio["QL/LargeObject"] = [ASFValue(b"." * (0xFFFF + 1), BYTEARRAY)]
audio.save()
self.failIf("QL/LargeObject" in audio.to_extended_content_description)
self.failIf("QL/LargeObject" in audio.to_metadata)
self.failIf("QL/LargeObject" not in dict(audio.to_metadata_library))
def test_save_small_string(self):
audio = ASF(self.filename)
audio["QL/LargeObject"] = [ASFValue("." * (0x7FFF - 1), UNICODE)]
audio.save()
self.failIf("QL/LargeObject" not in audio.to_extended_content_description)
self.failIf("QL/LargeObject" in audio.to_metadata)
self.failIf("QL/LargeObject" in dict(audio.to_metadata_library))
def test_save_large_string(self):
audio = ASF(self.filename)
audio["QL/LargeObject"] = [ASFValue("." * 0x7FFF, UNICODE)]
audio.save()
self.failIf("QL/LargeObject" in audio.to_extended_content_description)
self.failIf("QL/LargeObject" in audio.to_metadata)
self.failIf("QL/LargeObject" not in dict(audio.to_metadata_library))
def test_save_guid(self):
# http://code.google.com/p/mutagen/issues/detail?id=81
audio = ASF(self.filename)
audio["QL/GuidObject"] = [ASFValue(b' '*16, GUID)]
audio.save()
self.failIf("QL/GuidObject" in audio.to_extended_content_description)
self.failIf("QL/GuidObject" in audio.to_metadata)
self.failIf("QL/GuidObject" not in dict(audio.to_metadata_library))
|
class TASFLargeValue(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_save_small_bytearray(self):
pass
def test_save_large_bytearray(self):
pass
def test_save_small_string(self):
pass
def test_save_large_string(self):
pass
def test_save_guid(self):
pass
| 8 | 0 | 6 | 0 | 6 | 0 | 1 | 0.02 | 1 | 2 | 1 | 0 | 7 | 1 | 7 | 82 | 52 | 8 | 43 | 15 | 35 | 1 | 43 | 15 | 35 | 1 | 3 | 0 | 7 |
147,088 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TOA
|
class TOA(TOPE):
"Original Artist/Perfomer"
|
class TOA(TOPE):
'''Original Artist/Perfomer'''
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 | 4 | 0 | 0 |
147,089 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/__init__.py
|
tests.TestCase
|
class TestCase(BaseTestCase):
def failUnlessRaisesRegexp(self, exc, re_, fun, *args, **kwargs):
def wrapped(*args, **kwargs):
try:
fun(*args, **kwargs)
except Exception as e:
self.failUnless(re.search(re_, str(e)))
raise
self.failUnlessRaises(exc, wrapped, *args, **kwargs)
# silence deprec warnings about useless renames
failUnless = BaseTestCase.assertTrue
failIf = BaseTestCase.assertFalse
failUnlessEqual = BaseTestCase.assertEqual
failUnlessRaises = BaseTestCase.assertRaises
failUnlessAlmostEqual = BaseTestCase.assertAlmostEqual
failIfEqual = BaseTestCase.assertNotEqual
failIfAlmostEqual = BaseTestCase.assertNotAlmostEqual
def assertReallyEqual(self, a, b):
self.assertEqual(a, b)
self.assertEqual(b, a)
self.assertTrue(a == b)
self.assertTrue(b == a)
self.assertFalse(a != b)
self.assertFalse(b != a)
def assertReallyNotEqual(self, a, b):
self.assertNotEqual(a, b)
self.assertNotEqual(b, a)
self.assertFalse(a == b)
self.assertFalse(b == a)
self.assertTrue(a != b)
self.assertTrue(b != a)
|
class TestCase(BaseTestCase):
def failUnlessRaisesRegexp(self, exc, re_, fun, *args, **kwargs):
pass
def wrapped(*args, **kwargs):
pass
def assertReallyEqual(self, a, b):
pass
def assertReallyNotEqual(self, a, b):
pass
| 5 | 0 | 7 | 0 | 7 | 0 | 1 | 0.03 | 1 | 2 | 0 | 96 | 3 | 0 | 3 | 75 | 35 | 4 | 30 | 13 | 25 | 1 | 30 | 12 | 25 | 2 | 2 | 1 | 5 |
147,090 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/__init__.py
|
tests.Runner
|
class Runner(object):
def run(self, test):
suite = unittest.makeSuite(test)
pref = '%s (%d): ' % (test.__name__, len(suite._tests))
print(pref + " " * (25 - len(pref)), end='')
result = Result()
suite(result)
result.printErrors()
return bool(result.failures + result.errors)
|
class Runner(object):
def run(self, test):
pass
| 2 | 0 | 8 | 0 | 8 | 0 | 1 | 0 | 1 | 2 | 1 | 0 | 1 | 0 | 1 | 1 | 9 | 0 | 9 | 5 | 7 | 0 | 9 | 5 | 7 | 1 | 1 | 0 | 1 |
147,091 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/__init__.py
|
tests.Result
|
class Result(unittest.TestResult):
separator1 = '=' * 70
separator2 = '-' * 70
def addSuccess(self, test):
unittest.TestResult.addSuccess(self, test)
sys.stdout.write('.')
def addError(self, test, err):
unittest.TestResult.addError(self, test, err)
sys.stdout.write('E')
def addFailure(self, test, err):
unittest.TestResult.addFailure(self, test, err)
sys.stdout.write('F')
def printErrors(self):
succ = self.testsRun - (len(self.errors) + len(self.failures))
v = "%3d" % succ
count = 50 - self.testsRun
sys.stdout.write((" " * count) + v + "\n")
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)
def printErrorList(self, flavour, errors):
for test, err in errors:
sys.stdout.write(self.separator1 + "\n")
sys.stdout.write("%s: %s\n" % (flavour, str(test)))
sys.stdout.write(self.separator2 + "\n")
sys.stdout.write("%s\n" % err)
|
class Result(unittest.TestResult):
def addSuccess(self, test):
pass
def addError(self, test, err):
pass
def addFailure(self, test, err):
pass
def printErrors(self):
pass
def printErrorList(self, flavour, errors):
pass
| 6 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 5 | 0 | 5 | 27 | 31 | 6 | 25 | 12 | 19 | 0 | 25 | 12 | 19 | 2 | 2 | 1 | 6 |
147,092 |
LordSputnik/mutagen
|
LordSputnik_mutagen/setup.py
|
setup.test_cmd
|
class test_cmd(Command):
description = "run automated tests"
user_options = [
("to-run=", None, "list of tests to run (default all)"),
("quick", None, "don't run slow mmap-failing tests"),
]
def initialize_options(self):
self.to_run = []
self.quick = False
def finalize_options(self):
if self.to_run:
self.to_run = self.to_run.split(",")
def run(self):
import tests
count, failures = tests.unit(self.to_run, self.quick)
if failures:
print("%d out of %d failed" % (failures, count))
raise SystemExit("Test failures are listed above.")
else:
print("All tests passed")
|
class test_cmd(Command):
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
pass
| 4 | 0 | 5 | 0 | 5 | 0 | 2 | 0 | 1 | 1 | 0 | 0 | 3 | 2 | 3 | 33 | 24 | 4 | 20 | 10 | 15 | 0 | 16 | 10 | 11 | 2 | 1 | 1 | 5 |
147,093 |
LordSputnik/mutagen
|
LordSputnik_mutagen/setup.py
|
setup.distcheck
|
class distcheck(sdist):
def _check_manifest(self):
assert self.get_archive_files()
# make sure MANIFEST.in includes all tracked files
if subprocess.call(["hg", "status"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE) == 0:
# contains the packaged files after run() is finished
included_files = self.filelist.files
assert included_files
process = subprocess.Popen(["hg", "locate"],
stdout=subprocess.PIPE)
out, err = process.communicate()
assert process.returncode == 0
tracked_files = out.splitlines()
for ignore in [".hgignore", ".hgtags"]:
tracked_files.remove(ignore)
assert not set(tracked_files) - set(included_files), \
"Not all tracked files included in tarball, update MANIFEST.in"
def _check_dist(self):
assert self.get_archive_files()
distcheck_dir = os.path.join(self.dist_dir, "distcheck")
if os.path.exists(distcheck_dir):
dir_util.remove_tree(distcheck_dir)
self.mkpath(distcheck_dir)
archive = self.get_archive_files()[0]
tfile = tarfile.open(archive, "r:gz")
tfile.extractall(distcheck_dir)
tfile.close()
name = self.distribution.get_fullname()
extract_dir = os.path.join(distcheck_dir, name)
old_pwd = os.getcwd()
os.chdir(extract_dir)
self.spawn([sys.executable, "setup.py", "test"])
self.spawn([sys.executable, "setup.py", "build"])
self.spawn([sys.executable, "setup.py", "build_sphinx"])
self.spawn([sys.executable, "setup.py", "install",
"--prefix", "../prefix", "--record", "../log.txt"])
os.environ["LC_ALL"] = "C"
self.spawn([sys.executable, "setup.py", "test", "--quick"])
os.chdir(old_pwd)
def run(self):
sdist.run(self)
self._check_manifest()
self._check_dist()
|
class distcheck(sdist):
def _check_manifest(self):
pass
def _check_dist(self):
pass
def run(self):
pass
| 4 | 0 | 17 | 3 | 14 | 1 | 2 | 0.05 | 1 | 2 | 0 | 0 | 3 | 0 | 3 | 56 | 56 | 11 | 43 | 15 | 39 | 2 | 38 | 15 | 34 | 3 | 2 | 2 | 6 |
147,094 |
LordSputnik/mutagen
|
LordSputnik_mutagen/setup.py
|
setup.coverage_cmd
|
class coverage_cmd(Command):
description = "generate test coverage data"
user_options = [
("quick", None, "don't run slow mmap-failing tests"),
]
def initialize_options(self):
self.quick = None
def finalize_options(self):
self.quick = bool(self.quick)
def run(self):
import trace
tracer = trace.Trace(
count=True, trace=False,
ignoredirs=[sys.prefix, sys.exec_prefix])
def run_tests():
import mutagen
import mutagen._util
reload(mutagen._util)
reload(mutagen)
cmd = self.reinitialize_command("test")
cmd.quick = self.quick
cmd.ensure_finalized()
cmd.run()
tracer.runfunc(run_tests)
results = tracer.results()
coverage = os.path.join(os.path.dirname(__file__), "coverage")
results.write_results(show_missing=True, coverdir=coverage)
for match in glob.glob(os.path.join(coverage, "[!m]*.cover")):
os.unlink(match)
try:
os.unlink(os.path.join(coverage, "..setup.cover"))
except OSError:
pass
total_lines = 0
bad_lines = 0
for filename in glob.glob(os.path.join(coverage, "*.cover")):
lines = open(filename, "rU").readlines()
total_lines += len(lines)
bad_lines += len(
[line for line in lines if
(line.startswith(">>>>>>") and
"finally:" not in line and '"""' not in line)])
pct = 100.0 * (total_lines - bad_lines) / float(total_lines)
print("Coverage data written to %s (%d/%d, %0.2f%%)" % (
coverage, total_lines - bad_lines, total_lines, pct))
if pct < 98.66:
raise SystemExit(
"Coverage percentage went down; write more tests.")
if pct > 98.7:
raise SystemExit("Coverage percentage went up; change setup.py.")
|
class coverage_cmd(Command):
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
pass
def run_tests():
pass
| 5 | 0 | 15 | 2 | 14 | 0 | 2 | 0 | 1 | 5 | 0 | 0 | 3 | 1 | 3 | 33 | 59 | 9 | 50 | 21 | 42 | 0 | 41 | 21 | 33 | 6 | 1 | 1 | 9 |
147,095 |
LordSputnik/mutagen
|
LordSputnik_mutagen/setup.py
|
setup.clean
|
class clean(distutils_clean):
def run(self):
# In addition to what the normal clean run does, remove pyc
# and pyo and backup files from the source tree.
distutils_clean.run(self)
def should_remove(filename):
if (filename.lower()[-4:] in [".pyc", ".pyo"] or
filename.endswith("~") or
(filename.startswith("#") and filename.endswith("#"))):
return True
else:
return False
for pathname, dirs, files in os.walk(os.path.dirname(__file__)):
for filename in files:
if should_remove(filename):
try:
os.unlink(os.path.join(pathname, filename))
except EnvironmentError as err:
print(str(err))
try:
os.unlink("MANIFEST")
except OSError:
pass
for base in ["coverage", "build", "dist"]:
path = os.path.join(os.path.dirname(__file__), base)
if os.path.isdir(path):
shutil.rmtree(path)
|
class clean(distutils_clean):
def run(self):
pass
def should_remove(filename):
pass
| 3 | 0 | 18 | 2 | 16 | 2 | 5 | 0.12 | 1 | 2 | 0 | 0 | 1 | 0 | 1 | 34 | 30 | 3 | 25 | 8 | 22 | 3 | 22 | 7 | 19 | 8 | 2 | 4 | 10 |
147,096 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TPicture
|
class TPicture(TestCase):
SAMPLE = os.path.join("tests", "data", "silence-44-s.flac")
def setUp(self):
self.flac = FLAC(self.SAMPLE)
self.p = self.flac.pictures[0]
def test_count(self):
self.failUnlessEqual(len(self.flac.pictures), 1)
def test_picture(self):
self.failUnlessEqual(self.p.width, 1)
self.failUnlessEqual(self.p.height, 1)
self.failUnlessEqual(self.p.depth, 24)
self.failUnlessEqual(self.p.colors, 0)
self.failUnlessEqual(self.p.mime, u'image/png')
self.failUnlessEqual(self.p.desc, u'A pixel.')
self.failUnlessEqual(self.p.type, 3)
self.failUnlessEqual(len(self.p.data), 150)
def test_eq(self):
self.failUnlessEqual(self.p, self.p)
def test_neq(self):
self.failIfEqual(self.p, 12)
def test_repr(self):
repr(self.p)
def test_roundtrip(self):
self.failUnlessEqual(Picture(self.p.write()), self.p)
|
class TPicture(TestCase):
def setUp(self):
pass
def test_count(self):
pass
def test_picture(self):
pass
def test_eq(self):
pass
def test_neq(self):
pass
def test_repr(self):
pass
def test_roundtrip(self):
pass
| 8 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 7 | 2 | 7 | 82 | 31 | 7 | 24 | 11 | 16 | 0 | 24 | 11 | 16 | 1 | 3 | 0 | 7 |
147,097 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.TCON
|
class TCON(TextFrame):
"""Content type (Genre)
ID3 has several ways genres can be represented; for convenience,
use the 'genres' property rather than the 'text' attribute.
"""
from mutagen._constants import GENRES
GENRES = GENRES
def __get_genres(self):
genres = []
import re
genre_re = re.compile(r"((?:\((?P<id>[0-9]+|RX|CR)\))*)(?P<str>.+)?")
for value in self.text:
# 255 possible entries in id3v1
if value.isdigit() and int(value) < 256:
try:
genres.append(self.GENRES[int(value)])
except IndexError:
genres.append(u"Unknown")
elif value == "CR":
genres.append(u"Cover")
elif value == "RX":
genres.append(u"Remix")
elif value:
newgenres = []
genreid, dummy, genrename = genre_re.match(value).groups()
if genreid:
for gid in genreid[1:-1].split(")("):
if gid.isdigit() and int(gid) < len(self.GENRES):
gid = text_type(self.GENRES[int(gid)])
newgenres.append(gid)
elif gid == "CR":
newgenres.append(u"Cover")
elif gid == "RX":
newgenres.append(u"Remix")
else:
newgenres.append(u"Unknown")
if genrename:
# "Unescaping" the first parenthesis
if genrename.startswith("(("):
genrename = genrename[1:]
if genrename not in newgenres:
newgenres.append(genrename)
genres.extend(newgenres)
return genres
def __set_genres(self, genres):
if isinstance(genres, string_types):
genres = [genres]
self.text = [self.__decode(g) for g in genres]
def __decode(self, value):
if isinstance(value, bytes):
enc = EncodedTextSpec._encodings[self.encoding][0]
return value.decode(enc)
else:
return value
genres = property(__get_genres, __set_genres, None,
"A list of genres parsed from the raw text data.")
def _pprint(self):
return " / ".join(self.genres)
|
class TCON(TextFrame):
'''Content type (Genre)
ID3 has several ways genres can be represented; for convenience,
use the 'genres' property rather than the 'text' attribute.
'''
def __get_genres(self):
pass
def __set_genres(self, genres):
pass
def __decode(self, value):
pass
def _pprint(self):
pass
| 5 | 1 | 13 | 1 | 12 | 1 | 5 | 0.12 | 1 | 4 | 1 | 1 | 4 | 1 | 4 | 25 | 69 | 11 | 52 | 16 | 45 | 6 | 44 | 16 | 37 | 15 | 3 | 5 | 20 |
147,098 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_easymp4.py
|
tests.test_easymp4.TEasyMP4
|
class TEasyMP4(TestCase):
def setUp(self):
fd, self.filename = mkstemp('.mp4')
os.close(fd)
empty = os.path.join('tests', 'data', 'has-tags.m4a')
shutil.copy(empty, self.filename)
self.mp4 = EasyMP4(self.filename)
self.mp4.delete()
def test_pprint(self):
self.mp4["artist"] = "baz"
self.mp4.pprint()
def test_in(self):
self.failIf("foo" in self.mp4)
def test_empty_file(self):
empty = os.path.join('tests', 'data', 'emptyfile.mp3')
self.assertRaises(MP4Error, EasyMP4, filename=empty)
def test_nonexistent_file(self):
empty = os.path.join('tests', 'data', 'does', 'not', 'exist')
self.assertRaises(IOError, EasyMP4, filename=empty)
def test_write_single(self):
for key in EasyMP4.Get:
if key in ["tracknumber", "discnumber", "date", "bpm"]:
continue
# Test creation
self.mp4[key] = "a test value"
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4[key], ["a test value"])
self.failUnlessEqual(list(mp4.keys()), [key])
# And non-creation setting.
self.mp4[key] = "a test value"
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4[key], ["a test value"])
self.failUnlessEqual(list(mp4.keys()), [key])
del(self.mp4[key])
def test_write_double(self):
for key in EasyMP4.Get:
if key in ["tracknumber", "discnumber", "date", "bpm"]:
continue
self.mp4[key] = ["a test", "value"]
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4.get(key), ["a test", "value"])
self.failUnlessEqual(list(mp4.keys()), [key])
self.mp4[key] = ["a test", "value"]
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4.get(key), ["a test", "value"])
self.failUnlessEqual(list(mp4.keys()), [key])
del(self.mp4[key])
def test_write_date(self):
self.mp4["date"] = "2004"
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4["date"], ["2004"])
self.mp4["date"] = "2004"
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4["date"], ["2004"])
def test_date_delete(self):
self.mp4["date"] = "2004"
self.failUnlessEqual(self.mp4["date"], ["2004"])
del(self.mp4["date"])
self.failIf("date" in self.mp4)
def test_write_date_double(self):
self.mp4["date"] = ["2004", "2005"]
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4["date"], ["2004", "2005"])
self.mp4["date"] = ["2004", "2005"]
self.mp4.save(self.filename)
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4["date"], ["2004", "2005"])
def test_write_invalid(self):
self.failUnlessRaises(ValueError, self.mp4.__getitem__, "notvalid")
self.failUnlessRaises(ValueError, self.mp4.__delitem__, "notvalid")
self.failUnlessRaises(
ValueError, self.mp4.__setitem__, "notvalid", "tests")
def test_numeric(self):
for tag in ["bpm"]:
self.mp4[tag] = "3"
self.failUnlessEqual(self.mp4[tag], ["3"])
self.mp4.save()
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4[tag], ["3"])
del(mp4[tag])
self.failIf(tag in mp4)
self.failUnlessRaises(KeyError, mp4.__delitem__, tag)
self.failUnlessRaises(
ValueError, self.mp4.__setitem__, tag, "hello")
def test_numeric_pairs(self):
for tag in ["tracknumber", "discnumber"]:
self.mp4[tag] = "3"
self.failUnlessEqual(self.mp4[tag], ["3"])
self.mp4.save()
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4[tag], ["3"])
del(mp4[tag])
self.failIf(tag in mp4)
self.failUnlessRaises(KeyError, mp4.__delitem__, tag)
self.mp4[tag] = "3/10"
self.failUnlessEqual(self.mp4[tag], ["3/10"])
self.mp4.save()
mp4 = EasyMP4(self.filename)
self.failUnlessEqual(mp4[tag], ["3/10"])
del(mp4[tag])
self.failIf(tag in mp4)
self.failUnlessRaises(KeyError, mp4.__delitem__, tag)
self.failUnlessRaises(
ValueError, self.mp4.__setitem__, tag, "hello")
def tearDown(self):
os.unlink(self.filename)
|
class TEasyMP4(TestCase):
def setUp(self):
pass
def test_pprint(self):
pass
def test_in(self):
pass
def test_empty_file(self):
pass
def test_nonexistent_file(self):
pass
def test_write_single(self):
pass
def test_write_double(self):
pass
def test_write_date(self):
pass
def test_date_delete(self):
pass
def test_write_date_double(self):
pass
def test_write_invalid(self):
pass
def test_numeric(self):
pass
def test_numeric_pairs(self):
pass
def tearDown(self):
pass
| 15 | 0 | 9 | 1 | 8 | 0 | 1 | 0.02 | 1 | 4 | 1 | 0 | 14 | 2 | 14 | 89 | 141 | 28 | 111 | 30 | 96 | 2 | 108 | 30 | 93 | 3 | 3 | 2 | 20 |
147,099 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.CVE20074619
|
class CVE20074619(TestCase):
# Tests to ensure Mutagen is not vulnerable to a number of security
# issues found in libFLAC.
# http://research.eeye.com/html/advisories/published/AD20071115.html
def test_1(self):
# "Editing any Metadata Block Size value to a large value such
# as 0xFFFFFFFF may result in a heap based overflow in the
# decoding software."
filename = os.path.join("tests", "data", "CVE-2007-4619-1.flac")
self.failUnlessRaises(IOError, FLAC, filename)
def test_2(self):
# "The second vulnerability lies within the parsing of any
# VORBIS Comment String Size fields. Settings this fields to
# an overly large size, such as 0xFFFFFFF, could also result
# in another heap-based overflow allowing arbitrary code to
# execute in the content of the decoding program."
filename = os.path.join("tests", "data", "CVE-2007-4619-2.flac")
self.failUnlessRaises(IOError, FLAC, filename)
# "By inserting an overly long VORBIS Comment data string along
# with an large VORBIS Comment data string size value (such as
# 0x000061A8 followed by 25,050 A's), applications that do not
# properly apply boundary checks will result in a stack-based
# buffer overflow."
#
# This is tested, among other places, in
# test_save_grown_split_setup_packet_reference which saves a
# comment field of 200K in size.
# Vulnerabilities 4-10 are the same thing for the picture block.
# Vulnerability 11 does not apply to Mutagen as it does not
# download images when given a redirect MIME type.
# "An overly large Padding length field value would set the basis
# for another heap overflow inside a vulnerable application. By
# setting this value to a large value such as 0xFFFFFFFF, a
# malformed FLAC file could cause a heap based corruption scenario
# when the memory for the Padding length is calculated without
# proper bounds checks."
# We should raise an IOError when trying to write such large
# blocks, or when reading blocks with an incorrect padding length.
# Although, I do wonder about the correctness of this
# vulnerability, since a padding length of 0xFFFFFFFF is
# impossible to store in a FLAC file.
def test_12_read(self):
filename = os.path.join("tests", "data", "CVE-2007-4619-12.flac")
self.failUnlessRaises(IOError, FLAC, filename)
def test_12_write_too_big(self):
filename = os.path.join("tests", "data", "silence-44-s.flac")
f = FLAC(filename)
# This size is too big to be an integer.
f.metadata_blocks[-1].length = 0xFFFFFFFFFFFFFFFF
self.failUnlessRaises(IOError, f.metadata_blocks[-1].write)
def test_12_write_too_big_for_flac(self):
from mutagen.flac import MetadataBlock
filename = os.path.join("tests", "data", "silence-44-s.flac")
f = FLAC(filename)
# This size is too big to be in a FLAC block but is overwise fine.
f.metadata_blocks[-1].length = 0x1FFFFFF
self.failUnlessRaises(
IOError, MetadataBlock.writeblocks, [f.metadata_blocks[-1]])
|
class CVE20074619(TestCase):
def test_1(self):
pass
def test_2(self):
pass
def test_12_read(self):
pass
def test_12_write_too_big(self):
pass
def test_12_write_too_big_for_flac(self):
pass
| 6 | 0 | 6 | 0 | 4 | 2 | 1 | 1.64 | 1 | 2 | 2 | 0 | 5 | 0 | 5 | 80 | 69 | 11 | 22 | 14 | 15 | 36 | 21 | 14 | 14 | 1 | 3 | 0 | 5 |
147,100 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.SYTC
|
class SYTC(Frame):
"""Synchronised tempo codes.
This frame's attributes may be changed in the future based on
feedback from real-world use.
"""
_framespec = [
ByteSpec("format"),
BinaryDataSpec("data"),
]
def __eq__(self, other):
return self.data == other
__hash__ = Frame.__hash__
|
class SYTC(Frame):
'''Synchronised tempo codes.
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.5 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 14 | 16 | 4 | 8 | 4 | 6 | 4 | 5 | 4 | 3 | 1 | 2 | 0 | 1 |
147,101 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.SYLT
|
class SYLT(Frame):
"""Synchronised lyrics/text."""
_framespec = [
EncodingSpec('encoding'),
StringSpec('lang', 3),
ByteSpec('format'),
ByteSpec('type'),
EncodedTextSpec('desc'),
SynchronizedTextSpec('text'),
]
@property
def HashKey(self):
return '%s:%s:%r' % (self.FrameID, self.desc, self.lang)
def __eq__(self, other):
return str(self) == other
__hash__ = Frame.__hash__
def __str__(self):
return u"".join(text for (text, time) in self.text)
def __bytes__(self):
return text_type(self).encode("utf-8")
|
class SYLT(Frame):
'''Synchronised lyrics/text.'''
@property
def HashKey(self):
pass
def __eq__(self, other):
pass
def __str__(self):
pass
def __bytes__(self):
pass
| 6 | 1 | 2 | 0 | 2 | 0 | 1 | 0.05 | 1 | 1 | 0 | 1 | 4 | 0 | 4 | 17 | 26 | 6 | 19 | 9 | 13 | 1 | 11 | 7 | 6 | 1 | 2 | 0 | 4 |
147,102 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.SIGN
|
class SIGN(Frame):
"""Signature frame."""
_framespec = [
ByteSpec('group'),
BinaryDataSpec('sig'),
]
@property
def HashKey(self):
return '%s:%c:%s' % (self.FrameID, self.group, self.sig)
def __bytes__(self):
return self.sig
def __eq__(self, other):
return self.sig == other
__hash__ = Frame.__hash__
|
class SIGN(Frame):
'''Signature frame.'''
@property
def HashKey(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
| 5 | 1 | 2 | 0 | 2 | 0 | 1 | 0.08 | 1 | 0 | 0 | 0 | 3 | 0 | 3 | 16 | 19 | 5 | 13 | 7 | 8 | 1 | 9 | 6 | 5 | 1 | 2 | 0 | 3 |
147,103 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/_id3frames.py
|
mutagen._id3frames.SEEK
|
class SEEK(Frame):
"""Seek frame.
Mutagen does not find tags at seek offsets.
"""
_framespec = [IntegerSpec('offset')]
def __pos__(self):
return self.offset
def __eq__(self, other):
return self.offset == other
__hash__ = Frame.__hash__
|
class SEEK(Frame):
'''Seek frame.
Mutagen does not find tags at seek offsets.
'''
def __pos__(self):
pass
def __eq__(self, other):
pass
| 3 | 1 | 2 | 0 | 2 | 0 | 1 | 0.43 | 1 | 0 | 0 | 0 | 2 | 0 | 2 | 15 | 15 | 5 | 7 | 5 | 4 | 3 | 7 | 5 | 4 | 1 | 2 | 0 | 2 |
147,104 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/oggopus.py
|
mutagen.oggopus.OggOpus
|
class OggOpus(OggFileType):
"""An Ogg Opus file."""
_Info = OggOpusInfo
_Tags = OggOpusVComment
_Error = OggOpusHeaderError
_mimes = ["audio/ogg", "audio/ogg; codecs=opus"]
@staticmethod
def score(filename, fileobj, header):
return (header.startswith(b"OggS") * (b"OpusHead" in header))
|
class OggOpus(OggFileType):
'''An Ogg Opus 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,105 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TCueSheet
|
class TCueSheet(TestCase):
SAMPLE = os.path.join("tests", "data", "silence-44-s.flac")
def setUp(self):
self.flac = FLAC(self.SAMPLE)
self.cs = self.flac.cuesheet
def test_cuesheet(self):
self.failUnlessEqual(self.cs.media_catalog_number, b"1234567890123")
self.failUnlessEqual(self.cs.lead_in_samples, 88200)
self.failUnlessEqual(self.cs.compact_disc, True)
self.failUnlessEqual(len(self.cs.tracks), 4)
def test_first_track(self):
self.failUnlessEqual(self.cs.tracks[0].track_number, 1)
self.failUnlessEqual(self.cs.tracks[0].start_offset, 0)
self.failUnlessEqual(self.cs.tracks[0].isrc, b'123456789012')
self.failUnlessEqual(self.cs.tracks[0].type, 0)
self.failUnlessEqual(self.cs.tracks[0].pre_emphasis, False)
self.failUnlessEqual(self.cs.tracks[0].indexes, [(1, 0)])
def test_second_track(self):
self.failUnlessEqual(self.cs.tracks[1].track_number, 2)
self.failUnlessEqual(self.cs.tracks[1].start_offset, 44100)
self.failUnlessEqual(self.cs.tracks[1].isrc, b'')
self.failUnlessEqual(self.cs.tracks[1].type, 1)
self.failUnlessEqual(self.cs.tracks[1].pre_emphasis, True)
self.failUnlessEqual(self.cs.tracks[1].indexes, [(1, 0),
(2, 588)])
def test_lead_out(self):
self.failUnlessEqual(self.cs.tracks[-1].track_number, 170)
self.failUnlessEqual(self.cs.tracks[-1].start_offset, 162496)
self.failUnlessEqual(self.cs.tracks[-1].isrc, b'')
self.failUnlessEqual(self.cs.tracks[-1].type, 0)
self.failUnlessEqual(self.cs.tracks[-1].pre_emphasis, False)
self.failUnlessEqual(self.cs.tracks[-1].indexes, [])
def test_track_eq(self):
track = self.cs.tracks[-1]
self.assertReallyEqual(track, track)
self.assertReallyNotEqual(track, 42)
def test_eq(self):
self.assertReallyEqual(self.cs, self.cs)
def test_neq(self):
self.assertReallyNotEqual(self.cs, 12)
def test_repr(self):
repr(self.cs)
def test_roundtrip(self):
self.failUnlessEqual(CueSheet(self.cs.write()), self.cs)
|
class TCueSheet(TestCase):
def setUp(self):
pass
def test_cuesheet(self):
pass
def test_first_track(self):
pass
def test_second_track(self):
pass
def test_lead_out(self):
pass
def test_track_eq(self):
pass
def test_eq(self):
pass
def test_neq(self):
pass
def test_repr(self):
pass
def test_roundtrip(self):
pass
| 11 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 10 | 2 | 10 | 85 | 54 | 10 | 44 | 15 | 33 | 0 | 43 | 15 | 32 | 1 | 3 | 0 | 10 |
147,106 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TFLAC
|
class TFLAC(TestCase):
SAMPLE = os.path.join("tests", "data", "silence-44-s.flac")
NEW = SAMPLE + ".new"
def setUp(self):
shutil.copy(self.SAMPLE, self.NEW)
self.failUnlessEqual(open(self.SAMPLE, "rb").read(),
open(self.NEW, "rb").read())
self.flac = FLAC(self.NEW)
def test_delete(self):
self.failUnless(self.flac.tags)
self.flac.delete()
self.failIf(self.flac.tags)
flac = FLAC(self.NEW)
self.failIf(flac.tags)
def test_module_delete(self):
delete(self.NEW)
flac = FLAC(self.NEW)
self.failIf(flac.tags)
def test_info(self):
self.failUnlessAlmostEqual(FLAC(self.NEW).info.length, 3.7, 1)
def test_keys(self):
self.failUnlessEqual(list(self.flac.keys()), list(self.flac.tags.keys()))
def test_values(self):
self.failUnlessEqual(list(self.flac.values()), list(self.flac.tags.values()))
def test_items(self):
self.failUnlessEqual(list(self.flac.items()), list(self.flac.tags.items()))
def test_vc(self):
self.failUnlessEqual(self.flac['title'][0], 'Silence')
def test_write_nochange(self):
f = FLAC(self.NEW)
f.save()
self.failUnlessEqual(open(self.SAMPLE, "rb").read(),
open(self.NEW, "rb").read())
def test_write_changetitle(self):
f = FLAC(self.NEW)
if PY3:
self.assertRaises(ValueError, f.__setitem__, b'title', b"A New Title")
else:
f[b'title'] = b"A New Title"
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[b"title"][0], b"A New Title")
def test_write_changetitle_unicode_value(self):
f = FLAC(self.NEW)
if PY3:
self.assertRaises(ValueError, f.__setitem__, b'title', u"A Unicode Title \u2022")
else:
f[b'title'] = u"A Unicode Title \u2022"
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[b"title"][0], u"A Unicode Title \u2022")
def test_write_changetitle_unicode_key(self):
f = FLAC(self.NEW)
f[u"title"] = b"A New Title"
if PY3:
self.assertRaises(ValueError, f.save)
else:
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[u"title"][0], b"A New Title")
def test_write_changetitle_unicode_key_and_value(self):
f = FLAC(self.NEW)
f[u"title"] = u"A Unicode Title \u2022"
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[u"title"][0], u"A Unicode Title \u2022")
def test_force_grow(self):
f = FLAC(self.NEW)
f[u"faketag"] = [u"a" * 1000] * 1000
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[u"faketag"], [u"a" * 1000] * 1000)
def test_force_shrink(self):
self.test_force_grow()
f = FLAC(self.NEW)
f[u"faketag"] = u"foo"
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(f[u"faketag"], [u"foo"])
def test_add_vc(self):
f = FLAC(os.path.join("tests", "data", "no-tags.flac"))
self.failIf(f.tags)
f.add_tags()
self.failUnless(f.tags == [])
self.failUnlessRaises(ValueError, f.add_tags)
def test_add_vc_implicit(self):
f = FLAC(os.path.join("tests", "data", "no-tags.flac"))
self.failIf(f.tags)
f["foo"] = "bar"
self.failUnless(f.tags == [(u"foo", u"bar")])
self.failUnlessRaises(ValueError, f.add_tags)
def test_ooming_vc_header(self):
# issue 112: Malformed FLAC Vorbis header causes out of memory error
# http://code.google.com/p/mutagen/issues/detail?id=112
self.assertRaises(IOError, FLAC, os.path.join('tests', 'data',
'ooming-header.flac'))
def test_with_real_flac(self):
if not have_flac:
return
self.flac["faketag"] = "foobar" * 1000
self.flac.save()
badval = os.system("tools/notarealprogram 2> %s" % devnull)
value = os.system("flac -t %s 2> %s" % (self.flac.filename, devnull))
self.failIf(value and value != badval)
def test_save_unknown_block(self):
block = MetadataBlock(b"test block data")
block.code = 99
self.flac.metadata_blocks.append(block)
self.flac.save()
def test_load_unknown_block(self):
self.test_save_unknown_block()
flac = FLAC(self.NEW)
self.failUnlessEqual(len(flac.metadata_blocks), 7)
self.failUnlessEqual(flac.metadata_blocks[5].code, 99)
self.failUnlessEqual(flac.metadata_blocks[5].data, b"test block data")
def test_two_vorbis_blocks(self):
self.flac.metadata_blocks.append(self.flac.metadata_blocks[1])
self.flac.save()
self.failUnlessRaises(IOError, FLAC, self.NEW)
def test_missing_streaminfo(self):
self.flac.metadata_blocks.pop(0)
self.flac.save()
self.failUnlessRaises(IOError, FLAC, self.NEW)
def test_load_invalid_flac(self):
self.failUnlessRaises(
IOError, FLAC, os.path.join("tests", "data", "xing.mp3"))
def test_save_invalid_flac(self):
self.failUnlessRaises(
IOError, self.flac.save, os.path.join("tests", "data", "xing.mp3"))
def test_pprint(self):
self.failUnless(self.flac.pprint())
def test_double_load(self):
blocks = list(self.flac.metadata_blocks)
self.flac.load(self.flac.filename)
self.failUnlessEqual(blocks, self.flac.metadata_blocks)
def test_seektable(self):
self.failUnless(self.flac.seektable)
def test_cuesheet(self):
self.failUnless(self.flac.cuesheet)
def test_pictures(self):
self.failUnless(self.flac.pictures)
def test_add_picture(self):
f = FLAC(self.NEW)
c = len(f.pictures)
f.add_picture(Picture())
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(len(f.pictures), c + 1)
def test_clear_pictures(self):
f = FLAC(self.NEW)
c1 = len(f.pictures)
c2 = len(f.metadata_blocks)
f.clear_pictures()
f.save()
f = FLAC(self.NEW)
self.failUnlessEqual(len(f.metadata_blocks), c2 - c1)
def test_ignore_id3(self):
id3 = ID3()
id3.add(TIT2(encoding=0, text='id3 title'))
id3.save(self.NEW)
f = FLAC(self.NEW)
f['title'] = 'vc title'
f.save()
id3 = ID3(self.NEW)
self.failUnlessEqual(id3['TIT2'].text, ['id3 title'])
f = FLAC(self.NEW)
self.failUnlessEqual(f['title'], ['vc title'])
def test_delete_id3(self):
id3 = ID3()
id3.add(TIT2(encoding=0, text='id3 title'))
id3.save(self.NEW, v1=2)
f = FLAC(self.NEW)
f['title'] = 'vc title'
f.save(deleteid3=True)
self.failUnlessRaises(ID3NoHeaderError, ID3, self.NEW)
f = FLAC(self.NEW)
self.failUnlessEqual(f['title'], ['vc title'])
def test_mime(self):
self.failUnless("audio/x-flac" in self.flac.mime)
def test_variable_block_size(self):
FLAC(os.path.join("tests", "data", "variable-block.flac"))
def test_load_flac_with_application_block(self):
FLAC(os.path.join("tests", "data", "flac_application.flac"))
def tearDown(self):
os.unlink(self.NEW)
|
class TFLAC(TestCase):
def setUp(self):
pass
def test_delete(self):
pass
def test_module_delete(self):
pass
def test_info(self):
pass
def test_keys(self):
pass
def test_values(self):
pass
def test_items(self):
pass
def test_vc(self):
pass
def test_write_nochange(self):
pass
def test_write_changetitle(self):
pass
def test_write_changetitle_unicode_value(self):
pass
def test_write_changetitle_unicode_key(self):
pass
def test_write_changetitle_unicode_key_and_value(self):
pass
def test_force_grow(self):
pass
def test_force_shrink(self):
pass
def test_add_vc(self):
pass
def test_add_vc_implicit(self):
pass
def test_ooming_vc_header(self):
pass
def test_with_real_flac(self):
pass
def test_save_unknown_block(self):
pass
def test_load_unknown_block(self):
pass
def test_two_vorbis_blocks(self):
pass
def test_missing_streaminfo(self):
pass
def test_load_invalid_flac(self):
pass
def test_save_invalid_flac(self):
pass
def test_pprint(self):
pass
def test_double_load(self):
pass
def test_seektable(self):
pass
def test_cuesheet(self):
pass
def test_pictures(self):
pass
def test_add_picture(self):
pass
def test_clear_pictures(self):
pass
def test_ignore_id3(self):
pass
def test_delete_id3(self):
pass
def test_mime(self):
pass
def test_variable_block_size(self):
pass
def test_load_flac_with_application_block(self):
pass
def tearDown(self):
pass
| 39 | 0 | 5 | 0 | 5 | 0 | 1 | 0.01 | 1 | 8 | 6 | 0 | 38 | 1 | 38 | 113 | 223 | 38 | 183 | 67 | 144 | 2 | 175 | 67 | 136 | 2 | 3 | 1 | 42 |
147,107 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TFLACBadBlockSize
|
class TFLACBadBlockSize(TestCase):
TOO_SHORT = os.path.join("tests", "data", "52-too-short-block-size.flac")
TOO_SHORT_2 = os.path.join("tests", "data",
"106-short-picture-block-size.flac")
OVERWRITTEN = os.path.join("tests", "data", "52-overwritten-metadata.flac")
INVAL_INFO = os.path.join("tests", "data", "106-invalid-streaminfo.flac")
def test_too_short_read(self):
flac = FLAC(self.TOO_SHORT)
self.failUnlessEqual(flac["artist"], ["Tunng"])
def test_too_short_read_picture(self):
flac = FLAC(self.TOO_SHORT_2)
self.failUnlessEqual(flac.pictures[0].width, 10)
def test_overwritten_read(self):
flac = FLAC(self.OVERWRITTEN)
self.failUnlessEqual(flac["artist"], ["Giora Feidman"])
def test_inval_streaminfo(self):
self.assertRaises(error, FLAC, self.INVAL_INFO)
|
class TFLACBadBlockSize(TestCase):
def test_too_short_read(self):
pass
def test_too_short_read_picture(self):
pass
def test_overwritten_read(self):
pass
def test_inval_streaminfo(self):
pass
| 5 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 4 | 0 | 4 | 79 | 21 | 4 | 17 | 12 | 12 | 0 | 16 | 12 | 11 | 1 | 3 | 0 | 4 |
147,108 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TFLACBadBlockSizeWrite
|
class TFLACBadBlockSizeWrite(TestCase):
TOO_SHORT = os.path.join("tests", "data", "52-too-short-block-size.flac")
NEW = TOO_SHORT + ".new"
def setUp(self):
shutil.copy(self.TOO_SHORT, self.NEW)
def test_write_reread(self):
flac = FLAC(self.NEW)
del(flac["artist"])
flac.save()
flac2 = FLAC(self.NEW)
self.failUnlessEqual(flac["title"], flac2["title"])
data = open(self.NEW, "rb").read(1024)
self.failIf(b"Tunng" in data)
def tearDown(self):
os.unlink(self.NEW)
|
class TFLACBadBlockSizeWrite(TestCase):
def setUp(self):
pass
def test_write_reread(self):
pass
def tearDown(self):
pass
| 4 | 0 | 4 | 0 | 4 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 3 | 0 | 3 | 78 | 18 | 3 | 15 | 9 | 11 | 0 | 15 | 9 | 11 | 1 | 3 | 0 | 3 |
147,109 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_flac.py
|
tests.test_flac.TFLACFile
|
class TFLACFile(TestCase):
def test_open_nonexistant(self):
"""mutagen 1.2 raises UnboundLocalError, then it tries to open
non-existant FLAC files"""
filename = os.path.join("tests", "data", "doesntexist.flac")
self.assertRaises(IOError, FLAC, filename)
|
class TFLACFile(TestCase):
def test_open_nonexistant(self):
'''mutagen 1.2 raises UnboundLocalError, then it tries to open
non-existant FLAC files'''
pass
| 2 | 1 | 5 | 0 | 3 | 2 | 1 | 0.5 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 76 | 7 | 1 | 4 | 3 | 2 | 2 | 4 | 3 | 2 | 1 | 3 | 0 | 1 |
147,110 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_easyid3.py
|
tests.test_easyid3.TEasyID3
|
class TEasyID3(TestCase):
def setUp(self):
fd, self.filename = mkstemp('.mp3')
os.close(fd)
empty = os.path.join('tests', 'data', 'emptyfile.mp3')
shutil.copy(empty, self.filename)
self.id3 = EasyID3()
def test_remember_ctr(self):
empty = os.path.join('tests', 'data', 'emptyfile.mp3')
mp3 = ID3FileType(empty, ID3=EasyID3)
self.failIf(mp3.tags)
mp3["artist"] = ["testing"]
self.failUnless(mp3.tags)
mp3.pprint()
self.failUnless(isinstance(mp3.tags, EasyID3))
def test_delete(self):
self.id3["artist"] = "foobar"
self.id3.save(self.filename)
self.failUnless(os.path.getsize(self.filename))
self.id3.delete(self.filename)
self.failIf(os.path.getsize(self.filename))
self.failIf(self.id3)
def test_pprint(self):
self.id3["artist"] = "baz"
self.id3.pprint()
def test_in(self):
self.failIf("foo" in self.id3)
def test_empty_file(self):
empty = os.path.join('tests', 'data', 'emptyfile.mp3')
self.assertRaises(ID3Error, EasyID3, filename=empty)
def test_nonexistent_file(self):
empty = os.path.join('tests', 'data', 'does', 'not', 'exist')
self.assertRaises(IOError, EasyID3, filename=empty)
def test_write_single(self):
for key in EasyID3.valid_keys:
if key == "date":
continue
elif key.startswith("replaygain_"):
continue
# Test creation
self.id3[key] = "a test value"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3[key], ["a test value"])
self.failUnlessEqual(list(id3.keys()), [key])
# And non-creation setting.
self.id3[key] = "a test value"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3[key], ["a test value"])
self.failUnlessEqual(list(id3.keys()), [key])
del(self.id3[key])
def test_write_double(self):
for key in EasyID3.valid_keys:
if key == "date":
continue
elif key.startswith("replaygain_"):
continue
elif key == "musicbrainz_trackid":
continue
self.id3[key] = ["a test", "value"]
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3.get(key), ["a test", "value"])
self.failUnlessEqual(list(id3.keys()), [key])
self.id3[key] = ["a test", "value"]
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3.get(key), ["a test", "value"])
self.failUnlessEqual(list(id3.keys()), [key])
del(self.id3[key])
def test_write_date(self):
self.id3["date"] = "2004"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["date"], ["2004"])
self.id3["date"] = "2004"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["date"], ["2004"])
def test_date_delete(self):
self.id3["date"] = "2004"
self.failUnlessEqual(self.id3["date"], ["2004"])
del(self.id3["date"])
self.failIf("date" in self.id3.keys())
def test_write_date_double(self):
self.id3["date"] = ["2004", "2005"]
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["date"], ["2004", "2005"])
self.id3["date"] = ["2004", "2005"]
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["date"], ["2004", "2005"])
def test_write_invalid(self):
self.failUnlessRaises(ValueError, self.id3.__getitem__, "notvalid")
self.failUnlessRaises(ValueError, self.id3.__delitem__, "notvalid")
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "notvalid", "tests")
def test_perfomer(self):
self.id3["performer:coder"] = ["piman", "mu"]
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["performer:coder"], ["piman", "mu"])
def test_no_performer(self):
self.failIf("performer:foo" in self.id3)
def test_performer_delete(self):
self.id3["performer:foo"] = "Joe"
self.id3["performer:bar"] = "Joe"
self.failUnless("performer:foo" in self.id3)
self.failUnless("performer:bar" in self.id3)
del(self.id3["performer:foo"])
self.failIf("performer:foo" in self.id3)
self.failUnless("performer:bar" in self.id3)
del(self.id3["performer:bar"])
self.failIf("performer:bar" in self.id3)
self.failIf("TMCL" in self.id3._EasyID3__id3)
def test_performer_delete_dne(self):
self.failUnlessRaises(KeyError, self.id3.__delitem__, "performer:bar")
self.id3["performer:foo"] = "Joe"
self.failUnlessRaises(KeyError, self.id3.__delitem__, "performer:bar")
def test_txxx_empty(self):
# http://code.google.com/p/mutagen/issues/detail?id=135
self.id3["asin"] = ""
def test_txxx_set_get(self):
self.failIf("asin" in self.id3.keys())
self.id3["asin"] = "Hello"
self.failUnless("asin" in self.id3.keys())
self.failUnlessEqual(self.id3["asin"], ["Hello"])
self.failUnless("TXXX:ASIN" in self.id3._EasyID3__id3)
def test_txxx_del_set_del(self):
self.failIf("asin" in self.id3.keys())
self.failUnlessRaises(KeyError, self.id3.__delitem__, "asin")
self.id3["asin"] = "Hello"
self.failUnless("asin" in self.id3.keys())
self.failUnlessEqual(self.id3["asin"], ["Hello"])
del(self.id3["asin"])
self.failIf("asin" in self.id3.keys())
self.failUnlessRaises(KeyError, self.id3.__delitem__, "asin")
def test_txxx_save(self):
self.id3["asin"] = "Hello"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["asin"], ["Hello"])
def test_txxx_unicode(self):
self.id3["asin"] = u"He\u1234llo"
self.failUnlessEqual(self.id3["asin"], [u"He\u1234llo"])
def test_bad_trackid(self):
self.failUnlessRaises(ValueError, self.id3.__setitem__,
"musicbrainz_trackid", ["a", "b"])
self.failIf(self.id3._EasyID3__id3.getall("RVA2"))
def test_gain_bad_key(self):
self.failIf("replaygain_foo_gain" in self.id3)
self.failIf(self.id3._EasyID3__id3.getall("RVA2"))
def test_gain_bad_value(self):
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_gain", [])
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_gain", ["foo"])
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_gain", ["1", "2"])
self.failIf(self.id3._EasyID3__id3.getall("RVA2"))
def test_peak_bad_key(self):
self.failIf("replaygain_foo_peak" in self.id3)
self.failIf(self.id3._EasyID3__id3.getall("RVA2"))
def test_peak_bad_value(self):
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_peak", [])
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_peak", ["foo"])
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_peak", ["1", "1"])
self.failUnlessRaises(
ValueError, self.id3.__setitem__, "replaygain_foo_peak", ["3"])
self.failIf(self.id3._EasyID3__id3.getall("RVA2"))
def test_gain_peak_get(self):
self.id3["replaygain_foo_gain"] = "+3.5 dB"
self.id3["replaygain_bar_peak"] = "0.5"
self.failUnlessEqual(
self.id3["replaygain_foo_gain"], ["+3.500000 dB"])
self.failUnlessEqual(self.id3["replaygain_foo_peak"], ["0.000000"])
self.failUnlessEqual(
self.id3["replaygain_bar_gain"], ["+0.000000 dB"])
self.failUnlessEqual(self.id3["replaygain_bar_peak"], ["0.500000"])
def test_gain_peak_set(self):
self.id3["replaygain_foo_gain"] = "+3.5 dB"
self.id3["replaygain_bar_peak"] = "0.5"
self.id3.save(self.filename)
id3 = EasyID3(self.filename)
self.failUnlessEqual(id3["replaygain_foo_gain"], ["+3.500000 dB"])
self.failUnlessEqual(id3["replaygain_foo_peak"], ["0.000000"])
self.failUnlessEqual(id3["replaygain_bar_gain"], ["+0.000000 dB"])
self.failUnlessEqual(id3["replaygain_bar_peak"], ["0.500000"])
def test_gain_peak_delete(self):
self.id3["replaygain_foo_gain"] = "+3.5 dB"
self.id3["replaygain_bar_peak"] = "0.5"
del(self.id3["replaygain_bar_gain"])
del(self.id3["replaygain_foo_peak"])
self.failUnless("replaygain_foo_gain" in self.id3.keys())
self.failUnless("replaygain_bar_gain" in self.id3.keys())
del(self.id3["replaygain_foo_gain"])
del(self.id3["replaygain_bar_peak"])
self.failIf("replaygain_foo_gain" in self.id3.keys())
self.failIf("replaygain_bar_gain" in self.id3.keys())
del(self.id3["replaygain_foo_gain"])
del(self.id3["replaygain_bar_peak"])
self.failIf("replaygain_foo_gain" in self.id3.keys())
self.failIf("replaygain_bar_gain" in self.id3.keys())
def test_pickle(self):
# http://code.google.com/p/mutagen/issues/detail?id=102
pickle.dumps(self.id3)
def test_get_fallback(self):
called = []
def get_func(id3, key):
id3.getall("")
self.failUnlessEqual(key, "nope")
called.append(1)
self.id3.GetFallback = get_func
self.id3["nope"]
self.failUnless(called)
def test_set_fallback(self):
called = []
def set_func(id3, key, value):
id3.getall("")
self.failUnlessEqual(key, "nope")
self.failUnlessEqual(value, ["foo"])
called.append(1)
self.id3.SetFallback = set_func
self.id3["nope"] = "foo"
self.failUnless(called)
def test_del_fallback(self):
called = []
def del_func(id3, key):
id3.getall("")
self.failUnlessEqual(key, "nope")
called.append(1)
self.id3.DeleteFallback = del_func
del self.id3["nope"]
self.failUnless(called)
def test_list_fallback(self):
def list_func(id3, key):
id3.getall("")
self.failIf(key)
return ["somekey"]
self.id3.ListFallback = list_func
self.failUnlessEqual(list(self.id3.keys()), ["somekey"])
def tearDown(self):
os.unlink(self.filename)
|
class TEasyID3(TestCase):
def setUp(self):
pass
def test_remember_ctr(self):
pass
def test_delete(self):
pass
def test_pprint(self):
pass
def test_in(self):
pass
def test_empty_file(self):
pass
def test_nonexistent_file(self):
pass
def test_write_single(self):
pass
def test_write_double(self):
pass
def test_write_date(self):
pass
def test_date_delete(self):
pass
def test_write_date_double(self):
pass
def test_write_invalid(self):
pass
def test_perfomer(self):
pass
def test_no_performer(self):
pass
def test_performer_delete(self):
pass
def test_performer_delete_dne(self):
pass
def test_txxx_empty(self):
pass
def test_txxx_set_get(self):
pass
def test_txxx_del_set_del(self):
pass
def test_txxx_save(self):
pass
def test_txxx_unicode(self):
pass
def test_bad_trackid(self):
pass
def test_gain_bad_key(self):
pass
def test_gain_bad_value(self):
pass
def test_peak_bad_key(self):
pass
def test_peak_bad_value(self):
pass
def test_gain_peak_get(self):
pass
def test_gain_peak_set(self):
pass
def test_gain_peak_delete(self):
pass
def test_pickle(self):
pass
def test_get_fallback(self):
pass
def get_func(id3, key):
pass
def test_set_fallback(self):
pass
def set_func(id3, key, value):
pass
def test_del_fallback(self):
pass
def del_func(id3, key):
pass
def test_list_fallback(self):
pass
def list_func(id3, key):
pass
def tearDown(self):
pass
| 41 | 0 | 7 | 0 | 7 | 0 | 1 | 0.02 | 1 | 5 | 2 | 0 | 36 | 2 | 36 | 111 | 298 | 50 | 244 | 60 | 203 | 4 | 230 | 60 | 189 | 5 | 3 | 2 | 47 |
147,111 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/mp4.py
|
mutagen.mp4.Atom
|
class Atom(object):
"""An individual atom.
Attributes:
* children -- list child atoms (or None for non-container atoms)
* length -- length of this atom, including length and name
* name -- four byte name of the atom, as bytes
* offset -- location in the constructor-given fileobj of this atom
This structure should only be used internally by Mutagen.
"""
children = None
def __init__(self, fileobj, level=0):
self.offset = fileobj.tell()
self.length, self.name = struct.unpack(">I4s", fileobj.read(8))
if self.length == 1:
self.length, = struct.unpack(">Q", fileobj.read(8))
if self.length < 16:
raise MP4MetadataError(
"64 bit atom length can only be 16 and higher")
elif self.length == 0:
if level != 0:
raise MP4MetadataError(
"only a top-level atom can have zero length")
# Only the last atom is supposed to have a zero-length, meaning it
# extends to the end of file.
fileobj.seek(0, 2)
self.length = fileobj.tell() - self.offset
fileobj.seek(self.offset + 8, 0)
elif self.length < 8:
raise MP4MetadataError(
"atom length can only be 0, 1 or 8 and higher")
if self.name in _CONTAINERS:
self.children = []
fileobj.seek(_SKIP_SIZE.get(self.name, 0), 1)
while fileobj.tell() < self.offset + self.length:
self.children.append(Atom(fileobj, level + 1))
else:
fileobj.seek(self.offset + self.length, 0)
# Takes two bytes arguments
@staticmethod
def render(name, data):
"""Render raw atom data."""
# this raises OverflowError if Py_ssize_t can't handle the atom data
size = len(data) + 8
if size <= 0xFFFFFFFF:
return struct.pack(">I4s", size, name) + data
else:
return struct.pack(">I4sQ", 1, name, size + 8) + data
def findall(self, name, recursive=False):
"""Recursively find all child atoms by specified name."""
if self.children is not None:
for child in self.children:
if child.name == name:
yield child
if recursive:
for atom in child.findall(name, True):
yield atom
def __getitem__(self, remaining):
"""Look up a child atom, potentially recursively.
e.g. atom['udta', 'meta'] => <Atom name='meta' ...>
"""
if not remaining:
return self
elif self.children is None:
raise KeyError("%r is not a container" % self.name)
for child in self.children:
if child.name == remaining[0]:
return child[remaining[1:]]
else:
raise KeyError("%r not found" % remaining[0])
def __repr__(self):
cls = self.__class__.__name__
if self.children is None:
return "<%s name=%r length=%r offset=%r>" % (
cls, self.name, self.length, self.offset)
else:
children = "\n".join([" " + line for child in self.children
for line in repr(child).splitlines()])
return "<%s name=%r length=%r offset=%r\n%s>" % (
cls, self.name, self.length, self.offset, children)
|
class Atom(object):
'''An individual atom.
Attributes:
* children -- list child atoms (or None for non-container atoms)
* length -- length of this atom, including length and name
* name -- four byte name of the atom, as bytes
* offset -- location in the constructor-given fileobj of this atom
This structure should only be used internally by Mutagen.
'''
def __init__(self, fileobj, level=0):
pass
@staticmethod
def render(name, data):
'''Render raw atom data.'''
pass
def findall(self, name, recursive=False):
'''Recursively find all child atoms by specified name.'''
pass
def __getitem__(self, remaining):
'''Look up a child atom, potentially recursively.
e.g. atom['udta', 'meta'] => <Atom name='meta' ...>
'''
pass
def __repr__(self):
pass
| 7 | 4 | 14 | 0 | 12 | 2 | 5 | 0.27 | 1 | 2 | 1 | 0 | 4 | 3 | 5 | 5 | 90 | 11 | 62 | 16 | 55 | 17 | 49 | 15 | 43 | 8 | 1 | 4 | 23 |
147,112 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_mp4.py
|
tests.test_mp4.TAtoms
|
class TAtoms(TestCase):
filename = os.path.join("tests", "data", "has-tags.m4a")
def setUp(self):
self.atoms = Atoms(open(self.filename, "rb"))
def test_getitem(self):
self.failUnless(self.atoms[b"moov"])
self.failUnless(self.atoms[b"moov.udta"])
self.failUnlessRaises(KeyError, self.atoms.__getitem__, b"whee")
def test_contains(self):
self.failUnless(b"moov" in self.atoms)
self.failUnless(b"moov.udta" in self.atoms)
self.failUnless(b"whee" not in self.atoms)
def test_name(self):
self.failUnlessEqual(self.atoms.atoms[0].name, b"ftyp")
def test_children(self):
self.failUnless(self.atoms.atoms[2].children)
def test_no_children(self):
self.failUnless(self.atoms.atoms[0].children is None)
def test_extra_trailing_data(self):
data = cBytesIO(Atom.render(b"data", b"whee") + b"\x00\x00")
self.failUnless(Atoms(data))
def test_repr(self):
repr(self.atoms)
|
class TAtoms(TestCase):
def setUp(self):
pass
def test_getitem(self):
pass
def test_contains(self):
pass
def test_name(self):
pass
def test_children(self):
pass
def test_no_children(self):
pass
def test_extra_trailing_data(self):
pass
def test_repr(self):
pass
| 9 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 3 | 2 | 0 | 8 | 1 | 8 | 83 | 31 | 8 | 23 | 12 | 14 | 0 | 23 | 12 | 14 | 1 | 3 | 0 | 8 |
147,113 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_trueaudio.py
|
tests.test_trueaudio.TTrueAudio
|
class TTrueAudio(TestCase):
def setUp(self):
self.audio = TrueAudio(os.path.join("tests", "data", "empty.tta"))
def test_tags(self):
self.failUnless(self.audio.tags is None)
def test_length(self):
self.failUnlessAlmostEqual(self.audio.info.length, 3.7, 1)
def test_sample_rate(self):
self.failUnlessEqual(44100, self.audio.info.sample_rate)
def test_not_my_file(self):
filename = os.path.join("tests", "data", "empty.ogg")
self.failUnlessRaises(IOError, TrueAudio, filename)
def test_module_delete(self):
delete(os.path.join("tests", "data", "empty.tta"))
def test_delete(self):
self.audio.delete()
self.failIf(self.audio.tags)
def test_pprint(self):
self.failUnless(self.audio.pprint())
def test_save_reload(self):
try:
fd, filename = mkstemp(suffix='.tta')
os.close(fd)
shutil.copy(self.audio.filename, filename)
audio = TrueAudio(filename)
audio.add_tags()
audio.tags.add(TIT1(encoding=0, text="A Title"))
audio.save()
audio = TrueAudio(filename)
self.failUnlessEqual(audio["TIT1"], "A Title")
finally:
os.unlink(filename)
def test_mime(self):
self.failUnless("audio/x-tta" in self.audio.mime)
|
class TTrueAudio(TestCase):
def setUp(self):
pass
def test_tags(self):
pass
def test_length(self):
pass
def test_sample_rate(self):
pass
def test_not_my_file(self):
pass
def test_module_delete(self):
pass
def test_delete(self):
pass
def test_pprint(self):
pass
def test_save_reload(self):
pass
def test_mime(self):
pass
| 11 | 0 | 3 | 0 | 3 | 0 | 1 | 0 | 1 | 2 | 2 | 0 | 10 | 1 | 10 | 85 | 44 | 10 | 34 | 15 | 23 | 0 | 33 | 15 | 22 | 1 | 3 | 1 | 10 |
147,114 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.MetadataLibraryObject
|
class MetadataLibraryObject(BaseObject):
"""Metadata library description."""
GUID = b"\x94\x1c#D\x98\x94\xd1I\xa1A\x1d\x13NEpT"
def parse(self, asf, data, fileobj, size):
super(MetadataLibraryObject, self).parse(asf, data, fileobj, size)
asf.metadata_library_obj = self
num_attributes, = struct.unpack("<H", data[0:2])
pos = 2
for i in range(num_attributes):
(language, stream, name_length, value_type,
value_length) = struct.unpack("<HHHHI", data[pos:pos+12])
pos += 12
name = data[pos:pos+name_length].decode("utf-16-le").strip("\x00")
pos += name_length
value = data[pos:pos+value_length]
pos += value_length
args = {'data': value, 'language': language, 'stream': stream}
if value_type == 2:
args['dword'] = False
attr = _attribute_types[value_type](**args)
asf.tags.append((name, attr))
def render(self, asf):
attrs = asf.to_metadata_library
data = b"".join([attr.render_ml(name) for (name, attr) in attrs])
return (self.GUID + struct.pack("<QH", 26 + len(data), len(attrs)) +
data)
|
class MetadataLibraryObject(BaseObject):
'''Metadata library description.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
| 3 | 1 | 12 | 0 | 12 | 0 | 2 | 0.08 | 1 | 2 | 0 | 0 | 2 | 0 | 2 | 4 | 28 | 2 | 25 | 15 | 22 | 2 | 23 | 14 | 20 | 3 | 2 | 2 | 4 |
147,115 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.HeaderObject
|
class HeaderObject(object):
"""ASF header."""
GUID = b"\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C"
|
class HeaderObject(object):
'''ASF header.'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0.5 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 3 | 0 | 2 | 2 | 1 | 1 | 2 | 2 | 1 | 0 | 1 | 0 | 0 |
147,116 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.HeaderExtensionObject
|
class HeaderExtensionObject(BaseObject):
"""Header extension."""
GUID = b"\xb5\x03\xbf_.\xa9\xcf\x11\x8e\xe3\x00\xc0\x0c Se"
def parse(self, asf, data, fileobj, size):
super(HeaderExtensionObject, self).parse(asf, data, fileobj, size)
asf.header_extension_obj = self
datasize, = struct.unpack("<I", data[18:22])
datapos = 0
self.objects = []
while datapos < datasize:
guid, size = struct.unpack("<16sQ", data[22+datapos:22+datapos+24])
if guid in _object_types:
obj = _object_types[guid]()
else:
obj = UnknownObject(guid)
obj.parse(asf, data[22+datapos+24:22+datapos+size], fileobj, size)
self.objects.append(obj)
datapos += size
def render(self, asf):
data = b"".join(obj.render(asf) for obj in self.objects)
return (self.GUID + struct.pack("<Q", 24 + 16 + 6 + len(data)) +
b"\x11\xD2\xD3\xAB\xBA\xA9\xcf\x11" +
b"\x8E\xE6\x00\xC0\x0C\x20\x53\x65" +
b"\x06\x00" + struct.pack("<I", len(data)) + data)
|
class HeaderExtensionObject(BaseObject):
'''Header extension.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
| 3 | 1 | 11 | 0 | 11 | 0 | 2 | 0.04 | 1 | 2 | 1 | 0 | 2 | 1 | 2 | 4 | 26 | 2 | 23 | 10 | 20 | 1 | 19 | 10 | 16 | 3 | 2 | 2 | 4 |
147,117 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.FilePropertiesObject
|
class FilePropertiesObject(BaseObject):
"""File properties."""
GUID = b"\xA1\xDC\xAB\x8C\x47\xA9\xCF\x11\x8E\xE4\x00\xC0\x0C\x20\x53\x65"
def parse(self, asf, data, fileobj, size):
super(FilePropertiesObject, self).parse(asf, data, fileobj, size)
length, _, preroll = struct.unpack("<QQQ", data[40:64])
asf.info.length = (length / 10000000.0) - (preroll / 1000.0)
|
class FilePropertiesObject(BaseObject):
'''File properties.'''
def parse(self, asf, data, fileobj, size):
pass
| 2 | 1 | 4 | 0 | 4 | 0 | 1 | 0.17 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | 3 | 8 | 1 | 6 | 4 | 4 | 1 | 6 | 4 | 4 | 1 | 2 | 0 | 1 |
147,118 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ExtendedContentDescriptionObject
|
class ExtendedContentDescriptionObject(BaseObject):
"""Extended content description."""
GUID = b"\x40\xA4\xD0\xD2\x07\xE3\xD2\x11\x97\xF0\x00\xA0\xC9\x5E\xA8\x50"
def parse(self, asf, data, fileobj, size):
super(ExtendedContentDescriptionObject, self).parse(
asf, data, fileobj, size)
asf.extended_content_description_obj = self
num_attributes, = struct.unpack("<H", data[0:2])
pos = 2
for i in range(num_attributes):
name_length, = struct.unpack("<H", data[pos:pos+2])
pos += 2
name = data[pos:pos+name_length].decode("utf-16-le").strip("\x00")
pos += name_length
value_type, value_length = struct.unpack("<HH", data[pos:pos+4])
pos += 4
value = data[pos:pos+value_length]
pos += value_length
attr = _attribute_types[value_type](data=value)
asf.tags.append((name, attr))
def render(self, asf):
attrs = asf.to_extended_content_description.items()
data = b"".join(attr.render(name) for (name, attr) in attrs)
data = struct.pack("<QH", 26 + len(data), len(attrs)) + data
return self.GUID + data
|
class ExtendedContentDescriptionObject(BaseObject):
'''Extended content description.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
| 3 | 1 | 11 | 0 | 11 | 0 | 2 | 0.04 | 1 | 2 | 0 | 0 | 2 | 0 | 2 | 4 | 27 | 2 | 24 | 14 | 21 | 1 | 23 | 14 | 20 | 2 | 2 | 1 | 3 |
147,119 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ContentDescriptionObject
|
class ContentDescriptionObject(BaseObject):
"""Content description."""
GUID = b"\x33\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C"
def parse(self, asf, data, fileobj, size):
super(ContentDescriptionObject, self).parse(asf, data, fileobj, size)
asf.content_description_obj = self
lengths = struct.unpack("<HHHHH", data[:10])
texts = []
pos = 10
for length in lengths:
end = pos + length
if length > 0:
texts.append(data[pos:end].decode("utf-16-le").strip("\x00"))
else:
texts.append(None)
pos = end
title, author, copyright, desc, rating = texts
for key, value in dict(
Title=title,
Author=author,
Copyright=copyright,
Description=desc,
Rating=rating
).items():
if value is not None:
asf.tags[key] = value
def render(self, asf):
def render_text(name):
value = asf.tags.get(name, [])
if value:
return value[0].encode("utf-16-le") + b"\x00\x00"
else:
return b""
texts = [render_text(x) for x in _standard_attribute_names]
data = struct.pack("<HHHHH", *map(len, texts)) + b"".join(texts)
return self.GUID + struct.pack("<Q", 24 + len(data)) + data
|
class ContentDescriptionObject(BaseObject):
'''Content description.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
def render_text(name):
pass
| 4 | 1 | 13 | 0 | 13 | 0 | 3 | 0.03 | 1 | 3 | 0 | 0 | 2 | 0 | 2 | 4 | 39 | 3 | 35 | 15 | 31 | 1 | 27 | 15 | 23 | 5 | 2 | 2 | 8 |
147,120 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.BaseObject
|
class BaseObject(object):
"""Base ASF object."""
GUID = None
def parse(self, asf, data, fileobj, size):
self.data = data
def render(self, asf):
data = self.GUID + struct.pack("<Q", len(self.data) + 24) + self.data
return data
|
class BaseObject(object):
'''Base ASF object.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
| 3 | 1 | 3 | 0 | 3 | 0 | 1 | 0.14 | 1 | 0 | 0 | 8 | 2 | 1 | 2 | 2 | 10 | 2 | 7 | 6 | 4 | 1 | 7 | 6 | 4 | 1 | 1 | 0 | 2 |
147,121 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFWordAttribute
|
class ASFWordAttribute(ASFBaseAttribute):
"""WORD attribute."""
TYPE = 0x0005
def parse(self, data):
return struct.unpack("<H", data)[0]
def _render(self):
return struct.pack("<H", self.value)
def data_size(self):
return 2
def __int__(self):
return self.value
def __bytes__(self):
return self.value
def __eq__(self, other):
return int(self.value) == other
def __lt__(self, other):
return int(self.value) < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFWordAttribute(ASFBaseAttribute):
'''WORD attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __int__(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.06 | 1 | 1 | 0 | 0 | 7 | 0 | 7 | 13 | 26 | 8 | 17 | 10 | 9 | 1 | 17 | 10 | 9 | 1 | 2 | 0 | 7 |
147,122 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFUnicodeAttribute
|
class ASFUnicodeAttribute(ASFBaseAttribute):
"""Unicode string attribute."""
TYPE = 0x0000
def parse(self, data):
return data.decode("utf-16-le").strip("\x00")
def _render(self):
return self.value.encode("utf-16-le") + b"\x00\x00"
def data_size(self):
return len(self._render())
def __bytes__(self):
return self.value.encode("utf-16-le")
def __str__(self):
return self.value
def __eq__(self, other):
return text_type(self) == other
def __lt__(self, other):
return text_type(self) < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFUnicodeAttribute(ASFBaseAttribute):
'''Unicode string attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.06 | 1 | 0 | 0 | 0 | 7 | 0 | 7 | 13 | 26 | 8 | 17 | 10 | 9 | 1 | 17 | 10 | 9 | 1 | 2 | 0 | 7 |
147,123 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFTags
|
class ASFTags(MutableMapping, Metadata):
"""Dictionary containing ASF attributes."""
def __init__(self):
self._internal = []
def append(self, x):
self._internal.append(x)
def pprint(self):
return "\n".join(("%s=%s" % (k, v)) for k, v in iteritems(self))
def __getitem__(self, key):
"""A list of values for the key.
This is a copy, so comment['title'].append('a title') will not
work.
"""
values = [value for (k, value) in self._internal if k == key]
if not values:
raise KeyError(key)
else:
return values
def __delitem__(self, key):
"""Delete all values associated with the key."""
to_delete = [x for x in self._internal if x[0] == key]
if not to_delete:
raise KeyError(key)
else:
for x in to_delete:
self._internal.remove(x)
def __setitem__(self, key, values):
"""Set a key's value or values.
Setting a value overwrites all old ones. The value may be a
list of Unicode or UTF-8 strings, or a single Unicode or UTF-8
string.
"""
if not isinstance(values, list):
values = [values]
try:
del(self[key])
except KeyError:
pass
for value in values:
if key in _standard_attribute_names:
value = text_type(value)
elif not isinstance(value, ASFBaseAttribute):
if isinstance(value, string_types):
if PY2 or isinstance(value, text_type):
value = ASFUnicodeAttribute(value)
elif isinstance(value, bool):
value = ASFBoolAttribute(value)
elif isinstance(value, int):
value = ASFDWordAttribute(value)
elif isinstance(value, long):
value = ASFQWordAttribute(value)
self.append((key, value))
def __iter__(self):
return iter({k for k,v in self._internal})
def __len__(self):
return len({k for k,v in self._internal})
def as_dict(self):
"""Return a copy of the comment data in a real dict."""
d = {}
for key, value in self._internal:
d.setdefault(key, []).append(value)
return d
|
class ASFTags(MutableMapping, Metadata):
'''Dictionary containing ASF attributes.'''
def __init__(self):
pass
def append(self, x):
pass
def pprint(self):
pass
def __getitem__(self, key):
'''A list of values for the key.
This is a copy, so comment['title'].append('a title') will not
work.
'''
pass
def __delitem__(self, key):
'''Delete all values associated with the key.'''
pass
def __setitem__(self, key, values):
'''Set a key's value or values.
Setting a value overwrites all old ones. The value may be a
list of Unicode or UTF-8 strings, or a single Unicode or UTF-8
string.
'''
pass
def __iter__(self):
pass
def __len__(self):
pass
def as_dict(self):
'''Return a copy of the comment data in a real dict.'''
pass
| 10 | 5 | 7 | 0 | 5 | 1 | 3 | 0.24 | 2 | 9 | 5 | 0 | 9 | 1 | 9 | 13 | 75 | 13 | 50 | 18 | 40 | 12 | 44 | 16 | 34 | 11 | 2 | 4 | 23 |
147,124 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFQWordAttribute
|
class ASFQWordAttribute(ASFBaseAttribute):
"""QWORD attribute."""
TYPE = 0x0004
def parse(self, data):
return struct.unpack("<Q", data)[0]
def _render(self):
return struct.pack("<Q", self.value)
def data_size(self):
return 8
def __int__(self):
return self.value
def __bytes__(self):
return self.value
def __eq__(self, other):
return int(self.value) == other
def __lt__(self, other):
return int(self.value) < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFQWordAttribute(ASFBaseAttribute):
'''QWORD attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __int__(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.06 | 1 | 1 | 0 | 0 | 7 | 0 | 7 | 13 | 26 | 8 | 17 | 10 | 9 | 1 | 17 | 10 | 9 | 1 | 2 | 0 | 7 |
147,125 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFInfo
|
class ASFInfo(StreamInfo):
"""ASF stream information."""
def __init__(self):
self.length = 0.0
self.sample_rate = 0
self.bitrate = 0
self.channels = 0
def pprint(self):
s = "Windows Media Audio %d bps, %s Hz, %d channels, %.2f seconds" % (
self.bitrate, self.sample_rate, self.channels, self.length)
return s
|
class ASFInfo(StreamInfo):
'''ASF stream information.'''
def __init__(self):
pass
def pprint(self):
pass
| 3 | 1 | 5 | 0 | 5 | 0 | 1 | 0.1 | 1 | 0 | 0 | 0 | 2 | 4 | 2 | 3 | 13 | 2 | 10 | 8 | 7 | 1 | 9 | 8 | 6 | 1 | 2 | 0 | 2 |
147,126 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFGUIDAttribute
|
class ASFGUIDAttribute(ASFBaseAttribute):
"""GUID attribute."""
TYPE = 0x0006
def parse(self, data):
assert isinstance(data, bytes)
return data
def _render(self):
assert isinstance(self.value, bytes)
return self.value
def data_size(self):
return len(self.value)
def __bytes__(self):
return self.value
def __str__(self):
return u"".join("%02X" % i for i in self.value)
def __eq__(self, other):
return self.value == other
def __lt__(self, other):
return self.value < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFGUIDAttribute(ASFBaseAttribute):
'''GUID attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.05 | 1 | 1 | 0 | 0 | 7 | 0 | 7 | 13 | 28 | 8 | 19 | 10 | 11 | 1 | 19 | 10 | 11 | 1 | 2 | 0 | 7 |
147,127 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFDWordAttribute
|
class ASFDWordAttribute(ASFBaseAttribute):
"""DWORD attribute."""
TYPE = 0x0003
def parse(self, data):
return struct.unpack("<L", data)[0]
def _render(self):
return struct.pack("<L", self.value)
def data_size(self):
return 4
def __int__(self):
return self.value
def __bytes__(self):
return self.value
def __eq__(self, other):
return int(self.value) == other
def __lt__(self, other):
return int(self.value) < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFDWordAttribute(ASFBaseAttribute):
'''DWORD attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __int__(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.06 | 1 | 1 | 0 | 0 | 7 | 0 | 7 | 13 | 26 | 8 | 17 | 10 | 9 | 1 | 17 | 10 | 9 | 1 | 2 | 0 | 7 |
147,128 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFByteArrayAttribute
|
class ASFByteArrayAttribute(ASFBaseAttribute):
"""Byte array attribute."""
TYPE = 0x0001
def parse(self, data):
assert isinstance(data, bytes)
return data
def _render(self):
assert isinstance(self.value, bytes)
return self.value
def data_size(self):
return len(self.value)
def __bytes__(self):
return self.value
def __str__(self):
return u"[binary data (%s bytes)]" % len(self.value)
def __eq__(self, other):
return self.value == other
def __lt__(self, other):
return self.value < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFByteArrayAttribute(ASFBaseAttribute):
'''Byte array attribute.'''
def parse(self, data):
pass
def _render(self):
pass
def data_size(self):
pass
def __bytes__(self):
pass
def __str__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 2 | 0 | 2 | 0 | 1 | 0.05 | 1 | 1 | 0 | 0 | 7 | 0 | 7 | 13 | 28 | 8 | 19 | 10 | 11 | 1 | 19 | 10 | 11 | 1 | 2 | 0 | 7 |
147,129 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASFBoolAttribute
|
class ASFBoolAttribute(ASFBaseAttribute):
"""Bool attribute."""
TYPE = 0x0002
def parse(self, data, dword=True):
if dword:
return struct.unpack("<I", data)[0] == 1
else:
return struct.unpack("<H", data)[0] == 1
def _render(self, dword=True):
if dword:
return struct.pack("<I", int(self.value))
else:
return struct.pack("<H", int(self.value))
def data_size(self):
return 4
def __bool__(self):
return bool(self.value)
def __bytes__(self):
return self.value
def __eq__(self, other):
return bool(self.value) == other
def __lt__(self, other):
return bool(self.value) < other
__hash__ = ASFBaseAttribute.__hash__
|
class ASFBoolAttribute(ASFBaseAttribute):
'''Bool attribute.'''
def parse(self, data, dword=True):
pass
def _render(self, dword=True):
pass
def data_size(self):
pass
def __bool__(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 8 | 1 | 3 | 0 | 3 | 0 | 1 | 0.04 | 1 | 2 | 0 | 0 | 7 | 0 | 7 | 13 | 32 | 8 | 23 | 10 | 15 | 1 | 21 | 10 | 13 | 2 | 2 | 1 | 9 |
147,130 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.ASF
|
class ASF(FileType):
"""An ASF file, probably containing WMA or WMV."""
_mimes = ["audio/x-ms-wma", "audio/x-ms-wmv", "video/x-ms-asf",
"audio/x-wma", "video/x-wmv"]
def load(self, filename):
self.filename = filename
fileobj = open(filename, "rb")
try:
self.size = 0
self.size1 = 0
self.size2 = 0
self.offset1 = 0
self.offset2 = 0
self.num_objects = 0
self.info = ASFInfo()
self.tags = ASFTags()
self.__read_file(fileobj)
finally:
fileobj.close()
def save(self):
# Move attributes to the right objects
self.to_extended_content_description = {}
self.to_metadata = {}
self.to_metadata_library = []
for name, value in self.tags._internal:
if name in _standard_attribute_names:
continue
library_only = (value.data_size() > 0xFFFF or value.TYPE == GUID)
if (value.language is None and value.stream is None and
name not in self.to_extended_content_description and
not library_only):
self.to_extended_content_description[name] = value
elif (value.language is None and value.stream is not None and
name not in self.to_metadata and not library_only):
self.to_metadata[name] = value
else:
self.to_metadata_library.append((name, value))
# Add missing objects
if not self.content_description_obj:
self.content_description_obj = \
ContentDescriptionObject()
self.objects.append(self.content_description_obj)
if not self.extended_content_description_obj:
self.extended_content_description_obj = \
ExtendedContentDescriptionObject()
self.objects.append(self.extended_content_description_obj)
if not self.header_extension_obj:
self.header_extension_obj = \
HeaderExtensionObject()
self.objects.append(self.header_extension_obj)
if not self.metadata_obj:
self.metadata_obj = \
MetadataObject()
self.header_extension_obj.objects.append(self.metadata_obj)
if not self.metadata_library_obj:
self.metadata_library_obj = \
MetadataLibraryObject()
self.header_extension_obj.objects.append(self.metadata_library_obj)
# Render the header
data = b"".join([obj.render(self) for obj in self.objects])
data = (HeaderObject.GUID +
struct.pack("<QL", len(data) + 30, len(self.objects)) +
b"\x01\x02" + data)
fileobj = open(self.filename, "rb+")
try:
size = len(data)
if size > self.size:
insert_bytes(fileobj, size - self.size, self.size)
if size < self.size:
delete_bytes(fileobj, self.size - size, 0)
fileobj.seek(0)
fileobj.write(data)
finally:
fileobj.close()
self.size = size
self.num_objects = len(self.objects)
def __read_file(self, fileobj):
header = fileobj.read(30)
if len(header) != 30 or header[:16] != HeaderObject.GUID:
raise ASFHeaderError("Not an ASF file.")
self.extended_content_description_obj = None
self.content_description_obj = None
self.header_extension_obj = None
self.metadata_obj = None
self.metadata_library_obj = None
self.size, self.num_objects = struct.unpack("<QL", header[16:28])
self.objects = []
for i in range(self.num_objects):
self.__read_object(fileobj)
def __read_object(self, fileobj):
guid, size = struct.unpack("<16sQ", fileobj.read(24))
if guid in _object_types:
obj = _object_types[guid]()
else:
obj = UnknownObject(guid)
data = fileobj.read(size - 24)
obj.parse(self, data, fileobj, size)
self.objects.append(obj)
@staticmethod
def score(filename, fileobj, header):
return header.startswith(HeaderObject.GUID) * 2
|
class ASF(FileType):
'''An ASF file, probably containing WMA or WMV.'''
def load(self, filename):
pass
def save(self):
pass
def __read_file(self, fileobj):
pass
def __read_object(self, fileobj):
pass
@staticmethod
def score(filename, fileobj, header):
pass
| 7 | 1 | 20 | 1 | 19 | 1 | 4 | 0.04 | 1 | 11 | 10 | 0 | 4 | 18 | 5 | 18 | 113 | 12 | 97 | 37 | 90 | 4 | 80 | 36 | 74 | 12 | 2 | 2 | 19 |
147,131 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/apev2.py
|
mutagen.apev2._APEv2Data
|
class _APEv2Data(object):
# Store offsets of the important parts of the file.
start = header = data = footer = end = None
# Footer or header; seek here and read 32 to get version/size/items/flags
metadata = None
# Actual tag data
tag = None
version = None
size = None
items = None
flags = 0
# The tag is at the start rather than the end. A tag at both
# the start and end of the file (i.e. the tag is the whole file)
# is not considered to be at the start.
is_at_start = False
def __init__(self, fileobj):
self.__find_metadata(fileobj)
if self.header is None:
self.metadata = self.footer
elif self.footer is None:
self.metadata = self.header
else:
self.metadata = max(self.header, self.footer)
if self.metadata is None:
return
self.__fill_missing(fileobj)
self.__fix_brokenness(fileobj)
if self.data is not None:
fileobj.seek(self.data)
self.tag = fileobj.read(self.size)
def __find_metadata(self, fileobj):
# Try to find a header or footer.
# Check for a simple footer.
try:
fileobj.seek(-32, 2)
except IOError:
fileobj.seek(0, 2)
return
if fileobj.read(8) == b"APETAGEX":
fileobj.seek(-8, 1)
self.footer = self.metadata = fileobj.tell()
return
# Check for an APEv2 tag followed by an ID3v1 tag at the end.
try:
fileobj.seek(-128, 2)
if fileobj.read(3) == b"TAG":
fileobj.seek(-35, 1) # "TAG" + header length
if fileobj.read(8) == b"APETAGEX":
fileobj.seek(-8, 1)
self.footer = fileobj.tell()
return
# ID3v1 tag at the end, maybe preceded by Lyrics3v2.
# (http://www.id3.org/lyrics3200.html)
# (header length - "APETAGEX") - "LYRICS200"
fileobj.seek(15, 1)
if fileobj.read(9) == b'LYRICS200':
fileobj.seek(-15, 1) # "LYRICS200" + size tag
try:
offset = int(fileobj.read(6))
except ValueError:
raise IOError
fileobj.seek(-32 - offset - 6, 1)
if fileobj.read(8) == b"APETAGEX":
fileobj.seek(-8, 1)
self.footer = fileobj.tell()
return
except IOError:
pass
# Check for a tag at the start.
fileobj.seek(0, 0)
if fileobj.read(8) == b"APETAGEX":
self.is_at_start = True
self.header = 0
def __fill_missing(self, fileobj):
fileobj.seek(self.metadata + 8)
self.version = fileobj.read(4)
self.size = cdata.uint_le(fileobj.read(4))
self.items = cdata.uint_le(fileobj.read(4))
self.flags = cdata.uint_le(fileobj.read(4))
if self.header is not None:
self.data = self.header + 32
# If we're reading the header, the size is the header
# offset + the size, which includes the footer.
self.end = self.data + self.size
fileobj.seek(self.end - 32, 0)
if fileobj.read(8) == b"APETAGEX":
self.footer = self.end - 32
elif self.footer is not None:
self.end = self.footer + 32
self.data = self.end - self.size
if self.flags & HAS_HEADER:
self.header = self.data - 32
else:
self.header = self.data
else:
raise APENoHeaderError("No APE tag found")
# exclude the footer from size
if self.footer is not None:
self.size -= 32
def __fix_brokenness(self, fileobj):
# Fix broken tags written with PyMusepack.
if self.header is not None:
start = self.header
else:
start = self.data
fileobj.seek(start)
while start > 0:
# Clean up broken writing from pre-Mutagen PyMusepack.
# It didn't remove the first 24 bytes of header.
try:
fileobj.seek(-24, 1)
except IOError:
break
else:
if fileobj.read(8) == b"APETAGEX":
fileobj.seek(-8, 1)
start = fileobj.tell()
else:
break
self.start = start
|
class _APEv2Data(object):
def __init__(self, fileobj):
pass
def __find_metadata(self, fileobj):
pass
def __fill_missing(self, fileobj):
pass
def __fix_brokenness(self, fileobj):
pass
| 5 | 0 | 30 | 3 | 23 | 4 | 7 | 0.21 | 1 | 4 | 2 | 0 | 4 | 0 | 4 | 4 | 139 | 19 | 101 | 15 | 96 | 21 | 94 | 15 | 89 | 10 | 1 | 4 | 26 |
147,132 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/apev2.py
|
mutagen.apev2._APEValue
|
class _APEValue(object):
def __init__(self, value, kind):
if not isinstance(value, bytes):
raise TypeError("value not bytes")
self.kind = kind
self.value = value
def __len__(self):
return len(self.value)
def __bytes__(self):
return self.value
def __eq__(self, other):
return bytes(self) == other
def __lt__(self, other):
return bytes(self) < other
# Packed format for an item:
# 4B: Value length
# 4B: Value type
# Key name
# 1B: Null
# Key value
def _internal(self, key):
if not isinstance(key, bytes):
key = key.encode("utf-8")
data = bytearray()
data += struct.pack("<2I", len(self.value), self.kind << 1)
data += key
data += b"\0"
data += self.value
return bytes(data)
def __repr__(self):
return "%s(%r, %d)" % (type(self).__name__, self.value, self.kind)
|
class _APEValue(object):
def __init__(self, value, kind):
pass
def __len__(self):
pass
def __bytes__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
def _internal(self, key):
pass
def __repr__(self):
pass
| 8 | 0 | 3 | 0 | 3 | 0 | 1 | 0.24 | 1 | 4 | 0 | 2 | 7 | 2 | 7 | 7 | 37 | 6 | 25 | 11 | 17 | 6 | 25 | 11 | 17 | 2 | 1 | 1 | 9 |
147,133 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/apev2.py
|
mutagen.apev2._APEUtf8Value
|
class _APEUtf8Value(_APEValue):
def __str__(self):
return self.value.decode("utf-8")
def __eq__(self, other):
return text_type(self) == other
def __lt__(self, other):
return text_type(self) < other
|
class _APEUtf8Value(_APEValue):
def __str__(self):
pass
def __eq__(self, other):
pass
def __lt__(self, other):
pass
| 4 | 0 | 2 | 0 | 2 | 0 | 1 | 0 | 1 | 0 | 0 | 2 | 3 | 0 | 3 | 10 | 10 | 3 | 7 | 4 | 3 | 0 | 7 | 4 | 3 | 1 | 2 | 0 | 3 |
147,134 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/apev2.py
|
mutagen.apev2.APEv2File
|
class APEv2File(FileType):
class _Info(StreamInfo):
length = 0
bitrate = 0
def __init__(self, fileobj):
pass
@staticmethod
def pprint():
return u"Unknown format with APEv2 tag."
def load(self, filename):
self.filename = filename
self.info = self._Info(open(filename, "rb"))
try:
self.tags = APEv2(filename)
except error:
self.tags = None
def add_tags(self):
if self.tags is None:
self.tags = APEv2()
else:
raise ValueError("%r already has tags: %r" % (self, self.tags))
@staticmethod
def score(filename, fileobj, header):
try:
fileobj.seek(-160, 2)
except IOError:
fileobj.seek(0)
footer = fileobj.read()
filename = filename.lower()
return ((b"APETAGEX" in footer) - header.startswith(b"ID3"))
|
class APEv2File(FileType):
class _Info(StreamInfo):
def __init__(self, fileobj):
pass
@staticmethod
def pprint():
pass
def load(self, filename):
pass
def add_tags(self):
pass
@staticmethod
def score(filename, fileobj, header):
pass
| 9 | 0 | 5 | 0 | 5 | 0 | 2 | 0 | 1 | 4 | 3 | 4 | 2 | 3 | 3 | 16 | 35 | 5 | 30 | 15 | 21 | 0 | 27 | 13 | 20 | 2 | 2 | 1 | 8 |
147,135 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.MetadataObject
|
class MetadataObject(BaseObject):
"""Metadata description."""
GUID = b"\xea\xcb\xf8\xc5\xaf[wH\x84g\xaa\x8cD\xfaL\xca"
def parse(self, asf, data, fileobj, size):
super(MetadataObject, self).parse(asf, data, fileobj, size)
asf.metadata_obj = self
num_attributes, = struct.unpack("<H", data[0:2])
pos = 2
for i in range(num_attributes):
(reserved, stream, name_length, value_type,
value_length) = struct.unpack("<HHHHI", data[pos:pos+12])
pos += 12
name = data[pos:pos+name_length].decode("utf-16-le").strip("\x00")
pos += name_length
value = data[pos:pos+value_length]
pos += value_length
args = {'data': value, 'stream': stream}
if value_type == 2:
args['dword'] = False
attr = _attribute_types[value_type](**args)
asf.tags.append((name, attr))
def render(self, asf):
attrs = asf.to_metadata.items()
data = b"".join([attr.render_m(name) for (name, attr) in attrs])
return (self.GUID + struct.pack("<QH", 26 + len(data), len(attrs)) +
data)
|
class MetadataObject(BaseObject):
'''Metadata description.'''
def parse(self, asf, data, fileobj, size):
pass
def render(self, asf):
pass
| 3 | 1 | 12 | 0 | 12 | 0 | 2 | 0.04 | 1 | 2 | 0 | 0 | 2 | 0 | 2 | 4 | 28 | 2 | 25 | 15 | 22 | 1 | 23 | 14 | 20 | 3 | 2 | 2 | 4 |
147,136 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.StreamPropertiesObject
|
class StreamPropertiesObject(BaseObject):
"""Stream properties."""
GUID = b"\x91\x07\xDC\xB7\xB7\xA9\xCF\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65"
def parse(self, asf, data, fileobj, size):
super(StreamPropertiesObject, self).parse(asf, data, fileobj, size)
channels, sample_rate, bitrate = struct.unpack("<HII", data[56:66])
asf.info.channels = channels
asf.info.sample_rate = sample_rate
asf.info.bitrate = bitrate * 8
|
class StreamPropertiesObject(BaseObject):
'''Stream properties.'''
def parse(self, asf, data, fileobj, size):
pass
| 2 | 1 | 6 | 0 | 6 | 0 | 1 | 0.13 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | 3 | 10 | 1 | 8 | 4 | 6 | 1 | 8 | 4 | 6 | 1 | 2 | 0 | 1 |
147,137 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/asf.py
|
mutagen.asf.UnknownObject
|
class UnknownObject(BaseObject):
"""Unknown ASF object."""
def __init__(self, guid):
assert isinstance(guid, bytes)
self.GUID = guid
|
class UnknownObject(BaseObject):
'''Unknown ASF object.'''
def __init__(self, guid):
pass
| 2 | 1 | 3 | 0 | 3 | 0 | 1 | 0.25 | 1 | 1 | 0 | 0 | 1 | 1 | 1 | 3 | 5 | 0 | 4 | 3 | 2 | 1 | 4 | 3 | 2 | 1 | 2 | 0 | 1 |
147,138 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/easyid3.py
|
mutagen.easyid3.EasyID3FileType
|
class EasyID3FileType(ID3FileType):
"""Like ID3FileType, but uses EasyID3 for tags."""
ID3 = EasyID3
|
class EasyID3FileType(ID3FileType):
'''Like ID3FileType, but uses EasyID3 for tags.'''
pass
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0.5 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 16 | 3 | 0 | 2 | 2 | 1 | 1 | 2 | 2 | 1 | 0 | 3 | 0 | 0 |
147,139 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.MetadataBlock
|
class MetadataBlock(object):
"""A generic block of FLAC metadata.
This class is extended by specific used as an ancestor for more specific
blocks, and also as a container for data blobs of unknown blocks.
Attributes:
* data -- raw binary data for this block
"""
_distrust_size = False
def __init__(self, data):
"""Parse the given data string or file-like as a metadata block.
The metadata header should not be included."""
if data is not None:
if not isinstance(data, StrictFileObject):
if isinstance(data, bytes):
data = cBytesIO(data)
elif not hasattr(data, 'read'):
raise TypeError(
"StreamInfo requires string data or a file-like")
data = StrictFileObject(data)
self.load(data)
def load(self, data):
self.data = data.read()
def write(self):
return self.data
@staticmethod
def writeblocks(blocks):
"""Render metadata block as a byte string."""
data = []
codes = [[block.code, block.write()] for block in blocks]
codes[-1][0] |= 128
for code, datum in codes:
byte = chr_(code)
if len(datum) > 2**24:
raise error("block is too long to write")
length = struct.pack(">I", len(datum))[-3:]
data.append(byte + length + datum)
return b"".join(data)
@staticmethod
def group_padding(blocks):
"""Consolidate FLAC padding metadata blocks.
The overall size of the rendered blocks does not change, so
this adds several bytes of padding for each merged block.
"""
paddings = [b for b in blocks if isinstance(b, Padding)]
for p in paddings:
blocks.remove(p)
# total padding size is the sum of padding sizes plus 4 bytes
# per removed header.
size = sum(padding.length for padding in paddings)
padding = Padding()
padding.length = size + 4 * (len(paddings) - 1)
blocks.append(padding)
|
class MetadataBlock(object):
'''A generic block of FLAC metadata.
This class is extended by specific used as an ancestor for more specific
blocks, and also as a container for data blobs of unknown blocks.
Attributes:
* data -- raw binary data for this block
'''
def __init__(self, data):
'''Parse the given data string or file-like as a metadata block.
The metadata header should not be included.'''
pass
def load(self, data):
pass
def write(self):
pass
@staticmethod
def writeblocks(blocks):
'''Render metadata block as a byte string.'''
pass
@staticmethod
def group_padding(blocks):
'''Consolidate FLAC padding metadata blocks.
The overall size of the rendered blocks does not change, so
this adds several bytes of padding for each merged block.
'''
pass
| 8 | 4 | 9 | 0 | 7 | 2 | 2 | 0.41 | 1 | 5 | 3 | 5 | 3 | 1 | 5 | 5 | 63 | 11 | 37 | 18 | 29 | 15 | 33 | 16 | 27 | 5 | 1 | 3 | 12 |
147,140 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.Padding
|
class Padding(MetadataBlock):
"""Empty padding space for metadata blocks.
To avoid rewriting the entire FLAC file when editing comments,
metadata is often padded. Padding should occur at the end, and no
more than one padding block should be in any FLAC file. Mutagen
handles this with MetadataBlock.group_padding.
"""
code = 1
def __init__(self, data=b""):
super(Padding, self).__init__(data)
def load(self, data):
self.length = len(data.read())
def write(self):
try:
return b"\x00" * self.length
# On some 64 bit platforms this won't generate a MemoryError
# or OverflowError since you might have enough RAM, but it
# still generates a ValueError. On other 64 bit platforms,
# this will still succeed for extremely large values.
# Those should never happen in the real world, and if they
# do, writeblocks will catch it.
except (OverflowError, ValueError, MemoryError):
raise error("cannot write %d bytes" % self.length)
def __eq__(self, other):
return isinstance(other, Padding) and self.length == other.length
__hash__ = MetadataBlock.__hash__
def __repr__(self):
return "<%s (%d bytes)>" % (type(self).__name__, self.length)
|
class Padding(MetadataBlock):
'''Empty padding space for metadata blocks.
To avoid rewriting the entire FLAC file when editing comments,
metadata is often padded. Padding should occur at the end, and no
more than one padding block should be in any FLAC file. Mutagen
handles this with MetadataBlock.group_padding.
'''
def __init__(self, data=b""):
pass
def load(self, data):
pass
def write(self):
pass
def __eq__(self, other):
pass
def __repr__(self):
pass
| 6 | 1 | 4 | 0 | 3 | 1 | 1 | 0.75 | 1 | 6 | 1 | 0 | 5 | 1 | 5 | 10 | 36 | 8 | 16 | 9 | 10 | 12 | 16 | 9 | 10 | 2 | 2 | 1 | 6 |
147,141 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.Picture
|
class Picture(MetadataBlock):
"""Read and write FLAC embed pictures.
Attributes:
* type -- picture type (same as types for ID3 APIC frames)
* mime -- MIME type of the picture
* desc -- picture's description
* width -- width in pixels
* height -- height in pixels
* depth -- color depth in bits-per-pixel
* colors -- number of colors for indexed palettes (like GIF),
0 for non-indexed
* data -- picture data
"""
code = 6
_distrust_size = True
def __init__(self, data=None):
self.type = 0
self.mime = u''
self.desc = u''
self.width = 0
self.height = 0
self.depth = 0
self.colors = 0
self.data = b''
super(Picture, self).__init__(data)
def __eq__(self, other):
try:
return (self.type == other.type and
self.mime == other.mime and
self.desc == other.desc and
self.width == other.width and
self.height == other.height and
self.depth == other.depth and
self.colors == other.colors and
self.data == other.data)
except (AttributeError, TypeError):
return False
__hash__ = MetadataBlock.__hash__
def load(self, data):
self.type, length = struct.unpack('>2I', data.read(8))
self.mime = data.read(length).decode('UTF-8', 'replace')
length, = struct.unpack('>I', data.read(4))
self.desc = data.read(length).decode('UTF-8', 'replace')
(self.width, self.height, self.depth,
self.colors, length) = struct.unpack('>5I', data.read(20))
self.data = data.read(length)
def write(self):
f = cBytesIO()
mime = self.mime.encode('UTF-8')
f.write(struct.pack('>2I', self.type, len(mime)))
f.write(mime)
desc = self.desc.encode('UTF-8')
f.write(struct.pack('>I', len(desc)))
f.write(desc)
f.write(struct.pack('>5I', self.width, self.height, self.depth,
self.colors, len(self.data)))
f.write(self.data)
return f.getvalue()
def __repr__(self):
return "<%s '%s' (%d bytes)>" % (type(self).__name__, self.mime,
len(self.data))
|
class Picture(MetadataBlock):
'''Read and write FLAC embed pictures.
Attributes:
* type -- picture type (same as types for ID3 APIC frames)
* mime -- MIME type of the picture
* desc -- picture's description
* width -- width in pixels
* height -- height in pixels
* depth -- color depth in bits-per-pixel
* colors -- number of colors for indexed palettes (like GIF),
0 for non-indexed
* data -- picture data
'''
def __init__(self, data=None):
pass
def __eq__(self, other):
pass
def load(self, data):
pass
def write(self):
pass
def __repr__(self):
pass
| 6 | 1 | 9 | 0 | 9 | 0 | 1 | 0.24 | 1 | 4 | 0 | 0 | 5 | 8 | 5 | 10 | 70 | 9 | 49 | 21 | 43 | 12 | 39 | 21 | 33 | 2 | 2 | 1 | 6 |
147,142 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.SeekPoint
|
class SeekPoint(tuple):
"""A single seek point in a FLAC file.
Placeholder seek points have first_sample of 0xFFFFFFFFFFFFFFFFL,
and byte_offset and num_samples undefined. Seek points must be
sorted in ascending order by first_sample number. Seek points must
be unique by first_sample number, except for placeholder
points. Placeholder points must occur last in the table and there
may be any number of them.
Attributes:
* first_sample -- sample number of first sample in the target frame
* byte_offset -- offset from first frame to target frame
* num_samples -- number of samples in target frame
"""
def __new__(cls, first_sample, byte_offset, num_samples):
return super(cls, SeekPoint).__new__(
cls, (first_sample, byte_offset, num_samples))
first_sample = property(lambda self: self[0])
byte_offset = property(lambda self: self[1])
num_samples = property(lambda self: self[2])
|
class SeekPoint(tuple):
'''A single seek point in a FLAC file.
Placeholder seek points have first_sample of 0xFFFFFFFFFFFFFFFFL,
and byte_offset and num_samples undefined. Seek points must be
sorted in ascending order by first_sample number. Seek points must
be unique by first_sample number, except for placeholder
points. Placeholder points must occur last in the table and there
may be any number of them.
Attributes:
* first_sample -- sample number of first sample in the target frame
* byte_offset -- offset from first frame to target frame
* num_samples -- number of samples in target frame
'''
def __new__(cls, first_sample, byte_offset, num_samples):
pass
| 2 | 1 | 3 | 0 | 3 | 0 | 1 | 1.71 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | 21 | 24 | 5 | 7 | 5 | 5 | 12 | 6 | 5 | 4 | 1 | 2 | 0 | 1 |
147,143 |
LordSputnik/mutagen
|
LordSputnik_mutagen/tests/test_tools_mutagen_pony.py
|
tests.test_tools_mutagen_pony.TMutagenPony
|
class TMutagenPony(_TTools):
TOOL_NAME = "mutagen-pony"
def test_basic(self):
base = os.path.join('tests', 'data')
res, out = self.call(base)
self.failIf(res)
self.failUnless("Report for tests/data" in out)
|
class TMutagenPony(_TTools):
def test_basic(self):
pass
| 2 | 0 | 5 | 0 | 5 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 80 | 9 | 2 | 7 | 5 | 5 | 0 | 7 | 5 | 5 | 1 | 4 | 0 | 1 |
147,144 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.SeekTable
|
class SeekTable(MetadataBlock):
"""Read and write FLAC seek tables.
Attributes:
* seekpoints -- list of SeekPoint objects
"""
__SEEKPOINT_FORMAT = '>QQH'
__SEEKPOINT_SIZE = struct.calcsize(__SEEKPOINT_FORMAT)
code = 3
def __init__(self, data):
self.seekpoints = []
super(SeekTable, self).__init__(data)
def __eq__(self, other):
try:
return (self.seekpoints == other.seekpoints)
except (AttributeError, TypeError):
return False
__hash__ = MetadataBlock.__hash__
def load(self, data):
self.seekpoints = []
sp = data.tryread(self.__SEEKPOINT_SIZE)
while len(sp) == self.__SEEKPOINT_SIZE:
self.seekpoints.append(SeekPoint(
*struct.unpack(self.__SEEKPOINT_FORMAT, sp)))
sp = data.tryread(self.__SEEKPOINT_SIZE)
def write(self):
f = cBytesIO()
for seekpoint in self.seekpoints:
packed = struct.pack(
self.__SEEKPOINT_FORMAT,
seekpoint.first_sample, seekpoint.byte_offset,
seekpoint.num_samples)
f.write(packed)
return f.getvalue()
def __repr__(self):
return "<%s seekpoints=%r>" % (type(self).__name__, self.seekpoints)
|
class SeekTable(MetadataBlock):
'''Read and write FLAC seek tables.
Attributes:
* seekpoints -- list of SeekPoint objects
'''
def __init__(self, data):
pass
def __eq__(self, other):
pass
def load(self, data):
pass
def write(self):
pass
def __repr__(self):
pass
| 6 | 1 | 5 | 0 | 5 | 0 | 2 | 0.13 | 1 | 5 | 1 | 0 | 5 | 1 | 5 | 10 | 45 | 10 | 31 | 15 | 25 | 4 | 27 | 15 | 21 | 2 | 2 | 1 | 8 |
147,145 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.StreamInfo
|
class StreamInfo(MetadataBlock, mutagen.StreamInfo):
"""FLAC stream information.
This contains information about the audio data in the FLAC file.
Unlike most stream information objects in Mutagen, changes to this
one will rewritten to the file when it is saved. Unless you are
actually changing the audio stream itself, don't change any
attributes of this block.
Attributes:
* min_blocksize -- minimum audio block size
* max_blocksize -- maximum audio block size
* sample_rate -- audio sample rate in Hz
* channels -- audio channels (1 for mono, 2 for stereo)
* bits_per_sample -- bits per sample
* total_samples -- total samples in file
* length -- audio length in seconds
"""
code = 0
def __eq__(self, other):
try:
return (self.min_blocksize == other.min_blocksize and
self.max_blocksize == other.max_blocksize and
self.sample_rate == other.sample_rate and
self.channels == other.channels and
self.bits_per_sample == other.bits_per_sample and
self.total_samples == other.total_samples)
except:
return False
__hash__ = MetadataBlock.__hash__
def load(self, data):
self.min_blocksize = int(to_int_be(data.read(2)))
self.max_blocksize = int(to_int_be(data.read(2)))
self.min_framesize = int(to_int_be(data.read(3)))
self.max_framesize = int(to_int_be(data.read(3)))
# first 16 bits of sample rate
sample_first = to_int_be(data.read(2))
# last 4 bits of sample rate, 3 of channels, first 1 of bits/sample
sample_channels_bps = to_int_be(data.read(1))
# last 4 of bits/sample, 36 of total samples
bps_total = to_int_be(data.read(5))
sample_tail = sample_channels_bps >> 4
self.sample_rate = int((sample_first << 4) + sample_tail)
if not self.sample_rate:
raise error("A sample rate value of 0 is invalid")
self.channels = int(((sample_channels_bps >> 1) & 7) + 1)
bps_tail = bps_total >> 36
bps_head = (sample_channels_bps & 1) << 4
self.bits_per_sample = int(bps_head + bps_tail + 1)
self.total_samples = bps_total & 0xFFFFFFFFF
self.length = self.total_samples / float(self.sample_rate)
self.md5_signature = to_int_be(data.read(16))
def write(self):
f = cBytesIO()
f.write(struct.pack(">I", self.min_blocksize)[-2:])
f.write(struct.pack(">I", self.max_blocksize)[-2:])
f.write(struct.pack(">I", self.min_framesize)[-3:])
f.write(struct.pack(">I", self.max_framesize)[-3:])
# first 16 bits of sample rate
f.write(struct.pack(">I", self.sample_rate >> 4)[-2:])
# 4 bits sample, 3 channel, 1 bps
byte = (self.sample_rate & 0xF) << 4
byte += ((self.channels - 1) & 7) << 1
byte += ((self.bits_per_sample - 1) >> 4) & 1
f.write(chr_(byte))
# 4 bits of bps, 4 of sample count
byte = ((self.bits_per_sample - 1) & 0xF) << 4
byte += (self.total_samples >> 32) & 0xF
f.write(chr_(byte))
# last 32 of sample count
f.write(struct.pack(">I", self.total_samples & 0xFFFFFFFF))
# MD5 signature
sig = self.md5_signature
f.write(struct.pack(
">4I", (sig >> 96) & 0xFFFFFFFF, (sig >> 64) & 0xFFFFFFFF,
(sig >> 32) & 0xFFFFFFFF, sig & 0xFFFFFFFF))
return f.getvalue()
def pprint(self):
return "FLAC, %.2f seconds, %d Hz" % (self.length, self.sample_rate)
|
class StreamInfo(MetadataBlock, mutagen.StreamInfo):
'''FLAC stream information.
This contains information about the audio data in the FLAC file.
Unlike most stream information objects in Mutagen, changes to this
one will rewritten to the file when it is saved. Unless you are
actually changing the audio stream itself, don't change any
attributes of this block.
Attributes:
* min_blocksize -- minimum audio block size
* max_blocksize -- maximum audio block size
* sample_rate -- audio sample rate in Hz
* channels -- audio channels (1 for mono, 2 for stereo)
* bits_per_sample -- bits per sample
* total_samples -- total samples in file
* length -- audio length in seconds
'''
def __eq__(self, other):
pass
def load(self, data):
pass
def write(self):
pass
def pprint(self):
pass
| 5 | 1 | 16 | 1 | 13 | 2 | 2 | 0.43 | 2 | 3 | 1 | 1 | 4 | 10 | 4 | 10 | 89 | 12 | 54 | 26 | 49 | 23 | 47 | 26 | 42 | 2 | 2 | 1 | 6 |
147,146 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.StrictFileObject
|
class StrictFileObject(object):
"""Wraps a file-like object and raises an exception if the requested
amount of data to read isn't returned."""
def __init__(self, fileobj):
self._fileobj = fileobj
for m in ["close", "tell", "seek", "write", "name"]:
if hasattr(fileobj, m):
setattr(self, m, getattr(fileobj, m))
def read(self, size=-1):
data = self._fileobj.read(size)
if size >= 0 and len(data) != size:
raise error("file said %d bytes, read %d bytes" % (
size, len(data)))
return data
def tryread(self, *args):
return self._fileobj.read(*args)
|
class StrictFileObject(object):
'''Wraps a file-like object and raises an exception if the requested
amount of data to read isn't returned.'''
def __init__(self, fileobj):
pass
def read(self, size=-1):
pass
def tryread(self, *args):
pass
| 4 | 1 | 4 | 0 | 4 | 0 | 2 | 0.14 | 1 | 1 | 1 | 0 | 3 | 1 | 3 | 3 | 19 | 3 | 14 | 7 | 10 | 2 | 13 | 7 | 9 | 3 | 1 | 2 | 6 |
147,147 |
LordSputnik/mutagen
|
LordSputnik_mutagen/mutagen/flac.py
|
mutagen.flac.VCFLACDict
|
class VCFLACDict(VCommentDict):
"""Read and write FLAC Vorbis comments.
FLACs don't use the framing bit at the end of the comment block.
So this extends VCommentDict to not use the framing bit.
"""
code = 4
_distrust_size = True
def load(self, data, errors='replace', framing=False):
super(VCFLACDict, self).load(data, errors=errors, framing=framing)
def write(self, framing=False):
return super(VCFLACDict, self).write(framing=framing)
|
class VCFLACDict(VCommentDict):
'''Read and write FLAC Vorbis comments.
FLACs don't use the framing bit at the end of the comment block.
So this extends VCommentDict to not use the framing bit.
'''
def load(self, data, errors='replace', framing=False):
pass
def write(self, framing=False):
pass
| 3 | 1 | 2 | 0 | 2 | 0 | 1 | 0.57 | 1 | 1 | 0 | 1 | 2 | 0 | 2 | 25 | 15 | 4 | 7 | 5 | 4 | 4 | 7 | 5 | 4 | 1 | 2 | 0 | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.