fix: remove secrets and token from repo, add gitignore

.gitignore

@@ -0,0 +1,10 @@
+client_secrets.json
+token.pickle
+*.pickle
+__pycache__/
+*.pyc
+runs/
+pipeline.log
+trigger_run
+trigger_skip
+TRANSFER_FILE.md

TRANSFER_FILE.md

@@ -1,1283 +0,0 @@
-# YOUTUBE SHORTS PIPELINE — TRANSFER FILE
-**Updated:** 2026-04-25T21:31:32.117518
-
-
-## COMPLETE CHAT HISTORY SUMMARY
-
-### Session 1 — Hardware Proposal Verification
-- Verified: DeepSeek-R1-Distill-Qwen-32B IQ3_XS (~13.7GB) on Kaggle P100 (15.9GB VRAM)
-- flash_attn=False (P100 = sm_60, Flash Attention needs sm_70+) — MANDATORY
-- offload_kqv=False: pushes KV cache to RAM (frees VRAM)
-- n_gpu_layers=-1: all 64 layers to VRAM
-- type_k/type_v=q4_0: compressed KV cache
-- VRAM: 13.7 + 1.1 buffers = 14.8/15.9 GB — safe
-- RAM: 8.6 GB KV cache at 128k ctx — fits in 13 GB RAM
-- Speed: 3-5 tok/s at small ctx, <1 tok/s at full 128k
-
-### Session 2 — Initial Pipeline Build (yt-shorts-bot-v2)
-- User: Arshit (arshitmalik on HF + Kaggle), MacBook Air M1, Delhi India
-- HF key: hf_REDACTED_SET_IN_HF_SECRETS
-- Kaggle: arshitmalik / REDACTED_SET_IN_KAGGLE_KEYS_JSON
-- Problem: OpenRouter + Groq rate limits, org bans
-- Built yt-shorts-bot-v2 with Kaggle DeepSeek-R1 for content + Kaggle FLUX images + Kaggle StyleTTS2 TTS
-- CONFIRMED WORKING: kaggle_template.py (FLUX images), kaggle_tts_stt_template.py (StyleTTS2+Whisper)
-  - kaggle_template.py uses: {{PROMPTS_PLACEHOLDER}} and {{HF_TOKEN_PLACEHOLDER}}
-  - kaggle_tts_stt_template.py uses: {{SCRIPT_PLACEHOLDER}} and {{VIDEO_SPEED_PLACEHOLDER}}
-  - Output: frame_0.png through frame_9.png, voice.wav, word_timings.json
-
-### Session 3 — Mac Setup Fixes
-- Bug: huggingface_hub not installed on Mac → pip3 install huggingface_hub
-- Bug: git auth format wrong → use https://arshitmalik:TOKEN@huggingface.co/... format
-
-### Session 4 — Kaggle Kernel Permission Fix
-- Error: "cannot access kernel" permission denied
-- Root cause: Kaggle API pushes kernels PRIVATE by default
-- Fix: ALL kernel-metadata.json MUST have "is_private": "false" (string, not bool)
-- Also fixed: TTS slug had no random suffix (409 conflict on retry)
-- Also fixed: all slugs now include random suffix to avoid collisions
-
-### Session 5 — HF Inference API proposal (REJECTED)
-- Proposed HF Inference API free tier — user rejected: only $0.10/month and 3 req/hour
-
-### Session 6 — CURRENT: OpenClaw + Ollama + Kaggle Pipeline (yt-openclaw)
-- OpenClaw with local Ollama model (qwen2.5-coder:7b-instruct) as monitoring brain
-- Content generation stays on Kaggle (DeepSeek-R1-32B, cached Dataset)
-- Kaggle FLUX + StyleTTS2 UNCHANGED
-- OpenClaw communicates via Telegram bot
-- SOUL.md defines monitoring/control commands
-- HF Dataset (arshitmalik/yt-pipeline-data) for persistence
-- User already created Kaggle Dataset: deepseek-r1-32b-gguf (private, in arshitmalik account)
-
-
-## CRITICAL CONTEXT FOR NEXT AI
-
-### User Info
-- Name: Arshit | HF username: arshitmalik | Kaggle: arshitmalik
-- Mac: MacBook Air M1 (8GB RAM) — setup only, not 24/7
-- Location: Delhi, India — no credit card for any paid services
-- Goal: 100% free 24/7 YouTube Shorts science channel automation
-
-### Current HF Space
-- Name: yt-openclaw (Docker, free: 2 vCPU, 16 GB RAM)
-- URL: https://arshitmalik-yt-openclaw.hf.space
-- Password: arshit2025 (OPENCLAW_PASSWORD secret)
-
-### HF Dataset (persistence)
-- Name: arshitmalik/yt-pipeline-data (private)
-- Synced files: topic_history.json, fact_history.json, token.pickle
-
-### Kaggle Dataset (GGUF model cache)
-- Name: deepseek-r1-32b-gguf (private, in arshitmalik account)
-- Contains: DeepSeek-R1-Distill-Qwen-32B-IQ3_XS.gguf
-- Mounted at: /kaggle/input/deepseek-r1-32b-gguf/ in kernels
-- kaggle_llm_template.py checks this path first before downloading from HF
-
-### Architecture
-- Ollama: qwen2.5-coder:7b-instruct (CPU, ~4.5GB RAM, ~1-2 tok/s — acceptable for monitoring)
-- OpenClaw gateway: port 8080, nginx proxies 7860->8080
-- OpenClaw Ollama config: baseUrl MUST be http://127.0.0.1:11434/v1 (with /v1!), api: openai-responses
-- Telegram: configured via OpenClaw web UI after Space starts
-
-### CONFIRMED WORKING (DO NOT CHANGE)
-1. kaggle_template.py — FLUX.1-schnell image generation
-   - Placeholders: {{PROMPTS_PLACEHOLDER}}, {{HF_TOKEN_PLACEHOLDER}}
-   - Output: frame_0.png to frame_9.png in /kaggle/working
-2. kaggle_tts_stt_template.py — StyleTTS2 + Whisper TTS
-   - Placeholders: {{SCRIPT_PLACEHOLDER}}, {{VIDEO_SPEED_PLACEHOLDER}}
-   - Output: voice.wav, word_timings.json in /kaggle/working
-
-### Critical Bugs Already Fixed (must stay fixed)
-- ALL kernel-metadata.json: "is_private": "false" (string, not bool)
-- ALL kernel slugs: include random.randint(1000,9999) suffix to avoid 409 conflicts
-- HF Token: check both HF_TOKEN and HF_HUB_TOKEN env vars
-- Ollama baseUrl: must include /v1 suffix or OpenClaw gets empty responses
-- Ollama api field: must be "openai-responses" not default
-
-### kaggle_llm_template.py Placeholders (NOT {{ }} format — plain text)
-- TOPICS_PLACEHOLDER → replaced with JSON array of used topics
-- FACTS_PLACEHOLDER  → replaced with JSON array of used facts
-- FRAMES_PLACEHOLDER → replaced with NUM_FRAMES integer
-- HFTOKEN_PLACEHOLDER → replaced with quoted HF token string
-
-### YouTube OAuth
-- token.pickle generated locally with auth_youtube.py
-- Uploaded to arshitmalik/yt-pipeline-data HF Dataset
-- Pipeline pulls it at startup via sync_hub.py
-
-### Instructions for You (Next AI)
-1. ALWAYS give terminal commands to write/edit files AND git push at the end of every response
-2. NEVER change kaggle_template.py or kaggle_tts_stt_template.py (CONFIRMED WORKING)
-3. NEVER use inline comments in commands (zsh doesn't like them)
-4. git push format: https://arshitmalik:hf_REDACTED_SET_IN_HF_SECRETS@huggingface.co/spaces/arshitmalik/yt-openclaw
-5. UPDATE THIS TRANSFER FILE in every response
-6. When debugging: check /app/pipeline.log, /app/runs/*/error.log, /app/runs/*/state.txt
-7. Kaggle kernels: ALWAYS "is_private": "false" + random int suffix in slug
-8. If user wants new HF Space: create fresh, do NOT reuse yt-shorts-bot or yt-shorts-bot-v2
-9. Space URL format: https://arshitmalik-yt-openclaw.hf.space
-
-## ALL CURRENT FILE CONTENTS
-
-### Dockerfile
-```
-FROM ghcr.io/openclaw/openclaw:latest
-
-RUN apt-get update && apt-get install -y \
-    python3 python3-pip ffmpeg curl git nginx \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN curl -fsSL https://ollama.com/install.sh | sh
-
-RUN pip3 install --break-system-packages \
-    requests kaggle huggingface_hub \
-    google-api-python-client google-auth \
-    google-auth-oauthlib google-auth-httplib2 \
-    pillow numpy
-
-RUN printf 'server {\n    listen 7860;\n    location / {\n        proxy_pass http://127.0.0.1:8080;\n        proxy_http_version 1.1;\n        proxy_set_header Upgrade $http_upgrade;\n        proxy_set_header Connection "upgrade";\n        proxy_set_header Host $host;\n    }\n}\n' > /etc/nginx/sites-available/default
-
-WORKDIR /app
-COPY . .
-RUN chmod +x start.sh
-
-EXPOSE 7860
-CMD ["/app/start.sh"]
-
-```
-
-### start.sh
-```sh
-#!/bin/bash
-set -e
-
-echo "[boot] Configuring Kaggle credentials..."
-if [ -n "$KAGGLE_USERNAME" ] && [ -n "$KAGGLE_KEY" ]; then
-    mkdir -p ~/.kaggle
-    printf '{"username":"%s","key":"%s"}' "$KAGGLE_USERNAME" "$KAGGLE_KEY" > ~/.kaggle/kaggle.json
-    chmod 600 ~/.kaggle/kaggle.json
-fi
-
-echo "[boot] Configuring YouTube client secrets..."
-if [ -n "$YOUTUBE_CLIENT_ID" ] && [ -n "$YOUTUBE_CLIENT_SECRET" ]; then
-    python3 - << PYEOF
-import json, os
-d = {"installed": {
-    "client_id": os.environ["YOUTUBE_CLIENT_ID"],
-    "project_id": "yt-ai-bot",
-    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-    "token_uri": "https://oauth2.googleapis.com/token",
-    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-    "client_secret": os.environ["YOUTUBE_CLIENT_SECRET"],
-    "redirect_uris": ["http://localhost"]
-}}
-open("/app/client_secrets.json", "w").write(json.dumps(d))
-print("[boot] client_secrets.json written")
-PYEOF
-fi
-
-echo "[boot] Pulling state from HF Dataset..."
-python3 - << PYEOF
-import sys; sys.path.insert(0, "/app")
-try:
-    from sync_hub import pull_state
-    from pathlib import Path
-    pull_state(Path("/app"))
-except Exception as e:
-    print(f"[boot] Hub pull skipped: {e}")
-PYEOF
-
-echo "[boot] Pre-configuring OpenClaw with Ollama..."
-mkdir -p ~/.openclaw
-GATEWAY_TOKEN="${OPENCLAW_PASSWORD:-arshit2025}"
-cat > ~/.openclaw/openclaw.json << JSONEOF
-{
-  "models": {
-    "providers": {
-      "ollama": {
-        "baseUrl": "http://127.0.0.1:11434/v1",
-        "apiKey": "ollama-local",
-        "api": "openai-responses",
-        "models": [
-          {
-            "id": "qwen2.5-coder:7b-instruct",
-            "name": "Qwen2.5-Coder 7B (local CPU)",
-            "contextWindow": 8192,
-            "maxTokens": 2048,
-            "cost": {"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0},
-            "input": ["text"]
-          }
-        ]
-      }
-    }
-  },
-  "agents": {
-    "defaults": {
-      "model": {"primary": "ollama/qwen2.5-coder:7b-instruct"}
-    }
-  },
-  "gateway": {
-    "port": 8080,
-    "token": "$GATEWAY_TOKEN"
-  }
-}
-JSONEOF
-cp /app/SOUL.md ~/.openclaw/SOUL.md
-
-echo "[boot] Starting nginx proxy (7860 -> 8080)..."
-nginx
-
-echo "[boot] Starting Ollama service..."
-OLLAMA_HOST=127.0.0.1 ollama serve &
-OLLAMA_PID=$!
-
-echo "[boot] Waiting for Ollama to be ready..."
-for i in $(seq 1 60); do
-    if curl -sf http://127.0.0.1:11434/api/tags > /dev/null 2>&1; then
-        echo "[boot] Ollama ready after ${i}s"
-        break
-    fi
-    sleep 2
-done
-
-echo "[boot] Pulling qwen2.5-coder:7b-instruct (~4.5 GB, first boot only)..."
-ollama pull qwen2.5-coder:7b-instruct
-
-echo "[boot] Starting automation pipeline..."
-python3 /app/automation.py >> /app/pipeline.log 2>&1 &
-PIPE_PID=$!
-echo "[boot] Pipeline PID: $PIPE_PID"
-
-echo "[boot] Starting OpenClaw gateway on port 8080..."
-export OPENCLAW_API_PORT=8080
-export OLLAMA_HOST=http://127.0.0.1:11434
-openclaw gateway start &
-GW_PID=$!
-
-echo "[boot] All services started. Tailing pipeline log..."
-sleep 5
-tail -f /app/pipeline.log
-
-```
-
-### SOUL.md
-```md
-# YouTube Shorts Science Bot — Pipeline Monitor
-
-You are the monitor and operator for Arshit's YouTube Shorts science channel automation pipeline.
-
-## Your Setup
-- You run locally on a HuggingFace Docker Space (2 vCPU, 16 GB RAM)
-- The pipeline runs as a background process at /app/automation.py
-- Pipeline log: /app/pipeline.log
-- Runs directory: /app/runs/
-- State file per run: /app/runs/<run_name>/state.txt
-- Error logs: /app/runs/<run_name>/error.log
-
-## Pipeline Stages (in order)
-1. CONTENT — Kaggle kernel: DeepSeek-R1-32B generates topic, fact, script, prompts, tags
-2. FRAMES — Kaggle kernel: FLUX.1-schnell generates 10 images
-3. TTS — Kaggle kernel: StyleTTS2+Whisper generates voice.wav + word_timings.json
-4. AUDIO — ffmpeg: speed adjustment (1.1x)
-5. VIDEO — ffmpeg: assembles final 1080x1920 mp4 with ASS subtitles
-6. UPLOAD — YouTube Data API v3 publishes the Short
-7. DONE / FAILED
-
-## Telegram Commands You Handle
-
-When the user says "status":
-Run: tail -n 40 /app/pipeline.log
-Then run: find /app/runs -name state.txt -exec sh -c 'echo "$(dirname $1 | xargs basename): $(cat $1)"' _ {} ; 2>/dev/null | head -10
-Summarise: current stage, last action, any errors.
-
-When the user says "logs" or "show logs":
-Run: tail -n 80 /app/pipeline.log
-Return the raw output.
-
-When the user says "errors":
-Run: find /app/runs -name error.log | xargs cat 2>/dev/null | tail -60
-Summarise what failed and in which stage.
-
-When the user says "run now":
-Run: touch /app/trigger_run
-Confirm: "Triggered. Next pipeline cycle will start within 5 minutes."
-
-When the user says "skip":
-Run: touch /app/trigger_skip
-Confirm: "Skipped current wait. Next run in 24 hours."
-
-When the user says "last video":
-Run: ls -t /app/runs/*/youtube_id.txt 2>/dev/null | head -1 | xargs cat 2>/dev/null
-Return: https://youtube.com/watch?v=<id>
-
-When the user says "disk" or "storage":
-Run: df -h /app && du -sh /app/runs/* 2>/dev/null | tail -20
-Return the output.
-
-When the user gives a code change instruction (e.g. "change video speed to 1.2x", "increase frames to 12"):
-1. Read the relevant section of /app/automation.py
-2. Make the precise edit
-3. Kill the old pipeline: pkill -f "automation.py" || true
-4. Restart it: python3 /app/automation.py >> /app/pipeline.log 2>&1 &
-5. Confirm the change and the new PID.
-
-## Rules
-- Always use shell commands to read actual files — never guess or fabricate output
-- Keep responses SHORT for mobile Telegram (3-5 lines max for status, longer only if asked)
-- When editing files, read before writing to avoid mistakes
-- After any file edit, always restart the pipeline process
-- If you cannot fix something, describe exactly what failed and what file to check
-
-```
-
-### README.md
-```md
----
-title: Yt Openclaw
-emoji: 🦞
-colorFrom: red
-colorTo: orange
-sdk: docker
-pinned: false
-license: mit
----
-
-```
-
-### sync_hub.py
-```py
-import os
-from pathlib import Path
-
-HF_TOKEN     = os.environ.get("HF_TOKEN", "hf_REDACTED_SET_IN_HF_SECRETS")
-DATASET_REPO = os.environ.get("OPENCLAW_DATASET_REPO", "")
-
-PERSISTENT_FILES = {"topic_history.json", "fact_history.json", "token.pickle"}
-
-_api = None
-def _get_api():
-    global _api
-    if _api is None:
-        from huggingface_hub import HfApi
-        _api = HfApi(token=HF_TOKEN)
-    return _api
-
-def pull_state(base_dir: Path):
-    if not DATASET_REPO or not HF_TOKEN:
-        print("OPENCLAW_DATASET_REPO not set, skipping Hub pull"); return
-    from huggingface_hub import hf_hub_download
-    from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
-    print(f"Pulling state from {DATASET_REPO}...")
-    for fname in PERSISTENT_FILES:
-        try:
-            hf_hub_download(repo_id=DATASET_REPO, filename=fname, repo_type="dataset",
-                            token=HF_TOKEN, local_dir=str(base_dir), local_dir_use_symlinks=False)
-            print(f"  pulled {fname}")
-        except (EntryNotFoundError, RepositoryNotFoundError): pass
-        except Exception as e: print(f"  could not pull {fname}: {e}")
-
-def push_file(local_path: Path):
-    if not DATASET_REPO or not HF_TOKEN: return
-    if local_path.name not in PERSISTENT_FILES or not local_path.exists(): return
-    try:
-        _get_api().upload_file(
-            path_or_fileobj=str(local_path), path_in_repo=local_path.name,
-            repo_id=DATASET_REPO, repo_type="dataset", token=HF_TOKEN,
-            commit_message=f"auto: {local_path.name}")
-        print(f"  synced {local_path.name} to Hub")
-    except Exception as e:
-        print(f"  Hub sync failed for {local_path.name}: {e}")
-
-def push_all_state(base_dir: Path):
-    for fname in PERSISTENT_FILES:
-        p = base_dir / fname
-        if p.exists(): push_file(p)
-
-```
-
-### automation.py
-```py
-#!/usr/bin/env python3
-import os, json, time, subprocess, pickle, sys, shutil, re, random, traceback, logging
-from pathlib import Path
-from datetime import datetime, timezone
-
-BASE_DIR            = Path(__file__).resolve().parent
-RUNS_DIR            = BASE_DIR / "runs"
-KAGGLE_TEMPLATE     = BASE_DIR / "kaggle_template.py"
-KAGGLE_TTS_TEMPLATE = BASE_DIR / "kaggle_tts_stt_template.py"
-KAGGLE_LLM_TEMPLATE = BASE_DIR / "kaggle_llm_template.py"
-TOPIC_HISTORY_FILE  = BASE_DIR / "topic_history.json"
-FACT_HISTORY_FILE   = BASE_DIR / "fact_history.json"
-KAGGLE_KEYS_FILE    = BASE_DIR / "kaggle_keys.json"
-CLIENT_SECRETS_FILE = BASE_DIR / "client_secrets.json"
-TOKEN_FILE          = BASE_DIR / "token.pickle"
-TRIGGER_RUN_FILE    = BASE_DIR / "trigger_run"
-TRIGGER_SKIP_FILE   = BASE_DIR / "trigger_skip"
-
-NUM_FRAMES   = 10
-VIDEO_SPEED  = 1.1
-SCOPES       = ["https://www.googleapis.com/auth/youtube.upload"]
-RUNS_DIR.mkdir(parents=True, exist_ok=True)
-
-HF_TOKEN = os.environ.get("HF_TOKEN", os.environ.get("HF_HUB_TOKEN", "hf_REDACTED_SET_IN_HF_SECRETS"))
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] %(message)s",
-    datefmt="%H:%M:%S",
-    handlers=[
-        logging.StreamHandler(sys.stdout),
-        logging.FileHandler(BASE_DIR / "pipeline.log", encoding="utf-8"),
-    ]
-)
-log = logging.getLogger()
-
-def load_kaggle_accounts():
-    if KAGGLE_KEYS_FILE.exists():
-        try:
-            return json.loads(KAGGLE_KEYS_FILE.read_text()).get("accounts", [])
-        except: pass
-    u = os.environ.get("KAGGLE_USERNAME", "")
-    k = os.environ.get("KAGGLE_KEY", "")
-    return [{"username": u, "key": k}] if u and k else []
-
-KAGGLE_ACCOUNTS = load_kaggle_accounts()
-
-def set_kaggle_creds(account):
-    kd = Path.home() / ".kaggle"
-    kd.mkdir(exist_ok=True)
-    (kd / "kaggle.json").write_text(json.dumps({"username": account["username"], "key": account["key"]}))
-    (kd / "kaggle.json").chmod(0o600)
-
-def load_json_list(path):
-    if path.exists():
-        try:
-            d = json.loads(path.read_text())
-            return d if isinstance(d, list) else []
-        except: pass
-    return []
-
-def get_used_topics():
-    return load_json_list(TOPIC_HISTORY_FILE)
-
-def get_used_facts():
-    return load_json_list(FACT_HISTORY_FILE)
-
-def save_topic(topic):
-    h = get_used_topics()
-    h.append({"topic": topic, "date": datetime.now().isoformat()})
-    TOPIC_HISTORY_FILE.write_text(json.dumps(h[-200:], ensure_ascii=False, indent=2))
-    try:
-        from sync_hub import push_file
-        push_file(TOPIC_HISTORY_FILE)
-    except: pass
-
-def save_fact(fact, topic=""):
-    h = get_used_facts()
-    h.append({"fact": fact, "topic": topic, "date": datetime.now().isoformat()})
-    FACT_HISTORY_FILE.write_text(json.dumps(h[-200:], ensure_ascii=False, indent=2))
-    try:
-        from sync_hub import push_file
-        push_file(FACT_HISTORY_FILE)
-    except: pass
-
-def load_state(run: Path) -> str:
-    f = run / "state.txt"
-    return f.read_text().strip() if f.exists() else "CONTENT"
-
-def save_state(run: Path, state: str):
-    (run / "state.txt").write_text(state)
-    log.info(f"State -> {state}")
-
-def save_error_log(run: Path, exc: Exception, stage: str):
-    (run / "error.log").write_text(
-        f"[{datetime.now().isoformat()}] Stage: {stage}\n{traceback.format_exc()}")
-
-def atomic_write(path: Path, data):
-    tmp = path.with_suffix(".tmp")
-    txt = json.dumps(data, ensure_ascii=False, indent=2) if isinstance(data, (dict, list)) else str(data)
-    tmp.write_text(txt)
-    tmp.replace(path)
-
-def push_kaggle_kernel(build_dir: Path, main_py_text: str, label: str):
-    (build_dir / "main.py").write_text(main_py_text)
-    suffix = build_dir.parent.name.replace("_", "")[-10:]
-    accounts = KAGGLE_ACCOUNTS.copy()
-    random.shuffle(accounts)
-    for acc in accounts:
-        tag = label[:5].replace(" ", "")
-        slug = f"{acc['username']}/yt-{tag}-{suffix}-{random.randint(1000, 9999)}"
-        meta = {
-            "id": slug,
-            "title": f"YT {label} {suffix}",
-            "code_file": "main.py",
-            "language": "python",
-            "kernel_type": "script",
-            "enable_gpu": "true",
-            "enable_internet": "true",
-            "is_private": "false"
-        }
-        (build_dir / "kernel-metadata.json").write_text(json.dumps(meta, indent=2))
-        set_kaggle_creds(acc)
-        r = subprocess.run(["kaggle", "kernels", "push", "-p", str(build_dir)],
-                           capture_output=True, text=True)
-        if r.returncode == 0:
-            (build_dir / "kaggle_account.json").write_text(
-                json.dumps({"username": acc["username"], "slug": slug}))
-            log.info(f"Pushed {label} ({acc['username']}): {slug}")
-            return
-        log.error(f"Push failed ({acc['username']}): {r.stderr.strip()[:200]}")
-    raise RuntimeError(f"{label} kernel push failed on all accounts")
-
-def wait_kaggle(slug: str, timeout: int = 3600):
-    start = time.time()
-    while time.time() - start < timeout:
-        elapsed = int(time.time() - start)
-        r = subprocess.run(["kaggle", "kernels", "status", slug],
-                           capture_output=True, text=True)
-        status = r.stdout.strip().lower()
-        lines = [l for l in status.split("\n") if "has status" in l]
-        cur = lines[0] if lines else status[:120]
-        log.info(f"  {elapsed//60:02d}:{elapsed%60:02d} | {cur}")
-        if "complete" in status:
-            log.info(f"Kernel done ({elapsed//60}m {elapsed%60}s)")
-            return
-        if "error" in status or "failed" in status:
-            raise RuntimeError(f"Kernel failed: {status}")
-        time.sleep(30)
-    raise RuntimeError(f"Kernel timed out after {timeout//60}min")
-
-def step_content(run: Path):
-    log.info("=" * 56)
-    log.info("STEP 1: CONTENT (Kaggle DeepSeek-R1-32B from Dataset)")
-    log.info("=" * 56)
-    build_dir = run / "kaggle_llm_build"
-    if not build_dir.exists():
-        build_dir.mkdir()
-        used_topics = [e.get("topic", "") for e in get_used_topics()[-60:] if e.get("topic")]
-        used_facts  = get_used_facts()[-20:]
-        tmpl = KAGGLE_LLM_TEMPLATE.read_text()
-        tmpl = tmpl.replace("TOPICS_PLACEHOLDER", json.dumps(used_topics, indent=2))
-        tmpl = tmpl.replace("FACTS_PLACEHOLDER",  json.dumps(used_facts, indent=2))
-        tmpl = tmpl.replace("FRAMES_PLACEHOLDER",  str(NUM_FRAMES))
-        tmpl = tmpl.replace("HFTOKEN_PLACEHOLDER", json.dumps(HF_TOKEN))
-        push_kaggle_kernel(build_dir, tmpl, "llm")
-
-    info = json.loads((build_dir / "kaggle_account.json").read_text())
-    for acc in KAGGLE_ACCOUNTS:
-        if acc["username"] == info["username"]:
-            set_kaggle_creds(acc); break
-
-    log.info(f"Waiting for LLM kernel {info['slug']} ...")
-    log.info("  (Dataset mount ~0min + inference ~3-5min)")
-    wait_kaggle(info["slug"])
-
-    log.info("Downloading content.json ...")
-    subprocess.run(["kaggle", "kernels", "output", info["slug"], "-p", str(run)],
-                   check=True, capture_output=True)
-
-    candidates = list(run.glob("**/content.json"))
-    if not candidates:
-        raise RuntimeError("content.json not found in kernel output")
-    src = candidates[0]
-    dst = run / "content.json"
-    if src != dst: shutil.move(str(src), str(dst))
-
-    data = json.loads(dst.read_text())
-    missing = [k for k in ("topic", "fact", "hook", "title", "script", "prompts", "tags")
-               if not data.get(k)]
-    if missing:
-        raise RuntimeError(f"content.json missing: {missing}")
-    if len(data["prompts"]) < NUM_FRAMES:
-        raise RuntimeError(f"Only {len(data['prompts'])}/{NUM_FRAMES} prompts")
-
-    save_topic(data["topic"])
-    save_fact(data["fact"], topic=data["topic"])
-    log.info(f"Content OK: topic={data['topic']} | {data['script_char_count']}c | {len(data['prompts'])} prompts")
-    shutil.rmtree(build_dir, ignore_errors=True)
-    save_state(run, "FRAMES")
-
-def step_frames(run: Path):
-    log.info("=" * 56)
-    log.info("STEP 2: IMAGES (Kaggle FLUX.1-schnell)")
-    log.info("=" * 56)
-    build_dir = run / "kaggle_frames_build"
-    if not build_dir.exists():
-        build_dir.mkdir()
-        data = json.loads((run / "content.json").read_text())
-        tmpl = KAGGLE_TEMPLATE.read_text()
-        tmpl = tmpl.replace("{{PROMPTS_PLACEHOLDER}}", json.dumps(data["prompts"], indent=2))
-        tmpl = tmpl.replace("{{HF_TOKEN_PLACEHOLDER}}", json.dumps(HF_TOKEN))
-        push_kaggle_kernel(build_dir, tmpl, "frames")
-
-    info = json.loads((build_dir / "kaggle_account.json").read_text())
-    for acc in KAGGLE_ACCOUNTS:
-        if acc["username"] == info["username"]:
-            set_kaggle_creds(acc); break
-    wait_kaggle(info["slug"])
-    subprocess.run(["kaggle", "kernels", "output", info["slug"], "-p", str(run)],
-                   check=True, capture_output=True)
-    frames = sorted(run.glob("**/frame_*.png"))
-    if len(frames) < NUM_FRAMES:
-        raise RuntimeError(f"Only {len(frames)}/{NUM_FRAMES} frames")
-    for f in frames:
-        if f.parent != run: shutil.move(str(f), str(run / f.name))
-    log.info(f"Downloaded {len(frames)} frames")
-    shutil.rmtree(build_dir, ignore_errors=True)
-    save_state(run, "TTS")
-
-def step_tts(run: Path):
-    log.info("=" * 56)
-    log.info("STEP 3: TTS (Kaggle StyleTTS2 + Whisper)")
-    log.info("=" * 56)
-    build_dir = run / "kaggle_tts_build"
-    if not build_dir.exists():
-        build_dir.mkdir()
-        data = json.loads((run / "content.json").read_text())
-        tmpl = KAGGLE_TTS_TEMPLATE.read_text()
-        tmpl = tmpl.replace("{{SCRIPT_PLACEHOLDER}}", json.dumps(data["script"]))
-        tmpl = tmpl.replace("{{VIDEO_SPEED_PLACEHOLDER}}", str(VIDEO_SPEED))
-        push_kaggle_kernel(build_dir, tmpl, "tts")
-
-    info = json.loads((build_dir / "kaggle_account.json").read_text())
-    for acc in KAGGLE_ACCOUNTS:
-        if acc["username"] == info["username"]:
-            set_kaggle_creds(acc); break
-    wait_kaggle(info["slug"])
-    subprocess.run(["kaggle", "kernels", "output", info["slug"], "-p", str(run)],
-                   check=True, capture_output=True)
-    voice   = next(iter(run.glob("**/voice.wav")),         None)
-    timings = next(iter(run.glob("**/word_timings.json")), None)
-    if not voice:   raise RuntimeError("voice.wav not found in TTS output")
-    if not timings: raise RuntimeError("word_timings.json not found in TTS output")
-    if voice.parent   != run: shutil.move(str(voice),   str(run / "voice.wav"))
-    if timings.parent != run: shutil.move(str(timings), str(run / "word_timings.json"))
-    log.info("TTS done: voice.wav + word_timings.json")
-    shutil.rmtree(build_dir, ignore_errors=True)
-    save_state(run, "AUDIO")
-
-def step_audio(run: Path):
-    log.info("STEP 4: AUDIO PROCESSING")
-    voice_fast = run / "voice_fast.wav"
-    r = subprocess.run(
-        ["ffmpeg", "-y", "-i", str(run / "voice.wav"),
-         "-filter:a", f"atempo={VIDEO_SPEED}", str(voice_fast)],
-        capture_output=True, text=True)
-    if r.returncode != 0:
-        raise RuntimeError(f"ffmpeg speed failed: {r.stderr[:300]}")
-    r2 = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
-         "-of", "csv=p=0", str(voice_fast)],
-        capture_output=True, text=True, check=True)
-    audio_dur = float(r2.stdout.strip())
-    timings = json.loads((run / "word_timings.json").read_text())
-    adj = [{"word": w["word"], "start": w["start"] / VIDEO_SPEED, "end": w["end"] / VIDEO_SPEED}
-           for w in timings]
-    atomic_write(run / "adjusted_timings.json", adj)
-    atomic_write(run / "audio_duration.txt", str(audio_dur))
-    log.info(f"Audio: {audio_dur:.2f}s at {VIDEO_SPEED}x")
-    save_state(run, "VIDEO")
-
-def build_ass(timings, out_path: Path, W=1080, H=1920):
-    def ts(s):
-        h = int(s // 3600); m = int((s % 3600) // 60); sec = s % 60
-        return f"{h}:{m:02d}:{sec:05.2f}"
-    header = (
-        "[Script Info]\nScriptType: v4.00+\n"
-        f"PlayResX: {W}\nPlayResY: {H}\nScaledBorderAndShadow: yes\n\n"
-        "[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, "
-        "OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, "
-        "Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n"
-        "Style: Default,Arial,72,&H00FFFFFF,&H000000FF,&H00000000,&H80000000,"
-        "-1,0,0,0,100,100,0,0,1,3,2,2,50,50,80,1\n\n"
-        "[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
-    lines = [header]
-    for chunk in [timings[i:i+5] for i in range(0, len(timings), 5)]:
-        if not chunk: continue
-        text = " ".join(w["word"] for w in chunk)
-        lines.append(f"Dialogue: 0,{ts(chunk[0]['start'])},{ts(chunk[-1]['end'])},Default,,0,0,0,,{text}\n")
-    out_path.write_text("".join(lines), encoding="utf-8")
-
-def step_video(run: Path):
-    log.info("STEP 5: VIDEO ASSEMBLY")
-    adj  = json.loads((run / "adjusted_timings.json").read_text())
-    dur  = float((run / "audio_duration.txt").read_text().strip())
-    frames = sorted(run.glob("frame_*.png"))
-    if not frames: raise RuntimeError("No frames found")
-    W, H = 1080, 1920
-    frame_dur = dur / len(frames)
-    concat_file = run / "frames.txt"
-    with open(concat_file, "w") as f:
-        for fr in frames:
-            f.write(f"file '{fr}'\nduration {frame_dur:.6f}\n")
-        f.write(f"file '{frames[-1]}'\n")
-    slides = run / "slides.mp4"
-    r = subprocess.run([
-        "ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", str(concat_file),
-        "-vf", f"scale={W}:{H}:force_original_aspect_ratio=increase,crop={W}:{H}",
-        "-c:v", "libx264", "-preset", "fast", "-pix_fmt", "yuv420p", "-r", "30", str(slides)
-    ], capture_output=True, text=True)
-    if r.returncode != 0: raise RuntimeError(f"Slides failed: {r.stderr[:400]}")
-    ass = run / "subtitles.ass"
-    build_ass(adj, ass, W, H)
-    final = run / "final.mp4"
-    r = subprocess.run([
-        "ffmpeg", "-y", "-i", str(slides), "-i", str(run / "voice_fast.wav"),
-        "-vf", f"ass={ass}",
-        "-c:v", "libx264", "-preset", "fast", "-c:a", "aac", "-b:a", "192k",
-        "-shortest", str(final)
-    ], capture_output=True, text=True)
-    if r.returncode != 0: raise RuntimeError(f"Final video failed: {r.stderr[:400]}")
-    log.info(f"Final video: {final.stat().st_size / 1024 / 1024:.1f} MB")
-    save_state(run, "UPLOAD")
-
-def step_upload(run: Path):
-    log.info("STEP 6: YOUTUBE UPLOAD")
-    data  = json.loads((run / "content.json").read_text())
-    final = run / "final.mp4"
-    if not final.exists(): raise RuntimeError("final.mp4 not found")
-    try:
-        from sync_hub import pull_state
-        pull_state(BASE_DIR)
-    except: pass
-    creds = None
-    if TOKEN_FILE.exists():
-        with open(TOKEN_FILE, "rb") as f:
-            creds = pickle.load(f)
-    if not creds or not creds.valid:
-        if creds and creds.expired and creds.refresh_token:
-            from google.auth.transport.requests import Request
-            creds.refresh(Request())
-            with open(TOKEN_FILE, "wb") as f: pickle.dump(creds, f)
-        else:
-            raise RuntimeError(
-                "token.pickle missing or invalid. Run auth_youtube.py on your Mac, "
-                "then upload token.pickle to HF Dataset arshitmalik/yt-pipeline-data")
-    try:
-        from sync_hub import push_file
-        push_file(TOKEN_FILE)
-    except: pass
-    from googleapiclient.discovery import build
-    from googleapiclient.http import MediaFileUpload
-    yt = build("youtube", "v3", credentials=creds)
-    body = {
-        "snippet": {
-            "title": data.get("title", "Science Fact")[:100],
-            "description": data.get("fact", "") + "\n\n" + "\n".join(data.get("tags", [])),
-            "tags": data.get("tags", []),
-            "categoryId": "28",
-            "defaultLanguage": "en"
-        },
-        "status": {"privacyStatus": "public", "selfDeclaredMadeForKids": False}
-    }
-    media = MediaFileUpload(str(final), chunksize=4 * 1024 * 1024, resumable=True)
-    req = yt.videos().insert(part="snippet,status", body=body, media_body=media)
-    log.info("Uploading to YouTube...")
-    resp = None
-    while resp is None:
-        status, resp = req.next_chunk()
-        if status: log.info(f"Upload progress: {int(status.progress() * 100)}%")
-    vid_id = resp.get("id", "unknown")
-    log.info(f"Published: https://youtube.com/watch?v={vid_id}")
-    atomic_write(run / "youtube_id.txt", vid_id)
-    try:
-        from sync_hub import push_all_state
-        push_all_state(BASE_DIR)
-    except: pass
-    save_state(run, "DONE")
-
-STEPS = {
-    "CONTENT":   step_content,
-    "FRAMES":    step_frames,
-    "TTS":       step_tts,
-    "AUDIO":     step_audio,
-    "VIDEO":     step_video,
-    "UPLOAD":    step_upload,
-}
-
-def main():
-    log.info("=" * 56)
-    log.info("YouTube Shorts Pipeline — STARTING")
-    log.info(f"DeepSeek-R1-32B (Kaggle) | FLUX (Kaggle) | StyleTTS2 (Kaggle)")
-    log.info(f"Frames: {NUM_FRAMES} | Speed: {VIDEO_SPEED}x | Accounts: {len(KAGGLE_ACCOUNTS)}")
-    log.info("=" * 56)
-    try:
-        from sync_hub import pull_state
-        pull_state(BASE_DIR)
-    except: pass
-
-    NEXT_RUN_AFTER = time.time() + 15
-
-    while True:
-        if TRIGGER_SKIP_FILE.exists():
-            TRIGGER_SKIP_FILE.unlink(missing_ok=True)
-            NEXT_RUN_AFTER = time.time() + 86400
-            log.info("Skipped. Next run in 24h.")
-            time.sleep(60); continue
-
-        if TRIGGER_RUN_FILE.exists():
-            TRIGGER_RUN_FILE.unlink(missing_ok=True)
-            NEXT_RUN_AFTER = 0
-            log.info("Triggered immediate run!")
-
-        if time.time() < NEXT_RUN_AFTER:
-            left = NEXT_RUN_AFTER - time.time()
-            if int(left) % 300 < 30:
-                log.info(f"Next run in {left/3600:.1f}h ...")
-            time.sleep(30); continue
-
-        run = None
-        if RUNS_DIR.exists():
-            for d in sorted(RUNS_DIR.iterdir(), key=lambda x: x.stat().st_mtime, reverse=True):
-                if d.is_dir() and load_state(d) not in ("DONE", "FAILED"):
-                    run = d; break
-        if not run:
-            run = RUNS_DIR / datetime.now().strftime("%Y%m%d_%H%M%S")
-            run.mkdir(parents=True)
-            save_state(run, "CONTENT")
-
-        state = load_state(run)
-        log.info(f"\nRun: {run.name}  Stage: {state}")
-        try:
-            if state in STEPS:
-                STEPS[state](run)
-            else:
-                save_state(run, "FAILED")
-        except KeyboardInterrupt:
-            log.info("Interrupted"); sys.exit(0)
-        except Exception as e:
-            log.error(f"Error in {state}: {e}")
-            traceback.print_exc()
-            save_error_log(run, e, state)
-            save_state(run, "FAILED")
-
-        cur = load_state(run)
-        if cur == "DONE":
-            content = json.loads((run / "content.json").read_text())
-            yt_id = (run / "youtube_id.txt").read_text().strip() if (run / "youtube_id.txt").exists() else "?"
-            log.info(f"\nCOMPLETE: {content.get('title', '')} — https://youtube.com/watch?v={yt_id}")
-            try: shutil.rmtree(run)
-            except: pass
-            NEXT_RUN_AFTER = time.time() + 86400
-            log.info("Next run in 24h.")
-        elif cur == "FAILED":
-            log.error(f"FAILED — check: {run}")
-            NEXT_RUN_AFTER = time.time() + 300
-            log.info("Retrying in 5 min.")
-
-if __name__ == "__main__":
-    main()
-
-```
-
-### kaggle_llm_template.py
-```py
-#!/usr/bin/env python3
-import os, sys, json, re, subprocess, gc
-from pathlib import Path
-
-OUTPUT_DIR = Path("/kaggle/working")
-OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-USED_TOPICS = TOPICS_PLACEHOLDER
-USED_FACTS  = FACTS_PLACEHOLDER
-NUM_FRAMES  = FRAMES_PLACEHOLDER
-HF_TOKEN    = HFTOKEN_PLACEHOLDER
-
-NUM_FRAMES = int(NUM_FRAMES)
-
-print("=" * 60)
-print("DeepSeek-R1-32B Content Generator (Kaggle Dataset Cache)")
-print("=" * 60)
-
-DATASET_MODEL_PATH = Path("/kaggle/input/deepseek-r1-32b-gguf/DeepSeek-R1-Distill-Qwen-32B-IQ3_XS.gguf")
-MODEL_DOWNLOAD_DIR = Path("/kaggle/temp/model")
-
-if DATASET_MODEL_PATH.exists():
-    model_path = str(DATASET_MODEL_PATH)
-    print(f"Using cached model from Dataset: {model_path}")
-    print("Compiling llama-cpp-python for sm_60...")
-    os.environ["CMAKE_ARGS"] = "-DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=60"
-    os.environ["FORCE_CMAKE"] = "1"
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "llama-cpp-python", "--no-cache-dir", "-q"],
-        stdout=subprocess.DEVNULL)
-else:
-    print("Dataset not found, downloading from HF Hub...")
-    os.environ["CMAKE_ARGS"] = "-DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=60"
-    os.environ["FORCE_CMAKE"] = "1"
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "llama-cpp-python", "huggingface_hub", "--no-cache-dir", "-q"],
-        stdout=subprocess.DEVNULL)
-    from huggingface_hub import hf_hub_download
-    kw = dict(
-        repo_id="bartowski/DeepSeek-R1-Distill-Qwen-32B-GGUF",
-        filename="DeepSeek-R1-Distill-Qwen-32B-IQ3_XS.gguf",
-        local_dir=str(MODEL_DOWNLOAD_DIR))
-    if HF_TOKEN:
-        kw["token"] = HF_TOKEN
-    model_path = hf_hub_download(**kw)
-    print(f"Downloaded to: {model_path}")
-
-print("\nLoading model...")
-from llama_cpp import Llama
-llm = Llama(
-    model_path=model_path,
-    n_gpu_layers=-1,
-    n_ctx=4096,
-    n_batch=256,
-    n_ubatch=256,
-    flash_attn=False,
-    offload_kqv=False,
-    type_k="q4_0",
-    type_v="q4_0",
-    verbose=False)
-print("Model loaded\n")
-
-_STOP = ["<|im_end|>", "<|end_of_text|>", "</s>"]
-
-def infer(prompt, max_tokens=600, temperature=0.35):
-    resp = llm.create_chat_completion(
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens, temperature=temperature, stop=_STOP)
-    text = resp["choices"][0]["message"]["content"] or ""
-    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
-    return text
-
-print("=" * 60 + "\nGenerating content...\n" + "=" * 60)
-
-used_str = "\n".join(f"- {t}" for t in USED_TOPICS[-60:]) or "none yet"
-
-TOPIC = ""
-for att in range(8):
-    raw = infer(
-        "Viral YouTube Shorts science content creator.\n\n"
-        "Topics already used - DO NOT repeat any:\n" + used_str + "\n\n"
-        "Generate exactly ONE new unique topic for a 60-second science Short.\n"
-        "Requirements: 2-6 words, physics/space/cosmology/quantum only, "
-        "makes viewers say WHAT or NO WAY, no living creatures or people, "
-        "never: quantum tunneling, parallel universe, dark energy, big bang.\n"
-        "Output ONLY the topic (2-6 words):",
-        max_tokens=50, temperature=0.35 + att * 0.05)
-    topic = re.sub(r"[^a-zA-Z0-9 \-]", "", raw.lower().strip().strip('"\'*- ')).strip()
-    if 2 <= len(topic.split()) <= 6 and 5 <= len(topic) <= 60:
-        TOPIC = topic
-        print(f"Topic: {TOPIC}")
-        break
-    print(f"  bad topic att {att+1}: '{raw[:50]}'")
-if not TOPIC:
-    raise RuntimeError("Could not generate valid topic in 8 attempts")
-
-recent_facts = "; ".join(e.get("fact", "")[:55] for e in USED_FACTS[-5:]) or "none"
-
-FACT = ""
-for att in range(6):
-    raw = infer(
-        "Scientific fact writer for viral science videos.\n\n"
-        f"Topic: {TOPIC}\n"
-        f"Recent facts used (use DIFFERENT angle): {recent_facts}\n\n"
-        "Write ONE astonishing scientific fact about this topic.\n"
-        "Rules: 1-2 sentences, include extreme number/comparison, 100% accurate, "
-        "no people/animals, start directly with fact.\nOutput ONLY the fact:",
-        max_tokens=200, temperature=0.30 + att * 0.05)
-    fact = raw.strip().strip('"\'')
-    bad = ["as an ai", "i will", "let me", "here is", "sure!", "certainly", "of course"]
-    if any(b in fact.lower() for b in bad):
-        print(f"  meta text att {att+1}"); continue
-    if len(fact.split()) < 8:
-        print(f"  too short att {att+1}"); continue
-    FACT = fact
-    print(f"Fact: {FACT[:100]}...")
-    break
-if not FACT:
-    raise RuntimeError("Could not generate valid fact in 6 attempts")
-
-HOOK = infer(
-    f"Fact: {FACT}\n\nWrite ONE hook that stops mid-scroll.\n"
-    "Must start with: What if..., Imagine..., or Did you know...\nOutput ONLY the hook:",
-    max_tokens=120, temperature=0.35).strip().strip('"\'')
-print(f"Hook: {HOOK[:90]}...")
-
-raw_script = infer(
-    f"Topic: {TOPIC}\nHook: {HOOK}\nFact: {FACT}\n\n"
-    "Write a 60-second voiceover script. Plain text only, no brackets or stage directions, "
-    "900-1050 characters, flow: hook->fact->details->CTA. "
-    "Final sentence MUST be: Follow for more mind-blowing science facts!\nOutput ONLY the script:",
-    max_tokens=1100, temperature=0.35)
-SCRIPT = re.sub(r"\s+", " ", re.sub(r"\[.*?\]", "", raw_script)).strip()
-if len(SCRIPT) > 1200: SCRIPT = SCRIPT[:1200].rsplit(" ", 1)[0]
-if "follow for more" not in SCRIPT.lower():
-    end = " Follow for more mind-blowing science facts!"
-    SCRIPT = SCRIPT + end if len(SCRIPT) + len(end) <= 1200 else SCRIPT[:1200 - len(end)].rsplit(" ", 1)[0] + end
-print(f"Script: {len(SCRIPT.split())}w {len(SCRIPT)}c")
-
-TITLE = infer(
-    f"Topic: {TOPIC}\nScript preview: {SCRIPT[:200]}\n\n"
-    "Write ONE viral YouTube Shorts title. KEY WORDS in ALL CAPS, 1-2 emojis, "
-    "include number if possible, max 100 chars, scientifically accurate.\nOutput ONLY the title:",
-    max_tokens=100, temperature=0.35).strip().strip('"\'')[:100]
-print(f"Title: {TITLE}")
-
-PROMPTS = []
-for att in range(5):
-    raw = infer(
-        f"Topic: {TOPIC}\nScript: {SCRIPT}\n\n"
-        f"Create EXACTLY {NUM_FRAMES} cosmic/space image prompts.\n"
-        "Rules: 15-25 words each, ZERO humans/faces/text, different visual each, "
-        "end every prompt with: cinematic lighting, highly detailed, 8k\n"
-        f"Output ONLY the numbered list 1 to {NUM_FRAMES}:",
-        max_tokens=1600, temperature=0.35)
-    parsed = [re.sub(r"^\d+[\.\)]\s*", "", l.strip())
-              for l in raw.split("\n") if re.match(r"^\d+[\.\)]\s+\S", l.strip())]
-    parsed = [p for p in parsed if len(p.split()) >= 5]
-    if len(parsed) >= NUM_FRAMES:
-        PROMPTS = parsed[:NUM_FRAMES]; break
-    print(f"  got {len(parsed)}/{NUM_FRAMES} prompts att {att+1}")
-if len(PROMPTS) < NUM_FRAMES:
-    raise RuntimeError(f"Only {len(PROMPTS)}/{NUM_FRAMES} image prompts")
-
-raw_tags = infer(
-    f"Generate 12 hashtags for a science Short about: {TOPIC}\n"
-    "Each starts with #, lowercase no spaces inside, relevant to physics/space/science.\n"
-    "Output ONLY hashtags one per line:",
-    max_tokens=280, temperature=0.3)
-TAGS_gen = ["#" + t.strip().strip("#").lower().replace(" ", "")
-            for t in raw_tags.split("\n") if t.strip().startswith("#")][:12]
-TAGS = list(dict.fromkeys(["#shorts", "#science", "#space", "#physics", "#physicsfacts"] + TAGS_gen))[:15]
-print(f"{len(TAGS)} tags")
-
-import datetime as _dt
-content = {
-    "topic": TOPIC, "fact": FACT, "hook": HOOK, "title": TITLE, "script": SCRIPT,
-    "script_word_count": len(SCRIPT.split()), "script_char_count": len(SCRIPT),
-    "tags": TAGS, "prompts": PROMPTS,
-    "timestamp": _dt.datetime.now().isoformat()
-}
-out = OUTPUT_DIR / "content.json"
-out.write_text(json.dumps(content, indent=2, ensure_ascii=False))
-print(f"\n{'='*60}")
-print(f"content.json saved ({out.stat().st_size} bytes)")
-print(f"  Topic:  {TOPIC}")
-print(f"  Title:  {TITLE}")
-print(f"  Script: {len(SCRIPT)} chars / {len(SCRIPT.split())} words")
-print(f"  Frames: {len(PROMPTS)}")
-print("=" * 60)
-
-```
-
-### auth_youtube.py
-```py
-#!/usr/bin/env python3
-"""
-Run this ONCE on your Mac to generate token.pickle.
-Then upload it to HF Dataset: arshitmalik/yt-pipeline-data
-"""
-import pickle, json
-from pathlib import Path
-from google_auth_oauthlib.flow import InstalledAppFlow
-
-SCOPES = ["https://www.googleapis.com/auth/youtube.upload"]
-
-import os
-cid = os.environ.get("YOUTUBE_CLIENT_ID", "")
-cs  = os.environ.get("YOUTUBE_CLIENT_SECRET", "")
-if cid and cs and not Path("client_secrets.json").exists():
-    Path("client_secrets.json").write_text(json.dumps({"installed": {
-        "client_id": cid, "project_id": "yt-ai-bot",
-        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-        "token_uri": "https://oauth2.googleapis.com/token",
-        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-        "client_secret": cs, "redirect_uris": ["http://localhost"]}}))
-
-flow = InstalledAppFlow.from_client_secrets_file("client_secrets.json", SCOPES)
-creds = flow.run_local_server(port=0)
-with open("token.pickle", "wb") as f:
-    pickle.dump(creds, f)
-print("token.pickle saved! Now run the upload command below.")
-
-```
-
-### kaggle_keys.json
-```json
-{"accounts":[{"username":"arshitmalik","key":"REDACTED_SET_IN_KAGGLE_KEYS_JSON"}]}
-
-```
-
-### kaggle_template.py
-```py
-# kaggle_template.py
-# =====================================================
-# KAGGLE IMAGE WORKER (FLUX.1-SCHNELL)
-# =====================================================
-import os, torch, gc, subprocess, sys
-
-# Install bitsandbytes if missing (Critical for T4 GPU)
-try:
-    import bitsandbytes
-except ImportError:
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "-U", "bitsandbytes"])
-
-from diffusers import FluxPipeline, FluxTransformer2DModel, BitsAndBytesConfig
-from pathlib import Path
-
-# --- CONFIG ---
-# The automation script will inject the prompts here automatically
-PROMPTS = [
-    # {{PROMPTS_PLACEHOLDER}}
-]
-
-OUTPUT_DIR = Path("/kaggle/working/images")
-OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-# --- MODEL LOADING ---
-print("📦 Loading Quantized Flux...")
-
-# 4-bit config to fit Flux on Kaggle T4s
-bnb_config = BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_quant_type="nf4",
-    bnb_4bit_compute_dtype=torch.bfloat16,
-)
-
-# Load Transformer
-transformer = FluxTransformer2DModel.from_pretrained(
-    "black-forest-labs/FLUX.1-schnell",
-    subfolder="transformer",
-    quantization_config=bnb_config,
-    torch_dtype=torch.bfloat16,
-    low_cpu_mem_usage=True
-)
-
-# Load Pipeline
-pipe = FluxPipeline.from_pretrained(
-    "black-forest-labs/FLUX.1-schnell",
-    transformer=transformer,
-    torch_dtype=torch.bfloat16,
-)
-
-pipe.enable_model_cpu_offload()
-
-# --- GENERATION ---
-print(f"🎨 Generating {len(PROMPTS)} images...")
-
-for i, prompt in enumerate(PROMPTS, 1):
-    print(f"   Frame {i}/{len(PROMPTS)}...")
-    gc.collect()
-    torch.cuda.empty_cache()
-    
-    # Generate
-    image = pipe(
-        prompt=prompt,
-        width=1072, 
-        height=1920,
-        num_inference_steps=4, # Schnell is fast
-        guidance_scale=1.0,
-        max_sequence_length=512,
-    ).images[0]
-    
-    # Save
-    save_path = OUTPUT_DIR / f"{i:02d}.png"
-    image.save(save_path)
-    print(f"   ✅ Saved: {save_path.name}")
-
-print("🏁 Job Complete")
-```
-
-### kaggle_tts_stt_template.py
-```py
-# kaggle_tts_stt_template.py
-# StyleTTS2 (LibriTTS, full quality) + Whisper large-v3 (float32, no quantization)
-# Optimised for single P100 GPU / 16 GB VRAM
-# Output: /kaggle/working/voice.wav  +  /kaggle/working/words.json
-
-import os, json, re, gc, subprocess, sys
-from pathlib import Path
-import torch
-import numpy as np
-
-OUTPUT_DIR  = Path("/kaggle/working")
-SCRIPT_TEXT = {{SCRIPT_TEXT_PLACEHOLDER}}
-
-# ── System deps ───────────────────────────────────────────────────────────────
-print("📦 System deps...")
-subprocess.check_call(["apt-get","install","-y","-q","espeak-ng","libsndfile1"],
-                      stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
-
-# ── Python deps ───────────────────────────────────────────────────────────────
-print("📦 Installing styletts2 + phonemizer + soundfile...")
-subprocess.check_call([sys.executable,"-m","pip","install","-q",
-                       "styletts2","phonemizer","gruut","soundfile"])
-
-# ── CRITICAL: restore numpy 2.x ───────────────────────────────────────────────
-# styletts2 pip solver downgrades numpy to 1.26.x but Kaggle's pre-compiled
-# pandas/bigquery/kaggle_gcp require numpy 2.x — causes binary incompatibility crash.
-# Fix: force reinstall numpy 2.x BEFORE any google/pandas import.
-print("🔧 Restoring numpy>=2.0...")
-subprocess.check_call([sys.executable,"-m","pip","install","-q",
-                       "--upgrade","--force-reinstall","--no-deps","numpy>=2.0.0"])
-
-print("📦 Installing openai-whisper...")
-subprocess.check_call([sys.executable,"-m","pip","install","-q","openai-whisper"])
-
-import importlib
-numpy = importlib.import_module("numpy")
-print(f"✅ numpy {numpy.__version__}")
-
-# ── Prepare script ────────────────────────────────────────────────────────────
-clean = re.sub(r'\[.*?\]','',SCRIPT_TEXT).strip()
-clean = re.sub(r'\s+',' ',clean)
-print(f"\n📝 Script: {len(clean)} chars")
-if not clean: raise RuntimeError("Empty script")
-
-# ── StyleTTS2 TTS ─────────────────────────────────────────────────────────────
-print("\n🎙️  StyleTTS2...")
-from styletts2.tts import StyleTTS2
-import soundfile as sf
-
-tts    = StyleTTS2()
-wav    = tts.inference(text=clean,alpha=0.3,beta=0.7,diffusion_steps=10,embedding_scale=1)
-wav_np = numpy.array(wav,dtype=numpy.float32)
-sf.write(str(OUTPUT_DIR/"voice.wav"),wav_np,24000)
-dur    = len(wav_np)/24000
-print(f"✅ voice.wav ({dur:.1f}s)")
-if dur < 5: raise RuntimeError(f"voice.wav only {dur:.1f}s — TTS failed")
-
-del tts,wav,wav_np; gc.collect(); torch.cuda.empty_cache()
-print("🧹 VRAM cleared")
-
-# ── Whisper large-v3 (fp32, full quality) ─────────────────────────────────────
-print("\n📝 Whisper large-v3 (fp32)...")
-import whisper
-
-model  = whisper.load_model("large-v3",device="cuda")
-result = model.transcribe(str(OUTPUT_DIR/"voice.wav"),language="en",
-                          word_timestamps=True,verbose=False,
-                          beam_size=5,best_of=5,temperature=0.0,fp16=False)
-
-words = []
-for seg in result["segments"]:
-    for w in seg.get("words",[]):
-        t = w["word"].strip()
-        if t: words.append({"text":t,"start":round(float(w["start"]),3),"end":round(float(w["end"]),3)})
-
-if not words: raise RuntimeError("Whisper returned 0 words")
-(OUTPUT_DIR/"words.json").write_text(json.dumps(words,indent=2))
-print(f"✅ words.json ({len(words)} words)")
-print("\n🏁 TTS+STT Complete")
-
-```
-
-## MANUAL STEPS REQUIRED AFTER PUSH
-
-1. Set Space secrets at https://huggingface.co/spaces/arshitmalik/yt-openclaw/settings
-   OPENCLAW_PASSWORD=arshit2025
-   HF_TOKEN=hf_REDACTED_SET_IN_HF_SECRETS
-   OPENCLAW_DATASET_REPO=arshitmalik/yt-pipeline-data
-   KAGGLE_USERNAME=arshitmalik
-   KAGGLE_KEY=REDACTED_SET_IN_KAGGLE_KEYS_JSON
-   YOUTUBE_CLIENT_ID=(from Google Cloud Console)
-   YOUTUBE_CLIENT_SECRET=(from Google Cloud Console)
-   TELEGRAM_TOKEN=(from @BotFather)
-
-2. Run auth_youtube.py on Mac, upload token.pickle to arshitmalik/yt-pipeline-data dataset
-3. Go to Space URL, enter password arshit2025, configure Telegram channel in sidebar
-4. Set up UptimeRobot: ping https://arshitmalik-yt-openclaw.hf.space every 5 min

client_secrets.json

@@ -1 +0,0 @@
-{"installed": {"client_id": "945316832951-u78qvtfc3239hhp5tgv9pb6fqdrlujko.apps.googleusercontent.com", "project_id": "yt-ai-bot", "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://oauth2.googleapis.com/token", "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", "client_secret": "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", "redirect_uris": ["http://localhost"]}}