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

musicdl/modules/sources/migu.py

@@ -1,75 +1,181 @@
 '''
 Function:
-    咪咕音乐下载: http://www.migu.cn/
+    Implementation of MiguMusicClient: https://music.migu.cn/v5/#/musicLibrary
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
-import requests
-from .base import Base
-from ..utils.misc import *
+import copy
+from .base import BaseMusicClient
+from rich.progress import Progress
+from urllib.parse import urlencode
+from ..utils import byte2mb, resp2json, seconds2hms, legalizestring, safeextractfromdict, usesearchheaderscookies, SongInfo
 
 
-'''咪咕音乐下载类'''
-class migu(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(migu, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'migu'
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            'ua': 'Android_migu',
-            'version': '5.0.1',
-            'text': keyword,
-            'pageNo': '1',
-            'pageSize': cfg['search_size_per_source'],
-            'searchSwitch': '{"song":1,"album":0,"singer":0,"tagSong":0,"mvSong":0,"songlist":0,"bestShow":1}',
+'''MiguMusicClient'''
+class MiguMusicClient(BaseMusicClient):
+    source = 'MiguMusicClient'
+    def __init__(self, **kwargs):
+        super(MiguMusicClient, 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',
         }
-        response = self.session.get(self.search_url, headers=self.headers, params=params)
-        all_items = response.json()['songResultData']['result']
-        songinfos = []
-        for item in all_items:
-            ext = ''
-            download_url = ''
-            filesize = '-MB'
-            for rate in sorted(item.get('rateFormats', []), key=lambda x: int(x['size']), reverse=True):
-                if (int(rate['size']) == 0) or (not rate.get('formatType', '')) or (not rate.get('resourceType', '')): continue
-                ext = 'flac' if rate.get('formatType') == 'SQ' else 'mp3'
-                download_url = self.player_url.format(
-                    copyrightId=item['copyrightId'], 
-                    contentId=item['contentId'], 
-                    toneFlag=rate['formatType'],
-                    resourceType=rate['resourceType']
-                )
-                filesize = str(round(int(rate['size'])/1024/1024, 2)) + 'MB'
-                break
-            if not download_url: continue
-            duration = '-:-:-'
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['id']),
-                'singers': filterBadCharacter(','.join([s.get('name', '') for s in item.get('singers', [])])),
-                'album': filterBadCharacter(item.get('albums', [{'name': '-'}])[0].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': duration
-            }
-            songinfos.append(songinfo)
-            if len(songinfos) == cfg['search_size_per_source']: break
-        return songinfos
-    '''初始化'''
-    def __initialize(self):
-        self.headers = {
-            'Referer': 'https://m.music.migu.cn/', 
-            'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Mobile Safari/537.36'
+        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 = 'http://pd.musicapp.migu.cn/MIGUM3.0/v1.0/content/search_all.do'
-        self.player_url = 'https://app.pd.nf.migu.cn/MIGUM3.0/v1.0/content/sub/listenSong.do?channel=mx&copyrightId={copyrightId}&contentId={contentId}&toneFlag={toneFlag}&resourceType={resourceType}&userId=15548614588710179085069&netType=00'
+        self.default_headers = self.default_search_headers
+        self._initsession()
+    '''_parsewithcggapi'''
+    def _parsewithcggapi(self, search_result: dict, request_overrides: dict = None):
+        # init
+        request_overrides, song_id = request_overrides or {}, search_result['contentId']
+        # _safefetchfilesize
+        def _safefetchfilesize(meta: dict):
+            if not isinstance(meta, dict): return 0
+            file_size = str(meta.get('size', '0.00 MB'))
+            file_size = file_size.removesuffix('MB').strip()
+            try: return float(file_size)
+            except: return 0
+        # parse
+        try:
+            try:
+                resp = self.get(url=f'https://api-v1.cenguigui.cn/api/mg_music/api.php?id={song_id}', timeout=10, **request_overrides)
+                resp.raise_for_status()
+            except:
+                resp = self.get(url=f'https://api.cenguigui.cn/api/mg_music/api.php?id={song_id}', timeout=10, **request_overrides)
+                resp.raise_for_status()
+            download_result = resp2json(resp=resp)
+        except:
+            return SongInfo(source=self.source)
+        for rate in sorted(safeextractfromdict(download_result, ['data', 'level', 'quality'], []), key=lambda x: _safefetchfilesize(x), reverse=True):
+            download_url = rate.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=str(rate.get('format', 'flac')).lower(), 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
+    '''_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 = {"text": keyword, 'pageNo': 1, 'pageSize': 10}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://app.u.nf.migu.cn/pc/resource/song/item/search/v1.0?'
+        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'] = int(count // page_size) + 1
+            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 {}
+        # _safefetchfilesize
+        def _safefetchfilesize(meta: dict):
+            file_size = meta.get('asize') or meta.get('isize') or meta.get('size') or '0'
+            if byte2mb(file_size) == 'NULL': file_size = '0'
+            return file_size
+        # user info
+        uid = '15548614588710179085069'
+        # successful
+        try:
+            # --search results
+            resp = self.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('copyrightId' not in search_result) or ('contentId' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                # ----try _parsewithcggapi first
+                try:
+                    song_info_cgg = self._parsewithcggapi(search_result, request_overrides)
+                except:
+                    song_info_cgg = SongInfo(source=self.source)
+                # ----general parse with official API
+                for rate in sorted(search_result.get('audioFormats', []), key=lambda x: int(_safefetchfilesize(x)), reverse=True):
+                    if not isinstance(rate, dict): continue
+                    if byte2mb(_safefetchfilesize(rate)) == 'NULL' or (not rate.get('formatType', '')) or (not rate.get('resourceType', '')): continue
+                    ext = {'PQ': 'mp3', 'HQ': 'mp3', 'SQ': 'flac', 'ZQ24': 'flac'}.get(rate['formatType'], 'NULL')
+                    url = (
+                        f"https://c.musicapp.migu.cn/MIGUM3.0/strategy/listen-url/v2.4?resourceType={rate['resourceType']}&netType=01&scene="
+                        f"&toneFlag={rate['formatType']}&contentId={search_result['contentId']}&copyrightId={search_result['copyrightId']}"
+                        f"&lowerQualityContentId={search_result['contentId']}"
+                    )
+                    headers = copy.deepcopy(self.default_headers)
+                    headers['channel'] = '014000D'
+                    try:
+                        resp = self.get(url, headers=headers, **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                    except:
+                        continue
+                    download_url = safeextractfromdict(download_result, ['data', 'url'], "") or \
+                                   f"https://app.pd.nf.migu.cn/MIGUM3.0/v1.0/content/sub/listenSong.do?channel=mx&copyrightId={search_result['copyrightId']}&contentId={search_result['contentId']}&toneFlag={rate['formatType']}&resourceType={rate['resourceType']}&userId={uid}&netType=00"
+                    song_info = SongInfo(
+                        source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                        ext=ext, raw_data={'search': search_result, 'download': download_result},
+                    )
+                    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 not song_info.file_size: song_info.file_size = 'NULL'
+                    if ext and ext != 'NULL': song_info.ext = ext
+                    if song_info_cgg.with_valid_download_url and song_info_cgg.file_size != 'NULL':
+                        file_size_cgg = float(song_info_cgg.file_size.removesuffix('MB').strip())
+                        file_size_official = float(song_info.file_size.removesuffix('MB').strip()) if song_info.file_size != 'NULL' else 0
+                        if file_size_cgg > file_size_official: song_info = song_info_cgg
+                    if song_info.with_valid_download_url: break
+                if not song_info.with_valid_download_url: song_info = song_info_cgg
+                if not song_info.with_valid_download_url: continue
+                # ----parse more information
+                song_info.update(dict(
+                    duration_s=search_result.get('duration', 0), duration=seconds2hms(search_result.get('duration', 0)),
+                    song_name=legalizestring(search_result.get('songName', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(', '.join([singer.get('name', 'NULL') for singer in search_result.get('singerList', [])]), replace_null_string='NULL'), 
+                    album=legalizestring(search_result.get('album', 'NULL'), replace_null_string='NULL'),
+                    identifier=f"{search_result['copyrightId']}_{search_result['contentId']}"
+                ))
+                # --lyric results
+                lyric_url = safeextractfromdict(search_result, ['ext', 'lrcUrl'], '') or safeextractfromdict(search_result, ['ext', 'mrcUrl'], '') or \
+                            safeextractfromdict(search_result, ['ext', 'trcUrl'], '')
+                if lyric_url:
+                    try:
+                        resp = self.get(lyric_url, **request_overrides)
+                        resp.encoding = 'utf-8'
+                        lyric_result, lyric = {'lyric': resp.text}, resp.text
+                    except:
+                        lyric_result, lyric = {}, 'NULL'
+                else:
+                    lyric_result, lyric = {}, '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/mitu.py

@@ -0,0 +1,140 @@
+'''
+Function:
+    Implementation of MituMusicClient: https://www.qqmp3.vip/
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import copy
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils import legalizestring, usesearchheaderscookies, resp2json, safeextractfromdict, SongInfo, QuarkParser
+
+
+'''MituMusicClient'''
+class MituMusicClient(BaseMusicClient):
+    source = 'MituMusicClient'
+    def __init__(self, **kwargs):
+        super(MituMusicClient, self).__init__(**kwargs)
+        if not self.quark_parser_config.get('cookies'): self.logger_handle.warning(f'{self.source}.__init__ >>> "quark_parser_config" is not configured, so song downloads are restricted and only mp3 files can be downloaded.')
+        self.default_search_headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "origin": "https://www.qqmp3.vip",
+            "priority": "u=1, i",
+            "referer": "https://www.qqmp3.vip/",
+            "sec-ch-ua": '"Chromium";v="142", "Google Chrome";v="142", "Not_A Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+        }
+        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.default_headers = self.default_search_headers
+        self._initsession()
+    '''_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 = {'keyword': keyword, 'type': 'search'}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://api.qqmp3.vip/api/songs.php?'
+        page_rule = copy.deepcopy(default_rule)
+        search_urls = [base_url + urlencode(page_rule)]
+        self.search_size_per_page = self.search_size_per_source
+        # 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']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('rid' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                # ----parse from quark links
+                if self.quark_parser_config.get('cookies'):
+                    quark_download_urls: list[str] = search_result.get('downurl', [])
+                    for quark_download_url in quark_download_urls:
+                        if 'mp3' in quark_download_url.lower(): continue
+                        song_info = SongInfo(source=self.source)
+                        try:
+                            quark_wav_download_url = quark_download_url[quark_download_url.index('https://'):]
+                            download_result, download_url = QuarkParser.parsefromurl(quark_wav_download_url, **self.quark_parser_config)
+                            if not download_url: continue
+                            download_url_status = self.quark_audio_link_tester.test(download_url, request_overrides)
+                            download_url_status['probe_status'] = self.quark_audio_link_tester.probe(download_url, request_overrides)
+                            ext = download_url_status['probe_status']['ext']
+                            if ext == 'NULL': ext = 'wav'
+                            song_info.update(dict(
+                                download_url=download_url, download_url_status=download_url_status, raw_data={'search': search_result, 'download': download_result},
+                                default_download_headers=self.quark_default_download_headers, ext=ext, file_size=download_url_status['probe_status']['file_size']
+                            ))
+                            if song_info.with_valid_download_url: break
+                        except:
+                            continue
+                # ----parse from play url
+                lyric_result = {}
+                if not song_info.with_valid_download_url:
+                    song_info = SongInfo(source=self.source)
+                    try:
+                        resp = self.get(f'https://api.qqmp3.vip/api/kw.php?rid={search_result["rid"]}&type=json&level=exhigh&lrc=true', **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                        download_url = download_result['data']['url']
+                        if not download_url: continue
+                        download_url_status = self.audio_link_tester.test(download_url, request_overrides)
+                        download_url_status['probe_status'] = self.audio_link_tester.probe(download_url, request_overrides)
+                        ext = download_url_status['probe_status']['ext']
+                        if ext == 'NULL': download_url.split('.')[-1].split('?')[0] or 'mp3'
+                        song_info.update(dict(
+                            download_url=download_url, download_url_status=download_url_status, raw_data={'search': search_result, 'download': download_result},
+                            ext=ext, file_size=download_url_status['probe_status']['file_size']
+                        ))
+                    except:
+                        continue
+                    lyric_result = copy.deepcopy(download_result)
+                else:
+                    try:
+                        resp = self.get(f'https://api.qqmp3.vip/api/kw.php?rid={search_result["rid"]}&type=json&level=exhigh&lrc=true', **request_overrides)
+                        resp.raise_for_status()
+                        lyric_result = resp2json(resp=resp)
+                    except:
+                        pass
+                if not song_info.with_valid_download_url: continue
+                # ----parse more infos
+                lyric = safeextractfromdict(lyric_result, ['data', 'lrc'], '')
+                if not lyric or '歌词获取失败' in lyric: lyric = 'NULL'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.update(dict(
+                    lyric=lyric, duration='-:-:-', song_name=legalizestring(search_result.get('name', 'NULL'), replace_null_string='NULL'),
+                    singers=legalizestring(search_result.get('artist', 'NULL'), replace_null_string='NULL'), album='NULL', identifier=search_result['rid'],
+                ))
+                # --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/mp3juice.py

@@ -0,0 +1,264 @@
+'''
+Function:
+    Implementation of MP3JuiceMusicClient: https://mp3juice.co/
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import re
+import json
+import copy
+import time
+import base64
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+from .base import BaseMusicClient
+from itertools import zip_longest
+from urllib.parse import urlencode
+from rich.progress import Progress
+from typing import List, Dict, Any, Optional
+from ..utils import legalizestring, usesearchheaderscookies, usedownloadheaderscookies, touchdir, resp2json, byte2mb, SongInfo, SongInfoUtils
+
+
+'''MP3JuiceMusicClient'''
+class MP3JuiceMusicClient(BaseMusicClient):
+    source = 'MP3JuiceMusicClient'
+    def __init__(self, **kwargs):
+        super(MP3JuiceMusicClient, 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",
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "priority": "u=1, i",
+            "referer": "https://mp3juice.co/",
+            "sec-ch-ua": "\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+        }
+        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",
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
+            "priority": "u=1, i",
+            "referer": "https://mp3juice.co/",
+            "sec-ch-ua": "\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+        }
+        self.default_headers = self.default_search_headers
+        self._initsession()
+    '''_download'''
+    @usedownloadheaderscookies
+    def _download(self, song_info: SongInfo, request_overrides: dict = None, downloaded_song_infos: list = [], progress: Progress = None, song_progress_id: int = 0):
+        request_overrides = request_overrides or {}
+        try:
+            touchdir(song_info.work_dir)
+            total_size = song_info.downloaded_contents.__sizeof__()
+            progress.update(song_progress_id, total=total_size)
+            with open(song_info.save_path, "wb") as fp:
+                fp.write(song_info.downloaded_contents)
+            progress.advance(song_progress_id, total_size)
+            progress.update(song_progress_id, description=f"{self.source}.download >>> {song_info.song_name} (Success)")
+            downloaded_song_infos.append(SongInfoUtils.fillsongtechinfo(copy.deepcopy(song_info), logger_handle=self.logger_handle, disable_print=self.disable_print))
+        except Exception as err:
+            progress.update(song_progress_id, description=f"{self.source}.download >>> {song_info.song_name} (Error: {err})")
+        return downloaded_song_infos
+    '''_decodebin'''
+    def _decodebin(self, bin_str: str) -> List[int]:
+        return [int(b, 2) for b in bin_str.split() if b]
+    '''_decodehex'''
+    def _decodehex(self, hex_str: str) -> bytes:
+        tokens = re.findall(r'0x[0-9a-fA-F]{2}', hex_str)
+        return bytes(int(h, 16) for h in tokens)
+    '''_authorization'''
+    def _authorization(self, gc: Dict[str, Any]) -> str:
+        bin_str, secret_b64 = gc["Ffw"]
+        flag_reverse, offset, max_len, case_mode = gc["LUy"]
+        hex_str = gc["Ixn"][0]
+        secret_bytes: bytes = base64.b64decode(secret_b64)
+        if flag_reverse > 0: secret_bytes = secret_bytes[::-1]
+        idx_list = self._decodebin(bin_str)
+        t: bytes = bytes(secret_bytes[i - offset] for i in idx_list)
+        if max_len > 0: t = t[:max_len]
+        if case_mode == 1: t = t.decode("latin1").lower().encode("latin1")
+        elif case_mode == 2: t = t.decode("latin1").upper().encode("latin1")
+        suffix: bytes = self._decodehex(hex_str)
+        raw: bytes = t + b"_" + suffix
+        return base64.b64encode(raw).decode("ascii")
+    '''_extractgcfromhtml'''
+    def _extractgcfromhtml(self, html: str) -> Dict[str, Any]:
+        soup = BeautifulSoup(html, "html.parser")
+        gc = self._tryextractgcnewstyle(soup)
+        if gc is not None: return gc
+        gc = self._tryextractgcoldstyle(soup)
+        if gc is not None: return gc
+        raise RuntimeError("Failed to extract gc config from HTML")
+    '''_tryextractgcnewstyle'''
+    def _tryextractgcnewstyle(self, soup) -> Optional[Dict[str, Any]]:
+        for script in soup.find_all("script"):
+            text = (script.string or script.get_text() or "").strip()
+            if "Object.defineProperty(gC" not in text: continue
+            for m in re.finditer(r"var\s+(\w+)\s*=\s*(\{.*?});", text, flags=re.S):
+                obj_literal = m.group(2)
+                try: y_dict = json.loads(obj_literal)
+                except json.JSONDecodeError: continue
+                gc = self._mapylikedicttogc(y_dict)
+                if gc is not None: return gc
+        return None
+    '''_tryextractgcoldstyle'''
+    def _tryextractgcoldstyle(self, soup) -> Dict[str, Any] | None:
+        for script in soup.find_all("script"):
+            text = script.string or ""
+            if "var gC" not in text or "dfU" not in text: continue
+            m = re.search(r"var\s+j\s*=\s*(\{.*?});", text, flags=re.S)
+            if not m: continue
+            j_obj_str = m.group(1)
+            try: j_dict = json.loads(j_obj_str)
+            except json.JSONDecodeError: continue
+            key_names = [base64.b64decode(x).decode("utf-8") for x in j_dict["dfU"]]
+            sub = {name: j_dict[name] for name in key_names}
+            gc = self._mapylikedicttogc(sub)
+            if gc is not None: return gc
+        return None
+    '''_mapylikedicttogc'''
+    def _mapylikedicttogc(self, d: Dict[str, Any]) -> Dict[str, Any] | None:
+        f_key = l_key = i_key = None
+        for k, v in d.items():
+            if not isinstance(v, list): continue
+            if len(v) == 4 and all(isinstance(x, int) for x in v): l_key = k; continue
+            if len(v) == 2 and isinstance(v[0], str):
+                if re.fullmatch(r"[01 ]+", v[0]): f_key = k; continue
+                if re.search(r"0x[0-9a-fA-F]{2}", v[0]): i_key = k; continue
+        if f_key and l_key and i_key: return {"Ffw": d[f_key], "LUy": d[l_key], "Ixn": d[i_key]}
+        return None
+    '''_getinitparamname'''
+    def _getinitparamname(self, gc: dict) -> str:
+        hex_param = gc["Ixn"][1]
+        name_bytes = self._decodehex(hex_param)
+        return name_bytes.decode("latin1")
+    '''_constructsearchurls'''
+    def _constructsearchurls(self, keyword: str, rule: dict = None, request_overrides: dict = None):
+        # init
+        rule, request_overrides = rule or {}, request_overrides or {}
+        resp = self.get('https://mp3juice.co/', **request_overrides)
+        resp.raise_for_status()
+        gc = self._extractgcfromhtml(resp.text)
+        auth_code = self._authorization(gc=gc)
+        init_param_name = self._getinitparamname(gc)
+        # search rules
+        default_rule = {'a': auth_code, 'y': 's', 'q': keyword, 't': str(int(time.time()))}
+        default_rule.update(rule)
+        default_rule['q'] = base64.b64encode(quote(keyword, safe="").encode("utf-8")).decode("utf-8")
+        # construct search urls based on search rules
+        base_url = 'https://mp3juice.co/api/v1/search?'
+        page_rule = copy.deepcopy(default_rule)
+        search_urls = [{'url': base_url + urlencode(page_rule), 'auth_code': auth_code, 'init_param_name': init_param_name}]
+        self.search_size_per_page = self.search_size_per_source
+        # return
+        return search_urls
+    '''_search'''
+    @usesearchheaderscookies
+    def _search(self, keyword: str = '', search_url: dict = None, request_overrides: dict = None, song_infos: list = [], progress: Progress = None, progress_id: int = 0):
+        # init
+        request_overrides, search_meta = request_overrides or {}, copy.deepcopy(search_url)
+        search_url, auth_code, init_param_name = search_meta['url'], search_meta['auth_code'], search_meta['init_param_name']
+        # successful
+        try:
+            # --search results
+            resp = self.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results_yt, search_results_sc = [], []
+            for item in resp2json(resp)["yt"]: item['root_source'] = 'YouTube'; search_results_yt.append(item)
+            for item in resp2json(resp)["sc"]: item['root_source'] = 'SoundCloud'; search_results_sc.append(item)
+            search_results = [x for ab in zip_longest(search_results_yt, search_results_sc) for x in ab if x is not None]
+            for search_result in search_results:
+                # --judgement for search_size
+                if self.strict_limit_search_size_per_page and len(song_infos) >= self.search_size_per_page: break
+                # --download results
+                if not isinstance(search_result, dict) or ('id' not in search_result):
+                    continue
+                song_info, download_result = SongInfo(source=self.source, root_source=search_result['root_source']), dict()
+                # ----song name and lyric
+                lyric_result, lyric = dict(), 'NULL'
+                singers_song_name = search_result.get('title', 'NULL-NULL').split('-')
+                if len(singers_song_name) == 1:
+                    singers, song_name = 'NULL', singers_song_name[0].strip()
+                elif len(singers_song_name) > 1:
+                    singers, song_name = singers_song_name[0].strip(), singers_song_name[1].strip()
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.update(dict(
+                    lyric=lyric, duration='-:-:-', song_name=legalizestring(song_name, replace_null_string='NULL'), singers=legalizestring(singers, replace_null_string='NULL'), 
+                    album='NULL', identifier=search_result['id'],
+                ))
+                # ----if in sound cloud, can be directly accessed
+                if search_result['root_source'] in ['SoundCloud']:
+                    try:
+                        download_url = f"https://eooc.cc/s/{search_result['id_base64']}/{search_result['title_base64']}/"
+                        download_url_status = self.audio_link_tester.test(download_url, request_overrides)
+                        song_info.update(dict(
+                            download_url=download_url, download_url_status=download_url_status, raw_data={'search': search_result, 'download': {}}, ext='mp3', 
+                        ))
+                        if not song_info.with_valid_download_url: continue
+                        song_info.downloaded_contents = self.get(download_url, **request_overrides).content
+                        song_info.file_size_bytes = song_info.downloaded_contents.__sizeof__()
+                        song_info.file_size = byte2mb(song_info.file_size_bytes)
+                        song_infos.append(song_info)
+                    except:
+                        continue
+                # ----init
+                params = {init_param_name: auth_code, 't': str(int(time.time()))}
+                try:
+                    resp = self.get('https://www1.eooc.cc/api/v1/init?', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    download_result['init'] = resp2json(resp=resp)
+                    convert_url = download_result['init'].get('convertURL', '')
+                    if not convert_url: continue
+                except:
+                    continue
+                # ----convert
+                convert_url = f'{convert_url}&v={search_result["id"]}&f=mp3&t={str(int(time.time()))}'
+                try:
+                    resp = self.get(convert_url, **request_overrides)
+                    resp.raise_for_status()
+                    download_result['conver'] = resp2json(resp=resp)
+                    redirect_url = download_result['conver'].get('redirectURL', '')
+                    if not redirect_url: continue
+                except:
+                    continue
+                # ----redirect
+                try:
+                    resp = self.get(redirect_url, **request_overrides)
+                    resp.raise_for_status()
+                    download_result['redirect'] = resp2json(resp=resp)
+                    download_url: str = download_result['redirect'].get('downloadURL', '')
+                    if not download_url: continue
+                except:
+                    continue
+                # ----test
+                download_url_status = self.audio_link_tester.test(download_url, request_overrides)
+                song_info.update(dict(
+                    download_url=download_url, download_url_status=download_url_status, raw_data={'search': search_result, 'download': download_result}, ext='mp3',
+                ))
+                if not song_info.with_valid_download_url: continue
+                # ----download should be directly conducted otherwise will have 404 errors
+                song_info.downloaded_contents = self.get(download_url, **request_overrides).content
+                song_info.file_size_bytes = song_info.downloaded_contents.__sizeof__()
+                song_info.file_size = byte2mb(song_info.file_size_bytes)
+                # --append to song_infos
+                song_infos.append(song_info)
+            # --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