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
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 09:46 +0000
1from __future__ import annotations
3from abc import ABC, abstractmethod
4from collections.abc import Callable
5from typing import (
6 Generic,
7 TypeVar,
8 cast,
9)
11import dask.array as da
12import numpy as np
14from bioimageio.spec.model import v0_5
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
23SerializedSampleBlockType = TypeVar("SerializedSampleBlockType")
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."""
34 return cls.serialize_sample_block(sample)
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."""
43 if not isinstance(serialized, list):
44 return cls.deserialize_sample_block(serialized)
46 leaves: list[Sample] = []
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 ]
59 sample = cls.deserialize_sample_block(grid)
60 leaves.append(sample)
61 return sample
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")
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
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())
97 return Sample(
98 id=first.id,
99 members=members,
100 stat=first.stat,
101 applied_ops=first.applied_ops,
102 )
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.
115 Edge blocks may be smaller so deserialization reconstructs the original sample.
116 """
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 )
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."""
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")
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 )
167 return serialize_grid()
169 @staticmethod
170 @abstractmethod
171 def serialize_sample_block(
172 sample_block: Sample,
173 ) -> SerializedSampleBlockType: ...
175 @staticmethod
176 @abstractmethod
177 def deserialize_sample_block(serialized: SerializedSampleBlockType) -> Sample:
178 """Deserialize one block into a sample."""