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

1from __future__ import annotations 

2 

3import json 

4from collections.abc import Sequence 

5from typing import Any, Literal 

6 

7import gradio as gr 

8from loguru import logger 

9from pydantic import TypeAdapter 

10 

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 

25 

26try: 

27 import spaces # pyright: ignore 

28except ImportError: 

29 logger.warning("Failed to import 'spaces' package") 

30 

31 class spaces: 

32 @staticmethod 

33 def GPU(func: Any): 

34 return func 

35 

36 

37logger.enable("bioimageio") 

38 

39 

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 

54 

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 """ 

71 

72 logger.info( 

73 "Received prediction request for model {}", 

74 model[:10] + "..." if len(model) > 10 else model, 

75 ) 

76 

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 ) 

84 

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) 

105 

106 

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

116 

117 

118def get_status() -> dict[Literal["message"], str]: 

119 """Check the status of the server.""" 

120 logger.info("Received status request") 

121 return {"message": "alive"} 

122 

123 

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

137 

138 

139def _cache_key(kwargs: dict[str, Any]) -> str: 

140 return json.dumps([kwargs["sha256"], kwargs["devices"]]) 

141 

142 

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 ) 

154 

155 

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 

169 

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

176 

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 

181 

182 

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) 

197 

198 

199def root(): 

200 return { 

201 "message": f"Running bioimageio.core {bioimageio.core.__version__} gradio server." 

202 } 

203 

204 

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

208 

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 ) 

234 

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) 

238 

239 @app.api(name="get_status") # pyright: ignore[reportUntypedFunctionDecorator] 

240 def get_status_api() -> dict[Literal["message"], str]: 

241 return get_status() 

242 

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) 

246 

247 @app.get("/") 

248 def root_api(): 

249 return root() 

250 

251 return app 

252 

253 

254app = _create_app() 

255 

256 

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 

273 

274 

275if __name__ == "__main__": 

276 _ = main()