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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mrd-python
-Version: 2.1.1
+Version: 2.2.0
 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,9 @@ 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: 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.0}/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.0}/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.0}/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.0}/mrd/binary.py

@@ -44,8 +44,8 @@ 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]:
@@ -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,20 +103,20 @@ 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_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_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_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_time_stamp_ns=field_values[4], physiology_time_stamp_ns=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_ns=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])
 
 
 class AcquisitionSerializer(_binary.RecordSerializer[Acquisition]):
@@ -679,20 +679,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 +715,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]):

{mrd_python-2.1.1 → mrd_python-2.2.0}/mrd/ndjson.py

@@ -170,14 +170,14 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
         self._idx_converter = EncodingCountersConverter()
         self._measurement_uid_converter = _ndjson.uint32_converter
         self._scan_counter_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
-        self._acquisition_time_stamp_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
-        self._physiology_time_stamp_converter = _ndjson.VectorConverter(_ndjson.uint32_converter)
+        self._acquisition_time_stamp_ns_converter = _ndjson.OptionalConverter(_ndjson.uint64_converter)
+        self._physiology_time_stamp_ns_converter = _ndjson.VectorConverter(_ndjson.uint64_converter)
         self._channel_order_converter = _ndjson.VectorConverter(_ndjson.uint32_converter)
         self._discard_pre_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._discard_post_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._center_sample_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._encoding_space_ref_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
-        self._sample_time_us_converter = _ndjson.OptionalConverter(_ndjson.float32_converter)
+        self._sample_time_ns_converter = _ndjson.OptionalConverter(_ndjson.uint64_converter)
         self._position_converter = _ndjson.FixedNDArrayConverter(_ndjson.float32_converter, (3,))
         self._read_dir_converter = _ndjson.FixedNDArrayConverter(_ndjson.float32_converter, (3,))
         self._phase_dir_converter = _ndjson.FixedNDArrayConverter(_ndjson.float32_converter, (3,))
@@ -190,14 +190,14 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
             ("idx", self._idx_converter.overall_dtype()),
             ("measurement_uid", self._measurement_uid_converter.overall_dtype()),
             ("scan_counter", self._scan_counter_converter.overall_dtype()),
-            ("acquisition_time_stamp", self._acquisition_time_stamp_converter.overall_dtype()),
-            ("physiology_time_stamp", self._physiology_time_stamp_converter.overall_dtype()),
+            ("acquisition_time_stamp_ns", self._acquisition_time_stamp_ns_converter.overall_dtype()),
+            ("physiology_time_stamp_ns", self._physiology_time_stamp_ns_converter.overall_dtype()),
             ("channel_order", self._channel_order_converter.overall_dtype()),
             ("discard_pre", self._discard_pre_converter.overall_dtype()),
             ("discard_post", self._discard_post_converter.overall_dtype()),
             ("center_sample", self._center_sample_converter.overall_dtype()),
             ("encoding_space_ref", self._encoding_space_ref_converter.overall_dtype()),
-            ("sample_time_us", self._sample_time_us_converter.overall_dtype()),
+            ("sample_time_ns", self._sample_time_ns_converter.overall_dtype()),
             ("position", self._position_converter.overall_dtype()),
             ("read_dir", self._read_dir_converter.overall_dtype()),
             ("phase_dir", self._phase_dir_converter.overall_dtype()),
@@ -217,9 +217,9 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
         json_object["measurementUid"] = self._measurement_uid_converter.to_json(value.measurement_uid)
         if value.scan_counter is not None:
             json_object["scanCounter"] = self._scan_counter_converter.to_json(value.scan_counter)
-        if value.acquisition_time_stamp is not None:
-            json_object["acquisitionTimeStamp"] = self._acquisition_time_stamp_converter.to_json(value.acquisition_time_stamp)
-        json_object["physiologyTimeStamp"] = self._physiology_time_stamp_converter.to_json(value.physiology_time_stamp)
+        if value.acquisition_time_stamp_ns is not None:
+            json_object["acquisitionTimeStampNs"] = self._acquisition_time_stamp_ns_converter.to_json(value.acquisition_time_stamp_ns)
+        json_object["physiologyTimeStampNs"] = self._physiology_time_stamp_ns_converter.to_json(value.physiology_time_stamp_ns)
         json_object["channelOrder"] = self._channel_order_converter.to_json(value.channel_order)
         if value.discard_pre is not None:
             json_object["discardPre"] = self._discard_pre_converter.to_json(value.discard_pre)
