def post(self, account, account_id): if account.account_id != account_id: return { "status": "failed", "message": get_request_message(request, "UNAUTHORIZED") }, 401 results = [] for file_data in request.files: file = request.files[file_data] if file and allowed_file(file.filename): filename = secure_filename(file.filename).replace("_", " ") new_filename = hashlib.sha1( (filename + str(datetime.datetime.now().timestamp()) ).encode()).hexdigest() + "." + file.filename.rsplit( '.', 1)[1].lower() file.save(os.path.join(ACCOUNT_SONGS_DIRECTORY, new_filename)) audio_file_metadata = audio_metadata.load( ACCOUNT_SONGS_DIRECTORY + "/" + new_filename) new_account_song = AccountSong( account_id, filename, strftime("%M:%S", gmtime(audio_file_metadata.streaminfo.duration)), new_filename, datetime.datetime.today().strftime("%Y-%m-%d")) database.session.add(new_account_song) database.session.commit() result = account_song_schema.dump(new_account_song).data results.append(result) if not results: return { "status": "failed", "message": get_request_message(request, "NO_FILES_SELECTED") }, 400 return {"status": "success", "data": results}, 201
def generate_client_id(song): if not isinstance(song, audio_metadata.Format): song = audio_metadata.load(song) md5sum = None if isinstance(song, audio_metadata.FLAC): md5sum = unhexlify(song.streaminfo.md5) else: m = md5() audio_size = song.streaminfo._size with open(song.filepath, 'rb') as f: f.seek(song.streaminfo._start) # Speed up by reading in chunks read = 0 while True: read_size = min(audio_size - read, 65536) if not read_size: break read += read_size data = f.read(read_size) m.update(data) md5sum = m.digest() client_id = b64encode(md5sum).rstrip(b'=').decode('ascii') return client_id
def supportedFormat(self, inFilename, outFilename): metadata = audio_metadata.load(inFilename) if metadata.streaminfo.duration <= MIDIView.maxDuration: self.correctDuration(inFilename, metadata, outFilename) else: raise ValueError( f"File exceeds maximum duration, {MIDIView.maxDuration}")
def meta_test(path): am = audio_metadata.load(path) print('path: ' + path.replace('media/', '') + ' | name: ' + am.tags.get('title')[0]) db = DB_Song_Interface db.create_single_song(db, am.tags.get('title')[0], path.replace('media/', ''))
def read_metadata(path): """ :param path: path object, e.g. os.path.expanduser('~/Music/Lieder_HighResolutionAudio') :return: [{"success": , "name": , "artist": , "path:"}, {...} """ parsed_songs = [] for filepath in pathlib.Path(path).glob('**/*'): if filepath.is_file(): try: filepath = filepath.absolute() metadata = audio_metadata.load(filepath) song_info = { "success": True, "name": metadata["tags"]["title"][0], "artist": metadata["tags"]["artist"][0], "path": filepath } # print(metadata["tags"]["genre"]) except KeyError: print("no Metadata found for song:", filepath) songinfo = {"success": False, "path": filepath} parsed_songs.append(song_info) print(parsed_songs) return parsed_songs
def get_files(path): """Get files from a specified path. """ # Get all files in the path filelist = os.listdir(path) # Filter file types filelist = [ file for file in filelist if file.endswith(('.mp3', '.wav', '.ogg')) ] # Create files object files = [] for filename in filelist: metadata = audio_metadata.load(os.path.join(path, filename)) files.append({ "name": filename, "size": "{:02}".format(round(metadata.filesize / 1048576, 2)), "duration": sec2min(metadata.streaminfo.duration), "metadata": metadata, }) return files
def readMusic(file_path): """Guarda en un diccionario toda la informacion del archivo, lo agrega al archivo pickle de musica """ for file in readTags("music"): if file["file_name"] == file_path: # Se determina si el archivo ya es existente return None # tags = {"file_name": file_path, "album": ["Unknown"], "artist": ["Unknown"], "date": ["Unknown"], "title": [file_path], "genre": ["Unknown"]} # Diccionario con la informacion a guardar song_data = audio_metadata.load(file_path) # Carga metadata de la musica con la funcion audio_metadata.load keys = [x for x in song_data.tags] values = [x for x in song_data.tags.values()] meta_data = dict(zip(keys, values)) # Lo convierte en diccionario para facilitar su manejo for x in tags.keys(): if x in meta_data: tags[x] = meta_data[x] # Guarda solo la metadata que nos interesa saveTags(modify(tags), 'music') allSongs = readTags('music') print("Se añadio recientemente: ") print("--------------------------------------------") print("--------------------------------------------") for x in allSongs[2:0:-1]: # Se muestra la musica añadida recientemente print("Name: ", x["title"], sep=" ") print("Data:") print(x["artist"], x["album"], x["date"], sep="\n") print("--------------------------------------------") print("--------------------------------------------")
def partition(files): ''' groups files based on metadata and returns the groupings ''' partitions = {} for file in files: besttag = "UnknownType" try: meta = audio_metadata.load(file) tags = meta["tags"] #print(tags) key = None if ("album" in tags): key = "album" elif ("artist" in tags): key = "artist" elif ("genre" in tags): key = "genre" besttag = tags[key][0] if key is not None else "Unknown" except: pass #file-friendly besttag = slugify(besttag) partitions[besttag] = partitions[besttag] + [ file ] if besttag in partitions else [file] return partitions
def generate(self, ctx, dirpath, filename, filepath): try: amd = audio_metadata.load(filepath) if not hasattr(amd, 'tags'): raise AttributeException("attribute tags missing") if not hasattr(amd.tags, 'artist'): raise AttributeException("attribute artist missing") if not hasattr(amd.tags, 'title'): raise AttributeException("attribute title missing") new_filename = ('-'.join(amd.tags.artist) + '_' + '-'.join(amd.tags.title)).strip() + os.path.splitext(filename)[1] new_filename = clean_windows_filename(new_filename) line = new_filename + ' | ' + filepath + '\n' ctx.ofs.write(line) dest_filepath = os.path.join(ctx.destpath, new_filename) if os.path.exists(dest_filepath): if os.stat(filepath).st_size <= os.stat(dest_filepath).st_size: return shutil.copyfile(filepath, dest_filepath) except audio_metadata.AudioMetadataException as e: self.error(filepath, e) except ValueError as e: self.error(filepath, e) except AttributeException as e: self.error(filepath, e) except OSError as e: self.error(filepath, e) except Exception as e: self.error(filepath, e) except: self.error(filepath, traceback.format_exc())
def handler(self, data, addr): print(f"Inbound request from {addr[0]} on UDP port {addr[1]}") song = random.choice(self.music) m = am.load(f"/home/monster/music/{song}") title = f'TITLE({m["tags"]["artist"][0]} - {m["tags"]["title"][0]})' try: self.socket.sendto(title.encode(), (addr[0], addr[1])) except (socket.error, socket.timeout, OSError) as error: print(error) return False with open(f"/home/monster/music/{song}", "rb") as f: while True: data = f.read(20000) if not data: print("Done with stream") try: self.socket.sendto(data, (addr[0], addr[1])) self.socket.sendto(b"DONE", (addr[0], addr[1])) except (socket.error, socket.timeout) as error: return False break try: self.socket.sendto(data, (addr[0], addr[1])) except (socket.error, socket.timeout) as error: print(error) self.socket.close() return error f.close() return True
def get_album_art(song): if not isinstance(song, audio_metadata.Format): song = audio_metadata.load(song) album_art = next( (picture.data for picture in song.pictures if picture.type == 3), None) return album_art
def extractor(audio, output, file): album_art_dir = '{}/album-art'.format(output) music_info = [] id = 0 if os.path.exists(album_art_dir): pass else: os.makedirs(album_art_dir) for music in glob.glob("{}/*.flac".format(audio)): tmp_music = { "id": "", "title": "", "album": "", "artist": "", "genre": "", "date": "", "filepath": "", "filesize": "", "albumart": "" } file_ = os.path.join(audio, music) meta_data = audio_metadata.load(file_) img = meta_data["pictures"] for pic in img: if pic.type == 3: album_art_path = os.path.join(album_art_dir, f"{str(id)}.jpg") with open(album_art_path, 'wb') as f: f.write(pic.data) tmp_music["id"] = str(id) tmp_music["title"] = meta_data["tags"]["title"][0] if meta_data[ "tags"].get("title") else "Track {}".format(id) tmp_music["album"] = meta_data["tags"]["album"][0] if meta_data[ "tags"].get("album") else "Unknown" tmp_music["artist"] = meta_data["tags"]["artist"][0] if meta_data[ "tags"].get("artist") else "Unknown" tmp_music["genre"] = meta_data["tags"]["genre"][0] if meta_data[ "tags"].get("genre") else "Unknown" tmp_music["date"] = meta_data["tags"]["date"][0] if meta_data[ "tags"].get("date") else "Unknown" tmp_music["filepath"] = meta_data["filepath"] if meta_data.get( "filepath") else "Unknown" tmp_music["filesize"] = meta_data["filesize"] if meta_data.get( "filesize") else "Unknown" try: tmp_music["albumart"] = album_art_path except KeyError: tmp_music["albumart"] = "Unknown" music_info.append(tmp_music) id += 1 print(music_info) with open(f'{output}/{file}.json', "w") as outFile: json.dump(music_info, outFile) print("file saved as {}.json...".format(file)) outFile.close()
def sample_recognize(filename): """ Transcribe a short audio file using synchronous speech recognition Args: local_file_path Path to local audio file, e.g. /path/audio.wav """ if (filename.endswith(".MOV")): #or .avi, .mpeg, whatever. mp3_filename = filename[:-4] + ".mp3" flac_filename = filename[:-4] + ".flac" monoFlac_filename = "mono" + flac_filename #subprocess.call(['ffmpeg', '-i', filename, mp3_filename]) #subprocess.call(['ffmpeg', '-i', mp3_filename, '-f', 'flac', flac_filename]) #subprocess.call(['ffmpeg', '-i', flac_filename, '-ac', '1', monoFlac_filename]) os.system("ffmpeg -i " + filename + " " + mp3_filename + " &> /dev/null") os.system("ffmpeg -i " + mp3_filename + " -f flac " + flac_filename + " &> /dev/null") os.system("ffmpeg -i " + flac_filename + " -ac 1 " + monoFlac_filename + " &> /dev/null") else: pass if (filename.endswith(".flac") and filename[0:4] == "mono"): metadata = audio_metadata.load(filename) sample_frequency = metadata['streaminfo']['sample_rate'] else: sample_frequency = 44100 client = speech_v1.SpeechClient() # The language of the supplied audio language_code = "en-US" # Sample rate in Hertz of the audio data sent sample_rate_hertz = sample_frequency # Encoding of audio data sent. This sample sets this explicitly. # This field is optional for FLAC and WAV audio formats. #encoding = enums.RecognitionConfig.AudioEncoding.MP3 config = { "language_code": language_code, "sample_rate_hertz": sample_rate_hertz, "encoding": "FLAC", } with io.open(monoFlac_filename, "rb") as f: content = f.read() audio = {"content": content} response = client.recognize(config, audio) for result in response.results: # First alternative is the most probable result alternative = result.alternatives[0] return "{}".format(alternative.transcript)
def albumInfo(mfile): #get file path and album\title\artist info into single dict format vdext = ['.flac','.mp3','.wav','.wma','.m4a'] ext = mfile[mfile.rfind('.'):]#file extension if ext in vdext: alinfo = { 'path':None, 'pic':None, 'title':None, 'album':None, 'artist':None } if ext == '.wma' or ext == '.m4a': fa = mutagen.File(mfile) if ext == '.wma': alinfo['path'] = mfile if 'Title' in fa: alinfo['title'] = str(fa['Title'][0]) if 'WM/AlbumTitle' in fa: alinfo['album'] = str(fa['WM/AlbumTitle'][0]) if 'WM/AlbumArtist' in fa: alinfo['artist'] = str(fa['WM/AlbumArtist'][0]) pass else: alinfo['path'] = mfile if '©ART' in fa: alinfo['artist'] = fa['©ART'][0] if '©nam' in fa: alinfo['title'] = fa['©nam'][0] if '©alb' in fa: alinfo['album'] = fa['©alb'][0] #'covr' is album art pass else: try: fa = audio_metadata.load(mfile) if 'filepath' in fa: alinfo['path'] = fa['filepath'] else: alinfo['path'] = mfile if 'pictures' in fa: if len(fa['pictures'])>0: alinfo['pic'] = fa['pictures'] tgs = fa['tags'] #print(tgs) if 'title' in tgs: alinfo['title'] = tgs['title'][0] if 'album' in tgs: alinfo['album'] = tgs['album'][0] if 'artist' in tgs: alinfo['artist'] = tgs['artist'][0] except: print(sys.exc_info()) return None return alinfo else: return None
def add_genre_to_dataset(genreID, genreFilesPath, copy=True): genre_id, genre = _create_Raga_ID_ditionary() files_list = librosa.util.find_files( platform_details.get_platform_path(genreFilesPath)) artists = [] fileIDs = [] for i in range(len(files_list)): meta = audio_metadata.load(files_list[i]) if meta['tags'].__contains__('artist'): artist = meta['tags'].artist else: artist = '' artists.append(artist) fileIDs.append( str(genreID).zfill(3) + str(0).zfill(3) + str(i + 1).zfill(3)) if genre.keys().__contains__(genreID): gen = genre[genreID] else: try: meta = audio_metadata.load(files_list[0]) gen = meta['tags'].genre except: raise Exception("Add genre name to the 'v4_genre_ids' first") ### assigning artist ID := 0 for now, will edit the code later ### TODO: add get_artist() and get_artist_id() metadata_path = os.path.join(copy_base, 'metadata.csv') if copy: with open(metadata_path, 'a', encoding='utf8') as f: for i in range(len(files_list)): copy_dest = os.path.join(copy_base, fileIDs[i]) try: os.mkdir(copy_dest) except: pass new_path = shutil.copy2(files_list[i], copy_dest) new_path = new_path.strip(copy_base) f.write( f"{new_path},{artists[i]},{gen},{gen.lower()},{fileIDs[i]}\n" ) print(f"file {i + 1} of {len(files_list)} copied!!")
def store_song_file(self, file): filename = secure_filename(file.filename).replace("_", " ") new_filename = hashlib.sha1( (filename + str(datetime.datetime.now().timestamp())).encode() ).hexdigest() + "." + file.filename.rsplit('.', 1)[1].lower() file.save(os.path.join(SONGS_DIRECTORY, new_filename)) audio_file_metadata = audio_metadata.load(SONGS_DIRECTORY + "/" + new_filename) return { "name": new_filename, "duration": strftime("%M:%S", gmtime(audio_file_metadata.streaminfo.duration)) }
def generate_client_id(song): def _hash_data(m, f, audio_size): # Speed up by reading in chunks read = 0 read_size = min(audio_size - read, 65536) while read_size > 0: data = f.read(read_size) m.update(data) read += read_size read_size = min(audio_size - read, 65536) return m.digest() if not isinstance(song, audio_metadata.Format): # pragma: nobranch song = audio_metadata.load(song) md5sum = None if isinstance(song, audio_metadata.FLAC): md5sum = unhexlify(song.streaminfo.md5) else: m = md5() if isinstance(song, audio_metadata.MP3): if '_id3' in song and isinstance(song._id3, audio_metadata.ID3v2): audio_start = song._id3._size else: audio_start = 0 audio_size = song.streaminfo._end - audio_start with open(song.filepath, 'rb') as f: f.seek(audio_start, os.SEEK_SET) md5sum = _hash_data(m, f, audio_size) elif isinstance(song, audio_metadata.OggVorbis): f = DataReader(song.filepath) f.seek(song.streaminfo._start) while True: page = audio_metadata.OggPage.parse(f) if page.position: break audio_start = f.tell() audio_size = song.streaminfo._size md5sum = _hash_data(m, f, audio_size) else: audio_size = song.streaminfo._size with open(song.filepath, 'rb') as f: f.seek(song.streaminfo._start) md5sum = _hash_data(m, f, audio_size) client_id = b64encode(md5sum).rstrip(b'=').decode('ascii') return client_id
def get_item_tags(item): if isinstance(item, (str, os.PathLike)): try: tags = audio_metadata.load(item).tags except AudioMetadataException: tags = None elif isinstance(item, audio_metadata.Format): tags = item.tags else: tags = item return tags
def __attrs_post_init__(self): super().__attrs_post_init__() inlined = { 'title': 'jumper-uploader-title-42', 'ClientId': self.track.client_id, 'ClientTotalSongCount': str(self.total_song_count), 'CurrentTotalUploadedCount': str(self.total_uploaded_count), 'CurrentUploadingTrackArtist': self.track.artist, 'CurrentUploadingTrack': self.track.title, 'ServerId': self.server_track_id, 'SyncNow': 'true', 'TrackBitRate': str(self.track.original_bit_rate), 'TrackDoNotRematch': 'false', 'UploaderId': self.uploader_id, } if not isinstance(self.song, audio_metadata.Format): self.song = audio_metadata.load(self.song) album_art = self.external_art or get_album_art(self.song) if album_art: inlined['AlbumArt'] = b64encode(album_art).decode() self._data.update({ 'clientId': 'Jumper Uploader', 'createSessionRequest': { 'fields': [{ 'external': { 'filename': os.path.basename(self.song.filepath), 'name': os.path.abspath(self.song.filepath), 'put': {}, # Size seems to be sent when uploading MP3, but not FLAC. # In fact, uploading FLAC directly fails when this is given. # Leaving it out works for everything. # 'size': self.track.estimated_size } }] }, 'protocolVersion': '0.8', }) for field, value in inlined.items(): self._data['createSessionRequest']['fields'].append( {'inlined': { 'content': value, 'name': field, }}) self._url = ScottyAgentPost.base_url
def Mostrar_info(self, info): filename = filedialog.askopenfilename(filetypes=[('WAV Files', '*.wav')]) self.archivo = list(filename) wav = ''.join(self.archivo) propiedades = audio_metadata.load(wav) Ruta1 = "Ruta: " + str(propiedades["filepath"]) Ruta = self.formato(Ruta1) AudioFormat = "AudioFormat: " + str( propiedades["streaminfo"]['audio_format']) Bit_depth = "Bit_depth: " + str(propiedades["streaminfo"]['bit_depth']) Sample_rate = "Sample_rate: " + str( propiedades["streaminfo"]['sample_rate']) self.informacion = Ruta + '\n' + AudioFormat + '\n' + Bit_depth + '\n' + Sample_rate info.config(text=self.informacion)
def load_songs(self): song_metadata = [] try: for filename in os.listdir(self.path): _, extension = os.path.splitext(filename) if extension in self.supported_extensions: try: metadata = audio_metadata.load( f"{self.path}/{filename}") song_metadata.append(metadata) except audio_metadata.exceptions.UnsupportedFormat: print(f"Filerror opening {filename}") except PermissionError: print("Denied access") except PermissionError: print("Denied access") except Exception as e: print("Unknown exception while opening the folder. ", str(e)) self.song_metadata = song_metadata
def collect_file_meta_data(file_name, parent_id=-1): ''' takes in a audio file and computes necesary metadata Parameters ---------- file_name : String path to the specified file parent_id : INT, optional This should be genreated in previous steps/known. The default is -1 showing an error. Returns ------- file_id : INT parent_id : INT size_bytes : FLOAT file_duration : FLOAT checksum : FLOAT blob_storage_url : STRING Location of file in Blob sample_rate : FLOAT ''' file_id = get_unique_id() file_extension = os.path.splitext(file_name) blob_storage_url = str( str(parent_id) + "/" + str(file_id) + file_extension[1]) # Using the audio_metadata import metadata = audio_metadata.load(file_name) # Store indiviual file data into dataframe size_bytes = metadata['filesize'] bitrate = metadata['streaminfo'].bitrate file_duration = metadata['streaminfo'].duration sample_rate = metadata['streaminfo'].sample_rate checksum = "" #metadata['streaminfo'].md5 return (file_id, parent_id, size_bytes, file_duration, checksum, blob_storage_url, sample_rate)
def get_album_art(song): if not isinstance(song, audio_metadata.Format): # pragma: nobranch song = audio_metadata.load(song) # Google's Music manager uses this album art selection algorithm: # * If picture(s) of type 'front cover' are found, use the first one of those in the list. # * If picture(s) of type 'other' are found, use the first one of those in the list. # * If picture(s) of type 'back cover' are found, use the first one of those in the list. for picture_type in [3, 0, 4]: album_art = next( ( picture.data for picture in song.pictures if picture.type == picture_type ), None ) if album_art is not None: break return album_art
def get_meta(music): try: metadata = audio_metadata.load(music) except Exception as e: print(e) duration = None artist = None title = None try: artist = str(metadata['tags']['artist'][0]) except: pass try: title = str(metadata['tags']['title'][0]) except: pass try: duration = str(metadata['streaminfo']['duration']) except: pass print(artist, duration, title) return {"artist": artist, "duration": duration, "title": title}
def zAudio(audioFile): zCh = audio_metadata.load(audioFile) print(zCh)
def fileSaver(audio, audioFileType, audioFileId): file_name = audio.filename file_duration = 0 host, paticipant, title, author, narrator = '', '', '', '', '' file_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(file_name)) audio.save(file_path) metadata = audio_metadata.load(file_path) print(metadata) if 'streaminfo' in metadata: streaminfo = metadata['streaminfo'] if 'duration' in streaminfo: file_duration = streaminfo['duration'] if "tags" in metadata: tags = metadata['tags'] if "title" in tags: title = str(tags["title"]) if "albumartist" in tags: author = str(tags["albumartist"]) if "artist" in tags: narrator = str(tags["artist"]) ''' Here implement code for get metaData of Podcast but currently this type of files is not available (you can provide.) so i have used defalut(empty) values. thanks''' if audioFileType == "Song": if audioFileId: update_song = Song.query.filter_by(id=audioFileId).first() if file_name: update_song.name = file_name if file_duration > 0: update_song.duration = file_duration db.session.commit() else: song = Song(name=file_name, duration=file_duration) db.session.add(song) db.session.commit() elif audioFileType == "Podcast": if audioFileId: update_podcast = Podcast.query.filter_by(id=audioFileId).first() if file_name: update_podcast.name = file_name if file_duration > 0: update_podcast.duration = file_duration if host != '': update_podcast.host = host if file_name != '': update_podcast.paticipant = paticipant db.session.commit() else: podcast = Podcast(name=file_name, duration=file_duration, host=host, paticipant=paticipant) db.session.add(podcast) db.session.commit() elif audioFileType == "Audiobook": if audioFileId: update_audiobook = Audiobook.query.filter_by( id=audioFileId).first() if file_name: update_audiobook.title = title if file_duration > 0: update_audiobook.duration = file_duration if host != '': update_audiobook.author = author if file_name != '': update_audiobook.narrator = narrator db.session.commit() else: audiobook = Audiobook(title=title, duration=file_duration, author=author, narrator=narrator) db.session.add(audiobook) db.session.commit()
def getMetadata(fileName): try: metadata = audio_metadata.load(fileName) except audio_metadata.exceptions.UnsupportedFormat: return None return metadata
def upload(self, song, *, album_art_path=None, no_sample=False): """Upload a song to a Google Music library. Parameters: song (os.PathLike or str or audio_metadata.Format): The path to an audio file or an instance of :class:`audio_metadata.Format`. album_art_path (os.PathLike or str, Optional): The relative filename or absolute filepath to external album art. no_sample(bool, Optional): Don't generate an audio sample from song; send empty audio sample. Default: Create an audio sample using ffmpeg/avconv. Returns: dict: A result dict with keys: ``'filepath'``, ``'success'``, ``'reason'``, and ``'song_id'`` (if successful). """ if not isinstance(song, audio_metadata.Format): try: song = audio_metadata.load(song) except audio_metadata.UnsupportedFormat: raise ValueError("'song' must be FLAC, MP3, or WAV.") if album_art_path: album_art_path = Path(album_art_path).resolve() if album_art_path.is_file(): with album_art_path.open('rb') as image_file: external_art = image_file.read() else: external_art = None else: external_art = None result = {'filepath': Path(song.filepath)} track_info = mm_calls.Metadata.get_track_info(song) response = self._call(mm_calls.Metadata, self.uploader_id, [track_info]) metadata_response = response.body.metadata_response if metadata_response.signed_challenge_info: # Sample requested. sample_request = metadata_response.signed_challenge_info[0] try: track_sample = mm_calls.Sample.generate_sample( song, track_info, sample_request, external_art=external_art, no_sample=no_sample, ) response = self._call(mm_calls.Sample, self.uploader_id, [track_sample]) track_sample_response = response.body.sample_response.track_sample_response[ 0] except (OSError, ValueError, subprocess.CalledProcessError): raise # TODO else: track_sample_response = metadata_response.track_sample_response[0] response_code = track_sample_response.response_code if response_code == upload_pb2.TrackSampleResponse.MATCHED: result.update({ 'success': True, 'reason': 'Matched', 'song_id': track_sample_response.server_track_id, }) elif response_code == upload_pb2.TrackSampleResponse.UPLOAD_REQUESTED: server_track_id = track_sample_response.server_track_id self._call(mm_calls.UploadState, self.uploader_id, 'START') attempts = 0 should_retry = True while should_retry and attempts <= 10: try: # Call with tenacity.retry_with to disable automatic retries. response = self._call.retry_with( stop=stop_after_attempt(1))( self, mm_calls.ScottyAgentPost, self.uploader_id, server_track_id, track_info, song, external_art=external_art, total_song_count=1, total_uploaded_count=0, ) except requests.RequestException as e: should_retry = True reason = e.response else: session_response = response.body if 'sessionStatus' in session_response: break try: # WHY, GOOGLE?! WHY??????????? status_code = session_response['errorMessage'][ 'additionalInfo'][ 'uploader_service.GoogleRupioAdditionalInfo'][ 'completionInfo']['customerSpecificInfo'][ 'ResponseCode'] except KeyError: status_code = None if status_code == 503: # Upload server still syncing. should_retry = True reason = "Server syncing" elif status_code == 200: # Song is already uploaded. should_retry = False reason = "Already uploaded" elif status_code == 404: # Rejected. should_retry = False reason = "Rejected" else: should_retry = True reason = "Unkown error" finally: attempts += 1 time.sleep(2) # Give the server time to sync. else: result.update({ 'success': False, 'reason': f'Could not get upload session: {reason}', }) if 'success' not in result: transfer = session_response['sessionStatus'][ 'externalFieldTransfers'][0] upload_url = transfer['putInfo']['url'] content_type = transfer.get('content_type', 'audio/mpeg') original_content_type = track_info.original_content_type transcode = (isinstance(song, audio_metadata.WAV) or original_content_type != locker_pb2.Track.MP3) if (transcode or original_content_type == locker_pb2.Track.MP3): if transcode: audio_file = transcode_to_mp3(song, quality='320k') else: with open(song.filepath, 'rb') as f: audio_file = f.read() # Google Music allows a maximum file size of 300 MiB. if len(audio_file) >= 300 * 1024 * 1024: result.update({ 'success': False, 'reason': 'Maximum allowed file size is 300 MiB.', }) else: upload_response = self._call( mm_calls.ScottyAgentPut, upload_url, audio_file, content_type=content_type, ).body if upload_response.get('sessionStatus', {}).get('state'): result.update({ 'success': True, 'reason': 'Uploaded', 'song_id': track_sample_response.server_track_id, }) else: result.update({ 'success': False, 'reason': upload_response, # TODO: Better error details. }) else: # Do not upload files if transcode option set to False. result.update({ 'success': False, 'reason': 'Transcoding disabled for file type.', }) self._call(mm_calls.UploadState, self.uploader_id, 'STOPPED') else: response_codes = upload_pb2._TRACKSAMPLERESPONSE.enum_types[0] response_type = response_codes.values_by_number[ track_sample_response.response_code].name reason = response_type result.update({'success': False, 'reason': f'{reason}'}) if response_type == 'ALREADY_EXISTS': result['song_id'] = track_sample_response.server_track_id return result
os.system('cls' if os.name == 'nt' else 'clear') try: pid = os.popen('wmic process get description, processid').read() pid = int(pid[pid.index("Music.UI.exe") + 12:pid.index("Music.UI.exe") + 45]) print(pid) p = psutil.Process(pid) print(p) openHandles = p.open_files() matching = [s for s in openHandles if "\Music" in str(s)] music = str(matching[0]) info = music[music.index("path=") + 6:music.index(", fd") - 1] info = info.replace('\\\\', '/') metadata = audio_metadata.load(info) infoTemp = info metadata = audio_metadata.load(info) RPC.update(state=metadata.tags['artist'][0], details=metadata.tags['title'][0], large_image="groove", small_image="mad", large_text="Groove Music", small_text="madge", end=int(time()) + int(metadata.streaminfo['duration'])) except ValueError: print("Groove Music not running") except IndexError: RPC.update(state="Idle", details="Idle", large_image="groove",
def test_load_pathobj(): for fp in test_filepaths: audio_metadata.load(fp)