Upload 3 files

README.md

@@ -1,14 +1,12 @@
 ---
-title: ImageResizer
-emoji: 🐢
-colorFrom: yellow
+title: Image Editor
+emoji: 🐠
+colorFrom: green
 colorTo: indigo
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
+sdk_version: 5.37.0
 app_file: app.py
 pinned: false
-short_description: Resize images, convert them to JPG, and download them easily
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,797 @@
+import gradio as gr
+from PIL import Image
+import os
+import zipfile
+import pandas as pd
+import requests
+import tempfile
+import shutil
+from io import BytesIO
+import threading
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+import time
+import random
+import cloudscraper
+from urllib.parse import urlparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+stop_event = threading.Event()
+cpu_cores = os.cpu_count() or 4
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+    "Mozilla/5.0 (Linux; Android 10)",
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X)"
+]
+
+PROXY_LIST = [
+    "http://user:pass@proxy1:port",
+    "http://user:pass@proxy2:port",
+]
+
+FAILED_LOG_PATH = "failed_downloads.txt"
+BLOCKED_SITES = ["bigw.com.au"]
+
+def random_headers(referer):
+    """Return a rotating User‑Agent + referer header dict."""
+    return {
+        "User-Agent": random.choice(USER_AGENTS),
+        "Referer": referer
+    }
+
+def try_download(url, headers, proxies):
+    """
+    Attempt a simple GET through a proxy dict {"http":..., "https":...}.
+    Returns the response if status_code==200 and content is image, else None.
+    """
+    try:
+        resp = session.get(url, headers=headers, proxies=proxies, stream=True, timeout=15)
+        if resp.status_code == 200 and "image" in resp.headers.get("Content-Type", ""):
+            return resp
+    except Exception as e:
+        print(f"⚠️ Proxy download error ({proxies}): {e}")
+    return None
+
+session = requests.Session()
+# --- Utility Functions ---
+def process_url_images(data, fmt, w, h):
+    return process_and_zip(data, fmt, w, h)
+
+def process_uploaded_images(files, fmt, w, h):
+    tmp = tempfile.mkdtemp()
+    data = []
+    for f in files:
+        src = str(f)
+        dst = os.path.join(tmp, os.path.basename(src))
+        shutil.copyfile(src, dst)
+        data.append({"url": dst, "name": os.path.splitext(os.path.basename(dst))[0]})
+    return process_and_zip(data, fmt, w, h)
+
+def process_single_url_image(url, fmt, w, h):
+    if not url.strip():
+        return [], None, "No URL provided", None
+    return process_and_zip([{"url": url.strip(), "name": "single"}], fmt, w, h)
+
+handle_process = lambda mode, sd, ups, pu, fmt, w, h: (
+    process_url_images(sd, fmt, w, h) if mode.startswith("📄") and sd else
+    process_uploaded_images(ups, fmt, w, h) if mode.startswith("📤") and ups else
+    process_single_url_image(pu, fmt, w, h) if pu.strip() else
+    ([], None, "⚠️ No valid input provided", None)
+)
+from PIL import ImageFile
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+def fetch_with_retries(url, headers, timeout=15, retries=2, backoff=1):
+    """
+    Try up to retries+1 times to GET url with timeout seconds.
+    Returns a requests.Response or None.
+    """
+    for attempt in range(retries + 1):
+        try:
+            resp = session.get(url, headers=headers, stream=True, timeout=timeout)
+            if resp.status_code == 200 and "image" in resp.headers.get("Content-Type", ""):
+                return resp
+        except Exception as e:
+            print(f"⚠️ Attempt {attempt+1} failed for {url}: {e}")
+        time.sleep(backoff * (attempt + 1))
+    return None
+
+def download_image(url, save_path):
+    # Skip cached
+    if os.path.exists(save_path) and os.path.getsize(save_path) > 1000:
+        return save_path
+
+    # Skip blocked
+    if any(b in url for b in BLOCKED_SITES):
+        log_failure(url, "Skipped known slow site")
+        return None
+
+    referer = f"{urlparse(url).scheme}://{urlparse(url).netloc}/"
+    headers = random_headers(referer)
+
+    # 1) Direct with retries
+    print(f"🚀 Fetching with retries: {url}")
+    resp = fetch_with_retries(url, headers, timeout=15, retries=2)
+    if resp:
+        with open(save_path, 'wb') as f:
+            for chunk in resp.iter_content(8192):
+                f.write(chunk)
+        print("✅ Direct fetch succeeded")
+        return save_path
+    else:
+        print("❌ Direct fetch failed after retries")
+
+    # 2) cloudscraper fallback
+    print("🟠 cloudscraper fallback...")
+    try:
+        scraper = cloudscraper.create_scraper(sess=session)
+        resp = scraper.get(url, headers=headers, stream=True, timeout=15)
+        if resp.status_code == 200 and "image" in resp.headers.get("Content-Type", ""):
+            with open(save_path, 'wb') as f:
+                for chunk in resp.iter_content(8192):
+                    f.write(chunk)
+            print("✅ cloudscraper worked")
+            return save_path
+    except Exception as e:
+        print(f"❌ cloudscraper failed: {e}")
+
+    # 3) Selenium fallback
+    try:
+        print("🧪 Headless browser fallback...")
+        chrome_opts = Options()
+        chrome_opts.add_argument("--headless")
+        chrome_opts.add_argument("--disable-gpu")
+        chrome_opts.add_argument("--no-sandbox")
+        chrome_opts.add_argument("--disable-dev-shm-usage")
+        chrome_opts.add_argument(f"user-agent={headers['User-Agent']}")
+
+        driver = webdriver.Chrome(
+            service=Service(ChromeDriverManager().install()),
+            options=chrome_opts
+        )
+        driver.get(url)
+        time.sleep(4)
+        final_url = driver.current_url
+        cookies = {c['name']: c['value'] for c in driver.get_cookies()}
+        driver.quit()
+
+        with session:
+            for k, v in cookies.items():
+                session.cookies.set(k, v)
+            r = session.get(final_url, headers=headers, stream=True, timeout=15)
+            if r.status_code == 200 and "image" in r.headers.get("Content-Type", ""):
+                with open(save_path, 'wb') as f:
+                    for chunk in r.iter_content(8192):
+                        f.write(chunk)
+                print("✅ Selenium + cookies worked")
+                return save_path
+    except Exception as e:
+        print(f"❌ Selenium failed: {e}")
+
+    # 4) Give up
+    log_failure(url, "All methods failed")
+    return None
+
+
+lamp_html = """
+<style>
+  * {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+  }
+  body {
+    background-color: #D8D2C2;
+    transition: background 0.4s ease;
+  }
+  body.night {
+    background: radial-gradient(#555, #111);
+  }
+  .lamp-fixed {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: 100px;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    z-index: 9999;
+    pointer-events: none;
+  }
+  .mount {
+    width: 30px;
+    height: 5px;
+    background: #111;
+    border-radius: 6px;
+    pointer-events: none;
+  }
+  .wire {
+    width: 4px;
+    height: 120px;
+    background: #000;
+    margin: 0;
+    pointer-events: none;
+  }
+  .blub {
+    position: relative;
+    width: 47px;
+    height: 47px;
+    background: #444;
+    border-radius: 50%;
+    cursor: pointer;
+    margin-top: -1px;
+    transition: all 0.3s ease;
+    z-index: 2;
+    pointer-events: auto;
+  }
+  .blub.night {
+    background: #ffec99;
+    box-shadow: 0 0 28px #ffec99, 0 0 56px #ffec99,
+                0 0 84px #ffec99, 0 0 168px #ffec99;
+  }
+  .blub.night::before {
+    background: #ffec99;
+  }
+  .blub.night::after {
+    content: "";
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-60%, -50%);
+    width: 78px;
+    height: 78px;
+    background: #ffec99;
+    border-radius: 100%;
+    filter: blur(26px);
+    z-index: -1;
+  }
+  .blub::before {
+    content: "";
+    position: absolute;
+    top: -30px;
+    left: 11px;
+    width: 25px;
+    height: 47px;
+    background: #444;
+    border-top: 19px solid #000;
+    border-radius: 8px;
+    transition: background 0.3s ease;
+  }
+  .blub span:nth-child(1) {
+    position: absolute;
+    top: -10px;
+    left: -2px;
+    width: 20px;
+    height: 18px;
+    background: transparent;
+    transform: rotate(343deg);
+    border-bottom-right-radius: 40px;
+    box-shadow: 12px 12px 0 5px #444;
+    transition: box-shadow 0.3s ease;
+  }
+  .blub.night span:nth-child(1) {
+    box-shadow: 12px 12px 0 5px #ffec99;
+  }
+  .blub span:nth-child(2) {
+    position: absolute;
+    top: -10px;
+    right: -2px;
+    width: 20px;
+    height: 18px;
+    background: transparent;
+    transform: rotate(18deg);
+    border-bottom-left-radius: 50px;
+    box-shadow: -12px 12px 0 5px #444;
+    transition: box-shadow 0.3s ease;
+  }
+  .blub.night span:nth-child(2) {
+    box-shadow: -12px 12px 0 5px #ffec99;
+  }
+</style>
+<div class="lamp-fixed">
+  <div class="mount"></div>
+  <div class="wire"></div>
+  <div class="blub" onclick="this.classList.toggle('night'); document.body.classList.toggle('night')">
+    <span></span>
+    <span></span>
+  </div>
+</div>
+"""
+def resize_with_padding(img, target_w, target_h, fill=(255,255,255)):
+    img.thumbnail((target_w, target_h), Image.LANCZOS)
+    bg = Image.new("RGB", (target_w, target_h), fill)
+    x = (target_w - img.width) // 2
+    y = (target_h - img.height) // 2
+    bg.paste(img, (x, y))
+    return bg
+
+def threaded_download_and_open(item, temp_dir):
+    from PIL import ImageSequence
+
+    name, src = item['name'], item['url']
+    try:
+        if os.path.exists(src):
+            path = src
+        else:
+            temp_path = os.path.join(temp_dir, f"{name}.gif")
+            path = download_image(src, temp_path)
+            if not path:
+                return (name, None, 'Download failed or invalid image')
+
+        img = Image.open(path)
+
+        # Rewind to first frame in case it's not
+        if getattr(img, "is_animated", False):
+            img.seek(0)
+            frames = []
+            for frame in ImageSequence.Iterator(img):
+                frame_copy = frame.convert("RGBA").copy()
+                frames.append(frame_copy)
+            return (name, frames, None)
+        else:
+            return (name, [img.convert("RGBA")], None)
+
+    except Exception as e:
+        return (name, None, str(e))
+
+def resize_and_save_worker(args):
+    name, img, fmt, w, h, out_dir = args
+    try:
+        # 1) Composite RGBA over white
+        img = img.convert('RGBA')
+        bg  = Image.new('RGBA', img.size, (255,255,255,255))
+        img = Image.alpha_composite(bg, img)
+
+        # 2) Determine save format & extension
+        fmt_upper = fmt.upper()
+        save_fmt  = "JPEG" if fmt_upper in ("JPEG", "JPG") else fmt_upper
+        ext       = "jpg"  if fmt_upper in ("JPEG", "JPG") else fmt.lower()
+
+        # 3) Convert to RGB if needed
+        if save_fmt == "JPEG":
+            img = img.convert("RGB")
+
+        # 4) Resize with padding
+        img = resize_with_padding(img, w, h)
+
+        # 5) Build filename & save
+        out_name = f"{name}.{ext}"
+        out_path = os.path.join(out_dir, out_name)
+        img.save(out_path, format=save_fmt, quality=90)
+
+        return out_path, None
+
+    except Exception as e:
+        return None, f"{name}: {e}"
+
+from multiprocessing import cpu_count
+import zipfile
+
+def process_and_zip(items, fmt, w, h):
+    tmp  = tempfile.mkdtemp()
+    proc = os.path.join(tmp, 'out')
+    os.makedirs(proc, exist_ok=True)
+
+    files, fails = [], []
+    # 1) Download & open in parallel
+    workers = cpu_count() * 2
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        results = list(ex.map(lambda it: threaded_download_and_open(it, tmp), items))
+
+    # 2) Process each downloaded image/list of frames
+    for name, imgs, err in results:
+        if err or not imgs:
+            fails.append(f"{name}: {err}")
+            continue
+
+        for i, img in enumerate(imgs):
+            try:
+                # Composite RGBA over white
+                img = img.convert("RGBA")
+                bg  = Image.new("RGBA", img.size, (255,255,255,255))
+                img = Image.alpha_composite(bg, img)
+
+                # Determine save format & extension
+                fmt_upper = fmt.upper()
+                save_fmt  = "JPEG" if fmt_upper in ("JPEG","JPG") else fmt_upper
+                ext       = "jpg"  if fmt_upper in ("JPEG","JPG") else fmt.lower()
+
+                # Convert to RGB if JPEG
+                if save_fmt == "JPEG":
+                    img = img.convert("RGB")
+
+                # Resize with padding
+                img = resize_with_padding(img, w, h)
+
+                # Build filename
+                fname = (
+                    f"{name}_frame{i+1}.{ext}"
+                    if len(imgs) > 1
+                    else f"{name}.{ext}"
+                )
+                out_path = os.path.join(proc, fname)
+
+                # Save & record
+                img.save(out_path, format=save_fmt, quality=90)
+                files.append(out_path)
+
+            except Exception as e:
+                print(f"⚠️ Save failed for {name}: {e}")
+                fails.append(f"{name}_frame{i+1}: {e}")
+
+    # 3) If nothing succeeded, clean up and report
+    if not files:
+        stop_event.clear()
+        shutil.rmtree(tmp)
+        return None, None, "No images processed.", None
+
+    # 4) Create ZIP in “store” mode (no compression)
+    date_str = datetime.now().strftime("%Y-%m-%d")
+    zip_name = f"{date_str}.zip"
+    zip_path = os.path.join(tmp, zip_name)
+    with zipfile.ZipFile(zip_path, 'w', compression=zipfile.ZIP_STORED) as zf:
+        for f in files:
+            zf.write(f, os.path.basename(f))
+
+    # 5) Build status message
+    msg_lines = [f"✅ Processed {len(files)} image(s)."]
+    if fails:
+        msg_lines.append(f"❌ Failed: {len(fails)} image(s)")
+        msg_lines += [f"   - {fail}" for fail in fails]
+
+    stop_event.clear()
+    return files, zip_path, "\n".join(msg_lines), tmp
+
+def read_uploaded_workbook(file):
+    if not file:
+        return [], "❌ No file uploaded"
+    try:
+        # read all sheets except "Cleared Data"
+        xls = pd.ExcelFile(file.name)
+        sheets = [s for s in xls.sheet_names if s.lower() != "cleared data"]
+        df_list = [pd.read_excel(file.name, sheet_name=s, engine="openpyxl") for s in sheets]
+        df = pd.concat(df_list, ignore_index=True)
+        df.columns = [c.strip() for c in df.columns]
+
+        item_col = next((c for c in df.columns if c.lower() == 'itemcode'), None)
+        if not item_col:
+            return [], "❌ Missing 'ItemCode' column"
+
+        url_cols = [c for c in df.columns if any(k in c.lower() for k in ["url", "image", "link"])]
+        data = []
+        for _, row in df.iterrows():
+            raw = row[item_col]
+            if pd.isna(raw):
+                continue
+            key = str(raw).strip().split('.')[0] if str(raw).strip().replace('.', '', 1).isdigit() else str(raw).strip()
+            idx = 0
+            for col in url_cols:
+                if pd.notna(row[col]):
+                    name = f"{key}" if idx == 0 else f"{key}_{idx}"
+                    data.append({"url": str(row[col]).strip(), "name": name})
+                    idx += 1
+        return data, f"✅ Fetched {len(data)} image link(s)"
+    except Exception as e:
+        return [], f"❌ Error: {e}"
+
+def clear_all(tmp_dir):
+    # wipe out the temp folder if it exists
+    if tmp_dir and os.path.exists(tmp_dir):
+        shutil.rmtree(tmp_dir)
+    return (
+        None,                                 # clear the single‐file upload
+        [],                                   # reset the image_data_state
+        [],                                   # clear the multi‐file upload
+        gr.update(visible=False, value=None), # hide & clear the hidden ZIP file
+        [],                                   # clear the “individual downloads” list
+        "Cleared.",                           # status message
+        None,                                 # reset temp_dir_state
+        ""                                    # clear the URL textbox
+    )
+
+
+# === CSS ===
+css = """
+    body {
+  margin: 0;
+  background: #4B352A;
+  font-family: 'Segoe UI', sans-serif;
+  color: #222;
+  display: flex;
+  justify-content: center;
+  padding: 2rem;
+  transition: background 0.3s, color 0.3s;
+}
+.gradio-container {
+  max-width: 1200px;   /* You can reduce this (e.g., 600px) */
+  width: 100%;
+  margin: 0 auto;
+    h1 {
+        font-size: 24px !important;
+        font-weight: 700 !important;
+        margin-bottom: 1rem !important;
+        color: #FFFFFF !important;
+        text-align: center !important;
+    }
+    .panel {
+        background: white;
+        padding: 1rem;
+        border-radius: 6px;
+        border: 1px solid #ddd;
+        box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+    }
+    #clear-btn, #stop-btn {
+        margin-top: 1rem;
+        font-size: 0.85rem !important;
+        font-weight: 600 !important;
+        padding: 0.5rem 1rem !important;
+        border-radius: 8px !important;
+        border: none !important;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
+        transition: background-color 0.2s ease !important;
+        width: 100% !important;
+    }
+    .btn-row {
+        display: flex;
+        justify-content: space-between;
+        gap: 0.5rem;
+    }
+    #clear-btn {
+        background-color: #e74c3c !important;
+        color: white !important;
+        width: 50% !important;
+    }
+    #clear-btn:hover {
+        background-color: #c0392b !important;
+        cursor: pointer !important;
+    }
+    #stop-btn {
+        background-color: #CA7842 !important;
+        color: white !important;
+        width: 50% !important;
+    }
+    #stop-btn:hover {
+        background-color: #FFA55D !important;
+        cursor: pointer !important;
+    }
+    .gradio-container .gr-row > div {
+        padding: 4px !important;
+    }
+    #process-btn-url {
+        background-color: #A4B465 !important;
+        color: #333 !important;
+    }
+    #fetch-btn {
+        background-color: #cfbed7 !important;
+        color: #333 !important;
+    }
+    #status-box {
+        background-color: #ffffff;
+        border: 2px solid #cfbed7;
+        border-radius: 6px;
+        padding: 1rem;
+        font-size: 0.95rem;
+        color: #333;
+/* Styling the toggle radio buttons */
+.gradio-container label.svelte-1ipelgc {
+    font-weight: 600 !important;
+    border: 2px solid #A4B465 !important;
+    padding: 0.4rem 1rem !important;
+    border-radius: 12px !important;
+    margin: 0.25rem !important;
+    background-color: #f5fbe8 !important;
+    transition: all 0.3s ease-in-out;
+    cursor: pointer;
+}
+/* Selected option */
+input[type="radio"]:checked + label.svelte-1ipelgc {
+    background-color: #A4B465 !important;
+    color: white !important;
+    border-color: #889E46 !important;
+}
+/* Unselected hover */
+.gradio-container input[type="radio"] + label.svelte-1ipelgc:hover {
+    background-color: #e0f1c4 !important;
+}
+    }
+"""
+gr.HTML("""
+<div class="wrapper">
+  <div class="toggle-icon-group">
+    <input type="radio" id="spreadsheet" name="mode" checked>
+    <label for="spreadsheet"><span>📄</span> Spreadsheet</label>
+    <input type="radio" id="upload" name="mode">
+    <label for="upload"><span>📁</span> Upload</label>
+  </div>
+</div>
+""")
+
+def process_all(mode, workbook_file, ups, pu, fmt, w, h):
+    # 1️⃣ If workbook mode, read links from Excel
+    if mode.startswith("📄"):
+        data, msg = read_uploaded_workbook(workbook_file)
+        print("💡 DEBUG – links extracted:", data)          # <<< DEBUG
+        if not data:
+            # no links or error reading
+            return [], None, msg, None
+
+        # we have a list of {"url":…, "name":…}
+        files, zip_path, proc_msg, tmp = process_and_zip(data, fmt, w, h)
+        return files, zip_path, f"{msg}\n{proc_msg}", tmp
+
+    # 2️⃣ If “Upload Images” mode
+    if mode.startswith("📤") and ups:
+        return process_uploaded_images(ups, fmt, w, h)
+
+    # 3️⃣ If single‑URL mode
+    if pu and pu.strip():
+        return process_single_url_image(pu, fmt, w, h)
+
+    # 4️⃣ Nothing valid
+    return [], None, "⚠️ No valid input provided", None
+    
+    if os.path.exists(FAILED_LOG_PATH):
+        with open(FAILED_LOG_PATH) as f:
+            failed = [line.split("\t")[1] for line in f if line.strip()]
+    if failed:
+        print(f"🔄 Retrying {len(failed)} failed URLs…")
+        # reuse your ThreadPoolExecutor to download them to a “retries” folder
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        os.makedirs("retries", exist_ok=True)
+        def retry_one(url):
+            fname = os.path.join("retries", url.split("/")[-1].split("?")[0])
+            r = fetch_with_retries(url, random_headers(f"{urlparse(url).scheme}://{urlparse(url).netloc}/"), timeout=15, retries=2)
+            if r:
+                with open(fname, 'wb') as f:
+                    for c in r.iter_content(8192): f.write(c)
+                return True
+            return False
+
+        with ThreadPoolExecutor(max_workers=8) as ex:
+            results = list(ex.map(retry_one, failed))
+        print(f"✅ Retried successes: {sum(results)} / {len(failed)}")
+
+
+with gr.Blocks(css=css) as demo:
+    # ─── States ───
+    image_data_state = gr.State([])
+    temp_dir_state  = gr.State(None)
+
+    # ─── Header ───
+    gr.HTML(lamp_html)
+    with gr.Row():
+        gr.Markdown("<h1>🖼️ Image Processor</h1>")
+
+    # ─── Main layout ───
+    with gr.Row():
+        # ── LEFT PANEL ──
+        with gr.Column(scale=3, min_width=500):
+            with gr.Group(elem_classes="panel"):
+                mode_toggle = gr.Radio(
+                    ["📄 Upload Workbook", "📤 Upload Images"],
+                    value="📄 Upload Workbook",
+                    label="Select Input Method"
+                )
+                workbook_upload = gr.File(
+                    label="📂 Upload .xlsx/.xlsm Workbook",
+                    file_types=['.xlsx', '.xlsm'],
+                    visible=True
+                )
+                upload_box = gr.File(
+                    label="📁 Upload Images",
+                    file_count="multiple",
+                    visible=False
+                )
+                image_url_input = gr.Textbox(
+                    label="🌐 Paste Image URL",
+                    visible=False
+                )
+                process_btn = gr.Button("⚙️ Process", elem_id="process-btn-url")
+
+            with gr.Group(elem_classes="panel"):
+                with gr.Row():
+                    format_choice = gr.Dropdown(
+                        ["JPG","PNG","WEBP","TIFF","GIF","JFIF","AVIF"],
+                        label="🖼️ Format",
+                        value="JPG"
+                    )
+                    width  = gr.Number(label="Width (px)",  value=1000, precision=0)
+                    height = gr.Number(label="Height (px)", value=1000, precision=0)
+
+        # ── RIGHT PANEL ──
+        with gr.Column(scale=2, min_width=400):
+            with gr.Group(elem_classes="panel"):
+                status = gr.Textbox(
+                    label="📣 Status",
+                    lines=6,
+                    interactive=False,
+                    elem_id="status-box"
+                )
+                zip_download_btn = gr.Button("📦 Download ZIP")
+                zip_file_hidden   = gr.File(visible=False)
+                with gr.Accordion("🧷 Individual Files", open=False):
+                    single_downloads = gr.File(label="Files", file_count="multiple")
+
+            with gr.Row(elem_classes="btn-row"):
+                stop_btn  = gr.Button("Stop",  elem_id="stop-btn")
+                clear_btn = gr.Button("Clear", elem_id="clear-btn")
+
+    # ─── Footer ───
+    gr.HTML(
+    "<div style='width:100%; text-align:center; margin-top:1rem; color:white;'>"
+    "Created with 💜 by Vishakha"
+    "</div>"
+)
+
+    # ─── EVENT HOOKS ───
+    mode_toggle.change(
+        fn=lambda choice: (
+            gr.update(visible=choice.startswith("📄")),
+            gr.update(visible=not choice.startswith("📄")),
+            gr.update(visible=not choice.startswith("📄"))
+        ),
+        inputs=[mode_toggle],
+        outputs=[workbook_upload, upload_box, image_url_input]
+    )
+
+    workbook_upload.change(
+        fn=read_uploaded_workbook,
+        inputs=[workbook_upload],
+        outputs=[image_data_state, status]
+    )
+
+    upload_box.change(
+        fn=lambda files: f"{len(files)} files ready." if files else "No files selected",
+        inputs=[upload_box],
+        outputs=[status]
+    )
+
+    process_btn.click(
+        fn=process_all,
+        inputs=[
+            mode_toggle,
+            workbook_upload,
+            upload_box,
+            image_url_input,
+            format_choice,
+            width,
+            height
+        ],
+        outputs=[
+            single_downloads,
+            zip_file_hidden,
+            status,
+            temp_dir_state
+        ]
+    )
+
+    zip_download_btn.click(
+        None,
+        inputs=[zip_file_hidden],
+        js="(file) => file && window.open(file.url, '_blank')"
+    )
+
+    clear_btn.click(
+        fn=clear_all,
+        inputs=[temp_dir_state],
+        outputs=[
+            workbook_upload, image_data_state, upload_box,
+            zip_file_hidden, single_downloads, status,
+            temp_dir_state, image_url_input
+        ]
+    )
+
+    stop_btn.click(
+        fn=lambda: "🛑 Stop signal sent",
+        outputs=[status]
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(debug=True)

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text