@@ -229,8 +229,8 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
             json_object["centerSample"] = self._center_sample_converter.to_json(value.center_sample)
         if value.encoding_space_ref is not None:
             json_object["encodingSpaceRef"] = self._encoding_space_ref_converter.to_json(value.encoding_space_ref)
-        if value.sample_time_us is not None:
-            json_object["sampleTimeUs"] = self._sample_time_us_converter.to_json(value.sample_time_us)
+        if value.sample_time_ns is not None:
+            json_object["sampleTimeNs"] = self._sample_time_ns_converter.to_json(value.sample_time_ns)
         json_object["position"] = self._position_converter.to_json(value.position)
         json_object["readDir"] = self._read_dir_converter.to_json(value.read_dir)
         json_object["phaseDir"] = self._phase_dir_converter.to_json(value.phase_dir)
@@ -250,9 +250,9 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
         json_object["measurementUid"] = self._measurement_uid_converter.numpy_to_json(value["measurement_uid"])
         if (field_val := value["scan_counter"]) is not None:
             json_object["scanCounter"] = self._scan_counter_converter.numpy_to_json(field_val)
-        if (field_val := value["acquisition_time_stamp"]) is not None:
-            json_object["acquisitionTimeStamp"] = self._acquisition_time_stamp_converter.numpy_to_json(field_val)
-        json_object["physiologyTimeStamp"] = self._physiology_time_stamp_converter.numpy_to_json(value["physiology_time_stamp"])
+        if (field_val := value["acquisition_time_stamp_ns"]) is not None:
+            json_object["acquisitionTimeStampNs"] = self._acquisition_time_stamp_ns_converter.numpy_to_json(field_val)
+        json_object["physiologyTimeStampNs"] = self._physiology_time_stamp_ns_converter.numpy_to_json(value["physiology_time_stamp_ns"])
         json_object["channelOrder"] = self._channel_order_converter.numpy_to_json(value["channel_order"])
         if (field_val := value["discard_pre"]) is not None:
             json_object["discardPre"] = self._discard_pre_converter.numpy_to_json(field_val)
@@ -262,8 +262,8 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
             json_object["centerSample"] = self._center_sample_converter.numpy_to_json(field_val)
         if (field_val := value["encoding_space_ref"]) is not None:
             json_object["encodingSpaceRef"] = self._encoding_space_ref_converter.numpy_to_json(field_val)
-        if (field_val := value["sample_time_us"]) is not None:
-            json_object["sampleTimeUs"] = self._sample_time_us_converter.numpy_to_json(field_val)
+        if (field_val := value["sample_time_ns"]) is not None:
+            json_object["sampleTimeNs"] = self._sample_time_ns_converter.numpy_to_json(field_val)
         json_object["position"] = self._position_converter.numpy_to_json(value["position"])
         json_object["readDir"] = self._read_dir_converter.numpy_to_json(value["read_dir"])
         json_object["phaseDir"] = self._phase_dir_converter.numpy_to_json(value["phase_dir"])
@@ -281,14 +281,14 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
             idx=self._idx_converter.from_json(json_object["idx"],),
             measurement_uid=self._measurement_uid_converter.from_json(json_object["measurementUid"],),
             scan_counter=self._scan_counter_converter.from_json(json_object.get("scanCounter")),
