pycompound 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

app.py

@@ -1,15 +1,18 @@
 
 from shiny import App, ui, reactive, render, req
+from shiny.types import SilentException
 from pycompound.spec_lib_matching import run_spec_lib_matching_on_HRMS_data 
 from pycompound.spec_lib_matching import run_spec_lib_matching_on_NRMS_data 
-from pycompound.spec_lib_matching import tune_params_on_HRMS_data
-from pycompound.spec_lib_matching import tune_params_on_NRMS_data
-from pycompound.spec_lib_matching import tune_params_on_HRMS_data_shiny
-from pycompound.spec_lib_matching import tune_params_on_NRMS_data_shiny
+from pycompound.spec_lib_matching import tune_params_on_HRMS_data_grid
+from pycompound.spec_lib_matching import tune_params_on_NRMS_data_grid
+from pycompound.spec_lib_matching import tune_params_on_HRMS_data_grid_shiny
+from pycompound.spec_lib_matching import tune_params_on_NRMS_data_grid_shiny
+from pycompound.spec_lib_matching import tune_params_DE
 from pycompound.plot_spectra import generate_plots_on_HRMS_data
 from pycompound.plot_spectra import generate_plots_on_NRMS_data
 from pathlib import Path
 from contextlib import redirect_stdout, redirect_stderr
+import contextlib
 import subprocess
 import traceback
 import asyncio
@@ -23,10 +26,34 @@ import netCDF4 as nc
 from pyteomics import mgf, mzml
 import ast
 from numbers import Real
+import logging
+from scipy.optimize import differential_evolution
 
 
 _LOG_QUEUE: asyncio.Queue[str] = asyncio.Queue()
 
+class _UIWriter:
+    def __init__(self, loop, q: asyncio.Queue[str]):
+        self._loop = loop
+        self._q = q
+    def write(self, s: str):
+        if s:
+            self._loop.call_soon_threadsafe(self._q.put_nowait, s)
+        return len(s)
+    def flush(self):
+        pass
+
+
+def attach_logging_to_writer(writer):
+    handler = logging.StreamHandler(writer)
+    handler.setLevel(logging.INFO)
+    root = logging.getLogger()
+    root.addHandler(handler)
+    root.setLevel(logging.INFO)
+    return handler, root
+
+
+
 def _run_with_redirects(fn, writer, *args, **kwargs):
     with redirect_stdout(writer), redirect_stderr(writer):
         return fn(*args, **kwargs)
@@ -394,7 +421,7 @@ def run_spec_lib_matching_ui(platform: str):
 
 
 
-def run_parameter_tuning_ui(platform: str):
+def run_parameter_tuning_grid_ui(platform: str):
     base_inputs = [
         ui.input_file("query_data", "Upload query dataset (mgf, mzML, cdf, msp, or csv):"),
         ui.input_file("reference_data", "Upload reference dataset (mgf, mzML, cdf, msp, or csv):"),
@@ -435,7 +462,7 @@ def run_parameter_tuning_ui(platform: str):
     ]
 
 
