MIDRC-MELODY 0.3.3__py3-none-any.whl

MIDRC_MELODY/gui/tqdm_handler.py

@@ -0,0 +1,210 @@
+"""ANSI escape sequence processor and worker/thread helpers for GUI."""
+
+import re
+from typing import Final, Optional
+
+from PySide6.QtCore import QObject, QRunnable, Signal
+from PySide6.QtGui import QFont, QTextCharFormat, QTextCursor
+from PySide6.QtWidgets import QPlainTextEdit
+
+__all__ = ["ANSIProcessor", "EmittingStream", "Worker"]
+
+_CSI_RE: Final[re.Pattern] = re.compile(r"\x1b\[(\d*)([A-Za-z])")
+
+
+def _next_csi_is_cursor_up(buf: str, pos: int) -> bool:
+    """Return True if next CSI sequence at pos is 'cursor up' (A)."""
+    if pos >= len(buf) or buf[pos] != "\x1b":
+        return False
+    match = _CSI_RE.match(buf, pos)
+    return bool(match and match.group(2) == "A")
+
+
+class ANSIProcessor:
+    """Process ANSI control sequences and render them in a QPlainTextEdit."""
+
+    @staticmethod
+    def process(console: QPlainTextEdit, chunk: str) -> None:
+        """
+        Parse chunk for ANSI escapes, updating the console widget.
+
+        Args:
+            console: Target QPlainTextEdit.
+            chunk: Text with possible ANSI sequences.
+        """
+        ANSIProcessor._ensure_console_flags(console)
+        cursor = console.textCursor()
+        i, n = 0, len(chunk)
+        text_buf: list[str] = []
+
+        while i < n:
+            if console._nl_pending:  # type: ignore[attr-defined]
+                ANSIProcessor._commit_pending_newline(console, cursor, chunk, i)
+
+            ch = chunk[i]
+            if ch == "\r":  # Handle carriage return
+                if text_buf:
+                    cursor.insertText("".join(text_buf))
+                    text_buf.clear()
+                ANSIProcessor._handle_carriage_return(cursor)
+                i += 1
+                continue
+
+            if ch == "\n":  # Handle line feed
+                if text_buf:
+                    cursor.insertText("".join(text_buf))
+                    text_buf.clear()
+                ANSIProcessor._handle_line_feed(cursor)
+                i += 1
+                continue
+
+            if ch == "\x1b":  # Handle CSI (Control Sequence Introducer) sequence
+                if text_buf:
+                    cursor.insertText("".join(text_buf))
+                    text_buf.clear()
+                new_pos = ANSIProcessor._handle_csi(console, cursor, chunk, i)
+                if new_pos is not None:
+                    i = new_pos
+                    continue
+
+            text_buf.append(ch)
+            i += 1
+
+        if text_buf:
+            cursor.insertText("".join(text_buf))
+
+        console.setTextCursor(cursor)
+        console.ensureCursorVisible()
+
+    @staticmethod
+    def _ensure_console_flags(console: QPlainTextEdit) -> None:
+        """Initialize internal flags for ANSI processing on the widget."""
+        if not hasattr(console, "_nl_pending"):
+            console._nl_pending = False  # type: ignore[attr-defined]
+        if not hasattr(console, "_ansi_fmt"):
+            console._ansi_fmt = QTextCharFormat()  # type: ignore[attr-defined]
+
+    @staticmethod
+    def _commit_pending_newline(
+        console: QPlainTextEdit, cursor: QTextCursor, buf: str, pos: int
+    ) -> None:
+        """Insert a newline unless the next sequence is cursor-up."""
+        if not _next_csi_is_cursor_up(buf, pos):
+            cursor.insertBlock()
+        console._nl_pending = False  # type: ignore[attr-defined]
+
+    @staticmethod
+    def _handle_carriage_return(cursor: QTextCursor) -> None:
+        """Handle '\\r': move to start of line and clear it."""
+        cursor.movePosition(QTextCursor.StartOfLine)
+        cursor.select(QTextCursor.LineUnderCursor)
+        cursor.removeSelectedText()
+
+    @staticmethod
+    def _handle_line_feed(cursor: QTextCursor) -> None:
+        """Handle '\\n': move down or insert a new block then start of line."""
+        if not cursor.movePosition(QTextCursor.Down):
+            cursor.insertBlock()
+        cursor.movePosition(QTextCursor.StartOfLine)
+
+    @staticmethod
+    def _handle_csi(
+        console: QPlainTextEdit,
+        cursor: QTextCursor,
+        buf: str,
+        pos: int,
+    ) -> Optional[int]:
+        """
+        Process CSI (Control Sequence Introducer) sequences.
+
+        Returns:
+            Position after CSI if handled, otherwise None.
+        """
+        match = _CSI_RE.match(buf, pos)
+        if not match:
+            return None
+
+        count = int(match.group(1) or 1)
+        cmd = match.group(2)
+
+        if cmd == "A":  # Cursor Up
+            for _ in range(count):
+                cursor.movePosition(QTextCursor.Up)
+            cursor.movePosition(QTextCursor.StartOfLine)
+            return match.end()
+
+        if cmd == "K":  # Erase Line
+            cursor.select(QTextCursor.LineUnderCursor)
+            cursor.removeSelectedText()
+            cursor.movePosition(QTextCursor.StartOfLine)
+            return match.end()
+
+        if cmd == "m":  # Set Graphics Rendition (text style: e.g. bold, reset, etc.)
+            for part in (match.group(1) or "0").split(";"):
+                style = part or "0"
+                if style == "0":
+                    console._ansi_fmt = QTextCharFormat()  # type: ignore[attr-defined]
+                elif style == "1":
+                    console._ansi_fmt.setFontWeight(QFont.Bold)
+                elif style == "22":
+                    console._ansi_fmt.setFontWeight(QFont.Normal)
+            cursor.setCharFormat(console._ansi_fmt)
+            return match.end()
+
+        return None
+
+
+class EmittingStream(QObject):
+    """A text stream that emits data via Qt signals."""
+
+    textWritten: Signal = Signal(str)
+
+    def write(self, data: str) -> None:
+        """Emit chunk of text written to this stream."""
+        text = str(data)
+        if text:
+            self.textWritten.emit(text)
+
+    def flush(self) -> None:
+        """No-op flush to satisfy stream interface."""
+        pass
+
+    def isatty(self) -> bool:
+        """Indicate this stream behaves like a terminal."""
+        return True
+
+
+class WorkerSignals(QObject):
+    """Signals for Worker: finished, error, and result."""
+    finished: Signal = Signal()
+    error: Signal = Signal(str)
+    result: Signal = Signal(object)
+
+
+class Worker(QRunnable):
+    """
+    QRunnable wrapper to execute a function in a separate thread.
+
+    Args:
+        fn: Callable to run.
+        *args: Positional args for fn.
+        **kwargs: Keyword args for fn.
+    """
+
+    def __init__(self, fn, *args, **kwargs) -> None:
+        super().__init__()
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+        self.signals = WorkerSignals()
+
+    def run(self) -> None:
+        """Execute the function and emit result, error, and finished signals."""
+        try:
+            result = self.fn(*self.args, **self.kwargs)
+        except Exception as exc:
+            self.signals.error.emit(str(exc))
+        else:
+            self.signals.result.emit(result)
+        finally:
+            self.signals.finished.emit()

