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

musicdl/modules/sources/gequbao.py

@@ -0,0 +1,148 @@
+'''
+Function:
+    Implementation of GequbaoMusicClient: https://www.gequbao.com/
+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
+
+
+'''GequbaoMusicClient'''
+class GequbaoMusicClient(BaseMusicClient):
+    source = 'GequbaoMusicClient'
+    def __init__(self, **kwargs):
+        super(GequbaoMusicClient, 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.gequbao.com/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")
+        base_url, search_results = "https://www.gequbao.com", []
+        for a in soup.select("a.music-link"):
+            href = urljoin(base_url, a.get("href", "").strip())
+            title_tag = a.select_one(".music-title span")
+            title = title_tag.get_text(strip=True) if title_tag else ""
+            artist_tag = a.select_one("small")
+            artist = artist_tag.get_text(strip=True) if artist_tag else ""
+            search_results.append({'href': href, 'title': title, 'artist': artist})
+        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 ('href' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                # ----fetch basic information
+                try:
+                    resp = self.get(search_result['href'], **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.gequbao.com/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/jamendo.py

@@ -0,0 +1,108 @@
+'''
+Function:
+    Implementation of JamendoMusicClient: https://www.jamendo.com/
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import copy
+import random
+import hashlib
+from .base import BaseMusicClient
+from urllib.parse import urlencode
+from rich.progress import Progress
+from ..utils import legalizestring, resp2json, usesearchheaderscookies, seconds2hms, safeextractfromdict, SongInfo
+
+
+'''JamendoMusicClient'''
+class JamendoMusicClient(BaseMusicClient):
+    source = 'JamendoMusicClient'
+    def __init__(self, **kwargs):
+        super(JamendoMusicClient, self).__init__(**kwargs)
+        self.default_search_headers = {
+            "referer": "https://www.jamendo.com/search?q=musicdl",
+            "sec-ch-ua": "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"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-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+            "x-jam-call": "$536ab7feabd2404af7b6e54b4db74039734b58b3*0.5310391483096057~",
+            "x-jam-version": "4gvfvv",
+            "x-requested-with": "XMLHttpRequest",
+        }
+        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()
+    '''_makexjamcall'''
+    def _makexjamcall(self, path: str = '/api/search') -> str:
+        rand = str(random.random())
+        digest = hashlib.sha1((path + rand).encode("utf-8")).hexdigest()
+        return f"${digest}*{rand}~"
+    '''_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 = {'query': keyword, 'type': 'track', 'limit': self.search_size_per_source, 'identities': 'www'}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://www.jamendo.com/api/search?'
+        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
+            headers = copy.deepcopy(self.default_headers)
+            headers['x-jam-call'] = self._makexjamcall()
+            resp = self.get(search_url, headers=headers, **request_overrides)
+            resp.raise_for_status()
+            search_results = resp2json(resp)
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('id' not in search_result) or ('stream' not in search_result and 'download' not in search_result):
+                    continue
+                song_info = SongInfo(source=self.source)
+                streams: dict = search_result.get('download') or search_result.get('stream')
+                for quality in ['flac', 'ogg', 'mp3']:
+                    download_url = streams.get(quality, "")
+                    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='mp3' if streams.get('mp3') else 'ogg', raw_data={'search': search_result, 'download': {}, 'lyric': {}}, lyric='NULL',
+                        duration_s=search_result.get('duration', 0), duration=seconds2hms(search_result.get('duration', 0)), 
+                        song_name=legalizestring(safeextractfromdict(search_result, ['name'], ""), replace_null_string='NULL'),
+                        singers=legalizestring(safeextractfromdict(search_result, ['artist', 'name'], ""), replace_null_string='NULL'),
+                        album=legalizestring(safeextractfromdict(search_result, ['album', 'name'], ""), replace_null_string='NULL'),
+                        identifier=search_result['id'],
+                    )
+                    if song_info.with_valid_download_url: break
+                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 not song_info.file_size: song_info.file_size = 'NULL'
+                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/joox.py

@@ -1,79 +1,115 @@
 '''
 Function:
-    JOOX音乐下载: https://www.joox.com/cn/login
+    Implementation of JooxMusicClient: https://www.joox.com/intl
 Author:
-    Charles
-微信公众号:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
     Charles的皮卡丘
 '''
-import json
-import time
+import copy
 import base64
-import requests
-from .base import Base
-from ..utils.misc import *
+import json_repair
+from .base import BaseMusicClient
+from rich.progress import Progress
+from urllib.parse import urlencode, urlparse, parse_qs
+from ..utils import legalizestring, byte2mb, resp2json, seconds2hms, usesearchheaderscookies, SongInfo
 
 
-'''JOOX音乐下载类'''
-class joox(Base):
-    def __init__(self, config, logger_handle, **kwargs):
-        super(joox, self).__init__(config, logger_handle, **kwargs)
-        self.source = 'joox'
-        self.__initialize()
-    '''歌曲搜索'''
-    def search(self, keyword):
-        self.logger_handle.info('正在%s中搜索 ——> %s...' % (self.source, keyword))
-        cfg = self.config.copy()
-        params = {
-            'country': 'hk',
-            'lang': 'zh_TW',
-            'search_input': keyword,
-            'sin': '0',
-            'ein': cfg['search_size_per_source']
-        }
-        response = self.session.get(self.search_url, headers=self.headers, params=params)
-        all_items = response.json()['itemlist']
-        songinfos = []
-        for item in all_items:
-            params = {
-                'songid': item['songid'],
-                'lang': 'zh_cn',
-                'country': 'hk',
-                'from_type': '-1',
-                'channel_id': '-1',
-                '_': str(int(time.time()*1000))
-            }
-            response = self.session.get(self.songinfo_url, headers=self.headers, params=params)
-            response_json = json.loads(response.text.replace('MusicInfoCallback(', '')[:-1])
-            if response_json.get('code') != 0: continue
-            for q_key in [('r320Url', '320'), ('r192Url', '192'), ('mp3Url', '128')]:
-                download_url = response_json.get(q_key[0], '')
-                if not download_url: continue
-                filesize = str(round(int(json.loads(response_json['kbps_map'])[q_key[1]])/1024/1024, 2)) + 'MB'
-                ext = 'mp3' if q_key[0] in ['r320Url', 'mp3Url'] else 'm4a'
-            if not download_url: continue
-            duration = int(item.get('playtime', 0))
-            songinfo = {
-                'source': self.source,
-                'songid': str(item['songid']),
-                'singers': filterBadCharacter(','.join([base64.b64decode(s['name']).decode('utf-8') for s in item.get('singer_list', [])])),
-                'album': filterBadCharacter(response_json.get('malbum', '-')),
-                'songname': filterBadCharacter(response_json.get('msong', '-')),
-                'savedir': cfg['savedir'],
-                'savename': '_'.join([self.source, filterBadCharacter(response_json.get('msong', '-'))]),
-                '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 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko)',
+'''JooxMusicClient'''
+class JooxMusicClient(BaseMusicClient):
+    source = 'JooxMusicClient'
+    def __init__(self, **kwargs):
+        super(JooxMusicClient, 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/139.0.0.0 Safari/537.36',
             'Cookie': 'wmid=142420656; user_type=1; country=id; session_key=2a5d97d05dc8fe238150184eaf3519ad;',
             'X-Forwarded-For': '36.73.34.109'
         }
-        self.search_url = 'https://api-jooxtt.sanook.com/web-fcgi-bin/web_search'
-        self.songinfo_url = 'https://api.joox.com/web-fcgi-bin/web_get_songinfo'
+        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 = {'country': 'sg', 'lang': 'zh_cn', 'keyword': keyword}
+        default_rule.update(rule)
+        # construct search urls based on search rules
+        base_url = 'https://cache.api.joox.com/openjoox/v3/search?'
+        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.session.get(search_url, **request_overrides)
+            resp.raise_for_status()
+            search_results = []
+            for section in resp2json(resp)['section_list']:
+                for items in section['item_list']:
+                    search_results.extend(items.get('song', []))
+            parsed_search_url = parse_qs(urlparse(search_url).query, keep_blank_values=True)
+            lang, country = parsed_search_url['lang'][0], parsed_search_url['country'][0]
+            for search_result in search_results:
+                # --download results
+                if not isinstance(search_result, dict) or ('song_info' not in search_result) or ('id' not in search_result['song_info']):
+                    continue
+                song_info = SongInfo(source=self.source)
+                params = {'songid': search_result['song_info']['id'], 'lang': lang, 'country': country}
+                try:
+                    resp = self.get('https://api.joox.com/web-fcgi-bin/web_get_songinfo', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    download_result = json_repair.loads(resp.text.replace('MusicInfoCallback(', '')[:-1])
+                    kbps_map = json_repair.loads(download_result['kbps_map'])
+                except:
+                    continue
+                for quality in [('r320Url', '320'), ('r192Url', '192'), ('mp3Url', '128'), ('m4aUrl', '96')]:
+                    if (not kbps_map.get(quality[1])) or (not download_result.get(quality[0])):
+                        continue
+                    download_url: str = download_result.get(quality[0])
+                    ext = download_url.split('.')[-1].split('?')[0]
+                    song_info = SongInfo(
+                        source=self.source, download_url=download_url, download_url_status=self.audio_link_tester.test(download_url, request_overrides), ext=ext,
+                        raw_data={'search': search_result, 'download': download_result}, file_size_bytes=kbps_map.get(quality[1], 0),
+                        file_size=byte2mb(kbps_map.get(quality[1], 0)), duration_s=download_result.get('minterval', 0), duration=seconds2hms(download_result.get('minterval', 0)),
+                    )
+                    if song_info.with_valid_download_url: break
+                if not song_info.with_valid_download_url: continue
+                song_info.update(dict(
+                    song_name=legalizestring(search_result['song_info'].get('name', 'NULL'), replace_null_string='NULL'), 
+                    singers=legalizestring(', '.join([singer.get('name', 'NULL') for singer in search_result['song_info'].get('artist_list', [])]), replace_null_string='NULL'), 
+                    album=legalizestring(search_result['song_info'].get('album_name', 'NULL'), replace_null_string='NULL'),
+                    identifier=search_result['song_info']['id'],
+                ))
+                # --lyric results
+                params = {'musicid': search_result['song_info']['id'], 'country': country, 'lang': lang}
+                try:
+                    resp = self.get('https://api.joox.com/web-fcgi-bin/web_lyric', params=params, **request_overrides)
+                    resp.raise_for_status()
+                    lyric_result: dict = json_repair.loads(resp.text.replace('MusicJsonCallback(', '')[:-1]) or {}
+                    lyric = base64.b64decode(lyric_result.get('lyric', '')).decode('utf-8') or 'NULL'
+                except:
+                    lyric_result, lyric = dict(), 'NULL'
+                song_info.raw_data['lyric'] = lyric_result
+                song_info.lyric = lyric
+                # --append to song_infos
+                song_infos.append(song_info)
+                # --judgement for search_size
+                if self.strict_limit_search_size_per_page and len(song_infos) >= self.search_size_per_page: break
+            # --update progress
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Success)")
+        # failure
+        except Exception as err:
+            progress.update(progress_id, description=f"{self.source}.search >>> {search_url} (Error: {err})")
+        # return
+        return song_infos