Implement curation_callback and set_external_curation

spikeinterface_gui/backend_panel.py

@@ -418,6 +418,29 @@ def _handle_shortcut(self, event):
                     tabs.stylesheets = []
 
 
+    def set_external_curation(self, curation_data):
+        """Set external curation to controlled and triggers curation and unitlist refresh
+
+        Parameters
+        ----------
+        curation_data : dict
+            The external curation data to be set.
+        """
+        if "curation" not in self.views:
+            return
+
+        curation_view = self.views["curation"]
+        self.controller.set_curation_data(curation_data)
+        self.controller.current_curation_saved = True
+        curation_view.notify_manual_curation_updated()
+        curation_view.refresh()
+
+        # we also need to refresh the unit list view to update the unit visibility according to the new curation
+        if "unitlist" in self.views:
+            unitlist_view = self.views["unitlist"]
+            unitlist_view.update_manual_labels()
+
+
 def get_local_ip():
     """
     Get the local IP address of the machine.

spikeinterface_gui/controller.py

@@ -47,6 +47,8 @@ def __init__(
         skip_extensions=None,
         disable_save_settings_button=False,
         external_data=None,
+        curation_callback=None,
+        curation_callback_kwargs=None,
         user_main_settings=None,
     ):
         self.views = []
@@ -337,6 +339,9 @@ def __init__(
         self.update_time_info()
 
         self.curation = curation
+        self.curation_callback = curation_callback
+        self.curation_callback_kwargs = curation_callback_kwargs
+
         if self.curation:
             # rules:
             #  * if user sends curation_data, then it is used
@@ -843,6 +848,23 @@ def construct_final_curation(self):
         model = CurationModel(**d)
         return model
 
+    def set_curation_data(self, curation_data):
+        print("Setting curation data")
+        new_curation_data = empty_curation_data.copy()
+        new_curation_data.update(curation_data)
+
+        if "unit_ids" not in curation_data:
+            print("Setting unit_ids from controller")
+            new_curation_data["unit_ids"] = self.unit_ids.tolist()
+
+        if "label_definitions" not in curation_data:
+            print("Setting default label definitions")
+            new_curation_data["label_definitions"] = default_label_definitions.copy()
+
+        # validate the curation data
+        model = CurationModel(**new_curation_data)
+        self.curation_data = model.model_dump()
+
     def save_curation_in_analyzer(self):
         if self.analyzer.format == "memory":
             print("Analyzer is an in-memory object. Cannot save curation file in it.")
@@ -865,6 +887,16 @@ def save_curation_in_analyzer(self):
             sigui_group.attrs["curation_data"] = curation_model.model_dump(mode="json")
             self.current_curation_saved = True
 
+    def save_curation_callback(self):
+        curation = self.construct_final_curation()
+        curation_data = curation.model_dump()
+        if self.curation_callback_kwargs is None:
+            curation_callback_kwargs = {}
+        else:
+            curation_callback_kwargs = self.curation_callback_kwargs
+        self.curation_callback(curation_data, **curation_callback_kwargs)
+        self.current_curation_saved = True
+
     def get_split_unit_ids(self):
         if not self.curation:
             return []

spikeinterface_gui/curationview.py

@@ -61,17 +61,19 @@ def select_and_notify_split(self, split_unit_id):
     ## Qt
     def _qt_make_layout(self):
         from .myqt import QT
-        import pyqtgraph as pg
 
         self.merge_info = {}
         self.layout = QT.QVBoxLayout()
 
         tb = self.qt_widget.view_toolbar
-        if self.controller.curation_can_be_saved():
+        if self.controller.curation_callback is not None:
+            but = QT.QPushButton("Save curation")
+            tb.addWidget(but)
+            but.clicked.connect(self.controller.save_curation_callback)
+        elif self.controller.curation_can_be_saved():
             but = QT.QPushButton("Save in analyzer")
             tb.addWidget(but)
-            but.clicked.connect(self.save_in_analyzer)
-
+            but.clicked.connect(self.controller.save_curation_in_analyzer)
         but = QT.QPushButton("Export JSON")
         but.clicked.connect(self._qt_export_json)
         tb.addWidget(but)
@@ -275,9 +277,6 @@ def _qt_on_unit_visibility_changed(self):
     def on_manual_curation_updated(self):
         self.refresh()
 
-    def save_in_analyzer(self):
-        self.controller.save_curation_in_analyzer()
-
     def _qt_export_json(self):
         from .myqt import QT
 
@@ -351,37 +350,47 @@ def _panel_make_layout(self):
         )
 
         # Create buttons
-        buttons_row = []
-        self.save_button = None
-        if self.controller.curation_can_be_saved():
-            self.save_button = pn.widgets.Button(name="Save in analyzer", button_type="primary", height=30)
-            self.save_button.on_click(self._panel_save_in_analyzer)
-            buttons_row.append(self.save_button)
-
-        self.download_button = pn.widgets.FileDownload(
+        if self.controller.curation_callback is not None:
+            save_button_name = "Save curation"
+            save_button_callback = self._panel_save_curation_callback
+        else:
+            save_button_name = "Save in analyzer"
+            save_button_callback = self._panel_save_in_analyzer
+        save_button = pn.widgets.Button(
+            name=save_button_name,
+            button_type="primary",
+            height=30
+        )
+        save_button.on_click(save_button_callback)
+
+        download_button = pn.widgets.FileDownload(
             button_type="primary", filename="curation.json", callback=self._panel_generate_json, height=30
         )
-        buttons_row.append(self.download_button)
 
         restore_button = pn.widgets.Button(name="Restore", button_type="primary", height=30)
         restore_button.on_click(self._panel_restore_units)
 
         remove_merge_button = pn.widgets.Button(name="Unmerge", button_type="primary", height=30)
         remove_merge_button.on_click(self._panel_unmerge)
 
-        remove_split = pn.widgets.Button(name="Unsplit", button_type="primary", height=30)
-        remove_split.on_click(self._panel_unsplit)
+        remove_split_button = pn.widgets.Button(name="Unsplit", button_type="primary", height=30)
+        remove_split_button.on_click(self._panel_unsplit)
 
         # Create layout
-        self.buttons_save = pn.Row(
-            *buttons_row,
+        buttons_save = pn.Row(
+            save_button,
+            download_button,
+            sizing_mode="stretch_width",
+        )
+        save_sections = pn.Column(
+            buttons_save,
             sizing_mode="stretch_width",
         )
 
         buttons_curate = pn.Row(
             restore_button,
             remove_merge_button,
-            remove_split,
+            remove_split_button,
             sizing_mode="stretch_width",
         )
 
@@ -397,7 +406,7 @@ def _panel_make_layout(self):
         # Create main layout with proper sizing
         sections = pn.Row(self.table_delete, self.table_merge, self.table_split, sizing_mode="stretch_width")
         self.layout = pn.Column(
-            self.buttons_save, buttons_curate, sections, shortcuts_component, scroll=True, sizing_mode="stretch_both"
+            save_sections, buttons_curate, sections, shortcuts_component, scroll=True, sizing_mode="stretch_both"
         )
 
     def _panel_refresh(self):
@@ -447,7 +456,7 @@ def _panel_ensure_save_warning_message(self):
         import panel as pn
 
         alert_markdown = pn.pane.Markdown(
-            f"""⚠️⚠️⚠️ Your curation is not saved""",
+            f"""⚠️ Your curation is not saved!""",
             hard_line_break=True,
             styles={"color": "red", "font-size": "16px"},
             name="curation_save_warning",
@@ -490,7 +499,11 @@ def _panel_unsplit(self, event):
         self.unsplit()
 
     def _panel_save_in_analyzer(self, event):
-        self.save_in_analyzer()
+        self.controller.save_curation_in_analyzer()
+        self.refresh()
+
+    def _panel_save_curation_callback(self, event):
+        self.controller.save_curation_callback()
         self.refresh()
 
     def _panel_generate_json(self):
@@ -612,12 +625,12 @@ def _conditional_refresh_split(self):
 revert, and export the curation data.
 
 ### Controls
-- **save in analyzer**: Save the current curation state in the analyzer.
+- **save in analyzer**/**save data**: Save the current curation state in the analyzer. 
+  If a custom save callback is provided, it will be used instead.
 - **export/download JSON**: Export the current curation state to a JSON file.
 - **restore**: Restore the selected unit from the deleted units table.
 - **unmerge**: Unmerge the selected merges from the merged units table.
 - **unsplit**: Unsplit the selected split groups from the split units table.
-- **submit to parent**: Submit the current curation state to the parent window (for use in web applications).
 - **press 'ctrl+r'**: Restore the selected units from the deleted units table.
 - **press 'ctrl+u'**: Unmerge the selected merges from the merged units table.
 - **press 'ctrl+x'**: Unsplit the selected split groups from the split units table.

spikeinterface_gui/main.py

@@ -29,14 +29,16 @@ def run_mainwindow(
     start_app=True,
     layout_preset=None,
     layout=None,
+    external_data=None,
+    curation_callback=None,
+    curation_callback_kwargs=None,
     address="localhost",
     port=0,
     panel_start_server_kwargs=None,
     panel_window_servable=True,
     verbose=False,
     user_settings=None,
     disable_save_settings_button=False,
-    external_data=None,
 ):
     """
     Create the main window and start the QT app loop.
