Upload 5 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+.gradio
+__pycache__

README.md

@@ -1,14 +1,15 @@
----
-title: HiDream O1 Image
-emoji: 🐢
-colorFrom: purple
-colorTo: gray
-sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: HiDream O1 Image
+emoji: 🚀
+colorFrom: yellow
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.23.3
+app_file: app.py
+pinned: false
+license: mit
+models:
+- HiDream-ai/HiDream-O1-Image
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,871 @@
+import logging
+import os
+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))
+
+# 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"
+)
+
+
+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):
+    """
+    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")
+
+    Returns:
+        str: Task ID
+
+    Raises:
+        APIError: If the API request fails
+    """
+    logger.info(
+        f"Starting create_request with prompt='{prompt[:50]}...', wh_ratio={wh_ratio}"
+    )
+
+    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)}")
+
+    model_params = {
+        "prompt": prompt,
+        "wh_ratio": wh_ratio,
+        "model_id": MODEL_ID,
+        "n": 1,
+    }
+
+    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")
+
+    url = _build_result_url(task_id)
+
+    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
+
+    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;
+}
+
+/* Header — two-column: title left, intro + links right. Compact so the whole
+   form + image fit on one screen without scrolling. */
+#app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 40px;
+    padding: 28px 8px 18px 8px;
+}
+.header-left { flex-shrink: 0; }
+.header-left h1 {
+    font-size: 46px;
+    font-weight: 700;
+    letter-spacing: -0.025em;
+    margin: 0;
+    /* line-height needs headroom for descenders (g/p/y) — at 1.0 the gradient
+       text mask clips them. 1.2 gives clean rendering without adding extra
+       visual whitespace because the H1 has no following sibling. */
+    line-height: 1.2;
+    padding-bottom: 2px;
+    /* Apple-Intelligence-style gradient: system blue → indigo → purple → pink.
+       Background is animated very slowly for a subtle "alive" feel. */
+    background: linear-gradient(
+        120deg,
+        #0071e3 0%,
+        #5e5ce6 35%,
+        #af52de 70%,
+        #ff375f 100%
+    );
+    background-size: 200% 200%;
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    animation: title-shimmer 12s ease-in-out infinite;
+}
+@keyframes title-shimmer {
+    0%, 100% { background-position: 0% 50%; }
+    50%      { background-position: 100% 50%; }
+}
+.header-right {
+    flex: 1;
+    text-align: right;
+    max-width: 640px;
+}
+.header-right .subtitle {
+    color: #6e6e73;
+    font-size: 15px;
+    font-weight: 400;
+    line-height: 1.5;
+    margin: 0 0 10px 0;
+}
+.header-right .links {
+    display: flex;
+    justify-content: flex-end;
+    gap: 22px;
+    flex-wrap: wrap;
+    font-size: 13px;
+}
+.header-right .links a {
+    color: #0071e3;
+    text-decoration: none;
+    font-weight: 500;
+    transition: opacity 0.15s ease;
+}
+.header-right .links a:hover { opacity: 0.7; }
+
+@media (max-width: 820px) {
+    #app-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 14px;
+        padding: 24px 8px 14px 8px;
+    }
+    .header-right { text-align: left; max-width: none; }
+    .header-right .links { justify-content: flex-start; }
+}
+
+/* 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;
+}
+
+/* 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;
+}
+.tagline a:hover { opacity: 0.7; }
+
+/* Hide gradio's default footer for a cleaner look */
+footer { display: none !important; }
+
+/* Mobile */
+@media (max-width: 640px) {
+    #app-header { padding: 32px 16px 16px 16px; }
+    #app-header h1 { font-size: 32px; }
+    #app-header p.subtitle { font-size: 15px; }
+}
+"""
+
+
+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 create_ui():
+    logger.info("Creating Gradio UI")
+    with gr.Blocks(
+        title="HiDream-O1-Image Generator",
+        theme=APPLE_THEME,
+        css=APPLE_CSS,
+    ) as demo:
+        gr.HTML(
+            """
+            <div id="app-header">
+                <div class="header-left">
+                    <h1>HiDream-O1-Image</h1>
+                </div>
+                <div class="header-right">
+                    <p class="subtitle">A natively unified pixel-space image generative model.</p>
+                    <div class="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>
+            </div>
+            """
+        )
+
+        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,
+                )
+
+                wh_ratio = gr.Dropdown(
+                    choices=WH_RATIO_OPTIONS,
+                    value=WH_RATIO_OPTIONS[0],
+                    label="Aspect Ratio",
+                    info="Width : Height",
+                )
+
+                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):
+            logger.info(
+                f"Starting image generation with prompt='{(prompt or '')[:50]}...', wh_ratio={wh_ratio_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
+
+                logger.info("Creating API request")
+                task_id = create_request(prompt, wh_ratio_value)
+                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")
+
+        generate_btn.click(
+            fn=generate_with_status,
+            inputs=[prompt, wh_ratio],
+            outputs=[output_image, status_msg],
+            show_progress="hidden",
+        )
+
+        def clear_outputs():
+            logger.info("Clearing UI outputs")
+            return None, _status_html("Ready", "info")
+
+        clear_btn.click(
+            fn=clear_outputs,
+            inputs=None,
+            outputs=[output_image, status_msg],
+        )
+
+        gr.HTML(
+            """
+            <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")

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+requests>=2.28.0
+Pillow>=9.0.0
+python-dotenv>=1.0.0
+numpy>=1.22.0
+tqdm>=4.65.0