dcnum 0.16.5__tar.gz → 0.16.7__tar.gz

{dcnum-0.16.5 → dcnum-0.16.7}/CHANGELOG

@@ -1,3 +1,17 @@
+0.16.7
+ - fix: if the writer dequeue fills up, stall the feature extractor
+ - enh: optimize DequeWriterThread loop
+ - enh: minor optimization in HDF5Writer.require_feature
+0.16.6
+ - fix: correctly handle mask images with no background on border
+ - fix: enforce user-defined features in concatenated_hdf5_data
+ - fix: Gate.features returned duplicate entries
+ - ref: cache empty border image creation for clear_border
+ - ref: rename internal background worker classes
+ - ref: simplify Gate initialization
+ - ref: Gate instance does not have to keep a reference to the data
+ - ref: better box_gates management for Gate class
+ - tests: increase coverage
 0.16.5
  - fix: replace unreliable Queue.empty and Queue.qsize (macOS support)
 0.16.4
@@ -9,7 +23,7 @@
  - enh: define valid DCNumJobRunner state
  - enh: more robust computation of progress
  - enh: use HDF5Data when loading input data for background computation
- - enh: automatically split segmenters and axtractors equally
+ - enh: automatically split segmenters and extractors equally
  - ref: reduce default image cache size from 5 to 2
  - ref: move dataset generation default kwargs to writer submodule
  - ref: warn above 0.5% of discarded events in EventExtractorManagerThread

{dcnum-0.16.5 → dcnum-0.16.7}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.16.5
+Version: 0.16.7
 Summary: numerics toolbox for imaging deformability cytometry
-Author: Paul Müller
+Author: Maximilian Schlögel, Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>
 License: MIT
 Project-URL: source, https://github.com/DC-Analysis/dcnum

{dcnum-0.16.5 → dcnum-0.16.7}/pyproject.toml

