vncmd 0.1.7__py3-none-any.whl

function/_defaults.py

@@ -0,0 +1,45 @@
+CONFIG_TOML = """\
+[download]
+# Absolute path, relative to VNCMD_HOME, or empty for ~/Downloads
+dir = ""
+# Filename format: 10=Title-Artist, 01=Artist-Title, 1=Title only
+filename_format = "10"
+# Download content: 0=song, 1=lyrics, 2=cover (e.g. 012=all, 12=lyrics&cover)
+content = "012"
+
+[download.song]
+# Audio quality: 128, 192, 320, 999 (highest)
+quality = "999"
+
+[download.lyric]
+# Embedded lyrics mode: 0=interleaved, 1=merged, 2=original only
+embed_mode = "2"
+# Standalone lyrics file mode: 0=interleaved, 1=merged, 2=separate files
+save_mode = "0"
+
+[download.cover]
+# Embedded cover quality: 0=original, 1=resize to max 500x500 JPEG
+embed_quality = "1"
+# Standalone cover file quality: 0=original, 1=resize to max 500x500 JPEG
+save_quality = "0"
+
+[cache]
+# Enable local cache for song details and lyrics
+enabled = true
+# Absolute path, or relative to VNCMD_HOME
+dir = "cache"
+"""
+
+TRACKER_SETTINGS_TOML = """\
+[tracker]
+description = "Describe this tracker here"
+
+[sources.song]
+ids = []
+
+[sources.playlist]
+ids = []
+
+[sources.album]
+ids = []
+"""

function/api.py

