bindmc 0.1.7__tar.gz → 0.1.9__tar.gz

{bindmc-0.1.7 → bindmc-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindmc
-Version: 0.1.7
+Version: 0.1.9
 Keywords: chemistry,analytical chemistry,binding constants,supramolecular
 Author: Martin Peeks
 Author-email: Martin Peeks <martinp23@googlemail.com>, m.peeks@unsw.edu.au

{bindmc-0.1.7 → bindmc-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindmc"
-version = "0.1.7"
+version = "0.1.9"
 readme = "README.md"
 keywords = ["chemistry", "analytical chemistry", "binding constants", "supramolecular"]
 classifiers = [

{bindmc-0.1.7 → bindmc-0.1.9}/src/bindmc/webgui/classes/ExptData.py

@@ -66,6 +66,11 @@ class ExptData:
             self.col_to_comp = np.array(self.col_to_comp, dtype=float)
         if not isinstance(self.integ_to_spec, np.ndarray):
             self.integ_to_spec = np.array(self.integ_to_spec, dtype=float)
+        if not isinstance(self.delta_to_spec, np.ndarray):
+            if self.delta_to_spec is not None:
+                self.delta_to_spec = np.array(self.delta_to_spec, dtype=object)
+            else:
+                self.delta_to_spec = np.array([], dtype=object)
 
         # if len(self.col_details) != len(self.data.columns):
         #     # Initialize col_details if it doesn't match the number of columns
@@ -81,6 +86,10 @@ class ExptData:
             if isinstance(self.model_id, str) and self.model_id != "None":
                 self.model_id = uuid.UUID(self.model_id)
 
+        if not isinstance(self.raw_data_id, uuid.UUID):
+            if isinstance(self.raw_data_id, str) and self.raw_data_id != "None":
+                self.raw_data_id = uuid.UUID(self.raw_data_id)
+
         if isinstance(self._model, Model) and not self.model_id:
             self.model_id = self._model.id
 
@@ -155,6 +164,7 @@ class ExptData:
     @property
     def columns(self) -> list[str]:
         """Get the column names of the selected experimental data."""
+        self.reconcile_matrices()
         return self.selected_data.columns.tolist() if not self.selected_data.empty else []
 
     @property
@@ -330,7 +340,7 @@ class ExptData:
             # ),
             "col_to_comp": self.col_to_comp.tolist() if isinstance(self.col_to_comp, np.ndarray) else [],
             "integ_to_spec": self.integ_to_spec.tolist() if isinstance(self.integ_to_spec, np.ndarray) else [],
-            "col_details": self.col_details if isinstance(self.col_details, dict) else {},
+            "col_details": {k: dict(v) if isinstance(v, dict) else v for k, v in self.col_details.items()} if isinstance(self.col_details, dict) else {},
             "id": str(self.id) if self.id else "",
             "model_id": str(self.model_id) if hasattr(self, "model_id") else "",
             "raw_data_id": str(self.raw_data_id) if hasattr(self, "raw_data_id") else "",
@@ -339,7 +349,7 @@ class ExptData:
             # limiting_shifts as a list for JSON safety (tuple keys not JSON-serializable)
             "limiting_shifts": [asdict(v) for v in self.limiting_shifts.values()],
             "is_analytical_fast_ex": self.is_analytical_fast_ex,
-            "selected_columns": self.selected_columns,
+            "selected_columns": list(self.selected_columns),
             "dark_species": {col: list(species) for col, species in self.dark_species.items()},
         }
 
@@ -487,3 +497,76 @@ class ExptData:
                         serialized_row.append(None)
             serialized_rows.append(serialized_row)
         return serialized_rows
+
+    def reconcile_matrices(self) -> None:
+        """Align col_to_comp, integ_to_spec, and delta_to_spec with selected_columns and col_details."""
+        current_sel_cols = self.selected_columns
+        n_comp_cols = len(current_sel_cols)
+
+        # 1. col_to_comp reconciliation
+        if isinstance(self.col_to_comp, np.ndarray) and self.col_to_comp.ndim == 2:
+            if not hasattr(self, "_matrix_columns") or len(self._matrix_columns) != self.col_to_comp.shape[1]:
+                if self.col_to_comp.shape[1] == n_comp_cols:
+                    self._matrix_columns = list(current_sel_cols)
+                else:
+                    self._matrix_columns = list(current_sel_cols)[:self.col_to_comp.shape[1]]
+                    if len(self._matrix_columns) < self.col_to_comp.shape[1]:
+                        self._matrix_columns += [f"__unknown_col_{i}__" for i in range(self.col_to_comp.shape[1] - len(self._matrix_columns))]
+
+            if self._matrix_columns != current_sel_cols:
+                new_col_to_comp = np.zeros((self.col_to_comp.shape[0], len(current_sel_cols)), dtype=float)
+                for new_idx, col_name in enumerate(current_sel_cols):
+                    if col_name in self._matrix_columns:
+                        old_idx = self._matrix_columns.index(col_name)
+                        new_col_to_comp[:, new_idx] = self.col_to_comp[:, old_idx]
+                self.col_to_comp = new_col_to_comp
+                self._matrix_columns = list(current_sel_cols)
+
+        # 2. integ_to_spec reconciliation
+        if isinstance(self.integ_to_spec, np.ndarray) and self.integ_to_spec.ndim == 2 and self.integ_to_spec.size > 0:
+            if not hasattr(self, "_matrix_integ_columns") or len(self._matrix_integ_columns) != self.integ_to_spec.shape[1]:
+                if self.integ_to_spec.shape[1] == n_comp_cols:
+                    self._matrix_integ_columns = list(current_sel_cols)
+                else:
+                    self._matrix_integ_columns = list(current_sel_cols)[:self.integ_to_spec.shape[1]]
+                    if len(self._matrix_integ_columns) < self.integ_to_spec.shape[1]:
+                        self._matrix_integ_columns += [f"__unknown_col_{i}__" for i in range(self.integ_to_spec.shape[1] - len(self._matrix_integ_columns))]
+
+            if self._matrix_integ_columns != current_sel_cols:
+                new_integ_to_spec = np.zeros((self.integ_to_spec.shape[0], len(current_sel_cols)), dtype=float)
+                for new_idx, col_name in enumerate(current_sel_cols):
+                    if col_name in self._matrix_integ_columns:
+                        old_idx = self._matrix_integ_columns.index(col_name)
+                        new_integ_to_spec[:, new_idx] = self.integ_to_spec[:, old_idx]
+                self.integ_to_spec = new_integ_to_spec
+                self._matrix_integ_columns = list(current_sel_cols)
+
+        # 3. delta_to_spec reconciliation
+        current_fast_ex_cols = []
+        if self.col_details:
+            for name, col in self.col_details.items():
+                if col.get("dtype") is None:
+                    continue
+                dtype_key = str(col.get("dtype", "")).lower()
+                if col.get("depindep") == "dep" and ("delta" in dtype_key or "ppm" in dtype_key or "shift" in dtype_key):
+                    current_fast_ex_cols.append(name)
+
+        if isinstance(self.delta_to_spec, np.ndarray) and self.delta_to_spec.ndim == 2 and self.delta_to_spec.size > 0:
+            if not hasattr(self, "_matrix_fast_ex_columns") or len(self._matrix_fast_ex_columns) != self.delta_to_spec.shape[0]:
+                if self.delta_to_spec.shape[0] == len(current_fast_ex_cols):
+                    self._matrix_fast_ex_columns = list(current_fast_ex_cols)
+                else:
+                    self._matrix_fast_ex_columns = list(current_fast_ex_cols)[:self.delta_to_spec.shape[0]]
+                    if len(self._matrix_fast_ex_columns) < self.delta_to_spec.shape[0]:
+                        self._matrix_fast_ex_columns += [f"__unknown_fast_col_{i}__" for i in range(self.delta_to_spec.shape[0] - len(self._matrix_fast_ex_columns))]
+
+            if self._matrix_fast_ex_columns != current_fast_ex_cols:
+                n_species = self.delta_to_spec.shape[1]
+                new_delta_to_spec = np.empty((len(current_fast_ex_cols), n_species), dtype=object)
+                new_delta_to_spec.fill(None)
+                for new_idx, col_name in enumerate(current_fast_ex_cols):
+                    if col_name in self._matrix_fast_ex_columns:
+                        old_idx = self._matrix_fast_ex_columns.index(col_name)
+                        new_delta_to_spec[new_idx, :] = self.delta_to_spec[old_idx, :]
+                self.delta_to_spec = new_delta_to_spec
+                self._matrix_fast_ex_columns = list(current_fast_ex_cols)

{bindmc-0.1.7 → bindmc-0.1.9}/src/bindmc/webgui/components/data_import.py

@@ -7,6 +7,7 @@ from nicegui.events import UploadEventArguments, ClickEventArguments
 
 from .base import BaseComponent
 from .graph import Graph
+from .dataset_selector import DatasetSelector
 from ..classes import ExptData, RawData, ExptDataType
 
 
@@ -19,6 +20,7 @@ class DataImportPanel(BaseComponent):
 
         self.dtype_labels = []
         self.dtype_dropdowns = []
+        self._restore_point = self._backup_expt(self.sm.active_expt_data_or_none)
 
     def setup_nicegui(self):
         self.container = ui.column().classes("w-full")
@@ -30,22 +32,7 @@ class DataImportPanel(BaseComponent):
             # - wide screens: show cards side-by-side (controls left, table/graph right)
             with ui.row().classes("w-full gap-4 items-start flex-col lg:flex-row"):
                 with ui.card().classes("w-full lg:flex-1 min-w-0"):
-                    active_expt = self.sm.active_expt_data_or_none
-                    if active_expt is not None:
-                        self.expt_data_dropdown_button = (
-                            ui.dropdown_button("Choose dataset", auto_close=True)
-                            .bind_text(active_expt, "name")
-                            .classes("mb-5")
-                        )
-                    else:
-                        self.expt_data_dropdown_button = ui.dropdown_button("No active model", auto_close=True).classes(
-                            "mb-5"
-                        )
-
-                    if len(self.sm.raw_datas) > 0:
-                        self.generate_data_dropdown()
-                    else:
-                        self.expt_data_dropdown_button.visible = False
+                    self.selector = DatasetSelector(self.sm)
 
                     ui.label("Upload Data File (CSV or Excel)")
                     ui.button("Upload File", on_click=self.load_exptdata)
@@ -94,42 +81,219 @@ class DataImportPanel(BaseComponent):
     def setup_bindings(self):
         super().setup_bindings()
         self.sm.add_listener("data_imported", self._load_data_to_table)
-        self.sm.add_listener("data_imported", self.generate_data_dropdown)
         self.sm.add_listener("active_context_changed", self._load_data_to_table)
-        self.sm.add_listener("active_context_changed", self.generate_data_dropdown)
         self.sm.add_listener(
             "expt_data_columns_changed", self._load_data_to_table
         )  # Update when column selection changes
 
+    def _backup_expt(self, old_expt: ExptData) -> ExptData:
+        """Return a copy of old_expt with the SAME UUID and name (a true backup)."""
+        if old_expt is None:
+            return None
+        import uuid
+        from dataclasses import asdict
+        from ..classes import ChemicalShiftParam
+        d = old_expt.to_dict()
+        limiting_shifts_raw = d.pop("limiting_shifts", []) or []
+        new_expt = ExptData(**d)
+        new_expt.limiting_shifts = {}
+        for cs in limiting_shifts_raw:
+            csp = ChemicalShiftParam(**cs)
+            key = (csp.species, csp.col)
+            new_expt.limiting_shifts[key] = csp
+        new_expt.find_and_link_model(self.sm.models)
+        new_expt.find_and_link_raw_data(self.sm.raw_datas)
+        return new_expt
+
+
+
     def prepare_data_model(self, e: ClickEventArguments):
         active_raw = self.sm.active_raw_data_or_none
         active_expt = self.sm.active_expt_data_or_none
         if self.sm.active_raw_data_id is not None and active_raw is not None:
             if active_expt is not None and active_expt.raw_data_id == active_raw.id:
-                # Auto-deselect unassigned columns
+                # Check if selected columns or details have changed from the restore point
+                has_changes = False
+                if hasattr(self, "_restore_point") and self._restore_point is not None:
+                    if set(active_expt.selected_columns) != set(self._restore_point.selected_columns):
+                        has_changes = True
+                    else:
+                        for col in active_expt.selected_columns:
+                            old_det = self._restore_point.col_details.get(col, {})
+                            new_det = active_expt.col_details.get(col, {})
+                            if old_det.get("depindep") != new_det.get("depindep") or old_det.get("dtype") != new_det.get("dtype"):
+                                has_changes = True
+                                break
+                
+                # Check if there are changes in the unassigned auto-deselect columns too
                 for col in active_expt.data.columns:
                     col_details = active_expt.col_details.get(col, {})
                     is_component = col.startswith("[") and col.endswith("]")
                     has_assignment = (col_details.get("depindep") in ["dep", "indep"]) and (
                         col_details.get("dtype") is not None
                     )
-
                     if not is_component and not has_assignment:
-                        # Remove from selected columns instead of marking as ignored
                         if col in active_expt.selected_columns:
-                            active_expt.selected_columns.remove(col)
-
-                self._load_expt_data_col_details()  # Refresh UI to show changes
-                self._load_data_to_table()  # Refresh table and graph to show selected data
-                ui.notify("Data model prepared. Unassigned columns have been deselected.", type="positive")
+                            has_changes = True
+
+                if has_changes:
+                    # Detect if there is existing work associated with this ExptData
+                    has_model_work = False
+                    if (
+                        (active_expt.limiting_shifts and len(active_expt.limiting_shifts) > 0)
+                        or (active_expt.delta_to_spec is not None and active_expt.delta_to_spec.size > 0)
+                        or (active_expt.integ_to_spec is not None and active_expt.integ_to_spec.size > 0)
+                    ):
+                        has_model_work = True
+                    
+                    has_fits = any(fit.expt_data_id == active_expt.id for fit in self.sm.fits.values())
+                    has_mcmc = any(mcmc.expt_data_id == active_expt.id for mcmc in self.sm.mcmcs.values())
+                    
+                    if has_model_work or has_fits or has_mcmc:
+                        # Existing work exists, prompt user to Overwrite or Rename
+                        self.prompt_overwrite_or_rename(active_expt, has_fits, has_mcmc, has_model_work)
+                    else:
+                        # No existing work to lose, perform direct overwrite in-place
+                        self.prepare_data_model_overwrite(active_expt, delete_dependents=False)
+                else:
+                    self._load_expt_data_col_details()
+                    self._load_data_to_table()
+                    ui.notify("Data model prepared.", type="positive")
             else:
                 rd = active_raw
                 new_expt_data = ExptData(name=rd.filename, init_raw_data=rd, init_model=self.sm.active_model)
                 self.sm.add_expt_data(new_expt_data)
-            self.sm.notify_listeners("data_imported")  # Trigger table and graph update
+                self._restore_point = self._backup_expt(new_expt_data)
+            self.sm.notify_listeners("data_imported")
         else:
             ui.notify("No raw data selected to prepare data model from.", type="negative")
 
+    def prompt_overwrite_or_rename(self, active_expt, has_fits, has_mcmc, has_model_work):
+        with ui.dialog() as dialog, ui.card().classes("p-4"):
+            ui.label("Existing Work Detected").classes("text-lg font-bold")
+            
+            msg = f"The active data model '{active_expt.name}' has existing work associated with it"
+            reasons = []
+            if has_model_work:
+                reasons.append("data model configuration")
+            if has_fits:
+                reasons.append("dependent fit results")
+            if has_mcmc:
+                reasons.append("MCMC simulation results")
+            msg += " (" + ", ".join(reasons) + ")."
+            
+            ui.label(msg).classes("text-sm text-gray-700 mb-2")
+            
+            if has_fits or has_mcmc:
+                ui.label(
+                    "WARNING: Overwriting this data model will PERMANENTLY delete all dependent fits and MCMC simulations."
+                ).classes("text-sm text-red-600 font-semibold mb-4")
+            
+            with ui.row().classes("justify-end gap-2 w-full"):
+                ui.button("Cancel", on_click=dialog.close).props("flat")
+                
+                # Rename / Create New button
+                def on_rename():
+                    dialog.close()
+                    self.prepare_data_model_rename(active_expt)
+                ui.button("Rename (Create New)", on_click=on_rename).props("outline color=primary")
+                
+                # Overwrite button
+                def on_overwrite():
+                    dialog.close()
+                    self.prepare_data_model_overwrite(active_expt, delete_dependents=True)
+                ui.button("Overwrite", on_click=on_overwrite).props("unelevated color=negative")
+
+    def prepare_data_model_overwrite(self, active_expt, delete_dependents=True):
+        # Auto-deselect unassigned columns in place
+        for col in active_expt.data.columns:
+            col_details = active_expt.col_details.get(col, {})
+            is_component = col.startswith("[") and col.endswith("]")
+            has_assignment = (col_details.get("depindep") in ["dep", "indep"]) and (
+                col_details.get("dtype") is not None
+            )
+            if not is_component and not has_assignment:
+                if col in active_expt.selected_columns:
+                    active_expt.selected_columns.remove(col)
+
+        # In-place reconciliation
+        active_expt.reconcile_matrices()
+
+        if delete_dependents:
+            # Delete dependent fits & mcmcs
+            to_delete = []
+            for fit in list(self.sm.fits.values()):
+                if fit.expt_data_id == active_expt.id:
+                    to_delete.append(fit)
+            for mcmc in list(self.sm.mcmcs.values()):
+                if mcmc.expt_data_id == active_expt.id:
+                    to_delete.append(mcmc)
+            
+            for obj in to_delete:
+                self.sm.delete_object(obj)
+
+        # Update restore point to current reconciled state
+        self._restore_point = self._backup_expt(active_expt)
+        
+        self._load_expt_data_col_details()
+        self._load_data_to_table()
+        ui.notify(f"Data model '{active_expt.name}' updated and reconciled.", type="positive")
+
+    def prepare_data_model_rename(self, active_expt):
+        import numpy as np
+        from dataclasses import asdict
+        from ..classes import ChemicalShiftParam
+
+        # 1. Clone the current mutated active_expt to create a new version
+        existing_names = [ed.name for ed in self.sm.expt_datas.values()]
+        new_name = self.selector.get_next_version_name(self._restore_point.name, existing_names)
+        target = self.selector._clone_expt_data(active_expt, new_name)
+        
+        # 2. Seed target's old matrix column associations from the restore point
+        target._matrix_columns = list(self._restore_point.selected_columns)
+        if self._restore_point.integ_to_spec is not None:
+            target._matrix_integ_columns = list(self._restore_point.selected_columns)
+        
+        fast_ex_cols = []
+        if self._restore_point.col_details:
+            for name, col in self._restore_point.col_details.items():
+                if col.get("dtype") is None:
+                    continue
+                dtype_key = str(col.get("dtype", "")).lower()
+                if col.get("depindep") == "dep" and ("delta" in dtype_key or "ppm" in dtype_key or "shift" in dtype_key):
+                    fast_ex_cols.append(name)
+        target._matrix_fast_ex_columns = fast_ex_cols
+
+        # Auto-deselect unassigned columns in place on the clone
+        for col in target.data.columns:
+            col_details = target.col_details.get(col, {})
+            is_component = col.startswith("[") and col.endswith("]")
+            has_assignment = (col_details.get("depindep") in ["dep", "indep"]) and (
+                col_details.get("dtype") is not None
+            )
+            if not is_component and not has_assignment:
+                if col in target.selected_columns:
+                    target.selected_columns.remove(col)
+
+        # 3. Reconcile the new clone
+        target.reconcile_matrices()
+        
+        # 4. Restore the original active_expt back to the restore point
+        active_expt.selected_columns = list(self._restore_point.selected_columns)
+        active_expt.col_details = {k: dict(v) for k, v in self._restore_point.col_details.items()}
+        active_expt.col_to_comp = np.copy(self._restore_point.col_to_comp) if isinstance(self._restore_point.col_to_comp, np.ndarray) else self._restore_point.col_to_comp
+        active_expt.integ_to_spec = np.copy(self._restore_point.integ_to_spec) if isinstance(self._restore_point.integ_to_spec, np.ndarray) else self._restore_point.integ_to_spec
+        active_expt.delta_to_spec = np.copy(self._restore_point.delta_to_spec) if isinstance(self._restore_point.delta_to_spec, np.ndarray) else self._restore_point.delta_to_spec
+        active_expt.limiting_shifts = {k: ChemicalShiftParam(**asdict(v)) for k, v in self._restore_point.limiting_shifts.items()}
+        
+        # 5. Add the clone to StateManager (becomes active, reconciles active ID, notify context changed)
+        self.sm.add_expt_data(target)
+        self._restore_point = self._backup_expt(target)
+        self.sm.notify_listeners("active_context_changed")
+        self.sm.notify_listeners("data_imported")
+        
+        ui.notify(f"New data model version '{new_name}' prepared. Original version preserved.", type="positive")
+
     async def load_exptdata(self):
         try:
             with ui.dialog() as dialog, ui.card():
@@ -237,6 +401,12 @@ class DataImportPanel(BaseComponent):
         self.dtype_labels.clear()
         self.dtype_dropdowns.clear()
 
+        # Update restore point if active context has changed
+        active_expt = self.sm.active_expt_data_or_none
+        if active_expt is not None:
+            if not hasattr(self, "_restore_point") or self._restore_point is None or self._restore_point.id != active_expt.id:
+                self._restore_point = self._backup_expt(active_expt)
+
         with self.expt_data_col_block:
             if not self.sm.active_expt_data.data.empty:
                 ui.label("Experimental Data Columns:")
@@ -398,63 +568,4 @@ class DataImportPanel(BaseComponent):
             ui.notify(f"New experimental data type '{name_input.value}' added.", type="positive")
             self._load_expt_data_col_details()
 
-    def generate_data_dropdown(self, e=None):
-        """Generate the dropdown for selecting experimental data."""
-
-        self.expt_data_dropdown_button.clear()
-        if len(self.sm.expt_datas) > 0 and len(self.sm.raw_datas) > 0:
-            self.expt_data_dropdown_button.visible = True
-            with self.expt_data_dropdown_button:
-                self.expt_data_dropdown_rows = []
-                for m in self.sm.raw_datas.values():
-                    with ui.row().classes("p-5 items-center") as x:
-                        self.expt_data_dropdown_rows.append(x)
-                        with ui.item(on_click=lambda m=m: self.load_raw_data(m)):
-                            ui.item_label(m.filename)
-                        ui.icon("delete").on("click", lambda m=m: self.delete_raw_data(m)).classes(
-                            "cursor-pointer text-red-600"
-                        )
-                # ui.item("Add a new model...", on_click= self.add_new_expt_data)
-        else:
-            self.expt_data_dropdown_button.visible = False
-        active_raw = self.sm.active_raw_data_or_none
-        if active_raw is not None and hasattr(active_raw, "filename"):
-            self.expt_data_dropdown_button.bind_text_from(active_raw, "filename")
-
-    def load_raw_data(self, raw_data):
-        self.sm.active_raw_data_id = raw_data.id
-        active_expt = self.sm.active_expt_data_or_none
-        if active_expt is None or active_expt.raw_data_id != raw_data.id:
-            self.sm.active_expt_data_id = None  # reset active expt data if raw data changes
-            # activate the newest expt data that uses this raw data
-            for ed in reversed(list(self.sm.expt_datas.values())):
-                if ed.raw_data_id == raw_data.id:
-                    self.sm.active_expt_data_id = ed.id
-                    break
-
-            active_fit = self.sm.active_fit_or_none
-            if active_fit is None or active_fit.expt_data_id != self.sm.active_expt_data_id:
-                self.sm.active_fit_id = None  # reset active fit if expt data changes
-                # activate the newest fit that uses this expt data
-                for f in reversed(list(self.sm.fits.values())):
-                    if f.expt_data_id == self.sm.active_expt_data_id:
-                        self.sm.active_fit_id = f.id
-                        break
-
-        self.sm.reconcile_active_context(reason="load_raw_data_selection", emit_events=True)
-        self.sm.notify_listeners("data_imported")
 
-    def delete_raw_data(self, raw_data):
-        self.sm.delete_raw_data(raw_data)
-        # objs_to_delete = []
-        # for f in self.sm.expt_datas.values():
-        #     if f.raw_data_id == raw_data.id:
-        #         objs_to_delete.append(f)
-        #         for ff in self.sm.fits.values():
-        #             if ff.expt_data_id == f.id:
-        #                 objs_to_delete.append(ff)
-        # for obj in objs_to_delete:
-        #     self.sm.delete_object(obj)
-
-    def add_new_raw_data(self):
-        pass

{bindmc-0.1.7 → bindmc-0.1.9}/src/bindmc/webgui/components/data_model.py

@@ -6,6 +6,7 @@ from nicegui.events import ClickEventArguments
 import numpy as np
 
 from .base import BaseComponent
+from .dataset_selector import DatasetSelector
 from ..classes import ChemicalShiftParam, ExptData
 from ..utils import _infer_simple_fast_exchange_topology
 
@@ -33,11 +34,7 @@ class DataModelPanel(BaseComponent):
         self.container = ui.column().classes("w-full")
 
         with self.container:
-            ui.label("Data model setup panel").classes("text-lg font-bold mb-4")
-
-            self.data_model_inp = (
-                ui.input("Data model name", placeholder="Enter data model name").classes("mb-5").props("clearable")
-            )
+            self.selector = DatasetSelector(self.sm)
 
             ui.label("Columns").classes("text-md font-semibold mt-4 mb-2")
             self.dataModel_col_block = ui.element()
@@ -55,12 +52,11 @@ class DataModelPanel(BaseComponent):
             if len(self.sm.expt_datas) > 0:
                 self._populate_blocks()
 
-    def setup_bindings(self):
-        super().setup_bindings()
         self.sm.add_listener("data_imported", self._populate_blocks)
+        self.sm.add_listener("active_context_changed", self._populate_blocks)
         return
 
-    def _populate_blocks(self):
+    def _populate_blocks(self, e=None):
         # add column chips to data model page
 
         nmr_fast_ex = False
@@ -91,8 +87,8 @@ class DataModelPanel(BaseComponent):
             self.slow_ex_label.visible = False
             self.dataModel_specInteg_block.visible = False
 
-        if self.sm.active_expt_data_or_none is not None:
-            self.data_model_inp.value = self.sm.active_expt_data.name[:]  # copy it
+        # Name input field is removed
+        pass
 
     def _gen_column_chips(self):
         """Generate the column chips for the data model."""
@@ -260,7 +256,7 @@ class DataModelPanel(BaseComponent):
                                 ui.chip(
                                     text,
                                     color="teal",
-                                    on_click=lambda h=text: self._insert_species_into_fast_inp(h),
+                                    on_click=lambda h=text, widget=inp: self._insert_species_into_fast_inp(h, widget=widget),
                                 )
                         # placeholder checkbox to enable the input
                         en_cb = ui.checkbox("Enabled", value=True)
@@ -292,19 +288,27 @@ class DataModelPanel(BaseComponent):
                             delta_for_eqn = active_expt.delta_to_spec[i].copy()
 
                             for ij, el in enumerate(delta_for_eqn):
-                                if np.isclose(el, 0):
+                                val = 0.0
+                                if el is not None:
+                                    if hasattr(el, "value"):
+                                        val = el.value
+                                    else:
+                                        try:
+                                            val = float(el)
+                                        except (TypeError, ValueError):
+                                            val = 0.0
+
+                                if np.isclose(val, 0):
                                     delta_for_eqn[ij] = 0
                                 else:
-                                    if (f"{self.sm.species[ij]}_free", shift) in active_expt.limiting_shifts:
+                                    if ij < len(self.sm.species) and (f"{self.sm.species[ij]}_free", shift) in active_expt.limiting_shifts:
                                         s = active_expt.limiting_shifts[f"{self.sm.species[ij]}_free", shift]
                                         if s.value:
-                                            delta_for_eqn[ij] = delta_for_eqn[ij] / s.value
+                                            delta_for_eqn[ij] = val / s.value
                                         else:
-                                            delta_for_eqn[ij] = 1
-
-                                        # self.sm.active_expt_data.limiting_shifts[f'{self.sm.species[i]}_free',shift].value
-
-                            # delta_for_eqn[delta_for_eqn != 0] = 1
+                                            delta_for_eqn[ij] = 1.0
+                                    else:
+                                        delta_for_eqn[ij] = val
 
                             value = self.vec_to_conc_expression(
                                 delta_for_eqn, [f"{x}_free" for x in self.sm.species]
@@ -340,6 +344,7 @@ class DataModelPanel(BaseComponent):
             curr_block = self.fast_ex_chem_shift_blocks[fast_ex_idx]
             curr_block.clear()
             curr_block.visible = False
+            self.fast_ex_chem_shift_map[fast_ex_idx].clear()
             # reset stored params
             if len(self.fast_ex_chem_shift_params) > 0:
                 del self.fast_ex_chem_shift_params[fast_ex_idx]
@@ -415,21 +420,7 @@ class DataModelPanel(BaseComponent):
                 w["min_num"].bind_enabled_from(cs_obj, "fixed", backward=lambda v: not v)
                 w["max_num"].bind_enabled_from(cs_obj, "fixed", backward=lambda v: not v)
 
-    def _clone_expt_data(self, old_expt: ExptData, new_name: str) -> ExptData:
-        """Return a copy of old_expt with a new UUID and name, linked to the same model and raw data."""
-        d = old_expt.to_dict()
-        d["id"] = str(uuid.uuid4())
-        d["name"] = new_name
-        limiting_shifts_raw = d.pop("limiting_shifts", []) or []
-        new_expt = ExptData(**d)
-        new_expt.limiting_shifts = {}
-        for cs in limiting_shifts_raw:
-            csp = ChemicalShiftParam(**cs)
-            key = (csp.species, csp.col)
-            new_expt.limiting_shifts[key] = csp
-        new_expt.find_and_link_model(self.sm.models)
-        new_expt.find_and_link_raw_data(self.sm.raw_datas)
-        return new_expt
+
 
     async def process_data_model(self):
         """Process the data model based on user input."""
@@ -440,7 +431,6 @@ class DataModelPanel(BaseComponent):
 
         # If existing fits depend on this ExptData, require saving as a new one
         dependent_fits = [f for f in self.sm.fits.values() if f.expt_data_id == active_expt.id]
-        new_name = self.data_model_inp.value  # default; overridden by dialog when cloning
         if dependent_fits:
             with ui.dialog() as dialog, ui.card().classes("w-96"):
                 ui.label("Existing fits depend on this data model.").classes("font-semibold")
@@ -454,8 +444,9 @@ class DataModelPanel(BaseComponent):
                 ui.notify("Cancelled — data model unchanged.", type="info")
                 return
             new_name = result
-            target = self._clone_expt_data(active_expt, new_name)
+            target = self.selector._clone_expt_data(active_expt, new_name)
         else:
+            new_name = active_expt.name
             target = active_expt
 
         # make col_to_comp matrix
@@ -553,6 +544,8 @@ class DataModelPanel(BaseComponent):
             self.sm.active_fit_id = None  # deselect any auto-selected fit
             self.sm.notify_listeners("fit_changed")
             self.sm.notify_listeners("fits_loaded")
+            self.sm.notify_listeners("active_context_changed")
+            self.sm.notify_listeners("data_imported")
         self.sm.save_to_storage()
         self.sm.notify_listeners("data_model_processed")
 
@@ -587,6 +580,8 @@ class DataModelPanel(BaseComponent):
         "+[[H]]+2[[G]]" or similar."""
         terms = []
         for i, v in enumerate(vec):
+            if i >= len(cols):
+                continue
             if v == "-1":
                 terms.append(f"-[{cols[i]}]")
             elif v == 1:
@@ -601,8 +596,12 @@ class DataModelPanel(BaseComponent):
     def insert_term(self, h: str | ClickEventArguments) -> None:
         if not isinstance(h, str):
             raise ValueError("Species name from chip is not a str")
-        if hasattr(self, "last_focus") and self.last_focus is not None and self.last_focus.value is not None:
-            self.last_focus.value += f"+{h}"
+        if hasattr(self, "last_focus") and self.last_focus is not None:
+            val = self.last_focus.value
+            if not val:
+                self.last_focus.value = h
+            else:
+                self.last_focus.value = val + f"+{h}"
             # if the focused widget is a fast-exchange input, trigger its handler to regenerate param blocks
 
             if hasattr(self, "specDeltaInps") and self.last_focus in self.specDeltaInps:
@@ -610,20 +609,26 @@ class DataModelPanel(BaseComponent):
                 # call handler (simulate a change/blur)
                 self._handle_spec_delta_blur(idx, self.last_focus)
 
-    def _insert_species_into_fast_inp(self, species_name: str | ClickEventArguments) -> None:
-        """Insert a species chip term into the currently focused fast-exchange input only.
+    def _insert_species_into_fast_inp(self, species_name: str | ClickEventArguments, widget=None) -> None:
+        """Insert a species chip term into the specified or currently focused fast-exchange input.
 
         The inserted token matches the concentration expression token format: `[Species]`.
         """
         if not isinstance(species_name, str):
             raise ValueError("Species name from chip is not a str")
-        if not hasattr(self, "last_focus") or self.last_focus is None:
+        target_widget = widget if widget is not None else getattr(self, "last_focus", None)
+        if target_widget is None:
             return
         # only insert into fast-exchange inputs
-        if hasattr(self, "specDeltaInps") and self.last_focus in self.specDeltaInps:
-            # insert as +[Species]
-            self.last_focus.value = "" if self.last_focus.value is None else self.last_focus.value
-            self.last_focus.value += "+[" + species_name + "]"
+        if hasattr(self, "specDeltaInps") and target_widget in self.specDeltaInps:
+            val = target_widget.value
+            term = f"[{species_name}]"
+            if not val:
+                target_widget.value = term
+            else:
+                target_widget.value = val + f"+{term}"
+
+            idx = self.specDeltaInps.index(target_widget)
+            self._handle_spec_delta_blur(idx, target_widget)
+
 
-            idx = self.specDeltaInps.index(self.last_focus)
-            self._handle_spec_delta_blur(idx, self.last_focus)

bindmc-0.1.9/src/bindmc/webgui/components/dataset_selector.py

@@ -0,0 +1,202 @@
+import uuid
+import re
+from nicegui import ui
+from .base import BaseComponent
+from ..classes import ExptData, RawData
+
+
+class DatasetSelector(BaseComponent):
+    """Reusable dropdown selection and management component for RawData and ExptData."""
+
+    def setup_nicegui(self):
+        self.container = ui.column().classes("w-full gap-2 p-0 m-0")
+        with self.container:
+            # Raw Dataset dropdown
+            with ui.row().classes("items-center gap-2 mb-2 no-wrap"):
+                ui.label("Raw Data:").classes("text-sm font-semibold w-24")
+                self.raw_data_dropdown_button = (
+                    ui.dropdown_button("Choose raw dataset", auto_close=True)
+                    .classes("w-80")
+                )
+
+            # Interpretation / Data Model dropdown
+            with ui.row().classes("items-center gap-2 mb-4 no-wrap"):
+                ui.label("Data Model:").classes("text-sm font-semibold w-24")
+                self.expt_data_dropdown_button = (
+                    ui.dropdown_button("Choose data model", auto_close=True)
+                    .classes("w-80")
+                )
+                self.rename_expt_button = (
+                    ui.button(icon="edit", on_click=self.rename_active_expt)
+                    .props("flat dense")
+                    .classes("q-px-sm")
+                    .tooltip("Rename current data model")
+                )
+                self.duplicate_expt_button = (
+                    ui.button(icon="content_copy", on_click=self.duplicate_active_expt)
+                    .props("flat dense")
+                    .classes("q-px-sm")
+                    .tooltip("Duplicate current configuration")
+                )
+        self.update_dropdown_visibility()
+        self.generate_dropdowns()
+
+    def setup_bindings(self):
+        super().setup_bindings()
+        self.sm.add_listener("data_imported", self.generate_dropdowns)
+        self.sm.add_listener("active_context_changed", self.generate_dropdowns)
+        self.sm.add_listener("expt_data_columns_changed", self.generate_dropdowns)
+
+    def update_dropdown_visibility(self):
+        has_raw = len(self.sm.raw_datas) > 0
+        has_expt = len(self.sm.expt_datas) > 0
+        
+        if hasattr(self, "raw_data_dropdown_button"):
+            self.raw_data_dropdown_button.visible = has_raw
+        if hasattr(self, "expt_data_dropdown_button"):
+            self.expt_data_dropdown_button.visible = has_expt
+        if hasattr(self, "rename_expt_button"):
+            self.rename_expt_button.visible = has_expt
+        if hasattr(self, "duplicate_expt_button"):
+            self.duplicate_expt_button.visible = has_expt
+
+    def generate_dropdowns(self, e=None):
+        """Generate the dropdowns for selecting raw datasets and data models."""
+        self.update_dropdown_visibility()
+        
+        if hasattr(self, "raw_data_dropdown_button"):
+            self.raw_data_dropdown_button.clear()
+            active_raw = self.sm.active_raw_data_or_none
+            if active_raw is not None:
+                self.raw_data_dropdown_button.set_text(active_raw.filename)
+            else:
+                self.raw_data_dropdown_button.set_text("Choose raw dataset")
+                
+            if len(self.sm.raw_datas) > 0:
+                with self.raw_data_dropdown_button:
+                    for raw in list(self.sm.raw_datas.values()):
+                        ui.item(raw.filename, on_click=lambda e, raw=raw: self.load_raw_data(raw))
+
+        if hasattr(self, "expt_data_dropdown_button"):
+            self.expt_data_dropdown_button.clear()
+            active_expt = self.sm.active_expt_data_or_none
+            active_raw = self.sm.active_raw_data_or_none
+            
+            if active_expt is not None:
+                self.expt_data_dropdown_button.set_text(active_expt.name)
+            else:
+                self.expt_data_dropdown_button.set_text("Choose data model")
+                
+            if active_raw is not None:
+                # Filter interpretations to only those belonging to the active raw dataset
+                matching_expts = [
+                    expt for expt in self.sm.expt_datas.values()
+                    if expt.raw_data_id == active_raw.id
+                ]
+                if matching_expts:
+                    with self.expt_data_dropdown_button:
+                        for expt in matching_expts:
+                            with ui.row().classes("p-1 items-center justify-between w-full no-wrap"):
+                                ui.item(expt.name, on_click=lambda e, expt=expt: self.load_expt_data(expt)).classes("flex-grow min-w-0")
+                                ui.icon("delete").on("click", lambda e, expt=expt: self.delete_expt_data(expt)).classes(
+                                    "cursor-pointer text-red-600 flex-shrink-0 self-center"
+                                ).tooltip("Delete data model")
+
+    def load_raw_data(self, raw):
+        self.sm.active_raw_data_id = raw.id
+        self.sm.reconcile_active_context(reason="load_raw_data", emit_events=True)
+        self.sm.notify_listeners("active_context_changed")
+        self.sm.notify_listeners("data_imported")
+
+    def load_expt_data(self, expt):
+        self.sm.active_expt_data_id = expt.id
+        self.sm.active_raw_data_id = expt.raw_data_id
+        
+        active_fit = self.sm.active_fit_or_none
+        if active_fit is None or active_fit.expt_data_id != expt.id:
+            self.sm.active_fit_id = None
+            for f in reversed(list(self.sm.fits.values())):
+                if f.expt_data_id == expt.id:
+                    self.sm.active_fit_id = f.id
+                    break
+
+        self.sm.reconcile_active_context(reason="load_expt_data", emit_events=True)
+        self.sm.notify_listeners("active_context_changed")
+        self.sm.notify_listeners("data_imported")
+
+    def delete_expt_data(self, expt):
+        self.sm.delete_expt_data(expt)
+        self.sm.notify_listeners("data_imported")
+
+    def get_next_version_name(self, base_name: str, existing_names: list[str]) -> str:
+        """Return the next incremented version name for base_name."""
+        match = re.search(r" v(\d+)$", base_name)
+        if match:
+            version = int(match.group(1))
+            prefix = base_name[:match.start()]
+        else:
+            version = 1
+            prefix = base_name
+        
+        new_version = version + 1
+        candidate = f"{prefix} v{new_version}"
+        while candidate in existing_names:
+            new_version += 1
+            candidate = f"{prefix} v{new_version}"
+        return candidate
+
+    def _clone_expt_data(self, old_expt: ExptData, new_name: str) -> ExptData:
+        """Return a copy of old_expt with a new UUID and name, linked to the same model and raw data."""
+        from ..classes import ChemicalShiftParam
+        d = old_expt.to_dict()
+        d["id"] = str(uuid.uuid4())
+        d["name"] = new_name
+        limiting_shifts_raw = d.pop("limiting_shifts", []) or []
+        new_expt = ExptData(**d)
+        new_expt.limiting_shifts = {}
+        for cs in limiting_shifts_raw:
+            csp = ChemicalShiftParam(**cs)
+            key = (csp.species, csp.col)
+            new_expt.limiting_shifts[key] = csp
+        new_expt.find_and_link_model(self.sm.models)
+        new_expt.find_and_link_raw_data(self.sm.raw_datas)
+        return new_expt
+
+    def duplicate_active_expt(self):
+        active_expt = self.sm.active_expt_data_or_none
+        if active_expt is not None:
+            # Clone active_expt to create a new version
+            existing_names = [ed.name for ed in self.sm.expt_datas.values()]
+            new_name = self.get_next_version_name(active_expt.name, existing_names)
+            target = self._clone_expt_data(active_expt, new_name)
+            
+            # Reconcile target matrices to align with its current columns
+            target.reconcile_matrices()
+            
+            # Add to StateManager and set as active
+            self.sm.add_expt_data(target)
+            ui.notify(f"Configuration duplicated as '{new_name}'.", type="positive")
+            self.sm.notify_listeners("data_imported")
+        else:
+            ui.notify("No active data model to duplicate.", type="warning")
+
+    async def rename_active_expt(self):
+        active_expt = self.sm.active_expt_data_or_none
+        if active_expt is not None:
+            with ui.dialog() as dialog, ui.card().classes("w-96"):
+                ui.label("Rename Data Model").classes("font-semibold text-lg")
+                name_input = ui.input("Data model name", value=active_expt.name).classes("w-full")
+                with ui.row().classes("justify-end gap-2 mt-2"):
+                    ui.button("Cancel", on_click=lambda: dialog.submit(None)).props("flat")
+                    ui.button("Rename", on_click=lambda: dialog.submit(name_input.value)).props("color=primary")
+            result = await dialog
+            if result is not None and result.strip() != "":
+                new_name = result.strip()
+                if new_name != active_expt.name:
+                    active_expt.name = new_name
+                    self.sm.save_to_storage()
+                    ui.notify(f"Data model renamed to '{new_name}'.", type="positive")
+                    self.sm.notify_listeners("active_context_changed")
+                    self.sm.notify_listeners("data_imported")
+        else:
+            ui.notify("No active data model to rename.", type="warning")

{bindmc-0.1.7 → bindmc-0.1.9}/src/bindmc/webgui/components/graph.py

@@ -210,8 +210,9 @@ class Graph(BaseComponent):
             raise ValueError("run_id cannot be None")
             # run_id = str(uuid.uuid4())
 
-        self.data_frames[str(run_id)] = (x, y)  # Store the original x and y data for later use
-        self.line_styles[str(run_id)] = scatter
+        df_key = f"{run_id}-{scatter}"
+        self.data_frames[df_key] = (x, y)  # Store the original x and y data for later use
+        self.line_styles[df_key] = scatter
 
         for ii, col in enumerate(x.columns):
             self.add_comp_name(col)
@@ -227,6 +228,7 @@ class Graph(BaseComponent):
                 "trace_id": str(run_id)  # is the uuid for the fit/etc
                 + "-"
                 + col,  # Unique trace ID for this simulation
+                "df_key": df_key,
                 "visible": True,
                 #'legendgroup': self.sm.modelName,
                 #'legendgrouptitle': dict(text=self.sm.modelName)
@@ -271,8 +273,9 @@ class Graph(BaseComponent):
         # y DataFrame includes species concentrations
         y_df = df[spec_cols] if spec_cols else pd.DataFrame()
 
-        self.data_frames[str(run_id)] = (x_df, y_df)
-        self.line_styles[str(run_id)] = scatter
+        df_key = f"{run_id}-{scatter}"
+        self.data_frames[df_key] = (x_df, y_df)
+        self.line_styles[df_key] = scatter
 
         for ii, col in enumerate(df.columns):
             if col.endswith("_tot"):
@@ -289,7 +292,8 @@ class Graph(BaseComponent):
                     "y": df[col].tolist(),
                     "name": run_name[:GRAPH_LEGEND_TITLE_W] + " " + col,
                     "species": col,
-                    "trace_id": run_id + "-" + col,  # Unique trace ID for this simulation
+                    "trace_id": str(run_id) + "-" + col,  # Unique trace ID for this simulation
+                    "df_key": df_key,
                     "visible": True,
                     #'legendgroup': self.sm.modelName,
                     #'legendgrouptitle': dict(text=self.sm.modelName)
@@ -317,7 +321,8 @@ class Graph(BaseComponent):
                     "y": df[col].tolist(),
                     "name": run_name[:GRAPH_LEGEND_TITLE_W] + " " + col,
                     "species": col,
-                    "trace_id": run_id + "-" + col,  # Unique trace ID for this simulation
+                    "trace_id": str(run_id) + "-" + col,  # Unique trace ID for this simulation
+                    "df_key": df_key,
                     "visible": True,
                     #'legendgroup': self.sm.modelName,
                     #'legendgrouptitle': dict(text=self.sm.modelName)
@@ -485,11 +490,15 @@ if (!plot || typeof Plotly === 'undefined') {{
 
         throw_warning = False
         for d in self.graph_data["data"]:
-            run_id = "-".join(d["trace_id"].split("-", 5)[0:5])  # Get the simulation ID from the trace_id
-            if run_id not in self.data_frames.keys():
-                ui.notify("Data not found for trace ID: " + run_id, type="warning")
+            df_key = d.get("df_key")
+            if df_key is None:
+                run_id = "-".join(d["trace_id"].split("-", 5)[0:5])
+                df_key = run_id
+
+            if df_key not in self.data_frames:
+                ui.notify("Data not found for trace: " + d.get("name", ""), type="warning")
                 continue
-            x_df = self.data_frames[run_id][0]
+            x_df = self.data_frames[df_key][0]
             x_cols = x_df.columns
 
             if numName == X_AXIS_ROW_INDEX:
@@ -497,22 +506,22 @@ if (!plot || typeof Plotly === 'undefined') {{
                 continue
             if numName not in x_cols:
                 ui.notify(
-                    f"Numerator '{numName}' not found in simulation data for trace ID: {run_id}",
+                    f"Numerator '{numName}' not found in simulation data for trace: {d.get('name', '')}",
                     type="warning",
                 )
                 continue
 
             if deNomName != 1 and deNomName not in x_cols:
                 ui.notify(
-                    f"Denomination '{deNomName}' not found in simulation data for trace ID: {run_id}",
+                    f"Denomination '{deNomName}' not found in simulation data for trace: {d.get('name', '')}",
                     type="warning",
                 )
                 continue
 
             if deNomName == 1 or deNomName is None:
-                d["x"] = self.data_frames[run_id][0][numName].tolist()
+                d["x"] = self.data_frames[df_key][0][numName].tolist()
             else:
-                d["x"] = (self.data_frames[run_id][0][numName] / self.data_frames[run_id][0][deNomName]).tolist()
+                d["x"] = (self.data_frames[df_key][0][numName] / self.data_frames[df_key][0][deNomName]).tolist()
 
         self.graph_data.setdefault("layout", {})
         self.graph_data["layout"].setdefault("xaxis", {})
@@ -554,12 +563,16 @@ if (!plot || typeof Plotly === 'undefined') {{
         normalize = hasattr(self, "chkNormalizeY") and bool(self.chkNormalizeY.value)
 
         for d in self.graph_data["data"]:
-            trace_id = d.get("trace_id", "")
-            run_id = "-".join(trace_id.split("-", 5)[0:5])
-            if run_id not in self.data_frames:
+            df_key = d.get("df_key")
+            if df_key is None:
+                trace_id = d.get("trace_id", "")
+                run_id = "-".join(trace_id.split("-", 5)[0:5])
+                df_key = run_id
+
+            if df_key not in self.data_frames:
                 continue
 
-            x_df, y_df = self.data_frames[run_id]
+            x_df, y_df = self.data_frames[df_key]
             species = d.get("species")
             y_values = None
             if species in y_df.columns:
@@ -660,10 +673,14 @@ if (!plot || typeof Plotly === 'undefined') {{
             run_id = str(run_id.id)
 
         """Remove data for a specific run_id from the graph."""
-        if run_id in self.data_frames:
-            del self.data_frames[run_id]
-        if run_id in self.line_styles:
-            del self.line_styles[run_id]
+        # Delete matching keys from data_frames and line_styles
+        keys_to_delete = [k for k in self.data_frames if k.startswith(run_id)]
+        for k in keys_to_delete:
+            del self.data_frames[k]
+
+        line_style_keys_to_delete = [k for k in self.line_styles if k.startswith(run_id)]
+        for k in line_style_keys_to_delete:
+            del self.line_styles[k]
 
         # Remove traces from the graph data
         self.graph_data["data"] = [d for d in self.graph_data["data"] if not d["trace_id"].startswith(run_id)]

{bindmc-0.1.7 → bindmc-0.1.9}/src/bindmc/webgui/state/statemanager.py

@@ -381,6 +381,18 @@ class StateManager:
                 del self.expt_datas[obj.id]
                 if self._active_expt_data_id == obj.id:
                     self._active_expt_data_id = None
+                
+                # Check if this was the last exptdata associated with its rawdata
+                raw_data = self.raw_datas.get(obj.raw_data_id)
+                if raw_data is not None:
+                    remaining_expts = [expt for expt in self.expt_datas.values() if expt.raw_data_id == raw_data.id]
+                    if len(remaining_expts) == 0:
+                        try:
+                            model = self.active_model
+                        except IndexError:
+                            model = None
+                        new_expt = ExptData(name=raw_data.filename, init_raw_data=raw_data, init_model=model)
+                        self.add_expt_data(new_expt, emit_events=False)
         elif isinstance(obj, RawData):
             if obj.id in self.raw_datas:
                 del self.raw_datas[obj.id]