dasmixer-gui 0.6.0a2__tar.gz

dasmixer_gui-0.6.0a2/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: dasmixer-gui
+Version: 0.6.0a2
+Summary: DASMixer GUI — Flet-based desktop application
+Author: gluck
+Author-email: glucksistemi@gmail.com
+Requires-Python: <4.0, >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: dasmixer-core[all] (==0.5.0)
+Requires-Dist: flet[all] (>=0.80.4,<0.81.0)
+Requires-Dist: pythonnet (==3.0.5) ; sys_platform == "win32" and python_version < "3.14"
+Requires-Dist: pythonnet (==3.1.0rc0) ; sys_platform == "win32" and python_version == "3.14"
+Requires-Dist: pywebview (>=6.1,<7) ; sys_platform == "win32"
+Requires-Dist: pywebview[gtk] (>=6.1,<7) ; sys_platform == "linux"
+Project-URL: Homepage, https://github.com/protdb/dasmixer
+Description-Content-Type: text/markdown
+
+# DASMixer GUI
+
+Cross-platform desktop graphical interface for comparative proteomics, built with Flet.
+
+## Features
+
+- **Project management** — create, open, configure projects
+- **Sample management** — import spectra (MGF), identifications (PowerNovo2, MaxQuant, PLGS), proteins (FASTA)
+- **Peptide analysis** — ion spectra visualization, PPM/coverage validation, cross-tool comparison
+- **Protein analysis** — detection, quantification (LFQ), UniProt enrichment
+- **Reports** — interactive PCA, Volcano, UpSet, Coverage, Sample Summary with HTML/DOCX/XLSX export
+- **Plugins** — extend parsers and reports via `.py` files
+
+## Installation
+
+```bash
+pip install dasmixer-gui
+# or the full metapackage:
+pip install dasmixer
+```
+
+## Launch
+
+```bash
+dasmixer                    # Open GUI
+dasmixer path/to/project.dasmix  # Open specific project
+```
+
+## Requirements
+
+- Python ≥ 3.11
+- Linux (GTK), Windows
+- For Kaleido export: Chrome (downloaded automatically on first run)
+
+Documentation: https://github.com/protdb/dasmixer

dasmixer_gui-0.6.0a2/README.md

@@ -0,0 +1,35 @@
+# DASMixer GUI
+
+Cross-platform desktop graphical interface for comparative proteomics, built with Flet.
+
+## Features
+
+- **Project management** — create, open, configure projects
+- **Sample management** — import spectra (MGF), identifications (PowerNovo2, MaxQuant, PLGS), proteins (FASTA)
+- **Peptide analysis** — ion spectra visualization, PPM/coverage validation, cross-tool comparison
+- **Protein analysis** — detection, quantification (LFQ), UniProt enrichment
+- **Reports** — interactive PCA, Volcano, UpSet, Coverage, Sample Summary with HTML/DOCX/XLSX export
+- **Plugins** — extend parsers and reports via `.py` files
+
+## Installation
+
+```bash
+pip install dasmixer-gui
+# or the full metapackage:
+pip install dasmixer
+```
+
+## Launch
+
+```bash
+dasmixer                    # Open GUI
+dasmixer path/to/project.dasmix  # Open specific project
+```
+
+## Requirements
+
+- Python ≥ 3.11
+- Linux (GTK), Windows
+- For Kaleido export: Chrome (downloaded automatically on first run)
+
+Documentation: https://github.com/protdb/dasmixer