-    run_button_parameter_tuning = ui.download_button("run_btn_parameter_tuning", "Tune parameters", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
+    run_button_parameter_tuning_grid = ui.download_button("run_btn_parameter_tuning_grid", "Tune parameters (grid search)", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
     back_button = ui.input_action_button("back", "Back to main menu", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
 
     if platform == "HRMS":
@@ -465,7 +492,7 @@ def run_parameter_tuning_ui(platform: str):
         ui.TagList(
             ui.h2("Tune parameters"),
             inputs_columns,
-            run_button_parameter_tuning,
+            run_button_parameter_tuning_grid,
             back_button,
             log_panel
         ),
@@ -473,12 +500,152 @@ def run_parameter_tuning_ui(platform: str):
 
 
 
-'''
-app_ui = ui.page_fluid(
-    ui.output_ui("main_ui"),
-    ui.output_text("status_output")
-)
-'''
+PARAMS_HRMS = {
+    "window_size_centroiding": (0.0, 0.5),
+    "window_size_matching":    (0.0, 0.5),
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0)
+}
+
+PARAMS_NRMS = {
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0)
+}
+
+
+def run_parameter_tuning_DE_ui(platform: str):
+    # Pick param set per platform
+    if platform == "HRMS":
+        PARAMS = PARAMS_HRMS
+    else:
+        PARAMS = PARAMS_NRMS
+
+    base_inputs = [
+        ui.input_file("query_data", "Upload query dataset (mgf, mzML, cdf, msp, or csv):"),
+        ui.input_file("reference_data", "Upload reference dataset (mgf, mzML, cdf, msp, or csv):"),
+        ui.input_select(
+            "similarity_measure",
+            "Select similarity measure:",
+            [
+                "cosine","shannon","renyi","tsallis","mixture","jaccard","dice",
+                "3w_jaccard","sokal_sneath","binary_cosine","mountford",
+                "mcconnaughey","driver_kroeber","simpson","braun_banquet",
+                "fager_mcgowan","kulczynski","intersection","hamming","hellinger",
+            ],
+        ),
+        ui.input_text(
+            "weights",
+            "Weights for mixture similarity measure (cosine, shannon, renyi, tsallis):",
+            "0.25, 0.25, 0.25, 0.25",
+        ),
+        ui.input_select(
+            "high_quality_reference_library",
+            "Indicate whether the reference library is considered high quality. If True, filtering and noise removal are only applied to the query spectra.",
+            [False, True],
+        ),
+    ]
+
+    if platform == "HRMS":
+        extra_inputs = [
+            ui.input_text(
+                "spectrum_preprocessing_order",
+                "Sequence of characters for preprocessing order (C (centroiding), F (filtering), M (matching), N (noise removal), L (low-entropy transformation), W (weight factor transformation)). M must be included, C before M if used.",
+                "FCNMWL",
+            ),
+            ui.input_numeric("window_size_centroiding", "Centroiding window-size:", 0.5),
+            ui.input_numeric("window_size_matching", "Matching window-size:", 0.5),
+        ]
+    else:
+        extra_inputs = [
+            ui.input_text(
+                "spectrum_preprocessing_order",
+                "Sequence of characters for preprocessing order (F (filtering), N (noise removal), L (low-entropy transformation), W (weight factor transformation)).",
+                "FNLW",
+            )
+        ]
+
+    numeric_inputs = [
+        ui.input_numeric("mz_min", "Minimum m/z for filtering:", 0),
+        ui.input_numeric("mz_max", "Maximum m/z for filtering:", 99_999_999),
+        ui.input_numeric("int_min", "Minimum intensity for filtering:", 0),
+        ui.input_numeric("int_max", "Maximum intensity for filtering:", 999_999_999),
+        ui.input_numeric("noise_threshold", "Noise removal threshold:", 0.0),
+        ui.input_numeric("wf_mz", "Mass/charge weight factor:", 0.0),
+        ui.input_numeric("wf_int", "Intensity weight factor:", 1.0),
+        ui.input_numeric("LET_threshold", "Low-entropy threshold:", 0.0),
+        ui.input_numeric("entropy_dimension", "Entropy dimension (Renyi/Tsallis only):", 1.1),
+        ui.input_numeric("max_iterations", "Maximum number of iterations:", 5),
+    ]
+
+    run_button_parameter_tuning_DE = ui.input_action_button(
+        "run_btn_parameter_tuning_DE",
+        "Tune parameters (differential evolution optimization)",
+        style="font-size:16px; padding:15px 30px; width:300px; height:100px",
+    )
+    back_button = ui.input_action_button(
+        "back",
+        "Back to main menu",
+        style="font-size:16px; padding:15px 30px; width:300px; height:100px",
+    )
+
+    # Build the 4-column inputs panel (fixed slices corrected, unpack lists properly)
+    if platform == "HRMS":
+        inputs_columns = ui.layout_columns(
+            ui.div(*base_inputs, style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*extra_inputs, style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*numeric_inputs[0:5], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*numeric_inputs[5:11], style="display:flex; flex-direction:column; gap:10px;"),
+            col_widths=(3, 3, 3, 3),
+        )
+    else:  # NRMS
+        inputs_columns = ui.layout_columns(
+            ui.div(*base_inputs, style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*extra_inputs, style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*numeric_inputs[0:5], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(*numeric_inputs[5:11], style="display:flex; flex-direction:column; gap:10px;"),
+            col_widths=(3, 3, 3, 3),
+        )
+
+    # Main page: sidebar (param selection + bounds) and body (inputs + buttons + live log)
+    return ui.page_fillable(
+        ui.layout_sidebar(
+            ui.sidebar(
+                ui.h3("Select continuous parameters to optimize"),
+                ui.input_checkbox_group(
+                    "params",
+                    None,
+                    choices=list(PARAMS.keys()),
+                    selected=["noise_threshold", "LET_threshold"],
+                ),
+                ui.hr(),
+                ui.h4("Bounds for selected parameters"),
+                ui.output_ui("bounds_inputs"),
+                width=360,
+            ),
+            ui.div(
+                ui.h2("Tune parameters (differential evolution optimization)"),
+                inputs_columns,
+                run_button_parameter_tuning_DE,
+                back_button,
+                ui.br(),
+                ui.card(
+                    ui.card_header("Live log"),
+                    ui.output_text_verbatim("run_log"),   # <-- make sure server defines this
+                ),
+                style="display:flex; flex-direction:column; gap:16px;",
+            ),
+        )
+    )
+
+
+
+
 
 app_ui = ui.page_fluid(
     ui.head_content(ui.tags.link(rel="icon", href="emblem.png")),
@@ -498,8 +665,10 @@ def server(input, output, session):
     run_status_plot_spectra = reactive.Value("")
     run_status_spec_lib_matching = reactive.Value("")
     run_status_plot_spectra_within_spec_lib_matching = reactive.Value("")
-    run_status_parameter_tuning = reactive.Value("")
-    is_tuning_running = reactive.Value(False)
+    run_status_parameter_tuning_grid = reactive.Value("")
+    run_status_parameter_tuning_DE = reactive.Value("")
+    is_tuning_grid_running = reactive.Value(False)
+    is_tuning_DE_running = reactive.Value(False)
     match_log_rv = reactive.Value("")
     is_matching_rv = reactive.Value(False)
     is_any_job_running = reactive.Value(False)
@@ -519,6 +688,64 @@ def server(input, output, session):
     converted_query_path_rv = reactive.Value(None)
     converted_reference_path_rv = reactive.Value(None)
 
+    @output
+    @render.ui
+    def bounds_inputs():
+        selected = input.params()
+        if not selected:
+            return ui.div(ui.em("Select one or more parameters above."))
+
+        if input.chromatography_platform() == 'HRMS':
+            PARAMS = PARAMS_HRMS
+        else:
+            PARAMS = PARAMS_NRMS
+        blocks = []
+        for name in selected:
+            lo, hi = PARAMS.get(name, (0.0, 1.0))
+            blocks.append(
+                ui.card(
+                    ui.card_header(name),
+                    ui.layout_columns(
+                        ui.input_numeric(f"min_{name}", "Lower", lo, step=0.001),
+                        ui.input_numeric(f"max_{name}", "Upper", hi, step=0.001),
+                    )
+                )
+            )
+        return ui.div(*blocks)
+
+    def _read_bounds_dict():
+        selected = input.params()
+        out = {}
+        for name in selected:
+            lo_default, hi_default = PARAMS.get(name, (0.0, 1.0))
+            lo_id = f"min_{name}"
+            hi_id = f"max_{name}"
+
+            lo_val = input[lo_id]() if lo_id in input else lo_default
+            hi_val = input[hi_id]() if hi_id in input else hi_default
+
+            out[name] = (float(lo_val), float(hi_val))
+        return out
+
+    def _read_bounds():
+        opt_params = input.params()
+        bounds_dict = {}
+        if input.chromatography_platform() == 'HRMS':
+            PARAMS = PARAMS_HRMS
+        else:
+            PARAMS = PARAMS_NRMS
+
+        for p in opt_params:
+            lo_id, hi_id = f"min_{p}", f"max_{p}"
+            lo_default, hi_default = PARAMS.get(p, (0.0, 1.0))
+            lo = input[lo_id]() if lo_id in input else lo_default
+            hi = input[hi_id]() if hi_id in input else hi_default
+            if lo > hi:
+                lo, hi = hi, lo
+            bounds_dict[p] = (float(lo), float(hi))
+
+        bounds_list = [bounds_dict[p] for p in opt_params]
+        return opt_params, bounds_dict, bounds_list
 
     def _reset_plot_spectra_state():
         query_status_rv.set("")
@@ -551,7 +778,8 @@ def server(input, output, session):
 
     def _reset_parameter_tuning_state():
         match_log_rv.set("")
-        is_tuning_running.set(False)
+        is_tuning_grid_running.set(False)
+        is_tuning_DE_running.set(False)
         is_any_job_running.set(False)
 
 
@@ -563,7 +791,9 @@ def server(input, output, session):
             _reset_plot_spectra_state()
         elif page == "run_spec_lib_matching":
             _reset_spec_lib_matching_state()
-        elif page == "run_parameter_tuning":
+        elif page == "run_parameter_tuning_grid":
+            _reset_parameter_tuning_state()
+        elif page == "run_parameter_tuning_DE":
             _reset_parameter_tuning_state()
 
     @reactive.effect
@@ -573,7 +803,9 @@ def server(input, output, session):
             _reset_plot_spectra_state()
         elif page == "run_spec_lib_matching":
             _reset_spec_lib_matching_state()
-        elif page == "run_parameter_tuning":
+        elif page == "run_parameter_tuning_grid":
+            _reset_parameter_tuning_state()
+        elif page == "run_parameter_tuning_DE":
             _reset_parameter_tuning_state()
 
 
@@ -601,7 +833,7 @@ def server(input, output, session):
 
     @reactive.effect
     async def _pump_logs():
-        if not (is_any_job_running.get() or is_tuning_running.get() or is_matching_rv.get()):
+        if not (is_any_job_running.get() or is_tuning_grid_running.get() or is_tuning_DE_running.get() or is_matching_rv.get()):
             return
         reactive.invalidate_later(0.05)
         msgs = _drain_queue_nowait(_LOG_QUEUE)
@@ -680,9 +912,12 @@ def server(input, output, session):
         elif input.run_spec_lib_matching() > match_clicks.get():
             current_page.set("run_spec_lib_matching")
             match_clicks.set(input.run_spec_lib_matching())
-        elif input.run_parameter_tuning() > match_clicks.get():
-            current_page.set("run_parameter_tuning")
-            match_clicks.set(input.run_parameter_tuning())
+        elif input.run_parameter_tuning_grid() > match_clicks.get():
+            current_page.set("run_parameter_tuning_grid")
+            match_clicks.set(input.run_parameter_tuning_grid())
+        elif input.run_parameter_tuning_DE() > match_clicks.get():
+            current_page.set("run_parameter_tuning_DE")
+            match_clicks.set(input.run_parameter_tuning_DE())
         elif hasattr(input, "back") and input.back() > back_clicks.get():
             current_page.set("main_menu")
             back_clicks.set(input.back())
@@ -726,7 +961,8 @@ def server(input, output, session):
                 ),
                 ui.input_action_button("plot_spectra", "Plot two spectra before and after preprocessing transformations.", style="font-size:18px; padding:20px 40px; width:550px; height:100px; margin-top:10px; margin-right:50px"),
                 ui.input_action_button("run_spec_lib_matching", "Run spectral library matching to perform compound identification on a query library of spectra.", style="font-size:18px; padding:20px 40px; width:550px; height:100px; margin-top:10px; margin-right:50px"),
-                ui.input_action_button("run_parameter_tuning", "Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:450px; height:120px; margin-top:10px; margin-right:50px"),
+                ui.input_action_button("run_parameter_tuning_grid", "Grid search: Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:450px; height:120px; margin-top:10px; margin-right:50px"),
+                ui.input_action_button("run_parameter_tuning_DE", "Differential evolution optimization: Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:500px; height:150px; margin-top:10px; margin-right:50px"),
                 ui.div(
                     "References:",
                     style="margin-top:35px; text-align:left; font-size:24px; font-weight:bold"
@@ -777,8 +1013,10 @@ def server(input, output, session):
             return plot_spectra_ui(input.chromatography_platform())
         elif current_page() == "run_spec_lib_matching":
             return run_spec_lib_matching_ui(input.chromatography_platform())
-        elif current_page() == "run_parameter_tuning":
-            return run_parameter_tuning_ui(input.chromatography_platform())
+        elif current_page() == "run_parameter_tuning_grid":
+            return run_parameter_tuning_grid_ui(input.chromatography_platform())
+        elif current_page() == "run_parameter_tuning_DE":
+            return run_parameter_tuning_DE_ui(input.chromatography_platform())
 
 
 
@@ -1020,10 +1258,10 @@ def server(input, output, session):
             yield buf.getvalue()
 
 
-    @render.download(filename="parameter_tuning_output.txt")
-    async def run_btn_parameter_tuning():
+    @render.download(filename="parameter_tuning_grid_output.txt")
+    async def run_btn_parameter_tuning_grid():
         is_any_job_running.set(True)
-        is_tuning_running.set(True)
+        is_tuning_grid_running.set(True)
         match_log_rv.set("Running grid search of all parameters specified...\n")
         await reactive.flush()
 
@@ -1044,7 +1282,7 @@ def server(input, output, session):
         common_kwargs = dict(
             query_data=input.query_data()[0]["datapath"],
             reference_data=input.reference_data()[0]["datapath"],
-            output_path=str(Path.cwd() / "parameter_tuning_output.txt"),
+            output_path=str(Path.cwd() / "parameter_tuning_grid_output.txt"),
             return_output=True,
         )
 
@@ -1072,7 +1310,7 @@ def server(input, output, session):
                     'window_size_centroiding': window_size_centroiding_tmp,
                     'window_size_matching': window_size_matching_tmp,
                 }
-                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_HRMS_data_shiny, rw, **common_kwargs, grid=grid)
+                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_HRMS_data_grid_shiny, rw, **common_kwargs, grid=grid)
             else:
                 grid = {
                     'similarity_measure': similarity_measure_tmp,
@@ -1089,14 +1327,14 @@ def server(input, output, session):
                     'entropy_dimension': entropy_dimension_tmp,
                     'high_quality_reference_library': high_quality_reference_library_tmp,
                 }
