scripts/crawl_mureka.py

#!/usr/bin/env python3
# pyright: basic, reportDeprecated=false, reportUnknownParameterType=false, reportMissingTypeArgument=false, reportUnknownVariableType=false, reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnusedCallResult=false, reportUnusedImport=false

import argparse
import html
import json
import re
import time
import xml.etree.ElementTree as ET
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
from urllib.parse import urljoin, urlparse

from utils import *


USER_AGENT = (
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
    "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
)

SITEMAP_URL = "https://www.mureka.ai/sitemap.xml"
HOME_URL = "https://www.mureka.ai/home"
API_BASE = "https://www.mureka.ai"
CDN_BASE = "https://static-cos.mureka.ai"

SUPPORTED_VERSIONS = ["v6", "v7.5", "v8"]
DEFAULT_TARGET = 2000
MAX_GENRE_PAGES = 300


def sanitize_filename(name: str) -> str:
    cleaned = re.sub(r"[^\w\-. ]+", "_", (name or "untitled").strip())
    cleaned = re.sub(r"\s+", "_", cleaned)
    return cleaned[:140] if cleaned else "untitled"


def normalize_tags(raw_tags: Any) -> List[str]:
    if isinstance(raw_tags, list):
        return [str(t).strip() for t in raw_tags if str(t).strip()]
    if isinstance(raw_tags, str):
        return [t.strip() for t in raw_tags.split(",") if t.strip()]
    return []


def detect_version_from_text(text: str) -> Optional[str]:
    t = (text or "").lower()
    if "v7.5" in t or "7.5" in t or re.search(r"\bv7\b", t):
        return "v7.5"
    if re.search(r"\bv8\b", t):
        return "v8"
    if re.search(r"\bv6\b", t):
        return "v6"
    return None


def detect_version(
    song: Dict[str, Any], feed: Optional[Dict[str, Any]] = None
) -> Optional[str]:
    candidates = [
        song.get("model"),
        song.get("model_version"),
        song.get("modelVersion"),
        (song.get("model_bandage") or {}).get("display_name")
        if isinstance(song.get("model_bandage"), dict)
        else None,
        (feed or {}).get("model"),
        song.get("title"),
        song.get("description"),
    ]
    for value in candidates:
        detected = detect_version_from_text(str(value) if value is not None else "")
        if detected:
            return detected
    return None


def canonicalize_mp3_url(raw_url: str) -> Optional[str]:
    if not raw_url:
        return None
    value = html.unescape(str(raw_url).strip())
    if not value:
        return None
    if value.startswith("http://") or value.startswith("https://"):
        return value
    cleaned = value.lstrip("/")
    if not cleaned:
        return None
    return f"{CDN_BASE}/{cleaned}"


def build_source_url(song: Dict[str, Any]) -> Optional[str]:
    share_key = str(song.get("share_key") or "").strip()
    if share_key:
        return f"https://www.mureka.ai/song-detail/{share_key}?is_from_share=1"
    song_id = str(song.get("song_id") or "").strip()
    if song_id:
        return f"https://www.mureka.ai/song-detail/{song_id}"
    return None


def request_with_backoff(
    session: requests.Session,
    method: str,
    url: str,
    limiter: RateLimiter,
    *,
    params: Optional[Dict[str, Any]] = None,
    timeout: int = 30,
    max_retries: int = 5,
) -> Optional[requests.Response]:
    delay = 1.0
    for attempt in range(1, max_retries + 1):
        limiter.wait()
        try:
            resp = session.request(
                method=method.upper(), url=url, params=params, timeout=timeout
            )
        except requests.RequestException as exc:
            if attempt == max_retries:
                logger.warning(f"Request failed for {url}: {exc}")
                return None
            time.sleep(min(delay, 30))
            delay *= 2
            continue

        if resp.status_code == 429:
            retry_after = resp.headers.get("Retry-After")
            wait_seconds = delay
            if retry_after:
                try:
                    wait_seconds = max(wait_seconds, float(retry_after))
                except ValueError:
                    pass
            logger.warning(f"429 from {url}; retrying in {wait_seconds:.1f}s")
            resp.close()
            time.sleep(min(wait_seconds, 30))
            delay *= 2
            continue

        if resp.status_code >= 500:
            logger.warning(f"Server error {resp.status_code} from {url}")
            resp.close()
            if attempt == max_retries:
                return None
            time.sleep(min(delay, 30))
            delay *= 2
            continue

        return resp

    return None