@@ -6,6 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "dcnum"
 authors = [
     # In alphabetical order.
+    {name = "Maximilian Schlögel"},
     {name = "Paul Müller"},
 ]
 maintainers = [

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.16.5'
-__version_tuple__ = version_tuple = (0, 16, 5)
+__version__ = version = '0.16.7'
+__version_tuple__ = version_tuple = (0, 16, 7)

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/feat/event_extractor_manager_thread.py

@@ -1,4 +1,5 @@
 """Feature computation: managing event extraction threads"""
+import collections
 import logging
 import multiprocessing as mp
 import threading
@@ -17,6 +18,7 @@ class EventExtractorManagerThread(threading.Thread):
                  labels_list: List,
                  fe_kwargs: Dict,
                  num_workers: int,
+                 writer_dq: collections.deque,
                  debug: bool = False,
                  *args, **kwargs):
         """Manage event extraction threads or precesses
@@ -40,6 +42,9 @@ class EventExtractorManagerThread(threading.Thread):
             :func:`.EventExtractor.get_init_kwargs` for more information.
         num_workers:
             Number of child threads or worker processes to use.
+        writer_dq:
+            The queue the writer uses. We monitor this queue. If it
+            fills up, we take a break.
         debug:
             Whether to run in debugging mode which means more log
             messages and only one thread (`num_workers` has no effect).
@@ -66,6 +71,8 @@ class EventExtractorManagerThread(threading.Thread):
         self.label_array = np.ctypeslib.as_array(
             self.fe_kwargs["label_array"]).reshape(
             self.data.image.chunk_shape)
+        #: Writer deque to monitor
+        self.writer_dq = writer_dq
         #: Time counter for feature extraction
         self.t_count = 0
         #: Whether debugging is enabled
@@ -86,6 +93,15 @@ class EventExtractorManagerThread(threading.Thread):
         chunks_processed = 0
         frames_processed = 0
         while True:
+            # If the writer_dq starts filling up, then this could lead to
+            # an oom-kill signal. Stall for the writer to prevent this.
+            ldq = len(self.writer_dq)
+            if ldq > 100:
+                stallsec = ldq / 100
+                self.logger.warning(
+                    f"Stalling {stallsec:.1f}s for slow writer.")
+                time.sleep(stallsec)
+
             cur_slot = 0
             unavailable_slots = 0
             # Check all slots for segmented labels

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/feat/feat_background/bg_roll_median.py

@@ -95,12 +95,12 @@ class BackgroundRollMed(Background):
         #: queue for median computation jobs
         self.queue = mp_spawn.Queue()
         #: list of workers (processes)
-        self.workers = [MedianWorker(self.queue,
-                                     self.worker_counter,
-                                     self.shared_input_raw,
-                                     self.shared_output_raw,
-                                     self.batch_size,
-                                     self.kernel_size)
+        self.workers = [WorkerRollMed(self.queue,
+                                      self.worker_counter,
+                                      self.shared_input_raw,
+                                      self.shared_output_raw,
+                                      self.batch_size,
+                                      self.kernel_size)
                         for _ in range(self.num_cpus)]
         [w.start() for w in self.workers]
 
@@ -216,11 +216,11 @@ class BackgroundRollMed(Background):
         self.image_proc.value += self.batch_size
 
 
-class MedianWorker(mp_spawn.Process):
+class WorkerRollMed(mp_spawn.Process):
     def __init__(self, job_queue, counter, shared_input, shared_output,
                  batch_size, kernel_size, *args, **kwargs):
         """Worker process for median computation"""
-        super(MedianWorker, self).__init__(*args, **kwargs)
+        super(WorkerRollMed, self).__init__(*args, **kwargs)
         self.queue = job_queue
         self.queue.cancel_join_thread()
         self.counter = counter

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/feat/feat_background/bg_sparse_median.py

@@ -152,11 +152,11 @@ class BackgroundSparseMed(Background):
         #: queue for median computation jobs
         self.queue = mp_spawn.Queue()
         #: list of workers (processes)
-        self.workers = [MedianWorkerSingle(self.queue,
-                                           self.worker_counter,
-                                           self.shared_input_raw,
-                                           self.shared_output_raw,
-                                           self.kernel_size)
+        self.workers = [WorkerSparseMed(self.queue,
+                                        self.worker_counter,
+                                        self.shared_input_raw,
+                                        self.shared_output_raw,
+                                        self.kernel_size)
                         for _ in range(self.num_cpus)]
         [w.start() for w in self.workers]
 
@@ -348,11 +348,11 @@ class BackgroundSparseMed(Background):
         self.image_proc.value = idx_stop
 
 
-class MedianWorkerSingle(mp_spawn.Process):
+class WorkerSparseMed(mp_spawn.Process):
     def __init__(self, job_queue, counter, shared_input, shared_output,
                  kernel_size, *args, **kwargs):
         """Worker process for median computation"""
-        super(MedianWorkerSingle, self).__init__(*args, **kwargs)
+        super(WorkerSparseMed, self).__init__(*args, **kwargs)
         self.queue = job_queue
         self.queue.cancel_join_thread()
         self.counter = counter

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/feat/gate.py

@@ -1,5 +1,6 @@
-"""Feature computation: gating after feature extraction"""
+"""Feature gating"""
 import copy
+import numbers
 import warnings
 
 import numpy as np
@@ -11,7 +12,8 @@ class Gate:
     #: the default value for `size_thresh_mask` if not given as kwarg
     _default_size_thresh_mask = 10
 
-    def __init__(self, data, *, online_gates: bool = False,
+    def __init__(self, data, *,
+                 online_gates: bool = False,
                  size_thresh_mask: int = None):
         """Gate feature data
 
@@ -20,51 +22,43 @@ class Gate:
         data: .HDF5Data
             dcevent data instance
         online_gates: bool
-            set to True to enable gating with `online_filters`
+            set to True to enable gating with "online" gates stored
+            in the input file; online gates are applied in real-time
+            deformability cytometry before writing data to disk during
+            a measurement
         size_thresh_mask: int
             Only masks with more pixels than `size_thresh_mask` are
-            considered to be a valid event; Originally, this
-            `trig_thresh` value defaulted to 200, but this seemed to
-            be a little too large, defaults to 10.
+            considered to be a valid event; Originally, the
+            `bin area min`/`trig_thresh` value defaulted to 200 which is
+            too large; defaults to 10 or the original value in case
+            `online_gates` is set.
         """
-        #: dcevent .HDF5Data instance
-        self.data = data
-
-        #: gating keyword arguments
-        self.kwargs = {}
+        #: box gating (value range for each feature)
+        self.box_gates = {}
 
         if online_gates:
-            self.box_gates = self._compute_online_gates()
-            # Set triggering threshold to value from source dataset
-            self._set_kwarg("size_thresh_mask", "online_contour",
-                            "bin area min", size_thresh_mask)
-            # If the user did not provide a value and there is nothing in the
-            # original file, then set the default value.
-            if self.kwargs.get("size_thresh_mask") is None:
-                self.kwargs["size_thresh_mask"] = \
-                    self._default_size_thresh_mask
-        else:
-            self.box_gates = {}
-            # If the user did not provide a size_thresh_mask, use the default.
+            # Deal with online gates.
+            # First, compute the box gates.
+            self.box_gates.update(self._extract_online_gates(data))
+            # If the user did not specify a threshold, attempt to extract
+            # it from the metadata.
             if size_thresh_mask is None:
-                size_thresh_mask = self._default_size_thresh_mask
-            self.kwargs["size_thresh_mask"] = size_thresh_mask
-
-        self.kwargs["online_gates"] = online_gates
-
-    def _set_kwarg(self, name, sec, key, user_value):
-        if user_value is None:
-            value = self.data.meta_nest.get(sec, {}).get(key)
-        else:
-            value = user_value
-        if value is not None:
-            self.kwargs[name] = value
+                size_thresh_mask = data.meta_nest.get(
+                    "online_contour", {}).get("bin area min")
 
-    def _compute_online_gates(self):
-        all_online_filters = {}
+        #: gating keyword arguments
+        self.kwargs = {
+            "online_gates": online_gates,
+            # Set the size threshold, defaulting to `_default_size_thresh_mask`
+            "size_thresh_mask":
+                size_thresh_mask or self._default_size_thresh_mask
+        }
+
+    def _extract_online_gates(self, data):
+        ogates = {}
         # Extract online filters from the dataset
-        of = self.data.meta_nest.get("online_filter", {})
-        for key in of:
+        source_meta = data.meta_nest.get("online_filter", {})
+        for key in source_meta:
             if key.endswith("polygon points"):
                 raise NotImplementedError("Polygon gating not implemented!")
             elif (key.endswith("soft limit")
@@ -72,66 +66,30 @@ class Gate:
                 # we only want hard gates
                 continue
             else:
-                # only add the filter if it is not a soft limit
-                sl = of.get(f"{key.rsplit(' ', 1)[0]} soft limit", True)
-                if not sl:
-                    all_online_filters[key] = of[key]
+                try:
+                    feat, lim = key.rsplit(' ', 1)
+                    lim_idx = ["min", "max"].index(lim)
+                except ValueError:
+                    warnings.warn(f"Unexpected online gate '{key}'")
+                else:
+                    # make sure we are not dealing with a soft limit
+                    if not source_meta.get(f"{feat} soft limit", True):
+                        ogates.setdefault(feat, [None, None])
+                        ogates[feat][lim_idx] = source_meta[key]
 
         # This is somehow hard-coded in Shape-In (minimum size is 3px)
-        px_size = self.data.pixel_size
-        all_online_filters["size_x min"] = max(
-            all_online_filters.get("size_x min", 0), 3 * px_size)
-        all_online_filters["size_y min"] = max(
-            all_online_filters.get("size_y min", 0), 3 * px_size)
-
-        return all_online_filters
-
-    def gate_feature(self, feat, data):
-        valid_left = True
-        valid_right = True
-        if f"{feat} min" in self.box_gates:
-            valid_left = data > self.box_gates[f"{feat} min"]
-        if f"{feat} max" in self.box_gates:
-            valid_right = data < self.box_gates[f"{feat} max"]
-        return np.logical_and(valid_left, valid_right)
+        px_size = data.pixel_size
+        ogates["size_x"] = [
+            max(ogates.get("size_x min", 0), 3 * px_size), None]
+        ogates["size_y"] = [
+            max(ogates.get("size_y min", 0), 3 * px_size), None]
 
-    def gate_event(self, event):
-        """Return None if the event should not be used, else `event`"""
-        if self.box_gates and event:
-            # Only use those events that are within the limits of the
-            # online filters.
-            for feat in self.features:
-                if not self.gate_feature(feat, event[feat]):
-                    return
-        return event
+        return ogates
 
-    def gate_events(self, events):
-        """Return boolean array with events that should be used"""
-        if self.box_gates and bool(events):
-            key0 = list(events.keys())[0]
-            size = len(events[key0])
-            valid = np.ones(size, dtype=bool)
-            for feat in self.features:
-                valid = np.logical_and(valid,
-                                       self.gate_feature(feat, events[feat])
-                                       )
-        else:
-            raise ValueError("Empty events provided!")
-        return valid
-
-    def gate_mask(self, mask, mask_sum=None):
-        """Gate the mask, return False if the mask should not be used
-
-        Parameters
-        ----------
-        mask: 2d ndarray
-            The boolean mask image for the event.
-        mask_sum: int
-            The sum of the mask (if not specified, it is computed)
-        """
-        if mask_sum is None:
-            mask_sum = np.sum(mask)
-        return mask_sum > self.kwargs["size_thresh_mask"]
+    @property
+    def features(self):
+        """Sorted list of feature gates defined"""
+        return sorted(self.box_gates.keys())
 
     def get_ppid(self):
         """Return a unique gating pipeline identifier
