now supporting mcp server

README.md

@@ -4,7 +4,7 @@ emoji: 🖥️
 colorFrom: indigo
 colorTo: green
 sdk: gradio
-sdk_version: 5.23.1
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 ---
@@ -12,7 +12,7 @@ pinned: false
 A web-based application for automated lung segmentation using deep learning, powered by **Gradio** and **PyTorch**. This tool allows users to upload lung images and obtain segmented outputs efficiently.
 
 <p align="center">
-    <img src="images/app.png" height="700">
+    <img src="https://raw.githubusercontent.com/qchapp/lungs-segmentation-app/refs/heads/master/images/app.png" height="700">
 </p>
 
 ---
@@ -28,13 +28,10 @@ You can also provide a `.tif` file hosted online using a URL parameter.
 
 To do so, simply append `?file_url=...` to your app's URL.
 
-##### Example (local):
-`http://localhost:7860/?file_url=https://zenodo.org/record/8099852/files/lungs_ct.tif`
-
 ##### Example (hosted on Hugging Face):
 `https://huggingface.co/spaces/qchapp/3d-lungs-segmentation/?file_url=https://zenodo.org/record/8099852/files/lungs_ct.tif`
 
-The application will automatically download the file and load it into the viewer.
+The application will automatically download the file and load it into the viewer (the operation can take some time).
 
 ---
 
@@ -55,7 +52,7 @@ Run:
 ```sh
 python app.py
 ```
-And go to http://localhost:7860/.
+And go to the indicated local URL.
 
 ---
 
@@ -66,7 +63,7 @@ from pathlib import Path
 import shutil
 from gradio_client import Client, handle_file
 
