ms-mint 0.3.0__tar.gz → 0.3.2__tar.gz

{ms-mint-0.3.0/ms_mint.egg-info → ms-mint-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ms-mint
-Version: 0.3.0
+Version: 0.3.2
 Summary: Metabolomics Integrator (Mint)
 Home-page: https://github.com/LewisResearchGroup/ms-mint
 Author: Soren Wacker
@@ -15,6 +15,8 @@ License-File: LICENSE
 [![Python package](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml/badge.svg)](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml)
 ![](https://github.com/LewisResearchGroup/ms-mint/blob/develop/images/coverage.svg)
 [![CodeQL](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml)
+![PyPI](https://img.shields.io/pypi/v/ms-mint?label=pypi%20package)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/ms-mint)
 
 # Wecome to ms-mint
 
@@ -136,7 +138,7 @@ If you only have retention time (Rt) values for your targets, or if the Rt value
 
 To use the `mint.opt.rt_min_max()` function, you will need to provide it with a list of retention times for your targets and the names of the mass spectrometry files containing your data. The function will then search through the data to find the optimal `rt_min` and `rt_max` values, which you can use to refine your analysis. You can then use these optimized values in conjunction with the other functions and methods of the `Mint` class to process and analyze your data.
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-before-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-before-opt.png)
 
 Now, we can run the peak optimization with:
 
@@ -153,7 +155,7 @@ If you do not provide a list of peak_labels to the `mint.opt.rt_min_max()` funct
 
 After running the optimization, it is a good idea to perform a manual fine-tuning of the `rt_min` and `rt_max` values, especially for complicated peaks (peaks with multiple components, noisy peaks, etc.). You can use the `mint.plot.peak_shapes()` function to visualize the peak shapes and identify any areas that may require further attention.
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/optimize-rt_min_max.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/optimize-rt_min_max.png)
 
 The black lines indicates the average intensity across all files used for the optimization. The orange dotted lines show the shape of the gaussian function used to weight the mean intensities for peak selection. The orange horizontal lines indicate the peak width and the blue `x`s show the identified peak maxima. The green shaded areas show the Rt ranges which were selected by the algorithm.
 
@@ -162,7 +164,7 @@ Then we apply the changes and plot the new peak shapes:
     mint.run()
     mint.plot.peak_shapes(col_wrap=3)
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
 As you can see, the shapes of Xanthine, Succinate, Citrulline look much better.
 
@@ -172,7 +174,7 @@ The `Mint` class has a few convenient methods to visualize and explore the proce
 
 ## Plot peak shapes
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
     mint.plot.peak_shapes(col_wrap = 3)
 
@@ -207,7 +209,7 @@ Before clustering the data can be transformed and scaled. By default `log2p1(x)
         cmap=None  # Name of a matplotlib color map                
     )
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/hierarchical_clustering.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/hierarchical_clustering.png)
 
 ## Principal Components Analysis
 
@@ -221,7 +223,7 @@ After running the PCA the results can be plotted with:
     
     mint.pca.plot.pairplot(n_components=5, interactive=False)
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/pca-pairplot.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/pca-pairplot.png)
 
 ## FAQ
 ### What is a target list

{ms-mint-0.3.0 → ms-mint-0.3.2}/README.md

@@ -1,6 +1,8 @@
 [![Python package](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml/badge.svg)](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml)
 ![](https://github.com/LewisResearchGroup/ms-mint/blob/develop/images/coverage.svg)
 [![CodeQL](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml)
+![PyPI](https://img.shields.io/pypi/v/ms-mint?label=pypi%20package)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/ms-mint)
 
 # Wecome to ms-mint
 
@@ -122,7 +124,7 @@ If you only have retention time (Rt) values for your targets, or if the Rt value
 
 To use the `mint.opt.rt_min_max()` function, you will need to provide it with a list of retention times for your targets and the names of the mass spectrometry files containing your data. The function will then search through the data to find the optimal `rt_min` and `rt_max` values, which you can use to refine your analysis. You can then use these optimized values in conjunction with the other functions and methods of the `Mint` class to process and analyze your data.
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-before-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-before-opt.png)
 
 Now, we can run the peak optimization with:
 
@@ -139,7 +141,7 @@ If you do not provide a list of peak_labels to the `mint.opt.rt_min_max()` funct
 
 After running the optimization, it is a good idea to perform a manual fine-tuning of the `rt_min` and `rt_max` values, especially for complicated peaks (peaks with multiple components, noisy peaks, etc.). You can use the `mint.plot.peak_shapes()` function to visualize the peak shapes and identify any areas that may require further attention.
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/optimize-rt_min_max.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/optimize-rt_min_max.png)
 
 The black lines indicates the average intensity across all files used for the optimization. The orange dotted lines show the shape of the gaussian function used to weight the mean intensities for peak selection. The orange horizontal lines indicate the peak width and the blue `x`s show the identified peak maxima. The green shaded areas show the Rt ranges which were selected by the algorithm.
 
@@ -148,7 +150,7 @@ Then we apply the changes and plot the new peak shapes:
     mint.run()
     mint.plot.peak_shapes(col_wrap=3)
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
 As you can see, the shapes of Xanthine, Succinate, Citrulline look much better.
 
@@ -158,7 +160,7 @@ The `Mint` class has a few convenient methods to visualize and explore the proce
 
 ## Plot peak shapes
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
     mint.plot.peak_shapes(col_wrap = 3)
 
@@ -193,7 +195,7 @@ Before clustering the data can be transformed and scaled. By default `log2p1(x)
         cmap=None  # Name of a matplotlib color map                
     )
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/hierarchical_clustering.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/hierarchical_clustering.png)
 
 ## Principal Components Analysis
 
