Update app.py

app.py

@@ -1,203 +1,364 @@
-# app.py
-
+# --- Imports ---
 import os
 import sys
-
-# --- Install Dependencies ---
-print("Installing required packages: diffusers, gradio_imageslider, huggingface-hub…")
-os.system("pip install --no-input diffusers gradio_imageslider huggingface-hub")
-
-# --- Standard Imports ---
-import logging
-import random
-import warnings
+import cv2
+import torch
+# Delay Gradio import until after installation
+# import gradio as gr
+import numpy as np
+from PIL import Image, ImageOps # <--- IMPORT ImageOps
 import io
 import base64
+import traceback
+# Delay spaces import until after installation
+# import spaces
+
+# --- Dependency Management ---
+# Force install specific compatible versions
+print("Installing specific Gradio and huggingface-hub versions...")
+os.system("pip uninstall -y gradio gradio-client huggingface-hub") # Uninstall all first
+os.system("pip install gradio==4.13.0 gradio-client==0.8.0") # Install specific Gradio
+os.system("pip install huggingface-hub==0.19.4") # Install older huggingface-hub
+print("Dependency installation complete.")
 
+# Now import Gradio and spaces
 import gradio as gr
-import numpy as np
 import spaces
-import torch
-from diffusers import FluxControlNetModel
-from diffusers.pipelines import FluxControlNetPipeline
-from gradio_imageslider import ImageSlider
-from PIL import Image, ImageOps
-from huggingface_hub import snapshot_download
-
-# --- Logging & Device Setup ---
-logging.basicConfig(level=logging.INFO)
-warnings.filterwarnings("ignore")
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 512px;
+# from huggingface_hub import HfFolder # Example import from hub if needed
+
+# Check installed versions (optional but helpful for debugging)
+try:
+    import pkg_resources
+    gradio_version = pkg_resources.get_distribution("gradio").version
+    hub_version = pkg_resources.get_distribution("huggingface-hub").version
+    print(f"Using Gradio version: {gradio_version}")
+    print(f"Using huggingface-hub version: {hub_version}")
+except Exception as e:
+    print(f"Could not check package versions: {e}")
+
+
+# Import model-specific libraries AFTER installing dependencies
+try:
+    from basicsr.archs.srvgg_arch import SRVGGNetCompact
+    from gfpgan.utils import GFPGANer
+    from realesrgan.utils import RealESRGANer
+    print("Successfully imported model libraries.")
+except ImportError as e:
+    print(f"Error importing model libraries: {e}")
+    print("Please ensure basicsr, gfpgan, realesrgan are installed or in requirements.txt")
+    sys.exit(1)
+
+# --- Constants ---
+OUTPUT_DIR = 'output' # This might not be strictly needed if not saving via gr.File
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# --- Model Weight Downloads ---
+MODEL_FILES = {
+    'realesr-general-x4v3.pth': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth',
+    'GFPGANv1.2.pth': 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.2.pth',
+    'GFPGANv1.3.pth': 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth',
+    'GFPGANv1.4.pth': 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth',
+    'RestoreFormer.pth': 'https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth',
 }
-.gradio-container {
-    max-width: 900px !important;
-    margin: auto !important;
+print("Downloading model weights...")
+for filename, url in MODEL_FILES.items():
+    try:
+        if not os.path.exists(filename):
+            print(f"Downloading {filename}...")
+            os.system(f"wget -q {url} -P .") # Use -q for quiet
+    except Exception as e:
+        print(f"Error downloading {filename}: {e}")
+if not os.path.exists('realesr-general-x4v3.pth'):
+    print("FATAL: RealESRGAN model (realesr-general-x4v3.pth) not found after download attempt. Cannot proceed.")
+    sys.exit(1)
+print("Model weight download check complete.")
+
+# --- Sample Image Downloads ---
+SAMPLE_IMAGES = {
+    'lincoln.jpg': 'https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/Abraham_Lincoln_O-77_matte_collodion_print.jpg/1024px-Abraham_Lincoln_O-77_matte_collodion_print.jpg',
+    'AI-generate.jpg': 'https://user-images.githubusercontent.com/17445847/187400315-87a90ac9-d231-45d6-b377-38702bd1838f.jpg',
+    'Blake_Lively.jpg': 'https://user-images.githubusercontent.com/17445847/187400981-8a58f7a4-ef61-42d9-af80-bc6234cef860.jpg',
+    '10045.png': 'https://user-images.githubusercontent.com/17445847/187401133-8a3bf269-5b4d-4432-b2f0-6d26ee1d3307.png'
 }
-"""
+print("Downloading sample images...")
+for filename, url in SAMPLE_IMAGES.items():
+    try:
+        if not os.path.exists(filename):
+             torch.hub.download_url_to_file(url, filename, progress=False)
+    except Exception as e:
+        print(f"Warning: Error downloading sample image {filename}: {e}")
+print("Sample image download check complete.")
+
+
+# --- Model Initialization (Background Enhancer) ---
+upsampler = None
+try:
+    print("Initializing RealESRGAN upsampler...")
+    model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu')
+    model_path = 'realesr-general-x4v3.pth'
+    half = torch.cuda.is_available()
+    print(f"CUDA available: {torch.cuda.is_available()}, Using half precision: {half}")
+    upsampler = RealESRGANer(scale=4, model_path=model_path, model=model, tile=0, tile_pad=10, pre_pad=0, half=half)
+    print("Successfully created RealESRGAN upsampler.")
+except Exception as e:
+    print(f"Error creating RealESRGAN upsampler: {e}")
+    print(traceback.format_exc())
+    print("Warning: GFPGAN will run without background enhancement.")
+
+
+# --- Inference Function (Handles API, PIL, Base64, EXIF) ---
+@spaces.GPU(duration=90) # Keep ZeroGPU decorator
+# --- MODIFIED Function Signature: Accepts filepath instead of PIL Image ---
+def inference(input_image_filepath, version, scale):
+    """
+    Processes an input image file using GFPGAN, handling EXIF and aspect ratio.
 
-if torch.cuda.is_available():
-    power_device = "GPU"
-    device = "cuda"
-    torch_dtype = torch.bfloat16
-else:
-    power_device = "CPU"
-    device = "cpu"
-    torch_dtype = torch.float32
+    Args:
+        input_image_filepath (str): Path to the temporary input image file provided by Gradio.
+        version (str): GFPGAN model version ('v1.2', 'v1.3', 'v1.4', 'RestoreFormer').
+        scale (float): Rescaling factor for the final output relative to original.
 
-logging.info(f"Running on device={device} with dtype={torch_dtype}")
+    Returns:
+        tuple: (PIL.Image.Image | None, str | None)
+               - Output PIL image (RGB) or None on error.
+               - Base64 encoded output image string (data URI) or an error message string.
+    """
+    # --- ADDED: Load image from filepath ---
+    input_pil_image = None
+    try:
+        print(f"Loading image from filepath: {input_image_filepath}")
+        if not input_image_filepath or not isinstance(input_image_filepath, str) or not os.path.exists(input_image_filepath):
+             error_msg = f"Error: Input image filepath is invalid or file does not exist: '{input_image_filepath}'"
+             print(error_msg)
+             # Return None for Image output, error message for Textbox output
+             return None, error_msg
+        input_pil_image = Image.open(input_image_filepath)
+        print(f"Successfully loaded image. Initial mode: {input_pil_image.mode}, size: {input_pil_image.size}")
+    except Exception as load_err:
+        error_msg = f"Error loading image from filepath {input_image_filepath}: {load_err}"
+        print(error_msg)
+        print(traceback.format_exc())
+        # Return None for Image output, error message for Textbox output
+        return None, error_msg
+    # --- End Added Image Loading ---
 
-# --- Model IDs & Download (no token) ---
-flux_model_id       = "black-forest-labs/FLUX.1-dev"
-controlnet_model_id = "jasperai/Flux.1-dev-Controlnet-Upscaler"
-local_model_dir     = flux_model_id.split("/")[-1]
-pipe = None
+    # Check if loading failed (redundant due to try/except, but safe)
+    if input_pil_image is None:
+        print("Error: No input image could be loaded.")
+        return None, "Error: Failed to load input image."
 
+    print(f"Processing image with GFPGAN version: {version}, scale: {scale}")
+
+    # --- Handle EXIF Orientation ---
+    original_size_before_exif = input_pil_image.size
+    try:
+        input_pil_image = ImageOps.exif_transpose(input_pil_image)
+        if input_pil_image.size != original_size_before_exif:
+            print(f"Image size changed by EXIF transpose: {original_size_before_exif} -> {input_pil_image.size}")
+    except Exception as exif_err:
+        print(f"Warning: Could not apply EXIF transpose: {exif_err}")
+    # -----------------------------
+
+    w_orig, h_orig = input_pil_image.size
+    print(f"Input size for processing (WxH): {w_orig}x{h_orig}")
+
+    # Convert PIL Image to OpenCV format (BGR numpy array)
+    try:
+        img_mode = input_pil_image.mode
+        if img_mode == 'RGBA':
+             input_pil_image = input_pil_image.convert('RGB')
+        elif img_mode != 'RGB':
+             print(f"Converting input image from {img_mode} to RGB")
+             input_pil_image = input_pil_image.convert('RGB')
+        img_bgr = np.array(input_pil_image)[:, :, ::-1].copy()
+    except Exception as conversion_err:
+        error_msg = f"Error converting PIL image to OpenCV format: {conversion_err}"
+        print(error_msg)
+        print(traceback.format_exc())
+        return None, error_msg # Return None for Image, error string for Textbox
+
+    # --- Start GFPGAN Processing ---
+    try:
+        h, w = img_bgr.shape[0:2]
+        if h > 4000 or w > 4000:
+            print(f'Warning: Image size ({w}x{h}) is very large, processing might be slow or fail.')
+
+        model_map = {
+            'v1.2': 'GFPGANv1.2.pth', 'v1.3': 'GFPGANv1.3.pth',
+            'v1.4': 'GFPGANv1.4.pth', 'RestoreFormer': 'RestoreFormer.pth'
+        }
+        arch_map = {
+            'v1.2': 'clean', 'v1.3': 'clean', 'v1.4': 'clean',
+            'RestoreFormer': 'RestoreFormer'
+        }
+
+        if version not in model_map:
+            error_msg = f"Error: Unknown version selected: {version}"
+            print(error_msg)
+            return None, error_msg
+        model_path = model_map[version]
+        arch = arch_map[version]
+        if not os.path.exists(model_path):
+             error_msg = f"Error: Model file not found for version {version}: {model_path}"
+             print(error_msg)
+             return None, error_msg
+
+        current_bg_upsampler = upsampler
+        if not current_bg_upsampler:
+             print("Warning: RealESRGAN upsampler not available. Background enhancement disabled.")
+
+        face_enhancer = GFPGANer(
+            model_path=model_path, upscale=2, arch=arch,
+            channel_multiplier=2, bg_upsampler=current_bg_upsampler
+        )
+
+        print(f"Running GFPGAN enhancement with {version}...")
+        _, _, output_bgr = face_enhancer.enhance(
+            img_bgr, has_aligned=False, only_center_face=False, paste_back=True
+        )
+        if output_bgr is None:
+             error_msg = "Error: GFPGAN enhancement returned None."
+             print(error_msg)
+             return None, error_msg
+        print(f"Enhancement complete. Intermediate output shape (HxWxC BGR): {output_bgr.shape}")
+
+        # --- Post-processing (Resizing) ---
+        target_scale_factor = float(scale)
+        h_gfpgan, w_gfpgan = output_bgr.shape[0:2]
+        target_w = int(w_orig * target_scale_factor)
+        target_h = int(h_orig * target_scale_factor)
+
+        if target_w <= 0 or target_h <= 0:
+             print(f"Warning: Invalid target size ({target_w}x{target_h}) calculated from scale {scale}. Using GFPGAN output size {w_gfpgan}x{h_gfpgan}.")
+             target_w, target_h = w_gfpgan, h_gfpgan
+
+        if abs(target_w - w_gfpgan) > 2 or abs(target_h - h_gfpgan) > 2:
+             print(f"Resizing GFPGAN output ({w_gfpgan}x{h_gfpgan}) to target ({target_w}x{target_h}) based on scale {target_scale_factor}...")
+             interpolation = cv2.INTER_LANCZOS4 if (target_w * target_h) > (w_gfpgan * h_gfpgan) else cv2.INTER_AREA
+             try:
+                 output_bgr = cv2.resize(output_bgr, (target_w, target_h), interpolation=interpolation)
+             except cv2.error as resize_err:
+                 # --- MODIFIED Resize Error Handling ---
+                 error_msg = f"Error during OpenCV resize: {resize_err}. Returning image before final resize attempt."
+                 print(error_msg)
+                 output_pil = Image.fromarray(cv2.cvtColor(output_bgr, cv2.COLOR_BGR2RGB))
+                 # Still try to encode this fallback image
+                 base64_output = None
+                 try:
+                     buffered = io.BytesIO()
+                     output_pil.save(buffered, format="WEBP", quality=85)
+                     img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+                     base64_output = f"data:image/webp;base64,{img_str}"
+                 except Exception as enc_err:
+                     print(f"Error encoding fallback image: {enc_err}")
+                     error_msg += f" | Encoding Error: {enc_err}" # Append encoding error
+                 # Return fallback image and combined error message
+                 return output_pil, base64_output if base64_output else error_msg
+                 # --- End Modified Resize Error Handling ---
+
+        # --- Convert final result back to PIL (RGB) ---
+        output_pil = Image.fromarray(cv2.cvtColor(output_bgr, cv2.COLOR_BGR2RGB))
+        print(f"Final output image size (WxH PIL): {output_pil.size}")
+
+        # --- Encode final PIL image to Base64 for API ---
+        # This replaces the need for gr.File saving/output
+        base64_output = None
+        try:
+            buffered = io.BytesIO()
+            output_pil.save(buffered, format="WEBP", quality=90)
+            img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+            base64_output = f"data:image/webp;base64,{img_str}"
+        except Exception as enc_err:
+            error_msg = f"Error encoding final image to base64: {enc_err}"
+            print(error_msg)
+            print(traceback.format_exc())
+            # Return the PIL image anyway, but with an error message
+            return output_pil, error_msg
+
+        # --- MODIFIED RETURN: Return PIL image and base64 string ---
+        # Remove save_path which is no longer needed for outputs
+        # Return the base64 string for the Textbox output (or success message)
+        success_msg = f"Success! Output size: {output_pil.size[0]}x{output_pil.size[1]}"
+        return output_pil, base64_output if base64_output else success_msg
+
+    except Exception as error:
+        # --- MODIFIED Main Exception Handling ---
+        error_msg = f"Error during GFPGAN processing: {error}"
+        print(error_msg)
+        print(traceback.format_exc())
+        # Return placeholder image (or None) and error message string
+        error_img = None
+        try:
+             error_img = Image.new('RGB', (100, 50), color = 'red')
+        except Exception: pass # Ignore if placeholder fails
+        return error_img, error_msg # Return placeholder/None and error string
+        # --- End Modified Main Exception Handling ---
+
+
+# --- Gradio Interface Definition ---
+title = "GFPGAN: Practical Face Restoration"
+description = """Gradio demo for <a href='https://github.com/TencentARC/GFPGAN' target='_blank'><b>GFPGAN: Towards Real-World Blind Face Restoration with Generative Facial Prior</b></a>.
+<br>Restore your <b>old photos</b> or improve <b>AI-generated faces</b>. Upload an image to start.
+<br>If helpful, please ⭐ the <a href='https://github.com/TencentARC/GFPGAN' target='_blank'>Original Github Repo</a>.
+<br>API endpoint available at `/predict`. Expects image filepath, version string, scale number. Returns Image and Textbox data.
+"""
+article = "Questions? Contact the original creators (see GFPGAN repo)."
+
+print("Creating Gradio interface...")
 try:
-    logging.info(f"Downloading base model: {flux_model_id}")
-    model_path = snapshot_download(
-        repo_id=flux_model_id,
-        repo_type="model",
-        local_dir=local_model_dir,
-        ignore_patterns=["*.md", "*.gitattributes"],
-    )
-    logging.info(f"Downloaded base model to: {model_path}")
-
-    logging.info(f"Loading ControlNet: {controlnet_model_id}")
-    controlnet = FluxControlNetModel.from_pretrained(
-        controlnet_model_id,
-        torch_dtype=torch_dtype
-    ).to(device)
-    logging.info("ControlNet loaded.")
-
-    logging.info("Initializing FluxControlNetPipeline…")
-    pipe = FluxControlNetPipeline.from_pretrained(
-        model_path,
-        controlnet=controlnet,
-        torch_dtype=torch_dtype
-    ).to(device)
-    logging.info("Pipeline ready.")
+    # --- MODIFIED INPUTS ---
+    # Changed gr.Image type to 'filepath'
+    inputs = [
+        gr.Image(type="filepath", label="Input Image", sources=["upload", "clipboard"]), # <-- TYPE CHANGED
+        gr.Radio(
+            ['v1.2', 'v1.3', 'v1.4', 'RestoreFormer'],
+            type="value", value='v1.4', label='GFPGAN Version',
+            info="v1.4 recommended. RestoreFormer for diverse poses."
+        ),
+        gr.Number(
+            label="Rescaling Factor", value=2,
+            info="Final output size multiplier relative to original input size (e.g., 2 = 2x original WxH)."
+        ),
+    ]
 
-except Exception as e:
-    logging.error(f"Error loading models: {e}", exc_info=True)
-    print(f"FATAL: could not load models: {e}")
-    sys.exit(1)
+    # --- MODIFIED OUTPUTS ---
+    # Removed gr.File, kept gr.Image and gr.Textbox
+    # Made Textbox visible for easier debugging
+    outputs = [
+        gr.Image(type="pil", label="Output Image"),
+        # gr.File(label="Download Output Image (Server Path)"), # <-- REMOVED
+        gr.Textbox(label="Output Info / Base64 Data", interactive=False, visible=True) # <-- KEPT (made visible)
+    ]
 
-# --- Constants & Helpers ---
-MAX_SEED = 2**32 - 1
-MAX_PIXEL_BUDGET = 1280 * 1280
-INTERNAL_PROCESSING_FACTOR = 4
-
-def process_input(input_image):
-    if input_image is None:
-        raise gr.Error("No input image provided!")
-    img = ImageOps.exif_transpose(input_image)
-    if img.mode != "RGB":
-        img = img.convert("RGB")
-    w, h = img.size
-
-    # enforce intermediate‐scale budget
-    target_px = (w*INTERNAL_PROCESSING_FACTOR)*(h*INTERNAL_PROCESSING_FACTOR)
-    if target_px > MAX_PIXEL_BUDGET:
-        max_in = MAX_PIXEL_BUDGET / (INTERNAL_PROCESSING_FACTOR**2)
-        scale = (max_in / (w*h))**0.5
-        w2, h2 = max(8,int(w*scale)), max(8,int(h*scale))
-        img = img.resize((w2,h2), Image.Resampling.LANCZOS)
-        was_resized = True
-    else:
-        was_resized = False
-
-    # round dimensions to multiples of 8
-    w2, h2 = img.size
-    w2 -= w2 % 8; h2 -= h2 % 8
-    if img.size != (w2,h2):
-        img = img.resize((w2,h2), Image.Resampling.LANCZOS)
-
-    return img, w, h, was_resized
-
-@spaces.GPU(duration=75)
-def infer(
-    seed,
-    randomize_seed,
-    input_image,
-    num_inference_steps,
-    final_upscale_factor,
-    controlnet_conditioning_scale,
-    progress=gr.Progress(track_tqdm=True),
-):
-    global pipe
-    if pipe is None:
-        raise gr.Error("Pipeline not loaded.")
-
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    seed = int(seed)
-    final_upscale_factor = int(final_upscale_factor)
-
-    processed, w0, h0, resized_flag = process_input(input_image)
-    w_proc, h_proc = processed.size
-
-    # prepare control image at INTERNAL scale
-    cw, ch = w_proc*INTERNAL_PROCESSING_FACTOR, h_proc*INTERNAL_PROCESSING_FACTOR
-    control_img = processed.resize((cw, ch), Image.Resampling.LANCZOS)
-
-    gen = torch.Generator(device=device).manual_seed(seed)
-    with torch.inference_mode():
-        result = pipe(
-            prompt="",
-            control_image=control_img,
-            controlnet_conditioning_scale=float(controlnet_conditioning_scale),
-            num_inference_steps=int(num_inference_steps),
-            guidance_scale=0.0,
-            height=ch, width=cw,
-            generator=gen
-        ).images[0]
-
-    # final resize to user factor
-    if resized_flag:
-        fw, fh = w_proc*final_upscale_factor, h_proc*final_upscale_factor
-    else:
-        fw, fh = w0*final_upscale_factor, h0*final_upscale_factor
-    if (fw, fh) != result.size:
-        result = result.resize((fw, fh), Image.Resampling.LANCZOS)
-
-    buf = io.BytesIO()
-    result.save(buf, format="WEBP", quality=90)
-    b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
-
-    return [[input_image, result], seed, f"data:image/webp;base64,{b64}"]
-
-# --- Gradio UI ---
-with gr.Blocks(css=css, theme=gr.themes.Soft(), title="Flux Upscaler Demo") as demo:
-    gr.Markdown(f"""
-    # ⚡ Flux.1‑dev Upscaler  
-    **Device:** {power_device} · **Internal scale:** {INTERNAL_PROCESSING_FACTOR}x · **Budget:** {MAX_PIXEL_BUDGET} px  
-    """)
-    with gr.Row():
-        with gr.Column(scale=2):
-            inp = gr.Image(label="Input Image", type="pil", sources=["upload","clipboard"], height=350)
-        with gr.Column(scale=1):
-            upf   = gr.Slider("Final Upscale Factor", 1, INTERNAL_PROCESSING_FACTOR, step=1, value=2)
-            steps = gr.Slider("Inference Steps", 4, 50, step=1, value=15)
-            cscale= gr.Slider("ControlNet Scale", 0.0, 1.5, step=0.05, value=0.6)
-            with gr.Row():
-                sld = gr.Slider("Seed", 0, MAX_SEED, step=1, value=42)
-                rnd = gr.Checkbox("Randomize", value=True, scale=0, min_width=80)
-            btn = gr.Button("⚡ Upscale Image", variant="primary")
-
-    slider = ImageSlider("Input / Output", type="pil", interactive=False, show_label=True, position=0.5)
-    out_seed= gr.Textbox("Seed Used", interactive=False, visible=True)
-    out_b64 = gr.Textbox("API Base64 Output", interactive=False, visible=False)
-
-    btn.click(
-        fn=infer,
-        inputs=[sld, rnd, inp, steps, upf, cscale],
-        outputs=[slider, out_seed, out_b64],
-        api_name="upscale"
+    # Define examples using file paths (Gradio handles loading them)
+    # These should still work even with type="filepath" for the input component
+    examples = [
+        ['AI-generate.jpg', 'v1.4', 2],
+        ['lincoln.jpg', 'v1.4', 2],
+        ['Blake_Lively.jpg', 'v1.4', 2],
+        ['10045.png', 'v1.4', 2]
+    ]
+
+    # --- Gradio Interface Instantiation ---
+    # Ensure fn=inference points to the modified function
+    demo = gr.Interface(
+        fn=inference, # Should now accept filepath and return 2 items
+        inputs=inputs, # Use modified inputs list
+        outputs=outputs, # Use modified outputs list
+        title=title,
+        description=description,
+        article=article,
+        examples=examples,
+        cache_examples=False, # Caching might be complex with filepaths vs PIL
+        allow_flagging='never'
     )
 
-# Expose JSON API at /run/upscale
-demo.queue(max_size=10).launch(share=False, show_api=True)
+    # Launch the interface
+    print("Launching Gradio interface...")
+    demo.queue().launch(server_name="0.0.0.0", share=False)
+    print("Gradio app launched successfully and should be accessible.")
+
+except Exception as e:
+    print(f"Error setting up or launching Gradio interface: {e}")
+    print(traceback.format_exc())
+    sys.exit(1)