-            acquisition_time_stamp=self._acquisition_time_stamp_converter.from_json(json_object.get("acquisitionTimeStamp")),
-            physiology_time_stamp=self._physiology_time_stamp_converter.from_json(json_object["physiologyTimeStamp"],),
+            acquisition_time_stamp_ns=self._acquisition_time_stamp_ns_converter.from_json(json_object.get("acquisitionTimeStampNs")),
+            physiology_time_stamp_ns=self._physiology_time_stamp_ns_converter.from_json(json_object["physiologyTimeStampNs"],),
             channel_order=self._channel_order_converter.from_json(json_object["channelOrder"],),
             discard_pre=self._discard_pre_converter.from_json(json_object.get("discardPre")),
             discard_post=self._discard_post_converter.from_json(json_object.get("discardPost")),
             center_sample=self._center_sample_converter.from_json(json_object.get("centerSample")),
             encoding_space_ref=self._encoding_space_ref_converter.from_json(json_object.get("encodingSpaceRef")),
-            sample_time_us=self._sample_time_us_converter.from_json(json_object.get("sampleTimeUs")),
+            sample_time_ns=self._sample_time_ns_converter.from_json(json_object.get("sampleTimeNs")),
             position=self._position_converter.from_json(json_object["position"],),
             read_dir=self._read_dir_converter.from_json(json_object["readDir"],),
             phase_dir=self._phase_dir_converter.from_json(json_object["phaseDir"],),
