dcnum 0.25.6__py3-none-any.whl → 0.25.7__py3-none-any.whl

dcnum/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.25.6'
-__version_tuple__ = version_tuple = (0, 25, 6)
+__version__ = version = '0.25.7'
+__version_tuple__ = version_tuple = (0, 25, 7)

dcnum/feat/event_extractor_manager_thread.py

@@ -35,8 +35,8 @@ class EventExtractorManagerThread(threading.Thread):
             with segmenter"), so that the segmenter can compute a new
             chunk of labels.
         slot_chunks:
-            For each slot in `slot_states`, this shared array defines
-            on which chunk in `image_data` the segmentation took place.
+            For each slot in ``slot_states``, this shared array defines
+            on which chunk in ``image_data`` the segmentation took place.
         fe_kwargs:
             Feature extraction keyword arguments. See
             :func:`.EventExtractor.get_init_kwargs` for more information.
@@ -47,36 +47,51 @@ class EventExtractorManagerThread(threading.Thread):
             fills up, we take a break.
         debug:
             Whether to run in debugging mode which means only one
-            event extraction thread (`num_workers` has no effect).
+            event extraction thread (``num_workers`` has no effect).
         """
         super(EventExtractorManagerThread, self).__init__(
               name="EventExtractorManager", *args, **kwargs)
         self.logger = logging.getLogger(
             "dcnum.feat.EventExtractorManagerThread")
-        #: Keyword arguments for class:`.EventExtractor`
+
         self.fe_kwargs = fe_kwargs
-        #: Data instance
+        """Keyword arguments
+        for :class:`event_extractor_manager_thread.py.QueueEventExtractor`
+        instances"""
+
         self.data = fe_kwargs["data"]
-        #: States of the segmenter-extractor pipeline slots
+        """Data instance"""
+
         self.slot_states = slot_states
-        #: Chunks indices corresponding to `slot_states`
+        """States of the segmenter-extractor pipeline slots"""
+
         self.slot_chunks = slot_chunks
-        #: Number of workers
+        """Chunk indices corresponding to ``slot_states``
+        """
+
         self.num_workers = 1 if debug else num_workers
-        #: Queue for sending chunks and label indices to the workers
+        """Number of workers"""
+
         self.raw_queue = self.fe_kwargs["raw_queue"]
-        #: List of chunk labels corresponding to `slot_states`
+        """Queue for sending chunks and label indices to the workers"""
+
         self.labels_list = labels_list
-        #: Shared labeling array
+        """List of chunk labels corresponding to ``slot_states``
+        """
+
         self.label_array = np.ctypeslib.as_array(
             self.fe_kwargs["label_array"]).reshape(
             self.data.image.chunk_shape)
-        #: Writer deque to monitor
+        """Shared labeling array"""
+
         self.writer_dq = writer_dq
-        #: Time counter for feature extraction
+        """Writer deque to monitor"""
+
         self.t_count = 0
-        #: Whether debugging is enabled
+        """Time counter for feature extraction"""
+
         self.debug = debug
+        """Whether debugging is enabled"""
 
     def run(self):
         # Initialize all workers

dcnum/feat/feat_background/base.py

@@ -21,7 +21,7 @@ mp_spawn = mp.get_context('spawn')
 class Background(abc.ABC):
     def __init__(self, input_data, output_path, compress=True, num_cpus=None,
                  **kwargs):
-        """
+        """Base class for background computation
 
         Parameters
         ----------
@@ -56,28 +56,35 @@ class Background(abc.ABC):
         # Using spec is not really necessary here, because kwargs are
         # fully populated for background computation, but this might change.
         spec = inspect.getfullargspec(self.check_user_kwargs)
-        #: background keyword arguments
+
         self.kwargs = spec.kwonlydefaults or {}
+        """background keyword arguments"""
         self.kwargs.update(kwargs)
 
         if num_cpus is None:
             num_cpus = mp_spawn.cpu_count()
-        #: number of CPUs used
+
         self.num_cpus = num_cpus
+        """number of CPUs used"""
 
-        #: number of images in the input data
         self.image_count = None
-        #: fraction images that have been processed
+        """number of images in the input data"""
+
         self.image_proc = mp_spawn.Value("d", 0)
+        """fraction images that have been processed"""
 
-        #: HDF5Data instance for input data
         self.hdin = None
-        #: input h5py.File
+        """HDF5Data instance for input data"""
+
         self.h5in = None
-        #: output h5py.File
+        """input h5py.File"""
+
         self.h5out = None
-        #: reference paths for logging to the output .rtdc file
+        """output h5py.File"""
+
         self.paths_ref = []
+        """reference paths for logging to the output .rtdc file"""
+
         # Check whether user passed an array or a path
         if isinstance(input_data, pathlib.Path):
             if str(input_data.resolve()) == str(output_path.resolve()):
@@ -96,10 +103,11 @@ class Background(abc.ABC):
         else:
             self.input_data = input_data
 
-        #: shape of event images
         self.image_shape = self.input_data[0].shape
-        #: total number of events
+        """shape of event images"""
+
         self.image_count = len(self.input_data)
+        """total number of events"""
 
         if self.h5out is None:
             if not output_path.exists():

dcnum/feat/feat_background/bg_copy.py

@@ -4,6 +4,10 @@ from .base import Background
 
 
 class BackgroundCopy(Background):
+    def __init__(self, *args, **kwargs):
+        """Copy the input background data to the output file"""
+        super().__init__(*args, **kwargs)
+
     @staticmethod
     def check_user_kwargs():
         pass

dcnum/feat/feat_background/bg_roll_median.py

@@ -42,7 +42,7 @@ class BackgroundRollMed(Background):
         batch_size: int
             Number of events to process at the same time. Increasing this
             number much more than two orders of magnitude larger than
-            `kernel_size` will not increase computation speed. Larger
+            ``kernel_size`` will not increase computation speed. Larger
             values lead to a higher memory consumption.
         compress: bool
             Whether to compress background data. Set this to False
@@ -64,39 +64,47 @@ class BackgroundRollMed(Background):
                              f"size {len(self.input_data)} is larger than the "
                              f"kernel size {kernel_size}!")
 
-        #: kernel size used for median filtering
         self.kernel_size = kernel_size
-        #: number of events processed at once
+        """kernel size used for median filtering"""
+
         self.batch_size = batch_size
+        """number of events processed at once"""
 
-        #: mp.RawArray for temporary batch input data
         self.shared_input_raw = mp_spawn.RawArray(
             np.ctypeslib.ctypes.c_uint8,
             int(np.prod(self.image_shape)) * (batch_size + kernel_size))
-        #: mp.RawArray for temporary batch output data
+        """mp.RawArray for temporary batch input data"""
+
         self.shared_output_raw = mp_spawn.RawArray(
             np.ctypeslib.ctypes.c_uint8,
             int(np.prod(self.image_shape)) * batch_size)
+        """mp.RawArray for temporary batch output data"""
+
         # Convert the RawArray to something we can write to fast
         # (similar to memoryview, but without having to cast) using
         # np.ctypeslib.as_array. See discussion in
         # https://stackoverflow.com/questions/37705974
-        #: numpy array reshaped view on `self.shared_input_raw` with
-        #: first axis enumerating the events
         self.shared_input = np.ctypeslib.as_array(
             self.shared_input_raw).reshape(batch_size + kernel_size, -1)
-        #: numpy array reshaped view on `self.shared_output_raw` with
-        #: first axis enumerating the events
+        """numpy array reshaped view on `self.shared_input_raw`.
+        The first axis enumerating the events
+        """
+
         self.shared_output = np.ctypeslib.as_array(
             self.shared_output_raw).reshape(batch_size, -1)
-        #: current batch index (see `self.process` and `process_next_batch`)
+        """numpy array reshaped view on `self.shared_output_raw`.
+        The first axis enumerating the events
+        """
+
         self.current_batch = 0
+        """current batch index (see `self.process` and `process_next_batch`)"""
 
-        #: counter tracking process of workers
         self.worker_counter = mp_spawn.Value("l", 0)
-        #: queue for median computation jobs
+        """counter tracking process of workers"""
+
         self.queue = mp_spawn.Queue()
-        #: list of workers (processes)
+        """queue for median computation jobs"""
+
         self.workers = [WorkerRollMed(self.queue,
                                       self.worker_counter,
                                       self.shared_input_raw,
@@ -104,6 +112,7 @@ class BackgroundRollMed(Background):
                                       self.batch_size,
                                       self.kernel_size)
                         for _ in range(self.num_cpus)]
+        """list of workers (processes)"""
         [w.start() for w in self.workers]
 
     def __enter__(self):
@@ -131,7 +140,7 @@ class BackgroundRollMed(Background):
         batch_size: int
             Number of events to process at the same time. Increasing this
             number much more than two orders of magnitude larger than
-            `kernel_size` will not increase computation speed. Larger
+            ``kernel_size`` will not increase computation speed. Larger
             values lead to a higher memory consumption.
         """
         assert kernel_size > 0, "kernel size must be positive number"
