pypsmcbor 0.0.3__py3-none-any.whl

pypsmcbor/__init__.py

@@ -0,0 +1,37 @@
+# This file is part of pypsmcbor.
+#
+# pypsmcbor is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pypsmcbor is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pypsmcbor. If not, see <http://www.gnu.org/licenses/>.
+
+from .comparsample import (
+    ComparSampleMatchingScanIndex,
+    ComparSampleMatchingScanNativeId,
+)
+from .enums import MzPrecisionUnit, PeaksEngine, PsmCborMass, PsmCborSoftware
+from .fastasequence import FastaSequence
+from .harvest.harvest_psmcbor import HarvestPsmCbor
+from .identificationdataset import IdentificationDataSet
+from .peaks.peakscomparsample import PeaksComparSampleMatchingScan
+from .peaks.peakspeptidetable import PeaksPeptideTable
+from .proforma import ProForma
+from .protein import Protein
+from .proteinmap import ProteinMap
+from .psm import Psm
+from .sample import Sample
+from .scan import Scan
+from .scanid import ScanId
+from .scanpair import ScanPair
+from .stream.proformamodreplace import ProFormaModReplace
+from .stream.psmcborpsmfilter import PsmCborPsmFilter
+from .stream.psmcborstreamin import PsmCborStreamIn
+from .stream.psmcborstreamout import PsmCborStreamOut

pypsmcbor/cbor2/__init__.py

@@ -0,0 +1 @@
+from .cborstreamdec import CborStreamDec

pypsmcbor/cbor2/cborstreamdec.py