-client = Client("https://huggingface.co/spaces/qchapp/3d-lungs-segmentation/")
+client = Client("qchapp/3d-lungs-segmentation")
 result_path = client.predict(
     file_obj=handle_file("https://zenodo.org/record/8099852/files/lungs_ct.tif?download=1"),
     api_name="/segment",
@@ -81,6 +78,6 @@ print("Saved the mask in:", dest.resolve())
 ---
 
 ## About Lungs Segmentation
-If you are interesten in the package used for segmentation please check the following [GitHub repository](https://github.com/qchapp/lungs-segmentation)!
+If you are interested in the package used for segmentation please check the following [GitHub repository](https://github.com/qchapp/lungs-segmentation)!
 
 ---

app.py

@@ -1,13 +1,23 @@
 import gradio as gr
-from core.utils import *
-
+from core.utils import (
+    example_file_path,
+    _load_volume_from_any,
+    volume_stats,
+    browse_axis_fast,
+    browse_overlay_axis_fast,
+    segment_volume,
+    APP_TMP_DIR,
+    clean_temp,
+    write_mask_tif,
+)
 import urllib.request
-import tempfile
-import os, time, threading, atexit
-from core.utils import APP_TMP_DIR, clean_temp, write_mask_tif
+import time, threading, tempfile, os
+from typing import Union
+from gradio import skip
+
 
 CLEAN_EVERY_SEC = 1800      # every 30 min
-CLEAN_AGE_HOURS = 6         # every 6 hours
+CLEAN_AGE_HOURS = 12        # every 12 hours
 
 def _start_cleanup_daemon():
     def _loop():
@@ -20,8 +30,6 @@ def _start_cleanup_daemon():
     threading.Thread(target=_loop, daemon=True).start()
 
 _start_cleanup_daemon()
-atexit.register(lambda: clean_temp(0))
-
 
 def get_axis_max(volume, axis):
     """Get the maximum index of each axis."""
@@ -33,67 +41,60 @@ def get_axis_max(volume, axis):
 def reset_app():
     """Reset everything to the initial state."""
     return (
-        gr.update(value=None),
-        None,
-        None,
-        gr.update(visible=False),
+        gr.update(value=None),   # file_input
+        None,                    # volume_state
+        None,                    # seg_state
+        gr.update(visible=False),# group_input
+        gr.update(visible=False),# segment_btn
         gr.update(value=0), gr.update(value=0), gr.update(value=0),
         gr.update(value=None), gr.update(value=None), gr.update(value=None),
-        gr.update(visible=False),
+        gr.update(visible=False),# group_seg
         gr.update(value=0), gr.update(value=0), gr.update(value=0),
         gr.update(value=None), gr.update(value=None), gr.update(value=None)
     )
 
-def segment_api(file_obj):
-    """
-    Accepts a TIF/TIFF via API, returns a TIF mask file path.
-    """
-    if not file_obj:
-        raise gr.Error("No file provided")
-
-    # Read volume (and let load_volume clean the temp upload)
-    volume = load_volume(file_obj)
-    seg = segment_volume(volume)  # uses your existing model wrapper
+def segment_api(file_obj: Union[dict, str, bytes]) -> str:
+    """Segments a 3D TIF/TIFF volume and returns a server path to a compressed TIF mask."""
+    volume = _load_volume_from_any(file_obj)
+    seg = segment_volume(volume)
     if seg is None:
         raise gr.Error("Segmentation failed")
-
-    # Write compressed TIF to app temp; return file path
     out_path = write_mask_tif(seg)
     return out_path
 
 def run_seg_with_progress(volume, progress=gr.Progress(track_tqdm=True)):
-    """
-    Thin wrapper to surface a progress bar in Gradio while the model runs.
-    """
+    """Surface a progress bar in Gradio while the model runs."""
     if volume is None:
         return None
     progress(0.1, desc="Preparing model…")
-    seg = segment_volume(volume)  # existing function from utils.py
+    seg = segment_volume(volume)
     progress(1.0, desc="Done")
     return seg
 
 with gr.Blocks(delete_cache=(1800, 21600)) as demo:
-    # ---- API (hidden) ----
-    _api_in = gr.File(file_types=[".tif", ".tiff"], visible=False)
-    _api_out = gr.File(visible=False)
-    gr.Button(visible=False).click(
-        fn=segment_api,
-        inputs=_api_in,
-        outputs=_api_out,
-        api_name="segment"
+    # Expose ONLY the /segment API/MCP tool
+    gr.api(
+        segment_api,
+        api_name="segment",
+        api_description="Accepts a 3D TIF/TIFF (URL, uploaded file, or raw bytes) and returns a path to the compressed TIF mask."
     )
 
-    # ---- UI ----
+    # -------- UI --------
     gr.Markdown("# 🐭 3D Lungs Segmentation")
     gr.Markdown("### ⚠️ Note: the visualization may take some time to render!")
 
+    # States
+    last_url_state = gr.State("")   # last processed ?file_url
     volume_state = gr.State()
     seg_state = gr.State()
     norm_state = gr.State()
 
-    file_input = gr.File(file_types=[".tif", ".tiff"], label="Upload your 3D TIF or TIFF file")
+    file_input = gr.File(
+        file_types=[".tif", ".tiff"],
+        file_count="single",
+        label="Upload your 3D TIF or TIFF file"
+    )
 
-    # ---- Example loader ----
     gr.Examples(
         examples=[[example_file_path]],
         inputs=[file_input],
@@ -101,7 +102,6 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
         examples_per_page=1
     )
 
-    # ---- RAW SLICES VIEWER ----
     with gr.Group(visible=False) as group_input:
         gr.Markdown("### Raw Volume Slices")
         with gr.Row():
@@ -114,10 +114,8 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
             x_img = gr.Image(label="X")
 
     segment_btn = gr.Button("Segment", visible=False)
-
     loading_md = gr.Markdown("⏳ **Segmenting…** This can take a bit.", visible=False)
 
-    # ---- OVERLAY SLICES VIEWER ----
     with gr.Group(visible=False) as group_seg:
         gr.Markdown("### Segmentation Overlay Slices")
         with gr.Row():
@@ -133,61 +131,81 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
 
     gr.Markdown("#### 📝 This work is based on the Bachelor Project of Quentin Chappuis 2024; for more information, consult the [repository](https://github.com/qchapp/lungs-segmentation)!")
 
-    # ---- CALLBACKS ----
-
-    # A) Load volume
+    # -------- Callbacks (hidden from API/MCP) --------
     file_input.change(
-        fn=load_volume,
+        fn=lambda f: _load_volume_from_any(f) if f is not None else skip(),
         inputs=file_input,
-        outputs=volume_state
+        outputs=volume_state,
+        show_api=False
     ).then(
-        fn=volume_stats,
+        fn=lambda vol: volume_stats(vol) if vol is not None else skip(),
         inputs=volume_state,
-        outputs=norm_state
+        outputs=norm_state,
+        show_api=False
     ).then(
-        fn=lambda vol: gr.update(visible=(vol is not None)),
+        fn=lambda vol: gr.update(visible=True) if vol is not None else skip(),
         inputs=volume_state,
-        outputs=group_input
+        outputs=group_input,
+        show_api=False
     ).then(
-        fn=lambda vol: gr.update(visible=(vol is not None)),
+        fn=lambda vol: gr.update(visible=True) if vol is not None else skip(),
         inputs=volume_state,
-        outputs=segment_btn
+        outputs=segment_btn,
+        show_api=False
     ).then(
         fn=lambda vol: (
             gr.update(maximum=get_axis_max(vol, "Z")),
             gr.update(maximum=get_axis_max(vol, "Y")),
             gr.update(maximum=get_axis_max(vol, "X")),
-        ),
+        ) if vol is not None else (skip(), skip(), skip()),
         inputs=volume_state,
-        outputs=[z_slider, y_slider, x_slider]
+        outputs=[z_slider, y_slider, x_slider],
+        show_api=False
     ).then(
         fn=lambda vol, st: (
             browse_axis_fast("Z", 0, vol, st),
             browse_axis_fast("Y", 0, vol, st),
             browse_axis_fast("X", 0, vol, st),
-        ),
+        ) if vol is not None else (skip(), skip(), skip()),
         inputs=[volume_state, norm_state],
-        outputs=[z_img, y_img, x_img]
+        outputs=[z_img, y_img, x_img],
+        show_api=False
     )
 
-    # B) RAW sliders
-    z_slider.change(fn=lambda idx, vol, st: browse_axis_fast("Z", idx, vol, st), inputs=[z_slider, volume_state, norm_state], outputs=z_img)
-    y_slider.change(fn=lambda idx, vol, st: browse_axis_fast("Y", idx, vol, st), inputs=[y_slider, volume_state, norm_state], outputs=y_img)
-    x_slider.change(fn=lambda idx, vol, st: browse_axis_fast("X", idx, vol, st), inputs=[x_slider, volume_state, norm_state], outputs=x_img)
+    z_slider.change(
+        fn=lambda idx, vol, st: browse_axis_fast("Z", idx, vol, st),
+        inputs=[z_slider, volume_state, norm_state],
+        outputs=z_img,
+        show_api=False
+    )
+    y_slider.change(
+        fn=lambda idx, vol, st: browse_axis_fast("Y", idx, vol, st),
+        inputs=[y_slider, volume_state, norm_state],
+        outputs=y_img,
+        show_api=False
+    )
+    x_slider.change(
+        fn=lambda idx, vol, st: browse_axis_fast("X", idx, vol, st),
+        inputs=[x_slider, volume_state, norm_state],
+        outputs=x_img,
+        show_api=False
+    )
 
-    # C) Segment
     segment_btn.click(
         fn=lambda: (gr.update(visible=True), gr.update(interactive=False)),
         inputs=[],
-        outputs=[loading_md, segment_btn]
+        outputs=[loading_md, segment_btn],
+        show_api=False
     ).then(
-        fn=run_seg_with_progress,  # <— shows a progress bar
+        fn=run_seg_with_progress,
         inputs=volume_state,
-        outputs=seg_state
+        outputs=seg_state,
+        show_api=False
     ).then(
         fn=lambda s: gr.update(visible=(s is not None)),
         inputs=seg_state,
-        outputs=group_seg
+        outputs=group_seg,
+        show_api=False
     ).then(
         fn=lambda vol: (
             gr.update(maximum=get_axis_max(vol, "Z")),
@@ -195,7 +213,8 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
             gr.update(maximum=get_axis_max(vol, "X")),
         ),
         inputs=volume_state,
-        outputs=[z_slider_seg, y_slider_seg, x_slider_seg]
+        outputs=[z_slider_seg, y_slider_seg, x_slider_seg],
+        show_api=False
     ).then(
         fn=lambda z, y, x, vol, seg, st: (
             browse_overlay_axis_fast("Z", z, vol, seg, st),
@@ -203,19 +222,34 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
             browse_overlay_axis_fast("X", x, vol, seg, st),
         ),
         inputs=[z_slider_seg, y_slider_seg, x_slider_seg, volume_state, seg_state, norm_state],
-        outputs=[z_img_overlay, y_img_overlay, x_img_overlay]
+        outputs=[z_img_overlay, y_img_overlay, x_img_overlay],
+        show_api=False
     ).then(
         fn=lambda: (gr.update(visible=False), gr.update(interactive=True)),
         inputs=[],
-        outputs=[loading_md, segment_btn]
+        outputs=[loading_md, segment_btn],
+        show_api=False
     )
 
-    # D) OVERLAY sliders
-    z_slider_seg.change(fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("Z", idx, vol, seg, st), inputs=[z_slider_seg, volume_state, seg_state, norm_state], outputs=z_img_overlay)
-    y_slider_seg.change(fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("Y", idx, vol, seg, st), inputs=[y_slider_seg, volume_state, seg_state, norm_state], outputs=y_img_overlay)
-    x_slider_seg.change(fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("X", idx, vol, seg, st), inputs=[x_slider_seg, volume_state, seg_state, norm_state], outputs=x_img_overlay)
+    z_slider_seg.change(
+        fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("Z", idx, vol, seg, st),
+        inputs=[z_slider_seg, volume_state, seg_state, norm_state],
+        outputs=z_img_overlay,
+        show_api=False
+    )
+    y_slider_seg.change(
+        fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("Y", idx, vol, seg, st),
+        inputs=[y_slider_seg, volume_state, seg_state, norm_state],
+        outputs=y_img_overlay,
+        show_api=False
+    )
+    x_slider_seg.change(
+        fn=lambda idx, vol, seg, st: browse_overlay_axis_fast("X", idx, vol, seg, st),
+        inputs=[x_slider_seg, volume_state, seg_state, norm_state],
+        outputs=x_img_overlay,
+        show_api=False
+    )
 
-    # E) Reset
     reset_btn.click(
         fn=reset_app,
         inputs=[],
@@ -224,85 +258,49 @@ with gr.Blocks(delete_cache=(1800, 21600)) as demo:
             volume_state,
             seg_state,
             group_input,
+            segment_btn,
             z_slider, y_slider, x_slider,
             z_img, y_img, x_img,
             group_seg,
             z_slider_seg, y_slider_seg, x_slider_seg,
             z_img_overlay, y_img_overlay, x_img_overlay
-        ]
+        ],
+        show_api=False
     )
 
