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

musicdl/modules/utils/data.py

@@ -0,0 +1,107 @@
+'''
+Function:
+    Implementation of SongInfo
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+from __future__ import annotations
+import os
+from .misc import sanitize_filepath
+from typing import Any, Dict, Optional
+from dataclasses import dataclass, field, fields
+
+
+'''SongInfo'''
+@dataclass
+class SongInfo:
+    # raw data replied by requested APIs
+    raw_data: Dict[str, Any] = field(default_factory=dict)
+    # from which music client
+    source: Optional[str] = None
+    root_source: Optional[str] = None
+    # song information
+    song_name: Optional[str] = None
+    singers: Optional[str] = None
+    album: Optional[str] = None
+    ext: Optional[str] = None
+    file_size_bytes: Optional[int] = None
+    file_size: Optional[str] = None
+    duration_s: Optional[int] = None
+    duration: Optional[str] = None
+    bitrate: Optional[int] = None
+    codec: Optional[str] = None
+    samplerate: Optional[int] = None
+    channels: Optional[int] = None
+    # lyric
+    lyric: Optional[str] = None
+    # cover
+    cover_url: Optional[str] = None
+    # download url related variables
+    download_url: Optional[Any] = None
+    download_url_status: Optional[Any] = None
+    default_download_headers: Dict[str, Any] = field(default_factory=dict)
+    downloaded_contents: Optional[Any] = None
+    chunk_size: Optional[int] = 1024 * 1024
+    @property
+    def with_valid_download_url(self) -> bool:
+        if isinstance(self.download_url, str):
+            is_valid_format = self.download_url and self.download_url.startswith('http')
+        else:
+            is_valid_format = self.download_url
+        is_downloadable = isinstance(self.download_url_status, dict) and self.download_url_status.get('ok')
+        return bool(is_valid_format and is_downloadable)
+    # save info
+    work_dir: Optional[str] = './'
+    _save_path: Optional[str] = None
+    @property
+    def save_path(self) -> str:
+        if self._save_path is not None: return self._save_path
+        sp, same_name_file_idx = os.path.join(self.work_dir, f"{self.song_name} - {self.identifier}.{self.ext.removeprefix('.')}"), 1
+        while os.path.exists(sp):
+            sp = os.path.join(self.work_dir, f"{self.song_name} - {self.identifier} ({same_name_file_idx}).{self.ext.removeprefix('.')}")
+            same_name_file_idx += 1
+        sp = sanitize_filepath(sp)
+        self._save_path = sp
+        return sp
+    # identifier
+    identifier: Optional[str] = None
+    '''fieldnames'''
+    @classmethod
+    def fieldnames(cls) -> set[str]:
+        return {f.name for f in fields(cls)}
+    '''fromdict'''
+    @classmethod
+    def fromdict(cls, data: Dict[str, Any]) -> "SongInfo":
+        field_names = cls.fieldnames()
+        filtered = {k: v for k, v in data.items() if k in field_names}
+        return cls(**filtered)
+    '''todict'''
+    def todict(self) -> Dict[str, Any]:
+        return {f.name: getattr(self, f.name) for f in fields(self)}
+    '''update'''
+    def update(self, data: Dict[str, Any] = None, **kwargs: Any) -> "SongInfo":
+        if data is None: data = {}
+        merged: Dict[str, Any] = {**data, **kwargs}
+        field_names = self.fieldnames()
+        for k, v in merged.items():
+            if k in field_names: setattr(self, k, v)
+        return self
+    '''getitem'''
+    def __getitem__(self, key: str) -> Any:
+        field_names = self.fieldnames()
+        if key not in field_names: raise KeyError(key)
+        return getattr(self, key)
+    '''setitem'''
+    def __setitem__(self, key: str, value: Any) -> None:
+        field_names = self.fieldnames()
+        if key not in field_names: raise KeyError(key)
+        setattr(self, key, value)
+    '''contains'''
+    def __contains__(self, key: object) -> bool:
+        return isinstance(key, str) and key in self.fieldnames()
+    '''get'''
+    def get(self, key: str, default: Any = None) -> Any:
+        if key in self.fieldnames(): return getattr(self, key)
+        return default

musicdl/modules/utils/logger.py

@@ -1,58 +1,211 @@
-'''
-Function:
-    一些终端打印工具
-Author:
-    Charles
-微信公众号:
-    Charles的皮卡丘
-'''
-import logging
-from prettytable import PrettyTable
-
-
-'''打印日志类'''
-class Logger():
-    def __init__(self, logfilepath, **kwargs):
-        setattr(self, 'logfilepath', logfilepath)
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s %(levelname)-8s %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S',
-            handlers=[logging.FileHandler(logfilepath), logging.StreamHandler()],
-        )
-    @staticmethod
-    def log(level, message):
-        logging.log(level, message)
-    def debug(self, message, disable_print=False):
-        if disable_print:
-            fp = open(self.logfilepath, 'a')
-            fp.write(message + '\n')
-        else:
-            Logger.log(logging.DEBUG, message)
-    def info(self, message, disable_print=False):
-        if disable_print:
-            fp = open(self.logfilepath, 'a')
-            fp.write(message + '\n')
-        else:
-            Logger.log(logging.INFO, message)
-    def warning(self, message, disable_print=False):
-        if disable_print:
-            fp = open(self.logfilepath, 'a')
-            fp.write(message + '\n')
-        else:
-            Logger.log(logging.WARNING, message)
-    def error(self, message, disable_print=False):
-        if disable_print:
-            fp = open(self.logfilepath, 'a')
-            fp.write(message + '\n')
-        else:
-            Logger.log(logging.ERROR, message)
-
-
-'''打印表格'''
-def printTable(title, items):
-    assert isinstance(title, list) and isinstance(items, list), 'title and items should be list...'
-    table = PrettyTable(title)
-    for item in items: table.add_row(item)
-    print(table)
-    return table
+'''
+Function:
+    Implementation of logging related utils
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import os
+import shutil
+import logging
+import collections.abc
+from wcwidth import wcswidth
+from tabulate import tabulate
+from prettytable import PrettyTable
+from platformdirs import user_log_dir
+
+
+'''predefined colors in terminal'''
+COLORS = {
+    'red': '\033[31m',
+    'green': '\033[32m',
+    'yellow': '\033[33m',
+    'blue': '\033[34m',
+    'pink': '\033[35m',
+    'cyan': '\033[36m',
+    'highlight': '\033[93m',
+    'number': '\033[96m',
+    'singer': '\033[93m',
+    'flac': '\033[95m',
+    'songname': '\033[91m'
+}
+
+
+'''LoggerHandle'''
+class LoggerHandle():
+    appname = 'musicdl'
+    appauthor = 'zcjin'
+    def __init__(self):
+        # set up log dir
+        log_dir = user_log_dir(appname=self.appname, appauthor=self.appauthor)
+        os.makedirs(log_dir, exist_ok=True)
+        log_file_path = os.path.join(log_dir, "musicdl.log")
+        self.log_file_path = log_file_path
+        # config logging
+        logging.basicConfig(
+            level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[logging.FileHandler(log_file_path, encoding="utf-8"), logging.StreamHandler()]
+        )
+    '''log'''
+    @staticmethod
+    def log(level, message):
+        message = str(message)
+        logger = logging.getLogger(LoggerHandle.appname)
+        logger.log(level, message)
+    '''debug'''
+    def debug(self, message, disable_print=False):
+        message = str(message)
+        if disable_print:
+            fp = open(self.log_file_path, 'a', encoding='utf-8')
+            fp.write(message + '\n')
+        else:
+            LoggerHandle.log(logging.DEBUG, message)
+    '''info'''
+    def info(self, message, disable_print=False):
+        message = str(message)
+        if disable_print:
+            fp = open(self.log_file_path, 'a', encoding='utf-8')
+            fp.write(message + '\n')
+        else:
+            LoggerHandle.log(logging.INFO, message)
+    '''warning'''
+    def warning(self, message, disable_print=False):
+        message = str(message)
+        if disable_print:
+            fp = open(self.log_file_path, 'a', encoding='utf-8')
+            fp.write(message + '\n')
+        else:
+            if '\033[31m' not in message:
+                message = colorize(message, 'red')
+            LoggerHandle.log(logging.WARNING, message)
+    '''error'''
+    def error(self, message, disable_print=False):
+        message = str(message)
+        if disable_print:
+            fp = open(self.log_file_path, 'a', encoding='utf-8')
+            fp.write(message + '\n')
+        else:
+            if '\033[31m' not in message:
+                message = colorize(message, 'red')
+            LoggerHandle.log(logging.ERROR, message)
+
+
+'''printtable'''
+def printtable(titles, items, terminal_right_space_len=4):
+    assert isinstance(titles, collections.abc.Sequence) and isinstance(items, collections.abc.Sequence), 'title and items should be iterable'
+    table = PrettyTable(titles)
+    for item in items: table.add_row(item)
+    max_width = shutil.get_terminal_size().columns - terminal_right_space_len
+    assert max_width > 0, f'"terminal_right_space_len" should smaller than {shutil.get_terminal_size()}'
+    table.max_table_width = max_width
+    print(table)
+    return table
+
+
+'''displen'''
+def displen(s: str) -> int:
+    if s is None:
+        return 0
+    return max(wcswidth(str(s)), 0)
+
+
+'''tablewidth'''
+def tablewidth(table_str: str) -> int:
+    lines = table_str.splitlines()
+    if not lines:
+        return 0
+    return max(displen(line) for line in lines)
+
+
+'''truncatebydispwidth'''
+def truncatebydispwidth(text: str, max_width: int) -> str:
+    text, cur_w = str(text), displen(text)
+    if cur_w <= max_width: return text
+    if max_width <= 0: return ""
+    if max_width <= 3:
+        acc, out = 0, []
+        for ch in text:
+            w = displen(ch)
+            if acc + w > max_width: break
+            out.append(ch)
+            acc += w
+        return "".join(out)
+    target, acc, out_chars = max_width - 3, 0, []
+    for ch in text:
+        w = displen(ch)
+        if acc + w > target: break
+        out_chars.append(ch)
+        acc += w
+    return "".join(out_chars) + "..."
+
+
+'''smarttrunctable'''
+def smarttrunctable(headers, rows, max_col_width=40, terminal_right_space_len=10, no_trunc_cols=None, min_col_width=4, max_iterations=2000):
+    headers = [str(h) for h in headers]
+    rows = [[str(c) for c in row] for row in rows]
+    ncols = len(headers)
+    assert all(len(r) == ncols for r in rows), "all rows must have same length as headers"
+    term_width = shutil.get_terminal_size().columns
+    target_width = term_width - terminal_right_space_len
+    if target_width <= 0: target_width = term_width
+    protected_idx = set()
+    if no_trunc_cols:
+        for spec in no_trunc_cols:
+            if isinstance(spec, int):
+                if 0 <= spec < ncols: protected_idx.add(spec)
+            else:
+                for j, h in enumerate(headers):
+                    if h == str(spec): protected_idx.add(j)
+    col_max = []
+    for j in range(ncols):
+        w = displen(headers[j])
+        for row in rows: w = max(w, displen(row[j]))
+        col_max.append(w)
+    col_limits = []
+    for j in range(ncols):
+        if j in protected_idx: col_limits.append(None)
+        else:
+            limit = col_max[j]
+            if max_col_width: limit = min(limit, max_col_width)
+            limit = max(limit, min_col_width)
+            col_limits.append(limit)
+    last_table = ""
+    for _ in range(max_iterations):
+        truncated_headers = []
+        for j, h in enumerate(headers):
+            if col_limits[j] is None: truncated_headers.append(h)
+            else: truncated_headers.append(truncatebydispwidth(h, col_limits[j]))
+        truncated_rows = []
+        for row in rows:
+            new_row = []
+            for j, cell in enumerate(row):
+                if col_limits[j] is None: new_row.append(cell)
+                else: new_row.append(truncatebydispwidth(cell, col_limits[j]))
+            truncated_rows.append(new_row)
+        table_str = tabulate(truncated_rows, headers=truncated_headers, tablefmt="fancy_grid")
+        last_table = table_str
+        w = tablewidth(table_str)
+        if w <= target_width: return table_str
+        col_cur = [displen(h) for h in truncated_headers]
+        for row in truncated_rows:
+            for j, cell in enumerate(row): col_cur[j] = max(col_cur[j], displen(cell))
+        candidates = [j for j in range(ncols) if col_limits[j] is not None and col_limits[j] > min_col_width]
+        if not candidates: return last_table
+        j_longest = max(candidates, key=lambda k: col_cur[k])
+        col_limits[j_longest] -= 1
+    return last_table
+
+
+'''colorize'''
+def colorize(string, color):
+    string = str(string)
+    if color not in COLORS: return string
+    return COLORS[color] + string + '\033[0m'
+
+
+'''printfullline'''
+def printfullline(ch: str = "*", end: str = '\n', terminal_right_space_len: int = 1):
+    cols = shutil.get_terminal_size().columns - terminal_right_space_len
+    assert cols > 0, f'"terminal_right_space_len" should smaller than {shutil.get_terminal_size()}'
+    print(ch * cols, end=end)

musicdl/modules/utils/lyric.py

@@ -0,0 +1,73 @@
+'''
+Function:
+    Implementation of WhisperLRC
+Author:
+    Zhenchao Jin
+WeChat Official Account (微信公众号):
+    Charles的皮卡丘
+'''
+import os
+import re
+import tempfile
+import requests
+
+
+'''WhisperLRC'''
+class WhisperLRC:
+    def __init__(self, model_size_or_path="small", device="auto", compute_type="int8", cpu_threads=4, num_workers=1, **kwargs):
+        try:
+            from faster_whisper import WhisperModel
+            self.whisper_model = WhisperModel(model_size_or_path, device=device, compute_type=compute_type, cpu_threads=cpu_threads, num_workers=num_workers, **kwargs)
+        except:
+            self.whisper_model = None
+    '''downloadtotmpdir'''
+    @staticmethod
+    def downloadtotmpdir(url: str, headers: dict = None, timeout: int = 300, cookies: dict = None, request_overrides: dict = None):
+        headers, cookies, request_overrides = headers or {}, cookies or {}, request_overrides or {}
+        if 'headers' not in request_overrides: request_overrides['headers'] = headers
+        if 'timeout' not in request_overrides: request_overrides['timeout'] = timeout
+        if 'cookies' not in request_overrides: request_overrides['cookies'] = cookies
+        resp = requests.get(url, stream=True, **request_overrides)
+        resp.raise_for_status()
+        m = re.search(r"\.([a-z0-9]{2,5})(?:\?|$)", url, re.I)
+        fd, path = tempfile.mkstemp(suffix="."+(m.group(1).lower() if m else "bin"))
+        with os.fdopen(fd, "wb") as fp:
+            for ch in resp.iter_content(32768):
+                if ch: fp.write(ch)
+        return path
+    '''timestamp'''
+    @staticmethod
+    def timestamp(t):
+        t = max(0.0, float(t)); mm = int(t//60); ss = t - mm*60
+        return f"[{mm:02d}:{ss:05.2f}]"
+    '''fromurl'''
+    def fromurl(self, url: str, transcribe_overrides: dict = None, headers: dict = None, timeout: int = 300, cookies: dict = None, request_overrides: dict = None):
+        assert self.whisper_model is not None, 'faster_whisper should be installed via "pip install "faster_whisper"'
+        transcribe_overrides, headers, cookies, request_overrides = transcribe_overrides or {}, headers or {}, cookies or {}, request_overrides or {}
+        tmp_file_path = ''
+        try:
+            tmp_file_path = self.downloadtotmpdir(url, headers=headers, timeout=timeout, cookies=cookies, request_overrides=request_overrides)
+            default_transcribe_settings = {
+                'language': None, 'vad_filter': True, 'vad_parameters': dict(min_silence_duration_ms=300), 'chunk_length': 30, 'beam_size': 5
+            }
+            default_transcribe_settings.update(transcribe_overrides)
+            segs, info = self.whisper_model.transcribe(tmp_file_path, **default_transcribe_settings)
+            lrc = "\n".join(f"{self.timestamp(s.start)}{s.text.strip()}" for s in segs)
+            result = {"language": info.language, "prob": info.language_probability, "duration": getattr(info, "duration", None), 'lyric': lrc}
+            return result
+        finally:
+            if tmp_file_path and os.path.exists(tmp_file_path):
+                try: os.remove(tmp_file_path)
+                except: pass
+    '''fromfilepath'''
+    def fromfilepath(self, file_path: str, transcribe_overrides: dict = None):
+        assert self.whisper_model is not None, 'faster_whisper should be installed via "pip install "faster_whisper"'
+        transcribe_overrides = transcribe_overrides or {}
+        default_transcribe_settings = {
+            'language': None, 'vad_filter': True, 'vad_parameters': dict(min_silence_duration_ms=300), 'chunk_length': 30, 'beam_size': 5
+        }
+        default_transcribe_settings.update(transcribe_overrides)
+        segs, info = self.whisper_model.transcribe(file_path, **default_transcribe_settings)
+        lrc = "\n".join(f"{self.timestamp(s.start)}{s.text.strip()}" for s in segs)
+        result = {"language": info.language, "prob": info.language_probability, "duration": getattr(info, "duration", None), 'lyric': lrc}
+        return result