@@ -207,7 +209,7 @@ After running the PCA the results can be plotted with:
     
     mint.pca.plot.pairplot(n_components=5, interactive=False)
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/pca-pairplot.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/pca-pairplot.png)
 
 ## FAQ
 ### What is a target list

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/Mint.py

@@ -10,6 +10,8 @@ from pathlib import Path as P
 from multiprocessing import Pool, Manager, cpu_count
 from glob import glob
 
+from sklearn.preprocessing import StandardScaler, RobustScaler
+
 from .standards import MINT_RESULTS_COLUMNS, TARGETS_COLUMNS, DEPRECATED_LABELS
 from .processing import process_ms1_files_in_parallel, extract_chromatogram_from_ms1
 from .io import export_to_excel, ms_file_to_df
@@ -21,7 +23,8 @@ from .tools import (
     get_targets_from_results,
     scale_dataframe,
     init_metadata,
-    fn_to_label
+    fn_to_label,
+    log2p1
 )
 from .pca import PrincipalComponentsAnalyser
 from .MintPlotter import MintPlotter
@@ -59,7 +62,8 @@ class Mint(object):
     ):
         self.verbose = verbose
         self._version = ms_mint.__version__
-        print("Mint version:", self.version, "\n")
+        if verbose: 
+            print("Mint version:", self.version, "\n")
         self.progress_callback = progress_callback
         self.reset()
         self.plot = MintPlotter(mint=self)
@@ -381,40 +385,82 @@ class Mint(object):
     def results(self, df):
         self._results = df
 
-    def crosstab(self, values: str = "peak_max", index: str = None, column: str = None, aggfunc: str = 'mean', apply: Callable = None, scaler: Callable = None):
+    def crosstab(self, var_name: str = None, index: str = None, column: str = None, aggfunc: str = 'mean', 
+                 apply: Callable = None, scaler: Callable = None, groupby: str = None):
         """
         Create condensed representation of the results.
         More specifically, a cross-table with filenames as index and target labels.
         The values in the cells are determined by *col_name*.
 
-        :param col_name: Name of the column from *mint.results* table that is used for the cell values.
-        :type col_name: str
+        :param var_name: Name of the column from *mint.results* table that is used for the cell values. If None, defaults to 'peak_area_top3'.
+        :type var_name: str, optional
+
+        :param index: Name of the column to be used as index in the resulting cross-tabulation. If None, defaults to 'ms_file_label'.
+        :type index: str, optional
+
+        :param column: Name of the column to be used as columns in the resulting cross-tabulation. If None, defaults to 'peak_label'.
+        :type column: str, optional
+
+        :param aggfunc: Aggregation function to be used for aggregating values. Defaults to 'mean'.
+        :type aggfunc: str, optional
+
+        :param apply: Function to be applied to the resulting cross-tabulation. If None, no function is applied.
+        :type apply: Callable, optional
 
-        cells of the returned table.
+        :param scaler: Function to scale the data in the resulting cross-tabulation. If None, no scaling is performed.
+        :type scaler: Callable, optional
+
+        :param groupby: Name of the column to group data before scaling. If None, scaling is applied to the whole data, not group-wise.
+        :type groupby: str, optional
+
+        :return: DataFrame representing the cross-tabulation.
+        :rtype: pandas.DataFrame
         """
-        
         df_meta = pd.merge(self.meta, self.results, left_index=True, right_on='ms_file_label')
-
+        # Remove None if in index
+        if isinstance(index, list):
+            if None in index:
+                index.remove(None)
+        if isinstance(groupby, str):
+            groupby = [groupby]
+            
         if index is None:
             index = 'ms_file_label'
         if column is None:
             column = 'peak_label'
-        if values is None:
-            values = 'peak_area_top3'
-
-        df = pd.crosstab(
-            df_meta[index],
-            df_meta[column],
-            df_meta[values],
-            aggfunc=aggfunc,
-        ).astype(np.float64)
-
+        if var_name is None:
+            var_name = 'peak_area_top3'
         if apply:
-            df = df.apply(apply)
+            if apply == 'log2p1':
+                apply = log2p1
+            if apply == 'logp1':
+                apply = np.log1p
+            df_meta[var_name] = df_meta[var_name].apply(apply)
+        if isinstance(scaler, str):
+            scaler_dict = {'standard': StandardScaler(),
+                           'robust': RobustScaler()}
+
+            if scaler not in scaler_dict:
+                raise ValueError(f"Unsupported scaler: {scaler}")
+
+            scaler = scaler_dict[scaler]
+            
         if scaler:
-            df = scale_dataframe(df, scaler=scaler)
+            if groupby:          
+                groupby_cols = groupby + [column]
+                df_meta[var_name] = df_meta.groupby(groupby_cols)[var_name].transform(lambda x: self._scale_group(x, scaler))
+            else:
+                df_meta[var_name] = df_meta.groupby(column)[var_name].transform(lambda x: self._scale_group(x, scaler))
+                
+        df = pd.pivot_table(
+            df_meta,
+            index=index,
+            columns=column,
+            values=var_name,
+            aggfunc=aggfunc,
+        ).astype(np.float64)
         return df
-
+    
     @property
     def progress(self):
         """
@@ -564,3 +610,9 @@ class Mint(object):
         elif str(fn).endswith('.parquet'):
             self.meta.to_parquet(fn)
         return self
+
+    def _scale_group(self, group, scaler):
+        """
+        Helper function to scale groups individually.
+        """
+        return scaler.fit_transform(group.to_numpy().reshape(-1, 1)).flatten()

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/MintPlotter.py

@@ -1,12 +1,16 @@
 import numpy as np
 import seaborn as sns
+import warnings
 
-from warnings import simplefilter
 from scipy.cluster.hierarchy import ClusterWarning
 
 from pathlib import Path as P
+
+import matplotlib
 from matplotlib import pyplot as plt
 
+from typing import Optional, List, Tuple
+
 from .plotly_tools import plotly_heatmap, plotly_peak_shapes
 from .matplotlib_tools import (
     plot_peak_shapes,
@@ -14,6 +18,7 @@ from .matplotlib_tools import (
     plot_metabolomics_hist2d,
 )
 
+import pandas as pd
 import plotly.express as px
 
 from .tools import scale_dataframe, mz_mean_width_to_min_max
@@ -36,103 +41,71 @@ class MintPlotter:
         :type mint: ms_mint.Mint.Mint
         """
         self.mint = mint
-
+        
+        
     def hierarchical_clustering(
         self,
-        data=None,
-        peak_labels=None,
-        ms_files=None,
-        title=None,
-        figsize=(8, 8),
-        targets_var="peak_max",
-        vmin=-3,
-        vmax=3,
-        xmaxticks=None,
-        ymaxticks=None,
-        transform_func="log2p1",
-        scaler_ms_file=None,
-        scaler_peak_label="standard",
-        metric="cosine",
-        transform_filenames_func="basename",
-        transposed=False,
+        data: Optional[pd.DataFrame] = None,
+        peak_labels: Optional[List[str]] = None,
+        ms_files: Optional[List[str]] = None,
+        title: Optional[str] = None,
+        figsize: Tuple[int, int] = (8, 8),
+        targets_var: Optional[str] = None,
+        var_name: str = "peak_max",
+        vmin: int = -3,
+        vmax: int = 3,
+        xmaxticks: Optional[int] = None,
+        ymaxticks: Optional[int] = None,
+        apply: str = "log2p1",
+        metric: str = "cosine",
+        scaler: str = "standard",
+        groupby: Optional[str] = None,
+        transposed: bool = False,
         **kwargs,
-    ):
+    ) -> matplotlib.figure.Figure:
         """
         Performs a cluster analysis and plots a heatmap. If no data is provided,
-        data is taken form self.mint.crosstab(targets_var).
+        data is taken from self.mint.crosstab(var_name).
         The clustered non-transformed non-scaled data is stored in `self.mint.clustered`.
 
-        :param transform_func: default 'log2p1', values: [None, 'log1p', 'log2p1', 'log10p1']
-            - None: no transformation
-            - log1p: tranform data with lambda x: np.log1p(x)
-            - log2p1: transform data with lambda x: log2(x+1)
-            - log10p1: transform data with lambda x: log10(x+1)
-
-        :param scaler_ms_file: default None, values: [None, 'standard', 'robust']
-            - scaler used to scale along ms_file axis
-            - if None no scaling is applied
-            - if 'standard' use scikit learn StandardScaler()
-            - if 'robust' use scikit learn RobustScaler()
-
-        :param scaler_peak_label: default 'standard'
-            - like scaler_ms_file, but scaling along peak_label axis
-
-        :param metric: default 'cosine', can be string or a list of two values:
-            if two values are provided e.g. ('cosine', 'euclidean') the first
-            will be used to cluster the x-axis and the second for the y-axis.
-
-            'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine',
-            'dice', 'euclidean', 'hamming', 'jaccard', 'jensenshannon', 'kulsinski', 'mahalanobis',
-            'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean',
-            'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'.
-            More information:
-            https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html
-
-        :param transpose: bool, default False
-            - True: transpose the figure
-        """
-        if len(self.mint.results) == 0:
-            return None
+        :param data: DataFrame with data to be used for clustering. If None, crosstab of mint instance is used.
+        :type data: pandas.DataFrame, optional
 
