musicdl 2.1.11__py3-none-any.whl → 2.7.3__py3-none-any.whl

musicdl/modules/sources/netease.py

@@ -1,124 +1,172 @@
 '''
 Function:
-    网易云音乐下载: https://music.163.com/
+    Implementation of NeteaseMusicClient: https://music.163.com/
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
-import os
-import base64
-import codecs
-import requests
-from .base import Base
-from ..utils.misc import *
-from Crypto.Cipher import AES
+import json
+import copy
+import random
+from .base import BaseMusicClient
+from rich.progress import Progress
+from ..utils.neteaseutils import EapiCryptoUtils
+from ..utils import resp2json, seconds2hms, legalizestring, safeextractfromdict, usesearchheaderscookies, SongInfo
 
 
-'''
-Function:
-    用于算post的两个参数, 具体原理详见知乎：
-    https://www.zhihu.com/question/36081767
-'''
-class Cracker():
-    def __init__(self):
-        self.modulus = '00e0b509f6259df8642dbc35662901477df22677ec152b5ff68ace615bb7b725152b3ab17a876aea8a5aa76d2e417629ec4ee341f56135fccf695280104e0312ecbda92557c93870114af6c9d05c4f7f0c3685b7a46bee255932575cce10b424d813cfe4875d3e82047b97ddef52741d546b8e289dc6935b3ece0462db0a22b8e7'
-        self.nonce = '0CoJUm6Qyw8W8jud'
-        self.pubKey = '010001'
-    def get(self, text):
-        text = json.dumps(text)
-        secKey = self.__createSecretKey(16)
-        encText = self.__aesEncrypt(self.__aesEncrypt(text, self.nonce), secKey)
-        encSecKey = self.__rsaEncrypt(secKey, self.pubKey, self.modulus)
-        post_data = {
-            'params': encText,
-            'encSecKey': encSecKey
-        }
-        return post_data
-    def __aesEncrypt(self, text, secKey):
-        pad = 16 - len(text) % 16
-        if isinstance(text, bytes):
-            text = text.decode('utf-8')
-        text = text + str(pad * chr(pad))
-        secKey = secKey.encode('utf-8')
-        encryptor = AES.new(secKey, 2, b'0102030405060708')
-        text = text.encode('utf-8')
-        ciphertext = encryptor.encrypt(text)
-        ciphertext = base64.b64encode(ciphertext)
-        return ciphertext
-    def __rsaEncrypt(self, text, pubKey, modulus):
-        text = text[::-1]
-        rs = int(codecs.encode(text.encode('utf-8'), 'hex_codec'), 16) ** int(pubKey, 16) % int(modulus, 16)
-        return format(rs, 'x').zfill(256)
-    def __createSecretKey(self, size):
-        return (''.join(map(lambda xx: (hex(ord(xx))[2:]), str(os.urandom(size)))))[0: 16]
-
-
-'''网易云音乐下载类'''
-class netease(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(netease, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'netease'
-        self.cracker = Cracker()
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            's': keyword,
-            'type': '1',
-            'offset': '0',
-            'sub': 'false',
-            'limit': cfg['search_size_per_source']
-        }
-        response = self.session.post(self.search_url, headers=self.headers, params=params, data=self.cracker.get(params))
-        all_items = response.json()['result']['songs']
-        songinfos = []
-        for item in all_items:
-            if item['privilege']['fl'] == 0: continue
-            for q in ['h', 'm', 'l']:
-                params = {
-                    'ids': [item['id']],
-                    'br': item[q]['br'],
-                    'csrf_token': ''
-                }
-                response = self.session.post(self.player_url, headers=self.headers, data=self.cracker.get(params))
-                response_json = response.json()
-                if response_json.get('code') == 200: break
-            if response_json.get('code') != 200: continue
-            download_url = response_json['data'][0]['url']
-            if not download_url: continue
-            filesize = str(round(int(item[q]['size'])/1024/1024, 2)) + 'MB'
-            ext = download_url.split('.')[-1]
-            duration = int(item.get('dt', 0) / 1000)
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['id']),
-                'singers': filterBadCharacter(','.join([s.get('name', '') for s in item.get('ar')])),
-                'album': filterBadCharacter(item.get('al', {}).get('name', '-')),
-                'songname': filterBadCharacter(item.get('name', '-')),
-                'savedir': cfg['savedir'],
-                'savename': '_'.join([self.source, filterBadCharacter(item.get('name', '-'))]),
-                'download_url': download_url,
-                'filesize': filesize,
-                'ext': ext,
-                'duration': seconds2hms(duration)
-            }
-            songinfos.append(songinfo)
-        return songinfos
-    '''初始化'''
-    def __initialize(self):
-        self.headers = {
-            'Accept': '*/*',
-            'Accept-Encoding': 'gzip,deflate,sdch',
-            'Accept-Language': 'zh-CN,zh;q=0.8,gl;q=0.6,zh-TW;q=0.4',
-            'Connection': 'keep-alive',
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Host': 'music.163.com',
-            'Origin': 'https://music.163.com',
+'''NeteaseMusicClient'''
+class NeteaseMusicClient(BaseMusicClient):
+    source = 'NeteaseMusicClient'
+    def __init__(self, **kwargs):
+        super(NeteaseMusicClient, self).__init__(**kwargs)
+        self.default_search_headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
             'Referer': 'https://music.163.com/',
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.32 Safari/537.36'
         }
-        self.search_url = 'http://music.163.com/weapi/cloudsearch/get/web?csrf_token='
-        self.player_url = 'http://music.163.com/weapi/song/enhance/player/url?csrf_token='
+        self.default_download_headers = {}
+        self.default_headers = self.default_search_headers
+        default_cookies = {'MUSIC_U': '1eb9ce22024bb666e99b6743b2222f29ef64a9e88fda0fd5754714b900a5d70d993166e004087dd3b95085f6a85b059f5e9aba41e3f2646e3cebdbec0317df58c119e5'}
+        if not self.default_search_cookies: self.default_search_cookies = default_cookies
+        if not self.default_download_cookies: self.default_download_cookies = default_cookies
+        self._initsession()
+    '''_parsewithcggapi'''
+    def _parsewithcggapi(self, search_result: dict, request_overrides: dict = None):
+        # init
+        request_overrides, song_id = request_overrides or {}, search_result['id']
+        # _safefetchfilesize
+        def _safefetchfilesize(meta: dict):
+            if not isinstance(meta, dict): return 0
+            file_size = str(meta.get('size', '0.00MB'))
+            file_size = file_size.removesuffix('MB').strip()
+            try: return float(file_size)
+            except: return 0
+        # parse
+        for quality in ['jymaster', 'sky', 'jyeffect', 'hires', 'lossless', 'exhigh', 'standard']:
+            try:
+                try:
+                    resp = self.get(url=f'https://api-v1.cenguigui.cn/api/netease/music_v1.php?id={song_id}&type=json&level={quality}', timeout=10, **request_overrides)
+                    resp.raise_for_status()
+                except:
+                    resp = self.get(url=f'https://api.cenguigui.cn/api/netease/music_v1.php?id={song_id}&type=json&level={quality}', timeout=10, **request_overrides)
+                    resp.raise_for_status()
+                download_result = resp2json(resp=resp)
+                if 'data' not in download_result or (_safefetchfilesize(download_result['data']) < 0.01): continue
+            except:
+                continue
+            download_url: str = download_result['data'].get('url', '')
+            if not download_url: continue
+            song_info = SongInfo(
+                source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                ext=download_url.split('.')[-1].split('?')[0], raw_data={'search': search_result, 'download': download_result},
+            )
+            song_info.download_url_status['probe_status'] = self.audio_link_tester.probe(song_info.download_url, request_overrides)
+            ext, file_size = song_info.download_url_status['probe_status']['ext'], song_info.download_url_status['probe_status']['file_size']
+            if file_size and file_size != 'NULL': song_info.file_size = file_size
+            if not song_info.file_size: song_info.file_size = 'NULL'
+            if ext and ext != 'NULL': song_info.ext = ext
+            if song_info.with_valid_download_url: break
+        # return
+        return song_info, quality
+    '''_constructsearchurls'''
+    def _constructsearchurls(self, keyword: str, rule: dict = None, request_overrides: dict = None):
+        # init
+        rule, request_overrides = rule or {}, request_overrides or {}
+        # search rules
+        default_rule = {'s': keyword, 'type': 1, 'limit': 10, 'offset': 0}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://music.163.com/api/cloudsearch/pc'
+        search_urls, page_size, count = [], self.search_size_per_page, 0
+        while self.search_size_per_source > count:
+            page_rule = copy.deepcopy(default_rule)
+            page_rule['limit'] = page_size
+            page_rule['offset'] = int(count // page_size) * page_size
+            search_urls.append({'url': base_url, 'data': page_rule})
+            count += page_size
+        # return
+        return search_urls
+    '''_search'''
+    @usesearchheaderscookies
+    def _search(self, keyword: str = '', search_url: dict = {}, request_overrides: dict = None, song_infos: list = [], progress: Progress = None, progress_id: int = 0):
+        # init
+        request_overrides = request_overrides or {}
+        search_meta = copy.deepcopy(search_url)
+        search_url = search_meta.pop('url')
+        # successful
+        try:
+            # --search results
+            resp = self.post(search_url, **search_meta, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)['result']['songs']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('id' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                # ----try _parsewithcggapi first
+                try:
+                    song_info_cgg, quality_cgg = self._parsewithcggapi(search_result, request_overrides)
+                except:
+                    song_info_cgg, quality_cgg = SongInfo(source=self.source), "standard"
+                # ----general parse with official API
+                qualties = ["jymaster", "jyeffect", "sky", "hires", "lossless", "exhigh", "standard"]
+                for quality_idx, quality in enumerate(qualties):
+                    if quality_idx >= qualties.index(quality_cgg) and song_info_cgg.with_valid_download_url: song_info = song_info_cgg; break
+                    header = {"os": "pc", "appver": "", "osver": "", "deviceId": "pyncm!"}
+                    header["requestId"] = str(random.randrange(20000000, 30000000))
+                    params = {'ids': [search_result['id']], 'level': quality, 'encodeType': 'flac', 'header': json.dumps(header)}
+                    if quality == 'sky': params['immerseType'] = 'c51'
+                    params = EapiCryptoUtils.encryptparams(url='https://interface3.music.163.com/eapi/song/enhance/player/url/v1', payload=params)
+                    try:
+                        resp = self.post('https://interface3.music.163.com/eapi/song/enhance/player/url/v1', data={"params": params}, **request_overrides)
+                        resp.raise_for_status()
+                        download_result: dict = resp2json(resp)
+                    except:
+                        continue
+                    if (download_result.get('code') not in [200, '200']) or ('data' not in download_result) or (not download_result['data']) or \
+                       (not isinstance(download_result['data'], list)) or (not isinstance(download_result['data'][0], dict)):
+                        continue
+                    download_url: str = download_result['data'][0].get('url', '')
+                    if not download_url: continue
+                    song_info = SongInfo(
+                        source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                        ext=download_url.split('.')[-1].split('?')[0], raw_data={'search': search_result, 'download': download_result},
+                    )
+                    song_info.download_url_status['probe_status'] = self.audio_link_tester.probe(song_info.download_url, request_overrides)
+                    ext, file_size = song_info.download_url_status['probe_status']['ext'], song_info.download_url_status['probe_status']['file_size']
+                    if file_size and file_size != 'NULL': song_info.file_size = file_size
+                    if not song_info.file_size: song_info.file_size = 'NULL'
+                    if ext and ext != 'NULL': song_info.ext = ext
+                    if song_info.with_valid_download_url: break
+                if not song_info.with_valid_download_url: continue
+                # ----parse more information
+                song_info.update(dict(
+                    duration=seconds2hms(search_result.get('dt', 0) / 1000 if isinstance(search_result.get('dt', 0), (int, float)) else 0),
+                    song_name=legalizestring(search_result.get('name', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(', '.join([singer.get('name', 'NULL') for singer in search_result.get('ar', [])]), replace_null_string='NULL'), 
+                    album=legalizestring(safeextractfromdict(search_result, ['al', 'name'], 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['id'],
+                ))
+                # --lyric results
+                data = {'id': search_result['id'], 'cp': 'false', 'tv': '0', 'lv': '0', 'rv': '0', 'kv': '0', 'yv': '0', 'ytv': '0', 'yrv': '0'}
+                try:
+                    resp = self.post('https://interface3.music.163.com/api/song/lyric', data=data, **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result: dict = resp2json(resp)
+                    lyric = lyric_result.get('lrc', {}).get('lyric', 'NULL') or lyric_result.get('tlyric', {}).get('lyric', 'NULL')
+                except:
+                    lyric_result, lyric = dict(), 'NULL'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.lyric = lyric
+                # --append to song_infos
+                song_infos.append(song_info)
+                # --judgement for search_size
+                if self.strict_limit_search_size_per_page and len(song_infos) >= self.search_size_per_page: break
+            # --update progress
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Success)")
+        # failure
+        except Exception as err:
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Error: {err})")
+        # return
+        return song_infos

musicdl/modules/sources/qianqian.py

@@ -1,88 +1,136 @@
 '''
 Function:
