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

musicdl/modules/utils/qqutils.py

@@ -0,0 +1,184 @@
+'''
+Function:
+    Implementation of QQMusicClient utils
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import time
+import orjson
+import base64
+import random
+import string
+import hashlib
+import requests
+import binascii
+from uuid import uuid4
+from typing import ClassVar, cast
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+
+'''constants'''
+PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDEIxgwoutfwoJxcGQeedgP7FG9qaIuS0qzfR8gWkrkTZKM2iWHn2ajQpBRZjMSoSf6+KJGvar2ORhBfpDXyVtZCKpqLQ+FLkpncClKVIrBwv6PHyUvuCb0rIarmgDnzkfQAqVufEtR64iazGDKatvJ9y6B9NMbHddGSAUmRTCrHQIDAQAB
+-----END PUBLIC KEY-----"""
+SECRET = "ZdJqM15EeO2zWc08"
+APP_KEY = "0AND0HD6FE4HY80F"
+DEFAULT_VIP_QUALITIES = {
+    "MASTER": ("AIM0", ".mflac"), "ATMOS_2": ("Q0M0", ".mflac"), "ATMOS_51": ("Q0M1", ".mflac"), "FLAC": ("F0M0", ".mflac"),
+    "OGG_640": ("O801", ".mgg"), "OGG_320": ("O800", ".mgg"), "OGG_192": ("O6M0", ".mgg"), "OGG_96": ("O4M0", ".mgg"),
+}
+DEFAULT_QUALITIES = {
+    "MASTER": ("AI00", ".flac"), "ATMOS_2": ("Q000", ".flac"), "ATMOS_51": ("Q001", ".flac"), "FLAC": ("F000", ".flac"), 
+    "OGG_640":  ("O801", ".ogg"), "OGG_320": ("O800", ".ogg"), "OGG_192": ("O600", ".ogg"), "OGG_96": ("O400", ".ogg"), 
+    "MP3_320": ("M800", ".mp3"), "MP3_128": ("M500", ".mp3"), "ACC_192": ("C600", ".m4a"), "ACC_96": ("C400", ".m4a"),
+    "ACC_48":   ("C200", ".m4a"),
+}
+
+
+'''QQMusicClientUtils'''
+class QQMusicClientUtils(object):
+    '''randomimei'''
+    @staticmethod
+    def randomimei():
+        imei, sum_ = [], 0
+        for i in range(14):
+            num = random.randint(0, 9)
+            if (i + 2) % 2 == 0:
+                num *= 2
+                if num >= 10: num = (num % 10) + 1
+            sum_ += num
+            imei.append(str(num))
+        ctrl_digit = (sum_ * 9) % 10
+        imei.append(str(ctrl_digit))
+        return "".join(imei)
+    '''rsaencrypt'''
+    @staticmethod
+    def rsaencrypt(content: bytes):
+        key = cast(RSAPublicKey, serialization.load_pem_public_key(PUBLIC_KEY.encode()))
+        return key.encrypt(content, padding.PKCS1v15())
+    '''aesencrypt'''
+    @staticmethod
+    def aesencrypt(key: bytes, content: bytes):
+        cipher = Cipher(algorithms.AES(key), modes.CBC(key))
+        padding_size = 16 - len(content) % 16
+        encryptor = cipher.encryptor()
+        return encryptor.update(content + (padding_size * chr(padding_size)).encode()) + encryptor.finalize()
+    '''calcmd5'''
+    @staticmethod
+    def calcmd5(*strings: str | bytes):
+        md5 = hashlib.md5()
+        for item in strings:
+            assert isinstance(item, (str, bytes))
+            if isinstance(item, bytes): md5.update(item)
+            elif isinstance(item, str): md5.update(item.encode())
+        return md5.hexdigest()
+    '''randombeaconid'''
+    @staticmethod
+    def randombeaconid():
+        beacon_id = ""
+        time_month = datetime.now().strftime("%Y-%m-") + "01"
+        rand1 = random.randint(100000, 999999)
+        rand2 = random.randint(100000000, 999999999)
+        for i in range(1, 41):
+            if i in [1, 2, 13, 14, 17, 18, 21, 22, 25, 26, 29, 30, 33, 34, 37, 38]:
+                beacon_id += f"k{i}:{time_month}{rand1}.{rand2}"
+            elif i == 3:
+                beacon_id += "k3:0000000000000000"
+            elif i == 4:
+                beacon_id += f"k4:{''.join(random.choices('123456789abcdef', k=16))}"
+            else:
+                beacon_id += f"k{i}:{random.randint(0, 9999)}"
+            beacon_id += ";"
+        return beacon_id
+    '''randompayloadbydevice'''
+    @staticmethod
+    def randompayloadbydevice(device, version: str):
+        fixed_rand = random.randint(0, 14400)
+        reserved = {
+            "harmony": "0", "clone": "0", "containe": "", "oz": "UhYmelwouA+V2nPWbOvLTgN2/m8jwGB+yUB5v9tysQg=", "oo": "Xecjt+9S1+f8Pz2VLSxgpw==",
+            "kelong": "0", "uptimes": (datetime.now() - timedelta(seconds=fixed_rand)).strftime("%Y-%m-%d %H:%M:%S"), "multiUser": "0",
+            "bod": device.brand, "dv": device.device, "firstLevel": "", "manufact": device.brand, "name": device.model, "host": "se.infra",
+            "kernel": device.proc_version,
+        }
+        return {
+            "androidId": device.android_id, "platformId": 1, "appKey": APP_KEY, "appVersion": version, "beaconIdSrc": QQMusicClientUtils.randombeaconid(),
+            "brand": device.brand, "channelId": "10003505", "cid": "", "imei": device.imei, "imsi": "", "mac": "", "model": device.model, "networkType": "unknown",
+            "oaid": "", "osVersion": f"Android {device.version.release},level {device.version.sdk}", "qimei": "", "qimei36": "", "sdkVersion": "1.2.13.6",
+            "targetSdkVersion": "33", "audit": "", "userId": "{}", "packageId": "com.tencent.qqmusic", "deviceType": "Phone", "sdkName": "",
+            "reserved": orjson.dumps(reserved).decode(),
+        }
+    '''obtainqimei'''
+    @staticmethod
+    def obtainqimei(version: str, device):
+        try:
+            payload = QQMusicClientUtils.randompayloadbydevice(device, version)
+            crypt_key = "".join(random.choices("adbcdef1234567890", k=16))
+            nonce = "".join(random.choices("adbcdef1234567890", k=16))
+            ts = int(time.time())
+            key = base64.b64encode(QQMusicClientUtils.rsaencrypt(crypt_key.encode())).decode()
+            params = base64.b64encode(QQMusicClientUtils.aesencrypt(crypt_key.encode(), orjson.dumps(payload))).decode()
+            extra = '{"appKey":"' + APP_KEY + '"}'
+            sign = QQMusicClientUtils.calcmd5(key, params, str(ts * 1000), nonce, SECRET, extra)
+            resp = requests.post(
+                "https://api.tencentmusic.com/tme/trpc/proxy",
+                headers={
+                    "Host": "api.tencentmusic.com", "method": "GetQimei", "service": "trpc.tme_datasvr.qimeiproxy.QimeiProxy", "appid": "qimei_qq_android",
+                    "sign": QQMusicClientUtils.calcmd5("qimei_qq_androidpzAuCmaFAaFaHrdakPjLIEqKrGnSOOvH", str(ts)), "user-agent": "QQMusic", "timestamp": str(ts),
+                },
+                json={
+                    "app": 0, "os": 1, "qimeiParams": {"key": key, "params": params, "time": str(ts), "nonce": nonce, "sign": sign, "extra": extra},
+                },
+            )
+            data = orjson.loads(orjson.loads(resp.content)["data"])["data"]
+            device.qimei = data["q36"]
+            result = {"q16": data["q16"], "q36": data["q36"]}
+            return result
+        except:
+            result = {"q16": "", "q36": "6c9d3cd110abca9b16311cee10001e717614"}
+        return result
+
+
+'''OSVersion'''
+@dataclass
+class OSVersion:
+    incremental: str = "5891938"
+    release: str = "10"
+    codename: str = "REL"
+    sdk: int = 29
+
+
+'''Device'''
+@dataclass
+class Device:
+    display: str = field(default_factory=lambda: f"QMAPI.{random.randint(100000, 999999)}.001")
+    product: str = "iarim"
+    device: str = "sagit"
+    board: str = "eomam"
+    model: str = "MI 6"
+    fingerprint: str = field(default_factory=lambda: f"xiaomi/iarim/sagit:10/eomam.200122.001/{random.randint(1000000, 9999999)}:user/release-keys")
+    boot_id: str = field(default_factory=lambda: str(uuid4()))
+    proc_version: str = field(default_factory=lambda: f"Linux 5.4.0-54-generic-{''.join(random.choices(string.ascii_letters + string.digits, k=8))} (android-build@google.com)")
+    imei: str = field(default_factory=QQMusicClientUtils.randomimei)
+    brand: str = "Xiaomi"
+    bootloader: str = "U-boot"
+    base_band: str = ""
+    version: OSVersion = field(default_factory=OSVersion)
+    sim_info: str = "T-Mobile"
+    os_type: str = "android"
+    mac_address: str = "00:50:56:C0:00:08"
+    ip_address: ClassVar[list[int]] = [10, 0, 1, 3]
+    wifi_bssid: str = "00:50:56:C0:00:08"
+    wifi_ssid: str = "<unknown ssid>"
+    imsi_md5: list[int] = field(default_factory=lambda: list(hashlib.md5(bytes([random.randint(0, 255) for _ in range(16)])).digest()))
+    android_id: str = field(default_factory=lambda: binascii.hexlify(bytes([random.randint(0, 255) for _ in range(8)])).decode("utf-8"))
+    apn: str = "wifi"
+    vendor_name: str = "MIUI"
+    vendor_os_name: str = "qmapi"
+    qimei: None | str = None

musicdl/modules/utils/quarkparser.py

@@ -0,0 +1,105 @@
+'''
+Function:
+    Implementation of QuarkParser
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import time
+import requests
+from .misc import resp2json
+from urllib.parse import urlparse
+
+
+'''QuarkParser'''
+class QuarkParser():
+    '''parsefromurl'''
+    @staticmethod
+    def parsefromurl(url: str, passcode: str = '', cookies: str | dict = '', max_tries: int = 3):
+        for _ in range(max_tries):
+            try:
+                download_result, download_url = QuarkParser._parsefromurl(url=url, passcode=passcode, cookies=cookies)
+                break
+            except:
+                download_result, download_url = {}, ""
+        return download_result, download_url
+    '''_parsefromurl'''
+    @staticmethod
+    def _parsefromurl(url: str, passcode: str = '', cookies: str | dict = ''):
+        # init
+        session, download_result = requests.Session(), {}
+        parsed_url = urlparse(url)
+        pwd_id = parsed_url.path.strip('/').split('/')[-1]
+        if cookies and isinstance(cookies, str): cookies = dict(item.split("=", 1) for item in cookies.split("; "))
+        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',
+        }
+        # share/sharepage/token
+        json_data = {'pwd_id': pwd_id, 'passcode': passcode}
+        params = {'pr': 'ucpro', 'fr': 'pc', 'uc_param_str': '', '__dt': '596', '__t': f'{str(int(time.time() * 1000))}'}
+        resp = session.post('https://drive-h.quark.cn/1/clouddrive/share/sharepage/token', params=params, json=json_data, cookies=cookies, headers=headers)
+        resp.raise_for_status()
+        token_data = resp2json(resp=resp)
+        stoken = token_data['data']['stoken']
+        download_result['token_data'] = token_data
+        time.sleep(0.1)
+        # share/sharepage/detail
+        params = {
+            "pr": "ucpro", "fr": "pc", "uc_param_str": "", "ver": "2", "pwd_id": pwd_id, "stoken": stoken, "pdir_fid": "0", "force": "0",
+            "_page": "1", "_size": "50", "_fetch_banner": "1", "_fetch_share": "1", "fetch_relate_conversation": "1", "_fetch_total": "1",
+            "_sort": "file_type:asc,file_name:asc", "__dt": "1020", "__t": f"{int(time.time() * 1000)}"
+        }
+        resp = session.get('https://drive-h.quark.cn/1/clouddrive/share/sharepage/detail', params=params, cookies=cookies, headers=headers)
+        resp.raise_for_status()
+        detail_data = resp2json(resp=resp)
+        fid = detail_data["data"]["list"][0]["fid"]
+        share_fid_token = detail_data["data"]["list"][0]["share_fid_token"]
+        download_result['detail_data'] = detail_data
+        time.sleep(0.1)
+        # clouddrive/file/info/path_list
+        params = {"pr": "ucpro", "fr": "pc", "uc_param_str": "", "__dt": "1266", "__t": f"{int(time.time() * 1000)}"}
+        json_data = {"file_path": ["/来自：分享"]}
+        resp = session.post('https://drive-pc.quark.cn/1/clouddrive/file/info/path_list', params=params, json=json_data, cookies=cookies, headers=headers)
+        resp.raise_for_status()
+        path_list_data = resp2json(resp=resp)
+        to_pdir_fid = path_list_data["data"][0]["fid"]
+        download_result['path_list_data'] = path_list_data
+        time.sleep(0.1)
+        # share/sharepage/save
+        params = {"pr": "ucpro", "fr": "pc", "uc_param_str": "", "__dt": "5660", "__t": f"{int(time.time() * 1000)}"}
+        json_data = {"pwd_id": pwd_id, "stoken": stoken, "pdir_fid": "0", "to_pdir_fid": to_pdir_fid, "fid_list": [fid], "fid_token_list": [share_fid_token], "scene": "link"}
+        resp = session.post(url='https://drive-pc.quark.cn/1/clouddrive/share/sharepage/save', params=params, cookies=cookies, json=json_data, headers=headers)
+        resp.raise_for_status()
+        save_data = resp2json(resp=resp)
+        task_id = save_data['data']['task_id']
+        download_result['save_data'] = save_data
+        time.sleep(0.1)
+        # clouddrive/task
+        for retry_index in range(5):
+            try:
+                params = {'pr': 'ucpro', 'fr': 'pc', 'uc_param_str': '', 'task_id': task_id, 'retry_index': str(retry_index), '__dt': '6355', '__t': f'{str(int(time.time() * 1000))}'}
+                resp = session.get('https://drive-pc.quark.cn/1/clouddrive/task', params=params, cookies=cookies, headers=headers)
+                resp.raise_for_status()
+                task_data = resp2json(resp=resp)
+                fid_encrypt = task_data['data']['save_as']['save_as_top_fids'][0]
+                download_result['task_data'] = task_data
+                break
+            except:
+                time.sleep(0.1)
+                continue
+        # clouddrive/file/download
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.56 Chrome/100.0.4896.160 Electron/18.3.5.12-a038f7b798 Safari/537.36 Channel/pckk_other_ch",
+            "Accept": "application/json, text/plain, */*", "Content-Type": "application/json", "accept-language": "zh-CN", "origin": "https://pan.quark.cn", "referer": "https://pan.quark.cn/",
+        }
+        params = {'pr': 'ucpro', 'fr': 'pc', 'uc_param_str': '', '__dt': '6743', '__t': f'{str(int(time.time() * 1000))}'}
+        json_data = {'fids': [fid_encrypt]}
+        resp = session.post('https://drive-pc.quark.cn/1/clouddrive/file/download', params=params, json=json_data, cookies=cookies, headers=headers)
+        resp.raise_for_status()
+        download_data = resp2json(resp=resp)
+        download_url = download_data["data"][0]["download_url"]
+        download_result['download_data'] = download_data
+        # return
+        return download_result, download_url