@@ -72,6 +74,15 @@ def run_mainwindow(
         The name of the layout preset. None is default.
     layout : dict | None
         The layout dictionary to use instead of the preset.
+    external_data: object, default: None
+        Whatever is passed to `external_data` is attached to the controller as the attribute
+        `external_data`. Useful for custom views.
+    curation_callback: function, default: None
+        A function that is called when the curation is saved. It should take two arguments:
+        - `curation_data`: a dictionary containing the curation data (merges, splits, removed units)
+        - `curation_callback_kwargs`: a dictionary of additional keyword arguments specified in `curation_callback_kwargs`
+    curation_callback_kwargs: dict, default: None
+        A dictionary of additional keyword arguments to pass to the `curation_callback` when it is called.
     address: str, default : "localhost"
         For "web" mode only. By default it is "localhost".
         Use "auto-ip" to use the real IP address of the machine.
@@ -93,9 +104,6 @@ def run_mainwindow(
         A dictionary of user settings for each view, which overwrite the default settings.
     disable_save_settings_button: bool, default: False
         If True, disables the "save default settings" button, so that user cannot do this.
-    external_data: object, default: None
-        Whatever is passed to `external_data` is attached to the controller as the attribute
-        `external_data`. Useful for custom views.
     """
 
     if mode == "desktop":
@@ -149,6 +157,8 @@ def run_mainwindow(
         skip_extensions=skip_extensions,
         disable_save_settings_button=disable_save_settings_button,
         external_data=external_data,
+        curation_callback=curation_callback,
+        curation_callback_kwargs=curation_callback_kwargs,
         user_main_settings=user_main_settings
     )
     if verbose:

spikeinterface_gui/tests/test_panel_embedded.py

@@ -0,0 +1,45 @@
+import panel as pn
+from pathlib import Path
+from spikeinterface import load_sorting_analyzer
+from spikeinterface_gui import run_mainwindow
+
+pn.extension()
+
+
+test_folder = Path(__file__).parent / 'my_dataset_small'
+
+
+analyzer = load_sorting_analyzer(test_folder / "sorting_analyzer")
+
+# State in the parent app
+status_md = pn.pane.Markdown("No curation submitted yet.")
+
+
+def on_curation_saved(curation_data, title):
+    """This runs in the parent app's context — pure Python, no JS."""
+    status_md.object = f"{title}\n\nReceived curation data:\n```\n{curation_data}\n```"
+    # You can do anything here: save to DB, trigger a pipeline, etc.
+
+# Create the embedded GUI with the callback
+win = run_mainwindow(
+    analyzer,
+    mode="web",
+    start_app=False,
+    panel_window_servable=False,
+    curation=True,
+    curation_callback=on_curation_saved,
+    curation_callback_kwargs={"title": "✅ Curation received!\n"},
+)
+
+# Compose the parent layout
+parent_layout = pn.Column(
+    "# Parent Application",
+    status_md,
+    pn.layout.Divider(),
+    win.main_layout,
+    sizing_mode="stretch_both",
+)
+
+parent_layout.servable()
+
+pn.serve(parent_layout, port=12345, show=True)

spikeinterface_gui/unitlistview.py

@@ -26,6 +26,12 @@ def get_selected_unit_ids(self):
         elif self.backend == 'panel':
             return self._panel_get_selected_unit_ids()
 
+    def update_manual_labels(self):
+        if self.backend == 'qt':
+            self._qt_full_table_refresh()
+        elif self.backend == 'panel':
+            self._panel_update_labels()
+
     ## Qt ##
     def _qt_make_layout(self):
 
@@ -710,6 +716,17 @@ def _panel_on_edit(self, event):
             self.notify_manual_curation_updated()
         self.notifier.notify_active_view_updated()
 
+    def _panel_update_labels(self):
+        # this is called after a label change to update the table values
+        for col in self.label_definitions:
+            for row in range(len(self.table.value)):
+                unit_id = self.table.value.index[row]
+                label_value = self.controller.get_unit_label(unit_id, col)
+                if label_value is None:
+                    label_value = ""
+                self.table.value.at[unit_id, col] = label_value
+        self.refresh()
+
     def _panel_on_only_selection(self):
         selected_unit = self.table.selection[0]
         unit_id = self.table.value.index.values[selected_unit]