msreport 0.0.27__py3-none-any.whl → 0.0.29__py3-none-any.whl

msreport/isobar.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import functools
 from typing import Protocol
 
@@ -27,7 +28,7 @@ class IsotopeImpurityCorrecter:
     def __init__(self):
         self._impurity_matrix = None
 
-    def fit(self, impurity_matrix: np.array) -> IsotopeImpurityCorrecter:
+    def fit(self, impurity_matrix: np.ndarray) -> IsotopeImpurityCorrecter:
         """Fits the isotope impurity correcter to a given impurity matrix.
 
         Args:
@@ -51,7 +52,7 @@ class IsotopeImpurityCorrecter:
         """Returns True if the IsotopeImpurityCorrecter has been fitted."""
         return self._impurity_matrix is not None
 
-    def get_fits(self) -> np.array:
+    def get_fits(self) -> np.ndarray:
         """Returns a copy of the fitted impurity matrix.
 
         returns:
@@ -89,9 +90,9 @@ class IsotopeImpurityCorrecter:
 
 
 def correct_isobaric_reporter_impurities(
-    intensity_table: np.array,
-    diagonal_impurity_matrix: np.array,
-) -> np.array:
+    intensity_table: np.ndarray,
+    diagonal_impurity_matrix: np.ndarray,
+) -> np.ndarray:
     """Performs isotope impurity correction on isobaric reporter expression values.
 
     Args:
@@ -122,8 +123,8 @@ def correct_isobaric_reporter_impurities(
 
 
 def _apply_impurity_contamination(
-    intensities: np.array, impurity_matrix: np.array
-) -> np.array:
+    intensities: np.ndarray, impurity_matrix: np.ndarray
+) -> np.ndarray:
     """Applies reporter isotope impurity interference to an intensity array.
 
     Args:
@@ -141,8 +142,8 @@ def _apply_impurity_contamination(
 
 
 def _correct_impurity_contamination(
-    intensities: np.array, impurity_matrix: np.array
-) -> np.array:
+    intensities: np.ndarray, impurity_matrix: np.ndarray
+) -> np.ndarray:
     """Applies reporter isotope impurity interference correction to an intensity array.
 
     Args:

msreport/normalize.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
+
 from typing import Callable, Iterable, Optional, Protocol
-from typing_extensions import Self
 
 import numpy as np
 import pandas as pd
 import statsmodels.nonparametric.smoothers_lowess
+from typing_extensions import Self
 
 import msreport.helper
 import msreport.helper.maxlfq as MAXLFQ

msreport/peptidoform.py

@@ -67,7 +67,9 @@ class Peptide:
         probabilities = []
         for site in self.list_modified_peptide_sites(modification):
             probabilities.append(self.get_peptide_site_probability(site))
-        return np.prod(probabilities)
+        if None in probabilities:
+            return None
+        return float(np.prod(probabilities))
 
     def get_peptide_site_probability(self, position: int) -> Optional[float]:
         """Return the modification localization probability of the peptide position.
@@ -161,7 +163,7 @@ def parse_modified_sequence(
     modified_sequence: str,
     tag_open: str,
     tag_close: str,
-) -> tuple[str, list]:
+) -> tuple[str, list[tuple[int, str]]]:
     """Returns the plain sequence and a list of modification positions and tags.
 
     Args:
@@ -253,7 +255,7 @@ def make_localization_string(
     return localization_string
 
 
-def read_localization_string(localization_string: str) -> dict:
+def read_localization_string(localization_string: str) -> dict[str, dict[int, float]]:
     """Converts a site localization probability string into a dictionary.
 
     Args:
@@ -269,7 +271,7 @@ def read_localization_string(localization_string: str) -> dict:
         A dictionary in the form {"modification tag": {position: probability}}, where
         positions are integers and probabilitiesa are floats ranging from 0 to 1.
     """
-    localization = {}
+    localization: dict[str, dict[int, float]] = {}
     if localization_string == "":
         return localization
 

msreport/plot/__init__.py

@@ -0,0 +1,41 @@
+"""This module provides various plotting functions for visualizing data within a Qtable.
+
+The functions in this module generate a wide range of plots, including heatmaps, PCA
+plots, volcano plots, and histograms, to analyze and compare expression values,
+missingness, contaminants, and other features in proteomics datasets. The plots are
+designed to work with the Qtable class as input, which provides structured access to
+proteomics data and experimental design information.
+
+The style of the plots can be customized using the `set_active_style` function, which
+allows applying style sheets from the msreport library or those available in matplotlib.
+"""
+
+from .comparison import expression_comparison, pvalue_histogram, volcano_ma
+from .distribution import experiment_ratios, replicate_ratios
+from .multivariate import expression_clustermap, sample_pca
+from .quality import (
+    contaminants,
+    missing_values_horizontal,
+    missing_values_vertical,
+    sample_correlation,
+    sample_intensities,
+)
+from .style import ColorWheelDict, set_active_style, set_dpi
+
+__all__ = [
+    "ColorWheelDict",
+    "set_dpi",
+    "set_active_style",
+    "missing_values_vertical",
+    "missing_values_horizontal",
+    "contaminants",
+    "sample_intensities",
+    "replicate_ratios",
+    "experiment_ratios",
+    "sample_pca",
+    "volcano_ma",
+    "expression_comparison",
+    "expression_clustermap",
+    "pvalue_histogram",
+    "sample_correlation",
+]

msreport/plot/_partial_plots.py

@@ -0,0 +1,159 @@
+from collections.abc import Iterable, Sequence
+from typing import Optional
+
+import adjustText
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from .style import with_active_style
+
+
+@with_active_style
+def annotated_scatter(
+    x_values,
+    y_values,
+    labels,
+    ax=None,
+    scatter_kws=None,
+    text_kws=None,
+) -> None:
+    ax = plt.gca() if ax is None else ax
+    if scatter_kws is None:
+        scatter_kws = {}
+    if text_kws is None:
+        text_kws = {}
+    text_params = {
+        "force_text": 0.15,
+        "arrowprops": {
+            "arrowstyle": "-",
+            "color": scatter_kws["color"],
+            "lw": 0.75,
+            "alpha": 0.5,
+        },
+        "lim": 100,
+    }
+
+    texts = []
+    for x, y, text in zip(x_values, y_values, labels, strict=True):
+        texts.append(ax.text(x, y, text, **text_kws))
+
+    if texts:
+        adjustText.adjust_text(texts, ax=ax, **text_params)  # type: ignore
+        ax.scatter(x_values, y_values, **scatter_kws)
+
+
+@with_active_style
+def box_and_bars(
+    box_values: Sequence[Iterable[float]],
+    bar_values: Sequence[float],
+    group_names: Sequence[str],
+    colors: Optional[Sequence[str]] = None,
+    edge_colors: Optional[Sequence[str]] = None,
+) -> tuple[plt.Figure, list[plt.Axes]]:
+    """Generates a figure with horizontally aligned box and bar subplots.
+
+    In the top subplot the 'box_values' are displayed as box plots, in lower subplot the
+    'bar_values' are displayed as bar plots. The figure width is automatically adjusted
+    to the number of groups that will be plotted. The length of group_names must be the
+    same as the length of the of the 'bar_values' and the number of iterables from
+    'box_values'. Each group from 'box_values' and 'bar_values' is horizontally aligned
+    between the two subplots.
+
+    Args:
+        box_values: A sequence of sequences that each contain y values for generating a
+            box plot.
+        bar_values: A sequence of y values for generating bar plots.
+        group_names: Used to label groups from box and bar plots.
+        colors: Sequence of hex color codes for each group that is used for the boxes of
+            the box and bar plots. Must be the same length as group names. If 'colors'
+            is None, boxes are colored in light grey.
+        edge_colors: Sequence of hex color codes for each group that is used for the
+            edges of the boxes and bars. Must be the same length as group names. If
+            None, black is used as edge color.
+
+    Raises:
+        ValueError: If the length of box_values, bar_values and group_names is not the
+            same or if the length of colors is not the same as group_names.
+
+    Returns:
+        A matplotlib Figure and a list of Axes objects containing the box and bar plots.
+    """
+    if not (len(box_values) == len(bar_values) == len(group_names)):
+        raise ValueError(
+            "The length of 'box_values', 'bar_values' and 'group_names' must be the "
+            "same."
+        )
+    if colors is not None and len(colors) != len(group_names):
+        raise ValueError(
+            "The length of 'colors' must be the same as the length of 'group_names'."
+        )
+    if edge_colors is not None and len(edge_colors) != len(group_names):
+        raise ValueError(
+            "The length of 'edge_colors' must be the same as the length of "
+            "'group_names'."
+        )
+
+    if colors is None:
+        colors = ["#D0D0D0" for _ in group_names]
+    if edge_colors is None:
+        edge_colors = ["#000000" for _ in group_names]
+
+    num_samples = len(group_names)
+    x_values = range(num_samples)
+    bar_width = 0.8
+
+    suptitle_space_inch = 0.4
+    ax_height_inch = 1.6
+    ax_hspace_inch = 0.35
+    bar_width_inches = 0.24
+    x_padding = 0.24
+    fig_height = suptitle_space_inch + ax_height_inch * 2 + ax_hspace_inch
+
+    fig_width = (num_samples + (2 * x_padding)) * bar_width_inches
+    fig_size = (fig_width, fig_height)
+
+    subplot_top = 1 - (suptitle_space_inch / fig_height)
+    subplot_hspace = ax_hspace_inch / ax_height_inch
+
+    bar_half_width = 0.5
+    lower_xbound = (0 - bar_half_width) - x_padding
+    upper_xbound = (num_samples - 1) + bar_half_width + x_padding
+
+    fig, axes = plt.subplots(2, figsize=fig_size, sharex=True)
+    fig.subplots_adjust(
+        bottom=0, top=subplot_top, left=0, right=1, hspace=subplot_hspace
+    )
+    fig.suptitle("A box and bars plot", y=1)
+
+    # Plot boxplots using the box_values
+    ax = axes[0]
+    ax.axhline(0, color="#999999", lw=1, zorder=2)
+    boxplots = ax.boxplot(
+        box_values,
+        positions=x_values,
+        vert=True,
+        showfliers=False,
+        patch_artist=True,
+        widths=bar_width,
+        medianprops={"color": "#000000"},
+    )
+    for color, edge_color, box in zip(
+        colors, edge_colors, boxplots["boxes"], strict=True
+    ):
+        box.set(facecolor=color)
+        box.set(edgecolor=edge_color)
+    ylim = ax.get_ylim()
+    ax.set_ylim(min(-0.4, ylim[0]), max(0.401, ylim[1]))
+
+    # Plot barplots using the bar_values
+    ax = axes[1]
+    ax.bar(x_values, bar_values, width=bar_width, color=colors, edgecolor=edge_colors)
+    ax.set_xticklabels(
+        group_names, fontsize=plt.rcParams["axes.labelsize"], rotation=90
+    )
+    for ax in axes:
+        ax.grid(False, axis="x")
+    sns.despine(top=True, right=True)
+
+    ax.set_xlim(lower_xbound, upper_xbound)
+    return fig, axes