Merge upstream OpenMS/streamlit-template into FLASHApp

.gitignore

@@ -31,3 +31,4 @@ gdpr_consent/node_modules/
 *~
 .streamlit/secrets.toml
 docs/superpowers/
+.venv/

README.md

@@ -57,3 +57,20 @@ After it has been built you can run the image with:
 `docker run -p 8501:8501 flashapp:latest`
 
 Navigate to `http://localhost:8501` in your browser.
+
+## Legal pages (Impressum, Privacy Policy, Terms of Use)
+
+Every page shows **Impressum**, **Privacy Policy** and **Terms of Use** links in the
+sidebar footer, and the GDPR consent banner links to the privacy policy. By default
+these point to the official OpenMS pages (`https://openms.de/impressum`, `/privacy`,
+`/terms`). To override them — for example when self-hosting or deploying FLASHApp
+under a different operator — set `legal_links` in `settings.json`:
+
+    "legal_links": {
+        "impressum": "https://your-domain.example/impressum",
+        "privacy": "https://your-domain.example/privacy",
+        "terms": "https://your-domain.example/terms"
+    }
+
+Any link you omit falls back to its OpenMS default. The `privacy` URL is reused for the
+consent banner's privacy-policy link, so consent and policy stay in sync.

gdpr_consent/src/main.ts

@@ -14,6 +14,7 @@ let klaroConfig: {
     mustConsent: boolean;
     acceptAll: boolean;
     services: Service[];
+    translations?: Record<string, any>;
 } = {
     mustConsent: true,
     acceptAll: true,
@@ -125,6 +126,18 @@ function onRender(event: Event): void {
         )
     }
 
+    // Link the consent banner to the privacy policy. Setting privacyPolicyUrl
+    // on the 'zz' fallback language makes Klaro render its default
+    // "To learn more, please read our privacy policy." text with the URL,
+    // regardless of the browser locale.
+    if (data.args['privacy_policy']) {
+        klaroConfig.translations = {
+            zz: {
+                privacyPolicyUrl: data.args['privacy_policy']
+            }
+        }
+    }
+
     // Create a new script element
     var script = document.createElement('script')
 

k8s/base/traefik-ingressroute.yaml

@@ -4,7 +4,8 @@ metadata:
   name: streamlit-traefik
 spec:
   entryPoints:
-    - web
+    - web          #  301-redirects to websecure
+    - websecure
   routes:
     - match: PathPrefix(`/`)
       kind: Rule
@@ -16,3 +17,4 @@ spec:
               name: stroute
               httpOnly: true
               sameSite: lax
+              secure: true   # only send the affinity cookie over HTTPS

settings.json

@@ -3,6 +3,11 @@
     "github-user": "OpenMS",
     "version": "1.0.0",
     "repository-name": "FLASHApp",
