Upload 8 files

README.md

@@ -0,0 +1,51 @@
+---
+title: VidGen Frontend
+emoji: 🎬
+colorFrom: purple
+colorTo: pink
+sdk: streamlit
+sdk_version: "1.29.0"
+app_file: app.py
+pinned: false
+---
+
+# VidGen Frontend
+
+Public frontend interface for Google Veo video generation.
+
+## 🚀 Features
+
+- Text-to-video and image-to-video generation
+- Real-time job monitoring with progress tracking
+- Batch processing support
+- JSON configuration mode
+- Responsive design
+
+## 🔧 Configuration
+
+The frontend connects to a private backend API for video generation processing.
+
+
+## 🎯 Usage
+
+1. Enter your Google API key
+2. Configure generation settings (model, resolution, aspect ratio)
+3. Enter prompts or upload images for image-to-video mode
+4. Click "Generate Video" to start processing
+5. Monitor progress and download results when completed
+
+## 📋 Supported Models
+
+- **veo-3.0-fast-generate-001** ✅ (1080p support, 16:9 only)
+- **veo-3.0-generate-001** ✅ (1080p support, 16:9 only)
+- **veo-2.0-generate-001** ⚠️ (720p max resolution)
+
+## 🔒 Security
+
+- API keys are processed securely through the private backend
+- No sensitive data stored locally
+- All video processing happens on secure backend servers
+
+---
+
+*Powered by Google Veo • Backend API: Private Space*

app.py