dasmixer_gui-0.6.0a2/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "dasmixer-gui"
+version = "0.6.0a2"
+description = "DASMixer GUI — Flet-based desktop application"
+authors = [
+    {name = "gluck", email = "glucksistemi@gmail.com"}
+]
+readme = "README.md"
+requires-python = "<4.0, >=3.11"
+urls = {Homepage = "https://github.com/protdb/dasmixer"}
+dependencies = [
+    "dasmixer-core[all] ==0.5.0",
+    "flet[all] >=0.80.4,<0.81.0",
+    "pywebview[gtk] >=6.1,<7 ; sys_platform == 'linux'",
+    "pywebview >=6.1,<7 ; sys_platform == 'win32'",
+    "pythonnet ==3.1.0rc0 ; sys_platform == 'win32' and python_version >= '3.14' and python_version < '3.15'",
+    "pythonnet ==3.0.5 ; sys_platform == 'win32' and python_version < '3.14'",
+]
+
+[project.scripts]
+dasmixer = "dasmixer.gui.main:app"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+packages = [
+    {include = "dasmixer/gui", from = "src"},
+]
+
+[tool.poetry.dependencies]
+dasmixer-core = {path = "../dasmixer-core", develop = true}
+pythonnet = [
+    {version = "==3.1.0rc0", python = ">=3.14,<3.15", markers = "sys_platform == 'win32'", allow-prereleases = true},
+    {version = "==3.0.5", python = ">=3.11,<3.14", markers = "sys_platform == 'win32'"},
+]

dasmixer_gui-0.6.0a2/src/dasmixer/gui/__init__.py

@@ -0,0 +1,3 @@
+"""GUI package for DASMixer."""
+
+# GUI implementation will be added in stage 3

dasmixer_gui-0.6.0a2/src/dasmixer/gui/actions/__init__.py

@@ -0,0 +1,21 @@
+"""
+GUI action classes for DASMixer calculation pipelines.
+
+Each action class wraps a calculation pipeline and provides:
+- Progress dialog management
+- Error/success snackbar messages
+- Optional sample_id filtering for per-sample operations
+"""
+
+from .ion_actions import IonCoverageAction, SelectPreferredAction
+from .protein_map_action import MatchProteinsAction
+from .protein_ident_action import ProteinIdentificationsAction
+from .lfq_action import LFQAction
+
+__all__ = [
+    'IonCoverageAction',
+    'SelectPreferredAction',
+    'MatchProteinsAction',
+    'ProteinIdentificationsAction',
+    'LFQAction',
+]

dasmixer_gui-0.6.0a2/src/dasmixer/gui/actions/base.py

@@ -0,0 +1,47 @@
+"""Base class for all GUI action handlers."""
+
+import flet as ft
+
+from dasmixer.api.project.project import Project
+from dasmixer.gui.views.tabs.peptides.dialogs.progress_dialog import ProgressDialog
+from dasmixer.gui.utils import show_snack
+
+
+class BaseAction:
+    """
+    Base class for calculation action handlers.
+
+    Provides helpers for progress dialogs and snackbar messages.
+    All concrete action classes inherit from this.
+    """
+
+    def __init__(self, project: Project, page: ft.Page):
+        self.project = project
+        self.page = page
+
+    # ------------------------------------------------------------------
+    # Snackbar helpers
+    # ------------------------------------------------------------------
+
+    def show_error(self, message: str) -> None:
+        show_snack(self.page, message, ft.Colors.RED_400)
+        self.page.update()
+
+    def show_success(self, message: str) -> None:
+        show_snack(self.page, message, ft.Colors.GREEN_400)
+        self.page.update()
+
+    def show_warning(self, message: str) -> None:
+        show_snack(self.page, message, ft.Colors.ORANGE_400)
+        self.page.update()
+
+    def show_info(self, message: str) -> None:
+        show_snack(self.page, message, ft.Colors.BLUE_400)
+        self.page.update()
+
+    # ------------------------------------------------------------------
+    # Progress dialog helpers
+    # ------------------------------------------------------------------
+
+    def make_progress_dialog(self, title: str, stoppable: bool = False) -> ProgressDialog:
+        return ProgressDialog(self.page, title, stoppable=stoppable)

dasmixer_gui-0.6.0a2/src/dasmixer/gui/actions/ion_actions.py