@@ -0,0 +1,274 @@
+# This file is part of pypsmcbor.
+#
+# pypsmcbor is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pypsmcbor is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pypsmcbor. If not, see <http://www.gnu.org/licenses/>.
+
+
+import struct
+import sys
+from dataclasses import dataclass
+from typing import IO, Any, cast
+
+from cbor2 import CBORDecoder
+from cbor2._types import CBORDecodeValueError
+
+
+@dataclass
+class ContainerEnd:
+    end_is_reached: bool
+    remaining_items: int | None
+
+
+class CborStreamDec:
+    def __init__(self, fp: IO[bytes]):
+        self._fp = fp
+        self._cbor_decoder = CBORDecoder(fp)
+        self._initial_byte = None
+        self._major_type = 0
+        self._subtype = 0
+        self._length = None
+        self._container_stack = []
+
+    @property
+    def length(self) -> int | None:
+        return self._length
+
+    @property
+    def expected_string(self) -> str:
+        if self._container_stack[-1].end_is_reached:
+            raise CBORDecodeValueError(f"end of container reached, use leave_container")
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self.is_string():
+            the_string = self._cbor_decoder.decode_string(self._subtype)
+            self._initial_byte = None
+            self._check_container_remaining_items()
+            return the_string
+        else:
+            raise CBORDecodeValueError(
+                f"next value is not a string 0x{self._major_type:x}"
+            )
+
+    def to_dict(self) -> Any:
+        """Use the internal cbor2 decoder to return the whole data as a dictionnary or array"""
+        if self._container_stack[-1].end_is_reached:
+            raise CBORDecodeValueError("end of container reached, use leave_container")
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self.is_map():
+            if self.has_next():
+                the_map = self._cbor_decoder.decode_map(self._subtype)
+                self._initial_byte = None
+                self._check_container_remaining_items()
+                return the_map
+        elif self.is_array():
+            if self.has_next():
+                the_map = self._cbor_decoder.decode_array(self._subtype)
+                self._initial_byte = None
+                self._check_container_remaining_items()
+                return the_map
+        elif self._container_stack[-1].end_is_reached:
+            raise CBORDecodeValueError("end of container reached, use leave_container")
+        raise CBORDecodeValueError("the value is not a dict nor an array")
+
+    def value(self) -> str | int | bytes | float | None:
+        # 0: CBORDecoder.decode_uint,
+        # 1: CBORDecoder.decode_negint,
+        # 2: CBORDecoder.decode_bytestring,
+        # 3: CBORDecoder.decode_string,
+        # 4: CBORDecoder.decode_array,
+        # 5: CBORDecoder.decode_map,
+        # 6: CBORDecoder.decode_semantic,
+        # 7: CBORDecoder.decode_special,
+        if self._container_stack[-1].end_is_reached:
+            raise CBORDecodeValueError(f"end of container reached, use leave_container")
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self.is_string():
+            the_string = self._cbor_decoder.decode_string(self._subtype)
+            self._initial_byte = None
+            self._check_container_remaining_items()
+            return the_string
+        elif self.is_uint():
+            the_uint = self._cbor_decoder.decode_uint(self._subtype)
+            self._initial_byte = None
+            self._check_container_remaining_items()
+            return the_uint
+        elif self.is_negint():
+            the_negint = self._cbor_decoder.decode_negint(self._subtype)
+            self._initial_byte = None
+            self._check_container_remaining_items()
+            return the_negint
+        elif self.is_bytestring():
+            the_bytestr = self._cbor_decoder.decode_bytestring(self._subtype)
+            self._initial_byte = None
+            self._check_container_remaining_items()
+            return the_bytestr
+        elif self._major_type == 7:
+            if self.has_next():
+                the_special = self._cbor_decoder.decode_special(self._subtype)
+                self._initial_byte = None
+                self._check_container_remaining_items()
+                return the_special
+        elif self.is_container():
+            raise CBORDecodeValueError(
+                "the next value is a container, use enter_container or to_dict to proceed"
+            )
+        else:
+            raise CBORDecodeValueError(
+                f"next value is not taken into account 0x{self._major_type:x}"
+            )
+
+    def _check_container_remaining_items(self):
+        if len(self._container_stack) > 0:
+            item_number = self._container_stack[-1].remaining_items
+            if item_number is not None:
+                self._container_stack[-1].remaining_items = item_number - 1
+                if self._container_stack[-1].remaining_items == 0:
+                    self._container_stack[-1].end_is_reached = True
+
+    def has_next(self) -> bool:
+        # print(f"1next major type is 0x{self._major_type:x} length{self._length}")
+        if self._container_stack[-1].end_is_reached:
+            return False
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        # print(f"next major type is 0x{self._major_type:x}")
+        if self._major_type == 7:
+            if self._subtype == 31:
+                # print("special subtype", self._subtype)
+                self._initial_byte = None
+                self._container_stack[-1].end_is_reached = True
+                return False
+            else:
+                pass
+                # print("special subtype", self._subtype)
+
+        return True
+
+    def next(self) -> bool:
+        """Advance the CBOR stream decoding one element. You should usually call this function when parsing fixed-width basic elements (that is, integers, simple values, tags and floating point values). But this function can be called when the current item is a string, array or map too and it will skip over that entire element, including all contained elements."""
+        if self._container_stack[-1].end_is_reached:
+            return False
+        self._cbor_decoder.decode()
+        self._initial_byte = None
+        self._check_container_remaining_items()
+        return True
+
+    def _read_next_initial_byte(self):
+        self._initial_byte = self._cbor_decoder.read(1)[0]
+        self._major_type = self._initial_byte >> 5
+        self._subtype = self._initial_byte & 31
+        self._length = None
+
+    def is_array(self) -> bool:
+        # 0: CBORDecoder.decode_uint,
+        # 1: CBORDecoder.decode_negint,
+        # 2: CBORDecoder.decode_bytestring,
+        # 3: CBORDecoder.decode_string,
+        # 4: CBORDecoder.decode_array,
+        # 5: CBORDecoder.decode_map,
+        # 6: CBORDecoder.decode_semantic,
+        # 7: CBORDecoder.decode_special,
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 4:
+            return True
+        return False
+
+    def is_negint(self) -> bool:
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 1:
+            return True
+        return False
+
+    def is_bytestring(self) -> bool:
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 2:
+            return True
+        return False
+
+    def is_uint(self) -> bool:
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 0:
+            return True
+        return False
+
+    def is_string(self) -> bool:
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 3:
+            return True
+        return False
+
+    def is_map(self) -> bool:
+        if self._initial_byte is None:
+            self._read_next_initial_byte()
+        if self._major_type == 5:
+            return True
+        return False
+
+    def is_container(self) -> bool:
+        if self.is_array() or self.is_map():
+            return True
+        return False
+
+    def leave_container(self) -> bool:
+        if self._container_stack[-1].end_is_reached:
+            self._container_stack.pop()
+            return True
+        return False
+
+    def enter_container(self) -> bool:
+        if self.is_container():
+            self._check_container_remaining_items()
+            self._length = self._decode_length(self._subtype, allow_indefinite=True)
+            items = self._length
+            if items is not None:
+                if self.is_map():
+                    items = items * 2
+            self._initial_byte = None
+            c_end = ContainerEnd(end_is_reached=False, remaining_items=items)
+            self._container_stack.append(c_end)
+            if self._length is None:
+                return True
+            else:
+                if self._length > sys.maxsize:
+                    raise CBORDecodeValueError(
+                        f"invalid length for array 0x{self._length:x}"
+                    )
+                return True
+        return False
+
+    def _decode_length(
+        self, subtype: int, allow_indefinite: bool = False
+    ) -> int | None:
+        if subtype < 24:
+            return subtype
+        elif subtype == 24:
+            return self._cbor_decoder.read(1)[0]
+        elif subtype == 25:
+            return cast(int, struct.unpack(">H", self._cbor_decoder.read(2))[0])
+        elif subtype == 26:
+            return cast(int, struct.unpack(">L", self._cbor_decoder.read(4))[0])
+        elif subtype == 27:
+            return cast(int, struct.unpack(">Q", self._cbor_decoder.read(8))[0])
+        elif subtype == 31 and allow_indefinite:
+            return None
+        else:
+            raise CBORDecodeValueError(
+                f"unknown unsigned integer subtype 0x{subtype:x}"
+            )

