Coverage for src/bioimageio/core/remote_backends/gradio/client.py: 0%
110 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
3from collections.abc import Mapping
4from types import MappingProxyType
5from typing import Any, Generic, Literal, TypeVar, overload
7from gradio_client.client import Client # pyright: ignore[reportMissingTypeStubs]
8from loguru import logger
10from bioimageio.spec import AnyModelDescr, ValidationSummary
12from ..._description_serializer import DescriptionSerializer
13from ..._model_adapter import RemoteModelAdapter
14from ..._prediction_pipeline import RemotePredictionPipeline
15from ..._settings import settings
16from ..._utils.type_hints import NestedList
17from ...axis import AxisSize, PerAxis
18from ...common import BlocksizeParameter, PerMember
19from ...sample import Sample
20from ...stat_measures import Measure, MeasureValue
21from .serializer import GradioSampleSerializer, SerializedSampleBlock
24class GradioModelAdapter(RemoteModelAdapter[SerializedSampleBlock]):
25 """Model adapter to use the bioimage-io-gradio-runner as a backend for model inference."""
27 def __init__(self, model_description: AnyModelDescr, *, server: str | None = None):
28 """Initialize the GradioModelAdapter.
30 Note:
31 - This adapter requires an environment with the same gradio version as the one used on the bioimage-io-gradio-runner server.
33 Args:
34 model_description: The model to run inference with.
35 server: The URL of a running bioimage-io-gradio-server instance (default server might not be availability/compatible).
36 """
37 server = server or settings.gradio_server
38 if server is None:
39 raise ValueError(
40 "No gradio server specified. Please provide a server URL or set the 'BIOIMAGEIO_GRADIO_SERVER' environment variable."
41 )
43 self._client = Client(server, httpx_kwargs={"timeout": 60})
44 self._serialized_model, self._sha256 = (
45 DescriptionSerializer.serialize_to_string_and_hash(model_description)
46 )
47 super().__init__(
48 model_description, server=server, sample_serializer=GradioSampleSerializer()
49 )
51 def _forward_impl(
52 self, serialized_input_sample: NestedList[SerializedSampleBlock]
53 ) -> NestedList[SerializedSampleBlock]:
54 return _call_predict_api(
55 self._client,
56 self._serialized_model,
57 self._sha256,
58 serialized_input_sample,
59 blocksize=None,
60 skip_preprocessing=True,
61 skip_postprocessing=True,
62 skip_input_padding=True,
63 skip_output_cropping=True,
64 batch_size=None,
65 )
67 def unload(self):
68 return super().unload()
70 def load(self) -> None:
71 for model_data in ("", self._serialized_model):
72 try:
73 result = self._client.submit(
74 api_name="/load_model", model=model_data, sha256=self._sha256
75 ).result()
76 except Exception as e:
77 if model_data:
78 logger.warning(
79 "Failed to load model on server with model_data, error was: {}",
80 len(model_data),
81 e,
82 )
83 else:
84 if result:
85 break
87 def test(self) -> ValidationSummary | None:
88 for model_data in ("", self._serialized_model):
89 try:
90 result = self._client.submit(
91 api_name="/test_model", model=model_data, sha256=self._sha256
92 ).result()
93 except Exception as e:
94 if model_data:
95 logger.warning(
96 "Failed to test model on server with model_data, error was: {}",
97 len(model_data),
98 e,
99 )
100 else:
101 if result:
102 return ValidationSummary.model_validate_json(result)
104 return None
107T = TypeVar("T")
110class _DummyJob(Generic[T]):
111 def __init__(self, result: T):
112 super().__init__()
113 self._result = result
115 def result(self, timeout: float | None = None) -> T:
116 return self._result
119class _DummyClient:
120 @overload
121 def submit(
122 self, api_name: Literal["/get_status"], **kwargs: Any
123 ) -> _DummyJob[dict[Literal["message"], str]]: ...
124 @overload
125 def submit(
126 self, api_name: Literal["/predict"], **kwargs: Any
127 ) -> _DummyJob[NestedList[SerializedSampleBlock]]: ...
128 def submit(
129 self, api_name: Literal["/get_status", "/predict"], **kwargs: Any
130 ) -> (
131 _DummyJob[dict[Literal["message"], str]]
132 | _DummyJob[NestedList[SerializedSampleBlock]]
133 ):
134 if api_name == "/get_status":
135 return _DummyJob({"message": "dummy client"})
136 elif api_name == "/predict":
137 from .server import predict as server_predict
139 return _DummyJob(server_predict(**kwargs))
140 else:
141 raise ValueError(f"Unknown api_name: {api_name}")
143 def close(self):
144 pass
147class GradioPredictionPipeline(RemotePredictionPipeline):
148 """Prediction pipeline to use the bioimage-io-gradio-runner as a fully remote prediction pipeline."""
150 def __init__(
151 self,
152 model_description: AnyModelDescr,
153 *,
154 server: str | None | Literal["run_in_client_process"] = None,
155 precomputed_statistics: Mapping[Measure, MeasureValue] = MappingProxyType({}),
156 default_blocksize_parameter: BlocksizeParameter = 10,
157 default_batch_size: int = 1,
158 ):
159 """
160 Note:
161 - This pipeline requires an environment with the same gradio version as the one used on the bioimage-io-gradio-runner server.
163 Args:
164 model_description: The model to run inference with.
165 server: The URL or Hugging Face space name of a running bioimageio gradio server instance (Note: default server might not be availabile/compatible!).
166 """
167 server = server or settings.gradio_server
168 if server is None:
169 raise ValueError(
170 "No gradio server specified. Please provide a server URL or set the 'BIOIMAGEIO_GRADIO_SERVER' environment variable."
171 )
173 super().__init__(
174 model_description,
175 server=server,
176 default_blocksize_parameter=default_blocksize_parameter,
177 default_batch_size=default_batch_size,
178 )
179 self._client = None
181 self._serialized_model, self._sha256 = (
182 DescriptionSerializer.serialize_to_string_and_hash(model_description)
183 )
184 self._serializer = GradioSampleSerializer
185 self._precomputed_statistics = dict(precomputed_statistics)
187 def load(self) -> None:
188 if self._server == "run_in_client_process":
189 # run via dummy client (intended for debugging)
190 self._client = _DummyClient()
191 else:
192 self._client = Client(self.server, httpx_kwargs={"timeout": 60})
194 def unload(self):
195 if self._client is not None:
196 logger.info(
197 "Closing GradioPredictionPipeline client connection to server {}",
198 self.server,
199 )
200 self._client.close()
201 self._client = None
203 def _predict_without_blocking_impl(
204 self,
205 sample: Sample,
206 *,
207 skip_input_padding: bool,
208 skip_preprocessing: bool,
209 skip_postprocessing: bool,
210 skip_output_cropping: bool,
211 ) -> Sample:
212 if self._client is None:
213 raise RuntimeError(
214 "GradioPredictionPipeline client is not initialized. "
215 + "Please call 'load()' before predicting or use the PredictionPipeline as context manager."
216 )
217 sample.stat.update(self._precomputed_statistics)
218 return self._serializer.deserialize_sample(
219 _call_predict_api(
220 self._client,
221 self._serialized_model,
222 self._sha256,
223 serialized_input_sample=self._serializer.serialize_sample(sample),
224 blocksize=None,
225 skip_preprocessing=skip_preprocessing,
226 skip_postprocessing=skip_postprocessing,
227 skip_input_padding=skip_input_padding,
228 skip_output_cropping=skip_output_cropping,
229 batch_size=self._default_batch_size,
230 )
231 )
233 def _predict_with_fixed_blocking_impl(
234 self,
235 sample: Sample,
236 block_shape: PerMember[PerAxis[int | AxisSize]],
237 *,
238 skip_preprocessing: bool,
239 skip_postprocessing: bool,
240 skip_input_padding: bool,
241 skip_output_cropping: bool,
242 ) -> Sample:
243 if self._client is None:
244 raise RuntimeError(
245 "GradioPredictionPipeline client is not initialized. "
246 + "Please call 'load()' before predicting or use the PredictionPipeline as context manager."
247 )
249 sample.stat.update(self._precomputed_statistics)
250 return self._serializer.deserialize_sample(
251 _call_predict_api(
252 self._client,
253 self._serialized_model,
254 self._sha256,
255 serialized_input_sample=self._serializer.serialize_sample(sample),
256 blocksize=block_shape,
257 skip_preprocessing=skip_preprocessing,
258 skip_postprocessing=skip_postprocessing,
259 skip_input_padding=skip_input_padding,
260 skip_output_cropping=skip_output_cropping,
261 batch_size=self._default_batch_size,
262 )
263 )
265 def get_status(self) -> dict[Literal["message"], str]:
266 """Check the status of the server."""
267 if self._client is None:
268 raise RuntimeError(
269 "GradioPredictionPipeline client is not initialized. "
270 + "Please call 'load()' before predicting or use the PredictionPipeline as context manager."
271 )
273 logger.info(
274 "Checking status of GradioPredictionPipeline server {}", self.server
275 )
276 return self._client.submit(api_name="/get_status").result(timeout=30)
279def _call_predict_api(
280 client: Client | _DummyClient,
281 serialized_model: str,
282 sha256: str,
283 serialized_input_sample: NestedList[SerializedSampleBlock],
284 blocksize: int
285 | Literal["blockwise_as_serialized"]
286 | PerMember[PerAxis[int | AxisSize]]
287 | None,
288 skip_preprocessing: bool,
289 skip_postprocessing: bool,
290 skip_input_padding: bool,
291 skip_output_cropping: bool,
292 batch_size: int | None,
293) -> NestedList[SerializedSampleBlock]:
294 if isinstance(blocksize, Mapping):
295 serialized_blocksize = {
296 str(member): {
297 str(axis): {"min": size.min, "max": size.max, "step": size.step}
298 if isinstance(size, AxisSize)
299 else size
300 for axis, size in axes.items()
301 }
302 for member, axes in blocksize.items()
303 }
304 else:
305 serialized_blocksize = blocksize
307 def submit(model: str) -> NestedList[SerializedSampleBlock]:
308 return client.submit(
309 api_name="/predict",
310 model=model,
311 sha256=sha256,
312 input_sample=serialized_input_sample,
313 blocksize=serialized_blocksize,
314 skip_preprocessing=skip_preprocessing,
315 skip_postprocessing=skip_postprocessing,
316 skip_input_padding=skip_input_padding,
317 skip_output_cropping=skip_output_cropping,
318 batch_size=batch_size,
319 ).result(timeout=300)
321 try:
322 return submit("")
323 except Exception as e:
324 logger.warning(
325 "Prediction without model upload failed; retrying with model upload: {}", e
326 )
327 return submit(serialized_model)