-                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_NRMS_data_shiny, rw, **common_kwargs, grid=grid)
+                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_NRMS_data_grid_shiny, rw, **common_kwargs, grid=grid)
 
             match_log_rv.set(match_log_rv.get() + "\n✅ Parameter tuning finished.\n")
         except Exception as e:
             match_log_rv.set(match_log_rv.get() + f"\n❌ Error: {e}\n")
             raise
         finally:
-            is_tuning_running.set(False)
+            is_tuning_grid_running.set(False)
             is_any_job_running.set(False)
             await reactive.flush()
 
@@ -1104,11 +1342,155 @@ def server(input, output, session):
 
 
 
+    @reactive.effect
+    @reactive.event(input.run_btn_parameter_tuning_DE)
+    async def run_btn_parameter_tuning_DE():
+        match_log_rv.set("Tuning specified continuous parameters using differential evolution...\n")
+        is_any_job_running.set(True)
+        is_tuning_DE_running.set(True)
+        await reactive.flush()
+
+        # --- helpers ---
+        def _safe_float(v, default):
+            try:
+                if v is None:
+                    return default
+                return float(v)
+            except Exception:
+                return default
+
+        def _iget(id, default=None):
+            # Safe getter for Shiny inputs (avoids SilentException)
+            if id in input:
+                try:
+                    return input[id]()
+                except SilentException:
+                    return default
+            return default
+
+        # ---- log plumbing (stdout/stderr -> UI) ----
+        loop = asyncio.get_running_loop()
+        q: asyncio.Queue[str | None] = asyncio.Queue()
+
+        class UIWriter(io.TextIOBase):
+            def write(self, s: str):
+                if s:
+                    loop.call_soon_threadsafe(q.put_nowait, s)
+                return len(s)
+            def flush(self): pass
+
+        async def _drain():
+            while True:
+                msg = await q.get()
+                if msg is None:
+                    break
+                match_log_rv.set(match_log_rv.get() + msg)
+                await reactive.flush()
+
+        drain_task = asyncio.create_task(_drain())
+        writer = UIWriter()
+
+        # ---------- SNAPSHOT INPUTS SAFELY ----------
+        try:
+            qfile = _iget("query_data")[0]["datapath"]
+            rfile = _iget("reference_data")[0]["datapath"]
+
+            platform = _iget("chromatography_platform", "HRMS")
+            sim = _iget("similarity_measure", "cosine")
+            spro = _iget("spectrum_preprocessing_order", "FCNMWL")
+
+            hq_raw = _iget("high_quality_reference_library", False)
+            if isinstance(hq_raw, str):
+                hq = hq_raw.lower() == "true"
+            else:
+                hq = bool(hq_raw)
+
+            mz_min = _safe_float(_iget("mz_min", 0.0), 0.0)
+            mz_max = _safe_float(_iget("mz_max", 99_999_999.0), 99_999_999.0)
+            int_min = _safe_float(_iget("int_min", 0.0), 0.0)
+            int_max = _safe_float(_iget("int_max", 999_999_999.0), 999_999_999.0)
+
+            # weights "a,b,c,d"
+            w_text = _iget("weights", "") or ""
+            w_list = [float(w.strip()) for w in w_text.split(",") if w.strip()]
+            w_list = (w_list + [0.0, 0.0, 0.0, 0.0])[:4]
+            weights = {"Cosine": w_list[0], "Shannon": w_list[1], "Renyi": w_list[2], "Tsallis": w_list[3]}
+
+            # selected params + bounds
+            opt_params = tuple(_iget("params", ()) or ())
+            bounds_dict = {}
+            # populate bounds using the min_/max_ inputs if present, otherwise fall back
+            # to your default PARAMS dicts already defined in your file
+            param_defaults = PARAMS_HRMS if platform == "HRMS" else PARAMS_NRMS
+            for p in opt_params:
+                lo = _safe_float(_iget(f"min_{p}", param_defaults.get(p, (0.0, 1.0))[0]),
+                                 param_defaults.get(p, (0.0, 1.0))[0])
+                hi = _safe_float(_iget(f"max_{p}", param_defaults.get(p, (0.0, 1.0))[1]),
+                                 param_defaults.get(p, (0.0, 1.0))[1])
+                if lo > hi:
+                    lo, hi = hi, lo
+                bounds_dict[p] = (lo, hi)
+
+            # defaults (guarded!)
+            defaults = {
+                "window_size_centroiding": _safe_float(_iget("window_size_centroiding", 0.5), 0.5),
+                "window_size_matching":    _safe_float(_iget("window_size_matching",    0.5), 0.5),
+                "noise_threshold":         _safe_float(_iget("noise_threshold",         0.0), 0.0),
+                "wf_mz":                   _safe_float(_iget("wf_mz",                   0.0), 0.0),
+                "wf_int":                  _safe_float(_iget("wf_int",                  1.0), 1.0),
+                "LET_threshold":           _safe_float(_iget("LET_threshold",           0.0), 0.0),
+                "entropy_dimension":       _safe_float(_iget("entropy_dimension",       1.1), 1.1),
+            }
+            if platform == "NRMS":
+                defaults.pop("window_size_centroiding", None)
+                defaults.pop("window_size_matching", None)
+
+        except Exception as e:
+            import traceback
+            tb = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+            match_log_rv.set(match_log_rv.get() + f"\n❌ Input snapshot failed:\n{tb}\n")
+            is_tuning_DE_running.set(False); is_any_job_running.set(False)
+            await q.put(None); await drain_task; await reactive.flush()
+            return
+
+        def _run():
+            from contextlib import redirect_stdout, redirect_stderr
+            with redirect_stdout(writer), redirect_stderr(writer):
+                return tune_params_DE(
+                    query_data=qfile,
+                    reference_data=rfile,
+                    chromatography_platform=input.chromatography_platform(),
+                    similarity_measure=sim,
+                    weights=weights,
+                    spectrum_preprocessing_order=spro,
+                    mz_min=mz_min, mz_max=mz_max,
+                    int_min=int_min, int_max=int_max,
+                    high_quality_reference_library=hq,
+                    optimize_params=list(opt_params),
+                    param_bounds=bounds_dict,
+                    default_params=defaults,
+                    de_workers=1,
+                    maxiters=input.max_iterations()
+                )
+
+        try:
+            _ = await asyncio.to_thread(_run)
+            match_log_rv.set(match_log_rv.get() + "\n✅ Differential evolution finished.\n")
+        except Exception as e:
+            import traceback
+            tb = "".join(traceback.format_exception(type(e), e, e.__traceback__))
+            match_log_rv.set(match_log_rv.get() + f"\n❌ {type(e).__name__}: {e}\n{tb}\n")
+        finally:
+            await q.put(None)
+            await drain_task
+            is_tuning_DE_running.set(False)
+            is_any_job_running.set(False)
+            await reactive.flush()
 
 
     @reactive.effect
     async def _pump_reactive_writer_logs():
