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

musicdl/modules/sources/__init__.py

@@ -1,10 +1,41 @@
-'''import all'''
-from .qq import qq
-from .kuwo import kuwo
-from .migu import migu
-from .joox import joox
-from .xiami import xiami
-from .kugou import kugou
-from .netease import netease
-from .qianqian import qianqian
-from .baiduFlac import baiduFlac
+'''initialize'''
+from .qq import QQMusicClient
+from .mitu import MituMusicClient
+from .joox import JooxMusicClient
+from .base import BaseMusicClient
+from .kuwo import KuwoMusicClient
+from .migu import MiguMusicClient
+from .tidal import TIDALMusicClient
+from .lizhi import LizhiMusicClient
+from .apple import AppleMusicClient
+from .kugou import KugouMusicClient
+from .fangpi import FangpiMusicClient
+from .buguyy import BuguyyMusicClient
+from ..utils import BaseModuleBuilder
+from .netease import NeteaseMusicClient
+from .youtube import YouTubeMusicClient
+from .gequbao import GequbaoMusicClient
+from .jamendo import JamendoMusicClient
+from ..common import GDStudioMusicClient
+from .mp3juice import MP3JuiceMusicClient
+from .fivesing import FiveSingMusicClient
+from .qianqian import QianqianMusicClient
+from .ximalaya import XimalayaMusicClient
+from .bilibili import BilibiliMusicClient
+from .yinyuedao import YinyuedaoMusicClient
+
+
+'''MusicClientBuilder'''
+class MusicClientBuilder(BaseModuleBuilder):
+    REGISTERED_MODULES = {
+        'QQMusicClient': QQMusicClient, 'MituMusicClient': MituMusicClient, 'BuguyyMusicClient': BuguyyMusicClient, 'GequbaoMusicClient': GequbaoMusicClient,
+        'MP3JuiceMusicClient': MP3JuiceMusicClient, 'YinyuedaoMusicClient': YinyuedaoMusicClient, 'LizhiMusicClient': LizhiMusicClient, 'XimalayaMusicClient': XimalayaMusicClient,
+        'JooxMusicClient': JooxMusicClient, 'KuwoMusicClient': KuwoMusicClient, 'KugouMusicClient': KugouMusicClient, 'FiveSingMusicClient': FiveSingMusicClient,
+        'QianqianMusicClient': QianqianMusicClient, 'MiguMusicClient': MiguMusicClient, 'NeteaseMusicClient': NeteaseMusicClient, 'YouTubeMusicClient': YouTubeMusicClient,
+        'TIDALMusicClient': TIDALMusicClient, 'AppleMusicClient': AppleMusicClient, 'FangpiMusicClient': FangpiMusicClient, 'GDStudioMusicClient': GDStudioMusicClient,
+        'JamendoMusicClient': JamendoMusicClient, 'BilibiliMusicClient': BilibiliMusicClient,
+    }
+
+
+'''BuildMusicClient'''
+BuildMusicClient = MusicClientBuilder().build

musicdl/modules/sources/apple.py

@@ -0,0 +1,207 @@
+'''
+Function:
+    Implementation of AppleMusicClient: https://music.apple.com/{geo}/new
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import re
+import os
+import copy
+import shutil
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils.appleutils import AppleMusicClientUtils, DownloadItem
+from ..utils import touchdir, legalizestring, resp2json, seconds2hms, usesearchheaderscookies, safeextractfromdict, usedownloadheaderscookies, SongInfo, SongInfoUtils
+
+
+'''AppleMusicClient'''
+class AppleMusicClient(BaseMusicClient):
+    source = 'AppleMusicClient'
+    def __init__(self, **kwargs):
+        super(AppleMusicClient, self).__init__(**kwargs)
+        # headers setting
+        self.default_search_headers = {
+            "authorization": f"Bearer {self._fetchtoken()}",
+            "accept": "*/*",
+            "accept-language": "en-US",
+            "origin": "https://music.apple.com",
+            "priority": "u=1, i",
+            "referer": "https://music.apple.com",
+            "sec-ch-ua": '"Google Chrome";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+            "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/137.0.0.0 Safari/537.36",
+        }
+        self.default_download_headers = copy.deepcopy(self.default_search_headers)
+        self.default_headers = self.default_search_headers
+        # account info (whether a VIP user)
+        self.account_info = {}
+        if not self.default_cookies or 'media-user-token' not in self.default_cookies: 
+            self.logger_handle.warning(f'{self.source}.__init__ >>> "media-user-token" is not configured, so song downloads are restricted and only the preview portion of the track can be downloaded.')
+        else:
+            self.account_info = self._fetchaccountinfo()
+        # init session
+        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):
+        if isinstance(song_info.download_url, str): return super()._download(song_info=song_info, request_overrides=request_overrides, downloaded_song_infos=downloaded_song_infos, progress=progress, song_progress_id=song_progress_id)
+        request_overrides = request_overrides or {}
+        try:
+            touchdir(song_info.work_dir)
+            tmp_dir = os.path.join(self.work_dir.replace(' ', ''), self.source.replace(' ', ''), song_info.identifier.replace(' ', '')) # replace space to avoid bugs
+            touchdir(tmp_dir)
+            download_item: DownloadItem = song_info.download_url
+            download_item.final_path = os.path.join(tmp_dir, f'{song_info.identifier}.{song_info.ext}')
+            progress.update(song_progress_id, total=1)
+            progress.update(song_progress_id, description=f"{self.source}.download >>> {song_info.song_name} (Downloading)")
+            AppleMusicClientUtils.download(download_item, work_dir=tmp_dir)
+            shutil.move(download_item.final_path, song_info.save_path)
+            progress.update(song_progress_id, total=os.path.getsize(song_info.save_path))
+            progress.advance(song_progress_id, os.path.getsize(song_info.save_path))
+            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))
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+        except Exception as err:
+            progress.update(song_progress_id, description=f"{self.source}.download >>> {song_info.song_name} (Error: {err})")
+        return downloaded_song_infos
+    '''_fetchtoken'''
+    def _fetchtoken(self, request_overrides: dict = None):
+        request_overrides = request_overrides or {}
+        resp = self.get('https://music.apple.com', **request_overrides)
+        resp.raise_for_status()
+        home_page = resp.text
+        index_js_uri_match = re.search(r"/(assets/index-legacy[~-][^/\"]+\.js)", home_page)
+        index_js_uri = index_js_uri_match.group(1)
+        resp = self.get(f"https://music.apple.com/{index_js_uri}", **request_overrides)
+        resp.raise_for_status()
+        index_js_page = resp.text
+        token_match = re.search('(?=eyJh)(.*?)(?=")', index_js_page)
+        token = token_match.group(1)
+        return token
+    '''_fetchaccountinfo'''
+    def _fetchaccountinfo(self, request_overrides: dict = None):
+        if self.account_info or (not self.default_cookies or 'media-user-token' not in self.default_cookies): return self.account_info
+        request_overrides = request_overrides or {}
+        resp = self.get('https://amp-api.music.apple.com/v1/me/account?meta=subscription', **request_overrides)
+        resp.raise_for_status()
+        account_info = resp2json(resp=resp)
+        self.account_info = account_info
+        return self.account_info
+    '''_constructsearchurls'''
+    def _constructsearchurls(self, keyword: str, rule: dict = None, request_overrides: dict = None):
+        # init
+        rule, request_overrides = rule or {}, request_overrides or {}
+        account_info = self._fetchaccountinfo(request_overrides=request_overrides)
+        geo = safeextractfromdict(account_info, ['meta', 'subscription', 'storefront'], 'us')
+        # search rules
+        default_rule = {
+            "groups": "song", "l": "en-US", "offset": "0", "term": keyword, "types": "activities,albums,apple-curators,artists,curators,editorial-items,music-movies,music-videos,playlists,record-labels,songs,stations,tv-episodes,uploaded-videos",
+            "art[url]": "f", "extend": "artistUrl", "fields[albums]": "artistName,artistUrl,artwork,contentRating,editorialArtwork,editorialNotes,name,playParams,releaseDate,url,trackCount", "fields[artists]": "url,name,artwork",
+            "format[resources]": "map", "include[editorial-items]": "contents", "include[songs]": "artists", "limit": "10", "omit[resource]": "autos", "platform": "web", "relate[albums]": "artists", "relate[editorial-items]": "contents",
+            "relate[songs]": "albums", "types": "activities,albums,apple-curators,artists,curators,music-movies,music-videos,playlists,songs,stations,tv-episodes,uploaded-videos", "with": "lyrics,serverBubbles", 
+        }
+        default_rule.update(rule)
+        geo = default_rule.pop('geo', geo)
+        # construct search urls based on search rules
+        base_url = f'https://amp-api-edge.music.apple.com/v1/catalog/{geo}/search?'
+        search_urls, page_size, count = [], self.search_size_per_page, 0
+        while self.search_size_per_source > count:
+            page_rule = copy.deepcopy(default_rule)
+            page_rule['limit'] = page_size
+            page_rule['offset'] = str(int(count // page_size) * page_size)
+            search_urls.append(base_url + urlencode(page_rule))
+            count += page_size
+        # return
+        return search_urls
+    '''_fetchlicenseexchange'''
+    def _fetchlicenseexchange(self, track_id: str, track_uri: str, challenge: str, key_system: str = "com.widevine.alpha", request_overrides: dict = None):
+        request_overrides = request_overrides or {}
+        json_data = {"challenge": challenge, "key-system": key_system, "uri": track_uri, "adamId": track_id, "isLibrary": False, "user-initiated": True}
+        resp = self.post("https://play.itunes.apple.com/WebObjects/MZPlay.woa/wa/acquireWebPlaybackLicense", json=json_data, **request_overrides)
+        resp.raise_for_status()
+        license_exchange = resp2json(resp)
+        return license_exchange
+    '''_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: dict = resp2json(resp)['resources']['songs']
+            for song_key, search_result in search_results.items():
+                # --download results
+                if not isinstance(search_result, dict) or ('id' not in search_result):
+                    continue
+                search_result['song_key'] = song_key
+                song_info = SongInfo(source=self.source)
+                # ----non-vip users
+                if not self.default_cookies or 'media-user-token' not in self.default_cookies:
+                    download_result = safeextractfromdict(search_result, ['attributes', 'previews', 0], {})
+                    download_url: str = download_result.get('url')
+                    if not download_url: continue
+                    song_info = SongInfo(
+                        source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides), 
+                        ext=download_url.split('.')[-1].split('?')[0], raw_data={'search': search_result, 'download': download_result, 'lyric': {}}, lyric='NULL',
+                    )
+                    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
+                # ----vip users
+                else:
+                    account_info = self._fetchaccountinfo(request_overrides=request_overrides)
+                    geo = safeextractfromdict(account_info, ['meta', 'subscription', 'storefront'], 'us')
+                    params = {"extend": "extendedAssetUrls", "include": "lyrics,albums"}
+                    try:
+                        resp = self.get(f'https://amp-api.music.apple.com/v1/catalog/{geo}/songs/{search_result["id"]}', params=params, **request_overrides)
+                        resp.raise_for_status()
+                        download_result = resp2json(resp=resp)
+                        song_metadata = download_result['data'][0]
+                        resp = self.post("https://play.itunes.apple.com/WebObjects/MZPlay.woa/wa/webPlayback", json={"salableAdamId": search_result["id"], "language": "en-US"}, **request_overrides)
+                        resp.raise_for_status()
+                        webplayback = resp2json(resp=resp)
+                        download_result['webplayback'] = webplayback
+                    except:
+                        continue
+                    download_item: DownloadItem = AppleMusicClientUtils.getsongdownloaditem(song_metadata=song_metadata, webplayback=webplayback, get_license_exchange_func=self._fetchlicenseexchange, request_overrides=request_overrides)
+                    lyric_result, lyric = download_item.lyrics_results if download_item.lyrics_results else {}, download_item.lyrics.synced if download_item.lyrics.synced else 'NULL'
+                    download_url, ext = download_item, download_item.stream_info.file_format.value
+                    song_info = SongInfo(
+                        source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_item.stream_info.audio_track.stream_url, request_overrides), 
+                        ext=ext, raw_data={'search': search_result, 'download': download_result, 'lyric': lyric_result}, lyric=lyric,
+                    )
+                    song_info.download_url_status['probe_status'] = self.audio_link_tester.probe(download_item.stream_info.audio_track.stream_url, request_overrides)
+                    file_size = 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 not song_info.with_valid_download_url: continue
+                song_info.update(
+                    duration=seconds2hms(float(safeextractfromdict(search_result, ['attributes', 'durationInMillis'], '0')) / 1000),
+                    song_name=legalizestring(safeextractfromdict(search_result, ['attributes', 'name'], 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(safeextractfromdict(search_result, ['attributes', 'artistName'], 'NULL'), replace_null_string='NULL'), 
+                    album=legalizestring(safeextractfromdict(search_result, ['attributes', 'albumName'], 'NULL'), 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/base.py

@@ -1,38 +1,266 @@
 '''
 Function:
-    各平台音乐下载器基类
+    Implementation of BaseMusicClient
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
+import os
+import copy
+import pickle
 import requests
-from ..utils.downloader import Downloader
+from rich.text import Text
+from itertools import chain
+from datetime import datetime
+from rich.progress import Task
+from freeproxy import freeproxy
+from fake_useragent import UserAgent
+from pathvalidate import sanitize_filepath
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from ..utils import (
+    LoggerHandle, AudioLinkTester, SongInfo, SongInfoUtils, touchdir, usedownloadheaderscookies, usesearchheaderscookies, cookies2dict, cookies2string
+)
+from rich.progress import (
+    Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn, DownloadColumn, TransferSpeedColumn, 
+    TimeRemainingColumn, MofNCompleteColumn, ProgressColumn,
+)
 
 
-'''音乐下载器基类'''
-class Base():
-    def __init__(self, config, logger_handle, **kwargs):
-        self.source = None
+'''AudioAwareColumn'''
+class AudioAwareColumn(ProgressColumn):
+    def __init__(self):
+        super(AudioAwareColumn, self).__init__()
+        self._download_col = DownloadColumn()
+    '''render'''
+    def render(self, task: Task):
+        kind = task.fields.get("kind", "download")
+        if kind == "overall":
+            completed = int(task.completed)
+            total = int(task.total) if task.total is not None else 0
+            return Text(f"{completed}/{total} audios")
+        else:
+            return self._download_col.render(task)
+
+
+'''BaseMusicClient'''
+class BaseMusicClient():
+    source = 'BaseMusicClient'
+    def __init__(self, search_size_per_source: int = 5, auto_set_proxies: bool = False, random_update_ua: bool = False, max_retries: int = 5, maintain_session: bool = False, 
+                 logger_handle: LoggerHandle = None, disable_print: bool = False, work_dir: str = 'musicdl_outputs', proxy_sources: list = None, default_search_cookies: dict | str = None,
+                 default_download_cookies: dict | str = None, search_size_per_page: int = 10, strict_limit_search_size_per_page: bool = True, quark_parser_config: dict = None):
+        # set up work dir
+        touchdir(work_dir)
+        # set attributes
+        self.search_size_per_source = search_size_per_source
+        self.auto_set_proxies = auto_set_proxies
+        self.random_update_ua = random_update_ua
+        self.max_retries = max_retries
+        self.maintain_session = maintain_session
+        self.logger_handle = logger_handle if logger_handle else LoggerHandle()
+        self.disable_print = disable_print
+        self.work_dir = work_dir
+        self.proxy_sources = proxy_sources
+        self.default_search_cookies = cookies2dict(default_search_cookies)
+        self.default_download_cookies = cookies2dict(default_download_cookies)
+        self.default_cookies = self.default_search_cookies
+        self.search_size_per_page = min(search_size_per_source, search_size_per_page)
+        self.strict_limit_search_size_per_page = strict_limit_search_size_per_page
+        self.quark_parser_config = quark_parser_config or {}
+        # init requests.Session
+        self.default_search_headers = {'User-Agent': UserAgent().random}
+        self.default_download_headers = {'User-Agent': UserAgent().random}
+        self.quark_default_download_headers = {
+            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36 Core/1.94.225.400 QQBrowser/12.2.5544.400',
+            'origin': 'https://pan.quark.cn', 'referer': 'https://pan.quark.cn/', 'accept-language': 'zh-CN,zh;q=0.9', 'cookie': cookies2string(self.quark_parser_config.get('cookies', '')),
+        }
+        self.quark_default_download_cookies = {} # placeholder, useless now
+        self.default_headers = self.default_search_headers
+        self._initsession()
+        # proxied_session_client
+        self.proxied_session_client = freeproxy.ProxiedSessionClient(
+            proxy_sources=['ProxiflyProxiedSession'] if proxy_sources is None else proxy_sources, 
+            disable_print=True
+        ) if auto_set_proxies else None
+    '''_initsession'''
+    def _initsession(self):
         self.session = requests.Session()
-        self.session.proxies.update(config['proxies'])
-        self.config = config
-        self.logger_handle = logger_handle
-    '''歌曲搜索'''
-    def search(self, keyword):
-        raise NotImplementedError('not be implemented...')
-    '''歌曲下载'''
-    def download(self, songinfos):
-        for songinfo in songinfos:
-            self.logger_handle.info('正在从%s下载 ——> %s...' % (self.source, songinfo['savename']))
-            task = Downloader(songinfo, self.session)
-            if task.start():
-                self.logger_handle.info('成功从%s下载到了 ——> %s...' % (self.source, songinfo['savename']))
+        self.session.headers = self.default_headers
+        self.audio_link_tester = AudioLinkTester(headers=copy.deepcopy(self.default_download_headers), cookies=copy.deepcopy(self.default_download_cookies))
+        self.quark_audio_link_tester = AudioLinkTester(headers=copy.deepcopy(self.quark_default_download_headers), cookies=copy.deepcopy(self.quark_default_download_cookies))
+    '''_constructsearchurls'''
+    def _constructsearchurls(self, keyword: str, rule: dict = None, request_overrides: dict = None):
+        raise NotImplementedError('not to be implemented')
+    '''_constructuniqueworkdir'''
+    def _constructuniqueworkdir(self, keyword: str):
+        time_stamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+        work_dir = os.path.join(self.work_dir, self.source, f'{time_stamp} {keyword.replace(" ", "")}')
+        touchdir(work_dir)
+        return work_dir
+    '''_removeduplicates'''
+    def _removeduplicates(self, song_infos: list[SongInfo] = None) -> list[SongInfo]:
+        unique_song_infos, identifiers = [], set()
+        for song_info in song_infos:
+            if song_info.identifier in identifiers: continue
+            identifiers.add(song_info.identifier)
+            unique_song_infos.append(song_info)
+        return unique_song_infos
+    '''_search'''
+    @usesearchheaderscookies
+    def _search(self, keyword: str = '', search_url: str = '', request_overrides: dict = None, song_infos: list = [], progress: Progress = None, progress_id: int = 0):
+        raise NotImplementedError('not be implemented')
+    '''search'''
+    @usesearchheaderscookies
+    def search(self, keyword: str, num_threadings=5, request_overrides: dict = None, rule: dict = None):
+        # init
+        rule, request_overrides = rule or {}, request_overrides or {}
+        # logging
+        self.logger_handle.info(f'Start to search music files using {self.source}.', disable_print=self.disable_print)
+        # construct search urls
+        search_urls = self._constructsearchurls(keyword=keyword, rule=rule, request_overrides=request_overrides)
+        # multi threadings for searching music files
+        with Progress(TextColumn("{task.description}"), BarColumn(bar_width=None), MofNCompleteColumn(), TimeRemainingColumn()) as progress:
+            progress_id = progress.add_task(f"{self.source}.search >>> completed (0/{len(search_urls)})", total=len(search_urls))
+            song_infos, submitted_tasks = {}, []
+            with ThreadPoolExecutor(max_workers=num_threadings) as pool:
+                for search_url_idx, search_url in enumerate(search_urls):
+                    song_infos[str(search_url_idx)] = []
+                    submitted_tasks.append(pool.submit(
+                        self._search, keyword, search_url, request_overrides, song_infos[str(search_url_idx)], progress, progress_id
+                    ))
+                for _ in as_completed(submitted_tasks):
+                    progress.advance(progress_id, 1)
+                    num_searched_urls = int(progress.tasks[progress_id].completed)
+                    progress.update(progress_id, description=f"{self.source}.search >>> completed ({num_searched_urls}/{len(search_urls)})")
+        song_infos = list(chain.from_iterable(song_infos.values()))
+        song_infos = self._removeduplicates(song_infos=song_infos)
+        work_dir = self._constructuniqueworkdir(keyword=keyword)
+        for song_info in song_infos: song_info.work_dir = work_dir
+        # logging
+        if len(song_infos) > 0:
+            work_dir = song_infos[0].work_dir
+            touchdir(work_dir)
+            self._savetopkl([s.todict() for s in song_infos], os.path.join(work_dir, 'search_results.pkl'))
+        else:
+            work_dir = self.work_dir
+        self.logger_handle.info(f'Finished searching music files using {self.source}. Search results have been saved to {work_dir}, valid items: {len(song_infos)}.', disable_print=self.disable_print)
+        # return
+        return song_infos
+    '''_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)
+            if song_info.default_download_headers: request_overrides['headers'] = song_info.default_download_headers
+            with self.get(song_info.download_url, stream=True, **request_overrides) as resp:
+                resp.raise_for_status()
+                total_size, chunk_size, downloaded_size = int(resp.headers.get('content-length', 0)), song_info.get('chunk_size', 1024), 0
+                progress.update(song_progress_id, total=total_size)
+                with open(song_info.save_path, "wb") as fp:
+                    for chunk in resp.iter_content(chunk_size=chunk_size):
+                        if not chunk: continue
+                        fp.write(chunk)
+                        downloaded_size = downloaded_size + len(chunk)
+                        if total_size > 0:
+                            downloading_text = "%0.2fMB/%0.2fMB" % (downloaded_size / 1024 / 1024, total_size / 1024 / 1024)
+                        else:
+                            progress.update(song_progress_id, total=downloaded_size)
+                            downloading_text = "%0.2fMB/%0.2fMB" % (downloaded_size / 1024 / 1024, downloaded_size / 1024 / 1024)
+                        progress.advance(song_progress_id, len(chunk))
+                        progress.update(song_progress_id, description=f"{self.source}.download >>> {song_info.song_name} (Downloading: {downloading_text})")
+                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
+    '''download'''
+    @usedownloadheaderscookies
+    def download(self, song_infos: list[SongInfo], num_threadings=5, request_overrides: dict = None):
+        # init
+        request_overrides = request_overrides or {}
+        # logging
+        self.logger_handle.info(f'Start to download music files using {self.source}.', disable_print=self.disable_print)
+        # multi threadings for downloading music files
+        columns = [
+            SpinnerColumn(), TextColumn("{task.description}"), BarColumn(bar_width=None), TaskProgressColumn(),
+            AudioAwareColumn(), TransferSpeedColumn(), TimeRemainingColumn(),
+        ]
+        with Progress(*columns, refresh_per_second=20, expand=True) as progress:
+            songs_progress_id = progress.add_task(f"{self.source}.download >>> completed (0/{len(song_infos)})", total=len(song_infos), kind='overall')
+            song_progress_ids, downloaded_song_infos, submitted_tasks = [], [], []
+            for _, song_info in enumerate(song_infos):
+                desc = f"{self.source}.download >>> {song_info.song_name} (Preparing)"
+                song_progress_ids.append(progress.add_task(desc, total=None, kind='download'))
+            with ThreadPoolExecutor(max_workers=num_threadings) as pool:
+                for song_progress_id, song_info in zip(song_progress_ids, song_infos):
+                    submitted_tasks.append(pool.submit(
+                        self._download, song_info, request_overrides, downloaded_song_infos, progress, song_progress_id
+                    ))
+                for _ in as_completed(submitted_tasks):
+                    progress.advance(songs_progress_id, 1)
+                    num_downloaded_songs = int(progress.tasks[songs_progress_id].completed)
+                    progress.update(songs_progress_id, description=f"{self.source}.download >>> completed ({num_downloaded_songs}/{len(song_infos)})")
+        # logging
+        if len(downloaded_song_infos) > 0:
+            work_dir = downloaded_song_infos[0]['work_dir']
+            touchdir(work_dir)
+            self._savetopkl([s.todict() for s in downloaded_song_infos], os.path.join(work_dir, 'download_results.pkl'))
+        else:
+            work_dir = self.work_dir
+        self.logger_handle.info(f'Finished downloading music files using {self.source}. Download results have been saved to {work_dir}, valid downloads: {len(downloaded_song_infos)}.', disable_print=self.disable_print)
+        # return
+        return downloaded_song_infos
+    '''get'''
+    def get(self, url, **kwargs):
+        if 'cookies' not in kwargs: kwargs['cookies'] = self.default_cookies
+        resp = None
+        for _ in range(self.max_retries):
+            if not self.maintain_session:
+                self._initsession()
+                if self.random_update_ua: self.session.headers.update({'User-Agent': UserAgent().random})
+            if self.auto_set_proxies:
+                try:
+                    self.session.proxies = self.proxied_session_client.getrandomproxy()
+                except Exception as err:
+                    self.logger_handle.error(f'{self.source}.get >>> {url} (Error: {err})', disable_print=self.disable_print)
+                    self.session.proxies = {}
+            else:
+                self.session.proxies = {}
+            try:
+                resp = self.session.get(url, **kwargs)
+            except Exception as err:
+                self.logger_handle.error(f'{self.source}.get >>> {url} (Error: {err})', disable_print=self.disable_print)
+                continue
+            if resp.status_code != 200: continue
+            return resp
+        return resp
+    '''post'''
+    def post(self, url, **kwargs):
+        if 'cookies' not in kwargs: kwargs['cookies'] = self.default_cookies
+        resp = None
+        for _ in range(self.max_retries):
+            if not self.maintain_session:
+                self._initsession()
+                if self.random_update_ua: self.session.headers.update({'User-Agent': UserAgent().random})
+            if self.auto_set_proxies:
+                try:
+                    self.session.proxies = self.proxied_session_client.getrandomproxy()
+                except Exception as err:
+                    self.logger_handle.error(f'{self.source}.post >>> {url} (Error: {err})', disable_print=self.disable_print)
+                    self.session.proxies = {}
             else:
-                self.logger_handle.info('无法从%s下载 ——> %s...' % (self.source, songinfo['savename']))
-    '''初始化'''
-    def __initialize(self):
-        raise NotImplementedError('not be implemented...')
-    '''返回类信息'''
-    def __repr__(self):
-        return 'Music Source: %s' % self.source
+                self.session.proxies = {}
+            try:
+                resp = self.session.post(url, **kwargs)
+            except Exception as err:
+                self.logger_handle.error(f'{self.source}.post >>> {url} (Error: {err})', disable_print=self.disable_print)
+                continue
+            if resp.status_code != 200: continue
+            return resp
+        return resp
+    '''_savetopkl'''
+    def _savetopkl(self, data, file_path, auto_sanitize=True):
+        if auto_sanitize: file_path = sanitize_filepath(file_path)
+        with open(file_path, 'wb') as fp:
+            pickle.dump(data, fp)