diff --git a/.github/workflows/publish_and_release.yml b/.github/workflows/publish_and_release.yml index f769424..d10ab1d 100644 --- a/.github/workflows/publish_and_release.yml +++ b/.github/workflows/publish_and_release.yml @@ -1,6 +1,6 @@ on: - # push: - # branches: [ main ] + push: + branches: [ main ] workflow_dispatch: diff --git a/README.md b/README.md index 414d651..211948c 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,7 @@ You can process DIA and DDA data analyzed by [AlphaPept](https://github.com/Mann - [About](#about) - [Installation](#installation) - [One-click GUI](#one-click-gui) + - [Pip](#pip) - [Developer](#developer) - [Running directLFQ](#running-directlfq) - [GUI](#gui) @@ -67,16 +68,22 @@ The GUI of directlfq is a completely stand-alone tool that requires no knowledge Older releases remain available on the [release page](https://github.com/MannLabs/directlfq/releases), but no backwards compatibility is guaranteed. - + ### Developer directlfq can also be installed in editable (i.e. developer) mode with a few `bash` commands. This allows to fully customize the software and even modify the source code to your specific needs. When an editable Python package is installed, its source code is stored in a transparent location of your choice. While optional, it is advised to first (create and) navigate to e.g. a general software folder: diff --git a/directlfq/__init__.py b/directlfq/__init__.py index 22b7fef..56e2717 100644 --- a/directlfq/__init__.py +++ b/directlfq/__init__.py @@ -2,7 +2,7 @@ __project__ = "directlfq" -__version__ = "0.2.7" +__version__ = "0.2.8" __license__ = "Apache" __description__ = "An open-source Python package of the AlphaPept ecosystem" __author__ = "Mann Labs" diff --git a/directlfq/_modidx.py b/directlfq/_modidx.py index b27d4bc..f750c93 100644 --- a/directlfq/_modidx.py +++ b/directlfq/_modidx.py @@ -642,9 +642,6 @@ 'directlfq/utils.py'), 'directlfq.utils.parse_channel_from_peptide_column': ( 'utils.html#parse_channel_from_peptide_column', 'directlfq/utils.py'), - 'directlfq.utils.plot_relative_to_median_fcs': ( 'utils.html#plot_relative_to_median_fcs', - 'directlfq/utils.py'), - 'directlfq.utils.plot_withincond_fcs': ('utils.html#plot_withincond_fcs', 'directlfq/utils.py'), 'directlfq.utils.prepare_loaded_tables': ('utils.html#prepare_loaded_tables', 'directlfq/utils.py'), 'directlfq.utils.process_with_dask': ('utils.html#process_with_dask', 'directlfq/utils.py'), 'directlfq.utils.reformat_and_save_input_file': ( 'utils.html#reformat_and_save_input_file', @@ -726,4 +723,8 @@ 'directlfq.visualizations.MultiOrganismMultiMethodBoxPlot._add_expected_fold_changes': ( 'visualizations.html#multiorganismmultimethodboxplot._add_expected_fold_changes', 'directlfq/visualizations.py'), 'directlfq.visualizations.MultiOrganismMultiMethodBoxPlot.plot_boxplot': ( 'visualizations.html#multiorganismmultimethodboxplot.plot_boxplot', - 'directlfq/visualizations.py')}}} + 'directlfq/visualizations.py'), + 'directlfq.visualizations.plot_relative_to_median_fcs': ( 'visualizations.html#plot_relative_to_median_fcs', + 'directlfq/visualizations.py'), + 'directlfq.visualizations.plot_withincond_fcs': ( 'visualizations.html#plot_withincond_fcs', + 'directlfq/visualizations.py')}}} diff --git a/directlfq/utils.py b/directlfq/utils.py index 6b924d1..801c208 100644 --- a/directlfq/utils.py +++ b/directlfq/utils.py @@ -27,7 +27,7 @@ 'get_original_file_from_aq_reformat', 'import_config_dict', 'load_samplemap', 'prepare_loaded_tables', 'LongTableReformater', 'AcquisitionTableHandler', 'AcquisitionTableInfo', 'AcquisitionTableHeaders', 'AcquisitionTableOutputPaths', 'AcquisitionTableReformater', 'AcquisitionTableHeaderFilter', - 'merge_acquisition_df_parameter_df', 'plot_withincond_fcs', 'plot_relative_to_median_fcs'] + 'merge_acquisition_df_parameter_df'] # %% ../nbdev_nbs/04_utils.ipynb 2 import os @@ -1190,44 +1190,3 @@ def merge_acquisition_df_parameter_df(acquisition_df, parameter_df, groupby_merg merged_df = merged_df.groupby('ion').max().reset_index() merged_df = merged_df.dropna(axis=1, how='all') return merged_df - -# %% ../nbdev_nbs/04_utils.ipynb 54 -import matplotlib.pyplot as plt -import itertools - -def plot_withincond_fcs(normed_intensity_df, cut_extremes = True): - """takes a normalized intensity dataframe and plots the fold change distribution between all samples. Column = sample, row = ion""" - - samplecombs = list(itertools.combinations(normed_intensity_df.columns, 2)) - - for spair in samplecombs:#compare all pairs of samples - s1 = spair[0] - s2 = spair[1] - diff_fcs = normed_intensity_df[s1].to_numpy() - normed_intensity_df[s2].to_numpy() #calculate fold changes by subtracting log2 intensities of both samples - - if cut_extremes: - cutoff = max(abs(np.nanquantile(diff_fcs,0.025)), abs(np.nanquantile(diff_fcs, 0.975))) #determine 2.5% - 97.5% interval, i.e. remove extremes - range = (-cutoff, cutoff) - else: - range = None - plt.hist(diff_fcs,80,density=True, histtype='step',range=range) #set the cutoffs to focus the visualization - plt.xlabel("log2 peptide fcs") - - plt.show() - -# %% ../nbdev_nbs/04_utils.ipynb 55 -import matplotlib.pyplot as plt -import itertools - -def plot_relative_to_median_fcs(normed_intensity_df): - - median_intensities = normed_intensity_df.median(axis=1) - median_intensities = median_intensities.to_numpy() - - diff_fcs = [] - for col in normed_intensity_df.columns: - median_fcs = normed_intensity_df[col].to_numpy() - median_intensities - diff_fcs.append(np.nanmedian(median_fcs)) - plt.hist(diff_fcs,80,density=True, histtype='step') - plt.xlabel("log2 peptide fcs") - plt.show() diff --git a/directlfq/visualizations.py b/directlfq/visualizations.py index 0d4bd5c..8d7aa86 100644 --- a/directlfq/visualizations.py +++ b/directlfq/visualizations.py @@ -2,7 +2,8 @@ # %% auto 0 __all__ = ['a4_dims', 'a4_width_no_margin', 'AlphaPeptColorMap', 'CmapRegistrator', 'IonTraceCompararisonPlotter', - 'IonTraceCompararisonPlotterNoDirectLFQTrace', 'IonTraceVisualizer', 'MultiOrganismMultiMethodBoxPlot'] + 'IonTraceCompararisonPlotterNoDirectLFQTrace', 'IonTraceVisualizer', 'MultiOrganismMultiMethodBoxPlot', + 'plot_withincond_fcs', 'plot_relative_to_median_fcs'] # %% ../nbdev_nbs/05_visualizations.ipynb 1 a4_dims = (11.7, 8.27) @@ -180,3 +181,44 @@ def _add_expected_fold_changes(self): self.ax.axhline(fc, color = color) + +# %% ../nbdev_nbs/05_visualizations.ipynb 6 +import matplotlib.pyplot as plt +import itertools + +def plot_withincond_fcs(normed_intensity_df, cut_extremes = True): + """takes a normalized intensity dataframe and plots the fold change distribution between all samples. Column = sample, row = ion""" + + samplecombs = list(itertools.combinations(normed_intensity_df.columns, 2)) + + for spair in samplecombs:#compare all pairs of samples + s1 = spair[0] + s2 = spair[1] + diff_fcs = normed_intensity_df[s1].to_numpy() - normed_intensity_df[s2].to_numpy() #calculate fold changes by subtracting log2 intensities of both samples + + if cut_extremes: + cutoff = max(abs(np.nanquantile(diff_fcs,0.025)), abs(np.nanquantile(diff_fcs, 0.975))) #determine 2.5% - 97.5% interval, i.e. remove extremes + range = (-cutoff, cutoff) + else: + range = None + plt.hist(diff_fcs,80,density=True, histtype='step',range=range) #set the cutoffs to focus the visualization + plt.xlabel("log2 peptide fcs") + + plt.show() + +# %% ../nbdev_nbs/05_visualizations.ipynb 7 +import matplotlib.pyplot as plt +import itertools + +def plot_relative_to_median_fcs(normed_intensity_df): + + median_intensities = normed_intensity_df.median(axis=1) + median_intensities = median_intensities.to_numpy() + + diff_fcs = [] + for col in normed_intensity_df.columns: + median_fcs = normed_intensity_df[col].to_numpy() - median_intensities + diff_fcs.append(np.nanmedian(median_fcs)) + plt.hist(diff_fcs,80,density=True, histtype='step') + plt.xlabel("log2 peptide fcs") + plt.show() diff --git a/misc/bumpversion.cfg b/misc/bumpversion.cfg index cc4077c..8b131d5 100644 --- a/misc/bumpversion.cfg +++ b/misc/bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.2.7 +current_version = 0.2.8 commit = True tag = False parse = (?P\d+)\.(?P\d+)\.(?P\d+)(\-(?P[a-z]+)(?P\d+))? diff --git a/nbdev_nbs/01_lfq_manager.ipynb b/nbdev_nbs/01_lfq_manager.ipynb index 97d3584..b11d0f9 100644 --- a/nbdev_nbs/01_lfq_manager.ipynb +++ b/nbdev_nbs/01_lfq_manager.ipynb @@ -94,15 +94,6 @@ "display_name": "alphatemplate", "language": "python", "name": "python3" - }, - "language_info": { - "name": "python", - "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "6323a234a298f1b06d100e5b842ce6ca7904d43140794ca9cb8f0b055bce87c6" - } } }, "nbformat": 4, diff --git a/nbdev_nbs/02_normalization.ipynb b/nbdev_nbs/02_normalization.ipynb index 0c65a82..295c663 100644 --- a/nbdev_nbs/02_normalization.ipynb +++ b/nbdev_nbs/02_normalization.ipynb @@ -881,12 +881,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "STDev 1.0005315602111322\n" + "STDev 0.9952471799150836\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGeCAYAAAC+dvpwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAjfklEQVR4nO3de3QU9eH+8ScJZLklG4MkS0oSQdGABKRcwgpaKikhUCo/UEERouXAgW6oEC+QHr6CWglSW0UbQVoLeI4pYluwooIxSKg13GI5cpMKxQYLm6iUbEhrgGR+f7Ruu+W6sJv5JHm/zpnT3ZnPzjxzbJvHz8zORliWZQkAAMAgkXYHAAAA+F8UFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOK3sDnA5GhoadPToUcXExCgiIsLuOAAA4BJYlqWamholJSUpMvIicyRWEF544QUrPT3diomJsWJiYqxBgwZZb731ln/7P//5T+sHP/iBFR8fb7Vv394aO3as5fV6A/bx17/+1Ro5cqTVtm1bq1OnTtZDDz1knT59OpgY1pEjRyxJLCwsLCwsLE1wOXLkyEX/1gc1g9KlSxctWrRI3bt3l2VZWrVqlW6//Xb96U9/0o033qjZs2frzTff1GuvvSan06nc3FyNHTtWf/zjHyVJ9fX1GjVqlFwulz744AMdO3ZMkydPVuvWrbVw4cJLzhETEyNJOnLkiGJjY4M5BQAAYBOfz6fk5GT/3/ELibCsK/uxwPj4eP3kJz/RHXfcoU6dOqmoqEh33HGHJOnjjz9Wjx49VFZWpkGDBuntt9/Wd7/7XR09elSJiYmSpGXLlmnOnDn6/PPPFR0dfUnH9Pl8cjqdqq6upqAAANBEBPP3+7Jvkq2vr9fq1atVW1srt9ut8vJynT59WpmZmf4xaWlpSklJUVlZmSSprKxM6enp/nIiSVlZWfL5fNq7d+95j1VXVyefzxewAACA5ivogrJ792516NBBDodD06dP19q1a9WzZ095vV5FR0crLi4uYHxiYqK8Xq8kyev1BpSTr7d/ve18CgoK5HQ6/UtycnKwsQEAQBMSdEG54YYbtGvXLm3btk0zZsxQTk6O9u3bF45sfvn5+aqurvYvR44cCevxAACAvYL+mnF0dLSuu+46SVK/fv20Y8cOLVmyROPHj9epU6d04sSJgFmUyspKuVwuSZLL5dL27dsD9ldZWenfdj4Oh0MOhyPYqAAAoIm64ge1NTQ0qK6uTv369VPr1q1VUlLi33bgwAFVVFTI7XZLktxut3bv3q2qqir/mOLiYsXGxqpnz55XGgUAADQTQc2g5OfnKzs7WykpKaqpqVFRUZE2b96sjRs3yul0asqUKcrLy1N8fLxiY2M1c+ZMud1uDRo0SJI0fPhw9ezZU5MmTdLixYvl9Xo1b948eTweZkgAAIBfUAWlqqpKkydP1rFjx+R0OtW7d29t3LhR3/nOdyRJzzzzjCIjIzVu3DjV1dUpKytLL7zwgv/zUVFRWr9+vWbMmCG326327dsrJydHjz/+eGjPCgAANGlX/BwUO/AcFAAAmp5GeQ4KAABAuFBQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYJ+hH3QNo5hY47U5w6RZU250AQJgwgwIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjUFAAAIBxKCgAAMA4FBQAAGAcCgoAADAOBQUAABiHggIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjBFVQCgoKNGDAAMXExCghIUFjxozRgQMHAsYMHTpUERERAcv06dMDxlRUVGjUqFFq166dEhIS9PDDD+vMmTNXfjYAAKBZaBXM4NLSUnk8Hg0YMEBnzpzRj370Iw0fPlz79u1T+/bt/eOmTp2qxx9/3P++Xbt2/tf19fUaNWqUXC6XPvjgAx07dkyTJ09W69attXDhwhCcEgAAaOqCKigbNmwIeL9y5UolJCSovLxct956q399u3bt5HK5zrmPd955R/v27dO7776rxMRE3XTTTXriiSc0Z84cLViwQNHR0ZdxGgAAoDm5ontQqqurJUnx8fEB61955RVdffXV6tWrl/Lz8/WPf/zDv62srEzp6elKTEz0r8vKypLP59PevXvPeZy6ujr5fL6ABQAANF9BzaD8t4aGBs2aNUuDBw9Wr169/OvvuecepaamKikpSR999JHmzJmjAwcO6He/+50kyev1BpQTSf73Xq/3nMcqKCjQY489drlRAQBAE3PZBcXj8WjPnj16//33A9ZPmzbN/zo9PV2dO3fWsGHDdOjQIV177bWXdaz8/Hzl5eX53/t8PiUnJ19ecAAAYLzLusSTm5ur9evX67333lOXLl0uODYjI0OSdPDgQUmSy+VSZWVlwJiv35/vvhWHw6HY2NiABQAANF9BzaBYlqWZM2dq7dq12rx5s7p27XrRz+zatUuS1LlzZ0mS2+3Wk08+qaqqKiUkJEiSiouLFRsbq549ewYZH0BLds3cN694H58uGhWCJABCLaiC4vF4VFRUpNdff10xMTH+e0acTqfatm2rQ4cOqaioSCNHjlTHjh310Ucfafbs2br11lvVu3dvSdLw4cPVs2dPTZo0SYsXL5bX69W8efPk8XjkcDhCf4YAAKDJCeoSz9KlS1VdXa2hQ4eqc+fO/uXVV1+VJEVHR+vdd9/V8OHDlZaWpgcffFDjxo3TG2+84d9HVFSU1q9fr6ioKLndbt17772aPHlywHNTAABAyxb0JZ4LSU5OVmlp6UX3k5qaqrfeeiuYQwMAgBaE3+IBAADGoaAAAADjUFAAAIBxKCgAAMA4l/0kWQCQpPSuKbYdO0ZzL2lczf5FYU4CINSYQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA5fMwbQ7H3a5p7zb1zQSCEWVDfSgYDmgRkUAABgHAoKAAAwDgUFAAAYh4ICAACMw02yAMJietkSuyP4Ff77Pz2u/2drDgCXjhkUAABgHGZQgGaicPqmEO1pbVCjp3tDdFgA+C/MoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA7f4gHQYqR3TbHv4KvSz7tpd87uRgwCNA3MoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA4/AkWQAtxpqCM+fddlc+/3cImIQZFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADG4ec7AYOlr0q/5LHTtSSMSQCgcTGDAgAAjBNUQSkoKNCAAQMUExOjhIQEjRkzRgcOHAgY89VXX8nj8ahjx47q0KGDxo0bp8rKyoAxFRUVGjVqlNq1a6eEhAQ9/PDDOnPmzJWfDQAAaBaCKiilpaXyeDzaunWriouLdfr0aQ0fPly1tbX+MbNnz9Ybb7yh1157TaWlpTp69KjGjh3r315fX69Ro0bp1KlT+uCDD7Rq1SqtXLlSjz76aOjOCgAANGlB3YOyYcOGgPcrV65UQkKCysvLdeutt6q6ulovvfSSioqKdNttt0mSVqxYoR49emjr1q0aNGiQ3nnnHe3bt0/vvvuuEhMTddNNN+mJJ57QnDlztGDBAkVHR4fu7AAAQJN0RfegVFdXS5Li4+MlSeXl5Tp9+rQyMzP9Y9LS0pSSkqKysjJJUllZmdLT05WYmOgfk5WVJZ/Pp717957zOHV1dfL5fAELAABovi67oDQ0NGjWrFkaPHiwevXqJUnyer2Kjo5WXFxcwNjExER5vV7/mP8uJ19v/3rbuRQUFMjpdPqX5OTky40NAACagMsuKB6PR3v27NHq1atDmeec8vPzVV1d7V+OHDkS9mMCAAD7XNZzUHJzc7V+/Xpt2bJFXbp08a93uVw6deqUTpw4ETCLUllZKZfL5R+zffv2gP19/S2fr8f8L4fDIYfDcTlRAQBAExTUDIplWcrNzdXatWu1adMmde3aNWB7v3791Lp1a5WUlPjXHThwQBUVFXK73ZIkt9ut3bt3q6qqyj+muLhYsbGx6tmz55WcCwAAaCaCmkHxeDwqKirS66+/rpiYGP89I06nU23btpXT6dSUKVOUl5en+Ph4xcbGaubMmXK73Ro0aJAkafjw4erZs6cmTZqkxYsXy+v1at68efJ4PMySAAAASUEWlKVLl0qShg4dGrB+xYoVuu+++yRJzzzzjCIjIzVu3DjV1dUpKytLL7zwgn9sVFSU1q9frxkzZsjtdqt9+/bKycnR448/fmVnAgAAmo2gCoplWRcd06ZNGxUWFqqwsPC8Y1JTU/XWW28Fc2gAANCC8Fs8AADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGuaxH3QNAU7Rp6PkffzC9rBGD/Nsy9wONf1CgiWAGBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMw6PugcawwHl5n+uaEtocANBEMIMCAACMQ0EBAADGoaAAAADjcA8KANjsmrlvnrXu00WjbEgCmIOCAgA2WVNw5t+vHvKvyx7ztD1hAMNwiQcAABiHggIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOK3sDgC0FPtXJwX9mTU6c8ljNw0NevcAYCxmUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwTtAFZcuWLRo9erSSkpIUERGhdevWBWy/7777FBEREbCMGDEiYMzx48c1ceJExcbGKi4uTlOmTNHJkyev6EQAAEDzEXRBqa2tVZ8+fVRYWHjeMSNGjNCxY8f8y69//euA7RMnTtTevXtVXFys9evXa8uWLZo2bVrw6QEAQLPUKtgPZGdnKzs7+4JjHA6HXC7XObft379fGzZs0I4dO9S/f39J0vPPP6+RI0fq6aefVlJS8D9JDwAAmpew3IOyefNmJSQk6IYbbtCMGTP05Zdf+reVlZUpLi7OX04kKTMzU5GRkdq2bds591dXVyefzxewAACA5ivkBWXEiBF6+eWXVVJSoqeeekqlpaXKzs5WfX29JMnr9SohISHgM61atVJ8fLy8Xu8591lQUCCn0+lfkpOTQx0bAAAYJOhLPBczYcIE/+v09HT17t1b1157rTZv3qxhw4Zd1j7z8/OVl5fnf+/z+SgpAAA0Y2H/mnG3bt109dVX6+DBg5Ikl8ulqqqqgDFnzpzR8ePHz3vfisPhUGxsbMACAACar7AXlM8++0xffvmlOnfuLElyu906ceKEysvL/WM2bdqkhoYGZWRkhDsOAABoAoK+xHPy5En/bIgkHT58WLt27VJ8fLzi4+P12GOPady4cXK5XDp06JAeeeQRXXfddcrKypIk9ejRQyNGjNDUqVO1bNkynT59Wrm5uZowYQLf4AEAAJIuYwZl586d6tu3r/r27StJysvLU9++ffXoo48qKipKH330kb73ve/p+uuv15QpU9SvXz/94Q9/kMPh8O/jlVdeUVpamoYNG6aRI0dqyJAhWr58eejOCgAANGlBz6AMHTpUlmWdd/vGjRsvuo/4+HgVFRUFe2gAANBC8Fs8AADAOBQUAABgnJA/BwVoKa6Z++Ylj/20TRiDAEAzxAwKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjUFAAAIBxKCgAAMA4FBQAAGAcHtSGFit9VfoVfT6mRxDHUorW6MwVHQ8AWhJmUAAAgHGYQQEu0/SyJUGN3zQ0PDkAoDliBgUAABiHggIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYByegwIABvm0zT3/erHAxhALqm08OPAvzKAAAADjUFAAAIBxKCgAAMA4FBQAAGAcCgoAADAOBQUAABiHggIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjUFAAAIBxKCgAAMA4FBQAAGCcoAvKli1bNHr0aCUlJSkiIkLr1q0L2G5Zlh599FF17txZbdu2VWZmpj755JOAMcePH9fEiRMVGxuruLg4TZkyRSdPnryiEwEAAM1H0AWltrZWffr0UWFh4Tm3L168WM8995yWLVumbdu2qX379srKytJXX33lHzNx4kTt3btXxcXFWr9+vbZs2aJp06Zd/lkAAIBmpVWwH8jOzlZ2dvY5t1mWpWeffVbz5s3T7bffLkl6+eWXlZiYqHXr1mnChAnav3+/NmzYoB07dqh///6SpOeff14jR47U008/raSkpLP2W1dXp7q6Ov97n88XbGwAANCEhPQelMOHD8vr9SozM9O/zul0KiMjQ2VlZZKksrIyxcXF+cuJJGVmZioyMlLbtm07534LCgrkdDr9S3JycihjAwAAw4S0oHi9XklSYmJiwPrExET/Nq/Xq4SEhIDtrVq1Unx8vH/M/8rPz1d1dbV/OXLkSChjAwAAwwR9iccODodDDofD7hgAAKCRhHQGxeVySZIqKysD1ldWVvq3uVwuVVVVBWw/c+aMjh8/7h8DAABatpAWlK5du8rlcqmkpMS/zufzadu2bXK73ZIkt9utEydOqLy83D9m06ZNamhoUEZGRijjAACAJiroSzwnT57UwYMH/e8PHz6sXbt2KT4+XikpKZo1a5Z+/OMfq3v37uratav+7//+T0lJSRozZowkqUePHhoxYoSmTp2qZcuW6fTp08rNzdWECRPO+Q0eAADQ8gRdUHbu3Klvf/vb/vd5eXmSpJycHK1cuVKPPPKIamtrNW3aNJ04cUJDhgzRhg0b1KZNG/9nXnnlFeXm5mrYsGGKjIzUuHHj9Nxzz4XgdAAAQHMQYVmWZXeIYPl8PjmdTlVXVys2NtbuOGii0lelX9Hnp5ctCVEStFS3bfacta7HhKM2JAl0zVdFF9z+6aJRjZQEzU0wf7/5LR4AAGCcJvE1YwBoKdK7ptgdQTGae9a6mv2LbEiCloyCAgA22TT07N80m15mQ5B/W+Z+wL6DA/+DSzwAAMA4FBQAAGAcCgoAADAOBQUAABiHggIAAIxDQQEAAMahoAAAAONQUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA6/xYOmaYHzyvdhwI+yAQDOjRkUAABgHGZQ0OztX510zvVrdOaK9rtp6BV9HABwAcygAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMw3NQAACSpDUFgc8GuiufPxGwDzMoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjUFAAAIBxKCgAAMA4FBQAAGAcnmMM410z982z1n3axoYgAIBGQ0FBk/Hwibb+14Vae+kfHBr6LACA8OISDwAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGCXlBWbBggSIiIgKWtLQ0//avvvpKHo9HHTt2VIcOHTRu3DhVVlaGOgYAAGjCwjKDcuONN+rYsWP+5f333/dvmz17tt544w299tprKi0t1dGjRzV27NhwxAAAAE1Uq7DstFUruVyus9ZXV1frpZdeUlFRkW677TZJ0ooVK9SjRw9t3bpVgwYNCkccAADQxIRlBuWTTz5RUlKSunXrpokTJ6qiokKSVF5ertOnTyszM9M/Ni0tTSkpKSorKzvv/urq6uTz+QIWAADQfIW8oGRkZGjlypXasGGDli5dqsOHD+uWW25RTU2NvF6voqOjFRcXF/CZxMREeb3e8+6zoKBATqfTvyQnJ4c6NgAAMEjIL/FkZ2f7X/fu3VsZGRlKTU3VmjVr1LZt28vaZ35+vvLy8vzvfT4fJQUAgGYs7F8zjouL0/XXX6+DBw/K5XLp1KlTOnHiRMCYysrKc96z8jWHw6HY2NiABQAANF9hLygnT57UoUOH1LlzZ/Xr10+tW7dWSUmJf/uBAwdUUVEht9sd7igAAKCJCPklnoceekijR49Wamqqjh49qvnz5ysqKkp33323nE6npkyZory8PMXHxys2NlYzZ86U2+3mGzwAAMAv5AXls88+0913360vv/xSnTp10pAhQ7R161Z16tRJkvTMM88oMjJS48aNU11dnbKysvTCCy+EOgYAAGjCQl5QVq9efcHtbdq0UWFhoQoLC0N9aAAA0EzwWzwAAMA4YXmSLACgefm0zT3/ebPAthhnW1BtdwKECTMoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMw7d4EBbpq9JDtq+YHv9+UbYkZPsEAJiNGRQAAGAcCgoAADAOl3gAAJKkTUMDf4Jketl/Xtvx4yTL3A9cfNB/XU7enbM7jGnQ2JhBAQAAxmEGBWGxpuBMyPe5aWjIdwkAMBQzKAAAwDgUFAAAYBwKCgDASGsKzoTlcjGaBgoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADj8KA2/McCZwh3lhTCfQEAWhpmUAAAgHEoKAAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwDgUFAAAYh4ICAACMQ0EBAADGoaAAAADjtLI7AAAAF7Km4Mwljdtf0CPMSaS78q/sz+bunN0hStL8MYMCAACMwwwKzqnQu/bKdjA0JDEAtGCbhhbaHeEcHrA7QIvBDAoAADAOBQUAABiHSzxNUPqq9PDsuGuK/+V0b3gOAQDApWAGBQAAGIcZlGbmUr+OdzGbhoZkNwAAXBZmUAAAgHGYQQm3Bc7Q7/O/7hUBAKA5oqCcQ0hvQqVMAAAQNC7xAAAA49haUAoLC3XNNdeoTZs2ysjI0Pbt2+2MAwAADGFbQXn11VeVl5en+fPn68MPP1SfPn2UlZWlqqoquyIBAABD2HYPys9+9jNNnTpV999/vyRp2bJlevPNN/WrX/1Kc+fOtSuWbaaXLQnJfvh6MACgObCloJw6dUrl5eXKz8/3r4uMjFRmZqbKysrOGl9XV6e6ujr/++rqakmSz+cLS776f9aHZb8X8s9TtY1+TABAcK7074MvPzZESRpB/mch3+XXf7cty7roWFsKyhdffKH6+nolJiYGrE9MTNTHH3981viCggI99thjZ61PTk4OW8bG9rC+Z3cEAMDFrLiyj4fhwRPhsyh8aWtqauR0Xnj/TeJrxvn5+crLy/O/b2ho0PHjx9WxY0dFRETYmOxffD6fkpOTdeTIEcXGNqF2fAU4Z865ueKcOefmzO7ztixLNTU1SkpKuuhYWwrK1VdfraioKFVWVgasr6yslMvlOmu8w+GQw+EIWBcXFxfOiJclNja2Rf0XXeKcWwrOuWXgnFsOO8/7YjMnX7PlWzzR0dHq16+fSkpK/OsaGhpUUlIit9ttRyQAAGAQ2y7x5OXlKScnR/3799fAgQP17LPPqra21v+tHgAA0HLZVlDGjx+vzz//XI8++qi8Xq9uuukmbdiw4awbZ5sCh8Oh+fPnn3UZqjnjnFsGzrll4JxbjqZ03hHWpXzXBwAAoBHxWzwAAMA4FBQAAGAcCgoAADAOBQUAABiHggIAAIxDQQmxJ598UjfffLPatWtn5NNuQ6GwsFDXXHON2rRpo4yMDG3fvt3uSGG1ZcsWjR49WklJSYqIiNC6devsjhR2BQUFGjBggGJiYpSQkKAxY8bowIEDdscKq6VLl6p3797+J2y63W69/fbbdsdqVIsWLVJERIRmzZpld5SwWbBggSIiIgKWtLQ0u2OF3d/+9jfde++96tixo9q2bav09HTt3LnT7lgXREEJsVOnTunOO+/UjBkz7I4SFq+++qry8vI0f/58ffjhh+rTp4+ysrJUVVVld7Swqa2tVZ8+fVRYWGh3lEZTWloqj8ejrVu3qri4WKdPn9bw4cNVW9t8f3W7S5cuWrRokcrLy7Vz507ddtttuv3227V37167ozWKHTt26MUXX1Tv3r3tjhJ2N954o44dO+Zf3n//fbsjhdXf//53DR48WK1bt9bbb7+tffv26ac//amuuuoqu6NdmIWwWLFiheV0Ou2OEXIDBw60PB6P/319fb2VlJRkFRQU2Jiq8Uiy1q5da3eMRldVVWVJskpLS+2O0qiuuuoq65e//KXdMcKupqbG6t69u1VcXGx961vfsh544AG7I4XN/PnzrT59+tgdo1HNmTPHGjJkiN0xgsYMCi7ZqVOnVF5erszMTP+6yMhIZWZmqqyszMZkCLfq6mpJUnx8vM1JGkd9fb1Wr16t2traFvH7YB6PR6NGjQr433Zz9sknnygpKUndunXTxIkTVVFRYXeksPr973+v/v37684771RCQoL69u2rX/ziF3bHuigKCi7ZF198ofr6+rN+jiAxMVFer9emVAi3hoYGzZo1S4MHD1avXr3sjhNWu3fvVocOHeRwODR9+nStXbtWPXv2tDtWWK1evVoffvihCgoK7I7SKDIyMrRy5Upt2LBBS5cu1eHDh3XLLbeopqbG7mhh85e//EVLly5V9+7dtXHjRs2YMUM//OEPtWrVKrujXZBtv8XTlMydO1dPPfXUBcfs37+/RdxohZbH4/Foz549zf46vSTdcMMN2rVrl6qrq/Wb3/xGOTk5Ki0tbbYl5ciRI3rggQdUXFysNm3a2B2nUWRnZ/tf9+7dWxkZGUpNTdWaNWs0ZcoUG5OFT0NDg/r376+FCxdKkvr27as9e/Zo2bJlysnJsTnd+VFQLsGDDz6o++6774JjunXr1jhhbHT11VcrKipKlZWVAesrKyvlcrlsSoVwys3N1fr167VlyxZ16dLF7jhhFx0dreuuu06S1K9fP+3YsUNLlizRiy++aHOy8CgvL1dVVZW++c1v+tfV19dry5Yt+vnPf666ujpFRUXZmDD84uLidP311+vgwYN2Rwmbzp07n1Wye/Tood/+9rc2Jbo0FJRL0KlTJ3Xq1MnuGLaLjo5Wv379VFJSojFjxkj6VzMvKSlRbm6uveEQUpZlaebMmVq7dq02b96srl272h3JFg0NDaqrq7M7RtgMGzZMu3fvDlh3//33Ky0tTXPmzGn25USSTp48qUOHDmnSpEl2RwmbwYMHn/WYgD//+c9KTU21KdGloaCEWEVFhY4fP66KigrV19dr165dkqTrrrtOHTp0sDdcCOTl5SknJ0f9+/fXwIED9eyzz6q2tlb333+/3dHC5uTJkwH/dnX48GHt2rVL8fHxSklJsTFZ+Hg8HhUVFen1119XTEyM/x4jp9Optm3b2pwuPPLz85Wdna2UlBTV1NSoqKhImzdv1saNG+2OFjYxMTFn3VfUvn17dezYsdneb/TQQw9p9OjRSk1N1dGjRzV//nxFRUXp7rvvtjta2MyePVs333yzFi5cqLvuukvbt2/X8uXLtXz5crujXZjdXyNqbnJycixJZy3vvfee3dFC5vnnn7dSUlKs6Ohoa+DAgdbWrVvtjhRW77333jn/mebk5NgdLWzOdb6SrBUrVtgdLWy+//3vW6mpqVZ0dLTVqVMna9iwYdY777xjd6xG19y/Zjx+/Hirc+fOVnR0tPWNb3zDGj9+vHXw4EG7Y4XdG2+8YfXq1ctyOBxWWlqatXz5crsjXVSEZVlW49ciAACA8+NrxgAAwDgUFAAAYBwKCgAAMA4FBQAAGIeCAgAAjENBAQAAxqGgAAAA41BQAACAcSgoAADAOBQUAABgHAoKAAAwzv8HfrOxZHkaqjMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -910,15 +910,16 @@ "outputs": [], "source": [ "#| include: false\n", + "import directlfq.visualizations as lfq_viz\n", "import directlfq.utils as lfq_utils\n", "def test_normalizing_between_samples(num_samples_quadratic):\n", " input_file = \"../test_data/unit_tests/protein_normalization/peptides.txt.maxquant_peptides_benchmarking.aq_reformat.tsv\"\n", " input_df = pd.read_csv(input_file, sep = '\\t')\n", " input_df = lfq_utils.index_and_log_transform_input_df(input_df)\n", " input_df = input_df[[x for x in input_df.columns if \"Shotgun\" in x]]\n", - " lfq_utils.plot_withincond_fcs(input_df)\n", + " lfq_viz.plot_withincond_fcs(input_df)\n", " input_df_normalized = NormalizationManagerSamples(input_df, num_samples_quadratic=num_samples_quadratic).complete_dataframe\n", - " lfq_utils.plot_withincond_fcs(input_df_normalized)\n", + " lfq_viz.plot_withincond_fcs(input_df_normalized)\n", " assert_that_results_scatter_around_zero(input_df_normalized)\n", "\n", "\n", @@ -1090,7 +1091,7 @@ ], "metadata": { "kernelspec": { - "display_name": "alphatemplate", + "display_name": "directlfq", "language": "python", "name": "python3" } diff --git a/nbdev_nbs/04_utils.ipynb b/nbdev_nbs/04_utils.ipynb index 04398aa..884f3df 100644 --- a/nbdev_nbs/04_utils.ipynb +++ b/nbdev_nbs/04_utils.ipynb @@ -1576,69 +1576,6 @@ " return merged_df" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting Functions\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import itertools\n", - "\n", - "def plot_withincond_fcs(normed_intensity_df, cut_extremes = True):\n", - " \"\"\"takes a normalized intensity dataframe and plots the fold change distribution between all samples. Column = sample, row = ion\"\"\"\n", - "\n", - " samplecombs = list(itertools.combinations(normed_intensity_df.columns, 2))\n", - "\n", - " for spair in samplecombs:#compare all pairs of samples\n", - " s1 = spair[0]\n", - " s2 = spair[1]\n", - " diff_fcs = normed_intensity_df[s1].to_numpy() - normed_intensity_df[s2].to_numpy() #calculate fold changes by subtracting log2 intensities of both samples\n", - "\n", - " if cut_extremes:\n", - " cutoff = max(abs(np.nanquantile(diff_fcs,0.025)), abs(np.nanquantile(diff_fcs, 0.975))) #determine 2.5% - 97.5% interval, i.e. remove extremes\n", - " range = (-cutoff, cutoff)\n", - " else:\n", - " range = None\n", - " plt.hist(diff_fcs,80,density=True, histtype='step',range=range) #set the cutoffs to focus the visualization\n", - " plt.xlabel(\"log2 peptide fcs\")\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import matplotlib.pyplot as plt\n", - "import itertools\n", - "\n", - "def plot_relative_to_median_fcs(normed_intensity_df):\n", - "\n", - " median_intensities = normed_intensity_df.median(axis=1)\n", - " median_intensities = median_intensities.to_numpy()\n", - " \n", - " diff_fcs = []\n", - " for col in normed_intensity_df.columns:\n", - " median_fcs = normed_intensity_df[col].to_numpy() - median_intensities\n", - " diff_fcs.append(np.nanmedian(median_fcs))\n", - " plt.hist(diff_fcs,80,density=True, histtype='step')\n", - " plt.xlabel(\"log2 peptide fcs\")\n", - " plt.show()" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/nbdev_nbs/05_visualizations.ipynb b/nbdev_nbs/05_visualizations.ipynb index 167d6fb..b56ebec 100644 --- a/nbdev_nbs/05_visualizations.ipynb +++ b/nbdev_nbs/05_visualizations.ipynb @@ -221,6 +221,62 @@ " " ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import itertools\n", + "\n", + "def plot_withincond_fcs(normed_intensity_df, cut_extremes = True):\n", + " \"\"\"takes a normalized intensity dataframe and plots the fold change distribution between all samples. Column = sample, row = ion\"\"\"\n", + "\n", + " samplecombs = list(itertools.combinations(normed_intensity_df.columns, 2))\n", + "\n", + " for spair in samplecombs:#compare all pairs of samples\n", + " s1 = spair[0]\n", + " s2 = spair[1]\n", + " diff_fcs = normed_intensity_df[s1].to_numpy() - normed_intensity_df[s2].to_numpy() #calculate fold changes by subtracting log2 intensities of both samples\n", + "\n", + " if cut_extremes:\n", + " cutoff = max(abs(np.nanquantile(diff_fcs,0.025)), abs(np.nanquantile(diff_fcs, 0.975))) #determine 2.5% - 97.5% interval, i.e. remove extremes\n", + " range = (-cutoff, cutoff)\n", + " else:\n", + " range = None\n", + " plt.hist(diff_fcs,80,density=True, histtype='step',range=range) #set the cutoffs to focus the visualization\n", + " plt.xlabel(\"log2 peptide fcs\")\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "import matplotlib.pyplot as plt\n", + "import itertools\n", + "\n", + "def plot_relative_to_median_fcs(normed_intensity_df):\n", + "\n", + " median_intensities = normed_intensity_df.median(axis=1)\n", + " median_intensities = median_intensities.to_numpy()\n", + " \n", + " diff_fcs = []\n", + " for col in normed_intensity_df.columns:\n", + " median_fcs = normed_intensity_df[col].to_numpy() - median_intensities\n", + " diff_fcs.append(np.nanmedian(median_fcs))\n", + " plt.hist(diff_fcs,80,density=True, histtype='step')\n", + " plt.xlabel(\"log2 peptide fcs\")\n", + " plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/release/one_click_linux_gui/control b/release/one_click_linux_gui/control index 2b08f75..579b5d8 100644 --- a/release/one_click_linux_gui/control +++ b/release/one_click_linux_gui/control @@ -1,5 +1,5 @@ Package: directlfq -Version: 0.2.7 +Version: 0.2.8 Architecture: all Maintainer: Mann Labs Description: directlfq diff --git a/release/one_click_linux_gui/create_installer_linux.sh b/release/one_click_linux_gui/create_installer_linux.sh index 0b7acf1..94ecbdf 100644 --- a/release/one_click_linux_gui/create_installer_linux.sh +++ b/release/one_click_linux_gui/create_installer_linux.sh @@ -17,7 +17,7 @@ python setup.py sdist bdist_wheel # Setting up the local package cd release/one_click_linux_gui # Make sure you include the required extra packages and always use the stable or very-stable options! -pip install "../../dist/directlfq-0.2.7-py3-none-any.whl[stable, gui]" +pip install "../../dist/directlfq-0.2.8-py3-none-any.whl[stable, gui]" # Creating the stand-alone pyinstaller folder pip install pyinstaller==4.10 diff --git a/release/one_click_macos_gui/Info.plist b/release/one_click_macos_gui/Info.plist index bdcf94a..1a820a6 100644 --- a/release/one_click_macos_gui/Info.plist +++ b/release/one_click_macos_gui/Info.plist @@ -9,9 +9,9 @@ CFBundleIconFile alpha_logo.icns CFBundleIdentifier - directlfq.0.2.7 + directlfq.0.2.8 CFBundleShortVersionString - 0.2.7 + 0.2.8 CFBundleInfoDictionaryVersion 6.0 CFBundleName diff --git a/release/one_click_macos_gui/create_installer_macos.sh b/release/one_click_macos_gui/create_installer_macos.sh index 91aabb2..91306da 100755 --- a/release/one_click_macos_gui/create_installer_macos.sh +++ b/release/one_click_macos_gui/create_installer_macos.sh @@ -20,7 +20,7 @@ python setup.py sdist bdist_wheel # Setting up the local package cd release/one_click_macos_gui -pip install "../../dist/directlfq-0.2.7-py3-none-any.whl[stable, gui]" +pip install "../../dist/directlfq-0.2.8-py3-none-any.whl[stable, gui]" # Creating the stand-alone pyinstaller folder pip install pyinstaller==4.10 @@ -40,5 +40,5 @@ cp ../../LICENSE Resources/LICENSE cp ../logos/alpha_logo.png Resources/alpha_logo.png chmod 777 scripts/* -pkgbuild --root dist/directlfq --identifier de.mpg.biochem.directlfq.app --version 0.2.7 --install-location /Applications/directlfq.app --scripts scripts directlfq.pkg +pkgbuild --root dist/directlfq --identifier de.mpg.biochem.directlfq.app --version 0.2.8 --install-location /Applications/directlfq.app --scripts scripts directlfq.pkg productbuild --distribution distribution.xml --resources Resources --package-path directlfq.pkg dist/directlfq_gui_installer_macos.pkg diff --git a/release/one_click_macos_gui/distribution.xml b/release/one_click_macos_gui/distribution.xml index 16e9b23..1e97efc 100644 --- a/release/one_click_macos_gui/distribution.xml +++ b/release/one_click_macos_gui/distribution.xml @@ -1,6 +1,6 @@ - directlfq 0.2.7 + directlfq 0.2.8 diff --git a/release/one_click_windows_gui/create_installer_windows.sh b/release/one_click_windows_gui/create_installer_windows.sh index dcd1032..e065b28 100644 --- a/release/one_click_windows_gui/create_installer_windows.sh +++ b/release/one_click_windows_gui/create_installer_windows.sh @@ -17,7 +17,7 @@ python setup.py sdist bdist_wheel # Setting up the local package cd release/one_click_windows_gui # Make sure you include the required extra packages and always use the stable or very-stable options! -pip install "../../dist/directlfq-0.2.7-py3-none-any.whl[stable, gui]" +pip install "../../dist/directlfq-0.2.8-py3-none-any.whl[stable, gui]" # Creating the stand-alone pyinstaller folder pip install pyinstaller==4.10 diff --git a/release/one_click_windows_gui/directlfq_innoinstaller.iss b/release/one_click_windows_gui/directlfq_innoinstaller.iss index 9a41479..f550d41 100644 --- a/release/one_click_windows_gui/directlfq_innoinstaller.iss +++ b/release/one_click_windows_gui/directlfq_innoinstaller.iss @@ -2,7 +2,7 @@ ; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES! #define MyAppName "directlfq" -#define MyAppVersion "0.2.7" +#define MyAppVersion "0.2.8" #define MyAppPublisher "Max Planck Institute of Biochemistry and the University of Copenhagen, Mann Labs" #define MyAppURL "https://github.com/MannLabs/directlfq" #define MyAppExeName "directlfq_gui.exe" diff --git a/settings.ini b/settings.ini index 85ae08a..3f08897 100644 --- a/settings.ini +++ b/settings.ini @@ -13,7 +13,7 @@ author = Constantin Ammar author_email = constantin.ammar@gmail.com copyright = fast.ai branch = master -version = 0.2.7 +version = 0.2.8 min_python = 3.6 audience = Developers language = English diff --git a/tests/normalization_tests/test_normalization_on_large_datatsets.ipynb b/tests/normalization_tests/test_normalization_on_large_datatsets.ipynb index 5c2e288..1694d03 100644 --- a/tests/normalization_tests/test_normalization_on_large_datatsets.ipynb +++ b/tests/normalization_tests/test_normalization_on_large_datatsets.ipynb @@ -531,18 +531,18 @@ ], "source": [ "import directlfq.normalization\n", - "import directlfq.utils as lfq_utils\n", + "import directlfq.visualizations as lfq_viz\n", "import random\n", "\n", "def visualize_normalization_steps(df_to_normalize):\n", - " lfq_utils.plot_relative_to_median_fcs(df_to_normalize)\n", + " lfq_viz.plot_relative_to_median_fcs(df_to_normalize)\n", " input_df_normalized = directlfq.normalization.NormalizationManagerSamples(df_to_normalize.copy(), num_samples_quadratic=5).complete_dataframe\n", - " lfq_utils.plot_relative_to_median_fcs(input_df_normalized)\n", + " lfq_viz.plot_relative_to_median_fcs(input_df_normalized)\n", "\n", " #randomly select 100 items from a list\n", " selected_protein_groups = random.sample(list(df_to_normalize.index), 100)\n", " input_df_normalized_selected_proteins = NormalizationManagerSamplesOnSelectedProteinsDirectInput(df_to_normalize.copy(), num_samples_quadratic=50, selected_protein_groups=selected_protein_groups).complete_dataframe\n", - " lfq_utils.plot_relative_to_median_fcs(input_df_normalized_selected_proteins)\n", + " lfq_viz.plot_relative_to_median_fcs(input_df_normalized_selected_proteins)\n", " display(input_df_normalized_selected_proteins)\n", "\n", "\n",