MIDRC_MELODY/melody.py

@@ -0,0 +1,102 @@
+#  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
+
+from MIDRC_MELODY.common.edit_config import edit_config
+from MIDRC_MELODY.common.generate_eod_aaod_spiders import generate_eod_aaod_spiders
+from MIDRC_MELODY.common.generate_qwk_spiders import generate_qwk_spiders
+
+try:
+    from PySide6.QtWidgets import QWidget  # noqa: F401
+    GUI_AVAILABLE = True
+except ImportError:
+    GUI_AVAILABLE = False
+
+
+def show_config(path):
+    """Print out the YAML config file at `path`."""
+    try:
+        print(open(path, encoding='utf-8').read())
+    except Exception as e:
+        print(f"Error reading config: {e}")
+
+
+def _launch_gui():
+    """Launch the GUI if available."""
+    try:
+        from MIDRC_MELODY.melody_gui import launch_gui
+    except ImportError as e1:
+        try:
+            from melody_gui import launch_gui
+        except ImportError as e2:
+            e = e2 if str(e1) == "No module named 'MIDRC_MELODY.melody_gui'" else (
+                str(e1) + "\n" + str(e2) if str(e2) != "No module named 'melody_gui'" else e1)
+            print('-' * 50)
+            print(f"GUI is not available, import failed with error:\n{e}")
+            print('-' * 50)
+            return
+    launch_gui()
+
+
+def set_config(current_path):
+    """Prompt for a new path and return it (or the old one)."""
+    new = input(f"Enter new config path [{current_path}]: ").strip()
+    return new or current_path
+
+
+def quit_program(_=None):
+    print("Goodbye!")
+    sys.exit(0)
+
+
+def main():
+    # wrap your mutable state in a dict
+    state = {"config_path": "config.yaml"}
+
+    commands = {
+        "1": ("Calculate QWK metrics",
+              lambda: generate_qwk_spiders(cfg_path=state["config_path"])),
+        "2": ("Calculate EOD/AAOD metrics",
+              lambda: generate_eod_aaod_spiders(cfg_path=state["config_path"])),
+    }
+    if GUI_AVAILABLE:
+        commands["3"] = ("Launch GUI", lambda: _launch_gui())
+    commands["s"] = ("Show current config file contents", lambda: show_config(state["config_path"]))
+    commands["f"] = ("Change config file path", lambda: state.update(config_path=set_config(state["config_path"])))
+    commands["e"] = ("Edit config file", lambda: edit_config(state["config_path"]))
+    commands["q"] = ("Quit", quit_program)
+
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+    while True:
+        print("\n=== MIDRC‑MELODY Menu ===")
+        print(f"Current config file path: {BOLD}{state['config_path']}{RESET}")
+        for key, (desc, _) in commands.items():
+            print(f"  {key}) {desc}")
+        choice = input("Select an option: ").strip()
+
+        action = commands.get(choice)
+        if not action:
+            print(f"  ❌  '{choice}' is not a valid choice.")
+            continue
+
+        # call the handler
+        _, handler = action
+        handler()
+
+
+if __name__ == "__main__":
+    main()

