msreport 0.0.26__tar.gz → 0.0.27__tar.gz

{msreport-0.0.26 → msreport-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msreport
-Version: 0.0.26
+Version: 0.0.27
 Summary: Post processing and analysis of quantitative proteomics data
 Author-email: "David M. Hollenstein" <hollenstein.david@gmail.com>
 License: Apache-2.0
@@ -24,6 +24,7 @@ Requires-Dist: scikit-learn>=1.0.0
 Requires-Dist: scipy>=1.9.1
 Requires-Dist: seaborn>=0.12.0
 Requires-Dist: statsmodels>=0.13.2
+Requires-Dist: typing_extensions>=4
 Dynamic: license-file
 
 [![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)

{msreport-0.0.26 → msreport-0.0.27}/msreport/__init__.py

@@ -10,4 +10,4 @@ import msreport.normalize
 import msreport.plot
 import msreport.reader
 
-__version__ = "0.0.26"
+__version__ = "0.0.27"

{msreport-0.0.26 → msreport-0.0.27}/msreport/analyze.py

@@ -9,7 +9,7 @@ import pandas as pd
 
 import msreport.normalize
 import msreport.rinterface
-from msreport.qtable import Qtable
+from msreport.helper import find_sample_columns
 
 
 class Transformer(Protocol):
@@ -33,8 +33,8 @@ class CategoryTransformer(Protocol):
     def transform(self, table: pd.DataFrame) -> pd.DataFrame:
         """Transform values in 'table'."""
 
-    def get_category_column(self, table: pd.DataFrame) -> pd.DataFrame:
-        """Returns the specified category column."""
+    def get_category_column(self) -> str:
+        """Returns the name of the category column."""
 
 
 def analyze_missingness(qtable: Qtable) -> None:
@@ -75,6 +75,7 @@ def analyze_missingness(qtable: Qtable) -> None:
 def validate_proteins(
     qtable: Qtable,
     min_peptides: int = 0,
+    min_spectral_counts: int = 0,
     remove_contaminants: bool = True,
     min_events: Optional[int] = None,
     max_missing: Optional[int] = None,
@@ -84,12 +85,13 @@ def validate_proteins(
     Adds an additional column "Valid" to the qtable, containing Boolean values.
 
     Requires expression columns to be set. Depending on the arguments requires the
-    columns "Total peptides", "Potential contaminant", and the experiment columns
-    "Missing experiment_name" and "Events experiment_name".
+    columns "Total peptides", "Spectral count Combined", "Potential contaminant", and
+    the experiment columns "Missing experiment_name" and "Events experiment_name".
 
     Args:
         qtable: A Qtable instance.
         min_peptides: Minimum number of unique peptides, default 0.
+        min_spectral_counts: Minimum number of combined spectral counts, default 0.
         remove_contaminants: If true, the "Potential contaminant" column is used to
             remove invalid entries, default True. If no "Potential contaminant" column
             is present 'remove_contaminants' is ignored.
@@ -107,6 +109,16 @@ def validate_proteins(
             [valid_entries, qtable["Total peptides"] >= min_peptides], axis=0
         )
 
+    if min_spectral_counts > 0:
+        if "Spectral count Combined" not in qtable:
+            raise KeyError(
+                "'Spectral count Combined' column not present in qtable.data"
+            )
+        valid_entries = np.all(
+            [valid_entries, qtable["Spectral count Combined"] >= min_spectral_counts],
+            axis=0,
+        )
+
     # TODO: not tested from here #
     if remove_contaminants:
         if "Potential contaminant" not in qtable:
@@ -138,6 +150,50 @@ def validate_proteins(
     qtable["Valid"] = valid_entries
 
 
+def apply_transformer(
+    qtable: msreport.Qtable,
+    transformer: Transformer,
+    tag: str,
+    exclude_invalid: bool,
+    remove_invalid: bool,
+    new_tag: Optional[str] = None,
+) -> None:
+    """Applies a transformer to the values of a Qtable selected with the tag parameter.
+
+    Args:
+        qtable: A Qtable instance, to which the transformer is applied.
+        transformer: The transformer to apply.
+        tag: The tag used to identify the columns for applying the transformer.
+        exclude_invalid: Exclude invalid values from the transformation.
+        remove_invalid: Remove invalid values from the table after the transformation.
+        new_tag: Optional, if specified than the tag is replaced with this value in the
+            column names and the transformed data is stored to these new columns.
+    """
+    valid = qtable.data["Valid"]
+    samples = qtable.get_samples()
+    sample_columns = find_sample_columns(qtable.data, tag, samples)
+
+    if not sample_columns:
+        raise ValueError(f"No sample columns found for tag '{tag}'.")
+
+    if new_tag is not None:
+        sample_columns = [c.replace(tag, new_tag) for c in sample_columns]
+    column_mapping = dict(zip(samples, sample_columns))
+
+    data_table = qtable.make_sample_table(tag, samples_as_columns=True)
+
+    if exclude_invalid:
+        data_table[valid] = transformer.transform(data_table[valid])
+    else:
+        data_table = transformer.transform(data_table)
+
+    if remove_invalid:
+        data_table[~valid] = np.nan
+
+    data_table.columns = [column_mapping[s] for s in data_table.columns]
+    qtable.data[data_table.columns] = data_table
+
+
 def normalize_expression(
     qtable: Qtable,
     normalizer: Transformer,
@@ -168,11 +224,9 @@ def normalize_expression(
     raw_data = table[sample_columns]
     if not normalizer.is_fitted():
         if exclude_invalid:
-            valid_mask = table["Valid"]
+            normalizer.fit(raw_data[table["Valid"]])
         else:
-            valid_mask = np.ones_like(table["Valid"], dtype=bool)
-        fit_data = raw_data[valid_mask]
-        normalizer = normalizer.fit(fit_data)
+            normalizer = normalizer.fit(raw_data)
 
     transformed_data = normalizer.transform(raw_data)
     qtable[expression_columns] = transformed_data[sample_columns]
@@ -421,7 +475,7 @@ def two_group_comparison(
 
 def calculate_multi_group_limma(
     qtable: Qtable,
-    experiment_pairs: list[list[str, str]],
+    experiment_pairs: Iterable[Iterable[str]],
     exclude_invalid: bool = True,
     batch: bool = False,
     limma_trend: bool = True,
@@ -454,6 +508,14 @@ def calculate_multi_group_limma(
         limma_trend: If true, an intensity-dependent trend is fitted to the prior
             variance during calculation of the moderated t-statistics, refer to
             limma.eBayes for details; default True.
+
+    Raises:
+        KeyError: If the "Batch" column is not present in the qtable.design when
+            'batch' is set to True.
+        ValueError: If all values from qtable.design["Batch"] are identical when 'batch'
+            is set to True.
+        ValueError: If the same experiment pair has been specified multiple times in
+            'experiment_pairs'.
     """
     # TODO: not tested #
     if batch and "Batch" not in qtable.get_design():
@@ -466,6 +528,11 @@ def calculate_multi_group_limma(
             "When using calculate_multi_group_limma(batch=True), not all values from"
             ' qtable.design["Batch"] are allowed to be identical.'
         )
+    if len(list(experiment_pairs)) != len(set(experiment_pairs)):
+        raise ValueError(
+            "The same experiment pair has been specified multiple times."
+            " Each entry in the `experiment_pairs` argument must be unique."
+        )
 
     design = qtable.get_design()
     table = qtable.make_expression_table(
@@ -504,7 +571,7 @@ def calculate_multi_group_limma(
         limma_result.rename(columns=mapping, inplace=True)
 
     limma_table = pd.DataFrame(index=table.index)
-    limma_table = limma_table.join(limma_results.values())
+    limma_table = limma_table.join(list(limma_results.values()))
     limma_table.fillna(np.nan, inplace=True)
     qtable.add_expression_features(limma_table)
 
@@ -516,7 +583,7 @@ def calculate_multi_group_limma(
 
 def calculate_two_group_limma(
     qtable: Qtable,
-    experiment_pair: list[str, str],
+    experiment_pair: list[str],
     exclude_invalid: bool = True,
     limma_trend: bool = True,
 ) -> None:
@@ -582,5 +649,3 @@ def calculate_two_group_limma(
     mapping = {col: f"{col} {comparison_group}" for col in limma_table.columns}
     limma_table.rename(columns=mapping, inplace=True)
     qtable.add_expression_features(limma_table)
-
-    return limma_result

{msreport-0.0.26 → msreport-0.0.27}/msreport/helper/calc.py

@@ -19,22 +19,28 @@ def mode(values: Iterable) -> float:
     Returns:
         The estimated mode. If no finite values are present, returns nan.
     """
-    values = np.array(values)
+    values = np.asarray(values)
     finite_values = values[np.isfinite(values)]
     if len(finite_values) == 0:
-        mode = np.nan
+        return np.nan
     elif len(np.unique(finite_values)) == 1:
-        mode = np.unique(finite_values)[0]
-    else:
-        median = np.median(finite_values)
-        bounds = (median - 1.5, median + 1.5)
-        kde = scipy.stats.gaussian_kde(finite_values)
-        optimize_result = scipy.optimize.minimize_scalar(
-            lambda x: -kde(x)[0], method="Bounded", bounds=bounds
-        )
-        mode = optimize_result.x
-        # Maybe add fallback function if optimize was not successful
-    return mode
+        return np.unique(finite_values)[0]
+
+    kde = scipy.stats.gaussian_kde(finite_values)
+    minimum_function = lambda x: -kde(x)[0]
+
+    min_slice, max_sclice = np.percentile(finite_values, (2, 98))
+    slice_step = 0.2
+    brute_optimize_result = scipy.optimize.brute(
+        minimum_function, [slice(min_slice, max_sclice + slice_step, slice_step)]
+    )
+    rough_minimum = brute_optimize_result[0]
+
+    local_optimize_result = scipy.optimize.minimize(
+        minimum_function, x0=rough_minimum, method="BFGS"
+    )
+    fine_minimum = local_optimize_result.x[0]
+    return fine_minimum
 
 
 def calculate_tryptic_ibaq_peptides(protein_sequence: str) -> int:

{msreport-0.0.26 → msreport-0.0.27}/msreport/impute.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Optional
+from typing import Optional, Any
 
 import numpy as np
 import pandas as pd
@@ -18,7 +18,7 @@ class FixedValueImputer:
     def __init__(
         self,
         strategy: str,
-        fill_value: Optional[float] = None,
+        fill_value: float = 0.0,
         column_wise: bool = True,
     ):
         """Initializes the FixedValueImputer.
@@ -51,13 +51,11 @@ class FixedValueImputer:
             Returns the fitted FixedValueImputer instance.
         """
         if self.strategy == "constant":
-            # if not isinstance(self.fill_value, (float, int)):
-            #     raise Excpetion()
             fill_values = {column: self.fill_value for column in table.columns}
         elif self.strategy == "below":
             if self.column_wise:
                 fill_values = {}
-                for column in table:
+                for column in table.columns:
                     fill_values[column] = _calculate_integer_below_min(table[column])
             else:
                 int_below_min = _calculate_integer_below_min(table)
@@ -240,7 +238,7 @@ class PerseusImputer:
         return _table
 
 
-def confirm_is_fitted(imputer: any, msg: Optional[str] = None) -> None:
+def confirm_is_fitted(imputer: Any, msg: Optional[str] = None) -> None:
     """Perform is_fitted validation for imputer instances.
 
     Checks if the imputer is fitted by verifying the presence of fitted attributes

{msreport-0.0.26 → msreport-0.0.27}/msreport/normalize.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
-import abc
-import itertools
-from typing import Callable, Iterable, Optional
+from typing import Callable, Iterable, Optional, Protocol
+from typing_extensions import Self
 
 import numpy as np
 import pandas as pd
@@ -12,27 +11,18 @@ import msreport.helper.maxlfq as MAXLFQ
 from msreport.errors import NotFittedError
 
 
-class BaseSampleNormalizer(abc.ABC):
-    """Base class for all sample normalizers."""
+class AbstractTransformer(Protocol):
+    def fit(self, table: pd.DataFrame) -> Self:
+        """Fits the Transformer and returns a fitted Transformer instance."""
 
-    @abc.abstractmethod
-    def fit(self, table: pd.DataFrame) -> BaseSampleNormalizer:
-        ...
-
-    @abc.abstractmethod
     def is_fitted(self) -> bool:
-        ...
-
-    @abc.abstractmethod
-    def get_fits(self) -> dict[...]:
-        ...
+        """Returns True if the Transformer has been fitted."""
 
-    @abc.abstractmethod
     def transform(self, table: pd.DataFrame) -> pd.DataFrame:
-        ...
+        """Transform values in table."""
 
 
-class FixedValueNormalizer(BaseSampleNormalizer):
+class FixedValueNormalizer:
     """Normalization by a constant normalization factor for each sample.
 
     Expects log transformed intensity values.
@@ -58,11 +48,11 @@ class FixedValueNormalizer(BaseSampleNormalizer):
                 f'"comparison" = {comparison} not allowed. '
                 'Must be either "paired" or "reference".'
             )
-        self._comparison_mode = comparison
-        self._fit_function = center_function
-        self._sample_fits = None
+        self._comparison_mode: str = comparison
+        self._fit_function: Callable = center_function
+        self._sample_fits: dict[str, float] = {}
 
-    def fit(self, table: pd.DataFrame) -> BaseSampleNormalizer:
+    def fit(self, table: pd.DataFrame) -> Self:
         """Fits the FixedValueNormalizer.
 
         Args:
@@ -80,7 +70,7 @@ class FixedValueNormalizer(BaseSampleNormalizer):
 
     def is_fitted(self) -> bool:
         """Returns True if the FixedValueNormalizer has been fitted."""
-        return self._sample_fits is not None
+        return True if self._sample_fits else False
 
     def get_fits(self) -> dict[str, float]:
         """Returns a dictionary containing the fitted center values per sample.
@@ -159,13 +149,13 @@ class FixedValueNormalizer(BaseSampleNormalizer):
             self._sample_fits[sample] = sample_fit
 
 
-class ValueDependentNormalizer(BaseSampleNormalizer):
+class ValueDependentNormalizer:
     """Normalization with a value dependent fit for each sample.
 
     Expects log transformed intensity values.
     """
 
-    def __init__(self, fit_function: Callable):
+    def __init__(self, fit_function: Callable[[Iterable, Iterable], np.ndarray]):
         """Initializes the ValueDependentNormalizer.
 
         Args:
@@ -175,10 +165,10 @@ class ValueDependentNormalizer(BaseSampleNormalizer):
                 with two columns. The first column contains the values and the second
                 column the fitted deviations.
         """
-        self._sample_fits = None
+        self._sample_fits: dict[str, np.ndarray] = {}
         self._fit_function = fit_function
 
-    def fit(self, table: pd.DataFrame) -> BaseSampleNormalizer:
+    def fit(self, table: pd.DataFrame) -> Self:
         """Fits the ValueDependentNormalizer.
 
         Args:
@@ -192,9 +182,9 @@ class ValueDependentNormalizer(BaseSampleNormalizer):
 
     def is_fitted(self) -> bool:
         """Returns True if the ValueDependentNormalizer has been fitted."""
-        return self._sample_fits is not None
+        return True if self._sample_fits else False
 
-    def get_fits(self) -> dict[str, Iterable[float, float]]:
+    def get_fits(self) -> dict[str, np.ndarray]:
         """Returns a dictionary containing lists of fitting data per sample.
 
         Returns:
@@ -324,14 +314,14 @@ class CategoricalNormalizer:
                 column must be present in the reference table and the table to be
                 transformed.
         """
-        self._fitted_table = None
-        self._category_column = category_column
+        self._fitted_table: pd.DataFrame = pd.DataFrame()
+        self._category_column: str = category_column
 
     def is_fitted(self) -> bool:
         """Returns True if the CategoricalNormalizer has been fitted."""
-        return self._fitted_table is not None
+        return not self._fitted_table.empty
 
-    def fit(self, reference_table: pd.DataFrame) -> BaseSampleNormalizer:
+    def fit(self, reference_table: pd.DataFrame) -> Self:
         """Fits the CategoricalNormalizer to a reference table.
 
         Args:
@@ -397,7 +387,34 @@ class CategoricalNormalizer:
         return transformed_table
 
 
-class ZscoreScaler(BaseSampleNormalizer):
+class PercentageScaler:
+    """Transform column values to percentages by dividing them with the column sum."""
+
+    def fit(self, table: pd.DataFrame) -> Self:
+        """Returns the instance itself."""
+        return self
+
+    def is_fitted(self) -> bool:
+        """Always returns True because the ZscoreScaler does not need to be fitted."""
+        return True
+
+    def get_fits(self) -> dict:
+        """Returns a dictionary containing the parameters 'with_mean' and 'with_std'."""
+        return {}
+
+    def transform(self, table: pd.DataFrame) -> pd.DataFrame:
+        """Transforms column values into percentages by devision with the column sum.
+
+        Args:
+            table: The table used to scale row values.
+
+        Returns:
+            A copy of the table containing the scaled values.
+        """
+        return table.divide(table.sum(axis=0), axis=1)
+
+
+class ZscoreScaler:
     """Normalize samples by z-score scaling."""
 
     def __init__(self, with_mean: bool = True, with_std: bool = True):
@@ -410,7 +427,7 @@ class ZscoreScaler(BaseSampleNormalizer):
         self._with_mean = with_mean
         self._with_std = with_std
 
-    def fit(self, table: pd.DataFrame) -> BaseSampleNormalizer:
+    def fit(self, table: pd.DataFrame) -> Self:
         """Returns the instance itself."""
         return self
 
@@ -440,7 +457,7 @@ class ZscoreScaler(BaseSampleNormalizer):
 
 
 def confirm_is_fitted(
-    normalizer: BaseSampleNormalizer, msg: Optional[str] = None
+    normalizer: AbstractTransformer, msg: Optional[str] = None
 ) -> None:
     """Perform is_fitted validation for normalizer instances.
 

{msreport-0.0.26 → msreport-0.0.27}/msreport/plot.py

@@ -703,16 +703,18 @@ def volcano_ma(
         y_col = " ".join([y_variable, comparison_group])
         x_values = data[x_col]
         y_values = data[y_col]
-        ax.grid(axis="both", linestyle="dotted", linewidth=1)
+        xy_labels = data[annotation_column]
 
-        mask = masks["default"]
-        ax.scatter(x_values[mask], y_values[mask], **params["default"])
+        valid_values = np.isfinite(x_values) & np.isfinite(y_values)
+        mask_default = masks["default"] & valid_values
+        mask_special = masks["highlight"] & valid_values
 
-        mask = masks["highlight"]
+        ax.grid(axis="both", linestyle="dotted", linewidth=1)
+        ax.scatter(x_values[mask_default], y_values[mask_default], **params["default"])
         _annotated_scatter(
-            x_values=data[x_col][mask],
-            y_values=data[y_col][mask],
-            labels=data[annotation_column][mask],
+            x_values=x_values[mask_special],
+            y_values=y_values[mask_special],
+            labels=xy_labels[mask_special],
             ax=ax,
             scatter_kws=params["highlight"],
         )

{msreport-0.0.26 → msreport-0.0.27}/msreport.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msreport
-Version: 0.0.26
+Version: 0.0.27
 Summary: Post processing and analysis of quantitative proteomics data
 Author-email: "David M. Hollenstein" <hollenstein.david@gmail.com>
 License: Apache-2.0
@@ -24,6 +24,7 @@ Requires-Dist: scikit-learn>=1.0.0
 Requires-Dist: scipy>=1.9.1
 Requires-Dist: seaborn>=0.12.0
 Requires-Dist: statsmodels>=0.13.2
+Requires-Dist: typing_extensions>=4
 Dynamic: license-file
 
 [![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)

{msreport-0.0.26 → msreport-0.0.27}/msreport.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ tests/test_impute.py
 tests/test_isobar.py
 tests/test_maxlfq.py
 tests/test_peptidoform.py
+tests/test_plot.py
 tests/test_qtable.py

{msreport-0.0.26 → msreport-0.0.27}/msreport.egg-info/requires.txt

@@ -10,3 +10,4 @@ scikit-learn>=1.0.0
 scipy>=1.9.1
 seaborn>=0.12.0
 statsmodels>=0.13.2
+typing_extensions>=4

{msreport-0.0.26 → msreport-0.0.27}/pyproject.toml

@@ -36,6 +36,7 @@ dependencies = [
   "scipy >= 1.9.1",
   "seaborn >= 0.12.0",
   "statsmodels >= 0.13.2",
+  "typing_extensions >= 4",
 ]
 dynamic = ["version"]
 

{msreport-0.0.26 → msreport-0.0.27}/tests/test_analyze.py

@@ -110,6 +110,48 @@ class TestValidateProteins:
         assert expected_valid == self.qtable.data["Valid"].sum()
 
 
+class TestApplyTransformer:
+    @pytest.fixture(autouse=True)
+    def _init_imputer(self, example_qtable):
+        class MockTransformer:
+            def fit(self, table: pd.DataFrame):
+                return self
+
+            def is_fitted(self):
+                return True
+
+            def transform(self, table: pd.DataFrame):
+                _table = table.copy()
+                _table[_table.columns] = 1.0
+                return _table
+
+        self.transformer = MockTransformer()
+
+    def test_transformation_applied_to_all_values_with_no_exclusion_and_removal(self, example_qtable):  # fmt: skip
+        msreport.analyze.apply_transformer(example_qtable, self.transformer, "Expression", exclude_invalid=False, remove_invalid=False)  # fmt: skip
+        table = example_qtable.make_expression_table()
+        assert table.eq(1.0).all().all()
+
+    def test_invalid_values_are_set_to_nan_with_remove_invalid(self, example_qtable):
+        example_qtable.data.loc[0, "Valid"] = False
+        msreport.analyze.apply_transformer(example_qtable, self.transformer, "Expression", exclude_invalid=False, remove_invalid=True)  # fmt: skip
+        table = example_qtable.make_expression_table()
+        assert table.loc[0, :].isna().all()
+
+    def test_invalid_values_are_not_transformed_with_exclude_invalid(self, example_qtable):  # fmt: skip
+        example_qtable.data.loc[0, "Valid"] = False
+        msreport.analyze.apply_transformer(example_qtable, self.transformer, "Expression", exclude_invalid=True, remove_invalid=False)  # fmt: skip
+        table = example_qtable.make_expression_table()
+        assert not table.loc[0, :].eq(1.0).all().all()
+        assert table.loc[1:, :].eq(1.0).all().all()
+
+    # Further test if the transformer creates a new set of columns and leaves the old set untouched
+    def test_new_columns_are_created_with_new_tag_parameter(self, example_qtable):
+        msreport.analyze.apply_transformer(example_qtable, self.transformer, "Expression", new_tag="New", exclude_invalid=False, remove_invalid=False)  # fmt: skip
+        new_column_samples = example_qtable.make_sample_table("New", samples_as_columns=True).columns.tolist()  # fmt: skip
+        assert new_column_samples == example_qtable.get_samples()
+
+
 class TestNormalizeExpression:
     def test_normalization_with_fitted_normalizer(self, example_qtable):
         shift = 1
@@ -315,7 +357,7 @@ class TestNormalizeExpressionByCategory:
 
             def transform(self, table: pd.DataFrame):
                 table = table.copy()
-                table.loc[:, :] = 0
+                table[table.columns] = 0
                 return table
 
             def get_category_column(self):

msreport-0.0.27/tests/test_plot.py

@@ -0,0 +1,121 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+import msreport.qtable
+import msreport.plot
+
+
+@pytest.fixture
+def example_data():
+    design = pd.DataFrame(
+        [
+            ("Sample_A1", "Experiment_A", "1"),
+            ("Sample_A2", "Experiment_A", "1"),
+            ("Sample_B1", "Experiment_B", "1"),
+            ("Sample_B2", "Experiment_B", "1"),
+        ],
+        columns=["Sample", "Experiment", "Replicate"],
+    )
+    data = pd.DataFrame(
+        {
+            "Representative protein": ["A", "B", "C"],
+            "Intensity Sample_A1": [10, 11, 10.3],
+            "Intensity Sample_A2": [10, np.nan, 10.3],
+            "Intensity Sample_B1": [11, 11, np.nan],
+            "Intensity Sample_B2": [15, np.nan, 10.3],
+            "Expression Experiment_A": [10, 11, 10.3],  # <- Adjust to Sample_A1/A2
+            "Expression Experiment_B": [13, 11, 10.3],  # <- Adjust to Sample_A1/A2
+            "Ratio [log2] Experiment_A vs Experiment_B": [-3, np.nan, 0],
+            "P-value Experiment_A vs Experiment_B": [0.0001, np.nan, 0.1],
+            "Average expression Experiment_A vs Experiment_B": [11.5, 11, 10.3],
+            "Valid": [True, False, True],
+        }
+    )
+    missing_values = pd.DataFrame(
+        {
+            "Missing total": [0, 4, 1],
+            "Missing Experiment_A": [0, 2, 0],
+            "Missing Experiment_B": [0, 2, 1],
+            "Events total": [4, 0, 3],
+            "Events Experiment_A": [2, 0, 2],
+            "Events Experiment_B": [2, 0, 1],
+        }
+    )
+    data = data.join(missing_values)
+    example_data = {"data": data, "design": design}
+    return example_data
+
+
+@pytest.fixture
+def example_qtable(example_data):
+    qtable = msreport.qtable.Qtable(example_data["data"], design=example_data["design"])
+    qtable.set_expression_by_tag("Intensity")
+    return qtable
+
+
+class TestVolcanoMa:
+    @pytest.fixture(autouse=True)
+    def _init_qtable(self, example_qtable):
+        self.qtable = example_qtable
+
+    def test_no_error_without_missing_values_due_to_exclude_invalid(self):
+        fig, axes = msreport.plot.volcano_ma(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            pvalue_tag="P-value",
+            special_proteins=["A", "B", "C"],
+            exclude_invalid=True,
+        )
+
+    def test_no_error_with_missing_values_but_no_special_protein_labeling(self):
+        fig, axes = msreport.plot.volcano_ma(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            pvalue_tag="P-value",
+            exclude_invalid=False,
+        )
+
+    def test_no_error_with_missing_values_of_special_proteins(self):
+        fig, axes = msreport.plot.volcano_ma(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            pvalue_tag="P-value",
+            special_proteins=["A", "B", "C"],
+            exclude_invalid=False,
+        )
+
+
+class TestExpressionComparison:
+    @pytest.fixture(autouse=True)
+    def _init_qtable(self, example_qtable):
+        self.qtable = example_qtable
+
+    def test_no_error_without_missing_values_due_to_exclude_invalid(self):
+        fig, axes = msreport.plot.expression_comparison(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            special_proteins=["A", "B", "C"],
+            exclude_invalid=True,
+        )
+
+    def test_no_error_with_missing_values_but_no_special_protein_labeling(self):
+        fig, axes = msreport.plot.expression_comparison(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            exclude_invalid=False,
+        )
+
+    def test_no_error_with_missing_values_of_special_proteins(self):
+        fig, axes = msreport.plot.expression_comparison(
+            self.qtable,
+            ["Experiment_A", "Experiment_B"],
+            comparison_tag=" vs ",
+            special_proteins=["A", "B", "C"],
+            exclude_invalid=False,
+        )