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

musicdl/modules/sources/kugou.py

@@ -1,85 +1,138 @@
 '''
 Function:
-    酷狗音乐下载: http://www.kugou.com/
+    Implementation of KugouMusicClient: http://www.kugou.com/
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
-import time
-import requests
-from .base import Base
-from ..utils.misc import *
+import copy
+import base64
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils import legalizestring, byte2mb, resp2json, seconds2hms, usesearchheaderscookies, safeextractfromdict, SongInfo
 
 
-'''酷狗音乐下载类'''
-class kugou(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(kugou, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'kugou'
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            'keyword': keyword,
-            'page': '1',
-            'pagesize': cfg['search_size_per_source'],
-            'userid': '-1',
-            'clientver': '',
-            'platform': 'WebFilter',
-            'tag': 'em',
-            'filter': '',
-            'iscorrection': '1',
-            'privilege_filter': '0',
-            '_': str(int(time.time() * 1000))
+'''KugouMusicClient'''
+class KugouMusicClient(BaseMusicClient):
+    source = 'KugouMusicClient'
+    def __init__(self, **kwargs):
+        super(KugouMusicClient, 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.search_headers, params=params)
-        all_items = response.json()['data']['lists']
-        songinfos = []
-        for item in all_items:
-            params = {
-                'r': 'play/getdata',
-                'hash': str(item['FileHash']),
-                'album_id': str(item['AlbumID']),
-                'dfid': '1aAcF31Utj2l0ZzFPO0Yjss0',
-                'mid': 'ccbb9592c3177be2f3977ff292e0f145',
-                'platid': '4',
-                '_': str(int(time.time() * 1000))
-            }
-            response = self.session.get(self.hash_url, headers=self.hash_headers, params=params)
-            response_json = response.json()
-            if response_json.get('err_code') != 0: continue
-            download_url = response_json['data']['play_url'].replace('\\', '')
-            if not download_url: continue
-            filesize = str(round(int(response_json['data']['filesize'])/1024/1024, 2)) + 'MB'
-            ext = download_url.split('.')[-1]
-            duration = int(item.get('Duration', 0))
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['ID']),
-                'singers': filterBadCharacter(item.get('SingerName', '-')),
-                'album': filterBadCharacter(item.get('AlbumName', '-')),
-                'songname': filterBadCharacter(item.get('SongName', '-')),
-                'savedir': cfg['savedir'],
-                'savename': '_'.join([self.source, filterBadCharacter(item.get('SongName', '-'))]),
-                'download_url': download_url,
-                'filesize': filesize,
-                'ext': ext,
-                'duration': seconds2hms(duration)
-            }
-            songinfos.append(songinfo)
-        return songinfos
-    '''初始化'''
-    def __initialize(self):
-        self.search_headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36',
-            'Referer': 'https://www.kugou.com/yy/html/search.html'
+        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.hash_headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36',
-            'Referer':'https://www.kugou.com/song/'
-        }
-        self.search_url = 'http://songsearch.kugou.com/song_search_v2'
-        self.hash_url = 'https://wwwapi.kugou.com/yy/index.php'
+        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, 'page': 1, 'pagesize': 10}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'http://songsearch.kugou.com/song_search_v2?'
+        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['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']['lists']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('FileHash' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                try:
+                    resp = self.get(f"http://m.kugou.com/app/i/getSongInfo.php?cmd=playInfo&hash={search_result['FileHash']}", **request_overrides)
+                    resp.raise_for_status()
+                    download_result_default: dict = resp2json(resp)
+                except:
+                    continue
+                better_hashes = [
+                    safeextractfromdict(download_result_default, ['extra', 'highhash'], ""), safeextractfromdict(download_result_default, ['extra', 'sqhash'], ""),
+                    safeextractfromdict(download_result_default, ['extra', '320hash'], ""), safeextractfromdict(download_result_default, ['extra', '128hash'], ""),
+                ]
+                for better_hash in better_hashes:
+                    if not better_hash: continue
+                    if better_hash == search_result['FileHash']:
+                        download_result = download_result_default
+                        download_url = download_result.get('url') or download_result.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),
+                        )
+                        if song_info.with_valid_download_url: break
+                    else:
+                        try:
+                            resp = self.get(f"http://m.kugou.com/app/i/getSongInfo.php?cmd=playInfo&hash={better_hash}", **request_overrides)
+                            resp.raise_for_status()
+                            download_result: dict = resp2json(resp)
+                            download_url = download_result.get('url') or download_result.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),
+                            )
+                            if song_info.with_valid_download_url: break
+                        except:
+                            continue
+                if not song_info.with_valid_download_url: continue
+                song_info.update(dict(
+                    file_size_bytes=download_result.get('fileSize', 0), file_size=byte2mb(download_result.get('fileSize', 0)),
+                    duration_s=download_result.get('timeLength', 0), duration=seconds2hms(download_result.get('timeLength', 0)),
+                    raw_data={'search': search_result, 'download': download_result}, ext=download_result.get('extName', 'mp3'),
+                    song_name=legalizestring(search_result.get('SongName', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(search_result.get('SingerName', 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(search_result.get('AlbumName', 'NULL'), replace_null_string='NULL'),
+                    identifier=better_hash,
+                ))
+                if song_info.song_name == 'NULL': song_info.song_name = legalizestring(search_result.get('FileName', 'NULL'), replace_null_string='NULL')
+                if song_info.song_name == 'NULL': song_info.song_name = legalizestring(search_result.get('OriSongName', 'NULL'), replace_null_string='NULL')
+                # --lyric results
+                params = {'keyword': search_result.get('FileName', ''), 'duration': search_result.get('Duration', '99999'), 'hash': better_hash}
+                try:
+                    resp = self.get('http://lyrics.kugou.com/search', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result = resp2json(resp=resp)
+                    id = lyric_result['candidates'][0]['id']
+                    accesskey = lyric_result['candidates'][0]['accesskey']
+                    resp = self.get(f'http://lyrics.kugou.com/download?ver=1&client=pc&id={id}&accesskey={accesskey}&fmt=lrc&charset=utf8', **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result['lyrics.kugou.com/download'] = resp2json(resp=resp)
+                    lyric = lyric_result['lyrics.kugou.com/download']['content']
+                    lyric = base64.b64decode(lyric).decode('utf-8')
+                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/kuwo.py

@@ -1,78 +1,198 @@
 '''
 Function:
-    酷我音乐下载: http://www.kuwo.cn/
+    Implementation of KuwoMusicClient: http://www.kuwo.cn/
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
-import time
-import requests
-from .base import Base
-from ..utils.misc import *
+import copy
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils import legalizestring, resp2json, seconds2hms, usesearchheaderscookies, SongInfo
 
 
-'''酷我音乐下载类'''
-class kuwo(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(kuwo, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'kuwo'
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            'key': keyword,
-            'pn': '1',
-            'rn': cfg['search_size_per_source'],
-            'reqId': 'ffa3dc80-73c2-11ea-a715-7de8a8cc7b68'
+'''KuwoMusicClient'''
+class KuwoMusicClient(BaseMusicClient):
+    source = 'KuwoMusicClient'
+    def __init__(self, **kwargs):
+        super(KuwoMusicClient, 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()['data']['list']
-        songinfos = []
-        for item in all_items:
-            params = {
-                'format': 'mp3',
-                'rid': str(item['rid']),
-                'response': 'url',
-                'type': 'convert_url3',
-                'br': '128kmp3',
-                'from': 'web',
-                't': str(int(time.time()*1000)),
-                'reqId': 'de97aac1-73c3-11ea-a715-7de8a8cc7b68'
-            }
-            response = self.session.get(self.player_url, headers=self.headers, params=params)
-            response_json = response.json()
-            if response_json.get('code') != 200: continue
-            download_url = response_json['url']
+        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()
+    '''_parsewithflacmusicapi'''
+    def _parsewithflacmusicapi(self, search_result: dict, request_overrides: dict = None):
+        # init
+        request_overrides, song_id = request_overrides or {}, search_result['MUSICRID'].removeprefix('MUSIC_')
+        headers = copy.deepcopy(self.default_search_headers)
+        headers['origin'] = "https://flac.music.hi.cn"
+        headers['cookie'] = 'sl-session=Arb4XF1mQmlUkvJAhAps2g==; sl-challenge-server=cloud; sl_jwt_session=Ob+9V4oyQWkappXP5u8Trw==; sl_jwt_sign='
+        # parse
+        for quality in [('flac', '2000', '2000kflac'), ('mp3', '320', '320kmp3')]:
+            try:
+                data = {'platform': 'kuwo', 'songid': song_id, 'format': quality[0], 'bitrate': quality[1]}
+                resp = self.post('https://flac.music.hi.cn/ajax.php?act=getUrl', headers=headers, data=data, timeout=10, **request_overrides)
+                resp.raise_for_status()
+                download_result = resp2json(resp=resp)
+                if 'data' not in download_result: continue
+            except:
+                continue
+            download_url: str = download_result['data'].get('url', '')
             if not download_url: continue
-            filesize = '-MB'
-            ext = download_url.split('.')[-1]
-            duration = int(item.get('duration', 0))
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['rid']),
-                'singers': filterBadCharacter(item.get('artist', '-')),
-                'album': filterBadCharacter(item.get('album', '-')),
-                '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 = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36',
-            'csrf': '0HQ0UGKNAKR',
-            'Host': 'www.kuwo.cn',
-            'Referer': 'http://www.kuwo.cn/search/list',
-            'Cookie': 'kw_token=0HQ0UGKNAKR;'
+            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},
+                duration_s=download_result['data'].get('duration', 0), duration=seconds2hms(download_result['data'].get('duration', 0)),
+            )
+            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 = {
+            "vipver": "1", "client": "kt", "ft": "music", "cluster": "0", "strategy": "2012", "encoding": "utf8",
+            "rformat": "json", "mobi": "1", "issubtitle": "1", "show_copyright_off": "1", "pn": "0", "rn": "10",
+            "all": keyword,
         }