-    # ---- HANDLE QUERY PARAMETERS ----
+
+    # -------- URL loader --------
     @demo.load(
-        outputs=[
-            file_input,
-            volume_state,
-            norm_state,
-            group_input,
-            segment_btn,
-            z_slider, y_slider, x_slider,
-            z_img, y_img, x_img
-        ]
+        inputs=[last_url_state],
+        outputs=[last_url_state, file_input],  # only these two
+        show_api=False
     )
-    def load_from_query(request: gr.Request):
+    def load_from_query(prev_url, request: gr.Request):
         params = request.query_params
+        url = params.get("file_url") or ""
 
-        if "file_url" in params:
-            try:
-                # A) Download the file from the URL to a managed temporary path
-                url = params["file_url"]
-                fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
-                os.close(fd)
-                urllib.request.urlretrieve(url, tmp_path)
-
-                # B) Open the file as a binary object
-                with open(tmp_path, "rb") as f:
-                    volume = load_volume(f)
+        # No URL -> no-op
+        if not url:
+            return [gr.skip(), gr.skip()]
 
-                # Remove downloaded temp file now that it's in memory
-                try:
-                    os.remove(tmp_path)
-                except Exception as e:
-                    print(f"[load_from_query] couldn't remove {tmp_path}: {e}")
+        # 🔧 Short-circuit: same URL as last time -> no-op
+        if url == prev_url:
+            return [gr.skip(), gr.skip()]
 