def fetch_json(
    session: requests.Session,
    endpoint: str,
    limiter: RateLimiter,
    params: Optional[Dict[str, Any]] = None,
) -> Optional[Dict[str, Any]]:
    url = endpoint if endpoint.startswith("http") else urljoin(API_BASE, endpoint)
    resp = request_with_backoff(session, "GET", url, limiter, params=params)
    if resp is None:
        return None

    try:
        if resp.status_code in {403, 404}:
            logger.warning(f"Skipping {url} with HTTP {resp.status_code}")
            return None
        if resp.status_code >= 400:
            logger.warning(f"HTTP {resp.status_code} for {url}")
            return None
        data = resp.json()
        if isinstance(data, dict):
            return data
        return None
    except ValueError:
        logger.warning(f"Failed to parse JSON from {url}")
        return None
    finally:
        resp.close()


def fetch_text(
    session: requests.Session,
    url: str,
    limiter: RateLimiter,
) -> Optional[str]:
    resp = request_with_backoff(session, "GET", url, limiter)
    if resp is None:
        return None
    try:
        if resp.status_code in {403, 404}:
            logger.warning(f"Skipping {url} with HTTP {resp.status_code}")
            return None
        if resp.status_code >= 400:
            logger.warning(f"HTTP {resp.status_code} for {url}")
            return None
        return resp.text
    finally:
        resp.close()


def parse_genre_pages_from_sitemap(xml_text: str) -> List[Tuple[str, int, str]]:
    pages: List[Tuple[str, int, str]] = []
    try:
        root = ET.fromstring(xml_text)
    except ET.ParseError as exc:
        logger.warning(f"Failed to parse sitemap XML: {exc}")
        return pages

    namespace = {"sm": "http://www.sitemaps.org/schemas/sitemap/0.9"}
    loc_nodes = root.findall("sm:url/sm:loc", namespace)
    seen_ids: Set[int] = set()

    for loc in loc_nodes:
        raw = (loc.text or "").strip()
        if "/genre/" not in raw:
            continue
        match = re.search(r"/genre/([^/]+)/([0-9]+)", raw)
        if not match:
            continue
        slug = match.group(1)
        genre_id = int(match.group(2))
        if genre_id in seen_ids:
            continue
        seen_ids.add(genre_id)
        pages.append((raw, genre_id, slug))

    return pages


def extract_api_endpoints_from_text(text: str) -> Set[str]:
    found: Set[str] = set()
    if not text:
        return found

    for rel in re.findall(r'"(/api/[^"\s]+)"', text):
        if "{" in rel or "}" in rel:
            continue
        found.add(urljoin(API_BASE, rel))
    for rel in re.findall(r"'(/api/[^'\s]+)'", text):
        if "{" in rel or "}" in rel:
            continue
        found.add(urljoin(API_BASE, rel))
    return found


def collect_song_like_nodes(node: Any, out: List[Dict[str, Any]]) -> None:
    if isinstance(node, dict):
        if node.get("song_id") and (node.get("mp3_url") or node.get("song_url")):
            out.append(node)
        for value in node.values():
            if isinstance(value, (dict, list)):
                collect_song_like_nodes(value, out)
    elif isinstance(node, list):
        for value in node:
            if isinstance(value, (dict, list)):
                collect_song_like_nodes(value, out)


def extract_embedded_song_candidates(
    html_text: str,
    source_url: str,
    genre_hint: Optional[str] = None,
) -> List[Dict[str, Any]]:
    candidates: List[Dict[str, Any]] = []
    if not html_text:
        return candidates

    json_blobs: List[str] = []

    for pat in [
        r"window\.__INITIAL_STATE__\s*=\s*(\{.*?\});",
        r"window\.__NEXT_DATA__\s*=\s*(\{.*?\});",
        r"window\.__INITIAL_DATA__\s*=\s*(\{.*?\});",
    ]:
        json_blobs.extend(re.findall(pat, html_text, flags=re.DOTALL))

    script_json_blobs = re.findall(
        r'<script[^>]*type="application/json"[^>]*>(.*?)</script>',
        html_text,
        flags=re.DOTALL | re.IGNORECASE,
    )
    json_blobs.extend(script_json_blobs)

    for blob in json_blobs:
        text = blob.strip()
        if not text.startswith("{"):
            continue
        try:
            payload = json.loads(text)
        except ValueError:
            continue
        nodes: List[Dict[str, Any]] = []
        collect_song_like_nodes(payload, nodes)
        for song in nodes:
            candidates.append(
                {
                    "song": song,
                    "feed": {},
                    "source_hint": f"embedded:{source_url}",
                    "genre_hint": genre_hint,
                }
            )

    return candidates


def to_song_candidate(
    song: Dict[str, Any],
    feed: Optional[Dict[str, Any]],
    source_hint: str,
    genre_hint: Optional[str],
) -> Optional[Dict[str, Any]]:
    song_id = str(song.get("song_id") or "").strip()
    if not song_id:
        return None

    download_url = canonicalize_mp3_url(
        str(song.get("mp3_url") or song.get("song_url") or "")
    )
    if not download_url:
        return None

    title = str(song.get("title") or "untitled").strip() or "untitled"
    version = detect_version(song, feed)

    genres = normalize_tags(song.get("genres") or [])
    moods = normalize_tags(song.get("moods") or [])
    description = str(song.get("description") or "").strip() or None
    tags = list(dict.fromkeys([*genres, *moods]))

    if genre_hint and genre_hint not in genres:
        genres = [*genres, genre_hint]

    return {
        "track_id": song_id,
        "title": title,
        "version": version,
        "prompt": description,
        "genre": genres[0] if genres else genre_hint,
        "genres": genres,
        "moods": moods,
        "tags": tags,
        "source_url": build_source_url(song),
        "download_url": download_url,
        "source_hint": source_hint,
    }


def pick_version_for_candidate(
    detected: Optional[str],
    requested_versions: List[str],
    counts: Dict[str, int],
    target: int,
    fallback_counter: List[int],
) -> Optional[str]:
    pending = [v for v in requested_versions if counts.get(v, 0) < target]
    if not pending:
        return None

    if detected in pending:
        return detected

    if len(requested_versions) == 1:
        only = requested_versions[0]
        return only if counts.get(only, 0) < target else None

    min_count = min(counts.get(v, 0) for v in pending)
    min_versions = [v for v in pending if counts.get(v, 0) == min_count]
    idx = fallback_counter[0] % len(min_versions)
    fallback_counter[0] += 1
    return min_versions[idx]


def load_existing_track_ids(managers: Dict[str, MetadataManager]) -> Set[str]:
    seen: Set[str] = set()
    for manager in managers.values():
        jsonl_path = manager.folder_path / "metadata.jsonl"
        if not jsonl_path.exists():
            continue
        try:
            with open(jsonl_path, "r", encoding="utf-8") as fin:
                for line in fin:
                    try:
                        data = json.loads(line.strip())
                    except json.JSONDecodeError:
                        continue
                    track_id = str(data.get("track_id") or "").strip()
                    if track_id:
                        seen.add(track_id)
        except Exception as exc:
            logger.warning(f"Failed loading existing metadata from {jsonl_path}: {exc}")
    return seen


def download_with_backoff(
    session: requests.Session,
    url: str,
    output_path: Path,
    limiter: RateLimiter,
    max_retries: int = 5,
) -> bool:
    if output_path.exists() and output_path.stat().st_size > 1000:
        return True

    tmp_path = output_path.with_suffix(output_path.suffix + ".part")
    delay = 1.0

    for attempt in range(1, max_retries + 1):
        limiter.wait()
        try:
            resp = session.get(url, timeout=60, stream=True)
        except requests.RequestException as exc:
            logger.warning(f"Download request failed for {url}: {exc}")
            if attempt == max_retries:
                return False
            time.sleep(min(delay, 30))
            delay *= 2
            continue

        status = resp.status_code
        if status in {403, 404}:
            logger.warning(f"CDN returned {status} for {url}")
            resp.close()
            return False
        if status == 429:
            retry_after = resp.headers.get("Retry-After")
            wait_seconds = delay
            if retry_after:
                try:
                    wait_seconds = max(wait_seconds, float(retry_after))
                except ValueError:
                    pass
            logger.warning(f"CDN 429 for {url}; retrying in {wait_seconds:.1f}s")
            resp.close()
            time.sleep(min(wait_seconds, 30))
            delay *= 2
            continue
        if status >= 500:
            logger.warning(f"CDN server error {status} for {url}")
            resp.close()
            if attempt == max_retries:
                return False
            time.sleep(min(delay, 30))
            delay *= 2
            continue
        if status >= 400:
            logger.warning(f"CDN HTTP {status} for {url}")
            resp.close()
            return False

        try:
            output_path.parent.mkdir(parents=True, exist_ok=True)
            with open(tmp_path, "wb") as fout:
                for chunk in resp.iter_content(chunk_size=8192):
                    if chunk:
                        fout.write(chunk)
        except Exception as exc:
            logger.warning(f"Failed writing {output_path}: {exc}")
            tmp_path.unlink(missing_ok=True)
            resp.close()
            if attempt == max_retries:
                return False
            time.sleep(min(delay, 30))
            delay *= 2
            continue
        finally:
            resp.close()

        if not tmp_path.exists() or tmp_path.stat().st_size < 1000:
            logger.warning(f"Downloaded file too small for {url}")
            tmp_path.unlink(missing_ok=True)
            if attempt == max_retries:
                return False
            time.sleep(min(delay, 30))
            delay *= 2
            continue

        tmp_path.replace(output_path)
        return True

    return False


def create_track_metadata(
    candidate: Dict[str, Any],
    file_path: Path,
    version: str,
) -> TrackMetadata:
    audio_info = get_audio_info(file_path)
    tags = normalize_tags(candidate.get("tags") or [])
    for extra_tag in [
        *(candidate.get("genres") or []),
        *(candidate.get("moods") or []),
    ]:
        if extra_tag and extra_tag not in tags:
            tags.append(extra_tag)
    if "mureka" not in [t.lower() for t in tags]:
        tags.append("mureka")

    return TrackMetadata(
        track_id=str(candidate.get("track_id") or ""),
        filename=file_path.name,
        category="A_commercial",
        subcategory=f"mureka_{version}",
        source_platform="mureka",
        source_type="commercial",
        model_name="Mureka",
        model_version=version,
        title=str(candidate.get("title") or "untitled"),
        prompt=str(candidate.get("prompt")) if candidate.get("prompt") else None,
        genre=str(candidate.get("genre")) if candidate.get("genre") else None,
        tags=tags,
        source_url=str(candidate.get("source_url"))
        if candidate.get("source_url")
        else None,
        download_url=str(candidate.get("download_url") or ""),
        collection_method="crawl",
        duration_sec=audio_info.get("duration_sec"),
        sample_rate=audio_info.get("sample_rate"),
        channels=audio_info.get("channels"),
        bitrate_kbps=audio_info.get("bitrate_kbps"),
        file_size_bytes=audio_info.get("file_size_bytes") or file_path.stat().st_size,
        audio_format="mp3",
        md5_hash=compute_md5(file_path),
    )


def process_candidate(
    session: requests.Session,
    candidate: Dict[str, Any],
    requested_versions: List[str],
    managers: Dict[str, MetadataManager],
    output_dirs: Dict[str, Path],
    counts: Dict[str, int],
    seen_song_ids: Set[str],
    target: int,
    fallback_counter: List[int],
    download_limiter: RateLimiter,
    progress: tqdm,
) -> bool:
    track_id = str(candidate.get("track_id") or "").strip()
    if not track_id or track_id in seen_song_ids:
        return False

    selected_version = pick_version_for_candidate(
        candidate.get("version"),
        requested_versions,
        counts,
        target,
        fallback_counter,
    )
    if not selected_version:
        return False

    manager = managers[selected_version]
    output_dir = output_dirs[selected_version]

    title = str(candidate.get("title") or "untitled").strip() or "untitled"
    filename = f"{track_id}_{sanitize_filename(title)}.mp3"
    file_path = output_dir / filename

    if (
        manager.has_track(track_id)
        and file_path.exists()
        and file_path.stat().st_size > 1000
    ):
        seen_song_ids.add(track_id)
        return False

    if not ensure_disk_space():
        logger.warning("Stopping due to insufficient disk space")
        return False

    download_url = str(candidate.get("download_url") or "")
    if not download_url:
        return False

    ok = download_with_backoff(session, download_url, file_path, download_limiter)
    if not ok:
        return False

    meta = create_track_metadata(candidate, file_path, selected_version)
    manager.add_track(meta)
    counts[selected_version] = manager.get_count()
    seen_song_ids.add(track_id)
    progress.update(1)
    return True