musicdl/modules/utils/songinfoutils.py

@@ -0,0 +1,54 @@
+'''
+Function:
+    Implementation of SongInfoUtils
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import os
+from pathlib import Path
+from .data import SongInfo
+from tinytag import TinyTag
+from .lyric import WhisperLRC
+from .logger import LoggerHandle
+from .misc import seconds2hms, byte2mb
+
+
+'''SongInfoUtils'''
+class SongInfoUtils:
+    '''fillsongtechinfo'''
+    @staticmethod
+    def fillsongtechinfo(song_info: SongInfo, logger_handle: LoggerHandle, disable_print: bool) -> SongInfo:
+        path = Path(song_info.save_path)
+        # correct file size
+        size = path.stat().st_size
+        song_info.file_size_bytes = size
+        song_info.file_size = byte2mb(size=size)
+        # tinytag parse
+        try:
+            tag = TinyTag.get(str(path))
+        except Exception as err:
+            logger_handle.warning(f'SongInfoUtils.fillsongtechinfo >>> {str(path)} (Err: {err})', disable_print=disable_print)
+            return song_info
+        if tag.duration:
+            song_info.duration_s = int(round(tag.duration))
+            song_info.duration = seconds2hms(tag.duration)
+        if tag.bitrate:
+            song_info.bitrate = int(round(tag.bitrate))
+        if tag.samplerate:
+            song_info.samplerate = int(tag.samplerate)
+        if tag.channels:
+            song_info.channels = int(tag.channels)
+        if getattr(tag, "codec", None):
+            song_info.codec = tag.codec
+        elif getattr(tag, "extra", None) and isinstance(tag.extra, dict):
+            song_info.codec = tag.extra.get("codec") or tag.extra.get("mime-type")
+        # lyric
+        if os.environ.get('ENABLE_WHISPERLRC', 'False').lower() == 'true' and ((not song_info.lyric) or (song_info.lyric == 'NULL')):
+            lyric_result = WhisperLRC(model_size_or_path='small').fromfilepath(str(path))
+            lyric = lyric_result['lyric']
+            song_info.lyric = lyric
+            song_info.raw_data['lyric'] = lyric_result
+        # return
+        return song_info