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

musicdl/modules/sources/bilibili.py

@@ -0,0 +1,118 @@
+'''
+Function:
+    Implementation of BilibiliMusicClient: https://www.bilibili.com/audio/home/?type=9
+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, resp2json, usesearchheaderscookies, seconds2hms, safeextractfromdict, SongInfo
+
+
+'''BilibiliMusicClient'''
+class BilibiliMusicClient(BaseMusicClient):
+    source = 'BilibiliMusicClient'
+    def __init__(self, **kwargs):
+        super(BilibiliMusicClient, 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/121.0.0.0 Safari/537.36 Edg/121.0.0.0",
+            "Sec-Ch-Ua": '"Not A(Brand";v="99", "Microsoft Edge";v="121", "Chromium";v="121"', "Sec-Ch-Ua-Mobile": "?0", "Sec-Ch-Ua-Platform": '"Windows"',
+            "Sec-Fetch-Dest": "document", "Sec-Fetch-Mode": "navigate", "Sec-Fetch-Site": "none", "Sec-Fetch-User": "?1", "Accept-Encoding": "gzip, deflate",
+            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6,zh-TW;q=0.5",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1", "Referer": "https://www.bilibili.com/",
+        }
+        self.default_download_headers = copy.deepcopy(self.default_search_headers)
+        self.default_headers = self.default_search_headers
+        if not self.default_cookies:
+            self.default_search_cookies = {
+                "buvid3": "2E109C72-251F-3827-FA8E-921FA0D7EC5291319infoc", "b_nut": "1676213591", "i-wanna-go-back": "-1", "_uuid": "2B2D7A6C-8310C-1167-F548-2F1095A6E93F290252infoc",
+                "buvid4": "31696B5F-BB23-8F2B-3310-8B3C55FB49D491966-023021222-WcoPnBbwgLUAZ6TJuAUN8Q%3D%3D", "CURRENT_FNVAL": "4048", "DedeUserID": "520271156",
+                "DedeUserID__ckMd5": "66450f2302095cc5", "nostalgia_conf": "-1", "rpdid": "|(JY))RmR~|u0J'uY~YkuJ~Ru", "buvid_fp_plain": "undefined", "b_ut": "5",
+                "hit-dyn-v2": "1", "LIVE_BUVID": "AUTO8716766313471956", "hit-new-style-dyn": "1", "CURRENT_PID": "418c8490-cadb-11ed-b23b-dd640f2e1c14",
+                "FEED_LIVE_VERSION": "V8", "header_theme_version": "CLOSE", "CURRENT_QUALITY": "80", "enable_web_push": "DISABLE", "buvid_fp": "52ad4773acad74caefdb23875d5217cd",
+                "PVID": "1", "home_feed_column": "5", "SESSDATA": "8036f42c%2C1719895843%2C19675%2A12CjATThdxG8TyQ2panBpBQcmT0gDKjexwc-zXNGiMnIQ2I9oLVmOiE9YkLao2_aawEhoSVlhGY05PVjVkZWM0T042Z2hZRXBOdElYWXhJa3RpVmZ0M3NvcWw1N0tPcGRVSmRoOVNQZnNHT1JHS05yR1Y1MUFLX3RXeXVJa3NjbEVBQkUxRVN6RFRRIIEC",
+                "bili_jct": "4c583b61b86b16d812a7804078828688", "sid": "8dt1ioao", "bili_ticket": "eyJhbGciOiJIUzI1NiIsImtpZCI6InMwMyIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MDQ2MjUzNjAsImlhdCI6MTcwNDM2NjEwMCwicGx0IjotMX0.4E-V4K2y452cy6eexwY2x_q3-xgcNF2qtugddiuF8d4",
+                "bili_ticket_expires": "1704625300", "fingerprint": "847f1839b443252d91ff0df7465fa8d9", "browser_resolution": "1912-924", "bp_video_offset_520271156": "883089613008142344",
+            }
+            self.default_cookies = self.default_search_cookies
+            self.default_download_cookies = self.default_search_cookies
+        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 = {
+            '__refresh__': 'true', '_extra': '', 'page': 1, 'page_size': self.search_size_per_page, 'platform': 'pc', 'highlight': '1',
+            'context': '', 'single_column': '0', 'keyword': keyword, 'category_id': '', 'search_type': 'video', 'dynamic_offset': '0',
+            'preload': 'true', 'com2co': 'true'
+        }
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://api.bilibili.com/x/web-interface/search/type?'
+        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['page_size'] = page_size
+            page_rule['page'] = 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 {}
+        # successful
+        try:
+            # --search results
+            resp = self.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)['data']['result']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('id' not in search_result) or ('bvid' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                try:
+                    resp = self.get(f"https://api.bilibili.com/x/web-interface/view?bvid={search_result['bvid']}", **request_overrides)
+                    resp.raise_for_status()
+                    pages = resp2json(resp=resp)['data']['pages']
+                    episodes = [(page["cid"], page["part"]) for page in pages] # we only pick the first one
+                    cid, episode_name = episodes[0]
+                    resp = self.get(f"https://api.bilibili.com/x/player/playurl?fnval=16&bvid={search_result['bvid']}&cid={cid}")
+                    download_result = resp2json(resp=resp)
+                    audios_sorted = sorted(download_result["data"]["dash"]["audio"], key=lambda x: x.get("bandwidth", 0), reverse=True)
+                except:
+                    continue
+                download_url = audios_sorted[0].get('baseUrl') or audios_sorted[0].get('base_url') or audios_sorted[0].get('backupUrl') or audios_sorted[0].get('backup_url')
+                if not download_url: continue
+                if isinstance(download_url, list): download_url = download_url[0]
+                song_info = SongInfo(
+                    source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                    ext='m4a', raw_data={'search': search_result, 'download': download_result, 'lyric': {}}, lyric='NULL', duration_s=download_result["data"]["dash"].get('duration', 0),
+                    duration=seconds2hms(download_result["data"]["dash"].get('duration', 0)), file_size='NULL', song_name=legalizestring(episode_name, replace_null_string='NULL'),
+                    singers=legalizestring(safeextractfromdict(search_result, ['author'], ""), replace_null_string='NULL'), album='NULL', identifier=f"{search_result['bvid']}_{cid}"
+                )
+                if not song_info.with_valid_download_url: continue
+                song_info.download_url_status['probe_status'] = self.audio_link_tester.probe(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
+                # --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/buguyy.py

@@ -0,0 +1,148 @@
+'''
+Function:
+    Implementation of BuguyyMusicClient: https://buguyy.top/
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import re
+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
+
+
+'''BuguyyMusicClient'''
+class BuguyyMusicClient(BaseMusicClient):
+    source = 'BuguyyMusicClient'
+    def __init__(self, **kwargs):
+        super(BuguyyMusicClient, 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": "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",
+            "origin": "https://buguyy.top",
+            "priority": "u=1, i",
+            "referer": "https://buguyy.top/",
+            "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}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://a.buguyy.top/newapi/search.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, verify=False, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp=resp)['data']['list']
+            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)
+                # ----parse from quark links
+                if self.quark_parser_config.get('cookies'):
+                    quark_download_urls = [search_result.get('downurl', ''), search_result.get('ktmdownurl', '')]
+                    for quark_download_url in quark_download_urls:
+                        song_info = SongInfo(source=self.source)
+                        try:
+                            m = re.search(r"WAV#(https?://[^#]+)", quark_download_url)
+                            quark_wav_download_url = m.group(1)
+                            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://a.buguyy.top/newapi/geturl2.php?id={search_result["id"]}', verify=False, **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                        download_url = safeextractfromdict(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://a.buguyy.top/newapi/geturl2.php?id={search_result["id"]}', verify=False, **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
+                try:
+                    duration = '{:02d}:{:02d}:{:02d}'.format(*([0,0,0] + list(map(int, re.findall(r'\d+', safeextractfromdict(lyric_result, ['data', 'duration'], '')))))[-3:])
+                    if duration == '00:00:00': duration = '-:-:-'
+                except:
+                    duration = '-:-:-'
+                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=duration, song_name=legalizestring(search_result.get('title', 'NULL'), replace_null_string='NULL'),
+                    singers=legalizestring(search_result.get('singer', 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(safeextractfromdict(lyric_result, ['data', 'album'], ''), replace_null_string='NULL'),
+                    identifier=search_result['id'],
+                ))
+                # --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/fangpi.py