-                # C) Return values for all components
-                stats = volume_stats(volume)
-                return [
-                    gr.update(value=None),
-                    volume,
-                    stats,
-                    gr.update(visible=True),
-                    gr.update(visible=True),
-                    gr.update(maximum=get_axis_max(volume, "Z")),
-                    gr.update(maximum=get_axis_max(volume, "Y")),
-                    gr.update(maximum=get_axis_max(volume, "X")),
-                    browse_axis_fast("Z", 0, volume, stats),
-                    browse_axis_fast("Y", 0, volume, stats),
-                    browse_axis_fast("X", 0, volume, stats),
-                ]
-
-            except Exception as e:
-                print(f"[Error loading file_url] {e}")
+        # Download to CLOSED temp file and programmatically set the File value.
+        fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
+        os.close(fd)
+        try:
+            urllib.request.urlretrieve(url, tmp_path)
+        except Exception as e:
+            try:
+                os.remove(tmp_path)
+            except Exception:
+                pass
+            raise gr.Error(f"Failed to download file_url: {e}")
 
-        # Fallback if no file_url or failure
-        return [
-            None,
-            None,
-            (0.0, 1.0),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(maximum=0),
-            gr.update(maximum=0),
-            gr.update(maximum=0),
-            None, None, None
-        ]
+        return [url, gr.update(value=tmp_path)]
 
 
 if __name__ == "__main__":