-        self.search_url = 'http://www.kuwo.cn/api/www/search/searchMusicBykeyWord'
-        self.player_url = 'http://www.kuwo.cn/url'
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'http://www.kuwo.cn/search/searchMusicBykeyWord?'
+        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['rn'] = page_size
+            page_rule['pn'] = str(int(count // page_size))
+            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)['abslist']
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('MUSICRID' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                brs = ['4000kflac', '2000kflac', 'flac', '320kmp3', '192kmp3', '128kmp3']
+                # ----try _parsewithflacmusicapi first
+                try:
+                    song_info_flac, quality_flac = self._parsewithflacmusicapi(search_result, request_overrides)
+                except:
+                    song_info_flac, quality_flac = SongInfo(source=self.source), ('mp3', '128', '128kmp3')
+                # ----try "https://mobi.kuwo.cn/mobi.s" second
+                for br_idx, br in enumerate(brs):
+                    if song_info_flac.with_valid_download_url and br_idx >= brs.index(quality_flac[-1]): song_info = song_info_flac; break
+                    try:
+                        resp = self.get(f"https://mobi.kuwo.cn/mobi.s?f=web&source=kwplayercar_ar_6.0.0.9_B_jiakong_vh.apk&from=PC&type=convert_url_with_sign&br={br}&rid={search_result['MUSICRID'].removeprefix('MUSIC_')}&&user=C_APK_guanwang_12609069939969033731", **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                        download_url = download_result['data']['url']
+                        song_info = SongInfo(
+                            source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                            ext=download_result['data'].get('format', br[-4:].removeprefix('k')), duration_s=download_result['data'].get('duration', 0), 
+                            duration=seconds2hms(download_result['data'].get('duration', 0)), raw_data={'search': search_result, 'download': download_result},
+                        )
+                        if song_info.with_valid_download_url: break
+                    except:
+                        continue
+                # ----try "https://www.kuwo.cn/api/v1/www/music/playUrl", third
+                if not song_info.with_valid_download_url:
+                    headers = {
+                        "Cookie": (
+                            "Hm_lvt_cdb524f42f0ce19b169a8071123a4797=1747998937; HMACCOUNT=3E88140C4BD6BF25; _ga=GA1.2.2122710619.1747998937; _gid=GA1.2.1827944406.1747998937; "
+                            "gtoken=RNbrzHWRp6DY; gid=d55a4884-42aa-4733-98eb-e7aaffc6122e; JSESSIONID=us1icx6617iy1k1ksiuykje71; Hm_lpvt_cdb524f42f0ce19b169a8071123a4797=1748000521; "
+                            "_gat=1; _ga_ETPBRPM9ML=GS2.2.s1747998937$o1$g1$t1748000535$j45$l0$h0; Hm_Iuvt_cdb524f42f23cer9b268564v7y735ewrq2324=jbikFazGJzBjt2bhSJGMxGfkM5zNYcis"
+                        ),
+                        "secret": "4932e2c95746126c945fe2fb3f88d3455b85b69a4fbdfa6c44b501d7dfe50cff04eb9a8e",
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0",
+                    } # TODO: implement secret generate algorithm
+                    for br in brs:
+                        params = {'mid': search_result['MUSICRID'].removeprefix('MUSIC_'), 'type': 'music', 'httpsStatus': '1', 'br': br}
+                        try:
+                            resp = self.get('https://www.kuwo.cn/api/v1/www/music/playUrl', params=params, headers=headers, **request_overrides)
+                            resp.raise_for_status()
+                            download_result = resp2json(resp=resp)
+                            download_url = download_result['data']['url']
+                            ext = download_url.split('.')[-1].split('?')[0] or 'mp3'
+                            song_info = SongInfo(
+                                source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                                ext=ext, duration_s=search_result.get('DURATION', 0), duration=seconds2hms(search_result.get('DURATION', 0)),
+                                raw_data={'search': search_result, 'download': download_result},
+                            )
+                            if song_info.with_valid_download_url: break
+                        except:
+                            continue
+                # ----try "http://antiserver.kuwo.cn/anti.s" finally (br only up to 320kmp3)
+                if not song_info.with_valid_download_url:
+                    params = {'format': 'aac|mp3', 'rid': search_result['MUSICRID'].removeprefix('MUSIC_'), 'type': 'convert_url3', 'response': 'url', 'br': '320kmp3'}
+                    try:
+                        resp = self.get('http://antiserver.kuwo.cn/anti.s', params=params, **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                        download_url = download_result['url']
+                        ext = download_url.split('.')[-1].split('?')[0] or 'mp3'
+                        song_info = SongInfo(
+                            source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides),
+                            ext=ext, duration_s=search_result.get('DURATION', 0), duration=seconds2hms(search_result.get('DURATION', 0)),
+                            raw_data={'search': search_result, 'download': download_result},
+                        )
+                    except:
+                        continue
+                if not song_info.with_valid_download_url: continue
+                # ----parse other information
+                song_info.update(dict(
+                    song_name=legalizestring(search_result.get('SONGNAME', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(search_result.get('ARTIST', 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(search_result.get('ALBUM', 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['MUSICRID'],
+                ))
+                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
+                # --lyric results
+                params = {'musicId': search_result['MUSICRID'].removeprefix('MUSIC_'), 'httpsStatus': '1'}
+                try:
+                    resp = self.get('http://m.kuwo.cn/newh5/singles/songinfoandlrc', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result: dict = resp2json(resp)
+                    lyric = lyric_result.get('data', {}).get('lrclist', []) or 'NULL'
+                except:
+                    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/lizhi.py

@@ -0,0 +1,107 @@
+'''
+Function:
+    Implementation of LizhiMusicClient: https://www.lizhi.fm/
+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, seconds2hms, usesearchheaderscookies, SongInfo
+
+
+'''LizhiMusicClient'''
+class LizhiMusicClient(BaseMusicClient):
+    source = 'LizhiMusicClient'
+    def __init__(self, **kwargs):
+        super(LizhiMusicClient, self).__init__(**kwargs)
+        self.default_search_headers = {
+            'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1',
+            'Referer': 'https://m.lizhi.fm',
+        }
+        self.default_download_headers = {
+            'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1',
+        }
+        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 = {'deviceId': "h5-b6ef91a9-3dbb-c716-1fdd-43ba08851150", "keywords": keyword, "page": 1, "receiptData": ""}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://m.lizhi.fm/vodapi/search/voice?'
+        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)
+            if len(search_urls) > 0:
+                try:
+                    resp = self.get(search_urls[-1], **request_overrides)
+                    receipt_data = resp2json(resp)['receiptData']
+                except:
+                    receipt_data = ""
+                page_rule['receiptData'] = receipt_data
+            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']
+            for search_result in search_results:
+                # --download results
+                if (not isinstance(search_result, dict)) or ('userInfo' not in search_result) or ('voiceInfo' not in search_result) or ('voicePlayProperty' not in search_result) or ('voiceId' not in search_result['voiceInfo']):
+                    continue
+                song_info = SongInfo(source=self.source)
+                download_url = search_result['voicePlayProperty'].get('trackUrl', '')
+                if not download_url: continue
+                for quality in ['_ud.mp3', '_hd.mp3', '_sd.m4a']:
+                    download_url: str = download_url[:-7] + quality
+                    ext = download_url.split('.')[-1].split('?')[0] or 'mp3'
+                    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': {}},
+                    )
+                    if song_info.with_valid_download_url: break
+                if not song_info.with_valid_download_url: continue
+                song_info.update(
+                    duration=seconds2hms(search_result['voiceInfo'].get('duration', 0)), duration_s=search_result['voiceInfo'].get('duration', 0)
+                )
+                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
+                lyric_result, lyric = dict(), 'NULL'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.update(dict(
+                    lyric=lyric, song_name=legalizestring(search_result['voiceInfo'].get('name', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(search_result['userInfo'].get('name', 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(search_result['voiceInfo'].get('lableName', 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['voiceInfo']['voiceId'],
+                ))
+                # --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