Update app.py

app.py

@@ -1,189 +1,371 @@
-# 😂 Shebangin’ it like it’s 1999—Python 3, let’s roll!
-
-# 🧳 Importing the whole circus—get ready for a wild ride!
+#!/usr/bin/env python3
 import os
+import glob
+import base64
 import time
 import pandas as pd
-import gradio as gr
-from gradio import DeepLinkButton  # 🔥 Deep links from 5.23.0!
-import pkg_resources  # 🕵️‍♂️ Sneaky version checker!
-import logging
-import glob
-from PIL import Image
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel
+from diffusers import StableDiffusionPipeline
+from torch.utils.data import Dataset, DataLoader
+import csv
 import fitz
+import requests
+from PIL import Image
+import numpy as np
+import logging
+import asyncio
+import aiofiles
+from io import BytesIO
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import zipfile
+import math
+import random
+import re
+import gradio as gr
 
-# 📜 Logging setup—because even AIs need a diary!
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
-log_records = []  # 🗒️ Dear diary, today I logged a thing...
+log_records = []
 
-# 🤓 LogCaptureHandler class—catching logs like a pro fisherman!
 class LogCaptureHandler(logging.Handler):
-    # 🎣 Hooking those logs right outta the stream!
     def emit(self, record):
         log_records.append(record)
 
-logger.addHandler(LogCaptureHandler())  # 🐟 Adding the hook to the logger—catch ‘em all!
+logger.addHandler(LogCaptureHandler())
+
+@dataclass
+class ModelConfig:
+    name: str
+    base_model: str
+    size: str
+    domain: Optional[str] = None
+    model_type: str = "causal_lm"
+    @property
+    def model_path(self):
+        return f"models/{self.name}"
+
+@dataclass
+class DiffusionConfig:
+    name: str
+    base_model: str
+    size: str
+    domain: Optional[str] = None
+    @property
+    def model_path(self):
+        return f"diffusion_models/{self.name}"
 
-# 😂 Time to stamp files like a boss—unique names incoming!
-def generate_filename(sequence, ext):
-    timestamp = time.strftime("%d%m%Y%H%M%S")  # ⏰ Clock says “name me now!”
+class ModelBuilder:
+    def __init__(self):
+        self.config = None
+        self.model = None
+        self.tokenizer = None
+        self.jokes = ["Why did the AI go to therapy? Too many layers to unpack! 😂", "Training complete! Time for a binary coffee break. ☕"]
+    def load_model(self, model_path: str, config: Optional[ModelConfig] = None):
+        self.model = AutoModelForCausalLM.from_pretrained(model_path)
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        if config:
+            self.config = config
+        self.model.to("cuda" if torch.cuda.is_available() else "cpu")
+        return self
+    def save_model(self, path: str):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        self.model.save_pretrained(path)
+        self.tokenizer.save_pretrained(path)
+
+class DiffusionBuilder:
+    def __init__(self):
+        self.config = None
+        self.pipeline = None
+    def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None):
+        self.pipeline = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float32).to("cpu")
+        if config:
+            self.config = config
+        return self
+    def save_model(self, path: str):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        self.pipeline.save_pretrained(path)
+    def generate(self, prompt: str):
+        return self.pipeline(prompt, num_inference_steps=20).images[0]
+
+def generate_filename(sequence, ext="png"):
+    timestamp = time.strftime("%d%m%Y%H%M%S")
     return f"{sequence}_{timestamp}.{ext}"
 
-# 🕵️‍♂️ Sherlocking the filesystem for your precious files!
-def get_gallery_files(file_types):
-    return sorted(list(set([f for ext in file_types for f in glob.glob(f"*.{ext}")])))  # 🗃️ Deduped treasure hunt!
+def pdf_url_to_filename(url):
+    safe_name = re.sub(r'[<>:"/\\|?*]', '_', url)
+    return f"{safe_name}.pdf"
 
