scripts/crawl_udio.py

#!/usr/bin/env python3

import argparse
import re
from pathlib import Path
from typing import Any, Dict, List, Optional

from utils import *


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 dget(obj: Any, key: str) -> Any:
    if isinstance(obj, dict):
        return obj.get(key)
    return None


def walk_for_song_lists(payload: Any) -> List[Dict[str, Any]]:
    if isinstance(payload, list):
        return [
            x
            for x in payload
            if isinstance(x, dict)
            and (x.get("id") or x.get("audio_url") or x.get("song_path"))
        ]
    if not isinstance(payload, dict):
        return []

    for key in ("songs", "items", "results", "data"):
        value = payload.get(key)
        if isinstance(value, list):
            return [x for x in value if isinstance(x, dict)]
        if isinstance(value, dict):
            nested = walk_for_song_lists(value)
            if nested:
                return nested

    for value in payload.values():
        if isinstance(value, (dict, list)):
            nested = walk_for_song_lists(value)
            if nested:
                return nested
    return []


def detect_version(song: Dict[str, Any], fallback: str) -> str:
    if not isinstance(song, dict):
        return fallback
    raw_metadata = dget(song, "metadata")
    metadata: Dict[str, Any] = {}
    if isinstance(raw_metadata, dict):
        metadata = raw_metadata
    candidates = [
        dget(song, "model_version"),
        dget(song, "version"),
        dget(song, "modelVersion"),
        dget(metadata, "model_version"),
        dget(metadata, "version"),
        dget(metadata, "modelVersion"),
    ]
    for c in candidates:
        if c:
            return str(c)
    return fallback


def resolve_download_url(song: Dict[str, Any]) -> Optional[str]:
    audio_url = song.get("audio_url")
    if isinstance(audio_url, str) and audio_url.strip():
        return audio_url.strip()

    song_path = song.get("song_path")
    if isinstance(song_path, str) and song_path.strip():
        path = song_path.strip()
        if path.startswith("http"):
            return path
        return f"https://www.udio.com{path if path.startswith('/') else '/' + path}"
    return None


VERSION_DATE_RANGES = {
    "v1": ("2024-01-01", "2024-06-15"),
    "v1.5": ("2024-06-15", "2025-01-01"),
    "v2": ("2025-01-01", "2030-01-01"),
}


VERSION_SORT_MAP = {"v1": "likes", "v1.5": "plays", "v2": "newest"}
ALL_SORT_MODES = ["likes", "plays", "newest"]
MAX_PAGE_PER_SORT = 120
VERSION_SEARCH_TERMS = {
    "v1": [
        "",
        "rock",
        "pop",
        "hip hop",
        "jazz",
        "country",
        "R&B",
        "electronic",
        "folk",
        "blues",
        "indie",
        "metal",
        "soul",
        "funk",
        "reggae",
        "classical",
        "ambient",
        "lo-fi",
        "dance",
        "trap",
        "acoustic",
        "cinematic",
        "latin",
        "punk",
        "alternative",
        "gospel",
        "disco",
        "house",
        "techno",
        "synthwave",
        "grunge",
        "shoegaze",
        "new wave",
        "psychedelic",
        "bossa nova",
        "swing",
        "ballad",
        "chillhop",
        "dubstep",
        "drill",
        "emo",
        "hardcore",
        "ska",
        "surf rock",
        "math rock",
        "post punk",
        "vaporwave",
    ],
    "v1.5": [
        "",
        "ambient",
        "lo-fi",
        "dance",
        "trap",
        "acoustic",
        "cinematic",
        "latin",
        "punk",
        "alternative",
        "gospel",
        "disco",
        "house",
        "techno",
        "rock",
        "pop",
        "hip hop",
        "jazz",
        "country",
        "R&B",
        "electronic",
        "folk",
        "blues",
        "indie",
        "metal",
        "soul",
        "funk",
        "reggae",
        "classical",
        "synthwave",
        "K-pop",
        "afrobeat",
        "phonk",
        "orchestral",
        "reggaeton",
        "drill",
        "grunge",
        "shoegaze",
        "new wave",
        "psychedelic",
        "dubstep",
        "emo",
    ],
    "v2": [
        "",
        "pop",
        "rock",
        "hip hop",
        "electronic",
        "R&B",
        "jazz",
        "country",
        "ambient",
        "lo-fi",
        "dance",
        "trap",
        "acoustic",
        "cinematic",
        "latin",
        "indie",
        "metal",
        "soul",
        "funk",
        "reggae",
        "house",
        "techno",
        "drum and bass",
        "synthwave",
        "K-pop",
        "afrobeat",
        "phonk",
        "orchestral",
        "reggaeton",
        "drill",
    ],
}


def fetch_page(
    session: requests.Session,
    page_param: int,
    page_size: int,
    limiter: RateLimiter,
    version: str = "v1.5",
    search_term: str = "",
    sort_mode: Optional[str] = None,
) -> List[Dict[str, Any]]:
    import json as _json
    import subprocess as _sp

    url = "https://www.udio.com/api/songs/search"
    sort_field = sort_mode or VERSION_SORT_MAP.get(version, "plays")
    payload = {
        "searchQuery": {"sort": sort_field, "searchTerm": search_term},
        "pageParam": page_param,
        "pageSize": page_size,
    }
    limiter.wait()

    result = _sp.run(
        [
            "curl",
            "-s",
            "-X",
            "POST",
            url,
            "-H",
            "Content-Type: application/json",
            "-H",
            "User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
            "-H",
            "Origin: https://www.udio.com",
            "-H",
            "Referer: https://www.udio.com/",
            "-H",
            "Accept: application/json, text/plain, */*",
            "-H",
            "Accept-Language: en-US,en;q=0.9",
            "-d",
            _json.dumps(payload),
            "--max-time",
            "30",
        ],
        capture_output=True,
        text=True,
        timeout=35,
    )

    if result.returncode != 0:
        raise RuntimeError(
            f"curl failed with exit code {result.returncode}: {result.stderr.strip()}"
        )

    body = result.stdout.strip()
    if not body:
        raise ValueError("Empty response from Udio API")

    data = _json.loads(body)
    raw_songs = walk_for_song_lists(data)

    date_lo, date_hi = VERSION_DATE_RANGES.get(version, ("2024-01-01", "2030-01-01"))
    filtered = []
    for s in raw_songs:
        created = str(s.get("created_at") or "")[:10]
        if created and date_lo <= created < date_hi:
            filtered.append(s)
    return filtered if filtered else raw_songs


def resolve_output_dir(version: str, output_dir: Optional[str]) -> Path:
    if output_dir:
        return Path(output_dir)
    return FAKE_DIR / "A_commercial" / f"udio_{version}"


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--target", type=int, default=2000)
    parser.add_argument(
        "--version", type=str, default="v1.5", choices=["v1", "v1.5", "v2"]
    )
    parser.add_argument("--output-dir", type=str, default=None)
    args = parser.parse_args()

    output_dir = resolve_output_dir(args.version, args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    metadata_manager = MetadataManager(output_dir)
    existing = metadata_manager.get_count()
    if existing >= args.target:
        logger.info(f"Target already reached in {output_dir}: {existing}/{args.target}")
        metadata_manager.update_summary()
        return

    def make_session() -> requests.Session:
        s = requests.Session()
        s.headers.update(
            {
                "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
                "Accept": "application/json, text/plain, */*",
                "Content-Type": "application/json",
                "Origin": "https://www.udio.com",
                "Referer": "https://www.udio.com/",
                "Accept-Language": "en-US,en;q=0.9",
                "Connection": "close",
            }
        )
        return s

    session = make_session()

    api_limiter = RateLimiter(requests_per_second=0.5)
    download_limiter = RateLimiter(requests_per_second=1.5)
    progress = tqdm(
        total=args.target, initial=existing, desc=f"udio_{args.version}", unit="track"
    )

    import time as _time

    page_size = 50
    downloaded_since_summary = 0
    search_terms = VERSION_SEARCH_TERMS.get(args.version, [""])

    def download_song(song: Dict[str, Any]) -> bool:
        nonlocal downloaded_since_summary
        if not isinstance(song, dict):
            return False

        song_id = str(song.get("id") or "").strip()
        if not song_id:
            return False

        title = str(song.get("title") or "untitled").strip()
        raw_metadata = dget(song, "metadata")
        song_metadata: Dict[str, Any] = {}
        if isinstance(raw_metadata, dict):
            song_metadata = raw_metadata
        prompt = dget(song_metadata, "prompt") or dget(song, "prompt")
        tags = normalize_tags(dget(song_metadata, "tags") or dget(song, "tags"))
        genre = dget(song_metadata, "genre") or dget(song, "genre")
        if not genre and tags:
            genre = ", ".join(tags)

        filename = f"{song_id}_{sanitize_filename(title)}.mp3"
        file_path = output_dir / filename

        if (
            metadata_manager.has_track(song_id)
            and file_path.exists()
            and file_path.stat().st_size > 0
        ):
            return False

        download_url = resolve_download_url(song)
        if not download_url:
            return False

        download_limiter.wait()
        try:
            ok = download_file(download_url, file_path, headers=dict(session.headers))
            if not ok:
                return False
        except Exception as e:
            logger.warning(f"Download failed for Udio track {song_id}: {e}")
            return False

        audio_info = get_audio_info(file_path)
        version = detect_version(song, args.version)
        lyrics_raw = dget(song, "lyrics")
        lyrics = str(lyrics_raw).strip() if lyrics_raw else None

        meta = TrackMetadata(
            track_id=song_id,
            filename=filename,
            category="A_commercial",
            subcategory=f"udio_{version}",
            source_platform="udio",
            source_type="commercial",
            model_name="Udio",
            model_version=version,
            title=title,
            prompt=str(prompt) if prompt else None,
            genre=str(genre) if genre else None,
            tags=tags,
            lyrics=lyrics,
            source_url=f"https://www.udio.com/songs/{song_id}",
            download_url=download_url,
            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),
        )

        if not metadata_manager.has_track(song_id):
            metadata_manager.add_track(meta)
            progress.update(1)
            downloaded_since_summary += 1

        if downloaded_since_summary >= 25:
            metadata_manager.update_summary()
            downloaded_since_summary = 0
        return True

    try:
        for term_idx, current_term in enumerate(search_terms):
            if metadata_manager.get_count() >= args.target:
                break
            if not ensure_disk_space():
                logger.warning("Stopping due to insufficient disk space")
                break

            for sort_mode in ALL_SORT_MODES:
                if metadata_manager.get_count() >= args.target:
                    break

                consecutive_empty = 0
                page_param = 0
                for page_param in range(MAX_PAGE_PER_SORT):
                    if metadata_manager.get_count() >= args.target:
                        break

                    retries = 0
                    songs: List[Dict[str, Any]] = []
                    while retries < 3:
                        try:
                            songs = fetch_page(
                                session,
                                page_param,
                                page_size,
                                api_limiter,
                                version=args.version,
                                search_term=current_term,
                                sort_mode=sort_mode,
                            )
                            break
                        except Exception as e:
                            retries += 1
                            if retries < 3:
                                _time.sleep(3.0 * retries)
                            else:
                                logger.debug(
                                    f"page={page_param} sort={sort_mode} "
                                    f"term={current_term!r}: {e}"
                                )

                    if not songs:
                        consecutive_empty += 1
                        if consecutive_empty >= 5:
                            break
                        continue

                    consecutive_empty = 0
                    for song in songs:
                        if metadata_manager.get_count() >= args.target:
                            break
                        download_song(song)

                logger.info(
                    f"[{args.version}] term={current_term!r} sort={sort_mode} "
                    f"done at page={page_param} | "
                    f"total={metadata_manager.get_count()}/{args.target}"
                )

    finally:
        metadata_manager.update_summary()
        progress.close()

    logger.info(
        f"Finished Udio crawl: {metadata_manager.get_count()}/{args.target} in {output_dir}"
    )


if __name__ == "__main__":
    main()