@@ -0,0 +1,153 @@
+'''
+Function:
+    Implementation of FangpiMusicClient: https://www.fangpi.net/
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import re
+import json_repair
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from .base import BaseMusicClient
+from rich.progress import Progress
+from ..utils import legalizestring, usesearchheaderscookies, resp2json, safeextractfromdict, SongInfo, QuarkParser
+
+
+'''FangpiMusicClient'''
+class FangpiMusicClient(BaseMusicClient):
+    source = 'FangpiMusicClient'
+    def __init__(self, **kwargs):
+        super(FangpiMusicClient, 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 = {
+            '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_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 {}
+        # construct search urls
+        search_urls = [f'https://www.fangpi.net/s/{keyword}']
+        self.search_size_per_page = self.search_size_per_source
+        # return
+        return search_urls
+    '''_parsesearchresultsfromhtml'''
+    def _parsesearchresultsfromhtml(self, html_text: str):
+        soup = BeautifulSoup(html_text, "lxml")
+        search_results, base_url = [], "https://www.fangpi.net"
+        for row in soup.select('div.card.mb-1 div.card-text > div.row'):
+            link = row.select_one('a.music-link')
+            if not link: continue
+            href = link.get('href', '').strip()
+            if not href: continue
+            url = urljoin(base_url, href)
+            title_span = link.select_one('.music-title span')
+            if title_span: title = title_span.get_text(strip=True)
+            else: title = link.get_text(strip=True)
+            artist_tag = link.find('small')
+            artist = artist_tag.get_text(strip=True) if artist_tag else ""
+            search_results.append({"title": title, "artist": artist, "url": url})
+        return search_results
+    '''_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 = self._parsesearchresultsfromhtml(resp.text)
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('url' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                # ----fetch basic information
+                try:
+                    resp = self.get(search_result['url'], **request_overrides)
+                    resp.raise_for_status()
+                    soup = BeautifulSoup(resp.text, "lxml")
+                    script_tag = soup.find("script", string=re.compile(r"window\.appData"))
+                    if script_tag is None: continue
+                    js_text: str = script_tag.string
+                    m = re.search(r"window\.appData\s*=\s*(\{.*?\})\s*;", js_text, re.S)
+                    if not m: continue
+                    download_result = json_repair.loads(m.group(1))
+                except:
+                    continue
+                # ----parse from quark links
+                if self.quark_parser_config.get('cookies'):
+                    quark_download_urls = download_result.get('mp3_extra_urls', [])
+                    for quark_download_url in quark_download_urls:
+                        song_info = SongInfo(source=self.source)
+                        try:
+                            quark_wav_download_url = quark_download_url['share_link']
+                            download_result['quark_parse_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 = 'mp3'
+                            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
+                if not song_info.with_valid_download_url:
+                    if 'play_id' not in download_result or not download_result['play_id']: continue
+                    song_info = SongInfo(source=self.source)
+                    try:
+                        resp = self.post('https://www.fangpi.net/api/play-url', json={'id': download_result['play_id']}, **request_overrides)
+                        resp.raise_for_status()
+                        download_result['api/play-url'] = resp2json(resp=resp)
+                        download_url = safeextractfromdict(download_result['api/play-url'], ['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
+                if not song_info.with_valid_download_url: continue
+                # ----parse more infos
+                try:
+                    lrc_div = soup.find("div", id="content-lrc")
+                    lyric, lyric_result = lrc_div.get_text("\n", strip=True), {'lrc_div': str(lrc_div)}
+                except:
+                    lyric, lyric_result = 'NULL', {}
+                format_duration = lambda d: "{:02}:{:02}:{:02}".format(*([0] * (3 - len(d.split(":"))) + list(map(int, d.split(":")))))
+                duration = format_duration(download_result.get('mp3_duration', '00:00:00') or '00:00:00')
+                if duration == '00:00:00': duration = '-:-:-'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.update(dict(
+                    lyric=lyric, duration=duration, song_name=legalizestring(download_result.get('mp3_title', 'NULL'), replace_null_string='NULL'),
+                    singers=legalizestring(download_result.get('mp3_author', 'NULL'), replace_null_string='NULL'), album='NULL',
+                    identifier=download_result.get('play_id') or song_info.download_url,
+                ))
+                # --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/fivesing.py

@@ -0,0 +1,108 @@
+'''
+Function:
+    Implementation of FiveSingMusicClient: https://5sing.kugou.com/index.html
+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, byte2mb, resp2json, usesearchheaderscookies, SongInfo
+
+
+'''FiveSingMusicClient'''
+class FiveSingMusicClient(BaseMusicClient):
+    source = 'FiveSingMusicClient'
+    def __init__(self, **kwargs):
+        super(FiveSingMusicClient, 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',
+        }
+        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, 'sort': 1, 'page': 1, 'filter': 0, 'type': 0}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'http://search.5sing.kugou.com/home/json?'
+        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['page'] = 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 {}
+        # successful
+        try:
+            # --search results
+            resp = self.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)['list']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('songId' not in search_result) or ('typeEname' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                params = {'songid': str(search_result['songId']), 'songtype': search_result['typeEname']}
+                try:
+                    resp = self.get('http://mobileapi.5sing.kugou.com/song/getSongUrl', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    download_result: dict = resp2json(resp)
+                    if download_result['code'] not in [1000, '1000']: continue
+                except:
+                    continue
+                data: dict = download_result.get('data', {})
+                for quality in ['sq', 'hq', 'lq']:
+                    download_url = data.get(f'{quality}url', '').strip() or data.get(f'{quality}url_backup', '').strip()
+                    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 = data.get(f'{quality}ext', 'mp3').strip() or 'mp3', file_size_bytes=data.get(f'{quality}size', 0),
+                        file_size = byte2mb(data.get(f'{quality}size', 0)), raw_data={'search': search_result, 'download': download_result},
+                    )
+                    if song_info.with_valid_download_url: break
+                if not song_info.with_valid_download_url: continue
+                # --lyric results
+                params = {'songid': str(search_result['songId']), 'songtype': search_result['typeEname'], 'songfields': '', 'userfields': ''}
+                try:
+                    resp = self.get('http://mobileapi.5sing.kugou.com/song/newget', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result: dict = resp2json(resp)
+                    lyric = str(lyric_result.get('data', {}).get('dynamicWords', 'NULL')).strip() or 'NULL'
+                except:
+                    lyric_result, lyric = {}, 'NULL'
+                # --update song_info
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.update(dict(
+                    song_name=legalizestring(search_result.get('songName', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(search_result.get('singer', 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(lyric_result.get('data', {}).get('albumName', 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['songId'], lyric=lyric, duration='-:-:-',
+                ))
+                # --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