-# 🖼️ Snap those pics like a paparazzi—upload images with flair!
-def upload_images(files, history, selected_files):
-    if not files:
-        return "No files uploaded", history, selected_files  # 😢 No pics, no party!
-    uploaded = []
-    for file in files:
-        ext = file.name.split('.')[-1].lower()  # 🕵️ Sniffing out the file type!
-        if ext in ["jpg", "png"]:
-            output_path = f"img_{int(time.time())}_{os.path.basename(file.name)}"  # 🏷️ Tagging it fresh!
-            with open(output_path, "wb") as f:
-                f.write(file.read())  # 📸 Snap saved!
-            uploaded.append(output_path)
-            history.append(f"Uploaded Image: {output_path}")  # 📜 Logging the fame!
-            selected_files[output_path] = False  # ✅ Unchecked for now!
-    return f"Uploaded {len(uploaded)} images", history, selected_files
-
-# 📜 Scribble some docs—PDFs and more, oh what a bore!
-def upload_documents(files, history, selected_files):
-    if not files:
-        return "No files uploaded", history, selected_files  # 📝 No docs, no drama!
-    uploaded = []
-    for file in files:
-        ext = file.name.split('.')[-1].lower()  # 🕵️ Peeking at the paper type!
-        if ext in ["pdf"]:  # Limiting to PDF for demo simplicity
-            output_path = f"doc_{int(time.time())}_{os.path.basename(file.name)}"  # 🏷️ Stamping the scroll!
+def get_gallery_files(file_types=["png", "pdf"]):
+    return sorted(list(set([f for ext in file_types for f in glob.glob(f"*.{ext}")])))  # Deduplicate files
+
+def get_model_files(model_type="causal_lm"):
+    path = "models/*" if model_type == "causal_lm" else "diffusion_models/*"
+    dirs = [d for d in glob.glob(path) if os.path.isdir(d)]
+    return dirs if dirs else ["None"]
+
+def download_pdf(url, output_path):
+    try:
+        response = requests.get(url, stream=True, timeout=10)
+        if response.status_code == 200:
             with open(output_path, "wb") as f:
-                f.write(file.read())  # 📜 Scroll secured!
-            uploaded.append(output_path)
-            history.append(f"Uploaded Document: {output_path}")  # 📜 Noted in history!
-            selected_files[output_path] = False  # ✅ Still on the bench!
-    return f"Uploaded {len(uploaded)} documents", history, selected_files
-
-# 📊 Data nerd alert—CSV uploads for the win!
-def upload_datasets(files, history, selected_files):
-    if not files:
-        return "No files uploaded", history, selected_files  # 📈 No data, no geek-out!
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            return True
+    except requests.RequestException as e:
+        logger.error(f"Failed to download {url}: {e}")
+    return False
+
+async def process_pdf_snapshot(pdf_path, mode="single"):
+    doc = fitz.open(pdf_path)
+    output_files = []
+    if mode == "single":
+        page = doc[0]
+        pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+        output_file = generate_filename("single", "png")
+        pix.save(output_file)
+        output_files.append(output_file)
+    elif mode == "twopage":
+        for i in range(min(2, len(doc))):
+            page = doc[i]
+            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            output_file = generate_filename(f"twopage_{i}", "png")
+            pix.save(output_file)
+            output_files.append(output_file)
+    elif mode == "allpages":
+        for i in range(len(doc)):
+            page = doc[i]
+            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            output_file = generate_filename(f"page_{i}", "png")
+            pix.save(output_file)
+            output_files.append(output_file)
+    doc.close()
+    return output_files
+
+async def process_ocr(image, output_file):
+    tokenizer = AutoTokenizer.from_pretrained("ucaslcl/GOT-OCR2_0", trust_remote_code=True)
+    model = AutoModel.from_pretrained("ucaslcl/GOT-OCR2_0", trust_remote_code=True, torch_dtype=torch.float32).to("cpu").eval()
+    temp_file = f"temp_{int(time.time())}.png"
+    image.save(temp_file)
+    result = model.chat(tokenizer, temp_file, ocr_type='ocr')
+    os.remove(temp_file)
+    async with aiofiles.open(output_file, "w") as f:
+        await f.write(result)
+    return result
+
+async def process_image_gen(prompt, output_file, builder):
+    if builder and isinstance(builder, DiffusionBuilder) and builder.pipeline:
+        pipeline = builder.pipeline
+    else:
+        pipeline = StableDiffusionPipeline.from_pretrained("OFA-Sys/small-stable-diffusion-v0", torch_dtype=torch.float32).to("cpu")
+    gen_image = pipeline(prompt, num_inference_steps=20).images[0]
+    gen_image.save(output_file)
+    return gen_image
+
+# Gradio Interface Functions
+def update_gallery(history, asset_checkboxes):
+    all_files = get_gallery_files()
+    gallery_images = []
+    for file in all_files[:5]:  # Limit to 5 for display
+        if file.endswith('.png'):
+            gallery_images.append(Image.open(file))
+        else:
+            doc = fitz.open(file)
+            pix = doc[0].get_pixmap(matrix=fitz.Matrix(0.5, 0.5))
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            gallery_images.append(img)
+            doc.close()
+    history.append(f"Gallery updated: {len(all_files)} files")
+    return gallery_images, history, asset_checkboxes
+
+def camera_snap(image, cam_id, history, asset_checkboxes, cam_files):
+    if image is not None:
+        filename = generate_filename(f"cam{cam_id}")
+        image.save(filename)
+        history.append(f"Snapshot from Cam {cam_id}: {filename}")
+        asset_checkboxes[filename] = True
+        cam_files[cam_id] = filename
+        return f"Image saved as {filename}", Image.open(filename), history, asset_checkboxes, cam_files
+    elif cam_files.get(cam_id) and os.path.exists(cam_files[cam_id]):
+        return f"Showing previous capture: {cam_files[cam_id]}", Image.open(cam_files[cam_id]), history, asset_checkboxes, cam_files
+    return "No image captured", None, history, asset_checkboxes, cam_files
+
+def download_pdfs(urls, history, asset_checkboxes):
+    urls = urls.strip().split("\n")
+    downloaded = []
+    for url in urls:
+        if url:
+            output_path = pdf_url_to_filename(url)
+            if download_pdf(url, output_path):
+                downloaded.append(output_path)
+                history.append(f"Downloaded PDF: {output_path}")
+                asset_checkboxes[output_path] = True
+    return f"Downloaded {len(downloaded)} PDFs", history, asset_checkboxes
+
+def upload_pdfs(pdf_files, history, asset_checkboxes):
     uploaded = []
-    for file in files:
-        ext = file.name.split('.')[-1].lower()  # 🕵️ Cracking the data code!
-        if ext == "csv":
-            output_path = f"data_{int(time.time())}_{os.path.basename(file.name)}"  # 🏷️ Labeling the stats!
+    for pdf_file in pdf_files:
+        if pdf_file:
+            output_path = f"uploaded_{int(time.time())}_{pdf_file.name}"
             with open(output_path, "wb") as f:
-                f.write(file.read())  # 📊 Stats stashed!
+                f.write(pdf_file.read())
             uploaded.append(output_path)