+    "legal_links": {
+        "impressum": "https://openms.de/impressum",
+        "privacy": "https://openms.de/privacy",
+        "terms": "https://openms.de/terms"
+    },
     "analytics": {
         "google-analytics": {
             "enabled": false,

src/common/captcha_.py

@@ -186,7 +186,7 @@ def add_page(main_script_path_str: str, page_name: str) -> None:
 
 
 # define the function for the captcha control
-def captcha_control():
+def captcha_control(privacy_policy_url: str = ""):
     """
     Control and verification of a CAPTCHA to ensure the user is not a robot.
 
@@ -199,6 +199,10 @@ def captcha_control():
 
     The CAPTCHA text is generated as a session state and should not change during refreshes.
 
+    Args:
+        privacy_policy_url (str, optional): URL shown as the privacy policy link
+            in the GDPR consent banner. Defaults to "".
+
     Returns:
         None
     """
@@ -214,7 +218,10 @@ def captcha_control():
             with st.spinner():
                 # Ask for consent
                 st.session_state.tracking_consent = consent_component(
-                    google_analytics=ga, piwik_pro=pp, matomo=mt
+                    google_analytics=ga,
+                    piwik_pro=pp,
+                    matomo=mt,
+                    privacy_policy=privacy_policy_url,
                 )
                 if st.session_state.tracking_consent is None:
                     # No response by user yet

src/common/common.py

@@ -31,6 +31,37 @@
 # Detect system platform
 OS_PLATFORM = sys.platform
 
+# Default legal/GDPR page links. These point to the centrally maintained
+# official OpenMS pages. Forks that self-host should override them via the
+# "legal_links" key in settings.json (an Impressum must name the actual
+# operator). The defaults live here too — not only in settings.json — so that
+# downstream apps built from an older settings.json without a "legal_links"
+# key still inherit working legal links by default.
+DEFAULT_LEGAL_LINKS = {
+    "impressum": "https://openms.de/impressum",
+    "privacy": "https://openms.de/privacy",
+    "terms": "https://openms.de/terms",
+}
+
+
+def get_legal_links() -> dict[str, str]:
+    """
+    Return the legal page URLs (Impressum, Privacy Policy, Terms of Use).
+
+    Values from the "legal_links" object in settings.json override the
+    built-in OpenMS defaults. Empty override values are ignored so a blank
+    entry can't erase a default.
+
+    Returns:
+        dict[str, str]: Mapping of "impressum", "privacy" and "terms" to URLs.
+    """
+    overrides = (
+        st.session_state.settings.get("legal_links", {})
+        if "settings" in st.session_state
+        else {}
+    )
+    return {**DEFAULT_LEGAL_LINKS, **{k: v for k, v in overrides.items() if v}}
+
 
 def is_safe_workspace_name(name: str) -> bool:
     """
@@ -549,7 +580,7 @@ def page_setup(page: str = "") -> dict[str, Any]:
     # Render the sidebar
     params = render_sidebar(page)
 
-    captcha_control()
+    captcha_control(privacy_policy_url=get_legal_links()["privacy"])
 
     # If run in hosted mode, show captcha as long as it has not been solved
     # if not "local" in sys.argv:
@@ -562,7 +593,7 @@ def page_setup(page: str = "") -> dict[str, Any]:
         "controllo" in params.keys() and params["controllo"] == False
     ):
         # Apply captcha by calling the captcha_control function
-        captcha_control()
+        captcha_control(privacy_policy_url=get_legal_links()["privacy"])
 
     return params
 
@@ -794,6 +825,19 @@ def change_workspace():
                 f'<div class="version-box">{app_name}<br>Version: {version_info}</div>',
                 unsafe_allow_html=True,
             )
+
+        # Legal links (Impressum, Privacy Policy, Terms of Use), shown on every
+        # page. URLs are configurable via "legal_links" in settings.json.
+        links = get_legal_links()
+        st.markdown(
+            '<div style="text-align:center; font-size:0.8rem; '
+            'margin-top:0.5rem; color:#a4a5ad;">'
+            f'<a href="{links["impressum"]}" target="_blank" rel="noopener" style="white-space:nowrap">Impressum</a> &middot; '
+            f'<a href="{links["privacy"]}" target="_blank" rel="noopener" style="white-space:nowrap">Privacy Policy</a> &middot; '
+            f'<a href="{links["terms"]}" target="_blank" rel="noopener" style="white-space:nowrap">Terms of Use</a>'
+            "</div>",
+            unsafe_allow_html=True,
+        )
     return params
 
 

src/workflow/CommandExecutor.py

@@ -5,7 +5,7 @@
 import threading
 from pathlib import Path
 from .Logger import Logger
-from .ParameterManager import ParameterManager
+from .ParameterManager import ParameterManager, bool_param_paths_from_param_xml_ini
 import sys
 import importlib.util
 import json
@@ -216,7 +216,7 @@ def read_stderr():
         stdout_thread.join()
         stderr_thread.join()
 
-    def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> bool:
+    def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}, tool_instance_name: str = None) -> bool:
         """
         Constructs and executes commands for the specified tool OpenMS TOPP tool based on the given
         input and output configurations. Ensures that all input/output file lists
@@ -234,6 +234,10 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
             tool (str): The executable name or path of the tool.
             input_output (dict): A dictionary specifying the input/output parameter names (as key) and their corresponding file paths (as value).
             custom_params (dict): A dictionary of custom parameters to pass to the tool.
+            tool_instance_name (str, optional): Key for ``params.json`` when it differs
+                from ``tool`` (e.g. multiple instances). Defaults to ``tool``.
+            Custom parameters whose keys appear in the tool's ParamXML ``type="bool"``
+            entries are passed as valueless CLI flags (``-name`` only when enabled).
 
         Returns:
             bool: True if all commands succeeded, False if any failed.
@@ -261,8 +265,15 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
 
         commands = []
 
-        # Load parameters for non-defaults
         params = self.parameter_manager.get_parameters_from_json()
+
+        topp_tool_ini_path = Path(self.parameter_manager.ini_dir, f"{tool}.ini")
+        # Keys of type="bool" in the .ini: TOPP treats these as on/off flags (omit value when off)
+        topp_bool_flag_param_keys = (
+            bool_param_paths_from_param_xml_ini(topp_tool_ini_path, tool)
+            if topp_tool_ini_path.exists()
+            else set()
+        )
         # Construct commands for each process
         for i in range(n_processes):
             command = [tool]
@@ -284,24 +295,40 @@ def run_topp(self, tool: str, input_output: dict, custom_params: dict = {}) -> b
             # Add non-default TOPP tool parameters
             if tool in params.keys():
                 for k, v in params[tool].items():
-                    # Boolean flag handling: 'true' -> flag only, 'false' -> skip entirely
-                    if isinstance(v, str) and v == 'true':
-                        command += [f"-{k}"]
-                    elif isinstance(v, str) and v == 'false':
-                        pass
-                    elif v == "" or v is None:
-                        # Empty string or None: flag only (no value)
-                        command += [f"-{k}"]
-                    else:
-                        command += [f"-{k}"]
-                        # Note: 0 and 0.0 are valid values, so use explicit check above
+                    # Boolean flag handling. A parameter is emitted as a
+                    # valueless TOPP on/off flag when EITHER the tool's ParamXML
+                    # .ini marks the key type="bool" (upstream key-based
+                    # detection via topp_bool_flag_param_keys) OR the stored
+                    # value is itself boolean. The value-based branch is the
+                    # fallback FLASHApp relies on: checkbox widgets persist a
+                    # Python bool (True/False) to params.json, and pyOpenMS /
+                    # presets may surface the 'true'/'false' string form. This
+                    # keeps flags correct even when the .ini bool set is empty
+                    # (e.g. the .ini was not written).
+                    is_bool_value = isinstance(v, bool) or (
+                        isinstance(v, str) and v.lower() in ("true", "false")
+                    )
+                    if (k in topp_bool_flag_param_keys and v != "") or is_bool_value:
+                        # CLI flag: include "-k" only when enabled, never a value.
+                        if isinstance(v, str):
+                            is_enabled = v.lower() == "true"
+                        else:
+                            is_enabled = bool(v)
+                        if is_enabled:
+                            command += [f"-{k}"]
+                        continue
+                    command += [f"-{k}"]
+                    # Skip only empty strings (pass flag with no value)
+                    # Note: 0 and 0.0 are valid values, so use explicit check
+                    if v != "" and v is not None:
                         if isinstance(v, str) and "\n" in v:
                             command += v.split("\n")
                         else:
                             command += [str(v)]
             # Add custom parameters
             for k, v in custom_params.items():
                 command += [f"-{k}"]
+
                 # Skip only empty strings (pass flag with no value)
                 # Note: 0 and 0.0 are valid values, so use explicit check
                 if v != "" and v is not None:

src/workflow/ParameterManager.py

@@ -3,8 +3,52 @@
 import shutil
 import subprocess
 import streamlit as st
+import xml.etree.ElementTree as ET
 from pathlib import Path
 
+
+def bool_param_paths_from_param_xml_ini(ini_path: Path, tool_stem: str) -> set[str]:
+    """
+    Return short parameter paths for every ``<ITEM type="bool">`` in a ParamXML .ini file.
+
+    Paths match the suffix after ``Tool:1:`` in pyOpenMS (e.g. ``algorithm:epd:masstrace_snr_filtering``).
+    """
+    try:
+        root = ET.parse(ini_path).getroot()
+    except (ET.ParseError, OSError):
+        return set()
+
+    def local_tag(el: ET.Element) -> str:
+        t = el.tag
+        return t.rsplit("}", 1)[-1] if isinstance(t, str) and "}" in t else str(t)
+
+    out: set[str] = set()
+
+    def walk(el: ET.Element, parts: tuple[str, ...]) -> None:
+        for ch in el:
+            lt = local_tag(ch)
+            if lt == "NODE":
+                nm = ch.get("name") or ""
+                walk(ch, parts + (nm,))
+            elif lt == "ITEM" and (ch.get("type") or "").lower() == "bool":
+                nm = ch.get("name") or ""
+                segs = [p for p in parts if p]
+                if nm:
+                    segs.append(nm)
+                if not segs:
+                    continue
+                # Strip tool root NODE name and instance NODE "1" (not part of pyOpenMS short keys)
+                while segs and segs[0] in (tool_stem, "1"):
+                    segs.pop(0)
+                if segs:
+                    out.add(":".join(segs))
+
+    for ch in root:
+        if local_tag(ch) == "NODE":
+            walk(ch, ())
+    return out
+
+
 class ParameterManager:
     """
     Manages the parameters for a workflow, including saving parameters to a JSON file,
@@ -29,6 +73,29 @@ def __init__(self, workflow_dir: Path, workflow_name: str = None):
         # Store workflow name for preset loading; default to directory stem if not provided
         self.workflow_name = workflow_name or workflow_dir.stem
 
+    def bool_pairs_session_key(self) -> str:
+        """Session state key holding a set of (tool name, param path) for bool TOPP params."""
+        return f"{self.ini_dir.parent.stem}-topp-bool-pairs"
+
+    def get_bool_param_pairs(self) -> set:
+        """Return the cached set of (tool, param path) bool params; empty set if none."""
+        return st.session_state.get(self.bool_pairs_session_key(), set())
+
+    def _merge_bool_params_from_ini(self, tool: str) -> None:
+        """Load tool.ini (XML) and merge type=bool parameter paths into session_state."""
+        ini_path = Path(self.ini_dir, f"{tool}.ini")
+        if not ini_path.exists():
+            return
+        try:
+            sk = self.bool_pairs_session_key()
+            if sk not in st.session_state:
+                st.session_state[sk] = set()
+            for short in bool_param_paths_from_param_xml_ini(ini_path, tool):
+                st.session_state[sk].add((tool, short))
+        except RuntimeError:
+            # No Streamlit session (e.g. plain `python` import)
+            pass
+
     def create_ini(self, tool: str) -> bool:
         """
         Create an ini file for a TOPP tool if it doesn't exist.
@@ -41,11 +108,14 @@ def create_ini(self, tool: str) -> bool:
         """
         ini_path = Path(self.ini_dir, tool + ".ini")
         if ini_path.exists():
+            self._merge_bool_params_from_ini(tool)
             return True
         try:
             subprocess.call([tool, "-write_ini", str(ini_path)])
         except FileNotFoundError:
             return False
+        if ini_path.exists():
+            self._merge_bool_params_from_ini(tool)
         return ini_path.exists()
 
     def save_parameters(self) -> None: