dcnum 0.21.3__tar.gz → 0.22.0__tar.gz

{dcnum-0.21.3 → dcnum-0.22.0}/CHANGELOG

@@ -1,3 +1,13 @@
+0.22.0
+ - fix: GPUSegmenter did not perform mask postprocessing
+   (this was not actually fixed in 0.21.0)
+ - tests: implement mock STO segmenter for testing (#3)
+ - tests: add tests for bg_off in segmentation
+ - ref: increment DCNUM_PPID_GENERATION to 10
+ - ref: renamed CPUSegmenter to MPOSegmenter
+ - ref: renamed GPUSegmenter to STOSegmenter
+0.21.4
+ - fix: division by zero error when computing stall time
 0.21.3
  - fix: negative stall time in log messages
 0.21.2
@@ -5,7 +15,6 @@
 0.21.1
  - enh: support boolean images in mask postprocessing
 0.21.0
- - fix: GPUSegmenter did not perform mask postprocessing
  - ref: enable mask postprocessing by default for all segmenters
  - ref: increment DCNUM_PPID_GENERATION to 9
 0.20.4

{dcnum-0.21.3/src/dcnum.egg-info → dcnum-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.21.3
+Version: 0.22.0
 Summary: numerics toolbox for imaging deformability cytometry
 Author: Maximilian Schlögel, Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.21.3'
-__version_tuple__ = version_tuple = (0, 21, 3)
+__version__ = version = '0.22.0'
+__version_tuple__ = version_tuple = (0, 22, 0)

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/feat/event_extractor_manager_thread.py

@@ -98,7 +98,7 @@ class EventExtractorManagerThread(threading.Thread):
             if (ldq := len(self.writer_dq)) > 1000:
                 time.sleep(1)
                 ldq2 = len(self.writer_dq)
-                stall_time = max(0., (ldq2 - 200) / (ldq - ldq2))
+                stall_time = max(0., (ldq2 - 200) / ((ldq - ldq2) or 1))
                 time.sleep(stall_time)
                 self.logger.warning(
                     f"Stalled {stall_time + 1:.1f}s for slow writer "

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/logic/ctrl.py

@@ -648,7 +648,7 @@ class DCNumJobRunner(threading.Thread):
             num_slots = 1
             num_extractors = 1
             num_segmenters = 1
-        elif seg_cls.hardware_processor == "cpu":  # CPU segmenter
+        elif seg_cls.hardware_processor == "cpu":  # MPO segmenter
             # We could in principle set the number of slots to one and
             # have both number of extractors and number of segmenters set
             # to the total number of CPUs. However, we would need more RAM

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/meta/ppid.py

@@ -10,7 +10,7 @@ import warnings
 
 #: Increment this string if there are breaking changes that make
 #: previous pipelines unreproducible.
-DCNUM_PPID_GENERATION = "9"
+DCNUM_PPID_GENERATION = "10"
 
 
 class ClassWithPPIDCapabilities(Protocol):

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/segm/__init__.py

@@ -1,6 +1,6 @@
 # flake8: noqa: F401
 from .segmenter import Segmenter, get_available_segmenters
-from .segmenter_cpu import CPUSegmenter
-from .segmenter_gpu import GPUSegmenter
+from .segmenter_mpo import MPOSegmenter
+from .segmenter_sto import STOSegmenter
 from .segmenter_manager_thread import SegmenterManagerThread
 from . import segm_thresh

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/segm/segm_thresh.py

@@ -1,7 +1,7 @@
-from .segmenter_cpu import CPUSegmenter
+from .segmenter_mpo import MPOSegmenter
 
 
-class SegmentThresh(CPUSegmenter):
+class SegmentThresh(MPOSegmenter):
     mask_postprocessing = True
     mask_default_kwargs = {
         "clear_border": True,
@@ -11,8 +11,8 @@ class SegmentThresh(CPUSegmenter):
     requires_background_correction = True
 
     @staticmethod
-    def segment_approach(image, *,
-                         thresh: float = -6):
+    def segment_algorithm(image, *,
+                          thresh: float = -6):
         """Mask retrieval using basic thresholding
 
         Parameters

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/segm/segmenter.py

@@ -18,7 +18,7 @@ class Segmenter(abc.ABC):
     hardware_processor = "none"
     #: Whether to enable mask post-processing. If disabled, you should
     #: make sure that your mask is properly defined and cleaned or you
-    #: have to call `process_mask` in your `segment_approach` implementation.
+    #: have to call `process_mask` in your `segment_algorithm` implementation.
     mask_postprocessing = True
     #: Default keyword arguments for mask post-processing. See `process_mask`
     #: for available options.
@@ -31,7 +31,13 @@ class Segmenter(abc.ABC):
                  kwargs_mask: Dict = None,
                  debug: bool = False,
                  **kwargs):
-        """Base segmenter
+        """Base segmenter class
+
+        This is the base segmenter class for the multiprocessing operation
+        segmenter :class:`.MPOSegmenter` (multiple subprocesses are spawned
+        and each of them works on a queue of images) and the single-threaded
+        operation segmenter :class:`.STOSegmenter` (e.g. for batch
+        segmentation on a GPU).
 
         Parameters
         ----------
@@ -45,7 +51,7 @@ class Segmenter(abc.ABC):
         self.debug = debug
         self.logger = logging.getLogger(__name__).getChild(
             self.__class__.__name__)
-        spec = inspect.getfullargspec(self.segment_approach)
+        spec = inspect.getfullargspec(self.segment_algorithm)
         #: custom keyword arguments for the subclassing segmenter
         self.kwargs = spec.kwonlydefaults or {}
         self.kwargs.update(kwargs)
@@ -90,7 +96,7 @@ class Segmenter(abc.ABC):
             KEY:KW_APPROACH:KW_MASK
 
         Where KEY is e.g. "legacy" or "watershed", and KW_APPROACH is a
-        list of keyword arguments for `segment_approach`, e.g.::
+        list of keyword arguments for `segment_algorithm`, e.g.::
 
             thresh=-6^blur=0
 
@@ -137,7 +143,7 @@ class Segmenter(abc.ABC):
 
         ppid_parts = [
             cls.get_ppid_code(),
-            kwargs_to_ppid(cls, "segment_approach", kwargs),
+            kwargs_to_ppid(cls, "segment_algorithm", kwargs),
             ]
 
         if cls.mask_postprocessing:
@@ -161,7 +167,7 @@ class Segmenter(abc.ABC):
             raise ValueError(
                 f"Could not find segmenter '{code}'!")
         kwargs = ppid_to_kwargs(cls=cls,
-                                method="segment_approach",
+                                method="segment_algorithm",
                                 ppid=pp_kwargs)
         if cls.mask_postprocessing:
             pp_kwargs_mask = ppid_parts[2]
@@ -196,7 +202,7 @@ class Segmenter(abc.ABC):
             if > 0, perform a binary closing with a disk
             of that radius in pixels
         """
-        if labels.dtype == np.bool_:
+        if labels.dtype == bool:
             # Convert mask image to labels
             labels, _ = ndi.label(
                 input=labels,
@@ -268,53 +274,71 @@ class Segmenter(abc.ABC):
 
         return labels
 
-    def segment_chunk(self, image_data, chunk, bg_off=None):
-        """Return the integer labels for one `image_data` chunk"""
-        data = image_data.get_chunk(chunk)
-        if bg_off is not None:
-            bg_off_chunk = bg_off[image_data.get_chunk_slice(chunk)]
-            data = data - bg_off_chunk.reshape(-1, 1, 1)
-        return self.segment_batch(data)
-
-    def segment_frame(self, image):
-        """Return the integer label image for `index`"""
-        segm_wrap = self.segment_frame_wrapper()
-        # obtain mask or label
-        mol = segm_wrap(image)
-        if mol.dtype == bool:
-            # convert mask to label
-            labels, _ = ndi.label(
-                input=mol,
-                structure=ndi.generate_binary_structure(2, 2))
-        else:
-            labels = mol
-        # optional postprocessing
-        if self.mask_postprocessing:
-            labels = self.process_mask(labels, **self.kwargs_mask)
-        return labels
+    @staticmethod
+    @abc.abstractmethod
+    def segment_algorithm(image):
+        """The segmentation algorithm implemented in the subclass
+
+        Perform segmentation and return integer label or binary mask image
+        """
 
     @functools.cache
-    def segment_frame_wrapper(self):
+    def segment_algorithm_wrapper(self):
+        """Wraps `self.segment_algorithm` to only accept an image
+
+        The static method `self.segment_algorithm` may optionally accept
+        keyword arguments `self.kwargs`. This wrapper returns the
+        wrapped method that only accepts the image as an argument. This
+        makes sense if you want to unify
+        """
         if self.kwargs:
             # For segmenters that accept keyword arguments.
-            segm_wrap = functools.partial(self.segment_approach,
+            segm_wrap = functools.partial(self.segment_algorithm,
                                           **self.kwargs)
         else:
             # For segmenters that don't accept keyword arguments.
-            segm_wrap = self.segment_approach
+            segm_wrap = self.segment_algorithm
         return segm_wrap
 
-    @staticmethod
     @abc.abstractmethod
-    def segment_approach(image):
-        """Perform segmentation and return integer label or binary mask image
+    def segment_batch(self, images, start=None, stop=None, bg_off=None):
+        """Return the integer labels for an entire batch
+
+        This is implemented in the MPO and STO segmenters.
+        """
+
+    def segment_chunk(self, image_data, chunk, bg_off=None):
+        """Return the integer labels for one `image_data` chunk
+
+        This is a wrapper for `segment_batch`.
 
-        This is the approach the subclasses implement.
+        Parameters
+        ----------
+        image_data:
+            Instance of dcnum's :class:`.BaseImageChunkCache` with
+            the methods `get_chunk` and `get_chunk_slice`.
+        chunk: int
+            Integer identifying the chunk in `image_data` to segment
+        bg_off: ndarray
+            Optional 1D array with same length as `image_data` that holds
+            additional background offset values that should be subtracted
+            from the image data before segmentation. Should only be
+            used in combination with segmenters that have
+            `requires_background_correction` set to True.
         """
+        images = image_data.get_chunk(chunk)
+        if bg_off is not None:
+            bg_off_chunk = bg_off[image_data.get_chunk_slice(chunk)]
+        else:
+            bg_off_chunk = None
+        return self.segment_batch(images, bg_off=bg_off_chunk)
 
     @abc.abstractmethod
-    def segment_batch(self, data, start=None, stop=None):
-        """Return the integer labels for an entire batch"""
+    def segment_single(self, image):
+        """Return the integer label for one image
+
+        This is implemented in the MPO and STO segmenters.
+        """
 
 
 @functools.cache

{dcnum-0.21.3 → dcnum-0.22.0}/src/dcnum/segm/segmenter_manager_thread.py

@@ -8,7 +8,7 @@ import numpy as np
 from ..read.cache import HDF5ImageCache, ImageCorrCache
 
 from .segmenter import Segmenter
-from .segmenter_cpu import CPUSegmenter
+from .segmenter_mpo import MPOSegmenter
 
 
 class SegmenterManagerThread(threading.Thread):
@@ -66,7 +66,8 @@ class SegmenterManagerThread(threading.Thread):
         #: Image data which is being segmented
         self.image_data = image_data
         #: Additional, optional background offset
-        self.bg_off = bg_off
+        self.bg_off = (
+            bg_off if self.segmenter.requires_background_correction else None)
         #: Slot states
         self.slot_states = slot_states
         #: Current slot chunk index for the slot states
@@ -128,7 +129,7 @@ class SegmenterManagerThread(threading.Thread):
             self.t_count += time.monotonic() - t1
 
         # Cleanup
-        if isinstance(self.segmenter, CPUSegmenter):
+        if isinstance(self.segmenter, MPOSegmenter):
             # Join the segmentation workers.
             self.segmenter.join_workers()
 

dcnum-0.21.3/src/dcnum/segm/segmenter_cpu.py → dcnum-0.22.0/src/dcnum/segm/segmenter_mpo.py

@@ -5,6 +5,7 @@ import threading
 from typing import Dict
 
 import numpy as np
+import scipy.ndimage as ndi
 
 from .segmenter import Segmenter
 
@@ -14,7 +15,7 @@ from .segmenter import Segmenter
 mp_spawn = mp.get_context('spawn')
 
 
-class CPUSegmenter(Segmenter, abc.ABC):
+class MPOSegmenter(Segmenter, abc.ABC):
     hardware_processor = "cpu"
 
     def __init__(self,
@@ -23,7 +24,7 @@ class CPUSegmenter(Segmenter, abc.ABC):
                  kwargs_mask: Dict = None,
                  debug: bool = False,
                  **kwargs):
-        """CPU base segmenter
+        """Segmenter with multiprocessing operation
 
         Parameters
         ----------
@@ -32,17 +33,23 @@ class CPUSegmenter(Segmenter, abc.ABC):
         debug: bool
             Debugging parameters
         kwargs:
-            Additional, optional keyword arguments for `segment_approach`
+            Additional, optional keyword arguments for `segment_algorithm`
             defined in the subclass.
         """
-        super(CPUSegmenter, self).__init__(kwargs_mask=kwargs_mask,
+        super(MPOSegmenter, self).__init__(kwargs_mask=kwargs_mask,
                                            debug=debug,
                                            **kwargs)
         self.num_workers = num_workers or mp.cpu_count()
+        # batch input image data
         self.mp_image_raw = None
         self._mp_image_np = None
+        # batch output image data
         self.mp_labels_raw = None
         self._mp_labels_np = None
+        # batch image background offset
+        self.mp_bg_off_raw = None
+        self._mp_bg_off_np = None
+        # workers
         self._mp_workers = []
         # Image shape of the input array
         self.image_shape = None
@@ -78,6 +85,7 @@ class CPUSegmenter(Segmenter, abc.ABC):
         del state["logger"]
         del state["_mp_image_np"]
         del state["_mp_labels_np"]
+        del state["_mp_bg_off_np"]
         del state["_mp_workers"]
         return state
 
@@ -86,26 +94,26 @@ class CPUSegmenter(Segmenter, abc.ABC):
         self.__dict__.update(state)
 
     @staticmethod
-    def _create_shared_array(image_shape, batch_size, dtype):
+    def _create_shared_array(array_shape, batch_size, dtype):
         """Return raw and numpy-view on shared array
 
         Parameters
         ----------
-        image_shape: tuple of int
+        array_shape: tuple of int
             Shape of one single image in the array
         batch_size: int
             Number of images in the array
         dtype:
             numpy dtype
         """
-        sx, sy = image_shape
         ctype = np.ctypeslib.as_ctypes_type(dtype)
-        sa_raw = mp_spawn.RawArray(ctype, int(sx * sy * batch_size))
+        sa_raw = mp_spawn.RawArray(ctype,
+                                   int(np.prod(array_shape) * batch_size))
         # Convert the RawArray to something we can write to fast
         # (similar to memory view, but without having to cast) using
         # np.ctypeslib.as_array. See discussion in
         # https://stackoverflow.com/questions/37705974
-        sa_np = np.ctypeslib.as_array(sa_raw).reshape(batch_size, sx, sy)
+        sa_np = np.ctypeslib.as_array(sa_raw).reshape(batch_size, *array_shape)
         return sa_raw, sa_np
 
     @property
@@ -127,39 +135,49 @@ class CPUSegmenter(Segmenter, abc.ABC):
             [w.join() for w in self._mp_workers]
 
     def segment_batch(self,
-                      image_data: np.ndarray,
+                      images: np.ndarray,
                       start: int = None,
-                      stop: int = None):
-        """Perform batch segmentation of `image_data`
+                      stop: int = None,
+                      bg_off: np.ndarray = None,
+                      ):
+        """Perform batch segmentation of `images`
+
+        Before segmentation, an optional background offset correction with
+        `bg_off` is performed. After segmentation, mask postprocessing is
+        performed according to the class definition.
 
         Parameters
         ----------
-        image_data: 3d np.ndarray
+        images: 3d np.ndarray
             The time-series image data. First axis is time.
         start: int
-            First index to analyze in `image_data`
+            First index to analyze in `images`
         stop: int
-            Index after the last index to analyze in `image_data`
+            Index after the last index to analyze in `images`
+        bg_off: 1D np.ndarray
+            Optional 1D numpy array with background offset
 
         Notes
         -----
         - If the segmentation algorithm only accepts background-corrected
-          images, then `image_data` must already be background-corrected.
+          images, then `images` must already be background-corrected,
+          except for the optional `bg_off`.
         """
         if stop is None or start is None:
             start = 0
-            stop = len(image_data)
+            stop = len(images)
 
         batch_size = stop - start
-        size = np.prod(image_data.shape[1:]) * batch_size
+        size = np.prod(images.shape[1:]) * batch_size
 
         if self.image_shape is None:
-            self.image_shape = image_data[0].shape
+            self.image_shape = images[0].shape
 
         if self._mp_image_np is not None and self._mp_image_np.size != size:
             # reset image data
             self._mp_image_np = None
             self._mp_labels_np = None
+            self._mp_bg_off_np = None
             # TODO: If only the batch_size changes, don't
             #  reinitialize the workers. Otherwise, the final rest of
             #  analyzing a dataset would always take a little longer.
@@ -168,31 +186,47 @@ class CPUSegmenter(Segmenter, abc.ABC):
             self.mp_batch_index.value = -1
             self.mp_shutdown.value = 0
 
+        if bg_off is not None:
+            if not self.requires_background_correction:
+                raise ValueError(f"The segmenter {self.__class__.__name__} "
+                                 f"does not employ background correction, "
+                                 f"but the `bg_off` keyword argument was "
+                                 f"passed to `segment_chunk`. Please check "
+                                 f"your analysis pipeline.")
+            # background offset
+            if self._mp_bg_off_np is None:
+                self.mp_bg_off_raw, self._mp_bg_off_np = \
+                    self._create_shared_array(
+                        array_shape=(stop - start,),
+                        batch_size=batch_size,
+                        dtype=np.float64)
+            self._mp_bg_off_np[:] = bg_off[start:stop]
+
+        # input images
         if self._mp_image_np is None:
             self.mp_image_raw, self._mp_image_np = self._create_shared_array(
-                image_shape=self.image_shape,
+                array_shape=self.image_shape,
                 batch_size=batch_size,
-                dtype=image_data.dtype,
+                dtype=images.dtype,
             )
+        self._mp_image_np[:] = images[start:stop]
 
+        # output labels
         if self._mp_labels_np is None:
             self.mp_labels_raw, self._mp_labels_np = self._create_shared_array(
-                image_shape=self.image_shape,
+                array_shape=self.image_shape,
                 batch_size=batch_size,
                 dtype=np.uint16,
             )
 
-        # populate image data
-        self._mp_image_np[:] = image_data[start:stop]
-
         # Create the workers
         if self.debug:
-            worker_cls = CPUSegmenterWorkerThread
+            worker_cls = MPOSegmenterWorkerThread
             num_workers = 1
             self.logger.debug("Running with one worker in main thread")
         else:
-            worker_cls = CPUSegmenterWorkerProcess
-            num_workers = min(self.num_workers, image_data.shape[0])
+            worker_cls = MPOSegmenterWorkerProcess
+            num_workers = min(self.num_workers, images.shape[0])
             self.logger.debug(f"Running with {num_workers} workers")
 
         if not self._mp_workers:
@@ -224,8 +258,33 @@ class CPUSegmenter(Segmenter, abc.ABC):
 
         return self._mp_labels_np
 
+    def segment_single(self, image, bg_off: float = None):
+        """Return the integer label image for an input image
+
+        Before segmentation, an optional background offset correction with
+        `bg_off` is performed. After segmentation, mask postprocessing is
+        performed according to the class definition.
+        """
+        segm_wrap = self.segment_algorithm_wrapper()
+        # optional subtraction of background offset
+        if bg_off is not None:
+            image = image - bg_off
+        # obtain mask or label
+        mol = segm_wrap(image)
+        if mol.dtype == bool:
+            # convert mask to labels
+            labels, _ = ndi.label(
+                input=mol,
+                structure=ndi.generate_binary_structure(2, 2))
+        else:
+            labels = mol
+        # optional mask/label postprocessing
+        if self.mask_postprocessing:
+            labels = self.process_mask(labels, **self.kwargs_mask)
+        return labels
+
 
-class CPUSegmenterWorker:
+class MPOSegmenterWorker:
     def __init__(self,
                  segmenter,
                  sl_start: int,
@@ -235,7 +294,7 @@ class CPUSegmenterWorker:
 
         Parameters
         ----------
-        segmenter: CPUSegmenter
+        segmenter: MPOSegmenter
             The segmentation instance
         sl_start: int
             Start of slice of input array to process
@@ -243,7 +302,7 @@ class CPUSegmenterWorker:
             Stop of slice of input array to process
         """
         # Must call super init, otherwise Thread or Process are not initialized
-        super(CPUSegmenterWorker, self).__init__()
+        super(MPOSegmenterWorker, self).__init__()
         self.segmenter = segmenter
         # Value incrementing the batch index. Starts with 0 and is
         # incremented every time :func:`Segmenter.segment_batch` is
@@ -255,8 +314,10 @@ class CPUSegmenterWorker:
         # Shutdown bit tells workers to stop when set to != 0
         self.shutdown = segmenter.mp_shutdown
         # The image data for segmentation
-        self.image_data_raw = segmenter.mp_image_raw
-        # Boolean mask array
+        self.image_arr_raw = segmenter.mp_image_raw
+        # Background data offset
+        self.bg_off = segmenter.mp_bg_off_raw
+        # Integer output label array
         self.labels_data_raw = segmenter.mp_labels_raw
         # The shape of one image
         self.image_shape = segmenter.image_shape
@@ -268,10 +329,14 @@ class CPUSegmenterWorker:
         # We have to create the numpy-versions of the mp.RawArrays here,
         # otherwise we only get some kind of copy in the new process
         # when we use "spawn" instead of "fork".
-        labels_data = np.ctypeslib.as_array(self.labels_data_raw).reshape(
+        labels_arr = np.ctypeslib.as_array(self.labels_data_raw).reshape(
             -1, self.image_shape[0], self.image_shape[1])
-        image_data = np.ctypeslib.as_array(self.image_data_raw).reshape(
+        image_arr = np.ctypeslib.as_array(self.image_arr_raw).reshape(
             -1, self.image_shape[0], self.image_shape[1])
+        if self.bg_off is not None:
+            bg_off_data = np.ctypeslib.as_array(self.bg_off)
+        else:
+            bg_off_data = None
 
         idx = self.sl_start
         itr = 0  # current iteration (incremented when we reach self.sl_stop)
@@ -285,8 +350,13 @@ class CPUSegmenterWorker:
                     with self.batch_worker:
                         self.batch_worker.value += 1
                 else:
-                    labels_data[idx, :, :] = self.segmenter.segment_frame(
-                        image_data[idx])
+                    if bg_off_data is None:
+                        bg_off = None
+                    else:
+                        bg_off = bg_off_data[idx]
+
+                    labels_arr[idx, :, :] = self.segmenter.segment_single(
+                        image=image_arr[idx], bg_off=bg_off)
                     idx += 1
             elif self.shutdown.value:
                 break
@@ -295,11 +365,11 @@ class CPUSegmenterWorker:
                 time.sleep(.01)
 
 
-class CPUSegmenterWorkerProcess(CPUSegmenterWorker, mp_spawn.Process):
+class MPOSegmenterWorkerProcess(MPOSegmenterWorker, mp_spawn.Process):
     def __init__(self, *args, **kwargs):
-        super(CPUSegmenterWorkerProcess, self).__init__(*args, **kwargs)
+        super(MPOSegmenterWorkerProcess, self).__init__(*args, **kwargs)
 
 
-class CPUSegmenterWorkerThread(CPUSegmenterWorker, threading.Thread):
+class MPOSegmenterWorkerThread(MPOSegmenterWorker, threading.Thread):
     def __init__(self, *args, **kwargs):
-        super(CPUSegmenterWorkerThread, self).__init__(*args, **kwargs)
+        super(MPOSegmenterWorkerThread, self).__init__(*args, **kwargs)