def build_progress_desc(
    counts: Dict[str, int], target: int, requested_versions: List[str]
) -> str:
    pieces = [f"{v}={counts.get(v, 0)}/{target}" for v in requested_versions]
    total = sum(counts.get(v, 0) for v in requested_versions)
    return f"mureka: {total}/{target * len(requested_versions)} [{', '.join(pieces)}]"


def resolve_output_dirs(version: str, output_dir: Optional[str]) -> Dict[str, Path]:
    if version == "all":
        base = Path(output_dir) if output_dir else FAKE_DIR / "A_commercial"
        return {v: base / f"mureka_{v}" for v in SUPPORTED_VERSIONS}

    if output_dir:
        return {version: Path(output_dir)}
    return {version: FAKE_DIR / "A_commercial" / f"mureka_{version}"}


def extract_genre_hint(slug: str) -> str:
    return slug.replace("%20", " ").replace("-", " ").strip()


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--target", type=int, default=DEFAULT_TARGET)
    parser.add_argument(
        "--version",
        type=str,
        default="all",
        choices=["v6", "v7.5", "v8", "all"],
    )
    parser.add_argument("--output-dir", type=str, default=None)
    args = parser.parse_args()

    requested_versions = SUPPORTED_VERSIONS if args.version == "all" else [args.version]
    output_dirs = resolve_output_dirs(args.version, args.output_dir)

    for out_dir in output_dirs.values():
        out_dir.mkdir(parents=True, exist_ok=True)

    managers = {v: MetadataManager(output_dirs[v]) for v in requested_versions}
    counts = {v: managers[v].get_count() for v in requested_versions}
    seen_song_ids = load_existing_track_ids(managers)

    if all(counts[v] >= args.target for v in requested_versions):
        logger.info("Requested Mureka targets already satisfied")
        for manager in managers.values():
            manager.update_summary()
        return

    session = requests.Session()
    session.headers.update(
        {
            "User-Agent": USER_AGENT,
            "Accept": "application/json,text/plain,text/html,*/*",
            "Referer": "https://www.mureka.ai/home",
        }
    )

    page_limiter = RateLimiter(requests_per_second=1.0)
    download_limiter = RateLimiter(requests_per_second=2.0)
    fallback_counter = [0]

    progress = tqdm(
        total=args.target * len(requested_versions),
        initial=sum(counts.values()),
        desc=build_progress_desc(counts, args.target, requested_versions),
        unit="track",
    )

    known_api_endpoints: Set[str] = {
        f"{API_BASE}/api/pgc/song/songs_by_genre",
        f"{API_BASE}/api/pgc/home/modules",
        f"{API_BASE}/api/pgc/home/modules/featured-songs",
        f"{API_BASE}/api/pgc/home/modules/featured-playlist",
        f"{API_BASE}/api/pgc/song/recommend_list",
    }

    def targets_filled() -> bool:
        return all(counts.get(v, 0) >= args.target for v in requested_versions)

    try:
        sitemap_text = fetch_text(session, SITEMAP_URL, page_limiter)
        genre_pages = parse_genre_pages_from_sitemap(sitemap_text or "")
        logger.info(f"Discovered {len(genre_pages)} genre pages from sitemap")

        home_html = fetch_text(session, HOME_URL, page_limiter)
        if home_html:
            known_api_endpoints.update(extract_api_endpoints_from_text(home_html))
            for embedded in extract_embedded_song_candidates(home_html, HOME_URL):
                candidate = to_song_candidate(
                    embedded.get("song") or {},
                    embedded.get("feed") or {},
                    embedded.get("source_hint") or "embedded:home",
                    embedded.get("genre_hint"),
                )
                if not candidate:
                    continue
                if process_candidate(
                    session,
                    candidate,
                    requested_versions,
                    managers,
                    output_dirs,
                    counts,
                    seen_song_ids,
                    args.target,
                    fallback_counter,
                    download_limiter,
                    progress,
                ):
                    progress.set_description(
                        build_progress_desc(counts, args.target, requested_versions)
                    )

        if not targets_filled():
            modules_payload = fetch_json(
                session,
                "/api/pgc/home/modules",
                page_limiter,
                params={"page_size": 20},
            )
            module_feeds = (
                ((modules_payload or {}).get("data") or {}).get("feeds")
                if isinstance((modules_payload or {}).get("data"), dict)
                else []
            )
            if isinstance(module_feeds, list):
                for module in module_feeds:
                    if not isinstance(module, dict):
                        continue
                    module_id = module.get("id")
                    module_type = module.get("type")
                    if not module_id:
                        continue

                    endpoint = None
                    if module_type == 100:
                        endpoint = "/api/pgc/home/modules/featured-songs"
                    elif module_type in {101, 102}:
                        endpoint = "/api/pgc/home/modules/featured-playlist"
                    if not endpoint:
                        continue

                    payload = fetch_json(
                        session,
                        endpoint,
                        page_limiter,
                        params={"module_id": module_id},
                    )
                    if not payload:
                        continue
                    data = payload.get("data") if isinstance(payload, dict) else None
                    if not isinstance(data, dict):
                        continue

                    if endpoint.endswith("featured-songs"):
                        raw_featured_song_feeds = data.get("feeds")
                        featured_song_feeds: List[Any] = (
                            raw_featured_song_feeds
                            if isinstance(raw_featured_song_feeds, list)
                            else []
                        )
                        for feed in featured_song_feeds:
                            if not isinstance(feed, dict):
                                continue
                            raw_song = feed.get("song")
                            module_song_dict: Dict[str, Any] = (
                                raw_song if isinstance(raw_song, dict) else {}
                            )
                            candidate = to_song_candidate(
                                module_song_dict,
                                feed,
                                f"home:module:{module_id}",
                                None,
                            )
                            if not candidate:
                                continue
                            if process_candidate(
                                session,
                                candidate,
                                requested_versions,
                                managers,
                                output_dirs,
                                counts,
                                seen_song_ids,
                                args.target,
                                fallback_counter,
                                download_limiter,
                                progress,
                            ):
                                progress.set_description(
                                    build_progress_desc(
                                        counts, args.target, requested_versions
                                    )
                                )
                            if targets_filled():
                                break

                    if endpoint.endswith("featured-playlist"):
                        raw_playlists = data.get("play_lists")
                        playlists: List[Any] = (
                            raw_playlists if isinstance(raw_playlists, list) else []
                        )
                        for playlist in playlists:
                            if not isinstance(playlist, dict):
                                continue
                            raw_playlist_feeds = playlist.get("feeds")
                            playlist_feeds: List[Any] = (
                                raw_playlist_feeds
                                if isinstance(raw_playlist_feeds, list)
                                else []
                            )
                            for feed in playlist_feeds:
                                if not isinstance(feed, dict):
                                    continue
                                raw_song = feed.get("song")
                                playlist_song_dict: Dict[str, Any] = (
                                    raw_song if isinstance(raw_song, dict) else {}
                                )
                                candidate = to_song_candidate(
                                    playlist_song_dict,
                                    feed,
                                    f"home:playlist:{module_id}:{playlist.get('id')}",
                                    None,
                                )
                                if not candidate:
                                    continue
                                if process_candidate(
                                    session,
                                    candidate,
                                    requested_versions,
                                    managers,
                                    output_dirs,
                                    counts,
                                    seen_song_ids,
                                    args.target,
                                    fallback_counter,
                                    download_limiter,
                                    progress,
                                ):
                                    progress.set_description(
                                        build_progress_desc(
                                            counts, args.target, requested_versions
                                        )
                                    )
                                if targets_filled():
                                    break
                            if targets_filled():
                                break

                    if targets_filled():
                        break

        for genre_url, genre_id, slug in genre_pages:
            if targets_filled():
                break

            genre_hint = extract_genre_hint(slug)
            genre_html = fetch_text(session, genre_url, page_limiter)
            if genre_html:
                known_api_endpoints.update(extract_api_endpoints_from_text(genre_html))
                for embedded in extract_embedded_song_candidates(
                    genre_html, genre_url, genre_hint
                ):
                    candidate = to_song_candidate(
                        embedded.get("song") or {},
                        embedded.get("feed") or {},
                        embedded.get("source_hint") or f"embedded:{genre_url}",
                        embedded.get("genre_hint") or genre_hint,
                    )
                    if not candidate:
                        continue
                    if process_candidate(
                        session,
                        candidate,
                        requested_versions,
                        managers,
                        output_dirs,
                        counts,
                        seen_song_ids,
                        args.target,
                        fallback_counter,
                        download_limiter,
                        progress,
                    ):
                        progress.set_description(
                            build_progress_desc(counts, args.target, requested_versions)
                        )
                    if targets_filled():
                        break

            last_id = 0
            for _ in range(MAX_GENRE_PAGES):
                if targets_filled() or not ensure_disk_space():
                    break

                params = {"genre_id": genre_id, "size": 20}
                if last_id:
                    params["last_id"] = last_id

                payload = fetch_json(
                    session,
                    "/api/pgc/song/songs_by_genre",
                    page_limiter,
                    params=params,
                )
                if not payload:
                    break

                data = payload.get("data") if isinstance(payload, dict) else None
                if not isinstance(data, dict):
                    break
                raw_genre_feeds = data.get("feeds")
                genre_feeds: List[Any] = (
                    raw_genre_feeds if isinstance(raw_genre_feeds, list) else []
                )
                if not genre_feeds:
                    break

                added_this_page = 0
                for feed in genre_feeds:
                    if not isinstance(feed, dict):
                        continue
                    raw_song = feed.get("song")
                    genre_song_dict: Dict[str, Any] = (
                        raw_song if isinstance(raw_song, dict) else {}
                    )
                    candidate = to_song_candidate(
                        genre_song_dict,
                        feed,
                        f"genre_api:{genre_id}",
                        genre_hint,
                    )
                    if not candidate:
                        continue
                    if process_candidate(
                        session,
                        candidate,
                        requested_versions,
                        managers,
                        output_dirs,
                        counts,
                        seen_song_ids,
                        args.target,
                        fallback_counter,
                        download_limiter,
                        progress,
                    ):
                        added_this_page += 1
                        progress.set_description(
                            build_progress_desc(counts, args.target, requested_versions)
                        )
                    if targets_filled():
                        break

                next_last_id = data.get("last_id")
                if not next_last_id or next_last_id == last_id:
                    break
                last_id = int(next_last_id)

                if added_this_page == 0 and targets_filled():
                    break

        if not targets_filled():
            recommend_payload = fetch_json(
                session,
                "/api/pgc/song/recommend_list",
                page_limiter,
                params={"size": 20},
            )
            data = (
                recommend_payload.get("data")
                if isinstance(recommend_payload, dict)
                else None
            )
            if isinstance(data, dict):
                raw_recommend_feeds = data.get("feeds")
                recommend_feeds: List[Any] = (
                    raw_recommend_feeds if isinstance(raw_recommend_feeds, list) else []
                )
            else:
                recommend_feeds = []
            for feed in recommend_feeds:
                if not isinstance(feed, dict):
                    continue
                raw_song = feed.get("song")
                recommend_song_dict: Dict[str, Any] = (
                    raw_song if isinstance(raw_song, dict) else {}
                )
                candidate = to_song_candidate(
                    recommend_song_dict,
                    feed,
                    "recommend_list",
                    None,
                )
                if not candidate:
                    continue
                if process_candidate(
                    session,
                    candidate,
                    requested_versions,
                    managers,
                    output_dirs,
                    counts,
                    seen_song_ids,
                    args.target,
                    fallback_counter,
                    download_limiter,
                    progress,
                ):
                    progress.set_description(
                        build_progress_desc(counts, args.target, requested_versions)
                    )
                if targets_filled():
                    break

    finally:
        for manager in managers.values():
            manager.update_summary()
        progress.close()

    logger.info(
        "Finished Mureka crawl with counts: "
        + ", ".join(f"{v}={counts.get(v, 0)}" for v in requested_versions)
    )
    logger.info(f"Discovered API hints: {len(known_api_endpoints)} endpoints")


if __name__ == "__main__":
    main()