def on_episode_downloaded(self, episode):
log(u'on_episode_downloaded(%s/%s)' % (episode.channel.title, episode.title))
filename = episode.local_filename(create=False, check_only=True)
if filename is None:
return
basename, extension = os.path.splitext(filename)
if episode.file_type() == 'audio' and extension.lower() == '.ogg':
log(u'trying to remove cover from %s' % filename)
found = False
try:
ogg = OggVorbis(filename)
for key in ogg.keys():
if key.startswith('cover'):
found = True
ogg[key]=''
if found:
log(u'removed cover from the ogg file successfully')
ogg.save()
else:
log(u'there was no cover to remove in the ogg file')
except:
None
def set_start(filename, start_time):
"""
Writes the start of the song section to file
"""
song_meta = OggVorbis(filename)
song_meta[Settings.song_start_tag] = start_time
song_meta.save()
def download_and_fix_ogg(ogg, audio_metadata, cover_art_file):
global DRY_RUN
if DRY_RUN:
print "This is a dry run. So pretending to download the ogg..."
return "/tmp/ogg"
print "Now downloading the ogg in order to set the metadata in it..."
if not LIVE and len(sys.argv) >= 6 and os.path.exists(sys.argv[5]):
ogg_local_fn = sys.argv[5]
print "(using presupplied file %s)" % ogg_local_fn
else:
f, metadata = client.get_file_and_metadata(ogg)
ogg_local_fn = fetch_file(f, metadata)
print "Successfully downloaded (to %s): now editing metadata..." % ogg_local_fn
audio = OggVorbis(ogg_local_fn)
for k in audio_metadata.keys():
audio[k] = audio_metadata[k]
# add cover art
im=Image.open(cover_art_file)
w,h=im.size
p=Picture()
imdata=open(cover_art_file,'rb').read()
p.data=imdata
p.type=3
p.desc=''
p.mime='image/jpeg';
p.width=w; p.height=h
p.depth=24
dt=p.write();
enc=base64.b64encode(dt).decode('ascii');
audio['metadata_block_picture']=[enc];
audio.save()
print "Successfully updated metadata."
return ogg_local_fn
def getFileInfoFromMeta(self, filepath):
artist = ''
title = ''
genre = ''
musicfile = self.getMusicForCdg(filepath)
if musicfile:
name, ext = os.path.splitext(musicfile)
print "Name:", name
print "Ext:", ext
if ext == '.mp3':
print "MP3"
try:
eid = EasyID3(musicfile)
artist = eid.get('artist', [''])[0]
title = eid.get('title', [''])[0]
genre = eid.get('genre', ['karaoke'])[0]
print "Got: (%s, %s, %s)" % (artist, title, genre)
except ID3NoHeaderError:
print "No ID Header for", musicfile
elif ext == '.ogg':
audio = OggVorbis(musicfile)
artist = audio.get('artist', '')[0]
title = audio.get('title', '')[0]
genre = audio.get('genre', ['karaoke'])[0]
return artist, title, genre
class _EasyPythonMutagenOggVorbis(object):
'''An interface like EasyId3, but for OggVorbis files.'''
def __init__(self, filename):
from mutagen.oggvorbis import OggVorbis
self.obj = OggVorbis(filename)
self.map = {
'album': 'album',
'comment': 'comment',
'artist': 'artist',
'title': 'title',
'albumartist': 'albumartist',
'tracknumber': 'tracknumber',
'discnumber': 'discnumber',
'composer': 'composer',
'genre': 'genre',
'description': 'description',
'website': 'www'}
def __getitem__(self, key):
return self.obj[self.map[key]]
def __setitem__(self, key, val):
self.obj[self.map[key]] = val
def __contains__(self, key):
return key in self.map and self.map[key] in self.obj
def save(self):
self.obj.save()
class Vorbis(object):
tags = ['title', 'artist', 'album', 'genre', 'tracknumber']
def __init__(self, filename):
self._comment = OggVorbis(filename)
def write_random_tag(self, data):
tag = random.choice(Vorbis.tags)
self._comment[tag] = data
self._comment.save()
def ogg_tag(config):
print("Tagging " + config.ogg_file)
audio = OggVorbis(config.ogg_file)
# Add the tags.
for k in config.tags.keys():
audio[k] = config.tags[k]
audio.save()
def remove_all(self):
if self.backup is True:
shutil.copy2(self.filename, self.output)
self.filename = self.output
mfile = OggVorbis(self.filename)
mfile.delete()
mfile.save()
def add_tag(f, tag, value):
if f.endswith('ogg'):
audio = OggVorbis(f)
elif f.endswith('flac'):
audio = FLAC(f)
audio[tag] = value
# audio.pprint()
audio.save()
def convert(self):
''' Convert wav -> ogg.'''
if self.songwav == self.song:
success = True
dec = None
else:
success, dec = self.decode()
if not success:
warn('Decoding of "%s" failed.' % self.song)
return
if dec and self.decoder == 'mpg123':
import mutagen
try:
info("additional option:" )
opts=['-R', str(mutagen.File(self.song).info.sample_rate)]
info(str(opts))
except:
opts=[]
else:
opts=[]
if dec:
enc = Popen(['oggenc', '-Q', '-o', self.songogg, '-q', str(self.conf.quality).replace('.', ','), '-'] + opts, stdin=dec.stdout)
enc.communicate()
dec.wait()
if dec.returncode < 0:
warn('Decoding of "%s" failed.' % self.song)
return False
elif enc.returncode < 0:
warn('Encoding of "%s" failed.' % self.song)
return False
else:
enc = call(['oggenc', '-o', self.songogg, '-q', str(self.conf.quality).replace('.', ','), self.songwav])
if enc != 0:
warn('Encoding of "%s" failed.' % self.songwav)
return False
elif not self.conf.preserve_wav and self.song != self.songwav:
os.remove(self.songwav)
if self.tags != {}:
try:
# Add tags to the ogg file
from mutagen.oggvorbis import OggVorbis
myogg = OggVorbis(self.songogg)
myogg.update(self.tags)
myogg.save()
except:
warn('Could not save the tags')
import traceback
traceback.print_exc()
return False
elif self.songwav != self.song or 'cd-' in self.decoder:
warn('No tags found...')
if self.conf.delete_input:
os.remove(self.song)
return True
def ogg_write_tags(self, path, tag_type, input_string):
try:
ogg_audio = OggVorbis(path) #Reading tags
except:
print ("No Ogg tag found or %r is not a valid OGG file") \
% (path.encode(sys.stdout.encoding or "utf-8", "replace"), )
return
ogg_audio[tag_type] = input_string
ogg_audio.save()
def test_save_split_setup_packet(self):
fn = os.path.join(DATA_DIR, "multipage-setup.ogg")
shutil.copy(fn, self.filename)
audio = OggVorbis(self.filename)
tags = audio.tags
self.failUnless(tags)
audio.save()
self.audio = OggVorbis(self.filename)
self.failUnlessEqual(self.audio.tags, tags)
def saveLabel(self, file, label):
'''read file and save label tag'''
af = OggVorbis(file)
logger.info( "Tags BEFORE labelizer: " + str(af) )
af['label'] = label
af.save()
logger.info( "Tags AFTER labelizer: " + str(af) )
def setValue(path, tag, value): format = os.path.splitext(path)[1] if(format == ".mp3"): audio = EasyID3(path) elif(format == ".ogg"): audio = OggVorbis(path) audio[tag] = value audio.save()
def _get_OGG_tags(filename):
tagsOGG = OggVorbis(filename)
tags = {}
tags['album'] = ''.join(tagsOGG.get('album', ['']))
tags['title'] = ''.join(tagsOGG.get('title', ['']))
tags['artist'] = ''.join(tagsOGG.get('artist', ['']))
tags['length'] = tagsOGG.info.length * 1000
tags['genre'] = 'Podcast'
return tags
def write_tags_to_ogg(path, tags):
audio = OggVorbis(path)
for dest, source in [['TITLE', 'TIT2'], ['ARTIST', 'TPE1'],
['ALBUM', 'TALB'], ['DATE', 'TDRC'],
['COPYRIGHT', 'TCOP'], ['LICENSE', 'WXXX:']]:
audio[dest] = tags[source]
audio['coverartmime'] = 'image/jpeg'
audio['coverartdescription'] = 'Radiotux_ID3Tag.jpg'
audio['coverart'] = get_ogg_coverart()
audio.save()
def __song_ogg(filename):
f = OggVorbis(filename)
artist = f.get("artist", ("",))[0]
title = f.get("title", ("",))[0]
rating = 0
for k, v in f.iteritems():
if k.startswith("rating"):
rating = SongFiles.__adjust_rating_ogg(float(v[0]))
break
return Song(filename, artist, title, rating)
def get_ogg_tag_info(f):
global blankstr
ret = {"file":f,"length":"0"}
try:
i = OggVorbis(f)
ret["length"] = str(i.info.length)
for k in ["artist", "album", "year", "tracknumber", "title"]:
if i.has_key(k):
ret[k] = str(i[k])
except Exception, e:
print("\r%s\rUnable to read OGG info for\n%s" %(blankstr, f))
print(str(e))
def walk_audio_files():
tag_count = 0
for root, dirs, files in os.walk('.'):
for name in files:
audio_set = False
if name.lower().endswith(".mp3"):
try:
audio = ID3(os.path.join(root, name))
except Exception, e:
print 'ERROR: ID3 Error %s : %s' % (e, os.path.join(root, name))
continue
if not select_audio(audio):
continue
if tag_mode == TAG_MODE_NORMAL and audio.has_key('TPE1'):
artist = audio["TPE1"]
genre = artist_to_genre(artist[0])
grouping = artist_to_groupings(artist[0])
if genre != None:
audio["TCON"] = TCON(encoding=3, text=genre)
audio_set = True
if grouping != None:
audio["TIT1"] = TIT1(encoding=3, text=grouping)
audio_set = True
else:
if audio.has_key("TIT1"):
genre = refine_genre(audio["TIT1"].text[0].split(","))
if genre != "":
print "Refining genre for artist %s from %s to %s" % (audio["TPE1"].text[0], audio["TCON"].text[0], genre)
audio["TCON"] = TCON(encoding=3, text=genre)
audio_set = True
elif name.lower().endswith(".ogg"):
try:
audio = OggVorbis(os.path.join(root, name))
except Exception, e:
print 'ERROR: Ogg Comment Error %s : %s' % (e, os.path.join(root, name))
continue
if not audio.has_key('artist'):
print 'ERROR: Vorbis comment has no "artist" key in file %s' % os.path.join(root, name)
continue
artist = audio['artist']
genre = artist_to_genre(artist[0])
if genre != None:
audio["genre"] = genre
audio_set = True
def CopyTags(source_file, target_file):
o = OggVorbis(source_file)
m = EasyID3(target_file)
for key in ["artist", "title", "album", "date", "genre", "tracknumber"]:
if o.has_key(key):
m[key] = o[key]
m.save()
if o.has_key("discnumber"):
m = MP3(target_file)
m["TPOS"] = TPOS(encoding=3, text=o["discnumber"])
m.save()
def write_tags_ogg(self):
file = self.file_dir + os.sep + self.filename
if os.path.exists(file):
audio = OggVorbis(file)
audio['TITLE'] = self.new_title.decode('utf8')
audio['ARTIST'] = self.professor.decode('utf8')
audio['ALBUM'] = self.organization.decode('utf8')
audio['DATE'] = self.date.decode('utf8')
audio['GENRE'] = self.genre.decode('utf8')
audio['SOURCE'] = self.organization.decode('utf8')
audio['ENCODER'] = self.encoder.decode('utf8')
audio['COMMENT'] = self.comment.decode('utf8')
audio.save()
class _OggVorbisWrapper(_AbstractWrapper):
TAG_MAP = {
'artwork': 'metadata_block_picture',
'artist': 'artist', 'album': 'album',
'title': 'title', 'genre': 'genre',
}
VALID_TAG_KEYS = ('artwork', 'artist', 'album', 'title', 'genre', )
def __init__(self, filename):
_AbstractWrapper.__init__(self)
self.audio = OggVorbis(filename)
def __getattr__(self, attr):
if attr in self.VALID_TAG_KEYS:
if attr == 'artwork':
try:
raw_artwork_data = b64decode(
self.audio['metadata_block_picture'][0])
picture = Picture(raw_artwork_data)
return Artwork(picture.mime, picture.data)
except KeyError:
return None
else:
try:
return self.audio[attr][0]
except KeyError:
return None
raise TagError(self, attr)
def __setattr__(self, attr, value):
if attr in self.VALID_TAG_KEYS:
if isinstance(value, Artwork):
picture = Picture()
picture.type = 3
picture.mime = value.mime
picture.data = value.data
self.audio['metadata_block_picture'] = [
b64encode(picture.write()).decode('utf-8')
]
elif isinstance(value, str):
self.audio[attr] = [value]
else:
raise TagValueError(value)
else:
object.__setattr__(self, attr, value)
def __repr__(self):
return repr(self.audio)
def save(self):
self.audio.save()
def get_file_info(filename):
# Get needed information from file
name, ext = os.path.splitext(os.path.basename(filename))
if ext.lower() == ".mp3":
track = MP3(filename)
data = ID3(filename)
title = data["TIT2"].text[0]
elif ext.lower() == ".ogg":
track = OggVorbis(filename)
title = str(track.get("title")).strip('[u"]')
elif ext.lower() == ".flac":
track = FLAC(filename)
title = str(track.get("title")).strip('[u"]')
return title, int(track.info.length)
def __load_tags(self, tags, expected):
m = OggVorbis(self.filename)
for key, value in tags.iteritems():
m.tags[key] = value
m.save()
song = OggFile(self.filename)
for key, value in expected.iteritems():
self.failUnlessEqual(song(key), value)
if self.MAIN not in expected:
self.failIf(self.MAIN in song)
if self.SINGLE not in expected:
self.failIf(self.SINGLE in song)
if self.FALLBACK not in expected:
self.failIf(self.FALLBACK in song)
def get(self):
"""
This is the no update version of musicd, so we read the FS once at
load to sync the DB and then load the tracks into a template.
A page refresh is necessary to reflect changes in the track listing.
"""
library_path = os.path.normpath(Config.absolute_library)
for root, dirs, files in os.walk(library_path):
for filename in fnmatch.filter(files, "*.ogg") + fnmatch.filter(files, "*.mp3"):
path = os.path.join(root, filename)
track = {}
try:
if re.search(".ogg", filename):
audio = OggVorbis(path)
track["length"] = audio.info.length
elif re.search(".mp3", filename):
audio = EasyID3(path)
track["length"] = MP3(path).info.length
except:
print "Failed to read tags: %s" % path
continue
for key in audio.keys():
if key in Config.tags:
track[key] = audio[key].pop()
track["path"] = re.sub(library_path + "/", "", path)
spec = {}
for tag in ["artist", "album", "title"]:
if tag in track:
spec[tag] = track[tag]
if not tracks.find_one(spec):
print "found %s" % track["path"]
tracks.save(track)
# look for deleted files
for track in tracks.find():
path = os.path.join(library_path, track["path"])
if not os.path.exists(path):
print "deleting from db: %s" % path
tracks.remove(track)
self.render(
"main.html",
tracks=tracks.find(fields=Config.tags, sort=[("artist", pymongo.ASCENDING), ("album", pymongo.ASCENDING)]),
)
def SetVirtualData(self, item, col, data):
print "Set Virtual Data"
index = self.itemIndexMap[item]
self.itemDataMap[index][col] = data
if self._tabclose:
print "Same row"
return
if self._origdata == str(self.itemDataMap[index]):
print "Data did not change."
return
print "Data changed!"
self._dirty = True
#SortVirtList.SetVirtualData(self, item, col, data)
#self.SetStringItem(self, item, col, data)
artist = self.itemDataMap[index][0]
title = self.itemDataMap[index][1]
genre = self.itemDataMap[index][2]
mtype = self.itemDataMap[index][3]
path = self.itemDataMap[index][4]
validexts = ['.mp3', '.ogg']
name, ext = os.path.splitext(path)
if ext == ".cdg":
candidates = glob.glob("%s.*" % name)
for candidate in candidates:
name, ext = os.path.splitext(candidate)
if ext in validexts:
path = candidate
break
if mtype in ('mp3', '.mp3'):
m = MP3(path, ID3=EasyID3)
try:
m.add_tags(ID3=EasyID3)
except mutagen.id3.error:
print "Already has tag"
elif mtype in ('ogg', 'ogg'):
m = OggVorbis(path)
else:
print "Unrecognized type."
return
m['title'] = title
m['artist'] = artist
m['genre'] = genre
m.save()
print "Updated data."
def copy_tags(origen, destino):
""" Copia los tags de origen a destino """
for i in range(len(origen)):
ogg = OggVorbis(origen[i])
flac = FLAC(destino[i])
# limpiamos los tags del flac
# flac.delete();
for item in ogg.items():
flac[item[0]] = item[1]
flac.save()
def __load_tags(self, tags, expected):
m = OggVorbis(self.filename)
for key, value in tags.iteritems():
m.tags[key] = value
m.save()
song = OggFile(self.filename)
for key, value in expected.iteritems():
self.failUnlessEqual(song(key), value)
if self.MAIN not in expected:
self.failIf(self.MAIN in song)
if self.SINGLE not in expected:
self.failIf(self.SINGLE in song)
if self.FALLBACK not in expected:
self.failIf(self.FALLBACK in song)
def SetVirtualData(self, item, col, data):
print "Set Virtual Data"
index=self.itemIndexMap[item]
self.itemDataMap[index][col] = data
if self._tabclose:
print "Same row"
return
if self._origdata == str(self.itemDataMap[index]):
print "Data did not change."
return
print "Data changed!"
self._dirty = True
#SortVirtList.SetVirtualData(self, item, col, data)
#self.SetStringItem(self, item, col, data)
artist = self.itemDataMap[index][0]
title = self.itemDataMap[index][1]
genre = self.itemDataMap[index][2]
mtype = self.itemDataMap[index][3]
path = self.itemDataMap[index][4]
validexts = ['.mp3', '.ogg']
name, ext = os.path.splitext(path)
if ext == ".cdg":
candidates = glob.glob("%s.*" % name)
for candidate in candidates:
name, ext = os.path.splitext(candidate)
if ext in validexts:
path = candidate
break
if mtype in ('mp3', '.mp3'):
m = MP3(path, ID3=EasyID3)
try:
m.add_tags(ID3=EasyID3)
except mutagen.id3.error:
print "Already has tag"
elif mtype in ('ogg', 'ogg'):
m = OggVorbis(path)
else:
print "Unrecognized type."
return
m['title'] = title
m['artist'] = artist
m['genre'] = genre
m.save()
print "Updated data."
def test_save_grown_split_setup_packet_reference(self):
if ogg is None: return
fn = os.path.join("tests", "data", "multipage-setup.ogg")
shutil.copy(fn, self.filename)
audio = OggVorbis(self.filename)
audio["foobar"] = ["quux" * 50000]
tags = audio.tags
self.failUnless(tags)
audio.save()
self.audio = OggVorbis(self.filename)
self.failUnlessEqual(self.audio.tags, tags)
vfc = ogg.vorbis.VorbisFile(self.filename).comment()
for key in self.audio:
self.failUnlessEqual(vfc[key], self.audio[key])
self.ogg_reference(self.filename)
def test_save_grown_split_setup_packet_reference(self):
if ogg is None: return
fn = os.path.join("tests", "data", "multipage-setup.ogg")
shutil.copy(fn, self.filename)
audio = OggVorbis(self.filename)
audio["foobar"] = ["quux" * 50000]
tags = audio.tags
self.failUnless(tags)
audio.save()
self.audio = OggVorbis(self.filename)
self.failUnlessEqual(self.audio.tags, tags)
vfc = ogg.vorbis.VorbisFile(self.filename).comment()
for key in self.audio:
self.failUnlessEqual(vfc[key], self.audio[key])
self.ogg_reference(self.filename)
def get_album_and_artist(self):
""" Return Ogg tags for album and artist"""
self.audio_files.sort()
for file in self.audio_files:
try:
tags = OggVorbis(file)
if tags:
if "album" in tags.keys() and "artist" in tags.keys():
return (tags["album"][0], tags["artist"][0])
break # If we found ID3 tag info from a file, no reason to query the rest in a directory.
except mutagen.oggvorbis.OggVorbisHeaderError:
continue
return (None, None)
def __init__(self, filename):
from mutagen.oggvorbis import OggVorbis
self.obj = OggVorbis(filename)
self.map = {
'album': 'album',
'comment': 'comment',
'artist': 'artist',
'title': 'title',
'albumartist': 'albumartist',
'tracknumber': 'tracknumber',
'discnumber': 'discnumber',
'composer': 'composer',
'genre': 'genre',
'description': 'description',
'website': 'www'}
def rename(directory, filename, artist, title, extension, namingConvention):
if namingConvention == "Artist - Title" or (namingConvention == 'Dynamic'
and ' - ' in filename):
try:
os.rename(
directory + '/' + filename,
directory + '/' + str(artist) + ' - ' + str(title) + extension)
filename = str(artist) + ' - ' + str(title) + extension
except PermissionError:
messagebox.showinfo(
"Permission Error",
"File cannot be renamed, it may still be open")
return False, False
elif namingConvention == "Title" or (namingConvention == 'Dynamic'
and ' - ' not in filename):
try:
os.rename(directory + '/' + filename,
str(directory) + '/' + str(title) + extension)
filename = str(title) + extension
except PermissionError:
messagebox.showinfo(
"Permission Error",
"File cannot be renamed, it may still be open")
return False, False
if extension == ".wav":
audio = WAVE(str(directory) + '/' + filename)
audio["TPE1"] = TPE1(encoding=3, text=artist)
audio["TIT2"] = TIT2(encoding=3, text=title)
audio.save()
return audio, filename
elif extension == ".flac":
audio = FLAC(str(directory) + '/' + filename)
audio['artist'] = artist
audio['title'] = title
audio.save()
return audio, filename
elif extension == ".aiff":
audio = AIFF(str(directory) + '/' + filename)
audio["TPE1"] = TPE1(encoding=3, text=artist)
audio["TIT2"] = TIT2(encoding=3, text=title)
audio.save()
return audio, filename
elif extension == ".m4a":
audio = MP4(str(directory) + '/' + filename)
audio["\xa9ART"] = artist
audio["\xa9nam"] = title
audio.save()
return audio, filename
elif extension == ".mp3":
audio = MP3(str(directory) + '/' + filename)
audio["TPE1"] = TPE1(encoding=3, text=artist)
audio["TIT2"] = TIT2(encoding=3, text=title)
audio.save()
return audio, filename
elif extension == ".ogg":
audio = OggVorbis(str(directory) + '/' + filename)
audio['artist'] = artist
audio['title'] = title
audio.save()
return audio, filename
def build_index_object(path):
from mutagen.id3._util import ID3NoHeaderError
from mutagen.easyid3 import EasyID3
from mutagen.oggvorbis import OggVorbis
files = next(os.walk(path))[2]
index = dict()
for file in files:
index[file] = list()
index[file].append(file)
meta = None
try:
if file.endswith(".mp3"):
meta = EasyID3(path + file)
elif file.endswith(".ogg"):
meta = OggVorbis(path + file)
else:
log.info(str.format("No Parser for '%s'."% file ))
continue
except ID3NoHeaderError:
log.warning(str.format("Failed to parse '%s': No ID3Header"% file))
continue
for thing in [meta[topic] for topic in meta if topic in VALID_TAGS]:
index[file].append(*thing)
return index
def extract_ogg_tag(path):
"""
Read tags out of .ogg files encoded with different codecs
Returns a tuple (tag, error)
"""
ogg_tag = None
error = None
# Encapsulate all try except blocks in if statements.
# Only read for tag if it already does not exist.
if not ogg_tag:
try:
# Try to read ogg-Vorbis files
ogg_tag = OggVorbis(path)
except Exception:
# move to next codec type
pass
if not ogg_tag:
try:
# Try to read ogg-FLAC files
ogg_tag = OggFLAC(path)
except Exception:
# move to next codec type
pass
if not ogg_tag:
# log error for user to see
error = 'Unable to read metadata from the .ogg/.oga file. Only Vorbis and FLAC are supported.'
return (ogg_tag, error)
def read(self):
"""
Read the informations from the ogg vorbis tags
"""
tags = OggVorbis(self.filename)
try:
self.name = tags["title"][0]
except (KeyError, IndexError):
pass
try:
self.license = tags["copyright"][0]
except (KeyError, IndexError):
pass
try:
self.author = tags["artist"][0]
except (KeyError, IndexError):
pass
try:
self.url = tags["contact"][0]
except (KeyError, IndexError):
pass
def __init__(self, location):
self.meta = dict()
self.trackmetas = [
'ID', 'title', 'album', 'artist', 'date', 'genre', 'length',
'description'
]
self.doNotAdd = False
if os.path.splitext(location)[1].lower() == u'.mp3':
try:
self.file = EasyID3(location)
self.mp3 = MP3(location)
except ID3NoHeaderError:
self.doNotAdd = True
print 'No ID3 tags found for ' + location + ', so not adding to library.'
return
self.fileType = 'mp3'
elif os.path.splitext(location)[1].lower() == '.flac':
self.file = FLAC(location)
self.fileType = 'flac'
elif os.path.splitext(location)[1].lower() == '.ogg':
self.file = OggVorbis(location)
self.fileType = 'ogg'
self.meta['location'] = location
for item in self.trackmetas:
self.readTag(item)
def find_release_mbids(albums):
albums_aid_map = {}
albums_gid_map = {}
without_info = []
for a in albums:
filepath = os.path.join(a, os.listdir(a)[0])
file_extension = filepath.split('.')[-1]
if file_extension == 'mp3':
id3_metadata = ID3(filepath)
album_id = safe_get(id3_metadata, 'TXXX:MusicBrainz Album Id')
album_gid = safe_get(id3_metadata,
'TXXX:MusicBrainz Release Group Id')
elif file_extension == 'flac' or file_extension == 'ogg':
vorbis_metadata = FLAC(
filepath) if file_extension == 'flac' else OggVorbis(filepath)
album_id = squeeze(safe_get(vorbis_metadata,
'musicbrainz_albumid'))
album_gid = squeeze(
safe_get(vorbis_metadata, 'musicbrainz_releasegroupid'))
else:
print('Unsupported file extension [{}] in album {}'.format(
file_extension, a))
continue
if len(album_id) == 0 and len(album_gid) == 0:
without_info.append(a)
else:
if len(album_id) != 0:
albums_aid_map[album_id] = a
if len(album_gid) != 0:
albums_gid_map[album_gid] = a
return albums_aid_map, albums_gid_map, without_info
def read_metainfo(path):
ext = path[-3:].lower()
if ext == 'mp3':
audio = EasyID3(path)
elif ext == 'ogg':
audio = OggVorbis(path)
return audio
def get_tag_values(filename):
"""Function to get the tag values."""
# Initialise variables
artist = ""
album_artist = ""
album = ""
trackno = ""
trackna = ""
duration = ""
genre = ""
year = ""
if filename.endswith('.mp3'):
audio = MP3(filename)
artist = mtl_mp3.artist(audio)
album_artist = mtl_mp3.album_artist(audio)
album = mtl_mp3.album(audio)
trackno = mtl_mp3.trackno(audio)
trackna = mtl_mp3.trackna(audio)
duration = mtl_mp3.length(audio)
genre = mtl_mp3.genre(audio)
year = mtl_mp3.year(audio)
elif filename.endswith('.flac'):
audio = FLAC(filename)
artist = mtl_flac.artist(audio)
album_artist = mtl_flac.album_artist(audio)
album = mtl_flac.album(audio)
trackno = mtl_flac.trackno(audio)
trackna = mtl_flac.trackna(audio)
duration = mtl_flac.duration(audio)
genre = mtl_flac.genre(audio)
year = mtl_flac.year(audio)
elif filename.endswith('.ogg'):
audio = OggVorbis(filename)
artist = mtl_flac.artist(audio)
album_artist = mtl_flac.album_artist(audio)
album = mtl_flac.album(audio)
trackno = mtl_flac.trackno(audio)
trackna = mtl_flac.trackna(audio)
duration = mtl_flac.duration(audio)
genre = mtl_flac.genre(audio)
year = mtl_flac.year(audio)
album_tags = {
'artist': artist,
'album_artist': album_artist,
'album': album,
'trackno': trackno,
'trackna': trackna,
'duration': duration,
'genre': genre,
'year': year
}
return album_tags
def SearchMusicFiles(dir):
fileList = []
ProcessFile = []
for ext in (SUPPORTEDFILES):
fileList.append(glob.glob((dir + "/**/*" + ext), recursive=True))
for SFiles in SUPPORTEDFILES:
if SFiles == ".flac":
for y in range(len(fileList[0])):
MFile = FLAC(fileList[0][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
elif SFiles == ".ogg":
for y in range(len(fileList[1])):
MFile = OggVorbis(fileList[1][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
elif SFiles == ".mp3":
for y in range(len(fileList[2])):
try:
MFile = EasyID3(fileList[2][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
except:
MFile = MP3(fileList[2][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
elif SFiles == ".m4a" or SFiles == ".mp4":
for y in range(len(fileList[3])):
MFile = EasyMP4(fileList[3][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
for y in range(len(fileList[4])):
MFile = EasyMP4(fileList[4][y])
not GetLyricsInFiles(MFile) and ProcessFile.append(MFile)
return ProcessFile
def get_gain(mime, music_file):
gain = None
try:
if mime == 'audio/mpeg':
# mp3gain stores replay gain info in an APEv2 tag, not ID3.
apev2 = APEv2(music_file)
gain = apev2['REPLAYGAIN_TRACK_GAIN'].value
elif mime == 'application/ogg':
tags = OggVorbis(music_file)
gain = tags['replaygain_track_gain'][0]
elif mime == 'audio/mp4':
tags = MP4(music_file)
gain = tags['----:com.apple.iTunes:replaygain_track_gain'][
0] # Oh, how I wish I were kidding
elif mime == 'audio/x-flac':
tags = FLAC(music_file)
gain = tags['replaygain_track_gain'][0]
except:
pass # Lazily we assume that if anything went wrong it's because the tag was not there
if gain:
# We have e.g. -3.100000 dB. Remove the "dB" and convert to float
gain = float(gain.split(" ")[0])
return gain
def __init__(self, media):
MediaBase.__init__(self)
self.description = "OGG Vorbis"
self.mime_type = 'audio/ogg'
self.extension = 'ogg'
self.format = 'OGG'
self.media = media
self.sourceobj = OggVorbis(self.media)
self.source = self.media
self.bitrate_default = '192'
self.tagdata = {
'title': '',
'artist': '',
'album': '',
'date': '',
'comment': '',
'genre': '',
'copyright': ''
}
self.info = self.sourceobj.info
self.bitrate = int(str(self.info.bitrate)[:-3])
self.length = datetime.timedelta(0, self.info.length)
self.read_file_metadata()
self.media_info = get_file_info(self.media)
self.file_name = self.media_info[0]
self.file_title = self.media_info[1]
self.file_ext = self.media_info[2]
self.size = os.path.getsize(self.media)
def __init__(self, filename, mastervolume):
"""
Create a volume object from an ogg file. mastervolume is a
reference to a MasterVolume object that will control this
sound.
"""
self.filename = filename
# Read the title in the ogg vorbis tags
tags = OggVorbis(filename)
try:
name = tags["title"][0]
except KeyError:
basename = os.path.basename(filename)
name, ext = os.path.splitext(basename)
Volume.__init__(self, name)
try:
self.index = int(tags["tracknumber"][0])
except KeyError:
self.index = 0
# Link with the MasterVolume object
self.mastervolume = mastervolume
# The pygame.mixer.Sound object (only loaded when necessary)
self.sound = None
def write_tags_to_ogg(path, tags):
audio = OggVorbis(path)
for dest, source in [['TITLE', 'title'], ['COMPOSER', 'composer'],
['ALBUM', 'album'], ['DATE', 'date'],
['ARTIST', 'artist'], ['GENRE', 'genre'],
['ALBUMARTIST', 'album-artist'],
['TRACKNUMBER', 'track'],
['TRACKTOTAL', 'number-of-tracks'], ['DISCNUMBER',
'disc'], ['COMMENT', 'comment']]:
if source in tags:
audio[dest] = tags[source]
if 'cover' in tags:
audio['coverartmime'] = 'image/jpeg'
audio['coverartdescription'] = 'Cover'
audio['coverarttype'] = '3'
audio['coverart'] = get_ogg_coverart(tags['cover'])
audio.save()
def findOGGTags(self):
try:
audio = OggVorbis(self.file)
except:
if self.debug:
print("Could not get OGG tags for {0}".format(self.file))
audio = None
self.tagsOGG = audio
def getMediawrapper(self, filename):
root, ext = os.path.splitext(filename.lower())
if (ext == '.mp3'): mediawrapper = ID3(filename)
elif (ext == '.m4a'): mediawrapper = MP4(filename)
elif (ext == '.ogg'): mediawrapper = OggVorbis(filename)
elif (ext == '.flac'): mediawrapper = FLAC(filename)
else: mediawrapper = mutagen.File(filename)
return mediawrapper
def getTrack(filename):
""" Return a Track created from an Ogg Vorbis file """
from mutagen.oggvorbis import OggVorbis
oggFile = OggVorbis(filename)
length = int(round(oggFile.info.length))
bitrate = int(oggFile.info.bitrate)
samplerate = int(oggFile.info.sample_rate)
try:
title = str(oggFile['title'][0])
except:
title = None
try:
album = str(oggFile['album'][0])
except:
album = None
try:
artist = str(oggFile['artist'][0])
except:
artist = None
try:
albumArtist = str(oggFile['albumartist'][0])
except:
albumArtist = None
try:
genre = str(oggFile['genre'][0])
except:
genre = None
try:
musicbrainzId = str(oggFile['musicbrainz_trackid'][0])
except:
musicbrainzId = None
try:
trackNumber = str(oggFile['tracknumber'][0])
except:
trackNumber = None
try:
discNumber = str(oggFile['discnumber'][0])
except:
discNumber = None
try:
date = str(oggFile['date'][0])
except:
date = None
return createFileTrack(filename, bitrate, length, samplerate, True, title,
album, artist, albumArtist, musicbrainzId, genre,
trackNumber, date, discNumber)
def clean(self):
file = self.cleaned_data.get('file', False)
acceptedMime = ['audio/mpeg', 'audio/mpeg3', 'audio/x-mpeg-3', 'audio/ogg', 'application/ogg', 'audio/x-ogg', 'application/x-ogg', 'video/ogg', 'audio/wav', 'audio/x-wav', 'audio/wave', 'audio/x-pn-wav']
type = "none"
if file:
if file._size > 10*1024*1024:
raise forms.ValidationError(file.name + ': File too large. Max Limit: 10MB')
elif not file.content_type in acceptedMime:
raise forms.ValidationError(file.name + ': It is not a mp3, ogg, or wav file')
try:
OggVorbis(file.temporary_file_path())
type = 'OGG'
except:
pass
try:
OggFLAC(file.temporary_file_path())
type = 'OGG'
except:
pass
try:
OggOpus(file.temporary_file_path())
type = 'OGG'
except:
pass
try:
OggSpeex(file.temporary_file_path())
type = 'OGG'
except:
pass
try:
OggTheora(file.temporary_file_path())
type = 'OGG'
except:
pass
try:
MP3(file.temporary_file_path())
type = 'MP3'
except:
pass
try:
WavPack(file.temporary_file_path())
type = 'WAV'
except:
pass
if not type in ['OGG', 'MP3', 'WAV']:
raise forms.ValidationError(file.name + ': Unsupported file type')
return file
else:
raise forms.ValidationError(file.name + ': File cannot be opened')
def add_ogg(self,
path='',
filename='file.ogg',
artist='',
album='',
title='',
tracknum=None,
year=None,
group='',
conductor='',
composer='',
basefile='silence.ogg',
apply_tags=True):
"""
Adds a new ogg with the given parameters to our library.
Pass in ``False`` for ``apply_tags`` to only use whatever tags happen to
be present in the source basefile.
"""
full_filename = self.add_file(basefile, filename, path=path)
# Finish here if we've been told to.
if not apply_tags:
return
# Apply the tags as specified
tags = OggVorbis(full_filename)
tags['ARTIST'] = artist
tags['ALBUM'] = album
tags['TITLE'] = title
if group != '':
tags['ENSEMBLE'] = group
if conductor != '':
tags['CONDUCTOR'] = conductor
if composer != '':
tags['COMPOSER'] = composer
if tracknum is not None:
tags['TRACKNUMBER'] = str(tracknum)
if year is not None:
tags['DATE'] = str(year)
# Save to our filename
tags.save()
def rm_ogg_cover(self, episode):
filename = episode.local_filename(create=False)
if filename is None:
return
basename, extension = os.path.splitext(filename)
if episode.file_type() != 'audio':
return
if extension.lower() != '.ogg':
return
try:
ogg = OggVorbis(filename)
found = False
for key in ogg.keys():
if key.startswith('cover'):
found = True
ogg.pop(key)
if found:
logger.info('Removed cover art from OGG file: %s', filename)
ogg.save()
except Exception, e:
logger.warn('Failed to remove OGG cover: %s', e, exc_info=True)
def get_tags(audio_file, audio_format):
print("Getting tags from " + audio_file)
if audio_format is 'mp3':
return EasyID3(audio_file)
elif audio_format is 'ogg':
return OggVorbis(audio_file)
else:
print("ERROR! Unknown audio format. Abort.")
sys.exit(1)
def __init__(self, file, threshold=60, duration_distance_threshold=10000):
self.file = file
self.threshold = threshold
self.ddt = duration_distance_threshold
self.cleaner = re.compile(r"[^A-Za-z0-9 ]").sub
try:
self.audio = MP3(file, ID3=EasyID3)
except:
try:
self.audio = FLAC(file)
except:
try:
self.audio = OggVorbis(file)
except:
try:
self.audio = OggFLAC(file)
except:
try:
self.audio = OggTheora(file)
except:
try:
self.audio = APEv2(file)
except:
try:
self.audio = ASF(file)
except:
try:
self.audio = MP4(file)
except:
try:
self.audio = Musepack(file)
except:
try:
self.audio = TrueAudio(file)
except:
try:
self.audio = WavPack(file)
except:
raise FileTypeException(
'Unknown file type, no metadata, or file not found.'
)
try:
[title] = self.audio['title']
self.title = self.__clean_literal(str(title))
except:
self.title = None
try:
[artist] = self.audio['artist']
self.artist = self.__clean_literal(str(artist))
except:
self.artist = None
try:
[album] = self.audio['album']
self.album = self.__clean_literal(str(album))
except:
self.album = None
self.mbzQuery()
def handleOGG(self):
from mutagen.oggvorbis import OggVorbis
f = OggVorbis(self.fileName)
for tag in f.tags: # pylint: disable=not-an-iterable
if tag[0].upper() == 'FMPS_RATING':
frame = tag[1]
print ("flac rating is", frame)
self.rating = float(frame) * 10
return
def is_clean(self):
'''
Check if the "metadata" block is present in the file
'''
mfile = OggVorbis(self.filename)
if mfile.tags == []:
return True
else:
return False
def get_meta(self):
'''
Return the content of the metadata block if present
'''
metadata = {}
mfile = OggVorbis(self.filename)
for key, value in mfile.tags:
metadata[key] = value
return metadata
def updateCoverOgg(lossyFileName, artworkFileName):
#
# Embed album art into transcoded file: OGG
#
import base64
from mutagen.oggvorbis import OggVorbis
from mutagen.flac import Picture
import PIL.Image
import tempfile
from shutil import copyfile # Use copyfile b/c this will *not* copy rights (which is error prone on gvfs/samba)
log('- embedding album art ' + artworkFileName + ' to ' + lossyFileName)
# Copy lossy file to a local location; to prevent (save) errors in a samba environment
tempLossyFile = tempfile.gettempdir() + '/' + 'temp.ogg'
copyfile(lossyFileName, tempLossyFile)
# Embed the image
o = OggVorbis(tempLossyFile)
im = PIL.Image.open(artworkFileName)
w, h = im.size
p = Picture()
imdata = open(artworkFileName, 'rb').read()
p.data = imdata
p.type = 3
p.desc = ''
p.mime = 'image/jpeg'
p.width = w
p.height = h
p.depth = 24
dt = p.write()
enc = base64.b64encode(dt).decode('ascii')
o['metadata_block_picture'] = [enc]
o.save()
# Now we are ready; copy the file to the desired output directory
copyfile(tempLossyFile, lossyFileName)
os.remove(tempLossyFile) # Remove the temporary file(s)
return
def read_ogg_tags(song, path):
audio = OggVorbis(path)
song[Song.artist] = get_str(audio, "artist", "unknown artist")
song[Song.album] = get_str(audio, "album", "unknown album")
song[Song.title] = get_str(audio, "title", "unknown title")
song[Song.genre] = get_str(audio, "genre", "unknown genre")
song[Song.album_index] = get_int(audio, 'tracknumber')
song[Song.year] = get_int(audio, "date", '-')
song[Song.length] = int(audio.info.length)
def run_ogg_info(filename):
"""Uses `Mutagen` library instead"""
# This will capture, as a dictionary, the title, album etc.
# However, each member will be a list, so grab 1st entry.
data = OggVorbis(filename)
# Can extract the length from data.info member
length = math.ceil(data.info.length)
# Return
return OggInfo(data["title"][0], data["artist"][0], data["album"][0],
data["tracknumber"][0], length)