@@ -306,14 +306,14 @@ class AcquisitionHeaderConverter(_ndjson.JsonConverter[AcquisitionHeader, np.voi
             self._idx_converter.from_json_to_numpy(json_object["idx"]),
             self._measurement_uid_converter.from_json_to_numpy(json_object["measurementUid"]),
             self._scan_counter_converter.from_json_to_numpy(json_object.get("scanCounter")),
-            self._acquisition_time_stamp_converter.from_json_to_numpy(json_object.get("acquisitionTimeStamp")),
-            self._physiology_time_stamp_converter.from_json_to_numpy(json_object["physiologyTimeStamp"]),
+            self._acquisition_time_stamp_ns_converter.from_json_to_numpy(json_object.get("acquisitionTimeStampNs")),
+            self._physiology_time_stamp_ns_converter.from_json_to_numpy(json_object["physiologyTimeStampNs"]),
             self._channel_order_converter.from_json_to_numpy(json_object["channelOrder"]),
             self._discard_pre_converter.from_json_to_numpy(json_object.get("discardPre")),
             self._discard_post_converter.from_json_to_numpy(json_object.get("discardPost")),
             self._center_sample_converter.from_json_to_numpy(json_object.get("centerSample")),
             self._encoding_space_ref_converter.from_json_to_numpy(json_object.get("encodingSpaceRef")),
-            self._sample_time_us_converter.from_json_to_numpy(json_object.get("sampleTimeUs")),
+            self._sample_time_ns_converter.from_json_to_numpy(json_object.get("sampleTimeNs")),
             self._position_converter.from_json_to_numpy(json_object["position"]),
             self._read_dir_converter.from_json_to_numpy(json_object["readDir"]),
             self._phase_dir_converter.from_json_to_numpy(json_object["phaseDir"]),
@@ -2425,8 +2425,8 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
         self._phase_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._repetition_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._set_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
-        self._acquisition_time_stamp_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
-        self._physiology_time_stamp_converter = _ndjson.VectorConverter(_ndjson.uint32_converter)
+        self._acquisition_time_stamp_ns_converter = _ndjson.OptionalConverter(_ndjson.uint64_converter)
+        self._physiology_time_stamp_ns_converter = _ndjson.VectorConverter(_ndjson.uint64_converter)
         self._image_type_converter = _ndjson.EnumConverter(ImageType, np.int32, image_type_name_to_value_map, image_type_value_to_name_map)
         self._image_index_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
         self._image_series_index_converter = _ndjson.OptionalConverter(_ndjson.uint32_converter)
@@ -2447,8 +2447,8 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
             ("phase", self._phase_converter.overall_dtype()),
             ("repetition", self._repetition_converter.overall_dtype()),
             ("set", self._set_converter.overall_dtype()),
-            ("acquisition_time_stamp", self._acquisition_time_stamp_converter.overall_dtype()),
-            ("physiology_time_stamp", self._physiology_time_stamp_converter.overall_dtype()),
+            ("acquisition_time_stamp_ns", self._acquisition_time_stamp_ns_converter.overall_dtype()),
+            ("physiology_time_stamp_ns", self._physiology_time_stamp_ns_converter.overall_dtype()),
             ("image_type", self._image_type_converter.overall_dtype()),
             ("image_index", self._image_index_converter.overall_dtype()),
             ("image_series_index", self._image_series_index_converter.overall_dtype()),
@@ -2481,9 +2481,9 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
             json_object["repetition"] = self._repetition_converter.to_json(value.repetition)
         if value.set is not None:
             json_object["set"] = self._set_converter.to_json(value.set)
-        if value.acquisition_time_stamp is not None:
-            json_object["acquisitionTimeStamp"] = self._acquisition_time_stamp_converter.to_json(value.acquisition_time_stamp)
-        json_object["physiologyTimeStamp"] = self._physiology_time_stamp_converter.to_json(value.physiology_time_stamp)
+        if value.acquisition_time_stamp_ns is not None:
+            json_object["acquisitionTimeStampNs"] = self._acquisition_time_stamp_ns_converter.to_json(value.acquisition_time_stamp_ns)
+        json_object["physiologyTimeStampNs"] = self._physiology_time_stamp_ns_converter.to_json(value.physiology_time_stamp_ns)
         json_object["imageType"] = self._image_type_converter.to_json(value.image_type)
         if value.image_index is not None:
             json_object["imageIndex"] = self._image_index_converter.to_json(value.image_index)
@@ -2518,9 +2518,9 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
             json_object["repetition"] = self._repetition_converter.numpy_to_json(field_val)
         if (field_val := value["set"]) is not None:
             json_object["set"] = self._set_converter.numpy_to_json(field_val)
-        if (field_val := value["acquisition_time_stamp"]) is not None:
-            json_object["acquisitionTimeStamp"] = self._acquisition_time_stamp_converter.numpy_to_json(field_val)
-        json_object["physiologyTimeStamp"] = self._physiology_time_stamp_converter.numpy_to_json(value["physiology_time_stamp"])
+        if (field_val := value["acquisition_time_stamp_ns"]) is not None:
+            json_object["acquisitionTimeStampNs"] = self._acquisition_time_stamp_ns_converter.numpy_to_json(field_val)
+        json_object["physiologyTimeStampNs"] = self._physiology_time_stamp_ns_converter.numpy_to_json(value["physiology_time_stamp_ns"])
         json_object["imageType"] = self._image_type_converter.numpy_to_json(value["image_type"])
         if (field_val := value["image_index"]) is not None:
             json_object["imageIndex"] = self._image_index_converter.numpy_to_json(field_val)
@@ -2548,8 +2548,8 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
             phase=self._phase_converter.from_json(json_object.get("phase")),
             repetition=self._repetition_converter.from_json(json_object.get("repetition")),
             set=self._set_converter.from_json(json_object.get("set")),
-            acquisition_time_stamp=self._acquisition_time_stamp_converter.from_json(json_object.get("acquisitionTimeStamp")),
-            physiology_time_stamp=self._physiology_time_stamp_converter.from_json(json_object["physiologyTimeStamp"],),
+            acquisition_time_stamp_ns=self._acquisition_time_stamp_ns_converter.from_json(json_object.get("acquisitionTimeStampNs")),
+            physiology_time_stamp_ns=self._physiology_time_stamp_ns_converter.from_json(json_object["physiologyTimeStampNs"],),
             image_type=self._image_type_converter.from_json(json_object["imageType"],),
             image_index=self._image_index_converter.from_json(json_object.get("imageIndex")),
             image_series_index=self._image_series_index_converter.from_json(json_object.get("imageSeriesIndex")),
@@ -2575,8 +2575,8 @@ class ImageHeaderConverter(_ndjson.JsonConverter[ImageHeader, np.void]):
             self._phase_converter.from_json_to_numpy(json_object.get("phase")),
             self._repetition_converter.from_json_to_numpy(json_object.get("repetition")),
             self._set_converter.from_json_to_numpy(json_object.get("set")),
-            self._acquisition_time_stamp_converter.from_json_to_numpy(json_object.get("acquisitionTimeStamp")),
-            self._physiology_time_stamp_converter.from_json_to_numpy(json_object["physiologyTimeStamp"]),
+            self._acquisition_time_stamp_ns_converter.from_json_to_numpy(json_object.get("acquisitionTimeStampNs")),
+            self._physiology_time_stamp_ns_converter.from_json_to_numpy(json_object["physiologyTimeStampNs"]),
             self._image_type_converter.from_json_to_numpy(json_object["imageType"]),
             self._image_index_converter.from_json_to_numpy(json_object.get("imageIndex")),
             self._image_series_index_converter.from_json_to_numpy(json_object.get("imageSeriesIndex")),
@@ -2639,13 +2639,13 @@ class NoiseCovarianceConverter(_ndjson.JsonConverter[NoiseCovariance, np.void]):
     def __init__(self) -> None:
         self._coil_labels_converter = _ndjson.VectorConverter(CoilLabelTypeConverter())
         self._receiver_noise_bandwidth_converter = _ndjson.float32_converter
-        self._noise_dwell_time_us_converter = _ndjson.float32_converter
+        self._noise_dwell_time_ns_converter = _ndjson.uint64_converter
         self._sample_count_converter = _ndjson.size_converter
         self._matrix_converter = _ndjson.NDArrayConverter(_ndjson.complexfloat32_converter, 2)
         super().__init__(np.dtype([
             ("coil_labels", self._coil_labels_converter.overall_dtype()),
             ("receiver_noise_bandwidth", self._receiver_noise_bandwidth_converter.overall_dtype()),
-            ("noise_dwell_time_us", self._noise_dwell_time_us_converter.overall_dtype()),
+            ("noise_dwell_time_ns", self._noise_dwell_time_ns_converter.overall_dtype()),
             ("sample_count", self._sample_count_converter.overall_dtype()),
             ("matrix", self._matrix_converter.overall_dtype()),
         ]))
@@ -2657,7 +2657,7 @@ class NoiseCovarianceConverter(_ndjson.JsonConverter[NoiseCovariance, np.void]):
 
         json_object["coilLabels"] = self._coil_labels_converter.to_json(value.coil_labels)
         json_object["receiverNoiseBandwidth"] = self._receiver_noise_bandwidth_converter.to_json(value.receiver_noise_bandwidth)
-        json_object["noiseDwellTimeUs"] = self._noise_dwell_time_us_converter.to_json(value.noise_dwell_time_us)
+        json_object["noiseDwellTimeNs"] = self._noise_dwell_time_ns_converter.to_json(value.noise_dwell_time_ns)
         json_object["sampleCount"] = self._sample_count_converter.to_json(value.sample_count)
         json_object["matrix"] = self._matrix_converter.to_json(value.matrix)
         return json_object
@@ -2669,7 +2669,7 @@ class NoiseCovarianceConverter(_ndjson.JsonConverter[NoiseCovariance, np.void]):
 
         json_object["coilLabels"] = self._coil_labels_converter.numpy_to_json(value["coil_labels"])
         json_object["receiverNoiseBandwidth"] = self._receiver_noise_bandwidth_converter.numpy_to_json(value["receiver_noise_bandwidth"])
-        json_object["noiseDwellTimeUs"] = self._noise_dwell_time_us_converter.numpy_to_json(value["noise_dwell_time_us"])
+        json_object["noiseDwellTimeNs"] = self._noise_dwell_time_ns_converter.numpy_to_json(value["noise_dwell_time_ns"])
         json_object["sampleCount"] = self._sample_count_converter.numpy_to_json(value["sample_count"])
         json_object["matrix"] = self._matrix_converter.numpy_to_json(value["matrix"])
         return json_object
@@ -2680,7 +2680,7 @@ class NoiseCovarianceConverter(_ndjson.JsonConverter[NoiseCovariance, np.void]):
         return NoiseCovariance(
             coil_labels=self._coil_labels_converter.from_json(json_object["coilLabels"],),
             receiver_noise_bandwidth=self._receiver_noise_bandwidth_converter.from_json(json_object["receiverNoiseBandwidth"],),
-            noise_dwell_time_us=self._noise_dwell_time_us_converter.from_json(json_object["noiseDwellTimeUs"],),
+            noise_dwell_time_ns=self._noise_dwell_time_ns_converter.from_json(json_object["noiseDwellTimeNs"],),
             sample_count=self._sample_count_converter.from_json(json_object["sampleCount"],),
             matrix=self._matrix_converter.from_json(json_object["matrix"],),
         )
@@ -2691,7 +2691,7 @@ class NoiseCovarianceConverter(_ndjson.JsonConverter[NoiseCovariance, np.void]):
         return (
             self._coil_labels_converter.from_json_to_numpy(json_object["coilLabels"]),
             self._receiver_noise_bandwidth_converter.from_json_to_numpy(json_object["receiverNoiseBandwidth"]),
-            self._noise_dwell_time_us_converter.from_json_to_numpy(json_object["noiseDwellTimeUs"]),
+            self._noise_dwell_time_ns_converter.from_json_to_numpy(json_object["noiseDwellTimeNs"]),
             self._sample_count_converter.from_json_to_numpy(json_object["sampleCount"]),
             self._matrix_converter.from_json_to_numpy(json_object["matrix"]),
         ) # type:ignore 
@@ -2702,16 +2702,16 @@ class WaveformConverter(typing.Generic[T, T_NP], _ndjson.JsonConverter[Waveform[
         self._flags_converter = _ndjson.uint64_converter
         self._measurement_uid_converter = _ndjson.uint32_converter
         self._scan_counter_converter = _ndjson.uint32_converter
-        self._time_stamp_converter = _ndjson.uint32_converter
-        self._sample_time_us_converter = _ndjson.float32_converter
+        self._time_stamp_ns_converter = _ndjson.uint64_converter
+        self._sample_time_ns_converter = _ndjson.uint64_converter
         self._waveform_id_converter = _ndjson.uint32_converter
         self._data_converter = _ndjson.NDArrayConverter(t_converter, 2)
         super().__init__(np.dtype([
             ("flags", self._flags_converter.overall_dtype()),
             ("measurement_uid", self._measurement_uid_converter.overall_dtype()),
             ("scan_counter", self._scan_counter_converter.overall_dtype()),
-            ("time_stamp", self._time_stamp_converter.overall_dtype()),
-            ("sample_time_us", self._sample_time_us_converter.overall_dtype()),
+            ("time_stamp_ns", self._time_stamp_ns_converter.overall_dtype()),
+            ("sample_time_ns", self._sample_time_ns_converter.overall_dtype()),
             ("waveform_id", self._waveform_id_converter.overall_dtype()),
             ("data", self._data_converter.overall_dtype()),
         ]))
@@ -2724,8 +2724,8 @@ class WaveformConverter(typing.Generic[T, T_NP], _ndjson.JsonConverter[Waveform[
         json_object["flags"] = self._flags_converter.to_json(value.flags)
         json_object["measurementUid"] = self._measurement_uid_converter.to_json(value.measurement_uid)
         json_object["scanCounter"] = self._scan_counter_converter.to_json(value.scan_counter)
-        json_object["timeStamp"] = self._time_stamp_converter.to_json(value.time_stamp)
-        json_object["sampleTimeUs"] = self._sample_time_us_converter.to_json(value.sample_time_us)
+        json_object["timeStampNs"] = self._time_stamp_ns_converter.to_json(value.time_stamp_ns)
+        json_object["sampleTimeNs"] = self._sample_time_ns_converter.to_json(value.sample_time_ns)
         json_object["waveformId"] = self._waveform_id_converter.to_json(value.waveform_id)
         json_object["data"] = self._data_converter.to_json(value.data)
         return json_object
@@ -2738,8 +2738,8 @@ class WaveformConverter(typing.Generic[T, T_NP], _ndjson.JsonConverter[Waveform[
         json_object["flags"] = self._flags_converter.numpy_to_json(value["flags"])
         json_object["measurementUid"] = self._measurement_uid_converter.numpy_to_json(value["measurement_uid"])
         json_object["scanCounter"] = self._scan_counter_converter.numpy_to_json(value["scan_counter"])
-        json_object["timeStamp"] = self._time_stamp_converter.numpy_to_json(value["time_stamp"])
-        json_object["sampleTimeUs"] = self._sample_time_us_converter.numpy_to_json(value["sample_time_us"])
+        json_object["timeStampNs"] = self._time_stamp_ns_converter.numpy_to_json(value["time_stamp_ns"])
+        json_object["sampleTimeNs"] = self._sample_time_ns_converter.numpy_to_json(value["sample_time_ns"])
         json_object["waveformId"] = self._waveform_id_converter.numpy_to_json(value["waveform_id"])
         json_object["data"] = self._data_converter.numpy_to_json(value["data"])
         return json_object
@@ -2751,8 +2751,8 @@ class WaveformConverter(typing.Generic[T, T_NP], _ndjson.JsonConverter[Waveform[
             flags=self._flags_converter.from_json(json_object["flags"],),
             measurement_uid=self._measurement_uid_converter.from_json(json_object["measurementUid"],),
             scan_counter=self._scan_counter_converter.from_json(json_object["scanCounter"],),
-            time_stamp=self._time_stamp_converter.from_json(json_object["timeStamp"],),
-            sample_time_us=self._sample_time_us_converter.from_json(json_object["sampleTimeUs"],),
+            time_stamp_ns=self._time_stamp_ns_converter.from_json(json_object["timeStampNs"],),
+            sample_time_ns=self._sample_time_ns_converter.from_json(json_object["sampleTimeNs"],),
             waveform_id=self._waveform_id_converter.from_json(json_object["waveformId"],),
             data=self._data_converter.from_json(json_object["data"],),
         )
@@ -2764,8 +2764,8 @@ class WaveformConverter(typing.Generic[T, T_NP], _ndjson.JsonConverter[Waveform[
             self._flags_converter.from_json_to_numpy(json_object["flags"]),
             self._measurement_uid_converter.from_json_to_numpy(json_object["measurementUid"]),
             self._scan_counter_converter.from_json_to_numpy(json_object["scanCounter"]),
-            self._time_stamp_converter.from_json_to_numpy(json_object["timeStamp"]),
-            self._sample_time_us_converter.from_json_to_numpy(json_object["sampleTimeUs"]),
+            self._time_stamp_ns_converter.from_json_to_numpy(json_object["timeStampNs"]),
+            self._sample_time_ns_converter.from_json_to_numpy(json_object["sampleTimeNs"]),
             self._waveform_id_converter.from_json_to_numpy(json_object["waveformId"]),
             self._data_converter.from_json_to_numpy(json_object["data"]),
         ) # type:ignore 
@@ -3179,8 +3179,8 @@ class NDJsonMrdReader(_ndjson.NDJsonProtocolReader, MrdReaderBase):
     """
 
 
-    def __init__(self, stream: typing.Union[io.BufferedReader, typing.TextIO, str]) -> None:
-        MrdReaderBase.__init__(self)
+    def __init__(self, stream: typing.Union[io.BufferedReader, typing.TextIO, str], skip_completed_check: bool = False) -> None:
+        MrdReaderBase.__init__(self, skip_completed_check)
         _ndjson.NDJsonProtocolReader.__init__(self, stream, MrdReaderBase.schema)
 
     def _read_header(self) -> typing.Optional[Header]:
@@ -3217,8 +3217,8 @@ class NDJsonMrdNoiseCovarianceReader(_ndjson.NDJsonProtocolReader, MrdNoiseCovar
     """
 
 
-    def __init__(self, stream: typing.Union[io.BufferedReader, typing.TextIO, str]) -> None:
-        MrdNoiseCovarianceReaderBase.__init__(self)
+    def __init__(self, stream: typing.Union[io.BufferedReader, typing.TextIO, str], skip_completed_check: bool = False) -> None:
+        MrdNoiseCovarianceReaderBase.__init__(self, skip_completed_check)
         _ndjson.NDJsonProtocolReader.__init__(self, stream, MrdNoiseCovarianceReaderBase.schema)
 
     def _read_noise_covariance(self) -> NoiseCovariance: