Coverage for src/bioimageio/core/remote_backends/gradio/server.py: 0%
101 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 09:46 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 09:46 +0000
1from __future__ import annotations
3import json
4from collections.abc import Sequence
5from typing import Any, Literal
7import gradio as gr
8from loguru import logger
9from pydantic import TypeAdapter
11import bioimageio.core
12from bioimageio.core import Stat
13from bioimageio.core._description_serializer import DescriptionSerializer
14from bioimageio.core._utils.type_hints import NestedList
15from bioimageio.core.axis import AxisSize, PerAxis
16from bioimageio.core.backends import create_model_adapter
17from bioimageio.core.common import PerMember
18from bioimageio.core.remote_backends.gradio.serializer import (
19 GradioSampleSerializer,
20 SerializedSampleBlock,
21)
22from bioimageio.spec import load_model_description
23from bioimageio.spec.common import Sha256
24from bioimageio.spec.model import AnyModelDescr, v0_4, v0_5
26try:
27 import spaces # pyright: ignore
28except ImportError:
29 logger.warning("Failed to import 'spaces' package")
31 class spaces:
32 @staticmethod
33 def GPU(func: Any):
34 return func
37logger.enable("bioimageio")
40def predict(
41 model: str,
42 sha256: str,
43 input_sample: NestedList[SerializedSampleBlock],
44 blocksize: int | PerMember[PerAxis[int | AxisSize]] | None = None,
45 skip_preprocessing: bool = False,
46 skip_postprocessing: bool = False,
47 skip_input_padding: bool = False,
48 skip_output_cropping: bool = False,
49 batch_size: int | None = None,
50 *,
51 devices: Sequence[str] | None = None,
52) -> NestedList[SerializedSampleBlock]:
53 """Run prediction on a sample
55 Args:
56 input_sample: Serialized sample or nested block grid created with GradioSampleSerializer.
57 model: A model source: URL, nickname or base64 encoded model package (if len(model) > 2083).
58 sha256: Sha256 hash of the model's bioimageio.yaml file at the model source or of the encoded model package.
59 blocksize:
60 - None (default): run non-blockwise, full-sample prediction.
61 - integer: run blockwise prediction with a block size derived from the model and this blocksize parameter.
62 - PerMember[PerAxis[int | AxisSize]]: run blockwise prediction with a fixed block shape given for each sample member.
63 skip_preprocessing: If True, skip preprocessing steps defined in the model.
64 skip_postprocessing: If True, skip postprocessing steps defined in the model.
65 skip_input_padding: If True, skip input padding for non-blockwise prediction.
66 Set this flag when predicting an (overlapping) sample block rather than a full sample.
67 skip_output_cropping: If True, skip output cropping for non-blockwise prediction.
68 Set this flag when predicting an (overlapping) sample block rather than a full sample.
69 batch_size: Optional batch size only applicable to predicting input samples with batch dimension.
70 """
72 logger.info(
73 "Received prediction request for model {}",
74 model[:10] + "..." if len(model) > 10 else model,
75 )
77 def setup(stat: Stat):
78 model_adapter = _get_model_adapter(model, sha256=sha256, devices=devices)
79 return bioimageio.core.create_prediction_pipeline(
80 model_adapter.model_descr,
81 model_adapter=model_adapter,
82 fixed_dataset_statistics=stat,
83 )
85 sample = GradioSampleSerializer.deserialize_sample(input_sample)
86 pp = setup(sample.stat)
87 kwargs = {
88 "skip_preprocessing": skip_preprocessing,
89 "skip_postprocessing": skip_postprocessing,
90 "skip_input_padding": skip_input_padding,
91 "skip_output_cropping": skip_output_cropping,
92 }
93 if isinstance(blocksize, int):
94 output = pp.predict_with_blocking(
95 sample, ns=blocksize, batch_size=batch_size, **kwargs
96 )
97 elif isinstance(blocksize, dict):
98 block_shape = TypeAdapter(PerMember[PerAxis[int | AxisSize]]).validate_python(
99 blocksize
100 )
101 output = pp.predict_with_fixed_blocking(sample, block_shape, **kwargs)
102 else:
103 output = pp.predict_without_blocking(sample, **kwargs)
104 return GradioSampleSerializer.serialize_sample(output)
107def load_model(
108 model: str,
109 sha256: str,
110 *,
111 devices: Sequence[str] | None = None,
112) -> dict[Literal["message"], str]:
113 """Load a model into the server's model cache. This can be used to pre-load a model before running predictions to avoid the overhead of loading the model during the first prediction request."""
114 _ = _get_model_adapter(model, sha256=sha256, devices=devices)
115 return {"message": "Model loaded successfully"}
118def get_status() -> dict[Literal["message"], str]:
119 """Check the status of the server."""
120 logger.info("Received status request")
121 return {"message": "alive"}
124def test_model(
125 model: str,
126 sha256: str,
127 *,
128 devices: Sequence[str] | None = None,
129) -> str:
130 """Run the bioimageio model test and return the validation summary. Returns None if testing failed."""
131 model_adapter = _get_model_adapter(model, sha256=sha256, devices=devices)
132 summary = bioimageio.core.test_model(
133 model_adapter.model_descr,
134 devices=None if devices is None else list(devices),
135 )
136 return summary.model_dump_json()
139def _cache_key(kwargs: dict[str, Any]) -> str:
140 return json.dumps([kwargs["sha256"], kwargs["devices"]])
143def _get_model_adapter(
144 model: str,
145 *,
146 sha256: str,
147 devices: Sequence[str] | None,
148):
149 return _get_cached_model_adapter(
150 model,
151 sha256=sha256,
152 devices=None if devices is None else tuple(devices),
153 )
156@gr.cache( # pyright: ignore[reportUntypedFunctionDecorator]
157 key=_cache_key,
158 max_size=bioimageio.core.settings.gradio_server_model_cache_max_size,
159 max_memory=bioimageio.core.settings.gradio_server_model_cache_max_memory,
160 per_session=False,
161)
162def _get_cached_model_adapter(
163 model: str,
164 *,
165 sha256: str,
166 devices: tuple[str, ...] | None,
167):
168 """Get a model adapter for the given model
170 Args:
171 model: A model source: URL (len(model) <= 2083)) or model base64 encoded package bytes (len(model) > 2083).
172 sha256: Sha256 hash of the model source at model URL or of the encoded model package bytes.
173 """
174 if not model:
175 raise ValueError("Model source cannot be empty")
177 model_descr = _get_model(model, sha256=sha256)
178 adapter = create_model_adapter(model_description=model_descr, devices=devices)
179 adapter.load()
180 return adapter
183def _get_model(
184 model: str,
185 *,
186 sha256: str,
187) -> AnyModelDescr:
188 if len(model) > 2083:
189 ret = DescriptionSerializer.deserialize_from_string(model)
190 if not isinstance(ret, (v0_4.ModelDescr, v0_5.ModelDescr)):
191 raise ValueError(
192 f"Deserialized model description is not a valid model description: got {ret.type} {ret.format_version}"
193 )
194 return ret
195 else:
196 return load_model_description(model, sha256=Sha256(sha256) if sha256 else None)
199def root():
200 return {
201 "message": f"Running bioimageio.core {bioimageio.core.__version__} gradio server."
202 }
205def _create_app(*, devices: Sequence[str] | None = None) -> gr.Server:
206 server_devices = None if devices is None else tuple(devices)
207 app = gr.Server(version="0.1")
209 @app.api(name="predict") # pyright: ignore[reportUntypedFunctionDecorator]
210 @spaces.GPU
211 def predict_api(
212 model: str,
213 sha256: str,
214 input_sample: NestedList[SerializedSampleBlock],
215 blocksize: int | PerMember[PerAxis[int | AxisSize]] | None = None,
216 skip_preprocessing: bool = False,
217 skip_postprocessing: bool = False,
218 skip_input_padding: bool = False,
219 skip_output_cropping: bool = False,
220 batch_size: int | None = None,
221 ) -> NestedList[SerializedSampleBlock]:
222 return predict(
223 model,
224 sha256,
225 input_sample,
226 blocksize,
227 skip_preprocessing,
228 skip_postprocessing,
229 skip_input_padding,
230 skip_output_cropping,
231 batch_size,
232 devices=server_devices,
233 )
235 @app.api(name="load_model") # pyright: ignore[reportUntypedFunctionDecorator]
236 def load_model_api(model: str, sha256: str) -> dict[Literal["message"], str]:
237 return load_model(model, sha256, devices=server_devices)
239 @app.api(name="get_status") # pyright: ignore[reportUntypedFunctionDecorator]
240 def get_status_api() -> dict[Literal["message"], str]:
241 return get_status()
243 @app.api(name="test_model") # pyright: ignore[reportUntypedFunctionDecorator]
244 def test_model_api(model: str, sha256: str) -> str:
245 return test_model(model, sha256, devices=server_devices)
247 @app.get("/")
248 def root_api():
249 return root()
251 return app
254app = _create_app()
257def main(port: int | None = None, *, devices: Sequence[str] | None = None) -> str:
258 """Start the server using the specified devices, or automatic selection by default."""
259 logger.info(
260 "Starting bioimageio.core gradio server on port {} with devices {}",
261 port,
262 devices,
263 )
264 app = _create_app(devices=devices)
265 _app, local_url, _share_url = app.launch(
266 debug=True,
267 mcp_server=True,
268 server_name="0.0.0.0",
269 server_port=port,
270 show_error=True,
271 )
272 return local_url
275if __name__ == "__main__":
276 _ = main()