Update src/streamlit_app.py

src/streamlit_app.py

@@ -33,20 +33,19 @@ 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"},
+    "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"},
+    "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"],"param_name": "aspect_ratio"},
+    "photon": {"id": "luma/photon","aspect_ratios": ["1:1","3:4","4:3","9:16","16:9","21:9"],"param_name": "aspect_ratio"},
+    "ideogram-v3-quality": {"id": "ideogram-ai/ideogram-v3-quality","aspect_ratios": ["1:1","16:9","9:16","2:3","3:2","4:5","5:4"],"param_name": "aspect_ratio"},
 }
 
 _thread_local = threading.local()
 
 def get_mongo_collection():
-    if not hasattr(_thread_local, 'mongo_collection'):
+    if not hasattr(_thread_local, "mongo_collection"):
         if not MONGO_URI:
             _thread_local.mongo_collection = None
             return None
@@ -54,7 +53,7 @@ def get_mongo_collection():
             client = MongoClient(MONGO_URI, serverSelectionTimeoutMS=3000)
             db = client[MONGO_DB]
             collection = db[MONGO_COLLECTION]
-            client.admin.command('ping')
+            client.admin.command("ping")
             _thread_local.mongo_collection = collection
         except Exception as e:
             logger.error(f"MongoDB connection failed: {e}")
@@ -62,8 +61,8 @@ def get_mongo_collection():
     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"]
+    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
@@ -89,23 +88,19 @@ 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
+    try:
+        filename = f"{uuid4().hex}.png"
+        file_key = f"adgenesis_image_file/json/images/{filename}"
+        s3_client.put_object(
+            Bucket=os.getenv("R2_BUCKET_NAME"),
+            Key=file_key,
+            Body=image_bytes,
+            ContentType="image/png",
+        )
+        return f"{os.getenv('NEW_BASE').rstrip('/')}/{file_key}"
+    except Exception as e:
+        logger.error(f"S3 upload failed: {e}")
+        return None
 
 def generate_one_image_optimized(model_key: str, prompt: str, aspect_ratio: str) -> List[str]:
     if not REPLICATE_API_TOKEN:
@@ -113,425 +108,184 @@ def generate_one_image_optimized(model_key: str, prompt: str, aspect_ratio: str)
     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)
+    try:
+        model_id = config["id"]
+        ar_param = config["param_name"]
+        inputs = {"prompt": prompt, ar_param: aspect_ratio}
+        output = replicate.run(model_id, input=inputs)
+        if isinstance(output, list) and output:
+            return [str(output[0])]
+        elif isinstance(output, str):
+            return [output]
+        elif hasattr(output, "url"):
+            return [getattr(output, "url")]
+    except Exception as e:
+        logger.error(f"Replicate error: {e}")
     return []
 
-def fetch_image_bytes_optimized(url: Union[str, Any]) -> Optional[bytes]:
-    url_str = getattr(url, "url", str(url))
+def fetch_image_bytes_optimized(url: str) -> Optional[bytes]:
     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 = requests.get(url, timeout=REQUEST_TIMEOUT, stream=True)
             response.raise_for_status()
-            content = b""
-            for chunk in response.iter_content(chunk_size=8192):
-                content += chunk
-            return content
+            return response.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]:
+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)
+    urls = generate_one_image_optimized(model_key, prompt, aspect_ratio)
+    if not urls:
+        result["error"] = "No URLs returned"
+        return result
+    source_url = urls[0]
+    result["source_url"] = 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"
     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 generate_images_parallel(model_key: str, aspect_ratio: str, prompt: str) -> Tuple[List[str],List[str],List[str]]:
+    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"]
 
-def save_creative_record_optimized(model_key: str, aspect_ratio: str, prompt: str, urls: List[str]) -> Optional[str]:
+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:
+        doc = {"model": model_key,"aspect_ratio": aspect_ratio,"prompt": prompt,"urls": urls,"num_images": len(urls),"lob": "json_batch","created_at": datetime.utcnow()}
+        return str(collection.insert_one(doc).inserted_id)
+    except Exception as e:
+        logger.error(f"Mongo insert failed: {e}")
         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]:
+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
+        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
+        total_count = collection.count_documents({"created_at":{"$gte":start_dt,"$lt":end_dt},"lob":"json_batch"})
+        cursor = collection.find({"created_at":{"$gte":start_dt,"$lt":end_dt},"lob":"json_batch"}).sort("created_at",-1).skip(page*LIBRARY_PAGE_SIZE).limit(LIBRARY_PAGE_SIZE)
+        return list(cursor), 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)
+        return [],0
 
-def display_image_with_download_optimized(url: Any, button_label: str = "Download image"):
-    url_str = getattr(url, "url", str(url))
+def display_image_with_download_optimized(url:str):
     try:
-        img_bytes = get_image_bytes_cached(url_str)
-        if img_bytes is None:
+        img_bytes = fetch_image_bytes_optimized(url)
+        if not img_bytes:
             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"
+        base = os.path.basename(urlparse(url).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)
+            base += ".png"
+        st.download_button("Download image", 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 display_image_gallery_optimized(urls: List[str]):
+    if not urls: return
+    cols = st.columns(min(4,len(urls)))
+    for i,url in enumerate(urls):
+        with cols[i % len(cols)]:
+            display_image_with_download_optimized(url)
 
-def main_app():
-    st.set_page_config(page_title="File-to-Image • Creative Library", layout="wide")
-    st.title("File-to-Image Generator")
-    with st.sidebar:
-        page = st.radio(" ", ["Generate from JSON", "Creative Library"], index=0)
-    if page == "Generate from JSON":
-        render_json_page()
-    elif page == "Creative Library":
-        render_library_page()
-
-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"
+def bulk_download_button(urls: List[str], filename="images_bundle.zip"):
+    if not urls: return
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer,"w",compression=zipfile.ZIP_DEFLATED) as zipf:
+        for i,url in enumerate(urls,1):
+            img = fetch_image_bytes_optimized(url)
+            if img:
+                base = os.path.basename(urlparse(url).path) or f"img_{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)
-
-    if not isinstance(data, dict) or "prompts" not in data or not isinstance(data["prompts"], list):
-        raise ValueError("Invalid JSON. Expected an object with a 'prompts' array of strings.")
-
-    prompts_out: List[Dict[str, Any]] = []
-    for i, item in enumerate(data["prompts"], 1):
-        if not isinstance(item, str) or not item.strip():
-            raise ValueError(f"'prompts[{i-1}]' must be a non-empty string.")
-        prompts_out.append({"id": f"p{i}", "content": item.strip()})
+                    base += ".png"
+                zipf.writestr(base,img)
+    zip_buffer.seek(0)
+    st.download_button("Download All Images",data=zip_buffer,file_name=filename,mime="application/zip",use_container_width=True)
 
-    return prompts_out
+def load_json_prompts(file)->List[Dict[str,str]]:
+    raw=file.getvalue().decode("utf-8")
+    data=json.loads(raw)
+    if not isinstance(data,dict) or "prompts" not in data or not isinstance(data["prompts"],list):
+        raise ValueError("JSON must be { 'prompts': [ 'string', ... ] }")
+    return [{"id":f"p{i}","content":p.strip()} for i,p in enumerate(data["prompts"],1) if isinstance(p,str) and p.strip()]
 
 def render_json_page():
     st.subheader("Generate from JSON Prompts")
-    up = st.file_uploader("Upload prompts JSON", type=["json"])
-
-    col1, col2 = st.columns([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")
-
-    debug_mode = st.checkbox("Debug Mode", value=False, key="json_debug")
-
+    up=st.file_uploader("Upload prompts JSON",type=["json"])
+    col1,col2=st.columns([1,1])
+    with col1: default_model=st.selectbox("Default Model",list(MODEL_REGISTRY.keys()),0)
+    with col2: default_aspect=st.selectbox("Default Aspect Ratio",MODEL_REGISTRY[default_model]["aspect_ratios"],0)
+    debug=st.checkbox("Debug Mode",False)
     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, debug_mode)
-        except json.JSONDecodeError as e:
-            st.error(f"Invalid JSON: {e}")
+            prompts=load_json_prompts(up)
+            st.json(prompts)
+            if st.button("Generate for All Prompts",type="primary",use_container_width=True):
+                handle_bulk_json_generation(prompts,default_model,default_aspect,debug)
         except Exception as e:
-            st.error(f"Failed to read prompts: {e}")
-    else:
-        st.caption('Expected format: { "prompts": ["prompt 1", "prompt 2", ...] }')
-
-def handle_bulk_json_generation(prompts: List[Dict[str, Any]], default_model: str, default_aspect: str, 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 = default_model
-        aspect_ratio = default_aspect
-        num_images = 1  # exactly one image per prompt
-        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: `1`")
-            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 1 image. DB: {rec_id or 'N/A'}")
-                display_image_gallery_optimized(r2_urls)
-                bulk_download_button(r2_urls, filename=f"prompt_{idx}_image.zip")
-                all_generated_urls.extend(r2_urls)
-            elif src_urls:
-                st.warning("Image generated but R2 upload failed. Showing original:")
-                display_image_gallery_optimized(src_urls)
-                bulk_download_button(src_urls, filename=f"prompt_{idx}_image.zip")
-                all_generated_urls.extend(src_urls)
-            else:
-                st.error("No image was 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)
+            st.error(str(e))
+
+def handle_bulk_json_generation(prompts:List[Dict[str,str]],default_model:str,default_aspect:str,debug:bool):
+    total=len(prompts)
+    all_urls=[]
+    for i,p in enumerate(prompts,1):
+        st.markdown(f"**Prompt {i}/{total}** — {p['content']}")
+        r2,src,errs=generate_images_parallel(default_model,default_aspect,p["content"])
+        if r2:
+            save_creative_record_optimized(default_model,default_aspect,p["content"],r2)
+            display_image_gallery_optimized(r2)
+            all_urls.extend(r2)
+        elif src:
+            display_image_gallery_optimized(src)
+            all_urls.extend(src)
+        else:
+            st.error("No image generated")
+        if errs and debug:
+            st.error(errs)
+    if all_urls:
+        st.subheader("Download All")
+        bulk_download_button(all_urls,"all_prompts_images.zip")
 
-        overall_progress.progress(min(idx / total, 1.0), text=f"Processed {idx}/{total}")
+def render_library_page():
+    st.subheader("Creative Library")
+    today=datetime.utcnow().date()
+    start_date=st.date_input("Start date",today-timedelta(days=30))
+    end_date=st.date_input("End date",today)
+    start_dt=datetime.combine(start_date,datetime.min.time())
+    end_dt=datetime.combine(end_date+timedelta(days=1),datetime.min.time())
+    records,total=query_creatives_optimized(start_dt,end_dt,0)
+    st.caption(f"{total} items")
+    for rec in records:
+        urls=rec.get("urls",[])
+        if urls: display_image_gallery_optimized(urls)
 
-    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_app():
+    st.title("File-to-Image Generator")
+    page=st.sidebar.radio("Navigation",["Generate from JSON","Creative Library"])
+    if page=="Generate from JSON": render_json_page()
+    else: render_library_page()
 
 def main():
-    st.set_page_config(page_title="File-to-Image • Creative Library", 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()
+    main_app()
 
-if __name__ == "__main__":
+if __name__=="__main__":
     main()