MIDRC-MELODY 0.3.3__py3-none-any.whl

MIDRC_MELODY/gui/config_editor.py

@@ -0,0 +1,200 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+#      Licensed under the Apache License, Version 2.0 (the "License");
+#      you may not use this file except in compliance with the License.
+#      You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#      Unless required by applicable law or agreed to in writing, software
+#      distributed under the License is distributed on an "AS IS" BASIS,
+#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#      See the License for the specific language governing permissions and
+#      limitations under the License.
+#
+
+from PySide6.QtWidgets import (QCheckBox, QDialog, QDoubleSpinBox, QFormLayout, QHBoxLayout, QLabel, QLineEdit,
+                               QMessageBox, QPushButton, QSpinBox, QTabWidget, QVBoxLayout, QWidget)
+import yaml
+
+
+class ConfigEditor(QDialog):
+    def __init__(self, config: dict, parent=None):
+        super().__init__(parent)
+        self.config = config  # store reference to config dict
+        self.setWindowTitle("Edit Config")
+        self.resize(600, 400)
+        main_layout = QVBoxLayout(self)
+        self.tab_widget = QTabWidget()
+        main_layout.addWidget(self.tab_widget)
+
+        # Initialize class variables
+        self.input_edits = {}
+        self.calc_edits = {}
+        self.output_widgets = {}
+        self.numeric_edit = None
+        self.custom_orders_edit = None
+        self.clockwise_checkbox = None
+        self.start_edit = None
+        self.bootstrap_iterations = None
+        self.bootstrap_seed = None
+
+        self.setup_input_tab()
+        self.setup_calculations_tab()
+        self.setup_output_tab()
+        self.setup_plots_tab()
+
+        # Button layout: Cancel, Apply, Save
+        btn_layout = QHBoxLayout()
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        apply_btn = QPushButton("Apply")
+        apply_btn.clicked.connect(self.apply_changes)
+        save_btn = QPushButton("Save")
+        save_btn.clicked.connect(self.on_save)
+        btn_layout.addWidget(cancel_btn)
+        btn_layout.addWidget(apply_btn)
+        btn_layout.addWidget(save_btn)
+        main_layout.addLayout(btn_layout)
+
+    def setup_input_tab(self):
+        self.input_edits = {}
+        input_tab = QWidget()
+        input_layout = QFormLayout(input_tab)
+        for key, value in self.config.get("input data", {}).items():
+            hbox = QHBoxLayout()
+            le = QLineEdit(str(value))
+            self.input_edits[key] = le
+            hbox.addWidget(le)
+            if key in ['truth file', 'test scores']:
+                browse_btn = QPushButton("Browse")
+                browse_btn.clicked.connect(lambda _, le=le: self.browse_file(le))
+                hbox.addWidget(browse_btn)
+            input_layout.addRow(QLabel(key), hbox)
+        numeric = self.config.get("numeric_cols", {})
+        numeric_str = "\n".join(f"{k}: {v}" for k, v in numeric.items())
+        self.numeric_edit = QLineEdit(numeric_str)
+        input_layout.addRow(QLabel("numeric_cols"), self.numeric_edit)
+        self.tab_widget.addTab(input_tab, "Input")
+
+    def browse_file(self, line_edit: QLineEdit):
+        from PySide6.QtWidgets import QFileDialog
+        file_path, _ = QFileDialog.getOpenFileName(self, "Select File", "", "All Files (*)")
+        if file_path:
+            line_edit.setText(file_path)
+
+    def setup_calculations_tab(self):
+        self.calc_edits = {}
+        calc_tab = QWidget()
+        calc_layout = QFormLayout(calc_tab)
+        # Use QDoubleSpinBox for binary threshold
+        if "binary threshold" in self.config:
+            threshold_value = self.config["binary threshold"]
+            threshold_spin = QDoubleSpinBox()
+            threshold_spin.setDecimals(2)
+            threshold_spin.setRange(0, 1000)  # adjust range as needed
+            threshold_spin.setValue(float(threshold_value))
+            self.calc_edits["binary threshold"] = threshold_spin
+            calc_layout.addRow(QLabel("binary threshold"), threshold_spin)
+        # Use QSpinBox for min count per category
+        if "min count per category" in self.config:
+            min_count = self.config["min count per category"]
+            min_count_spin = QSpinBox()
+            min_count_spin.setMinimum(0)
+            min_count_spin.setMaximum(10000)  # adjust range as needed
+            min_count_spin.setValue(int(min_count))
+            self.calc_edits["min count per category"] = min_count_spin
+            calc_layout.addRow(QLabel("min count per category"), min_count_spin)
+        # Bootstrap settings using QSpinBox
+        bootstrap = self.config.get("bootstrap", {})
+        self.bootstrap_iterations = QSpinBox()
+        self.bootstrap_iterations.setMinimum(0)
+        self.bootstrap_iterations.setMaximum(1000000)
+        self.bootstrap_iterations.setValue(int(bootstrap.get("iterations", 0)))
+        calc_layout.addRow(QLabel("Bootstrap Iterations"), self.bootstrap_iterations)
+        self.bootstrap_seed = QSpinBox()
+        self.bootstrap_seed.setMinimum(0)
+        self.bootstrap_seed.setMaximum(1000000)
+        self.bootstrap_seed.setValue(int(bootstrap.get("seed", 0)))
+        calc_layout.addRow(QLabel("Bootstrap Seed"), self.bootstrap_seed)
+        self.tab_widget.addTab(calc_tab, "Calculations")
+
+    def setup_output_tab(self):
+        self.output_widgets = {}
+        output_tab = QWidget()
+        output_layout = QFormLayout(output_tab)
+        output = self.config.get("output", {})
+        for subcat, settings in output.items():
+            row_widget = QWidget()
+            row_layout = QHBoxLayout(row_widget)
+            row_layout.setContentsMargins(0, 0, 0, 0)
+            cb = QCheckBox("Save")
+            cb.setChecked(settings.get("save", False))
+            le = QLineEdit(str(settings.get("file prefix", "")))
+            le.setEnabled(cb.isChecked())
+            cb.toggled.connect(lambda checked, le=le: le.setEnabled(checked))
+            row_layout.addWidget(cb)
+            row_layout.addWidget(QLabel("File Prefix:"))
+            row_layout.addWidget(le)
+            output_layout.addRow(QLabel(subcat.capitalize()), row_widget)
+            self.output_widgets[subcat] = (cb, le)
+        self.tab_widget.addTab(output_tab, "Pickle (.pkl) Output")
+
+    def setup_plots_tab(self):
+        plots_tab = QWidget()
+        plots_layout = QFormLayout(plots_tab)
+        plot = self.config.get("plot", {})
+        custom_orders = plot.get("custom_orders", {})
+        custom_orders_str = "\n".join(f"{k}: {v}" for k, v in custom_orders.items())
+        self.custom_orders_edit = QLineEdit(custom_orders_str)
+        plots_layout.addRow(QLabel("Custom Orders"), self.custom_orders_edit)
+        self.clockwise_checkbox = QCheckBox()
+        self.clockwise_checkbox.setChecked(plot.get("clockwise", False))
+        plots_layout.addRow(QLabel("Clockwise"), self.clockwise_checkbox)
+        self.start_edit = QLineEdit(str(plot.get("start", "")))
+        plots_layout.addRow(QLabel("Start"), self.start_edit)
+        self.tab_widget.addTab(plots_tab, "Plots")
+
+    def apply_changes(self):
+        # Input Tab
+        for key, widget in self.input_edits.items():
+            self.config.setdefault("input data", {})[key] = widget.text()
+        try:
+            new_numeric = yaml.load(self.numeric_edit.text(), Loader=yaml.SafeLoader)
+            if not isinstance(new_numeric, dict):
+                raise ValueError("numeric_cols must be a dictionary")
+        except Exception as e:
+            QMessageBox.warning(self, "Warning", f"Invalid format for numeric_cols: {e}")
+            new_numeric = self.config.get("numeric_cols", {})
+        self.config["numeric_cols"] = new_numeric
+
+        # Calculations Tab: use spinbox values
+        for key, widget in self.calc_edits.items():
+            self.config[key] = widget.value()  # Use value() from spinboxes
+        self.config["bootstrap"] = {
+            "iterations": self.bootstrap_iterations.value(),
+            "seed": self.bootstrap_seed.value()
+        }
+        # Output Tab
+        for subcat, (cb, le) in self.output_widgets.items():
+            self.config.setdefault("output", {})[subcat] = {
+                "save": cb.isChecked(),
+                "file prefix": le.text()
+            }
+        # Plots Tab: Parse custom_orders into a dictionary
+        try:
+            new_custom_orders = yaml.load(self.custom_orders_edit.text(), Loader=yaml.SafeLoader)
+            if not isinstance(new_custom_orders, dict):
+                raise ValueError("custom_orders must be a dictionary")
+        except Exception as e:
+            QMessageBox.warning(self, "Warning", f"Invalid format for custom_orders: {e}")
+            new_custom_orders = self.config.get("plot", {}).get("custom_orders", {})
+        self.config.setdefault("plot", {})["custom_orders"] = new_custom_orders
+
+        self.config["plot"]["clockwise"] = self.clockwise_checkbox.isChecked()
+        self.config["plot"]["start"] = self.start_edit.text()
+        QMessageBox.information(self, "Applied", "Configuration updated.")
+
+    def on_save(self):
+        self.apply_changes()
+        self.accept()

