LibViz 0.1.0__tar.gz

libviz-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: LibViz
+Version: 0.1.0
+Summary: App to visualize MS library spectra
+Author-Email: Matteo Miotto <miotsdata@gmail.com>
+License: MIT
+Requires-Python: ==3.13
+Requires-Dist: sqlalchemy>=2.0.46
+Requires-Dist: alembic>=1.18.4
+Requires-Dist: pandas>=3.0.0
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: pyteomics>=4.7.5
+Requires-Dist: tqdm>=4.67.3
+Requires-Dist: lxml>=6.0.2
+Provides-Extra: gui
+Requires-Dist: pyside6>=6.10.2; extra == "gui"
+Requires-Dist: pyqt6>=6.10.2; extra == "gui"
+Requires-Dist: PySide6-Essentials>=6.10.2; extra == "gui"
+Provides-Extra: all
+Requires-Dist: libviz[gui]; extra == "all"
+Description-Content-Type: text/markdown
+
+# LibViz

libviz-0.1.0/README.md

@@ -0,0 +1 @@
+# LibViz

libviz-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "LibViz"
+version = "0.1.0"
+description = "App to visualize MS library spectra"
+authors = [
+    { name = "Matteo Miotto", email = "miotsdata@gmail.com" },
+]
+dependencies = [
+    "sqlalchemy>=2.0.46",
+    "alembic>=1.18.4",
+    "pandas>=3.0.0",
+    "numpy>=2.4.2",
+    "pyteomics>=4.7.5",
+    "tqdm>=4.67.3",
+    "lxml>=6.0.2",
+]
+requires-python = "==3.13"
+readme = "README.md"
+
+[project.license]
+text = "MIT"
+
+[project.optional-dependencies]
+gui = [
+    "pyside6>=6.10.2",
+    "pyqt6>=6.10.2",
+    "PySide6-Essentials>=6.10.2",
+]
+all = [
+    "libviz[gui]",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+excludes = [
+    "src/libviz/old",
+    "tests",
+    "**/.DS_Store",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pylint>=4.0.4",
+    "pyside6-stubs>=6.7.3.0",
+    "hupper>=1.12.1",
+    "pyinstaller>=6.19.0",
+]

libviz-0.1.0/src/libviz/bridge/__init__.py

@@ -0,0 +1 @@
+from .library_manager_bridge import LibraryManagerBridge

libviz-0.1.0/src/libviz/bridge/library_manager_bridge.py

@@ -0,0 +1,149 @@
+# libviz/bridge/library_manager_bridge.py
+
+from PySide6.QtCore import QObject, Signal, Slot, Property, QThread, QUrl # pylint: disable=no-name-in-module
+from libviz.core import LibraryManager
+
+
+class _MspLoaderWorker(QObject):
+    """Runs in a separate thread — no Qt UI calls allowed here."""
+    finished = Signal(str)   # emits path on success
+    failed = Signal(str)     # emits error message on failure
+
+    def __init__(self, manager: LibraryManager, msp_path: str):
+        super().__init__()
+        self._manager = manager
+        self._msp_path = msp_path
+
+    @Slot()
+    def run(self):
+        try:
+            self._manager.load_library_from_msp(self._msp_path)
+            self.finished.emit(self._msp_path)
+        except Exception as e:
+            self.failed.emit(str(e))
+
+
+class LibraryManagerBridge(QObject):
+
+    # --- Signals ---
+    libraryLoaded = Signal(str)
+    libraryUnloaded = Signal(str)
+    selectedLibraryChanged = Signal()
+    libraryCountChanged = Signal()
+    errorOccurred = Signal(str)
+    statusChanged = Signal(str)
+
+    def __init__(self, manager: LibraryManager, parent=None):
+        super().__init__(parent)
+        self._manager = manager
+        self._thread: QThread | None = None
+        self._worker: _MspLoaderWorker | None = None
+
+    # --- Internal helpers ---
+
+    def _set_status(self, message: str):
+        self.statusChanged.emit(message)
+
+    def _clear_status(self):
+        self.statusChanged.emit("")
+
+    # --- Slots ---
+
+    @Slot(str, str)
+    def createLibrary(self, name: str, path: str):
+        try:
+            self._set_status(f"Creating: {path}")
+            self._manager.create_library(name, path)
+            self.libraryCountChanged.emit()
+            self.libraryLoaded.emit(path)
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+        finally:
+            self._clear_status()
+
+    @Slot(str)
+    def loadLibraryFromMsp(self, msp_path: str):
+        """Offloads the heavy parse to a QThread; status bar shown until done."""
+        if self._thread and self._thread.isRunning():
+            self.errorOccurred.emit("An MSP load is already in progress.")
+            return
+
+        msp_path = QUrl(msp_path).toLocalFile()
+
+        self._set_status(f"Loading: {msp_path}")
+
+        self._worker = _MspLoaderWorker(self._manager, msp_path)
+        self._thread = QThread(self)
+        self._worker.moveToThread(self._thread)
+
+        # Wire up lifecycle
+        self._thread.started.connect(self._worker.run)
+        self._worker.finished.connect(self._on_msp_loaded)
+        self._worker.failed.connect(self._on_msp_failed)
+
+        # Clean up thread and worker after work is done
+        self._worker.finished.connect(self._thread.quit)
+        self._worker.failed.connect(self._thread.quit)
+        self._thread.finished.connect(self._worker.deleteLater)
+        self._thread.finished.connect(self._thread.deleteLater)
+
+        self._thread.start()
+
+    def _on_msp_loaded(self, path: str):
+        self._clear_status()
+        self.libraryCountChanged.emit()
+        self.libraryLoaded.emit(path)
+
+    def _on_msp_failed(self, message: str):
+        self._clear_status()
+        self.errorOccurred.emit(message)
+
+    @Slot(str)
+    def loadLibraryFromDb(self, path: str):
+        try:
+            self._set_status(f"Loading: {path}")
+            self._manager.load_library_from_db(path)
+            self.libraryCountChanged.emit()
+            self.libraryLoaded.emit(path)
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+        finally:
+            self._clear_status()
+
+    @Slot(str)
+    def saveAsDb(self, path: str):
+        try:
+            self._set_status(f"Saving: {path}")
+            self._manager.save_as_db(path)
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+        finally:
+            self._clear_status()
+
+    @Slot(str)
+    def unloadLibrary(self, path: str):
+        try:
+            self._manager.unload_library(path)
+            self.libraryCountChanged.emit()
+            self.libraryUnloaded.emit(path)
+        except Exception as e:
+            self.errorOccurred.emit(str(e))
+
+    @Slot(str)
+    def selectLibrary(self, path: str):
+        self._manager._selected_library = path
+        self.selectedLibraryChanged.emit()
+
+    # --- Properties ---
+
+    @Property(bool, notify=libraryCountChanged)
+    def hasLibraries(self) -> bool:
+        return self._manager.has_libraries
+
+    @Property(int, notify=libraryCountChanged)
+    def libraryCount(self) -> int:
+        return self._manager.library_count
+
+    @Property(str, notify=selectedLibraryChanged)
+    def selectedLibraryKey(self) -> str:
+        return self._manager.selected_library_key or ""

libviz-0.1.0/src/libviz/core/__init__.py

@@ -0,0 +1 @@
+from .managers import LibraryManager

libviz-0.1.0/src/libviz/core/db/__init__.py

@@ -0,0 +1 @@
+from .extensions import Base

libviz-0.1.0/src/libviz/core/db/extensions.py

@@ -0,0 +1,3 @@
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()

libviz-0.1.0/src/libviz/core/db/migrations.py

@@ -0,0 +1,27 @@
+import sys
+from pathlib import Path
+from alembic.config import Config
+from alembic import command
+
+def get_bundle_dir():
+    """Get the path to the app directory, even if frozen by PyInstaller."""
+    if getattr(sys, 'frozen', False):
+        # Running in a bundle (.exe / .app)
+        return Path(sys._MEIPASS)
+    # Running in normal Python environment
+    return Path(__file__).parent.parent.parent.parent.parent
+
+def upgrade_library_schema(db_path: Path):
+    bundle_dir = get_bundle_dir()
+    ini_path = bundle_dir / "alembic.ini"
+    
+    alembic_cfg = Config(str(ini_path))
+    
+    # CRITICAL: Tell Alembic where the versions folder is inside the bundle
+    # This overrides the 'script_location' in alembic.ini
+    script_location = bundle_dir / "migrations"
+    alembic_cfg.set_main_option("script_location", str(script_location))
+    
+    alembic_cfg.set_main_option("sqlalchemy.url", f"sqlite:///{db_path}")
+    
+    command.upgrade(alembic_cfg, "head")

libviz-0.1.0/src/libviz/core/db/models/__init__.py

@@ -0,0 +1,5 @@
+from .compound import Compound
+from .spectrum import Spectrum, calculate_spectrum_hash
+from .adducts_type import AdductType, populate_adduct_types
+from .spectrum_metadata import SpectrumMetadata
+from .library_metadata import LibraryMetadata

libviz-0.1.0/src/libviz/core/db/models/adducts_type.py

@@ -0,0 +1,56 @@
+from sqlalchemy import Column, Integer, String, Float
+from sqlalchemy.orm import relationship
+
+from libviz.core.db import Base
+
+PROTON = 1.007276466812
+ELECTRON = 0.000548579909065  # optional, often ignored
+
+COMMON_ADDUCTS = [
+    # Positive mode
+    {"formula": "[M+H]+",     "charge": 1, "delta": PROTON, "multiplication_factor": 1},
+    {"formula": "[M+Na]+",    "charge": 1, "delta": 22.989218, "multiplication_factor": 1},
+    {"formula": "[M+K]+",     "charge": 1, "delta": 38.963158, "multiplication_factor": 1},
+    {"formula": "[M+NH4]+",   "charge": 1, "delta": 18.033823, "multiplication_factor": 1},
+
+    {"formula": "[M+2H]2+",   "charge": 2, "delta": 2 * PROTON, "multiplication_factor": 1},
+
+    # Negative mode
+    {"formula": "[M-H]-",     "charge": -1, "delta": -PROTON, "multiplication_factor": 1},
+    {"formula": "[M+Cl]-",    "charge": -1, "delta": 34.969402, "multiplication_factor": 1},
+    {"formula": "[M+FA-H]-",  "charge": -1, "delta": 44.998201, "multiplication_factor": 1},
+]
+
+class AdductType(Base):
+    __tablename__ = "adduct_type"
+
+    id = Column(Integer, primary_key=True)
+
+    formula = Column(String, unique=True)
+    charge = Column(Integer, nullable=False, index=True)
+    delta_mass = Column(Float, index=True)
+    multiplication_factor = Column(Integer, default=1, nullable=False, index=True)
+
+    spectra = relationship("Spectrum", back_populates="adduct_type")
+
+
+def populate_adduct_types(session):
+
+    for p in COMMON_ADDUCTS:
+        exists = session.query(AdductType)\
+            .filter_by(formula=p["formula"])\
+            .one_or_none()
+
+        if exists:
+            continue
+
+        session.add(
+            AdductType(
+                formula=p["formula"],
+                charge=p["charge"],
+                delta_mass=p["delta"],
+                multiplication_factor=p["multiplication_factor"]
+            )
+        )
+
+    session.commit()

libviz-0.1.0/src/libviz/core/db/models/compound.py

@@ -0,0 +1,25 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+from libviz.core.db import Base
+
+class Compound(Base):
+    __tablename__ = "compound"
+
+    id = Column(Integer, primary_key=True)
+
+    name = Column(String(collation="NOCASE"), index=True)
+    formula = Column(String, index=True)
+    exact_mass = Column(Float, index=True)
+    inchikey = Column(String, unique=True, nullable=False)
+    smiles = Column(String, index=True, unique=True)
+    pubchem_id = Column(Integer, index=True, unique=True)
+    added_on = Column(
+        DateTime(timezone=True),
+        default=datetime.now,
+        nullable=False
+    )
+
+
+    spectra = relationship("Spectrum", back_populates="compound")

libviz-0.1.0/src/libviz/core/db/models/library_metadata.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, Integer, String, DateTime
+from datetime import datetime
+
+from libviz.core.db import Base
+
+class LibraryMetadata(Base):
+    __tablename__ = "library_metadata"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String, nullable=False)
+    added_on = Column(
+        DateTime(timezone=True),
+        default=datetime.now,
+        nullable=False
+    )
+    last_updated_on = Column(
+        DateTime(timezone=True),
+        default=datetime.now,
+        onupdate=datetime.now,
+        nullable=False
+    )

libviz-0.1.0/src/libviz/core/db/models/spectrum.py

@@ -0,0 +1,89 @@
+import hashlib
+import numpy as np
+
+from sqlalchemy import CheckConstraint, Column, Integer, String, Float, DateTime, ForeignKey, LargeBinary, UniqueConstraint
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+from libviz.core.db import Base
+
+class Spectrum(Base):
+    __tablename__ = "spectrum"
+
+    id = Column(Integer, primary_key=True)
+    compound_id = Column(Integer, ForeignKey("compound.id"), nullable=False, index=True)
+    precursor_mz = Column(Float, index=True, nullable=False)
+    adduct_type_id = Column(Integer, ForeignKey("adduct_type.id"), nullable=False, index=True)
+    polarity = Column(String, CheckConstraint("polarity IN ('POSITIVE', 'NEGATIVE')"), nullable=True, index=True)
+    collision_energy = Column(Float, index=True, nullable=False)
+    mz_array = Column(LargeBinary, nullable=False)
+    intensity_array = Column(LargeBinary, nullable=False)
+    added_on = Column(
+        DateTime(timezone=True),
+        default=datetime.now,
+        nullable=False
+    )
+    spectrum_hash = Column(String(64), nullable=False, index=True)
+
+    compound = relationship("Compound", back_populates="spectra")
+    adduct_type = relationship("AdductType", back_populates="spectra")
+    spectrum_metadata = relationship(
+        "SpectrumMetadata",
+        back_populates="spectrum",
+        cascade="all, delete-orphan"
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "compound_id",
+            "adduct_type_id",
+            "polarity",
+            "collision_energy",
+            "spectrum_hash",
+            name="uq_spectrum_identity"
+        ),
+    )
+
+    @classmethod
+    def from_arrays(
+        cls,
+        *,
+        compound_id: int,
+        precursor_mz: float,
+        adduct_type_id: int,
+        polarity: str,
+        collision_energy: float,
+        mz: np.ndarray,
+        intensity: np.ndarray,
+    ):
+        
+        mz = np.asarray(mz, dtype="<f4")
+        intensity = np.asarray(intensity, dtype="<f4")
+        order = np.argsort(mz)
+        mz = np.round(mz[order], 4)
+        intensity = np.round(intensity[order], 2)
+
+
+        return cls(
+            compound_id=compound_id,
+            precursor_mz=precursor_mz,
+            adduct_type_id=adduct_type_id,
+            polarity=polarity,
+            collision_energy=collision_energy,
+            mz_array=mz.tobytes(),
+            intensity_array=intensity.tobytes(),
+            spectrum_hash=calculate_spectrum_hash(mz, intensity),
+        )
+
+    def mz_numpy(self) -> np.ndarray:
+        return np.frombuffer(self.mz_array, dtype="<f4")
+
+    def intensity_numpy(self) -> np.ndarray:
+        return np.frombuffer(self.intensity_array, dtype="<f4")
+
+
+def calculate_spectrum_hash(mz: np.ndarray, intensity: np.ndarray) -> str:
+    h = hashlib.sha256()
+    h.update(np.asarray(mz, dtype="<f4").tobytes())
+    h.update(np.asarray(intensity, dtype="<f4").tobytes())
+    return h.hexdigest()

libviz-0.1.0/src/libviz/core/db/models/spectrum_metadata.py

@@ -0,0 +1,14 @@
+from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy.orm import relationship
+
+from libviz.core.db import Base
+
+class SpectrumMetadata(Base):
+    __tablename__ = "spectrum_metadata"
+
+    id = Column(Integer, primary_key=True)
+    spectrum_id = Column(Integer, ForeignKey("spectrum.id"), nullable=False, index=True)
+    key = Column(String, nullable=False, index=True)
+    value = Column(String, nullable=False)
+
+    spectrum = relationship("Spectrum", back_populates="spectrum_metadata")