@@ -0,0 +1,343 @@
+"""Ion coverage and preferred identification selection actions."""
+
+import asyncio
+import math
+import os
+from concurrent.futures import ProcessPoolExecutor
+
+import flet as ft
+
+from dasmixer.utils import logger
+from dasmixer.api.project.project import Project
+from dasmixer.api.config import config as _config
+from dasmixer.api.calculations.spectra.ion_match import IonMatchParameters
+from dasmixer.api.calculations.spectra.coverage_worker import process_peptide_match_batch
+from dasmixer.api.calculations.spectra.identification_processor import process_identificatons_batch
+from dasmixer.api.calculations.peptides.matching import calculate_preferred_identifications_for_file
+from dasmixer.gui.views.tabs.peptides.shared_state import PeptidesTabState
+from .base import BaseAction
+
+
+class IonCoverageAction(BaseAction):
+    """
+    Calculate ion coverage + PPM + theor_mass + override_charge for identifications.
+
+    Extracted from IonCalculations.run_coverage_calc().
+    Supports optional per-sample filtering via spectra_file_ids.
+    """
+
+    def __init__(self, project: Project, page: ft.Page):
+        super().__init__(project, page)
+
+    async def run(
+        self,
+        state: PeptidesTabState,
+        recalc_all: bool = False,
+        sample_id: int | None = None,
+    ) -> None:
+        """
+        Run ion coverage calculation.
+
+        Args:
+            state: PeptidesTabState with ion settings.
+            recalc_all: If True, recalculate all; otherwise only missing.
+            sample_id: If provided, only process identifications for this sample.
+        """
+        # Get batch size and worker count from config
+        batch_size = _config.identification_processing_batch_size
+        worker_count = _config.max_cpu_threads or max(1, (os.cpu_count() or 2) - 1)
+        
+        # Persist current ion settings
+        if self.page and hasattr(self.page, 'peptides_tab'):
+            ion_section = self.page.peptides_tab.sections.get('ion_settings')
+            if ion_section and hasattr(ion_section, 'save_settings'):
+                await ion_section.save_settings()
+
+        params = IonMatchParameters(
+            ions=state.ion_types,
+            tolerance=state.ion_ppm_threshold,
+            mode='largest',
+            water_loss=state.water_loss,
+            ammonia_loss=state.nh3_loss,
+            charges=state.fragment_charges
+        )
+        params_dict = {
+            'ions': params.ions,
+            'tolerance': params.tolerance,
+            'mode': params.mode,
+            'water_loss': params.water_loss,
+            'ammonia_loss': params.ammonia_loss,
+        }
+        fragment_charges = list(state.fragment_charges)
+        target_ppm = state.ion_ppm_threshold
+        min_charge = state.min_precursor_charge
+        max_charge = state.max_precursor_charge
+        force_isotope_offset = state.force_isotope_offset
+        max_isotope_offset = state.max_isotope_offset
+        seq_criteria = state.seq_criteria
+
+        tool_ids = list(state.tool_settings_controls.keys())
+        if not tool_ids:
+            self.show_warning("No tools configured")
+            return
+
+        # Per-tool PTM settings
+        max_ptm_sites = state.max_ptm_sites
+
+        tool_settings_map = {}
+        for tid, controls in state.tool_settings_controls.items():
+            ptm_selected: list[str] = controls.get('ptm_selected', [])
+            from dasmixer.utils.seqfixer_utils import PTMS as _ALL_PTMS
+            all_codes = {p.code for p in _ALL_PTMS}
+            ptm_list = None if set(ptm_selected) == all_codes else ptm_selected
+            max_ptm_ctrl = controls.get('max_ptm')
+            try:
+                max_ptm = int(max_ptm_ctrl.value) if max_ptm_ctrl else 5
+            except (ValueError, AttributeError):
+                max_ptm = 5
+            tool_settings_map[tid] = {'ptm_list': ptm_list, 'max_ptm': max_ptm}
+
+        only_missing = not recalc_all
+
+        # Resolve spectra_file_ids for sample filter
+        spectra_file_ids: list[int] | None = None
+        if sample_id is not None:
+            sf_df = await self.project.get_spectra_files(sample_id=sample_id)
+            if sf_df.empty:
+                self.show_warning(f"No spectra files for sample id={sample_id}")
+                return
+            spectra_file_ids = list(sf_df['id'].astype(int))
+
+        from dasmixer.gui.views.tabs.peptides.dialogs.progress_dialog import ProgressDialog
+        dialog = ProgressDialog(self.page, "Calculating Ion Coverage", stoppable=True)
+        dialog.show()
+        dialog.update_progress(None, "Preparing...", "Counting identifications...")
+
+        # Count after dialog is visible so the UI doesn't appear frozen
+        total_count = 0
+        for tool_id in tool_ids:
+            total_count += await self.project.get_identifications_count(
+                tool_id=tool_id,
+                only_missing=only_missing,
+                spectra_file_ids=spectra_file_ids,
+            )
+
+        total_processed = 0
+        chunk_size = max(1, math.ceil(batch_size / worker_count))
+        stopped_early = False
+
+        async def _compute_batch(
+            loop, executor, worker_batch, ptm_list, max_ptm
+        ) -> list:
+            """Submit worker_batch to the process pool and gather results."""
+            sub_batches = [
+                worker_batch[i:i + chunk_size]
+                for i in range(0, len(worker_batch), chunk_size)
+            ]
+            futures = [
+                loop.run_in_executor(
+                    executor,
+                    process_identificatons_batch,
+                    sub_batch,
+                    params_dict,
+                    fragment_charges,
+                    target_ppm,
+                    min_charge,
+                    max_charge,
+                    max_isotope_offset,
+                    force_isotope_offset,
+                    ptm_list,
+                    max_ptm,
+                    seq_criteria,
+                    max_ptm_sites,
+                )
+                for sub_batch in sub_batches
+            ]
+            sub_results = await asyncio.gather(*futures)
+            return [item for sub in sub_results for item in sub]
+
+        async def _write_and_commit(results: list) -> None:
+            """Write a computed batch to DB and commit without touching modified_at."""
+            await self.project.put_identification_data_batch(results)
+            await self.project._commit()
+
+        try:
+            loop = asyncio.get_event_loop()
+            with ProcessPoolExecutor(max_workers=worker_count) as executor:
+                for tool_id in tool_ids:
+                    if stopped_early:
+                        break
+                    t_settings = tool_settings_map.get(tool_id, {})
+                    ptm_list = t_settings.get('ptm_list', None)
+                    max_ptm = t_settings.get('max_ptm', 5)
+
+                    offset = 0
+
+                    # --- Prime the pipeline: read and compute the first batch ---
+                    dialog.update_progress(None, "Loading...", "Reading first batch...")
+                    batch_objects = await self.project.get_identifications_with_spectra_batch(
+                        tool_id=tool_id,
+                        offset=offset,
+                        limit=batch_size,
+                        only_missing=only_missing,
+                        spectra_file_ids=spectra_file_ids,
+                    )
+
+                    if not batch_objects:
+                        continue
+
+                    worker_batch = [obj.to_worker_dict() for obj in batch_objects]
+                    del batch_objects  # free spectrum arrays from memory
+                    offset += batch_size
+
+                    pending_results = await _compute_batch(
+                        loop, executor, worker_batch, ptm_list, max_ptm
+                    )
+                    del worker_batch
+
+                    while True:
+                        # --- Overlap: write previous results AND read next batch in parallel ---
+                        next_read_task = asyncio.create_task(
+                            self.project.get_identifications_with_spectra_batch(
+                                tool_id=tool_id,
+                                offset=offset,
+                                limit=batch_size,
+                                only_missing=only_missing,
+                                spectra_file_ids=spectra_file_ids,
+                            )
+                        )
+                        write_task = asyncio.create_task(
+                            _write_and_commit(pending_results)
+                        )
+                        next_batch_objects, _ = await asyncio.gather(
+                            next_read_task, write_task
+                        )
+
+                        total_processed += len(pending_results)
+                        del pending_results
+                        offset += batch_size
+
+                        progress_value = (total_processed / total_count) if total_count > 0 else None
+                        dialog.update_progress(
+                            progress_value,
+                            "Calculating...",
+                            f"Processed {total_processed} / {total_count}",
+                            processed=total_processed,
+                            total=total_count,
+                        )
+
+                        if dialog.stop_requested:
+                            stopped_early = True
+                            break
+
+                        if not next_batch_objects:
+                            break
+
+                        # --- Compute next batch while loop iterates ---
+                        next_worker_batch = [obj.to_worker_dict() for obj in next_batch_objects]
+                        del next_batch_objects  # free spectrum arrays from memory
+                        pending_results = await _compute_batch(
+                            loop, executor, next_worker_batch, ptm_list, max_ptm
+                        )
+                        del next_worker_batch
+
+            await self.project.save()
+
+            if stopped_early:
+                dialog.complete(f"Stopped: {total_processed} / {total_count} processed")
+            else:
+                dialog.complete(f"Done: {total_processed} identifications")
+            await asyncio.sleep(1)
+            dialog.close()
+
+            self.show_success(f"Ion coverage calculated for {total_processed} identifications")
+
+        except Exception as exc:
+            logger.exception(ex)
+            try:
+                dialog.close()
+            except Exception:
+                pass
+            self.show_error(f"Error: {exc}")
+
+
+class SelectPreferredAction(BaseAction):
+    """
+    Select preferred identifications for spectra files.
+
+    Extracted from MatchingSection.run_matching_internal().
+    Supports optional per-sample filtering.
+    """
+
+    def __init__(self, project: Project, page: ft.Page):
+        super().__init__(project, page)
+
+    async def run(
+        self,
+        tool_settings: dict,
+        criterion: str = 'intensity',
+        sample_id: int | None = None,
+    ) -> None:
+        """
+        Run preferred identification selection.
+
+        Args:
+            tool_settings: Tool-specific settings dict (from ToolSettingsSection).
+            criterion: 'ppm' or 'intensity'.
+            sample_id: If provided, only process files of this sample.
+        """
+        if not tool_settings:
+            self.show_warning("No tools configured")
+            return
+
+        from dasmixer.gui.views.tabs.peptides.dialogs.progress_dialog import ProgressDialog
+        from pathlib import Path
+
+        dialog = ProgressDialog(self.page, "Running Identification Matching")
+        dialog.show()
+
+        try:
+            spectre_files = await self.project.get_spectra_files(
+                sample_id=sample_id if sample_id is not None else None
+            )
+            progress = 0.0
+            processed_files = 0
+            total_files = len(spectre_files)
+            progress_step = round(1 / total_files, 3) if total_files > 0 else 1.0
+
+            for _, spectra_file in spectre_files.iterrows():
+                file_name = Path(spectra_file['path']).name
+                dialog.update_progress(
+                    progress,
+                    f"Processing {file_name} ({processed_files + 1}/{total_files})..."
+                )
+                idents = await calculate_preferred_identifications_for_file(
+                    self.project,
+                    spectra_file['id'],
+                    criterion,
+                    tool_settings,
+                )
+                dialog.update_progress(
+                    progress,
+                    f"Saving {file_name} ({processed_files + 1}/{total_files})..."
+                )
+                await self.project.set_preferred_identifications_for_file(
+                    spectra_file['id'],
+                    idents,
+                )
+                progress += progress_step
+                processed_files += 1
+
+            dialog.complete(f"Completed {processed_files}/{total_files}!")
+            await asyncio.sleep(0.5)
+            dialog.close()
+
+            self.show_success(f"Processed {processed_files} spectra files!")
+
+        except Exception as ex:
+            logger.exception(ex)
+            try:
+                dialog.close()
+            except Exception:
+                pass
+            self.show_error(f"Error: {str(ex)}")

dasmixer_gui-0.6.0a2/src/dasmixer/gui/actions/lfq_action.py

@@ -0,0 +1,112 @@
+"""Label-Free Quantification action."""
+
+import asyncio
+
+import flet as ft
+
+from dasmixer.utils import logger
+from dasmixer.api.project.project import Project
+from dasmixer.api.calculations.proteins.lfq import calculate_lfq
+from dasmixer.gui.views.tabs.proteins.shared_state import ProteinsTabState
+from .base import BaseAction
+
+
+class LFQAction(BaseAction):
+    """
+    Calculate Label-Free Quantification for protein identifications.
+
+    Extracted from LFQSection.calculate_lfq().
+    Supports optional per-sample calculation.
+    """
+
+    def __init__(self, project: Project, page: ft.Page):
+        super().__init__(project, page)
+
+    async def run(
+        self,
+        state: ProteinsTabState,
+        sample_id: int | None = None,
+    ) -> int:
+        """
+        Run LFQ calculation.
+
+        Args:
+            state: ProteinsTabState with LFQ parameters.
+            sample_id: If provided, only calculate for this sample.
+
+        Returns:
+            Total number of quantification records saved.
+        """
+        selected_methods = state.get_selected_lfq_methods()
+        if not selected_methods:
+            self.show_warning("No LFQ methods selected. Configure in Proteins tab.")
+            return 0
+
+        from dasmixer.gui.views.tabs.peptides.dialogs.progress_dialog import ProgressDialog
+
+        dialog = ProgressDialog(self.page, "Calculating LFQ")
+        dialog.show()
+
+        try:
+            # Clear old results (per sample or globally)
+            dialog.update_progress(None, "Clearing old quantifications...")
+            if sample_id is not None:
+                await self.project.clear_protein_quantifications_for_sample(sample_id)
+            else:
+                await self.project.clear_protein_quantifications()
+
+            # Determine which samples to process
+            dialog.update_progress(None, "Loading samples...")
+            if sample_id is not None:
+                samples_df = await self.project.execute_query_df(
+                    "SELECT id FROM sample WHERE id = ?",
+                    (int(sample_id),)
+                )
+            else:
+                samples_df = await self.project.execute_query_df(
+                    "SELECT DISTINCT id FROM sample ORDER BY id"
+                )
+
+            if len(samples_df) == 0:
+                dialog.close()
+                self.show_warning("No samples found")
+                return 0
+
+            total_samples = len(samples_df)
+            total_saved = 0
+
+            for idx, row in samples_df.iterrows():
+                s_id = row['id']
+                dialog.update_progress(
+                    (idx + 1) / total_samples,
+                    f"Processing sample {idx + 1} of {total_samples}"
+                )
+                result_df = await calculate_lfq(
+                    project=self.project,
+                    sample_id=s_id,
+                    methods=selected_methods,
+                    enzyme=state.enzyme,
+                    min_length=state.min_peptide_length,
+                    max_length=state.max_peptide_length,
+                    max_cleavage_sites=state.max_cleavage_sites,
+                    empai_base=state.empai_base_value,
+                )
+                if len(result_df) > 0:
+                    await self.project.add_protein_quantifications_batch(result_df)
+                    total_saved += len(result_df)
+
+            dialog.complete()
+            await asyncio.sleep(1)
+            dialog.close()
+
+            self.show_success(f"LFQ calculated: {total_saved} quantifications")
+            return total_saved
+
+        except Exception as ex:
+            logger.exception(ex)
+            try:
+                dialog.close()
+            except Exception:
+                pass
+            self.show_error(f"Error: {str(ex)}")
+            return 0