Spaces:
Paused
Paused
| """Motion Factory daily cron — drives the OpenReels API inside this container. | |
| POST /api/v1/jobs {topic, providers{...}} -> poll GET /api/v1/jobs/:id | |
| -> copy final mp4 to /data/motion/renders + index.jsonl. | |
| Env: RUN_HOUR_UTC (14), RUNNER_ENABLED (1), CHANNEL_NICHE, | |
| OMNIROUTE_* (topic generation + pipeline LLM), PEXELS_API_KEY. | |
| """ | |
| import json | |
| import os | |
| import shutil | |
| import time | |
| from datetime import datetime, timezone | |
| from pathlib import Path | |
| import requests | |
| API = "http://127.0.0.1:7860" | |
| RUN_HOUR_UTC = int(os.environ.get("RUN_HOUR_UTC", "14")) | |
| DATA_ROOT = Path("/data/motion") if os.path.isdir("/data") else Path.home() / ".motion" | |
| RENDERS = DATA_ROOT / "renders" | |
| TOPICS_FILE = DATA_ROOT / "topics.json" | |
| INDEX_FILE = RENDERS / "index.jsonl" | |
| POLL_INTERVAL = 30 | |
| POLL_MAX = 60 * 50 # 50 min ceiling | |
| def log(m): | |
| print(f"[runner {datetime.now(timezone.utc):%H:%M:%S}] {m}", flush=True) | |
| def load_topics(): | |
| try: | |
| return json.loads(TOPICS_FILE.read_text()) | |
| except Exception: | |
| return {"topics": [], "used": []} | |
| def save_topics(d): | |
| TOPICS_FILE.parent.mkdir(parents=True, exist_ok=True) | |
| TOPICS_FILE.write_text(json.dumps(d, indent=2)) | |
| def llm_topic(niche): | |
| key, base = os.environ.get("OMNIROUTE_API_KEY"), os.environ.get("OMNIROUTE_BASE_URL", "").rstrip("/") | |
| model = os.environ.get("OMNIROUTE_MODEL", "") | |
| if not (key and base): | |
| return None | |
| try: | |
| r = requests.post( | |
| f"{base}/v1/chat/completions", | |
| headers={"Authorization": f"Bearer {key}"}, | |
| json={"model": model, "max_tokens": 60, "messages": [{"role": "user", "content": | |
| f"Give me ONE specific, viral-worthy topic for a faceless YouTube Short " | |
| f"about {niche}. Reply with ONLY the topic text."}]}, | |
| timeout=90) | |
| r.raise_for_status() | |
| return (r.json()["choices"][0]["message"]["content"].strip().strip('"') or None)[:120] | |
| except Exception as e: | |
| log(f"llm topic failed: {e}") | |
| return None | |
| def next_topic(): | |
| d = load_topics() | |
| while d["topics"]: | |
| t = d["topics"].pop(0).strip() | |
| if t and t not in d["used"]: | |
| d["used"].append(t) | |
| save_topics(d) | |
| return t | |
| niche = os.environ.get("CHANNEL_NICHE", "surprising science and technology facts") | |
| save_topics(d) | |
| return llm_topic(niche) | |
| def create_job(topic): | |
| body = { | |
| "topic": topic, | |
| "noVideo": True, | |
| "providers": { | |
| "llm": "openai-compatible", | |
| "llmModel": os.environ.get("OMNIROUTE_MODEL", ""), | |
| "llmBaseUrl": os.environ.get("OMNIROUTE_BASE_URL", "").rstrip("/") + "/v1", | |
| "tts": "kokoro", | |
| "stock": "pexels", | |
| "music": "bundled", | |
| "searchProvider": "none", | |
| }, | |
| } | |
| for attempt in range(3): | |
| try: | |
| r = requests.post(f"{API}/api/v1/jobs", json=body, timeout=60) | |
| if r.status_code == 200: | |
| jid = r.json().get("jobId") or r.json().get("id") | |
| log(f"job created: {jid}") | |
| return jid | |
| log(f"create attempt {attempt+1} -> {r.status_code} {r.text[:200]}") | |
| except Exception as e: | |
| log(f"create attempt {attempt+1} error: {e}") | |
| time.sleep(20) | |
| return None | |
| def poll_job(jid): | |
| waited = 0 | |
| while waited < POLL_MAX: | |
| time.sleep(POLL_INTERVAL) | |
| waited += POLL_INTERVAL | |
| try: | |
| r = requests.get(f"{API}/api/v1/jobs/{jid}", timeout=30) | |
| r.raise_for_status() | |
| meta = r.json() | |
| except Exception as e: | |
| log(f"poll error: {e}") | |
| continue | |
| status = meta.get("status") | |
| stages = meta.get("stages", {}) | |
| cur = " ".join(f"{k}:{v.get('status','?')}" for k, v in stages.items() if v.get("status") not in ("pending",)) | |
| log(f"job {jid}: {status} | {cur[:160]}") | |
| if status in ("completed", "failed", "cancelled"): | |
| return meta | |
| log("poll timeout") | |
| return None | |
| def archive(meta, topic): | |
| vp = meta.get("videoPath") | |
| if not vp: | |
| log(f"no videoPath; error={str(meta.get('error'))[:200]}") | |
| return | |
| src = Path(vp) | |
| if not src.exists(): | |
| cand = list(Path("/app/jobs").rglob("*.mp4")) | |
| src = max(cand, key=lambda p: p.stat().st_size) if cand else None | |
| if not src: | |
| log("mp4 not found on disk") | |
| return | |
| RENDERS.mkdir(parents=True, exist_ok=True) | |
| stamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S") | |
| slug = "".join(c if c.isalnum() else "-" for c in topic.lower())[:40].strip("-") | |
| dst = RENDERS / f"{stamp}_{slug}.mp4" | |
| shutil.copy2(src, dst) | |
| with INDEX_FILE.open("a") as f: | |
| f.write(json.dumps({"date": stamp, "topic": topic, "file": dst.name, | |
| "size_mb": round(dst.stat().st_size / 1e6, 2)}) + "\n") | |
| log(f"ARCHIVED {dst.name}") | |
| def run_once(): | |
| topic = next_topic() | |
| if not topic: | |
| log("no topic; skipping") | |
| return | |
| log(f"creating job for: {topic!r}") | |
| jid = create_job(topic) | |
| if not jid: | |
| return | |
| meta = poll_job(jid) | |
| if meta and meta.get("status") == "completed": | |
| archive(meta, topic) | |
| def seconds_until_next_run(): | |
| now = datetime.now(timezone.utc) | |
| t = now.replace(hour=RUN_HOUR_UTC, minute=0, second=0, microsecond=0) | |
| from datetime import timedelta | |
| if t <= now: | |
| t += timedelta(days=1) | |
| return (t - now).total_seconds() | |
| def main(): | |
| if os.environ.get("RUNNER_ENABLED", "1") != "1": | |
| log("disabled; idling") | |
| while True: | |
| time.sleep(3600) | |
| for _ in range(120): | |
| try: | |
| requests.get(f"{API}/api/v1/health", timeout=5) | |
| break | |
| except Exception: | |
| time.sleep(5) | |
| log(f"online; daily run at {RUN_HOUR_UTC}:00 UTC") | |
| while True: | |
| w = seconds_until_next_run() | |
| log(f"next run in {w/3600:.1f}h") | |
| time.sleep(max(w, 10)) | |
| try: | |
| run_once() | |
| except Exception as e: | |
| log(f"cycle crashed: {e}") | |
| if __name__ == "__main__": | |
| main() | |