MIDRC_MELODY/gui/data_loading.py

@@ -0,0 +1,157 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+#      Licensed under the Apache License, Version 2.0 (the "License");
+#      you may not use this file except in compliance with the License.
+#      You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#      Unless required by applicable law or agreed to in writing, software
+#      distributed under the License is distributed on an "AS IS" BASIS,
+#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#      See the License for the specific language governing permissions and
+#      limitations under the License.
+#
+
+import json
+import yaml
+import os
+
+from PySide6.QtCore import QSettings
+from PySide6.QtWidgets import (
+    QFileDialog,
+    QMessageBox,
+    QDialog,
+)
+from MIDRC_MELODY.gui.config_editor import ConfigEditor
+
+
+def load_config_dict() -> dict:
+    """
+    Load config settings from QSettings or fallback to config.yaml in the repo root.
+    Post-process numeric columns so that any ".inf"/"inf" strings become float("inf").
+    """
+    settings = QSettings("MIDRC", "MIDRC-MELODY")
+    config_str = settings.value("config", "")
+    if config_str:
+        config = json.loads(config_str)
+    else:
+        # Default path: three levels up from this file
+        config_path = os.path.join(os.path.dirname(__file__), ".", ".", ".", "config.yaml")
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = yaml.load(f, Loader=yaml.CLoader)
+        settings.setValue("config", json.dumps(config))
+
+    # Convert any ".inf"/"inf" bins into actual float("inf")
+    if "numeric_cols" in config:
+        for col, d in config["numeric_cols"].items():
+            if "bins" in d:
+                processed_bins = []
+                for b in d["bins"]:
+                    if isinstance(b, (int, float)):
+                        processed_bins.append(b)
+                    else:
+                        try:
+                            if b.strip() in [".inf", "inf"]:
+                                processed_bins.append(float("inf"))
+                            else:
+                                processed_bins.append(float(b))
+                        except Exception:
+                            processed_bins.append(b)
+                config["numeric_cols"][col]["bins"] = processed_bins
+
+    return config
+
+
+@staticmethod
+def save_config_dict(config: dict) -> None:
+    settings = QSettings("MIDRC", "MIDRC-MELODY")
+    settings.setValue("config", json.dumps(config))
+
+
+def load_config_file(parent):
+    """
+    Attempt to load configuration from QSettings. If none exists, prompt the
+    user to pick a YAML/JSON file.  Any errors are shown via QMessageBox.
+    """
+    try:
+        # This will raise if no config is stored in QSettings
+        _ = load_config_dict()
+        QMessageBox.information(parent, "Config Loaded", "Configuration loaded from QSettings.")
+    except Exception:
+        # Prompt user to select a file on disk
+        file_path, _ = QFileDialog.getOpenFileName(
+            parent,
+            "Select Config File",
+            os.path.expanduser("~"),
+            "Config Files (*.yaml *.json);;All Files (*)"
+        )
+        if file_path:
+            try:
+                # Read JSON or YAML and then save into QSettings via save_config_dict
+                if file_path.endswith(".json"):
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        config = json.load(f)
+                else:
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        config = yaml.load(f, Loader=yaml.CLoader)
+
+                save_config_dict(config)  # persist into QSettings
+                QMessageBox.information(parent, "Config Loaded", "Configuration loaded from file.")
+            except Exception as e2:
+                QMessageBox.critical(parent, "Error", f"Failed to load selected config file:\n{e2}")
+        else:
+            QMessageBox.critical(parent, "Error", "No config file selected.")
+
+
+def edit_config_file(parent):
+    """
+    Open the ConfigEditor on the current config (pulled via load_config_dict).
+    If loading fails, ask whether to pick an existing config file or start blank.
+    Upon acceptance, persist via save_config_dict.
+    """
+    try:
+        config = load_config_dict()
+        editor = ConfigEditor(config, parent=parent)
+        if editor.exec() == QDialog.Accepted:
+            save_config_dict(config)
+    except Exception as e:
+        # If load_config_dict() failed, ask user if they want to pick an existing file
+        resp = QMessageBox.question(
+            parent,
+            "Edit Config",
+            f"Failed to load config: {e}\n\nWould you like to select an existing config file?\n"
+            "Press Yes to select a file; or No to create a blank config.",
+            QMessageBox.Yes | QMessageBox.No,
+        )
+        if resp == QMessageBox.Yes:
+            # User chose to pick a file
+            file_path, _ = QFileDialog.getOpenFileName(
+                parent,
+                "Select Config File",
+                os.path.expanduser("~"),
+                "Config Files (*.yaml *.json);;All Files (*)"
+            )
+            if file_path:
+                try:
+                    if file_path.endswith(".json"):
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            config = json.load(f)
+                    else:
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            config = yaml.load(f, Loader=yaml.CLoader)
+                    save_config_dict(config)
+                except Exception as e3:
+                    QMessageBox.critical(parent, "Error", f"Failed to load selected config file: {e3}")
+                    return
+            else:
+                QMessageBox.critical(parent, "Error", "No config file selected.")
+                return
+        else:
+            # User chose “No” → start with a blank config
+            config = {}
+
+        # Finally, open ConfigEditor on whichever config dict we have
+        editor = ConfigEditor(config, parent=parent)
+        if editor.exec() == QDialog.Accepted:
+            save_config_dict(config)