@@ -283,7 +292,7 @@ def compute_median_for_slice(shared_input, shared_output, kernel_size,
         in the original image, batch_size + kernel_size events are
         stored in this array one after another in a row.
         The total size of this array is
-        `batch_size` * `kernel_size` * `number_of_pixels_in_the_image`.
+        ``batch_size * kernel_size * number_of_pixels_in_the_image``.
     shared_output: multiprocessing.RawArray
         Used for storing the result. Note that the last `kernel_size`
         elements for each pixel in this output array are junk data

dcnum/feat/feat_background/bg_sparse_median.py

@@ -21,8 +21,8 @@ class BackgroundSparseMed(Background):
 
         In contrast to the rolling median background correction,
         this algorithm only computes the background image every
-        `split_time` seconds, but with a larger window (default kernel size is
-        200 frames instead of 100 frames).
+        ``split_time`` seconds, but with a larger window (default kernel
+        size is 200 frames instead of 100 frames).
 
         1. At time stamps every `split_time` seconds, a background image is
            computed, resulting in a background series.
@@ -103,16 +103,20 @@ class BackgroundSparseMed(Background):
                 f"size {len(self.input_data)}. Setting it to input data size!")
             kernel_size = len(self.input_data)
 
-        #: kernel size used for median filtering
         self.kernel_size = kernel_size
-        #: time between background images in the background series
+        """kernel size used for median filtering"""
+
         self.split_time = split_time
-        #: cleansing threshold factor
+        """time between background images in the background series"""
+
         self.thresh_cleansing = thresh_cleansing
-        #: keep at least this many background images from the series
+        """cleansing threshold factor"""
+
         self.frac_cleansing = frac_cleansing
-        #: offset/flickering correction
+        """keep at least this many background images from the series"""
+
         self.offset_correction = offset_correction
+        """offset/flickering correction"""
 
         # time axis
         self.time = None
@@ -142,48 +146,59 @@ class BackgroundSparseMed(Background):
             self.time = np.linspace(0, dur, self.image_count,
                                     endpoint=True)
 
-        #: duration of the measurement
         self.duration = self.time[-1] - self.time[0]
+        """duration of the measurement"""
 
         self.step_times = np.arange(0, self.duration, self.split_time)
-        #: array containing all background images
+
         self.bg_images = np.zeros((self.step_times.size,
                                    self.image_shape[0],
                                    self.image_shape[1]),
                                   dtype=np.uint8)
+        """array containing all background images"""
 
-        #: mp.RawArray for temporary batch input data
         self.shared_input_raw = mp_spawn.RawArray(
             np.ctypeslib.ctypes.c_uint8,
             int(np.prod(self.image_shape)) * kernel_size)
-        #: mp.RawArray for the median background image
+        """mp.RawArray for temporary batch input data"""
+
         self.shared_output_raw = mp_spawn.RawArray(
             np.ctypeslib.ctypes.c_uint8,
             int(np.prod(self.image_shape)))
+        """mp.RawArray for the median background image"""
+
         # Convert the RawArray to something we can write to fast
         # (similar to memoryview, but without having to cast) using
         # np.ctypeslib.as_array. See discussion in
         # https://stackoverflow.com/questions/37705974
-        #: numpy array reshaped view on `self.shared_input_raw` with
-        #: first axis enumerating the events
         self.shared_input = np.ctypeslib.as_array(
             self.shared_input_raw).reshape(kernel_size, -1)
+        """numpy array reshaped view on `self.shared_input_raw`.
+        The First axis enumerating the events
+        """
+
         self.shared_output = np.ctypeslib.as_array(
             self.shared_output_raw).reshape(self.image_shape)
-        #: multiprocessing pool for parallel processing
+        """numpy array reshaped view on `self.shared_output_raw`.
+        The First axis enumerating the events
+        """
+
         self.pool = mp_spawn.Pool(processes=self.num_cpus)
+        """multiprocessing pool for parallel processing"""
 
-        #: counter tracking process of workers
         self.worker_counter = mp_spawn.Value("l", 0)
-        #: queue for median computation jobs
+        """counter tracking process of workers"""
+
         self.queue = mp_spawn.Queue()
-        #: list of workers (processes)
+        """queue for median computation jobs"""
+
         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)]
+        """list of workers (processes)"""
         [w.start() for w in self.workers]
 
     def __enter__(self):

dcnum/feat/feat_contour/volume.py

