Spaces:

favoredone
/

111

Build error

App Files Files Community

favoredone commited on Oct 20, 2025

Commit

d27b88b

verified ·

1 Parent(s): 3a78518

Update app.py

Browse files

Files changed (1) hide show

app.py +435 -362

app.py CHANGED Viewed

@@ -1,362 +1,435 @@
-"""
-FastAPI server for Bitcoin mining dashboard - Complete Integration
-"""
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-import uvicorn
-import threading
-import time
-import json
-import asyncio
-from typing import Dict, Optional, List
-import logging
-import sys
-import os
-# Add the current directory to Python path to import your miner
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-app = FastAPI(title="Bitcoin Mining Dashboard", version="1.0.0")
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-# Mount static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-# Global mining state
-class MiningState:
-    def __init__(self):
-        self.is_mining = False
-        self.miner_instance = None
-        self.mining_thread = None
-        self.stats = {
-            "status": "Stopped",
-            "hashrate": "0 H/s",
-            "total_hashes": "0",
-            "blocks_found": "0",
-            "best_hash": "None",
-            "difficulty": "0",
-            "network_difficulty": "0",
-            "block_alert": "Ready to start mining",
-            "mining_time": "0s",
-            "cores_active": "0",
-            "wallet_address": "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"
-        }
-        self.start_time = None
-mining_state = MiningState()
-@app.get("/", response_class=HTMLResponse)
-async def get_index():
-    """Serve the dashboard HTML"""
-    try:
-        return FileResponse("static/index.html")
-    except:
-        # Fallback minimal HTML
-        return """
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>Bitcoin Mining Dashboard</title>
-            <style>
-                body { font-family: Arial, sans-serif; margin: 40px; background: #f0f0f0; }
-                .container { max-width: 800px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; }
-                .stats { background: #2c3e50; color: white; padding: 20px; border-radius: 5px; margin: 10px 0; }
-                .alert { background: #e74c3c; color: white; padding: 15px; border-radius: 5px; margin: 10px 0; }
-                .success { background: #27ae60; }
-                .button { background: #3498db; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 5px; }
-                .button:disabled { background: #95a5a6; }
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <h1>⛏️ Bitcoin Mining Dashboard</h1>
-                <div id="blockAlert" class="alert">Ready to start mining</div>
-                <div class="stats">
-                    <h3>Mining Statistics</h3>
-                    <div id="statsDisplay"></div>
-                </div>
-                <button class="button" onclick="startMining()" id="startBtn">Start Mining</button>
-                <button class="button" onclick="stopMining()" id="stopBtn" disabled>Stop Mining</button>
-                <script>
-                    function updateStats(stats) {
-                        document.getElementById('statsDisplay').innerHTML = `
-                            <p><strong>Status:</strong> ${stats.status}</p>
-                            <p><strong>Hash Rate:</strong> ${stats.hashrate}</p>
-                            <p><strong>Total Hashes:</strong> ${stats.total_hashes}</p>
-                            <p><strong>Blocks Found:</strong> ${stats.blocks_found}</p>
-                            <p><strong>Best Hash:</strong> ${stats.best_hash}</p>
-                            <p><strong>Mining Time:</strong> ${stats.mining_time}</p>
-                            <p><strong>Wallet:</strong> ${stats.wallet_address}</p>
-                        `;
-                        document.getElementById('blockAlert').textContent = stats.block_alert;
-                        document.getElementById('blockAlert').className = stats.blocks_found > 0 ? 'alert success' : 'alert';
-                        document.getElementById('startBtn').disabled = stats.status === 'Running';
-                        document.getElementById('stopBtn').disabled = stats.status !== 'Running';
-                    }
-                    async function startMining() {
-                        const response = await fetch('/start_mining', { method: 'POST' });
-                        const result = await response.json();
-                        alert(result.message);
-                    }
-                    async function stopMining() {
-                        const response = await fetch('/stop_mining', { method: 'POST' });
-                        const result = await response.json();
-                        alert(result.message);
-                    }
-                    // Poll for stats updates
-                    setInterval(async () => {
-                        const response = await fetch('/get_stats');
-                        const stats = await response.json();
-                        updateStats(stats);
-                    }, 1000);
-                </script>
-            </div>
-        </body>
-        </html>
-        """
-def mining_worker(duration=None):
-    """Worker function to run mining in background thread"""
-    try:
-        # Import and initialize the miner
-        from parallel_miner_v3 import ParallelMiner
-        mining_state.miner_instance = ParallelMiner(
-            num_cores=7,
-            wallet_address="1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"
-        )
-        mining_state.start_time = time.time()
-        # Start mining
-        mining_state.miner_instance.start_mining(duration=duration)
-    except Exception as e:
-        logging.error(f"Mining worker error: {e}")
-    finally:
-        mining_state.is_mining = False
-        mining_state.mining_thread = None
-@app.post("/start_mining")
-async def start_mining(background_tasks: BackgroundTasks):
-    """Start the mining process"""
-    global mining_state
-    if mining_state.is_mining:
-        raise HTTPException(status_code=400, detail="Mining is already running")
-    try:
-        mining_state.is_mining = True
-        mining_state.stats["status"] = "Starting..."
-        mining_state.stats["block_alert"] = "🔄 Starting mining process..."
-        # Start mining in background thread
-        mining_state.mining_thread = threading.Thread(
-            target=mining_worker,
-            kwargs={"duration": None}  # Mine indefinitely
-        )
-        mining_state.mining_thread.daemon = True
-        mining_state.mining_thread.start()
-        logging.info("✅ Mining started via API")
-        return {"message": "Mining started successfully", "status": "started"}
-    except Exception as e:
-        mining_state.is_mining = False
-        logging.error(f"Error starting mining: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-@app.post("/stop_mining")
-async def stop_mining():
-    """Stop the mining process"""
-    global mining_state
-    if not mining_state.is_mining:
-        raise HTTPException(status_code=400, detail="Mining is not running")
-    try:
-        if mining_state.miner_instance:
-            mining_state.miner_instance.mining = False
-            mining_state.is_mining = False
-            # Log final statistics
-            if hasattr(mining_state.miner_instance, 'total_hashes'):
-                total_hashes = mining_state.miner_instance.total_hashes
-                blocks_found = mining_state.miner_instance.blocks_found
-                mining_time = time.time() - mining_state.start_time
-                logging.info("\n" + "="*50)
-                logging.info("⛏️ FINAL MINING STATISTICS")
-                logging.info("="*50)
-                logging.info(f"⏱️ Total mining time: {mining_time:.2f} seconds")
-                logging.info(f"🔢 Total hashes: {total_hashes:,}")
-                logging.info(f"💰 Blocks found: {blocks_found}")
-                logging.info(f"⚡ Average hash rate: {total_hashes/max(mining_time,1)/1000:.2f} KH/s")
-                if hasattr(mining_state.miner_instance, 'cores'):
-                    for core_idx, core in enumerate(mining_state.miner_instance.cores):
-                        logging.info(f"🔩 Core {core_idx}: {core.total_hashes:,} hashes")
-                logging.info("="*50)
-            mining_state.stats["status"] = "Stopped"
-            mining_state.stats["block_alert"] = "🛑 Mining stopped"
-            return {"message": "Mining stopped successfully", "status": "stopped"}
-        raise HTTPException(status_code=400, detail="No active mining instance")
-    except Exception as e:
-        logging.error(f"Error stopping mining: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-@app.get("/get_stats")
-async def get_mining_stats():
-    """Get current mining statistics"""
-    global mining_state
-    if not mining_state.is_mining or not mining_state.miner_instance:
-        return mining_state.stats
-    try:
-        miner = mining_state.miner_instance
-        # Calculate mining time
-        mining_time = time.time() - mining_state.start_time
-        time_str = f"{int(mining_time//3600)}h {int((mining_time%3600)//60)}m {int(mining_time%60)}s"
-        # Create block alert message
-        if miner.blocks_found > 0:
-            block_alert = f"🎉 FOUND {miner.blocks_found} BLOCK(S)! 🎉"
-            if miner.best_hash:
-                block_alert += f" Hash: {miner.best_hash.hex()[:16]}..."
-        else:
-            progress = (miner.best_hash_difficulty / max(miner.network_difficulty, 1)) * 100 if miner.best_hash_difficulty else 0
-            block_alert = f"⛏️ Mining... Progress: {progress:.8f}%"
-        # Update stats
-        mining_state.stats.update({
-            "status": "Running",
-            "hashrate": f"{miner.current_hashrate/1000:.2f} KH/s",
-            "total_hashes": f"{miner.total_hashes:,}",
-            "blocks_found": str(miner.blocks_found),
-            "best_hash": miner.best_hash.hex()[:32] + "..." if miner.best_hash else "None",
-            "difficulty": f"{miner.best_hash_difficulty:.8f}" if miner.best_hash_difficulty else "0",
-            "network_difficulty": f"{miner.network_difficulty:,.2f}" if hasattr(miner, 'network_difficulty') else "0",
-            "block_alert": block_alert,
-            "mining_time": time_str,
-            "cores_active": f"{len(miner.cores)}" if hasattr(miner, 'cores') else "0"
-        })
-        return mining_state.stats
-    except Exception as e:
-        logging.error(f"Error getting mining stats: {e}")
-        return {
-            "status": "Error",
-            "hashrate": "0 H/s",
-            "total_hashes": "0",
-            "blocks_found": "0",
-            "best_hash": "Error",
-            "difficulty": "0",
-            "block_alert": f"Error: {str(e)}",
-            "mining_time": "0s",
-            "cores_active": "0"
-        }
-@app.get("/get_detailed_stats")
-async def get_detailed_stats():
-    """Get detailed mining statistics including per-core info"""
-    global mining_state
-    if not mining_state.is_mining or not mining_state.miner_instance:
-        return {"error": "Mining not active"}
-    try:
-        miner = mining_state.miner_instance
-        detailed_stats = {
-            "overview": {
-                "status": "Running",
-                "total_hashes": miner.total_hashes,
-                "blocks_found": miner.blocks_found,
-                "current_hashrate": miner.current_hashrate,
-                "best_hash_difficulty": miner.best_hash_difficulty,
-                "network_difficulty": miner.network_difficulty,
-                "mining_time": time.time() - mining_state.start_time
-            },
-            "cores": []
-        }
-        if hasattr(miner, 'cores'):
-            for core in miner.cores:
-                core_info = {
-                    "core_id": core.core_id,
-                    "total_hashes": core.total_hashes,
-                    "blocks_found": core.blocks_found,
-                    "units": []
-                }
-                for unit in core.units:
-                    core_info["units"].append({
-                        "unit_id": unit.unit_id,
-                        "total_hashes": unit.total_hashes,
-                        "blocks_found": unit.blocks_found
-                    })
-                detailed_stats["cores"].append(core_info)
-        return detailed_stats
-    except Exception as e:
-        return {"error": str(e)}
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "mining_active": mining_state.is_mining,
-        "timestamp": time.time()
-    }
-# Background task to periodically update stats
-@app.on_event("startup")
-async def startup_event():
-    """Initialize on startup"""
-    logging.info("🚀 Bitcoin Mining Dashboard starting up...")
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Cleanup on shutdown"""
-    global mining_state
-    if mining_state.is_mining and mining_state.miner_instance:
-        mining_state.miner_instance.mining = False
-        mining_state.is_mining = False
-    logging.info("🛑 Bitcoin Mining Dashboard shutting down...")
-if __name__ == "__main__":
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7868,
-        reload=False,
-        log_level="info"
-    )

+import gradio as gr
+import subprocess
+import torch
+from PIL import Image
+import requests
+from io import BytesIO
+import base64
+from transformers import AutoProcessor, AutoModelForCausalLM
+import os
+import threading
+import time
+import urllib.parse
+# Attempt to install flash-attn
+try:
+    subprocess.run('pip install flash-attn --no-build-isolation', env={'FLASH_ATTENTION_SKIP_CUDA_BUILD': "TRUE"}, check=True, shell=True)
+except subprocess.CalledProcessError as e:
+    print(f"Error installing flash-attn: {e}")
+    print("Continuing without flash-attn.")
+# Determine the device to use
+device = "cuda" if torch.cuda.is_available() else "cpu"
+# Load the base model and processor
+try:
+    vision_language_model_base = AutoModelForCausalLM.from_pretrained('microsoft/Florence-2-base', trust_remote_code=True).to(device).eval()
+    vision_language_processor_base = AutoProcessor.from_pretrained('microsoft/Florence-2-base', trust_remote_code=True)
+    print("✓ Base model loaded successfully")
+except Exception as e:
+    print(f"Error loading base model: {e}")
+    vision_language_model_base = None
+    vision_language_processor_base = None
+# Load the large model and processor
+try:
+    vision_language_model_large = AutoModelForCausalLM.from_pretrained('microsoft/Florence-2-large', trust_remote_code=True).to(device).eval()
+    vision_language_processor_large = AutoProcessor.from_pretrained('microsoft/Florence-2-large', trust_remote_code=True)
+    print("✓ Large model loaded successfully")
+except Exception as e:
+    print(f"Error loading large model: {e}")
+    vision_language_model_large = None
+    vision_language_processor_large = None
+def load_image_from_url(image_url):
+    """Load an image from a URL."""
+    try:
+        response = requests.get(image_url, timeout=30)
+        response.raise_for_status()
+        image = Image.open(BytesIO(response.content))
+        return image.convert('RGB')
+    except Exception as e:
+        raise ValueError(f"Error loading image from URL: {e}")
+def process_image_description(model, processor, image):
+    """Process an image and generate description using the specified model."""
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+    inputs = processor(text="<MORE_DETAILED_CAPTION>", images=image, return_tensors="pt").to(device)
+    with torch.no_grad():
+        generated_ids = model.generate(
+            input_ids=inputs["input_ids"],
+            pixel_values=inputs["pixel_values"],
+            max_new_tokens=1024,
+            early_stopping=False,
+            do_sample=False,
+            num_beams=3,
+        )
+    generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+    processed_description = processor.post_process_generation(
+        generated_text,
+        task="<MORE_DETAILED_CAPTION>",
+        image_size=(image.width, image.height)
+    )
+    image_description = processed_description["<MORE_DETAILED_CAPTION>"]
+    return image_description
+def describe_image(uploaded_image, model_choice):
+    """Generate description from uploaded image."""
+    if uploaded_image is None:
+        return "Please upload an image."
+    if model_choice == "Florence-2-base":
+        if vision_language_model_base is None:
+            return "Base model failed to load."
+        model = vision_language_model_base
+        processor = vision_language_processor_base
+    elif model_choice == "Florence-2-large":
+        if vision_language_model_large is None:
+            return "Large model failed to load."
+        model = vision_language_model_large
+        processor = vision_language_processor_large
+    else:
+        return "Invalid model choice."
+    try:
+        return process_image_description(model, processor, uploaded_image)
+    except Exception as e:
+        return f"Error generating caption: {str(e)}"
+def describe_image_from_url(image_url, model_choice):
+    """Generate description from image URL."""
+    try:
+        if not image_url:
+            return {"error": "image_url is required"}
+        if model_choice not in ["Florence-2-base", "Florence-2-large"]:
+            return {"error": "Invalid model choice. Use 'Florence-2-base' or 'Florence-2-large'"}
+        # Load image from URL
+        image = load_image_from_url(image_url)
+        # Select model and processor
+        if model_choice == "Florence-2-base":
+            if vision_language_model_base is None:
+                return {"error": "Base model not available"}
+            model = vision_language_model_base
+            processor = vision_language_processor_base
+        else:
+            if vision_language_model_large is None:
+                return {"error": "Large model not available"}
+            model = vision_language_model_large
+            processor = vision_language_processor_large
+        # Generate caption
+        caption = process_image_description(model, processor, image)
+        return {
+            "status": "success",
+            "model": model_choice,
+            "caption": caption,
+            "image_size": {"width": image.width, "height": image.height}
+        }
+    except Exception as e:
+        return {"error": f"Error processing image: {str(e)}"}
+# ---- Background captioning worker -------------------------------------------------
+# This worker will start in a daemon thread before Gradio launches. It polls the
+# image middleware on IMAGE_SERVER_BASE, downloads frames, captions them using
+# the already-loaded Florence models, posts results to DATA_COLLECTION_BASE:/submit,
+# then releases frames and courses. It uses blocking requests so it runs in a
+# separate thread and will not interfere with the UI thread.
+IMAGE_SERVER_BASE = os.getenv("IMAGE_SERVER_BASE", "https://fred808-vssee.hf.space")
+DATA_COLLECTION_BASE = os.getenv("DATA_COLLECTION_BASE", "https://fred808-flow.hf.space")
+REQUESTER_ID = os.getenv("FLO_REQUESTER_ID", f"florence-2-{os.getpid()}")
+MODEL_CHOICE = os.getenv("FLO_MODEL_CHOICE", "Florence-2-base")
+def _build_download_url(course: str, video: str, frame: str) -> str:
+    file_param = f"frame:{course}/{video}/{frame}"
+    return f"{IMAGE_SERVER_BASE.rstrip('/')}/download?course={urllib.parse.quote(course, safe='')}&file={urllib.parse.quote(file_param, safe='') }"
+def _download_bytes(url: str, timeout: int = 30):
+    try:
+        r = requests.get(url, timeout=timeout)
+        r.raise_for_status()
+        return r.content, r.headers.get('content-type')
+    except Exception as e:
+        print(f"[BACKGROUND] download failed {url}: {e}")
+        return None, None
+def _post_submit(caption: str, image_name: str, course: str, image_url: str, image_bytes: bytes):
+    submit_url = f"{DATA_COLLECTION_BASE.rstrip('/')}/submit"
+    files = {'image': (image_name, image_bytes, 'application/octet-stream')}
+    data = {'caption': caption, 'image_name': image_name, 'course': course, 'image_url': image_url}
+    try:
+        r = requests.post(submit_url, data=data, files=files, timeout=30)
+        try:
+            return r.status_code, r.json()
+        except Exception:
+            return r.status_code, r.text
+    except Exception as e:
+        print(f"[BACKGROUND] submit POST failed: {e}")
+        return None, None
+def _release_frame(course: str, video: str, frame: str):
+    try:
+        release_url = f"{IMAGE_SERVER_BASE.rstrip('/')}/middleware/release/frame/{urllib.parse.quote(course, safe='')}/{urllib.parse.quote(video, safe='')}/{urllib.parse.quote(frame, safe='')}"
+        requests.post(release_url, params={"requester_id": REQUESTER_ID}, timeout=10)
+    except Exception as e:
+        print(f"[BACKGROUND] release frame failed: {e}")
+def _release_course(course: str):
+    try:
+        release_url = f"{IMAGE_SERVER_BASE.rstrip('/')}/middleware/release/course/{urllib.parse.quote(course, safe='')}"
+        requests.post(release_url, params={"requester_id": REQUESTER_ID}, timeout=10)
+    except Exception as e:
+        print(f"[BACKGROUND] release course failed: {e}")
+def background_worker():
+    print("[BACKGROUND] Worker waiting for model to be available...")
+    # wait for model(s) to load (respect existing loading logic)
+    waited = 0
+    while waited < 120:
+        if MODEL_CHOICE == "Florence-2-base":
+            if vision_language_model_base is not None and vision_language_processor_base is not None:
+                break
+        else:
+            if vision_language_model_large is not None and vision_language_processor_large is not None:
+                break
+        time.sleep(1)
+        waited += 1
+    if waited >= 120:
+        print("[BACKGROUND] Model not available after timeout; background worker exiting.")
+        return
+    print("[BACKGROUND] Model loaded; starting polling loop")
+    while True:
+        try:
+            # Acquire next course
+            try:
+                r = requests.get(f"{IMAGE_SERVER_BASE.rstrip('/')}/middleware/next/course", params={"requester_id": REQUESTER_ID}, timeout=15)
+                if r.status_code == 404:
+                    time.sleep(3)
+                    continue
+                r.raise_for_status()
+                course_json = r.json()
+            except Exception as e:
+                print(f"[BACKGROUND] failed to get next course: {e}")
+                time.sleep(3)
+                continue
+            course = course_json.get('course_id') or course_json.get('course')
+            if not course:
+                print(f"[BACKGROUND] invalid course response: {course_json}")
+                time.sleep(2)
+                continue
+            print(f"[BACKGROUND] processing course: {course}")
+            # Pull images until none left
+            while True:
+                try:
+                    img_url = f"{IMAGE_SERVER_BASE.rstrip('/')}/middleware/next/image/{urllib.parse.quote(course, safe='')}"
+                    rimg = requests.get(img_url, params={"requester_id": REQUESTER_ID}, timeout=15)
+                    if rimg.status_code == 404:
+                        print(f"[BACKGROUND] no images for course {course}")
+                        break
+                    rimg.raise_for_status()
+                    img_json = rimg.json()
+                except Exception as e:
+                    print(f"[BACKGROUND] failed to get next image: {e}")
+                    time.sleep(1)
+                    continue
+                video = img_json.get('video')
+                frame = img_json.get('frame')
+                file_id = img_json.get('file_id')
+                if not (video and frame and file_id):
+                    print(f"[BACKGROUND] unexpected image entry: {img_json}")
+                    time.sleep(0.5)
+                    continue
+                download_url = _build_download_url(course, video, frame)
+                print(f"[BACKGROUND] downloading {download_url}")
+                img_bytes, content_type = _download_bytes(download_url)
+                if not img_bytes:
+                    print(f"[BACKGROUND] failed to download image, releasing frame {file_id}")
+                    _release_frame(course, video, frame)
+                    time.sleep(1)
+                    continue
+                try:
+                    pil_img = Image.open(BytesIO(img_bytes)).convert('RGB')
+                except Exception as e:
+                    print(f"[BACKGROUND] failed to open image bytes: {e}")
+                    _release_frame(course, video, frame)
+                    time.sleep(1)
+                    continue
+                # Choose model and processor according to MODEL_CHOICE
+                if MODEL_CHOICE == "Florence-2-base":
+                    model = vision_language_model_base
+                    processor = vision_language_processor_base
+                else:
+                    model = vision_language_model_large
+                    processor = vision_language_processor_large
+                caption = ""
+                try:
+                    # Reuse existing processing function: process_image_description(model, processor, image)
+                    caption = process_image_description(model, processor, pil_img)
+                except Exception as e:
+                    print(f"[BACKGROUND] captioning failed: {e}")
+                status, resp = _post_submit(caption, frame, course, download_url, img_bytes)
+                print(f"[BACKGROUND] submitted caption for {frame}: status={status}")
+                # release frame
+                _release_frame(course, video, frame)
+                time.sleep(0.2)
+            # release course
+            _release_course(course)
+            time.sleep(1)
+        except Exception as e:
+            print(f"[BACKGROUND] unexpected loop error: {e}")
+            time.sleep(5)
+# Start background worker thread (daemon) so it doesn't block shutdown
+def _start_worker_thread():
+    t = threading.Thread(target=background_worker, daemon=True)
+    t.start()
+# Description for the interface
+description = "> Select the model to use for generating the image description. 'Base' is smaller and faster, while 'Large' is more accurate but slower."
+if device == "cpu":
+    description += " Note: Running on CPU, which may be slow for large models."
+# Define examples - use placeholder if files don't exist
+examples = [
+    ["https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg", "Florence-2-large"],
+    ["https://huggingface.co/spaces/Fred808/NNE/resolve/main/young-woman-doing-fencing-special-equipment.jpg", "Florence-2-base"],
+]
+css = """
+.submit-btn {
+    background-color: #4682B4 !important;
+    color: white !important;
+}
+.submit-btn:hover {
+    background-color: #87CEEB !important;
+}
+"""
+# Create the Gradio interface with Blocks
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    gr.Markdown("# Florence-2 Models Image Captions")
+    gr.Markdown(description)
+    with gr.Tab("Upload Image"):
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(label="Upload Image", type="pil")
+                generate_btn = gr.Button("Generate Caption", elem_classes="submit-btn")
+            with gr.Column():
+                model_choice = gr.Radio(
+                    ["Florence-2-base", "Florence-2-large"],
+                    label="Model Choice",
+                    value="Florence-2-base"
+                )
+                output = gr.Textbox(label="Generated Caption", lines=4, show_copy_button=True)
+        # Examples for upload tab
+        gr.Examples(
+            examples=examples,
+            inputs=[image_input, model_choice],
+            outputs=[output],
+            fn=describe_image,
+            run_on_click=True
+        )
+        generate_btn.click(
+            fn=describe_image,
+            inputs=[image_input, model_choice],
+            outputs=output
+        )
+    with gr.Tab("Image from URL"):
+        gr.Markdown("## Generate caption from image URL")
+        gr.Markdown("Enter an image URL below to generate a caption.")
+        with gr.Row():
+            with gr.Column():
+                url_input = gr.Textbox(
+                    label="Image URL",
+                    placeholder="https://example.com/image.jpg",
+                    lines=2
+                )
+                url_model_choice = gr.Radio(
+                    ["Florence-2-base", "Florence-2-large"],
+                    label="Model Choice",
+                    value="Florence-2-large"
+                )
+                url_generate_btn = gr.Button("Generate Caption from URL", variant="primary")
+            with gr.Column():
+                url_output = gr.JSON(label="API Response")
+                url_caption = gr.Textbox(label="Caption", lines=4, show_copy_button=True)
+        # URL examples
+        url_examples = [
+            ["https://huggingface.co/spaces/Fred808/NNE/resolve/main/young-woman-doing-fencing-special-equipment.jpg", "Florence-2-large"],
+            ["https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg", "Florence-2-base"],
+        ]
+        gr.Examples(
+            examples=url_examples,
+            inputs=[url_input, url_model_choice],
+            outputs=[url_output, url_caption],
+            fn=describe_image_from_url,
+            run_on_click=True
+        )
+        def process_url_request(image_url, model_choice):
+            result = describe_image_from_url(image_url, model_choice)
+            caption = result.get("caption", "") if "caption" in result else result.get("error", "")
+            return result, caption
+        url_generate_btn.click(
+            fn=process_url_request,
+            inputs=[url_input, url_model_choice],
+            outputs=[url_output, url_caption]
+        )
+# Get the port from environment variable (for Hugging Face Spaces)
+port = int(os.environ.get("PORT", 7860))
+# Launch the interface with simplified settings
+try:
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=False,  # Disable share for Hugging Face Spaces
+        debug=False,   # Disable debug mode for stability
+        show_error=True,
+        quiet=True,    # Reduce verbose output
+    )
+except Exception as e:
+    print(f"Error launching app: {e}")
+    # Fallback launch with minimal settings
+    demo.launch(server_name="0.0.0.0", server_port=port, share=False, quiet=True)