pypsmcbor/comparsample.py

@@ -0,0 +1,72 @@
+# This file is part of pypsmcbor.
+#
+# pypsmcbor is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pypsmcbor is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pypsmcbor. If not, see <http://www.gnu.org/licenses/>.
+
+
+from .sample import Sample
+from .scanpair import ScanPair
+
+
+class ComparSampleMatchingScanBase(object):
+    def __init__(self, sample_data1: Sample, sample_data2: Sample, compar_scan):
+        self.scan_pair_list = []
+        for scan_data1 in sample_data1.scan_list:
+            for scan_data2 in sample_data2.scan_list:
+                if compar_scan(scan_data1, scan_data2):
+                    self.scan_pair_list.append(ScanPair(scan_data1, scan_data2))
+
+    @property
+    def count_scan_pair(self) -> int:
+        return len(self.scan_pair_list)
+
+    def find_if(self, check_scanpair) -> list[ScanPair]:
+        """find scanpair that respect the check_scanpair conditions
+        :param check_scanpair: a function accepting a scanpair as argument
+        and return true if conditions are met"""
+        scan_pair_list = []
+        for scan_pair in self.scan_pair_list:
+            if check_scanpair(scan_pair):
+                scan_pair_list.append(scan_pair)
+        return scan_pair_list
+
+    def count_if(self, check_scanpair) -> int:
+        """count scanpair that respect the check_scanpair conditions
+        :param check_scanpair: a function accepting a scanpair as argument
+        and return true if conditions are met"""
+        count = 0
+        for scan_pair in self.scan_pair_list:
+            if check_scanpair(scan_pair):
+                count = count + 1
+        return count
+
+    def count_scan_containing_similar_sequence(self) -> int:
+        return self.count_if(lambda scan_pair: scan_pair.has_similar_sequence())
+
+
+class ComparSampleMatchingScanNativeId(ComparSampleMatchingScanBase):
+    def __init__(self, sample_data1: Sample, sample_data2: Sample):
+        super().__init__(
+            sample_data1,
+            sample_data2,
+            lambda scan1, scan2: scan1.id.native_id == scan2.id.native_id,
+        )
+
+
+class ComparSampleMatchingScanIndex(ComparSampleMatchingScanBase):
+    def __init__(self, sample_data1: Sample, sample_data2: Sample):
+        super().__init__(
+            sample_data1,
+            sample_data2,
+            lambda scan1, scan2: scan1.has_index(scan2.id.index),
+        )

pypsmcbor/data/typst/global_report.typ