@@ -181,13 +139,63 @@ class Gate:
                                 ppid=pp_gate_kwargs)
         return kwargs
 
-    @property
-    def features(self):
-        return [kk.split()[0] for kk in list(self.box_gates.keys())]
-
     @classmethod
     def get_ppid_from_kwargs(cls, kwargs):
         warnings.warn(
             "Please use get_ppid_from_ppkw instead of get_ppid_from_kwargs",
             DeprecationWarning)
         return cls.get_ppid_from_ppkw(kwargs)
+
+    def gate_event(self, event):
+        """Return None if the event should not be used, else `event`"""
+        if self.box_gates and event:
+            # Only use those events that are within the limits of the
+            # online filters.
+            for feat in self.features:
+                if not self.gate_feature(feat, event[feat]):
+                    return
+        return event
+
+    def gate_events(self, events):
+        """Return boolean array with events that should be used"""
+        if self.box_gates and bool(events):
+            key0 = list(events.keys())[0]
+            size = len(events[key0])
+            valid = np.ones(size, dtype=bool)
+            for feat in self.features:
+                valid = np.logical_and(valid,
+                                       self.gate_feature(feat, events[feat])
+                                       )
+        else:
+            raise ValueError("Empty events provided!")
+        return valid
+
+    def gate_feature(self,
+                     feat: str,
+                     data: numbers.Number | np.ndarray):
+        """Return boolean indicating whether `data` value is in box gate
+
+        `data` may be a number or an array. If no box filter is defined
+        for `feat`, `True` is always returned. Otherwise, either a boolean
+        or a boolean array is returned, depending on the type of `data`.
+        Not that `np.logical_and` can deal with mixed argument types
+        (scalar and array).
+        """
+        bound_lo, bound_up = self.box_gates[feat]
+        valid_lo = data >= bound_lo if bound_lo is not None else True
+        valid_up = data <= bound_up if bound_up is not None else True
+        return np.logical_and(valid_lo, valid_up)
+
+    def gate_mask(self, mask, mask_sum=None):
+        """Gate the mask, return False if the mask should not be used
+
+        Parameters
+        ----------
+        mask: 2d ndarray
+            The boolean mask image for the event.
+        mask_sum: int
+            The sum of the mask (if not specified, it is computed)
+        """
+        if mask_sum is None:
+            mask_sum = np.sum(mask)
+        return mask_sum > self.kwargs["size_thresh_mask"]

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/logic/ctrl.py

@@ -546,6 +546,7 @@ class DCNumJobRunner(threading.Thread):
             fe_kwargs=fe_kwargs,
             num_workers=num_extractors,
             labels_list=thr_segm.labels_list,
+            writer_dq=writer_dq,
             debug=self.job["debug"])
         thr_feat.start()
 

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/read/hdf5_data.py

