Update app.py

app.py

@@ -1,1291 +1,34 @@
-import logging
-import os
-import random
-import time
-import traceback
-from io import BytesIO
-
 import gradio as gr
 import requests
 from PIL import Image
-from dotenv import load_dotenv
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-load_dotenv()
-
-# API Configuration (new style: host + gen_image_path)
-API_TOKEN = os.environ.get("token")
-API_HOST = os.environ.get("host")
-GEN_IMAGE_PATH = os.environ.get("gen_image_path")
-MODEL_ID = os.environ.get("model_id")
-
-# Polling / retry configuration (with sensible defaults)
-MAX_RETRY_COUNT = int(os.environ.get("MAX_RETRY_COUNT", 3))
-POLL_INTERVAL = float(os.environ.get("POLL_INTERVAL", 2.0))
-MAX_POLL_TIME = int(os.environ.get("MAX_POLL_TIME", 300))
-
-# Local-only test mode: skip the real API and return a random-colored image after
-# a randomised delay. Useful for testing the UI / queueing flow without burning
-# real model credits. Enable with FAKE_TEST=1 (also accepts "true"/"yes").
-FAKE_TEST = os.environ.get("FAKE_TEST", "").strip().lower() in ("1", "true", "yes", "on")
-
-# Predefined aspect ratios (wh_ratio) — kept in the same order as the original
-# (width, height) list so each entry mirrors the previous resolution choice:
-#   1:1  ←→ 2048×2048   4:3  ←→ 2304×1728   3:4  ←→ 1728×2304
-#  16:9  ←→ 2560×1440   9:16 ←→ 1440×2560   3:2  ←→ 2496×1664
-#   2:3  ←→ 1664×2496  21:9  ←→ 3104×1312   9:21 ←→ 1312×3104
-#   9:7  ←→ 2304×1792   7:9  ←→ 1792×2304
-WH_RATIO_OPTIONS = [
-    "1:1",
-    "4:3",
-    "3:4",
-    "16:9",
-    "9:16",
-    "3:2",
-    "2:3",
-    "21:9",
-    "9:21",
-    "9:7",
-    "7:9",
-]
-
-logger.info(
-    f"API configuration loaded: HOST={API_HOST}, GEN_IMAGE_PATH={GEN_IMAGE_PATH}, MODEL_ID={MODEL_ID}"
-)
-logger.info(
-    f"Retry configuration: MAX_RETRY_COUNT={MAX_RETRY_COUNT}, POLL_INTERVAL={POLL_INTERVAL}s, MAX_POLL_TIME={MAX_POLL_TIME}s"
-)
-if FAKE_TEST:
-    logger.warning("FAKE_TEST mode is ENABLED — no real API calls will be made.")
-
-
-class APIError(Exception):
-    """Custom exception for API-related errors"""
-    pass
-
-
-# Status codes returned by the API
-SUCCESS_CODE = 0
-
-
-def _build_request_url() -> str:
-    if not API_HOST or not GEN_IMAGE_PATH:
-        raise APIError("API host or gen_image_path is not configured. Please set the 'host' and 'gen_image_path' environment variables.")
-    return f"{API_HOST.rstrip('/')}{GEN_IMAGE_PATH}"
-
-
-def _build_result_url(task_id: str) -> str:
-    return f"{_build_request_url()}/results?task_id={task_id}"
-
-
-def _headers() -> dict:
-    if not API_TOKEN:
-        raise APIError("API token is not configured. Please set the 'token' environment variable.")
-    return {"Authorization": f"Bearer {API_TOKEN}"}
-
-
-def create_request(
-    prompt,
-    wh_ratio,
-    negative_prompt="",
-    enable_prompt_refine=True,
-    seed=-1,
-    guidance_scale=5.0,
-):
-    """
-    Submit an image generation request to the API.
-
-    Args:
-        prompt (str): Text prompt describing the image to generate
-        wh_ratio (str): Aspect ratio for the output image (e.g. "16:9")
-        negative_prompt (str): Optional text describing what to avoid.
-        enable_prompt_refine (bool): Whether to let the backend rewrite/expand
-            the prompt before generation. Sent to the API as 0 / 1.
-        seed (int): Generation seed. -1 means the backend will pick one
-            randomly; any other integer fixes the seed for reproducible runs.
-        guidance_scale (float): Classifier-free guidance strength. Higher
-            values follow the prompt more strictly.
-
-    Returns:
-        str: Task ID
-
-    Raises:
-        APIError: If the API request fails
-    """
-    logger.info(
-        f"Starting create_request with prompt='{prompt[:50]}...', "
-        f"wh_ratio={wh_ratio}, enable_prompt_refine={enable_prompt_refine}, "
-        f"seed={seed}, guidance_scale={guidance_scale}, "
-        f"negative_prompt='{(negative_prompt or '')[:30]}...'"
-    )
-
-    if not prompt or not prompt.strip():
-        logger.error("Empty prompt provided to create_request")
-        raise ValueError("Prompt cannot be empty")
-
-    if not wh_ratio or not isinstance(wh_ratio, str) or wh_ratio not in WH_RATIO_OPTIONS:
-        logger.error(f"Invalid wh_ratio: {wh_ratio}. Valid options: {WH_RATIO_OPTIONS}")
-        raise ValueError(f"Invalid aspect ratio. Must be one of: {', '.join(WH_RATIO_OPTIONS)}")
-
-    try:
-        seed_int = int(seed)
-    except (TypeError, ValueError):
-        logger.warning(f"Invalid seed value '{seed}', falling back to -1 (random)")
-        seed_int = -1
-
-    try:
-        guidance_scale_f = float(guidance_scale)
-    except (TypeError, ValueError):
-        logger.warning(f"Invalid guidance_scale '{guidance_scale}', falling back to 5.0")
-        guidance_scale_f = 5.0
-
-    model_params = {
-        "prompt": prompt,
-        "wh_ratio": wh_ratio,
-        "model_id": MODEL_ID,
-        "n": 1,
-        "negative_prompt": negative_prompt or "",
-        "enable_prompt_refine": 1 if enable_prompt_refine else 0,
-        "seed": seed_int,
-        "guidance_scale": guidance_scale_f,
-    }
-
-    url = _build_request_url()
-
-    retry_count = 0
-    while retry_count < MAX_RETRY_COUNT:
-        try:
-            logger.info(
-                f"Sending API request [attempt {retry_count + 1}/{MAX_RETRY_COUNT}] for prompt: '{prompt[:50]}...'"
-            )
-            response = requests.post(url, json=model_params, headers=_headers(), timeout=15)
-            logger.info(f"API request response status: {response.status_code}")
-            response.raise_for_status()
-
-            response_json = response.json()
-            code = response_json.get("code")
-            message = response_json.get("message", "")
-            if code != SUCCESS_CODE:
-                logger.error(f"API returned error code {code}: {message}")
-                raise APIError(f"Failed to submit task (code={code}): {message}")
-
-            task_id = response_json.get("result", {}).get("task_id")
-            if not task_id:
-                logger.error(f"No task ID in API response: {response_json}")
-                raise APIError(f"No task ID returned from API: {response_json}")
-
-            logger.info(f"Successfully created task with ID: {task_id}")
-            return task_id
-
-        except requests.exceptions.Timeout:
-            retry_count += 1
-            logger.warning(f"Request timed out. Retrying ({retry_count}/{MAX_RETRY_COUNT})...")
-            time.sleep(1)
-
-        except requests.exceptions.HTTPError as e:
-            status_code = e.response.status_code
-            error_message = f"HTTP error {status_code}"
-            try:
-                error_detail = e.response.json()
-                error_message += f": {error_detail}"
-                logger.error(f"API response error content: {error_detail}")
-            except Exception:
-                logger.error(f"Could not parse API error response as JSON. Raw content: {e.response.content[:500]}")
-
-            if status_code == 401:
-                logger.error(f"Authentication failed with API token. Status code: {status_code}")
-                raise APIError("Authentication failed. Please check your API token.")
-            elif status_code == 429:
-                retry_count += 1
-                wait_time = min(2 ** retry_count, 10)
-                logger.warning(f"Rate limit exceeded. Waiting {wait_time}s before retry ({retry_count}/{MAX_RETRY_COUNT})...")
-                time.sleep(wait_time)
-            elif 400 <= status_code < 500:
-                logger.error(f"Client error: {error_message}, Prompt: '{prompt[:50]}...', Status: {status_code}")
-                raise APIError(error_message)
-            else:
-                retry_count += 1
-                logger.warning(f"Server error: {error_message}. Retrying ({retry_count}/{MAX_RETRY_COUNT})...")
-                time.sleep(1)
-
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Request error: {str(e)}")
-            logger.debug(f"Request error details: {traceback.format_exc()}")
-            raise APIError(f"Failed to connect to API: {str(e)}")
-
-        except APIError:
-            raise
-
-        except Exception as e:
-            logger.error(f"Unexpected error in create_request: {str(e)}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise APIError(f"Unexpected error: {str(e)}")
-
-    logger.error(f"Failed to create request after {MAX_RETRY_COUNT} retries for prompt: '{prompt[:50]}...'")
-    raise APIError(f"Failed after {MAX_RETRY_COUNT} retries")
-
-
-def get_results(task_id):
-    """
-    Check the status of an image generation task.
-
-    Args:
-        task_id (str): The task ID to check
-
-    Returns:
-        dict: Task result information (the "result" object from the response), or None on transient failure.
-
-    Raises:
-        APIError: For unrecoverable errors (e.g. authentication failure).
-    """
-    logger.debug(f"Checking status for task ID: {task_id}")
-
-    if not task_id:
-        logger.error("Empty task ID provided to get_results")
-        raise ValueError("Task ID cannot be empty")
+from io import BytesIO
 
-    url = _build_result_url(task_id)
+print("✅ Glowmation API Server Booting up! (Dev: Rahul Terpathi)")
 
+def generate_image(prompt):
+    if not prompt: return None
     try:
-        response = requests.get(url, headers=_headers(), timeout=10)
-        logger.debug(f"Status check response code: {response.status_code}")
-        response.raise_for_status()
-        response_json = response.json()
-
-        code = response_json.get("code")
-        message = response_json.get("message", "")
-        if code != SUCCESS_CODE:
-            logger.warning(f"API returned non-success code {code} for task {task_id}: {message}")
-            return None
-
-        return response_json.get("result")
-
-    except requests.exceptions.Timeout:
-        logger.warning(f"Request timed out when checking task {task_id}")
-        return None
-
-    except requests.exceptions.HTTPError as e:
-        status_code = e.response.status_code
-        logger.warning(f"HTTP error {status_code} when checking task {task_id}")
-        try:
-            error_content = e.response.json()
-            logger.error(f"Error response content: {error_content}")
-        except Exception:
-            logger.error(f"Could not parse error response as JSON. Raw content: {e.response.content[:500]}")
-
-        if status_code == 401:
-            logger.error(f"Authentication failed when checking task {task_id}")
-            raise APIError(f"Authentication failed. Please check your API token when checking task {task_id}")
-        elif 400 <= status_code < 500:
-            logger.error(f"Client error {status_code} when checking task {task_id}")
-            return None
-        else:
-            logger.warning(f"Server error {status_code} when checking task {task_id}")
-            return None
-
-    except requests.exceptions.RequestException as e:
-        logger.warning(f"Network error when checking task {task_id}: {str(e)}")
-        logger.debug(f"Network error details: {traceback.format_exc()}")
-        return None
-
+        # Hugging Face ke backend se unlimited call jaayegi (Koi ad-blocker nahi rok payega)
+        safe_prompt = prompt.replace(" ", "%20")
+        url = f"https://image.pollinations.ai/prompt/{safe_prompt}?width=1024&height=1024&nologo=true"
+        
+        response = requests.get(url)
+        image = Image.open(BytesIO(response.content))
+        return image
     except Exception as e:
-        logger.error(f"Unexpected error when checking task {task_id}: {str(e)}")
-        logger.error(f"Full traceback: {traceback.format_exc()}")
         return None
 
-
-def download_image(image_url):
-    """
-    Download an image from a URL and return it as a PIL Image.
-    Converts non-PNG formats (e.g. WebP) to PNG while preserving original metadata.
-    """
-    logger.info(f"Starting download_image from URL: {image_url}")
-
-    if not image_url:
-        logger.error("Empty image URL provided to download_image")
-        raise ValueError("Image URL cannot be empty when downloading image")
-
-    retry_count = 0
-    while retry_count < MAX_RETRY_COUNT:
-        try:
-            logger.info(f"Downloading image [attempt {retry_count + 1}/{MAX_RETRY_COUNT}] from {image_url}")
-            response = requests.get(image_url, timeout=30)
-            logger.debug(
-                f"Image download response status: {response.status_code}, "
-                f"Content-Type: {response.headers.get('Content-Type')}, "
-                f"Content-Length: {response.headers.get('Content-Length')}"
-            )
-            response.raise_for_status()
-
-            image = Image.open(BytesIO(response.content))
-            logger.info(
-                f"Image opened successfully. Format: {image.format}, "
-                f"Size: {image.size[0]}x{image.size[1]}, Mode: {image.mode}"
-            )
-
-            original_metadata = {}
-            for key, value in image.info.items():
-                if isinstance(key, str) and isinstance(value, str):
-                    original_metadata[key] = value
-            logger.debug(f"Original image metadata: {original_metadata}")
-
-            if image.format != 'PNG':
-                logger.info(f"Converting image from {image.format} to PNG format")
-                png_buffer = BytesIO()
-                if 'A' in image.getbands():
-                    image_to_save = image
-                else:
-                    image_to_save = image.convert('RGB')
-                image_to_save.save(png_buffer, format='PNG')
-                png_buffer.seek(0)
-                image = Image.open(png_buffer)
-                for key, value in original_metadata.items():
-                    image.info[key] = value
-
-            logger.info(f"Successfully downloaded and processed image: {image.size[0]}x{image.size[1]}")
-            return image
-
-        except requests.exceptions.Timeout:
-            retry_count += 1
-            logger.warning(f"Download timed out. Retrying ({retry_count}/{MAX_RETRY_COUNT})...")
-            time.sleep(1)
-
-        except requests.exceptions.HTTPError as e:
-            status_code = e.response.status_code
-            logger.error(f"HTTP error {status_code} when downloading image from {image_url}")
-            if 400 <= status_code < 500:
-                raise APIError(f"HTTP error {status_code} when downloading image")
-            else:
-                retry_count += 1
-                time.sleep(1)
-
-        except requests.exceptions.RequestException as e:
-            retry_count += 1
-            logger.warning(f"Network error during image download: {str(e)}. Retrying ({retry_count}/{MAX_RETRY_COUNT})...")
-            time.sleep(1)
-
-        except Exception as e:
-            logger.error(f"Error processing image from {image_url}: {str(e)}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise APIError(f"Failed to process image: {str(e)}")
-
-    logger.error(f"Failed to download image from {image_url} after {MAX_RETRY_COUNT} retries")
-    raise APIError(f"Failed to download image after {MAX_RETRY_COUNT} retries")
-
-
-APPLE_CSS = """
-/* ---- Apple-inspired minimalist UI ---- */
-.gradio-container {
-    font-family: -apple-system, BlinkMacSystemFont, "SF Pro Display", "SF Pro Text",
-                 "Helvetica Neue", "Segoe UI", Inter, sans-serif !important;
-    background: linear-gradient(180deg, #fbfbfd 0%, #f5f5f7 100%) !important;
-    /* Always use ~3/4 of the viewport, capped at 1600px on huge screens.
-       Using width AND max-width ensures the page is wide from first paint
-       instead of growing only after content loads. */
-    width: min(1600px, 92vw) !important;
-    max-width: 1600px !important;
-    margin: 0 auto !important;
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-    color: #1d1d1f !important;
-}
-
-/* Cards / panels */
-.panel-card {
-    background: #ffffff !important;
-    border-radius: 18px !important;
-    padding: 18px !important;
-    box-shadow: 0 1px 2px rgba(0,0,0,0.04), 0 8px 28px rgba(0,0,0,0.05) !important;
-    border: 1px solid rgba(0,0,0,0.05) !important;
-}
-
-/* Inputs - rounded with apple-blue focus ring */
-textarea, input[type="text"], input[type="number"],
-.gradio-container .form input,
-.gradio-container .form textarea {
-    border-radius: 12px !important;
-    border: 1px solid #d2d2d7 !important;
-    background: #ffffff !important;
-    transition: border-color 0.15s ease, box-shadow 0.15s ease !important;
-    font-size: 15px !important;
-}
-textarea:focus, input:focus,
-.gradio-container .form input:focus,
-.gradio-container .form textarea:focus {
-    border-color: #0071e3 !important;
-    box-shadow: 0 0 0 4px rgba(0, 113, 227, 0.15) !important;
-    outline: none !important;
-}
-
-/* Dropdown */
-.gradio-container .wrap.svelte-1ipelgc { border-radius: 12px !important; }
-
-/* Block labels */
-.gradio-container span[data-testid="block-label"],
-.gradio-container .block-label,
-.gradio-container label > span {
-    color: #6e6e73 !important;
-    font-weight: 500 !important;
-    font-size: 13px !important;
-    letter-spacing: 0.01em;
-}
-
-/* Buttons - pill shape, Apple blue. Scoped to the variant classes so it does
-   NOT bleed into internal buttons inside dropdowns, accordions, etc. */
-.gradio-container button.primary,
-.gradio-container button.secondary {
-    border-radius: 980px !important;
-    font-weight: 500 !important;
-    font-size: 15px !important;
-    padding: 12px 22px !important;
-    transition: transform 0.08s ease, box-shadow 0.18s ease, background 0.18s ease, opacity 0.15s ease !important;
-    border: none !important;
-    letter-spacing: 0.01em;
-}
-.gradio-container button.primary {
-    background: #0071e3 !important;
-    color: #ffffff !important;
-    box-shadow: 0 1px 2px rgba(0,113,227,0.25), 0 6px 16px rgba(0,113,227,0.22) !important;
-}
-.gradio-container button.primary:hover {
-    background: #0077ed !important;
-    transform: translateY(-1px);
-    box-shadow: 0 2px 4px rgba(0,113,227,0.3), 0 10px 22px rgba(0,113,227,0.28) !important;
-}
-.gradio-container button.primary:active { transform: translateY(0); }
-.gradio-container button.secondary {
-    background: rgba(0,0,0,0.05) !important;
-    color: #1d1d1f !important;
-    box-shadow: none !important;
-}
-.gradio-container button.secondary:hover {
-    background: rgba(0,0,0,0.09) !important;
-}
-
-/* Make sure the dropdown's selected-value text never gets pill-clipped and
-   is properly aligned inside its rounded box. */
-.gradio-container .wrap-inner,
-.gradio-container .single-select,
-.gradio-container .secondary-wrap {
-    border-radius: 12px !important;
-}
-.gradio-container .single-select input,
-.gradio-container input[role="listbox"] {
-    border-radius: 12px !important;
-    padding: 10px 14px !important;
-    font-size: 15px !important;
-}
-
-/* Status pill */
-#status-bar {
-    padding: 0 !important;
-    margin-top: 6px;
-}
-.status-pill {
-    display: inline-flex;
-    align-items: center;
-    gap: 9px;
-    background: #f5f5f7;
-    color: #1d1d1f;
-    padding: 10px 14px;
-    border-radius: 12px;
-    font-size: 13px;
-    font-weight: 500;
-    line-height: 1;
-    border: 1px solid rgba(0,0,0,0.04);
-}
-.status-dot {
-    width: 8px;
-    height: 8px;
-    border-radius: 50%;
-    background: #8e8e93;
-    flex-shrink: 0;
-}
-.status-info .status-dot { background: #8e8e93; }
-.status-success { background: rgba(48,209,88,0.10); color: #0a7f2e; border-color: rgba(48,209,88,0.20); }
-.status-success .status-dot { background: #30d158; }
-.status-error   { background: rgba(255,59,48,0.10); color: #b8261b; border-color: rgba(255,59,48,0.20); }
-.status-error   .status-dot { background: #ff3b30; }
-.status-running { background: rgba(0,113,227,0.10); color: #0058b8; border-color: rgba(0,113,227,0.20); }
-.status-running .status-dot {
-    background: #0071e3;
-    animation: pulse 1.4s ease-in-out infinite;
-}
-@keyframes pulse {
-    0%, 100% { opacity: 0.4; transform: scale(0.85); }
-    50%      { opacity: 1.0; transform: scale(1.15); }
-}
-
-/* Image output frame — never crop the image; show full picture with letterbox. */
-.image-output {
-    border-radius: 18px !important;
-    background: #f5f5f7 !important;
-}
-.image-output,
-.image-output > div,
-.image-output [data-testid="image"],
-.image-output .image-container,
-.image-output .image-frame,
-.image-output .preview {
-    min-height: 440px !important;
-    display: flex !important;
-    align-items: center !important;
-    justify-content: center !important;
-}
-.image-output img {
-    border-radius: 14px !important;
-    object-fit: contain !important;
-    max-width: 100% !important;
-    max-height: 62vh !important;
-    width: auto !important;
-    height: auto !important;
-}
-
-/* Status pill placed inside the right column, above the image. */
-.right-status {
-    display: flex;
-    justify-content: flex-start;
-    margin-bottom: 6px;
-}
-
-/* Accordion */
-.gradio-container details {
-    border-radius: 14px !important;
-    border: 1px solid rgba(0,0,0,0.06) !important;
-    background: #ffffff !important;
-}
-
-/* Negative prompt — softer accent so it visually de-emphasises vs. the main prompt */
-.negative-prompt textarea {
-    background: #fbfbfd !important;
-    border-color: #e3e3e8 !important;
-}
-.negative-prompt textarea:focus {
-    background: #ffffff !important;
-}
-
-/* Advanced options row — keeps the refine switch + seed input visually paired */
-.advanced-row {
-    gap: 14px !important;
-    margin-top: 2px;
-}
-
-/* Refine toggle — iOS-style settings card.
-   Goal: title + helper text on the left, a polished pill switch on the right,
-   everything contained inside a single soft card so the helper text no longer
-   floats orphaned above the box. */
-.refine-toggle {
-    background: linear-gradient(180deg, #ffffff 0%, #f5f5f7 100%) !important;
-    border-radius: 14px !important;
-    border: 1px solid rgba(0,0,0,0.06) !important;
-    padding: 14px 16px !important;
-    box-shadow: 0 1px 2px rgba(0,0,0,0.03) !important;
-    transition: border-color 0.18s ease, box-shadow 0.18s ease !important;
-    min-height: 88px;
-    display: flex !important;
-    flex-direction: column !important;
-    justify-content: center !important;
-}
-.refine-toggle:hover {
-    border-color: rgba(0,0,0,0.10) !important;
-    box-shadow: 0 1px 2px rgba(0,0,0,0.04), 0 4px 14px rgba(0,0,0,0.05) !important;
-}
-
-/* Strip default backgrounds from gradio's inner wrappers so only our card shows. */
-.refine-toggle .form,
-.refine-toggle .wrap,
-.refine-toggle .form-wrap,
-.refine-toggle > div {
-    background: transparent !important;
-    border: none !important;
-    padding: 0 !important;
-    margin: 0 !important;
-    box-shadow: none !important;
-}
-
-/* Helper / "info" text becomes a proper subtitle UNDER the toggle row. */
-.refine-toggle [data-testid="block-info"],
-.refine-toggle .info {
-    color: #6e6e73 !important;
-    font-size: 12px !important;
-    line-height: 1.4 !important;
-    margin: 8px 0 0 0 !important;
-    padding: 0 !important;
-    text-align: left !important;
-    order: 2 !important;
-}
-
-/* Force the gradio wrapper to stack: label-row first, info below. */
-.refine-toggle .form,
-.refine-toggle > div:not([data-testid="block-info"]):not(.info) {
-    display: flex !important;
-    flex-direction: column !important;
-    align-items: stretch !important;
-}
-
-/* Label row: title on the LEFT (full width), toggle pinned to the RIGHT. */
-.refine-toggle label {
-    display: flex !important;
-    align-items: center !important;
-    justify-content: space-between !important;
-    flex-direction: row-reverse !important;
-    cursor: pointer !important;
-    margin: 0 !important;
-    padding: 0 !important;
-    gap: 14px !important;
-    width: 100% !important;
-    order: 1 !important;
-}
-.refine-toggle label > span {
-    color: #1d1d1f !important;
-    font-size: 15px !important;
-    font-weight: 600 !important;
-    letter-spacing: -0.01em;
-    flex: 1 1 auto !important;
-    text-align: left !important;
-    line-height: 1.3 !important;
-}
-
-/* Pill switch — bigger, smoother, more "Apple-like" */
-.refine-toggle input[type="checkbox"] {
-    appearance: none;
-    -webkit-appearance: none;
-    width: 46px !important;
-    height: 28px !important;
-    border-radius: 999px !important;
-    background: #e5e5ea !important;
-    position: relative;
-    cursor: pointer;
-    transition: background 0.22s ease, box-shadow 0.22s ease;
-    border: none !important;
-    flex-shrink: 0 !important;
-    margin: 0 !important;
-    box-shadow: inset 0 0 1px rgba(0,0,0,0.06);
-}
-.refine-toggle input[type="checkbox"]::after {
-    content: "";
-    position: absolute;
-    top: 2px;
-    left: 2px;
-    width: 24px;
-    height: 24px;
-    border-radius: 50%;
-    background: #ffffff;
-    box-shadow: 0 2px 5px rgba(0,0,0,0.18), 0 0 1px rgba(0,0,0,0.05);
-    transition: transform 0.24s cubic-bezier(0.4, 0.0, 0.2, 1);
-}
-.refine-toggle input[type="checkbox"]:hover {
-    background: #dcdce0 !important;
-}
-.refine-toggle input[type="checkbox"]:checked {
-    background: #34c759 !important;
-}
-.refine-toggle input[type="checkbox"]:checked:hover {
-    background: #30b352 !important;
-}
-.refine-toggle input[type="checkbox"]:checked::after {
-    transform: translateX(18px);
-}
-.refine-toggle input[type="checkbox"]:focus-visible {
-    box-shadow: 0 0 0 4px rgba(0,113,227,0.20) !important;
-}
-.refine-toggle input[type="checkbox"]:active::after {
-    /* tiny squish on press, very iOS */
-    width: 28px;
-}
-.refine-toggle input[type="checkbox"]:checked:active::after {
-    transform: translateX(14px);
-}
-
-/* Seed number input — match the prompt/dropdown rounding */
-.seed-input input[type="number"] {
-    border-radius: 12px !important;
-    padding: 10px 14px !important;
-    font-variant-numeric: tabular-nums;
-}
-/* Hide the native spinner buttons on number inputs for a cleaner look */
-.seed-input input[type="number"]::-webkit-outer-spin-button,
-.seed-input input[type="number"]::-webkit-inner-spin-button {
-    -webkit-appearance: none;
-    margin: 0;
-}
-.seed-input input[type="number"] {
-    -moz-appearance: textfield;
-}
-/* Keep the seed column visually aligned with the refine card next to it */
-.seed-input {
-    align-self: stretch !important;
-}
-
-/* Guidance scale slider — Apple-blue track + softer thumb */
-.guidance-slider input[type="range"] {
-    accent-color: #0071e3 !important;
-}
-.guidance-slider .head { padding-top: 0 !important; }
-.guidance-slider {
-    margin-top: 4px;
-}
-
-/* Footer tagline */
-.tagline {
-    text-align: center;
-    color: #6e6e73;
-    font-size: 12px;
-    margin: 18px 0 14px 0;
-    font-weight: 400;
-}
-.tagline a {
-    color: #0071e3;
-    text-decoration: none;
-    font-weight: 500;
-    transition: opacity 0.15s ease;
-}
-.tagline a:hover { opacity: 0.7; }
-
-/* Footer links row (HuggingFace / GitHub / Twitter) */
-.footer-links {
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    gap: 26px;
-    flex-wrap: wrap;
-    font-size: 13px;
-    margin: 24px 0 6px 0;
-}
-/* When the vivago tagline follows the links row, tighten the gap. */
-.footer-links + .tagline {
-    margin-top: 4px;
-}
-
-/* Hide gradio's default footer for a cleaner look */
-footer { display: none !important; }
-
-/* Mobile */
-@media (max-width: 640px) {
-    .footer-links { gap: 18px; font-size: 12px; }
-}
-"""
-
-
-APPLE_THEME = gr.themes.Soft(
-    primary_hue=gr.themes.colors.blue,
-    neutral_hue=gr.themes.colors.slate,
-    radius_size=gr.themes.sizes.radius_lg,
-    text_size=gr.themes.sizes.text_md,
-    font=[
-        gr.themes.GoogleFont("Inter"),
-        "ui-sans-serif",
-        "-apple-system",
-        "BlinkMacSystemFont",
-        "Segoe UI",
-        "Helvetica Neue",
-        "sans-serif",
-    ],
-).set(
-    body_background_fill="*neutral_50",
-    block_background_fill="white",
-    block_border_width="1px",
-    block_label_text_weight="500",
-    block_title_text_weight="600",
-    button_primary_background_fill="#0071e3",
-    button_primary_background_fill_hover="#0077ed",
-    button_primary_text_color="white",
-    button_primary_border_color="#0071e3",
-    button_secondary_background_fill="rgba(0,0,0,0.05)",
-    button_secondary_background_fill_hover="rgba(0,0,0,0.09)",
-    button_secondary_text_color="#1d1d1f",
-    input_background_fill="white",
-    input_border_color="#d2d2d7",
-    input_border_color_focus="#0071e3",
-    input_shadow_focus="0 0 0 4px rgba(0,113,227,0.15)",
-)
-
-
-def _status_html(text: str, kind: str = "info") -> str:
-    """Render a styled status pill. kind: info | success | error | running"""
-    return (
-        f'<div class="status-pill status-{kind}">'
-        f'<span class="status-dot"></span>{text}'
-        f'</div>'
-    )
-
-
-def _queue_text(waiting: int, running: int) -> str:
-    """Inline status text describing the queue from the user's POV.
-
-    Used inside the right-side status pill while THIS user's request is
-    sitting in the queue waiting for an open slot.
-    """
-    if waiting <= 0 and running <= 0:
-        return "Queued · waiting for an open slot…"
-    parts = []
-    if waiting > 0:
-        parts.append(f"{waiting} waiting")
-    if running > 0:
-        parts.append(f"{running} generating")
-    return f"In queue · {' · '.join(parts)}"
-
-
-def _read_queue_stats(demo_obj) -> tuple[int, int, float]:
-    """Best-effort read of gradio's internal queue.
-
-    Gradio 5.x structure (gradio/queueing.py):
-      demo._queue.event_queue_per_concurrency_id: dict[str, EventQueue]
-        EventQueue.queue: list[Event]              ← actually-waiting events
-      demo._queue.active_jobs: list[None | list[Event]]
-        each slot is None (idle) or a list of currently-processing events.
-      demo._queue.process_time_per_fn: dict[BlockFunction, ProcessTime]
-        ProcessTime.avg_time: float
-
-    Returns (waiting, running, avg_secs). Each lookup is wrapped in a try
-    so the UI degrades gracefully ("idle") if Gradio ever renames a field.
-    """
-    try:
-        q = getattr(demo_obj, "_queue", None)
-        if q is None:
-            return 0, 0, 0.0
-
-        # ---- Waiting: events sitting in EventQueue.queue ----
-        waiting = 0
-        events_per_cid = getattr(q, "event_queue_per_concurrency_id", None) or {}
-        for ev_q in events_per_cid.values():
-            # Newer gradio: ev_q is an EventQueue with a .queue list.
-            # Older/alt: ev_q might already be a list. Handle both.
-            inner = getattr(ev_q, "queue", ev_q)
-            try:
-                waiting += len(inner)
-            except (TypeError, AttributeError):
-                # Last resort: try iterating
-                try:
-                    waiting += sum(1 for _ in inner)
-                except Exception:
-                    continue
-
-        # ---- Running: count events held in active_jobs slots ----
-        # Each slot is None or a list[Event]; sum the list lengths.
-        running = 0
-        active = getattr(q, "active_jobs", None) or []
-        for slot in active:
-            if slot is None:
-                continue
-            try:
-                running += len(slot)
-            except (TypeError, AttributeError):
-                running += 1  # very old gradio: single Event per slot
-
-        # ---- Average per-run time (best effort across versions) ----
-        avg_secs = 0.0
-        # Gradio 5.x: dict[BlockFunction, ProcessTime] with .avg_time
-        ptpf = getattr(q, "process_time_per_fn", None)
-        if isinstance(ptpf, dict) and ptpf:
-            try:
-                vals = []
-                for v in ptpf.values():
-                    avg_t = getattr(v, "avg_time", None)
-                    if avg_t:
-                        vals.append(float(avg_t))
-                if vals:
-                    avg_secs = sum(vals) / len(vals)
-            except Exception:
-                avg_secs = 0.0
-        # Older: dict[int, float]
-        if not avg_secs:
-            ptpfi = getattr(q, "process_time_per_fn_index", None)
-            if isinstance(ptpfi, dict) and ptpfi:
-                try:
-                    vals = [float(v) for v in ptpfi.values() if v]
-                    if vals:
-                        avg_secs = sum(vals) / len(vals)
-                except Exception:
-                    avg_secs = 0.0
-        # Oldest: single float on the queue
-        if not avg_secs:
-            apt = getattr(q, "avg_process_time", None)
-            if apt:
-                try:
-                    avg_secs = float(apt)
-                except Exception:
-                    avg_secs = 0.0
-
-        return waiting, running, avg_secs
-    except Exception as exc:
-        logger.debug(f"Queue introspection failed: {exc}")
-        return 0, 0, 0.0
-
-
-def _fake_generation_iter(prompt: str, wh_ratio_value: str):
-    """FAKE_TEST mode generator.
-
-    Mimics the real flow's yield protocol without hitting any external API.
-    Useful for exercising the queue UI / status pill locally.
-
-    Yields (image_or_None, status_html) tuples. The very first 'Sending
-    request to API…' yield is emitted by the caller, so this iterator picks
-    up from 'Request submitted' onwards.
-    """
-    time.sleep(random.uniform(0.4, 1.0))
-
-    fake_id = f"{random.randint(0, 0xFFFFFFFF):08x}"
-    yield None, _status_html(f"Request submitted · Task {fake_id}…", "running")
-
-    target_secs = random.uniform(8.0, 22.0)
-    start = time.time()
-    while time.time() - start < target_secs:
-        elapsed = int(time.time() - start)
-        yield None, _status_html(f"Generating… {elapsed}s", "running")
-        time.sleep(POLL_INTERVAL)
-
-    yield None, _status_html("Downloading image…", "running")
-    time.sleep(0.3)
-
-    rgb = (
-        random.randint(40, 220),
-        random.randint(40, 220),
-        random.randint(40, 220),
-    )
-    fake_image = Image.new("RGB", (1024, 1024), color=rgb)
-    logger.info(f"FAKE_TEST: returning random color image rgb={rgb}, took {target_secs:.1f}s")
-    yield fake_image, _status_html("Image generated", "success")
-
-
-def create_ui():
-    logger.info("Creating Gradio UI")
-    with gr.Blocks(
-        title="HiDream-O1-Image Generator",
-        theme=APPLE_THEME,
-        css=APPLE_CSS,
-    ) as demo:
-        # Per-session state used to drive the right-side status pill while
-        # this user's request is sitting in the queue. `last_pill_state`
-        # caches the most recent pill HTML so the timer can return
-        # `gr.update()` (=no-op, no DOM replacement → no flicker) when the
-        # queue counts haven't actually changed between ticks.
-        queued_state = gr.State(False)
-        last_pill_state = gr.State("")
-
-        with gr.Row(equal_height=False):
-            with gr.Column(scale=1, elem_classes=["panel-card"]):
-                prompt = gr.Textbox(
-                    label="Prompt",
-                    placeholder="Describe the image you want to create...",
-                    lines=5,
-                    show_label=True,
-                )
-
-                negative_prompt = gr.Textbox(
-                    label="Negative Prompt",
-                    placeholder="Things you want to avoid in the image (optional)...",
-                    lines=2,
-                    show_label=True,
-                    elem_classes=["negative-prompt"],
-                )
-
-                wh_ratio = gr.Dropdown(
-                    choices=WH_RATIO_OPTIONS,
-                    value=WH_RATIO_OPTIONS[0],
-                    label="Aspect Ratio",
-                    info="Width : Height",
-                )
-
-                guidance_scale = gr.Slider(
-                    minimum=1.0,
-                    maximum=20.0,
-                    step=0.1,
-                    value=5.0,
-                    label="Guidance Scale",
-                    info="Higher values follow the prompt more strictly",
-                    elem_classes=["guidance-slider"],
-                )
-
-                with gr.Row(elem_classes=["advanced-row"], equal_height=True):
-                    enable_prompt_refine = gr.Checkbox(
-                        value=True,
-                        label="Prompt Refine",
-                        info="Let the model rewrite & enrich your prompt",
-                        elem_classes=["refine-toggle"],
-                        scale=1,
-                    )
-                    seed = gr.Number(
-                        value=-1,
-                        label="Seed",
-                        info="Use -1 for a random seed",
-                        precision=0,
-                        minimum=-1,
-                        elem_classes=["seed-input"],
-                        scale=1,
-                    )
-
-                with gr.Row():
-                    clear_btn = gr.Button("Clear", variant="secondary", scale=1)
-                    generate_btn = gr.Button("Generate", variant="primary", scale=3)
-
-            with gr.Column(scale=1, elem_classes=["panel-card"]):
-                status_msg = gr.HTML(
-                    value=_status_html("Ready", "info"),
-                    elem_id="status-bar",
-                    elem_classes=["right-status"],
-                )
-                output_image = gr.Image(
-                    label="Generated Image",
-                    format="png",
-                    type="pil",
-                    interactive=False,
-                    show_download_button=True,
-                    elem_classes=["image-output"],
-                )
-
-        def generate_with_status(
-            prompt,
-            wh_ratio_value,
-            negative_prompt_value,
-            enable_prompt_refine_value,
-            seed_value,
-            guidance_scale_value,
-        ):
-            logger.info(
-                f"Starting image generation with prompt='{(prompt or '')[:50]}...', "
-                f"wh_ratio={wh_ratio_value}, "
-                f"negative_prompt='{(negative_prompt_value or '')[:30]}...', "
-                f"enable_prompt_refine={enable_prompt_refine_value}, "
-                f"seed={seed_value}, guidance_scale={guidance_scale_value}"
-            )
-
-            yield None, _status_html("Sending request to API…", "running")
-
-            try:
-                if not prompt or not prompt.strip():
-                    logger.error("Empty prompt provided in UI")
-                    yield None, _status_html("Prompt cannot be empty", "error")
-                    return
-
-                if wh_ratio_value not in WH_RATIO_OPTIONS:
-                    logger.error(f"Invalid aspect ratio selection: {wh_ratio_value}")
-                    yield None, _status_html(f"Invalid aspect ratio “{wh_ratio_value}”", "error")
-                    return
-
-                try:
-                    seed_int = int(seed_value) if seed_value is not None else -1
-                except (TypeError, ValueError):
-                    seed_int = -1
-
-                try:
-                    guidance_scale_f = float(guidance_scale_value) if guidance_scale_value is not None else 5.0
-                except (TypeError, ValueError):
-                    guidance_scale_f = 5.0
-
-                if FAKE_TEST:
-                    logger.info("FAKE_TEST mode active — bypassing real API call")
-                    yield from _fake_generation_iter(prompt, wh_ratio_value)
-                    return
-
-                logger.info("Creating API request")
-                task_id = create_request(
-                    prompt,
-                    wh_ratio_value,
-                    negative_prompt=negative_prompt_value or "",
-                    enable_prompt_refine=bool(enable_prompt_refine_value),
-                    seed=seed_int,
-                    guidance_scale=guidance_scale_f,
-                )
-                yield None, _status_html(f"Request submitted · Task {task_id[:8]}…", "running")
-
-                start_time = time.time()
-                logger.info(f"Starting to poll for results for task ID: {task_id}")
-
-                while time.time() - start_time < MAX_POLL_TIME:
-                    elapsed_time = time.time() - start_time
-                    logger.debug(
-                        f"Polling for results - Task ID: {task_id}, Elapsed: {elapsed_time:.2f}s"
-                    )
-
-                    result = get_results(task_id)
-                    if not result:
-                        time.sleep(POLL_INTERVAL)
-                        continue
-
-                    overall_status = result.get("status")
-                    sub_results = result.get("sub_task_results", []) or []
-
-                    if overall_status != 1:
-                        elapsed = int(time.time() - start_time)
-                        yield None, _status_html(f"Generating… {elapsed}s", "running")
-                        time.sleep(POLL_INTERVAL)
-                        continue
-
-                    if not sub_results:
-                        logger.error(f"Task completed but no sub_task_results returned. Task ID: {task_id}")
-                        yield None, _status_html("Task completed but no results returned", "error")
-                        return
-
-                    sub = sub_results[0]
-                    sub_status = sub.get("task_status")
-
-                    if sub_status == 1:
-                        logger.info(f"Task completed successfully - Task ID: {task_id}")
-
-                        image_url = sub.get("url")
-                        if not image_url:
-                            logger.error(f"No image URL in successful response. Sub result: {sub}")
-                            yield None, _status_html("No image URL in response", "error")
-                            return
-
-                        yield None, _status_html("Downloading image…", "running")
-
-                        logger.info(f"Downloading image - Task ID: {task_id}, URL: {image_url}")
-                        image = download_image(image_url)
-
-                        if image:
-                            logger.info(f"Image generation complete - Task ID: {task_id}")
-                            yield image, _status_html("Image generated", "success")
-                            return
-                        else:
-                            logger.error(f"Failed to download image - Task ID: {task_id}, URL: {image_url}")
-                            yield None, _status_html("Failed to download generated image", "error")
-                            return
-
-                    elif sub_status == 3:
-                        error_msg = sub.get("task_error") or sub.get("message") or "Unknown error"
-                        logger.error(
-                            f"Task failed - Task ID: {task_id}, Sub status: {sub_status}, Error: {error_msg}"
-                        )
-                        yield None, _status_html(f"Task failed: {error_msg}", "error")
-                        return
-
-                    else:
-                        elapsed = int(time.time() - start_time)
-                        yield None, _status_html(f"Waiting… {elapsed}s", "running")
-                        time.sleep(POLL_INTERVAL)
-
-                logger.error(
-                    f"Timeout waiting for task completion - Task ID: {task_id}, Max time: {MAX_POLL_TIME}s"
-                )
-                yield None, _status_html(f"Timed out after {MAX_POLL_TIME}s", "error")
-
-            except APIError as e:
-                logger.error(f"API Error during generation: {str(e)}")
-                yield None, _status_html(f"API error: {str(e)}", "error")
-
-            except ValueError as e:
-                logger.error(f"Value Error during generation: {str(e)}")
-                yield None, _status_html(f"Value error: {str(e)}", "error")
-
-            except Exception as e:
-                logger.error(f"Unexpected error during image generation: {str(e)}")
-                logger.error(f"Full traceback: {traceback.format_exc()}")
-                yield None, _status_html(f"Unexpected error: {str(e)}", "error")
-
-        def _enter_queue():
-            """Click handler #1 — runs IMMEDIATELY (queue=False).
-
-            Flips queued_state to True and seeds the pill with a snapshot of
-            the current queue. Subsequent live updates come from the timer.
-            """
-            waiting, running, _ = _read_queue_stats(demo)
-            html = _status_html(_queue_text(waiting, running), "running")
-            return None, html, True, html
-
-        def _generate_wrapped(
-            prompt_value,
-            wh_ratio_value,
-            negative_prompt_value,
-            enable_prompt_refine_value,
-            seed_value,
-            guidance_scale_value,
-        ):
-            """Click handler #2 — queued.
-
-            Wraps the existing generator and, on the FIRST yield, also flips
-            queued_state to False so the timer stops touching the pill and
-            lets the generator's own `yield`s drive it (Generating XXs → ...).
-            """
-            first = True
-            for image, status_html in generate_with_status(
-                prompt_value,
-                wh_ratio_value,
-                negative_prompt_value,
-                enable_prompt_refine_value,
-                seed_value,
-                guidance_scale_value,
-            ):
-                if first:
-                    first = False
-                    yield image, status_html, False
-                else:
-                    yield image, status_html, gr.update()
-
-        generate_btn.click(
-            fn=_enter_queue,
-            inputs=None,
-            outputs=[output_image, status_msg, queued_state, last_pill_state],
-            queue=False,
-            show_progress="hidden",
-        ).then(
-            fn=_generate_wrapped,
-            inputs=[prompt, wh_ratio, negative_prompt, enable_prompt_refine, seed, guidance_scale],
-            outputs=[output_image, status_msg, queued_state],
-            show_progress="minimal",
-            show_progress_on=[generate_btn],
-        )
-
-        def clear_outputs():
-            logger.info("Clearing UI outputs")
-            return None, _status_html("Ready", "info"), False, ""
-
-        clear_btn.click(
-            fn=clear_outputs,
-            inputs=None,
-            outputs=[output_image, status_msg, queued_state, last_pill_state],
-        )
-
-        # Live queue updates inside the right-side pill — only while THIS
-        # user is queued. Returns gr.update() (no-op) when nothing changed,
-        # which prevents the DOM from being replaced and avoids the pulse
-        # animation resetting (= no flicker).
-        pill_timer = gr.Timer(value=1.5, active=True)
-
-        def _tick_pill(queued_flag, last_html):
-            if not queued_flag:
-                return gr.update(), last_html
-            waiting, running, _ = _read_queue_stats(demo)
-            new_html = _status_html(_queue_text(waiting, running), "running")
-            if new_html == last_html:
-                return gr.update(), last_html
-            return new_html, new_html
-
-        pill_timer.tick(
-            fn=_tick_pill,
-            inputs=[queued_state, last_pill_state],
-            outputs=[status_msg, last_pill_state],
-            queue=False,
-            show_progress="hidden",
-        )
-
-        gr.HTML(
-            """
-            <div class="tagline footer-links">
-                <a href="https://huggingface.co/HiDream-ai/HiDream-O1-Image" target="_blank">HuggingFace</a>
-                <a href="https://github.com/HiDream-ai/HiDream-O1-Image" target="_blank">GitHub</a>
-                <a href="https://x.com/vivago_ai" target="_blank">Twitter</a>
-            </div>
-            <div class="tagline">
-                For more features and the full experience, visit
-                <a href="https://vivago.ai/" target="_blank">vivago.ai</a>.
-            </div>
-            """
-        )
-
-    logger.info("Gradio UI created successfully")
-    return demo
-
-
-if __name__ == "__main__":
-    logger.info("Starting HiDream-O1-Image Generator application")
-    demo = create_ui()
-    logger.info("Launching Gradio interface with queue")
-    demo.queue(max_size=50, default_concurrency_limit=4).launch(show_api=False)
-    logger.info("Application shutdown")
+# Clean Dark Mode API Interface
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# ⚙️ VoiceForge API Engine")
+    
+    with gr.Row():
+        inp = gr.Textbox(label="Input Prompt")
+        btn = gr.Button("Generate")
+    out = gr.Image(label="Output Image")
+    
+    # Ye api_name="generate" hi tere frontend se connect hoga
+    btn.click(fn=generate_image, inputs=inp, outputs=out, api_name="generate")
+
+demo.launch()
+