Coverage for src/bioimageio/core/_sample_serializer.py: 98%

70 statements  

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

1from __future__ import annotations 

2 

3from abc import ABC, abstractmethod 

4from collections.abc import Callable 

5from typing import ( 

6 Generic, 

7 TypeVar, 

8 cast, 

9) 

10 

11import dask.array as da 

12import numpy as np 

13 

14from bioimageio.spec.model import v0_5 

15 

16from ._utils.type_hints import NestedList 

17from .axis import AxisSize, PerAxis 

18from .block import Block, split_multiple_tensors_into_blocks 

19from .common import HaloLike, MemberId, PadMode, PerMember 

20from .sample import Sample 

21from .tensor import Array, Tensor 

22 

23SerializedSampleBlockType = TypeVar("SerializedSampleBlockType") 

24 

25 

26class SampleSerializer(ABC, Generic[SerializedSampleBlockType]): 

27 @classmethod 

28 def serialize_sample( 

29 cls, 

30 sample: Sample, 

31 ) -> NestedList[SerializedSampleBlockType]: 

32 """Serialize a sample as a single block.""" 

33 

34 return cls.serialize_sample_block(sample) 

35 

36 @classmethod 

37 def deserialize_sample( 

38 cls, 

39 serialized: NestedList[SerializedSampleBlockType], 

40 ) -> Sample: 

41 """Assemble a nested block grid; blocks must already be cropped to avoid overlap.""" 

42 

43 if not isinstance(serialized, list): 

44 return cls.deserialize_sample_block(serialized) 

45 

46 leaves: list[Sample] = [] 

47 

48 def deserialize( 

49 grid: NestedList[SerializedSampleBlockType], 

50 ) -> NestedList[Sample]: 

51 if isinstance(grid, list): 

52 if not grid: 

53 raise ValueError("Serialized sample contains an empty block grid") 

54 return [ 

55 deserialize(item) 

56 for item in cast(list[NestedList[SerializedSampleBlockType]], grid) 

57 ] 

58 

59 sample = cls.deserialize_sample_block(grid) 

60 leaves.append(sample) 

61 return sample 

62 

63 samples = deserialize(cast(NestedList[SerializedSampleBlockType], serialized)) 

64 first = leaves[0] 

65 for sample in leaves[1:]: 

66 if sample.id != first.id: 

67 raise ValueError("Sample blocks have different sample IDs") 

68 if sample.members.keys() != first.members.keys(): 

69 raise ValueError("Sample blocks have different members") 

70 if sample.applied_ops != first.applied_ops: 

71 raise ValueError("Sample blocks have different applied operators") 

72 if any(sample.members[m].dims != t.dims for m, t in first.members.items()): 

73 raise ValueError("Sample blocks have different member dimensions") 

74 

75 def select_arrays( 

76 grid: NestedList[Sample], member: MemberId 

77 ) -> NestedList[Array]: 

78 if isinstance(grid, list): 

79 return [select_arrays(item, member) for item in grid] 

80 return grid.members[member].data.data 

81 

82 members: dict[MemberId, Tensor] = {} 

83 for member, tensor in first.members.items(): 

84 block_impl = cast( 

85 Callable[[NestedList[Array]], Array], 

86 da.block 

87 if any( 

88 isinstance(s.members[member].data.data, da.Array) for s in leaves 

89 ) 

90 else np.block, 

91 ) 

92 members[member] = Tensor( 

93 block_impl(select_arrays(samples, member)), tensor.dims 

94 ) 

95 members[member].set_metadata(tensor.get_metadata()) 

96 

97 return Sample( 

98 id=first.id, 

99 members=members, 

100 stat=first.stat, 

101 applied_ops=first.applied_ops, 

102 ) 

103 

104 @classmethod 

105 def serialize_sample_blockwise( 

106 cls, 

107 sample: Sample, 

108 *, 

109 model: v0_5.ModelDescr, 

110 blocksize_parameter: int, 

111 batch_size: int = 1, 

112 ) -> NestedList[SerializedSampleBlockType]: 

113 """Serialize a non-overlapping grid with model-derived maximum block sizes. 

114 

115 Edge blocks may be smaller so deserialization reconstructs the original sample. 

116 """ 

117 

118 block_shape = model.get_tensor_sizes( 

119 blocksize_parameter, batch_size, sample.shape 

120 ).inputs 

121 return cls.serialize_sample_with_fixed_blocking( 

122 sample, 

123 block_shapes={ 

124 m: {a: AxisSize(min=1, max=size) for a, size in shape.items()} 

125 for m, shape in block_shape.items() 

126 }, 

127 halo={}, 

128 ) 

129 

130 @classmethod 

131 def serialize_sample_with_fixed_blocking( 

132 cls, 

133 sample: Sample, 

134 *, 

135 block_shapes: PerMember[PerAxis[int | AxisSize]], 

136 halo: PerMember[PerAxis[HaloLike]], 

137 pad_mode: PadMode | PerMember[PadMode] = "symmetric", 

138 ) -> NestedList[SerializedSampleBlockType]: 

139 """Serialize an aligned block grid, retaining each block's halo and overlap.""" 

140 

141 blocks = split_multiple_tensors_into_blocks( 

142 sample.members, 

143 block_shape=block_shapes, 

144 halo=halo, 

145 pad_mode=pad_mode, 

146 ) 

147 grid_shape = next(iter(blocks.values())).shape 

148 if any(size == 0 for size in grid_shape): 148 ↛ 149line 148 didn't jump to line 149 because the condition on line 148 was never true

149 raise ValueError("Sample has no blocks") 

150 

151 def serialize_grid( 

152 loc: tuple[int, ...] = (), 

153 ) -> NestedList[SerializedSampleBlockType]: 

154 if len(loc) < len(grid_shape): 

155 return [serialize_grid((*loc, i)) for i in range(grid_shape[len(loc)])] 

156 return cls.serialize_sample_block( 

157 Sample( 

158 id=sample.id, 

159 stat=sample.stat, 

160 applied_ops=sample.applied_ops, 

161 members={ 

162 m: cast(Block, b[loc]).outer_tensor for m, b in blocks.items() 

163 }, 

164 ) 

165 ) 

166 

167 return serialize_grid() 

168 

169 @staticmethod 

170 @abstractmethod 

171 def serialize_sample_block( 

172 sample_block: Sample, 

173 ) -> SerializedSampleBlockType: ... 

174 

175 @staticmethod 

176 @abstractmethod 

177 def deserialize_sample_block(serialized: SerializedSampleBlockType) -> Sample: 

178 """Deserialize one block into a sample."""