mrd-python 2.1.1__tar.gz → 2.2.1__tar.gz

{mrd_python-2.1.1 → mrd_python-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mrd-python
-Version: 2.1.1
+Version: 2.2.1
 Summary: Library and tools for working with data in the ISMRM Raw Data (MRD) format.
 Project-URL: Homepage, https://ismrmrd.github.io/mrd
 Project-URL: Documentation, https://ismrmrd.github.io/mrd
@@ -11,8 +11,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: h5py>=3.15.1
+Requires-Dist: ismrmrd>=1.14.2
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: pillow>=9.2.0
 

{mrd_python-2.1.1 → mrd_python-2.2.1}/mrd/__init__.py

@@ -26,6 +26,8 @@ from .types import (
     AcquisitionData,
     AcquisitionFlags,
     AcquisitionHeader,
+    AcquisitionPhase,
+    AcquisitionPrototype,
     AcquisitionSystemInformationType,
     AnyImage,
     Array,
@@ -70,6 +72,14 @@ from .types import (
     ParallelImagingType,
     PatientGender,
     PatientPosition,
+    PulseqADCEvent,
+    PulseqArbitraryGradient,
+    PulseqBlock,
+    PulseqDefinitions,
+    PulseqRFEvent,
+    PulseqShape,
+    PulseqTrapezoidalGradient,
+    RFPulseUse,
     ReconAssembly,
     ReconBuffer,
     ReconData,

{mrd_python-2.1.1 → mrd_python-2.2.1}/mrd/_binary.py

@@ -632,7 +632,7 @@ class Complex32Serializer(StructSerializer[ComplexFloat, np.complex64]):
         stream.write(self._struct, value.real, value.imag)
 
     def read(self, stream: CodedInputStream) -> ComplexFloat:
-        return ComplexFloat(*stream.read(self._struct))
+        return complex(*stream.read(self._struct))
 
     def read_numpy(self, stream: CodedInputStream) -> np.complex64:
         real, imag = stream.read(self._struct)
@@ -656,7 +656,7 @@ class Complex64Serializer(StructSerializer[ComplexDouble, np.complex128]):
         stream.write(self._struct, value.real, value.imag)
 
     def read(self, stream: CodedInputStream) -> ComplexDouble:
-        return ComplexDouble(*stream.read(self._struct))
+        return complex(*stream.read(self._struct))
 
     def read_numpy(self, stream: CodedInputStream) -> np.complex128:
         real, imag = stream.read(self._struct)
@@ -687,7 +687,7 @@ class StringSerializer(TypeSerializer[str, np.object_]):
         return str(view, "utf-8")
 
     def read_numpy(self, stream: CodedInputStream) -> np.object_:
-        return np.object_(self.read(stream))
+        return np.object_(self.read(stream))  # pyright: ignore [reportReturnType]
 
 
 string_serializer = StringSerializer()
@@ -770,7 +770,7 @@ class TimeSerializer(TypeSerializer[Time, np.timedelta64]):
 time_serializer = TimeSerializer()
 
 DATETIME_NANOSECONDS_DTYPE = np.dtype("datetime64[ns]")
-EPOCH_DATETIME = datetime.datetime.utcfromtimestamp(0)
+EPOCH_DATETIME = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
 
 
 class DateTimeSerializer(TypeSerializer[DateTime, np.datetime64]):
@@ -1034,7 +1034,7 @@ class VectorSerializer(Generic[T, T_NP], TypeSerializer[list[T], np.object_]):
         return [self._element_serializer.read(stream) for _ in range(length)]
 
     def read_numpy(self, stream: CodedInputStream) -> np.object_:
-        return np.object_(self.read(stream))
+        return np.object_(self.read(stream))  # pyright: ignore [reportReturnType]
 
 
 TKey = TypeVar("TKey")
@@ -1073,7 +1073,7 @@ class MapSerializer(
         }
 
     def read_numpy(self, stream: CodedInputStream) -> np.object_:
-        return np.object_(self.read(stream))
+        return np.object_(self.read(stream))  # pyright: ignore [reportReturnType]
 
 
 class NDArraySerializerBase(

{mrd_python-2.1.1 → mrd_python-2.2.1}/mrd/_dtypes.py

@@ -3,6 +3,7 @@
 
 import datetime
 from types import GenericAlias
+from typing import Annotated, Any
 import sys
 
 if sys.version_info >= (3, 10):
@@ -15,10 +16,13 @@ from . import yardl_types as yardl
 
 def make_get_dtype_func(
     dtype_map: dict[
-        Union[type, GenericAlias],
+        Union[type, GenericAlias, Annotated[Any, Any]],
         Union[np.dtype[Any], Callable[[tuple[type, ...]], np.dtype[Any]]],
-    ]
-) -> Callable[[Union[type, GenericAlias]], np.dtype[Any]]:
+    ],
+) -> Callable[
+    [Union[type, GenericAlias, Annotated[Any, Any]]],
+    np.dtype[Any],
+]:
     dtype_map[bool] = np.dtype(np.bool_)
     dtype_map[yardl.Int8] = np.dtype(np.int8)
     dtype_map[yardl.UInt8] = np.dtype(np.uint8)
@@ -50,7 +54,7 @@ def make_get_dtype_func(
 
     def get_dtype_impl(
         dtype_map: dict[
-            Union[type, GenericAlias],
+            Union[type, GenericAlias, Annotated[Any, Any]],
             Union[np.dtype[Any], Callable[[tuple[type, ...]], np.dtype[Any]]],
         ],
         t: Union[type, GenericAlias],
@@ -65,7 +69,8 @@ def make_get_dtype_func(
         origin = get_origin(t)
 
         if origin == Union or (
-            sys.version_info >= (3, 10) and isinstance(t, UnionType)
+            sys.version_info >= (3, 10)
+            and isinstance(t, UnionType)  # pyright: ignore[reportUnnecessaryIsInstance]
         ):
             return _get_union_dtype(get_args(t))
 

{mrd_python-2.1.1 → mrd_python-2.2.1}/mrd/_ndjson.py

@@ -568,7 +568,7 @@ class StringConverter(JsonConverter[str, np.object_]):
         return cast(str, json_object)
 
     def from_json_to_numpy(self, json_object: object) -> np.object_:
-        return np.object_(json_object)
+        return np.object_(json_object)  # pyright: ignore [reportReturnType]
 
 
 string_converter = StringConverter()

{mrd_python-2.1.1 → mrd_python-2.2.1}/mrd/binary.py

@@ -34,7 +34,7 @@ class BinaryMrdWriter(_binary.BinaryProtocolWriter, MrdWriterBase):
         _binary.OptionalSerializer(HeaderSerializer()).write(self._stream, value)
 
     def _write_data(self, value: collections.abc.Iterable[StreamItem]) -> None:
-        _binary.StreamSerializer(_binary.UnionSerializer(StreamItem, [(StreamItem.Acquisition, AcquisitionSerializer()), (StreamItem.WaveformUint32, WaveformSerializer(_binary.uint32_serializer)), (StreamItem.ImageUint16, ImageSerializer(_binary.uint16_serializer)), (StreamItem.ImageInt16, ImageSerializer(_binary.int16_serializer)), (StreamItem.ImageUint32, ImageSerializer(_binary.uint32_serializer)), (StreamItem.ImageInt32, ImageSerializer(_binary.int32_serializer)), (StreamItem.ImageFloat, ImageSerializer(_binary.float32_serializer)), (StreamItem.ImageDouble, ImageSerializer(_binary.float64_serializer)), (StreamItem.ImageComplexFloat, ImageSerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageComplexDouble, ImageSerializer(_binary.complexfloat64_serializer)), (StreamItem.AcquisitionBucket, AcquisitionBucketSerializer()), (StreamItem.ReconData, ReconDataSerializer()), (StreamItem.ArrayComplexFloat, _binary.DynamicNDArraySerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageArray, ImageArraySerializer())])).write(self._stream, value)
+        _binary.StreamSerializer(_binary.UnionSerializer(StreamItem, [(StreamItem.Acquisition, AcquisitionSerializer()), (StreamItem.AcquisitionPrototype, AcquisitionPrototypeSerializer()), (StreamItem.WaveformUint32, WaveformSerializer(_binary.uint32_serializer)), (StreamItem.ImageUint16, ImageSerializer(_binary.uint16_serializer)), (StreamItem.ImageInt16, ImageSerializer(_binary.int16_serializer)), (StreamItem.ImageUint32, ImageSerializer(_binary.uint32_serializer)), (StreamItem.ImageInt32, ImageSerializer(_binary.int32_serializer)), (StreamItem.ImageFloat, ImageSerializer(_binary.float32_serializer)), (StreamItem.ImageDouble, ImageSerializer(_binary.float64_serializer)), (StreamItem.ImageComplexFloat, ImageSerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageComplexDouble, ImageSerializer(_binary.complexfloat64_serializer)), (StreamItem.AcquisitionBucket, AcquisitionBucketSerializer()), (StreamItem.ReconData, ReconDataSerializer()), (StreamItem.ArrayComplexFloat, _binary.DynamicNDArraySerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageArray, ImageArraySerializer()), (StreamItem.PulseqDefinitions, PulseqDefinitionsSerializer()), (StreamItem.PulseqBlocks, _binary.VectorSerializer(PulseqBlockSerializer())), (StreamItem.PulseqRfEvent, PulseqRFEventSerializer()), (StreamItem.PulseqArbitraryGradient, PulseqArbitraryGradientSerializer()), (StreamItem.PulseqTrapezoidalGradient, PulseqTrapezoidalGradientSerializer()), (StreamItem.PulseqAdcEvent, PulseqADCEventSerializer()), (StreamItem.PulseqShape, PulseqShapeSerializer())])).write(self._stream, value)
 
 
 class BinaryMrdReader(_binary.BinaryProtocolReader, MrdReaderBase):
@@ -44,15 +44,15 @@ class BinaryMrdReader(_binary.BinaryProtocolReader, MrdReaderBase):
     """
 
 
-    def __init__(self, stream: typing.Union[io.BufferedReader, io.BytesIO, typing.BinaryIO, str]) -> None:
-        MrdReaderBase.__init__(self)
+    def __init__(self, stream: typing.Union[io.BufferedReader, io.BytesIO, typing.BinaryIO, str], skip_completed_check: bool = False) -> None:
+        MrdReaderBase.__init__(self, skip_completed_check)
         _binary.BinaryProtocolReader.__init__(self, stream, MrdReaderBase.schema)
 
     def _read_header(self) -> typing.Optional[Header]:
         return _binary.OptionalSerializer(HeaderSerializer()).read(self._stream)
 
     def _read_data(self) -> collections.abc.Iterable[StreamItem]:
-        return _binary.StreamSerializer(_binary.UnionSerializer(StreamItem, [(StreamItem.Acquisition, AcquisitionSerializer()), (StreamItem.WaveformUint32, WaveformSerializer(_binary.uint32_serializer)), (StreamItem.ImageUint16, ImageSerializer(_binary.uint16_serializer)), (StreamItem.ImageInt16, ImageSerializer(_binary.int16_serializer)), (StreamItem.ImageUint32, ImageSerializer(_binary.uint32_serializer)), (StreamItem.ImageInt32, ImageSerializer(_binary.int32_serializer)), (StreamItem.ImageFloat, ImageSerializer(_binary.float32_serializer)), (StreamItem.ImageDouble, ImageSerializer(_binary.float64_serializer)), (StreamItem.ImageComplexFloat, ImageSerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageComplexDouble, ImageSerializer(_binary.complexfloat64_serializer)), (StreamItem.AcquisitionBucket, AcquisitionBucketSerializer()), (StreamItem.ReconData, ReconDataSerializer()), (StreamItem.ArrayComplexFloat, _binary.DynamicNDArraySerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageArray, ImageArraySerializer())])).read(self._stream)
+        return _binary.StreamSerializer(_binary.UnionSerializer(StreamItem, [(StreamItem.Acquisition, AcquisitionSerializer()), (StreamItem.AcquisitionPrototype, AcquisitionPrototypeSerializer()), (StreamItem.WaveformUint32, WaveformSerializer(_binary.uint32_serializer)), (StreamItem.ImageUint16, ImageSerializer(_binary.uint16_serializer)), (StreamItem.ImageInt16, ImageSerializer(_binary.int16_serializer)), (StreamItem.ImageUint32, ImageSerializer(_binary.uint32_serializer)), (StreamItem.ImageInt32, ImageSerializer(_binary.int32_serializer)), (StreamItem.ImageFloat, ImageSerializer(_binary.float32_serializer)), (StreamItem.ImageDouble, ImageSerializer(_binary.float64_serializer)), (StreamItem.ImageComplexFloat, ImageSerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageComplexDouble, ImageSerializer(_binary.complexfloat64_serializer)), (StreamItem.AcquisitionBucket, AcquisitionBucketSerializer()), (StreamItem.ReconData, ReconDataSerializer()), (StreamItem.ArrayComplexFloat, _binary.DynamicNDArraySerializer(_binary.complexfloat32_serializer)), (StreamItem.ImageArray, ImageArraySerializer()), (StreamItem.PulseqDefinitions, PulseqDefinitionsSerializer()), (StreamItem.PulseqBlocks, _binary.VectorSerializer(PulseqBlockSerializer())), (StreamItem.PulseqRfEvent, PulseqRFEventSerializer()), (StreamItem.PulseqArbitraryGradient, PulseqArbitraryGradientSerializer()), (StreamItem.PulseqTrapezoidalGradient, PulseqTrapezoidalGradientSerializer()), (StreamItem.PulseqAdcEvent, PulseqADCEventSerializer()), (StreamItem.PulseqShape, PulseqShapeSerializer())])).read(self._stream)
 
 class BinaryMrdNoiseCovarianceWriter(_binary.BinaryProtocolWriter, MrdNoiseCovarianceWriterBase):
     """Binary writer for the MrdNoiseCovariance protocol.
@@ -76,8 +76,8 @@ class BinaryMrdNoiseCovarianceReader(_binary.BinaryProtocolReader, MrdNoiseCovar
     """
 
 
-    def __init__(self, stream: typing.Union[io.BufferedReader, io.BytesIO, typing.BinaryIO, str]) -> None:
-        MrdNoiseCovarianceReaderBase.__init__(self)
+    def __init__(self, stream: typing.Union[io.BufferedReader, io.BytesIO, typing.BinaryIO, str], skip_completed_check: bool = False) -> None:
+        MrdNoiseCovarianceReaderBase.__init__(self, skip_completed_check)
         _binary.BinaryProtocolReader.__init__(self, stream, MrdNoiseCovarianceReaderBase.schema)
 
     def _read_noise_covariance(self) -> NoiseCovariance:
@@ -103,38 +103,56 @@ class EncodingCountersSerializer(_binary.RecordSerializer[EncodingCounters]):
 
 class AcquisitionHeaderSerializer(_binary.RecordSerializer[AcquisitionHeader]):
     def __init__(self) -> None:
-        super().__init__([("flags", _binary.EnumSerializer(_binary.uint64_serializer, AcquisitionFlags)), ("idx", EncodingCountersSerializer()), ("measurement_uid", _binary.uint32_serializer), ("scan_counter", _binary.OptionalSerializer(_binary.uint32_serializer)), ("acquisition_time_stamp", _binary.OptionalSerializer(_binary.uint32_serializer)), ("physiology_time_stamp", _binary.VectorSerializer(_binary.uint32_serializer)), ("channel_order", _binary.VectorSerializer(_binary.uint32_serializer)), ("discard_pre", _binary.OptionalSerializer(_binary.uint32_serializer)), ("discard_post", _binary.OptionalSerializer(_binary.uint32_serializer)), ("center_sample", _binary.OptionalSerializer(_binary.uint32_serializer)), ("encoding_space_ref", _binary.OptionalSerializer(_binary.uint32_serializer)), ("sample_time_us", _binary.OptionalSerializer(_binary.float32_serializer)), ("position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("read_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("phase_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("slice_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("patient_table_position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("user_int", _binary.VectorSerializer(_binary.int32_serializer)), ("user_float", _binary.VectorSerializer(_binary.float32_serializer))])
+        super().__init__([("flags", _binary.EnumSerializer(_binary.uint64_serializer, AcquisitionFlags)), ("idx", EncodingCountersSerializer()), ("measurement_uid", _binary.uint32_serializer), ("scan_counter", _binary.OptionalSerializer(_binary.uint32_serializer)), ("acquisition_center_frequency", _binary.OptionalSerializer(_binary.uint64_serializer)), ("acquisition_time_stamp_ns", _binary.OptionalSerializer(_binary.uint64_serializer)), ("physiology_time_stamp_ns", _binary.VectorSerializer(_binary.uint64_serializer)), ("channel_order", _binary.VectorSerializer(_binary.uint32_serializer)), ("discard_pre", _binary.OptionalSerializer(_binary.uint32_serializer)), ("discard_post", _binary.OptionalSerializer(_binary.uint32_serializer)), ("center_sample", _binary.OptionalSerializer(_binary.uint32_serializer)), ("encoding_space_ref", _binary.OptionalSerializer(_binary.uint32_serializer)), ("sample_time_ns", _binary.OptionalSerializer(_binary.uint64_serializer)), ("position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("read_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("phase_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("slice_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("patient_table_position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("user_int", _binary.VectorSerializer(_binary.int32_serializer)), ("user_float", _binary.VectorSerializer(_binary.float32_serializer))])
 
     def write(self, stream: _binary.CodedOutputStream, value: AcquisitionHeader) -> None:
         if isinstance(value, np.void):
             self.write_numpy(stream, value)
             return
-        self._write(stream, value.flags, value.idx, value.measurement_uid, value.scan_counter, value.acquisition_time_stamp, value.physiology_time_stamp, value.channel_order, value.discard_pre, value.discard_post, value.center_sample, value.encoding_space_ref, value.sample_time_us, value.position, value.read_dir, value.phase_dir, value.slice_dir, value.patient_table_position, value.user_int, value.user_float)
+        self._write(stream, value.flags, value.idx, value.measurement_uid, value.scan_counter, value.acquisition_center_frequency, value.acquisition_time_stamp_ns, value.physiology_time_stamp_ns, value.channel_order, value.discard_pre, value.discard_post, value.center_sample, value.encoding_space_ref, value.sample_time_ns, value.position, value.read_dir, value.phase_dir, value.slice_dir, value.patient_table_position, value.user_int, value.user_float)
 
     def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
-        self._write(stream, value['flags'], value['idx'], value['measurement_uid'], value['scan_counter'], value['acquisition_time_stamp'], value['physiology_time_stamp'], value['channel_order'], value['discard_pre'], value['discard_post'], value['center_sample'], value['encoding_space_ref'], value['sample_time_us'], value['position'], value['read_dir'], value['phase_dir'], value['slice_dir'], value['patient_table_position'], value['user_int'], value['user_float'])
+        self._write(stream, value['flags'], value['idx'], value['measurement_uid'], value['scan_counter'], value['acquisition_center_frequency'], value['acquisition_time_stamp_ns'], value['physiology_time_stamp_ns'], value['channel_order'], value['discard_pre'], value['discard_post'], value['center_sample'], value['encoding_space_ref'], value['sample_time_ns'], value['position'], value['read_dir'], value['phase_dir'], value['slice_dir'], value['patient_table_position'], value['user_int'], value['user_float'])
 
     def read(self, stream: _binary.CodedInputStream) -> AcquisitionHeader:
         field_values = self._read(stream)
-        return AcquisitionHeader(flags=field_values[0], idx=field_values[1], measurement_uid=field_values[2], scan_counter=field_values[3], acquisition_time_stamp=field_values[4], physiology_time_stamp=field_values[5], channel_order=field_values[6], discard_pre=field_values[7], discard_post=field_values[8], center_sample=field_values[9], encoding_space_ref=field_values[10], sample_time_us=field_values[11], position=field_values[12], read_dir=field_values[13], phase_dir=field_values[14], slice_dir=field_values[15], patient_table_position=field_values[16], user_int=field_values[17], user_float=field_values[18])
+        return AcquisitionHeader(flags=field_values[0], idx=field_values[1], measurement_uid=field_values[2], scan_counter=field_values[3], acquisition_center_frequency=field_values[4], acquisition_time_stamp_ns=field_values[5], physiology_time_stamp_ns=field_values[6], channel_order=field_values[7], discard_pre=field_values[8], discard_post=field_values[9], center_sample=field_values[10], encoding_space_ref=field_values[11], sample_time_ns=field_values[12], position=field_values[13], read_dir=field_values[14], phase_dir=field_values[15], slice_dir=field_values[16], patient_table_position=field_values[17], user_int=field_values[18], user_float=field_values[19])
 
 
 class AcquisitionSerializer(_binary.RecordSerializer[Acquisition]):
     def __init__(self) -> None:
-        super().__init__([("head", AcquisitionHeaderSerializer()), ("data", _binary.NDArraySerializer(_binary.complexfloat32_serializer, 2)), ("trajectory", _binary.NDArraySerializer(_binary.float32_serializer, 2))])
+        super().__init__([("head", AcquisitionHeaderSerializer()), ("data", _binary.NDArraySerializer(_binary.complexfloat32_serializer, 2)), ("phase", _binary.OptionalSerializer(_binary.NDArraySerializer(_binary.float32_serializer, 1))), ("trajectory", _binary.NDArraySerializer(_binary.float32_serializer, 2))])
 
     def write(self, stream: _binary.CodedOutputStream, value: Acquisition) -> None:
         if isinstance(value, np.void):
             self.write_numpy(stream, value)
             return
-        self._write(stream, value.head, value.data, value.trajectory)
+        self._write(stream, value.head, value.data, value.phase, value.trajectory)
 
     def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
-        self._write(stream, value['head'], value['data'], value['trajectory'])
+        self._write(stream, value['head'], value['data'], value['phase'], value['trajectory'])
 
     def read(self, stream: _binary.CodedInputStream) -> Acquisition:
         field_values = self._read(stream)
-        return Acquisition(head=field_values[0], data=field_values[1], trajectory=field_values[2])
+        return Acquisition(head=field_values[0], data=field_values[1], phase=field_values[2], trajectory=field_values[3])
+
+
+class AcquisitionPrototypeSerializer(_binary.RecordSerializer[AcquisitionPrototype]):
+    def __init__(self) -> None:
+        super().__init__([("head", AcquisitionHeaderSerializer()), ("data_sample_counts", _binary.NDArraySerializer(_binary.uint32_serializer, 1))])
+
+    def write(self, stream: _binary.CodedOutputStream, value: AcquisitionPrototype) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.head, value.data_sample_counts)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['head'], value['data_sample_counts'])
+
+    def read(self, stream: _binary.CodedInputStream) -> AcquisitionPrototype:
+        field_values = self._read(stream)
+        return AcquisitionPrototype(head=field_values[0], data_sample_counts=field_values[1])
 
 
 class SubjectInformationTypeSerializer(_binary.RecordSerializer[SubjectInformationType]):
@@ -679,20 +697,20 @@ class HeaderSerializer(_binary.RecordSerializer[Header]):
 
 class ImageHeaderSerializer(_binary.RecordSerializer[ImageHeader]):
     def __init__(self) -> None:
-        super().__init__([("flags", _binary.EnumSerializer(_binary.uint64_serializer, ImageFlags)), ("measurement_uid", _binary.uint32_serializer), ("field_of_view", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("col_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("line_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("slice_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("patient_table_position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("average", _binary.OptionalSerializer(_binary.uint32_serializer)), ("slice", _binary.OptionalSerializer(_binary.uint32_serializer)), ("contrast", _binary.OptionalSerializer(_binary.uint32_serializer)), ("phase", _binary.OptionalSerializer(_binary.uint32_serializer)), ("repetition", _binary.OptionalSerializer(_binary.uint32_serializer)), ("set", _binary.OptionalSerializer(_binary.uint32_serializer)), ("acquisition_time_stamp", _binary.OptionalSerializer(_binary.uint32_serializer)), ("physiology_time_stamp", _binary.VectorSerializer(_binary.uint32_serializer)), ("image_type", _binary.EnumSerializer(_binary.int32_serializer, ImageType)), ("image_index", _binary.OptionalSerializer(_binary.uint32_serializer)), ("image_series_index", _binary.OptionalSerializer(_binary.uint32_serializer)), ("user_int", _binary.VectorSerializer(_binary.int32_serializer)), ("user_float", _binary.VectorSerializer(_binary.float32_serializer))])
+        super().__init__([("flags", _binary.EnumSerializer(_binary.uint64_serializer, ImageFlags)), ("measurement_uid", _binary.uint32_serializer), ("field_of_view", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("col_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("line_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("slice_dir", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("patient_table_position", _binary.FixedNDArraySerializer(_binary.float32_serializer, (3,))), ("average", _binary.OptionalSerializer(_binary.uint32_serializer)), ("slice", _binary.OptionalSerializer(_binary.uint32_serializer)), ("contrast", _binary.OptionalSerializer(_binary.uint32_serializer)), ("phase", _binary.OptionalSerializer(_binary.uint32_serializer)), ("repetition", _binary.OptionalSerializer(_binary.uint32_serializer)), ("set", _binary.OptionalSerializer(_binary.uint32_serializer)), ("acquisition_time_stamp_ns", _binary.OptionalSerializer(_binary.uint64_serializer)), ("physiology_time_stamp_ns", _binary.VectorSerializer(_binary.uint64_serializer)), ("image_type", _binary.EnumSerializer(_binary.int32_serializer, ImageType)), ("image_index", _binary.OptionalSerializer(_binary.uint32_serializer)), ("image_series_index", _binary.OptionalSerializer(_binary.uint32_serializer)), ("user_int", _binary.VectorSerializer(_binary.int32_serializer)), ("user_float", _binary.VectorSerializer(_binary.float32_serializer))])
 
     def write(self, stream: _binary.CodedOutputStream, value: ImageHeader) -> None:
         if isinstance(value, np.void):
             self.write_numpy(stream, value)
             return
-        self._write(stream, value.flags, value.measurement_uid, value.field_of_view, value.position, value.col_dir, value.line_dir, value.slice_dir, value.patient_table_position, value.average, value.slice, value.contrast, value.phase, value.repetition, value.set, value.acquisition_time_stamp, value.physiology_time_stamp, value.image_type, value.image_index, value.image_series_index, value.user_int, value.user_float)
+        self._write(stream, value.flags, value.measurement_uid, value.field_of_view, value.position, value.col_dir, value.line_dir, value.slice_dir, value.patient_table_position, value.average, value.slice, value.contrast, value.phase, value.repetition, value.set, value.acquisition_time_stamp_ns, value.physiology_time_stamp_ns, value.image_type, value.image_index, value.image_series_index, value.user_int, value.user_float)
 
     def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
-        self._write(stream, value['flags'], value['measurement_uid'], value['field_of_view'], value['position'], value['col_dir'], value['line_dir'], value['slice_dir'], value['patient_table_position'], value['average'], value['slice'], value['contrast'], value['phase'], value['repetition'], value['set'], value['acquisition_time_stamp'], value['physiology_time_stamp'], value['image_type'], value['image_index'], value['image_series_index'], value['user_int'], value['user_float'])
+        self._write(stream, value['flags'], value['measurement_uid'], value['field_of_view'], value['position'], value['col_dir'], value['line_dir'], value['slice_dir'], value['patient_table_position'], value['average'], value['slice'], value['contrast'], value['phase'], value['repetition'], value['set'], value['acquisition_time_stamp_ns'], value['physiology_time_stamp_ns'], value['image_type'], value['image_index'], value['image_series_index'], value['user_int'], value['user_float'])
 
     def read(self, stream: _binary.CodedInputStream) -> ImageHeader:
         field_values = self._read(stream)
-        return ImageHeader(flags=field_values[0], measurement_uid=field_values[1], field_of_view=field_values[2], position=field_values[3], col_dir=field_values[4], line_dir=field_values[5], slice_dir=field_values[6], patient_table_position=field_values[7], average=field_values[8], slice=field_values[9], contrast=field_values[10], phase=field_values[11], repetition=field_values[12], set=field_values[13], acquisition_time_stamp=field_values[14], physiology_time_stamp=field_values[15], image_type=field_values[16], image_index=field_values[17], image_series_index=field_values[18], user_int=field_values[19], user_float=field_values[20])
+        return ImageHeader(flags=field_values[0], measurement_uid=field_values[1], field_of_view=field_values[2], position=field_values[3], col_dir=field_values[4], line_dir=field_values[5], slice_dir=field_values[6], patient_table_position=field_values[7], average=field_values[8], slice=field_values[9], contrast=field_values[10], phase=field_values[11], repetition=field_values[12], set=field_values[13], acquisition_time_stamp_ns=field_values[14], physiology_time_stamp_ns=field_values[15], image_type=field_values[16], image_index=field_values[17], image_series_index=field_values[18], user_int=field_values[19], user_float=field_values[20])
 
 
 class ImageSerializer(typing.Generic[T, T_NP], _binary.RecordSerializer[Image[T_NP]]):
@@ -715,38 +733,38 @@ class ImageSerializer(typing.Generic[T, T_NP], _binary.RecordSerializer[Image[T_
 
 class NoiseCovarianceSerializer(_binary.RecordSerializer[NoiseCovariance]):
     def __init__(self) -> None:
-        super().__init__([("coil_labels", _binary.VectorSerializer(CoilLabelTypeSerializer())), ("receiver_noise_bandwidth", _binary.float32_serializer), ("noise_dwell_time_us", _binary.float32_serializer), ("sample_count", _binary.size_serializer), ("matrix", _binary.NDArraySerializer(_binary.complexfloat32_serializer, 2))])
+        super().__init__([("coil_labels", _binary.VectorSerializer(CoilLabelTypeSerializer())), ("receiver_noise_bandwidth", _binary.float32_serializer), ("noise_dwell_time_ns", _binary.uint64_serializer), ("sample_count", _binary.size_serializer), ("matrix", _binary.NDArraySerializer(_binary.complexfloat32_serializer, 2))])
 
     def write(self, stream: _binary.CodedOutputStream, value: NoiseCovariance) -> None:
         if isinstance(value, np.void):
             self.write_numpy(stream, value)
             return
-        self._write(stream, value.coil_labels, value.receiver_noise_bandwidth, value.noise_dwell_time_us, value.sample_count, value.matrix)
+        self._write(stream, value.coil_labels, value.receiver_noise_bandwidth, value.noise_dwell_time_ns, value.sample_count, value.matrix)
 
     def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
-        self._write(stream, value['coil_labels'], value['receiver_noise_bandwidth'], value['noise_dwell_time_us'], value['sample_count'], value['matrix'])
+        self._write(stream, value['coil_labels'], value['receiver_noise_bandwidth'], value['noise_dwell_time_ns'], value['sample_count'], value['matrix'])
 
     def read(self, stream: _binary.CodedInputStream) -> NoiseCovariance:
         field_values = self._read(stream)
-        return NoiseCovariance(coil_labels=field_values[0], receiver_noise_bandwidth=field_values[1], noise_dwell_time_us=field_values[2], sample_count=field_values[3], matrix=field_values[4])
+        return NoiseCovariance(coil_labels=field_values[0], receiver_noise_bandwidth=field_values[1], noise_dwell_time_ns=field_values[2], sample_count=field_values[3], matrix=field_values[4])
 
 
 class WaveformSerializer(typing.Generic[T, T_NP], _binary.RecordSerializer[Waveform[T_NP]]):
     def __init__(self, t_serializer: _binary.TypeSerializer[T, T_NP]) -> None:
-        super().__init__([("flags", _binary.uint64_serializer), ("measurement_uid", _binary.uint32_serializer), ("scan_counter", _binary.uint32_serializer), ("time_stamp", _binary.uint32_serializer), ("sample_time_us", _binary.float32_serializer), ("waveform_id", _binary.uint32_serializer), ("data", _binary.NDArraySerializer(t_serializer, 2))])
+        super().__init__([("flags", _binary.uint64_serializer), ("measurement_uid", _binary.uint32_serializer), ("scan_counter", _binary.uint32_serializer), ("time_stamp_ns", _binary.uint64_serializer), ("sample_time_ns", _binary.uint64_serializer), ("waveform_id", _binary.uint32_serializer), ("data", _binary.NDArraySerializer(t_serializer, 2))])
 
     def write(self, stream: _binary.CodedOutputStream, value: Waveform[T_NP]) -> None:
         if isinstance(value, np.void):
             self.write_numpy(stream, value)
             return
-        self._write(stream, value.flags, value.measurement_uid, value.scan_counter, value.time_stamp, value.sample_time_us, value.waveform_id, value.data)
+        self._write(stream, value.flags, value.measurement_uid, value.scan_counter, value.time_stamp_ns, value.sample_time_ns, value.waveform_id, value.data)
 
     def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
-        self._write(stream, value['flags'], value['measurement_uid'], value['scan_counter'], value['time_stamp'], value['sample_time_us'], value['waveform_id'], value['data'])
+        self._write(stream, value['flags'], value['measurement_uid'], value['scan_counter'], value['time_stamp_ns'], value['sample_time_ns'], value['waveform_id'], value['data'])
 
     def read(self, stream: _binary.CodedInputStream) -> Waveform[T_NP]:
         field_values = self._read(stream)
-        return Waveform[T_NP](flags=field_values[0], measurement_uid=field_values[1], scan_counter=field_values[2], time_stamp=field_values[3], sample_time_us=field_values[4], waveform_id=field_values[5], data=field_values[6])
+        return Waveform[T_NP](flags=field_values[0], measurement_uid=field_values[1], scan_counter=field_values[2], time_stamp_ns=field_values[3], sample_time_ns=field_values[4], waveform_id=field_values[5], data=field_values[6])
 
 
 class AcquisitionBucketSerializer(_binary.RecordSerializer[AcquisitionBucket]):
@@ -875,3 +893,129 @@ class ImageArraySerializer(_binary.RecordSerializer[ImageArray]):
         return ImageArray(data=field_values[0], headers=field_values[1], meta=field_values[2], waveforms=field_values[3])
 
 
+class PulseqDefinitionsSerializer(_binary.RecordSerializer[PulseqDefinitions]):
+    def __init__(self) -> None:
+        super().__init__([("gradient_raster_time", _binary.float64_serializer), ("radiofrequency_raster_time", _binary.float64_serializer), ("adc_raster_time", _binary.float64_serializer), ("block_duration_raster", _binary.float64_serializer), ("name", _binary.OptionalSerializer(_binary.string_serializer)), ("fov", _binary.OptionalSerializer(ThreeDimensionalFloatSerializer())), ("total_duration", _binary.OptionalSerializer(_binary.float64_serializer)), ("custom", _binary.MapSerializer(_binary.string_serializer, _binary.string_serializer))])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqDefinitions) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.gradient_raster_time, value.radiofrequency_raster_time, value.adc_raster_time, value.block_duration_raster, value.name, value.fov, value.total_duration, value.custom)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['gradient_raster_time'], value['radiofrequency_raster_time'], value['adc_raster_time'], value['block_duration_raster'], value['name'], value['fov'], value['total_duration'], value['custom'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqDefinitions:
+        field_values = self._read(stream)
+        return PulseqDefinitions(gradient_raster_time=field_values[0], radiofrequency_raster_time=field_values[1], adc_raster_time=field_values[2], block_duration_raster=field_values[3], name=field_values[4], fov=field_values[5], total_duration=field_values[6], custom=field_values[7])
+
+
+class PulseqBlockSerializer(_binary.RecordSerializer[PulseqBlock]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("duration", _binary.uint64_serializer), ("rf", _binary.int32_serializer), ("gx", _binary.int32_serializer), ("gy", _binary.int32_serializer), ("gz", _binary.int32_serializer), ("adc", _binary.int32_serializer), ("ext", _binary.int32_serializer)])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqBlock) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.duration, value.rf, value.gx, value.gy, value.gz, value.adc, value.ext)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['duration'], value['rf'], value['gx'], value['gy'], value['gz'], value['adc'], value['ext'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqBlock:
+        field_values = self._read(stream)
+        return PulseqBlock(id=field_values[0], duration=field_values[1], rf=field_values[2], gx=field_values[3], gy=field_values[4], gz=field_values[5], adc=field_values[6], ext=field_values[7])
+
+
+class PulseqRFEventSerializer(_binary.RecordSerializer[PulseqRFEvent]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("amp", _binary.float64_serializer), ("mag_id", _binary.int32_serializer), ("phase_id", _binary.int32_serializer), ("time_id", _binary.int32_serializer), ("center", _binary.float64_serializer), ("delay", _binary.uint64_serializer), ("freq_ppm", _binary.float64_serializer), ("phase_ppm", _binary.float64_serializer), ("freq_offset", _binary.float64_serializer), ("phase_offset", _binary.float64_serializer), ("use", _binary.EnumSerializer(_binary.int32_serializer, RFPulseUse))])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqRFEvent) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.amp, value.mag_id, value.phase_id, value.time_id, value.center, value.delay, value.freq_ppm, value.phase_ppm, value.freq_offset, value.phase_offset, value.use)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['amp'], value['mag_id'], value['phase_id'], value['time_id'], value['center'], value['delay'], value['freq_ppm'], value['phase_ppm'], value['freq_offset'], value['phase_offset'], value['use'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqRFEvent:
+        field_values = self._read(stream)
+        return PulseqRFEvent(id=field_values[0], amp=field_values[1], mag_id=field_values[2], phase_id=field_values[3], time_id=field_values[4], center=field_values[5], delay=field_values[6], freq_ppm=field_values[7], phase_ppm=field_values[8], freq_offset=field_values[9], phase_offset=field_values[10], use=field_values[11])
+
+
+class PulseqArbitraryGradientSerializer(_binary.RecordSerializer[PulseqArbitraryGradient]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("amp", _binary.float64_serializer), ("first", _binary.float64_serializer), ("last", _binary.float64_serializer), ("shape_id", _binary.int32_serializer), ("time_id", _binary.int32_serializer), ("delay", _binary.uint64_serializer)])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqArbitraryGradient) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.amp, value.first, value.last, value.shape_id, value.time_id, value.delay)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['amp'], value['first'], value['last'], value['shape_id'], value['time_id'], value['delay'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqArbitraryGradient:
+        field_values = self._read(stream)
+        return PulseqArbitraryGradient(id=field_values[0], amp=field_values[1], first=field_values[2], last=field_values[3], shape_id=field_values[4], time_id=field_values[5], delay=field_values[6])
+
+
+class PulseqTrapezoidalGradientSerializer(_binary.RecordSerializer[PulseqTrapezoidalGradient]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("amp", _binary.float64_serializer), ("rise", _binary.uint64_serializer), ("flat", _binary.uint64_serializer), ("fall", _binary.uint64_serializer), ("delay", _binary.uint64_serializer)])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqTrapezoidalGradient) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.amp, value.rise, value.flat, value.fall, value.delay)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['amp'], value['rise'], value['flat'], value['fall'], value['delay'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqTrapezoidalGradient:
+        field_values = self._read(stream)
+        return PulseqTrapezoidalGradient(id=field_values[0], amp=field_values[1], rise=field_values[2], flat=field_values[3], fall=field_values[4], delay=field_values[5])
+
+
+class PulseqADCEventSerializer(_binary.RecordSerializer[PulseqADCEvent]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("num", _binary.uint64_serializer), ("dwell", _binary.float32_serializer), ("delay", _binary.uint64_serializer), ("freq_ppm", _binary.float64_serializer), ("phase_ppm", _binary.float64_serializer), ("freq", _binary.float64_serializer), ("phase", _binary.float64_serializer), ("phase_shape_id", _binary.int32_serializer)])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqADCEvent) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.num, value.dwell, value.delay, value.freq_ppm, value.phase_ppm, value.freq, value.phase, value.phase_shape_id)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['num'], value['dwell'], value['delay'], value['freq_ppm'], value['phase_ppm'], value['freq'], value['phase'], value['phase_shape_id'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqADCEvent:
+        field_values = self._read(stream)
+        return PulseqADCEvent(id=field_values[0], num=field_values[1], dwell=field_values[2], delay=field_values[3], freq_ppm=field_values[4], phase_ppm=field_values[5], freq=field_values[6], phase=field_values[7], phase_shape_id=field_values[8])
+
+
+class PulseqShapeSerializer(_binary.RecordSerializer[PulseqShape]):
+    def __init__(self) -> None:
+        super().__init__([("id", _binary.int32_serializer), ("num_samples", _binary.uint64_serializer), ("data", _binary.NDArraySerializer(_binary.float64_serializer, 1))])
+
+    def write(self, stream: _binary.CodedOutputStream, value: PulseqShape) -> None:
+        if isinstance(value, np.void):
+            self.write_numpy(stream, value)
+            return
+        self._write(stream, value.id, value.num_samples, value.data)
+
+    def write_numpy(self, stream: _binary.CodedOutputStream, value: np.void) -> None:
+        self._write(stream, value['id'], value['num_samples'], value['data'])
+
+    def read(self, stream: _binary.CodedInputStream) -> PulseqShape:
+        field_values = self._read(stream)
+        return PulseqShape(id=field_values[0], num_samples=field_values[1], data=field_values[2])
+
+