Repository: MannLabs/alphapept (language: python)

Issue:
Revert "Develop to Master"
Reverts MannLabs/alphapept#199


Discussion / hints:

Fix patch:
diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index 89193e82..a1169c40 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,16 +1,16 @@
 [bumpversion]
-current_version = 0.3.19-dev0
+current_version = 0.3.20-dev0
 commit = True
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\-(?P<release>[a-z]+)(?P<build>\d+))?
-serialize = 
+serialize =
 	{major}.{minor}.{patch}-{release}{build}
 	{major}.{minor}.{patch}
 
 [bumpversion:part:release]
 optional_value = prod
 first_value = dev
-values = 
+values =
 	dev
 	prod
 
@@ -18,6 +18,8 @@ values =
 
 [bumpversion:file:./installer/one_click_windows/alphapept_innoinstaller.iss]
 
+[bumpversion:file:./installer/one_click_windows/create_installer_windows.bat]
+
 [bumpversion:file:settings.ini]
 
 [bumpversion:file:./alphapept/__version__.py]
diff --git a/.github/workflows/win_installer.yml b/.github/workflows/win_installer.yml
deleted file mode 100644
index 1e33f1c6..00000000
--- a/.github/workflows/win_installer.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-# GitHub Actions to automatically create an installer
-name: Windows Installer
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  Create_Installer_Windows:
-    runs-on: self-hosted
-    steps:
-    - name: Creating installer for Windows
-      run: |
-        conda deactivate
-        cd installer\one_click_windows
-        .\create_installer_windows.bat
-    - name: Test compiled version - cmd
-      run: |
-        C:\actions-runner\_work\alphapept\alphapept\installer\one_click_windows\dist\alphapept\alphapept.exe
diff --git a/Parameter Test.ipynb b/Parameter Test.ipynb
deleted file mode 100644
index 2d9f5fe8..00000000
--- a/Parameter Test.ipynb
+++ /dev/null
@@ -1,351 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Parameter Test\n",
-    "\n",
-    "Calls AlphaPept for a parameter range and checks performance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from time import time\n",
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "import logging"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Parameter Test"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "File not recognized: 20190402_QX1_SeVW_MA_HeLa_500ng_LC11.npz\n",
-      "Found thermo file: 20190402_QX1_SeVW_MA_HeLa_500ng_LC11.raw\n",
-      "File not recognized: 20190402_QX1_SeVW_MA_HeLa_500ng_LC11_ap.csv\n",
-      "File not recognized: 20190402_QX1_SeVW_MA_HeLa_500ng_LC11_ap.yaml\n",
-      "Found bruker file: 20191209_TIMS05_QC_ADB_AfterSRIGUpgrade_200ng_03_A1_1_1428.d\n",
-      "File not recognized: 20191209_TIMS05_QC_ADB_AfterSRIGUpgrade_200ng_03_A1_1_1428.npz\n",
-      "File not recognized: 20191209_TIMS05_QC_ADB_AfterSRIGUpgrade_200ng_03_A1_1_1428_ap.csv\n",
-      "File not recognized: 20191209_TIMS05_QC_ADB_AfterSRIGUpgrade_200ng_03_A1_1_1428_ap.yaml\n",
-      "Found fasta file: F:\\projects\\alphapept\\integration_test\\uniprot_Human_reviewed_March_2019_manual.fasta\n",
-      "File not recognized: uniprot_Human_reviewed_March_2019_manual.npz\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "\n",
-    "test_dir = './integration_test/'\n",
-    "\n",
-    "files = os.listdir('./integration_test/')\n",
-    "\n",
-    "raw_files = None\n",
-    "fasta_file = None\n",
-    "\n",
-    "for file in files:\n",
-    "    base, ext = os.path.splitext(file)\n",
-    "    \n",
-    "    if ext == '.fasta':\n",
-    "        fasta_file = os.path.abspath(os.path.join(test_dir, file))\n",
-    "        print('Found fasta file: {}'.format(fasta_file))\n",
-    "    elif ext == '.raw':\n",
-    "        if not raw_files:\n",
-    "            raw_files = []\n",
-    "            raw_files.append(os.path.abspath(os.path.join(test_dir, file)))\n",
-    "        else:\n",
-    "            raw_files.append(os.path.abspath(os.path.join(test_dir, file)))\n",
-    "        print('Found thermo file: {}'.format(file))\n",
-    "    elif ext == '.d':\n",
-    "        if not raw_files:\n",
-    "            raw_files = []\n",
-    "            raw_files.append(os.path.abspath(os.path.join(test_dir, file)))\n",
-    "        else:\n",
-    "            raw_files.append(os.path.abspath(os.path.join(test_dir, file)))\n",
-    "        print('Found bruker file: {}'.format(file))\n",
-    "    else:\n",
-    "        print('File not recognized: {}'.format(file))\n",
-    "        \n",
-    "        \n",
-    "#Todo: Later combine files that might belong together (i.e. in folder, or of same type)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from alphapept.settings import load_settings\n",
-    "\n",
-    "settings_template = load_settings('settings_template.yaml')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "param_group = 'search'\n",
-    "param_key = 'm_tol'\n",
-    "\n",
-    "minval = settings_template[param_group][param_key]['min']\n",
-    "maxval = settings_template[param_group][param_key]['max']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from alphapept.settings import load_settings\n",
-    "\n",
-    "default_settings = load_settings('default_settings.yaml')\n",
-    "\n",
-    "# Deactivate maxlfq and match between runs in the default case as they are not implemented\n",
-    "# Also deactivete library creation\n",
-    "# Otherwise: Activate all functions and deactivate to test\n",
-    "\n",
-    "default_settings['quantification']['max_lfq'] = False\n",
-    "default_settings['misc']['match_between_runs'] = False\n",
-    "default_settings['general']['create_library'] = False\n",
-    "default_settings['general']['find_features'] = False\n",
-    "default_settings['raw']['convert_raw'] = False\n",
-    "\n",
-    "#Fill with paths from above \n",
-    "default_settings['fasta']['fasta_path'] = 'F:/projects/alphapept/integration_test/uniprot_Human_reviewed_March_2019_manual.fasta'\n",
-    "default_settings['fasta']['contaminants_path'] = 'F:/projects/alphapept/contaminants.fasta'\n",
-    "default_settings['fasta']['library_path'] =  'F:/projects/alphapept/integration_test/uniprot_Human_reviewed_March_2019_manual.npz'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import copy \n",
-    "from tqdm.notebook import tqdm as tqdm\n",
-    "import numpy as np\n",
-    "\n",
-    "n_checks = 30\n",
-    "\n",
-    "test_cases = []\n",
-    "\n",
-    "for point in np.linspace(10, maxval, n_checks): #todo: Change minval to get 0 psms\n",
-    "    for file in raw_files:        \n",
-    "        test_case = copy.deepcopy(default_settings)\n",
-    "\n",
-    "        test_case['raw']['raw_path'] = file\n",
-    "        base, ext = os.path.splitext(file)\n",
-    "        test_case['raw']['raw_path_npz'] = base + '.npz'\n",
-    "        test_case[param_group][param_key] = point\n",
-    "\n",
-    "        test_cases.append(test_case)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from time import time\n",
-    "import numpy as np\n",
-    "from alphapept.runner import alpha_runner\n",
-    "\n",
-    "def run_test(settings):\n",
-    "    \"\"\"\n",
-    "    Run a test with certain settings\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def dummy_status(var):\n",
-    "        pass\n",
-    "\n",
-    "    start = time()\n",
-    "    \n",
-    "    try:\n",
-    "        df, features = alpha_runner(settings, CURRENT_TASK = dummy_status)\n",
-    "        error = False\n",
-    "    except Exception as e:\n",
-    "        print('Experienced the following exception:')\n",
-    "        print('-'*100)\n",
-    "        print(e)\n",
-    "        print('-'*100)\n",
-    "        df = None\n",
-    "        error = True\n",
-    "\n",
-    "    end = time()\n",
-    "            \n",
-    "            \n",
-    "    if df is not None:\n",
-    "        n_proteins = len(set(df['protein']))\n",
-    "        n_sequences = len(set(df['sequence']))\n",
-    "        n_sequence_charges = len(set(df['sequence'] + df['charge'].astype('int').astype('str')))\n",
-    "    else:\n",
-    "        n_proteins = np.nan\n",
-    "        n_sequences = np.nan\n",
-    "        n_sequence_charges = np.nan      \n",
-    "    \n",
-    "    time_minutes = (end-start)/60\n",
-    "    \n",
-    "    return (n_proteins, n_sequences, n_sequence_charges, time_minutes, error)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "874ca339f7634e059c08a4c4c1ea6707",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HBox(children=(FloatProgress(value=0.0, max=60.0), HTML(value='')))"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Integration test complete. Time elapsed 3.11 hours\n",
-      "Complete\n"
-     ]
-    }
-   ],
-   "source": [
-    "if False:\n",
-    "    import pandas as pd\n",
-    "    from tqdm.notebook import tqdm as tqdm\n",
-    "\n",
-    "    report = []\n",
-    "    start = time()\n",
-    "    for test_case in tqdm(test_cases):\n",
-    "        filepath = test_case[\"raw\"][\"raw_path_npz\"]\n",
-    "        filename = os.path.split(filepath)[-1]\n",
-    "        report.append(tuple([filename, test_case[param_group][param_key]]) + run_test(test_case))\n",
-    "\n",
-    "    end = time()\n",
-    "\n",
-    "    import pandas as pd\n",
-    "\n",
-    "    print('Integration test complete. Time elapsed {:.2f} hours'.format((end-start)/60/60))\n",
-    "\n",
-    "    columns = ['filename', 'value', 'n_proteins', 'n_sequences', 'n_sequence_charges', 'time_minutes', 'error']\n",
-    "\n",
-    "    rep = pd.DataFrame(report, columns = columns)\n",
-    "\n",
-    "    print('Complete')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.figure()\n",
-    "sns.scatterplot(y='n_proteins', x = 'value', hue = 'filename', data = rep)\n",
-    "plt.title(param_group + '/' + param_key)\n",
-    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
-    "plt.show()\n",
-    "\n",
-    "plt.figure()\n",
-    "sns.scatterplot(y='n_sequences', x = 'value', hue = 'filename', data = rep)\n",
-    "plt.title(param_group + '/' + param_key)\n",
-    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
-    "plt.show()\n",
-    "\n",
-    "plt.figure()\n",
-    "sns.scatterplot(y='n_sequence_charges', x = 'value', hue = 'filename', data = rep)\n",
-    "plt.title(param_group + '/' + param_key)\n",
-    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/Test_Run.ipynb b/Test_Run.ipynb
deleted file mode 100644
index 866b9f91..00000000
--- a/Test_Run.ipynb
+++ /dev/null
@@ -1,747 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# AlphaPept Test Runs and Visualization Examples\n",
-    "\n",
-    "This notebooks is intended to show how a HeLa File can be processed."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Download Test Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "try:\n",
-    "    import wget\n",
-    "except ModuleNotFoundError:\n",
-    "    !pip install wget\n",
-    "    \n",
-    "FILE_DICT = {}\n",
-    "FILE_DICT['thermo_IRT.raw'] = 'https://datashare.biochem.mpg.de/s/GpXsATZtMwgQoQt/download'\n",
-    "FILE_DICT['IRT_fasta.fasta'] = 'https://datashare.biochem.mpg.de/s/p8Qu3KolzbSiCHH/download'\n",
-    "\n",
-    "tmp_folder = os.path.join(os.getcwd(),'/temp')\n",
-    "\n",
-    "if not os.path.isdir(tmp_folder):\n",
-    "    os.mkdir(tmp_folder)\n",
-    "    \n",
-    "for file in FILE_DICT:\n",
-    "    target = os.path.join(tmp_folder, file)\n",
-    "    if not os.path.isfile(target):\n",
-    "        wget.download(FILE_DICT[file], target)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Test Run"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:40 INFO - Currently 122.26 GB of memory available.\n",
-      "2021-01-09 23:32:40 INFO - System information: uname_result(system='Windows', node='PCMANN338', release='10', version='10.0.18362', machine='AMD64', processor='Intel64 Family 6 Model 85 Stepping 4, GenuineIntel')\n",
-      "2021-01-09 23:32:40 INFO - AlphaPept version 0.3.9-dev0\n",
-      "2021-01-09 23:32:40 INFO - Python version 3.8.6 | packaged by conda-forge | (default, Nov 27 2020, 18:58:29) [MSC v.1916 64 bit (AMD64)]\n",
-      "2021-01-09 23:32:40 INFO - Numba version 0.51.2\n",
-      "2021-01-09 23:32:40 INFO - Check for settings not completely implemented yet.\n",
-      "2021-01-09 23:32:40 INFO - Checking CPU settings.\n",
-      "2021-01-09 23:32:40 INFO - Setting number of processes to 24.\n",
-      "2021-01-09 23:32:40 INFO - Checking if files exist.\n",
-      "2021-01-09 23:32:40 INFO - Results path was not set. Setting to F:\\temp\\results.hdf\n",
-      "2021-01-09 23:32:40 INFO - Shortnames not set. Setting to filename.\n",
-      "2021-01-09 23:32:40 INFO - No database path set and save_db option checked. Using default path F:\\temp\\database.hdf\n",
-      "2021-01-09 23:32:40 INFO - Workflow has 10 steps\n",
-      "2021-01-09 23:32:40 INFO - Database path set and exists. Using F:\\temp\\database.hdf as database.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\r",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:40 INFO - Processing 1 files for step raw_conversion\n",
-      "2021-01-09 23:32:40 INFO - File conversion of file F:/temp\\thermo_IRT.raw complete.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:42 INFO - Processing 1 files for step find_features\n",
-      "2021-01-09 23:32:42 INFO - Found *.hdf with features for F:/temp\\thermo_IRT.ms_data.hdf\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:42 INFO - Processing 1 files for step search_db\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:43 INFO - Performing search on 1,889 query and 40 db entries with m_tol = 30.00 and m_offset = 30.00.\n",
-      "2021-01-09 23:32:47 INFO - Compared 156 spectra and found 28 psms.\n",
-      "2021-01-09 23:32:47 INFO - Extracting columns for scoring.\n",
-      "2021-01-09 23:32:53 INFO - Extracted columns from 28 spectra.\n",
-      "2021-01-09 23:32:53 INFO - Saving first_search results to F:/temp\\thermo_IRT.ms_data.hdf\n",
-      "2021-01-09 23:32:53 INFO - Search of file F:/temp\\thermo_IRT.raw complete.\n",
-      "2021-01-09 23:32:53 INFO - First search complete.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\r",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:54 INFO - Processing 1 files for step calibrate_hdf\n",
-      "2021-01-09 23:32:54 INFO - Scoring using X-Tandem\n",
-      "2021-01-09 23:32:54 INFO - Note: NumExpr detected 24 cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.\n",
-      "2021-01-09 23:32:54 INFO - NumExpr defaulting to 8 threads.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|                                                                                            | 0/1 [00:11<?, ?it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:54 INFO - Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
-      "2021-01-09 23:32:54 INFO - 8 target (0 decoy) of 8 PSM. fdr 0.000000 for a cutoff of 18.09 \n",
-      "2021-01-09 23:32:54 INFO - Not enough data points present. Skipping recalibration.\n",
-      "2021-01-09 23:32:54 INFO - Calibration of file F:/temp\\thermo_IRT.ms_data.hdf complete.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:54 INFO - Processing 1 files for step search_db\n",
-      "2021-01-09 23:32:54 INFO - Found calibrated m_offset with value 6.68\n",
-      "2021-01-09 23:32:54 INFO - Performing search on 1,889 query and 40 db entries with m_tol = 30.00 and m_offset = 6.68.\n",
-      "2021-01-09 23:32:54 INFO - Compared 156 spectra and found 28 psms.\n",
-      "2021-01-09 23:32:54 INFO - Extracting columns for scoring.\n",
-      "2021-01-09 23:32:55 INFO - Extracted columns from 28 spectra.\n",
-      "2021-01-09 23:32:55 INFO - Saving second_search results to F:/temp\\thermo_IRT.ms_data.hdf\n",
-      "2021-01-09 23:32:55 INFO - Search of file F:/temp\\thermo_IRT.raw complete.\n",
-      "2021-01-09 23:32:55 INFO - Second search complete.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A\u001b[A"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:55 INFO - Processing 1 files for step score_hdf\n",
-      "2021-01-09 23:32:55 INFO - Found second search psms for scoring.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:55 INFO - Last q_value 0.000 of dataset is smaller than fdr_level 0.100\n",
-      "2021-01-09 23:32:55 INFO - 8 target (0 decoy) of 8 PSM. fdr 0.000000 for a cutoff of 18.09 \n",
-      "2021-01-09 23:32:55 INFO - The total number of available decoys is lower than the initial set of high scoring targets.\n",
-      "2021-01-09 23:32:55 INFO - ML failed. Defaulting to x_tandem score\n",
-      "2021-01-09 23:32:55 INFO - There are fewer high scoring targets or decoys than required by 'min_train'.\n",
-      "2021-01-09 23:32:55 INFO - Filter df with x_tandem score\n",
-      "2021-01-09 23:32:55 INFO - Global FDR on precursor\n",
-      "2021-01-09 23:32:55 INFO - Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
-      "2021-01-09 23:32:55 INFO - 8 target (0 decoy) of 8 PSM. fdr 0.000000 for a cutoff of 18.09 \n",
-      "2021-01-09 23:32:55 INFO - FDR on peptides complete. For 0.01 FDR found 8 targets and 0 decoys.\n",
-      "2021-01-09 23:32:55 INFO - Scoring of file F:/temp\\thermo_IRT.ms_data.hdf complete.\n",
-      "2021-01-09 23:32:55 INFO - Extracting protein groups.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:55 INFO - A total of 1 proteins with unique PSMs found\n",
-      "2021-01-09 23:32:55 INFO - A total of 0 ambigious proteins\n",
-      "2021-01-09 23:32:55 INFO - A total of 0 proteins with unique PSMs found\n",
-      "2021-01-09 23:32:55 INFO - A total of 0 ambigious proteins\n",
-      "2021-01-09 23:32:55 INFO - Global FDR on protein\n",
-      "2021-01-09 23:32:55 INFO - Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
-      "2021-01-09 23:32:55 INFO - 1 target (0 decoy) of 1 PSM. fdr 0.000000 for a cutoff of 41.00 \n",
-      "2021-01-09 23:32:55 INFO - FDR on proteins complete. For 0.01 FDR found 8 targets and 0 decoys. A total of 1 proteins found.\n",
-      "2021-01-09 23:32:55 INFO - Extracting ions\n",
-      "2021-01-09 23:32:55 INFO - Extracting ions complete.\n",
-      "2021-01-09 23:32:56 INFO - Saving complete.\n",
-      "2021-01-09 23:32:56 INFO - Protein groups complete.\n",
-      "2021-01-09 23:32:56 INFO - Only 1 dataset present. Skipping alignment.\n",
-      "2021-01-09 23:32:56 INFO - Assembling dataframe.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\r",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:56 INFO - Assembly complete.\n",
-      "2021-01-09 23:32:56 INFO - Complete. \n",
-      "2021-01-09 23:32:56 INFO - Starting profile extraction.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2021-01-09 23:32:56 INFO - LFQ complete.\n",
-      "2021-01-09 23:32:56 INFO - Exporting as csv.\n",
-      "2021-01-09 23:32:56 INFO - Settings saved to F:\\temp\\results.yaml\n",
-      "2021-01-09 23:32:56 INFO - Analysis complete.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from alphapept.settings import load_settings\n",
-    "settings = load_settings('default_settings.yaml')\n",
-    "\n",
-    "settings['experiment']['file_paths'] =  [os.path.join(tmp_folder, 'thermo_IRT.raw')]\n",
-    "settings['fasta']['fasta_paths'] = [os.path.join(tmp_folder, 'IRT_fasta.fasta')]\n",
-    "    \n",
-    "import alphapept.interface\n",
-    "\n",
-    "settings_ = alphapept.interface.run_complete_workflow(settings)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Basic file access\n",
-    "\n",
-    "Files can be read via the alphapept.io class and displayed as pandas dataframe"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['Raw', 'corrected_fragment_mzs', 'feature_table', 'features', 'first_search', 'ions', 'peptide_fdr', 'protein_fdr', 'second_search']\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>abs_delta_m_ppm</th>\n",
-       "      <th>b-H2O_hits</th>\n",
-       "      <th>b-NH3_hits</th>\n",
-       "      <th>b_hits</th>\n",
-       "      <th>charge</th>\n",
-       "      <th>db_idx</th>\n",
-       "      <th>decoy</th>\n",
-       "      <th>decoys_cum</th>\n",
-       "      <th>decoys_cum_protein</th>\n",
-       "      <th>delta_m</th>\n",
-       "      <th>...</th>\n",
-       "      <th>target</th>\n",
-       "      <th>target_cum</th>\n",
-       "      <th>target_cum_protein</th>\n",
-       "      <th>target_precursor</th>\n",
-       "      <th>target_protein</th>\n",
-       "      <th>total_int</th>\n",
-       "      <th>x_tandem</th>\n",
-       "      <th>y-H2O_hits</th>\n",
-       "      <th>y-NH3_hits</th>\n",
-       "      <th>y_hits</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.881906</td>\n",
-       "      <td>0</td>\n",
-       "      <td>2</td>\n",
-       "      <td>4</td>\n",
-       "      <td>2</td>\n",
-       "      <td>0</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0.000782</td>\n",
-       "      <td>...</td>\n",
-       "      <td>True</td>\n",
-       "      <td>6</td>\n",
-       "      <td>1</td>\n",
-       "      <td>True</td>\n",
-       "      <td>True</td>\n",
-       "      <td>40067735</td>\n",
-       "      <td>30.914789</td>\n",
-       "      <td>3</td>\n",
-       "      <td>6</td>\n",
-       "      <td>8</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>13.398595</td>\n",
-       "      <td>0</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "      <td>2</td>\n",
-       "      <td>2</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0.004837</td>\n",
-       "      <td>...</td>\n",
-       "      <td>True</td>\n",
-       "      <td>8</td>\n",
-       "      <td>1</td>\n",
-       "      <td>True</td>\n",
-       "      <td>True</td>\n",
-       "      <td>635629</td>\n",
-       "      <td>18.091496</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>5</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>0.245930</td>\n",
-       "      <td>4</td>\n",
-       "      <td>1</td>\n",
-       "      <td>5</td>\n",
-       "      <td>2</td>\n",
-       "      <td>9</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>-0.000090</td>\n",
-       "      <td>...</td>\n",
-       "      <td>True</td>\n",
-       "      <td>1</td>\n",
-       "      <td>1</td>\n",
-       "      <td>True</td>\n",
-       "      <td>True</td>\n",
-       "      <td>21819864</td>\n",
-       "      <td>41.003103</td>\n",
-       "      <td>5</td>\n",
-       "      <td>0</td>\n",
-       "      <td>12</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>30.018059</td>\n",
-       "      <td>2</td>\n",
-       "      <td>1</td>\n",
-       "      <td>5</td>\n",
-       "      <td>2</td>\n",
-       "      <td>13</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0.013741</td>\n",
-       "      <td>...</td>\n",
-       "      <td>True</td>\n",
-       "      <td>2</td>\n",
-       "      <td>1</td>\n",
-       "      <td>True</td>\n",
-       "      <td>True</td>\n",
-       "      <td>12946349</td>\n",
-       "      <td>40.650891</td>\n",
-       "      <td>9</td>\n",
-       "      <td>0</td>\n",
-       "      <td>12</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>13.148873</td>\n",
-       "      <td>5</td>\n",
-       "      <td>0</td>\n",
-       "      <td>6</td>\n",
-       "      <td>2</td>\n",
-       "      <td>15</td>\n",
-       "      <td>False</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0.005780</td>\n",
-       "      <td>...</td>\n",
-       "      <td>True</td>\n",
-       "      <td>3</td>\n",
-       "      <td>1</td>\n",
-       "      <td>True</td>\n",
-       "      <td>True</td>\n",
-       "      <td>33162092</td>\n",
-       "      <td>36.109841</td>\n",
-       "      <td>1</td>\n",
-       "      <td>2</td>\n",
-       "      <td>9</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>5 rows × 68 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "   abs_delta_m_ppm  b-H2O_hits  b-NH3_hits  b_hits  charge  db_idx  decoy  \\\n",
-       "0         1.881906           0           2       4       2       0  False   \n",
-       "1        13.398595           0           1       2       2       2  False   \n",
-       "2         0.245930           4           1       5       2       9  False   \n",
-       "3        30.018059           2           1       5       2      13  False   \n",
-       "4        13.148873           5           0       6       2      15  False   \n",
-       "\n",
-       "   decoys_cum  decoys_cum_protein   delta_m  ...  target  target_cum  \\\n",
-       "0           0                   0  0.000782  ...    True           6   \n",
-       "1           0                   0  0.004837  ...    True           8   \n",
-       "2           0                   0 -0.000090  ...    True           1   \n",
-       "3           0                   0  0.013741  ...    True           2   \n",
-       "4           0                   0  0.005780  ...    True           3   \n",
-       "\n",
-       "   target_cum_protein  target_precursor  target_protein  total_int   x_tandem  \\\n",
-       "0                   1              True            True   40067735  30.914789   \n",
-       "1                   1              True            True     635629  18.091496   \n",
-       "2                   1              True            True   21819864  41.003103   \n",
-       "3                   1              True            True   12946349  40.650891   \n",
-       "4                   1              True            True   33162092  36.109841   \n",
-       "\n",
-       "   y-H2O_hits  y-NH3_hits  y_hits  \n",
-       "0           3           6       8  \n",
-       "1           0           0       5  \n",
-       "2           5           0      12  \n",
-       "3           9           0      12  \n",
-       "4           1           2       9  \n",
-       "\n",
-       "[5 rows x 68 columns]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import alphapept.io\n",
-    "\n",
-    "_ = settings['experiment']['file_paths'][0]\n",
-    "base, ext = os.path.splitext(_)\n",
-    "\n",
-    "ms_file = alphapept.io.MS_Data_File(base+'.ms_data.hdf')\n",
-    "\n",
-    "print(ms_file.read())\n",
-    "\n",
-    "df = ms_file.read(dataset_name='protein_fdr')\n",
-    "\n",
-    "df.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## MS2 Spectrum\n",
-    "\n",
-    "Visualize PSMS"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\r",
-      "100%|████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  1.70it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Plotting PSMS for LGGNEQVTR_2\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Plotting PSMS for YILAGVENSK_2\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Plotting PSMS for GAGSSEPVTGLDAK_2\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "def plot_psms(precursor, ms_file):\n",
-    "\n",
-    "    df = ms_file.read(dataset_name='protein_fdr')\n",
-    "    \n",
-    "    ion_dict = {}\n",
-    "    ion_dict[0] = ''\n",
-    "    ion_dict[1] = '-H20'\n",
-    "    ion_dict[2] = '-NH3'\n",
-    "\n",
-    "    spectrum = df[df['precursor'] == precursor].iloc[0]\n",
-    "    start = spectrum['ion_idx']\n",
-    "    end = spectrum['n_ions'] + start\n",
-    "\n",
-    "    query_data = ms_file.read_DDA_query_data()\n",
-    "    ions = ms_file.read(dataset_name=\"ions\")\n",
-    "\n",
-    "    ion = [('b'+str(int(_))).replace('b-','y') for _ in ions.iloc[start:end]['ion_index']]\n",
-    "    losses = [ion_dict[int(_)] for _ in ions.iloc[start:end]['ion_type']]\n",
-    "    ion = [a+b for a,b in zip(ion, losses)]\n",
-    "    ints = ions.iloc[start:end]['ion_int'].astype('int').values\n",
-    "    masses = ions.iloc[start:end]['ion_mass'].astype('float').values\n",
-    "    ion_type = ions.iloc[start:end]['ion_type'].abs().values\n",
-    "\n",
-    "    query_idx = spectrum['raw_idx']\n",
-    "\n",
-    "    query_indices = query_data[\"indices_ms2\"]\n",
-    "    query_bounds = query_data['bounds']\n",
-    "    query_charges = query_data['charge2']\n",
-    "    query_frags = query_data['mass_list_ms2']\n",
-    "    query_ints = query_data['int_list_ms2']\n",
-    "\n",
-    "    query_idx_start = query_indices[query_idx]\n",
-    "    query_idx_end = query_indices[query_idx + 1]\n",
-    "    query_frag = query_frags[query_idx_start:query_idx_end]\n",
-    "    query_int = query_ints[query_idx_start:query_idx_end]\n",
-    "\n",
-    "    ax = plt.figure(figsize=(15, 5))\n",
-    "\n",
-    "    plt.vlines(query_frag, 0, query_int, \"k\", label=\"Query\", alpha=0.5)\n",
-    "\n",
-    "    plt.vlines(masses, ints, max(query_int)*(1+0.1*ion_type), \"k\", label=\"Hits\", alpha=0.5, linestyle=':')\n",
-    "\n",
-    "    plt.vlines(masses, 0, ints, \"r\", label=\"Hits\", alpha=0.5)\n",
-    "\n",
-    "    for i in range(len(masses)):\n",
-    "        plt.text(masses[i], (1+0.1*ion_type[i])*max(query_int), ion[i])\n",
-    "\n",
-    "    figure_title = f\"{spectrum['precursor']} - b-hits {spectrum['b_hits']}, y-hits {spectrum['y_hits']}, matched int {spectrum['matched_int_ratio']*100:.2f} %\"\n",
-    "\n",
-    "    plt.xlabel(\"Mass\")\n",
-    "    plt.ylabel('Intensity')\n",
-    "    plt.ylim([0, (1+0.1*max(ion_type)+0.1)*max(query_int)])\n",
-    "    plt.legend()\n",
-    "    plt.title(figure_title)\n",
-    "    plt.show()\n",
-    "    \n",
-    "    \n",
-    "for index in range(3):\n",
-    "    precursor = df['precursor'].iloc[index]\n",
-    "    print(f\" Plotting PSMS for {precursor}\")\n",
-    "    plot_psms(precursor, ms_file)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python [conda env:alphapept] *",
-   "language": "python",
-   "name": "conda-env-alphapept-py"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.6"
-  },
-  "toc": {
-   "base_numbering": 1,
-   "nav_menu": {},
-   "number_sections": true,
-   "sideBar": true,
-   "skip_h1_title": false,
-   "title_cell": "Table of Contents",
-   "title_sidebar": "Contents",
-   "toc_cell": false,
-   "toc_position": {},
-   "toc_section_display": true,
-   "toc_window_display": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/alphapept/__init__.py b/alphapept/__init__.py
index e05f3ec9..befe9097 100644
--- a/alphapept/__init__.py
+++ b/alphapept/__init__.py
@@ -1,1 +1,1 @@
-__version__ = "0.3.19-dev0"
+__version__ = "0.3.20-dev0"
diff --git a/alphapept/__version__.py b/alphapept/__version__.py
index 24573061..c434b807 100644
--- a/alphapept/__version__.py
+++ b/alphapept/__version__.py
@@ -33,7 +33,7 @@
 AUTHOR_EMAIL = "straussmaximilian@gmail.com"
 COPYRIGHT = "Mann Labs"
 BRANCH = "master"
-VERSION_NO = "0.3.19-dev0"
+VERSION_NO = "0.3.20-dev0"
 MIN_PYTHON = "3.6"
 MAX_PYTHON = "4"
 AUDIENCE = "Developers"
diff --git a/alphapept/default_settings.yaml b/alphapept/default_settings.yaml
index dd835049..6fb6bd7a 100644
--- a/alphapept/default_settings.yaml
+++ b/alphapept/default_settings.yaml
@@ -1,4 +1,5 @@
 workflow:
+  continue_runs: false
   create_database: true
   import_raw_data: true
   find_features: true
diff --git a/alphapept/gui/__init__.py b/alphapept/gui/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/alphapept/gui/experiment.py b/alphapept/gui/experiment.py
new file mode 100644
index 00000000..255f89a5
--- /dev/null
+++ b/alphapept/gui/experiment.py
@@ -0,0 +1,181 @@
+import streamlit as st
+import os
+import pandas as pd
+import datetime
+from alphapept.paths import SETTINGS_TEMPLATE, QUEUE_PATH, DEFAULT_SETTINGS_PATH
+from alphapept.settings import load_settings_as_template, save_settings
+from alphapept.gui.utils import escape_markdown
+
+
+def parse_folder(file_folder):
+    """
+    Checks a folder for raw, fasta and db_data.hdf files
+    """
+    raw_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.raw') or _.lower().endswith('.d')]
+    fasta_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.fasta')]
+    db_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.db_data.hdf')]
+
+    return raw_files, fasta_files, db_files
+
+
+def widget_from_setting(recorder, key, group, element, override=None):
+    """
+    Creates streamlit widgets from settigns
+    Returns a recorder to extract set values
+    """
+    _ = group[element]
+
+    if key not in recorder:
+        recorder[key] = {}
+
+    if 'description' in _:
+        help = _['description']
+    else:
+        help = ''
+
+    value = _['default']
+
+    if override:
+        value = override
+
+    if _['type'] == 'doublespinbox':
+        recorder[key][element] = st.slider(element, min_value = float(_['min']), max_value = float(_['max']), value = float(value), help = help)
+    elif _['type'] == 'spinbox':
+        recorder[key][element] = st.slider(element, min_value = _['min'], max_value = _['max'], value = value, help = help)
+    elif _['type'] == 'checkbox':
+        recorder[key][element] = st.checkbox(element, value = value, help = help)
+    elif _['type'] == 'checkgroup':
+        opts = list(_['value'].keys())
+        recorder[key][element] = st.multiselect(label = element, options = opts, default = value, help = help)
+    elif _['type'] == 'combobox':
+        recorder[key][element] = st.selectbox(label = element, options = _['value'], index = _['value'].index(value),  help = help)
+    else:
+        st.write(f"Not understood {_}")
+
+    return recorder
+
+def submit_experiment(recorder):
+    """
+    Asks for an experiment name and creates a button to submit.
+    """
+    name = st.text_input('Enter experiment name and press enter.', datetime.datetime.today().strftime('%Y_%m_%d_'))
+
+    long_name = name + '.yaml'
+    long_name_path = os.path.join(QUEUE_PATH, long_name)
+
+    if os.path.exists(long_name_path):
+        st.error(f'Name {escape_markdown(long_name)} already exists. Please rename.')
+    else:
+        st.info(f'Filename will be: {escape_markdown(long_name)}. Click submit button to add to queue.')
+        if st.button('Submit'):
+            settings = load_settings_as_template(DEFAULT_SETTINGS_PATH)
+            for group in recorder:
+                for key in recorder[group]:
+                    settings[group][key] = recorder[group][key]
+
+            save_settings(settings, long_name_path)
+            #Change things from experiment
+            st.success(f'Experiment {escape_markdown(long_name)} submitted. Switch to Status tab to track progress.')
+
+
+def customize_settings(recorder, uploaded_settings, loaded):
+
+    with st.beta_expander("Settings", loaded):
+        for key in SETTINGS_TEMPLATE.keys():
+            if key not in ['experiment', 'workflow']:
+                group = SETTINGS_TEMPLATE[key]
+                #Check if different than default
+                if loaded:
+                    changed = sum([uploaded_settings[key][element] != group[element]['default'] for element in group]) > 0
+                else:
+                    changed = False
+
+                if st.checkbox(key, changed):
+                    for element in group:
+                        override = None
+                        if changed:
+                            if uploaded_settings[key][element] != group[element]['default']:
+                                override = uploaded_settings[key][element]
+
+                        recorder = widget_from_setting(recorder, key, group, element, override)
+
+    return recorder
+
+
+def experiment():
+    st.write("# New experiment")
+    st.write('## Files')
+
+    recorder = {}
+    recorder['experiment'] = {}
+
+    cwd = os.getcwd()
+    file_folder = st.text_input("Enter path to folder that contains all experimental files. AlphaPept will parse for raw (.d / .raw), FASTA and AlphaPept database (.db_files.hdf) files and add them to the experiment.", cwd)
+
+    if not os.path.isdir(file_folder):
+        st.warning('Not a valid folder.')
+    else:
+        with st.spinner('Parsing folder'):
+            raw_files, fasta_files, db_files = parse_folder(file_folder)
+
+            recorder['experiment']['fasta_paths'] = [os.path.join(file_folder, _) for _ in fasta_files]
+            recorder['experiment']['file_paths'] = [os.path.join(file_folder, _) for _ in raw_files]
+
+            if (len(raw_files) == 0) or (len(fasta_files) == 0):
+                if (len(raw_files) == 0) and (len(fasta_files) == 0):
+                    st.warning('No raw and FASTA files in folder.')
+                elif len(raw_files) == 0:
+                    st.warning('No raw files in folder.')
+                elif len(fasta_files) == 0:
+                    st.warning('No fasta files in folder.')
+
+            else:
+                with st.beta_expander(f"Raw files ({len(raw_files)})"):
+                    st.table(pd.DataFrame(raw_files, columns=['File']))
+
+                if len(fasta_files) > 0:
+                    with st.beta_expander(f"FASTA files ({len(fasta_files)})"):
+                        st.table(pd.DataFrame(fasta_files, columns=['File']))
+
+                #TODO: Include databse files
+                #if len(fasta_files) > 0:
+                #    with st.beta_expander(f"FASTA files ({len(fasta_files)})"):
+                #        st.table(pd.DataFrame(fasta_files, columns=['File']))
+
+                with st.beta_expander("Fractions"):
+                    st.write('Fractions are currently not supported.')
+                    if False:
+                        st.write('Fractions can be automatically assigned based on the filename.',
+                                'Enter the string that preceds the fraction identifier and the string that comes after.')
+                        prec = st.text_input('Preceding')
+                        after = st.text_input('After')
+
+                        if st.button('Apply'):
+                            with st.spinner('Parsing folder'):
+                                files = pd.DataFrame(raw_files, columns=['File'])
+                                files['Fraction'] = files['File'].apply(lambda x: x.split(prec)[1].split(after)[0])
+                                st.table(files)
+
+                st.write(f"## Workflow")
+
+                with st.beta_expander("Steps"):
+                    group = SETTINGS_TEMPLATE['workflow']
+                    for element in group:
+                        recorder = widget_from_setting(recorder, 'workflow', group, element)
+
+                st.write("## Additional settings")
+
+                prev_settings = st.checkbox('Use previous settings as template')
+
+                loaded = False
+                uploaded_settings = None
+                if prev_settings:
+                    uploaded_file = st.file_uploader("Choose a file")
+                    if uploaded_file is not None:
+                        uploaded_settings =  yaml.load(uploaded_file, Loader=yaml.FullLoader)
+                        loaded=True
+
+
+                recorder = customize_settings(recorder, uploaded_settings, loaded)
+
+                submit_experiment(recorder)
diff --git a/alphapept/gui/filewatcher.py b/alphapept/gui/filewatcher.py
new file mode 100644
index 00000000..ceff58a2
--- /dev/null
+++ b/alphapept/gui/filewatcher.py
@@ -0,0 +1,142 @@
+import streamlit as st
+from alphapept.paths import FILE_WATCHER_FILE, DEFAULT_SETTINGS_PATH, QUEUE_PATH
+from alphapept.gui.utils import check_process, init_process, start_process
+from alphapept.settings import load_settings_as_template, save_settings
+import os
+import time
+import datetime
+import yaml
+import psutil
+
+def check_file_completion(file, minimum_file_size):
+
+    to_analyze = []
+
+    if file.endswith('.d'):
+        #Bruker
+        to_check = os.path.join(file, 'analysis.tdf_bin')
+        while not os.path.isfile(to_check):
+            time.sleep(1)
+    else:
+        to_check = file
+
+    filesize = os.path.getsize(to_check)
+
+    writing = True
+    while writing:
+        time.sleep(1)
+        new_filesize = os.path.getsize(to_check)
+        if filesize == new_filesize:
+            writing  = False
+        else:
+            filesize = new_filesize
+
+    if filesize/1024/1024 > minimum_file_size: #bytes, kbytes, mbytes
+        to_analyze.append(file)
+
+    return to_analyze
+
+
+
+def file_watcher_process(folder, settings_template, minimum_file_size, tag):
+    """
+    Start the filewatcher process
+    """
+
+    from watchdog.observers import Observer
+    from watchdog.events import PatternMatchingEventHandler
+
+    patterns = "*"
+    ignore_patterns = ""
+    ignore_directories = False
+    case_sensitive = False
+    my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
+
+    def on_created(event):
+        print(f"{event.src_path} has been created.")
+
+        file = event.src_path
+
+        if tag != 'None':
+            if tag not in file:
+                return
+
+        if file.lower().endswith('.raw') or file.lower().endswith('.d'):
+            print(f"Checking {file}")
+            files = check_file_completion(file, minimum_file_size)
+
+            if len(files) > 0:
+                settings = settings_template.copy()
+                settings['experiment']['file_paths'] = files
+                new_file = os.path.splitext(os.path.split(file)[1])[0] + '.yaml'
+                settings['experiment']['results_path'] = os.path.splitext(file)[0] + '.yaml'
+                save_settings(settings, os.path.join(QUEUE_PATH, new_file))
+                print(f'{datetime.datetime.now()} Added {file}')
+
+    print(f'{datetime.datetime.now()} file watcher started.')
+
+    my_event_handler.on_created = on_created
+
+    go_recursively = True
+    my_observer = Observer()
+    my_observer.schedule(my_event_handler, folder, recursive=go_recursively)
+
+    init_process(FILE_WATCHER_FILE, folder=folder)
+
+    my_observer.start()
+    while True:
+        time.sleep(1)
+
+def filewatcher():
+    st.write('# FileWatcher')
+
+    # FIleWatcher
+    running, last_pid, p_name, status, p_init  = check_process(FILE_WATCHER_FILE)
+
+    if running:
+        if p_init:
+            with open(FILE_WATCHER_FILE, "r") as process_file:
+                process = yaml.load(process_file, Loader=yaml.FullLoader)
+                path = process['folder']
+        else:
+            path = None
+        st.success(f'PID {last_pid} - {p_name} - {status} - {path}')
+
+        if st.button('Stop file watcher'):
+            p_ = psutil.Process(last_pid)
+            p_.terminate()
+            st.success(f'Terminated {last_pid}')
+            raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
+    else:
+        st.warning('FileWatcher is currently not running.')
+
+    valid = True
+    st.write('AlphaPept can watch folders for new files and automatically add them to the processing queue.')
+
+    folder = st.text_input("Enter folder to watch.", os.getcwd())
+
+    if not os.path.isdir(folder):
+        st.error('Not a valid path.')
+        valid = False
+
+    minimum_size = st.slider("Minimum file size in MB. Files that are smaller will be ignored.", min_value=1, max_value = 10000, value=200)
+
+    tag = st.text_input("Enter tag to only select files with tag. Keep None for all files. ",'None')
+
+    settings_template = st.text_input("Enter path to a settings template:", DEFAULT_SETTINGS_PATH)
+    if not os.path.isfile(settings_template):
+        st.error('Not a valid path.')
+        valid = False
+    else:
+        settings_ = load_settings_as_template(settings_template)
+        st.success('Valid settings file.')
+        if st.checkbox('Show'):
+            st.write(settings_)
+
+    if valid:
+        start_watcher = st.button('Start file watcher ')
+        valid = False
+
+        if start_watcher:
+            start_process(target = file_watcher_process, process_file = FILE_WATCHER_FILE, args = (folder, settings_, minimum_size, tag), verbose = True)
+            raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
diff --git a/alphapept/gui/history.py b/alphapept/gui/history.py
new file mode 100644
index 00000000..4e52693a
--- /dev/null
+++ b/alphapept/gui/history.py
@@ -0,0 +1,141 @@
+import os
+import streamlit as st
+import plotly.express as px
+import yaml
+import pandas as pd
+from alphapept.paths import PROCESSED_PATH, AP_PATH
+from alphapept.gui.utils import files_in_folder
+
+def load_files(file_list, callback = None):
+    """
+    Read multiple yaml files and return a dict with results
+    """
+    all_results = {}
+
+    for idx, _ in enumerate(file_list):
+        with open(os.path.join(PROCESSED_PATH, _), "r") as settings_file:
+            results = yaml.load(settings_file, Loader=yaml.FullLoader)
+            base, ext = os.path.splitext(_)
+            all_results[base] = results
+
+        if callback:
+            callback.progress((idx+1)/len(file_list))
+
+    return all_results
+
+def read_groups():
+    """
+    Checks the AlphaPept Home Folder if a group.txt is present
+    """
+    group_txt = os.path.join(AP_PATH, 'groups.txt')
+    if os.path.isfile(group_txt):
+        with open(group_txt, 'r') as f:
+            groups = f.readlines()
+            groups = [_.rstrip('\n') for _ in groups]
+    else:
+        groups = []
+
+    return groups
+
+def filter_by_tag(files):
+    """
+    Streamlit text input to filter filenames by tag
+    """
+    filter = st.text_input('Filter')
+
+    if filter:
+        filtered = [_ for _ in files if filter in _]
+    else:
+        filtered = files
+
+    st.write(filter)
+    st.write(f"Remaining {len(filtered)} of {len(files)} files.")
+
+    return filtered
+
+def check_group(filename, groups):
+    for group in groups:
+        if group in filename:
+            return group
+    return 'None'
+
+
+def create_single_plot(all_results, files, acquisition_date_times, mode, groups, plot):
+    """
+    Creates single plotly express plot
+    """
+    vals = []
+    for idx, _ in enumerate(all_results.keys()):
+        if plot == 'timing':
+            vals.append(all_results[_]["summary"]["timing"]["total"])
+        else:
+            try:
+                vals.append(all_results[_]["summary"][files[idx]][plot])
+            except KeyError:
+                vals.append(0)
+
+    plot_df = pd.DataFrame([files, acquisition_date_times, vals]).T
+    plot_df.columns = ['Filename', 'AcquisitionDateTime', plot]
+
+    if groups != []:
+        plot_df['group'] = plot_df['Filename'].apply(lambda x: check_group(x, groups))
+    else:
+        plot_df['group'] = 'None'
+
+    median_ = plot_df[plot].median()
+    plot_df = plot_df.sort_values(mode)
+
+    if mode == 'Filename':
+        height = 800
+    else:
+        height = 400
+
+    fig = px.scatter(plot_df, x=mode, y=plot, color = 'group', hover_name='Filename', hover_data=['AcquisitionDateTime'], title=f'{plot} - median {median_:.2f}', height=height).update_traces(mode='lines+markers')
+    fig.add_hline(y=median_, line_dash="dash")
+    st.plotly_chart(fig)
+
+def create_multiple_plots(all_results, groups):
+    """
+    Creates multiple plotly express plots
+
+    """
+    plot_types = ['feature_table', 'feature_table_median_rt_length','protein_fdr_n_sequence','protein_fdr_n_protein', 'protein_fdr_n_protein_group', 'id_rate','timing']
+    mode = st.selectbox('X-Axis', options = ['AcquisitionDateTime','Filename'])
+
+    with st.spinner('Creating plots..'):
+
+        # Get filename and acquisition_date_time
+        files = [os.path.splitext(all_results[_]['summary']['processed_files'][0])[0] for _ in all_results.keys()]
+        acquisition_date_times = [all_results[_]["summary"][files[idx]]['acquisition_date_time'] for idx, _ in enumerate(all_results.keys())]
+
+        for plot in plot_types:
+            create_single_plot(all_results, files, acquisition_date_times, mode, groups, plot)
+
+
+def history():
+    """
+    Plot history of previous experiments
+    """
+    st.write("# History")
+    st.text(f'History allows to visualize summary information from multiple previous analysis.'
+    f'\nIt checks {PROCESSED_PATH} for *.yaml files.'
+    '\nFiles can be filtered to only include a subset.')
+
+    processed_files = files_in_folder(PROCESSED_PATH, '.yaml')
+
+    with st.beta_expander(f"Processed files ({len(processed_files)})"):
+        st.table(processed_files)
+
+    groups = read_groups()
+
+    with st.beta_expander("Group files"):
+        st.text(f"If a groups.txt is present in the AlphaPept folder {AP_PATH}, data will be grouped.")
+        groups = st.multiselect('Groups', default = groups, options=groups)
+
+    filtered = filter_by_tag(processed_files)
+    if len(filtered) > 1:
+        filtered = filtered[:st.slider('Preview', 1, len(filtered), min(len(filtered), 50))]
+    all_results = load_files(filtered, callback=st.progress(0))
+
+    if len(all_results) > 0:
+        create_multiple_plots(all_results, groups)
diff --git a/alphapept/gui/results.py b/alphapept/gui/results.py
new file mode 100644
index 00000000..21de6241
--- /dev/null
+++ b/alphapept/gui/results.py
@@ -0,0 +1,123 @@
+import streamlit as st
+from alphapept.gui.utils import files_in_folder, read_log
+from alphapept.paths import PROCESSED_PATH
+from alphapept.settings import load_settings
+import os
+import yaml
+import alphapept.io
+import pandas as pd
+import base64
+
+
+def readable_files_from_yaml(results_yaml):
+    """
+    Returns all readable files from results yaml
+    """
+
+    raw_files = [os.path.splitext(_)[0]+'.ms_data.hdf' for _ in results_yaml['experiment']['file_paths']]
+    raw_files = raw_files + [results_yaml['experiment']['results_path']]
+    raw_files = [_ for _ in raw_files if os.path.exists(_)]
+
+    return raw_files
+
+def get_table_download_link(df, name):
+    """Generates a link allowing the data in a given panda dataframe to be downloaded
+    in:  dataframe
+    out: href string
+    """
+    csv = df.to_csv(index=False)
+    b64 = base64.b64encode(
+        csv.encode()
+    ).decode()  # some strings <-> bytes conversions necessary here
+
+    href = f'<a href="data:file/csv;base64,{b64}" download="%{name}" >Download as *.csv</a>'
+    st.markdown('')
+    st.markdown(href, unsafe_allow_html=True)
+
+
+def make_df_downloadble(df, file):
+    """
+    Creates checkbox to make displayed data downloadable
+    """
+    if st.button('Create download link'):
+        file_name = os.path.splitext(os.path.split(file)[-1])[0] + '.csv'
+        get_table_download_link(df, file_name)
+
+
+def parse_file_and_display(file):
+    """
+    Loads file and displays dataframe in streamlit
+    """
+
+    pandas_hdf = False
+
+    try:
+        ms_file = alphapept.io.MS_Data_File(file)
+        options = [_ for _ in ms_file.read() if _ != "Raw"]
+    except KeyError:
+        pandas_hdf = True
+
+        with pd.HDFStore(file) as hdf:
+            options = list(hdf.keys())
+
+    opt = st.selectbox('Select group', [None] + options)
+    if opt is not None:
+        if pandas_hdf:
+            df = pd.read_hdf(file, opt)
+        else:
+            df = ms_file.read(dataset_name = opt)
+        if not isinstance(df, pd.DataFrame):
+            df = pd.DataFrame(df)
+
+        data_range = st.slider('Data range', 0, len(df), (0,1000))
+        st.write(df.iloc[data_range[0]:data_range[1]])
+
+        make_df_downloadble(df, file)
+
+
+def results():
+    st.write("# Results")
+
+    st.text("This page allows to explore the analysis results.\nAlphaPept uses the HDF container format which can be accessed here.")
+
+    #TOdo: include previously processed output files..
+
+    selection = st.selectbox('File selection', ('Previous results', 'Enter file'))
+
+    if selection == 'Previous results':
+
+        results_files = files_in_folder(PROCESSED_PATH, '.yaml')
+
+        with st.beta_expander(f"Total {len(results_files)} Files"):
+            st.table(results_files)
+
+        st.write('### Select results file')
+
+        selection = st.selectbox('Run', results_files)
+
+        if selection:
+
+            filepath_selection = os.path.join(PROCESSED_PATH, selection)
+            results_yaml = load_settings(filepath_selection)
+
+            with st.beta_expander("Run summary"):
+                st.write(results_yaml['summary'])
+
+            read_log(os.path.splitext(filepath_selection)[0]+'.log')
+            raw_files = readable_files_from_yaml(results_yaml)
+            st.write('### Select file from Experiment')
+            file = st.selectbox('Select file from experiment', raw_files)
+
+    elif selection == 'Enter file':
+        file = st.text_input("Enter path to hdf file.", os.getcwd())
+    else:
+        file = ''
+
+    if file is None:
+        file = ''
+
+    if not os.path.isfile(file):
+        st.warning('Not a valid file.')
+    else:
+        with st.spinner('Parsing file'):
+            parse_file_and_display(file)
diff --git a/alphapept/gui/status.py b/alphapept/gui/status.py
new file mode 100644
index 00000000..8da9f30b
--- /dev/null
+++ b/alphapept/gui/status.py
@@ -0,0 +1,181 @@
+import streamlit as st
+from alphapept.gui.utils import files_in_folder, read_log, check_process, init_process, start_process, escape_markdown
+from alphapept.paths import PROCESSED_PATH, PROCESS_FILE, QUEUE_PATH, FAILED_PATH
+from alphapept.settings import load_settings, load_settings_as_template, save_settings
+import os
+import psutil
+import datetime
+import pandas as pd
+import time
+import yaml
+import alphapept.interface
+
+def queue_watcher():
+    """
+    Start the queue_watcher.
+    """
+    #This is in pool and should be reporting.
+    print(f'{datetime.datetime.now()} Started queue_watcher')
+
+    init_process(PROCESS_FILE)
+
+
+    while True:
+        queue_files = [_ for _ in os.listdir(QUEUE_PATH) if _.endswith('.yaml')]
+        #print(f'{datetime.datetime.now()} queue_watcher running. {len(queue_files)} experiments to process.')
+
+        if len(queue_files) > 0:
+            file_path = os.path.join(QUEUE_PATH, queue_files[0])
+            settings = load_settings_as_template(file_path)
+
+            current_file = {}
+            current_file['started'] = datetime.datetime.now()
+            current_file['file'] = queue_files[0]
+
+            current_file_path = os.path.join(QUEUE_PATH, 'current_file')
+
+            with open(current_file_path, "w") as file:
+                yaml.dump(current_file, file, sort_keys=False)
+
+            logfile = os.path.join(PROCESSED_PATH, os.path.splitext(queue_files[0])[0]+'.log')
+            try:
+                settings_ = alphapept.interface.run_complete_workflow(settings, progress=True, logfile = logfile)
+                save_settings(settings_, os.path.join(PROCESSED_PATH, queue_files[0]))
+
+            except Exception as e:
+                print(f'Run {file_path} failed with {e}')
+                settings_ = settings.copy()
+                settings_['error'] = f"{e}"
+                save_settings(settings_, os.path.join(FAILED_PATH, queue_files[0]))
+
+            os.remove(file_path)
+            if os.path.isfile(current_file_path):
+                os.remove(current_file_path)
+        else:
+            time.sleep(15)
+
+def status():
+
+    st.write("# Status")
+    st.text(f'This page shows the status of the current analysis.\nSwitch to `New experiment` to define a new experiment')
+    status_msg = st.empty()
+    failed_msg = st.empty()
+
+    current_log = ''
+    log_txt = []
+
+    st.write("## Progress")
+
+    overall_txt = st.empty()
+
+    overall_txt.text('Overall: 0%')
+    overall = st.progress(0)
+
+    task = st.empty()
+    task.text('Current task: None')
+
+    current_p = st.empty()
+    current_p.text('Current progess: 0%')
+
+    current = st.progress(0)
+
+    last_log = st.empty()
+
+    st.write("## Hardware utilization")
+
+    st.text('Ram')
+    ram = st.progress(0)
+    st.text('CPU')
+    cpu = st.progress(0)
+
+    running, last_pid, p_name, status, queue_watcher_state = check_process(PROCESS_FILE)
+
+    if not running:
+        start_process(target = queue_watcher, process_file= PROCESS_FILE, verbose=False)
+        st.warning('Initializing Alphapept and waiting for process to start. Please refresh page in a couple of seconds.')
+    elif not queue_watcher_state:
+        st.warning('Initializing Alphapept and waiting for process to start. Please refresh page in a couple of seconds.')
+    else:
+        current_file = os.path.join(QUEUE_PATH, 'current_file')
+
+        with st.beta_expander(f"Full log "):
+            log_ = st.empty()
+
+        with st.beta_expander(f"Queue"):
+            queue_table = st.empty()
+
+        with st.beta_expander(f"Failed"):
+            failed_table = st.empty()
+
+        refresh = st.checkbox('Auto-Update Page')
+
+        while True:
+            if os.path.isfile(current_file):
+                with open(current_file, "r") as file:
+                    cf_ = yaml.load(file, Loader=yaml.FullLoader)
+
+                cf = cf_['file']
+                cf_start = cf_['started']
+                status_msg.success(f'Processing {escape_markdown(cf)}. Started at {cf_start}')
+
+                logfile = os.path.join(PROCESSED_PATH, os.path.splitext(cf)[0]+'.log')
+                if current_log != logfile:
+                    current_log = logfile
+                    log_txt = []
+                    f = open(logfile, "r")
+
+                for line in f.readlines():
+                    if '__progress_current' in line:
+                        current_p_ = float(line.split('__progress_current ')[1][:5])
+                        current.progress(current_p_)
+
+                        current_p.text(f'Current progress: {current_p_*100:.2f}%')
+                    elif '__progress_overall' in line:
+
+                        overall_p = float(line.split('__progress_overall ')[1][:5])
+                        overall.progress(overall_p)
+
+                        overall_txt.text(f'Overall: {overall_p*100:.2f}%')
+                    elif '__current_task' in line:
+                        task_ = line.strip('\n').split('__current_task ')[1]
+                        task.text(f'Current task: {task_}')
+                    else:
+                        log_txt.append(line)
+
+                    last_log.code(''.join(log_txt[-3:]))
+                    log_.code(''.join(log_txt))
+
+            ram.progress(1-psutil.virtual_memory().available/psutil.virtual_memory().total)
+            cpu.progress(psutil.cpu_percent()/100)
+
+            queue_files = [_ for _ in os.listdir(QUEUE_PATH) if _.endswith('.yaml')]
+            failed_files = [_ for _ in os.listdir(FAILED_PATH) if _.endswith('.yaml')]
+            n_failed = len(failed_files)
+            n_queue = len(queue_files)
+
+            if n_queue == 0:
+                status_msg.success(f'{datetime.datetime.now().strftime("%d.%m.%Y %H:%M:%S")} No files to process. Please add new experiments.')
+                current.progress(0)
+                overall.progress(0)
+                overall_txt.text('Overall: 0%')
+                task.text('None')
+
+                queue_table.table(pd.DataFrame())
+
+            else:
+                created = [time.ctime(os.path.getctime(os.path.join(QUEUE_PATH, _))) for _ in queue_files]
+                queue_df = pd.DataFrame(queue_files, columns = ['File'])
+                queue_df['Created'] = created
+
+                queue_table.table(queue_df)
+
+            if n_failed == 1:
+                failed_msg.error(f'{n_failed} run failed. Please check {FAILED_PATH}.')
+            elif n_failed > 1:
+                failed_msg.error(f'{n_failed} runs failed. Please check {FAILED_PATH}.')
+
+            failed_table.table(pd.DataFrame(failed_files))
+            time.sleep(0.2)
+
+            if not refresh:
+                break
diff --git a/alphapept/gui/utils.py b/alphapept/gui/utils.py
new file mode 100644
index 00000000..3869e257
--- /dev/null
+++ b/alphapept/gui/utils.py
@@ -0,0 +1,94 @@
+import os
+import datetime
+import yaml
+import streamlit as st
+from multiprocessing import Process
+import psutil
+import time
+
+def escape_markdown(text):
+    """
+    Escape markdown
+    """
+    MD_SPECIAL_CHARS = "\`*_{}[]()#+-.!"
+    for char in MD_SPECIAL_CHARS:
+        text = text.replace(char, "\\"+char)
+    return text
+
+def files_in_folder(folder, ending):
+    """
+    Reads a folder and returns all files that have this ending. Sorts the files by name.
+    """
+    files = [_ for _ in os.listdir(folder) if _.endswith(ending)]
+    files.sort()
+    files = files[::-1]
+
+    return files
+
+
+def read_log(log_path):
+    """
+    Reads logfile cleanly (i.e. removing lines with __ which are used for progress)
+    """
+    if os.path.isfile(log_path):
+        with st.beta_expander("Run log"):
+            with st.spinner('Parsing file'):
+                with open(log_path, "r") as logfile:
+                    lines = logfile.readlines()
+                    lines = [_ for _ in lines if '__' not in _]
+                    st.code(''.join(lines))
+
+
+def start_process(target, process_file, args = None, verbose = True):
+    process = {}
+    now = datetime.datetime.now()
+    process['created'] = now
+    if args:
+        p = Process(target=target, args = args)
+    else:
+        p = Process(target=target)
+    p.start()
+    process['pid'] = p.pid
+
+    if verbose:
+        st.success(f'Started process PID {p.pid} at {now}')
+
+    with open(process_file, "w") as file:
+        yaml.dump(process, file, sort_keys=False)
+
+def check_process(process_path):
+    if os.path.isfile(process_path):
+        with open(process_path, "r") as process_file:
+            process = yaml.load(process_file, Loader=yaml.FullLoader)
+        last_pid = process['pid']
+
+        if 'init' in process:
+            p_init = process['init']
+        else:
+            p_init = False
+
+        if psutil.pid_exists(last_pid):
+            p_ = psutil.Process(last_pid)
+            with p_.oneshot():
+                p_name = p_.name()
+                status = p_.status()
+            return True, last_pid, p_name, status, p_init
+
+    return False, None, None, None, False
+
+def init_process(process_path, **kwargs):
+    """
+    Waits until a process file is created and then writes an init flag to the file
+    """
+    while True:
+        if os.path.isfile(process_path):
+            with open(process_path, "r") as process_file:
+                p = yaml.load(process_file, Loader=yaml.FullLoader)
+            p['init'] = True
+            for _ in kwargs:
+                p[_] = kwargs[_]
+            with open(process_path, "w") as file:
+                yaml.dump(p, file, sort_keys=False)
+            break
+        else:
+            time.sleep(1)
diff --git a/alphapept/interface.py b/alphapept/interface.py
index a368238b..533ea831 100644
--- a/alphapept/interface.py
+++ b/alphapept/interface.py
@@ -604,6 +604,7 @@ def export(
 from time import time, sleep
 from .__version__ import VERSION_NO
 import datetime
+import alphapept.utils
 
 
 def get_file_summary(ms_data):
@@ -685,6 +686,10 @@ def run_complete_workflow(
 
     workflow = settings['workflow']
 
+    if "continue_runs" in workflow:
+        if not workflow["continue_runs"]:
+            for _ in settings['experiment']['file_paths']:
+                alphapept.utils.delete_file(os.path.splitext(_)[0]+".ms_data.hdf")
     if workflow["create_database"]:
         steps.append(create_database)
     if workflow["import_raw_data"]:
diff --git a/alphapept/menu.py b/alphapept/menu.py
deleted file mode 100644
index cf84043f..00000000
--- a/alphapept/menu.py
+++ /dev/null
@@ -1,742 +0,0 @@
-import streamlit as st
-import os
-import psutil
-import pandas as pd
-import yaml
-import time
-import matplotlib.pyplot as plt
-import alphapept.io
-from multiprocessing import Process
-from datetime import datetime
-from alphapept.settings import save_settings, load_settings_as_template
-import alphapept.interface
-import base64
-
-
-_this_file = os.path.abspath(__file__)
-_this_directory = os.path.dirname(_this_file)
-
-DEFAULT_SETTINGS_PATH = os.path.join(_this_directory, 'default_settings.yaml')
-SETTINGS_TEMPLATE_PATH = os.path.join(_this_directory, 'settings_template.yaml')
-
-SETTINGS_TEMPLATE = load_settings_as_template(SETTINGS_TEMPLATE_PATH)
-
-HOME = os.path.expanduser("~")
-AP_PATH = os.path.join(HOME, "alphapept")
-QUEUE_PATH = os.path.join(HOME, "alphapept", "queue")
-PROCESSED_PATH = os.path.join(HOME, "alphapept", "finished")
-PROCESS_FILE = os.path.join(QUEUE_PATH, 'process')
-FILE_WATCHER_FILE = os.path.join(QUEUE_PATH, 'file_watcher')
-
-for folder in [AP_PATH, QUEUE_PATH, PROCESSED_PATH]:
-    if not os.path.isdir(folder):
-        os.mkdir(folder)
-
-def check_file_completion(file, minimum_file_size):
-
-    to_analyze = []
-
-    if file.endswith('.d'):
-        #Bruker
-        to_check = os.path.join(file, 'analysis.tdf_bin')
-    else:
-        to_check = file
-
-    filesize = os.path.getsize(to_check)
-
-    writing = True
-    while writing:
-        time.sleep(1)
-        new_filesize = os.path.getsize(to_check)
-        if filesize == new_filesize:
-            writing  = False
-        else:
-            filesize = new_filesize
-
-    if filesize/1024/1024 > minimum_file_size: #bytes, kbytes, mbytes
-        to_analyze.append(file)
-
-    return to_analyze
-
-def history():
-    """
-    Plot history of previous experiments
-    """
-    st.write("# History")
-    st.text(f'History allows to visualize summary information from multiple previous analysis.'
-    f'\nIt checks {PROCESSED_PATH} for *.yaml files.'
-    '\nFiles can be filtered to only include a subset.')
-
-    processed_files = [_ for _ in os.listdir(PROCESSED_PATH) if _.endswith('.yaml')]
-    with st.beta_expander(f"Processed files ({len(processed_files)})"):
-        st.table(processed_files)
-
-    filter = st.text_input('Filter')
-
-    if filter:
-        filtered = [_ for _ in processed_files if filter in _]
-    else:
-        filtered = processed_files
-
-    st.write(f"Remaining {len(filtered)} of {len(processed_files)} files.")
-    bar = st.progress(0)
-
-    all_results = {}
-
-    for idx, _ in enumerate(filtered):
-        with open(os.path.join(PROCESSED_PATH, _), "r") as settings_file:
-            results = yaml.load(settings_file, Loader=yaml.FullLoader)
-
-            all_results[_] = results
-
-        bar.progress((idx+1)/len(filtered))
-
-    if len(all_results) > 0:
-        options = ['timing', 'feature_table','protein_fdr']
-
-        plots = st.multiselect('Plots', options = options, default=options)
-
-        with st.spinner('Creating plots..'):
-            for plot in plots:
-                plot_dict = {} # summary_time
-                if plot == 'timing':
-                    for _ in all_results.keys():
-                        plot_dict[_] = all_results[_]["summary"]["timing"]["total"]
-                else:
-                    for _ in all_results.keys():
-                        file = os.path.splitext(all_results[_]['summary']['processed_files'][0])[0]
-                        try:
-                            plot_dict[_] = all_results[_]["summary"][file][plot]
-                        except KeyError:
-                            plot_dict[_] = 0
-
-                fig = plt.figure(figsize=(10,3))
-                plt.bar(range(len(plot_dict)), list(plot_dict.values()), align='center')
-                plt.xticks(range(len(plot_dict)), list(plot_dict.keys()), rotation='vertical')
-                plt.title(plot)
-                st.write(fig)
-
-
-        if False:
-            plot_dict[_] = results['summary']['timing'][field]
-
-            fig = plt.figure(figsize=(10,3))
-            plt.bar(range(len(plot_dict)), list(plot_dict.values()), align='center')
-            plt.xticks(range(len(plot_dict)), list(plot_dict.keys()))
-            plt.title(field)
-            st.write(fig)
-
-def queue_watcher():
-    """
-    Start the queue_watcher.
-    """
-    #This is in pool and should be reporting.
-    print(f'{datetime.now()} Started queue_watcher')
-
-    while True:
-        if os.path.isfile(PROCESS_FILE):
-            with open(PROCESS_FILE, "r") as process_file:
-                p = yaml.load(process_file, Loader=yaml.FullLoader)
-            p['init'] = True
-            with open(PROCESS_FILE, "w") as file:
-                yaml.dump(p, file, sort_keys=False)
-            break
-        else:
-            time.sleep(1)
-
-    while True:
-        queue_files = [_ for _ in os.listdir(QUEUE_PATH) if _.endswith('.yaml')]
-        print(f'{datetime.now()} queue_watcher running. {len(queue_files)} experiments to process.')
-
-        if len(queue_files) > 0:
-            file_path = os.path.join(QUEUE_PATH, queue_files[0])
-            settings = load_settings_as_template(file_path)
-
-            current_file = {}
-            current_file['started'] = datetime.now()
-            current_file['file'] = queue_files[0]
-
-            current_file_path = os.path.join(QUEUE_PATH, 'current_file')
-
-            with open(current_file_path, "w") as file:
-                yaml.dump(current_file, file, sort_keys=False)
-
-            logfile = os.path.join(PROCESSED_PATH, os.path.splitext(queue_files[0])[0]+'.log')
-            settings_ = alphapept.interface.run_complete_workflow(settings, progress=True, logfile = logfile)
-            save_settings(settings_, os.path.join(PROCESSED_PATH, queue_files[0]))
-            os.remove(file_path)
-
-            if os.path.isfile(current_file_path):
-                os.remove(current_file_path)
-
-        else:
-            time.sleep(15)
-
-
-def file_watcher(folder, settings_template, minimum_file_size, tag):
-    """
-    Start the file Watcher
-
-    """
-
-    from watchdog.observers import Observer
-    from watchdog.events import PatternMatchingEventHandler
-
-    patterns = "*"
-    ignore_patterns = ""
-    ignore_directories = False
-    case_sensitive = False
-    my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
-
-    def on_created(event):
-        print(f"{event.src_path} has been created!")
-
-        file = event.src_path
-
-        if tag != 'None':
-            if tag not in file:
-                return
-
-        if file.lower().endswith('.raw') or file.lower().endswith('.d'):
-
-            files = check_file_completion(file, minimum_file_size)
-
-            if len(files) > 0:
-                settings = settings_template.copy()
-                settings['experiment']['file_paths'] = files
-                new_file = os.path.splitext(os.path.split(file)[1])[0] + '.yaml'
-                settings['experiment']['results_path'] = os.path.splitext(file)[0] + '.yaml'
-                save_settings(settings, os.path.join(QUEUE_PATH, new_file))
-                print(f'{datetime.now()} Added {file}')
-
-    print(f'{datetime.now()} file watcher started.')
-
-
-    my_event_handler.on_created = on_created
-
-    go_recursively = True
-    my_observer = Observer()
-    my_observer.schedule(my_event_handler, folder, recursive=go_recursively)
-
-    while True:
-        if os.path.isfile(FILE_WATCHER_FILE):
-            with open(FILE_WATCHER_FILE, "r") as process_file:
-                p = yaml.load(process_file, Loader=yaml.FullLoader)
-            p['init'] = True
-            p['folder'] = folder
-            with open(FILE_WATCHER_FILE, "w") as file:
-                yaml.dump(p, file, sort_keys=False)
-            break
-        else:
-            time.sleep(1)
-
-    my_observer.start()
-    while True:
-        time.sleep(1)
-
-
-def start_process(target, process_file, args = None, verbose = True):
-    process = {}
-    now = datetime.now()
-    process['created'] = now
-    if args:
-        p = Process(target=target, args = args)
-    else:
-        p = Process(target=target)
-    p.start()
-    process['pid'] = p.pid
-
-    if verbose:
-        st.success(f'Started process PID {p.pid} at {now}')
-
-    with open(process_file, "w") as file:
-        yaml.dump(process, file, sort_keys=False)
-
-def check_process(process_path):
-    if os.path.isfile(process_path):
-        with open(process_path, "r") as process_file:
-            process = yaml.load(process_file, Loader=yaml.FullLoader)
-        last_pid = process['pid']
-
-        if 'init' in process:
-            p_init = process['init']
-        else:
-            p_init = False
-
-        if psutil.pid_exists(last_pid):
-            p_ = psutil.Process(last_pid)
-            with p_.oneshot():
-                p_name = p_.name()
-                status = p_.status()
-            return True, last_pid, p_name, status, p_init
-
-    return False, None, None, None, False
-
-
-def system():
-
-    st.write("# System")
-    st.text(f'This page shows system status and settings and allows to launch a file watcher.')
-    st.write('## General')
-
-    # Main Process
-    running, last_pid, p_name, status, p_init  = check_process(PROCESS_FILE)
-
-    if running:
-        st.success(f'PID {last_pid} - {p_name} - {status}')
-
-        if st.button('Stop'):
-            p_ = psutil.Process(last_pid)
-            p_.terminate()
-            st.success(f'Terminated {last_pid}')
-            raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
-    else:
-        st.warning('No running AlphaPept process found. Please start.')
-        if st.button('Start'):
-            start_process(target = queue_watcher, process_file= PROCESS_FILE)
-            raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
-
-
-    with st.beta_expander(f"System paths "):
-        st.code(f"queue \t\t {QUEUE_PATH}")
-        st.code(f"processed \t {PROCESSED_PATH}")
-
-    with st.beta_expander(f"File watcher "):
-        # FIleWatcher
-        running, last_pid, p_name, status, p_init  = check_process(FILE_WATCHER_FILE)
-
-        if running:
-            if p_init:
-                with open(FILE_WATCHER_FILE, "r") as process_file:
-                    process = yaml.load(process_file, Loader=yaml.FullLoader)
-                    path = process['folder']
-            else:
-                path = None
-            st.success(f'PID {last_pid} - {p_name} - {status} - {path}')
-
-            if st.button('Stop file watcher'):
-                p_ = psutil.Process(last_pid)
-                p_.terminate()
-                st.success(f'Terminated {last_pid}')
-                raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
-        else:
-            st.warning('No running FileWatcher process found. Please start.')
-
-        valid = True
-        st.write('AlphaPept can watch folders for new files and automatically add them to the processing queue.')
-
-        folder = st.text_input("Enter path to folder to watch.", os.getcwd())
-
-        if not os.path.isdir(folder):
-            st.error('Not a valid path.')
-            valid = False
-
-        minimum_size = st.slider("Minimum file size in MB. Files that are smaller will be ignored.", min_value=1, max_value = 10000, value=200)
-
-        tag = st.text_input("Enter tag to only select files with tag. Keep None for all files. ",'None')
-
-        settings_template = st.text_input("Enter path to a settings template:", DEFAULT_SETTINGS_PATH)
-        if not os.path.isfile(settings_template):
-            st.error('Not a valid path.')
-            valid = False
-        else:
-            settings_ = load_settings_as_template(settings_template)
-            st.success('Valid settings file.')
-            if st.checkbox('Show'):
-                st.write(settings_)
-
-        if valid:
-            start_watcher = st.button('Start file watcher ')
-            valid = False
-
-            if start_watcher:
-                start_process(target = file_watcher, process_file = FILE_WATCHER_FILE, args = (folder, settings_, minimum_size, tag), verbose = True)
-                raise st.script_runner.RerunException(st.script_request_queue.RerunData(None))
-
-
-
-
-def status():
-
-    st.write("# Status")
-    st.text(f'This page shows the status of the current analysis.\nSwitch to `New experiment` to define a new experiment')
-    status_msg = st.empty()
-
-    current_log = ''
-    log_txt = []
-
-    st.write("## Progress")
-
-    overall_txt = st.empty()
-
-    overall_txt.text('Overall: 0%')
-    overall = st.progress(0)
-
-    task = st.empty()
-    task.text('Current task: None')
-
-    current_p = st.empty()
-    current_p.text('Current progess: 0%')
-
-    current = st.progress(0)
-
-    last_log = st.empty()
-
-    st.write("## Hardware utilization")
-
-    st.text('Ram')
-    ram = st.progress(0)
-    st.text('CPU')
-    cpu = st.progress(0)
-
-    running, last_pid, p_name, status, queue_watcher_state = check_process(PROCESS_FILE)
-
-    if not running:
-        start_process(target = queue_watcher, process_file= PROCESS_FILE, verbose=False)
-        st.warning('Initializing Alphapept and waiting for process to start. Please refresh page in a couple of seconds.')
-    elif not queue_watcher_state:
-        st.warning('Initializing Alphapept and waiting for process to start. Please refresh page in a couple of seconds.')
-    else:
-        current_file = os.path.join(QUEUE_PATH, 'current_file')
-
-        with st.beta_expander(f"Full log "):
-            log_ = st.empty()
-
-        with st.beta_expander(f"Queue"):
-            queue_table = st.empty()
-
-        refresh = st.checkbox('Auto-Update Page')
-
-        while True:
-            if os.path.isfile(current_file):
-                with open(current_file, "r") as file:
-                    cf_ = yaml.load(file, Loader=yaml.FullLoader)
-
-                cf = cf_['file']
-                cf_start = cf_['started']
-                status_msg.success(f'Processing {cf}. Started at {cf_start}')
-
-                logfile = os.path.join(PROCESSED_PATH, os.path.splitext(cf)[0]+'.log')
-                if current_log != logfile:
-                    current_log = logfile
-                    log_txt = []
-                    f = open(logfile, "r")
-
-                for line in f.readlines():
-                    if '__progress_current' in line:
-                        current_p_ = float(line.split('__progress_current ')[1][:5])
-                        current.progress(current_p_)
-
-                        current_p.text(f'Current progress: {current_p_*100:.2f}%')
-                    elif '__progress_overall' in line:
-
-                        overall_p = float(line.split('__progress_overall ')[1][:5])
-                        overall.progress(overall_p)
-
-                        overall_txt.text(f'Overall: {overall_p*100:.2f}%')
-                    elif '__current_task' in line:
-                        task_ = line.strip('\n').split('__current_task ')[1]
-                        task.text(f'Current task: {task_}')
-                    else:
-                        log_txt.append(line)
-
-                    last_log.code(''.join(log_txt[-3:]))
-                    log_.code(''.join(log_txt))
-
-            ram.progress(1-psutil.virtual_memory().available/psutil.virtual_memory().total)
-            cpu.progress(psutil.cpu_percent()/100)
-
-            queue_files = [_ for _ in os.listdir(QUEUE_PATH) if _.endswith('.yaml')]
-            n_queue = len(queue_files)
-
-            if n_queue == 0:
-                status_msg.success(f'{datetime.now().strftime("%d.%m.%Y %H:%M:%S")} No files to process. Please add new experiments.')
-                current.progress(0)
-                overall.progress(0)
-                overall_txt.text('Overall: 0%')
-                task.text('None')
-
-                queue_table.table(pd.DataFrame())
-
-            else:
-                created = [time.ctime(os.path.getctime(os.path.join(QUEUE_PATH, _))) for _ in queue_files]
-                queue_df = pd.DataFrame(queue_files, columns = ['File'])
-                queue_df['Created'] = created
-
-                queue_table.table(queue_df)
-
-            time.sleep(0.2)
-
-            if not refresh:
-                break
-
-def get_table_download_link(df, name):
-    """Generates a link allowing the data in a given panda dataframe to be downloaded
-    in:  dataframe
-    out: href string
-    """
-    csv = df.to_csv(index=False)
-    b64 = base64.b64encode(
-        csv.encode()
-    ).decode()  # some strings <-> bytes conversions necessary here
-
-    href = f'<a href="data:file/csv;base64,{b64}" download="%{name}" >Download as *.csv</a>'
-    st.markdown('')
-    st.markdown(href, unsafe_allow_html=True)
-
-
-def result():
-    st.write("# Results")
-
-    st.text("This page allows to explore the analysis results.\nAlphaPept uses the HDF container format which can be accessed here.")
-
-    #TOdo: include previously processed output files..
-
-    selection = st.selectbox('File selection', ('Previous results', 'Enter file'))
-
-    file = ''
-
-    if selection == 'Previous results':
-        results_files = [_ for _ in os.listdir(PROCESSED_PATH) if _.endswith('.yaml')]
-
-        results_files.sort()
-
-        results_files = results_files[::-1]
-
-
-        with st.beta_expander(f"Total {len(results_files)} Files"):
-            st.table(results_files)
-
-        st.write('### Select results file')
-
-        selection = st.selectbox('Run', results_files)
-
-        if selection:
-
-            with open(os.path.join(PROCESSED_PATH, selection), "r") as settings_file:
-                results = yaml.load(settings_file, Loader=yaml.FullLoader)
-
-            with st.beta_expander(f"Run summary"):
-                st.write(results['summary'])
-
-            log_path = os.path.join(PROCESSED_PATH, os.path.splitext(selection)[0]+'.log')
-
-            if os.path.isfile(log_path):
-                with st.beta_expander(f"Run log"):
-                    with st.spinner('Parsing file'):
-                        with open(log_path, "r") as logfile:
-                            lines = logfile.readlines()
-                            lines = [_ for _ in lines if '__' not in _]
-                            st.code(''.join(lines))
-
-            raw_files = [os.path.splitext(_)[0]+'.ms_data.hdf' for _ in results['experiment']['file_paths']]
-
-            #TODO: add results.hdf file
-            raw_files = raw_files + [results['experiment']['results_path']]
-
-            raw_files = [_ for _ in raw_files if os.path.exists(_)]
-
-            st.write('### Select file from Experiment')
-            file = st.selectbox('Select file from experiment', raw_files)
-
-    elif selection == 'Enter file':
-        file = st.text_input("Enter path to hdf file.", os.getcwd())
-    else:
-        file = ''
-
-    if file is None:
-        file = ''
-
-    if not os.path.isfile(file):
-        st.warning('Not a valid file.')
-    else:
-        with st.spinner('Parsing file'):
-
-            pandas_hdf = False
-
-            try:
-                ms_file = alphapept.io.MS_Data_File(file)
-                options = [_ for _ in ms_file.read() if _ != "Raw"]
-            except KeyError:
-                pandas_hdf = True
-
-                with pd.HDFStore(file) as hdf:
-                    options = list(hdf.keys())
-
-            opt = st.selectbox('Select group', [None] + options)
-            if opt is not None:
-                if pandas_hdf:
-                    df = pd.read_hdf(file, opt)
-                else:
-                    df = ms_file.read(dataset_name = opt)
-
-                range = st.slider('Data range', 0, len(df), (0,1000))
-                st.write(df.iloc[range[0]:range[1]])
-                if st.checkbox('Create download link'):
-                    if not isinstance(df, pd.DataFrame):
-                        df = pd.DataFrame(df)
-
-                    file_name = os.path.splitext(os.path.split(file)[-1])[0] + '.csv'
-                    get_table_download_link(df, file_name)
-
-def parse_folder(file_folder):
-    """
-
-    """
-    raw_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.raw') or _.lower().endswith('.d')]
-    fasta_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.fasta')]
-    db_files = [_ for _ in os.listdir(file_folder) if _.lower().endswith('.db_data.hdf')]
-
-    return raw_files, fasta_files, db_files
-
-
-def widget_from_setting(recorder, key, group, element, override=None):
-    """
-    e.g. key = General
-
-    """
-
-    _ = group[element]
-
-    if key not in recorder:
-        recorder[key] = {}
-
-    if 'description' in _:
-        help = _['description']
-    else:
-        help = ''
-
-    value = _['default']
-
-    if override:
-        value = override
-
-    if _['type'] == 'doublespinbox':
-        recorder[key][element] = st.slider(element, min_value = float(_['min']), max_value = float(_['max']), value = float(value), help = help)
-    elif _['type'] == 'spinbox':
-        recorder[key][element] = st.slider(element, min_value = _['min'], max_value = _['max'], value = value, help = help)
-    elif _['type'] == 'checkbox':
-        recorder[key][element] = st.checkbox(element, value = value, help = help)
-    elif _['type'] == 'checkgroup':
-        opts = list(_['value'].keys())
-        recorder[key][element] = st.multiselect(label = element, options = opts, default = value, help = help)
-    elif _['type'] == 'combobox':
-        recorder[key][element] = st.selectbox(label = element, options = _['value'], index = _['value'].index(value),  help = help)
-    else:
-        st.write(f"Not understood {_}")
-
-    return recorder
-
-
-def experiment():
-    st.write(f"# New experiment")
-    st.write(f'## Files')
-
-    recorder = {}
-    recorder['experiment'] = {}
-
-    #files = file_selector()
-    cwd = os.getcwd()
-    file_folder = st.text_input("Enter path to folder that contains all experimental files. AlphaPept will parse for raw (.d / .raw), FASTA and AlphaPept database (.db_files.hdf) files and add them to the experiment.", cwd)
-
-    if not os.path.isdir(file_folder):
-        st.warning('Not a valid folder.')
-    else:
-        with st.spinner('Parsing folder'):
-            raw_files, fasta_files, db_files = parse_folder(file_folder)
-
-            recorder['experiment']['fasta_paths'] = [os.path.join(file_folder, _) for _ in fasta_files]
-            recorder['experiment']['file_paths'] = [os.path.join(file_folder, _) for _ in raw_files]
-
-
-            if (len(raw_files) == 0) or (len(fasta_files) == 0):
-                if (len(raw_files) == 0) and (len(fasta_files) == 0):
-                    st.warning('No raw and FASTA files in folder.')
-                elif len(raw_files) == 0:
-                    st.warning('No raw files in folder.')
-                elif len(fasta_files) == 0:
-                    st.warning('No fasta files in folder.')
-
-            else:
-                with st.beta_expander(f"Raw files ({len(raw_files)})"):
-                    st.table(pd.DataFrame(raw_files, columns=['File']))
-
-                if len(fasta_files) > 0:
-                    with st.beta_expander(f"FASTA files ({len(fasta_files)})"):
-                        st.table(pd.DataFrame(fasta_files, columns=['File']))
-
-                #TODO: Include databse files
-                #if len(fasta_files) > 0:
-                #    with st.beta_expander(f"FASTA files ({len(fasta_files)})"):
-                #        st.table(pd.DataFrame(fasta_files, columns=['File']))
-
-                with st.beta_expander("Fractions"):
-                    st.write('Fractions can be automatically assigned based on the filename.',
-                            'Enter the string that preceds the fraction identifier and the string that comes after.')
-                    prec = st.text_input('Preceding')
-                    after = st.text_input('After')
-
-                    if st.button('Apply'):
-                        with st.spinner('Parsing folder'):
-                            files = pd.DataFrame(raw_files, columns=['File'])
-                            files['Fraction'] = files['File'].apply(lambda x: x.split(prec)[1].split(after)[0])
-                            st.table(files)
-
-                st.write(f"## Workflow")
-
-                with st.beta_expander("Steps"):
-                    group = SETTINGS_TEMPLATE['workflow']
-                    for element in group:
-                        recorder = widget_from_setting(recorder, 'workflow', group, element)
-
-                st.write(f"## Additional settings")
-
-                prev_settings = st.checkbox('Use previous settings as template')
-
-                loaded = False
-                if prev_settings:
-                    uploaded_file = st.file_uploader("Choose a file")
-                    if uploaded_file is not None:
-                        uploaded_settings =  yaml.load(uploaded_file, Loader=yaml.FullLoader)
-                        loaded=True
-
-                with st.beta_expander("Settings", loaded):
-                    for key in SETTINGS_TEMPLATE.keys():
-                        if key not in ['experiment', 'workflow']:
-                            group = SETTINGS_TEMPLATE[key]
-
-                            #Check if different than default
-                            if loaded:
-                                changed = sum([uploaded_settings[key][element] != group[element]['default'] for element in group]) > 0
-                            else:
-                                changed = False
-
-                            if st.checkbox(key, changed):
-                                for element in group:
-                                    override = None
-                                    if changed:
-                                        if uploaded_settings[key][element] != group[element]['default']:
-                                            override = uploaded_settings[key][element]
-
-                                    recorder = widget_from_setting(recorder, key, group, element, override)
-
-
-                name = st.text_input('Enter experiment name and press enter.')
-
-                if name:
-                    long_name = datetime.today().strftime('%Y_%m_%d_') + name + '.yaml'
-                    long_name_path = os.path.join(QUEUE_PATH, long_name)
-
-                    if os.path.exists(long_name_path):
-                        st.error(f'Name {long_name} already exists. Please rename.')
-                    else:
-                        st.info(f'Filename will be: {long_name}. Click submit button to add to queue.')
-                        if st.button('Submit'):
-                            settings = load_settings_as_template(DEFAULT_SETTINGS_PATH)
-                            for group in recorder:
-                                for key in recorder[group]:
-                                    settings[group][key] = recorder[group][key]
-
-                            save_settings(settings, long_name_path)
-                            #Change things from experiment
-                            st.success(f'Experiment {long_name} submitted. Switch to Status tab to track progress.')
diff --git a/alphapept/paths.py b/alphapept/paths.py
new file mode 100644
index 00000000..677c2a4e
--- /dev/null
+++ b/alphapept/paths.py
@@ -0,0 +1,23 @@
+import os
+from alphapept.settings import load_settings_as_template, load_settings
+
+_this_file = os.path.abspath(__file__)
+_this_directory = os.path.dirname(_this_file)
+
+DEFAULT_SETTINGS_PATH = os.path.join(_this_directory, 'default_settings.yaml')
+SETTINGS_TEMPLATE_PATH = os.path.join(_this_directory, 'settings_template.yaml')
+
+SETTINGS_TEMPLATE = load_settings(SETTINGS_TEMPLATE_PATH)
+DEFAULT_SETTINGS = load_settings_as_template(DEFAULT_SETTINGS_PATH)
+
+HOME = os.path.expanduser("~")
+AP_PATH = os.path.join(HOME, "alphapept")
+QUEUE_PATH = os.path.join(HOME, "alphapept", "queue")
+PROCESSED_PATH = os.path.join(HOME, "alphapept", "finished")
+FAILED_PATH = os.path.join(HOME, "alphapept", "failed")
+PROCESS_FILE = os.path.join(QUEUE_PATH, 'process')
+FILE_WATCHER_FILE = os.path.join(QUEUE_PATH, 'file_watcher')
+
+for folder in [AP_PATH, QUEUE_PATH, PROCESSED_PATH, FAILED_PATH]:
+    if not os.path.isdir(folder):
+        os.mkdir(folder)
diff --git a/alphapept/settings_template.yaml b/alphapept/settings_template.yaml
index 159cf02d..a9c4d25b 100644
--- a/alphapept/settings_template.yaml
+++ b/alphapept/settings_template.yaml
@@ -1,4 +1,9 @@
 workflow:
+  continue_runs:
+    type: checkbox
+    default: false
+    description: Flag to continue previously computated runs. If False existing ms_data
+      will be deleted.
   create_database:
     type: checkbox
     default: true
@@ -285,12 +290,12 @@ features:
   max_gap:
     type: spinbox
     min: 1
-    max: 99
+    max: 10
     default: 2
   ppm_tol:
     type: spinbox
     min: 1
-    max: 99
+    max: 25
     default: 8
   min_hill_length:
     type: spinbox
diff --git a/alphapept/utils.py b/alphapept/utils.py
index 78caf99e..10a01c8d 100644
--- a/alphapept/utils.py
+++ b/alphapept/utils.py
@@ -300,3 +300,8 @@ def assemble_df(settings, field = 'protein_fdr', callback=None):
         xx = pd.DataFrame()
 
     return xx
+
+def delete_file(filename):
+    if os.path.isfile(filename):
+        os.remove(filename)
+        logging.info(f'Deleted {filename}')
diff --git a/alphapept/webui.py b/alphapept/webui.py
index f461138e..030a0919 100644
--- a/alphapept/webui.py
+++ b/alphapept/webui.py
@@ -1,5 +1,5 @@
 import streamlit as st
-from menu import experiment, status, result, history, system
+from alphapept.gui import history, results, filewatcher, status, experiment
 from PIL import Image
 from alphapept.__version__ import VERSION_NO
 import os
@@ -22,11 +22,11 @@
 st.sidebar.image(image, width = 300)
 st.sidebar.code(f"AlphaPept {VERSION_NO} \n{computer_name}")
 
-sidebar = {'Status': status,
-           'New experiment': experiment,
-           'Results': result,
-           'History': history,
-           'System': system}
+sidebar = {'Status': status.status,
+           'New experiment': experiment.experiment,
+           'Results': results.results,
+           'History': history.history,
+           'FileWatcher': filewatcher.filewatcher}
 
 menu = st.sidebar.radio("", list(sidebar.keys()))
 
diff --git a/centroids.pkl b/centroids.pkl
deleted file mode 100644
index 8036f9c3..00000000
Binary files a/centroids.pkl and /dev/null differ
diff --git a/default_settings.yaml b/default_settings.yaml
deleted file mode 100644
index dd835049..00000000
--- a/default_settings.yaml
+++ /dev/null
@@ -1,87 +0,0 @@
-workflow:
-  create_database: true
-  import_raw_data: true
-  find_features: true
-  search_data: true
-  recalibrate_data: true
-  align: true
-  match: false
-  lfq_quantification: true
-general:
-  n_processes: 60
-experiment:
-  results_path: null
-  shortnames: []
-  file_paths: []
-  fractions: []
-  database_path: null
-  fasta_paths: []
-raw:
-  most_abundant: 400
-  use_profile_ms1: false
-fasta:
-  mods_fixed:
-  - cC
-  mods_fixed_terminal: []
-  mods_variable:
-  - oxM
-  mods_variable_terminal: []
-  mods_fixed_terminal_prot: []
-  mods_variable_terminal_prot: []
-  num_missed_cleavages: 2
-  min_length: 6
-  max_length: 27
-  max_isoforms: 1024
-  pseudo_reverse: true
-  AL_swap: false
-  KR_swap: false
-  protease: trypsin
-  spectra_block: 100000
-  fasta_block: 1000
-  save_db: true
-  max_fasta_size: 100
-features:
-  max_gap: 2
-  ppm_tol: 8
-  min_hill_length: 3
-  split_level: 1.3
-  smoothing_window: 1
-  large_peak: 40
-  min_charge: 1
-  max_charge: 6
-  seed_masses: 100
-  hill_nboot_max: 300
-  hill_nboot: 150
-  mass_range: 5
-  min_correlation: 0.6
-  ppm_range: 20
-  rt_range: 0.5
-  mob_range: 0.3
-  n_neighbors: 5
-  search_unidentified: false
-search:
-  m_offset: 30
-  m_tol: 30
-  min_frag_hits: 7
-  ppm: true
-  calibrate: true
-  calibration_std: 3
-  parallel: true
-  peptide_fdr: 0.01
-  protein_fdr: 0.01
-  recalibration_min: 100
-score:
-  method: random_forest
-calibration:
-  outlier_std: 3
-  n_neighbors: 100
-  ppm_range: 20
-  rt_range: 0.5
-  mob_range: 0.3
-matching:
-  min_match_p: 0.05
-  min_match_d: 3
-quantification:
-  max_lfq: true
-  lfq_minimum_ratio: 1
-  mode: int_sum
diff --git a/installer/one_click_windows/alphapept_innoinstaller.iss b/installer/one_click_windows/alphapept_innoinstaller.iss
index 7a1f11e8..45899261 100644
--- a/installer/one_click_windows/alphapept_innoinstaller.iss
+++ b/installer/one_click_windows/alphapept_innoinstaller.iss
@@ -2,7 +2,7 @@
 ; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
 
 #define MyAppName "AlphaPept"
-#define MyAppVersion "0.3.19-dev0"
+#define MyAppVersion "0.3.20-dev0"
 #define MyAppPublisher "MannLabs"
 #define MyAppURL "https://github.com/MannLabs/alphapept"
 #define MyAppExeName "alphapept.exe"
diff --git a/installer/one_click_windows/create_installer_windows.bat b/installer/one_click_windows/create_installer_windows.bat
index 2d876038..c859d001 100644
--- a/installer/one_click_windows/create_installer_windows.bat
+++ b/installer/one_click_windows/create_installer_windows.bat
@@ -1,13 +1,19 @@
-DEL /F/Q/S build > NUL
-DEL /F/Q/S dist > NUL
-RMDIR /Q/S build
-RMDIR /Q/S dist
+call DEL /F/Q/S build > NUL
+call DEL /F/Q/S dist > NUL
+call RMDIR /Q/S build
+call RMDIR /Q/S dist
 call conda env remove -n alphapeptinstaller
-call conda create -n alphapeptinstaller python=3.8 pip=20.2 -y
+call conda create -n alphapeptinstaller python=3.8 -y
 call conda activate alphapeptinstaller
-call pip install ../../.
-call pip install -r ../../requirements.txt
-call pip install pyinstaller
+call cd ../..
+call DEL /F/Q/S build > NUL
+call DEL /F/Q/S dist > NUL
+call RMDIR /Q/S build
+call RMDIR /Q/S dist
+call python setup.py sdist bdist_wheel
+call pip install dist/alphapept-0.3.20.dev0-py3-none-any.whl
+call pip install pyinstaller==4.2
+call cd installer/one_click_windows
 call pyinstaller ../alphapept.spec -y
 call conda deactivate
 call "C:\Program Files (x86)\Inno Setup 6\ISCC.exe" alphapept_innoinstaller.iss
diff --git a/installer/one_click_windows/create_pyinstaller_windows.bat b/installer/one_click_windows/create_pyinstaller_windows.bat
deleted file mode 100644
index 5f2d7c67..00000000
--- a/installer/one_click_windows/create_pyinstaller_windows.bat
+++ /dev/null
@@ -1,12 +0,0 @@
-DEL /F/Q/S build > NUL
-DEL /F/Q/S dist > NUL
-RMDIR /Q/S build
-RMDIR /Q/S dist
-call conda env remove -n alphapeptinstaller
-call conda create -n alphapeptinstaller python=3.8 pip=20.2 -y
-call conda activate alphapeptinstaller
-call pip install ../../.
-call pip install -r ../../requirements.txt
-call pip install pyinstaller
-call pyinstaller ../alphapept.spec -y
-call conda deactivate
diff --git a/nbs/00_settings.ipynb b/nbs/00_settings.ipynb
index 100281e3..49fe2416 100644
--- a/nbs/00_settings.ipynb
+++ b/nbs/00_settings.ipynb
@@ -141,6 +141,7 @@
     "# Workflow\n",
     "workflow = {}\n",
     "\n",
+    "workflow[\"continue_runs\"] = {'type':'checkbox', 'default':False, 'description':\"Flag to continue previously computated runs. If False existing ms_data will be deleted.\"}\n",
     "workflow[\"create_database\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to create a database.\"}\n",
     "workflow[\"import_raw_data\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to import the raw data.\"}\n",
     "workflow[\"find_features\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to perform feature finding.\"}\n",
@@ -166,6 +167,11 @@
       "  default: true\n",
       "  description: Flag to align the data.\n",
       "  type: checkbox\n",
+      "continue_runs:\n",
+      "  default: false\n",
+      "  description: Flag to continue previously computated runs. If False existing ms_data\n",
+      "    will be deleted.\n",
+      "  type: checkbox\n",
       "create_database:\n",
       "  default: true\n",
       "  description: Flag to create a database.\n",
@@ -662,8 +668,8 @@
     "features = {}\n",
     "# Thermo FF settings\n",
     "\n",
-    "features[\"max_gap\"] = {'type':'spinbox', 'min':1, 'max':99, 'default':2}\n",
-    "features[\"ppm_tol\"] = {'type':'spinbox', 'min':1, 'max':99, 'default':8}\n",
+    "features[\"max_gap\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':2}\n",
+    "features[\"ppm_tol\"] = {'type':'spinbox', 'min':1, 'max':25, 'default':8}\n",
     "features[\"min_hill_length\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':3}\n",
     "features[\"split_level\"] = {'type':'doublespinbox', 'min':0.1, 'max':10.0, 'default':1.3}\n",
     "features[\"smoothing_window\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':1}\n",
@@ -725,7 +731,7 @@
       "  type: spinbox\n",
       "max_gap:\n",
       "  default: 2\n",
-      "  max: 99\n",
+      "  max: 10\n",
       "  min: 1\n",
       "  type: spinbox\n",
       "min_charge:\n",
@@ -760,7 +766,7 @@
       "  type: spinbox\n",
       "ppm_tol:\n",
       "  default: 8\n",
-      "  max: 99\n",
+      "  max: 25\n",
       "  min: 1\n",
       "  type: spinbox\n",
       "rt_range:\n",
diff --git a/nbs/11_interface.ipynb b/nbs/11_interface.ipynb
index 8f447adb..bdf9a564 100644
--- a/nbs/11_interface.ipynb
+++ b/nbs/11_interface.ipynb
@@ -752,6 +752,7 @@
     "from time import time, sleep\n",
     "from alphapept.__version__ import VERSION_NO\n",
     "import datetime\n",
+    "import alphapept.utils\n",
     "\n",
     "\n",
     "def get_file_summary(ms_data):\n",
@@ -833,6 +834,10 @@
     "    \n",
     "    workflow = settings['workflow']\n",
     "    \n",
+    "    if \"continue_runs\" in workflow:\n",
+    "        if not workflow[\"continue_runs\"]:\n",
+    "            for _ in settings['experiment']['file_paths']:\n",
+    "                alphapept.utils.delete_file(os.path.splitext(_)[0]+\".ms_data.hdf\")\n",
     "    if workflow[\"create_database\"]:\n",
     "        steps.append(create_database)\n",
     "    if workflow[\"import_raw_data\"]:\n",
diff --git a/requirements.txt b/requirements.txt
index 6c0f0178..5fd7fe9f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -20,3 +20,4 @@ fastcore==1.3.5
 nbdev==1.1.5
 click==7.1.2
 streamlit==0.80.0
+plotly_express==0.4.0
diff --git a/Systems_check.ipynb b/sandbox/Systems_check.ipynb
similarity index 100%
rename from Systems_check.ipynb
rename to sandbox/Systems_check.ipynb
diff --git a/sandbox/Test_Run.ipynb b/sandbox/Test_Run.ipynb
new file mode 100644
index 00000000..4d4609b2
--- /dev/null
+++ b/sandbox/Test_Run.ipynb
@@ -0,0 +1,782 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AlphaPept Test Runs and Visualization Examples\n",
+    "\n",
+    "This notebooks is intended to show how a HeLa File can be processed."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download Test Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "try:\n",
+    "    import wget\n",
+    "except ModuleNotFoundError:\n",
+    "    !pip install wget\n",
+    "    import wget\n",
+    "    \n",
+    "FILE_DICT = {}\n",
+    "FILE_DICT['thermo_IRT.raw'] = 'https://datashare.biochem.mpg.de/s/GpXsATZtMwgQoQt/download'\n",
+    "FILE_DICT['IRT_fasta.fasta'] = 'https://datashare.biochem.mpg.de/s/p8Qu3KolzbSiCHH/download'\n",
+    "\n",
+    "tmp_folder = os.path.join(os.getcwd(),'/temp')\n",
+    "\n",
+    "if not os.path.isdir(tmp_folder):\n",
+    "    os.mkdir(tmp_folder)\n",
+    "    \n",
+    "for file in FILE_DICT:\n",
+    "    target = os.path.join(tmp_folder, file)\n",
+    "    if not os.path.isfile(target):\n",
+    "        wget.download(FILE_DICT[file], target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test Run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:22:23> Logging to C:\\Users\\admin\\alphapept\\logs\\log_20210503152223.txt.\n",
+      "2021-05-03 15:22:23> Platform information:\n",
+      "2021-05-03 15:22:23> system     - Windows\n",
+      "2021-05-03 15:22:23> release    - 10\n",
+      "2021-05-03 15:22:23> version    - 10.0.18362\n",
+      "2021-05-03 15:22:23> machine    - AMD64\n",
+      "2021-05-03 15:22:23> processor  - Intel64 Family 6 Model 85 Stepping 4, GenuineIntel\n",
+      "2021-05-03 15:22:23> cpu count  - 24\n",
+      "2021-05-03 15:22:23> ram memory - 115.4/127.7 Gb (available/total)\n",
+      "2021-05-03 15:22:23> \n",
+      "2021-05-03 15:22:23> Python information:\n",
+      "2021-05-03 15:22:23> PyQt5             - 5.15.2\n",
+      "2021-05-03 15:22:23> SQLAlchemy        - 1.3.22\n",
+      "2021-05-03 15:22:23> alphapept         - 0.3.19-dev0\n",
+      "2021-05-03 15:22:23> biopython         - 1.78\n",
+      "2021-05-03 15:22:23> click             - 7.1.2\n",
+      "2021-05-03 15:22:23> comtypes          - 1.1.7\n",
+      "2021-05-03 15:22:23> fastcore          - 1.3.5\n",
+      "2021-05-03 15:22:23> h5py              - 3.1.0\n",
+      "2021-05-03 15:22:23> lxml              - 4.6.2\n",
+      "2021-05-03 15:22:23> matplotlib        - 3.3.3\n",
+      "2021-05-03 15:22:23> nbdev             - 1.1.5\n",
+      "2021-05-03 15:22:23> networkx          - 2.5\n",
+      "2021-05-03 15:22:23> numba             - 0.52.0\n",
+      "2021-05-03 15:22:23> numpy             - 1.19.4\n",
+      "2021-05-03 15:22:23> pandas            - 1.2.1\n",
+      "2021-05-03 15:22:23> psutil            - 5.8.0\n",
+      "2021-05-03 15:22:23> python            - 3.8.8\n",
+      "2021-05-03 15:22:23> pythonnet         - 2.5.1\n",
+      "2021-05-03 15:22:23> pyyaml            - 5.3.1\n",
+      "2021-05-03 15:22:23> qdarkstyle        - 2.8.1\n",
+      "2021-05-03 15:22:23> qroundprogressbar - 1.0.0\n",
+      "2021-05-03 15:22:23> scikit-learn      - 0.23.2\n",
+      "2021-05-03 15:22:23> scipy             - 1.6.0\n",
+      "2021-05-03 15:22:23> seaborn           - 0.11.1\n",
+      "2021-05-03 15:22:23> tables            - 3.6.1\n",
+      "2021-05-03 15:22:23> tqdm              - 4.56.0\n",
+      "2021-05-03 15:22:23> \n",
+      "2021-05-03 15:22:23> Check for settings not completely implemented yet.\n",
+      "2021-05-03 15:22:23> Checking if files exist.\n",
+      "2021-05-03 15:22:23> Results path was not set. Setting to F:\\temp\\results.hdf\n",
+      "2021-05-03 15:22:23> Shortnames not set. Setting to filename.\n",
+      "2021-05-03 15:22:23> No database path set and save_db option checked. Using default path F:\\temp\\database.hdf\n",
+      "2021-05-03 15:22:23> Deleted {filename}\n",
+      "2021-05-03 15:22:23> Workflow has 10 steps\n",
+      "2021-05-03 15:22:24> Database path set and exists. Using F:\\temp\\database.hdf as database.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:22:24> Processing 1 files for step raw_conversion\n",
+      "2021-05-03 15:22:24> File F:/temp\\thermo_IRT has extension .raw - converting from Thermo.\n",
+      "2021-05-03 15:22:27> File conversion complete. Extracted 2,603 precursors.\n",
+      "2021-05-03 15:22:27> File conversion of file F:/temp\\thermo_IRT.raw complete.\n",
+      "2021-05-03 15:22:27> init\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                            | 0/1 [00:05<?, ?it/s]\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:22:29> Processing 1 files for step find_features\n",
+      "2021-05-03 15:22:29> No *.hdf file with features found for F:/temp\\thermo_IRT.ms_data.hdf. Adding to feature finding list.\n",
+      "2021-05-03 15:22:29> Feature finding on F:/temp\\thermo_IRT.raw\n",
+      "2021-05-03 15:22:31> Number of hills 45,516, len = 20.18\n",
+      "2021-05-03 15:22:31> Repeating hill extraction with ppm_tol 5.10\n",
+      "2021-05-03 15:22:32> Number of hills 52,919, len = 21.29\n",
+      "2021-05-03 15:22:37> After split hill_ptrs 79,545\n",
+      "2021-05-03 15:22:38> After filter hill_ptrs 77,220\n",
+      "2021-05-03 15:22:52> Extracting hill stats complete\n",
+      "2021-05-03 15:22:54> Found 7,527 pre isotope patterns.\n",
+      "2021-05-03 15:23:09> Extracted 7,578 isotope patterns.\n",
+      "2021-05-03 15:23:16> Report complete.\n",
+      "2021-05-03 15:23:16> Matching features to query data.\n",
+      "2021-05-03 15:23:16> Note: NumExpr detected 24 cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.\n",
+      "2021-05-03 15:23:16> NumExpr defaulting to 8 threads.\n",
+      "2021-05-03 15:23:16> Saving feature table.\n",
+      "2021-05-03 15:23:16> Feature table saved to F:/temp\\thermo_IRT.ms_data.hdf\n",
+      "2021-05-03 15:23:16> Saving features.\n",
+      "2021-05-03 15:23:16> Feature finding of file F:/temp\\thermo_IRT.raw complete.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:16> Starting first search.\n",
+      "2021-05-03 15:23:16> Processing 1 files for step search_db\n",
+      "2021-05-03 15:23:16> Calibrating fragments\n",
+      "2021-05-03 15:23:17> Performing search on 1,533 query and 40 db entries with m_tol = 30.00 and m_offset = 30.00.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                            | 0/1 [00:49<?, ?it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:21> Compared 128 spectra and found 27 psms.\n",
+      "2021-05-03 15:23:21> Extracting columns for scoring.\n",
+      "2021-05-03 15:23:27> Extracted columns from 27 spectra.\n",
+      "2021-05-03 15:23:27> Saving first_search results to F:/temp\\thermo_IRT.ms_data.hdf\n",
+      "2021-05-03 15:23:27> Search of file F:/temp\\thermo_IRT.raw complete.\n",
+      "2021-05-03 15:23:27> First search complete.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:27> Processing 1 files for step calibrate_hdf\n",
+      "2021-05-03 15:23:27> Scoring using X-Tandem\n",
+      "2021-05-03 15:23:27> Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
+      "2021-05-03 15:23:27> 11 target (0 decoy) of 11 PSMs. fdr 0.000000 for a cutoff of 16.81 (set fdr was 0.01)\n",
+      "2021-05-03 15:23:27> Not enough data points present. Skipping recalibration.\n",
+      "2021-05-03 15:23:27> Calibration of file F:/temp\\thermo_IRT.ms_data.hdf complete.\n",
+      "2021-05-03 15:23:27> Calibrating fragments\n",
+      "2021-05-03 15:23:27> Median fragment offset 10.91 - std 13.28 ppm\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:27> Starting second search with DB.\n",
+      "2021-05-03 15:23:27> Processing 1 files for step search_db\n",
+      "2021-05-03 15:23:27> Found calibrated m_offset with value 11.01\n",
+      "2021-05-03 15:23:27> Performing search on 1,533 query and 40 db entries with m_tol = 30.00 and m_offset = 11.01.\n",
+      "2021-05-03 15:23:27> Compared 128 spectra and found 24 psms.\n",
+      "2021-05-03 15:23:27> Extracting columns for scoring.\n",
+      "2021-05-03 15:23:27> Extracted columns from 24 spectra.\n",
+      "2021-05-03 15:23:27> Saving second_search results to F:/temp\\thermo_IRT.ms_data.hdf\n",
+      "2021-05-03 15:23:27> Search of file F:/temp\\thermo_IRT.raw complete.\n",
+      "2021-05-03 15:23:27> Second search complete.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A\u001b[A\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:27> Processing 1 files for step score_hdf\n",
+      "2021-05-03 15:23:27> Found second search psms for scoring.\n",
+      "2021-05-03 15:23:28> Last q_value 0.000 of dataset is smaller than fdr_level 0.100\n",
+      "2021-05-03 15:23:28> 11 target (0 decoy) of 11 PSMs. fdr 0.000000 for a cutoff of 18.09 (set fdr was 0.1)\n",
+      "2021-05-03 15:23:28> The total number of available decoys is lower than the initial set of high scoring targets.\n",
+      "2021-05-03 15:23:28> ML failed. Defaulting to x_tandem score\n",
+      "2021-05-03 15:23:28> There are fewer high scoring targets or decoys than required by 'min_train'.\n",
+      "2021-05-03 15:23:28> Filter df with x_tandem score\n",
+      "2021-05-03 15:23:28> Global FDR on precursor\n",
+      "2021-05-03 15:23:28> Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
+      "2021-05-03 15:23:28> 8 target (0 decoy) of 8 PSMs. fdr 0.000000 for a cutoff of 18.09 (set fdr was 0.01)\n",
+      "2021-05-03 15:23:28> FDR on peptides complete. For 0.01 FDR found 11 targets and 0 decoys.\n",
+      "2021-05-03 15:23:28> Scoring of file F:/temp\\thermo_IRT.ms_data.hdf complete.\n",
+      "2021-05-03 15:23:28> Fasta dict with length 1, Pept dict with length 40\n",
+      "2021-05-03 15:23:28> Extracting protein groups.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A\u001b[A\u001b[A\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:28> A total of 1 proteins with unique PSMs found\n",
+      "2021-05-03 15:23:28> A total of 0 ambigious proteins\n",
+      "2021-05-03 15:23:28> A total of 0 proteins with unique PSMs found\n",
+      "2021-05-03 15:23:28> A total of 0 ambigious proteins\n",
+      "2021-05-03 15:23:28> Global FDR on protein\n",
+      "2021-05-03 15:23:28> Last q_value 0.000 of dataset is smaller than fdr_level 0.010\n",
+      "2021-05-03 15:23:28> 1 target (0 decoy) of 1 PSMs. fdr 0.000000 for a cutoff of 42.12 (set fdr was 0.01)\n",
+      "2021-05-03 15:23:28> FDR on proteins complete. For 0.01 FDR found 11 targets and 0 decoys. A total of 1 proteins found.\n",
+      "2021-05-03 15:23:28> Extracting ions\n",
+      "2021-05-03 15:23:28> Extracting ions complete.\n",
+      "2021-05-03 15:23:28> Saving complete.\n",
+      "2021-05-03 15:23:28> Protein groups complete.\n",
+      "2021-05-03 15:23:28> Only 1 dataset present. Skipping alignment.\n",
+      "2021-05-03 15:23:28> Assembling dataframe.\n",
+      "2021-05-03 15:23:28> Assembly complete.\n",
+      "2021-05-03 15:23:28> Complete. \n",
+      "2021-05-03 15:23:28> Starting profile extraction.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "  0%|                                                                                            | 0/1 [00:00<?, ?it/s]\u001b[A\u001b[A\u001b[A\u001b[A\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2021-05-03 15:23:28> LFQ complete.\n",
+      "2021-05-03 15:23:28> Exporting as csv.\n",
+      "2021-05-03 15:23:28> Saved df of length 11 saved to F:\\temp\\results\n",
+      "2021-05-03 15:23:29> Settings saved to F:\\temp\\results.yaml\n",
+      "2021-05-03 15:23:29> Analysis complete.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from alphapept.settings import load_settings\n",
+    "from alphapept.paths import DEFAULT_SETTINGS as settings\n",
+    "\n",
+    "settings['experiment']['file_paths'] =  [os.path.join(tmp_folder, 'thermo_IRT.raw')]\n",
+    "settings['experiment']['fasta_paths'] = [os.path.join(tmp_folder, 'IRT_fasta.fasta')]\n",
+    "    \n",
+    "import alphapept.interface\n",
+    "\n",
+    "settings_ = alphapept.interface.run_complete_workflow(settings)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic file access\n",
+    "\n",
+    "Files can be read via the alphapept.io class and displayed as pandas dataframe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Raw', 'corrected_fragment_mzs', 'feature_table', 'features', 'first_search', 'ions', 'peptide_fdr', 'protein_fdr', 'second_search']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>abs_delta_m_ppm</th>\n",
+       "      <th>b-H2O_hits</th>\n",
+       "      <th>b-NH3_hits</th>\n",
+       "      <th>b_hits</th>\n",
+       "      <th>charge</th>\n",
+       "      <th>db_idx</th>\n",
+       "      <th>decoy</th>\n",
+       "      <th>decoys_cum</th>\n",
+       "      <th>decoys_cum_protein</th>\n",
+       "      <th>delta_m</th>\n",
+       "      <th>...</th>\n",
+       "      <th>target</th>\n",
+       "      <th>target_cum</th>\n",
+       "      <th>target_cum_protein</th>\n",
+       "      <th>target_precursor</th>\n",
+       "      <th>target_protein</th>\n",
+       "      <th>total_int</th>\n",
+       "      <th>x_tandem</th>\n",
+       "      <th>y-H2O_hits</th>\n",
+       "      <th>y-NH3_hits</th>\n",
+       "      <th>y_hits</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>8.414643</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>-0.003156</td>\n",
+       "      <td>...</td>\n",
+       "      <td>True</td>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>641633</td>\n",
+       "      <td>25.415767</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.972251</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>-0.000351</td>\n",
+       "      <td>...</td>\n",
+       "      <td>True</td>\n",
+       "      <td>8</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>635629</td>\n",
+       "      <td>18.091496</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2.986360</td>\n",
+       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>9</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>-0.001072</td>\n",
+       "      <td>...</td>\n",
+       "      <td>True</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>11149388</td>\n",
+       "      <td>42.123869</td>\n",
+       "      <td>6</td>\n",
+       "      <td>3</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>19.885189</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>3</td>\n",
+       "      <td>13</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.009802</td>\n",
+       "      <td>...</td>\n",
+       "      <td>True</td>\n",
+       "      <td>7</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>1404850</td>\n",
+       "      <td>18.537535</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>10.337601</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2</td>\n",
+       "      <td>13</td>\n",
+       "      <td>False</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.004405</td>\n",
+       "      <td>...</td>\n",
+       "      <td>True</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>True</td>\n",
+       "      <td>7453017</td>\n",
+       "      <td>37.531887</td>\n",
+       "      <td>7</td>\n",
+       "      <td>3</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 68 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   abs_delta_m_ppm  b-H2O_hits  b-NH3_hits  b_hits  charge  db_idx  decoy  \\\n",
+       "0         8.414643           0           0       3       2       0  False   \n",
+       "1         0.972251           0           1       2       2       2  False   \n",
+       "2         2.986360           3           2       6       2       9  False   \n",
+       "3        19.885189           0           0       3       3      13  False   \n",
+       "4        10.337601           1           0       4       2      13  False   \n",
+       "\n",
+       "   decoys_cum  decoys_cum_protein   delta_m  ...  target  target_cum  \\\n",
+       "0           0                   0 -0.003156  ...    True           4   \n",
+       "1           0                   0 -0.000351  ...    True           8   \n",
+       "2           0                   0 -0.001072  ...    True           1   \n",
+       "3           0                   0  0.009802  ...    True           7   \n",
+       "4           0                   0  0.004405  ...    True           2   \n",
+       "\n",
+       "   target_cum_protein  target_precursor  target_protein  total_int   x_tandem  \\\n",
+       "0                   1              True            True     641633  25.415767   \n",
+       "1                   1              True            True     635629  18.091496   \n",
+       "2                   1              True            True   11149388  42.123869   \n",
+       "3                   1              True            True    1404850  18.537535   \n",
+       "4                   1              True            True    7453017  37.531887   \n",
+       "\n",
+       "   y-H2O_hits  y-NH3_hits  y_hits  \n",
+       "0           1           2       8  \n",
+       "1           0           0       5  \n",
+       "2           6           3      12  \n",
+       "3           1           0       5  \n",
+       "4           7           3      12  \n",
+       "\n",
+       "[5 rows x 68 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import alphapept.io\n",
+    "\n",
+    "_ = settings['experiment']['file_paths'][0]\n",
+    "base, ext = os.path.splitext(_)\n",
+    "\n",
+    "ms_file = alphapept.io.MS_Data_File(base+'.ms_data.hdf')\n",
+    "\n",
+    "print(ms_file.read())\n",
+    "\n",
+    "df = ms_file.read(dataset_name='protein_fdr')\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## MS2 Spectrum\n",
+    "\n",
+    "Visualize PSMS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "100%|████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00,  4.96it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Plotting PSMS for LGGNEQVTR_2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Plotting PSMS for YILAGVENSK_2\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Plotting PSMS for GAGSSEPVTGLDAK_2\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    import matplotlib.pyplot as plt\n",
+    "except ModuleNotFoundError:\n",
+    "    !pip install matplotlib\n",
+    "    import matplotlib.pyplot as plt\n",
+    "\n",
+    "def plot_psms(precursor, ms_file):\n",
+    "\n",
+    "    df = ms_file.read(dataset_name='protein_fdr')\n",
+    "    \n",
+    "    ion_dict = {}\n",
+    "    ion_dict[0] = ''\n",
+    "    ion_dict[1] = '-H20'\n",
+    "    ion_dict[2] = '-NH3'\n",
+    "\n",
+    "    spectrum = df[df['precursor'] == precursor].iloc[0]\n",
+    "    start = spectrum['ion_idx']\n",
+    "    end = spectrum['n_ions'] + start\n",
+    "\n",
+    "    query_data = ms_file.read_DDA_query_data()\n",
+    "    ions = ms_file.read(dataset_name=\"ions\")\n",
+    "\n",
+    "    ion = [('b'+str(int(_))).replace('b-','y') for _ in ions.iloc[start:end]['ion_index']]\n",
+    "    losses = [ion_dict[int(_)] for _ in ions.iloc[start:end]['ion_type']]\n",
+    "    ion = [a+b for a,b in zip(ion, losses)]\n",
+    "    ints = ions.iloc[start:end]['ion_int'].astype('int').values\n",
+    "    masses = ions.iloc[start:end]['ion_mass'].astype('float').values\n",
+    "    ion_type = ions.iloc[start:end]['ion_type'].abs().values\n",
+    "\n",
+    "    query_idx = spectrum['raw_idx']\n",
+    "\n",
+    "    query_indices = query_data[\"indices_ms2\"]\n",
+    "    query_charges = query_data['charge2']\n",
+    "    query_frags = query_data['mass_list_ms2']\n",
+    "    query_ints = query_data['int_list_ms2']\n",
+    "\n",
+    "    query_idx_start = query_indices[query_idx]\n",
+    "    query_idx_end = query_indices[query_idx + 1]\n",
+    "    query_frag = query_frags[query_idx_start:query_idx_end]\n",
+    "    query_int = query_ints[query_idx_start:query_idx_end]\n",
+    "\n",
+    "    ax = plt.figure(figsize=(15, 5))\n",
+    "\n",
+    "    plt.vlines(query_frag, 0, query_int, \"k\", label=\"Query\", alpha=0.5)\n",
+    "\n",
+    "    plt.vlines(masses, ints, max(query_int)*(1+0.1*ion_type), \"k\", label=\"Hits\", alpha=0.5, linestyle=':')\n",
+    "\n",
+    "    plt.vlines(masses, 0, ints, \"r\", label=\"Hits\", alpha=0.5)\n",
+    "\n",
+    "    for i in range(len(masses)):\n",
+    "        plt.text(masses[i], (1+0.1*ion_type[i])*max(query_int), ion[i])\n",
+    "\n",
+    "    figure_title = f\"{spectrum['precursor']} - b-hits {spectrum['b_hits']}, y-hits {spectrum['y_hits']}, matched int {spectrum['matched_int_ratio']*100:.2f} %\"\n",
+    "\n",
+    "    plt.xlabel(\"m/z\")\n",
+    "    plt.ylabel('Intensity')\n",
+    "    plt.ylim([0, (1+0.1*max(ion_type)+0.1)*max(query_int)])\n",
+    "    plt.legend()\n",
+    "    plt.title(figure_title)\n",
+    "    plt.show()\n",
+    "    \n",
+    "    \n",
+    "for index in range(3):\n",
+    "    precursor = df['precursor'].iloc[index]\n",
+    "    print(f\" Plotting PSMS for {precursor}\")\n",
+    "    plot_psms(precursor, ms_file)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:alphapept]",
+   "language": "python",
+   "name": "conda-env-alphapept-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/settings.ini b/settings.ini
index 1e5a7308..af219a73 100644
--- a/settings.ini
+++ b/settings.ini
@@ -7,7 +7,7 @@ author = Maximilian T. Strauss
 author_email = straussmaximilian@gmail.com
 copyright = Mann Labs
 branch = master
-version = 0.3.19-dev0
+version = 0.3.20-dev0
 min_python = 3.6
 max_python = 4
 audience = Developers


Test patch:
diff --git a/alphapept/test.py b/alphapept/test.py
new file mode 100644
index 00000000..e69de29b
diff --git a/test_ci.py b/test_ci.py
index abf8ef16..9536da7c 100644
--- a/test_ci.py
+++ b/test_ci.py
@@ -18,6 +18,7 @@
 import alphapept
 import alphapept.io
 from alphapept.__version__ import VERSION_NO as alphapept_version
+from alphapept.paths import DEFAULT_SETTINGS
 
 
 # Global dictionary to store links to the files
@@ -147,7 +148,7 @@ def prepare_settings(self):
         Prepares the settings according to the test run
         """
 
-        self.settings = load_settings('default_settings.yaml')
+        self.settings = DEFAULT_SETTINGS
         self.settings['experiment']['file_paths'] =  [TEST_DIR + _ for _ in self.file_paths]
 
         self.settings['experiment']['fasta_paths'] = [TEST_DIR + _ for _ in self.fasta_paths]
@@ -225,7 +226,6 @@ def upload_to_db(self, password):
         string = f"mongodb+srv://{MONGODB_USER}:{password}@{MONGODB_URL}"
         client = MongoClient(string)
 
-
         #When having keys with dots like filename.ms_data.hdf, mongodb causes an error. This is to remove the dots.
         report = self.report