dcscope 2.25.0__tar.gz → 2.25.2__tar.gz

{dcscope-2.25.0 → dcscope-2.25.2}/CHANGELOG

@@ -1,3 +1,13 @@
+2.25.2
+ - fix: check directory existence when loading files (#227)
+2.25.1
+ - fix: removing a box filter did not clear the filter in some cases
+ - ref: do not allow specifying filters in `FilterRay.get_dataset()`
+ - ref: unify hashing caching of datasets in `FilterRay.segments`
+ - ref: remove ambiguous `FilterRay.root_child` workaround
+ - ref: simplify `FilterRay.get_final_child`
+ - tests: improve `FilterRay` test coverage
+ - setup: bump dclab to 0.67.4 (correct `reset_filter` method)
 2.25.0
  - feat: increase width of dataset tile in block matrix via settings (#225)
  - fix: IndexError when trying to view the logs of a log-less dataset

{dcscope-2.25.0/dcscope.egg-info → dcscope-2.25.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcscope
-Version: 2.25.0
+Version: 2.25.2
 Summary: User interface for deformability cytometry (DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maximilian Schlögel, Paul Müller, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>
@@ -16,7 +16,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: dclab[dcor,export,http,s3]>=0.67.3
+Requires-Dist: dclab[dcor,export,http,s3]>=0.67.4
 Requires-Dist: h5py>=2.8.0
 Requires-Dist: numpy>=1.21
 Requires-Dist: pygments

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.25.0'
-__version_tuple__ = version_tuple = (2, 25, 0)
+__version__ = version = '2.25.2'
+__version_tuple__ = version_tuple = (2, 25, 2)
 
-__commit_id__ = commit_id = 'gd56e9d0fe'
+__commit_id__ = commit_id = 'g7db9e4d5b'

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope/gui/main.py

@@ -28,6 +28,7 @@ from .helpers import connect_pp_mod_signals
 from . import pipeline_plot
 from . import preferences
 from . import quick_view
+from . import settings
 from . import update
 from . import widgets
 
@@ -270,7 +271,7 @@ class DCscope(QtWidgets.QMainWindow):
             fnames, _ = QtWidgets.QFileDialog.getOpenFileNames(
                 parent=self,
                 caption="Select an RT-DC measurement",
-                directory=self.settings.value("paths/add dataset", ""),
+                directory=settings.get_dir("add_dataset", self.settings),
                 filter="RT-DC Files (*.rtdc)")
         else:
             fnames = paths
@@ -290,8 +291,7 @@ class DCscope(QtWidgets.QMainWindow):
                     path = fn
                 else:
                     path = pathlib.Path(fn)
-                    self.settings.setValue("paths/add dataset",
-                                           str(path.parent))
+                    settings.set_dir("add_dataset", path, self.settings)
                 # add a filter if we don't have one already
                 if self.pipeline.num_filters == 0:
                     self.add_filter()
@@ -662,8 +662,12 @@ class DCscope(QtWidgets.QMainWindow):
         """
         if path is None:
             path, _ = QtWidgets.QFileDialog.getOpenFileName(
-                self, 'Select Filter', '', 'Filters formats (*.poly *.sof)')
+                parent=self,
+                caption='Select Filter',
+                directory=settings.get_dir("filters", self.settings),
+                filter='Filters formats (*.poly *.sof)')
         if path:
+            settings.set_dir("filters", path, self.settings)
             with self.pipeline.lock:
                 session.import_filters(path, self.pipeline)
                 self.pp_mod_send.emit(
@@ -677,10 +681,14 @@ class DCscope(QtWidgets.QMainWindow):
                 return
         if path is None:
             path, _ = QtWidgets.QFileDialog.getOpenFileName(
-                self, 'Open session', '', 'DCscope session (*.so2)',
-                'DCscope session (*.so2)',
-                QtWidgets.QFileDialog.Option.DontUseNativeDialog)
+                parent=self,
+                caption='Open session',
+                directory=settings.get_dir("session", self.settings),
+                filter='DCscope session (*.so2)',
+                initialFilter='DCscope session (*.so2)',
+                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog)
         if path:
+            settings.set_dir("session", path, self.settings)
             with self.pipeline.lock:
                 search_paths = []
                 while True:
@@ -724,8 +732,12 @@ class DCscope(QtWidgets.QMainWindow):
     @QtCore.pyqtSlot()
     def on_action_save(self):
         path, _ = QtWidgets.QFileDialog.getSaveFileName(
-            self, 'Save session', '', 'DCscope session (*.so2)')
+            parent=self,
+            caption='Save session',
+            directory=settings.get_dir("session", self.settings),
+            filter='DCscope session (*.so2)')
         if path:
+            settings.set_dir("session", path, self.settings)
             if not path.endswith(".so2"):
                 path += ".so2"
             session.save_session(path, self.pipeline)

dcscope-2.25.2/dcscope/gui/settings.py

@@ -0,0 +1,41 @@
+import pathlib
+from PyQt6 import QtCore
+
+
+def get_dir(topic: str,
+            settings: QtCore.QSettings
+            ) -> str:
+    """Given a QSettings instance, return a directory
+
+    If writable is `True`, return a writable directory
+    """
+    location = settings.value(f"paths/{topic}", "")
+
+    if not location:
+        # use default value
+        location = QtCore.QStandardPaths.standardLocations(
+            QtCore.QStandardPaths.StandardLocation.HomeLocation)[0]
+    else:
+        # check whether the location exists
+        path = pathlib.Path(location)
+        if not path.is_dir():
+            for pp in path.parents:
+                if pp.is_dir():
+                    location = str(pp)
+                    break
+            else:
+                location = "."
+
+    return location or "."
+
+
+def set_dir(topic: str,
+            path: pathlib.Path | str,
+            settings: QtCore.QSettings,
+            ):
+    """Given a QSettings instance, save a directory topic"""
+    path = pathlib.Path(path)
+    if path.exists():
+        if not path.is_dir():
+            path = path.parent
+        settings.setValue(f"paths/{topic}", str(path))

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope/pipeline/core.py

@@ -464,8 +464,9 @@ class Pipeline(object):
             filters = self.get_filters_for_slot(slot_id=slot_id,
                                                 max_filter_index=filt_index)
             # filter ray magic
-            ray = self.get_ray(slot.identifier)
-            ds = ray.get_dataset(filters, apply_filter=apply_filter)
+            ray = self.get_ray(slot_id)
+            ray.set_filters(filters)
+            ds = ray.get_dataset(apply_filter=apply_filter)
         return ds
 
     def get_datasets(self, filt_index=-1, apply_filter=True):

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope/pipeline/filter_ray.py

@@ -12,29 +12,28 @@ class FilterRay(object):
         self.identifier = slot.identifier
         #: slot defining the ray
         self.slot = slot
-        #: list of RTDCBase (hierarchy children)
-        self.steps = []
-        #: corresponds to hashes of the applied filters
-        self.step_hashes = []
+        #: segments of the filter ray, consisting of hash, previous, and
+        #: next dataset
+        self.segments = []
         # holds the filters (protected so that users use set_filters)
         self._filters = []
         # used for testing (incremented when the ray is cut)
         self._generation = 0
         # used for checking validity of the ray
         self._slot_hash = "unset"
-        self._root_child = None
 
     def __repr__(self):
         repre = "<Pipeline Filter Ray '{}' at {}>".format(self.identifier,
                                                           hex(id(self)))
         return repre
 
-    def _add_step(self, ds, filt):
-        """Add a filter step"""
-        self.step_hashes.append(filt.hash)
+    def _add_segment(self, ds, filt):
+        """Add a filter segment"""
+        ds.reset_filter()
         filt.update_dataset(ds)
-        self.steps.append(ds)
-        return self._new_child(ds, filt)
+        child = self._new_child(ds, filt)
+        self.segments.append([filt.hash, ds, child])
+        return child
 
     def _new_child(self, ds, filt=None, apply_filter=False):
         identifier = self.slot.identifier
@@ -58,21 +57,7 @@ class FilterRay(object):
         """
         return self._filters
 
-    @property
-    def root_child(self):
-        """This is the first element in self.steps
-        (Will return a dataset even if self.steps is empty)
-        """
-        if self._slot_hash != self.slot.hash:
-            # reset everything (e.g. emodulus recipe might have changed)
-            self.steps = []
-            self.step_hashes = []
-            self._root_child = self._new_child(self.slot.get_dataset(),
-                                               apply_filter=True)
-            self._slot_hash = self.slot.hash
-        return self._root_child
-
-    def get_final_child(self, rtdc_ds=None, apply_filter=True):
+    def get_final_child(self, rtdc_ds=None, filters=None, apply_filter=True):
         """Return the final ray child of `rtdc_ds`
 
         If `rtdc_ds` is None, then the dataset of the current
@@ -86,19 +71,27 @@ class FilterRay(object):
         is applied to other data on disk e.g. when computing
         statistics. For regular use of the filter ray in a
         pipeline, use :func:`get_dataset`.
+
+        .. versionchanged:: 2.25.1
+          The dataset returned is a clean child dataset without any
+          filters defined.
+
         """
-        filters = self.filters
+        if filters is None:
+            filters = self.filters
+            external_filt = False
+        else:
+            external_filt = True
 
         if rtdc_ds is None:
             # normal case
-            external = False
-            rtdc_ds = self.slot.get_dataset()
-            ds = self.root_child
+            external_ds = False
+            ds = self.slot.get_dataset()
         else:
             # ray is applied to other data
-            external = True
-            # do not modify rtdc_ds (create a child to work with)
-            ds = self._new_child(rtdc_ds, apply_filter=True)
+            external_ds = True
+            # do not modify the original dataset (create a child to work with)
+            ds = self._new_child(rtdc_ds)
 
         # Dear future self,
         #
@@ -107,48 +100,46 @@ class FilterRay(object):
         # Sincerely,
         # past self
 
+        filters = [f for f in filters if f.filter_used]
+
         if filters:
             # apply all filters
             for ii, filt in enumerate(filters):
                 # remember the previous hierarchy parent
                 # (ds is always used for the next iteration)
-                prev_ds = ds
-                if external:
-                    # do not touch self.steps or self.step_hashes
+                if external_ds or external_filt:
+                    # do not touch self.segments
                     filt.update_dataset(ds)
                     ds = self._new_child(ds, filt)
-                elif len(self.steps) < ii+1:
-                    # just create a new step
-                    ds = self._add_step(ds, filt)
-                elif filt.hash != self.step_hashes[ii]:
+                elif len(self.segments) < ii + 1:
+                    # just create a new segment
+                    ds = self._add_segment(ds, filt)
+                elif filt.hash != self.segments[ii][0]:
                     # the filter ray is changing here;
-                    # cut it and add a new step
-                    self.steps = self.steps[:ii]
-                    self.step_hashes = self.step_hashes[:ii]
-                    ds = self._add_step(ds, filt)
+                    # trim it and add a new segment
+                    self.segments = self.segments[:ii]
+                    ds = self._add_segment(ds, filt)
                     self._generation += 1  # for testing
                 else:
-                    # the filters match so far
-                    if len(self.steps) > ii + 1:  # next child exists
-                        ds = self.steps[ii + 1]
-                    else:  # next child does not exist
-                        ds = self._new_child(ds, filt)
-            # we now have the entire filter pipeline in self.steps
-            final_ds = prev_ds
+                    # reuse previous segment
+                    ds = self.segments[ii][2]
+            final_ds = ds
         else:
-            final_ds = rtdc_ds
+            final_ds = ds
+
+        if not external_ds:
+            ds.reset_filter()
+
         if apply_filter:
             final_ds.apply_filter()
+
         return final_ds
 
-    def get_dataset(self, filters=None, apply_filter=True):
+    def get_dataset(self, apply_filter=True):
         """Return the dataset that corresponds to applying these filters
 
         Parameters
         ----------
-        filters: list of Filter or None
-            Filters used for computing the dataset hierarchy. If set
-            to None, the current filters in `self.filters` are used.
         apply_filter: bool
             Whether to apply all filters and update the metadata of
             the requested dataset. This should be True if you are
@@ -157,9 +148,6 @@ class FilterRay(object):
             apply some more filters and then call `rejuvenate`
             yourself.
         """
-        if filters is not None:
-            # put the filters in place
-            self.set_filters(filters)
         # compute the final hierarchy child
         ds = self.get_final_child(apply_filter=apply_filter)
         return ds
@@ -167,4 +155,4 @@ class FilterRay(object):
     def set_filters(self, filters):
         """Set the filters of the current ray"""
         # only take into account active filters
-        self._filters = [f for f in filters if f.filter_used]
+        self._filters = filters

{dcscope-2.25.0 → dcscope-2.25.2/dcscope.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcscope
-Version: 2.25.0
+Version: 2.25.2
 Summary: User interface for deformability cytometry (DC)
 Author: Benedikt Hartmann, Eoghan O'Connell, Maximilian Schlögel, Paul Müller, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>
@@ -16,7 +16,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: dclab[dcor,export,http,s3]>=0.67.3
+Requires-Dist: dclab[dcor,export,http,s3]>=0.67.4
 Requires-Dist: h5py>=2.8.0
 Requires-Dist: numpy>=1.21
 Requires-Dist: pygments

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ dcscope/gui/pipeline_plot.py
 dcscope/gui/pipeline_plot.ui
 dcscope/gui/preferences.py
 dcscope/gui/preferences.ui
+dcscope/gui/settings.py
 dcscope/gui/update.py
 dcscope/gui/analysis/__init__.py
 dcscope/gui/analysis/ana_basins.py

{dcscope-2.25.0 → dcscope-2.25.2}/dcscope.egg-info/requires.txt

@@ -1,4 +1,4 @@
-dclab[dcor,export,http,s3]>=0.67.3
+dclab[dcor,export,http,s3]>=0.67.4
 h5py>=2.8.0
 numpy>=1.21
 pygments

{dcscope-2.25.0 → dcscope-2.25.2}/pyproject.toml

@@ -30,7 +30,7 @@ classifiers = [
 ]
 license = "GPL-3.0-or-later"
 dependencies = [
-    "dclab[dcor,export,http,s3]>=0.67.3",
+    "dclab[dcor,export,http,s3]>=0.67.4",
     "h5py>=2.8.0",
     "numpy>=1.21",  # CVE-2021-33430
     "pygments",

{dcscope-2.25.0 → dcscope-2.25.2}/tests/test_gui_filter.py

@@ -101,6 +101,104 @@ def test_box_filter_selection_no_preselection_issue_67(qtbot):
     qtbot.mouseClick(wf.toolButton_moreless, QtCore.Qt.MouseButton.LeftButton)
 
 
+def test_filter_min_max_delete(qtbot):
+    """Create a box filter, apply it, and delete it again"""
+    path = make_fake_dataset()
+
+    mw = DCscope()
+    qtbot.addWidget(mw)
+
+    # add the file
+    mw.add_dataslot(paths=[path, path])
+
+    assert len(mw.pipeline.slot_ids) == 2, "we added that"
+    assert len(mw.pipeline.filter_ids) == 1, "automatically added"
+    # sanity check
+    ds10 = dclab.new_dataset(mw.pipeline.get_dataset(0))
+    ds20 = dclab.new_dataset(mw.pipeline.get_dataset(0))
+    assert np.max(ds10["area_um"]) > 20
+    assert np.max(ds20["area_um"]) > 20
+
+    # open the filter edit in the Analysis View
+    fe = mw.block_matrix.get_widget(filt_plot_id=mw.pipeline.filter_ids[0])
+    qtbot.mouseClick(fe.toolButton_modify, QtCore.Qt.MouseButton.LeftButton)
+
+    # box filtering
+    wf = mw.widget_ana_view.widget_filter
+    mw.widget_ana_view.tabWidget.setCurrentWidget(
+        mw.widget_ana_view.tab_filter)
+
+    # enable selection
+    qtbot.mouseClick(wf.toolButton_moreless, QtCore.Qt.MouseButton.LeftButton)
+    # find the porosity item and click the checkbox
+    rc = wf._box_range_controls["area_um"]
+    qtbot.mouseClick(rc.checkBox, QtCore.Qt.MouseButton.LeftButton)
+    # disable selection
+    qtbot.mouseClick(wf.toolButton_moreless, QtCore.Qt.MouseButton.LeftButton)
+
+    # set the range control for area from 20 to 30 µm
+    rc.doubleSpinBox_min.setValue(20)
+    rc.doubleSpinBox_max.setValue(30)
+
+    # click apply
+    qtbot.mouseClick(wf.pushButton_apply, QtCore.Qt.MouseButton.LeftButton)
+
+    # make sure this worked
+    assert rc.read_pipeline_state()["end"] == 30
+    box_filters = mw.pipeline.filters[0].__getstate__()["box filters"]
+    assert box_filters["area_um"]["end"] == 30
+    assert box_filters["area_um"]["active"] is True
+
+    # activate the filter for both datasets
+    me1 = mw.block_matrix.get_widget(filt_plot_id=mw.pipeline.filter_ids[0],
+                                     slot_id=mw.pipeline.slot_ids[0]
+                                     )
+    qtbot.mouseClick(me1, QtCore.Qt.MouseButton.LeftButton)
+    me2 = mw.block_matrix.get_widget(filt_plot_id=mw.pipeline.filter_ids[0],
+                                     slot_id=mw.pipeline.slot_ids[1]
+                                     )
+    qtbot.mouseClick(me2, QtCore.Qt.MouseButton.LeftButton)
+
+    QtWidgets.QApplication.processEvents(
+        QEventLoop.ProcessEventsFlag.AllEvents, 500)
+
+    assert len(mw.pipeline.get_filters_for_slot(mw.pipeline.slot_ids[0])) == 1
+    assert len(mw.pipeline.get_filters_for_slot(mw.pipeline.slot_ids[1])) == 1
+
+    # get the datasets from the pipeline and check that they are filtered
+    ds1a = dclab.new_dataset(mw.pipeline.get_dataset(0))
+    ds2a = dclab.new_dataset(mw.pipeline.get_dataset(1))
+
+    # This is expected
+    assert np.max(ds1a["area_um"]) < 30
+    assert np.max(ds2a["area_um"]) < 30
+
+    # Now, remove the box filter!
+    qtbot.mouseClick(wf.toolButton_moreless, QtCore.Qt.MouseButton.LeftButton)
+    # find the porosity item and click the checkbox
+    rc = wf._box_range_controls["area_um"]
+    qtbot.mouseClick(rc.checkBox, QtCore.Qt.MouseButton.LeftButton)
+    # disable selection
+    qtbot.mouseClick(wf.toolButton_moreless, QtCore.Qt.MouseButton.LeftButton)
+
+    # click apply
+    qtbot.mouseClick(wf.pushButton_apply, QtCore.Qt.MouseButton.LeftButton)
+    QtWidgets.QApplication.processEvents(
+        QEventLoop.ProcessEventsFlag.AllEvents, 500)
+
+    # make sure this worked
+    box_filters = mw.pipeline.filters[0].__getstate__()["box filters"]
+    assert "area_um" not in box_filters
+
+    # get the datasets from the pipeline and check that they are filtered
+    ds1b = dclab.new_dataset(mw.pipeline.get_dataset(0))
+    ds2b = dclab.new_dataset(mw.pipeline.get_dataset(1))
+
+    # This was the bug. The filters were not removed correctly.
+    assert np.max(ds1b["area_um"]) > 30
+    assert np.max(ds2b["area_um"]) > 30
+
+
 def test_filter_min_max_inf(qtbot):
     path = make_fake_dataset()
 
@@ -199,7 +297,7 @@ def test_polygon_filter_basic(qtbot):
     ds = mw.pipeline.get_dataset(0)
     assert ds_slot is not ds
     assert np.sum(ds.filter.all) == 5
-    assert len(ds) == 47
+    assert len(ds) == 5
 
 
 def test_polygon_filter_delete(qtbot):

{dcscope-2.25.0 → dcscope-2.25.2}/tests/test_pipeline_filter_ray.py

@@ -18,9 +18,11 @@ def test_get_heredity():
     filt1.boxdict["area_um"] = {"start": np.min(ds["area_um"]),
                                 "end": np.mean(ds["area_um"]),
                                 "active": True}
+
     # this one does nothing (and should be ignored)
-    filt2 = pipeline.Filter()
-    filt2.filter_used = False
+    fign2 = pipeline.Filter()
+    fign2.filter_used = False
+
     # another one with simple things
     filt3 = pipeline.Filter()
     filt3.boxdict["deform"] = {"start": np.min(ds["deform"]),
@@ -28,38 +30,46 @@ def test_get_heredity():
                                "active": True}
 
     # simple
-    ds1 = ray.get_dataset(filters=[filt1, filt2], apply_filter=True)
+    ray.set_filters([filt1, fign2])
+    ds1 = ray.get_dataset()
     assert ray._generation == 0
 
     # leaving out a filter that does nothing will not change anything
-    ds2 = ray.get_dataset(filters=[filt1], apply_filter=True)
+    ray.set_filters([filt1])
+    ds2 = ray.get_dataset()
     assert ray._generation == 0
     assert ds1 is ds2
 
     # changing the order will not change anything either
-    ds3 = ray.get_dataset(filters=[filt2, filt1], apply_filter=True)
+    ray.set_filters([fign2, filt1])
+    ds3 = ray.get_dataset()
     assert ray._generation == 0
     assert ds1 is ds3
 
     # adding a new filter will change the dataset
-    ds4 = ray.get_dataset(filters=[filt1, filt2, filt3], apply_filter=True)
+    ray.set_filters([filt1, fign2, filt3])
+    ds4 = ray.get_dataset()
     assert ray._generation == 0
     assert ds1 is not ds4
+
     assert ds1 is ds4.hparent
 
     # going back does not increment the generation...
-    ds5 = ray.get_dataset(filters=[filt1, filt2], apply_filter=True)
+    ray.set_filters([filt1, fign2])
+    ds5 = ray.get_dataset()
     assert ray._generation == 0
     assert ds1 is ds5
 
     # ...but changing the order is
-    ds5 = ray.get_dataset(filters=[filt3, filt1, filt2], apply_filter=True)
+    ray.set_filters([filt3, filt1, fign2])
+    ds5 = ray.get_dataset()
     assert ray._generation == 1
     assert ds1 is not ds5
     assert ds3 is not ds5
 
     # and then again, when we remove a filter, we get something different
-    ds6 = ray.get_dataset(filters=[filt3, filt1], apply_filter=True)
+    ray.set_filters([filt3, filt1])
+    ds6 = ray.get_dataset()
     assert ray._generation == 1
     assert ds1 is not ds6
     assert ds5 is ds6  # b/c filt2 does nothing
@@ -71,6 +81,7 @@ def test_filtering():
     # initialize
     slot = pipeline.Dataslot(path)
     ds = slot.get_dataset()
+    assert len(ds) == 47
     ray = pipeline.FilterRay(slot)
 
     # come up with a few filters
@@ -79,30 +90,60 @@ def test_filtering():
     filt1.boxdict["area_um"] = {"start": np.min(ds["area_um"]),
                                 "end": np.mean(ds["area_um"]),
                                 "active": True}
+
     # this one does nothing (and should be ignored)
-    filt2 = pipeline.Filter()
-    filt2.filter_used = False
+    fign2 = pipeline.Filter()
+    fign2.filter_used = False
+
     # another one with simple things
     filt3 = pipeline.Filter()
     filt3.boxdict["deform"] = {"start": np.min(ds["deform"]),
                                "end": np.mean(ds["deform"]),
                                "active": True}
 
-    ds2 = ray.get_dataset(filters=[filt2, filt1], apply_filter=True)
-    assert len(ds2) == 47
-    ds3 = ray.get_dataset(filters=[filt1, filt3], apply_filter=True)
-    assert len(ds3) == 22
+    ray.set_filters([fign2])
+    ds1 = ray.get_dataset()
+    assert len(ds1) == 47, "filter two, nothing happens"
+    assert np.sum(ds1.filter.all) == len(ds)
+
+    ray.set_filters([fign2, filt1])
+    ds2 = ray.get_dataset()
+    assert len(ds2) == 22, "filter two applied first, no events removed"
     assert np.sum(ds2.filter.all) == 22
+
+    ray.set_filters([filt1, filt3])
+    ds3 = ray.get_dataset()
+    assert len(ds3) == 12, "filter one applied first"
     assert np.sum(ds3.filter.all) == 12
-    ds1 = ray.get_dataset(filters=[filt2], apply_filter=True)
-    assert np.sum(ds1.filter.all) == len(ds)
-    ds4 = ray.get_dataset(filters=[filt1, filt2], apply_filter=True)
-    assert len(ds4) == 47
+
+    ray.set_filters([filt1, fign2])
+    ds4 = ray.get_dataset()
+    assert len(ds4) == 22, "filter one applied first, filter two ignored"
+    assert np.sum(ds4.filter.all) == 22
 
 
-if __name__ == "__main__":
-    # Run all tests
-    loc = locals()
-    for key in list(loc.keys()):
-        if key.startswith("test_") and hasattr(loc[key], "__call__"):
-            loc[key]()
+def test_remove_filter():
+    path = pathlib.Path(__file__).parent / "data" / "calibration_beads_47.rtdc"
+
+    # initialize
+    slot = pipeline.Dataslot(path)
+    ds = slot.get_dataset()
+    assert len(ds) == 47
+    ray = pipeline.FilterRay(slot)
+
+    # come up with a few filters
+    # this does some simple things
+    filt1 = pipeline.Filter()
+    filt1.boxdict["area_um"] = {"start": np.min(ds["area_um"]),
+                                "end": np.mean(ds["area_um"]),
+                                "active": True}
+
+    ray.set_filters([filt1])
+    ds1 = ray.get_dataset()
+    assert len(ds1) == 22
+    assert np.sum(ds1.filter.all) == 22
+
+    ray.set_filters([])
+    ds2 = ray.get_dataset()
+    assert len(ds2) == 47
+    assert np.sum(ds2.filter.all) == 47