app.py first codeblocks

README.md

@@ -10,4 +10,54 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# UnReflectAnything – Gradio demo
+
+Remove specular reflections from images using the UnReflectAnything model.
+
+## Run locally
+
+From the **repository root** (parent of `gradio_space`):
+
+```bash
+# 1. Install the project and Gradio
+pip install -e .
+pip install "gradio>=4.0"
+
+# 2. Download weights (once)
+unreflect download --weights
+
+# 3. Run the Gradio app from the repo root so Python finds the package
+cd gradio_space && python app.py
+```
+
+Then open the URL shown in the terminal (e.g. http://127.0.0.1:7860).
+
+Alternatively, from `gradio_space` only (e.g. if the repo root is one level up):
+
+```bash
+cd gradio_space
+pip install -r requirements.txt   # installs gradio + parent package (-e ..)
+python app.py
+```
+
+Weights are downloaded automatically on first run if missing.
+
+## Run on Hugging Face Spaces
+
+1. Create a new Space, choose **Gradio** SDK, and set the **Root directory** to `gradio_space` (so the Space uses this folder as the app root).
+2. Push this repo (or the `gradio_space` folder and a way to install the parent package). The Space’s `requirements.txt` will run `pip install -e ..`, so the **full repo must be in the Space** (clone the whole repo and set root to `gradio_space`).
+3. On first run, the app will download weights to the Space cache.
+
+**To test the live Space:** open the Space URL (e.g. `https://huggingface.co/spaces/<your-username>/<space-name>`), upload an image, optionally adjust the brightness threshold, and click **Remove reflections**.
+
+**API / headless test:** use the “View API” link at the bottom of the Space page to get the Gradio API URL (e.g. `https://<space-name>.hf.space`), then call the `/predict` endpoint with your image, or use the Gradio client:
+
+```bash
+pip install gradio_client
+python -c "
+from gradio_client import Client
+client = Client('https://YOUR-USER-YOUR-SPACE.hf.space')
+result = client.predict('path/to/image.png', 0.8, api_name='/predict')  # adjust api_name if needed
+print(result)
+"
+```

app.py

@@ -0,0 +1,122 @@
+"""Gradio demo for UnReflectAnything: remove specular reflections from images."""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+
+# Allow importing unreflectanything when run from gradio_space (e.g. HF Space with root dir)
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+if _REPO_ROOT not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+import gradio as gr
+import numpy as np
+import torch
+
+
+def _ensure_weights():
+    """Download weights to cache if not present."""
+    from unreflectanything import download
+    from unreflectanything._shared import DEFAULT_WEIGHTS_FILENAME, get_cache_dir
+
+    weights_dir = get_cache_dir("weights")
+    if not (weights_dir / DEFAULT_WEIGHTS_FILENAME).exists():
+        download("weights")
+
+
+def run_inference(
+    image: np.ndarray | None,
+    brightness_threshold: float,
+) -> np.ndarray | None:
+    """Run reflection removal on a single image. Returns RGB numpy [H,W,3] in 0–255 or None."""
+    if image is None:
+        return None
+    from unreflectanything import inference
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    with tempfile.TemporaryDirectory() as tmpdir:
+        inp_path = Path(tmpdir) / "input.png"
+        out_path = Path(tmpdir) / "output.png"
+        # Gradio passes RGB numpy (H, W, 3) in 0–255
+        from PIL import Image
+
+        Image.fromarray(image.astype(np.uint8)).save(inp_path)
+        try:
+            result = inference(
+                input=str(inp_path),
+                output=None,
+                device=device,
+                batch_size=1,
+                brightness_threshold=brightness_threshold,
+                resize_output=True,
+                verbose=False,
+            )
+        except FileNotFoundError as e:
+            if "Weights not found" in str(e) or "Run 'unreflect download" in str(e):
+                _ensure_weights()
+                result = inference(
+                    input=str(inp_path),
+                    output=None,
+                    device=device,
+                    batch_size=1,
+                    brightness_threshold=brightness_threshold,
+                    resize_output=True,
+                    verbose=False,
+                )
+            else:
+                raise
+    # result: [1, 3, H, W], float 0–1
+    out = result[0].cpu().numpy().transpose(1, 2, 0)
+    out = (np.clip(out, 0.0, 1.0) * 255).astype(np.uint8)
+    return out
+
+
+def build_ui():
+    _ensure_weights()
+
+    with gr.Blocks(
+        title="UnReflectAnything",
+        theme=gr.themes.Soft(primary_hue="green", secondary_hue="purple"),
+    ) as demo:
+        gr.Markdown(
+            """
+            # UnReflectAnything
+            Remove **specular reflections** from a single image. Upload an image and adjust the highlight threshold if needed.
+            """
+        )
+        with gr.Row():
+            inp = gr.Image(
+                label="Input image",
+                type="numpy",
+                height=360,
+            )
+            out = gr.Image(
+                label="Reflection‑removed (diffuse)",
+                type="numpy",
+                height=360,
+            )
+        brightness = gr.Slider(
+            minimum=0.0,
+            maximum=1.0,
+            value=0.8,
+            step=0.05,
+            label="Brightness threshold (highlight detection)",
+        )
+        run_btn = gr.Button("Remove reflections", variant="primary")
+        run_btn.click(
+            fn=run_inference,
+            inputs=[inp, brightness],
+            outputs=out,
+        )
+        gr.Markdown(
+            "Weights are cached after first run. On CPU inference may be slow."
+        )
+    return demo
+
+
+demo = build_ui()
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,9 @@
+# Gradio app dependencies.
+# Install from repo root so unreflectanything and its deps are available:
+#   cd /path/to/UnReflectAnything && pip install -e .
+# Then install Gradio (or use this file when running from gradio_space):
+gradio>=4.0
+
+# When running from gradio_space (e.g. Hugging Face Space with root = gradio_space),
+# install the parent package so "unreflectanything" and root-level modules exist:
+-e ..