Solve conflicts

Author: alejoe91

spikeinterface_gui/basescatterview.py

@@ -17,7 +17,7 @@ class BaseScatterView(ViewBase):
             {'name': 'display_high_percentiles', 'type': 'float', 'value' : 98.0, 'limits':(50, 100), 'step':0.5},
         ]
     _need_compute = False
-    
+
     def __init__(self, spike_data, y_label, controller=None, parent=None, backend="qt"):
 
         # compute data bounds
@@ -46,6 +46,12 @@ def get_unit_data(self, unit_id, segment_index=0):
         spike_times = self.controller.sample_index_to_time(spike_indices)
         spike_data = self.spike_data[inds]
 
+        if len(spike_data) == 1:
+            spike_data_value = spike_data[0]
+            ymin = spike_data_value - 0.1 * spike_data_value
+            ymax = spike_data_value + 0.1 * spike_data_value
+            return spike_times, spike_data, np.array([1]), np.array([ymin, ymax]), ymin, ymax, inds
+
         # avoid clear outliers in the plot and histogram by using percentiles
         ymin, ymax = np.percentile(spike_data, [self.settings['display_low_percentiles'], self.settings['display_high_percentiles']])
         min_bin_size = np.min(np.diff(np.unique(spike_data)))
@@ -185,6 +191,9 @@ def on_unit_visibility_changed(self):
                 self._current_selected = self.controller.get_indices_spike_selected().size
         self.refresh(set_scatter_range=True)
 
+    def on_spike_selection_changed(self):
+        self.refresh()
+
     def on_use_times_updated(self):
         self.refresh(set_scatter_range=True)
 
@@ -295,6 +304,8 @@ def _qt_refresh(self, set_scatter_range=False):
                 unit_id, 
                 segment_index=segment_index
             )
+            if len(spike_times) == 0:
+                continue
 
             # make a copy of the color
             color = QT.QColor(self.get_unit_color(unit_id))
@@ -314,7 +325,7 @@ def _qt_refresh(self, set_scatter_range=False):
 
         # set x range to time range of the current segment for scatter, and max count for histogram
         # set y range to min and max of visible spike amplitudes
-        if set_scatter_range or not self._first_refresh_done:
+        if len(ymins) > 0 and (set_scatter_range or not self._first_refresh_done):
             ymin = np.min(ymins)
             ymax = np.max(ymaxs)
             t_start, t_stop = self.controller.get_t_start_t_stop()
@@ -490,6 +501,7 @@ def _panel_make_layout(self):
         self.plotted_inds = []
 
     def _panel_refresh(self, set_scatter_range=False):
+        import panel as pn
         from bokeh.models import FixedTicker
 
         self.plotted_inds = []
@@ -516,6 +528,8 @@ def _panel_refresh(self, set_scatter_range=False):
                 unit_id,
                 segment_index=segment_index
             )
+            if len(spike_times) == 0:
+                continue
             color = self.get_unit_color(unit_id)
             xs.extend(spike_times)
             ys.extend(spike_data)
@@ -555,28 +569,45 @@ def _panel_refresh(self, set_scatter_range=False):
         # handle selected spikes
         self._panel_update_selected_spikes()
 
