bindmc 0.1.6__tar.gz → 0.1.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bindmc
-Version: 0.1.6
+Version: 0.1.7
 Keywords: chemistry,analytical chemistry,binding constants,supramolecular
 Author: Martin Peeks
 Author-email: Martin Peeks <martinp23@googlemail.com>, m.peeks@unsw.edu.au
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Requires-Dist: arviz==0.21.0
-Requires-Dist: bindtools>=0.2.1
+Requires-Dist: bindtools>=0.2.2
 Requires-Dist: corner==2.2.3
 Requires-Dist: emcee==3.1.6
 Requires-Dist: h5py>=3.14.0
@@ -53,6 +53,16 @@ Download the latest executable for your platform from the [Releases](https://git
 pip install bindmc
 ```
 
+## Upgrades
+
+### Pre-built Binary
+Re-download from the link above. 
+
+### Pip
+```bash
+pip install --upgrade bindmc
+```
+
 ## Usage
 
 If using the pre-built binary, run the downloaded executable.

{bindmc-0.1.6 → bindmc-0.1.7}/README.md

@@ -15,6 +15,16 @@ Download the latest executable for your platform from the [Releases](https://git
 pip install bindmc
 ```
 
+## Upgrades
+
+### Pre-built Binary
+Re-download from the link above. 
+
+### Pip
+```bash
+pip install --upgrade bindmc
+```
+
 ## Usage
 
 If using the pre-built binary, run the downloaded executable.

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "bindmc"
-version = "0.1.6"
+version = "0.1.7"
 readme = "README.md"
 keywords = ["chemistry", "analytical chemistry", "binding constants", "supramolecular"]
 classifiers = [
@@ -28,7 +28,7 @@ classifiers = [
 requires-python = ">=3.12"
 dependencies = [
     "arviz==0.21.0",
-    "bindtools>=0.2.1",
+    "bindtools>=0.2.2",
     "corner==2.2.3",
     "emcee==3.1.6",
     "h5py>=3.14.0",

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

@@ -443,7 +443,7 @@ class ExptData:
                     species_key = species_names[j]
                     parameter_matrix[i, j] = _get_parameter_for_species(species_key, delta_col)
                 else:
-                    parameter_matrix[i, j] = 0.0
+                    parameter_matrix[i, j] = None
 
         self.delta_to_spec = parameter_matrix
         return parameter_matrix

{bindmc-0.1.6 → bindmc-0.1.7}/src/bindmc/webgui/classes/FitResult.py

@@ -30,8 +30,6 @@ class FitResult:
     bd_model: Optional[bd.bindingModel] = None
     analytical_fast_exchange: bool = False
     analytical_topology: Optional[str] = None
-    analytical_obs_columns: list[str] = field(default_factory=list)
-    analytical_obs_components: list[int] = field(default_factory=list)
     analytical_complex_indices: list[int] = field(default_factory=list)
 
     init_model: InitVar[Optional[Model]] = None  # The model used for the fit, if any
@@ -150,8 +148,6 @@ class FitResult:
             "success": self.success,
             "analytical_fast_exchange": self.analytical_fast_exchange,
             "analytical_topology": self.analytical_topology,
-            "analytical_obs_columns": list(self.analytical_obs_columns),
-            "analytical_obs_components": list(self.analytical_obs_components),
             "analytical_complex_indices": list(self.analytical_complex_indices),
             "fit_speciation": (
                 self.fit_speciation.to_dict(orient="list") if isinstance(self.fit_speciation, pd.DataFrame) else {}

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

@@ -140,14 +140,15 @@ class DataModelPanel(BaseComponent):
 
         with self.dataModel_specInteg_block:
             self.spec_integ_inps: dict[str, ui.input] = {}
+            self.spec_integ_cbs: dict[str, ui.checkbox] = {}
             for i, spec in enumerate(self.sm.species):
                 with ui.row().classes("items-center"):
                     ui.label(f"Species conc. [{spec}]_free:")
                     self.spec_integ_inps[spec] = ui.input().classes("flex-1").props("clearable")
 
                     self.spec_integ_inps[spec].on("blur", lambda c=self.spec_integ_inps[spec]: self.set_focus(c))
-                    b = ui.checkbox("Enabled", value=True).props(f"testid=spec-enabled-{spec}")
-                    self.spec_integ_inps[spec].bind_enabled_from(b, "value")
+                    self.spec_integ_cbs[spec] = ui.checkbox("Enabled", value=True).props(f"testid=spec-enabled-{spec}")
+                    self.spec_integ_inps[spec].bind_enabled_from(self.spec_integ_cbs[spec], "value")
                     if (
                         hasattr(active_expt, "integ_to_spec")
                         and active_expt.integ_to_spec is not None
@@ -157,9 +158,9 @@ class DataModelPanel(BaseComponent):
                             active_expt.integ_to_spec[i], active_expt.columns
                         )
                         if self.spec_integ_inps[spec].value == "":
-                            b.value = False
+                            self.spec_integ_cbs[spec].value = False
                     else:
-                        b.value = False
+                        self.spec_integ_cbs[spec].value = False
 
     def _gen_spec_fast_exchange_block(self):
         """Generate the species fast exchange block.
@@ -227,95 +228,94 @@ class DataModelPanel(BaseComponent):
         self.fast_ex_chem_shift_params = []
         # map per spec-delta index -> { species_name: {card, shift_num, fixed_cb, min_num, max_num} }
         self.fast_ex_chem_shift_map = []
+        self.specDeltaCbs = []
 
         # keep the fast-exchange column names for later processing and bindings
         self.fast_ex_list_names = list(fast_ex_list)
-        if len(extra_deps) > 0:
-            with self.dataModel_specFastExchange_block:
-                # species_list = [f'{x}_free' for x in self.sm.species]
-
-                # default_shift_species = _default_analytical_shift_species(
-                #     self.sm.active_model.eq_mat,
-                #     list(self.sm.active_model.component_names),
-                #     species_list,
-                #     len(self.fast_ex_list_names),
-                # )
-                # if default_shift_species is not None:
-                #     ui.label(
-                #         f"Analytical model detected: defaulting fast-exchange expression to [{default_shift_species}] "
-                #         "for this observable. You can edit it if needed."
-                #     ).classes("text-xs text-gray-600")
-
-                for i, shift in enumerate(self.fast_ex_list_names):
-                    # card per chemical shift column
-                    card = ui.card().classes("mb-2")
-                    self.specDeltaCards.append(card)
-                    with card:
-                        ui.label(f"Fast exchange shift {i + 1} ({shift})").classes("text-sm font-semibold")
-                        with ui.row().classes("items-center"):
-                            inp = ui.input().classes("flex-1").props("clearable")
-                            self.specDeltaInps.append(inp)
-                            # species chips row will be added below the input to allow quick insertion
-                            with ui.row().classes("gap-1 mt-2"):
-                                for text in [f"{x}_free" for x in self.sm.species]:
-                                    ui.chip(
-                                        text,
-                                        color="teal",
-                                        on_click=lambda h=text: self._insert_species_into_fast_inp(h),
-                                    )
-                            # placeholder checkbox to enable the input
-                            en_cb = ui.checkbox("Enabled", value=True)
-                            inp.bind_enabled_from(en_cb, "value")
-                            # placeholder param block element (initially empty/hidden)
-                            pb = ui.element()
-                            self.fast_ex_chem_shift_blocks.append(pb)
-                            self.fast_ex_chem_shift_map.append({})
-                            # store param dict for later
-                            # self.fast_ex_chem_shift_params.append({'shift': None, 'fixed': False, 'min': None, 'max': None})
-
-                            # bind blur handler to create/update parameter block
-                            # use default args to capture current inp and index
-                            # allow chips/clicks to insert into this input by remembering last focus
-                            inp.on("focus", lambda e, widget=inp: self.set_focus(widget))
-                            inp.on("click", lambda e, widget=inp: self.set_focus(widget))
-                            # handle blur to create/update parameter sub-blocks
-                            inp.on("blur", lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
-                            # immediate change handler: reparse on every change
-                            inp.on_value_change(lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
-
-                            # if there is saved delta_to_spec data, populate the input
-                            if (
-                                hasattr(active_expt, "delta_to_spec")
-                                and active_expt.delta_to_spec is not None
-                                and len(active_expt.delta_to_spec) > 0
-                            ):
-                                delta_for_eqn = active_expt.delta_to_spec[i].copy()
-
-                                for ij, el in enumerate(delta_for_eqn):
-                                    if np.isclose(el, 0):
-                                        delta_for_eqn[ij] = 0
-                                    else:
-                                        if (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
-                                            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
-
-                                value = self.vec_to_conc_expression(
-                                    delta_for_eqn, [f"{x}_free" for x in self.sm.species]
+        with self.dataModel_specFastExchange_block:
+            # species_list = [f'{x}_free' for x in self.sm.species]
+
+            default_shift_species = None
+            if simple_model is not None and len(simple_model[1]) > 0:
+                default_shift_species = f"{self.sm.species[simple_model[1][0]]}_free"
+
+            if default_shift_species is not None:
+                ui.label(
+                    f"Analytical model detected: defaulting fast-exchange expression to [{default_shift_species}] "
+                    "for this observable. You can edit it if needed."
+                ).classes("text-xs text-gray-600")
+
+            for i, shift in enumerate(self.fast_ex_list_names):
+                # card per chemical shift column
+                card = ui.card().classes("mb-2")
+                self.specDeltaCards.append(card)
+                with card:
+                    ui.label(f"Fast exchange shift {i + 1} ({shift})").classes("text-sm font-semibold")
+                    with ui.row().classes("items-center"):
+                        inp = ui.input().classes("flex-1").props("clearable")
+                        self.specDeltaInps.append(inp)
+                        # species chips row will be added below the input to allow quick insertion
+                        with ui.row().classes("gap-1 mt-2"):
+                            for text in [f"{x}_free" for x in self.sm.species]:
+                                ui.chip(
+                                    text,
+                                    color="teal",
+                                    on_click=lambda h=text: self._insert_species_into_fast_inp(h),
                                 )
-                                inp.value = value
-                                if value == "":
-                                    en_cb.value = False
-                            # elif default_shift_species is not None:
-                            #     inp.value = f"[{default_shift_species}]"
-                            #     # Build corresponding ChemicalShiftParam widgets immediately.
-                            #     self._handle_spec_delta_blur(i, inp)
+                        # placeholder checkbox to enable the input
+                        en_cb = ui.checkbox("Enabled", value=True)
+                        self.specDeltaCbs.append(en_cb)
+                        inp.bind_enabled_from(en_cb, "value")
+                        # placeholder param block element (initially empty/hidden)
+                        pb = ui.element()
+                        self.fast_ex_chem_shift_blocks.append(pb)
+                        self.fast_ex_chem_shift_map.append({})
+                        # store param dict for later
+                        # self.fast_ex_chem_shift_params.append({'shift': None, 'fixed': False, 'min': None, 'max': None})
+
+                        # bind blur handler to create/update parameter block
+                        # use default args to capture current inp and index
+                        # allow chips/clicks to insert into this input by remembering last focus
+                        inp.on("focus", lambda e, widget=inp: self.set_focus(widget))
+                        inp.on("click", lambda e, widget=inp: self.set_focus(widget))
+                        # handle blur to create/update parameter sub-blocks
+                        inp.on("blur", lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
+                        # immediate change handler: reparse on every change
+                        inp.on_value_change(lambda e, idx=i, widget=inp: self._handle_spec_delta_blur(idx, widget))
+
+                        # if there is saved delta_to_spec data, populate the input
+                        if (
+                            hasattr(active_expt, "delta_to_spec")
+                            and active_expt.delta_to_spec is not None
+                            and len(active_expt.delta_to_spec) > 0
+                        ):
+                            delta_for_eqn = active_expt.delta_to_spec[i].copy()
+
+                            for ij, el in enumerate(delta_for_eqn):
+                                if np.isclose(el, 0):
+                                    delta_for_eqn[ij] = 0
+                                else:
+                                    if (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
+                                        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
+
+                            value = self.vec_to_conc_expression(
+                                delta_for_eqn, [f"{x}_free" for x in self.sm.species]
+                            )
+                            inp.value = value
+                            if value == "":
+                                en_cb.value = False
+                        elif default_shift_species is not None:
+                            inp.value = f"[{default_shift_species}]"
+                            # Build corresponding ChemicalShiftParam widgets immediately.
+                            self._handle_spec_delta_blur(i, inp)
 
         # finished generating fast-exchange block
 
@@ -371,6 +371,14 @@ class DataModelPanel(BaseComponent):
                 if not isinstance(cs_obj, ChemicalShiftParam):
                     # create with safe defaults
                     cs_obj = ChemicalShiftParam(species=spec_name, col=col_name, fixed=False)
+                    try:
+                        if hasattr(active_expt, "data") and active_expt.data is not None and col_name in active_expt.data.columns:
+                            first_val = float(active_expt.data[col_name].dropna().iloc[0])
+                            cs_obj.value = round(first_val, 4)
+                            cs_obj._min = round(first_val - 1.0, 4)
+                            cs_obj._max = round(first_val + 1.0, 4)
+                    except Exception:
+                        pass
                     active_expt.limiting_shifts[k] = cs_obj
 
                 # reuse if exists
@@ -463,10 +471,10 @@ class DataModelPanel(BaseComponent):
             target.integ_to_spec = None
         else:
             integ_to_spec = [
-                self.conc_expression_to_vec(input.value, target.columns)
-                if input.enabled
+                self.conc_expression_to_vec(self.spec_integ_inps[spec].value, target.columns)
+                if self.spec_integ_cbs[spec].value
                 else np.zeros(len(target.columns))
-                for input in self.spec_integ_inps.values()
+                for spec in self.sm.species
             ]
             integ_to_spec = np.array(integ_to_spec)
             if integ_to_spec.size == 0 or np.all(np.isclose(integ_to_spec, 0)):
@@ -483,9 +491,9 @@ class DataModelPanel(BaseComponent):
         if hasattr(self, "specDeltaInps") and isinstance(self.specDeltaInps, list) and len(self.specDeltaInps) > 0:
             species_label_list = [f"{s}_free" for s in self.sm.species]
             for idx, input_widget in enumerate(self.specDeltaInps):
+                cb = self.specDeltaCbs[idx]
                 if (
-                    hasattr(input_widget, "enabled")
-                    and input_widget.enabled
+                    cb.value
                     and isinstance(input_widget.value, str)
                     and input_widget.value.strip()
                 ):

{bindmc-0.1.6 → bindmc-0.1.7}/src/bindmc/webgui/components/fitting.py

@@ -132,8 +132,6 @@ def _infer_analytical_fast_exchange_config(model, expt_data, expt_dtypes: dict)
         return {
             "topology": topo_name,
             "complex_indices": complex_indices,
-            "obs_columns": [],  # no NMR shift columns
-            "obs_components": [],
         }
 
     # Pure NMR shift path (existing behaviour).
@@ -146,85 +144,9 @@ def _infer_analytical_fast_exchange_config(model, expt_data, expt_dtypes: dict)
         if finite.size > 0 and np.any(~np.isclose(finite, 0.0)):
             return None
 
-    component_free_labels = [f"{name}_free" for name in model.component_names]
-    if len(component_free_labels) != 2:
-        return None
-
-    # Build optional hints from existing user mappings when available.
-    shift_species_by_col: dict[str, set[str]] = {}
-    if isinstance(expt_data.limiting_shifts, dict):
-        for (species, col_name), _ in expt_data.limiting_shifts.items():
-            if col_name is None:
-                continue
-            shift_species_by_col.setdefault(str(col_name), set()).add(str(species))
-
-    delta_species_hints: dict[str, set[str]] = {}
-    delta_to_spec = expt_data.delta_to_spec
-    if isinstance(delta_to_spec, np.ndarray) and delta_to_spec.ndim == 2 and delta_to_spec.size > 0:
-        # In this UI flow, delta_to_spec rows are created from fast-exchange observable columns.
-        # For analytical mode all dependent observables are shift observables, so the row order
-        # corresponds to obs_list.
-        n_rows = min(delta_to_spec.shape[0], len(obs_list))
-        n_species = min(delta_to_spec.shape[1], len(component_free_labels))
-        for ridx in range(n_rows):
-            col_name = obs_list[ridx]
-            for sidx in range(n_species):
-                try:
-                    is_nonzero = not np.isclose(float(delta_to_spec[ridx, sidx]), 0.0)
-                except Exception:
-                    is_nonzero = bool(delta_to_spec[ridx, sidx])
-                if is_nonzero:
-                    delta_species_hints.setdefault(col_name, set()).add(component_free_labels[sidx])
-
-    def _component_from_text_hints(col_name: str, dtype_key: str | None) -> int | None:
-        # Tokenize to avoid over-matching short component names in arbitrary strings.
-        tokens = []
-        for src in (col_name, dtype_key or ""):
-            parts = [t for t in re.split(r"[^A-Za-z0-9]+", str(src).lower()) if t]
-            tokens.extend(parts)
-        matches = [idx for idx, comp in enumerate(model.component_names) if str(comp).lower() in tokens]
-        return matches[0] if len(matches) == 1 else None
-
-    obs_components: list[int] = []
-    unresolved: list[tuple[int, str]] = []
-    for obs_idx, col in enumerate(obs_list):
-        col_meta = expt_data.col_details.get(col, {})
-        dtype_key = col_meta.get("dtype")
-
-        included_species = set()
-        included_species |= shift_species_by_col.get(col, set())
-        included_species |= delta_species_hints.get(col, set())
-
-        has_comp0 = component_free_labels[0] in included_species
-        has_comp1 = component_free_labels[1] in included_species
-        if has_comp0 != has_comp1:
-            obs_components.append(0 if has_comp0 else 1)
-            continue
-
-        inferred = _component_from_text_hints(col, dtype_key)
-        if inferred is not None:
-            obs_components.append(inferred)
-            continue
-
-        unresolved.append((obs_idx, col))
-        obs_components.append(-1)
-
-    # Final fallback keeps analytical mode enabled even without manual shift metadata.
-    if unresolved:
-        for obs_idx, col in unresolved:
-            fallback = obs_idx % len(component_free_labels)
-            obs_components[obs_idx] = fallback
-            logger.info(
-                "Analytical fast-exchange: inferred observable '%s' as component %d by default fallback.",
-                col,
-                fallback,
-            )
-
     return {
         "topology": topo_name,
         "complex_indices": complex_indices,
-        "obs_columns": list(obs_list),
-        "obs_components": obs_components,
     }
 
 
@@ -237,9 +159,9 @@ class FittingPanel(BaseComponent):
             ui.label("Fitting panel").classes("text-lg font-bold mb-4")
             with ui.row().classes("w-full gap-4 items-start flex-col lg:flex-row"):
                 with ui.card().classes("w-full lg:w-80 shrink-0"):
-                    ui.label("Fitting options to go here.")
+                    # ui.label("Fitting options to go here.")
                     self.fit_alg_select = ui.select(
-                        ["least_squares", "l-bfgs", "ampgo"],
+                        ["least_squares", "l-bfgs", "l-bfgs-b", "nelder-mead", "ampgo"],
                         label="Algorithm",
                         on_change=lambda e: print(f"Selected: {e.value}"),
                         value="least_squares",
@@ -494,8 +416,6 @@ class FittingPanel(BaseComponent):
                 bd_model=self.m1,
                 analytical_fast_exchange=self.m1.analytical_fast_exchange,
                 analytical_topology=self.m1.analytical_topology,
-                analytical_obs_columns=[str(x) for x in self.m1.analytical_obs_columns],
-                analytical_obs_components=[int(x) for x in self.m1.analytical_obs_components],
                 analytical_complex_indices=self.m1.analytical_complex_indices,
             )
             self.sm.add_fit(new_fit)
@@ -510,6 +430,11 @@ class FittingPanel(BaseComponent):
                     "initial_value": v.init_value,
                 }
 
+            print("DEBUG: specToInteg =", self.sm.active_expt_data.integ_to_spec)
+            print("DEBUG: specToDd =", self.sm.active_expt_data.delta_to_spec)
+            print("DEBUG: obsList =", self.m1.obsList)
+            print("DEBUG: calc_obs shape =", np.shape(calc_obs))
+
             self.sm.active_fit.calc_obs = pd.DataFrame(calc_obs, columns=self.m1.obsList)
 
             self.sm.active_fit.fit_speciation = pd.DataFrame(speciation, columns=[x + "_free" for x in self.sm.species])
@@ -800,7 +725,7 @@ class FitResultsCard(BaseComponent):
         for fit in self.sm.fits.values():
             row = {
                 "name": fit.name,
-                "chisqr": self.rounded_value(fit.chisqr),
+                "chisqr": self.rounded_value(fit.chisqr,scientific=True),
                 "aic": self.rounded_value(fit.aic, dp=1),
                 "bic": self.rounded_value(fit.bic, dp=1),
                 "message": fit.termination_message,
@@ -817,10 +742,10 @@ class FitResultsCard(BaseComponent):
         self.add_body_slot()
         self.table.update()
 
-    def rounded_value(self, value: float, dp: int = 3) -> str:
+    def rounded_value(self, value: float, dp: int = 3, scientific=False) -> str:
         """Round the value for display."""
-        if abs(value) >= 10000 or abs(value) < 0.001:
-            return f"{value:.4e}"
+        if abs(value) >= 10000 or abs(value) < 0.001 or scientific:
+            return f"{value:.3e}"
         else:
             return f"{value:.{dp}f}" if isinstance(value, float) else str(value)
 

{bindmc-0.1.6 → bindmc-0.1.7}/src/bindmc/webgui/export/notebook_exporter.py

@@ -239,17 +239,7 @@ def _build_lin_obs_cell4_lines(
     return lines
 
 
-def _build_analytical_lin_obs_lines(lin_obs_param_map: list) -> list[str]:
-    """Return setup lines for the analytical path's linear_obs_param_map.
 
-    Extracts the param name (or None) from each cell so
-    fitfun_analytical_fast_exchange can call calc_analytical_linear_observables.
-    """
-    # Serialise as [[name_or_none, ...], ...]
-    name_map = [[cell["name"] if cell is not None else None for cell in row] for row in lin_obs_param_map]
-    return [
-        f"m.analytical_linear_obs_param_map = {name_map!r}",
-    ]
 
 
 def export_fit_notebook(
@@ -382,7 +372,31 @@ def export_fit_notebook(
         spec_to_integ_arg = "None"
 
     if has_delta:
-        spec_to_dd_line = f"spec_to_dd = np.array({delta_to_spec.T.tolist()!r}, dtype=object)"
+        # Build spec_to_dd reconstruction lines dynamically to properly instantiate lmfit.Parameters
+        spec_to_dd_lines = [
+            "spec_to_dd = np.empty((len(species_names), len(obs_list)), dtype=object)"
+        ]
+        delta_T = delta_to_spec.T
+        for i in range(delta_T.shape[0]):
+            for j in range(delta_T.shape[1]):
+                cell = delta_T[i, j]
+                if cell is None:
+                    spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = None")
+                elif isinstance(cell, (int, float, np.floating)):
+                    if np.isnan(cell):
+                        spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = None")
+                    else:
+                        spec_to_dd_lines.append(f"spec_to_dd[{i}, {j}] = {float(cell)!r}")
+                else: # lmfit.Parameter
+                    pname = getattr(cell, "name", "")
+                    pval = getattr(cell, "value", 0.0)
+                    pmin = getattr(cell, "min", -np.inf)
+                    pmax = getattr(cell, "max", np.inf)
+                    pvary = getattr(cell, "vary", True)
+                    spec_to_dd_lines.append(
+                        f"spec_to_dd[{i}, {j}] = lmfit.Parameter({pname!r}, value={pval!r}, min={pmin!r}, max={pmax!r}, vary={pvary!r})"
+                    )
+        spec_to_dd_line = "\n".join(spec_to_dd_lines)
         spec_to_dd_arg = "spec_to_dd"
     else:
         spec_to_dd_line = "spec_to_dd = None"
@@ -390,8 +404,6 @@ def export_fit_notebook(
 
     is_analytical = bool(getattr(fit, "analytical_fast_exchange", False))
     analytical_topology = getattr(fit, "analytical_topology", None)
-    analytical_obs_columns = list(getattr(fit, "analytical_obs_columns", []))
-    analytical_obs_components = list(getattr(fit, "analytical_obs_components", []))
     analytical_complex_indices = list(getattr(fit, "analytical_complex_indices", []))
 
     has_lin_obs = bool(lin_obs_col_names and lin_obs_param_map)
@@ -399,15 +411,11 @@ def export_fit_notebook(
     if is_analytical:
         analytical_setup_lines: list[str] = [
             "",
-            "# Analytical fast-exchange backend — must be configured before prepModel()",
+            "# Analytical fast-exchange speciation",
             "m.analytical_fast_exchange = True",
             f"m.analytical_topology = {analytical_topology!r}",
-            f"m.analytical_obs_columns = {analytical_obs_columns!r}",
-            f"m.analytical_obs_components = {analytical_obs_components!r}",
             f"m.analytical_complex_indices = {analytical_complex_indices!r}",
         ]
-        if has_lin_obs:
-            analytical_setup_lines += _build_analytical_lin_obs_lines(lin_obs_param_map)  # type: ignore[arg-type]
     else:
         analytical_setup_lines = []
 

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

@@ -1167,6 +1167,9 @@ class StateManager:
         fittemp = data.get("fits", [])  # List of fits
         if fittemp:
             for fit in fittemp:
+                # backward compatibility to load pre-0.1.7 fits
+                fit.pop("analytical_obs_columns",None)
+                fit.pop("analytical_obs_components",None)
                 fit_result = FitResult(**fit)
                 fit_result.fit_speciation = pd.DataFrame(fit.get("fit_speciation", {}))
                 fit_result.calc_obs = pd.DataFrame(fit.get("calc_obs", {}))
@@ -1233,7 +1236,7 @@ class StateManager:
                                 parameter.vary = bool(cell.get("vary", True))
                                 reconstructed_row.append(parameter)
                             elif cell is None:
-                                reconstructed_row.append(0.0)
+                                reconstructed_row.append(None)
                             elif isinstance(cell, (str, int, float)):
                                 try:
                                     reconstructed_row.append(float(cell))
@@ -1736,16 +1739,12 @@ bd.makeFitResidPlot(fit,plotMask=(0,1),ylabel='Chemical shift (ppm)')"""
             cfg = {
                 "topology": fit.analytical_topology,
                 "complex_indices": list(getattr(fit, "analytical_complex_indices", [])),
-                "obs_columns": list(getattr(fit, "analytical_obs_columns", [])),
-                "obs_components": list(getattr(fit, "analytical_obs_components", [])),
             }
 
         if cfg is not None:
             model.analytical_fast_exchange = True
             model.analytical_topology = str(cfg["topology"])
             model.analytical_complex_indices = [int(x) for x in cfg["complex_indices"]]  # type: ignore[index]
-            model.analytical_obs_columns = [str(x) for x in cfg["obs_columns"]]  # type: ignore[index]
-            model.analytical_obs_components = [int(x) for x in cfg["obs_components"]]  # type: ignore[index]
             logger.info(
                 "Using analytical fast-exchange backend (%s model) for fitting.",
                 model.analytical_topology,