dcscope 2.22.1__py3-none-any.whl

dcscope/__init__.py

@@ -0,0 +1,17 @@
+"""GUI for analysis and visualization of deformability cytometry datasets
+Copyright (C) 2019 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 3 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, see <https://www.gnu.org/licenses/>.
+"""
+from ._version import version as __version__  # noqa: F401

dcscope/__main__.py

@@ -0,0 +1,44 @@
+def main(splash=True):
+    import importlib.resources
+    import sys
+
+    from PyQt6.QtWidgets import QApplication
+    from PyQt6.QtCore import QEventLoop
+    # import before creating application
+    import pyqtgraph  # noqa: F401
+
+    app = QApplication(sys.argv)
+
+    if splash:
+        from PyQt6.QtWidgets import QSplashScreen
+        from PyQt6.QtGui import QPixmap
+        ref = importlib.resources.files("dcscope.img") / "splash.png"
+        with importlib.resources.as_file(ref) as splash_path:
+            splash_pix = QPixmap(str(splash_path))
+        splash = QSplashScreen(splash_pix)
+        splash.setMask(splash_pix.mask())
+        splash.show()
+        # make sure Qt really displays the splash screen
+        app.processEvents(QEventLoop.ProcessEventsFlag.AllEvents, 300)
+
+    from PyQt6 import QtCore, QtGui
+    from .gui import DCscope
+
+    # Set Application Icon
+    ref = importlib.resources.files("dcscope.img") / "icon.png"
+    with importlib.resources.as_file(ref) as icon_path:
+        app.setWindowIcon(QtGui.QIcon(str(icon_path)))
+
+    # Use dots as decimal separators
+    QtCore.QLocale.setDefault(QtCore.QLocale(QtCore.QLocale.Language.C))
+
+    window = DCscope(*app.arguments()[1:])
+
+    if splash:
+        splash.finish(window)
+
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

dcscope/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '2.22.1'
+__version_tuple__ = version_tuple = (2, 22, 1)

dcscope/extensions.py

