napari-tapenade-processing 0.0.1__py3-none-any.whl

napari_tapenade_processing/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.0.1"
+from ._widget import TapenadeProcessingWidget
+
+__all__ = (
+    "TapenadeProcessingWidget",
+    
+)

napari_tapenade_processing/_custom_widgets.py

@@ -0,0 +1,99 @@
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QSizePolicy,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class MultiLineTabWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+
+    def initUI(self):
+        self.layout = QVBoxLayout()
+        self.tabBarLayout = QVBoxLayout()
+
+        self.scrollArea = QScrollArea()
+        self.scrollArea.setWidgetResizable(True)
+        self.tabContainer = QWidget()
+        self.tabContainer.setLayout(self.tabBarLayout)
+        self.scrollArea.setWidget(self.tabContainer)
+
+        self.layout.addWidget(self.scrollArea)
+
+        self.stackedWidget = QStackedWidget()
+        self.layout.addWidget(self.stackedWidget)
+
+        self.setLayout(self.layout)
+
+        self.tabs = []
+
+    def addTab(self, widget, title):
+        tabButton = QPushButton(title)
+        tabButton.setCheckable(True)
+        tabButton.clicked.connect(lambda: self.onTabClicked(tabButton))
+
+        tabRowLayout = None
+        if len(self.tabs) % 3 == 0:
+            tabRowLayout = QHBoxLayout()
+            self.tabBarLayout.addLayout(tabRowLayout)
+        else:
+            tabRowLayout = self.tabBarLayout.itemAt(
+                self.tabBarLayout.count() - 1
+            ).layout()
+
+        tabRowLayout.addWidget(tabButton)
+        self.tabs.append(tabButton)
+
+        self.stackedWidget.addWidget(widget)
+
+    def onTabClicked(self, tabButton):
+        for i, btn in enumerate(self.tabs):
+            if btn == tabButton:
+                self.stackedWidget.setCurrentIndex(i)
+                btn.setChecked(True)
+            else:
+                btn.setChecked(False)
+
+
+class RichTextPushButton(QPushButton):
+    def __init__(self, parent=None, text=None):
+        if parent is not None:
+            super().__init__(parent)
+        else:
+            super().__init__()
+        self.__lbl = QLabel(self)
+        if text is not None:
+            self.__lbl.setText(text)
+        self.__lyt = QHBoxLayout()
+        self.__lyt.setContentsMargins(0, 0, 0, 0)
+        self.__lyt.setSpacing(0)
+        self.setLayout(self.__lyt)
+        self.__lbl.setAttribute(Qt.WA_TranslucentBackground)
+        self.__lbl.setAttribute(Qt.WA_TransparentForMouseEvents)
+        self.__lbl.setSizePolicy(
+            QSizePolicy.Expanding,
+            QSizePolicy.Expanding,
+        )
+        self.__lbl.setTextFormat(Qt.RichText)
+        self.__lyt.addWidget(self.__lbl)
+        return
+
+    def setText(self, text):
+        self.__lbl.setText(text)
+        self.updateGeometry()
+        return
+
+    def sizeHint(self):
+        s = QPushButton.sizeHint(self)
+        w = self.__lbl.sizeHint()
+        s.setWidth(w.width())
+        s.setHeight(w.height())
+        return s

napari_tapenade_processing/_macro_recorder.py

@@ -0,0 +1,99 @@
+import json
+import os
+from collections import OrderedDict
+from datetime import datetime
+
+
+class MacroRecorder:
+    def __init__(self, adjective_dict):
+        self._is_recording_parameters = False
+        self._record_parameters_list = []
+
+        # key: napari name, value: standardized name
+        self._record_data_dict = {
+            "mask": {},
+            "image": {},
+            "labels": {},
+            "tracks": {},
+        }
+
+        self._adjective_dict = adjective_dict
+
+    def _reset_recording(self):
+        for k in self._record_data_dict.keys():
+            self._record_data_dict[k] = {}
+        self._record_parameters_list = []
+
+    def dump_recorded_parameters(self, path: str):
+        date = (
+            str(datetime.now())
+            .split(".")[:-1][0]
+            .replace(" ", "_")
+            .replace(":", "-")
+        )
+        filename = f"recorded_parameters_{date}.json"
+
+        with open(os.path.join(path, filename), "w") as f:
+            json.dump(self._record_parameters_list, f)
+
+        self._reset_recording()
+
+    def record(
+        self,
+        function_name: str,
+        layers_names_in: dict,
+        layers_names_out: dict,
+        func_params: dict,
+        overwrite: bool,
+    ):
+        """
+        layer_names are dicts that map layer_type (e.g 'mask', 'image'...) to
+        the names of the layers in the viewer
+        """
+
+        dict_in = dict()
+        dict_out = OrderedDict()
+
+        for layer_type in ["mask", "image", "labels", "tracks"]:
+            # building dict_in
+            layer_in = None
+            if layer_type in layers_names_in:
+                layer_name_in = layers_names_in[layer_type]
+
+                if layer_name_in is not None:
+                    layer_in = self._record_data_dict[layer_type].get(
+                        layer_name_in, layer_type
+                    )
+
+                dict_in[layer_type] = layer_in
+            # building dict_out
+            if layer_type in layers_names_out:
+                layer_name_out = layers_names_out[layer_type]
+
+                if layer_name_out is not None:
+                    if overwrite and layer_in is not None:
+                        layer_out = layer_in
+                    elif layer_in is not None:
+                        adjective = self._adjective_dict[function_name]
+                        layer_out = f"{layer_in}_{adjective}"
+                        self._record_data_dict[layer_type][
+                            layer_name_out
+                        ] = layer_out
+                    else:
+                        layer_out = layer_type
+                        self._record_data_dict[layer_type][
+                            layer_name_out
+                        ] = layer_out
+                else:
+                    layer_out = None
+
+                dict_out[layer_type] = layer_out
+
+        params = {
+            "function": function_name,
+            "in": dict_in,
+            "out": dict_out,
+            "func_params": func_params,
+        }
+
+        self._record_parameters_list.append(params)