-        simplefilter("ignore", ClusterWarning)
-        if data is None:
-            data = self.mint.crosstab(targets_var).copy()
+        :param var_name: Name of the column from data to be used for cell values in the heatmap. Defaults to "peak_max".
+        :type var_name: str
 
-        if peak_labels is not None:
-            data = data[peak_labels]
+        :param apply: Transformation to be applied on the data. Can be "log1p", "log2p1", "log10p1" or None. Defaults to "log2p1".
+        :type apply: str, optional
+
+        :param scaler: Method to scale data along both axes. Can be "standard", "robust" or None. Defaults to "standard".
+        :type scaler: str, optional
 
-        if ms_files is not None:
-            data = data.loc[ms_files]
+        :param groupby: Name of the column to group data before scaling. If None, scaling is applied to the whole data, not group-wise.
+        :type groupby: str, optional
 
-        tmp_data = data.copy()
+        :param metric: The distance metric to use for the tree. Can be any metric supported by scipy.spatial.distance.pdist.
+        :type metric: str, optional
 
-        if transform_func == "log1p":
-            transform_func = np.log1p
-        if transform_func == "log2p1":
-            transform_func = lambda x: np.log2(x + 1)
-        if transform_func == "log10p1":
-            transform_func = lambda x: np.log10(x + 1)
-        if transform_func is not None:
-            tmp_data = tmp_data.apply(transform_func)
+        :param transposed: Whether to transpose the figure or not. Defaults to False.
+        :type transposed: bool, optional
 
-        if transform_filenames_func == "basename":
-            transform_filenames_func = lambda x: P(x).with_suffix("").name
-        if transform_filenames_func is not None:
-            tmp_data.index = [transform_filenames_func(i) for i in tmp_data.index]
+        :return: Matplotlib figure representing the clustered heatmap.
+        :rtype: matplotlib.figure.Figure
+        """
 
-        # Scale along ms-files
-        if scaler_ms_file is not None:
-            tmp_data = scale_dataframe(tmp_data.T, scaler_ms_file).T
+        if targets_var is not None:
+            warnings.warn("targets_var is depricated use var_name instead", DeprecationWarning)
+            var_name = targets_var
 
-        # Scale along peak_labels
-        if scaler_peak_label is not None:
-            tmp_data = scale_dataframe(tmp_data, scaler_peak_label)
+        warnings.simplefilter("ignore", ClusterWarning)
+        if data is None:
+            data = self.mint.crosstab(var_name=var_name, apply=apply, scaler=scaler, groupby=groupby)
 
         if transposed:
-            tmp_data = tmp_data.T
+            data = data.T
 
         _, fig, ndx_x, ndx_y = hierarchical_clustering(
-            tmp_data,
+            data,
             vmin=vmin,
             vmax=vmax,
             figsize=figsize,
@@ -142,10 +115,8 @@ class MintPlotter:
             **kwargs,
         )
 
-        if not transposed:
-            self.mint.clustered = data.iloc[ndx_x, ndx_y]
-        else:
-            self.mint.clustered = data.iloc[ndx_y, ndx_x]
+        self.mint.clustered = data.iloc[ndx_x, ndx_y]
+        
         return fig
     
 
@@ -162,11 +133,11 @@ class MintPlotter:
         if len(self.mint.results) > 0:
             if not interactive:
                 return plot_peak_shapes(
-                    self.mint.results, fns=fns, peak_labels=peak_labels, **kwargs
+                    self.mint.results, mint_metadata=self.mint.meta, fns=fns, peak_labels=peak_labels, **kwargs
                 )
             else:
                 return plotly_peak_shapes(
-                    self.mint.results, fns=fns, peak_labels=peak_labels, **kwargs
+                    self.mint.results, mint_metadata=self.mint.meta, fns=fns, peak_labels=peak_labels, **kwargs
                 )
 
     def heatmap(

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-07-12T09:44:18-0600",
+ "date": "2023-08-18T12:58:02-0600",
  "dirty": false,
  "error": null,
- "full-revisionid": "7cbe79c73d391939c5b0c475118bd3f68f274928",
- "version": "v0.3.0"
+ "full-revisionid": "2563246318a0e00988500da34daed80721f81b98",
+ "version": "v0.3.2"
 }
 '''  # END VERSION_JSON
 

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/io.py

@@ -64,7 +64,10 @@ def ms_file_to_df(fn, read_only: bool = False):
     except IndexError as e:
         logging.warning(f"{e}: {fn}")
         return None
-    if not read_only:
+    
+    if read_only:
+        return df
+    else:
         # Compatibility with old schema
         df = df.rename(
             columns={
@@ -73,9 +76,12 @@ def ms_file_to_df(fn, read_only: bool = False):
                 "m/z array": "mz",
             }
         )
+        if 'scan_id' not in df.columns:
+            df['scan_id'] = 0
+        if 'ms_level' not in df.columns:
+            df['ms_level'] = 1
         # Set datatypes
         set_dtypes(df)
-    print(df.columns)
     return df
 
 

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/matplotlib_tools.py

@@ -130,17 +130,19 @@ def hierarchical_clustering(
 
 def plot_peak_shapes(
     mint_results,
+    mint_metadata=None,
     fns=None,
     peak_labels=None,
     height=3,
     aspect=1.5,
     legend=False,
     col_wrap=4,
-    hue="ms_file",
+    hue="ms_file_label",
     title=None,
     dpi=None,
     sharex=False,
     sharey=False,
+    kind='line',
     **kwargs,
 ):
     """
@@ -148,6 +150,8 @@ def plot_peak_shapes(
 
     :param mint_results: DataFrame in Mint results format.
     :type mint_results: pandas.DataFrame
+    :param mint_metadata: DataFrame in Mint metadata format.
+    :type mint_metadata: pandas.DataFrame
     :param fns: Filenames to include, defaults to None
     :type fns: list, optional
     :param peak_labels: Peak-labels to include, defaults to None
@@ -170,6 +174,8 @@ def plot_peak_shapes(
     :type sharex: bool, optional
     :param sharey: Whether or not to share y-axis range between subplots, defaults to False
     :type sharey: bool, optional
+    :param kind: Kind of seaborn relplot
+    :type kind: str, optional
     :return: Generated figure object.
     :rtype: matplotlib.pyplot.Figure
     """
@@ -197,7 +203,7 @@ def plot_peak_shapes(
         ].iterrows():
             peak_rt = [float(i) for i in row.peak_shape_rt.split(",")]
             peak_int = [float(i) for i in row.peak_shape_int.split(",")]
-            ms_file = row.ms_file
+            ms_file_label = row.ms_file_label
             mz = row.mz_mean
             rt = row.rt
 
@@ -205,7 +211,7 @@ def plot_peak_shapes(
                 {
                     "Scan time [s]": peak_rt,
                     "Intensity": peak_int,
-                    "ms_file": ms_file,
+                    "ms_file_label": ms_file_label,
                     "peak_label": peak_label + f"\nm/z={mz:.3f}",
                     "Expected Scan time [s]": rt,
                 }
@@ -214,13 +220,17 @@ def plot_peak_shapes(
 
     df = pd.concat(dfs).reset_index(drop=True)
 
+    # Add metadata
+    if mint_metadata is not None:
+        df = pd.merge(df, mint_metadata, left_on='ms_file_label', right_index=True)
+
     g = sns.relplot(
         data=df,
         x="Scan time [s]",
         y="Intensity",
         hue=hue,
         col="peak_label",
-        kind="line",
+        kind=kind,
         col_wrap=col_wrap,
         height=height,
         aspect=aspect,

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/pca.py

@@ -2,6 +2,8 @@ import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
+import warnings
+
 import plotly.figure_factory as ff
 from plotly import express as px
 
@@ -25,7 +27,7 @@ class PrincipalComponentsAnalyser:
         self.results = None
         self.plot = PCA_Plotter(self)
 
-    def run(self, n_components=3, on="peak_max", fillna="median", scaler="standard"):
+    def run(self, n_components=3, on=None, var_name="peak_max", fillna="median", apply=None, groupby=None, scaler="standard"):
         """
         Run Principal Component Analysis on current results. Results are stored in
         self.decomposition_results.
@@ -39,8 +41,12 @@ class PrincipalComponentsAnalyser:
         :param scaler: Method to scale the columns, defaults to "standard"
         :type scaler: str, optional
         """
-
-        df = self.mint.crosstab(on).fillna(fillna)
+        
+        if on is not None:
+            warnings.warn("on is depricated use var_name instead", DeprecationWarning)            
+            var_name = on            
+        
+        df = self.mint.crosstab(var_name=var_name, apply=apply, scaler=scaler, groupby=groupby)
 
         if fillna == "median":
             fillna = df.median()
@@ -50,8 +56,6 @@ class PrincipalComponentsAnalyser:
             fillna = 0
 
         df = df.fillna(fillna)
-        if scaler is not None:
-            df = scale_dataframe(df, scaler)
 
         min_dim = min(df.shape)
         n_components = min(n_components, min_dim)

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/plotly_tools.py

@@ -1,6 +1,7 @@
 import logging
 
 import numpy as np
+import pandas as pd
 import colorlover as cl
 
 import plotly.graph_objects as go
@@ -222,6 +223,8 @@ def plotly_heatmap(
 
 def plotly_peak_shapes(
     mint_results,
+    mint_metadata=None,
+    color='ms_file_label',  # Add the new argument for specifying color column
     fns=None,
     col_wrap=1,
     peak_labels=None,
@@ -229,52 +232,90 @@ def plotly_peak_shapes(
     verbose=False,
     legend_orientation="v",
     call_show=False,
+    palette='Plasma',
 ):
-    """
-    Returns a plotly multiplost of all peak_shapes in mint.results
-    grouped by peak_label.
+    """ 
+    Plot peak shapes of mint results.
+
+    :param mint_results: DataFrame in Mint results format.
+    :type mint_results: pandas.DataFrame
+    :param mint_metadata: DataFrame in Mint metadata format, defaults to None.
+    :type mint_metadata: pandas.DataFrame, optional
+    :param color: Column name determining color-coding of plots, defaults to 'ms_file_label'.
+    :type color: str, optional
+    :param fns: Filenames to include, defaults to None.
+    :type fns: list, optional
+    :param col_wrap: Maximum number of subplot columns, defaults to 1.
+    :type col_wrap: int, optional
+    :param peak_labels: Peak-labels to include, defaults to None.
+    :type peak_labels: list, optional
+    :param legend: Whether to display legend, defaults to True.
+    :type legend: bool, optional
+    :param verbose: If True, prints additional details, defaults to False.
+    :type verbose: bool, optional
+    :param legend_orientation: Legend orientation, defaults to 'v'.
+    :type legend_orientation: str, optional
+    :param call_show: If True, displays the plot immediately, defaults to False.
+    :type call_show: bool, optional
+    :param palette: Color palette to use, defaults to 'Plasma'.
+    :type palette: str, optional
+
+    :return: Plotly Figure object or None if call_show is True.
+    :rtype: plotly.graph_objs._figure.Figure or None
     """
     mint_results = mint_results.copy()
 
+    # Merge with metadata if provided
+    if mint_metadata is not None:
+        mint_results = pd.merge(mint_results, mint_metadata, left_on='ms_file_label', right_index=True)
 
+    # Filter by filenames
     if fns is not None:
         fns = [fn_to_label(fn) for fn in fns]
         mint_results = mint_results[mint_results.ms_file_label.isin(fns)]
+    else:
+        fns = mint_results.ms_file_label.unique()
+    
+    # Filter by peak_labels
+    if peak_labels is not None:
+        if isinstance(peak_labels, str):
+            peak_labels = [peak_labels]
+        mint_results = mint_results[mint_results.peak_label.isin(peak_labels)]
+    else:
+        peak_labels = mint_results.results.peak_label.unique()
+        
+    # Handle colors based on metadata or fall back to default behavior
+    colors = None
+    if color:
+        unique_hues = mint_results[color].unique()
+
+        colors = get_palette_colors(palette, len(unique_hues)) 
+
+        color_mapping = dict(zip(unique_hues, colors))
+                        
+        if color == 'ms_file_label':
+            hue_column = [color_mapping[fn] for fn in fns]
+        else:
+            # Existing logic remains the same for the else part
+            hue_column = mint_results.drop_duplicates('ms_file_label').set_index('ms_file_label')[color].map(color_mapping).reindex(fns).tolist()
 
-    mint_results.ms_file = [P(fn).name for fn in mint_results.ms_file]
-
-    logging.warning("TEST")
+    else:
+        hue_column = colors
 
+    # Rest of the plotting process
     res = mint_results[mint_results.peak_max > 0]
-
-    fns = res.ms_file_label.unique()
     labels = mint_results.peak_label.unique()
-
     res = res.set_index(["peak_label", "ms_file_label"]).sort_index()
 
-    if isinstance(peak_labels, str):
-        peak_labels = [peak_labels]
-
-    # Calculate neccessary number of rows
+    # Calculate necessary number of rows
     n_rows = max(1, len(labels) // col_wrap)
     if n_rows * col_wrap < len(labels):
         n_rows += 1
 
-    if verbose:
-        print(n_rows, col_wrap)
-        print("ms_files:", fns)
-        print("peak_labels:", peak_labels)
-        print("Data:", res)
-
     fig = make_subplots(
         rows=max(1, n_rows), cols=max(1, col_wrap), subplot_titles=peak_labels
     )
-    if len(fns) < 13:
-        colors = cl.scales["12"]["qual"]["Paired"]
-    else:
-        colors = cl.interp(cl.scales["12"]["qual"]["Paired"], len(fns))
 
-    # Create sub-plots
     for label_i, label in enumerate(peak_labels):
         for file_i, fn in enumerate(fns):
             try:
@@ -282,9 +323,9 @@ def plotly_peak_shapes(
             except KeyError as e:
                 logging.warning(e)
                 continue
+
             if not isinstance(x, Iterable):
                 continue
-
             if isinstance(x, str):
                 x = x.split(",")
                 y = y.split(",")
@@ -297,6 +338,8 @@ def plotly_peak_shapes(
             else:
                 mode = "lines"
 
+            trace_color = trace_color = hue_column[file_i]
+
             fig.add_trace(
                 go.Scatter(
                     x=x,
@@ -305,7 +348,7 @@ def plotly_peak_shapes(
                     mode=mode,
                     legendgroup=file_i,
                     showlegend=(label_i == 0),
-                    marker_color=colors[file_i],
+                    marker_color=trace_color,
                     text=fn,
                 ),
                 row=ndx_r,
@@ -315,10 +358,10 @@ def plotly_peak_shapes(
             fig.update_xaxes(title_text="Scan time [s]", row=ndx_r, col=ndx_c)
             fig.update_yaxes(title_text="Intensity", row=ndx_r, col=ndx_c)
 
-    # Layout
+    # Layout updates
     if legend:
         fig.update_layout(legend_orientation=legend_orientation)
-
+        
     fig.update_layout(showlegend=legend)
     fig.update_layout(height=400 * n_rows, title_text="Peak Shapes")
 
@@ -326,3 +369,17 @@ def plotly_peak_shapes(
         fig.show(config={"displaylogo": False})
     else:
         return fig
+
+
+def get_palette_colors(palette_name, num_colors):
+    # Categories in the colorlover package
+    categories = ["qual", "seq", "div"]
+
+    num_colors = max(num_colors, 3)
+    # Check in which category our palette resides
+    for category in categories:
+        if palette_name in cl.scales[f"{num_colors}"][category]:
+            return cl.scales[f"{num_colors}"][category][palette_name]
+
+    # If palette not found in any category, return a default one or raise an error
+    return cl.scales[f"{num_colors}"]["qual"]["Paired"]

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/processing.py

@@ -89,7 +89,7 @@ def process_ms1_file(filename, targets):
     results["ms_file"] = filename
     results["ms_file_label"] = P(filename).with_suffix('').name
     results["ms_file_size_MB"] = os.path.getsize(filename) / 1024 / 1024
-    results["peak_score"] = score_peaks(results)
+    results["peak_score"] = 0 #  score_peaks(results)
     return results[MINT_RESULTS_COLUMNS]
 
 

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/standards.py

@@ -58,4 +58,18 @@ DEPRECATED_LABELS = {
     "ms_file_size": "ms_file_size_MB",
 }
 
+MINT_METADATA_COLUMNS = [
+    'ms_file_label',
+    'label', 
+    'group',
+    'batch',
+    'sample_type',
+    'run_order', 
+    'plate',
+    'plate_row', 
+    'plate_col',
+    'lc_column',
+    'polarity'
+]
+
 M_PROTON = 1.00782503223

{ms-mint-0.3.0 → ms-mint-0.3.2}/ms_mint/tools.py

@@ -8,11 +8,15 @@ from molmass import Formula, FormulaError
 from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler
 from scipy.signal import find_peaks, peak_widths
 
-from .standards import M_PROTON, TARGETS_COLUMNS
+from .standards import M_PROTON, TARGETS_COLUMNS, MINT_METADATA_COLUMNS
 from .filelock import FileLock
 from .matplotlib_tools import plot_peaks
 
 
+def log2p1(x):
+    return np.log2(x+1)
+
+
 def lock(fn):
     """
     File lock to ensure safe writing to file.
@@ -226,18 +230,9 @@ def mz_mean_width_to_min_max(mz_mean, mz_width):
     mz_max = mz_mean + delta_mass
     return mz_min, mz_max
 
+
 def init_metadata():
-    cols = [
-        'ms_file_label',
-        'ms_file',
-        'label', 
-        'group', 
-        'type',
-        'run_order', 
-        'plate', 
-        'plate_row', 
-        'plate_col'
-    ]
+    cols = MINT_METADATA_COLUMNS
     return pd.DataFrame(columns=cols).set_index('ms_file_label')
 
 

{ms-mint-0.3.0 → ms-mint-0.3.2/ms_mint.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ms-mint
-Version: 0.3.0
+Version: 0.3.2
 Summary: Metabolomics Integrator (Mint)
 Home-page: https://github.com/LewisResearchGroup/ms-mint
 Author: Soren Wacker
@@ -15,6 +15,8 @@ License-File: LICENSE
 [![Python package](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml/badge.svg)](https://github.com/LewisResearchGroup/ms-mint/actions/workflows/pythonpackage.yml)
 ![](https://github.com/LewisResearchGroup/ms-mint/blob/develop/images/coverage.svg)
 [![CodeQL](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/lewisresearchgroup/ms-mint/actions/workflows/codeql-analysis.yml)
+![PyPI](https://img.shields.io/pypi/v/ms-mint?label=pypi%20package)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/ms-mint)
 
 # Wecome to ms-mint
 
@@ -136,7 +138,7 @@ If you only have retention time (Rt) values for your targets, or if the Rt value
 
 To use the `mint.opt.rt_min_max()` function, you will need to provide it with a list of retention times for your targets and the names of the mass spectrometry files containing your data. The function will then search through the data to find the optimal `rt_min` and `rt_max` values, which you can use to refine your analysis. You can then use these optimized values in conjunction with the other functions and methods of the `Mint` class to process and analyze your data.
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-before-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-before-opt.png)
 
 Now, we can run the peak optimization with:
 
@@ -153,7 +155,7 @@ If you do not provide a list of peak_labels to the `mint.opt.rt_min_max()` funct
 
 After running the optimization, it is a good idea to perform a manual fine-tuning of the `rt_min` and `rt_max` values, especially for complicated peaks (peaks with multiple components, noisy peaks, etc.). You can use the `mint.plot.peak_shapes()` function to visualize the peak shapes and identify any areas that may require further attention.
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/optimize-rt_min_max.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/optimize-rt_min_max.png)
 
 The black lines indicates the average intensity across all files used for the optimization. The orange dotted lines show the shape of the gaussian function used to weight the mean intensities for peak selection. The orange horizontal lines indicate the peak width and the blue `x`s show the identified peak maxima. The green shaded areas show the Rt ranges which were selected by the algorithm.
 
@@ -162,7 +164,7 @@ Then we apply the changes and plot the new peak shapes:
     mint.run()
     mint.plot.peak_shapes(col_wrap=3)
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
 As you can see, the shapes of Xanthine, Succinate, Citrulline look much better.
 
@@ -172,7 +174,7 @@ The `Mint` class has a few convenient methods to visualize and explore the proce
 
 ## Plot peak shapes
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/peak-shapes-after-opt.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/peak-shapes-after-opt.png)
 
     mint.plot.peak_shapes(col_wrap = 3)
 
@@ -207,7 +209,7 @@ Before clustering the data can be transformed and scaled. By default `log2p1(x)
         cmap=None  # Name of a matplotlib color map                
     )
 
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/hierarchical_clustering.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/hierarchical_clustering.png)
 
 ## Principal Components Analysis
 
@@ -221,7 +223,7 @@ After running the PCA the results can be plotted with:
     
     mint.pca.plot.pairplot(n_components=5, interactive=False)
     
-![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/pca-pairplot.png)
+![](https://raw.githubusercontent.com/LewisResearchGroup/ms-mint/develop/notebooks/img/pca-pairplot.png)
 
 ## FAQ
 ### What is a target list