-        if not is_tuning_running.get():
+        if not is_tuning_grid_running.get():
             return
 
         reactive.invalidate_later(0.1)
@@ -1122,32 +1504,16 @@ def server(input, output, session):
     def status_output():
         return run_status_plot_spectra.get()
         return run_status_spec_lib_matching.get()
-        return run_status_parameter_tuning.get()
-
-
-app = App(app_ui, server)
-
+        return run_status_parameter_tuning_grid.get()
+        return run_status_parameter_tuning_DE.get()
 
+    @output
+    @render.text
+    def run_log():
+        return match_log_rv.get()
 
-'''
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
 
-class _InjectBaseURLMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        hdrs = dict(request.scope.get("headers", []))
-        if b"rstudio-connect-app-base-url" not in hdrs:
-            host = request.headers.get("x-forwarded-host") or request.headers.get("host") or ""
-            proto = request.headers.get("x-forwarded-proto") or "https"
-            root_path = (request.scope.get("root_path") or "").rstrip("/")
-            base = f"{proto}://{host}{root_path}"
-            new_headers = list(request.scope.get("headers", [])) + [
-                (b"rstudio-connect-app-base-url", base.encode("utf-8"))
-            ]
-            request.scope["headers"] = new_headers
-        return await call_next(request)
+app = App(app_ui, server)
 
-app.starlette_app.add_middleware(_InjectBaseURLMiddleware)
-'''
 
 

