AI short drama & micro-drama video generator — turns any idea into a complete short-form drama using multi-agent AI pipeline (screenwriter → storyboard → frames → video). Seedance 2 VIP, Kling 3.0 Pro, Veo 3.1, Sora 2.
Python agentic-aiai-dramaai-filmmakingai-short-dramaai-video-generationdrama-generatorfastapigenerative-aiimage-to-videokling-aimicro-dramamulti-agentnextjsseedanceseedance2short-dramashort-filmshort-form-videotext-to-videoveo3
import asyncio
import json
import os
import uuid
from pathlib import Path
from typing import Any, Dict
from dotenv import load_dotenv
load_dotenv()
from fastapi import FastAPI, BackgroundTasks, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
from pipelines.idea2video import Idea2VideoPipeline
from pipelines.script2video import Script2VideoPipeline
from agents.character_extractor import CharacterExtractor
# ---------------------------------------------------------------------------
# App setup
# ---------------------------------------------------------------------------
app = FastAPI(title="MicroDrama AI API", version="1.0.0")
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Ensure outputs directory exists on startup
OUTPUTS_DIR = Path("outputs")
OUTPUTS_DIR.mkdir(exist_ok=True)
app.mount("/outputs", StaticFiles(directory="outputs"), name="outputs")
# ---------------------------------------------------------------------------
# In-memory job store
# ---------------------------------------------------------------------------
# job structure:
# {
# "status": "running" | "completed" | "failed",
# "events": [...], # list of JSON-serialisable dicts
# "video_url": str | None,
# "error": str | None,
# "queue": asyncio.Queue, # fed by pipeline, consumed by SSE
# }
jobs: Dict[str, Dict[str, Any]] = {}
# ---------------------------------------------------------------------------
# Request / Response schemas
# ---------------------------------------------------------------------------
class GenerateRequest(BaseModel):
idea: str
user_requirement: str = ""
style: str = "Cinematic"
mode: str = "idea2video" # "idea2video" or "script2video"
script: str = "" # used when mode == "script2video"
class GenerateResponse(BaseModel):
job_id: str
class JobResult(BaseModel):
job_id: str
status: str
video_url: str | None = None
error: str | None = None
# ---------------------------------------------------------------------------
# Background pipeline runner
# ---------------------------------------------------------------------------
async def run_pipeline(job_id: str, req: GenerateRequest) -> None:
job = jobs[job_id]
queue: asyncio.Queue = job["queue"]
async def progress_callback(stage: str, message: str, progress: int) -> None:
event = {
"type": "progress",
"stage": stage,
"message": message,
"progress": progress,
}
job["events"].append(event)
await queue.put(event)
try:
if req.mode == "script2video":
# Script2Video: user provides a single scene script
pipeline = Script2VideoPipeline()
character_extractor = CharacterExtractor()
await progress_callback("characters", "Extracting characters...", 10)
characters = await character_extractor.extract_characters(req.script or req.idea)
output_dir = str(OUTPUTS_DIR / job_id / "scene_00")
video_path = await pipeline.run(
script=req.script or req.idea,
characters=characters,
user_requirement=req.user_requirement,
style=req.style,
working_dir=output_dir,
progress_callback=progress_callback,
scene_idx=0,
base_progress=15,
progress_range=80,
)
else:
# Idea2Video: full agentic pipeline
pipeline = Idea2VideoPipeline()
video_path = await pipeline.run(
idea=req.idea,
user_requirement=req.user_requirement,
style=req.style,
job_id=job_id,
progress_callback=progress_callback,
)
# Convert local path to URL
rel_path = Path(video_path).relative_to(Path("."))
video_url = f"/{rel_path}"
job["status"] = "completed"
job["video_url"] = video_url
complete_event = {
"type": "complete",
"video_url": video_url,
"progress": 100,
}
job["events"].append(complete_event)
await queue.put(complete_event)
except Exception as exc:
error_msg = str(exc)
job["status"] = "failed"
job["error"] = error_msg
error_event = {
"type": "error",
"message": error_msg,
"progress": -1,
}
job["events"].append(error_event)
await queue.put(error_event)
finally:
# Signal SSE consumers that the stream is done
await queue.put(None)
# ---------------------------------------------------------------------------
# Endpoints
# ---------------------------------------------------------------------------
@app.get("/api/health")
async def health():
return {"status": "ok", "service": "microdrama-api"}
@app.post("/api/generate", response_model=GenerateResponse)
async def generate(req: GenerateRequest, background_tasks: BackgroundTasks):
job_id = str(uuid.uuid4())
jobs[job_id] = {
"status": "running",
"events": [],
"video_url": None,
"error": None,
"queue": asyncio.Queue(),
}
background_tasks.add_task(run_pipeline, job_id, req)
return GenerateResponse(job_id=job_id)
@app.get("/api/status/{job_id}")
async def status_stream(job_id: str):
"""SSE endpoint — streams progress events until job completes or fails."""
if job_id not in jobs:
raise HTTPException(status_code=404, detail="Job not found")
job = jobs[job_id]
async def event_generator():
# Replay already-emitted events first (in case client reconnects)
for event in job["events"]:
yield f"data: {json.dumps(event)}\n\n"
# If job is already done, we've replayed everything — finish
if job["status"] in ("completed", "failed"):
return
# Otherwise stream live events from queue
queue: asyncio.Queue = job["queue"]
while True:
event = await queue.get()
if event is None:
# Sentinel — pipeline finished
break
yield f"data: {json.dumps(event)}\n\n"
if event.get("type") in ("complete", "error"):
break
return StreamingResponse(
event_generator(),
media_type="text/event-stream",
headers={
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"X-Accel-Buffering": "no",
},
)
@app.get("/api/result/{job_id}", response_model=JobResult)
async def get_result(job_id: str):
if job_id not in jobs:
raise HTTPException(status_code=404, detail="Job not found")
job = jobs[job_id]
return JobResult(
job_id=job_id,
status=job["status"],
video_url=job.get("video_url"),
error=job.get("error"),
)
# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------
if __name__ == "__main__":
import uvicorn
uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=True)