@@ -0,0 +1,329 @@
+# fe-vidgen/app.py
+import os, sys, time, json, pathlib, re, base64, mimetypes, random
+import streamlit as st
+from typing import List, Tuple
+
+# ---------- ENV ----------
+os.environ.setdefault("HOME", "/home/user")
+os.environ.setdefault("STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION", "false")
+os.environ.setdefault("STREAMLIT_SERVER_ENABLE_CORS", "false")
+os.environ.setdefault("STREAMLIT_BROWSER_GATHER_USAGE_STATS", "false")
+os.environ.setdefault("STREAMLIT_SERVER_MAX_UPLOAD_SIZE", "1024")
+
+st.set_page_config(page_title="VidGen — Google Veo", page_icon="🎬", layout="wide")
+
+# ---------- INIT STATE ----------
+def _init_state():
+    defaults = {
+        "backend": None, "api_key_val": "",
+        "jobs": [], "job_idx": 0, "running": False,
+        "total": 0, "overall_progress_value": 0.0,
+        "images_info": [], "image_order_mode": "Filename (Numeric 1–9)",
+        "prompt_main": "",
+        "last_model_ui": None, "last_mode_backend": None,
+        "last_aspect": None, "last_resolution": None,
+        "last_negative": None, "last_person": None,
+        "last_audio_on": True, "worker_delay": 1.0,
+    }
+    for k,v in defaults.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
+_init_state()
+
+# ---------- BACKEND ----------
+@st.cache_resource(ttl=3600, show_spinner=False)
+def load_backend():
+    from huggingface_hub import snapshot_download
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        st.error("❌ HF_TOKEN not set in Space Secrets")
+        st.stop()
+    LOCAL_DIR = snapshot_download(
+        repo_id="saltudio/be-vidgen",
+        repo_type="space",
+        token=hf_token,
+        cache_dir="/tmp/hf_vidgen_cache",
+        allow_patterns=["src/**"],
+        ignore_patterns=["*.md","*.txt","app.py","requirements.txt"],
+    )
+    SRC_DIR = os.path.join(LOCAL_DIR,"src")
+    if SRC_DIR not in sys.path: sys.path.insert(0,SRC_DIR)
+    from veo_backend import generate_one_with_ui, get_model_capabilities, MODELS_UI, ASPECTS
+    return {"generate_one_with_ui":generate_one_with_ui,
+            "get_model_capabilities":get_model_capabilities,
+            "MODELS_UI":MODELS_UI, "ASPECTS":ASPECTS}
+
+backend = st.session_state.backend or load_backend()
+st.session_state.backend = backend
+generate_one_with_ui = backend["generate_one_with_ui"]
+get_model_capabilities = backend["get_model_capabilities"]
+MODELS_UI = backend["MODELS_UI"]
+ASPECTS = backend["ASPECTS"]
+
+# ---------- STYLE ----------
+st.markdown("""
+<style>
+#MainMenu, header, footer {visibility:hidden;}
+.job-card{border:1px solid #2b2f36;background:#12151b;border-radius:12px;padding:12px;margin-bottom:14px;}
+.job-head{font-weight:600;color:#cfd8e3;margin-bottom:6px;}
+.badges{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:8px;}
+.badge{padding:.2rem .5rem;border-radius:999px;background:#1f2430;color:#9fb0c3;border:1px solid #2b2f36;font-size:.75rem;}
+.floating-donations{position:fixed;right:20px;top:50%;transform:translateY(-50%);z-index:1000;display:flex;flex-direction:column;gap:15px;}
+.floating-btn{width:60px;height:60px;border-radius:50%;display:flex;align-items:center;justify-content:center;text-decoration:none;font-weight:bold;font-size:14px;box-shadow:0 4px 20px rgba(0,0,0,0.3);transition:all .3s ease;}
+.floating-btn:hover{transform:scale(1.1);box-shadow:0 6px 30px rgba(0,0,0,0.4);}
+.kofi-floating{background:linear-gradient(135deg,#ff5f5f,#ff3838);color:#fff;}
+.saweria-floating{background:linear-gradient(135deg,#ffbd44,#f39c12);color:#2c3e50;}
+@media(max-width:768px){.floating-donations{display:none;}}
+</style>
+""",unsafe_allow_html=True)
+st.markdown("""
+<div class="floating-donations">
+  <a href="https://ko-fi.com/saltudio" target="_blank" class="floating-btn kofi-floating">☕</a>
+  <a href="https://saweria.co/saltudio" target="_blank" class="floating-btn saweria-floating">💝</a>
+</div>
+""",unsafe_allow_html=True)
+
+# ---------- CONSTANT NEGATIVE PROMPT ----------
+NEG_PROMPT_DEFAULT = (
+    "no text overlays, no subtitles, no watermarks, no copyright logos, "
+    "no UI elements, no cartoon or comic effects, no unrealistic body proportions, "
+    "no extra limbs, no deformed anatomy, no blurry or out-of-focus areas, "
+    "no distorted hands or faces, no glitches, no pixelation, "
+    "no low resolution artifacts, no compression noise"
+)
+
+# ---------- HELPERS ----------
+def file_to_b64(uploaded_file):
+    data = uploaded_file.read(); uploaded_file.seek(0)
+    b64 = base64.b64encode(data).decode("ascii")
+    mime = mimetypes.guess_type(uploaded_file.name)[0] or "image/jpeg"
+    return b64, mime, uploaded_file.name
+
+def _extract_number_for_sort(name: str) -> int:
+    m = re.search(r"(\d+)", name)
+    return int(m.group(1)) if m else 10**9
+
+def normalize_b64_front(s: str) -> str:
+    if not s: return s
+    ss = s.strip()
+    if "," in ss and ss.lower().startswith("data:"):
+        ss = ss.split(",",1)[1]
+    ss = "".join(ss.split())
+    rem = len(ss) % 4
+    if rem: ss += "=" * (4 - rem)
+    return ss
+
+def parse_batch_prompts(txt: str, json_mode: bool):
+    txt = (txt or "").strip()
+    if not txt: return []
+    if not json_mode:
+        return [ln.strip() for ln in txt.splitlines() if ln.strip()]
+    try:
+        data = json.loads(txt)
+    except Exception:
+        return []
+    if isinstance(data, dict): data = [data]
+    out = []
+    for it in data:
+        if isinstance(it, str): out.append(it.strip())
+        elif isinstance(it, dict): out.append(it.get("prompt") or "")
+    return [s for s in out if s]
+
+def enhance_prompt_from_image(filename: str, aspect: str, resolution: str) -> str:
+    """Prompt singkat, natural, variatif (motion, style, camera, shot, lens, ambiance)."""
+    stem = pathlib.Path(filename).stem.replace("_"," ").replace("-"," ")
+
+    motions  = ["gentle breeze", "subtle breathing", "calm parallax shift", "slow light flicker", "soft camera drift"]
+    styles   = ["cinematic realistic", "dreamy pastel film", "moody noir", "bright daylight", "golden hour glow"]
+    cameras  = ["eye-level", "smooth dolly forward", "slow pan", "aerial view", "low angle"]
+    shots    = ["wide shot", "medium shot", "close-up", "over-the-shoulder", "establishing shot"]
+    lenses   = ["24mm wide lens", "35mm lifestyle lens", "50mm portrait lens", "85mm telephoto lens", "macro lens"]
+    ambiances= ["warm tones", "cool night tones", "soft pastel colors", "high contrast palette", "natural balanced light"]
+
+    motion   = random.choice(motions)
+    style    = random.choice(styles)
+    camera   = random.choice(cameras)
+    shot     = random.choice(shots)
+    lens     = random.choice(lenses)
+    ambiance = random.choice(ambiances)
+
+    # Prompt langsung siap generate
+    return f"{stem}, {motion}, {style}, {camera}, {shot}, using {lens}, {ambiance}. Aspect {aspect}, Resolution {resolution}."
+
+def ensure_api_key():
+    key = st.session_state.api_key_val
+    if not key:
+        st.error("❌ Provide Google API key in sidebar")
+        return None
+    os.environ["GOOGLE_API_KEY"] = key
+    return key
+
+# ---------- SIDEBAR ----------
+with st.sidebar:
+    st.header("🔑 API Key")
+    api_key = st.text_input("Google API Key", type="password", value=st.session_state.api_key_val)
+    if api_key: st.session_state.api_key_val = api_key
+
+    st.header("Settings")
+    model_ui = st.selectbox("Model", MODELS_UI)
+    mode_ui  = st.radio("Mode", ["Text → Video","Image → Video"])
+
+    images_info: List[Tuple[str,str,str]] = []
+    if mode_ui.startswith("Image"):
+        uploaded = st.file_uploader("Upload images", type=["png","jpg","jpeg"], accept_multiple_files=True)
+        sort_mode = st.selectbox("Sort images by", ["Filename (Numeric 1–9)", "Upload order"], index=0)
+        if uploaded:
+            if sort_mode == "Filename (Numeric 1–9)":
+                files = sorted(uploaded, key=lambda f: (_extract_number_for_sort(f.name), f.name.lower()))
+            else:
+                files = list(uploaded)
+
+            st.caption("Order:")
+            for i, f in enumerate(files, 1):
+                st.write(f"{i}. {f.name}")
+
+            images_info = [file_to_b64(f) for f in files]
+            st.session_state.images_info = images_info
+
+            # Auto-fill prompt (variatif) langsung di textarea
+            st.session_state.prompt_main = "\n".join([
+                enhance_prompt_from_image(fn, "16:9", "1080p") for _,_,fn in images_info
+            ])
+
+    # Resolution & aspect
+    want_resolution = st.selectbox("Resolution", ["720p","1080p"], index=1)
+    aspect          = st.selectbox("Aspect", ASPECTS)
+
+    @st.cache_data
+    def get_caps(model): return get_model_capabilities(model)
+    caps = get_caps(model_ui)
+    st.caption(f"Max: {caps.get('max_resolution','unknown')}")
+    if want_resolution == "1080p" and aspect != "16:9":
+        st.warning("⚠️ 1080p → 16:9 only")
+    elif want_resolution == "1080p" and not caps.get("supports_1080p", True):
+        st.warning("⚠️ Model may fallback to 720p")
+
+    # Negative prompt (konstan, masih bisa diedit)
+    negative_prompt = st.text_area(
+        "Negative Prompt",
+        value=NEG_PROMPT_DEFAULT,
+        height=120,
+        help="Constant default applied unless you edit."
+    )
+    person_generation = st.selectbox("Person Gen", ["auto","allow_adult","allow_all"])
+    audio_on = st.checkbox("Enable Audio", True)
+    num_results = st.number_input("Results per prompt", 1, 3, 1)
+    worker_delay = st.number_input("Worker Delay (s)", 0.0, 10.0, st.session_state.worker_delay, 0.5)
+    st.session_state.worker_delay = worker_delay
+
+    c1, c2 = st.columns(2)
+    run_btn = c1.button("🎬 Generate", type="primary", use_container_width=True)
+    clr_btn = c2.button("🗑️ Clear", use_container_width=True)
+
+# ---------- MAIN ----------
+st.title("🎬 VidGen — Google Veo")
+prompt_text = st.text_area("Prompts", value=st.session_state.prompt_main, height=200)
+json_mode   = st.checkbox("JSON Mode")
+batch_prompts = parse_batch_prompts(prompt_text, json_mode)
+st.caption(f"🧾 Parsed prompts: {len(batch_prompts)}")
+
+def clear_state():
+    st.session_state.jobs=[]; st.session_state.job_idx=0; st.session_state.running=False
+    st.session_state.total=0; st.session_state.overall_progress_value=0.0
+
+if clr_btn:
+    clear_state(); st.session_state.prompt_main=""; st.rerun()
+
+# ---------- BUILD & RUN ----------
+if run_btn and not st.session_state.running:
+    key = ensure_api_key()
+    if key:
+        jobs=[]; have_images = bool(st.session_state.images_info)
+        if have_images:
+            images = st.session_state.images_info
+            # Jika textarea kosong, isi ulang sesuai setting saat ini
+            prompts = batch_prompts or [enhance_prompt_from_image(fn, aspect, want_resolution) for _,_,fn in images]
+            total_pairs = max(len(prompts), len(images))
+            for i in range(total_pairs):
+                p = prompts[i % len(prompts)]
+                b64v, mime, _ = images[i % len(images)]
+                jobs.append({"prompt": p, "img_b64": b64v, "img_mime": mime})
+        else:
+            jobs = [{"prompt": p, "img_b64": None, "img_mime": None} for p in (batch_prompts or [])]
+
+        expanded = [j.copy() for j in jobs for _ in range(int(num_results))]
+        if not expanded:
+            st.error("❌ No jobs to run."); st.stop()
+
+        st.session_state.jobs = expanded
+        st.session_state.total = len(expanded)
+        st.session_state.job_idx = 0
+        st.session_state.running = True
+
+        # snapshot settings
+        st.session_state.last_model_ui = model_ui
+        st.session_state.last_mode_backend = "image" if have_images else "text"
+        st.session_state.last_aspect = aspect
+        st.session_state.last_resolution = want_resolution
+        st.session_state.last_negative = negative_prompt
+        st.session_state.last_person = person_generation
+        st.session_state.last_audio_on = audio_on
+        st.session_state.prompt_main = prompt_text
+
+        st.rerun()
+
+# ---------- RUNNER ----------
+overall = st.empty(); cols = st.columns(2)
+if st.session_state.running and st.session_state.total > 0:
+    idx = st.session_state.job_idx; total = st.session_state.total
+    overall.progress(st.session_state.overall_progress_value)
+    if idx > 0 and st.session_state.worker_delay > 0:
+        time.sleep(float(st.session_state.worker_delay))
+
+    col = cols[idx % 2]
+    with col:
+        neg_text = (st.session_state.last_negative or "").strip()
+        neg_badge = f'<span class="badge">Neg: {neg_text}</span>' if neg_text else ""
+        st.markdown(
+            f"""
+            <div class='job-card'>
+              <div class='job-head'>Job {idx+1}/{total}</div>
+              <div class='badges'>
+                <span class='badge'>Mode: {st.session_state.last_mode_backend}</span>
+                <span class='badge'>Aspect: {st.session_state.last_aspect}</span>
+                <span class='badge'>Res: {st.session_state.last_resolution}</span>
+                {neg_badge}
+              </div>
+            """,
+            unsafe_allow_html=True
+        )
+        box = st.container()
+        try:
+            job = st.session_state.jobs[idx]
+            generate_one_with_ui(
+                api_key=st.session_state.api_key_val,
+                model_ui=st.session_state.last_model_ui,
+                mode=st.session_state.last_mode_backend,
+                prompt=job["prompt"],
+                negative_prompt=st.session_state.last_negative,
+                aspect=st.session_state.last_aspect,
+                want_resolution=st.session_state.last_resolution,
+                person_generation=None if st.session_state.last_person=="auto" else st.session_state.last_person,
+                img_b64=normalize_b64_front(job["img_b64"]),
+                img_mime=job["img_mime"],
+                enable_audio=st.session_state.last_audio_on,
+                ui_box=box
+            )
+        except Exception as err:
+            box.error(f"❌ {err}")
+        st.markdown("</div>", unsafe_allow_html=True)
+
+    st.session_state.job_idx += 1
+    st.session_state.overall_progress_value = st.session_state.job_idx / total
+    overall.progress(st.session_state.overall_progress_value)
+
+    if st.session_state.job_idx < total:
+        st.rerun()
+    else:
+        st.session_state.running = False
+        st.success("✅ Batch complete")