MIDRC_MELODY/melody_gui.py

@@ -0,0 +1,111 @@
+#  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 importlib import resources as _resources
+import sys
+try:
+    from PySide6.QtWidgets import QApplication
+    from PySide6.QtCore import QTimer, Qt
+    from PySide6.QtGui import QIcon, QPixmap
+    from MIDRC_MELODY.gui.main_window import MainWindow  # Import the custom MainWindow
+except ImportError as e:
+    raise ImportError("To use the GUI features, please install the package PySide6.\n"
+                      "You can install it using the command:\n"
+                      "pip install PySide6\n"
+                      "\n"
+                      "Error details: " + str(e))
+
+
+# Global list to hold window references.
+_open_windows = []
+
+def _load_package_icon() -> QIcon:
+    """
+    Load the bundled icon from the installed package resources.
+    Uses importlib.resources.files(...) with the current package name.
+    """
+    try:
+        pkg = __package__ or "MIDRC_MELODY"
+        data = _resources.files(pkg).joinpath("resources", "MIDRC.ico").read_bytes()
+        pix = QPixmap()
+        pix.loadFromData(data)
+        return QIcon(pix)
+    except Exception:
+        return QIcon()
+
+# optional: import ctypes only on Windows
+_ctypes = None
+if sys.platform == "win32":
+    try:
+        import ctypes as _ctypes
+    except Exception:
+        _ctypes = None
+
+def _set_windows_appid(appid: str) -> None:
+    """
+    On Windows set an explicit AppUserModelID so the taskbar uses the correct icon.
+    Must be called before creating any windows / QApplication.
+    """
+    if sys.platform != "win32" or _ctypes is None:
+        return
+    try:
+        _ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(appid)
+    except Exception:
+        # best-effort; ignore failures
+        pass
+
+def launch_gui() -> None:
+    _set_windows_appid("com.midrc.melody")
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication([])
+        new_app = True
+    else:
+        new_app = False
+
+    icon = _load_package_icon()
+    if not icon.isNull():
+        app.setWindowIcon(icon)
+
+    window = MainWindow()
+    if not icon.isNull():
+        window.setWindowIcon(icon)
+    _open_windows.clear()
+    _open_windows.append(window)
+    
+    # Store original window flags
+    original_flags = window.windowFlags()
+    
+    window.show()
+    # Temporarily add the always-on-top flag without losing other flags.
+    QTimer.singleShot(100, lambda: (
+         window.setWindowFlags(original_flags | Qt.WindowStaysOnTopHint),
+         window.show()
+    ))
+    # After a short delay, restore the original flags with the window still in the front.
+    QTimer.singleShot(300, lambda: (
+         window.setWindowFlags(original_flags),
+         window.show()
+    ))
+    if new_app:
+        app.exec()
+
+
+def main():
+    launch_gui()
+
+
+if __name__ == "__main__":
+    main()