-    try:
-        demo.queue(concurrency_count=1, max_size=16).launch()
-    except TypeError:
-        try:
-            demo.queue(max_size=16).launch()
-        except TypeError:
-            demo.queue().launch()
+    demo.queue(default_concurrency_limit=1, max_size=16).launch(mcp_server=True)

core/utils.py

@@ -7,12 +7,24 @@ from PIL import Image
 from pathlib import Path
 import time, uuid, atexit
 from unet_lungs_segmentation import LungsPredict
+import gradio as gr
 
 model = LungsPredict()
 
 APP_TMP_DIR = Path(tempfile.gettempdir()) / "lungs_seg_tmp"
 APP_TMP_DIR.mkdir(parents=True, exist_ok=True)
 
+# ---------- Example file ----------
+def get_example_file():
+    url = "https://zenodo.org/record/8099852/files/lungs_ct.tif?download=1"
+    tmp_path = APP_TMP_DIR / "example_lungs.tif"
+    if not tmp_path.exists():
+        urllib.request.urlretrieve(url, tmp_path)
+    return str(tmp_path)
+
+example_file_path = get_example_file()
+PROTECTED_PATHS = {Path(example_file_path).resolve()}
+
 def new_tmp_path(basename: str = "tmp.tif") -> str:
     """Return a unique path inside the app temp dir."""
     uid = uuid.uuid4().hex[:8]
@@ -39,29 +51,92 @@ def write_mask_tif(mask: np.ndarray) -> str:
     tifffile.imwrite(out_path, mask.astype(np.uint8), compression="zlib")
     return out_path
 
-def load_volume(file_obj):
-    if not file_obj:
-        return None
-    path = getattr(file_obj, "name", None) or getattr(file_obj, "path", None) or file_obj
+# ---------- Reading helpers ----------
+def _read_tif_from_path(path: str):
+    """Read a tif from a local filesystem path; only auto-delete files in APP_TMP_DIR (not protected)."""
     arr = tifffile.imread(path)
-
     try:
         if path and os.path.exists(path):
-            src = Path(path).resolve()
-            if src not in PROTECTED_PATHS:
-                os.remove(src)
+            rp = Path(path).resolve()
+            if (rp not in PROTECTED_PATHS) and (APP_TMP_DIR in rp.parents):
+                os.remove(rp)
     except Exception as e:
         print(f"[load_volume] couldn't remove temp file {path}: {e}")
-
     return arr
 