@@ -0,0 +1,273 @@
+import time
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from function.config import get_cookie
+from function.cache import get_song as cache_get_song, put_song as cache_put_song
+from function.cache import (
+    get_lyrics as cache_get_lyrics,
+    put_lyrics as cache_put_lyrics,
+)
+
+BASE_URL = "https://music.163.com"
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Referer": "https://music.163.com/",
+}
+
+_session = None
+
+
+def _get_session():
+    global _session
+    if _session is None:
+        _session = requests.Session()
+        _session.headers.update(HEADERS)
+
+        retry = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[500, 502, 503, 504],
+            allowed_methods={"GET"},
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        _session.mount("http://", adapter)
+        _session.mount("https://", adapter)
+
+        cookie = get_cookie()
+        if cookie:
+            for item in cookie.split(";"):
+                item = item.strip()
+                if "=" not in item:
+                    continue
+                name, value = item.split("=", 1)
+                name = name.strip()
+                value = value.strip()
+                try:
+                    value.encode("latin-1")
+                except UnicodeEncodeError:
+                    value = value.encode("latin-1", errors="ignore").decode("latin-1")
+                if name and value:
+                    _session.cookies.set(name, value, domain="music.163.com")
+    return _session
+
+
+def format_timestamp(ts: int | None) -> str:
+    if ts is None:
+        return ""
+    t = time.localtime(ts / 1000)
+    return time.strftime("%Y-%m-%d %H:%M:%S", t)
+
+
+def _fmt_duration(ms: int | None) -> str:
+    if not ms:
+        return ""
+    total_sec = ms // 1000
+    m, s = divmod(total_sec, 60)
+    return f"{m}:{s:02d}"
+
+
+def get_song_details(song_id: int) -> dict:
+    cached = cache_get_song(song_id)
+    if cached:
+        return cached
+
+    url = f"{BASE_URL}/api/song/detail/?id={song_id}&ids=%5B{song_id}%5D"
+    resp = _get_session().get(url, timeout=15)
+    data = resp.json()
+    if not data.get("songs"):
+        raise ValueError(f"Song {song_id} not found")
+
+    song = data["songs"][0]
+    result = {
+        "id": song["id"],
+        "title": song["name"],
+        "artist": ",".join(a["name"] for a in song.get("artists", [])),
+        "album": song.get("album", {}).get("name", ""),
+        "album_id": song.get("album", {}).get("id"),
+        "cover": song.get("album", {}).get("picUrl", ""),
+        "publish_time": format_timestamp(song.get("album", {}).get("publishTime")),
+        "duration": _fmt_duration(song.get("duration")),
+    }
+    cache_put_song(song_id, result)
+    return result
+
+
+def get_playlist_details(playlist_id: int, limit: int | None = None) -> dict:
+    url = f"{BASE_URL}/api/v6/playlist/detail/?id={playlist_id}"
+    resp = _get_session().get(url, timeout=15)
+    data = resp.json()
+    if not data.get("playlist"):
+        raise ValueError(f"Playlist {playlist_id} not found")
+
+    pl = data["playlist"]
+    tracks = []
+
+    full_tracks = pl.get("tracks") or []
+    track_ids = pl.get("trackIds") or []
+    ft_map = {t["id"]: t for t in full_tracks}
+
+    # Limit resolution to what's needed
+    resolve_count = min(limit, len(track_ids)) if limit else len(track_ids)
+
+    if track_ids and resolve_count > 0:
+        if resolve_count > len(full_tracks):
+            print(f"Resolving {resolve_count} tracks...")
+        for i, tid in enumerate(track_ids[:resolve_count]):
+            sid = tid if isinstance(tid, int) else tid["id"]
+            ft = ft_map.get(sid)
+            if ft:
+                tracks.append(
+                    {
+                        "id": ft["id"],
+                        "title": ft["name"],
+                        "artist": ", ".join(a["name"] for a in ft.get("ar", [])),
+                        "album": ft.get("al", {}).get("name", ""),
+                        "cover": ft.get("al", {}).get("picUrl", ""),
+                        "publish_time": format_timestamp(
+                            ft.get("publishTime") or ft.get("al", {}).get("publishTime")
+                        ),
+                        "duration": _fmt_duration(ft.get("dt")),
+                    }
+                )
+            else:
+                try:
+                    song = get_song_details(sid)
+                    tracks.append(
+                        {
+                            "id": song["id"],
+                            "title": song["title"],
+                            "artist": song["artist"],
+                            "album": song["album"],
+                            "cover": song["cover"],
+                            "publish_time": song["publish_time"],
+                            "duration": song["duration"],
+                        }
+                    )
+                except Exception:
+                    pass
+            if (i + 1) % 20 == 0:
+                print(f"  ... {i + 1}/{len(track_ids)}")
+            time.sleep(0.1)
+    elif full_tracks:
+        for t in full_tracks:
+            tracks.append(
+                {
+                    "id": t["id"],
+                    "title": t["name"],
+                    "artist": ", ".join(a["name"] for a in t.get("ar", [])),
+                    "album": t.get("al", {}).get("name", ""),
+                    "cover": t.get("al", {}).get("picUrl", ""),
+                    "publish_time": format_timestamp(
+                        t.get("publishTime") or t.get("al", {}).get("publishTime")
+                    ),
+                    "duration": _fmt_duration(t.get("dt")),
+                }
+            )
+
+    result = {
+        "id": pl["id"],
+        "name": pl["name"],
+        "creator": pl.get("creator", {}).get("nickname", ""),
+        "cover": pl.get("coverImgUrl", ""),
+        "track_count": pl.get("trackCount", len(tracks)),
+        "tracks": tracks,
+    }
+    return result
+
+
+def get_album_details(album_id: int) -> dict:
+    url = f"{BASE_URL}/api/v1/album/{album_id}"
+    resp = _get_session().get(url, timeout=15)
+    data = resp.json()
+    album = data.get("album")
+    if not album:
+        raise ValueError(f"Album {album_id} not found")
+
+    tracks = []
+    for s in data.get("songs", []):
+        tracks.append(
+            {
+                "id": s["id"],
+                "title": s["name"],
+                "artist": ", ".join(a["name"] for a in s.get("ar", [])),
+                "album": album.get("name", ""),
+                "cover": album.get("picUrl", ""),
+                "publish_time": format_timestamp(
+                    s.get("publishTime") or album.get("publishTime")
+                ),
+                "duration": _fmt_duration(s.get("dt")),
+            }
+        )
+
+    return {
+        "id": album["id"],
+        "name": album["name"],
+        "artist": album.get("artist", {}).get("name", ""),
+        "cover": album.get("picUrl", ""),
+        "track_count": album.get("size", len(tracks)),
+        "tracks": tracks,
+    }
+
+
+def search(q: str, limit: int = 30, offset: int = 0) -> dict:
+    url = f"{BASE_URL}/api/cloudsearch/pc?type=1&s={q}&limit={limit}&offset={offset}"
+    resp = _get_session().get(url, timeout=15)
+    data = resp.json()
+    if data.get("code") != 200:
+        raise ValueError(f"Search failed: {data}")
+
+    songs = []
+    for s in data.get("result", {}).get("songs", []):
+        songs.append(
+            {
+                "id": s["id"],
+                "title": s["name"],
+                "artist": ",".join(a["name"] for a in s.get("ar", [])),
+                "album": s.get("al", {}).get("name", ""),
+                "cover": s.get("al", {}).get("picUrl", ""),
+                "publish_time": format_timestamp(s.get("publishTime")),
+                "duration": _fmt_duration(s.get("dt")),
+            }
+        )
+
+    return {
+        "total": data.get("result", {}).get("songCount", 0),
+        "songs": songs,
+    }
+
+
+def get_lyrics_url(song_id: int) -> str:
+    return f"{BASE_URL}/api/song/lyric?os=pc&id={song_id}&lv=-1&tv=1"
+
+
+def get_lyrics(song_id: int) -> dict:
+    cached = cache_get_lyrics(song_id)
+    if cached:
+        return cached
+
+    url = get_lyrics_url(song_id)
+    try:
+        resp = _get_session().get(url, timeout=15)
+        data = resp.json()
+    except Exception:
+        return {"lrc": {"lyric": ""}, "tlyric": {"lyric": ""}}
+
+    if data.get("code") != 200:
+        return {"lrc": {"lyric": ""}, "tlyric": {"lyric": ""}}
+
+    result = {"lrc": data.get("lrc", {}), "tlyric": data.get("tlyric", {})}
+    cache_put_lyrics(song_id, result)
+    return result
+
+
+def get_song_url(song_id: int, quality: int | None = None) -> str | None:
+    br = quality if quality else 2147483647
+    url = f"{BASE_URL}/api/song/enhance/player/url?ids=[{song_id}]&br={br}"
+    resp = _get_session().get(url, timeout=15)
+    data = resp.json()
+    if data.get("data") and data["data"][0].get("url"):
+        return data["data"][0]["url"]
+    return None

