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

1from __future__ import annotations 

2 

3from collections.abc import Mapping 

4from types import MappingProxyType 

5from typing import Any, Generic, Literal, TypeVar, overload 

6 

7from gradio_client.client import Client # pyright: ignore[reportMissingTypeStubs] 

8from loguru import logger 

9 

10from bioimageio.spec import AnyModelDescr, ValidationSummary 

11 

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 

22 

23 

24class GradioModelAdapter(RemoteModelAdapter[SerializedSampleBlock]): 

25 """Model adapter to use the bioimage-io-gradio-runner as a backend for model inference.""" 

26 

27 def __init__(self, model_description: AnyModelDescr, *, server: str | None = None): 

28 """Initialize the GradioModelAdapter. 

29 

30 Note: 

31 - This adapter requires an environment with the same gradio version as the one used on the bioimage-io-gradio-runner server. 

32 

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 ) 

42 

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 ) 

50 

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 ) 

66 

67 def unload(self): 

68 return super().unload() 

69 

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 

86 

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) 

103 

104 return None 

105 

106 

107T = TypeVar("T") 

108 

109 

110class _DummyJob(Generic[T]): 

111 def __init__(self, result: T): 

112 super().__init__() 

113 self._result = result 

114 

115 def result(self, timeout: float | None = None) -> T: 

116 return self._result 

117 

118 

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 

138 

139 return _DummyJob(server_predict(**kwargs)) 

140 else: 

141 raise ValueError(f"Unknown api_name: {api_name}") 

142 

143 def close(self): 

144 pass 

145 

146 

147class GradioPredictionPipeline(RemotePredictionPipeline): 

148 """Prediction pipeline to use the bioimage-io-gradio-runner as a fully remote prediction pipeline.""" 

149 

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. 

162 

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 ) 

172 

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 

180 

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) 

186 

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}) 

193 

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 

202 

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 ) 

232 

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 ) 

248 

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 ) 

264 

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 ) 

272 

273 logger.info( 

274 "Checking status of GradioPredictionPipeline server {}", self.server 

275 ) 

276 return self._client.submit(api_name="/get_status").result(timeout=30) 

277 

278 

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 

306 

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) 

320 

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)