Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,587 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import os
+import io
+import zipfile
+import replicate
+import time
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timedelta, date
+from typing import Dict, Any, List, Tuple, Optional, Union
+import requests
 import streamlit as st
+from pymongo import MongoClient
+import boto3
+from uuid import uuid4
+from dotenv import load_dotenv
+from urllib.parse import urlparse
+import threading
+from functools import lru_cache
+import json
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("imagegen_app")
+
+REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
+MONGO_URI = os.getenv("MONGO_URI")
+MONGO_DB = os.getenv("MONGO_DB", "adgenesis_image_text")
+MONGO_COLLECTION = os.getenv("MONGO_COLLECTION", "creatives")
+MAX_WORKERS = min(32, (os.cpu_count() or 1) + 4)
+REQUEST_TIMEOUT = 30
+RETRY_ATTEMPTS = 3
+LIBRARY_PAGE_SIZE = 20
+
+MODEL_REGISTRY: Dict[str, Dict[str, Any]] = {
+    "imagegen-4-ultra": {"id": "google/imagen-4-ultra","aspect_ratios": ["1:1", "16:9", "9:16", "3:4", "4:3"],"param_name": "aspect_ratio"},
+    "imagen-4": {"id": "google/imagen-4","aspect_ratios": ["1:1", "16:9", "9:16", "3:4", "4:3"],"param_name": "aspect_ratio"},
+    "nano-banana": {"id": "google/nano-banana","aspect_ratios": ["1:1", "16:9", "9:16", "3:4", "4:3"],"param_name": "aspect_ratio"},
+    "qwen": {"id": "qwen/qwen-image","aspect_ratios": ["1:1", "16:9", "9:16", "3:4", "4:3", "3:2", "2:3"],"param_name": "aspect_ratio"},
+    "seedream-3": {"id": "bytedance/seedream-3","aspect_ratios": ["1:1", "16:9", "9:16", "3:4", "4:3", "3:2", "2:3", "21:9"],"param_name": "aspect_ratio"},
+    "recraft-v3": {"id": "recraft-ai/recraft-v3","aspect_ratios": ["1:1", "4:3", "3:4", "3:2", "2:3", "16:9", "9:16", "1:2", "2:1", "7:5", "5:7", "4:5", "5:4", "3:5", "5:3"],"param_name": "aspect_ratio"},
+    "photon": {"id": "luma/photon","aspect_ratios": ["1:1", "3:4", "4:3", "9:16", "16:9", "9:21", "21:9"],"param_name": "aspect_ratio"},
+    "ideogram-v3-quality": {"id": "ideogram-ai/ideogram-v3-quality","aspect_ratios": ["1:3", "3:1", "1:2", "2:1", "9:16", "16:9", "10:16", "16:10", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "1:1"],"param_name": "aspect_ratio"},
+}
+
+_thread_local = threading.local()
+
+def get_mongo_collection():
+    if not hasattr(_thread_local, 'mongo_collection'):
+        if not MONGO_URI:
+            _thread_local.mongo_collection = None
+            return None
+        try:
+            client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=3000)
+            db = client[MONGO_DB]
+            collection = db[MONGO_COLLECTION]
+            client.admin.command('ping')
+            _thread_local.mongo_collection = collection
+        except Exception as e:
+            logger.error(f"MongoDB connection failed: {e}")
+            _thread_local.mongo_collection = None
+    return _thread_local.mongo_collection
+
+def get_s3_client():
+    if not hasattr(_thread_local, 's3_client'):
+        required_vars = ["R2_ENDPOINT", "R2_ACCESS_KEY", "R2_SECRET_KEY", "R2_BUCKET_NAME"]
+        missing = [var for var in required_vars if not os.getenv(var)]
+        if missing:
+            _thread_local.s3_client = None
+            return None
+        try:
+            _thread_local.s3_client = boto3.client(
+                "s3",
+                endpoint_url=os.getenv("R2_ENDPOINT"),
+                aws_access_key_id=os.getenv("R2_ACCESS_KEY"),
+                aws_secret_access_key=os.getenv("R2_SECRET_KEY"),
+                region_name="auto",
+            )
+        except Exception as e:
+            logger.error(f"S3 client initialization failed: {e}")
+            _thread_local.s3_client = None
+    return _thread_local.s3_client
+
+@lru_cache(maxsize=128)
+def get_model_config(model_key: str) -> Optional[Dict[str, Any]]:
+    return MODEL_REGISTRY.get(model_key)
+
+def upload_to_r2_optimized(image_bytes: bytes) -> Optional[str]:
+    s3_client = get_s3_client()
+    if not s3_client:
+        return None
+    for attempt in range(RETRY_ATTEMPTS):
+        try:
+            filename = f"{uuid4().hex}.png"
+            file_key = f"adgenesis_image_file/balraaj/images/{filename}"
+            s3_client.put_object(
+                Bucket=os.getenv("R2_BUCKET_NAME"),
+                Key=file_key,
+                Body=image_bytes,
+                ContentType="image/png",
+            )
+            r2_url = f'{os.getenv("NEW_BASE").rstrip("/")}/{file_key}'
+            return r2_url
+        except Exception:
+            if attempt == RETRY_ATTEMPTS - 1:
+                return None
+            time.sleep(2 ** attempt)
+    return None
+
+def generate_one_image_optimized(model_key: str, prompt: str, aspect_ratio: str) -> List[str]:
+    if not REPLICATE_API_TOKEN:
+        return []
+    config = get_model_config(model_key)
+    if not config:
+        return []
+    for attempt in range(RETRY_ATTEMPTS):
+        try:
+            model_id = config["id"]
+            ar_param = config["param_name"]
+            inputs = {"prompt": prompt, ar_param: aspect_ratio}
+            output = replicate.run(model_id, input=inputs)
+            urls: List[str] = []
+            if isinstance(output, list) and output:
+                first = output[0]
+                url = getattr(first, "url", str(first))
+                urls = [url]
+            elif isinstance(output, str):
+                urls = [output]
+            elif hasattr(output, "url"):
+                urls = [getattr(output, "url")]
+            if urls:
+                return urls
+        except Exception:
+            if attempt == RETRY_ATTEMPTS - 1:
+                return []
+            time.sleep(1)
+    return []
+
+def fetch_image_bytes_optimized(url: Union[str, Any]) -> Optional[bytes]:
+    url_str = getattr(url, "url", str(url))
+    for attempt in range(RETRY_ATTEMPTS):
+        try:
+            response = requests.get(
+                url_str,
+                timeout=REQUEST_TIMEOUT,
+                headers={"Cache-Control": "no-cache","Pragma": "no-cache","User-Agent": "Mozilla/5.0 (compatible; ImageBot/1.0)"},
+                stream=True
+            )
+            response.raise_for_status()
+            content = b""
+            for chunk in response.iter_content(chunk_size=8192):
+                content += chunk
+            return content
+        except Exception:
+            if attempt == RETRY_ATTEMPTS - 1:
+                return None
+            time.sleep(1)
+    return None
+
+def process_single_image(args: Tuple[str, str, str, int]) -> Dict[str, Any]:
+    model_key, prompt, aspect_ratio, index = args
+    result = {"index": index,"success": False,"source_url": None,"r2_url": None,"error": None}
+    try:
+        urls = generate_one_image_optimized(model_key, prompt, aspect_ratio)
+        if not urls:
+            result["error"] = "No URLs returned from generation"
+            return result
+        source_url = urls[0]
+        result["source_url"] = getattr(source_url, "url", str(source_url))
+        img_bytes = fetch_image_bytes_optimized(source_url)
+        if not img_bytes:
+            result["error"] = "Failed to fetch image bytes"
+            return result
+        r2_url = upload_to_r2_optimized(img_bytes)
+        if r2_url:
+            result["r2_url"] = r2_url
+            result["success"] = True
+        else:
+            result["error"] = "Failed to upload to R2"
+    except Exception as e:
+        result["error"] = str(e)
+    return result
+
+def generate_images_parallel(model_key: str, aspect_ratio: str, prompt: str, num_images: int) -> Tuple[List[str], List[str], List[str]]:
+    if num_images == 1:
+        result = process_single_image((model_key, prompt, aspect_ratio, 0))
+        if result["success"]:
+            return [result["r2_url"]], [result["source_url"]], []
+        else:
+            return [], [], [result["error"] or "Generation failed"]
+    args_list = [(model_key, prompt, aspect_ratio, i) for i in range(num_images)]
+    all_r2_urls: List[str] = []
+    all_source_urls: List[str] = []
+    generation_errors: List[str] = []
+    with ThreadPoolExecutor(max_workers=min(MAX_WORKERS, num_images)) as executor:
+        future_to_index = {executor.submit(process_single_image, args): args[3] for args in args_list}
+        for future in as_completed(future_to_index):
+            try:
+                result = future.result()
+                if result["success"]:
+                    all_r2_urls.append(result["r2_url"])
+                    if result["source_url"]:
+                        all_source_urls.append(result["source_url"])
+                else:
+                    error_msg = result["error"] or f"Generation {result['index']} failed"
+                    generation_errors.append(error_msg)
+            except Exception as e:
+                generation_errors.append(f"Future execution error: {str(e)}")
+    return all_r2_urls, all_source_urls, generation_errors
+
+def save_creative_record_optimized(model_key: str, aspect_ratio: str, prompt: str, urls: List[str]) -> Optional[str]:
+    collection = get_mongo_collection()
+    if collection is None:
+        return None
+    try:
+        doc = {"model": model_key,"aspect_ratio": aspect_ratio,"prompt": prompt,"urls": urls,"num_images": len(urls),"lob": "balraaj","created_at": datetime.utcnow()}
+        result = collection.insert_one(doc)
+        return str(result.inserted_id)
+    except Exception:
+        return None
+
+@st.cache_data(ttl=300)
+def query_creatives_optimized(start_dt: datetime, end_dt: datetime, page: int = 0) -> Tuple[List[Dict[str, Any]], int]:
+    collection = get_mongo_collection()
+    if collection is None:
+        return [], 0
+    try:
+        total_count = collection.count_documents({"created_at": {"$gte": start_dt, "$lt": end_dt},"lob": "balraaj"})
+        cursor = collection.find({"created_at": {"$gte": start_dt, "$lt": end_dt}, "lob": "balraaj"}).sort("created_at", -1).skip(page * LIBRARY_PAGE_SIZE).limit(LIBRARY_PAGE_SIZE)
+        records = list(cursor)
+        return records, total_count
+    except Exception:
+        return [], 0
+
+@st.cache_data(ttl=3600)
+def get_image_bytes_cached(url: str) -> Optional[bytes]:
+    return fetch_image_bytes_optimized(url)
+
+def display_image_with_download_optimized(url: Any, button_label: str = "Download image"):
+    url_str = getattr(url, "url", str(url))
+    try:
+        img_bytes = get_image_bytes_cached(url_str)
+        if img_bytes is None:
+            st.error("Failed to load image")
+            return
+        st.image(img_bytes, use_container_width=True)
+        path = urlparse(url_str).path
+        base = os.path.basename(path) or "image.png"
+        if not os.path.splitext(base)[1]:
+            base = f"{base}.png"
+        st.download_button(label=button_label, data=img_bytes, file_name=base, mime="image/png", use_container_width=True)
+    except Exception as e:
+        st.error(f"Failed to display image: {e}")
+
+def bulk_download_button(urls: List[str], filename: str = "images_bundle.zip"):
+    if not urls:
+        return
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w", compression=zipfile.ZIP_DEFLATED) as zip_file:
+        for idx, url in enumerate(urls):
+            try:
+                img_bytes = fetch_image_bytes_optimized(url)
+                if img_bytes:
+                    path = urlparse(str(url)).path
+                    base = os.path.basename(path) or f"image_{idx}.png"
+                    if not os.path.splitext(base)[1]:
+                        base = f"{base}.png"
+                    zip_file.writestr(base, img_bytes)
+            except Exception:
+                pass
+    zip_buffer.seek(0)
+    st.download_button("Download All Images", data=zip_buffer, file_name=filename, mime="application/zip", use_container_width=True)
+
+def main_app():
+    st.set_page_config(page_title="Image Generator + Creative Library", layout="wide")
+    st.title("Multi Model Image Generator")
+    with st.sidebar:
+        page = st.radio(" ", ["Generate Bulk Images", "Generate from JSON", "Creative Library"], index=0)
+    if page == "Generate Bulk Images":
+        render_generate_page()
+    elif page == "Generate from JSON":
+        render_json_page()
+    elif page == "Creative Library":
+        render_library_page()
+
+def render_generate_page():
+    colA, colB = st.columns([1, 1])
+    with colA:
+        model_key = st.selectbox("Model", list(MODEL_REGISTRY.keys()), index=0)
+        aspect_options = MODEL_REGISTRY[model_key]["aspect_ratios"]
+        aspect_ratio = st.selectbox("Aspect Ratio", aspect_options, index=0)
+        num_images = st.slider("Number of images", min_value=1, max_value=50, value=1, step=1)
+    with colB:
+        prompt = st.text_area("Prompt", placeholder="Describe the image you want to generate...", height=160)
+        debug_mode = st.checkbox("Debug Mode")
+    if st.button("Generate Images", type="primary", use_container_width=True):
+        handle_image_generation_optimized(model_key, aspect_ratio, prompt, num_images, debug_mode)
+
+def handle_image_generation_optimized(model_key: str, aspect_ratio: str, prompt: str, num_images: int, debug_mode: bool = False):
+    if not REPLICATE_API_TOKEN:
+        st.error("Missing REPLICATE_API_TOKEN. Set it as an environment variable.")
+        return
+    if not prompt.strip():
+        st.warning("Please enter a prompt.")
+        return
+    progress = st.progress(0, text="Starting generation...")
+    status_container = st.empty()
+    start_time = time.time()
+    try:
+        with status_container.container():
+            st.info(f"Generating {num_images} image(s) in parallel...")
+        progress.progress(0.1, text="Initializing parallel generation...")
+        all_r2_urls, all_source_urls, generation_errors = generate_images_parallel(model_key, aspect_ratio, prompt.strip(), num_images)
+        progress.progress(0.8, text="Saving results...")
+        rec_id = None
+        if all_r2_urls:
+            rec_id = save_creative_record_optimized(model_key, aspect_ratio, prompt.strip(), all_r2_urls)
+        progress.progress(1.0, text="Complete!")
+        generation_time = time.time() - start_time
+        if all_r2_urls:
+            with status_container.container():
+                st.success(f"Generated {len(all_r2_urls)} image(s) in {generation_time:.1f}s. Saved to DB: {rec_id or 'N/A'}")
+            display_image_gallery_optimized(all_r2_urls)
+            bulk_download_button(all_r2_urls, filename="generated_images.zip")
+        elif all_source_urls:
+            with status_container.container():
+                st.warning("Images generated but R2 upload failed. Showing originals:")
+            display_image_gallery_optimized(all_source_urls)
+            bulk_download_button(all_source_urls, filename="generated_images.zip")
+        else:
+            with status_container.container():
+                st.error("No images were generated.")
+            if generation_errors and debug_mode:
+                with st.expander("Generation Errors", expanded=True):
+                    for error in generation_errors:
+                        st.error(f"{error}")
+    except Exception as e:
+        with status_container.container():
+            st.error(f"Generation failed: {str(e)}")
+
+def display_image_gallery_optimized(urls: List[str]):
+    if not urls:
+        return
+    num_cols = min(4, len(urls)) if len(urls) > 1 else 1
+    cols = st.columns(num_cols)
+    for idx, url in enumerate(urls):
+        with cols[idx % num_cols]:
+            try:
+                display_image_with_download_optimized(url)
+            except Exception as e:
+                st.error(f"Failed to display image: {e}")
+
+def render_library_page():
+    st.subheader("Creative Library")
+    if "library_page" not in st.session_state:
+        st.session_state.library_page = 0
+    today_utc = datetime.utcnow().date()
+    default_start = today_utc - timedelta(days=30)
+    c1, c2, c3 = st.columns([1, 1, 1])
+    with c1:
+        start_date: date = st.date_input("Start date", value=default_start)
+    with c2:
+        end_date: date = st.date_input("End date", value=today_utc)
+    with c3:
+        if st.button("Apply Filters", use_container_width=True):
+            st.session_state.library_page = 0
+            st.cache_data.clear()
+    start_dt = datetime.combine(start_date, datetime.min.time())
+    end_dt = datetime.combine(end_date + timedelta(days=1), datetime.min.time())
+    records, total_count = query_creatives_optimized(start_dt, end_dt, st.session_state.library_page)
+    if not records and st.session_state.library_page == 0:
+        st.info("No creatives found for the selected dates.")
+        return
+    start_idx = st.session_state.library_page * LIBRARY_PAGE_SIZE + 1
+    end_idx = min(start_idx + len(records) - 1, total_count)
+    st.caption(f"Showing {start_idx}-{end_idx} of {total_count} items")
+    if total_count > LIBRARY_PAGE_SIZE:
+        col1, col2, col3, col4 = st.columns([1, 1, 1, 1])
+        with col1:
+            if st.button("First", disabled=st.session_state.library_page == 0):
+                st.session_state.library_page = 0
+                st.rerun()
+        with col2:
+            if st.button("Previous", disabled=st.session_state.library_page == 0):
+                st.session_state.library_page = max(0, st.session_state.library_page - 1)
+                st.rerun()
+        with col3:
+            max_page = (total_count - 1) // LIBRARY_PAGE_SIZE
+            if st.button("Next", disabled=st.session_state.library_page >= max_page):
+                st.session_state.library_page += 1
+                st.rerun()
+        with col4:
+            max_page = (total_count - 1) // LIBRARY_PAGE_SIZE
+            if st.button("Last", disabled=st.session_state.library_page >= max_page):
+                st.session_state.library_page = max_page
+                st.rerun()
+    display_creative_grid_optimized(records)
+
+def display_creative_grid_optimized(records: List[Dict[str, Any]]):
+    if not records:
+        return
+    items: List[Tuple[str, str, str, datetime]] = []
+    for doc in records:
+        created_at = doc.get("created_at", datetime.utcnow())
+        model = doc.get("model", "?")
+        aspect = doc.get("aspect_ratio", "?")
+        urls = doc.get("urls", []) or []
+        for url in urls:
+            items.append((url, model, aspect, created_at))
+    if not items:
+        return
+    if "selected_urls" not in st.session_state:
+        st.session_state.selected_urls = set()
+    colA, colB, colC = st.columns([1, 1, 2])
+    with colA:
+        if st.button("Select all on this page", use_container_width=True, disabled=not items):
+            for (url, _, _, _) in items:
+                st.session_state.selected_urls.add(getattr(url, "url", str(url)))
+    with colB:
+        if st.button("Clear selection", use_container_width=True, disabled=not st.session_state.selected_urls):
+            st.session_state.selected_urls = set()
+    with colC:
+        if st.session_state.selected_urls:
+            zip_bytes = build_zip_from_selected()
+            st.download_button("Download selected (.zip)", data=zip_bytes, file_name="selected_images.zip", mime="application/zip", use_container_width=True)
+    cols = st.columns(4)
+    for i, (url, model, aspect, created_at) in enumerate(items):
+        with cols[i % 4]:
+            try:
+                display_image_with_download_optimized(url)
+                st.caption(f"{model} • {aspect} • {created_at.strftime('%Y-%m-%d %H:%M UTC')}")
+                url_str = getattr(url, "url", str(url))
+                key = f"lib_sel_{hash(url_str)}_{i}"
+                checked = st.checkbox("Select", key=key, value=(url_str in st.session_state.selected_urls))
+                if checked:
+                    st.session_state.selected_urls.add(url_str)
+                else:
+                    st.session_state.selected_urls.discard(url_str)
+            except Exception as e:
+                st.error(f"Failed to display image: {e}")
+
+def build_zip_from_selected() -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for i, u in enumerate(sorted(list(st.session_state.selected_urls)), 1):
+            data = get_image_bytes_cached(u)
+            if data:
+                path = urlparse(u).path
+                base = os.path.basename(path) or f"image_{i}.png"
+                if not os.path.splitext(base)[1]:
+                    base = f"{base}.png"
+                zf.writestr(base, data)
+    buf.seek(0)
+    return buf.getvalue()
+
+@lru_cache(maxsize=1)
+def check_token_cached(user_token: str) -> Tuple[bool, str]:
+    ACCESS_TOKEN = os.getenv("ACCESS_TOKEN")
+    if not ACCESS_TOKEN:
+        return False, "Server error: Access token not configured."
+    if user_token == ACCESS_TOKEN:
+        return True, ""
+    return False, "Invalid token."
+
+def load_json_prompts(file) -> List[Dict[str, Any]]:
+    raw = file.getvalue().decode("utf-8", errors="replace")
+    data = json.loads(raw)
+    prompts_out: List[Dict[str, Any]] = []
+    def push(idx: int, item: Any):
+        if isinstance(item, str):
+            prompts_out.append({"id": f"p{idx}", "content": item})
+        elif isinstance(item, dict) and "content" in item:
+            obj = {"id": str(item.get("id", f"p{idx}")), "content": str(item["content"])}
+            if "num" in item: obj["num"] = int(item["num"])
+            if "aspect_ratio" in item: obj["aspect_ratio"] = str(item["aspect_ratio"])
+            if "model" in item: obj["model"] = str(item["model"])
+            prompts_out.append(obj)
+    if isinstance(data, dict) and "prompts" in data and isinstance(data["prompts"], list):
+        for i, item in enumerate(data["prompts"], 1):
+            push(i, item)
+    elif isinstance(data, list):
+        for i, item in enumerate(data, 1):
+            push(i, item)
+    return prompts_out
+
+def render_json_page():
+    st.subheader("Generate from JSON Prompts")
+    up = st.file_uploader("Upload prompts JSON", type=["json"])
+    col1, col2, col3 = st.columns([1,1,1])
+    with col1:
+        default_model = st.selectbox("Default Model", list(MODEL_REGISTRY.keys()), index=0)
+    with col2:
+        aspect_options = MODEL_REGISTRY[default_model]["aspect_ratios"]
+        default_aspect = st.selectbox("Default Aspect Ratio", aspect_options, index=0, key="json_default_ar")
+    with col3:
+        default_num = st.slider("Default Images per Prompt", 1, 20, 1, 1, key="json_default_num")
+    debug_mode = st.checkbox("Debug Mode", value=False, key="json_debug")
+    if up:
+        try:
+            prompts_list = load_json_prompts(up)
+            if not prompts_list:
+                st.error("No prompts found in the JSON.")
+                return
+            with st.expander("Preview normalized prompts", expanded=False):
+                st.json(prompts_list, expanded=False)
+            if st.button("Generate for All Prompts", type="primary", use_container_width=True):
+                handle_bulk_json_generation(prompts_list, default_model, default_aspect, default_num, debug_mode)
+        except json.JSONDecodeError as e:
+            st.error(f"Invalid JSON: {e}")
+        except Exception as e:
+            st.error(f"Failed to read prompts: {e}")
+    else:
+        st.caption("Your JSON can be a list of strings, a list of objects with `content`, or `{ 'prompts': [...] }`. Optional per-prompt keys: `model`, `aspect_ratio`, `num`.")
+
+def handle_bulk_json_generation(prompts: List[Dict[str, Any]], default_model: str, default_aspect: str, default_num: int, debug_mode: bool):
+    if not REPLICATE_API_TOKEN:
+        st.error("Missing REPLICATE_API_TOKEN. Set it as an environment variable.")
+        return
+    total = len(prompts)
+    overall_progress = st.progress(0, text=f"Starting batch • 0/{total}")
+    all_generated_urls: List[str] = []
+    errors_total: List[str] = []
+    start_time = time.time()
+    for idx, p in enumerate(prompts, 1):
+        model_key = str(p.get("model", default_model))
+        aspect_ratio = str(p.get("aspect_ratio", default_aspect))
+        num_images = int(p.get("num", default_num))
+        prompt_text = str(p.get("content", "")).strip()
+        block = st.container(border=True)
+        with block:
+            st.markdown(f"**Prompt {idx}/{total}** — Model: `{model_key}` • Aspect: `{aspect_ratio}` • Num: `{num_images}`")
+            st.code(prompt_text or "(empty)", language="markdown")
+            if not prompt_text:
+                st.error("Prompt text is empty. Skipping.")
+                overall_progress.progress(min(idx / total, 1.0), text=f"Processed {idx}/{total}")
+                continue
+            r2_urls, src_urls, gen_errors = generate_images_parallel(model_key, aspect_ratio, prompt_text, num_images)
+            rec_id = None
+            if r2_urls:
+                rec_id = save_creative_record_optimized(model_key, aspect_ratio, prompt_text, r2_urls)
+            if r2_urls:
+                st.success(f"Generated {len(r2_urls)} image(s). DB: {rec_id or 'N/A'}")
+                display_image_gallery_optimized(r2_urls)
+                bulk_download_button(r2_urls, filename=f"prompt_{idx}_images.zip")
+                all_generated_urls.extend(r2_urls)
+            elif src_urls:
+                st.warning("Images generated but R2 upload failed. Showing originals:")
+                display_image_gallery_optimized(src_urls)
+                bulk_download_button(src_urls, filename=f"prompt_{idx}_images.zip")
+                all_generated_urls.extend(src_urls)
+            else:
+                st.error("No images were generated for this prompt.")
+            if gen_errors and debug_mode:
+                with st.expander("Errors", expanded=False):
+                    for e in gen_errors:
+                        st.error(e)
+                    errors_total.extend(gen_errors)
+        overall_progress.progress(min(idx / total, 1.0), text=f"Processed {idx}/{total}")
+    elapsed = time.time() - start_time
+    st.success(f"Batch complete in {elapsed:.1f}s. Total prompts: {total}.")
+    if all_generated_urls:
+        st.subheader("Download All Generated")
+        bulk_download_button(all_generated_urls, filename="all_prompts_images.zip")
+    if errors_total and debug_mode:
+        with st.expander("All Errors Summary", expanded=False):
+            for e in errors_total:
+                st.error(e)
+
+def main():
+    st.set_page_config(page_title="Bulk Creative Generation", layout="wide")
+    if "authenticated" not in st.session_state:
+        st.session_state["authenticated"] = False
+    if not st.session_state["authenticated"]:
+        st.markdown("## Access Required")
+        token_input = st.text_input("Enter Access Token", type="password")
+        if st.button("Unlock App"):
+            ok, error_msg = check_token_cached(token_input)
+            if ok:
+                st.session_state["authenticated"] = True
+                st.rerun()
+            else:
+                st.error(error_msg)
+    else:
+        main_app()
+
+if __name__ == "__main__":
+    main()