Coverage for src/bioimageio/core/remote_backends/gradio/serializer.py: 0%

58 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-20 09:46 +0000

1from __future__ import annotations 

2 

3import tempfile 

4from collections.abc import Mapping 

5from pathlib import Path 

6from typing import Annotated, cast 

7 

8import numpy as np 

9from gradio_client import handle_file # pyright: ignore[reportMissingTypeStubs] 

10from pydantic import BaseModel, BeforeValidator 

11from typing_extensions import Self 

12 

13from ..._common_annotations import PerMemberAnno 

14from ..._sample_serializer import SampleSerializer 

15from ..._utils.type_hints import cast_and_assert 

16from ...axis import AxisId 

17from ...common import MemberId, SampleId 

18from ...io import JsonValue, load_stat, save_tensor, serialize_stat 

19from ...sample import Sample 

20from ...stat_measures import AppliedOps 

21from ...tensor import MultiIndex, Tensor 

22 

23 

24class _SerializableBlock(BaseModel, frozen=True): 

25 path: Path 

26 meta: Mapping[str, str] 

27 orig_name: str 

28 

29 @classmethod 

30 def from_tensor(cls, tensor: Tensor) -> Self: 

31 with tempfile.NamedTemporaryFile(suffix=".npy", delete=False) as tmp: 

32 save_tensor(tmp.name, tensor) 

33 

34 handled = handle_file(Path(tmp.name)) 

35 return cls.model_validate(handled) 

36 

37 

38def _restore_sample_id(value: object) -> object: 

39 # JSON encodes tuple sample IDs as lists. 

40 if isinstance(value, list): 

41 return tuple(_restore_sample_id(item) for item in cast(list[object], value)) 

42 return value 

43 

44 

45class _SerializableSampleBlock(BaseModel, frozen=True): 

46 id: Annotated[SampleId, BeforeValidator(_restore_sample_id)] 

47 dims: PerMemberAnno[tuple[AxisId, ...]] 

48 data: PerMemberAnno[_SerializableBlock | Path] 

49 serialized_stat: list[JsonValue] 

50 batch_indices: PerMemberAnno[dict[str, list[JsonValue]]] = {} 

51 applied_ops: AppliedOps 

52 

53 

54SerializedSampleBlock = dict[str, JsonValue] 

55 

56 

57class GradioSampleSerializer(SampleSerializer[SerializedSampleBlock]): 

58 @staticmethod 

59 def serialize_sample_block(sample_block: Sample) -> SerializedSampleBlock: 

60 handled_members: dict[MemberId, _SerializableBlock] = {} 

61 for m, t in sample_block.members.items(): 

62 handled_members[m] = _SerializableBlock.from_tensor(t) 

63 

64 serializable = _SerializableSampleBlock( 

65 data=handled_members, 

66 id=sample_block.id, 

67 dims={m: t.dims for m, t in sample_block.members.items()}, 

68 serialized_stat=serialize_stat(sample_block.stat), 

69 applied_ops=sample_block.applied_ops, 

70 batch_indices={ 

71 m: { 

72 str(name): index.get_level_values(i).tolist() 

73 for i, name in enumerate(index.names) 

74 } 

75 for m, tensor in sample_block.members.items() 

76 if (index := tensor.batch_multi_index) is not None 

77 }, 

78 ) 

79 serialized = serializable.model_dump(mode="json") 

80 return serialized 

81 

82 @staticmethod 

83 def deserialize_sample_block(serialized: SerializedSampleBlock) -> Sample: 

84 deserializable_sample = _SerializableSampleBlock.model_validate(serialized) 

85 if deserializable_sample.data.keys() != deserializable_sample.dims.keys(): 

86 raise ValueError( 

87 "Serialized sample data and dimensions have different members" 

88 ) 

89 

90 members = { 

91 k: Tensor( 

92 np.load(v if isinstance(v, Path) else v.path, allow_pickle=False), 

93 dims=deserializable_sample.dims[k], 

94 ) 

95 for k, v in deserializable_sample.data.items() 

96 } 

97 for member, index in deserializable_sample.batch_indices.items(): 

98 members[member] = members[member].assign_batch_multi_index( 

99 cast_and_assert( 

100 MultiIndex, 

101 MultiIndex.from_arrays(list(index.values()), names=list(index)), 

102 ) 

103 ) 

104 return Sample( 

105 id=deserializable_sample.id, 

106 members=members, 

107 stat=load_stat(deserializable_sample.serialized_stat), 

108 applied_ops=deserializable_sample.applied_ops, 

109 )