@@ -35,7 +35,7 @@ def volume_from_contours(
     average is then used.
 
     The volume is computed radially from the center position
-    given by (`pos_x`, `pos_y`). For sufficiently smooth contours,
+    given by (``pos_x``, ``pos_y``). For sufficiently smooth contours,
     such as densely sampled ellipses, the center position does not
     play an important role. For contours that are given on a coarse
     grid, as is the case for deformability cytometry, the center position
@@ -111,7 +111,7 @@ def vol_revolve(r, z, point_scale=1.):
       V = \frac{h \cdot \pi}{3} \cdot (R^2 + R \cdot r + r^2)
 
     Where :math:`h` is the height of the cone and :math:`r` and
-    `R` are the smaller and larger radii of the truncated cone.
+    ``R`` are the smaller and larger radii of the truncated cone.
 
     Each line segment of the contour resembles one truncated cone. If
     the z-step is positive (counter-clockwise contour), then the

dcnum/feat/gate.py

@@ -9,8 +9,8 @@ from ..meta.ppid import kwargs_to_ppid, ppid_to_kwargs
 
 
 class Gate:
-    #: the default value for `size_thresh_mask` if not given as kwarg
     _default_size_thresh_mask = 10
+    """the default value for `size_thresh_mask` if not given as kwarg"""
 
     def __init__(self, data, *,
                  online_gates: bool = False,
@@ -19,7 +19,7 @@ class Gate:
 
         Parameters
         ----------
-        data: .HDF5Data
+        data: .hdf5_data.HDF5Data
             dcnum data instance
         online_gates: bool
             set to True to enable gating with "online" gates stored
@@ -27,14 +27,14 @@ class Gate:
             deformability cytometry before writing data to disk during
             a measurement
         size_thresh_mask: int
-            Only masks with more pixels than `size_thresh_mask` are
+            Only masks with more pixels than ``size_thresh_mask`` are
             considered to be a valid event; Originally, the
-            `bin area min`/`trig_thresh` value defaulted to 200 which is
+            ``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.
+            ``online_gates`` is set.
         """
-        #: box gating (value range for each feature)
         self.box_gates = {}
+        """box gating (value range for each feature)"""
 
         if online_gates:
             # Deal with online gates.
@@ -46,13 +46,13 @@ class Gate:
                 size_thresh_mask = data.meta_nest.get(
                     "online_contour", {}).get("bin area min")
 
-        #: 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
         }
+        """gating keyword arguments"""
 
     def _extract_online_gates(self, data):
         ogates = {}
@@ -168,10 +168,10 @@ class Gate:
                      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
+        ``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]

dcnum/feat/queue_event_extractor.py

@@ -12,7 +12,7 @@ import numpy as np
 
 from ..os_env_st import RequestSingleThreaded, confirm_single_threaded
 from ..meta.ppid import kwargs_to_ppid, ppid_to_kwargs
-from ..read import HDF5Data
+from ..read.hdf5_data import HDF5Data
 
 from .feat_brightness import brightness_features
 from .feat_contour import moments_based_features, volume_from_contours
@@ -48,9 +48,9 @@ class QueueEventExtractor:
 
         Parameters
         ----------
-        data: HDF5Data
+        data: .hdf5_data.HDF5Data
             Data source.
-        gate: Gate
+        gate: .gate.Gate
             Gating rules.
         raw_queue:
             Queue from which the worker obtains the chunks and
@@ -84,41 +84,57 @@ class QueueEventExtractor:
             The index to increment values in `worker_monitor`
         """
         super(QueueEventExtractor, self).__init__(*args, **kwargs)
-        #: Worker index for populating
+
         self.worker_index = worker_index or 0
-        #: Data instance
+        """Worker index for populating"""
+
         self.data = data
-        #: Gating information
+        """Data instance"""
+
         self.gate = gate
-        #: queue containing sub-indices for `label_array`
+        """Gating information"""
+
         self.raw_queue = raw_queue
-        #: queue with event-wise feature dictionaries
+        """queue containing sub-indices for ``label_array``"""
+
         self.event_queue = event_queue
-        #: queue for logging
+        """queue with event-wise feature dictionaries"""
+
         self.log_queue = log_queue
-        #: invalid mask counter
+        """queue for logging"""
+
         self.invalid_mask_counter = invalid_mask_counter
-        #: worker busy counter
+        """invalid mask counter"""
+
         self.worker_monitor = worker_monitor
+        """worker busy counter"""
+
         # Logging needs to be set up after `start` is called, otherwise
         # it looks like we have the same PID as the parent process. We
         # are setting up logging in `run`.
         self.logger = None
         self.log_level = log_level or logging.getLogger("dcnum").level
-        #: Shared array of length `len(data)` into which the number of
-        #: events per frame is written.
+
         self.feat_nevents = feat_nevents
-        #: Shared array containing the labels of one chunk from `data`.
+        """Number of events per frame
+        Shared array of length `len(data)` into which the number of
+        events per frame is written.
+        """
+
         self.label_array = label_array
-        #: Set to True to let worker join when `raw_queue` is empty.
+        """Shared array containing the labels of one chunk from `data`."""
+
         self.finalize_extraction = finalize_extraction
+        """Set to True to let worker join when `raw_queue` is empty."""
+
         # Keyword arguments for data extraction
         if extract_kwargs is None:
             extract_kwargs = {}
         extract_kwargs.setdefault("brightness", True)
         extract_kwargs.setdefault("haralick", True)
-        #: Feature extraction keyword arguments.
+
         self.extract_kwargs = extract_kwargs
+        """Feature extraction keyword arguments."""
 
     @staticmethod
     def get_init_kwargs(data: HDF5Data,
@@ -127,18 +143,19 @@ class QueueEventExtractor:
                         log_queue: mp.Queue,
                         log_level: int = None,
                         ):
-        """Get initialization arguments for :cass:`.QueueEventExtractor`
+        """Get initialization arguments for :class:`.QueueEventExtractor`
 
         This method was created for convenience reasons:
+
         - It makes sure that the order of arguments is correct, since it
           is implemented in the same class.
         - It simplifies testing.
 
         Parameters
         ----------
-        data: HDF5Data
+        data: .hdf5_data.HDF5Data
             Input data
-        gate: HDF5Data
+        gate: .gate.Gate
             Gating class to use
         num_extractors: int
             Number of extractors that will be used
@@ -330,9 +347,11 @@ class QueueEventExtractor:
         self.worker_monitor[self.worker_index] = 0
         # Don't wait for these two queues when joining workers
         self.raw_queue.cancel_join_thread()
-        #: logger sends all logs to `self.log_queue`
+
         self.logger = logging.getLogger(
             f"dcnum.feat.EventExtractor.{os.getpid()}")
+        """logger that sends all logs to `self.log_queue`"""
+
         self.logger.setLevel(self.log_level)
         # Clear any handlers that might be set for this logger. This is
         # important for the case when we are an instance of

dcnum/logic/ctrl.py

@@ -39,8 +39,6 @@ from .json_encoder import ExtendedJSONEncoder
 # queues and threads and would end up with race conditions otherwise.
 mp_spawn = mp.get_context("spawn")
 
-#: valid states for a job runnter. The states must be in logical ordern,
-#: not in alphabetical order.
 valid_states = [
     "created",
     "init",
@@ -52,6 +50,9 @@ valid_states = [
     "done",
     "error",
 ]
+"""Valid states for a `DCNumJobRunner`.
+The states must be in logical order, not in alphabetical order.
+"""
 
 
 class DCNumJobRunner(threading.Thread):
@@ -59,11 +60,11 @@ class DCNumJobRunner(threading.Thread):
                  job: DCNumPipelineJob,
                  tmp_suffix: str = None,
                  *args, **kwargs):
-        """Run a pipeline as defined by a :class:`DCNumPipelineJob` instance
+        """Run a pipeline as defined by a :class:`.job.DCNumPipelineJob`
 
         Parameters
         ----------
-        job: DCNumPipelineJob
+        job: .job.DCNumPipelineJob
             pipeline job to run
         tmp_suffix: str
             optional unique string for creating temporary files

dcnum/logic/job.py

@@ -67,6 +67,7 @@ class DCNumPipelineJob:
             strategy on how to handle event data; In principle, not all
             events have to be stored in the output file if basins are
             defined, linking back to the original file.
+
             - You can "drain" all basins which means that the output file
               will contain all features, but will also be very big.
             - You can "tap" the basins, including the input file, which means
@@ -89,8 +90,9 @@ class DCNumPipelineJob:
             else:
                 basin_strategy = "tap"
 
-        #: initialize keyword arguments for this job
         self.kwargs = {}
+        """initialize keyword arguments for this job"""
+
         spec = inspect.getfullargspec(DCNumPipelineJob.__init__)
         locs = locals()
         for arg in spec.args:

dcnum/logic/json_encoder.py

@@ -7,6 +7,15 @@ import numpy as np
 
 class ExtendedJSONEncoder(json.JSONEncoder):
     def default(self, obj):
+        """Extended JSON encoder for the **dcnum** logic
+
+        This JSON encoder can handle the following additional objects:
+
+        - ``pathlib.Path``
+        - integer numbers
+        - ``numpy`` boolean
+        - slices (via "PYTHON-SLICE" identifier)
+        """
         if isinstance(obj, pathlib.Path):
             return str(obj)
         elif isinstance(obj, numbers.Integral):

dcnum/meta/paths.py

@@ -1,6 +1,7 @@
 import pathlib
 
 search_path_registry = {}
+"""Dictionary keeping track of user-defined search paths"""
 
 
 def register_search_path(topic: str,

dcnum/meta/ppid.py

@@ -9,9 +9,11 @@ import warnings
 
 import numpy as np
 
-#: Increment this string if there are breaking changes that make
-#: previous pipelines unreproducible.
 DCNUM_PPID_GENERATION = "11"
+"""The dcnum pipeline generation.
+Increment this string if there are breaking changes that make
+previous pipelines unreproducible.
+"""
 
 
 class ClassWithPPIDCapabilities(Protocol):

dcnum/os_env_st.py

@@ -4,7 +4,6 @@ import os
 
 logger = logging.getLogger(__name__)
 
-#: environment variables that set number of threads
 os_env_threading = [
     "MKL_NUM_THREADS",
     "NUMBA_NUM_THREADS",
@@ -14,13 +13,14 @@ os_env_threading = [
     "OPENBLAS_NUM_THREADS",
     "VECLIB_MAXIMUM_THREADS",
 ]
+"""environment variables that define number of threads libraries will use"""
 
 
 class RequestSingleThreaded:
     """Context manager for starting a process with specific environment
 
     When entering the context, the environment variables defined in
-    `os_env_threading` are all set to "1", telling the relevant libraries
+    ``os_env_threading`` are all set to "1", telling the relevant libraries
     that they should work in single-threaded mode.
     When exiting the context, these environment variables are reset to
     their original values (or unset if applicable).

dcnum/read/cache.py

@@ -25,8 +25,10 @@ class BaseImageChunkCache(abc.ABC):
         self._dtype = None
         chunk_size = min(shape[0], chunk_size)
         self._len = self.shape[0]
-        #: This is a FILO cache for the chunks
+
         self.cache = collections.OrderedDict()
+        """This is a FILO cache for the chunks"""
+
         self.image_shape = self.shape[1:]
         self.chunk_shape = (chunk_size,) + self.shape[1:]
         self.chunk_size = chunk_size

dcnum/read/const.py

@@ -1,5 +1,3 @@
-#: Scalar features that apply to all events in a frame and which are
-#: not computed for individual events.
 PROTECTED_FEATURES = [
     "bg_off",
     "flow_rate",
@@ -10,6 +8,11 @@ PROTECTED_FEATURES = [
     "temp_amb",
     "time",
 ]
+"""Frame-defined scalar features.
+Scalar features that apply to all events in a frame and which are
+not computed for individual events
+"""
+
 
 # User-defined features may be anything, but if the user needs something
 # very specific for the pipeline, having them protected is a nice feature.

dcnum/read/detect_flicker.py

@@ -17,7 +17,7 @@ def detect_flickering(image_data: np.ndarray | HDF5Data,
     triggering signal.
 
     If flickering is detected, you should use the "sparsemed" background
-    computation with `offset_correction` set to True.
+    computation with ``offset_correction`` set to True.
 
     Parameters
     ----------

dcnum/segm/segm_torch/segm_torch_base.py

@@ -52,9 +52,10 @@ class TorchSegmenterBase(Segmenter):
         segmenter_kwargs: dict
             Keyword arguments for the segmenter
         meta: dict
-            Dictionary of metadata from an :class:`HDF5Data` instance
+            Dictionary of metadata from an :class:`.hdf5_data.HDF5Data`
+             instance
         logs: dict
-            Dictionary of logs from an :class:`HDF5Data` instance
+            Dictionary of logs from an :class:`.hdf5_data.HDF5Data` instance
 
         Returns
         -------

dcnum/segm/segm_torch/torch_postproc.py

@@ -11,6 +11,7 @@ def postprocess_masks(masks,
     """Postprocess mask images from ML segmenters
 
     The transformation includes:
+
     - Revert the cropping and padding operations done in
       :func:`.preprocess_images` by padding with zeros and cropping.
     - If the original image shape is larger than the mask image shape,

dcnum/segm/segm_torch/torch_preproc.py

@@ -11,6 +11,7 @@ def preprocess_images(images: np.ndarray,
     """Transform image data to something torch models expect
 
     The transformation includes:
+
     - normalization (division by 255, subtraction of mean, division by std)
     - cropping and padding of the input images to `image_shape`. For padding,
       the median of each *individual* image is used.

dcnum/segm/segmenter.py

@@ -26,17 +26,23 @@ class SegmenterNotApplicableError(BaseException):
 
 
 class Segmenter(abc.ABC):
-    #: Required hardware ("cpu" or "gpu") defined in first-level subclass.
     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_algorithm` implementation.
+    """Required hardware ("cpu" or "gpu") defined in first-level subclass."""
+
     mask_postprocessing = True
-    #: Default keyword arguments for mask post-processing. See `process_mask`
-    #: for available options.
+    """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_algorithm`` implementation.
+    """
+
     mask_default_kwargs = {}
-    #: If the segmenter requires a background-corrected image, set this to True
+    """Default keyword arguments for mask post-processing.
+    See `process_mask` for available options.
+    """
+
     requires_background_correction = False
+    """Whether the segmenter requires a background-corrected image"""
 
     def __init__(self,
                  *,
@@ -46,10 +52,11 @@ class Segmenter(abc.ABC):
         """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).
+        segmenter :class:`.segmenter_mpo.MPOSegmenter` (multiple
+        subprocesses are spawned and each of them works on a queue of images)
+        and the single-threaded operation segmenter
+        :class:`.segmenter_sto.STOSegmenter` (e.g. for batch segmentation on
+        a GPU).
 
         Parameters
         ----------
@@ -64,12 +71,15 @@ class Segmenter(abc.ABC):
         self.logger = logging.getLogger(__name__).getChild(
             self.__class__.__name__)
         spec = inspect.getfullargspec(self.segment_algorithm)
-        #: custom keyword arguments for the subclassing segmenter
+
         self.kwargs = spec.kwonlydefaults or {}
+        """custom keyword arguments for the subclassing segmenter"""
+
         self.kwargs.update(kwargs)
 
-        #: keyword arguments for mask post-processing
         self.kwargs_mask = {}
+        """keyword arguments for mask post-processing"""
+
         if self.mask_postprocessing:
             spec_mask = inspect.getfullargspec(self.process_mask)
             self.kwargs_mask.update(spec_mask.kwonlydefaults or {})
@@ -108,7 +118,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_algorithm`, e.g.::
+        list of keyword arguments for ``segment_algorithm``, e.g.::
 
             thresh=-6^blur=0
 
@@ -296,10 +306,10 @@ class Segmenter(abc.ABC):
 
     @functools.cache
     def segment_algorithm_wrapper(self):
-        """Wraps `self.segment_algorithm` to only accept an image
+        """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
+        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
         """
@@ -336,7 +346,7 @@ class Segmenter(abc.ABC):
             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.
+            ``requires_background_correction`` set to True.
         """
         images = image_data.get_chunk(chunk)
         if bg_off is not None:
@@ -364,9 +374,10 @@ class Segmenter(abc.ABC):
         segmenter_kwargs: dict
             Keyword arguments for the segmenter
         meta: dict
-            Dictionary of metadata from an :class:`HDF5Data` instance
+            Dictionary of metadata from an :class:`.hdf5_data.HDF5Data`
+            instance
         logs: dict
-            Dictionary of logs from an :class:`HDF5Data` instance
+            Dictionary of logs from an :class:`.hdf5_data.HDF5Data` instance
 
         Returns
         -------

dcnum/segm/segmenter_manager_thread.py

@@ -36,8 +36,8 @@ class SegmenterManagerThread(threading.Thread):
             its job for a slot, the slot value will be set to "e" (for
             "task is with feature extractor").
         slot_chunks:
-            For each slot in `slot_states`, this shared array defines
-            on which chunk in `image_data` the segmentation took place.
+            For each slot in ``slot_states``, this shared array defines
+            on which chunk in ``image_data`` the segmentation took place.
         bg_off:
             1d array containing additional background image offset values
             that are added to each background image before subtraction
@@ -45,10 +45,10 @@ class SegmenterManagerThread(threading.Thread):
 
         Notes
         -----
-        This manager keeps a list `labels_list` which enumerates the
-        slots just like `slot_states` and `slot_chunks` do. For each
+        This manager keeps a list ``labels_list`` which enumerates the
+        slots just like ``slot_states` and ``slot_chunks`` do. For each
         slot, this list contains the labeled image data (integer-valued)
-        for the input `image_data` chunks.
+        for the input ``image_data`` chunks.
 
         The working principle of this `SegmenterManagerThread` allows
         the user to define a fixed number of slots on which the segmenter
@@ -61,21 +61,28 @@ class SegmenterManagerThread(threading.Thread):
         super(SegmenterManagerThread, self).__init__(
               name="SegmenterManager", *args, **kwargs)
         self.logger = logging.getLogger("dcnum.segm.SegmenterManagerThread")
-        #: Segmenter instance
+
         self.segmenter = segmenter
-        #: Image data which is being segmented
+        """Segmenter instance"""
+
         self.image_data = image_data
-        #: Additional, optional background offset
+        """Image data which is being segmented"""
+
         self.bg_off = (
             bg_off if self.segmenter.requires_background_correction else None)
-        #: Slot states
+        """Additional, optional background offset"""
+
         self.slot_states = slot_states
-        #: Current slot chunk index for the slot states
+        """Slot states"""
+
         self.slot_chunks = slot_chunks
-        #: List containing the segmented labels of each slot
+        """Current slot chunk index for the slot states"""
+
         self.labels_list = [None] * len(self.slot_states)
-        #: Time counter for segmentation
+        """List containing the segmented labels of each slot"""
+
         self.t_count = 0
+        """Time counter for segmentation"""
 
     def run(self):
         num_slots = len(self.slot_states)

dcnum/segm/segmenter_mpo.py

@@ -35,7 +35,7 @@ class MPOSegmenter(Segmenter, abc.ABC):
         debug: bool
             Debugging parameters
         kwargs:
-            Additional, optional keyword arguments for `segment_algorithm`
+            Additional, optional keyword arguments for ``segment_algorithm``
             defined in the subclass.
         """
         super(MPOSegmenter, self).__init__(kwargs_mask=kwargs_mask,
@@ -145,7 +145,7 @@ class MPOSegmenter(Segmenter, abc.ABC):
         """Perform batch segmentation of `images`
 
         Before segmentation, an optional background offset correction with
-        `bg_off` is performed. After segmentation, mask postprocessing is
+        ``bg_off`` is performed. After segmentation, mask postprocessing is
         performed according to the class definition.
 
         Parameters
@@ -264,7 +264,7 @@ class MPOSegmenter(Segmenter, abc.ABC):
         """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
+        ``bg_off`` is performed. After segmentation, mask postprocessing is
         performed according to the class definition.
         """
         segm_wrap = self.segment_algorithm_wrapper()
@@ -296,7 +296,7 @@ class MPOSegmenterWorker:
 
         Parameters
         ----------
-        segmenter: MPOSegmenter
+        segmenter: .segmenter_mpo.MPOSegmenter
             The segmentation instance
         sl_start: int
             Start of slice of input array to process

dcnum/segm/segmenter_sto.py

@@ -27,7 +27,7 @@ class STOSegmenter(Segmenter, abc.ABC):
         debug: bool
             Debugging parameters
         kwargs:
-            Additional, optional keyword arguments for `segment_algorithm`
+            Additional, optional keyword arguments for ``segment_algorithm``
             defined in the subclass.
         """
         if num_workers not in [None, 1]:
@@ -46,7 +46,7 @@ class STOSegmenter(Segmenter, abc.ABC):
         """Perform batch segmentation of `images`
 
         Before segmentation, an optional background offset correction with
-        `bg_off` is performed. After segmentation, mask postprocessing is
+        ``bg_off`` is performed. After segmentation, mask postprocessing is
         performed according to the class definition.
 
         Parameters

dcnum/write/queue_collector_thread.py

@@ -26,23 +26,31 @@ class EventStash:
             List that defines how many events there are for each input
             frame. If summed up, this defines `self.size`.
         """
-        #: Dictionary containing the event arrays
         self.events = {}
-        #: List containing the number of events per input frame
+        """Dictionary containing the event arrays"""
+
         self.feat_nevents = feat_nevents
-        #: Cumulative sum of `feat_nevents` for determining sorting offsets
+        """List containing the number of events per input frame"""
+
         self.nev_idx = np.cumsum(feat_nevents)
-        #: Number of events in this stash
+        """Cumulative sum of `feat_nevents` for determining sorting offsets"""
+
         self.size = int(np.sum(feat_nevents))
-        #: Number of frames in this stash
+        """Number of events in this stash"""
+
         self.num_frames = len(feat_nevents)
-        #: Global offset compared to the original data instance.
+        """Number of frames in this stash"""
+
         self.index_offset = index_offset
-        #: Array containing the indices in the original data instance
-        #: that correspond to the events in `events`.
+        """Global offset compared to the original data instance."""
+
         self.indices_for_data = np.zeros(self.size, dtype=np.uint32)
-        # Private array that tracks the progress.
+        """Array containing the indices in the original data instance.
+        These indices correspond to the events in `events`.
+        """
+
         self._tracker = np.zeros(self.num_frames, dtype=bool)
+        """Private array that tracks the progress."""
 
     def is_complete(self):
         """Determine whether the event stash is complete (all events added)"""
@@ -141,22 +149,31 @@ class QueueCollectorThread(threading.Thread):
         super(QueueCollectorThread, self).__init__(
               name="QueueCollector", *args, **kwargs)
         self.logger = logging.getLogger("dcnum.write.QueueCollector")
-        #: Event queue from which to collect event data
+
         self.event_queue = event_queue
-        #: Writer deque to which event arrays are appended
+        """Event queue from which to collect event data"""
+
         self.writer_dq = writer_dq
-        #: Buffer deque to which events are appended that do not belong
-        #: to the current chunk (chunk defined by `write_threshold`).
+        """Writer deque to which event arrays are appended"""
+
         self.buffer_dq = deque()
-        #: A shared array containing the number of events for each
-        #: frame in `data`.
+        """Buffer deque
+        Events that do not not belong to the current chunk
+        (chunk defined by `write_threshold`) go here.
+        """
+
         self.feat_nevents = feat_nevents
-        #: Number of frames to send to `writer_dq` at a time.
+        """shared array containing the number of events
+        for each frame in `data`."""
+
         self.write_threshold = write_threshold
-        #: Number of events sent to `writer_dq`
+        """Number of frames to send to `writer_dq` at a time."""
+
         self.written_events = 0
-        #: Number of frames from `data` written to `writer_dq`
+        """Number of events sent to `writer_dq`"""
+
         self.written_frames = 0
+        """Number of frames from `data` written to `writer_dq`"""
 
     def run(self):
         # We are not writing to `event_queue` so we can safely cancel

dcnum/write/writer.py

@@ -275,13 +275,13 @@ class HDF5Writer:
     def store_log(self,
                   log: str,
                   data: List[str],
-                  override: bool = False):
+                  override: bool = False) -> h5py.Dataset:
         """Store log data
 
         Store the log data under the key `log`. The `data`
         kwarg must be a list of strings. If the log entry
         already exists, `ValueError` is raised unless
-        `override` is set to True.
+        ``override`` is set to True.
         """
         logs = self.h5.require_group("logs")
         if log in logs:
@@ -290,7 +290,7 @@ class HDF5Writer:
             else:
                 raise ValueError(
                     f"Log '{log}' already exists in {self.h5.filename}!")
-        logs.create_dataset(
+        log_ds = logs.create_dataset(
             name=log,
             data=data,
             shape=(len(data),),
@@ -298,6 +298,7 @@ class HDF5Writer:
             dtype=f"S{max([len(ll) for ll in data])}",
             chunks=True,
             **self.ds_kwds)
+        return log_ds
 
 
 def create_with_basins(

{dcnum-0.25.6.dist-info → dcnum-0.25.7.dist-info}/METADATA

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

dcnum-0.25.7.dist-info/RECORD

@@ -0,0 +1,57 @@
+dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
+dcnum/_version.py,sha256=hjm1pvHN0ZX7nlIod7PG7Fba0cyr_wIaCY9stsERSag,513
+dcnum/os_env_st.py,sha256=4psq-gPuWTTQ118kCiTx0Mhoyads4Irn6JSUzZk8gyc,3052
+dcnum/feat/__init__.py,sha256=jUJYWTD3VIoDNKrmryXbjHb1rGwYtK4b7VPWihYgUoo,325
+dcnum/feat/event_extractor_manager_thread.py,sha256=6D3RVYBuH7gOoGZ4Kz74n6fhq7MtlTY26kpSwZRqg3M,7972
+dcnum/feat/gate.py,sha256=EOleB83sOlBjc8bjaZfWwGuxfCcEO5mknuFunlw_j7o,7252
+dcnum/feat/queue_event_extractor.py,sha256=s-sC7Inkly_HYbqT3OPB6zWRvKm4TNOewujt1EuZF4M,16183
+dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
+dcnum/feat/feat_background/base.py,sha256=N2_CqA1LJwvsfhr3xMPbicVs3DVDXtvlNDZ-uPrJi5w,8749
+dcnum/feat/feat_background/bg_copy.py,sha256=Xfju4DqbrtPyaUf3x-ybrWci5ip_cEbeiEg7Jh56YIY,1182
+dcnum/feat/feat_background/bg_roll_median.py,sha256=rb3JnFzm4aXVLMKdP9wJlRXwTwmKUz2R1RBS9GXPepg,13622
+dcnum/feat/feat_background/bg_sparse_median.py,sha256=PbcTehk46b9l03ZA1mBdyeMPHmGgGN4-59eLy2TzwX8,22634
+dcnum/feat/feat_brightness/__init__.py,sha256=o6AebVlmydwNgVF5kW6ITqJyFreoKrU3Ki_3EC8If-s,155
+dcnum/feat/feat_brightness/bright_all.py,sha256=vf8xaYBdKD24hHUXdkI0_S7nbr7m49KW6gvuWvbHDVg,4545
+dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
+dcnum/feat/feat_contour/__init__.py,sha256=Td4Hs47kUgJj0VXm3q5ofXhaUWr9QTfVgbwh5EELA-I,163
+dcnum/feat/feat_contour/contour.py,sha256=_qyHCGvylVxruMWafvVbVOzhWGXLoFi10LReNxGcWhY,463
+dcnum/feat/feat_contour/moments.py,sha256=W8sD2X7JqIBq-9nL82hf4Hm2uJkfca8EvAl_hqI_IDg,5109
+dcnum/feat/feat_contour/volume.py,sha256=ScxP_VdLRchDFnYJCR3srUa_stVbP3T4toQX0o-91jk,6645
+dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9CjuTgH0,137
+dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
+dcnum/feat/feat_texture/tex_all.py,sha256=_5H3sXYRN0Uq2eUHn3XUyEHkU_tncEqbqJTC-HZcnGY,5198
+dcnum/logic/__init__.py,sha256=7J3GrwJInNQbrLk61HRIV7X7p69TAIbMYpR34hh6u14,177
+dcnum/logic/ctrl.py,sha256=c06ZOUD0T4_FdQDHbigkLAPQTyoeFxhETg-K3W1UyeM,37520
+dcnum/logic/job.py,sha256=MprDL6DwXWmvtGgy7W9A7s2rVRx68ObdJB8mvGFwVcw,7718
+dcnum/logic/json_encoder.py,sha256=wb6uk6EeTkXyrvwtLm9uWe0cfmiBannzcsKLsDLHuQo,843
+dcnum/meta/__init__.py,sha256=AVqRgyKXO1orKnE305h88IBvoZ1oz6X11HN1WP5nGvg,60
+dcnum/meta/paths.py,sha256=aIG39JYbZpOlCbPQIlp0SqGumjbGINYhL2AAoznJt5o,1113
+dcnum/meta/ppid.py,sha256=JInGtwSCsO9nr1E1aishm0k9iQIFB-essBKvv5aBE98,8510
+dcnum/read/__init__.py,sha256=LYHyZHgiNTpjV5oEcty-7Kh5topLpHT_cFlNl-QX8gg,262
+dcnum/read/cache.py,sha256=ChxokVuMaTfi6N6ZbOTWpNYkPgAAYi1lR8nD7JbzjPQ,6497
+dcnum/read/const.py,sha256=x6LfRwWvIxm6nDWlSADVWqDuzMX6bLzy5kQprwLPzA4,496
+dcnum/read/detect_flicker.py,sha256=XVf7nqaHx6weRTtS7KPa5_WRU2flDQIZTbKspeguqdU,1829
+dcnum/read/hdf5_data.py,sha256=Q4sFT1HBrkrKCX1TUaOpibvz8VFj0ETMa9lw_xIF6tw,26360
+dcnum/read/mapped.py,sha256=zU2fYdZfLNHn0rKHxDzBhNFMu4--WWa8nSeE2likyZA,3637
+dcnum/segm/__init__.py,sha256=9cLEAd3JWE8IGqDHV-eSDIYOGBfOepd8OcebtNs8Omk,309
+dcnum/segm/segm_thresh.py,sha256=iVhvIhzO0Gw0t3rXOgH71rOI0CNjJJQq4Gg6BulUhK8,948
+dcnum/segm/segmenter.py,sha256=k130BoriJJ3cXHZjKXkL7rlBFEeAOQI-3Hp6FM_DdvM,15000
+dcnum/segm/segmenter_manager_thread.py,sha256=vMZFBa18oO8OyVB3niy_mtEfKkGOWHEga41E0K-S6Tc,5963
+dcnum/segm/segmenter_mpo.py,sha256=O6G4xzHKNMSmyX9HDXTfl-3f9Fk2filxvVrRIO2D9hg,14117
+dcnum/segm/segmenter_sto.py,sha256=C55orEAZtMowNwtAT_WdSv46n5CzgLFuGq9kwdHc97I,3963
+dcnum/segm/segm_torch/__init__.py,sha256=DtUqJTbj7ybrTbXlwHq1Y4SCzi22rMW9Cus6wX-iU-A,822
+dcnum/segm/segm_torch/segm_torch_base.py,sha256=Z2c9_lZI4qEljQEMXuN_6CpBti57PbbjlDq0NGX3-EU,4514
+dcnum/segm/segm_torch/segm_torch_mpo.py,sha256=GOva6o-6_SppxWD4BeBB3ap1TR-6rIYHavtfIstaYvc,2643
+dcnum/segm/segm_torch/segm_torch_sto.py,sha256=PTOJrP_FkaxZZul8lM4VA2HL3KyxrheDDWWdJbmJdiw,3393
+dcnum/segm/segm_torch/torch_model.py,sha256=5aL6SwSvg1N2gATEGBhP3aA4WTHlvGzQVYuizmh0LrU,3187
+dcnum/segm/segm_torch/torch_postproc.py,sha256=3WUuBvcNyFJF-b-T0MEaj-8yZs-cYKTsq_i55uu5s54,3312
+dcnum/segm/segm_torch/torch_preproc.py,sha256=m4Dd2URdvS7ifA1MkbEkc9d9T30lA_1qbE6P_Gsa0r4,4003
+dcnum/write/__init__.py,sha256=sK79IlvCFIqf2oFABVeyYedMnHOsEIQpxAauEeNO-Tw,273
+dcnum/write/deque_writer_thread.py,sha256=ao7F1yrVKyufgC4rC0Y2_Vt7snuT6KpI7W2qVxcjdhk,1994
+dcnum/write/queue_collector_thread.py,sha256=-p5vrk9cDhtaIMFIu_cCmvlZJafrFkW68uONonMURYo,11617
+dcnum/write/writer.py,sha256=JkVb4KDBV3oo9r3p2yy9wECO1REx7FG0PRBmVWTxJdk,20577
+dcnum-0.25.7.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.25.7.dist-info/METADATA,sha256=X3578YE2gN-g5mMPHH8bMnFyU9E64PP_ivRsIHPKcYc,2321
+dcnum-0.25.7.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+dcnum-0.25.7.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
+dcnum-0.25.7.dist-info/RECORD,,

{dcnum-0.25.6.dist-info → dcnum-0.25.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dcnum-0.25.6.dist-info/RECORD

@@ -1,57 +0,0 @@
-dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=N1UqtqTPcEuecB4pzTavKGDVtOMZMeCfIAQoIiuZRGY,513
-dcnum/os_env_st.py,sha256=ujEVzn1G5sxZfJSITOMw48e2O_oMFu2VD6oj5QCUFSU,3025
-dcnum/feat/__init__.py,sha256=jUJYWTD3VIoDNKrmryXbjHb1rGwYtK4b7VPWihYgUoo,325
-dcnum/feat/event_extractor_manager_thread.py,sha256=FAxSyRfaNAuBWNplxHngp5h-44s0qIP24XX_oETdfMk,7836
-dcnum/feat/gate.py,sha256=Yhxq80JoRMmQzBxl35C8NT91c9QcmQa-EIKLuxK6WvE,7221
-dcnum/feat/queue_event_extractor.py,sha256=KA7K7fOUbLYRfHjdfmN6mVuPPjCJbWMCHv0-b41lBMs,16038
-dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
-dcnum/feat/feat_background/base.py,sha256=bQBPvztrku-8YSVk8YBUUNh7MaYcnztgyD2-dQHxpzw,8674
-dcnum/feat/feat_background/bg_copy.py,sha256=PK8x4_Uph-_A6uszZC5uhe1gD1dSRdHnDMEsN0HSGHA,1034
-dcnum/feat/feat_background/bg_roll_median.py,sha256=NqdgVYm-iUhgDZEonZxQrDvh5e26NoryQKCge8pNGoM,13571
-dcnum/feat/feat_background/bg_sparse_median.py,sha256=QrerkPENHkC9PBgivamu-N1Od6-0b61Ohy_oZYL4www,22449
-dcnum/feat/feat_brightness/__init__.py,sha256=o6AebVlmydwNgVF5kW6ITqJyFreoKrU3Ki_3EC8If-s,155
-dcnum/feat/feat_brightness/bright_all.py,sha256=vf8xaYBdKD24hHUXdkI0_S7nbr7m49KW6gvuWvbHDVg,4545
-dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
-dcnum/feat/feat_contour/__init__.py,sha256=Td4Hs47kUgJj0VXm3q5ofXhaUWr9QTfVgbwh5EELA-I,163
-dcnum/feat/feat_contour/contour.py,sha256=_qyHCGvylVxruMWafvVbVOzhWGXLoFi10LReNxGcWhY,463
-dcnum/feat/feat_contour/moments.py,sha256=W8sD2X7JqIBq-9nL82hf4Hm2uJkfca8EvAl_hqI_IDg,5109
-dcnum/feat/feat_contour/volume.py,sha256=xVHWtv6USUHJZ5dM1Ur7fI7OwoPT5N2Ps0gKVWylfl8,6639
-dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9CjuTgH0,137
-dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
-dcnum/feat/feat_texture/tex_all.py,sha256=_5H3sXYRN0Uq2eUHn3XUyEHkU_tncEqbqJTC-HZcnGY,5198
-dcnum/logic/__init__.py,sha256=7J3GrwJInNQbrLk61HRIV7X7p69TAIbMYpR34hh6u14,177
-dcnum/logic/ctrl.py,sha256=RZ2xl0496Iv91cdCdbkIg2W1fClqsTUDq7YlHHwWQfk,37514
-dcnum/logic/job.py,sha256=9BN2WjYqjjJuLnfNZAtQ2Nn47Glo2jVrivDodGJoqlQ,7713
-dcnum/logic/json_encoder.py,sha256=cxMnqisbKEVf-rVcw6rK2BBAb6iz_hKFaGl81kK36lQ,571
-dcnum/meta/__init__.py,sha256=AVqRgyKXO1orKnE305h88IBvoZ1oz6X11HN1WP5nGvg,60
-dcnum/meta/paths.py,sha256=J_ikeHzd7gEeRgAKjuayz3x6q4h1fOiDadM-ZxhAGm4,1053
-dcnum/meta/ppid.py,sha256=RnDkJSdV1kDznAsOhQN5WI7uC9UwSMCjyADP7yWNvkM,8478
-dcnum/read/__init__.py,sha256=LYHyZHgiNTpjV5oEcty-7Kh5topLpHT_cFlNl-QX8gg,262
-dcnum/read/cache.py,sha256=LNA5nnDyrw8Nj07E7XfG2GcHEoWm6vA6Qo_8N-n-sGw,6492
-dcnum/read/const.py,sha256=GG9iyXDtEldvJYOBnhZjlimzIeBMAt4bSr2-xn2gzzc,464
-dcnum/read/detect_flicker.py,sha256=CeUyxI6LaX_lCNvBPm_yzsiWmiNcZYqbNZCtvKPdkcU,1827
-dcnum/read/hdf5_data.py,sha256=Q4sFT1HBrkrKCX1TUaOpibvz8VFj0ETMa9lw_xIF6tw,26360
-dcnum/read/mapped.py,sha256=zU2fYdZfLNHn0rKHxDzBhNFMu4--WWa8nSeE2likyZA,3637
-dcnum/segm/__init__.py,sha256=9cLEAd3JWE8IGqDHV-eSDIYOGBfOepd8OcebtNs8Omk,309
-dcnum/segm/segm_thresh.py,sha256=iVhvIhzO0Gw0t3rXOgH71rOI0CNjJJQq4Gg6BulUhK8,948
-dcnum/segm/segmenter.py,sha256=FWLFDBR-x_85ku2rObA2F-QBrM4IUaUL-YHChLagVvM,14902
-dcnum/segm/segmenter_manager_thread.py,sha256=frM0sMxC7f7TQiFjmpRxuwG2kUBFpW1inV8dtpADHiI,5924
-dcnum/segm/segmenter_mpo.py,sha256=XcYMKTnCu6-D-TJ62V18S3OE9DhaPhqFkhGhUaDWJFg,14096
-dcnum/segm/segmenter_sto.py,sha256=e6MtN_RWusA0wTExV-FLGpDXNJs1CbSyXcSdWUPBMvM,3959
-dcnum/segm/segm_torch/__init__.py,sha256=DtUqJTbj7ybrTbXlwHq1Y4SCzi22rMW9Cus6wX-iU-A,822
-dcnum/segm/segm_torch/segm_torch_base.py,sha256=G9AhVyD6LkAmk0tkbYnJUSpvcj3_HYf0uqfILZQsyus,4479
-dcnum/segm/segm_torch/segm_torch_mpo.py,sha256=GOva6o-6_SppxWD4BeBB3ap1TR-6rIYHavtfIstaYvc,2643
-dcnum/segm/segm_torch/segm_torch_sto.py,sha256=PTOJrP_FkaxZZul8lM4VA2HL3KyxrheDDWWdJbmJdiw,3393
-dcnum/segm/segm_torch/torch_model.py,sha256=5aL6SwSvg1N2gATEGBhP3aA4WTHlvGzQVYuizmh0LrU,3187
-dcnum/segm/segm_torch/torch_postproc.py,sha256=ctirQTmsZnuZGIxkwFWN9arRneHRYJUxaJ_ZyCgjByM,3311
-dcnum/segm/segm_torch/torch_preproc.py,sha256=kjabu76paw23kO7RP7Ik6IY60Kk1VBAHKBAedflA0aQ,4002
-dcnum/write/__init__.py,sha256=sK79IlvCFIqf2oFABVeyYedMnHOsEIQpxAauEeNO-Tw,273
-dcnum/write/deque_writer_thread.py,sha256=ao7F1yrVKyufgC4rC0Y2_Vt7snuT6KpI7W2qVxcjdhk,1994
-dcnum/write/queue_collector_thread.py,sha256=KwwNIDFEF2DU83woKES5K05MxxOhDxPMZLLeyPugfDo,11542
-dcnum/write/writer.py,sha256=oHlq4bDHQxb33-3Fw1xnzJwACecLyH-6koGK8SN0cSk,20528
-dcnum-0.25.6.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.25.6.dist-info/METADATA,sha256=1hcNBNKwW1nri1olDXf1Rb9jWMCvL2327enWOvMx4s0,2321
-dcnum-0.25.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-dcnum-0.25.6.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
-dcnum-0.25.6.dist-info/RECORD,,