midrc_melody-0.3.3.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: MIDRC_MELODY
+Version: 0.3.3
+Summary: MELODY: Model EvaLuation across subgroups for cOnsistent Decision accuracY
+Author-email: Robert Tomek <rtomek@uchicago.edu>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/MIDRC/MIDRC_MELODY
+Project-URL: Issues, https://github.com/MIDRC/MIDRC_MELODY/issues
+Keywords: machine-learning,model-evaluation,fairness,subgroup-analysis
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: PyYAML
+Requires-Dist: joblib
+Requires-Dist: tqdm
+Requires-Dist: tabulate
+Requires-Dist: tqdm-joblib
+Requires-Dist: mplcursors
+Requires-Dist: windows-curses; sys_platform == "win32"
+Requires-Dist: PySide6>=6.8.0
+Dynamic: license-file
+
+# MIDRC MELODY (Model EvaLuation across subgroups for cOnsistent Decision accuracY)
+
+[Overview](#overview) | [Installation](#installation) | [CLI Commands](#cli-commands) | [Configuration](#configuration) | [License](#license)
+
+[📱 Visit MIDRC Website](https://www.midrc.org/)
+
+**MIDRC MELODY** is a tool designed to assess the performance and subgroup-level reliability and robustness of AI models
+developed for medical imaging analysis tasks, such as the estimation of disease severity. It enables consistent
+evaluation of models across predefined subgroups (e.g. manufacturer, race, scanner type) by computing intergroup
+performance metrics and corresponding confidence intervals.
+
+The tool supports two types of evaluation:
+
+- **Ordinal Estimation Task Evaluation**:
+  - Uses an ordinal reference standard ("truth") and ordinal AI model outputs.
+  - Performance in terms of agreement of AI output with the reference standard "truth" is quantified using the **quadratic
+    weighted kappa (QWK)** metric.
+- **Binary Decision Task Evaluation**:
+  - Converts scores into binary decisions based on a threshold.
+  - Computes **Equal Opportunity Difference (EOD)** and **Average Absolute Odds Difference (AAOD)** metrics using bootstrapping across various groups.
+- Generates spider plots comparing these metrics.
+- Saves the generated data for further analysis.
+
+### Data Processing and Visualization
+
+- **Bootstrapping:** Both scripts perform bootstrapping to compute confidence intervals for the respective metrics using NumPy's percentile method.
+- **Plotting:** Spider charts provide a visual overview of how each model's metrics vary across different groups and categories.
+- **Utilities:** Shared functionality is available in common utility modules (e.g., `data_tools.py` and `plot_tools.py`), ensuring easier maintenance and testing.
+
+## Overview
+
+**MIDRC MELODY** is a lightweight toolkit for stress‑testing medical‑imaging AI models across clinical and demographic sub‑groups. It supports both command‑line and GUI workflows, enabling rapid quantification of performance disparities (QWK, EOD, AAOD, etc.) and intuitive radar‑chart visualisation.
+
+- **Console‑first** – core metrics and plots run with **no GUI dependencies**.
+- **Opt‑in GUI** – an optional PySide6 interface for interactive configuration and result browsing.
+- **Config‑driven** – YAML files keep experiments reproducible and shareable.
+
+## Installation
+
+```bash
+# Standard console install from PyPI
+pip install midrc-melody
+
+# (Alternative) Install in editable/development mode from source code
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Run analysis (reads default config.yaml in current directory)
+melody
+
+# Launch the GUI
+melody_gui
+```
+
+## CLI Commands
+
+Running `melody` opens a **Command‑Line Interface (CLI)**, which presents a text‑based menu of interactive commands. Here’s what you can do:
+
+#### Available Commands
+
+- **Calculate QWK metrics**: Computes delta QWK values for different subgroups and generates spider plots.
+- **Calculate EOD and AAOD metrics**: Computes EOD and AAOD metrics for binary decision tasks and generates spider plots.
+- **Print config file contents**: Displays the contents of the current YAML configuration file.
+- **Change config file**: Prompts you to enter and set a different configuration file path.
+- **Launch GUI**: Opens the Graphical User Interface (GUI) using PySide6 (requires PySide6).
+- **Exit**: Exits the program.
+
+## GUI (Optional)
+
+Launching the graphical interface only requires that PySide6 is installed. If you used pip, the `melody_gui` command is available.
+
+```bash
+# Launch the GUI:
+melody_gui
+```
+
+## Configuration
+
+Experiments are described in a single YAML file. Below is a **minimal** example that keeps storage light and avoids plotting custom order metadata.
+
+```yaml
+input data:
+  truth file: data/demo_truthNdemographics.csv
+  test scores: data/demo_scores.csv
+  uid column: case_name
+  truth column: truth
+
+# Scores ≥ binary threshold are counted as positive
+binary threshold: 4
+min count per category: 10
+
+bootstrap:
+  iterations: 1000
+  seed: 42  # set to null for random entropy
+
+output:
+  qwk:  { save: false, file prefix: output/delta_kappas_ }
+  eod:  { save: false, file prefix: output/eod_ }
+  aaod: { save: false, file prefix: output/aaod_ }
+
+numeric_cols:
+  age_binned:
+    raw column: age
+    bins: [0, 18, 30, 40, 50, 65, 75, 85, .inf]
+
+plot:
+  clockwise: true            # rotate clockwise instead of CCW
+  start: top                 # starting angle: top, bottom, left, right (t/b/l/r)
+```
+
+## Input Data
+
+| File           | Required Columns            | Purpose                                   | Example                                            |
+| -------------- | --------------------------- | ----------------------------------------- |----------------------------------------------------|
+| **Truth file** | `uid`, `truth`, attributes… | Ground‑truth labels and subgroup columns. | [demo_truth.csv](data/demo_truthNdemographics.csv) |
+| **Score file** | `uid`, `score`              | Model predictions keyed to the same UID.  | [demo_scores.csv](data/demo_scores.csv)            |
+
+> UID values must match between truth and score files.
+
+## License
+
+Distributed under the Apache 2.0 License.
+

midrc_melody-0.3.3.dist-info/RECORD

@@ -0,0 +1,37 @@
+MIDRC_MELODY/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MIDRC_MELODY/__main__.py,sha256=0iJVMq84JaIZHWWBVb2Ly_ea1diOW3V6wSAoZbABDZs,67
+MIDRC_MELODY/melody.py,sha256=5K8-mROTlG2Bm2qUGYflTCf9aErW5RyfHHrbGWbq_wA,3564
+MIDRC_MELODY/melody_gui.py,sha256=IIN9Lz_7ADoeaOzZGiXSifVnNyPKkv_Ak1lPPZkSTxY,3559
+MIDRC_MELODY/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MIDRC_MELODY/common/data_loading.py,sha256=MRX0B3aw9Y8x94pSWcHF-RHneoz4HGwLIQJ_BhLbcak,7648
+MIDRC_MELODY/common/data_preprocessing.py,sha256=oKpfl14-nM_X9u6Rkpp6kKMGSK12zt4Cvd-rn-pxzz0,5291
+MIDRC_MELODY/common/edit_config.py,sha256=q6gZiy-sA6sY9bD_tP4w1fwpFls4zHDi1_YPegoD17U,4740
+MIDRC_MELODY/common/eod_aaod_metrics.py,sha256=nCJ9g1kMKA5NY-JasI3kITozsbF_XdVZcv8NOD-DNmI,11733
+MIDRC_MELODY/common/generate_eod_aaod_spiders.py,sha256=qe4WkUA_j50yjzW65orWyfBuHeZG9ULcuuJ3cq3ei0A,2954
+MIDRC_MELODY/common/generate_qwk_spiders.py,sha256=MRplmYU3N5AX-p8FBOVg3jI8OMo8RSwql5Sgiq-t8hI,2252
+MIDRC_MELODY/common/matplotlib_spider.py,sha256=G7ILK3hS7CcxJUXtYGSXTJKyIzyh3qbLbh-jNlSJ7BM,15478
+MIDRC_MELODY/common/plot_tools.py,sha256=TV3az3geV7Y3w8DszjP0umnUqLqfc6jg_rhl_6DyAmA,4874
+MIDRC_MELODY/common/plotly_spider.py,sha256=asUki0EeWwonJCQhCZrC2pIquIM7HJc9oGcUeBmjuUA,9218
+MIDRC_MELODY/common/qwk_metrics.py,sha256=yucVOumytQS_CvndqRpkuSs_LaRU71zTWkhZRGHT90M,10379
+MIDRC_MELODY/common/table_tools.py,sha256=zMVmOQs7U4TDiyhHF1e_GYHYvmKxypSrgu6gyikLItk,9251
+MIDRC_MELODY/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MIDRC_MELODY/gui/config_editor.py,sha256=q_NNBnj4VAvCQ6-KINBe5mhUVTHKbibK7kUTvXMjkXk,9420
+MIDRC_MELODY/gui/data_loading.py,sha256=AfAFfle0lMrE4BOfepzy2aSEM5k4oT279G5xFi1-Z7U,6456
+MIDRC_MELODY/gui/main_controller.py,sha256=4ZJPAzzq3TE2cKy8UlkniPV6VKBf6qMVkBZNk4HZu2c,6809
+MIDRC_MELODY/gui/main_window.py,sha256=1wF6qw8m_C7l3i1nGGUO9pyV9a3v4oNLVkhTYhA1Cxc,20191
+MIDRC_MELODY/gui/matplotlib_spider_widget.py,sha256=yxuVPIPEtWXqmCacfsG6XexNLST1gd1ykD_BpJygMC4,8185
+MIDRC_MELODY/gui/metrics_model.py,sha256=bVlQSrh8JQJUGCXgoO8Vm6Hbf-W1fKjvtcuyYTafWjQ,3046
+MIDRC_MELODY/gui/plotly_spider_widget.py,sha256=SQOEATppxVfxrHTFkjD-d5F6cKvxtfBCsDbIP7RxLO8,2193
+MIDRC_MELODY/gui/qchart_spider_widget.py,sha256=iBXc-w9So2re2aFFszqMV_BFcU18tV6JpO5NBo4f8Cs,10437
+MIDRC_MELODY/gui/tqdm_handler.py,sha256=drMVl9c5Rc6rPogD0pMaeFvyhHTXcqtUUU2I-W6D318,7143
+MIDRC_MELODY/gui/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MIDRC_MELODY/gui/shared/react/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MIDRC_MELODY/gui/shared/react/copyabletableview.py,sha256=jn_9RvlX2uU8Ib6KRCqmHGbnmtvU3Hu8DrUWuimgyGU,3668
+MIDRC_MELODY/gui/shared/react/grabbablewidget.py,sha256=a7Z736TmtShki8nKSWVzTlaw53-TqxIRN1r3OyOr1K4,15569
+MIDRC_MELODY/resources/MIDRC.ico,sha256=xvcK2nPPuOdqNsxBNdRxOKuXbCQ6J-cTuxDKQ6yX-qI,4022
+midrc_melody-0.3.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+midrc_melody-0.3.3.dist-info/METADATA,sha256=WEGNWJokukCKF8weu88AYv5hfvYf87F0yOoe-geU8_o,6289
+midrc_melody-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+midrc_melody-0.3.3.dist-info/entry_points.txt,sha256=O9uD1ZfwtlU7C9lAMiWEbh-19GGgCOw83cMqO-9iF5E,136
+midrc_melody-0.3.3.dist-info/top_level.txt,sha256=2lK9hz0vJgDTCknUwOlanlf38tRV5RrDQVFwHxwjqQ0,13
+midrc_melody-0.3.3.dist-info/RECORD,,

midrc_melody-0.3.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

midrc_melody-0.3.3.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+melody = MIDRC_MELODY.melody:main
+melody-gui = MIDRC_MELODY.melody_gui:main
+melody_gui = MIDRC_MELODY.melody_gui:main