desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Returns:
text: tag information'
| def pprint(self):
| raise NotImplementedError
|
'save(filething=None, **kwargs)
Save changes to a file.
Args:
filething (filething): or `None`
Raises:
MutagenError: if saving wasn\'t possible'
| @loadfile(writable=False)
def save(self, filething, **kwargs):
| raise NotImplementedError
|
'delete(filething=None)
Remove tags from a file.
In most cases this means any traces of the tag will be removed
from the file.
Args:
filething (filething): or `None`
Raises:
MutagenError: if deleting wasn\'t possible'
| @loadfile(writable=False)
def delete(self, filething):
| raise NotImplementedError
|
'Raises TrueAudioHeaderError'
| @convert_error(IOError, TrueAudioHeaderError)
def __init__(self, fileobj, offset):
| fileobj.seek((offset or 0))
header = fileobj.read(18)
if ((len(header) != 18) or (not header.startswith('TTA'))):
raise TrueAudioHeaderError('TTA header not found')
self.sample_rate = cdata.int_le(header[10:14])
samples = cdata.uint_le(header[14:18])
self.length = (float(samples... |
'Raises MonkeysAudioHeaderError'
| @convert_error(IOError, MonkeysAudioHeaderError)
def __init__(self, fileobj):
| header = fileobj.read(76)
if ((len(header) != 76) or (not header.startswith('MAC '))):
raise MonkeysAudioHeaderError("not a Monkey's Audio file")
self.version = cdata.ushort_le(header[4:6])
if (self.version >= 3980):
(blocks_per_frame, final_frame_blocks, total_frames, sel... |
'A new _WavPackHeader or raises WavPackHeaderError'
| @classmethod
@convert_error(IOError, WavPackHeaderError)
def from_fileobj(cls, fileobj):
| header = fileobj.read(32)
if ((len(header) != 32) or (not header.startswith('wvpk'))):
raise WavPackHeaderError(('not a WavPack header: %r' % header))
block_size = cdata.uint_le(header[4:8])
version = cdata.ushort_le(header[8:10])
track_no = ord(header[10:11])
index_no = ord(... |
'Returns:
text: a stream information text summary'
| def pprint(self):
| s = (u'ASF (%s) %d bps, %s Hz, %d channels, %.2f seconds' % ((self.codec_type or self.codec_name or u'???'), self.bitrate, self.sample_rate, self.channels, self.length))
return s
|
'A list of values for the key.
This is a copy, so comment[\'title\'].append(\'a title\') will not
work.'
| def __getitem__(self, key):
| if isinstance(key, slice):
return list.__getitem__(self, key)
values = [value for (k, value) in self if (k == key)]
if (not values):
raise KeyError(key)
else:
return values
|
'Delete all values associated with the key.'
| def __delitem__(self, key):
| if isinstance(key, slice):
return list.__delitem__(self, key)
to_delete = [x for x in self if (x[0] == key)]
if (not to_delete):
raise KeyError(key)
else:
for k in to_delete:
self.remove(k)
|
'Return true if the key has any values.'
| def __contains__(self, key):
| for (k, value) in self:
if (k == key):
return True
else:
return False
|
'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.'
| def __setitem__(self, key, values):
| if isinstance(key, slice):
return list.__setitem__(self, key, values)
if (not isinstance(values, list)):
values = [values]
to_append = []
for value in values:
if (not isinstance(value, ASFBaseAttribute)):
if isinstance(value, string_types):
value = ASF... |
'Return a sequence of all keys in the comment.'
| def keys(self):
| return (self and set(next(izip(*self))))
|
'Return a copy of the comment data in a real dict.'
| def as_dict(self):
| d = {}
for (key, value) in self:
d.setdefault(key, []).append(value)
return d
|
'Returns a string containing all key, value pairs.
:rtype: text'
| def pprint(self):
| return '\n'.join((('%s=%s' % (k, v)) for (k, v) in self))
|
'load(filething)
Args:
filething (filething)
Raises:
mutagen.MutagenError'
| @convert_error(IOError, error)
@loadfile()
def load(self, filething):
| fileobj = filething.fileobj
self.info = ASFInfo()
self.tags = ASFTags()
self._tags = {}
self._header = HeaderObject.parse_full(self, fileobj)
for guid in [ContentDescriptionObject.GUID, ExtendedContentDescriptionObject.GUID, MetadataObject.GUID, MetadataLibraryObject.GUID]:
self.tags.ext... |
'save(filething=None, padding=None)
Save tag changes back to the loaded file.
Args:
filething (filething)
padding (PaddingFunction)
Raises:
mutagen.MutagenError'
| @convert_error(IOError, error)
@loadfile(writable=True)
def save(self, filething, padding=None):
| self.to_content_description = {}
self.to_extended_content_description = {}
self.to_metadata = {}
self.to_metadata_library = []
for (name, value) in self.tags:
library_only = ((value.data_size() > 65535) or (value.TYPE == GUID))
can_cont_desc = (value.TYPE == UNICODE)
if (libr... |
'delete(filething=None)
Args:
filething (filething)
Raises:
mutagen.MutagenError'
| @loadfile(writable=True)
def delete(self, filething):
| self.tags.clear()
self.save(filething, padding=(lambda x: 0))
|
'Raises ASFHeaderError'
| @classmethod
def parse_full(cls, asf, fileobj):
| header = cls()
(remaining_header, num_objects) = cls.parse_size(fileobj)
remaining_header -= 30
for i in xrange(num_objects):
obj_header_size = 24
if (remaining_header < obj_header_size):
raise ASFHeaderError('invalid header size')
data = fileobj.read(obj_header... |
'Returns (size, num_objects)
Raises ASFHeaderError'
| @classmethod
def parse_size(cls, fileobj):
| header = fileobj.read(30)
if ((len(header) != 30) or (header[:16] != HeaderObject.GUID)):
raise ASFHeaderError('Not an ASF file.')
return struct.unpack('<QL', header[16:28])
|
'can raise cdata.error'
| def _parse_entry(self, data, offset):
| (type_, offset) = cdata.uint16_le_from(data, offset)
(units, offset) = cdata.uint16_le_from(data, offset)
next_offset = (offset + (units * 2))
try:
name = data[offset:next_offset].decode('utf-16-le').strip('\x00')
except UnicodeDecodeError:
name = u''
offset = next_offset
(un... |
'Raises KeyError'
| @classmethod
def _get_type(cls, type_):
| return cls._TYPES[type_]
|
'Raises TypeError or ValueError in case the user supplied value
isn\'t valid.'
| def _validate(self, value):
| return value
|
'Write tag data into the Theora comment packet/page.'
| def _inject(self, fileobj, padding_func):
| fileobj.seek(0)
page = OggPage(fileobj)
while (not page.packets[0].startswith('\x81theora')):
page = OggPage(fileobj)
old_pages = [page]
while (not (old_pages[(-1)].complete or (len(old_pages[(-1)].packets) > 1))):
page = OggPage(fileobj)
if (page.serial == old_pages[0].seria... |
'While this context manager is active any signals for aborting
the process will be queued and exit the program once the context
is left.'
| @contextlib.contextmanager
def block(self):
| self._nosig = True
(yield)
self._nosig = False
if self._interrupted:
raise SystemExit('Aborted...')
|
'Raises IOError and apev2.error'
| 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... |
'Raises IOError and apev2.error'
| def __fill_missing(self, fileobj):
| fileobj.seek((self.metadata + 8))
data = fileobj.read(16)
if (len(data) != 16):
raise error
self.version = data[:4]
self.size = cdata.uint32_le(data[4:8])
self.items = cdata.uint32_le(data[8:12])
self.flags = cdata.uint32_le(data[12:])
if (self.header is not None):
self.d... |
'Return tag key=value pairs in a human-readable format.'
| def pprint(self):
| items = sorted(self.items())
return u'\n'.join(((u'%s=%s' % (k, v.pprint())) for (k, v) in items))
|
'Load tags from a filename.
Raises apev2.error'
| @convert_error(IOError, error)
@loadfile()
def load(self, filething):
| data = _APEv2Data(filething.fileobj)
if data.tag:
self.clear()
self.__parse_tag(data.tag, data.items)
else:
raise APENoHeaderError('No APE tag found')
|
'Raises IOError and APEBadItemError'
| def __parse_tag(self, tag, count):
| fileobj = cBytesIO(tag)
for i in xrange(count):
tag_data = fileobj.read(8)
if (not tag_data):
break
if (len(tag_data) != 8):
raise error
size = cdata.uint32_le(tag_data[:4])
flags = cdata.uint32_le(tag_data[4:8])
kind = ((flags & 6) >> 1)
... |
'\'Magic\' value setter.
This function tries to guess at what kind of value you want to
store. If you pass in a valid UTF-8 or Unicode string, it
treats it as a text value. If you pass in a list, it treats it
as a list of string/Unicode values. If you pass in a string
that is not valid UTF-8, it assumes it is a binary... | def __setitem__(self, key, value):
| if (not is_valid_apev2_key(key)):
raise KeyError(('%r is not a valid APEv2 key' % key))
if PY2:
key = key.encode('ascii')
if (not isinstance(value, _APEValue)):
if isinstance(value, text_type):
value = APEValue(value, TEXT)
elif isinstance(value,... |
'Save changes to a file.
If no filename is given, the one most recently loaded is used.
Tags are always written at the end of the file, and include
a header and a footer.'
| @convert_error(IOError, error)
@loadfile(writable=True, create=True)
def save(self, filething):
| fileobj = filething.fileobj
data = _APEv2Data(fileobj)
if data.is_at_start:
delete_bytes(fileobj, (data.end - data.start), data.start)
elif (data.start is not None):
fileobj.seek(data.start)
fileobj.truncate()
fileobj.seek(0, 2)
tags = []
for (key, value) in self.item... |
'Remove tags from a file.'
| @convert_error(IOError, error)
@loadfile(writable=True)
def delete(self, filething):
| fileobj = filething.fileobj
data = _APEv2Data(fileobj)
if ((data.start is not None) and (data.size is not None)):
delete_bytes(fileobj, (data.end - data.start), data.start)
self.clear()
|
'Sets value or raises APEBadItemError'
| def _parse(self, data):
| raise NotImplementedError
|
'Returns bytes'
| def _write(self):
| raise NotImplementedError
|
'Returns validated value or raises TypeError/ValueErrr'
| def _validate(self, value):
| raise NotImplementedError
|
'Iterate over the strings of the value (not the characters)'
| def __iter__(self):
| return iter(self.value.split(u'\x00'))
|
'Whether the padding bits are all zero'
| @staticmethod
def has_valid_padding(value, bits=7):
| assert (bits <= 8)
mask = (((1 << (8 - bits)) - 1) << bits)
if isinstance(value, integer_types):
while value:
if (value & mask):
return False
value >>= 8
elif isinstance(value, bytes):
for byte in bytearray(value):
if (byte & mask):
... |
'Raises ID3NoHeaderError, ID3UnsupportedVersionError or error'
| @convert_error(IOError, error)
def __init__(self, fileobj=None):
| if (fileobj is None):
self._flags = 0
return
fn = getattr(fileobj, 'name', '<unknown>')
data = fileobj.read(10)
if (len(data) != 10):
raise ID3NoHeaderError(('%s: too small' % fn))
(id3, vmaj, vrev, flags, size) = struct.unpack('>3sBBB4s', data)
self._flags = flags
... |
'Return all frames with a given name (the list may be empty).
Args:
key (text): key for frames to get
This is best explained by examples::
id3.getall(\'TIT2\') == [id3[\'TIT2\']]
id3.getall(\'TTTT\') == []
id3.getall(\'TXXX\') == [TXXX(desc=\'woo\', text=\'bar\'),
TXXX(desc=\'baz\', text=\'quuuux\'), ...]
Since this is... | def getall(self, key):
| if (key in self):
return [self[key]]
else:
key = (key + ':')
return [v for (s, v) in self.items() if s.startswith(key)]
|
'Delete frames of the given type and add frames in \'values\'.
Args:
key (text): key for frames to delete
values (List[`Frame`]): frames to add'
| def setall(self, key, values):
| self.delall(key)
for tag in values:
self[tag.HashKey] = tag
|
'Delete all tags of a given kind; see getall.
Args:
key (text): key for frames to delete'
| def delall(self, key):
| if (key in self):
del self[key]
else:
key = (key + ':')
for k in list(self.keys()):
if k.startswith(key):
del self[k]
|
'Returns:
text: tags in a human-readable format.
"Human-readable" is used loosely here. The format is intended
to mirror that used for Vorbis or APEv2 output, e.g.
``TIT2=My Title``
However, ID3 frames can have multiple keys:
``POPM=user@example.org=3 128/255``'
| def pprint(self):
| frames = sorted((Frame.pprint(s) for s in self.values()))
return '\n'.join(frames)
|
'Add a frame.
Args:
frame (Frame): the frame to add
strict (bool): if this should raise in case it can\'t be added
and frames shouldn\'t be merged.'
| def _add(self, frame, strict):
| if (not isinstance(frame, Frame)):
raise TypeError(('%r not a Frame instance' % frame))
orig_frame = frame
frame = frame._upgrade_frame()
if (frame is None):
if (not strict):
return
raise TypeError(("Can't upgrade %r frame" % type(orig_frame).__na... |
'Deprecated; use the add method.'
| def loaded_frame(self, tag):
| self._add(tag, True)
|
'Add a frame to the tag.'
| def add(self, frame):
| self.loaded_frame(frame)
|
'Updates done by both v23 and v24 update'
| def __update_common(self):
| if ('TCON' in self):
self['TCON'].genres = self['TCON'].genres
mimes = {'PNG': 'image/png', 'JPG': 'image/jpeg'}
for pic in self.getall('APIC'):
if (pic.mime in mimes):
newpic = APIC(encoding=pic.encoding, mime=mimes[pic.mime], type=pic.type, desc=pic.desc, data=pic.data)
... |
'Convert older tags into an ID3v2.4 tag.
This updates old ID3v2 frames to ID3v2.4 ones (e.g. TYER to
TDRC). If you intend to save tags, you must call this function
at some point; it is called by default when loading the tag.'
| def update_to_v24(self):
| self.__update_common()
try:
date = text_type(self.get('TYER', ''))
if date.strip(u'\x00'):
self.pop('TYER')
dat = text_type(self.get('TDAT', ''))
if dat.strip('\x00'):
self.pop('TDAT')
date = ('%s-%s-%s' % (date, dat[2:], dat[:2... |
'Convert older (and newer) tags into an ID3v2.3 tag.
This updates incompatible ID3v2 frames to ID3v2.3 ones. If you
intend to save tags as ID3v2.3, you must call this function
at some point.
If you want to to go off spec and include some v2.4 frames
in v2.3, remove them before calling this and add them back afterwards.... | def update_to_v23(self):
| self.__update_common()
if (('TIPL' in self) or ('TMCL' in self)):
people = []
if ('TIPL' in self):
f = self.pop('TIPL')
people.extend(f.people)
if ('TMCL' in self):
f = self.pop('TMCL')
people.extend(f.people)
if ('IPLS' not in self... |
'Creates a shallow copy of all tags'
| def _copy(self):
| items = self.items()
subs = {}
for f in (self.getall('CHAP') + self.getall('CTOC')):
subs[f.HashKey] = f.sub_frames._copy()
return (items, subs)
|
'Restores the state copied with _copy()'
| def _restore(self, value):
| (items, subs) = value
self.clear()
for (key, value) in items:
self[key] = value
if (key in subs):
value.sub_frames._restore(subs[key])
|
'Return a possibly modified value which, if written,
results in valid id3v2.3 data.'
| def _validate23(self, frame, value, **kwargs):
| return value
|
'Returns:
(value: object, left_data: bytes)
Raises:
SpecError'
| def read(self, header, frame, data):
| raise NotImplementedError
|
'Returns:
bytes: The serialized data
Raises:
SpecError'
| def write(self, config, frame, value):
| raise NotImplementedError
|
'Returns:
the validated value
Raises:
ValueError
TypeError'
| def validate(self, frame, value):
| raise NotImplementedError
|
'`tuple`: ID3 tag version as a tuple (of the loaded file)'
| @property
def version(self):
| if (self._header is not None):
return self._header.version
return self._version
|
'load(filething, known_frames=None, translate=True, v2_version=4)
Load tags from a filename.
Args:
filename (filething): filename or file object to load tag data from
known_frames (Dict[`mutagen.text`, `Frame`]): dict mapping frame
IDs to Frame objects
translate (bool): Update all tags to ID3v2.3/4 internally. If you
i... | @convert_error(IOError, error)
@loadfile()
def load(self, filething, known_frames=None, translate=True, v2_version=4):
| fileobj = filething.fileobj
if (v2_version not in (3, 4)):
raise ValueError('Only 3 and 4 possible for v2_version')
self.unknown_frames = []
self._header = None
self._padding = 0
self._pre_load_header(fileobj)
try:
self._header = ID3Header(fileobj)
excep... |
'save(filething=None, v1=1, v2_version=4, v23_sep=\'/\', padding=None)
Save changes to a file.
Args:
filename (fspath):
Filename to save the tag to. If no filename is given,
the one most recently loaded is used.
v1 (ID3v1SaveOptions):
if 0, ID3v1 tags will be removed.
if 1, ID3v1 tags will be updated but not added.
if ... | @convert_error(IOError, error)
@loadfile(writable=True, create=True)
def save(self, filething, v1=1, v2_version=4, v23_sep='/', padding=None):
| f = filething.fileobj
try:
header = ID3Header(filething.fileobj)
except ID3NoHeaderError:
old_size = 0
else:
old_size = header.size
data = self._prepare_data(f, 0, old_size, v2_version, v23_sep, padding)
new_size = len(data)
if (old_size < new_size):
insert_by... |
'delete(filething=None, delete_v1=True, delete_v2=True)
Remove tags from a file.
Args:
filething (filething): A filename or `None` to use the one used
when loading.
delete_v1 (bool): delete any ID3v1 tag
delete_v2 (bool): delete any ID3v2 tag
If no filename is given, the one most recently loaded is used.'
| @loadfile(writable=True)
def delete(self, filething, delete_v1=True, delete_v2=True):
| delete(filething, delete_v1, delete_v2)
self.clear()
|
'Add an empty ID3 tag to the file.
Args:
ID3 (ID3): An ID3 subclass to use or `None` to use the one
that used when loading.
A custom tag reader may be used in instead of the default
`ID3` object, e.g. an `mutagen.easyid3.EasyID3` reader.'
| def add_tags(self, ID3=None):
| if (ID3 is None):
ID3 = self.ID3
if (self.tags is None):
self.ID3 = ID3
self.tags = ID3()
else:
raise error('an ID3 tag already exists')
|
'Returns either this instance or a new instance if this is a v2.2
frame and an upgrade to a v2.3/4 equivalent is viable.
If this is a v2.2 instance and there is no upgrade path, returns None.'
| def _upgrade_frame(self):
| if (len(type(self).__name__) == 3):
base = type(self).__base__
if (base is Frame):
return
return base(self)
else:
return self
|
'Returns a frame copy which is suitable for writing into a v2.3 tag.
kwargs get passed to the specs.'
| def _get_v23_frame(self, **kwargs):
| new_kwargs = {}
for checker in self._framespec:
name = checker.name
value = getattr(self, name)
new_kwargs[name] = checker._validate23(self, value, **kwargs)
for checker in self._optionalspec:
name = checker.name
if hasattr(self, name):
value = getattr(sel... |
'An internal key used to ensure frame uniqueness in a tag'
| @property
def HashKey(self):
| return self.FrameID
|
'ID3v2 three or four character frame ID'
| @property
def FrameID(self):
| return type(self).__name__
|
'Python representation of a frame.
The string returned is a valid Python expression to construct
a copy of this frame.'
| def __repr__(self):
| kw = []
for attr in self._framespec:
if hasattr(self, attr.name):
kw.append(('%s=%r' % (attr.name, getattr(self, attr.name))))
for attr in self._optionalspec:
if hasattr(self, attr.name):
kw.append(('%s=%r' % (attr.name, getattr(self, attr.name))))
return ('%s(%s)... |
'Raises ID3JunkFrameError; Returns leftover data'
| def _readData(self, id3, data):
| for reader in self._framespec:
if (len(data) or reader.handle_nodata):
try:
(value, data) = reader.read(id3, self, data)
except SpecError as e:
raise ID3JunkFrameError(e)
else:
raise ID3JunkFrameError('no data left')
s... |
'Raises error'
| def _writeData(self, config=None):
| if (config is None):
config = ID3SaveConfig()
if (config.v2_version == 3):
frame = self._get_v23_frame(sep=config.v23_separator)
else:
frame = self
data = []
for writer in self._framespec:
try:
data.append(writer.write(config, frame, getattr(frame, writer.... |
'Return a human-readable representation of the frame.'
| def pprint(self):
| return ('%s=%s' % (type(self).__name__, self._pprint()))
|
'Construct this ID3 frame from raw string data.
Raises:
ID3JunkFrameError in case parsing failed
NotImplementedError in case parsing isn\'t implemented
ID3EncryptionUnsupportedError in case the frame is encrypted.'
| @classmethod
def _fromData(cls, header, tflags, data):
| if (header.version >= header._V24):
if (tflags & (Frame.FLAG24_COMPRESS | Frame.FLAG24_DATALEN)):
datalen_bytes = data[:4]
data = data[4:]
if ((tflags & Frame.FLAG24_UNSYNCH) or header.f_unsynch):
try:
data = unsynch.decode(data)
except... |
'Append a string.'
| def append(self, value):
| return self.text.append(value)
|
'Extend the list by appending all strings from the given list.'
| def extend(self, value):
| return self.text.extend(value)
|
'Return the numerical value of the string.'
| def __pos__(self):
| return int(self.text[0])
|
'Raises error, IOError, EOFError'
| def __init__(self, fileobj=None):
| self.packets = []
if (fileobj is None):
return
self.offset = fileobj.tell()
header = fileobj.read(27)
if (len(header) == 0):
raise EOFError
try:
(oggs, self.version, self.__type_flags, self.position, self.serial, self.sequence, crc, segments) = struct.unpack('<4sBBqIIiB',... |
'Two Ogg pages are the same if they write the same data.'
| def __eq__(self, other):
| try:
return (self.write() == other.write())
except AttributeError:
return False
|
'Return a string encoding of the page header and data.
A ValueError is raised if the data is too big to fit in a
single page.'
| def write(self):
| data = [struct.pack('<4sBBqIIi', 'OggS', self.version, self.__type_flags, self.position, self.serial, self.sequence, 0)]
lacing_data = []
for datum in self.packets:
(quot, rem) = divmod(len(datum), 255)
lacing_data.append((('\xff' * quot) + chr_(rem)))
lacing_data = ''.join(lacing_data)
... |
'Total frame size.'
| @property
def size(self):
| size = 27
for datum in self.packets:
(quot, rem) = divmod(len(datum), 255)
size += (quot + 1)
if ((not self.complete) and (rem == 0)):
size -= 1
size += sum(map(len, self.packets))
return size
|
'Renumber pages belonging to a specified logical stream.
fileobj must be opened with mode r+b or w+b.
Starting at page number \'start\', renumber all pages belonging
to logical stream \'serial\'. Other pages will be ignored.
fileobj must point to the start of a valid Ogg page; any
occuring after it and part of the spec... | @staticmethod
def renumber(fileobj, serial, start):
| number = start
while True:
try:
page = OggPage(fileobj)
except EOFError:
break
else:
if (page.serial != serial):
continue
fileobj.seek((- page.size), 1)
page.sequence = number
fileobj.write(page.write())
... |
'Construct a list of packet data from a list of Ogg pages.
If strict is true, the first page must start a new packet,
and the last page must end the last packet.'
| @staticmethod
def to_packets(pages, strict=False):
| serial = pages[0].serial
sequence = pages[0].sequence
packets = []
if strict:
if pages[0].continued:
raise ValueError('first packet is continued')
if (not pages[(-1)].complete):
raise ValueError('last packet does not complete')
elif (pages... |
'Like from_packets but in case the size and number of the packets
is the same as in the given pages the layout of the pages will
be copied (the page size and number will match).
If the packets don\'t match this behaves like::
OggPage.from_packets(packets, sequence=old_pages[0].sequence)'
| @classmethod
def _from_packets_try_preserve(cls, packets, old_pages):
| old_packets = cls.to_packets(old_pages)
if ([len(p) for p in packets] != [len(p) for p in old_packets]):
return cls.from_packets(packets, old_pages[0].sequence)
new_data = ''.join(packets)
new_pages = []
for old in old_pages:
new = OggPage()
new.sequence = old.sequence
... |
'Construct a list of Ogg pages from a list of packet data.
The algorithm will generate pages of approximately
default_size in size (rounded down to the nearest multiple of
255). However, it will also allow pages to increase to
approximately default_size + wiggle_room if allowing the
wiggle room would finish a packet (o... | @staticmethod
def from_packets(packets, sequence=0, default_size=4096, wiggle_room=2048):
| chunk_size = ((default_size // 255) * 255)
pages = []
page = OggPage()
page.sequence = sequence
for packet in packets:
page.packets.append('')
while packet:
(data, packet) = (packet[:chunk_size], packet[chunk_size:])
if ((page.size < default_size) and (len(pag... |
'Replace old_pages with new_pages within fileobj.
old_pages must have come from reading fileobj originally.
new_pages are assumed to have the \'same\' data as old_pages,
and so the serial and sequence numbers will be copied, as will
the flags for the first and last pages.
fileobj will be resized and pages renumbered as... | @classmethod
def replace(cls, fileobj, old_pages, new_pages):
| if ((not len(old_pages)) or (not len(new_pages))):
raise ValueError('empty pages list not allowed')
first = old_pages[0].sequence
for (page, seq) in izip(new_pages, xrange(first, (first + len(new_pages)))):
page.sequence = seq
page.serial = old_pages[0].serial
new_pag... |
'Find the last page of the stream \'serial\'.
If the file is not multiplexed this function is fast. If it is,
it must read the whole the stream.
This finds the last page in the actual file object, or the last
page in the stream (with eos set), whichever comes first.
Returns None in case no page with the serial exists.
... | @staticmethod
def find_last(fileobj, serial):
| seek_end(fileobj, (256 * 256))
data = fileobj.read()
try:
index = data.rindex('OggS')
except ValueError:
raise error('unable to find final Ogg header')
bytesobj = cBytesIO(data[index:])
best_page = None
try:
page = OggPage(bytesobj)
except error:
... |
'load(filething)
Load file information from a filename.
Args:
filething (filething)
Raises:
mutagen.MutagenError'
| @loadfile()
def load(self, filething):
| fileobj = filething.fileobj
try:
self.info = self._Info(fileobj)
self.tags = self._Tags(fileobj, self.info)
self.info._post_tags(fileobj)
except (error, IOError) as e:
reraise(self._Error, e, sys.exc_info()[2])
except EOFError:
raise self._Error('no appropriate... |
'delete(filething=None)
Remove tags from a file.
If no filename is given, the one most recently loaded is used.
Args:
filething (filething)
Raises:
mutagen.MutagenError'
| @loadfile(writable=True)
def delete(self, filething):
| fileobj = filething.fileobj
self.tags.clear()
try:
try:
self.tags._inject(fileobj, (lambda x: 0))
except error as e:
reraise(self._Error, e, sys.exc_info()[2])
except EOFError:
raise self._Error('no appropriate stream found')
except IO... |
'save(filething=None, padding=None)
Save a tag to a file.
If no filename is given, the one most recently loaded is used.
Args:
filething (filething)
padding (PaddingFunction)
Raises:
mutagen.MutagenError'
| @loadfile(writable=True)
def save(self, filething, padding=None):
| try:
self.tags._inject(filething.fileobj, padding)
except (IOError, error) as e:
reraise(self._Error, e, sys.exc_info()[2])
except EOFError:
raise self._Error('no appropriate stream found')
|
'Raises OptimFROGHeaderError'
| @convert_error(IOError, OptimFROGHeaderError)
def __init__(self, fileobj):
| header = fileobj.read(76)
if ((len(header) != 76) or (not header.startswith('OFR ')) or (struct.unpack('<I', header[4:8])[0] not in [12, 15])):
raise OptimFROGHeaderError('not an OptimFROG file')
(total_samples, total_samples_high, sample_type, self.channels, self.sample_rate) = struct.u... |
'Raises MusepackHeaderError'
| @convert_error(IOError, MusepackHeaderError)
def __init__(self, fileobj):
| header = fileobj.read(4)
if (len(header) != 4):
raise MusepackHeaderError('not a Musepack file')
if (header[:3] == 'ID3'):
header = fileobj.read(6)
if (len(header) != 6):
raise MusepackHeaderError('not a Musepack file')
size = (10 + BitPaddedInt(... |
'Raises LAMEError if parsing fails'
| def __init__(self, xing, fileobj):
| payload = fileobj.read(27)
if (len(payload) != 27):
raise LAMEError('Not enough data')
r = BitReader(cBytesIO(payload))
revision = r.bits(4)
if (revision != 0):
raise LAMEError(('unsupported header revision %d' % revision))
self.vbr_method = r.bits(4)
self.lowp... |
'Gives a guess about the encoder settings used. Returns an empty
string if unknown.
The guess is mostly correct in case the file was encoded with
the default options (-V --preset --alt-preset --abr -b etc) and no
other fancy options.
Args:
major (int)
minor (int)
Returns:
text'
| def guess_settings(self, major, minor):
| version = (major, minor)
if (self.vbr_method == 2):
if ((version in ((3, 90), (3, 91), (3, 92))) and self.encoding_flags):
if (self.bitrate < 255):
return (u'--alt-preset %d' % self.bitrate)
else:
return (u'--alt-preset %d+' % self.bitrate)
... |
'Returns a version string and True if a LAMEHeader follows.
The passed file object will be positioned right before the
lame header if True.
Raises LAMEError if there is no lame version info.'
| @classmethod
def parse_version(cls, fileobj):
| data = fileobj.read(20)
if (len(data) != 20):
raise LAMEError('Not a lame header')
if (not data.startswith(('LAME', 'L3.99'))):
raise LAMEError('Not a lame header')
data = data.lstrip('EMAL')
(major, data) = (data[0:1], data[1:].lstrip('.'))
minor = ''
for c... |
'Parses the Xing header or raises XingHeaderError.
The file position after this returns is undefined.'
| def __init__(self, fileobj):
| data = fileobj.read(8)
if ((len(data) != 8) or (data[:4] not in ('Xing', 'Info'))):
raise XingHeaderError('Not a Xing header')
self.is_info = (data[:4] == 'Info')
flags = cdata.uint32_be_from(data, 4)[0]
if (flags & XingHeaderFlags.FRAMES):
data = fileobj.read(4)
if ... |
'Returns the guessed encoder settings'
| def get_encoder_settings(self):
| if (self.lame_header is None):
return u''
return self.lame_header.guess_settings(*self.lame_version)
|
'Calculate the offset to the Xing header from the start of the
MPEG header including sync based on the MPEG header\'s content.'
| @classmethod
def get_offset(cls, info):
| assert (info.layer == 3)
if (info.version == 1):
if (info.mode != 3):
return 36
else:
return 21
elif (info.mode != 3):
return 21
else:
return 13
|
'Reads the VBRI header or raises VBRIHeaderError.
The file position is undefined after this returns'
| def __init__(self, fileobj):
| data = fileobj.read(26)
if ((len(data) != 26) or (not data.startswith('VBRI'))):
raise VBRIHeaderError('Not a VBRI header')
offset = 4
(self.version, offset) = cdata.uint16_be_from(data, offset)
if (self.version != 1):
raise VBRIHeaderError(('Unsupported header version... |
'Offset in bytes from the start of the MPEG header including sync'
| @classmethod
def get_offset(cls, info):
| assert (info.layer == 3)
return 36
|
'Raises HeaderNotFoundError'
| def __init__(self, fileobj):
| self.frame_offset = fileobj.tell()
r = BitReader(fileobj)
try:
if (r.bits(11) != 2047):
raise HeaderNotFoundError('invalid sync')
version = r.bits(2)
layer = r.bits(2)
protection = r.bits(1)
bitrate = r.bits(4)
sample_rate = r.bits(2)
pa... |
'Does not raise'
| def _parse_vbr_header(self, fileobj, frame_offset, frame_size):
| xing_offset = XingHeader.get_offset(self)
fileobj.seek((frame_offset + xing_offset), 0)
try:
xing = XingHeader(fileobj)
except XingHeaderError:
pass
else:
lame = xing.lame_header
self.sketchy = False
self.bitrate_mode = _guess_xing_bitrate_mode(xing)
s... |
'Parse MPEG stream information from a file-like object.
If an offset argument is given, it is used to start looking
for stream information and Xing headers; otherwise, ID3v2 tags
will be skipped automatically. A correct offset can make
loading files significantly faster.
Raises HeaderNotFoundError, error'
| @convert_error(IOError, error)
def __init__(self, fileobj, offset=None):
| if (offset is None):
fileobj.seek(0, 0)
else:
fileobj.seek(offset, 0)
skip_id3(fileobj)
max_read = (1024 * 1024)
max_syncs = 1000
enough_frames = 4
min_frames = 2
self.sketchy = True
frames = []
first_frame = None
for _ in iter_sync(fileobj, max_read):
... |
'Raises ogg.error, IOError'
| def __init__(self, fileobj):
| page = OggPage(fileobj)
while (not page.packets[0].startswith('\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, ... |
'Raises ogg.error'
| def _post_tags(self, fileobj):
| page = OggPage.find_last(fileobj, self.serial)
if (page is None):
raise OggVorbisHeaderError
self.length = (page.position / float(self.sample_rate))
|
'Write tag data into the Vorbis comment packet/page.'
| def _inject(self, fileobj, padding_func):
| fileobj.seek(0)
page = OggPage(fileobj)
while (not page.packets[0].startswith('\x03vorbis')):
page = OggPage(fileobj)
old_pages = [page]
while (not (old_pages[(-1)].complete or (len(old_pages[(-1)].packets) > 1))):
page = OggPage(fileobj)
if (page.serial == old_pages[0].seria... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.