function/audio.py

@@ -0,0 +1,47 @@
+import re
+from pathlib import Path
+
+from function.config import get_filename_format
+
+
+def check_filename(name: str) -> str:
+    return re.sub(r'[\\/:*?"<>|]', "-", name)
+
+
+def get_type_from_url(url: str) -> str:
+    pattern = r"((?!.*\.))([^?]+)"
+    matches = re.search(pattern, url)
+    if matches:
+        ext = matches.group(0)
+        if ext in ("mp3", "flac", "m4a", "wav", "ogg"):
+            return ext
+    return "mp3"
+
+
+def cover_ext(cover_url: str | None) -> str:
+    if not cover_url:
+        return "jpg"
+    ext = cover_url.rsplit("?", 1)[0].rsplit(".", 1)[-1].lower()
+    return ext if ext in ("jpg", "jpeg", "png") else "jpg"
+
+
+def build_filename(title: str, artist: str) -> str:
+    fmt = get_filename_format()
+    safe_title = check_filename(title)
+    safe_artist = check_filename(artist)
+    if fmt == "10":
+        return f"{safe_title} - {safe_artist}"
+    elif fmt == "01":
+        return f"{safe_artist} - {safe_title}"
+    else:
+        return safe_title
+
+
+def resolve_path(base: str, ext: str, directory: str) -> str:
+    counter = 0
+    while True:
+        suffix = f"({counter})" if counter > 0 else ""
+        path = Path(directory) / f"{base}{suffix}.{ext}"
+        if not path.exists():
+            return str(path)
+        counter += 1

function/cache.py

