@tikomni/skills 0.1.0

package/skills/single-work-analysis/scripts/platform/douyin/run_douyin_single_video.py

@@ -0,0 +1,1233 @@
+#!/usr/bin/env python3
+"""Douyin single-video low-quality runner (APP first, WEB fallback)."""
+
+from __future__ import annotations
+
+if __package__ in {None, ""}:
+    import sys
+    from pathlib import Path
+
+    _self = Path(__file__).resolve()
+    for _parent in _self.parents:
+        if (_parent / "scripts" / "core" / "bootstrap_env.py").is_file():
+            sys.path.insert(0, str(_parent))
+            break
+
+
+import argparse
+
+from scripts.core.bootstrap_env import bootstrap_for_direct_run
+
+bootstrap_for_direct_run(__file__, __package__)
+import hashlib
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from scripts.core.config_loader import config_get, load_tikomni_config, resolve_storage_paths
+from scripts.core.extract_pipeline import resolve_trace_error_context
+from scripts.core.progress_report import ProgressReporter
+from scripts.core.storage_router import render_output_filename, resolve_json_filename_pattern
+from scripts.platform.douyin.douyin_video_type_matrix import normalize_douyin_video_type
+from scripts.pipeline.asr.asr_pipeline import submit_u2_asr_with_retry
+from scripts.pipeline.asr.poll_u2_task import poll_u2_task
+from scripts.platform.douyin.select_low_quality_video_url import select_low_quality_video_url
+from scripts.core.tikomni_common import (
+    call_json_api,
+    deep_find_all,
+    normalize_text,
+    resolve_runtime,
+    summarize_content,
+    write_json_stdout,
+)
+from scripts.writers.write_benchmark_card import write_benchmark_card
+
+APP_ENDPOINT = "/api/u1/v1/douyin/app/v3/fetch_one_video_by_share_url"
+WEB_ENDPOINT = "/api/u1/v1/douyin/web/fetch_one_video_by_share_url"
+U2_SUBMIT_ENDPOINT = "/api/u2/v1/services/audio/asr/transcription"
+
+
+def _format_published_date(value: Any) -> str:
+    if value is None:
+        return "N/A"
+    try:
+        timestamp = int(value)
+        if timestamp > 1_000_000_000_000:
+            timestamp //= 1000
+        if timestamp <= 0:
+            return "N/A"
+        return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d")
+    except Exception:
+        return "N/A"
+
+
+
+
+def _safe_slug(value: Optional[str], fallback: str = "unknown") -> str:
+    text = normalize_text(value)
+    if not text:
+        return fallback
+    lowered = text.lower()
+    slug = re.sub(r"[^a-z0-9_-]+", "-", lowered).strip("-")
+    return slug[:64] or fallback
+
+
+def _traceable_identifier(source_input: Dict[str, Optional[str]], platform_work_id: Optional[str]) -> str:
+    if platform_work_id:
+        return _safe_slug(platform_work_id)
+
+    share_url = normalize_text(source_input.get("share_url"))
+    if not share_url:
+        return "missing_input"
+
+    digest = hashlib.sha1(share_url.encode("utf-8")).hexdigest()[:10]
+    return f"url-{digest}"
+
+
+def _build_persist_payload(
+    *,
+    result: Dict[str, Any],
+    source_input: Dict[str, Optional[str]],
+    platform_work_id: Optional[str],
+    status: str,
+    written_at: datetime,
+) -> Dict[str, Any]:
+    summary = {
+        "summary": result.get("summary", ""),
+        "insights": result.get("insights", []),
+        "confidence": result.get("confidence"),
+        "error_reason": result.get("error_reason"),
+    }
+    normalized = {
+        "platform": result.get("platform", "douyin"),
+        "content_kind": result.get("content_kind", "single_video"),
+        "platform_work_id": result.get("platform_work_id"),
+        "title": result.get("title"),
+        "duration_ms": result.get("duration_ms"),
+        "is_video": result.get("is_video"),
+        "u2_task_id": result.get("u2_task_id"),
+        "u2_task_status": result.get("u2_task_status"),
+        "request_id": result.get("request_id"),
+        "source": source_input,
+    }
+    return {
+        "meta": {
+            "written_at": written_at.isoformat(timespec="seconds"),
+            "status": status,
+            "platform": "douyin",
+            "identifier": _traceable_identifier(source_input, platform_work_id),
+        },
+        "summary": summary,
+        "normalized": normalized,
+        "raw": result,
+    }
+
+
+def _persist_output_artifact(
+    *,
+    result: Dict[str, Any],
+    source_input: Dict[str, Optional[str]],
+    platform_work_id: Optional[str],
+    storage_config: Optional[Dict[str, Any]],
+    persist_output: bool,
+) -> Dict[str, Any]:
+    if not persist_output:
+        return {"enabled": False, "skipped": True, "reason": "disabled_by_flag"}
+
+    try:
+        paths = resolve_storage_paths(storage_config or {})
+    except Exception as error:
+        return {"enabled": True, "ok": False, "error": f"resolve_storage_paths_failed:{error}"}
+
+    now = datetime.now()
+    date_key = now.strftime("%Y%m%d")
+    timestamp = now.strftime("%Y%m%dT%H%M%S")
+    identifier = _traceable_identifier(source_input, platform_work_id)
+    has_error = bool(result.get("error_reason"))
+    status = "error" if has_error else "success"
+
+    if has_error:
+        target_dir = Path(paths.get("errors_root", "")) / date_key
+    else:
+        target_dir = Path(paths.get("results_root", "")) / date_key
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+    file_name = render_output_filename(
+        pattern=resolve_json_filename_pattern(storage_config),
+        context={
+            "prefix": status,
+            "platform": "douyin",
+            "card_type": "single_work_result",
+            "author_slug": identifier,
+            "title_slug": identifier,
+            "identifier": identifier,
+            "timestamp": timestamp,
+            "date": date_key,
+            "ext": ".json",
+        },
+        default_filename=f"{timestamp}-douyin-{identifier}.json",
+        default_ext=".json",
+    )
+    file_path = target_dir / file_name
+
+    payload = _build_persist_payload(
+        result=result,
+        source_input=source_input,
+        platform_work_id=platform_work_id,
+        status=status,
+        written_at=now,
+    )
+    file_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    return {
+        "enabled": True,
+        "ok": True,
+        "status": status,
+        "path": str(file_path),
+    }
+
+
+def _finalize_result(
+    *,
+    result: Dict[str, Any],
+    source_input: Dict[str, Optional[str]],
+    platform_work_id: Optional[str],
+    storage_config: Optional[Dict[str, Any]],
+    persist_output: bool,
+) -> Dict[str, Any]:
+    result["output_persist"] = _persist_output_artifact(
+        result=result,
+        source_input=source_input,
+        platform_work_id=platform_work_id,
+        storage_config=storage_config,
+        persist_output=persist_output,
+    )
+    return result
+
+def _normalize_input(
+    input_value: Optional[str],
+    share_url: Optional[str],
+) -> Dict[str, Optional[str]]:
+    normalized_share = (share_url or "").strip() or None
+
+    if input_value and not normalized_share:
+        candidate = input_value.strip()
+        if candidate.startswith("http://") or candidate.startswith("https://"):
+            normalized_share = candidate
+
+    return {"share_url": normalized_share}
+
+
+def _extract_aweme_detail(payload: Any) -> Optional[Dict[str, Any]]:
+    if isinstance(payload, dict):
+        direct = payload.get("aweme_detail")
+        if isinstance(direct, dict):
+            return direct
+
+        for list_key in ("aweme_details", "aweme_list", "item_list", "items"):
+            values = payload.get(list_key)
+            if isinstance(values, list) and values:
+                first = values[0]
+                if isinstance(first, dict):
+                    return first
+
+        nested_data = payload.get("data")
+        if nested_data is not None:
+            hit = _extract_aweme_detail(nested_data)
+            if hit:
+                return hit
+
+        for value in payload.values():
+            hit = _extract_aweme_detail(value)
+            if hit:
+                return hit
+
+    elif isinstance(payload, list):
+        for item in payload:
+            hit = _extract_aweme_detail(item)
+            if hit:
+                return hit
+
+    return None
+
+
+def _safe_int(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return 1 if value else 0
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    if isinstance(value, str):
+        text = value.strip()
+        if text.startswith("-"):
+            sign = -1
+            text = text[1:]
+        else:
+            sign = 1
+        if text.isdigit():
+            return sign * int(text)
+    return None
+
+
+def _normalize_duration_ms(item: Dict[str, Any]) -> Optional[int]:
+    raw = item.get("duration")
+    if raw is None:
+        video = item.get("video")
+        if isinstance(video, dict):
+            raw = video.get("duration")
+
+    value = _safe_int(raw)
+    if value is None:
+        return None
+
+    # Douyin commonly uses ms; convert obvious second-level durations.
+    if 0 < value < 10000:
+        return value * 1000
+    return value
+
+
+def _pick_title(item: Dict[str, Any]) -> str:
+    for key in ("item_title", "title", "desc", "preview_title"):
+        value = item.get(key)
+        text = normalize_text(value)
+        if text:
+            return text
+    return ""
+
+
+def _pick_desc(item: Dict[str, Any]) -> str:
+    for key in ("desc", "item_title", "title", "preview_title"):
+        value = item.get(key)
+        text = normalize_text(value)
+        if text:
+            return text
+    return ""
+
+
+def _extract_author(item: Dict[str, Any]) -> Dict[str, Optional[str]]:
+    author = item.get("author")
+    if not isinstance(author, dict):
+        author = {}
+
+    author_platform_id = normalize_text(author.get("uid")) or normalize_text(author.get("id")) or normalize_text(item.get("author_user_id"))
+    author_handle = normalize_text(author.get("short_id")) or normalize_text(author.get("nickname"))
+    douyin_sec_uid = normalize_text(author.get("sec_uid"))
+    douyin_aweme_author_id = normalize_text(item.get("author_user_id")) or author_platform_id
+
+    return {
+        "author_handle": author_handle or None,
+        "platform_author_id": author_platform_id or None,
+        "author_platform_id": author_platform_id or None,
+        "douyin_sec_uid": douyin_sec_uid or None,
+        "douyin_aweme_author_id": douyin_aweme_author_id or None,
+        "nickname": normalize_text(author.get("nickname")) or None,
+        "signature": normalize_text(author.get("signature")) or None,
+    }
+
+
+def _extract_metrics(item: Dict[str, Any]) -> Dict[str, int]:
+    statistics = item.get("statistics")
+    if not isinstance(statistics, dict):
+        statistics = {}
+
+    def metric(*keys: str) -> int:
+        for key in keys:
+            value = _safe_int(statistics.get(key))
+            if value is not None:
+                return value
+            value = _safe_int(item.get(key))
+            if value is not None:
+                return value
+        return 0
+
+    return {
+        "digg_count": metric("digg_count"),
+        "comment_count": metric("comment_count"),
+        "collect_count": metric("collect_count"),
+        "share_count": metric("share_count", "forward_count"),
+        "play_count": metric("play_count"),
+    }
+
+
+def _extract_platform_work_id(item: Dict[str, Any]) -> Optional[str]:
+    for key in ("aweme_id", "item_id", "id"):
+        value = item.get(key)
+        if value is None:
+            continue
+        text = normalize_text(value)
+        if text:
+            return text
+
+    statistics = item.get("statistics")
+    if isinstance(statistics, dict):
+        value = statistics.get("aweme_id")
+        text = normalize_text(value)
+        if text:
+            return text
+    return None
+
+
+def _extract_create_time_sec(item: Dict[str, Any]) -> Optional[int]:
+    for key in ("create_time", "aweme_create_time"):
+        value = _safe_int(item.get(key))
+        if value is not None and value > 0:
+            return value
+    return None
+
+
+def _pick_first_url(value: Any) -> Optional[str]:
+    if isinstance(value, str):
+        text = value.strip()
+        return text or None
+    if isinstance(value, list):
+        for item in value:
+            if isinstance(item, str) and item.strip():
+                return item.strip()
+    if isinstance(value, dict):
+        for key in ("url_list", "url", "uri"):
+            hit = _pick_first_url(value.get(key))
+            if hit:
+                return hit
+    return None
+
+
+def _extract_cover_image(item: Dict[str, Any]) -> Optional[str]:
+    # prefer video-level covers
+    video = item.get("video") if isinstance(item.get("video"), dict) else {}
+    for key in ("cover", "origin_cover", "dynamic_cover"):
+        hit = _pick_first_url(video.get(key))
+        if hit:
+            return hit
+
+    # fallback to item-level covers
+    for key in ("cover", "origin_cover", "dynamic_cover"):
+        hit = _pick_first_url(item.get(key))
+        if hit:
+            return hit
+
+    return None
+
+
+def _clean_tag_text(value: Any) -> str:
+    text = normalize_text(value)
+    if not text:
+        return ""
+    text = text.strip().strip("#")
+    return text
+
+
+def _append_tag(raw: Any, output: List[str], seen: set) -> None:
+    tag = _clean_tag_text(raw)
+    if not tag or tag in seen:
+        return
+    seen.add(tag)
+    output.append(tag)
+
+
+def _extract_tags_from_container(value: Any, output: List[str], seen: set) -> None:
+    if isinstance(value, str):
+        text = value.strip()
+        if not text:
+            return
+        if text.startswith("{") or text.startswith("["):
+            try:
+                parsed = json.loads(text)
+                _extract_tags_from_container(parsed, output, seen)
+                return
+            except Exception:
+                pass
+        for part in re.split(r"[,，\s]+", text):
+            _append_tag(part, output, seen)
+        return
+
+    if isinstance(value, list):
+        for item in value:
+            _extract_tags_from_container(item, output, seen)
+        return
+
+    if isinstance(value, dict):
+        for key in ("hashtag_name", "cha_name", "name", "tag_name", "topic_name", "hashtag"):
+            _append_tag(value.get(key), output, seen)
+
+
+def _extract_douyin_tags(item: Dict[str, Any]) -> List[str]:
+    tags: List[str] = []
+    seen: set = set()
+
+    for value in deep_find_all(item, ["text_extra"]):
+        _extract_tags_from_container(value, tags, seen)
+
+    for value in deep_find_all(item, ["cha_list"]):
+        _extract_tags_from_container(value, tags, seen)
+
+    for value in deep_find_all(item, ["hashtag"]):
+        _extract_tags_from_container(value, tags, seen)
+
+    for common_flags in deep_find_all(item, ["common_flags"]):
+        if not isinstance(common_flags, str):
+            continue
+        try:
+            parsed = json.loads(common_flags)
+        except Exception:
+            continue
+        _extract_tags_from_container(parsed.get("hashtag"), tags, seen)
+
+    for text_field in (normalize_text(item.get("caption")), normalize_text(item.get("desc"))):
+        if not text_field:
+            continue
+        for match in re.findall(r"#([^#\s]+)", text_field):
+            _append_tag(match, tags, seen)
+
+    return tags
+
+
+def _u1_fetch_one_video(
+    *,
+    base_url: str,
+    token: str,
+    share_url: str,
+    app_timeout_ms: int,
+    web_timeout_ms: int,
+) -> Dict[str, Any]:
+    app_response = call_json_api(
+        base_url=base_url,
+        path=APP_ENDPOINT,
+        token=token,
+        method="GET",
+        timeout_ms=app_timeout_ms,
+        params={"share_url": share_url},
+    )
+    app_response["_endpoint"] = APP_ENDPOINT
+    if app_response.get("ok"):
+        return app_response
+
+    app_response["fallback_trigger_reason"] = (
+        "primary_timeout_retry_exhausted" if app_response.get("timeout_retry_exhausted") else "primary_non_timeout_failure"
+    )
+    web_response = call_json_api(
+        base_url=base_url,
+        path=WEB_ENDPOINT,
+        token=token,
+        method="GET",
+        timeout_ms=web_timeout_ms,
+        params={"share_url": share_url},
+    )
+    web_response["_endpoint"] = WEB_ENDPOINT
+    web_response["_app_failed"] = app_response
+    web_response["fallback_trigger_reason"] = app_response.get("fallback_trigger_reason")
+    return web_response
+
+
+def _trace_step(
+    *,
+    step: str,
+    endpoint: Optional[str] = None,
+    response: Optional[Dict[str, Any]] = None,
+    extra: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {"step": step}
+    if endpoint:
+        payload["endpoint"] = endpoint
+    if response is not None:
+        payload.update(
+            {
+                "ok": response.get("ok"),
+                "status_code": response.get("status_code"),
+                "request_id": response.get("request_id"),
+                "error_reason": response.get("error_reason"),
+                "rate_limit_wait_ms": response.get("rate_limit_wait_ms", 0),
+                "retry_attempt": response.get("retry_attempt", 0),
+                "fallback_trigger_reason": response.get("fallback_trigger_reason"),
+            }
+        )
+    if extra:
+        payload.update(extra)
+    return payload
+
+
+def _build_missing_fields(
+    *,
+    title: str,
+    desc: str,
+    platform_work_id: Optional[str],
+    video_down_url: Optional[str],
+    author: Dict[str, Optional[str]],
+) -> List[Dict[str, str]]:
+    missing: List[Dict[str, str]] = []
+
+    def _append(field: str) -> None:
+        missing.append({"field": field, "reason": "missing_metadata"})
+
+    if not normalize_text(title):
+        _append("title")
+    if not normalize_text(desc):
+        _append("desc")
+    if not normalize_text(platform_work_id):
+        _append("platform_work_id")
+    if not normalize_text(video_down_url):
+        _append("video_down_url")
+
+    author_key_map = {
+        "author_handle": ("author_handle",),
+        "platform_author_id": ("platform_author_id", "author_platform_id"),
+        "douyin_sec_uid": ("douyin_sec_uid",),
+        "douyin_aweme_author_id": ("douyin_aweme_author_id",),
+    }
+    for field, aliases in author_key_map.items():
+        if not any(normalize_text(author.get(alias)) for alias in aliases):
+            _append(field)
+
+    return missing
+
+
+def _build_result(
+    *,
+    source_input: Dict[str, Optional[str]],
+    platform_work_id: Optional[str],
+    title: str,
+    desc: str,
+    duration_ms: Optional[int],
+    video_down_url: Optional[str],
+    author: Dict[str, Optional[str]],
+    metrics: Dict[str, int],
+    tags: List[str],
+    is_video: bool,
+    video_type_reason: str,
+    raw_content: str,
+    confidence: str,
+    error_reason: Optional[str],
+    extract_trace: List[Dict[str, Any]],
+    fallback_trace: List[Dict[str, Any]],
+    request_id: Optional[str],
+    u2_task_id: Optional[str],
+    u2_task_status: str,
+    u2_gate_reason: str,
+    create_time_sec: Optional[int] = None,
+    cover_image: Optional[str] = None,
+    asr_source: str = "fallback_none",
+) -> Dict[str, Any]:
+    summary_block = summarize_content(raw_content, source="douyin:single-video-low-quality")
+    insights = list(summary_block.get("insights", []))
+    insights.extend(
+        [
+            f"platform_work_id={platform_work_id or ''}",
+            f"is_video={is_video}",
+            f"video_type_reason={video_type_reason}",
+            f"u2_gate_reason={u2_gate_reason}",
+        ]
+    )
+
+    endpoint_list = [
+        step.get("endpoint")
+        for step in extract_trace
+        if isinstance(step, dict) and isinstance(step.get("endpoint"), str)
+    ]
+    primary_text = raw_content
+    analysis_eligibility = "eligible" if raw_content else "incomplete"
+    analysis_exclusion_reason = "" if raw_content else "video_asr_unavailable"
+
+    payload: Dict[str, Any] = {
+        "platform": "douyin",
+        "content_kind": "single_video",
+        "source": source_input,
+        "platform_work_id": platform_work_id,
+        "title": title,
+        "caption_raw": desc,
+        "desc": desc,
+        "duration_ms": duration_ms,
+        "create_time_sec": create_time_sec,
+        "published_date": _format_published_date(create_time_sec),
+        "cover_image": cover_image,
+        "video_down_url": video_down_url,
+        "video_download_url": video_down_url,
+        "work_modality": "video",
+        "author": author,
+        "author_handle": author.get("author_handle"),
+        "platform_author_id": author.get("platform_author_id") or author.get("author_platform_id"),
+        "douyin_sec_uid": author.get("douyin_sec_uid"),
+        "douyin_aweme_author_id": author.get("douyin_aweme_author_id"),
+        "digg_count": metrics.get("digg_count", 0),
+        "comment_count": metrics.get("comment_count", 0),
+        "collect_count": metrics.get("collect_count", 0),
+        "share_count": metrics.get("share_count", 0),
+        "play_count": metrics.get("play_count", 0),
+        "tags": tags or [],
+        "is_video": is_video,
+        "video_type_reason": video_type_reason,
+        "u2_task_id": u2_task_id,
+        "u2_task_status": u2_task_status,
+        "raw_content": raw_content,
+        "primary_text": primary_text,
+        "primary_text_source": "asr_clean",
+        "analysis_eligibility": analysis_eligibility,
+        "analysis_exclusion_reason": analysis_exclusion_reason,
+        "asr_source": asr_source,
+        "summary": summary_block.get("summary", ""),
+        "insights": insights,
+        "confidence": confidence,
+        "error_reason": error_reason,
+        "missing_fields": _build_missing_fields(
+            title=title,
+            desc=desc,
+            platform_work_id=platform_work_id,
+            video_down_url=video_down_url,
+            author=author,
+        ),
+        "extract_trace": extract_trace,
+        "fallback_trace": fallback_trace,
+        "request_id": request_id,
+        "endpoint_list": endpoint_list,
+    }
+    return payload
+
+
+def run_douyin_single_video(
+    *,
+    input_value: Optional[str],
+    share_url: Optional[str],
+    env_file: Optional[str],
+    api_key_env: str,
+    base_url: Optional[str],
+    timeout_ms: Optional[int],
+    app_timeout_ms: Optional[int],
+    web_timeout_ms: Optional[int],
+    poll_interval_sec: float,
+    max_polls: int,
+    u2_submit_max_retries: int,
+    u2_submit_backoff_ms: int,
+    write_card: bool,
+    card_type: str,
+    card_root: Optional[str],
+    content_kind: str = "single_video",
+    storage_config: Optional[Dict[str, Any]] = None,
+    allow_process_env: bool = False,
+    persist_output: bool = True,
+    progress: Optional[ProgressReporter] = None,
+) -> Dict[str, Any]:
+    if not write_card or not persist_output:
+        raise ValueError(
+            f"fixed_pipeline_requires_full_persistence:douyin:{content_kind}:write_card={bool(write_card)}:persist_output={bool(persist_output)}"
+        )
+
+    source_input = _normalize_input(input_value, share_url)
+    if progress is not None:
+        progress.started(stage="single_video.workflow", message="douyin single_video workflow started")
+    if not source_input.get("share_url"):
+        result = _build_result(
+            source_input=source_input,
+            platform_work_id=None,
+            title="",
+            desc="",
+            duration_ms=None,
+            video_down_url=None,
+            author={"author_handle": None, "author_platform_id": None, "douyin_sec_uid": None, "douyin_aweme_author_id": None, "nickname": None, "signature": None},
+            metrics={
+                "digg_count": 0,
+                "comment_count": 0,
+                "collect_count": 0,
+                "share_count": 0,
+                "play_count": 0,
+            },
+            tags=[],
+            is_video=False,
+            video_type_reason="missing_share_url",
+            raw_content="",
+            confidence="low",
+            error_reason="missing_share_url",
+            extract_trace=[],
+            fallback_trace=[],
+            request_id=None,
+            u2_task_id=None,
+            u2_task_status="UNKNOWN",
+            u2_gate_reason="not_started",
+        )
+        if write_card:
+            result["card_write"] = write_benchmark_card(
+                payload=result,
+                platform="douyin",
+                card_type=card_type,
+                card_root=card_root,
+                content_kind=content_kind,
+                storage_config=storage_config,
+            )
+        return _finalize_result(
+            result=result,
+            source_input=source_input,
+            platform_work_id=None,
+            storage_config=storage_config,
+            persist_output=persist_output,
+        )
+
+    runtime = resolve_runtime(
+        env_file=env_file,
+        api_key_env=api_key_env,
+        base_url=base_url,
+        timeout_ms=timeout_ms,
+        allow_process_env=allow_process_env,
+    )
+
+    app_timeout = int(app_timeout_ms or runtime["timeout_ms"])
+    web_timeout = int(web_timeout_ms or runtime["timeout_ms"])
+
+    trace: List[Dict[str, Any]] = []
+
+    if progress is not None:
+        progress.progress(stage="single_video.fetch", message="fetching douyin single_video payload")
+    one_video_response = _u1_fetch_one_video(
+        base_url=runtime["base_url"],
+        token=runtime["token"],
+        share_url=source_input["share_url"] or "",
+        app_timeout_ms=app_timeout,
+        web_timeout_ms=web_timeout,
+    )
+
+    app_failed = one_video_response.get("_app_failed")
+    if app_failed:
+        trace.append(
+            _trace_step(
+                step="u1_fetch_one_video_primary",
+                endpoint=APP_ENDPOINT,
+                response=app_failed,
+                extra={"timeout_ms": app_timeout},
+            )
+        )
+
+    trace.append(
+        _trace_step(
+            step="u1_fetch_one_video_effective",
+            endpoint=one_video_response.get("_endpoint"),
+            response=one_video_response,
+            extra={
+                "app_timeout_ms": app_timeout,
+                "web_timeout_ms": web_timeout,
+            },
+        )
+    )
+
+    if not one_video_response.get("ok"):
+        error_ctx = resolve_trace_error_context(
+            responses=[one_video_response],
+            extract_trace=trace,
+            default_error_reason="u1_fetch_one_video_failed",
+        )
+        result = _build_result(
+            source_input=source_input,
+            platform_work_id=None,
+            title="",
+            desc="",
+            duration_ms=None,
+            video_down_url=None,
+            author={"author_handle": None, "author_platform_id": None, "douyin_sec_uid": None, "douyin_aweme_author_id": None, "nickname": None, "signature": None},
+            metrics={
+                "digg_count": 0,
+                "comment_count": 0,
+                "collect_count": 0,
+                "share_count": 0,
+                "play_count": 0,
+            },
+            tags=[],
+            is_video=False,
+            video_type_reason="u1_failed",
+            raw_content="",
+            confidence="low",
+            error_reason=error_ctx.get("error_reason"),
+            extract_trace=trace,
+            fallback_trace=error_ctx.get("fallback_trace", []),
+            request_id=error_ctx.get("request_id"),
+            u2_task_id=None,
+            u2_task_status="UNKNOWN",
+            u2_gate_reason="u1_failed",
+        )
+        if write_card:
+            result["card_write"] = write_benchmark_card(
+                payload=result,
+                platform="douyin",
+                card_type=card_type,
+                card_root=card_root,
+                content_kind=content_kind,
+                storage_config=storage_config,
+            )
+        return _finalize_result(
+            result=result,
+            source_input=source_input,
+            platform_work_id=None,
+            storage_config=storage_config,
+            persist_output=persist_output,
+        )
+
+    aweme_detail = _extract_aweme_detail(one_video_response.get("data"))
+    if not aweme_detail:
+        error_ctx = resolve_trace_error_context(
+            responses=[one_video_response],
+            extract_trace=trace,
+            default_error_reason="aweme_detail_missing",
+        )
+        result = _build_result(
+            source_input=source_input,
+            platform_work_id=None,
+            title="",
+            desc="",
+            duration_ms=None,
+            video_down_url=None,
+            author={"author_handle": None, "author_platform_id": None, "douyin_sec_uid": None, "douyin_aweme_author_id": None, "nickname": None, "signature": None},
+            metrics={
+                "digg_count": 0,
+                "comment_count": 0,
+                "collect_count": 0,
+                "share_count": 0,
+                "play_count": 0,
+            },
+            tags=[],
+            is_video=False,
+            video_type_reason="aweme_detail_missing",
+            raw_content="",
+            confidence="low",
+            error_reason=error_ctx.get("error_reason"),
+            extract_trace=trace,
+            fallback_trace=error_ctx.get("fallback_trace", []),
+            request_id=error_ctx.get("request_id"),
+            u2_task_id=None,
+            u2_task_status="UNKNOWN",
+            u2_gate_reason="aweme_detail_missing",
+        )
+        if write_card:
+            result["card_write"] = write_benchmark_card(
+                payload=result,
+                platform="douyin",
+                card_type=card_type,
+                card_root=card_root,
+                content_kind=content_kind,
+                storage_config=storage_config,
+            )
+        return _finalize_result(
+            result=result,
+            source_input=source_input,
+            platform_work_id=None,
+            storage_config=storage_config,
+            persist_output=persist_output,
+        )
+
+    video_type_info = normalize_douyin_video_type(aweme_detail)
+    duration_ms = _normalize_duration_ms(aweme_detail)
+    platform_work_id = _extract_platform_work_id(aweme_detail)
+    title = _pick_title(aweme_detail)
+    desc = _pick_desc(aweme_detail)
+    author = _extract_author(aweme_detail)
+    metrics = _extract_metrics(aweme_detail)
+    tags = _extract_douyin_tags(aweme_detail)
+    create_time_sec = _extract_create_time_sec(aweme_detail)
+    cover_image = _extract_cover_image(aweme_detail)
+
+    video_obj = aweme_detail.get("video") if isinstance(aweme_detail.get("video"), dict) else {}
+    down_url_selection = select_low_quality_video_url(video_obj)
+    video_down_url = down_url_selection.get("video_down_url")
+
+    trace.append(
+        {
+            "step": "video_type_normalization",
+            "is_video": video_type_info.get("is_video"),
+            "video_type_reason": video_type_info.get("video_type_reason"),
+            "matched_field": video_type_info.get("matched_field"),
+            "duration_ms": duration_ms,
+        }
+    )
+
+    trace.append(
+        {
+            "step": "select_low_quality_video_url",
+            "selection_reason": down_url_selection.get("selection_reason"),
+            "selected_from": down_url_selection.get("selected_from"),
+            "video_down_url": video_down_url,
+            "min_bit_rate": down_url_selection.get("min_bit_rate"),
+            "download_url_count": down_url_selection.get("download_url_count"),
+            "bit_rate_count": down_url_selection.get("bit_rate_count"),
+        }
+    )
+
+    can_u2 = bool(video_type_info.get("is_video")) and bool(duration_ms and duration_ms > 13000 and duration_ms <= 1800000)
+    can_u2 = can_u2 and bool(video_down_url)
+
+    if not video_type_info.get("is_video"):
+        gate_reason = "skip:not_video"
+    elif not duration_ms:
+        gate_reason = "skip:duration_missing"
+    elif duration_ms <= 13000:
+        gate_reason = "skip:duration_too_short"
+    elif duration_ms > 1800000:
+        gate_reason = "skip:duration_too_long"
+    elif not video_down_url:
+        gate_reason = "skip:video_down_url_missing"
+    else:
+        gate_reason = "pass"
+
+    trace.append(
+        {
+            "step": "u2_gate",
+            "can_u2": can_u2,
+            "gate_reason": gate_reason,
+            "rule": "is_video && 13000<duration_ms<=1800000 && video_down_url_present",
+            "is_video": bool(video_type_info.get("is_video")),
+            "video_type_reason": video_type_info.get("video_type_reason"),
+            "duration_ms": duration_ms,
+            "video_down_url_present": bool(video_down_url),
+        }
+    )
+
+    raw_content = ""
+    error_reason: Optional[str] = None
+    u2_task_id: Optional[str] = None
+    u2_task_status = "SKIPPED"
+    submit_response: Dict[str, Any] = {}
+    poll_result: Dict[str, Any] = {}
+
+    if can_u2 and video_down_url:
+        if progress is not None:
+            progress.progress(
+                stage="single_video.u2",
+                message="starting douyin u2 submit",
+                data={"video_down_url_present": True},
+            )
+        submit_bundle = submit_u2_asr_with_retry(
+            base_url=runtime["base_url"],
+            token=runtime["token"],
+            timeout_ms=runtime["timeout_ms"],
+            video_url=video_down_url,
+            max_retries=u2_submit_max_retries,
+            backoff_ms=u2_submit_backoff_ms,
+        )
+        submit_response = submit_bundle["submit_response"]
+        u2_task_id = submit_bundle.get("task_id")
+
+        trace.append(
+            _trace_step(
+                step="u2_submit_transcription",
+                endpoint=U2_SUBMIT_ENDPOINT,
+                response=submit_response,
+                extra={
+                    "task_id": u2_task_id,
+                    "video_down_url": video_down_url,
+                    "final_submit_status": submit_bundle.get("final_submit_status"),
+                },
+            )
+        )
+
+        trace.append(
+            {
+                "step": "u2_submit_retry_chain",
+                "final_submit_status": submit_bundle.get("final_submit_status"),
+                "retries_config": {
+                    "u2_submit_max_retries": max(0, int(u2_submit_max_retries)),
+                    "u2_submit_backoff_ms": max(0, int(u2_submit_backoff_ms)),
+                },
+                "attempts": submit_bundle.get("retry_chain", []),
+            }
+        )
+
+        if not submit_response.get("ok") or not u2_task_id:
+            if progress is not None:
+                progress.failed(
+                    stage="single_video.u2",
+                    message="douyin u2 submit failed",
+                    data={"error_reason": submit_response.get("error_reason") or "u2_submit_failed_or_missing_task_id"},
+                )
+            error_reason = submit_response.get("error_reason") or "u2_submit_failed_or_missing_task_id"
+            u2_task_status = "UNKNOWN"
+        else:
+            if progress is not None:
+                progress.progress(stage="single_video.u2", message="polling douyin u2 task", data={"task_id": u2_task_id})
+            poll_result = poll_u2_task(
+                base_url=runtime["base_url"],
+                token=runtime["token"],
+                timeout_ms=runtime["timeout_ms"],
+                task_id=u2_task_id,
+                poll_interval_sec=poll_interval_sec,
+                max_polls=max_polls,
+            )
+            u2_task_status = poll_result.get("task_status") or "UNKNOWN"
+            raw_content = poll_result.get("transcript_text", "") if poll_result.get("ok") else ""
+            error_reason = poll_result.get("error_reason")
+
+            trace.append(
+                {
+                    "step": "u2_poll_task",
+                    "endpoint": "/api/u2/v1/tasks/{task_id}",
+                    "task_id": u2_task_id,
+                    "ok": poll_result.get("ok"),
+                    "task_status": u2_task_status,
+                    "request_id": poll_result.get("request_id"),
+                    "error_reason": poll_result.get("error_reason"),
+                    "attempts": len(poll_result.get("trace", [])),
+                }
+            )
+            if progress is not None:
+                (progress.done if poll_result.get("ok") else progress.failed)(
+                    stage="single_video.u2",
+                    message="douyin u2 polling finished" if poll_result.get("ok") else "douyin u2 polling failed",
+                    data={"task_id": u2_task_id, "task_status": u2_task_status, "attempts": len(poll_result.get("trace", []))},
+                )
+
+    error_ctx = resolve_trace_error_context(
+        responses=[poll_result, submit_response, one_video_response],
+        extract_trace=trace,
+        explicit_error_reason=error_reason,
+        explicit_request_id=poll_result.get("request_id") or submit_response.get("request_id") or one_video_response.get("request_id"),
+    )
+    error_reason = error_ctx.get("error_reason")
+
+    if error_reason:
+        confidence = "low"
+    elif can_u2 and raw_content:
+        confidence = "high"
+    elif can_u2 and not raw_content:
+        confidence = "medium"
+    else:
+        confidence = "medium"
+
+    result = _build_result(
+        source_input=source_input,
+        platform_work_id=platform_work_id,
+        title=title,
+        desc=desc,
+        duration_ms=duration_ms,
+        create_time_sec=create_time_sec,
+        cover_image=cover_image,
+        video_down_url=video_down_url,
+        author=author,
+        metrics=metrics,
+        tags=tags,
+        is_video=bool(video_type_info.get("is_video")),
+        video_type_reason=str(video_type_info.get("video_type_reason") or ""),
+        raw_content=raw_content,
+        confidence=confidence,
+        error_reason=error_reason,
+        extract_trace=trace,
+        fallback_trace=error_ctx.get("fallback_trace", []),
+        request_id=error_ctx.get("request_id"),
+        u2_task_id=u2_task_id,
+        u2_task_status=u2_task_status,
+        u2_gate_reason=gate_reason,
+        asr_source="u2" if raw_content else "fallback_none",
+    )
+
+    if write_card:
+        if progress is not None:
+            progress.progress(stage="single_video.card_write", message="writing douyin single_video card")
+        result["card_write"] = write_benchmark_card(
+            payload=result,
+            platform="douyin",
+            card_type=card_type,
+            card_root=card_root,
+            content_kind=content_kind,
+            storage_config=storage_config,
+        )
+
+    finalized = _finalize_result(
+        result=result,
+        source_input=source_input,
+        platform_work_id=platform_work_id,
+        storage_config=storage_config,
+        persist_output=persist_output,
+    )
+    if progress is not None:
+        final_event = progress.failed if finalized.get("error_reason") else progress.done
+        final_event(
+            stage="single_video.workflow",
+            message="douyin single_video workflow finished" if not finalized.get("error_reason") else "douyin single_video workflow failed",
+            data={
+                "request_id": finalized.get("request_id"),
+                "card_write_ok": bool((finalized.get("card_write") or {}).get("ok")),
+                "output_persist_ok": bool((finalized.get("output_persist") or {}).get("ok")),
+            },
+        )
+    return finalized
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run Douyin single-video low-quality extraction")
+    parser.add_argument("input", nargs="?", default=None, help="Douyin share URL")
+    parser.add_argument("--share-url", default=None, help="Douyin share URL")
+    parser.add_argument("--config", default=None, help="Runtime config YAML path")
+    parser.add_argument("--env-file", default=None, help="Optional env file path")
+    parser.add_argument("--allow-process-env", action="store_true", help="Allow process env to override .env/.env.local")
+    parser.add_argument("--api-key-env", default=None, help="API key env variable name")
+    parser.add_argument("--base-url", default=None, help="Tikomni base URL")
+    parser.add_argument("--timeout-ms", type=int, default=None, help="Global timeout ms")
+    parser.add_argument("--app-timeout-ms", type=int, default=None, help="APP endpoint timeout ms (optional)")
+    parser.add_argument("--web-timeout-ms", type=int, default=None, help="WEB endpoint timeout ms (optional)")
+    parser.add_argument("--poll-interval-sec", type=float, default=3.0, help="U2 poll interval seconds")
+    parser.add_argument("--max-polls", type=int, default=30, help="Max U2 polls")
+    parser.add_argument(
+        "--u2-submit-max-retries",
+        type=int,
+        default=2,
+        help="Max retries for retriable U2 submit failures",
+    )
+    parser.add_argument(
+        "--u2-submit-backoff-ms",
+        type=int,
+        default=1500,
+        help="Base backoff ms for retriable U2 submit failures (exponential)",
+    )
+    parser.add_argument("--card-type", choices=["work", "author", "author_sample_work"], default="work", help="Primary card type")
+    parser.add_argument("--content-kind", default="single_video", help="Routing kind, e.g. single_video/author_home/author_analysis")
+    parser.add_argument("--card-root", default=None, help="Card root (absolute); falls back to TIKOMNI_CARD_ROOT when writing cards")
+    args = parser.parse_args()
+
+    config, _ = load_tikomni_config(
+        args.config,
+        env_file=args.env_file,
+        allow_process_env=args.allow_process_env,
+    )
+    resolved_env_file = args.env_file or config_get(config, "runtime.env_file", None)
+    api_key_env = args.api_key_env or config_get(config, "runtime.auth_env_key", "TIKOMNI_API_KEY")
+    base_url = args.base_url or config_get(config, "runtime.base_url", None)
+    timeout_ms = args.timeout_ms if args.timeout_ms is not None else config_get(config, "runtime.timeout_ms", None)
+
+    try:
+        result = run_douyin_single_video(
+            input_value=args.input,
+            share_url=args.share_url,
+            env_file=resolved_env_file,
+            api_key_env=api_key_env,
+            base_url=base_url,
+            timeout_ms=timeout_ms,
+            app_timeout_ms=args.app_timeout_ms,
+            web_timeout_ms=args.web_timeout_ms,
+            poll_interval_sec=args.poll_interval_sec,
+            max_polls=args.max_polls,
+            u2_submit_max_retries=args.u2_submit_max_retries,
+            u2_submit_backoff_ms=args.u2_submit_backoff_ms,
+            write_card=True,
+            card_type=args.card_type,
+            card_root=args.card_root,
+            content_kind=args.content_kind,
+            storage_config=config,
+            allow_process_env=args.allow_process_env,
+            persist_output=True,
+        )
+    except ValueError as error:
+        result = {
+            "platform": "douyin",
+            "raw_content": "",
+            "summary": "",
+            "insights": ["source=douyin:single-video-low-quality", "runtime_not_ready"],
+            "confidence": "low",
+            "error_reason": str(error),
+            "missing_fields": [],
+            "extract_trace": [],
+            "fallback_trace": [],
+            "request_id": None,
+            "endpoint_list": [],
+        }
+
+    write_json_stdout(result)
+    raise SystemExit(0 if not result.get("error_reason") else 1)
+
+
+if __name__ == "__main__":
+    main()