@@ -0,0 +1,250 @@
+import collections
+import functools
+import pathlib
+import shutil
+
+from dclab.util import hashfile
+from dclab.rtdc_dataset.feat_anc_plugin import plugin_feature
+
+
+SUPPORTED_FORMATS = [
+    ".py",
+]
+
+
+class ExtensionManager:
+    def __init__(self, store_path):
+        """Extension manager
+
+        This class can be used to maintain a set of extensions
+        (plugin features or machine-learning features) at a
+        specific location `store_path` on the file system.
+
+        All extensions are loaded during instantiation. It is
+        possible to disable individual extensions (without
+        deleting them) on-the-fly.
+        """
+        self.store_path = pathlib.Path(store_path)
+        self.store_path.mkdir(exist_ok=True, parents=True)
+        self.extension_hash_dict = collections.OrderedDict()
+        self.load_extensions_from_store()
+
+    def __contains__(self, key):
+        if isinstance(key, Extension):
+            key = key.hash
+        return key in self.extension_hash_dict
+
+    def __getitem__(self, key):
+        return self.get_extension_or_bust(key)
+
+    def __iter__(self):
+        for ahash in self.extension_hash_dict:
+            yield self.extension_hash_dict[ahash]
+
+    def __len__(self):
+        return len(self.extension_hash_dict)
+
+    def get_extension_or_bust(self, ext):
+        """Return an Extension instance or raise ValueError
+
+        Parameter `ext` can be an instance of Extension, an
+        extension hash, or an index. If an Extension or a
+        hash is provided, this function checks whether the
+        extension is maintained by this manager and returns
+        the correct instance.
+
+        Parameters
+        ----------
+        ext: Extension
+            Extension instance
+        """
+        if isinstance(ext, Extension):
+            the_hash = ext.hash
+        elif isinstance(ext, int):
+            the_hash = list(self.extension_hash_dict.keys())[ext]
+        else:
+            the_hash = ext
+        if the_hash in self.extension_hash_dict:
+            return self.extension_hash_dict[the_hash]
+        else:
+            raise ValueError(f"Extension not in {self.store_path}: {the_hash}")
+
+    def import_extension_from_path(self, path):
+        """Import an extension file to `self.store_path`"""
+        ext = Extension(path)
+        if ext.hash not in self.extension_hash_dict:
+            new_name = f"ext_{ext.type}_{ext.hash}{ext.suffix}"
+            new_path = self.store_path / new_name
+            shutil.copy2(path, new_path)
+            ext.path = new_path
+            self.extension_load(ext)
+        return ext
+
+    def load_extensions_from_store(self):
+        """Load all extensions from `self.store_path`
+
+        This function is called during initialization.
+        """
+        failed = []
+        # load all (enabled) extensions
+        for pp in self.store_path.glob("ext_*"):
+            if pp.suffix in SUPPORTED_FORMATS:
+                ext = Extension(pp)
+                try:
+                    self.extension_load(ext)
+                except BaseException:
+                    failed.append(ext)
+        if failed:
+            raise ValueError(f"Could not load these extensions: {failed}")
+
+    def extension_load(self, ext):
+        """Load a single extension
+
+        Parameters
+        ----------
+        ext: Extension
+            Extension instance
+        """
+        # add to hash dict first in case it gets disabled
+        self.extension_hash_dict[ext.hash] = ext
+        ext.load()
+
+    def extension_remove(self, ext):
+        """Remove an extension from `self.store_path` and unload it
+
+        Parameters
+        ----------
+        ext: Extension or str or int
+            Extension instance, its hash or its index in
+            ExtensionManager
+        """
+        ext = self.get_extension_or_bust(ext)
+        self.extension_hash_dict.pop(ext.hash)
+        # re-instantiate ext to get the path right
+        ext.destroy()
+
+    def extension_set_enabled(self, ext, enabled):
+        """Enable or disable an extension
+
+        Parameters
+        ----------
+        ext: Extension or str or int
+            Extension instance, its hash or its index in
+            ExtensionManager
+        enabled: bool
+            Whether to enable the extension.
+        """
+        ext = self.get_extension_or_bust(ext)
+        ext.set_enabled(enabled)
+
+
+class Extension:
+    def __init__(self, path):
+        """Helper class for managing individual extensions"""
+        self.path = pathlib.Path(path)
+        self.suffix = self.path.suffix
+
+    def __repr__(self):
+        return f"<DCscope Extension {self.path} at {hex(id(self))}>"
+
+    @property
+    def description(self):
+        """Description of the extension"""
+        description = "No description provided."
+        if self.loaded:
+            if self.type == "feat_anc_plugin":
+                pfinst = self.get_plugin_feature_instances()[0]
+                info = pfinst.plugin_feature_info
+                description = info['long description']
+        return description
+
+    @property
+    def enabled(self):
+        """Whether the extension is enabled"""
+        return not self.path_lock_disabled.exists()
+
+    @property
+    @functools.lru_cache()
+    def hash(self):
+        """MD5 hash of the extension"""
+        return hashfile(self.path)
+
+    @property
+    def loaded(self):
+        """Whether the extension is currently loaded"""
+        if self.type == "feat_anc_plugin":
+            return bool(self.get_plugin_feature_instances())
+
+    @property
+    def path_lock_disabled(self):
+        return self.path.with_name(self.path.name + "_disabled")
+
+    @property
+    def title(self):
+        """Descriptive title including version of the extension"""
+        title = self.path.name  # fallback
+        if self.loaded:
+            if self.type == "feat_anc_plugin":
+                pfinst = self.get_plugin_feature_instances()[0]
+                info = pfinst.plugin_feature_info
+                title = f"{info['description']} " \
+                    + f"({info['version']}-{info['identifier'][:4]})"
+        return title
+
+    @property
+    @functools.lru_cache()
+    def type(self):
+        """Type of the extension (e.g. "feat_anc_plugin")"""
+        if self.path.suffix == ".py":
+            return "feat_anc_plugin"
+        else:
+            raise ValueError(f"Cannot determine extension type: {self.path}!")
+
+    def get_plugin_feature_instances(self):
+        """Return a list of all PlugInFeature instances for this extension"""
+        pf_instances = []
+        for inst in plugin_feature.PlugInFeature.features:
+            if (isinstance(inst, plugin_feature.PlugInFeature)
+                    and self.path.samefile(inst.plugin_path)):
+                pf_instances.append(inst)
+        return pf_instances
+
+    def set_enabled(self, enabled):
+        """Set this extension to enabled (True) or disabled (False)
+
+        The extension is also loaded (True) or unloaded (False).
+        """
+        if enabled:
+            # set enabled so that `load` works
+            self.path_lock_disabled.unlink(missing_ok=True)
+            self.load()
+        else:
+            self.unload()
+            self.path_lock_disabled.touch()
+
+    def load(self):
+        """Load the extension if it is enabled and not loaded"""
+        if not self.enabled or self.loaded:
+            # do not load disabled extensions or extensions already loaded
+            return
+
+        try:
+            if self.type == "feat_anc_plugin":
+                plugin_feature.load_plugin_feature(self.path)
+        except BaseException:
+            # If loading the extension fails, disable it and only then
+            # raise the exception.
+            self.set_enabled(False)
+            raise
+
+    def unload(self):
+        """Unload the extension"""
+        if self.type == "feat_anc_plugin":
+            for inst in self.get_plugin_feature_instances():
+                plugin_feature.remove_plugin_feature(inst)
+
+    def destroy(self):
+        """Unload and remove the extension"""
+        self.unload()
+        self.path_lock_disabled.unlink(missing_ok=True)
+        self.path.unlink(missing_ok=True)