MIDRC_MELODY/gui/main_controller.py

@@ -0,0 +1,154 @@
+#  Copyright (c) 2025 Medical Imaging and Data Resource Center (MIDRC).
+#
+#      Licensed under the Apache License, Version 2.0 (the "License");
+#      you may not use this file except in compliance with the License.
+#      You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#      Unless required by applicable law or agreed to in writing, software
+#      distributed under the License is distributed on an "AS IS" BASIS,
+#      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#      See the License for the specific language governing permissions and
+#      limitations under the License.
+#
+
+import sys
+import time
+from contextlib import ExitStack, redirect_stdout, redirect_stderr
+
+from PySide6.QtWidgets import QMessageBox
+from PySide6.QtGui import QTextCursor
+
+from MIDRC_MELODY.common.data_loading import TestAndDemographicData, build_test_and_demographic_data
+from MIDRC_MELODY.gui.data_loading import load_config_dict
+from MIDRC_MELODY.gui.metrics_model import compute_qwk_metrics, compute_eod_aaod_metrics
+from MIDRC_MELODY.gui.tqdm_handler import Worker, EmittingStream
+
+
+class MainController:
+    def __init__(self, main_window):
+        self.main_window = main_window
+
+    def calculate_qwk(self):
+        """
+        Triggered by the “QWK Metrics” toolbar button.  Loads config, shows the progress view,
+        and spins up a Worker that captures print() → GUI and calls compute_qwk_metrics.
+        """
+        try:
+            config = load_config_dict()
+        except Exception as e:
+            QMessageBox.critical(self.main_window, "Error", f"Failed to load config:\n{e}")
+            return
+
+        # Ensure the “Progress Output” tab is visible before the Worker starts
+        self.main_window.show_progress_view()
+
+        # Create and start a Worker that wraps compute_qwk_metrics
+        worker = self._make_worker(
+            banner="QWK",
+            compute_fn=compute_qwk_metrics,
+            result_handler=self.main_window.update_qwk_tables,
+            config=config,
+        )
+        self.main_window.threadpool.start(worker)
+
+    def calculate_eod_aaod(self):
+        """
+        Triggered by the “EOD/AAOD Metrics” toolbar button.  Loads config, shows the progress view,
+        and spins up a Worker that captures print() → GUI and calls compute_eod_aaod_metrics.
+        """
+        try:
+            config = load_config_dict()
+        except Exception as e:
+            QMessageBox.critical(self.main_window, "Error", f"Failed to load config:\n{e}")
+            return
+
+        self.main_window.show_progress_view()
+
+        worker = self._make_worker(
+            banner="EOD/AAOD",
+            compute_fn=compute_eod_aaod_metrics,
+            result_handler=self.main_window.update_eod_aaod_tables,
+            config=config,
+        )
+        self.main_window.threadpool.start(worker)
+
+    def _make_worker(self, banner: str, compute_fn, result_handler, config: dict):
+        """
+        Internal helper to create a Worker that:
+         1) Redirects stdout/stderr → EmittingStream → main_window.append_progress
+         2) Prints “Computing {banner} metrics…”
+         3) Calls the appropriate compute_fn (either compute_qwk_metrics or compute_eod_aaod_metrics)
+         4) Restores stdout/stderr and returns the result
+
+        Parameters:
+        - banner:          "QWK" or "EOD/AAOD" (used in the printed banner and error dialogs)
+        - compute_fn:      either compute_qwk_metrics or compute_eod_aaod_metrics
+        - result_handler:  a slot on main_window (update_qwk_tables or update_eod_aaod_tables)
+        - config:          the loaded configuration dict
+
+        Returns:
+        - A Worker instance that, when started, will run _task(config) in a background thread.
+        """
+        def _task(cfg):
+            # 1) Save original stdout/stderr so we can restore later
+            original_stdout = sys.stdout
+            original_stderr = sys.stderr
+
+            # 2) Build an EmittingStream and connect its textWritten → append_progress
+            stream = EmittingStream()
+            stream.textWritten.connect(self.main_window.append_progress)
+
+            # 3) Redirect stdout/stderr → EmittingStream
+            with ExitStack() as es:
+                es.enter_context(redirect_stdout(stream))
+                es.enter_context(redirect_stderr(stream))
+
+                # 4) Print the initial banner
+                time_start = time.time()
+                if not self.main_window.progress_view.document().isEmpty():
+                    # Move cursor to the end of the progress view
+                    self.main_window.progress_view.moveCursor(QTextCursor.End)
+                    print('\n', '-'*140, '\n')
+                print(f"Computing {banner} metrics... "
+                      f"(Started at {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time_start))})")
+
+                # 5) Build test data and run the compute function
+                test_data: TestAndDemographicData = build_test_and_demographic_data(cfg)
+                plot_config = cfg.get("plot", None)
+                if compute_fn is compute_eod_aaod_metrics:
+                    # EOD/AAOD needs a threshold from cfg (default to 0.5)
+                    threshold = cfg.get("binary threshold", 0.5)
+                    result = compute_fn(test_data, threshold, plot_config)
+                else:
+                    # QWK just takes test_data
+                    result = compute_fn(test_data, plot_config)
+
+                print(f"Finished {banner} metrics in {time.time() - time_start:.2f} seconds.")
+
+            # 6) Restore original stdout/stderr so further print() goes to console
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+
+            # 7) Return the computed result, e.g.
+            #    - For QWK: (all_rows, filtered_rows, kappas_rows, plot_args), reference_groups
+            #    - For EOD/AAOD: (all_eod_rows, all_aaod_rows, filtered_rows, plot_args), reference_groups
+            return result, test_data.reference_groups
+
+        # Instantiate the Worker around our _task function + config dict
+        worker = Worker(_task, config)
+
+        # Connect the result signal to the appropriate table‐update slot
+        worker.signals.result.connect(result_handler)
+
+        # Connect any error to a QMessageBox
+        worker.signals.error.connect(
+            lambda e: QMessageBox.critical(
+                self.main_window,
+                "Error",
+                f"Error in {banner} Metrics:\n{e}"
+            )
+        )
+
+        return worker