dclab 0.62.16__tar.gz → 0.62.17__tar.gz

{dclab-0.62.16 → dclab-0.62.17}/CHANGELOG

@@ -1,3 +1,8 @@
+0.62.17
+ - docs: properly employ license GPL-2.0-or-later
+ - ref: add KernelDensityEstimator class
+ - ref: perform avi export with PyAV instead of imageio
+ - setup: bump fcswrite to 0.5.1
 0.62.16
  - enh: allow editing S3 credentials via environment variables at runtime
  - docs: fix typo in S3 section (missing `DCLAB_S3_SECRET_ACCESS_KEY`)

{dclab-0.62.16 → dclab-0.62.17}/LICENSE

@@ -1,5 +1,5 @@
 Unless otherwise specified by LICENSE files in individual
-directories, all code is
+directories, all code is licensed under the following license.
 
                     GNU GENERAL PUBLIC LICENSE
                        Version 2, June 1991
@@ -281,63 +281,3 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
                      END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    {description}
-    Copyright (C) {year}  {fullname}
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  {signature of Ty Coon}, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
-

{dclab-0.62.16 → dclab-0.62.17}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: dclab
-Version: 0.62.16
+Version: 0.62.17
 Summary: Library for real-time deformability cytometry (RT-DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maik Herbig, Maximilian Schlögel, Nadia Sbaa, Paul Müller, Philipp Rosendahl, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>
-License: GPL version 2.0 or later
+License: GPL-2.0-or-later
 Project-URL: source, https://github.com/DC-Analysis/dclab
 Project-URL: tracker, https://github.com/DC-Analysis/dclab/issues
 Project-URL: documentation, https://dclab.readthedocs.io/en/stable/
@@ -27,8 +27,8 @@ Requires-Dist: dclab[dcor,export,http,s3,tdms]; extra == "all"
 Provides-Extra: dcor
 Requires-Dist: requests<3,>=2.31.0; extra == "dcor"
 Provides-Extra: export
-Requires-Dist: fcswrite>=0.5.0; extra == "export"
-Requires-Dist: imageio[ffmpeg]; extra == "export"
+Requires-Dist: fcswrite>=0.5.1; extra == "export"
+Requires-Dist: av; extra == "export"
 Provides-Extra: http
 Requires-Dist: requests<3,>=2.31.0; extra == "http"
 Provides-Extra: s3

dclab-0.62.17/dclab/__init__.py

@@ -0,0 +1,41 @@
+"""Core tools for the analysis of deformability cytometry datasets
+
+Copyright (C) 2015 Paul Müller
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+"""
+# flake8: noqa: F401
+from . import definitions as dfn
+from . import features
+from . import isoelastics
+from . import lme4
+from .polygon_filter import PolygonFilter
+from . import rtdc_dataset
+from .rtdc_dataset import new_dataset, IntegrityChecker, RTDCWriter
+from .rtdc_dataset.feat_temp import (
+    register_temporary_feature, set_temporary_feature)
+from .rtdc_dataset.feat_anc_ml import (
+    MachineLearningFeature, load_modc, load_ml_feature, save_modc)
+from .rtdc_dataset.feat_anc_plugin.plugin_feature import (
+    PlugInFeature, load_plugin_feature)
+from . import statistics
+from . import util
+
+from ._version import __version__, __version_tuple__
+
+
+# Lazy-load deprecated kde modules 
+kde_contours = util.LazyLoader("dclab.kde_contours")
+kde_methods = util.LazyLoader("dclab.kde_methods")

{dclab-0.62.16 → dclab-0.62.17}/dclab/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.62.16'
-__version_tuple__ = version_tuple = (0, 62, 16)
+__version__ = version = '0.62.17'
+__version_tuple__ = version_tuple = (0, 62, 17)

dclab-0.62.17/dclab/kde/__init__.py

@@ -0,0 +1 @@
+from .base import KernelDensityEstimator  # noqa: F401

dclab-0.62.17/dclab/kde/base.py

@@ -0,0 +1,238 @@
+import warnings
+
+import numpy as np
+
+from .methods import bin_width_doane, get_bad_vals, methods
+
+
+class KernelDensityEstimator:
+    def __init__(self, rtdc_ds):
+        self.rtdc_ds = rtdc_ds
+
+    @staticmethod
+    def apply_scale(a, scale, feat):
+        """Helper function for transforming an aray to log-scale
+
+        Parameters
+        ----------
+        a: np.ndarray
+            Input array
+        scale: str
+            If set to "log", take the logarithm of `a`; if set to
+            "linear" return `a` unchanged.
+        feat: str
+            Feature name (required for debugging)
+
+        Returns
+        -------
+        b: np.ndarray
+            The scaled array
+
+        Notes
+        -----
+        If the scale is not "linear", then a new array is returned.
+        All warnings are suppressed when computing `np.log(a)`, as
+        `a` may have negative or nan values.
+        """
+        if scale == "linear":
+            b = a
+        elif scale == "log":
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                b = np.log(a)
+                if len(w):
+                    # Tell the user that the log-transformation issued
+                    # a warning.
+                    warnings.warn(f"Invalid values encounterd in np.log "
+                                  f"while scaling feature '{feat}'!")
+        else:
+            raise ValueError(f"`scale` must be either 'linear' or 'log', "
+                             f"got '{scale}'!")
+        return b
+
+    @staticmethod
+    def get_spacing(a, method, scale="linear", method_kw=None,
+                    feat="undefined", ret_scaled=False):
+        """Convenience function for computing the contour spacing
+
+        Parameters
+        ----------
+        a: ndarray
+            feature data
+        scale: str
+            how the data should be scaled ("log" or "linear")
+        method: callable
+            KDE spacing method to use
+        method_kw: dict
+            keyword arguments to `method`
+        feat: str
+            feature name for debugging
+        ret_scaled: bool
+            whether to return the scaled array of `a`
+        """
+        if method_kw is None:
+            method_kw = {}
+        # Apply scale (no change for linear scale)
+        asc = KernelDensityEstimator.apply_scale(a, scale, feat)
+        # Apply multiplicator
+        acc = method(asc, **method_kw)
+        if ret_scaled:
+            return acc, asc
+        else:
+            return acc
+
+    def get_contour(self, xax="area_um", yax="deform", xacc=None, yacc=None,
+                    kde_type="histogram", kde_kwargs=None, xscale="linear",
+                    yscale="linear"):
+        """Evaluate the kernel density estimate for contour plots
+
+        Parameters
+        ----------
+        xax: str
+            Identifier for X axis (e.g. "area_um", "aspect", "deform")
+        yax: str
+            Identifier for Y axis
+        xacc: float
+            Contour accuracy in x direction
+        yacc: float
+            Contour accuracy in y direction
+        kde_type: str
+            The KDE method to use
+        kde_kwargs: dict
+            Additional keyword arguments to the KDE method
+        xscale: str
+            If set to "log", take the logarithm of the x-values before
+            computing the KDE. This is useful when data are
+            displayed on a log-scale. Defaults to "linear".
+        yscale: str
+            See `xscale`.
+
+        Returns
+        -------
+        X, Y, Z : coordinates
+            The kernel density Z evaluated on a rectangular grid (X,Y).
+        """
+        if kde_kwargs is None:
+            kde_kwargs = {}
+        xax = xax.lower()
+        yax = yax.lower()
+        kde_type = kde_type.lower()
+        if kde_type not in methods:
+            raise ValueError(f"Not a valid kde type: {kde_type}!")
+
+        # Get data
+        x = self.rtdc_ds[xax][self.rtdc_ds.filter.all]
+        y = self.rtdc_ds[yax][self.rtdc_ds.filter.all]
+
+        xacc_sc, xs = self.get_spacing(
+            a=x,
+            feat=xax,
+            scale=xscale,
+            method=bin_width_doane,
+            ret_scaled=True)
+
+        yacc_sc, ys = self.get_spacing(
+            a=y,
+            feat=yax,
+            scale=yscale,
+            method=bin_width_doane,
+            ret_scaled=True)
+
+        if xacc is None or xacc == 0:
+            xacc = xacc_sc / 5
+
+        if yacc is None or yacc == 0:
+            yacc = yacc_sc / 5
+
+        # Ignore infs and nans
+        bad = get_bad_vals(xs, ys)
+        xc = xs[~bad]
+        yc = ys[~bad]
+
+        xnum = int(np.ceil((xc.max() - xc.min()) / xacc))
+        ynum = int(np.ceil((yc.max() - yc.min()) / yacc))
+
+        xlin = np.linspace(xc.min(), xc.max(), xnum, endpoint=True)
+        ylin = np.linspace(yc.min(), yc.max(), ynum, endpoint=True)
+
+        xmesh, ymesh = np.meshgrid(xlin, ylin, indexing="ij")
+
+        kde_fct = methods[kde_type]
+        if len(x):
+            density = kde_fct(events_x=xs, events_y=ys,
+                              xout=xmesh, yout=ymesh,
+                              **kde_kwargs)
+        else:
+            density = np.array([])
+
+        # Convert mesh back to linear scale if applicable
+        if xscale == "log":
+            xmesh = np.exp(xmesh)
+        if yscale == "log":
+            ymesh = np.exp(ymesh)
+
+        return xmesh, ymesh, density
+
+    def get_scatter(self, xax="area_um", yax="deform", positions=None,
+                    kde_type="histogram", kde_kwargs=None, xscale="linear",
+                    yscale="linear"):
+        """Evaluate the kernel density estimate for scatter plots
+
+        Parameters
+        ----------
+        xax: str
+            Identifier for X axis (e.g. "area_um", "aspect", "deform")
+        yax: str
+            Identifier for Y axis
+        positions: list of two 1d ndarrays or ndarray of shape (2, N)
+            The positions where the KDE will be computed. Note that
+            the KDE estimate is computed from the points that
+            are set in `self.rtdc_ds.filter.all`.
+        kde_type: str
+            The KDE method to use, see :const:`.kde_methods.methods`
+        kde_kwargs: dict
+            Additional keyword arguments to the KDE method
+        xscale: str
+            If set to "log", take the logarithm of the x-values before
+            computing the KDE. This is useful when data are are
+            displayed on a log-scale. Defaults to "linear".
+        yscale: str
+            See `xscale`.
+
+        Returns
+        -------
+        density : 1d ndarray
+            The kernel density evaluated for the filtered data points.
+        """
+        if kde_kwargs is None:
+            kde_kwargs = {}
+        xax = xax.lower()
+        yax = yax.lower()
+        kde_type = kde_type.lower()
+        if kde_type not in methods:
+            raise ValueError(f"Not a valid kde type: {kde_type}!")
+
+        # Get data
+        x = self.rtdc_ds[xax][self.rtdc_ds.filter.all]
+        y = self.rtdc_ds[yax][self.rtdc_ds.filter.all]
+
+        # Apply scale (no change for linear scale)
+        xs = self.apply_scale(x, xscale, xax)
+        ys = self.apply_scale(y, yscale, yax)
+
+        if positions is None:
+            posx = None
+            posy = None
+        else:
+            posx = self.apply_scale(positions[0], xscale, xax)
+            posy = self.apply_scale(positions[1], yscale, yax)
+
+        kde_fct = methods[kde_type]
+        if len(x):
+            density = kde_fct(events_x=xs, events_y=ys,
+                              xout=posx, yout=posy,
+                              **kde_kwargs)
+        else:
+            density = np.array([])
+
+        return density

dclab-0.62.16/dclab/kde_contours.py → dclab-0.62.17/dclab/kde/contours.py

@@ -1,10 +1,10 @@
 
 import numpy as np
 
-from .external.skimage.measure import find_contours, points_in_poly
+from ..external.skimage.measure import find_contours, points_in_poly
 import scipy.interpolate as spint
 
-from .kde_methods import get_bad_vals
+from .methods import get_bad_vals
 
 
 def find_contours_level(density, x, y, level, closed=False):

dclab-0.62.16/dclab/kde_methods.py → dclab-0.62.17/dclab/kde/methods.py

@@ -4,8 +4,8 @@ import numpy as np
 from scipy.interpolate import RectBivariateSpline
 from scipy.stats import gaussian_kde, skew
 
-from .cached import Cache
-from .external.statsmodels.nonparametric.kernel_density import KDEMultivariate
+from ..cached import Cache
+from ..external.statsmodels.nonparametric.kernel_density import KDEMultivariate
 
 
 def bin_num_doane(a):

dclab-0.62.17/dclab/kde_contours.py

@@ -0,0 +1,10 @@
+import warnings
+
+from .kde.contours import (  # noqa: F401
+    find_contours_level, _find_quantile_level, get_quantile_levels
+)
+
+
+warnings.warn("`dclab.kde_contours` is deprecated; please use "
+              "the `dclab.kde.contours` instead",
+              DeprecationWarning)

dclab-0.62.17/dclab/kde_methods.py

@@ -0,0 +1,11 @@
+import warnings
+
+from .kde.methods import (  # noqa: F401
+    bin_num_doane, bin_width_doane, bin_width_percentile, get_bad_vals,
+    ignore_nan_inf, kde_gauss, kde_histogram, kde_multivariate, kde_none,
+    methods
+)
+
+warnings.warn("`dclab.kde_methods` is deprecated; please use "
+              "the `dclab.kde.methods` instead",
+              DeprecationWarning)

{dclab-0.62.16 → dclab-0.62.17}/dclab/rtdc_dataset/core.py

@@ -4,23 +4,23 @@ import hashlib
 import json
 import os.path
 import pathlib
+import random
 import traceback
 from typing import Literal
 import uuid
-import random
 import warnings
 
 import numpy as np
 
 from .. import definitions as dfn
 from .. import downsampling
+from ..kde import KernelDensityEstimator
+from ..kde import methods as kde_methods
 from ..polygon_filter import PolygonFilter
-from .. import kde_methods
 from ..util import hashobj
-
-from .feat_anc_core import AncillaryFeature, FEATURES_RAPID
 from . import feat_basin
 from .export import Export
+from .feat_anc_core import FEATURES_RAPID, AncillaryFeature
 from .filter import Filter
 
 
@@ -28,6 +28,10 @@ class FeatureShouldExistButNotFoundWarning(UserWarning):
     pass
 
 
+class LocalBasinForbiddenWarning(UserWarning):
+    pass
+
+
 class LogTransformWarning(UserWarning):
     pass
 
@@ -322,47 +326,6 @@ class RTDCBase(abc.ABC):
                     pass
         return data
 
-    @staticmethod
-    def _apply_scale(a, scale, feat):
-        """Helper function for transforming an aray to log-scale
-
-        Parameters
-        ----------
-        a: np.ndarray
-            Input array
-        scale: str
-            If set to "log", take the logarithm of `a`; if set to
-            "linear" return `a` unchanged.
-        feat: str
-            Feature name (required for debugging)
-
-        Returns
-        -------
-        b: np.ndarray
-            The scaled array
-
-        Notes
-        -----
-        If the scale is not "linear", then a new array is returned.
-        All warnings are suppressed when computing `np.log(a)`, as
-        `a` may have negative or nan values.
-        """
-        if scale == "linear":
-            b = a
-        elif scale == "log":
-            with warnings.catch_warnings(record=True) as w:
-                warnings.simplefilter("always")
-                b = np.log(a)
-                if len(w):
-                    # Tell the user that the log-transformation issued
-                    # a warning.
-                    warnings.warn("Invalid values encounterd in np.log "
-                                  "while scaling feature '{}'!".format(feat))
-        else:
-            raise ValueError("`scale` must be either 'linear' or 'log', "
-                             + "got '{}'!".format(scale))
-        return b
-
     @staticmethod
     def get_kde_spacing(a, scale="linear", method=kde_methods.bin_width_doane,
                         method_kw=None, feat="undefined", ret_scaled=False):
@@ -383,16 +346,14 @@ class RTDCBase(abc.ABC):
         ret_scaled: bool
             whether to return the scaled array of `a`
         """
-        if method_kw is None:
-            method_kw = {}
-        # Apply scale (no change for linear scale)
-        asc = RTDCBase._apply_scale(a, scale, feat)
-        # Apply multiplicator
-        acc = method(asc, **method_kw)
-        if ret_scaled:
-            return acc, asc
-        else:
-            return acc
+        return KernelDensityEstimator.get_spacing(
+            a=a,
+            scale=scale,
+            method=method,
+            method_kw=method_kw,
+            feat=feat,
+            ret_scaled=ret_scaled,
+        )
 
     @property
     def _feature_candidates(self):
@@ -625,8 +586,8 @@ class RTDCBase(abc.ABC):
         y = self[yax][self.filter.all]
 
         # Apply scale (no change for linear scale)
-        xs = RTDCBase._apply_scale(x, xscale, xax)
-        ys = RTDCBase._apply_scale(y, yscale, yax)
+        xs = KernelDensityEstimator.apply_scale(x, xscale, xax)
+        ys = KernelDensityEstimator.apply_scale(y, yscale, yax)
 
         _, _, idx = downsampling.downsample_grid(xs, ys,
                                                  samples=downsample,
@@ -673,64 +634,11 @@ class RTDCBase(abc.ABC):
         X, Y, Z : coordinates
             The kernel density Z evaluated on a rectangular grid (X,Y).
         """
-        if kde_kwargs is None:
-            kde_kwargs = {}
-        xax = xax.lower()
-        yax = yax.lower()
-        kde_type = kde_type.lower()
-        if kde_type not in kde_methods.methods:
-            raise ValueError("Not a valid kde type: {}!".format(kde_type))
-
-        # Get data
-        x = self[xax][self.filter.all]
-        y = self[yax][self.filter.all]
-
-        xacc_sc, xs = RTDCBase.get_kde_spacing(
-            a=x,
-            feat=xax,
-            scale=xscale,
-            method=kde_methods.bin_width_doane,
-            ret_scaled=True)
-
-        yacc_sc, ys = RTDCBase.get_kde_spacing(
-            a=y,
-            feat=yax,
-            scale=yscale,
-            method=kde_methods.bin_width_doane,
-            ret_scaled=True)
-
-        if xacc is None or xacc == 0:
-            xacc = xacc_sc / 5
-
-        if yacc is None or yacc == 0:
-            yacc = yacc_sc / 5
-
-        # Ignore infs and nans
-        bad = kde_methods.get_bad_vals(xs, ys)
-        xc = xs[~bad]
-        yc = ys[~bad]
-
-        xnum = int(np.ceil((xc.max() - xc.min()) / xacc))
-        ynum = int(np.ceil((yc.max() - yc.min()) / yacc))
-
-        xlin = np.linspace(xc.min(), xc.max(), xnum, endpoint=True)
-        ylin = np.linspace(yc.min(), yc.max(), ynum, endpoint=True)
-
-        xmesh, ymesh = np.meshgrid(xlin, ylin, indexing="ij")
-
-        kde_fct = kde_methods.methods[kde_type]
-        if len(x):
-            density = kde_fct(events_x=xs, events_y=ys,
-                              xout=xmesh, yout=ymesh,
-                              **kde_kwargs)
-        else:
-            density = np.array([])
-
-        # Convert mesh back to linear scale if applicable
-        if xscale == "log":
-            xmesh = np.exp(xmesh)
-        if yscale == "log":
-            ymesh = np.exp(ymesh)
+        kde_instance = KernelDensityEstimator(rtdc_ds=self)
+        xmesh, ymesh, density = kde_instance.get_contour(
+            xax=xax, yax=yax, xacc=xacc, yacc=yacc, kde_type=kde_type,
+            kde_kwargs=kde_kwargs, xscale=xscale, yscale=yscale
+        )
 
         return xmesh, ymesh, density
 
@@ -765,36 +673,11 @@ class RTDCBase(abc.ABC):
         density : 1d ndarray
             The kernel density evaluated for the filtered data points.
         """
-        if kde_kwargs is None:
-            kde_kwargs = {}
-        xax = xax.lower()
-        yax = yax.lower()
-        kde_type = kde_type.lower()
-        if kde_type not in kde_methods.methods:
-            raise ValueError("Not a valid kde type: {}!".format(kde_type))
-
-        # Get data
-        x = self[xax][self.filter.all]
-        y = self[yax][self.filter.all]
-
-        # Apply scale (no change for linear scale)
-        xs = RTDCBase._apply_scale(x, xscale, xax)
-        ys = RTDCBase._apply_scale(y, yscale, yax)
-
-        if positions is None:
-            posx = None
-            posy = None
-        else:
-            posx = RTDCBase._apply_scale(positions[0], xscale, xax)
-            posy = RTDCBase._apply_scale(positions[1], yscale, yax)
-
-        kde_fct = kde_methods.methods[kde_type]
-        if len(x):
-            density = kde_fct(events_x=xs, events_y=ys,
-                              xout=posx, yout=posy,
-                              **kde_kwargs)
-        else:
-            density = np.array([])
+        kde_instance = KernelDensityEstimator(rtdc_ds=self)
+        density = kde_instance.get_scatter(
+            xax=xax, yax=yax, positions=positions, kde_type=kde_type,
+            kde_kwargs=kde_kwargs, xscale=xscale, yscale=yscale
+        )
 
         return density
 
@@ -879,7 +762,8 @@ class RTDCBase(abc.ABC):
             elif bdict["type"] == "file":
                 if not self._local_basins_allowed:
                     warnings.warn(f"Basin type 'file' not allowed for format "
-                                  f"'{self.format}'")
+                                  f"'{self.format}'",
+                                  LocalBasinForbiddenWarning)
                     # stop processing this basin
                     continue
                 p_paths = list(bdict["paths"])