@@ -0,0 +1,59 @@
+#import "@preview/proteograph:0.2.2": *
+
+#import "mz_delta_plot.typ": aa-mass-delta-plot, mz-delta-plot
+
+= Global report
+
+
+
+#let psm_json_global = json("psm_data.json").global
+
+== #psm_json_global.samples.keys().len() samples
+
+#for (name, sample) in psm_json_global.samples.pairs() {
+  terms.item(name, [#sample.peaklist_file.name
+    #if name in psm_json_global.mzstats {
+      let count_usable_scans = 0
+      if "tic" in psm_json_global.mzstats.at(name) {
+        let xic0 = psm_json_global.mzstats.at(name).at("tic")
+        xic0.insert("TIC", "TIC")
+
+        xic-plot(
+          height: 10cm,
+          title: "Total Ion Count",
+          xic0,
+        )
+      }
+      if "ms_level_count" in psm_json_global.mzstats.at(name) {
+        let ms_level_count = psm_json_global.mzstats.at(name).at("ms_level_count")
+        for (ms_level, count) in ms_level_count.pairs() {
+          terms.item([MS level #ms_level], [#count scans])
+          if int(ms_level) > 1 {
+            count_usable_scans += count
+          }
+        }
+      }
+
+      if "psm_count" in psm_json_global.mzstats.at(name) {
+        let psm_count = psm_json_global.mzstats.at(name).at("psm_count")
+        terms.item(
+          [Coverage],
+          [#calc.round(psm_count.scans * 100 / count_usable_scans, digits: 2)% #psm_count.scans assigned on #count_usable_scans scans],
+        )
+
+        terms.item(
+          [PSM FDR],
+          [#calc.round((psm_count.psms - psm_count.target_psms) * 100 / psm_count.psms, digits: 2)% (total PSMs: #psm_count.psms)],
+        )
+      }
+    }
+  ])
+}
+
+#mz-delta-plot(psm_json_global.ppm_delta)
+
+#mz-delta-plot(psm_json_global.dalton_delta, unit: "dalton")
+
+#if "aa_mass_delta" in psm_json_global {
+  aa-mass-delta-plot(psm_json_global.aa_mass_delta)
+}

pypsmcbor/data/typst/mz_delta_plot.typ

@@ -0,0 +1,118 @@
+#import "@preview/lilaq:0.6.0" as lq
+
+#let mz-delta-diagram(unit: "ppm") = it => {
+  show: lq.set-diagram(
+    xlabel: [$m/z$ #sym.Delta (observed - theoretical) in #unit],
+    ylabel: [PSM count],
+    legend: none,
+    xaxis: (mirror: none),
+    yaxis: (mirror: none),
+  )
+  it
+}
+
+
+/// Generates a XIC plot.
+/// -> content
+#let mz-delta-plot(
+  /// The width of the diagram. This can be
+  /// - A `length`; in this case, it defines just the width of the data area,
+  ///   excluding axes, labels, title etc.
+  /// - A `ratio` or `relative` where the ratio part is relative to the width
+  ///   of the parent that the diagram is placed in. This is not allowed if the
+  ///   parent has an unbounded width, e.g., a page with `width: auto`.
+  /// -> length | relative
+  width: 15cm,
+  /// The height of the diagram. This can be
+  /// - A `length`; in this case, it defines just the height of the data area,
+  ///   excluding axes, labels, title etc.
+  /// - A `ratio` or `relative` where the ratio part is relative to the height
+  ///   of the parent that the diagram is placed in. This is not allowed if the
+  ///   parent has an unbounded height, e.g., a page with `height: auto`.
+  /// -> length | relative
+  height: 10cm,
+  /// Graph title
+  /// -> content
+  title: none,
+  unit: "ppm",
+  /// dictionary containing delta histogram
+  delta,
+) = {
+  show: lq.cond-set(lq.grid.with(kind: "x"), stroke: orange.lighten(50%))
+  show: lq.cond-set(lq.grid.with(kind: "y"), stroke: none)
+  show: mz-delta-diagram(unit: unit)
+
+  let color-cycle = lq.color.map.petroff6
+
+  let ylimit = auto
+
+  lq.diagram(
+    width: width,
+    height: height,
+    title: title,
+    lq.bar(
+      delta.interval,
+      delta.count,
+    ),
+
+    lq.place(10%, 10%, box(baseline: top, [#set align(left)
+      / std dev: $#calc.round(delta.stddev, digits: 2)$
+      / mean: $#if delta.mean > 0 { sym.plus }#calc.round(delta.mean, digits: 2)$
+      / median: $#if delta.median > 0 { sym.plus }#calc.round(delta.median, digits: 2)$
+    ])),
+  )
+}
+
+#let aa-mass-delta-plot(
+  /// The width of the diagram. This can be
+  /// - A `length`; in this case, it defines just the width of the data area,
+  ///   excluding axes, labels, title etc.
+  /// - A `ratio` or `relative` where the ratio part is relative to the width
+  ///   of the parent that the diagram is placed in. This is not allowed if the
+  ///   parent has an unbounded width, e.g., a page with `width: auto`.
+  /// -> length | relative
+  width: 15cm,
+  /// The height of the diagram. This can be
+  /// - A `length`; in this case, it defines just the height of the data area,
+  ///   excluding axes, labels, title etc.
+  /// - A `ratio` or `relative` where the ratio part is relative to the height
+  ///   of the parent that the diagram is placed in. This is not allowed if the
+  ///   parent has an unbounded height, e.g., a page with `height: auto`.
+  /// -> length | relative
+  height: 10cm,
+  /// Graph title
+  /// -> content
+  title: none,
+  /// dictionary containing delta histogram
+  delta,
+) = {
+  show: lq.cond-set(lq.grid.with(kind: "y"), stroke: none)
+  show: lq.show_(
+    lq.tick-label.with(kind: "x"),
+    it => scale(x: 50%, y: 50%, reflow: true, box(
+      width: 0pt,
+      align(right, rotate(-45deg, reflow: true, it)),
+    )),
+  )
+
+  let ylimit = auto
+
+  lq.diagram(
+    width: width,
+    height: height,
+    title: "most frequent AA mass delta",
+    xlim: (0, 60),
+    xaxis: (
+      ticks: delta.interval.map(massf => str(massf)).enumerate(),
+      subticks: none,
+    ),
+    yaxis: (
+      label: [count],
+      auto-exponent-threshold: 5,
+    ),
+    lq.bar(
+      range(delta.interval.len()),
+      delta.count,
+    ),
+  )
+}

pypsmcbor/data/typst/psm_report.typ

@@ -0,0 +1,14 @@
+#import "@preview/proteograph:0.2.4": *
+
+#let psm_json = json("psm_data.json")
+
+#if "global" in psm_json {
+  include "global_report.typ"
+}
+
+
+#if psm_json.scan_arr.len() > 0 {
+  heading([PSM scan report])
+
+  for scan in psm_json.scan_arr { psm-cbor-scan-report(scan, protein-dict: psm_json.protein_map) }
+}

pypsmcbor/data/typst/psm_report_svg.typ

@@ -0,0 +1,16 @@
+#import "@preview/proteograph:0.2.4": *
+
+#set page(height: auto, width: auto, margin: 1em)
+
+#let psm_json = json("psm_data.json")
+
+#if "global" in psm_json {
+  include "global_report.typ"
+}
+
+
+#if psm_json.scan_arr.len() > 0 {
+  heading([PSM scan report])
+
+  for scan in psm_json.scan_arr { psm-cbor-scan-report(scan, protein-dict: psm_json.protein_map) }
+}

pypsmcbor/enums.py

@@ -0,0 +1,42 @@
+# This file is part of pypsmcbor.
+#
+# pypsmcbor is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pypsmcbor is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pypsmcbor. If not, see <http://www.gnu.org/licenses/>.
+
+from enum import Enum
+
+
+class MzPrecisionUnit(Enum):
+    ppm = "ppm"
+    dalton = "dalton"
+
+
+class PeaksEngine(Enum):
+    db_search = "DB Search"
+    deepnovo = "DeepNovo"
+
+
+class PsmCborSoftware(Enum):
+    grouping = "grouping"
+    sage = "sage"
+    spoms = "spoms"
+    features = "features"
+
+
+class PsmCborMass(float, Enum):
+    MHPLUS = 1.007276466879  # The (monoisotopic) mass of the H+ ion
+    MPROTIUM = 1.007825032241  # The (monoisotopic) mass of the H atom
+    ONEMILLION = 1000000
+    MASSOXYGEN = 15.99491461956
+    MASSCARBON = 12.0
+    MASSNITROGEN = 14.0030740048

pypsmcbor/fastasequence.py

@@ -0,0 +1,20 @@
+# This file is part of pypsmcbor.
+#
+# pypsmcbor is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# pypsmcbor is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with pypsmcbor. If not, see <http://www.gnu.org/licenses/>.
+
+
+class FastaSequence:
+    def __init__(self, header: str, sequence: str):
+        self.header = header
+        self.sequence = sequence

pypsmcbor/harvest/__init__.py

@@ -0,0 +1 @@
+from .harvest_psmcbor import HarvestPsmCbor