def __init__(self, container): self.container = container # fix #737 EasyID3 doesn't recognize subtitle and comment tags EasyID3.RegisterTextKey("comments", "COMM") EasyID3.RegisterTextKey("subtitle", "TIT3") EasyMP4Tags.RegisterTextKey("comments", "desc") EasyMP4Tags.RegisterFreeformKey("subtitle", "SUBTITLE")
def assign_metadata_to_track(self, track_file_path, track_full_path_minus_file_type): info = self.get_track_info(track_file_path) # This assigns the m4a track field values to the new mp3 mp3 = EasyID3(f"{track_full_path_minus_file_type}.mp3") # Verify that there are values to assign to the new mp3 and assign them if info.album is not None: mp3['album'] = album if info.title is not None: mp3['title'] = title if info.artist is not None: mp3['artist'] = artist if info.composer is not None: mp3['composer'] = composer if genre is not None: mp3['genre'] = genre if year is not None: mp3['date'] = year if track_number is not None and track_total is not None: EasyID3.RegisterTextKey('track total', 'TRCK') mp3['track total'] = f"{track_number}/{track_total}" if disc_number is not None and disc_total is not None: EasyID3.RegisterTextKey('disc total', 'TPOS') mp3['disc total'] = f"{disc_number}/{disc_total}" mp3.save(v2_version=3) return album, title, artist, composer, genre, year, track_number, disc_number
def __init__(self, path): self.file = MP3(path, ID3=EasyID3) self.id3file = ID3(path) self.bitrateModeTable = { BitrateMode.UNKNOWN: "CBR", BitrateMode.CBR: "CBR", BitrateMode.VBR: "VBR", BitrateMode.ABR: "ABR" } EasyID3.RegisterTextKey("initialkey", "TKEY") EasyID3.RegisterTextKey("comment", "COMM") EasyID3.RegisterTextKey("modified", "TPE4") EasyID3.RegisterTXXXKey('tiktag', 'TikTag')
def _write_mp3_tags(self, path, track, tags=None): if "DATA" in track: track = track["DATA"] if not tags: tags = self.get_track_tags(track) audio = MP3(path, ID3=EasyID3) audio.delete() EasyID3.RegisterTextKey("label", "TPUB") cover = tags["_albumart"] del tags["_albumart"] for key, val in tags.items(): if val: audio[key] = str(val) audio.save() if cover: cover_handle = ID3(path) cover_handle["APIC"] = APIC(type=3, mime=cover["mime_type"], data=cover["image"]) cover_handle.save(path) return True
def writeMP3Tags(filename, tags, coverArtId): handle = MP3(filename, ID3=EasyID3) handle.delete() # label is not supported by easyID3, so we add it EasyID3.RegisterTextKey("label", "TPUB") # tracknumber and total tracks is one tag for ID3 tags['tracknumber'] = f'{str(tags["tracknumber"])}/{str(tags["totaltracks"])}' del tags['totaltracks'] for key, val in tags.items(): if key == 'artist': # Concatenate artists artists = val[0] # Main artist for artist in val[1:]: artists += ";" + artist handle[key] = artists elif key == 'lyrics': if 'uslt' in val: # unsynced lyrics handle.save() id3Handle = ID3(filename) id3Handle['USLT'] = USLT(encoding=3, text=val['uslt']) id3Handle.save(filename) handle.load(filename) # Reload tags else: handle[key] = str(val) handle.save() return True
def add_tag_mp3(self, fichero, name_cancion, parDir, directorio): patronMusicaMP3 = re.compile( '.\.mp3') # Utilizaremos el patros para seleccionar archivos mp3 if patronMusicaMP3.search( str(fichero)): # Comprobamos si supuestamente es un fich mp3 name_cancion = name_cancion.rstrip( ".mp3" ) # ahora al nombre le quitamos la extension que queda fea. try: print( "file", os.path.basename(str(fichero)), "directory_1", os.path.basename(str(self.ruta)), "dir_2:", os.path.basename( os.path.dirname(os.path.normpath(str(self.ruta))))) audioTag = EasyID3(str(fichero)) audioTag['title'] = name_cancion audioTag['artist'] = parDir audioTag['album'] = directorio audioTag['composer'] = "" EasyID3.RegisterTextKey("album_artist", "TPE2") audioTag['album_artist'] = "" print(audioTag['title'], "nuevo") audioTag.save(v2_version=3) audioTag.save() except ID3NoHeaderError: audioTag = mutagen.File(str(fichero), easy=True) audioTag.add_tags() audioTag['title'] = name_cancion audioTag['album'] = directorio audioTag['artist'] = parDir print("No existe un tag previo") audioTag.save(v2_version=3) audioTag.save()
def __init__(self, location): """Initializes the class and generates ID3 tags for the mp3 :param location: a string, the location of the mp3 that you want ID3 tags on """ EasyID3.RegisterTextKey("comment", "COMM") self.location = location self.mp3 = EasyID3(self.location)
def __init__(self, info): from mutagen.mp3 import MP3 as mp3 from mutagen.easyid3 import EasyID3 from mutagen.id3 import ID3 EasyID3.RegisterTextKey('description', "COMM") p = path + name audio = mp3(p, ID3=EasyID3) for key, value in info.items(): try: audio[key] = value except: pass audio.save() self.audio = ID3(p) self.id = info['description']
def writeMP3Tags(filename, tags, coverArtId): handle = MP3(filename, ID3=EasyID3) handle.delete() # label is not supported by easyID3, so we add it EasyID3.RegisterTextKey("label", "TPUB") # tracknumber and total tracks is one tag for ID3 tags[ 'tracknumber'] = f'{str(tags["tracknumber"])}/{str(tags["totaltracks"])}' del tags['totaltracks'] separator = config.get('DEFAULT', 'artist separator') for key, val in tags.items(): if key == 'artist': # Concatenate artists artists = val[0] # Main artist for artist in val[1:]: artists += separator + artist handle[key] = artists elif key == 'lyrics': if 'uslt' in val: # unsynced lyrics handle.save() id3Handle = ID3(filename) id3Handle['USLT'] = USLT(encoding=3, text=val['uslt']) id3Handle.save(filename) handle.load(filename) # Reload tags else: handle[key] = str(val) handle.save() # Cover art if coverArtId: ext = config.get('DEFAULT', 'album art embed format') image = getCoverArt( coverArtId, config.getint( 'DEFAULT', 'embed album art size'), # TODO: write to temp folder? ext) id3Handle = ID3(filename) if ext == 'jpg': mime = 'image/jpeg' else: mime = 'image/png' id3Handle['APIC'] = APIC( encoding=3, # 3 is for utf-8 mime=mime, type=3, # 3 is for the cover image data=image) id3Handle.save(filename) return True
def set_id3_tags(file, title, artist, album, comment): try: tag = EasyID3(file) except: tag = mutagen.File(file, easy=True) tag.add_tags() if title: tag['title'] = title if artist: tag['artist'] = artist if album: tag['album'] = album # if year: # tag['date'] = year if comment: EasyID3.RegisterTextKey("comment", "COMM") tag['comment'] = comment tag.save(v2_version=3)
def writeMP3Tags(filename, tags, imageUrl): handle = MP3(filename, ID3=EasyID3) handle.delete() # label is not supported by easyID3, so we add it EasyID3.RegisterTextKey("label", "TPUB") # tracknumber and total tracks is one tag for ID3 tags['tracknumber'] = f'{str(tags["tracknumber"])}/{str(tags["totaltracks"])}' del tags['totaltracks'] for key, val in tags.items(): handle[key] = str(val) handle.save() if imageUrl: image = getCoverArt(imageUrl, filename, 1500) # TODO: write to temp folder? handle= MP3(filename) handle["APIC"] = mutagen.id3.APIC( encoding=3, # 3 is for utf-8 mime='image/png', type=3, # 3 is for the cover image data=image) handle.save() return True
def _tag_mp3(self, file): """ Tag Mp3 file only called from `track.tag()` """ tagger = Tagger(self, '.mp3') tag = EasyMP3(file) EasyID3.RegisterTextKey('comment', 'COMM') tag.delete() for tag_obj in tagger.tag_map: tag[tag_obj.key] = str(tag_obj.value) tag.save() # image if cc.tag_cover and self.album.picture_url is not None: cover_data = self.get_cover_data() if cover_data: audio = MP3(file, ID3=ID3) audio.tags.add( APIC(encoding=3, mime='image/jpeg', type=3, desc=u'Cover', data=cover_data)) audio.save() else: log.warning(f'No Cover for {self}') # lyrics if cc.tag_lyrics: if self.lyrics != None: tag = ID3(file) tag[u"USLT::'eng'"] = (USLT(encoding=3, lang=u'eng', desc=u'desc', text=self.lyrics.lyrics_text)) tag.save()
def add_metadata(self, path, link, genre): if os.path.isfile(path): fn = path.split('/')[-1] vi = fn.split('__')[0] vidinfo = re.sub(r"[\(\[].*?[\)\]]", "", vi) if '-' in vidinfo: artist = vidinfo.split('-')[0] fulltitle = vidinfo.split('-')[1] title = fulltitle.split('__')[0] else: title = vidinfo artist = '' if '?' in link: link = link.split('?')[0] try: song = EasyID3(path) except ID3NoHeaderError: song = File(path, easy=True) EasyID3.RegisterTextKey('comment', 'COMM') song['title'] = title song['artist'] = artist song['genre'] = genre song['comment'] = link song.save()
def writeTags(filename, ext, trackInfo, albInfo): ''' Function to write tags to the file, be it FLAC or MP3.''' # retrieve tags try: genre = albInfo['genres']['data'][0]['name'] except: genre = '' tags = { 'title': trackInfo['title'], 'discnumber': trackInfo['disk_number'], 'tracknumber': trackInfo['track_position'], 'album': trackInfo['album']['title'], 'date': trackInfo['album']['release_date'], 'artist': trackInfo['artist']['name'], 'bpm': trackInfo['bpm'], 'albumartist': albInfo['artist']['name'], 'totaltracks': albInfo['nb_tracks'], 'label': albInfo['label'], 'genre': genre } # Download and load the image # cover_xl returns 1000px jpg link, # but 1500px png is available, so we modify url url = trackInfo['album']['cover_xl'].rsplit('/', 1)[0] image = getCoverArt(url, filename, 1500) if ext == '.flac': try: handle = mutagen.File(filename + ext) except mutagen.flac.FLACNoHeaderError as error: print(error) os.remove(filename + ext) return False handle.delete() # delete pre-existing tags and pics handle.clear_pictures() if getSetting('embed album art') == 'True': pic = mutagen.flac.Picture() pic.encoding = 3 pic.mime = 'image/png' pic.type = 3 pic.data = image handle.add_picture(pic) for key, val in tags.items(): handle[key] = str(val) handle.save() return True elif ext == '.mp3': handle = MP3(filename + ext, ID3=EasyID3) handle.delete() # label is not supported by easyID3, so we add it EasyID3.RegisterTextKey("label", "TPUB") # tracknumber and total tracks is one tag for ID3 tags['tracknumber'] = (str(tags['tracknumber']) + '/' + str(tags['totaltracks'])) del tags['totaltracks'] for key, val in tags.items(): handle[key] = str(val) handle.save() if getSetting('embed album art') == 'True': handle = MP3(filename + ext) handle["APIC"] = mutagen.id3.APIC( encoding=3, # 3 is for utf-8 mime='image/png', type=3, # 3 is for the cover image data=image) handle.save() return True else: print("Could not write tags. File extension not supported.") return None
#coding: utf-8 import sys reload(sys) sys.setdefaultencoding('utf-8') import os from os import path from mutagen.easyid3 import EasyID3 EasyID3.RegisterTextKey('ALBUMARTIST', 'TPE2') EasyID3.RegisterTextKey('ALBUMARTISTSORT', 'TSO2') from mutagen.mp3 import EasyMP3 as MP3 from mutagen.easymp4 import EasyMP4 as MP4 from mutagen.flac import FLAC from pypinyin import lazy_pinyin def beginWithCJK(str): if u'\u4e00' <= str[0] <= u'\u9fff': return True else: return False def CJKFirstLetters(str): pinyins = lazy_pinyin(str) firstLetters = '' for pinyin in pinyins: firstLetters += pinyin[0]
def __init__(self, container): self.container = container # fix #737 EasyID3 doesn't recognize subtitle and comment tags EasyID3.RegisterTextKey("comments", "COMM") EasyID3.RegisterTextKey("subtitle", "TIT3")
transcode_info['discnumber'] = [ u'%s/%s' % (transcode_info['discnumber'][0], totaldiscs) ] transcode_info.save() # EasyID3 extensions for PTHbetter. for key, frameid in { 'albumartist': 'TPE2', 'album artist': 'TPE2', 'grouping': 'TIT1', 'content group': 'TIT1', }.iteritems(): EasyID3.RegisterTextKey(key, frameid) def comment_get(id3, _): return [comment.text for comment in id3['COMM'].text] def comment_set(id3, _, value): id3.add(mutagen.id3.COMM(encoding=3, lang='eng', desc='', text=value)) def originaldate_get(id3, _): return [stamp.text for stamp in id3['TDOR'].text] def originaldate_set(id3, _, value):
try: language = id3['language'] except KeyError: language = 'eng' id3.add(mutagen.id3.USLT(encoding=3, lang=language, desc='desc', text=value[0])) def lyrics_delete(id3, key): id3.delall('USLT') def lyrics_list(): return EasyID3.RegisterKey('picture', getter=picture_get, setter=picture_set, deleter=picture_delete, lister = picture_list) #EasyID3.RegisterKey('comments', getter=comments_get, setter=comments_set, deleter=comments_delete, lister = comments_list) EasyID3.RegisterKey('lyrics', getter=lyrics_get, setter=lyrics_set, deleter=lyrics_delete, lister = lyrics_list) EasyID3.RegisterTextKey('language', 'TLAN') class IrreplaceableKeyError(Exception): def __init__(self, msg): self.msg = msg def __str__(self): return repr(self.msg) class Song: #wiping TXXX wipes replaygain calc. def __init__(self, location, tagsToReplace=['album', 'artist', 'title', 'tracknumber', 'picture'], # future tags: comments/COMM, url/WXXX tagsToWipe=[]): try: self.tags = EasyID3(location)
__author__ = 'Charlie' import mutagen from collections import defaultdict # Monkey patch mutagen easyid3 to accept 'albumartist' as an mp3 tag (TPE2) # Note this results in albumartist and performer being the same mp3 key # so we map "performer" to a nonexistent mp3 tag entity # Most software uses PTE2 as the albumartist key. # M4a files work out of the box. from mutagen.easyid3 import EasyID3 EasyID3.RegisterTextKey("albumartist", "TPE2") EasyID3.RegisterTextKey("performer", "XXX") class LibraryEntry(object): def __init__(self, filename): self.filename = filename self.etags = mutagen.File(filename, easy=True) self.mimetype = self.etags.mime[0] @property def tags(self): """returns a defaultdict of the etags. useful for checking for keys that don't exist""" tags = defaultdict(lambda: []) # Populate the self tags for k, v in self.etags.items(): tags[k] = v return tags
import argparse import requests import unicodedata from mutagen.easyid3 import EasyID3 from mutagen.easymp4 import EasyMP4 from mutagen.id3 import ID3 import mutagen.id3._util extra_id3_tags = [ ('comments', 'COMM') ] for k, v in extra_id3_tags: EasyID3.RegisterTextKey(k, v) logger = logging.getLogger() def load_mp3(filename): try: return EasyID3(filename) except mutagen.id3._util.ID3NoHeaderError: # Fix mp3 file no tag loading error, m4a has no this problem id3 = ID3() id3.save(filename) return EasyID3(filename)
from gmusicapi import Mobileclient import gMusicLogin from tqdm import tqdm import sys, os, time, requests from mutagen.easyid3 import EasyID3 from mutagen.mp3 import MP3 import mutagen.id3 EasyID3.RegisterTextKey("albumartist", "TPE2") EasyID3.RegisterTextKey("media", "TMED") r_albumID = 'Bmzku73mo3yicub2vnes43wv52y' api = Mobileclient() try: api.login(gMusicLogin.getUser(), gMusicLogin.getPass(), Mobileclient.FROM_MAC_ADDRESS) except: sys.exit("Login Failed") while api.is_authenticated() == False: time.sleep(.1) def removeNonASCII(text): return ''.join(i for i in text if ord(i) < 128) def runMainBody():
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ---------------------------------------------------------------------------- from .Utilities import * from .Parameters import * import dateutil.parser from mutagen.easyid3 import EasyID3 from mutagen.flac import FLAC import mutagen import os from os import path EasyID3.RegisterTextKey("albumartist", "TPE2") class Episode: def __init__(self, podcast, xmlEp=None, enclInd=0): self.podcast = podcast self.filePath = '' if xmlEp: # Get the podcast attributes self.title = xmlEp.title if 'href' in xmlEp.enclosures[enclInd]: self.url = xmlEp.enclosures[enclInd]['href'] elif 'url' in xmlEp.enclosures[enclInd]: self.url = xmlEp.enclosures[enclInd]['url'] else: self.url = ''
from __future__ import print_function from __future__ import unicode_literals from multiprocessing.context import Process import stat from subprocess import Popen, PIPE import os from mutagen.easyid3 import EasyID3 import re # Regular expression library import time from modules.common.utility import Utility FFMPEG_CMD = ['ffmpeg'] EasyID3.RegisterTextKey('comment', 'COMM') class Worker(Process, Utility): def __init__(self, main, id): Process.__init__(self) self.convertQueue = main.ConvertQueue self.name = "Converter " + str(id) self.isRunning = True self.dataTransport = main.dataTransport self.main = main self.params = main.params self.filter = main.params['filter'] def set_id3(self, file, playlistData): fileData = self.GetDataFromFilename(str(file)) tagFile = EasyID3(file) videoData = self.getdata('video', playlistData, fileData)
def __init__(self, location): self.spotify = spotipy.Spotify() self.location = location self.mp3 = EasyID3(self.location) EasyID3.RegisterTextKey("comment", "COMM")
import logging from pathlib import Path from typing import TYPE_CHECKING, Any, AnyStr, Dict, Iterator, List, Optional, cast from urllib.error import HTTPError from moviepy.editor import AudioFileClip from mutagen.easyid3 import EasyID3 from pytube import YouTube from pytube.streams import Stream from youtubesearchpython import VideosSearch from dotify._model import Model, logger logger = logging.getLogger("{0}.{1}".format(logger.name, __name__)) EasyID3.RegisterTextKey("albumcover", "APIC") if TYPE_CHECKING is True: from dotify.models._artist import Artist class TrackBase(Model): """`TrackBase` defines the interface of the `Track` class, which is subclassing it.""" class Json(object): abstract = True def __str__(self) -> str: return "{0} - {1}".format(self.artist, self.name) @property