+def load_volume(file_obj):
+    """
+    Backward-compatible wrapper used by older code that passes in a path-like object.
+    Prefer _load_volume_from_any() in new code.
+    """
+    if not file_obj:
+        return None
+    path = getattr(file_obj, "name", None) or getattr(file_obj, "path", None) or file_obj
+    if isinstance(path, (str, os.PathLike)):
+        return _read_tif_from_path(str(path))
+    # If a dict/FileData slipped through, delegate to the robust path:
+    return _load_volume_from_any(file_obj)
+
+def _load_volume_from_any(file_obj):
+    """
+    Normalize different inputs to a real filesystem path and read via _read_tif_from_path.
+    Accepts:
+      - dict with 'path' or 'url' (Gradio FileData / programmatic)
+      - str local path or URL
+      - bytes / bytearray
+      - file-like object with .read()
+    """
+    try:
+        # Gradio FileData-like dict
+        if isinstance(file_obj, dict):
+            path = file_obj.get("path") or file_obj.get("url")
+            if not path:
+                raise gr.Error("Invalid file object (missing 'path' or 'url').")
+            if isinstance(path, str) and (path.startswith("http://") or path.startswith("https://")):
+                fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
+                os.close(fd)
+                urllib.request.urlretrieve(path, tmp_path)
+                return _read_tif_from_path(tmp_path)
+            return _read_tif_from_path(path)
+
+        # String path or URL
+        if isinstance(file_obj, (str, os.PathLike)):
+            s = str(file_obj)
+            if s.startswith("http://") or s.startswith("https://"):
+                fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
+                os.close(fd)
+                urllib.request.urlretrieve(s, tmp_path)
+                return _read_tif_from_path(tmp_path)
+            return _read_tif_from_path(s)
+
+        # Raw bytes
+        if isinstance(file_obj, (bytes, bytearray)):
+            fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
+            os.close(fd)
+            with open(tmp_path, "wb") as w:
+                w.write(file_obj)
+            return _read_tif_from_path(tmp_path)
+
+        # File-like object
+        if hasattr(file_obj, "read"):
+            data = file_obj.read()
+            fd, tmp_path = tempfile.mkstemp(suffix=".tif", dir=str(APP_TMP_DIR))
+            os.close(fd)
+            with open(tmp_path, "wb") as w:
+                w.write(data)
+            return _read_tif_from_path(tmp_path)
+
+        raise gr.Error(f"Unsupported input type for file_obj: {type(file_obj)}")
+    except Exception as e:
+        raise gr.Error(f"Failed to read input file: {e}")
+
+# ---------- Model + viz ----------
 def segment_volume(volume):
     """Run segmentation on the loaded volume (return shape (Z, Y, X))."""
     if volume is None:
         return None
     return model.segment_lungs(volume)
 
-# Optimization for faster processing
 def volume_stats(volume):
     """Return (min, max) as floats for global 8-bit scaling."""
     if volume is None:
@@ -103,20 +178,8 @@ def browse_overlay_axis_fast(axis, idx, volume, seg, stats, alpha=0.35):
 
     raw8 = _to_8bit_stats(raw, mn, mx)
     rgb  = np.repeat(raw8[..., None], 3, axis=-1)
-    # color mask in red channel
     mask_rgb = np.zeros_like(rgb)
     mask_rgb[..., 0] = (mask.astype(np.uint8) * 255)
 
     blended = rgb.astype(np.float32) * (1 - alpha) + mask_rgb.astype(np.float32) * alpha
-    return Image.fromarray(blended.astype(np.uint8))
-
-# Example file
-def get_example_file():
-    url = "https://zenodo.org/record/8099852/files/lungs_ct.tif?download=1"
-    tmp_path = APP_TMP_DIR / "example_lungs.tif"
-    if not tmp_path.exists():
-        urllib.request.urlretrieve(url, tmp_path)
-    return str(tmp_path)
-
-example_file_path = get_example_file()
-PROTECTED_PATHS = {Path(example_file_path).resolve()}
+    return Image.fromarray(blended.astype(np.uint8))

requirements.txt

@@ -1,4 +1,4 @@
 unet_lungs_segmentation
-gradio==5.25.1
+gradio[mcp]==5.49.1
 torch==2.6.0
 torchvision==0.21.0