components/__init__.py

@@ -0,0 +1,19 @@
+"""
+Components package for VidGen
+"""
+
+from .donation_widget import (
+    render_donation_widget,
+    render_donation_html, 
+    render_donation_scripts,
+    render_sidebar_support,
+    render_footer_support
+)
+
+__all__ = [
+    'render_donation_widget',
+    'render_donation_html',
+    'render_donation_scripts', 
+    'render_sidebar_support',
+    'render_footer_support'
+]

components/donation_widget.py

@@ -0,0 +1,246 @@
+"""
+Floating Donation Widget Component
+Separated for better performance and maintainability
+"""
+
+import streamlit as st
+
+def render_donation_widget():
+    """Render the floating donation widget with optimized CSS and JS"""
+    
+    st.markdown("""
+    <style>
+    /* Floating Donation Widgets - Optimized */
+    .floating-donations {
+      position: fixed;
+      right: 20px;
+      top: 50%;
+      transform: translateY(-50%);
+      z-index: 1000;
+      display: flex;
+      flex-direction: column;
+      gap: 15px;
+    }
+
+    .floating-btn {
+      width: 60px;
+      height: 60px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      text-decoration: none;
+      font-weight: bold;
+      font-size: 14px;
+      box-shadow: 0 4px 20px rgba(0,0,0,0.3);
+      transition: all 0.3s ease;
+      cursor: pointer;
+      border: none;
+      position: relative;
+      overflow: hidden;
+      will-change: transform;
+    }
+
+    .floating-btn:hover {
+      transform: scale(1.1);
+      box-shadow: 0 6px 30px rgba(0,0,0,0.4);
+      text-decoration: none;
+    }
+
+    .floating-btn:before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: -100%;
+      width: 100%;
+      height: 100%;
+      background: linear-gradient(90deg, transparent, rgba(255,255,255,0.2), transparent);
+      transition: left 0.5s;
+    }
+
+    .floating-btn:hover:before {
+      left: 100%;
+    }
+
+    .kofi-floating {
+      background: linear-gradient(135deg, #ff5f5f, #ff3838);
+      color: white;
+    }
+
+    .saweria-floating {
+      background: linear-gradient(135deg, #ffbd44, #f39c12);
+      color: #2c3e50;
+    }
+
+    .floating-tooltip {
+      position: absolute;
+      right: 70px;
+      top: 50%;
+      transform: translateY(-50%);
+      background: rgba(0,0,0,0.8);
+      color: white;
+      padding: 8px 12px;
+      border-radius: 6px;
+      font-size: 12px;
+      white-space: nowrap;
+      opacity: 0;
+      visibility: hidden;
+      transition: all 0.3s ease;
+      pointer-events: none;
+    }
+
+    .floating-tooltip:after {
+      content: '';
+      position: absolute;
+      left: 100%;
+      top: 50%;
+      transform: translateY(-50%);
+      border: 5px solid transparent;
+      border-left-color: rgba(0,0,0,0.8);
+    }
+
+    .floating-btn:hover .floating-tooltip {
+      opacity: 1;
+      visibility: visible;
+    }
+
+    /* Responsive hiding for mobile */
+    @media (max-width: 768px) {
+      .floating-donations {
+        display: none;
+      }
+    }
+
+    /* Ko-fi widget custom styling */
+    .kofi-widget-container {
+      position: fixed !important;
+      bottom: 20px !important;
+      right: 20px !important;
+      z-index: 999 !important;
+    }
+
+    /* Hide default Ko-fi widget on mobile */
+    @media (max-width: 768px) {
+      .kofi-widget-container {
+        display: none !important;
+      }
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+def render_donation_html():
+    """Render the HTML structure for donation widgets"""
+    
+    st.markdown("""
+    <!-- Floating Donation Widgets -->
+    <div class="floating-donations">
+      <a href="https://ko-fi.com/saltudio" target="_blank" class="floating-btn kofi-floating" rel="noopener">
+        <span>☕</span>
+        <div class="floating-tooltip">Support on Ko-fi</div>
+      </a>
+      <a href="https://saweria.co/saltudio" target="_blank" class="floating-btn saweria-floating" rel="noopener">
+        <span>💝</span>
+        <div class="floating-tooltip">Support on Saweria</div>
+      </a>
+    </div>
+    """, unsafe_allow_html=True)
+
+@st.cache_resource
+def load_donation_scripts():
+    """Load donation widget scripts with caching"""
+    
+    return """
+    <!-- Ko-fi Floating Widget Script -->
+    <script src='https://storage.ko-fi.com/cdn/scripts/overlay-widget.js' async defer></script>
+    <script>
+      // Lazy load Ko-fi widget
+      document.addEventListener('DOMContentLoaded', function() {
+        if (typeof kofiWidgetOverlay !== 'undefined') {
+          kofiWidgetOverlay.draw('saltudio', {
+            'type': 'floating-chat',
+            'floating-chat.donateButton.text': 'Support me',
+            'floating-chat.donateButton.background-color': '#ff38b8',
+            'floating-chat.donateButton.text-color': '#fff'
+          });
+        }
+      });
+
+      // Custom Saweria floating widget - optimized
+      (function() {
+        function initDonationWidgets() {
+          const kofiWidget = document.querySelector('.kofi-widget-container');
+          const customWidgets = document.querySelector('.floating-donations');
+          
+          if (kofiWidget && customWidgets) {
+            customWidgets.style.bottom = '100px';
+            customWidgets.style.top = 'auto';
+            customWidgets.style.transform = 'none';
+          }
+          
+          // Add click tracking with throttling
+          let clickThrottle = false;
+          document.querySelectorAll('.floating-btn').forEach(btn => {
+            btn.addEventListener('click', function(e) {
+              if (!clickThrottle) {
+                clickThrottle = true;
+                const platform = this.classList.contains('kofi-floating') ? 'ko-fi' : 'saweria';
+                console.log(`Donation click: ${platform}`);
+                setTimeout(() => clickThrottle = false, 1000);
+              }
+            });
+          });
+        }
+        
+        // Initialize when DOM is ready
+        if (document.readyState === 'loading') {
+          document.addEventListener('DOMContentLoaded', initDonationWidgets);
+        } else {
+          initDonationWidgets();
+        }
+      })();
+    </script>
+    """
+
+def render_donation_scripts():
+    """Render donation widget scripts"""
+    scripts = load_donation_scripts()
+    st.markdown(scripts, unsafe_allow_html=True)
+
+def render_sidebar_support():
+    """Render compact support section for sidebar"""
+    
+    st.markdown("""
+    <div style="text-align: center;">
+        <p style="color: #9fb0c3; font-size: 0.9rem; margin-bottom: 1rem;">
+            Help keep this free tool running!
+        </p>
+        <div style="display: flex; gap: 10px; justify-content: center;">
+            <a href="https://ko-fi.com/saltudio" target="_blank" style="text-decoration: none;" rel="noopener">
+                <div style="background: linear-gradient(135deg, #ff5f5f, #ff3838); color: white; padding: 8px 16px; border-radius: 20px; font-size: 0.8rem; display: inline-flex; align-items: center; gap: 5px;">
+                    ☕ Ko-fi
+                </div>
+            </a>
+            <a href="https://saweria.co/saltudio" target="_blank" style="text-decoration: none;" rel="noopener">
+                <div style="background: linear-gradient(135deg, #ffbd44, #f39c12); color: #2c3e50; padding: 8px 16px; border-radius: 20px; font-size: 0.8rem; display: inline-flex; align-items: center; gap: 5px;">
+                    💝 Saweria
+                </div>
+            </a>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+def render_footer_support():
+    """Render footer support section"""
+    
+    st.markdown("""
+    <div style="text-align: center; padding: 20px; color: #9fb0c3;">
+        <p>💖 <strong>Enjoying VidGen?</strong> Support the project to keep it free!</p>
+        <p style="font-size: 0.9rem;">
+            Use the floating buttons on the right or the links in the sidebar to show your appreciation.
+            <br>Every coffee helps maintain the servers and develop new features! ☕✨
+        </p>
+        <p style="font-size: 0.8rem; margin-top: 1rem;">
+            Made with ❤️ using Streamlit • Veo • HuggingFace Spaces
+        </p>
+    </div>
+    """, unsafe_allow_html=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

requirements.txt

@@ -0,0 +1,4 @@
+streamlit>=1.28.0
+huggingface_hub>=0.17.0
+requests>=2.28.0
+google-genai>=0.5.0

utils/error_handler.py

@@ -0,0 +1,88 @@
+"""
+Error handling utilities for VidGen
+"""
+
+import streamlit as st
+import time
+import functools
+from typing import Any, Callable, Optional
+
+def retry_on_error(max_retries: int = 3, delay: float = 1.0, backoff: float = 2.0):
+    """Decorator to retry functions on specific errors"""
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            last_exception = None
+            
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    error_msg = str(e).lower()
+                    
+                    # Check for retryable errors
+                    retryable_errors = [
+                        'bodystreamBuffer was aborted',
+                        'connection error',
+                        'timeout',
+                        'network error',
+                        'temporary failure',
+                        'rate limit'
+                    ]
+                    
+                    is_retryable = any(err in error_msg for err in retryable_errors)
+                    
+                    if not is_retryable or attempt == max_retries - 1:
+                        raise e
+                    
+                    wait_time = delay * (backoff ** attempt)
+                    st.warning(f"⚠️ Attempt {attempt + 1} failed: {e}. Retrying in {wait_time:.1f}s...")
+                    time.sleep(wait_time)
+            
+            raise last_exception
+        return wrapper
+    return decorator
+
+def handle_stream_error(func: Callable) -> Callable:
+    """Handle stream buffer errors specifically"""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            error_msg = str(e).lower()
+            if 'bodystreamBuffer' in error_msg or 'aborted' in error_msg:
+                st.error("🔄 Connection interrupted. Please try again.")
+                st.info("💡 Tip: Try refreshing the page if the issue persists.")
+                return None
+            else:
+                raise e
+    return wrapper
+
+class ProgressTracker:
+    """Track progress with better error handling"""
+    
+    def __init__(self, total_jobs: int):
+        self.total_jobs = total_jobs
+        self.current_job = 0
+        self.progress_bar = None
+        self.status_text = None
+        
+    def start(self):
+        """Initialize progress tracking"""
+        self.progress_bar = st.progress(0)
+        self.status_text = st.empty()
+        
+    def update(self, job_idx: int, status: str = "Processing..."):
+        """Update progress"""
+        if self.progress_bar and self.status_text:
+            progress = (job_idx + 1) / self.total_jobs
+            self.progress_bar.progress(progress)
+            self.status_text.text(f"{status} ({job_idx + 1}/{self.total_jobs})")
+            
+    def complete(self):
+        """Mark as complete"""
+        if self.progress_bar and self.status_text:
+            self.progress_bar.progress(1.0)
+            self.status_text.text("✅ All jobs completed!")

utils/session_manager.py

@@ -0,0 +1,53 @@
+"""
+Session state management utilities
+"""
+
+import streamlit as st
+from typing import Any, Dict, Optional
+
+class SessionManager:
+    """Manage session state with better error handling"""
+    
+    @staticmethod
+    def init_session_state():
+        """Initialize session state with default values"""
+        defaults = {
+            "results": [],
+            "jobs": [],
+            "job_idx": 0,
+            "running": False,
+            "api_key_val": "",
+            "last_error": None,
+            "retry_count": 0,
+            "backend_loaded": False,
+            "backend": None
+        }
+        
+        for key, value in defaults.items():
+            if key not in st.session_state:
+                st.session_state[key] = value
+    
+    @staticmethod
+    def safe_update(updates: Dict[str, Any]):
+        """Safely update session state"""
+        try:
+            st.session_state.update(updates)
+        except Exception as e:
+            st.error(f"Session update failed: {e}")
+    
+    @staticmethod
+    def reset_job_state():
+        """Reset job-related state"""
+        SessionManager.safe_update({
+            "results": [],
+            "jobs": [],
+            "job_idx": 0,
+            "running": False,
+            "last_error": None,
+            "retry_count": 0
+        })
+    
+    @staticmethod
+    def get_safe(key: str, default: Any = None) -> Any:
+        """Safely get session state value"""
+        return st.session_state.get(key, default)