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

app.py

@@ -1,5 +1,6 @@
 
 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_grid
@@ -11,6 +12,7 @@ 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
@@ -24,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)
@@ -492,18 +518,37 @@ PARAMS_NRMS = {
     "entropy_dimension":       (1.0, 3.0)
 }
 
+
 def run_parameter_tuning_DE_ui(platform: str):
-    if platform == 'HRMS':
-        PARAMS=PARAMS_HRMS
+    # Pick param set per platform
+    if platform == "HRMS":
+        PARAMS = PARAMS_HRMS
     else:
-        PARAMS=PARAMS_NRMS
+        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],),
+        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":
@@ -527,47 +572,56 @@ def run_parameter_tuning_DE_ui(platform: str):
 
     numeric_inputs = [
         ui.input_numeric("mz_min", "Minimum m/z for filtering:", 0),
-        ui.input_numeric("mz_max", "Maximum m/z for filtering:", 99999999),
+        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:", 999999999),
+        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",
+    )
 
-    #run_button_parameter_tuning_DE = ui.download_button("run_btn_parameter_tuning_DE", "Tune parameters (differential evolution optimization)", style="font-size:16px; padding:15px 30px; width:300px; height:100px")
-    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[0:6], style="display:flex; flex-direction:column; gap:10px;"),
-            ui.div([base_inputs[6:7], *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:10]], style="display:flex; flex-direction:column; gap:10px;"),
-            col_widths=(3,3,3,3),
+            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),
         )
-    elif platform == "NRMS":
+    else:  # NRMS
         inputs_columns = ui.layout_columns(
-            ui.div(base_inputs[0:6], style="display:flex; flex-direction:column; gap:10px;"),
-            ui.div([base_inputs[6:7], *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:10]], style="display:flex; flex-direction:column; gap:10px;"),
-            col_widths=(3,3,3,3),
+            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 parameters"),
+                ui.h3("Select continuous parameters to optimize"),
                 ui.input_checkbox_group(
                     "params",
                     None,
                     choices=list(PARAMS.keys()),
-                    selected=["noise_threshold","LET_threshold"],
+                    selected=["noise_threshold", "LET_threshold"],
                 ),
                 ui.hr(),
                 ui.h4("Bounds for selected parameters"),
@@ -576,9 +630,15 @@ def run_parameter_tuning_DE_ui(platform: str):
             ),
             ui.div(
                 ui.h2("Tune parameters (differential evolution optimization)"),
-                *(inputs_columns if isinstance(inputs_columns, (list, tuple)) else [inputs_columns]),
+                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;",
             ),
         )
     )
@@ -586,6 +646,7 @@ def run_parameter_tuning_DE_ui(platform: str):
 
 
 
+
 app_ui = ui.page_fluid(
     ui.head_content(ui.tags.link(rel="icon", href="emblem.png")),
     ui.output_ui("main_ui"),
@@ -1280,40 +1341,151 @@ def server(input, output, session):
         yield df_out.to_csv(index=False).encode("utf-8", sep='\t')
 
 
+
     @reactive.effect
     @reactive.event(input.run_btn_parameter_tuning_DE)
-    def _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)
-        match_log_rv.set("Tuning specified continuous parameters using differential evolution...\n")
+        await reactive.flush()
 
-        #print('\nhere!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
-        weights = [float(weight.strip()) for weight in input.weights().split(",") if weight.strip()]
-        weights = {'Cosine':weights[0], 'Shannon':weights[1], 'Renyi':weights[2], 'Tsallis':weights[3]}
-        opt_params, bounds_dict, bounds_list = _read_bounds()
-        #print(input.params())
-        #print("Optimizing over:", opt_params)
-        #print("Bounds list:", bounds_list)
-        #print("Bounds dict:", bounds_dict)
-        #tmp = {"window_size_centroiding":input.window_size_centroiding(), "window_size_matching":input.window_size_matching(), "noise_threshold":input.noise_threshold(), "wf_mz":input.wf_mz(), "wf_int":input.wf_int(), "LET_threshold":input.LET_threshold(), "entropy_dimension":input.entropy_dimension()}
-        #print(tmp)
-        if input.chromatography_platform() == 'HRMS':
-            tune_params_DE(query_data=input.query_data()[0]["datapath"],
-                           reference_data=input.reference_data()[0]["datapath"],
-                           similarity_measure=input.similarity_measure(),
-                           weights=weights,
-                           spectrum_preprocessing_order=input.spectrum_preprocessing_order(),
-                           mz_min=input.mz_min(),
-                           mz_max=input.mz_max(),
-                           int_min=input.int_min(),
-                           int_max=input.int_max(),
-                           high_quality_reference_library=input.high_quality_reference_library(),
-                           optimize_params=list(input.params()),
-                           param_bounds={"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)},
-                           #param_bounds=bounds_dict,
-                           default_params={"window_size_centroiding":input.window_size_centroiding(), "window_size_matching":input.window_size_matching(), "noise_threshold":input.noise_threshold(), "wf_mz":input.wf_mz(), "wf_int":input.wf_int(), "LET_threshold":input.LET_threshold(), "entropy_dimension":input.entropy_dimension()})
-        #print('here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n')
+        # --- 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
@@ -1335,6 +1507,11 @@ def server(input, output, session):
         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()
+
 
 app = App(app_ui, server)
 

pycompound/spec_lib_matching.py

@@ -21,46 +21,46 @@ def _vector_to_full_params(X, default_params, optimize_params):
 
 def objective_function_HRMS(X, ctx):
     p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
-    if 'window_size_centroiding' in ctx.keys():
-        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
-        )
-    else:
-        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
-        )
+    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, 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}):
+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):
 