pycompound/spec_lib_matching.py

@@ -9,6 +9,129 @@ from itertools import product
 from joblib import Parallel, delayed
 import csv
 import sys, csv
+from scipy.optimize import differential_evolution
+
+
+def _vector_to_full_params(X, default_params, optimize_params):
+    params = default_params.copy()
+    for name, val in zip(optimize_params, X):
+        params[name] = float(val)
+    return params
+
+
+def objective_function_HRMS(X, ctx):
+    p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
+    acc = get_acc_HRMS(
+        ctx["df_query"], ctx["df_reference"],
+        ctx["unique_query_ids"], ctx["unique_reference_ids"],
+        ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+        ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+        p["window_size_centroiding"], p["window_size_matching"], p["noise_threshold"],
+        p["wf_mz"], p["wf_int"], p["LET_threshold"],
+        p["entropy_dimension"],
+        ctx["high_quality_reference_library"],
+        verbose=False
+    )
+    print(f"\nparams({ctx['optimize_params']}) = {np.array(X)}\naccuracy: {acc*100}%")
+    return 1.0 - acc
+
+def objective_function_NRMS(X, ctx):
+    p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
+    acc = get_acc_NRMS(
+        ctx["df_query"], ctx["df_reference"],
+        ctx["unique_query_ids"], ctx["unique_reference_ids"],
+        ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+        ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+        p["noise_threshold"], p["wf_mz"], p["wf_int"], p["LET_threshold"], p["entropy_dimension"],
+        ctx["high_quality_reference_library"],
+        verbose=False
+    )
+    print(f"\nparams({ctx['optimize_params']}) = {np.array(X)}\naccuracy: {acc*100}%")
+    return 1.0 - acc
+
+
+
+def tune_params_DE(query_data=None, reference_data=None, chromatography_platform='HRMS', similarity_measure='cosine', weights=None, spectrum_preprocessing_order='CNMWL', mz_min=0, mz_max=999999999, int_min=0, int_max=999999999, high_quality_reference_library=False, optimize_params=["window_size_centroiding","window_size_matching","noise_threshold","wf_mz","wf_int","LET_threshold","entropy_dimension"], param_bounds={"window_size_centroiding":(0.0,0.5),"window_size_matching":(0.0,0.5),"noise_threshold":(0.0,0.25),"wf_mz":(0.0,5.0),"wf_int":(0.0,5.0),"LET_threshold":(0.0,5.0),"entropy_dimension":(1.0,3.0)}, default_params={"window_size_centroiding": 0.5, "window_size_matching":0.5, "noise_threshold":0.10, "wf_mz":0.0, "wf_int":1.0, "LET_threshold":0.0, "entropy_dimension":1.1}, maxiters=3, de_workers=1, de_updating='immediate', log_hook=None):
+
+    def _log(msg):
+        if log_hook:
+            try: log_hook(msg if msg.endswith("\n") else msg + "\n")
+            except: pass
+
+    def callback(xk, conv):
+        _log(f"iter callback: conv={conv:.4g}, x={xk}")
+        return False
+
+    if query_data is None:
+        print('\nError: No argument passed to the mandatory query_data. Please pass the path to the TXT file of the query data.')
+        sys.exit()
+    else:
+        extension = query_data.rsplit('.',1)
+        extension = extension[(len(extension)-1)]
+        if extension == 'mgf' or extension == 'MGF' or extension == 'mzML' or extension == 'mzml' or extension == 'MZML' or extension == 'cdf' or extension == 'CDF':
+            output_path_tmp = query_data[:-3] + 'csv'
+            build_library_from_raw_data(input_path=query_data, output_path=output_path_tmp, is_reference=False)
+            df_query = pd.read_csv(output_path_tmp)
+        if extension == 'csv' or extension == 'CSV':
+            df_query = pd.read_csv(query_data)
+        unique_query_ids = df_query.iloc[:,0].unique()
+
+    if reference_data is None:
+        print('\nError: No argument passed to the mandatory reference_data. Please pass the path to the CSV file of the reference data.')
+        sys.exit()
+    else:
+        if isinstance(reference_data,str):
+            df_reference = get_reference_df(reference_data=reference_data)
+            unique_reference_ids = df_reference.iloc[:,0].unique()
+        else:
+            dfs = []
+            unique_reference_ids = []
+            for f in reference_data:
+                tmp = get_reference_df(reference_data=f)
+                dfs.append(tmp)
+                unique_reference_ids.extend(tmp.iloc[:,0].unique())
+            df_reference = pd.concat(dfs, axis=0, ignore_index=True)
+
+    unique_query_ids = df_query['id'].unique().tolist()
+    unique_reference_ids = df_reference['id'].unique().tolist()
+
+    ctx = dict(
+        df_query=df_query,
+        df_reference=df_reference,
+        unique_query_ids=unique_query_ids,
+        unique_reference_ids=unique_reference_ids,
+        similarity_measure=similarity_measure,
+        weights=weights,
+        spectrum_preprocessing_order=spectrum_preprocessing_order,
+        mz_min=mz_min, mz_max=mz_max, int_min=int_min, int_max=int_max,
+        high_quality_reference_library=high_quality_reference_library,
+        default_params=default_params,
+        optimize_params=optimize_params,
+    )
+
+    bounds = [param_bounds[p] for p in optimize_params]
+
+    print('here!!!!!!!!!!!!!!!')
+    print(de_workers)
+    print('here!!!!!!!!!!!!!!!')
+    if chromatography_platform == 'HRMS':
+        result = differential_evolution(objective_function_HRMS, bounds=bounds, args=(ctx,), maxiter=maxiters, tol=0.0, workers=de_workers, seed=1)
+    else:
+        result = differential_evolution(objective_function_NRMS, bounds=bounds, args=(ctx,), maxiter=maxiters, tol=0.0, workers=de_workers, seed=1)
+
+    best_full_params = _vector_to_full_params(result.x, default_params, optimize_params)
+    best_acc = 100.0 - (result.fun * 100.0)
+
+    print("\n=== Differential Evolution Result ===")
+    print(f"Optimized over: {optimize_params}")
+    print("Best values (selected params):")
+    for name in optimize_params:
+        print(f"  {name}: {best_full_params[name]}")
+    print("\nFull parameter set used in final evaluation:")
+    for k, v in best_full_params.items():
+        print(f"  {k}: {v}")
+    print(f"\nBest accuracy: {best_acc:.3f}%")
+    _log(f"best = {result.x}, acc={100*(1-result.fun):.3f}%")
 
 
 default_HRMS_grid = {'similarity_measure':['cosine'], 'weight':[{'Cosine':0.25,'Shannon':0.25,'Renyi':0.25,'Tsallis':0.25}], 'spectrum_preprocessing_order':['FCNMWL'], 'mz_min':[0], 'mz_max':[9999999], 'int_min':[0], 'int_max':[99999999], 'window_size_centroiding':[0.5], 'window_size_matching':[0.5], 'noise_threshold':[0.0], 'wf_mz':[0.0], 'wf_int':[1.0], 'LET_threshold':[0.0], 'entropy_dimension':[1.1], 'high_quality_reference_library':[False]}