@@ -386,8 +386,8 @@ def concatenated_hdf5_data(paths: List[pathlib.Path],
     path_out:
         If `None`, then the dataset is created in memory. If `True`
         (default), create a file on disk. If a pathlib.Path is specified,
-        the dataset is written to that file. Note that files in memory
-        are liekely not pickable (so don't use for multiprocessing).
+        the dataset is written to that file. Note that datasets in memory
+        are likely not pickable (so don't use them for multiprocessing).
     compute_frame:
         Whether to compute the "events/frame" feature, taking the frame
         data from the input files and properly incrementing them along
@@ -435,7 +435,8 @@ def concatenated_hdf5_data(paths: List[pathlib.Path],
                 # get metadata
                 if ii == 0:
                     meta = dict(h5.attrs)
-                    features = featsi
+                    if not features:
+                        features = featsi
                 # make sure number of features are consistent
                 if not set(features) <= set(featsi):
                     raise ValueError(

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/segm/segmenter.py

@@ -64,6 +64,17 @@ class Segmenter(abc.ABC):
                 "`kwargs_mask` has been specified, but mask post-processing "
                 f"is disabled for segmenter {self.__class__}")
 
+    @staticmethod
+    @functools.cache
+    def get_border(shape):
+        """Cached boolean image with outer pixels set to True"""
+        border = np.zeros(shape, dtype=bool)
+        border[0, :] = True
+        border[-1, :] = True
+        border[:, 0] = True
+        border[:, -1] = True
+        return border
+
     @staticmethod
     @functools.cache
     def get_disk(radius):
@@ -178,14 +189,13 @@ class Segmenter(abc.ABC):
             #
             if (labels[0, :].sum() or labels[-1, :].sum()
                     or labels[:, 0].sum() or labels[:, -1].sum()):
-                border = np.zeros_like(labels, dtype=bool)
-                border[0] = True
-                border[-1] = True
-                border[:, 0] = True
-                border[:, -1] = True
+                border = Segmenter.get_border(labels.shape)
                 indices = sorted(np.unique(labels[border]))
-                for ii in indices[1:]:
-                    labels[labels == ii] = 0
+                for li in indices:
+                    if li == 0:
+                        # ignore background values
+                        continue
+                    labels[labels == li] = 0
 
         # scikit-image is too slow for us here. So we use OpenCV.
         # https://github.com/scikit-image/scikit-image/issues/1190

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/write/deque_writer_thread.py

@@ -41,11 +41,13 @@ class DequeWriterThread(threading.Thread):
 
     def run(self):
         while True:
+            ldq = len(self.dq)
             if self.must_stop_loop:
                 break
-            elif len(self.dq):
-                feat, data = self.dq.popleft()
-                self.writer.store_feature_chunk(feat=feat, data=data)
+            elif ldq:
+                for _ in range(ldq):
+                    feat, data = self.dq.popleft()
+                    self.writer.store_feature_chunk(feat=feat, data=data)
             elif self.may_stop_loop:
                 break
             else:

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum/write/writer.py

@@ -35,7 +35,7 @@ class HDF5Writer:
 
     @staticmethod
     def get_best_nd_chunks(item_shape, feat_dtype=np.float64):
-        """Return best chunks for image data
+        """Return best chunks for HDF5 datasets
 
         Chunking has performance implications. It’s recommended to keep the
         total size of dataset chunks between 10 KiB and 1 MiB. This number
@@ -44,6 +44,7 @@ class HDF5Writer:
         """
         # set image feature chunk size to approximately 1MiB
         num_bytes = 1024 ** 2
+        # Note that `np.prod(()) == 1`
         event_size = np.prod(item_shape) * np.dtype(feat_dtype).itemsize
         chunk_size = num_bytes / event_size
         # Set minimum chunk size to 10 so that we can have at least some
@@ -53,12 +54,11 @@ class HDF5Writer:
 
     def require_feature(self, feat, item_shape, feat_dtype, ds_kwds=None):
         """Create a new feature in the "events" group"""
-
-        if ds_kwds is None:
-            ds_kwds = {}
-        for key in self.ds_kwds:
-            ds_kwds.setdefault(key, self.ds_kwds[key])
         if feat not in self.events:
+            if ds_kwds is None:
+                ds_kwds = {}
+            for key in self.ds_kwds:
+                ds_kwds.setdefault(key, self.ds_kwds[key])
             dset = self.events.create_dataset(
                 feat,
                 shape=tuple([0] + list(item_shape)),

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.16.5
+Version: 0.16.7
 Summary: numerics toolbox for imaging deformability cytometry
-Author: Paul Müller
+Author: Maximilian Schlögel, Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>
 License: MIT
 Project-URL: source, https://github.com/DC-Analysis/dcnum

{dcnum-0.16.5 → dcnum-0.16.7}/src/dcnum.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ tests/test_feat_background_bg_roll_median.py
 tests/test_feat_background_bg_sparsemed.py
 tests/test_feat_brightness.py
 tests/test_feat_event_extractor_manager.py
+tests/test_feat_gate.py
 tests/test_feat_haralick.py
 tests/test_feat_moments_based.py
 tests/test_feat_moments_based_extended.py

{dcnum-0.16.5 → dcnum-0.16.7}/tests/test_feat_background_bg_roll_median.py

@@ -1,3 +1,5 @@
+import threading
+
 import h5py
 import numpy as np
 import pytest
@@ -149,6 +151,7 @@ def test_median_rollmed_small_file(tmp_path):
     input_data = np.arange(5*7).reshape(1, 5, 7) * np.ones((event_count, 1, 1))
     assert np.all(input_data[0] == input_data[1])
     assert np.all(input_data[0].flatten() == np.arange(5*7))
+    assert np.median(np.arange(5*7)) == 17, "sanity check"
 
     with pytest.raises(ValueError, match="Cannot compute background"):
         with bg_roll_median.BackgroundRollMed(input_data=input_data,
@@ -157,3 +160,47 @@ def test_median_rollmed_small_file(tmp_path):
                                               batch_size=1000,
                                               ):
             pass
+
+
+@pytest.mark.filterwarnings(
+    "ignore::dcnum.write.writer.CreatingFileWithoutBasinWarning")
+def test_median_rollmed_worker(tmp_path):
+    event_count = 720
+    kernel_size = 100
+    batch_size = 200
+    output_path = tmp_path / "test.h5"
+    # image shape: 5 * 7
+    input_data = np.arange(5*7).reshape(1, 5, 7) * np.ones((event_count, 1, 1))
+    assert np.all(input_data[0] == input_data[1])
+    assert np.all(input_data[0].flatten() == np.arange(5*7))
+
+    with bg_roll_median.BackgroundRollMed(input_data=input_data,
+                                          output_path=output_path,
+                                          kernel_size=kernel_size,
+                                          batch_size=batch_size,
+                                          ) as bic:
+        # make all workers join
+        bic.worker_counter.value = -1000
+        [w.join() for w in bic.workers]
+        bic.worker_counter.value = 0
+        # create our own worker
+        worker = bg_roll_median.WorkerRollMed(
+            job_queue=bic.queue,
+            counter=bic.worker_counter,
+            shared_input=bic.shared_input_raw,
+            shared_output=bic.shared_output_raw,
+            kernel_size=bic.kernel_size,
+            batch_size=batch_size
+        )
+        # run the worker in a thread
+        thr = threading.Thread(target=worker.run)
+        thr.start()
+        # request the worker to do its thing
+        bic.process()
+        bic.worker_counter.value = -1000
+        thr.join()
+
+    assert output_path.exists()
+    with h5py.File(output_path) as h5:
+        assert len(h5["events/image_bg"]) == 720
+        assert np.median(h5["events/image_bg"][0]) == 17

{dcnum-0.16.5 → dcnum-0.16.7}/tests/test_feat_background_bg_sparsemed.py

@@ -217,7 +217,7 @@ def test_median_sparsemend_worker(tmp_path):
         [w.join() for w in bic.workers]
         bic.worker_counter.value = 0
         # create our own worker
-        worker = bg_sparse_median.MedianWorkerSingle(
+        worker = bg_sparse_median.WorkerSparseMed(
             job_queue=bic.queue,
             counter=bic.worker_counter,
             shared_input=bic.shared_input_raw,

{dcnum-0.16.5 → dcnum-0.16.7}/tests/test_feat_event_extractor_manager.py

@@ -1,3 +1,4 @@
+import collections
 import logging
 import multiprocessing as mp
 import queue
@@ -48,6 +49,7 @@ def test_event_extractor_manager_thread():
         fe_kwargs=fe_kwargs,
         num_workers=1,
         labels_list=thr_segm.labels_list,
+        writer_dq=collections.deque(),
         debug=True)
     thr_feat.run()
     thr_segm.join()