-            history.append(f"Uploaded Dataset: {output_path}")  # 📜 Data’s in the books!
-            selected_files[output_path] = False  # ✅ Not picked yet!
-    return f"Uploaded {len(uploaded)} datasets", history, selected_files
-
-# 🖼️ Gallery glow-up—show off all your files in style!
-def update_galleries(history, selected_files):
-    galleries = {
-        "images": get_gallery_files(["jpg", "png"]),  # 🖼️ Picture parade!
-        "documents": get_gallery_files(["pdf"]),  # 📜 Doc depot!
-        "datasets": get_gallery_files(["csv"]),  # 📊 Data den!
-    }
-    gallery_outputs = {
-        "images": [(Image.open(f), os.path.basename(f)) for f in galleries["images"]],  # 🖼️ Picture perfect!
-        "documents": [(Image.frombytes("RGB", fitz.open(f)[0].get_pixmap(matrix=fitz.Matrix(0.5, 0.5)).size, fitz.open(f)[0].get_pixmap(matrix=fitz.Matrix(0.5, 0.5)).samples), os.path.basename(f)) for f in galleries["documents"]],  # 📜 Doc dazzle!
-        "datasets": [(f, os.path.basename(f)) for f in galleries["datasets"]],  # 📊 Data delight!
-    }
-    history.append(f"Updated galleries: {sum(len(g) for g in galleries.values())} files")  # 📜 Gallery grand total!
-    return gallery_outputs, history, selected_files
-
-# 📂 Sidebar swagger—download links that scream “take me home!”
-def update_sidebar(history, selected_files):
-    all_files = get_gallery_files(["jpg", "png", "pdf", "csv"])
-    file_list = [gr.File(label=os.path.basename(f), value=f) for f in all_files]  # 📥 Download goodies!
-    return file_list, history
-
-# ✅ Check it or wreck it—toggle those selections like a pro!
-def toggle_selection(file_list, selected_files):
-    for file in file_list:
-        selected_files[file] = not selected_files.get(file, False)  # ✅ Flip the switch, baby!
-    return selected_files
-
-# 📊 Dataframe demo—showing off Gradio 5.21.0+ dataframe mastery!
-def get_dataframe():
-    df = pd.DataFrame({
-        "Name": ["Alice", "Bob", "Charlie"],
-        "Age": [25, 30, 35],
-        "Score": [95.5, 87.0, 92.3]
-    })
-    return df
-
-# 📜 Mermaid.js demo—flowchart fun from 5.23.0!
-def get_mermaid_chart():
-    return """```mermaid
-    graph TD
-        A[Upload Files] --> B[View Gallery]
-        B --> C[Select Files]
-        C --> D[Generate Output]
-        D --> E[Deep Link to Result]
-        ```"""
-
-# 🎨 Code editor demo—Jedi completion from 5.23.0!
-def get_code_snippet():
-return "def hello(name):\n    return f'Hello, {name}!'"
-
-# 🎪 Gradio UI—step right up to the AI circus!
-with gr.Blocks(title="Gradio 5.23.0 Mastery Demo 🚀") as demo:
-gr.Markdown(f"# Gradio 5.23.0 Mastery Demo 🚀\nRunning Gradio version: {pkg_resources.get_distribution('gradio').version}")  # 🎉 Welcome to the big top with version check!
-history = gr.State(value=[])  # 📜 The ringmaster’s logbook!
-selected_files = gr.State(value={})  # ✅ The chosen ones, ready to perform!
-
-with gr.Row():
-    with gr.Column(scale=1):
-        gr.Markdown("## 📁 Files")  # 🗃️ The file circus tent!
-        sidebar_files = gr.Files(label="Downloads", height=300)  # 📥 Grab your souvenirs here!
-
-with gr.Column(scale=3):
+            history.append(f"Uploaded PDF: {output_path}")
+            asset_checkboxes[output_path] = True
+    return f"Uploaded {len(uploaded)} PDFs", history, asset_checkboxes
+
+def snapshot_pdfs(mode, history, asset_checkboxes):
+    selected_pdfs = [path for path in get_gallery_files() if path.endswith('.pdf') and asset_checkboxes.get(path, False)]
+    if not selected_pdfs:
+        return "No PDFs selected", [], history, asset_checkboxes
+    snapshots = []
+    mode_key = {"Single Page (High-Res)": "single", "Two Pages (High-Res)": "twopage", "All Pages (High-Res)": "allpages"}[mode]
+    for pdf_path in selected_pdfs:
+        snap_files = asyncio.run(process_pdf_snapshot(pdf_path, mode_key))
+        for snap in snap_files:
+            snapshots.append(Image.open(snap))
+            asset_checkboxes[snap] = True
+            history.append(f"Snapshot {mode_key}: {snap}")
+    return f"Generated {len(snapshots)} snapshots", snapshots, history, asset_checkboxes
+
+def process_ocr_all(history, asset_checkboxes):
+    all_files = get_gallery_files()
+    if not all_files:
+        return "No assets to OCR", history, asset_checkboxes
+    full_text = "# OCR Results\n\n"
+    for file in all_files:
+        if file.endswith('.png'):
+            image = Image.open(file)
+        else:
+            doc = fitz.open(file)
+            pix = doc[0].get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            doc.close()
+        output_file = generate_filename(f"ocr_{os.path.basename(file)}", "txt")
+        result = asyncio.run(process_ocr(image, output_file))
+        full_text += f"## {os.path.basename(file)}\n\n{result}\n\n"
+        history.append(f"OCR Test: {file} -> {output_file}")
+    md_output_file = f"full_ocr_{int(time.time())}.md"
+    with open(md_output_file, "w") as f:
+        f.write(full_text)
+    return f"Full OCR saved to {md_output_file}", history, asset_checkboxes
+
+def process_ocr_single(file_path, history, asset_checkboxes):
+    if not file_path:
+        return "No file selected", None, "", history, asset_checkboxes
+    if file_path.endswith('.png'):
+        image = Image.open(file_path)
+    else:
+        doc = fitz.open(file_path)
+        pix = doc[0].get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+        image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+        doc.close()
+    output_file = generate_filename("ocr_output", "txt")
+    result = asyncio.run(process_ocr(image, output_file))
+    history.append(f"OCR Test: {file_path} -> {output_file}")
+    return f"OCR output saved to {output_file}", image, result, history, asset_checkboxes
+
+def build_model(model_type, base_model, model_name, domain, history):
+    config = (ModelConfig if model_type == "Causal LM" else DiffusionConfig)(name=model_name, base_model=base_model, size="small", domain=domain)
+    builder = ModelBuilder() if model_type == "Causal LM" else DiffusionBuilder()
+    builder.load_model(base_model, config)
+    builder.save_model(config.model_path)
+    history.append(f"Built {model_type} model: {model_name}")
+    return builder, f"Model saved to {config.model_path}", history
+
+def image_gen(prompt, file_path, builder, history, asset_checkboxes):
+    if not file_path:
+        return "No file selected", None, history, asset_checkboxes
+    if file_path.endswith('.png'):
+        image = Image.open(file_path)
+    else:
+        doc = fitz.open(file_path)
+        pix = doc[0].get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+        image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+        doc.close()
+    output_file = generate_filename("gen_output", "png")
+    gen_image = asyncio.run(process_image_gen(prompt, output_file, builder))
+    history.append(f"Image Gen Test: {prompt} -> {output_file}")
+    asset_checkboxes[output_file] = True
+    return f"Image saved to {output_file}", gen_image, history, asset_checkboxes
+
+# Gradio UI
+with gr.Blocks(title="AI Vision & SFT Titans 🚀") as demo:
+    gr.Markdown("# AI Vision & SFT Titans 🚀")
+    history = gr.State(value=[])
+    builder = gr.State(value=None)
+    asset_checkboxes = gr.State(value={})
+    cam_files = gr.State(value={})
+
     with gr.Row():
-        gr.Markdown("## 🛠️ Toolbar")  # 🔧 The circus control panel!
-        select_btn = gr.Button("✅ Select")  # ✅ Pick your performers!
-
-with gr.Tabs():
-    with gr.TabItem("📤 Upload"):  # 📤 The upload trapeze!
-        with gr.Row():
-            img_upload = gr.File(label="🖼️ Images (jpg/png)", file_count="multiple")  # 🖼️ Picture trapeze!
-            doc_upload = gr.File(label="📜 Docs (pdf)", file_count="multiple")  # 📜 Doc drop!
-        with gr.Row():
-            data_upload = gr.File(label="📊 Data (csv)", file_count="multiple")  # 📊 Data dive!
-            upload_status = gr.Textbox(label="Status")  # 📢 Ringmaster’s update!
-        gr.Button("📤 Upload Images").click(upload_images, inputs=[img_upload, history, selected_files], outputs=[upload_status, history, selected_files]).then(update_galleries, inputs=[history, selected_files], outputs=[gr.Gallery(), gr.Gallery(), gr.Gallery(), history, selected_files]).then(update_sidebar, inputs=[history, selected_files], outputs=[sidebar_files, history])
-        gr.Button("📤 Upload Docs").click(upload_documents, inputs=[doc_upload, history, selected_files], outputs=[upload_status, history, selected_files]).then(update_galleries, inputs=[history, selected_files], outputs=[gr.Gallery(), gr.Gallery(), gr.Gallery(), history, selected_files]).then(update_sidebar, inputs=[history, selected_files], outputs=[sidebar_files, history])
-        gr.Button("📤 Upload Data").click(upload_datasets, inputs=[data_upload, history, selected_files], outputs=[upload_status, history, selected_files]).then(update_galleries, inputs=[history, selected_files], outputs=[gr.Gallery(), gr.Gallery(), gr.Gallery(), history, selected_files]).then(update_sidebar, inputs=[history, selected_files], outputs=[sidebar_files, history])
-
-with gr.TabItem("🖼️ Gallery"):  # 🖼️ The big top showcase!
-    img_gallery = gr.Gallery(label="🖼️ Images (jpg/png)", columns=4, height="auto")  # 🖼️ Picture parade!
-    doc_gallery = gr.Gallery(label="📜 Docs (pdf)", columns=4, height="auto")  # 📜 Doc depot!
-    data_gallery = gr.Gallery(label="📊 Data (csv)", columns=4, height="auto")  # 📊 Data den!
-    gr.Button("🔄 Refresh").click(update_galleries, inputs=[history, selected_files], outputs=[img_gallery, doc_gallery, data_gallery, history, selected_files]).then(update_sidebar, inputs=[history, selected_files], outputs=[sidebar_files, history])
-
-with gr.TabItem("🔍 Features"):  # 🔍 The magic trick tent!
-    gr.Markdown("### 📊 Dataframe Mastery (5.21.0)")  # 📊 Flexing new dataframe tricks!
-    df_output = gr.Dataframe(value=get_dataframe, interactive=True, static_columns=["Name"], wrap=True)  # 🔥 Static columns, drag selection from 5.21.0!
-    
-    gr.Markdown("### 📜 Mermaid.js Flowchart (5.23.0)")  # 📜 Mermaid.js from 5.23.0!
-    mermaid_output = gr.Markdown(value=get_mermaid_chart)  # 🌐 Flowchart fun!
-    
-    gr.Markdown("### 🎨 Code Editor with Jedi Completion (5.23.0)")  # 🎨 Jedi power from 5.23.0!
-    code_output = gr.Code(value=get_code_snippet, language="python", interactive=True)  # ✍️ Code with autocompletion!
-    
-    gr.Markdown("### 💥 Deep Link Button (5.23.0)")  # 💥 Deep links from 5.23.0!
-    DeepLinkButton(label="Link to Latest Output", variant="secondary", deep_link="/gallery/images")  # 🔥 Secondary variant from 5.23.0!
-
-    with gr.TabItem("📜 History"):  # 📜 The logbook showcase!
-        history_output = gr.Textbox(label="History", lines=5, value="\n".join(history.value), interactive=False)  # 📜 What’s been cooking?
-
-# 🎉 Auto-update history on load—Gradio 5.20.1 event listener vibes!
-demo.load(lambda h: "\n".join(h[-5:]), inputs=[history], outputs=[history_output])
-
-# 🎉 Launch the circus—step right up, folks!
+        with gr.Column(scale=1):
+            gr.Markdown("## Captured Files 📜")
+            gallery_output = gr.Gallery(label="Asset Gallery", columns=2, height="auto")
+            gr.Button("Update Gallery").click(update_gallery, inputs=[history, asset_checkboxes], outputs=[gallery_output, history, asset_checkboxes])
+            gr.Markdown("## History 📜")
+            history_output = gr.Textbox(label="History", lines=5, interactive=False)
+            gr.Markdown("## Action Logs 📜")
+            log_output = gr.Textbox(label="Logs", value="\n".join([f"{r.asctime} - {r.levelname} - {r.message}" for r in log_records]), lines=5, interactive=False)
+
+        with gr.Column(scale=3):
+            with gr.Tabs():
+                with gr.TabItem("Camera Snap 📷"):
+                    with gr.Row():
+                        cam0_input = gr.Image(type="pil", label="Camera 0")
+                        cam1_input = gr.Image(type="pil", label="Camera 1")
+                    with gr.Row():
+                        cam0_output = gr.Textbox(label="Cam 0 Status")
+                        cam1_output = gr.Textbox(label="Cam 1 Status")
+                    with gr.Row():
+                        cam0_image = gr.Image(label="Cam 0 Preview")
+                        cam1_image = gr.Image(label="Cam 1 Preview")
+                    gr.Button("Capture Cam 0").click(camera_snap, inputs=[cam0_input, gr.State(value=0), history, asset_checkboxes, cam_files], outputs=[cam0_output, cam0_image, history, asset_checkboxes, cam_files])
+                    gr.Button("Capture Cam 1").click(camera_snap, inputs=[cam1_input, gr.State(value=1), history, asset_checkboxes, cam_files], outputs=[cam1_output, cam1_image, history, asset_checkboxes, cam_files])
+
+                with gr.TabItem("Download PDFs 📥"):
+                    url_input = gr.Textbox(label="Enter PDF URLs (one per line)", lines=5)
+                    pdf_upload = gr.File(label="Upload PDFs", file_count="multiple", type="binary")
+                    pdf_output = gr.Textbox(label="Status")
+                    snapshot_mode = gr.Dropdown(["Single Page (High-Res)", "Two Pages (High-Res)", "All Pages (High-Res)"], label="Snapshot Mode")
+                    snapshot_output = gr.Textbox(label="Snapshot Status")
+                    snapshot_images = gr.Gallery(label="Snapshots", columns=2, height="auto")
+                    gr.Button("Download URLs").click(download_pdfs, inputs=[url_input, history, asset_checkboxes], outputs=[pdf_output, history, asset_checkboxes])
+                    gr.Button("Upload PDFs").click(upload_pdfs, inputs=[pdf_upload, history, asset_checkboxes], outputs=[pdf_output, history, asset_checkboxes])
+                    gr.Button("Snapshot Selected").click(snapshot_pdfs, inputs=[snapshot_mode, history, asset_checkboxes], outputs=[snapshot_output, snapshot_images, history, asset_checkboxes])
+
+                with gr.TabItem("Test OCR 🔍"):
+                    all_files = gr.Dropdown(choices=get_gallery_files(), label="Select File")
+                    ocr_output = gr.Textbox(label="Status")
+                    ocr_image = gr.Image(label="Input Image")
+                    ocr_result = gr.Textbox(label="OCR Result", lines=5)
+                    gr.Button("OCR All Assets").click(process_ocr_all, inputs=[history, asset_checkboxes], outputs=[ocr_output, history, asset_checkboxes])
+                    gr.Button("OCR Selected").click(process_ocr_single, inputs=[all_files, history, asset_checkboxes], outputs=[ocr_output, ocr_image, ocr_result, history, asset_checkboxes])
+
+                with gr.TabItem("Build Titan 🌱"):
+                    model_type = gr.Dropdown(["Causal LM", "Diffusion"], label="Model Type")
+                    base_model = gr.Dropdown(
+                        choices=["HuggingFaceTB/SmolLM-135M", "Qwen/Qwen1.5-0.5B-Chat"],
+                        label="Base Model",
+                        value="HuggingFaceTB/SmolLM-135M"
+                    )
+                    model_name = gr.Textbox(label="Model Name", value=f"tiny-titan-{int(time.time())}")
+                    domain = gr.Textbox(label="Target Domain", value="general")
+                    build_output = gr.Textbox(label="Status")
+                    gr.Button("Build").click(build_model, inputs=[model_type, base_model, model_name, domain, history], outputs=[builder, build_output, history])
+
+                with gr.TabItem("Test Image Gen 🎨"):
+                    gen_file = gr.Dropdown(choices=get_gallery_files(), label="Select Reference File")
+                    gen_prompt = gr.Textbox(label="Prompt", value="Generate a neon superhero version of this image")
+                    gen_output = gr.Textbox(label="Status")
+                    gen_image = gr.Image(label="Generated Image")
+                    gr.Button("Generate").click(image_gen, inputs=[gen_prompt, gen_file, builder, history, asset_checkboxes], outputs=[gen_output, gen_image, history, asset_checkboxes])
+
+    # Update history output on every interaction
+    demo.load(lambda h: "\n".join(h[-5:]), inputs=[history], outputs=[history_output])
+
 demo.launch()