-    千千音乐下载: http://music.taihe.com/
+    Implementation of QianqianMusicClient: http://music.taihe.com/
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
+import re
 import time
+import copy
 import hashlib
-import requests
-from .base import Base
-from ..utils.misc import *
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils import byte2mb, resp2json, seconds2hms, legalizestring, safeextractfromdict, usesearchheaderscookies, SongInfo
 
 
-'''千千音乐下载类'''
-class qianqian(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(qianqian, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'qianqian'
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            'sign': self.__calcSign(keyword),
-            'word': keyword,
-            'timestamp': str(int(time.time()))
+'''QianqianMusicClient'''
+class QianqianMusicClient(BaseMusicClient):
+    source = 'QianqianMusicClient'
+    def __init__(self, **kwargs):
+        super(QianqianMusicClient, self).__init__(**kwargs)
+        self.appid = '16073360'
+        self.default_search_headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+            'Referer': 'https://music.91q.com/',
+            'From': 'Web',
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
         }
-        response = self.session.get(self.search_url, headers=self.headers, params=params)
-        all_items = response.json()['data']['typeTrack']
-        songinfos = []
-        for item in all_items:
-            params = {
-                'sign': self.__calcSign(keyword),
-                'TSID': item['TSID'],
-                'timestamp': str(int(time.time())),
-                'from': 'web',
-                's_protocol': '1',
-            }
-            response = self.session.get(self.tracklink_url, headers=self.headers, params=params)
-            response_json = response.json()
-            if response_json.get('errno') != 22000: continue
-            download_url = response_json['data']['path']
-            if not download_url: continue
-            filesize = str(round(int(response_json['data']['size'])/1024/1024, 2)) + 'MB'
-            ext = response_json['data']['format']
-            duration = int(response_json['data']['duration'])
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['id']),
-                'singers': filterBadCharacter(item['artist'][0].get('name', '-')),
-                'album': filterBadCharacter(item.get('albumTitle', '-')),
-                'songname': filterBadCharacter(item.get('title', '-')).split('–')[0].strip(),
-                'savedir': cfg['savedir'],
-                'savename': '_'.join([self.source, filterBadCharacter(item.get('title', '-')).split('–')[0].strip()]),
-                'download_url': download_url,
-                'filesize': filesize,
-                'ext': ext,
-                'duration': seconds2hms(duration)
-            }
-            songinfos.append(songinfo)
-            if len(songinfos) == cfg['search_size_per_source']: break
-        return songinfos
-    '''计算sign值'''
-    def __calcSign(self, keyword):
-        secret = '0b50b02fd0d73a9c4c8c3a781c30845f'
-        e = {
-            'word': keyword,
-            'timestamp': str(int(time.time()))
-        }
-        n = list(e.keys())
-        n.sort()
-        i = f'{n[0]}={e[n[0]]}'
-        for r in range(1, len(n)):
-            o = n[r]
-            i += f'&{o}={e[o]}'
-        sign = hashlib.md5((i + secret).encode('utf-8')).hexdigest()
-        return sign
-    '''初始化'''
-    def __initialize(self):
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36',
-            'Referer': 'https://music.taihe.com/'
+        self.default_download_headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
         }