@@ -78,7 +201,7 @@ def _eval_one_NRMS(df_query, df_reference, unique_query_ids, unique_reference_id
 
 
 
-def tune_params_on_HRMS_data(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_HRMS_data_grid(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on high-resolution mass spectrometry (HRMS) data with all possible combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, and prints top-performing parameters
 
@@ -154,7 +277,7 @@ def tune_params_on_HRMS_data(query_data=None, reference_data=None, grid=None, ou
 
 
 
-def tune_params_on_HRMS_data_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_HRMS_data_grid_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on high-resolution mass spectrometry (HRMS) data with all possible 
     combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, 
@@ -262,7 +385,7 @@ def tune_params_on_HRMS_data_shiny(query_data=None, reference_data=None, grid=No
         print(f'Wrote results to {output_path}')
 
 
-def tune_params_on_NRMS_data(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_NRMS_data_grid(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on nominal-resolution mass spectrometry (NRMS) data with all possible combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, and prints top-performing parameters
 
@@ -336,7 +459,7 @@ def tune_params_on_NRMS_data(query_data=None, reference_data=None, grid=None, ou
 
 
 
-def tune_params_on_NRMS_data_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_NRMS_data_grid_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on nominal-resolution mass spectrometry (NRMS) data with all possible 
     combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, 

{pycompound-0.1.4.dist-info → pycompound-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycompound
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python package to perform compound identification in mass spectrometry via spectral library matching.
 Author-email: Hunter Dlugas <fy7392@wayne.edu>
 License-Expression: MIT

{pycompound-0.1.4.dist-info → pycompound-0.1.6.dist-info}/RECORD

@@ -1,15 +1,15 @@
-app.py,sha256=e_QULBLubrZLk_huIyDvL64lFzgDRo_vaYV0MIx9VJQ,51950
+app.py,sha256=lc54MkUqNTpGDBaF-3sDkSKDBSem0lDzZXo875d4W0c,67545
 pycompound/build_library.py,sha256=sXG5MTJnPE7Gr8YMlLWjfMS7JQrW32lCeCGDw-DFe38,4826
 pycompound/plot_spectra.py,sha256=_yeHooNoJHYlTajaZ9hgUudisdWVlw1Zw1wJfV3tpqc,40632
 pycompound/plot_spectra_CLI.py,sha256=ObaLad5Z5DmfQB-j0HSCg1mLORbYj2BM3hb5Yd0ZdDI,8395
 pycompound/processing.py,sha256=q629rcDaMQMgef-4SbeV9cJnuiLXg97VT2F5AIsyqgI,10654
 pycompound/similarity_measures.py,sha256=NbeVIy9DE_KWlDMXXylekjKuYVrtzbeEXbTutKFxmfU,10460
-pycompound/spec_lib_matching.py,sha256=TBH7cZLeIWNk5XkXcN7kiBfCSe6eRkseXIPMMLB54iI,67261
+pycompound/spec_lib_matching.py,sha256=Dqz8yU1W7aqqPLLiZefLVXU3V0ojEnXLbKoyZJFTbAA,73386
 pycompound/spec_lib_matching_CLI.py,sha256=qiekC52FP6ET_3NYvxUDN7km7y1OLUsd9FB4SHfne_Y,9690
 pycompound/tuning_CLI_DE.py,sha256=PXy95LD_jmVeWdgiMlMwEZU_KqPGqDao1skwe5U4Sfc,9147
 pycompound/tuning_CLI_grid.py,sha256=0XU-4ShZiZ2MQy5d0zydH0hphqXvqGtf4etl-ePNarU,8560
-pycompound-0.1.4.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
-pycompound-0.1.4.dist-info/METADATA,sha256=qlCzW19-6MpmuGoHbmQVL9ljKRCO4JXZ55-GTyKc3_I,1732
-pycompound-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pycompound-0.1.4.dist-info/top_level.txt,sha256=wFBLVrqpC07HghIU8tsEdgdvgkdOE3GN_1Gfjk-uEUc,15
-pycompound-0.1.4.dist-info/RECORD,,
+pycompound-0.1.6.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
+pycompound-0.1.6.dist-info/METADATA,sha256=Rw4Z889RSMLStLvxDy8mVA-b_AKNzryMtSQHH_X0m2Q,1732
+pycompound-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pycompound-0.1.6.dist-info/top_level.txt,sha256=wFBLVrqpC07HghIU8tsEdgdvgkdOE3GN_1Gfjk-uEUc,15
+pycompound-0.1.6.dist-info/RECORD,,