-        # set y range to min and max of visible spike amplitudes
+        # Defer Range updates to avoid nested document lock issues
+        # def update_ranges():
         if set_scatter_range or not self._first_refresh_done:
             self.y_range.start = np.min(ymins)
             self.y_range.end = np.max(ymaxs)
             self._first_refresh_done = True
         self.hist_fig.x_range.end = max_count
         self.hist_fig.xaxis.ticker = FixedTicker(ticks=[0, max_count // 2, max_count])
 
+        # Schedule the update to run after the current event loop iteration
+        # pn.state.execute(update_ranges, schedule=True)
+
     def _panel_on_select_button(self, event):
-        if self.select_toggle_button.value:
-            self.scatter_fig.toolbar.active_drag = self.lasso_tool
-        else:
-            self.scatter_fig.toolbar.active_drag = None
-            self.scatter_source.selected.indices = []
+        import panel as pn
+
+        value = self.select_toggle_button.value
+
+        def _do_update():
+            if value:
+                self.scatter_fig.toolbar.active_drag = self.lasso_tool
+            else:
+                self.scatter_fig.toolbar.active_drag = None
+                self.scatter_source.selected.indices = []
+
+        pn.state.execute(_do_update, schedule=True)
 
     def _panel_change_segment(self, event):
+        import panel as pn
+
         self._current_selected = 0
         segment_index = int(self.segment_selector.value.split()[-1])
         self.controller.set_time(segment_index=segment_index)
         t_start, t_end = self.controller.get_t_start_t_stop()
-        self.scatter_fig.x_range.start = t_start
-        self.scatter_fig.x_range.end = t_end
+
+        def _do_update():
+            self.scatter_fig.x_range.start = t_start
+            self.scatter_fig.x_range.end = t_end
+
+        pn.state.execute(_do_update, schedule=True)
         self.refresh(set_scatter_range=True)
         self.notify_time_info_updated()
 
@@ -618,9 +649,17 @@ def _panel_split(self, event):
         self.split()
 
     def _panel_update_selected_spikes(self):
+        import panel as pn
+
         # handle selected spikes
         selected_spike_indices = self.controller.get_indices_spike_selected()
         selected_spike_indices = np.intersect1d(selected_spike_indices, self.plotted_inds)
+        if len(selected_spike_indices) == 1:
+            selected_segment = self.controller.spikes[selected_spike_indices[0]]['segment_index']
+            segment_index = self.controller.get_time()[1]
+            if selected_segment != segment_index:
+                self.segment_selector.value = f"Segment {selected_segment}"
+                self._panel_change_segment(None)
         if len(selected_spike_indices) > 0:
             # map absolute indices to visible spikes
             segment_index = self.controller.get_time()[1]
@@ -634,23 +673,16 @@ def _panel_update_selected_spikes(self):
             # set selected spikes in scatter plot
             if self.settings["auto_decimate"] and len(selected_indices) > 0:
                 selected_indices, = np.nonzero(np.isin(self.plotted_inds, selected_spike_indices))
-            self.scatter_source.selected.indices = list(selected_indices)
         else:
-            self.scatter_source.selected.indices = []
+            selected_indices = []
+
+        def _do_update():
+            self.scatter_source.selected.indices = list(selected_indices)
+
+        pn.state.execute(_do_update, schedule=True)
 
     def _panel_on_spike_selection_changed(self):
-        # set selection in scatter plot
-        selected_indices = self.controller.get_indices_spike_selected()
-        if len(selected_indices) == 0:
-            self.scatter_source.selected.indices = []
-            return
-        elif len(selected_indices) == 1:
-            selected_segment = self.controller.spikes[selected_indices[0]]['segment_index']
-            segment_index = self.controller.get_time()[1]
-            if selected_segment != segment_index:
-                self.segment_selector.value = f"Segment {selected_segment}"
-                self._panel_change_segment(None)
-        # update selected spikes
+        # update selected spikes (scheduled via pn.state.execute inside)
         self._panel_update_selected_spikes()
 
     def _panel_handle_shortcut(self, event):

spikeinterface_gui/controller.py

@@ -9,10 +9,7 @@
 from spikeinterface.widgets.utils import get_unit_colors
 from spikeinterface import compute_sparsity
 from spikeinterface.core import get_template_extremum_channel
-import spikeinterface.postprocessing
-import spikeinterface.qualitymetrics
 from spikeinterface.core.sorting_tools import spike_vector_to_indices
-from spikeinterface.core.core_tools import check_json
 from spikeinterface.curation import validate_curation_dict
 from spikeinterface.curation.curation_model import CurationModel
 from spikeinterface.widgets.utils import make_units_table_from_analyzer
@@ -345,7 +342,6 @@ def __init__(
         self.curation_callback = curation_callback
         self.curation_callback_kwargs = curation_callback_kwargs
 
-        # TODO: Reload the dictionary if it already exists
         if self.curation:
             # rules:
             #  * if user sends curation_data, then it is used
@@ -354,6 +350,7 @@ def __init__(
 
             if curation_data is not None:
                 # validate the curation data
+                curation_data = deepcopy(curation_data)
                 format_version = curation_data.get("format_version", None)
                 # assume version 2 if not present
                 if format_version is None:
@@ -363,24 +360,6 @@ def __init__(
                 except Exception as e:
                     raise ValueError(f"Invalid curation data.\nError: {e}")
 
-                if curation_data.get("merges") is None:
-                    curation_data["merges"] = []
-                else:
-                    # here we reset the merges for better formatting (str)
-                    existing_merges = curation_data["merges"]
-                    new_merges = []
-                    for m in existing_merges:
-                        if "unit_ids" not in m:
-                            continue
-                        if len(m["unit_ids"]) < 2:
-                            continue
-                        new_merges = add_merge(new_merges, m["unit_ids"])
-                    curation_data["merges"] = new_merges
-                if curation_data.get("splits") is None:
-                    curation_data["splits"] = []
-                if curation_data.get("removed") is None:
-                    curation_data["removed"] = []
-
             elif self.analyzer.format == "binary_folder":
                 json_file = self.analyzer.folder / "spikeinterface_gui" / "curation_data.json"
                 if json_file.exists():
@@ -395,24 +374,27 @@ def __init__(
 
             if curation_data is None:
                 curation_data = deepcopy(empty_curation_data)
+                curation_data["unit_ids"] = self.unit_ids.tolist()
 
-            self.curation_data = curation_data
-
-            self.has_default_quality_labels = False
-            if "label_definitions" not in self.curation_data:
+            if "label_definitions" not in curation_data:
                 if label_definitions is not None:
-                    self.curation_data["label_definitions"] = label_definitions
+                    curation_data["label_definitions"] = label_definitions
                 else:
-                    self.curation_data["label_definitions"] = default_label_definitions.copy()
+                    curation_data["label_definitions"] = default_label_definitions.copy()
 
-            if "quality" in self.curation_data["label_definitions"]:
-                curation_dict_quality_labels = self.curation_data["label_definitions"]["quality"]["label_options"]
+            # This will enable the default shortcuts if has default quality labels
+            self.has_default_quality_labels = False
+            if "quality" in curation_data["label_definitions"]:
+                curation_dict_quality_labels = curation_data["label_definitions"]["quality"]["label_options"]
                 default_quality_labels = default_label_definitions["quality"]["label_options"]
                 if set(curation_dict_quality_labels) == set(default_quality_labels):
                     if self.verbose:
                         print('Curation quality labels are the default ones')
                     self.has_default_quality_labels = True
 
+            curation_data = CurationModel(**curation_data).model_dump()
+            self.curation_data = curation_data
+
     def check_is_view_possible(self, view_name):
         from .viewlist import get_all_possible_views
         possible_class_views = get_all_possible_views()
@@ -854,7 +836,7 @@ def compute_auto_merge(self, **params):
         )
 
         return merge_unit_groups, extra
-    
+
     def curation_can_be_saved(self):
         return self.analyzer.format != "memory"