Create ui.py

ui.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Modern UI for Video Background Replacer
+- Clean, responsive layout with Streamlit
+- File uploaders, previews, and processing controls
+- Log viewer and download buttons
+"""
+import streamlit as st
+import os
+from pathlib import Path
+from PIL import Image
+import numpy as np
+import logging
+from datetime import datetime
+import time
+
+logger = logging.getLogger("Advanced Video Background Replacer")
+
+# --- UI Helpers ---
+def tail_file(path: str, lines: int = 400) -> str:
+    """Read last N lines from a text file efficiently."""
+    if not os.path.exists(path):
+        return "(log file not found)"
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.readlines()
+        return "".join(content[-lines:])
+    except Exception as e:
+        return f"(failed to read log: {e})"
+
+def read_file_bytes(path: str) -> bytes:
+    """Read a file as bytes; return b'' if missing/error."""
+    try:
+        if not os.path.exists(path):
+            return b""
+        with open(path, "rb") as f:
+            return f.read()
+    except Exception:
+        return b""
+
+# --- Render UI ---
+def render_ui(process_video_func):
+    # --- Sidebar: System Status & Logs ---
+    with st.sidebar:
+        st.subheader("System Status")
+        st.markdown("**Log file:** `/tmp/app.log`")
+
+        # Log level control
+        log_level = st.selectbox(
+            "Log Level",
+            ["DEBUG", "INFO", "WARNING", "ERROR"],
+            index=1,  # Default: INFO
+            key="log_level_select"
+        )
+        if log_level != st.session_state.get('log_level_name', 'INFO'):
+            from streamlit_app import set_log_level
+            set_log_level(log_level)
+
+        if st.session_state.get('gpu_available', False):
+            try:
+                import torch
+                dev = torch.cuda.get_device_name(0)
+            except Exception:
+                dev = "Detected (name unavailable)"
+            st.success(f"GPU: {dev}")
+        else:
+            st.error("GPU: Not Available")
+
+        # Log viewer controls
+        st.checkbox("Auto-refresh log tail (every 2s)", key="auto_refresh_logs")
+        st.number_input("Tail last N lines", min_value=50, max_value=5000, step=50, key="log_tail_lines")
+
+        # Download logs button
+        log_bytes = read_file_bytes("/tmp/app.log")
+        st.download_button(
+            "Download Logs",
+            data=log_bytes if log_bytes else b"Log file not available yet.",
+            file_name="app.log",
+            mime="text/plain",
+            use_container_width=True,
+            disabled=not bool(log_bytes)
+        )
+
+        # Log tail viewer
+        with st.expander("View Log Tail", expanded=True):
+            if st.session_state.get('auto_refresh_logs', False):
+                time.sleep(2)
+                st.rerun()
+            log_text = tail_file("/tmp/app.log", st.session_state.get('log_tail_lines', 400))
+            st.code(log_text, language="text")
+
+    # --- Main UI: Two-Column Layout ---
+    col1, col2 = st.columns([1, 1], gap="large")
+
+    # --- Column 1: Video Upload ---
+    with col1:
+        st.header("1. Upload Video")
+        uploaded_video = st.file_uploader(
+            "Upload Video",
+            type=["mp4", "mov", "avi", "mkv", "webm"],
+            key="video_uploader"
+        )
+
+        st.markdown("### Video Preview")
+        video_preview_placeholder = st.empty()
+        if uploaded_video is not None:
+            try:
+                uploaded_video.seek(0)
+                video_bytes = uploaded_video.read()
+                with video_preview_placeholder.container():
+                    st.video(video_bytes)
+            except Exception as e:
+                logger.error(f"[UI] Video preview error: {e}", exc_info=True)
+                video_preview_placeholder.error(f"Cannot display video: {e}")
+        else:
+            video_preview_placeholder.empty()
+
+    # --- Column 2: Background & Processing ---
+    with col2:
+        st.header("2. Background Settings")
+        bg_type = st.radio(
+            "Select Background Type:",
+            ["Image", "Color"],
+            horizontal=True,
+            key="bg_type_radio"
+        )
+
+        # Background Image Upload
+        if bg_type == "Image":
+            bg_image = st.file_uploader(
+                "Upload Background Image",
+                type=["jpg", "png", "jpeg"],
+                key="bg_image_uploader"
+            )
+            bg_preview_placeholder = st.empty()
+            if bg_image is not None:
+                try:
+                    bg_image_pil = Image.open(bg_image)
+                    with bg_preview_placeholder.container():
+                        st.image(bg_image_pil, caption="Selected Background", use_column_width=True)
+                except Exception as e:
+                    logger.error(f"[UI] Background image error: {e}", exc_info=True)
+                    bg_preview_placeholder.error(f"Cannot display image: {e}")
+            else:
+                bg_preview_placeholder.empty()
+
+        # Background Color Picker
+        else:
+            selected_color = st.color_picker(
+                "Choose Background Color",
+                st.session_state.get('bg_color', "#00FF00"),
+                key="color_picker"
+            )
+            if selected_color != st.session_state.get('cached_color'):
+                st.session_state.bg_color = selected_color
+                st.session_state.cached_color = selected_color
+                color_rgb = tuple(int(selected_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
+                color_display = np.zeros((100, 100, 3), dtype=np.uint8)
+                color_display[:, :] = color_rgb
+                st.session_state.color_display_cache = color_display
+            color_preview_placeholder = st.empty()
+            if st.session_state.get('color_display_cache') is not None:
+                with color_preview_placeholder.container():
+                    st.image(st.session_state.color_display_cache, caption="Selected Color", width=200)
+            else:
+                color_preview_placeholder.empty()
+
+        # --- Process Button ---
+        st.header("3. Process Video")
+        can_process = (uploaded_video is not None and not st.session_state.get('processing', False))
+        if st.button("Process Video", disabled=not can_process, use_container_width=True):
+            if bg_type == "Image" and bg_image is None:
+                st.error("Please upload a background image")
+            else:
+                background = bg_image if bg_type == "Image" else st.session_state.get('bg_color')
+                success = process_video_func(uploaded_video, bg_image, background, bg_type)
+                if success:
+                    st.success("Video processing complete!")
+                else:
+                    st.error("Video processing failed. Check logs for details.")
+
+        # --- Results Display ---
+        if st.session_state.get('processed_video_bytes') is not None:
+            st.markdown("---")
+            st.markdown("### Processed Video")
+            try:
+                st.video(st.session_state.processed_video_bytes)
+                st.download_button(
+                    label="Download Processed Video",
+                    data=st.session_state.processed_video_bytes,
+                    file_name="processed_video.mp4",
+                    mime="video/mp4",
+                    use_container_width=True
+                )
+            except Exception as e:
+                logger.error(f"[UI] Display error: {e}", exc_info=True)
+                st.error(f"Display error: {e}")
+
+    # --- Error Display ---
+    if st.session_state.get('last_error'):
+        with st.expander("⚠️ Last Error", expanded=True):
+            st.error(st.session_state.last_error)
+            if st.button("Clear Error"):
+                st.session_state.last_error = None
+                st.rerun()