dclab 0.62.17__cp39-cp39-macosx_11_0_arm64.whl → 0.67.3__cp39-cp39-macosx_11_0_arm64.whl

dclab/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.62.17'
-__version_tuple__ = version_tuple = (0, 62, 17)
+__version__ = version = '0.67.3'
+__version_tuple__ = version_tuple = (0, 67, 3)
+
+__commit_id__ = commit_id = 'g42c771e2c'

dclab/cli/task_tdms2rtdc.py

@@ -158,7 +158,7 @@ def tdms2rtdc_parser():
                         help='Compute features, such as volume or emodulus, '
                              + 'that are otherwise computed on-the-fly. '
                              + 'Use this if you want to minimize analysis '
-                             + 'time in e.g. Shape-Out. CAUTION: ancillary '
+                             + 'time in e.g. DCscope. CAUTION: ancillary '
                              + 'feature recipes might be subject to change '
                              + '(e.g. if an error is found in the recipe). '
                              + 'Disabling this option maximizes '

dclab/cli/task_verify_dataset.py

@@ -56,9 +56,9 @@ def verify_dataset(path_in=None):
         else:
             # everything is ok
             exit_status = 0
-    finally:
-        # return sys.exit for testing (monkeypatched)
-        return sys.exit(exit_status)
+
+    # return sys.exit for testing (monkeypatched)
+    return sys.exit(exit_status)
 
 
 def verify_dataset_parser():

dclab/definitions/__init__.py

@@ -6,7 +6,7 @@ from .feat_const import (
     # these should not be used
     feature_names, feature_labels, feature_name2label,
     # this one should also not be used, but we wait with deprecation,
-    # because Shape-Out heavily relies on it (it shouldn't)
+    # because DCscope heavily relies on it (it shouldn't)
     scalar_feature_names
     )
 from .feat_logic import (

dclab/definitions/feat_const.py

@@ -91,11 +91,13 @@ FEATURES_SCALAR = [
     # Sum of the pressures applied to sample and sheath flow
     ["pressure", "Pressure [mPa]"],
     # QPI features computed from holographic data
-    ["qpi_dm_avg", "Dry mass (average) [pg]"],
-    ["qpi_dm_sd", "Dry mass (SD) [pg]"],
+    ["qpi_dm", "Dry mass [pg]"],
+    ["qpi_dm_avg", "DEPRECATED Dry mass (average) [pg]"],
+    ["qpi_dm_dns", "Dry mass density [mg/ml]"],
+    ["qpi_dm_sd", "DEPRECATED Dry mass (SD) [pg]"],
     ["qpi_pha_int", "Integrated phase [rad]"],
     ["qpi_ri_avg", "Refractive index (average)"],
-    ["qpi_ri_sd", "Refractive index (SD)"],
+    ["qpi_ri_sd", "DEPRECATED Refractive index (SD)"],
     # QPI features from refocused events
     ["qpi_focus", "Computed focus distance [µm]"],
     # Size features
@@ -149,7 +151,7 @@ for _i in range(10):
 #: consist of the integer array `[1, 3, 5, 7, ...]` (indexing starts at zero).
 #: The `basinmap1` feature must then be referenced in the corresponding basin
 #: definition. These features should not be presented explicitly to the
-#: normal user (e.g. in Shape-Out) to avoid ambiguities, and they should
+#: normal user (e.g. in DCscope) to avoid ambiguities, and they should
 #: always be exported alongside basins that refer to them.
 for _j in range(10):
     FEATURES_SCALAR.append([f"basinmap{_j}", f"Basin mapping {_j}"])

dclab/definitions/feat_logic.py

@@ -1,6 +1,11 @@
+import re
+
 from . import feat_const
 
 
+ML_SCORE_REGEX = re.compile(r"^ml_score_[a-z0-9]{3}$")
+
+
 def check_feature_shape(name, data):
     """Check if (non)-scalar feature matches with its data's dimensionality
 
@@ -17,11 +22,15 @@ def check_feature_shape(name, data):
         If the data's shape does not match its scalar description
     """
     if len(data.shape) == 1 and not scalar_feature_exists(name):
-        raise ValueError(f"Feature '{name}' is not a scalar feature, but "
-                         "a 1D array was given for `data`!")
+        raise ValueError(
+            f"Feature '{name}' is not a scalar feature, but "
+            "a 1D array was given for `data`!"
+        )
     elif len(data.shape) != 1 and scalar_feature_exists(name):
-        raise ValueError(f"Feature '{name}' is a scalar feature, but the "
-                         "`data` array is not 1D!")
+        raise ValueError(
+            f"Feature '{name}' is a scalar feature, but the "
+            "`data` array is not 1D!"
+        )
 
 
 def feature_exists(name, scalar_only=False):
@@ -56,15 +65,9 @@ def feature_exists(name, scalar_only=False):
     elif not scalar_only and name in feat_const.feature_names:
         # non-scalar feature
         valid = True
-    else:
-        # check whether we have an `ml_score_???` feature
-        valid_chars = "0123456789abcdefghijklmnopqrstuvwxyz"
-        if (name.startswith("ml_score_")
-            and len(name) == len("ml_score_???")
-            and name[-3] in valid_chars
-            and name[-2] in valid_chars
-                and name[-1] in valid_chars):
-            valid = True
+    elif ML_SCORE_REGEX.match(name):
+        # machine-learning score feature ml_score_???
+        valid = True
     return valid
 
 
@@ -93,8 +96,10 @@ def feature_register(name, label=None, is_scalar=True):
     allowed_chars = "abcdefghijklmnopqrstuvwxyz_1234567890"
     feat = "".join([f for f in name if f in allowed_chars])
     if feat != name:
-        raise ValueError("`feature` must only contain lower-case characters, "
-                         f"digits, and underscores; got '{name}'!")
+        raise ValueError(
+            "`feature` must only contain lower-case characters, "
+            f"digits, and underscores; got '{name}'!"
+        )
     if label is None:
         label = f"User-defined feature {name}"
     if feature_exists(name):
@@ -156,22 +161,16 @@ def get_feature_label(name, rtdc_ds=None, with_unit=True):
     TODO: extract feature label from ancillary information when an rtdc_ds is
     given.
     """
-    # TODO: Is there another way of avoiding this circular import?
-    from ..rtdc_dataset.feat_anc_core.ancillary_feature import AncillaryFeature
-    assert feature_exists(name)
     if name in feat_const.feature_name2label:
         label = feat_const.feature_name2label[name]
+    elif ML_SCORE_REGEX.match(name):
+        # use a generic name for machine-learning features
+        label = f"ML score {name[-3:].upper()}"
     else:
-        # First check whether an ancillary feature with that
-        # name exists.
-        for af in AncillaryFeature.features:
-            if af.feature_name == name:
-                labelid = af.data.outputs.index(name)
-                label = af.data.output_labels[labelid]
-                break
-        else:
-            # If that did not work, use a generic name.
-            label = "ML score {}".format(name[-3:].upper())
+        exists = feature_exists(name)
+        msg = f"Could not find label for '{name}'"
+        msg += " (feature does not exist)" if not exists else ""
+        raise ValueError(msg)
     if not with_unit:
         if label.endswith("]") and label.count("["):
             label = label.rsplit("[", 1)[0].strip()

dclab/downsampling.pyx

@@ -176,14 +176,19 @@ def downsample_grid(a, b, samples, remove_invalid=False, ret_idx=False):
     if not remove_invalid:
         diff_bad = (samples_int or keep.size) - np.sum(keep)
         if diff_bad > 0:
-            # Add a few of the invalid values so that in the end
-            # we have the desired array size.
             add_indices_bad = np.where(bad)[0]
-            np.random.set_state(rs)
-            add_bad = np.random.choice(add_indices_bad,
-                                       size=diff_bad,
-                                       replace=False)
-            keep[add_bad] = True
+            if add_indices_bad.size > diff_bad:
+                # Add a few of the invalid values so that in the end
+                # we have the desired array size.
+                np.random.set_state(rs)
+                add_bad = np.random.choice(add_indices_bad,
+                                           size=diff_bad,
+                                           replace=False)
+                keep[add_bad] = True
+            else:
+                # We don't have enough bad indices (or just enough),
+                # so we add them all.
+                keep[add_indices_bad] = True
 
     # paulmueller 2024-01-03
     # if samples_int and not remove_invalid:

dclab/features/bright.py

@@ -2,10 +2,19 @@
 Computation of mean and standard deviation of grayscale values inside the
 RT-DC event image mask.
 """
+from __future__ import annotations
+
 import numpy as np
+import numpy.typing as npt
 
 
-def get_bright(mask, image, ret_data="avg,sd"):
+def get_bright(mask: npt.NDArray[bool] | list[npt.NDArray[bool]],
+               image: npt.NDArray | list[npt.NDArray],
+               ret_data: str = "avg,sd"
+               ) -> (float |
+                     npt.NDArray |
+                     tuple[float, float] |
+                     tuple[npt.NDArray, npt.NDArray]):
     """Compute avg and/or std of the event brightness
 
     The event brightness is defined by the gray-scale values of the
@@ -18,7 +27,7 @@ def get_bright(mask, image, ret_data="avg,sd"):
     image: ndarray or list of ndarrays of shape (M,N)
         A 2D array that holds the image in form of grayscale values
         of an event.
-    ret_data: str
+    ret_data
         A comma-separated list of metrices to compute
         - "avg": compute the average
         - "sd": compute the standard deviation

dclab/features/bright_bc.py

@@ -2,10 +2,21 @@
 Computation of mean and standard deviation of grayscale values inside the
 RT-DC event image mask with background-correction taken into account.
 """
+from __future__ import annotations
+
 import numpy as np
+import numpy.typing as npt
 
 
-def get_bright_bc(mask, image, image_bg, bg_off=None, ret_data="avg,sd"):
+def get_bright_bc(mask: npt.NDArray[bool] | list[npt.NDArray[bool]],
+                  image: npt.NDArray | list[npt.NDArray],
+                  image_bg: npt.NDArray | list[npt.NDArray],
+                  bg_off: float | npt.NDArray = None,
+                  ret_data: str = "avg,sd"
+                  ) -> (float |
+                        npt.NDArray |
+                        tuple[float, float] |
+                        tuple[npt.NDArray, npt.NDArray]):
     """Compute avg and/or std of the background-corrected event brightness
 
     The background-corrected event brightness is defined by the
@@ -24,7 +35,7 @@ def get_bright_bc(mask, image, image_bg, bg_off=None, ret_data="avg,sd"):
     bg_off: float or 1D ndarray
         Additional offset value that is added to `image_bg` before
         background correction
-    ret_data: str
+    ret_data
         A comma-separated list of metrices to compute
         - "avg": compute the average
         - "sd": compute the standard deviation

dclab/features/bright_perc.py

@@ -2,10 +2,18 @@
 Computation of the 10th and 90th percentile of grayscale values inside the
 RT-DC event image mask with background-correction taken into account.
 """
+from __future__ import annotations
+
 import numpy as np
+import numpy.typing as npt
 
 
-def get_bright_perc(mask, image, image_bg, bg_off=None):
+def get_bright_perc(mask: npt.NDArray[bool] | list[npt.NDArray[bool]],
+                    image: npt.NDArray | list[npt.NDArray],
+                    image_bg: npt.NDArray | list[npt.NDArray],
+                    bg_off: float | npt.NDArray = None
+                    ) -> (tuple[float, float] |
+                          tuple[npt.NDArray, npt.NDArray]):
     """Compute 10th and 90th percentile of the bg-corrected event brightness
 
     The background-corrected event brightness is defined by the
@@ -29,7 +37,7 @@ def get_bright_perc(mask, image, image_bg, bg_off=None):
     -------
     bright_perc_10: float or ndarray of size N
         10th percentile of brightness
-    bright_perc_10: float or ndarray of size N
+    bright_perc_90: float or ndarray of size N
         90th percentile of brightness
     """
     if isinstance(mask, np.ndarray) and len(mask.shape) == 2:

dclab/features/contour.py

@@ -1,8 +1,11 @@
 """Computation of event contour from event mask"""
+from __future__ import annotations
+
 from collections import deque
 import numbers
 
 import numpy as np
+import numpy.typing as npt
 
 # equivalent to
 # from skimage.measure import find_contours
@@ -14,15 +17,15 @@ class NoValidContourFoundError(BaseException):
 
 
 class LazyContourList(object):
-    def __init__(self, masks, max_events=1000):
+    def __init__(self, masks: npt.ArrayLike, max_events: int = 1000) -> None:
         """A list-like object that computes contours upon indexing
 
         Parameters
         ----------
-        masks: array-like
+        masks
             3D array of masks, may be an HDF5 dataset or any other
             structure that supports indexing
-        max_events: int
+        max_events
             maximum number of contours to keep in the contour list;
             set to 0/False/None to cache all contours
 
@@ -40,7 +43,7 @@ class LazyContourList(object):
         self.identifier = str(masks[0][:].tobytes())
         self.shape = len(masks), np.nan, 2
 
-    def __getitem__(self, idx):
+    def __getitem__(self, idx) -> npt.NDArray:
         """Compute contour(s) if not already in self.contours"""
         if not isinstance(idx, numbers.Integral):
             # slicing!
@@ -74,7 +77,8 @@ class LazyContourList(object):
         return len(self.masks)
 
 
-def get_contour(mask):
+def get_contour(mask: npt.NDArray[np.bool | np.int]
+                ) -> npt.NDArray | list[npt.NDArray]:
     """Compute the image contour from a mask
 
     The contour is computed in a very inefficient way using scikit-image
@@ -127,7 +131,8 @@ def get_contour(mask):
         return contours[0]
 
 
-def get_contour_lazily(mask):
+def get_contour_lazily(mask: npt.NDArray[np.bool | np.int]
+                       ) -> npt.NDArray | LazyContourList:
     """Like :func:`get_contour`, but computes contours on demand
 
     Parameters
@@ -153,7 +158,7 @@ def get_contour_lazily(mask):
     return cont
 
 
-def remove_duplicates(cont):
+def remove_duplicates(cont: npt.NDArray) -> npt.NDArray:
     """Remove duplicates in a circular contour"""
     x = np.resize(cont, (len(cont) + 1, 2))
     selection = np.ones(len(x), dtype=bool)

dclab/features/emodulus/__init__.py

@@ -7,6 +7,7 @@ from typing import Literal
 import warnings
 
 import numpy as np
+import numpy.typing as npt
 import scipy.interpolate as spint
 
 from ...warn import PipelineWarning
@@ -18,7 +19,6 @@ from .scale_linear import convert  # noqa: F401
 from .scale_linear import scale_emodulus, scale_feature
 from .viscosity import get_viscosity
 
-
 #: Set this to True to globally enable spline extrapolation when the
 #: `area_um`/`deform` data are outside the LUT. This is discouraged and
 #: a :class:`KnowWhatYouAreDoingWarning` warning will be issued.
@@ -33,8 +33,13 @@ class YoungsModulusLookupTableExceededWarning(PipelineWarning):
     pass
 
 
-def extrapolate_emodulus(lut, datax, deform, emod, deform_norm,
-                         deform_thresh=.05, inplace=True):
+def extrapolate_emodulus(lut: npt.NDArray,
+                         datax: npt.NDArray,
+                         deform: npt.NDArray,
+                         emod: npt.NDArray,
+                         deform_norm: float,
+                         deform_thresh: float = .05,
+                         inplace: bool = True) -> npt.NDArray:
     """Use spline interpolation to fill in nan-values
 
     When points (`datax`, `deform`) are outside the convex
@@ -61,16 +66,16 @@ def extrapolate_emodulus(lut, datax, deform, emod, deform_norm,
     emod: ndarray of size N
         The emodulus (corresponding to `lut[:, 2]`); If `emod`
         does not contain nan-values, there is nothing to do here.
-    deform_norm: float
+    deform_norm
         The normalization value used to normalize `lut[:, 1]` and
         `deform`.
-    deform_thresh: float
+    deform_thresh
         Not the entire LUT is used for bivariate spline interpolation.
         Only the points where `lut[:, 1] > deform_thresh/deform_norm`
         are used. This is necessary, because for small deformations,
         the LUT has an extreme slope that kills any meaningful
         spline interpolation.
-    inplace: bool
+    inplace
         If True (default), replaces nan values in `emod` in-place.
         If False, `emod` is not modified.
     """
@@ -99,50 +104,51 @@ def extrapolate_emodulus(lut, datax, deform, emod, deform_norm,
     return emod
 
 
-def get_emodulus(deform: float | np.array,
-                 area_um: float | np.array | None = None,
-                 volume: float | np.array | None = None,
+def get_emodulus(deform: float | npt.NDArray,
+                 area_um: float | npt.NDArray | None = None,
+                 volume: float | npt.NDArray | None = None,
                  medium: float | str = "0.49% MC-PBS",
                  channel_width: float = 20.0,
                  flow_rate: float = 0.16,
                  px_um: float = 0.34,
-                 temperature: float | np.ndarray | None = 23.0,
-                 lut_data: str | pathlib.Path | np.ndarray = "LE-2D-FEM-19",
+                 temperature: float | npt.NDArray | None = 23.0,
+                 lut_data: (str | pathlib.Path |
+                            tuple[npt.NDArray, dict]) = "LE-2D-FEM-19",
                  visc_model: Literal['herold-2017',
                                      'herold-2017-fallback',
                                      'buyukurganci-2022',
                                      'kestin-1978',
                                      None] = "herold-2017-fallback",
                  extrapolate: bool = INACCURATE_SPLINE_EXTRAPOLATION,
-                 copy: bool = True):
+                 copy: bool = True) -> npt.NDArray:
     """Compute apparent Young's modulus using a look-up table
 
     Parameters
     ----------
-    area_um: float or ndarray
-        Apparent (2D image) area [µm²] of the event(s)
-    deform: float or ndarray
+    deform
         Deformation (1-circularity) of the event(s)
-    volume: float or ndarray
+    area_um
+        Apparent (2D image) area [µm²] of the event(s)
+    volume
         Apparent volume of the event(s). It is not possible to define
         `volume` and `area_um` at the same time (makes no sense).
 
         .. versionadded:: 0.25.0
-    medium: str or float
+    medium
         The medium to compute the viscosity for. If a string
         is given, the viscosity is computed. If a float is given,
         this value is used as the viscosity in mPa*s (Note that
         `temperature` and `visc_model` must be set to None in this case).
-    channel_width: float
+    channel_width
         The channel width [µm]
-    flow_rate: float
+    flow_rate
         Flow rate [µL/s]
-    px_um: float
+    px_um
         The detector pixel size [µm] used for pixelation correction.
         Set to zero to disable.
-    temperature: float, ndarray, or None
+    temperature
         Temperature [°C] of the event(s)
-    lut_data: path, str, or tuple of (np.ndarray of shape (N, 3), dict)
+    lut_data: str, path, or tuple of (np.ndarray of shape (N, 3), dict)
         The LUT data to use. If it is a built-in identifier,
         then the respective LUT will be used. Otherwise, a path to a
         file on disk or a tuple (LUT array, metadata) is possible.
@@ -150,14 +156,14 @@ def get_emodulus(deform: float | np.array,
         (e.g. `area_um` and `deform`) are valid interpolation choices.
 
         .. versionadded:: 0.25.0
-    visc_model: str
+    visc_model
         The viscosity model to use,
         see :func:`dclab.features.emodulus.viscosity.get_viscosity`
-    extrapolate: bool
+    extrapolate
         Perform extrapolation using :func:`extrapolate_emodulus`. This
         is discouraged!
-    copy: bool
-        Copy input arrays. If set to false, input arrays are
+    copy
+        Copy input arrays. If set to False, input arrays are
         overridden.
 
     Returns
@@ -326,7 +332,7 @@ def get_emodulus(deform: float | np.array,
     return emod
 
 
-def normalize(data, dmax):
+def normalize(data: npt.NDArray, dmax: float) -> npt.NDArray:
     """Perform normalization in-place for interpolation
 
     Note that :func:`scipy.interpolate.griddata` has a `rescale`

dclab/features/emodulus/load.py

@@ -12,6 +12,7 @@ import importlib_resources
 import warnings
 
 import numpy as np
+import numpy.typing as npt
 
 from ... import definitions as dfn
 
@@ -24,7 +25,7 @@ EXTERNAL_LUTS = {}
 
 
 @functools.lru_cache()
-def get_internal_lut_names_dict():
+def get_internal_lut_names_dict() -> dict:
     """Return list of internal lut names"""
     lutfiles = {}
     for pp in importlib_resources.files('dclab.features.emodulus').iterdir():
@@ -34,10 +35,10 @@ def get_internal_lut_names_dict():
     return lutfiles
 
 
-def get_lut_path(path_or_id):
+def get_lut_path(path_or_id: str | pathlib.Path) -> pathlib.Path:
     """Find the path to a LUT
 
-    path_or_id: str or pathlib.Path
+    path_or_id
         Identifier of a LUT. This can be either an existing path
         (checked first), or an internal identifier (see
         :func:`get_internal_lut_names_dict`).
@@ -63,7 +64,8 @@ def get_lut_path(path_or_id):
     return lut_path
 
 
-def load_lut(lut_data: str | pathlib.Path | np.ndarray = "LE-2D-FEM-19"):
+def load_lut(lut_data: str | pathlib.Path | tuple[npt.NDArray, dict] =
+             "LE-2D-FEM-19") -> tuple[npt.NDArray, dict]:
     """Load LUT data from disk
 
     Parameters
@@ -98,7 +100,7 @@ def load_lut(lut_data: str | pathlib.Path | np.ndarray = "LE-2D-FEM-19"):
     return lut, meta
 
 
-def load_mtext(path):
+def load_mtext(path: str | pathlib.Path) -> tuple[npt.NDArray, dict]:
     """Load column-based data from text files with metadata
 
     This file format is used for isoelasticity lines and look-up
@@ -217,7 +219,7 @@ def load_mtext(path):
     return data, meta
 
 
-def register_lut(path, identifier=None):
+def register_lut(path: str | pathlib.Path, identifier: str = None) -> None:
     """Register an external LUT file in dclab
 
     This will add it to :const:`EXTERNAL_LUTS`, which is required