molass-gui 0.1.0__tar.gz

molass_gui-0.1.0/.github/workflows/upload_to_pypi.yml

@@ -0,0 +1,42 @@
+name: Manual Upload Python Package to PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  pypi-publish:
+    name: upload release to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install build
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Set up git for pushing
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git
+
+      - name: Create and push version tag
+        run: |
+          VERSION=$(grep -m1 '^version' pyproject.toml | sed 's/version *= *//;s/"//g')
+          git tag "v$VERSION"
+          git push origin "v$VERSION"

molass_gui-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.eggs/

molass_gui-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: molass_gui
+Version: 0.1.0
+Summary: Tkinter GUI for Molass — initial estimate workflow
+Project-URL: Repository, https://github.com/biosaxs-dev/molass-gui
+Author: Molass Community
+Maintainer: Molass Community
+License: GNU General Public License v3.0
+Keywords: SEC-SAXS
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python
+Requires-Python: <3.15,>=3.9
+Requires-Dist: molass-legacy>=1.6.13
+Requires-Dist: molass>=1.0.5
+Description-Content-Type: text/markdown
+
+# molass-gui
+
+Tkinter GUI for [Molass](https://github.com/biosaxs-dev/molass-library) — progressive SEC-SAXS analysis workflow.
+
+## Five-phase workflow
+
+| Phase | Window | What happens |
+|---|---|---|
+| 1 Setup | Main window | Enter the data folder path |
+| 2 Naive View | `plot_compact` with baseline | Inspect raw data; enter number of components; click **Decompose** |
+| 3 Quick Optimization View | `plot_components` (EGH) | Review EGH decomposition; select column model; click **Upgrade** or **Skip** |
+| 4 Upgraded View | `plot_components` (column model) | Review upgraded decomposition; select method (BH/DE) and subprocess option; click **Rigorous Optimization…** |
+| 5 Rigorous Optimization View | 4-panel live monitor | Rg curve computed → initial score drawn → optimization starts automatically; **Terminate** button available |
+
+## Installation
+
+```
+pip install molass-gui
+```
+
+## Usage
+
+```
+molass-gui
+```
+
+Or during development (from the repository root):
+
+```
+py app.py
+```
+
+## Requirements
+
+- Python 3.9–3.14
+- [molass](https://pypi.org/project/molass/) ≥ 1.0.5
+- [molass_legacy](https://pypi.org/project/molass_legacy/) ≥ 1.6.13

molass_gui-0.1.0/README.md

@@ -0,0 +1,37 @@
+# molass-gui
+
+Tkinter GUI for [Molass](https://github.com/biosaxs-dev/molass-library) — progressive SEC-SAXS analysis workflow.
+
+## Five-phase workflow
+
+| Phase | Window | What happens |
+|---|---|---|
+| 1 Setup | Main window | Enter the data folder path |
+| 2 Naive View | `plot_compact` with baseline | Inspect raw data; enter number of components; click **Decompose** |
+| 3 Quick Optimization View | `plot_components` (EGH) | Review EGH decomposition; select column model; click **Upgrade** or **Skip** |
+| 4 Upgraded View | `plot_components` (column model) | Review upgraded decomposition; select method (BH/DE) and subprocess option; click **Rigorous Optimization…** |
+| 5 Rigorous Optimization View | 4-panel live monitor | Rg curve computed → initial score drawn → optimization starts automatically; **Terminate** button available |
+
+## Installation
+
+```
+pip install molass-gui
+```
+
+## Usage
+
+```
+molass-gui
+```
+
+Or during development (from the repository root):
+
+```
+py app.py
+```
+
+## Requirements
+
+- Python 3.9–3.14
+- [molass](https://pypi.org/project/molass/) ≥ 1.0.5
+- [molass_legacy](https://pypi.org/project/molass_legacy/) ≥ 1.6.13

molass_gui-0.1.0/app.py

@@ -0,0 +1,5 @@
+"""Thin launcher — allows `py app.py` during development."""
+from molass_gui.app import main
+
+if __name__ == "__main__":
+    main()

molass_gui-0.1.0/molass_gui/__init__.py

@@ -0,0 +1 @@
+"""molass-gui — Tkinter GUI for Molass initial estimate workflow."""

molass_gui-0.1.0/molass_gui/app.py

@@ -0,0 +1,82 @@
+"""molass-gui — Phase 1: data folder input."""
+import threading
+import tkinter as tk
+from tkinter import ttk, filedialog
+
+_DEFAULT_FOLDER = r"C:\Users\takahashi\PyTools\Data\20230705"
+
+
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Molass")
+        self.resizable(False, False)
+        self._build_ui()
+        self.protocol("WM_DELETE_WINDOW", self._quit)
+
+    def _quit(self):
+        import sys
+        self.destroy()
+        sys.exit(0)
+
+    def _build_ui(self):
+        f = ttk.Frame(self, padding=16)
+        f.pack(fill=tk.BOTH, expand=True)
+
+        ttk.Label(f, text="Data folder:").grid(row=0, column=0, sticky=tk.W, pady=4)
+        self._folder_var = tk.StringVar(value=_DEFAULT_FOLDER)
+        ttk.Entry(f, textvariable=self._folder_var, width=52).grid(
+            row=0, column=1, padx=6)
+        ttk.Button(f, text="Browse…", command=self._browse).grid(row=0, column=2)
+
+        self._btn = ttk.Button(f, text="Load", command=self._run)
+        self._btn.grid(row=1, column=0, columnspan=3, pady=10)
+
+        self._status_var = tk.StringVar(value="Ready.")
+        ttk.Label(f, textvariable=self._status_var, foreground="gray").grid(
+            row=2, column=0, columnspan=3, sticky=tk.W)
+
+    def _browse(self):
+        d = filedialog.askdirectory(title="Select data folder")
+        if d:
+            self._folder_var.set(d)
+
+    def _run(self):
+        folder = self._folder_var.get().strip()
+        if not folder:
+            self._status_var.set("Please select a data folder first.")
+            return
+
+        self._btn.state(["disabled"])
+        self._status_var.set("Loading…")
+
+        def worker():
+            try:
+                from molass.DataObjects import SecSaxsData as SSD
+                ssd = SSD(folder)
+                trimmed = ssd.trimmed_copy()
+
+                def on_main():
+                    self._btn.state(["!disabled"])
+                    self._status_var.set("Ready.")
+                    from molass_gui.naive_view import NaiveView
+                    NaiveView(ssd, trimmed, parent=self).show()
+
+                self.after(0, on_main)
+
+            except Exception as exc:
+                msg = str(exc)
+                def on_error(m=msg):
+                    self._status_var.set(f"Error: {m}")
+                    self._btn.state(["!disabled"])
+                self.after(0, on_error)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+
+def main():
+    App().mainloop()
+
+
+if __name__ == "__main__":
+    main()

molass_gui-0.1.0/molass_gui/naive_view.py

@@ -0,0 +1,63 @@
+"""NaiveView — Phase 2: plot_compact + num_components → Decompose → QuickView."""
+import threading
+import tkinter as tk
+from tkinter import ttk
+
+
+class NaiveView:
+    def __init__(self, ssd, trimmed, parent=None):
+        self._ssd = ssd
+        self._trimmed = trimmed
+        self._parent = parent
+
+    def show(self):
+        from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+
+        win = tk.Toplevel(self._parent)
+        win.title("Naive View")
+
+        # Header: num_components + Decompose button + status
+        hdr = ttk.Frame(win, padding=(8, 4))
+        hdr.pack(fill=tk.X)
+        ttk.Label(hdr, text="Components:").pack(side=tk.LEFT)
+        self._nc_var = tk.IntVar(value=3)
+        ttk.Spinbox(hdr, from_=1, to=6, textvariable=self._nc_var, width=5).pack(
+            side=tk.LEFT, padx=6)
+        self._decomp_btn = ttk.Button(hdr, text="Decompose", command=self._decompose)
+        self._decomp_btn.pack(side=tk.LEFT, padx=12)
+        self._status_var = tk.StringVar(value="")
+        ttk.Label(hdr, textvariable=self._status_var, foreground="gray").pack(side=tk.LEFT)
+
+        # Show trimmed compact plot with baseline overlay
+        result = self._trimmed.plot_compact(baseline=True)
+        canvas = FigureCanvasTkAgg(result.fig, master=win)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        NavigationToolbar2Tk(canvas, win).update()
+        self._win = win
+
+    def _decompose(self):
+        nc = self._nc_var.get()
+        self._decomp_btn.state(["disabled"])
+        self._status_var.set("Decomposing\u2026")
+
+        def worker():
+            try:
+                corrected = self._trimmed.corrected_copy()
+                decomp = corrected.quick_decomposition(num_components=nc)
+
+                def on_main():
+                    self._decomp_btn.state(["!disabled"])
+                    self._status_var.set("")
+                    from molass_gui.quick_view import QuickView
+                    QuickView(decomp, self._trimmed, nc, parent=self._win).show()
+
+                self._win.after(0, on_main)
+            except Exception as exc:
+                msg = str(exc)
+                def on_error(m=msg):
+                    self._status_var.set(f"Error: {m}")
+                    self._decomp_btn.state(["!disabled"])
+                self._win.after(0, on_error)
+
+        threading.Thread(target=worker, daemon=True).start()

molass_gui-0.1.0/molass_gui/quick_view.py

@@ -0,0 +1,118 @@
+"""QuickView — Phase 3: plot_components (EGH) + model selection → Upgrade / Skip → UpgradedView."""
+import threading
+import tkinter as tk
+from tkinter import ttk
+
+# (label, recipe model key, pore_dist kwarg or None)
+_MODEL_OPTIONS = [
+    ('EGH',                        'egh',  None),
+    ('EGH \u2192 SDM (mono)',       'sdm',  None),
+    ('EGH \u2192 SDM (lognormal)',  'sdm',  'lognormal'),
+    ('EGH \u2192 EDM',              'cedm', None),
+    ('EGH \u2192 LKM',              'lkm',  None),
+    ('EGH \u2192 GRM',              'grm',  None),
+]
+_MODEL_LABELS = [m[0] for m in _MODEL_OPTIONS]
+
+
+class QuickView:
+    def __init__(self, decomp, trimmed, nc, parent=None):
+        self._decomp = decomp
+        self._trimmed = trimmed
+        self._nc = nc
+        self._parent = parent
+
+    def show(self):
+        from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+
+        win = tk.Toplevel(self._parent)
+        win.title("Quick Optimization View")
+
+        # Header: model selection + PSD σ (conditional) + Upgrade / Skip buttons
+        hdr = ttk.Frame(win, padding=(8, 4))
+        hdr.pack(fill=tk.X)
+
+        ttk.Label(hdr, text="Model:").pack(side=tk.LEFT)
+        self._model_var = tk.StringVar(value='EGH')
+        self._model_cb = ttk.Combobox(hdr, textvariable=self._model_var, values=_MODEL_LABELS,
+                                      state='readonly', width=24)
+        self._model_cb.pack(side=tk.LEFT, padx=4)
+
+        # PSD σ frame — shown only when SDM (lognormal) is selected
+        self._psd_frame = ttk.Frame(hdr)
+        ttk.Label(self._psd_frame, text="PSD \u03c3:").pack(side=tk.LEFT, padx=(8, 0))
+        self._psd_sigma_var = tk.StringVar(value="0.1")
+        ttk.Entry(self._psd_frame, textvariable=self._psd_sigma_var, width=6).pack(
+            side=tk.LEFT, padx=4)
+
+        self._action_btn = ttk.Button(hdr, text="Skip", command=self._skip)
+        self._action_btn.pack(side=tk.RIGHT, padx=8)
+        self._status_var = tk.StringVar(value="")
+        ttk.Label(hdr, textvariable=self._status_var, foreground="gray").pack(
+            side=tk.LEFT, padx=8)
+
+        def _on_model_change(*_):
+            label = self._model_var.get()
+            is_ln = label == 'EGH \u2192 SDM (lognormal)'
+            if is_ln:
+                self._psd_frame.pack(side=tk.LEFT, after=self._model_cb)
+            else:
+                self._psd_frame.pack_forget()
+            _, key, _ = next(m for m in _MODEL_OPTIONS if m[0] == label)
+            if key == 'egh':
+                self._action_btn.configure(text='Skip', command=self._skip)
+            else:
+                self._action_btn.configure(text='Upgrade', command=self._upgrade)
+        self._model_var.trace_add('write', _on_model_change)
+
+        # Show EGH plot_components immediately
+        result = self._decomp.plot_components()
+        canvas = FigureCanvasTkAgg(result.fig, master=win)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        NavigationToolbar2Tk(canvas, win).update()
+        self._win = win
+
+    def _skip(self):
+        model_info = {'model': 'egh', 'pore_dist': None, 'ln_pore_sigma': None}
+        from molass_gui.upgraded_view import UpgradedView
+        UpgradedView(self._decomp, self._trimmed, self._nc, model_info,
+                     parent=self._win).show()
+
+    def _upgrade(self):
+        model_label = self._model_var.get()
+        _, model_key, pore_dist = next(m for m in _MODEL_OPTIONS if m[0] == model_label)
+        if model_key == 'egh':
+            self._skip()
+            return
+        ln_pore_sigma = float(self._psd_sigma_var.get()) if pore_dist == 'lognormal' else None
+        self._action_btn.state(["disabled"])
+        self._status_var.set(f"Upgrading to {model_key.upper()}\u2026")
+
+        def worker():
+            try:
+                upgrade_kwargs = {}
+                if pore_dist is not None:
+                    upgrade_kwargs['pore_dist'] = pore_dist
+                    if ln_pore_sigma is not None:
+                        upgrade_kwargs['model_params'] = {'ln_pore_sigma': ln_pore_sigma}
+                upgraded = self._decomp.upgrade(model_key, **upgrade_kwargs)
+                model_info = {'model': model_key, 'pore_dist': pore_dist,
+                              'ln_pore_sigma': ln_pore_sigma}
+
+                def on_main():
+                    self._action_btn.state(["!disabled"])
+                    self._status_var.set("")
+                    from molass_gui.upgraded_view import UpgradedView
+                    UpgradedView(upgraded, self._trimmed, self._nc, model_info,
+                                 parent=self._win).show()
+
+                self._win.after(0, on_main)
+            except Exception as exc:
+                msg = str(exc)
+                def on_error(m=msg):
+                    self._status_var.set(f"Error: {m}")
+                    self._action_btn.state(["!disabled"])
+                self._win.after(0, on_error)
+
+        threading.Thread(target=worker, daemon=True).start()

molass_gui-0.1.0/molass_gui/rigorous_view.py

@@ -0,0 +1,352 @@
+"""RigorousView — Phase 5: Rg computation + auto-start optimization + live 4-panel monitor.
+
+Receives an already-upgraded Decomposition from UpgradedView (Phase 4).
+Transitions: computing Rg → scoring → running → done.
+"""
+import os
+import queue
+import traceback
+import threading
+import time
+import tkinter as tk
+from tkinter import ttk
+
+
+class RigorousView:
+    def __init__(self, decomp, trimmed, est_kwargs, analysis_folder, parent=None):
+        """
+        Parameters
+        ----------
+        decomp : Decomposition
+            EGH decomposition; Rg curve already cached by QuickView.
+        trimmed : SecSaxsData
+            Trimmed (uncorrected) SSD, passed to score().
+        est_kwargs : dict
+            Keys: use_subprocess, pipeline_recipe.
+        analysis_folder : str
+            Output folder for optimization results.
+        parent : tk widget or None
+        """
+        self._decomp = decomp
+        self._trimmed = trimmed
+        self._est_kwargs = est_kwargs
+        self._analysis_folder = analysis_folder
+        self._parent = parent
+        self._decomp_for_opt = None
+        self._score = None
+        self._run_info = None
+        self._stopped = False
+        self._niter = 0
+        self._last_sv_len = 0
+        self._redraw_event = threading.Event()
+
+    def show(self):
+        import matplotlib.pyplot as plt
+        import matplotlib.gridspec as gridspec
+        from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+
+        win = tk.Toplevel(self._parent)
+        recipe = (self._est_kwargs.get('pipeline_recipe') or {})
+        model  = recipe.get('model', 'egh').upper()
+        method = recipe.get('method', 'bh').upper()
+        proc   = 'subprocess' if self._est_kwargs.get('use_subprocess') else 'in-process'
+        win.title(f"Rigorous Optimization \u2014 {model} | {method} | {proc}")
+
+        # Prep phase header (hidden after prep completes)
+        self._prep_frame = ttk.Frame(win, padding=(8, 2))
+        self._prep_frame.pack(fill=tk.X)
+        self._prep_var = tk.StringVar(value="Computing Rg curve\u2026")
+        ttk.Label(self._prep_frame, textvariable=self._prep_var).pack(side=tk.LEFT)
+        n_frames = len(self._decomp.ssd.xr.jv)
+        self._pb = ttk.Progressbar(self._prep_frame, maximum=n_frames, length=300)
+        self._pb.pack(side=tk.LEFT, padx=8, fill=tk.X, expand=True)
+
+        # Optimization header (SV, evals, action button)
+        hdr = ttk.Frame(win, padding=(8, 4))
+        hdr.pack(fill=tk.X)
+        self._status_var = tk.StringVar(value="")
+        ttk.Label(hdr, textvariable=self._status_var, width=24).pack(side=tk.LEFT)
+        self._sv_var = tk.StringVar(value="SV: \u2014")
+        ttk.Label(hdr, textvariable=self._sv_var, font=("", 12, "bold")).pack(
+            side=tk.LEFT, padx=16)
+        self._n_var = tk.StringVar(value="0 evals")
+        ttk.Label(hdr, textvariable=self._n_var).pack(side=tk.LEFT)
+        self._iter_var = tk.StringVar(value="Iter: \u2014")
+        ttk.Label(hdr, textvariable=self._iter_var).pack(side=tk.LEFT, padx=12)
+        self._time_var = tk.StringVar(value="")
+        ttk.Label(hdr, textvariable=self._time_var, foreground="#555").pack(side=tk.LEFT, padx=4)
+        self._action_btn = ttk.Button(hdr, text="Terminate", command=self._stop,
+                                      state='disabled')
+        self._action_btn.pack(side=tk.RIGHT, padx=8)
+
+        # 4-panel figure: top 3 panels + bottom SV strip
+        self._fig = plt.figure(figsize=(18, 6.5))
+        gs = gridspec.GridSpec(2, 3, figure=self._fig,
+                               height_ratios=[4, 1.5], hspace=0.45)
+        self._ax_uv      = self._fig.add_subplot(gs[0, 0])
+        self._ax_xr      = self._fig.add_subplot(gs[0, 1])
+        self._ax_score   = self._fig.add_subplot(gs[0, 2])
+        self._ax_xr_twin = self._ax_xr.twinx()
+        self._ax_xr_twin.grid(False)
+        self._ax_sv      = self._fig.add_subplot(gs[1, :])
+        self._axis_info  = (self._fig,
+                            (self._ax_uv, self._ax_xr, self._ax_score, self._ax_xr_twin))
+
+        canvas = FigureCanvasTkAgg(self._fig, master=win)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        NavigationToolbar2Tk(canvas, win).update()
+        self._canvas = canvas
+        self._win = win
+
+        self._prep_q = queue.Queue()
+        threading.Thread(target=self._prep_worker, daemon=True).start()
+        win.after(100, self._prep_poll)
+
+    # ------------------------------------------------------------------
+    # Prep phase
+
+    def _prep_worker(self):
+        try:
+            # Upgrade already done in Phase 3; compute Rg then score
+            def _rg_cb(rg_buffer, j):
+                self._prep_q.put(('rg', j))
+            self._decomp.get_rg_curve(progress_cb=_rg_cb)
+            self._decomp_for_opt = self._decomp
+            score = self._decomp_for_opt.score(trimmed_ssd=self._trimmed)
+            self._prep_q.put(('done', score))
+        except Exception as exc:
+            short = str(exc).split('\n')[0][:120]
+            self._prep_q.put(('error', short))
+
+    def _prep_poll(self):
+        while True:
+            try:
+                item = self._prep_q.get_nowait()
+            except queue.Empty:
+                break
+            if item[0] == 'rg':
+                self._pb['value'] = item[1]
+            elif item[0] == 'done':
+                self._on_prep_done(item[1])
+                return
+            elif item[0] == 'error':
+                self._prep_var.set(f"Prep error: {item[1]}")
+                return
+        self._win.after(100, self._prep_poll)
+
+    def _on_prep_done(self, score):
+        self._score = score
+        self._pb.stop()
+        self._prep_frame.pack_forget()
+        try:
+            opt = score.optimizer
+            opt.objective_func(score.init_params, plot=True, axis_info=self._axis_info)
+            _retitle_panels(self._ax_uv, self._ax_xr, self._ax_score, score.sv)
+            _draw_sv_history(self._ax_sv, [], 0)
+        except Exception:
+            pass
+        self._canvas.draw()
+        self._status_var.set(f"Ready \u2014 SV={score.sv:.2f}")
+        self._sv_var.set(f"SV: {score.sv:.2f}")
+        self._optimize()  # auto-start; user can Terminate if needed
+
+    # ------------------------------------------------------------------
+    # Optimization phase
+
+    def _optimize(self):
+        self._status_var.set("Starting\u2026")
+        threading.Thread(target=self._launch, daemon=True).start()
+
+    def _launch(self):
+        try:
+            use_subprocess  = self._est_kwargs.get('use_subprocess', False)
+            pipeline_recipe = self._est_kwargs.get('pipeline_recipe', None)
+            method = (pipeline_recipe or {}).get('method', 'BH').upper()
+
+            run_info = self._decomp_for_opt.optimize_rigorously(
+                trimmed_ssd=self._trimmed,
+                in_process=not use_subprocess,
+                async_=True,
+                monitor=False,
+                method=method,
+                analysis_folder=self._analysis_folder,
+                pipeline_recipe=pipeline_recipe,
+            )
+            self._run_info = run_info
+            self._win.after(0, self._on_started)
+        except Exception as exc:
+            tb = traceback.format_exc()
+            log_path = os.path.join(self._analysis_folder, 'molass_gui_error.log')
+            try:
+                os.makedirs(self._analysis_folder, exist_ok=True)
+                with open(log_path, 'w') as f:
+                    f.write(tb)
+            except Exception:
+                pass
+            short = str(exc).split('\n')[0][:120]
+            self._win.after(0, lambda m=short: self._status_var.set(
+                f"Error: {m}  \u2014 see {log_path}"))
+
+    def _on_started(self):
+        self._action_btn.state(['!disabled'])
+        self._status_var.set("Running\u2026")
+        threading.Thread(target=self._watch_loop, daemon=True).start()
+        self._win.after(500, self._ui_poll)
+
+    def _watch_loop(self):
+        """Background: redraw UV/XR/score panels every ~3 s."""
+        first = True
+        while not self._stopped:
+            if first:
+                first = False
+            else:
+                time.sleep(3.0)
+            try:
+                opt = self._run_info.optimizer
+                params = self._run_info.best_params
+                if params is None:
+                    params = self._run_info.init_params
+                if params is not None:
+                    lock = getattr(opt, '_objective_lock', None)
+                    acquired = lock.acquire(timeout=1.5) if lock else True
+                    if acquired:
+                        try:
+                            for ax in (self._ax_uv, self._ax_xr, self._ax_score,
+                                       self._ax_xr_twin):
+                                ax.cla()
+                            self._ax_xr_twin.grid(False)
+                            opt.objective_func(params, plot=True,
+                                               axis_info=self._axis_info)
+                            sv_hist = self._run_info.sv_history
+                            sv_now = sv_hist[-1] if sv_hist else None
+                            _retitle_panels(self._ax_uv, self._ax_xr, self._ax_score, sv_now)
+                        finally:
+                            if lock:
+                                lock.release()
+                        self._redraw_event.set()
+            except Exception:
+                pass
+
+    def _ui_poll(self):
+        """Main-thread: update labels and flush canvas every 500 ms."""
+        if self._stopped:
+            return
+        if self._run_info is None:
+            self._win.after(500, self._ui_poll)
+            return
+        try:
+            status      = self._run_info.live_status()
+            phase       = status.get('phase', '?')
+            best_sv     = status.get('best_sv')
+            n_evals     = status.get('n_evals', 0)
+            n_callbacks = status.get('n_callbacks') or 0
+            elapsed_s   = status.get('elapsed_s') or 0.0
+            manifest    = status.get('manifest') or {}
+            niter       = manifest.get('niter', 0)
+
+            self._n_var.set(f"{n_evals} evals")
+            if best_sv is not None:
+                self._sv_var.set(f"SV: {best_sv:.2f}")
+            self._iter_var.set(
+                f"Iter: {n_callbacks}/{niter}" if niter else f"Iter: {n_callbacks}")
+            self._time_var.set(_fmt_time_info(elapsed_s, n_callbacks, niter))
+            if niter:
+                self._niter = niter
+
+            if phase == 'done':
+                self._status_var.set("Done.")
+                self._action_btn.state(["disabled"])
+                self._stopped = True
+            else:
+                p = getattr(self._run_info, '_subprocess_process', None)
+                if p is not None and p.poll() is not None and p.poll() != 0 and not n_callbacks:
+                    stderr_path = os.path.join(
+                        self._run_info.work_folder or '', 'optimizer_stderr.txt')
+                    self._status_var.set(
+                        f"Subprocess error (exit {p.poll()}) \u2014 see {stderr_path}")
+                    self._action_btn.state(["disabled"])
+                    self._stopped = True
+                else:
+                    self._status_var.set(f"Phase: {phase}")
+
+            try:
+                sv_hist = self._run_info.sv_history
+                sv_len = len(sv_hist) if sv_hist else 0
+                sv_changed = sv_len != self._last_sv_len
+                if sv_changed:
+                    _draw_sv_history(self._ax_sv, sv_hist, self._niter)
+                    self._last_sv_len = sv_len
+            except Exception:
+                sv_changed = False
+        except Exception:
+            sv_changed = False
+
+        if self._redraw_event.is_set() or sv_changed:
+            self._redraw_event.clear()
+            self._canvas.draw()
+        if not self._stopped:
+            self._win.after(500, self._ui_poll)
+
+    def _stop(self):
+        self._stopped = True
+        if self._run_info is not None:
+            try:
+                self._run_info.stop()
+            except Exception:
+                pass
+        self._status_var.set("Terminating\u2026")
+        self._action_btn.state(["disabled"])
+
+        def _wait_dead():
+            ri = self._run_info
+            if ri is not None:
+                for _ in range(60):
+                    time.sleep(0.5)
+                    if not ri.is_alive:
+                        break
+            self._win.after(0, lambda: self._status_var.set("Terminated."))
+        threading.Thread(target=_wait_dead, daemon=True).start()
+
+
+# ------------------------------------------------------------------
+
+def _retitle_panels(ax_uv, ax_xr, ax_score, sv):
+    ax_uv.set_title("UV Decomposition", fontsize=16)
+    ax_xr.set_title("XR Decomposition", fontsize=16)
+    if sv is not None:
+        ax_score.set_title(f"Score Breakdown  (SV={sv:.1f})", fontsize=16)
+    else:
+        ax_score.set_title("Score Breakdown", fontsize=16)
+
+
+def _fmt_duration(seconds):
+    h, rem = divmod(int(seconds), 3600)
+    m, s = divmod(rem, 60)
+    return f"{h}:{m:02d}:{s:02d}" if h else f"{m:02d}:{s:02d}"
+
+
+def _fmt_time_info(elapsed_s, n_done, n_total):
+    parts = [f"Elapsed: {_fmt_duration(elapsed_s)}"]
+    if n_done > 0 and n_total > 0 and elapsed_s > 0:
+        rate = elapsed_s / n_done
+        remaining = (n_total - n_done) * rate
+        parts.append(f"ETA: ~{_fmt_duration(remaining)}")
+    return "  ".join(parts)
+
+
+def _draw_sv_history(ax, sv_hist, niter=0):
+    ax.cla()
+    n = len(sv_hist) if sv_hist else 0
+    if n > 0:
+        xs = range(n)
+        ax.step(xs, sv_hist, where='post', lw=1.2, color='steelblue')
+        ax.set_ylim(bottom=max(0, min(sv_hist) - 5), top=105)
+        if niter > n:
+            ax.axvspan(n - 1, niter, alpha=0.06, color='grey')
+            ax.axvline(n - 1, color='steelblue', lw=0.8, ls='--', alpha=0.6)
+    if niter > 0:
+        ax.set_xlim(0, niter)
+    ax.set_xlabel("BH hop")
+    ax.set_ylabel("SV")
+    ax.set_title("SV history")

molass_gui-0.1.0/molass_gui/upgraded_view.py

@@ -0,0 +1,95 @@
+"""UpgradedView — Phase 4: upgraded plot_components + method/subprocess → RigorousView."""
+import tkinter as tk
+from tkinter import ttk
+
+_METHOD_LABELS = ['BH', 'DE']
+
+
+class UpgradedView:
+    def __init__(self, decomp, trimmed, nc, model_info, parent=None):
+        """
+        Parameters
+        ----------
+        decomp : Decomposition
+            Upgraded (or EGH) decomposition.
+        trimmed : SecSaxsData
+            Trimmed SSD for score().
+        nc : int
+            Number of components (for pipeline_recipe).
+        model_info : dict
+            Keys: model, pore_dist, ln_pore_sigma.
+        parent : tk widget or None
+        """
+        self._decomp = decomp
+        self._trimmed = trimmed
+        self._nc = nc
+        self._model_info = model_info
+        self._parent = parent
+
+    def show(self):
+        from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+
+        win = tk.Toplevel(self._parent)
+        model = self._model_info['model'].upper()
+        win.title(f"Upgraded View \u2014 {model}")
+
+        # Header: method + subprocess + Rigorous button
+        hdr = ttk.Frame(win, padding=(8, 4))
+        hdr.pack(fill=tk.X)
+
+        ttk.Label(hdr, text="Method:").pack(side=tk.LEFT)
+        self._method_var = tk.StringVar(value='BH')
+        ttk.Combobox(hdr, textvariable=self._method_var, values=_METHOD_LABELS,
+                     state='readonly', width=8).pack(side=tk.LEFT, padx=4)
+
+        self._subprocess_var = tk.BooleanVar(value=True)
+        ttk.Checkbutton(hdr, text="Use subprocess",
+                        variable=self._subprocess_var).pack(side=tk.LEFT, padx=12)
+
+        self._rig_btn = ttk.Button(hdr, text="Rigorous Optimization\u2026",
+                                   command=self._proceed_rigorous)
+        self._rig_btn.pack(side=tk.RIGHT, padx=8)
+
+        # Show plot_components for the current model
+        result = self._decomp.plot_components()
+        canvas = FigureCanvasTkAgg(result.fig, master=win)
+        canvas.draw()
+        canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
+        NavigationToolbar2Tk(canvas, win).update()
+        self._win = win
+
+    def _proceed_rigorous(self):
+        from tkinter import filedialog
+        folder = filedialog.askdirectory(
+            title="Select output folder for optimization results",
+            parent=self._win)
+        if not folder:
+            return
+
+        model_key     = self._model_info['model']
+        pore_dist     = self._model_info['pore_dist']
+        ln_pore_sigma = self._model_info['ln_pore_sigma']
+        method        = self._method_var.get().lower()
+        use_subprocess = self._subprocess_var.get()
+
+        pipeline_recipe = {
+            'num_components': self._nc,
+            'model': model_key,
+            'method': method,
+            'decomp_params': {},
+            'trim_params': {},
+            'baseline_params': {},
+        }
+        if pore_dist is not None:
+            pipeline_recipe['pore_dist'] = pore_dist
+        if ln_pore_sigma is not None:
+            pipeline_recipe['ln_pore_sigma'] = ln_pore_sigma
+
+        est_kwargs = {
+            'use_subprocess': use_subprocess,
+            'pipeline_recipe': pipeline_recipe,
+        }
+
+        from molass_gui.rigorous_view import RigorousView
+        RigorousView(self._decomp, self._trimmed, est_kwargs,
+                     analysis_folder=folder, parent=self._win).show()

molass_gui-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "molass_gui"
+version = "0.1.0"
+
+dependencies = [
+  "molass>=1.0.5",
+  "molass_legacy>=1.6.13",
+]
+
+requires-python = ">=3.9,<3.15"
+
+authors = [
+  {name = "Molass Community"},
+]
+
+maintainers = [
+  {name = "Molass Community"}
+]
+
+description = "Tkinter GUI for Molass — initial estimate workflow"
+readme = "README.md"
+license = { text = "GNU General Public License v3.0" }
+
+keywords = ["SEC-SAXS"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Programming Language :: Python",
+  "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+]
+
+[project.scripts]
+molass-gui = "molass_gui.app:main"
+
+[project.urls]
+Repository = "https://github.com/biosaxs-dev/molass-gui"