-    '''
-    print('<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
-    print(param_bounds)
-    print(default_params)
-    print(type(param_bounds['noise_threshold'][0]))
-    print(type(param_bounds['noise_threshold'][1]))
-    print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
-    '''
+    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.')
@@ -111,22 +111,13 @@ def tune_params_DE(query_data=None, reference_data=None, similarity_measure='cos
 
     bounds = [param_bounds[p] for p in optimize_params]
 
-    #print('<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
-    #print(df_query.head())
-    #print(df_reference.head())
-    #print(bounds)
-    #print(ctx)
-    #print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
-
-    result = differential_evolution(
-        objective_function_HRMS,
-        bounds=bounds,
-        args=(ctx,),
-        maxiter=3,
-        tol=0.0,
-        workers=-1,
-        seed=1,
-    )
+    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)
@@ -140,8 +131,7 @@ def tune_params_DE(query_data=None, reference_data=None, similarity_measure='cos
     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]}
@@ -577,7 +567,6 @@ def tune_params_on_NRMS_data_grid_shiny(query_data=None, reference_data=None, gr
 
 def get_acc_HRMS(df_query, df_reference, unique_query_ids, unique_reference_ids, similarity_measure, weights, spectrum_preprocessing_order, mz_min, mz_max, int_min, int_max, window_size_centroiding, window_size_matching, noise_threshold, wf_mz, wf_int, LET_threshold, entropy_dimension, high_quality_reference_library, verbose=True):
 
-    #print('\n\n\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n\n')
     n_top_matches_to_save = 1
 
     all_similarity_scores =  []

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycompound
-Version: 0.1.5
+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.5.dist-info → pycompound-0.1.6.dist-info}/RECORD

@@ -1,16 +1,15 @@
-app.py,sha256=GdKSi0aRstcIeQulLMxANTwhScVJDNR4HlHC4bkUhXg,62350
-app2.py,sha256=ZTmShHRlv27_HhSzCj8JOVAPv5LLsjtgEkxt1c-7r6I,2950
+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=-4WNGUPqkAZwfrrmhdi7S3PcV-6d3O6nCe-efAtTzZA,73346
+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.5.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
-pycompound-0.1.5.dist-info/METADATA,sha256=DIz-j3Hh4tXJMjXS-Epg_fy0auOcwYx2UUUWk3MyGN4,1732
-pycompound-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pycompound-0.1.5.dist-info/top_level.txt,sha256=cd0cQe1lhTXW9uwTTM5kZgjscKvRQV8XQ41qOwedgHU,20
-pycompound-0.1.5.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,,

{pycompound-0.1.5.dist-info → pycompound-0.1.6.dist-info}/top_level.txt

@@ -1,3 +1,2 @@
 app
-app2
 pycompound

app2.py

@@ -1,101 +0,0 @@
-
-
-# app.py
-from shiny import App, ui, render, reactive
-import pandas as pd
-
-# Parameters to choose from + suggested default ranges
-PARAMS = {
-    "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),
-}
-
-app_ui = ui.page_fillable(
-    ui.layout_sidebar(
-        ui.sidebar(
-            ui.h3("Select parameters"),
-            ui.input_checkbox_group(
-                id="params",
-                label=None,
-                choices=list(PARAMS.keys()),
-                selected=["window_size_centroiding", "noise_threshold"],
-            ),
-            ui.hr(),
-            ui.h4("Bounds for selected parameters"),
-            ui.output_ui("bounds_inputs"),
-            width=360,
-        ),
-    )
-)
-
-def server(input, output, session):
-    @output
-    @render.ui
-    def bounds_inputs():
-        selected = input.params()
-        if not selected:
-            return ui.div(ui.em("Select one or more parameters above."))
-
-        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}"
-
-            # Use input[...]() and guard with "in input"
-            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
-
-
-
-    # Table of current bounds
-    @output
-    @render.data_frame
-    def bounds_table():
-        b = _read_bounds_dict()
-        if not b:
-            return pd.DataFrame(columns=["parameter", "lower", "upper"])
-        rows = [{"parameter": k, "lower": v[0], "upper": v[1]} for k, v in b.items()]
-        return pd.DataFrame(rows)
-
-    # JSON-ish view (string) you can parse/use elsewhere
-    @output
-    @render.text
-    def bounds_json():
-        b = _read_bounds_dict()
-        if not b:
-            return "{}"
-        # Pretty-print as Python dict literal for quick copy/paste
-        lines = ["{"]
-        for k, (lo, hi) in b.items():
-            lines.append(f"  '{k}': ({lo}, {hi}),")
-        lines.append("}")
-        return "\n".join(lines)
-
-app = App(app_ui, server)
-
-