dcscope/gui/__init__.py

@@ -0,0 +1,2 @@
+from .main import DCscope  # noqa: F401
+from . import widgets  # noqa: F401

dcscope/gui/analysis/__init__.py

@@ -0,0 +1,10 @@
+# flake8: noqa: F401
+from .dlg_slot_reorder import DlgSlotReorder
+from .ana_basins import BasinsPanel
+from .ana_filter import FilterPanel
+from .ana_log import LogPanel
+from .ana_meta import MetaPanel
+from .ana_plot import PlotPanel
+from .ana_slot import SlotPanel
+from .ana_tables import TablesPanel
+from .ana_view import AnalysisView

dcscope/gui/analysis/ana_basins.py

@@ -0,0 +1,110 @@
+import importlib.resources
+import json
+
+from pygments import highlight, lexers, formatters
+from PyQt6 import uic, QtCore, QtWidgets
+
+
+class BasinsPanel(QtWidgets.QWidget):
+    """Tables panel widget
+
+    Visualizes tables stored in the .rtdc file
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(BasinsPanel, self).__init__(*args, **kwargs)
+        ref = importlib.resources.files(
+            "dcscope.gui.analysis") / "ana_basins.ui"
+        with importlib.resources.as_file(ref) as path_ui:
+            uic.loadUi(path_ui, self)
+        # current DCscope pipeline
+        self._pipeline = None
+        self.data_role = QtCore.Qt.ItemDataRole.UserRole + 2
+        self.treeWidget_basin_name.setColumnCount(1)
+
+        self.listWidget_dataset.currentRowChanged.connect(
+            self.on_select_dataset)
+        self.treeWidget_basin_name.currentItemChanged.connect(
+            self.on_select_basin)
+        self.update_content()
+
+    @property
+    def pipeline(self):
+        return self._pipeline
+
+    def add_basin_nodes(self, parent_widget, ds):
+        for bd in ds.basins_get_dicts():
+            # Get all basins
+            item = QtWidgets.QTreeWidgetItem(parent_widget)
+            item.setText(0, bd["name"])
+            item.setData(0, self.data_role, (ds, bd))
+
+    @QtCore.pyqtSlot(int)
+    def on_select_dataset(self, ds_idx):
+        """Show the tables of the dataset in the right-hand list widget"""
+        self.treeWidget_basin_name.clear()
+        if ds_idx >= 0:
+            ds = self._pipeline.slots[ds_idx].get_dataset()
+            self.add_basin_nodes(parent_widget=self.treeWidget_basin_name,
+                                 ds=ds)
+
+    @QtCore.pyqtSlot(QtWidgets.QTreeWidgetItem, QtWidgets.QTreeWidgetItem)
+    def on_select_basin(self, current, previous=None):
+        """Show the tables of the dataset in the right-hand list widget"""
+        ds_idx = self.listWidget_dataset.currentRow()
+        if current is not None and ds_idx >= 0:
+            # Get the correct basin
+            ds, bd = current.data(0, self.data_role)
+            # try to access that basin in `ds`
+            for bn in ds.basins:
+                if bn.key == bd["key"]:
+                    # We've got a match
+                    loaded = True
+                    available = bn.is_available()
+                    break
+            else:
+                loaded = False
+                available = False
+                bn = None
+
+            # Display the basin information
+            self.label_status.setText(f"{loaded=}, {available=}")
+            self.label_id.setText(f"{bd.get('name')} ({bd['key']})")
+            self.textEdit_def.setText(
+                highlight(json.dumps(bd, sort_keys=True, indent=2),
+                          lexers.JsonLexer(),
+                          formatters.HtmlFormatter(full=True,
+                                                   noclasses=True,
+                                                   nobackground=True))
+            )
+
+            if available and bn is not None and not current.childCount():
+                # Add child tree nodes
+                self.add_basin_nodes(parent_widget=current,
+                                     ds=bn.ds)
+                current.setExpanded(True)
+        else:
+            self.textEdit_def.clear()
+            self.label_status.setText("")
+            self.label_id.setText("")
+
+    def set_pipeline(self, pipeline):
+        self._pipeline = pipeline
+
+    def update_content(self, slot_index=None, **kwargs):
+        if self._pipeline and self._pipeline.slots:
+            self.setEnabled(True)
+            self.setUpdatesEnabled(False)
+            self.listWidget_dataset.clear()
+            self.treeWidget_basin_name.clear()
+            for slot in self._pipeline.slots:
+                self.listWidget_dataset.addItem(slot.name)
+            self.setUpdatesEnabled(True)
+            if slot_index is None or slot_index < 0:
+                slot_index = max(0, self.listWidget_dataset.currentRow())
+            slot_index = min(slot_index, self._pipeline.num_slots - 1)
+            self.listWidget_dataset.setCurrentRow(slot_index)
+        else:
+            self.setEnabled(False)
+            self.listWidget_dataset.clear()
+            self.treeWidget_basin_name.clear()

dcscope/gui/analysis/ana_basins.ui

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>701</width>
+    <height>538</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout" stretch="0,0,1">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,1">
+     <item>
+      <layout class="QVBoxLayout" name="verticalLayout_2">
+       <item>
+        <widget class="QLabel" name="label">
+         <property name="text">
+          <string>Dataset</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QListWidget" name="listWidget_dataset">
+         <property name="minimumSize">
+          <size>
+           <width>200</width>
+           <height>0</height>
+          </size>
+         </property>
+         <property name="showDropIndicator" stdset="0">
+          <bool>false</bool>
+         </property>
+         <property name="alternatingRowColors">
+          <bool>true</bool>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectionBehavior::SelectRows</enum>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </item>
+     <item>
+      <layout class="QVBoxLayout" name="verticalLayout_3">
+       <item>
+        <widget class="QLabel" name="label_2">
+         <property name="text">
+          <string>Basins</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QTreeWidget" name="treeWidget_basin_name">
+         <property name="showDropIndicator" stdset="0">
+          <bool>false</bool>
+         </property>
+         <property name="alternatingRowColors">
+          <bool>true</bool>
+         </property>
+         <property name="autoExpandDelay">
+          <number>0</number>
+         </property>
+         <property name="uniformRowHeights">
+          <bool>true</bool>
+         </property>
+         <property name="headerHidden">
+          <bool>true</bool>
+         </property>
+         <column>
+          <property name="text">
+           <string notr="true">1</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+      </layout>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QFormLayout" name="formLayout">
+     <item row="0" column="0">
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Basin</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QLabel" name="label_id">
+       <property name="text">
+        <string/>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_6">
+       <property name="text">
+        <string>Status</string>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="0">
+      <widget class="QLabel" name="label_5">
+       <property name="text">
+        <string>Definition</string>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="1">
+      <widget class="QTextEdit" name="textEdit_def">
+       <property name="readOnly">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QLabel" name="label_status">
+       <property name="text">
+        <string/>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>