-        self.search_url = 'https://music.taihe.com/v1/search'
-        self.tracklink_url = 'https://music.taihe.com/v1/song/tracklink'
+        self.default_headers = self.default_search_headers
+        self._initsession()
+    '''_addsignandtstoparams'''
+    def _addsignandtstoparams(self, params: dict):
+        secret = '0b50b02fd0d73a9c4c8c3a781c30845f'
+        params['timestamp'] = str(int(time.time()))
+        keys = sorted(params.keys())
+        string = "&".join(f"{k}={params[k]}" for k in keys)
+        params['sign'] = hashlib.md5((string + secret).encode('utf-8')).hexdigest()
+        return params
+    '''_constructsearchurls'''
+    def _constructsearchurls(self, keyword: str, rule: dict = None, request_overrides: dict = None):
+        # init
+        rule, request_overrides = rule or {}, request_overrides or {}
+        # search rules
+        default_rule = {'word': keyword, 'type': '1', 'pageNo': '1', 'pageSize': '10', 'appid': self.appid}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://music.91q.com/v1/search?'
+        search_urls, page_size, count = [], self.search_size_per_page, 0
+        while self.search_size_per_source > count:
+            page_rule = copy.deepcopy(default_rule)
+            page_rule['pageSize'] = page_size
+            page_rule['pageNo'] = str(int(count // page_size) + 1)
+            page_rule = self._addsignandtstoparams(params=page_rule)
+            search_urls.append(base_url + urlencode(page_rule))
+            count += page_size
+        # return
+        return search_urls
+    '''_search'''
+    @usesearchheaderscookies
+    def _search(self, keyword: str = '', search_url: str = '', request_overrides: dict = None, song_infos: list = [], progress: Progress = None, progress_id: int = 0):
+        # init
+        request_overrides = request_overrides or {}
+        # successful
+        try:
+            # --search results
+            resp = self.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)['data']['typeTrack']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('TSID' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                for rate in ['64', '128', '320', '3000'][::-1]:
+                    params = {'TSID': search_result['TSID'], 'appid': self.appid, 'rate': rate}
+                    params = self._addsignandtstoparams(params=params)
+                    try:
+                        resp = self.get("https://music.91q.com/v1/song/tracklink", params=params, **request_overrides)
+                        resp.raise_for_status()
+                        download_result: dict = resp2json(resp)
+                        download_url = safeextractfromdict(download_result, ['data', 'path'], '')
+                        if not download_url: continue
+                        song_info = SongInfo(
+                            source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                            raw_data={'search': search_result, 'download': download_result}, file_size_bytes=download_result['data'].get('size', 0), 
+                            file_size=byte2mb(download_result['data'].get('size', 0)), duration_s=download_result['data'].get('duration', 0),
+                            duration = seconds2hms(download_result['data'].get('duration', 0)), ext=download_result['data'].get('format', 'mp3')
+                        )
+                        if song_info.with_valid_download_url: break
+                    except:
+                        continue
+                if not song_info.with_valid_download_url: continue
+                song_info.download_url_status['probe_status'] = self.audio_link_tester.probe(song_info.download_url, request_overrides)
+                ext, file_size = song_info.download_url_status['probe_status']['ext'], song_info.download_url_status['probe_status']['file_size']
+                if file_size and file_size != 'NULL': song_info.file_size = file_size
+                if ext and ext != 'NULL': song_info.ext = ext
+                song_info.update(dict(
+                    song_name=legalizestring(search_result.get('title', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(', '.join([singer.get('name', 'NULL') for singer in search_result.get('artist', [])]), replace_null_string='NULL'), 
+                    album=legalizestring(search_result.get('albumTitle', 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['TSID'],
+                ))
+                # --lyric results
+                try:
+                    resp = self.get(search_result['lyric'], **request_overrides)
+                    resp.raise_for_status()
+                    resp.encoding = 'utf-8'
+                    lyric = resp.text or 'NULL'
+                    lyric_result = dict(lyric=lyric)
+                    if song_info.singers == 'NULL':
+                        try:
+                            song_info.singers = re.findall(r'\[ar:(.*?)\]', lyric)[0]
+                        except:
+                            song_info.singers = 'NULL'
+                except:
+                    lyric_result, lyric = dict(), 'NULL'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.lyric = lyric
+                # --append to song_infos
+                song_infos.append(song_info)
+                # --judgement for search_size
+                if self.strict_limit_search_size_per_page and len(song_infos) >= self.search_size_per_page: break
+            # --update progress
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Success)")
+        # failure
+        except Exception as err:
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Error: {err})")
+        # return
+        return song_infos