@@ -0,0 +1,60 @@
+import json
+from pathlib import Path
+
+from function.config import get_cache_dir, is_cache_enabled
+
+
+def _song_dir(song_id: int) -> Path:
+    path = Path(get_cache_dir()) / "song" / str(song_id)
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_song_cache_dir(song_id: int) -> Path:
+    return _song_dir(song_id)
+
+
+def get_song(song_id: int) -> dict | None:
+    if not is_cache_enabled():
+        return None
+    path = _song_dir(song_id) / "info.json"
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def put_song(song_id: int, data: dict) -> None:
+    if not is_cache_enabled():
+        return
+    path = _song_dir(song_id) / "info.json"
+    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+
+
+def get_lyrics(song_id: int) -> dict | None:
+    """Read lyrics from cache. Returns dict {lrc, tlyric} or None."""
+    if not is_cache_enabled():
+        return None
+    d = _song_dir(song_id)
+    lrc_path = d / "lyric.lrc"
+    if not lrc_path.exists():
+        return None
+    result = {"lrc": {"lyric": lrc_path.read_text(encoding="utf-8")}}
+    tlyric_path = d / "tlyric.lrc"
+    if tlyric_path.exists():
+        result["tlyric"] = {"lyric": tlyric_path.read_text(encoding="utf-8")}
+    else:
+        result["tlyric"] = {"lyric": ""}
+    return result
+
+
+def put_lyrics(song_id: int, data: dict) -> None:
+    """Save lyrics to cache. data is {lrc: {lyric: str}, tlyric: {lyric: str}}."""
+    if not is_cache_enabled():
+        return
+    d = _song_dir(song_id)
+    lrc_text = data.get("lrc", {}).get("lyric", "")
+    (d / "lyric.lrc").write_text(lrc_text, encoding="utf-8")
+
+    tlyric_text = data.get("tlyric", {}).get("lyric", "")
+    if tlyric_text:
+        (d / "tlyric.lrc").write_text(tlyric_text, encoding="utf-8")

function/checkpoint.py

@@ -0,0 +1,92 @@
+import json
+from pathlib import Path
+
+from function.config import get_cache_dir
+from function.output import info
+
+_CHECKPOINT_DIR = None
+
+
+def _get_checkpoint_dir():
+    global _CHECKPOINT_DIR
+    if _CHECKPOINT_DIR is None:
+        _CHECKPOINT_DIR = Path(get_cache_dir()) / "download"
+    _CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)
+    return _CHECKPOINT_DIR
+
+
+def get_checkpoint_path(dl_type: str, dl_id: str) -> Path:
+    return _get_checkpoint_dir() / f"{dl_type}_{dl_id}.json"
+
+
+def load_checkpoint(dl_type: str, dl_id: str) -> dict | None:
+    path = get_checkpoint_path(dl_type, dl_id)
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def save_checkpoint(dl_type: str, dl_id: str, data: dict) -> None:
+    path = get_checkpoint_path(dl_type, dl_id)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def create_checkpoint(dl_type: str, dl_id: str, download_dir: str, track_ids: list[int]) -> dict:
+    data = {
+        "type": dl_type,
+        "id": dl_id,
+        "download_dir": download_dir,
+        "tracks": {str(tid): False for tid in track_ids},
+    }
+    save_checkpoint(dl_type, dl_id, data)
+    return data
+
+
+def mark_downloaded(dl_type: str, dl_id: str, song_id: int) -> None:
+    cp = load_checkpoint(dl_type, dl_id)
+    if cp is None:
+        return
+    cp["tracks"][str(song_id)] = True
+    save_checkpoint(dl_type, dl_id, cp)
+
+
+def sync_checkpoint_tracks(dl_type: str, dl_id: str, current_tracks: dict[str, str]) -> tuple[list[str], bool]:
+    """Sync checkpoint tracks with current API list.
+
+    ``current_tracks`` is a dict of ``{id: title}``.
+    Returns ``(pending_ids, has_changes)``.
+    For album/playlist: notifies about added/removed tracks with titles.
+    For tracker: silently updates.
+    """
+    cp = load_checkpoint(dl_type, dl_id)
+    if cp is None:
+        return list(current_tracks.keys()), False
+
+    current_ids = {str(tid) for tid in current_tracks}
+    cp_ids = set(cp["tracks"].keys())
+    new_ids = current_ids - cp_ids
+    removed_ids = cp_ids - current_ids
+
+    # Update checkpoint: add new tracks, remove gone tracks
+    for tid in new_ids:
+        cp["tracks"][tid] = False
+    has_changes = bool(new_ids or removed_ids)
+
+    # Notify for album/playlist
+    if dl_type in ("album", "playlist") and has_changes:
+        for tid in sorted(new_ids):
+            title = current_tracks.get(tid, current_tracks.get(int(tid), "?"))
+            info(f"  New track in {dl_type}: {title} (ID {tid})")
+        for tid in sorted(removed_ids):
+            info(f"  Track removed from {dl_type}: ID {tid}")
+        info(
+            "  Tip: if this list changes often, consider using the tracker feature"
+            " (vncmd tracker --help)"
+        )
+
+    for tid in removed_ids:
+        del cp["tracks"][tid]
+    save_checkpoint(dl_type, dl_id, cp)
+
+    pending = [tid for tid, done in cp["tracks"].items() if not done]
+    return pending, has_changes