nbs/00_settings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Settings\n",
    "\n",
    "> A template for settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AlphaPept stores all settings in `*.yaml`-files. This notebook contains functions to load, save, and print settings. Additionally, a settings template is defined. Here we define parameters, default values, and a range and what kind of parameter this is (e.g., float value, list, etc.). The idea here is to have definitions to automatically create graphical user interfaces for the settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings\n",
    "\n",
    "### Saving and Loading\n",
    "\n",
    "The default scheme for saving settings are `*.yaml`-files. These files can be easily modified when opening with a text editor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import yaml\n",
    "import os\n",
    "\n",
    "def print_settings(settings: dict):\n",
    "    \"\"\"Print a yaml settings file\n",
    "\n",
    "    Args:\n",
    "        settings (dict): A yaml dictionary.\n",
    "    \"\"\"\n",
    "    print(yaml.dump(settings, default_flow_style=False))\n",
    "\n",
    "\n",
    "def load_settings(path: str):\n",
    "    \"\"\"Load a yaml settings file.\n",
    "\n",
    "    Args:\n",
    "        path (str): Path to the settings file.\n",
    "    \"\"\"\n",
    "    with open(path, \"r\") as settings_file:\n",
    "        SETTINGS_LOADED = yaml.load(settings_file, Loader=yaml.FullLoader)\n",
    "        return SETTINGS_LOADED\n",
    "    \n",
    "    \n",
    "def load_settings_as_template(path: str):\n",
    "    \"\"\"Loads settings but removes fields that contain summary information.\n",
    "\n",
    "    Args:\n",
    "        path (str): Path to the settings file.\n",
    "    \"\"\"\n",
    "    settings = load_settings(path)\n",
    "    \n",
    "    for _ in ['summary','failed']:\n",
    "        if _ in settings:\n",
    "            settings.pop(_)\n",
    "\n",
    "    _ = 'prec_tol_calibrated'\n",
    "    if 'search' in settings:\n",
    "        if _ in settings['search']:\n",
    "            settings['search'].pop(_)\n",
    "\n",
    "    return settings\n",
    "    \n",
    "\n",
    "def save_settings(settings: dict, path: str):\n",
    "    \"\"\"Save settings file to path.\n",
    "\n",
    "    Args:\n",
    "        settings (dict): A yaml dictionary.\n",
    "        path (str): Path to the settings file.\n",
    "    \"\"\"\n",
    "    \n",
    "    base_dir = os.path.dirname(path)\n",
    "    \n",
    "    if base_dir != '':\n",
    "        os.makedirs(os.path.dirname(path), exist_ok=True)\n",
    "    \n",
    "    with open(path, \"w\") as file:\n",
    "        yaml.dump(settings, file, sort_keys=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- print_settings ---\n",
      "field1: 0\n",
      "summary: 123\n",
      "\n",
      "--- load_settings ---\n",
      "field1: 0\n",
      "summary: 123\n",
      "\n",
      "--- load_settings_as_template ---\n",
      "field1: 0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "settings = {'field1': 0,'summary':123}\n",
    "dummy_path = 'to_delete.yaml'\n",
    "\n",
    "print('--- print_settings ---')\n",
    "print_settings(settings)\n",
    "\n",
    "save_settings(settings, dummy_path)\n",
    "\n",
    "print('--- load_settings ---')\n",
    "\n",
    "print_settings(load_settings(dummy_path))\n",
    "\n",
    "print('--- load_settings_as_template ---')\n",
    "\n",
    "print_settings(load_settings_as_template(dummy_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "def test_settings_utils():\n",
    "    settings = {'field1': 0,'summary':123}\n",
    "    dummy_path = 'to_delete.yaml'\n",
    "\n",
    "    save_settings(settings, dummy_path)\n",
    "\n",
    "    s = load_settings(dummy_path)\n",
    "\n",
    "    assert s==settings\n",
    "\n",
    "    s_ = load_settings_as_template(dummy_path)\n",
    "\n",
    "    assert 'summary' not in s_\n",
    "    assert 'failed' not in s_\n",
    "    \n",
    "test_settings_utils()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings Template\n",
    "\n",
    "The settings template defines individual settings. The idea is to provide a template so that a graphical user interface can be automatically generated. The list below represents what each item would be when using `streamlit`. This could be adapted for any kind of GUI library.\n",
    "\n",
    "Each entry has a type, default values, and a description.\n",
    "\n",
    "* spinbox -> `st.range`, range with minimum and maximum values (int)\n",
    "* doublespinbox -> `st.range`, range with minimum and maximum values (float)\n",
    "* path -> `st.button`, clickable button to select a path to save / load files.\n",
    "* combobox -> `st.selectbox`, dropdown menu with values to choose from\n",
    "* checkbox -> `st.checkbox`, checkbox that can be selected\n",
    "* checkgroup -> `st.multiselect`, creates a list of options that can be selected\n",
    "* string -> `st.text_input`, generic string input\n",
    "* list -> Creates a list that is displayed\n",
    "* placeholder -> This just prints the parameter and cannot be changed\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Worfklow settings\n",
    "\n",
    "Workflow settings regarding the workflow - which algorithmic steps should be performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import pandas as pd\n",
    "from alphapept.constants import protease_dict\n",
    "\n",
    "SETTINGS_TEMPLATE = {}\n",
    "\n",
    "# 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",
    "workflow[\"search_data\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to perform search.\"}\n",
    "workflow[\"recalibrate_data\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to perform recalibration.\"}\n",
    "workflow[\"align\"] = {'type':'checkbox', 'default':False, 'description':\"Flag to align the data.\"}\n",
    "workflow[\"match\"] = {'type':'checkbox', 'default':False, 'description':\"Flag to perform match-between runs.\"}\n",
    "workflow[\"lfq_quantification\"] = {'type':'checkbox', 'default':True, 'description':\"Flag to perfrom lfq normalization.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"workflow\"] = workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "align:\n",
      "  default: false\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",
      "  type: checkbox\n",
      "find_features:\n",
      "  default: true\n",
      "  description: Flag to perform feature finding.\n",
      "  type: checkbox\n",
      "import_raw_data:\n",
      "  default: true\n",
      "  description: Flag to import the raw data.\n",
      "  type: checkbox\n",
      "lfq_quantification:\n",
      "  default: true\n",
      "  description: Flag to perfrom lfq normalization.\n",
      "  type: checkbox\n",
      "match:\n",
      "  default: false\n",
      "  description: Flag to perform match-between runs.\n",
      "  type: checkbox\n",
      "recalibrate_data:\n",
      "  default: true\n",
      "  description: Flag to perform recalibration.\n",
      "  type: checkbox\n",
      "search_data:\n",
      "  default: true\n",
      "  description: Flag to perform search.\n",
      "  type: checkbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['workflow']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "general = {}\n",
    "\n",
    "general['n_processes'] = {'type':'spinbox', 'min':1, 'max':60, 'default':60, 'description':\"Maximum number of processes for multiprocessing. If larger than number of processors it will be capped.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"general\"] = general"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_processes:\n",
      "  default: 60\n",
      "  description: Maximum number of processes for multiprocessing. If larger than number\n",
      "    of processors it will be capped.\n",
      "  max: 60\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['general']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experimental Settings\n",
    "\n",
    "Core defintions of the experiment, regarding the filepaths.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "experiment = {}\n",
    "\n",
    "experiment[\"results_path\"] = {'type':'path','default': None, 'filetype':['hdf'], 'folder':False, 'description':\"Path where the results should be stored.\"}\n",
    "experiment[\"shortnames\"] = {'type':'list','default':[], 'description':\"List of shortnames for the raw files.\"}\n",
    "experiment[\"file_paths\"] = {'type':'list','default':[], 'description':\"Filepaths of the experiments.\"}\n",
    "experiment[\"sample_group\"] = {'type':'list','default':[], 'description':\"Sample group, for raw files that should be quanted together.\"}\n",
    "experiment[\"matching_group\"] = {'type':'list','default':[], 'description':\"List of macthing groups for the raw files. This only allows match-between-runs of files within the same groups.\"}\n",
    "experiment[\"fraction\"] = {'type':'list','default':[], 'description':\"List of fraction numbers for fractionated samples.\"}\n",
    "experiment[\"database_path\"] = {'type':'path','default':None, 'filetype':['hdf'], 'folder':False, 'description':\"Path to library file (.hdf).\"}\n",
    "experiment[\"fasta_paths\"] = {'type':'list','default':[], 'description':\"List of paths for FASTA files.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"experiment\"] = experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "database_path:\n",
      "  default: null\n",
      "  description: Path to library file (.hdf).\n",
      "  filetype:\n",
      "  - hdf\n",
      "  folder: false\n",
      "  type: path\n",
      "fasta_paths:\n",
      "  default: []\n",
      "  description: List of paths for FASTA files.\n",
      "  type: list\n",
      "file_paths:\n",
      "  default: []\n",
      "  description: Filepaths of the experiments.\n",
      "  type: list\n",
      "fraction:\n",
      "  default: []\n",
      "  description: List of fraction numbers for fractionated samples.\n",
      "  type: list\n",
      "matching_group:\n",
      "  default: []\n",
      "  description: List of macthing groups for the raw files. This only allows match-between-runs\n",
      "    of files within the same groups.\n",
      "  type: list\n",
      "results_path:\n",
      "  default: null\n",
      "  description: Path where the results should be stored.\n",
      "  filetype:\n",
      "  - hdf\n",
      "  folder: false\n",
      "  type: path\n",
      "sample_group:\n",
      "  default: []\n",
      "  description: Sample group, for raw files that should be quanted together.\n",
      "  type: list\n",
      "shortnames:\n",
      "  default: []\n",
      "  description: List of shortnames for the raw files.\n",
      "  type: list\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['experiment']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raw file handling\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "raw = {}\n",
    "\n",
    "raw[\"n_most_abundant\"] = {'type':'spinbox', 'min':-1, 'max':1000, 'default':400, 'description':\"Number of most abundant peaks to be isolated from raw spectra.\"}\n",
    "raw[\"use_profile_ms1\"] = {'type':'checkbox', 'default':False, 'description':\"Use profile data for MS1 and perform own centroiding.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"raw\"] = raw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_most_abundant:\n",
      "  default: 400\n",
      "  description: Number of most abundant peaks to be isolated from raw spectra.\n",
      "  max: 1000\n",
      "  min: -1\n",
      "  type: spinbox\n",
      "use_profile_ms1:\n",
      "  default: false\n",
      "  description: Use profile data for MS1 and perform own centroiding.\n",
      "  type: checkbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['raw']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FASTA settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import os\n",
    "fasta = {}\n",
    "\n",
    "## Read modifications from modifications file\n",
    "\n",
    "try:\n",
    "    base = os.path.dirname(os.path.abspath(__file__)) #Cant do this in notebook\n",
    "except NameError:\n",
    "    base = os.path.join(os.pardir, 'alphapept')\n",
    "\n",
    "if not os.path.isfile(os.path.join(base, \"modifications.tsv\")):\n",
    "    #Calling nbdev build_docs from parent dir\n",
    "    base = os.path.join(base, 'alphapept')\n",
    "    \n",
    "modfile_path = os.path.join(base, \"modifications.tsv\")  \n",
    "\n",
    "mod_db = pd.read_csv(modfile_path, sep='\\t')\n",
    "\n",
    "mods = {}\n",
    "mods_terminal = {}\n",
    "mods_protein = {}\n",
    "\n",
    "for i in range(len(mod_db)):\n",
    "    mod = mod_db.iloc[i]\n",
    "    if 'terminus' in mod['Type']:\n",
    "        if 'peptide' in mod['Type']:\n",
    "            mods_terminal[mod['Identifier']] = mod['Description']\n",
    "        elif 'protein' in mod['Type']:\n",
    "            mods_protein[mod['Identifier']] = mod['Description']\n",
    "        else:\n",
    "            print('Not understood')\n",
    "            print(mod['Type'])\n",
    "    else:\n",
    "        mods[mod['Identifier']] = mod['Description']\n",
    "\n",
    "fasta[\"mods_fixed\"] = {'type':'checkgroup', 'value':mods.copy(), 'default':['cC'],'description':\"Fixed modifications.\"}\n",
    "fasta[\"mods_fixed_terminal\"] = {'type':'checkgroup', 'value':mods_terminal.copy(), 'default':[],'description':\"Fixed terminal modifications.\"}\n",
    "fasta[\"mods_variable\"] = {'type':'checkgroup', 'value':mods.copy(), 'default':['oxM'],'description':\"Variable modifications.\"}\n",
    "fasta[\"mods_variable_terminal\"]  = {'type':'checkgroup', 'value':mods_terminal.copy(), 'default':[], 'description':\"Varibale terminal modifications.\"}\n",
    "\n",
    "fasta[\"mods_fixed_terminal_prot\"] = {'type':'checkgroup', 'value':mods_protein.copy(), 'default':[],'description':\"Fixed terminal modifications on proteins.\"}\n",
    "fasta[\"mods_variable_terminal_prot\"]  = {'type':'checkgroup', 'value':mods_protein.copy(), 'default':['a<^'], 'description':\"Varibale terminal modifications on proteins.\"}\n",
    "\n",
    "fasta[\"n_missed_cleavages\"] = {'type':'spinbox', 'min':0, 'max':99, 'default':2, 'description':\"Number of missed cleavages.\"}\n",
    "fasta[\"pep_length_min\"] = {'type':'spinbox', 'min':7, 'max':99, 'default':7, 'description':\"Minimum peptide length.\"}\n",
    "fasta[\"pep_length_max\"] = {'type':'spinbox', 'min':7, 'max':99, 'default':27, 'description':\"Maximum peptide length.\"}\n",
    "fasta[\"isoforms_max\"] = {'type':'spinbox', 'min':1, 'max':4096, 'default':1024, 'description':\"Maximum number of isoforms per peptide.\"}\n",
    "fasta[\"n_modifications_max\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':3, 'description':\"Limit the number of modifications per peptide.\"}\n",
    "\n",
    "fasta[\"pseudo_reverse\"] = {'type':'checkbox', 'default':True, 'description':\"Use pseudo-reverse strategy instead of reverse.\"}\n",
    "fasta[\"AL_swap\"] = {'type':'checkbox', 'default':False, 'description':\"Swap A and L for decoy generation.\"}\n",
    "fasta[\"KR_swap\"] = {'type':'checkbox', 'default':False, 'description':\"Swap K and R (only if terminal) for decoy generation.\"}\n",
    "\n",
    "proteases = [_ for _ in protease_dict.keys()]\n",
    "fasta[\"protease\"] = {'type':'combobox', 'value':proteases, 'default':'trypsin', 'description':\"Protease for digestions.\"}\n",
    "\n",
    "fasta[\"spectra_block\"] = {'type':'spinbox', 'min':1000, 'max':1000000, 'default':100000, 'description':\"Maximum number of sequences to be collected before theoretical spectra are generated.\"}\n",
    "fasta[\"fasta_block\"] = {'type':'spinbox', 'min':100, 'max':10000, 'default':1000, 'description':\"Number of fasta entries to be processed in one block.\"}\n",
    "fasta[\"save_db\"] = {'type':'checkbox', 'default':True, 'description':\"Save DB or create on the fly.\"}\n",
    "fasta[\"fasta_size_max\"] = {'type':'spinbox', 'min':1, 'max':1000000, 'default':100, 'description':\"Maximum size of FASTA (MB) when switching on-the-fly.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"fasta\"] = fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AL_swap:\n",
      "  default: false\n",
      "  description: Swap A and L for decoy generation.\n",
      "  type: checkbox\n",
      "KR_swap:\n",
      "  default: false\n",
      "  description: Swap K and R (only if terminal) for decoy generation.\n",
      "  type: checkbox\n",
      "fasta_block:\n",
      "  default: 1000\n",
      "  description: Number of fasta entries to be processed in one block.\n",
      "  max: 10000\n",
      "  min: 100\n",
      "  type: spinbox\n",
      "fasta_size_max:\n",
      "  default: 100\n",
      "  description: Maximum size of FASTA (MB) when switching on-the-fly.\n",
      "  max: 1000000\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "isoforms_max:\n",
      "  default: 1024\n",
      "  description: Maximum number of isoforms per peptide.\n",
      "  max: 4096\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "mods_fixed:\n",
      "  default:\n",
      "  - cC\n",
      "  description: Fixed modifications.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    aK: acetylation of lysine\n",
      "    cC: carbamidomethylation of C\n",
      "    deamN: deamidation of N\n",
      "    deamQ: deamidation of Q\n",
      "    eK: EASItag 6-plex on K\n",
      "    itraq4K: iTRAQ 4-plex on K\n",
      "    itraq4Y: iTRAQ 4-plex on Y\n",
      "    itraq8K: iTRAQ 8-plex on K\n",
      "    itraq8Y: iTRAQ 8-plex on Y\n",
      "    oxM: oxidation of M\n",
      "    pS: phosphorylation of S\n",
      "    pT: phosphorylation of T\n",
      "    pY: phosphorylation of Y\n",
      "    tmt0K: TMT zero on K\n",
      "    tmt0Y: TMT zero on Y\n",
      "    tmt2K: TMT duplex on K\n",
      "    tmt2Y: TMT duplex on Y\n",
      "    tmt6K: TMT sixplex/tenplex on K\n",
      "    tmt6Y: TMT sixplex/tenplex on Y\n",
      "mods_fixed_terminal:\n",
      "  default: []\n",
      "  description: Fixed terminal modifications.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    arg10>R: Arg 10 on peptide C-terminus\n",
      "    arg6>R: Arg 6 on peptide C-terminus\n",
      "    cm<C: pyro-cmC\n",
      "    e<^: EASItag 6-plex on peptide N-terminus\n",
      "    itraq4K<^: iTRAQ 4-plex on peptide N-terminus\n",
      "    itraq8K<^: iTRAQ 8-plex on peptide N-terminus\n",
      "    lys8>K: Lys 8 on peptide C-terminus\n",
      "    pg<E: pyro-E\n",
      "    pg<Q: pyro-Q\n",
      "    tmt0<^: TMT zero on peptide N-terminus\n",
      "    tmt2<^: TMT duplex on peptide N-terminus\n",
      "    tmt6<^: TMT sixplex/tenplex on peptide N-terminus\n",
      "mods_fixed_terminal_prot:\n",
      "  default: []\n",
      "  description: Fixed terminal modifications on proteins.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    a<^: acetylation of protein N-terminus\n",
      "    am>^: amidation of protein C-terminus\n",
      "mods_variable:\n",
      "  default:\n",
      "  - oxM\n",
      "  description: Variable modifications.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    aK: acetylation of lysine\n",
      "    cC: carbamidomethylation of C\n",
      "    deamN: deamidation of N\n",
      "    deamQ: deamidation of Q\n",
      "    eK: EASItag 6-plex on K\n",
      "    itraq4K: iTRAQ 4-plex on K\n",
      "    itraq4Y: iTRAQ 4-plex on Y\n",
      "    itraq8K: iTRAQ 8-plex on K\n",
      "    itraq8Y: iTRAQ 8-plex on Y\n",
      "    oxM: oxidation of M\n",
      "    pS: phosphorylation of S\n",
      "    pT: phosphorylation of T\n",
      "    pY: phosphorylation of Y\n",
      "    tmt0K: TMT zero on K\n",
      "    tmt0Y: TMT zero on Y\n",
      "    tmt2K: TMT duplex on K\n",
      "    tmt2Y: TMT duplex on Y\n",
      "    tmt6K: TMT sixplex/tenplex on K\n",
      "    tmt6Y: TMT sixplex/tenplex on Y\n",
      "mods_variable_terminal:\n",
      "  default: []\n",
      "  description: Varibale terminal modifications.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    arg10>R: Arg 10 on peptide C-terminus\n",
      "    arg6>R: Arg 6 on peptide C-terminus\n",
      "    cm<C: pyro-cmC\n",
      "    e<^: EASItag 6-plex on peptide N-terminus\n",
      "    itraq4K<^: iTRAQ 4-plex on peptide N-terminus\n",
      "    itraq8K<^: iTRAQ 8-plex on peptide N-terminus\n",
      "    lys8>K: Lys 8 on peptide C-terminus\n",
      "    pg<E: pyro-E\n",
      "    pg<Q: pyro-Q\n",
      "    tmt0<^: TMT zero on peptide N-terminus\n",
      "    tmt2<^: TMT duplex on peptide N-terminus\n",
      "    tmt6<^: TMT sixplex/tenplex on peptide N-terminus\n",
      "mods_variable_terminal_prot:\n",
      "  default:\n",
      "  - a<^\n",
      "  description: Varibale terminal modifications on proteins.\n",
      "  type: checkgroup\n",
      "  value:\n",
      "    a<^: acetylation of protein N-terminus\n",
      "    am>^: amidation of protein C-terminus\n",
      "n_missed_cleavages:\n",
      "  default: 2\n",
      "  description: Number of missed cleavages.\n",
      "  max: 99\n",
      "  min: 0\n",
      "  type: spinbox\n",
      "n_modifications_max:\n",
      "  default: 3\n",
      "  description: Limit the number of modifications per peptide.\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "pep_length_max:\n",
      "  default: 27\n",
      "  description: Maximum peptide length.\n",
      "  max: 99\n",
      "  min: 7\n",
      "  type: spinbox\n",
      "pep_length_min:\n",
      "  default: 7\n",
      "  description: Minimum peptide length.\n",
      "  max: 99\n",
      "  min: 7\n",
      "  type: spinbox\n",
      "protease:\n",
      "  default: trypsin\n",
      "  description: Protease for digestions.\n",
      "  type: combobox\n",
      "  value:\n",
      "  - arg-c\n",
      "  - asp-n\n",
      "  - bnps-skatole\n",
      "  - caspase 1\n",
      "  - caspase 2\n",
      "  - caspase 3\n",
      "  - caspase 4\n",
      "  - caspase 5\n",
      "  - caspase 6\n",
      "  - caspase 7\n",
      "  - caspase 8\n",
      "  - caspase 9\n",
      "  - caspase 10\n",
      "  - chymotrypsin high specificity\n",
      "  - chymotrypsin low specificity\n",
      "  - clostripain\n",
      "  - cnbr\n",
      "  - enterokinase\n",
      "  - factor xa\n",
      "  - formic acid\n",
      "  - glutamyl endopeptidase\n",
      "  - granzyme b\n",
      "  - hydroxylamine\n",
      "  - iodosobenzoic acid\n",
      "  - lys_c\n",
      "  - lys_c/p\n",
      "  - lys_n\n",
      "  - ntcb\n",
      "  - pepsin ph1.3\n",
      "  - pepsin ph2.0\n",
      "  - proline endopeptidase\n",
      "  - proteinase k\n",
      "  - staphylococcal peptidase i\n",
      "  - thermolysin\n",
      "  - thrombin\n",
      "  - trypsin_full\n",
      "  - trypsin_exception\n",
      "  - non-specific\n",
      "  - trypsin\n",
      "pseudo_reverse:\n",
      "  default: true\n",
      "  description: Use pseudo-reverse strategy instead of reverse.\n",
      "  type: checkbox\n",
      "save_db:\n",
      "  default: true\n",
      "  description: Save DB or create on the fly.\n",
      "  type: checkbox\n",
      "spectra_block:\n",
      "  default: 100000\n",
      "  description: Maximum number of sequences to be collected before theoretical spectra\n",
      "    are generated.\n",
      "  max: 1000000\n",
      "  min: 1000\n",
      "  type: spinbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['fasta']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Finding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "\n",
    "features = {}\n",
    "# Thermo FF settings\n",
    "\n",
    "features[\"max_gap\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':2}\n",
    "features[\"centroid_tol\"] = {'type':'spinbox', 'min':1, 'max':25, 'default':8}\n",
    "features[\"hill_length_min\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':3}\n",
    "features[\"hill_split_level\"] = {'type':'doublespinbox', 'min':0.1, 'max':10.0, 'default':1.3}\n",
    "features[\"iso_split_level\"] = {'type':'doublespinbox', 'min':0.1, 'max':10.0, 'default':1.3}\n",
    "\n",
    "features[\"hill_smoothing\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':1}\n",
    "features[\"hill_check_large\"] = {'type':'spinbox', 'min':1, 'max':100, 'default':40}\n",
    "\n",
    "features[\"iso_charge_min\"] = {'type':'spinbox', 'min':1, 'max':6, 'default':1}\n",
    "features[\"iso_charge_max\"] = {'type':'spinbox', 'min':1, 'max':6, 'default':6}\n",
    "features[\"iso_n_seeds\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':100}\n",
    "\n",
    "features[\"hill_nboot_max\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':300}\n",
    "features[\"hill_nboot\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':150}\n",
    "\n",
    "features[\"iso_mass_range\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':5}\n",
    "features[\"iso_corr_min\"] = {'type':'doublespinbox', 'min':0.1, 'max':1, 'default':0.6}\n",
    "\n",
    "features[\"map_mz_range\"] = {'type':'doublespinbox', 'min':0.1, 'max':2, 'default':1.5}\n",
    "features[\"map_rt_range\"] = {'type':'doublespinbox', 'min':0.1, 'max':1, 'default':0.5}\n",
    "features[\"map_mob_range\"] = {'type':'doublespinbox', 'min':0.1, 'max':1, 'default':0.3}\n",
    "features[\"map_n_neighbors\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':5}\n",
    "\n",
    "features[\"search_unidentified\"] = {'type':'checkbox', 'default':False, 'description':\"Search MSMS w/o feature.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"features\"] = features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "centroid_tol:\n",
      "  default: 8\n",
      "  max: 25\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_check_large:\n",
      "  default: 40\n",
      "  max: 100\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_length_min:\n",
      "  default: 3\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_nboot:\n",
      "  default: 150\n",
      "  max: 500\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_nboot_max:\n",
      "  default: 300\n",
      "  max: 500\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_smoothing:\n",
      "  default: 1\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "hill_split_level:\n",
      "  default: 1.3\n",
      "  max: 10.0\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "iso_charge_max:\n",
      "  default: 6\n",
      "  max: 6\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "iso_charge_min:\n",
      "  default: 1\n",
      "  max: 6\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "iso_corr_min:\n",
      "  default: 0.6\n",
      "  max: 1\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "iso_mass_range:\n",
      "  default: 5\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "iso_n_seeds:\n",
      "  default: 100\n",
      "  max: 500\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "iso_split_level:\n",
      "  default: 1.3\n",
      "  max: 10.0\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "map_mob_range:\n",
      "  default: 0.3\n",
      "  max: 1\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "map_mz_range:\n",
      "  default: 1.5\n",
      "  max: 2\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "map_n_neighbors:\n",
      "  default: 5\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "map_rt_range:\n",
      "  default: 0.5\n",
      "  max: 1\n",
      "  min: 0.1\n",
      "  type: doublespinbox\n",
      "max_gap:\n",
      "  default: 2\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "search_unidentified:\n",
      "  default: false\n",
      "  description: Search MSMS w/o feature.\n",
      "  type: checkbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['features']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Search Settings\n",
    "search = {}\n",
    "\n",
    "search[\"prec_tol\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':20, 'description':\"Maximum allowed precursor mass offset.\"}\n",
    "search[\"frag_tol\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':50, 'description':\"Maximum fragment mass tolerance.\"}\n",
    "search[\"top_n\"] = {'type':'spinbox', 'min':1, 'max':50, 'default':10, 'description':\"Top n selection of peptides for search.\"}\n",
    "search[\"min_frag_hits\"] = {'type':'spinbox', 'min':1, 'max':99, 'default':7, 'description':\"Minimum number of fragment hits.\"}\n",
    "search[\"ppm\"] = {'type':'checkbox', 'default':True, 'description':\"Use ppm instead of Dalton.\"}\n",
    "search[\"calibrate\"] = {'type':'checkbox', 'default':True, 'description':\"Recalibrate masses.\"}\n",
    "search[\"calibration_std_prec\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':5, 'description':\"Std range for precursor tolerance after calibration.\"}\n",
    "search[\"calibration_std_frag\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':5, 'description':\"Std range for fragment tolerance after calibration.\"}\n",
    "search[\"parallel\"] = {'type':'checkbox', 'default':True, 'description':\"Use parallel processing.\"}\n",
    "search[\"peptide_fdr\"] = {'type':'doublespinbox', 'min':0.0, 'max':1.0, 'default':0.01, 'description':\"FDR level for peptides.\"}\n",
    "search[\"protein_fdr\"] = {'type':'doublespinbox', 'min':0.0, 'max':1.0, 'default':0.01, 'description':\"FDR level for proteins.\"}\n",
    "search['recalibration_min'] = {'type':'spinbox', 'min':100, 'max':10000, 'default':100, 'description':\"Minimum number of datapoints to perform calibration.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"search\"] = search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calibrate:\n",
      "  default: true\n",
      "  description: Recalibrate masses.\n",
      "  type: checkbox\n",
      "calibration_std_frag:\n",
      "  default: 5\n",
      "  description: Std range for fragment tolerance after calibration.\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "calibration_std_prec:\n",
      "  default: 5\n",
      "  description: Std range for precursor tolerance after calibration.\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "frag_tol:\n",
      "  default: 50\n",
      "  description: Maximum fragment mass tolerance.\n",
      "  max: 500\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "min_frag_hits:\n",
      "  default: 7\n",
      "  description: Minimum number of fragment hits.\n",
      "  max: 99\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "parallel:\n",
      "  default: true\n",
      "  description: Use parallel processing.\n",
      "  type: checkbox\n",
      "peptide_fdr:\n",
      "  default: 0.01\n",
      "  description: FDR level for peptides.\n",
      "  max: 1.0\n",
      "  min: 0.0\n",
      "  type: doublespinbox\n",
      "ppm:\n",
      "  default: true\n",
      "  description: Use ppm instead of Dalton.\n",
      "  type: checkbox\n",
      "prec_tol:\n",
      "  default: 20\n",
      "  description: Maximum allowed precursor mass offset.\n",
      "  max: 500\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "protein_fdr:\n",
      "  default: 0.01\n",
      "  description: FDR level for proteins.\n",
      "  max: 1.0\n",
      "  min: 0.0\n",
      "  type: doublespinbox\n",
      "recalibration_min:\n",
      "  default: 100\n",
      "  description: Minimum number of datapoints to perform calibration.\n",
      "  max: 10000\n",
      "  min: 100\n",
      "  type: spinbox\n",
      "top_n:\n",
      "  default: 1\n",
      "  description: Top n selection of peptides for search.\n",
      "  max: 50\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['search']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Score\n",
    "score = {}\n",
    "\n",
    "score[\"method\"] = {'type':'combobox', 'value':['x_tandem','random_forest','generic_score','morpheus'], 'default':'random_forest', 'description':\"Scoring method.\"}\n",
    "score[\"ml_ini_score\"] = {'type':'combobox', 'value':['x_tandem','hits','generic_score'], 'default':'generic_score', 'description':\"Initial score for ML. Hits is equivalent to Morpehus score.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"score\"] = score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "method:\n",
      "  default: random_forest\n",
      "  description: Scoring method.\n",
      "  type: combobox\n",
      "  value:\n",
      "  - x_tandem\n",
      "  - random_forest\n",
      "  - generic_score\n",
      "  - morpheus\n",
      "ml_ini_score:\n",
      "  default: hits\n",
      "  description: Initial score for ML. Hits is equivalent to Morpehus score.\n",
      "  type: combobox\n",
      "  value:\n",
      "  - x_tandem\n",
      "  - hits\n",
      "  - generic_score\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['score']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calibration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Calibration\n",
    "calibration = {}\n",
    "\n",
    "calibration[\"outlier_std\"] = {'type':'spinbox', 'min':1, 'max':5, 'default':3, 'description':\"Number of std. deviations to filter outliers in psms.\"}\n",
    "calibration[\"calib_n_neighbors\"] = {'type':'spinbox', 'min':1, 'max':1000, 'default':100, 'description':\"Number of neighbors that are used for offset interpolation.\"}\n",
    "calibration[\"calib_mz_range\"] = {'type':'spinbox', 'min':1, 'max':10000, 'default':2000, 'description':\"Scaling factor for mz axis in ppm.\"}\n",
    "calibration[\"calib_rt_range\"] = {'type':'doublespinbox', 'min':0.0, 'max':10, 'default':0.5, 'description':\"Scaling factor for rt axis.\"}\n",
    "calibration[\"calib_mob_range\"] = {'type':'doublespinbox', 'min':0.0, 'max':1.0, 'default':0.3, 'description':\"Scaling factor for mobility axis.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"calibration\"] = calibration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calib_mob_range:\n",
      "  default: 0.3\n",
      "  description: Scaling factor for mobility axis.\n",
      "  max: 1.0\n",
      "  min: 0.0\n",
      "  type: doublespinbox\n",
      "calib_mz_range:\n",
      "  default: 2000\n",
      "  description: Scaling factor for mz axis in ppm.\n",
      "  max: 10000\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "calib_n_neighbors:\n",
      "  default: 100\n",
      "  description: Number of neighbors that are used for offset interpolation.\n",
      "  max: 1000\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "calib_rt_range:\n",
      "  default: 0.5\n",
      "  description: Scaling factor for rt axis.\n",
      "  max: 10\n",
      "  min: 0.0\n",
      "  type: doublespinbox\n",
      "outlier_std:\n",
      "  default: 3\n",
      "  description: Number of std. deviations to filter outliers in psms.\n",
      "  max: 5\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['calibration']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Matching\n",
    "\n",
    "matching = {}\n",
    "\n",
    "matching[\"match_p_min\"] = {'type':'doublespinbox', 'min':0.001, 'max':1.0, 'default':0.05, 'description':\"Minimum probability cutoff for matching.\"}\n",
    "matching[\"match_d_min\"] = {'type':'doublespinbox', 'min':0.001, 'max':10.0, 'default':3, 'description': \"Minimum distance cutoff for matching.\"}\n",
    "matching[\"match_group_tol\"] = {'type':'spinbox', 'min':0, 'max':100, 'default':0, 'description': \"When having matching groups, match neighboring groups.\"}\n",
    "\n",
    "\n",
    "SETTINGS_TEMPLATE[\"matching\"] = matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "match_d_min:\n",
      "  default: 3\n",
      "  description: Minimum distance cutoff for matching.\n",
      "  max: 10.0\n",
      "  min: 0.001\n",
      "  type: doublespinbox\n",
      "match_group_tol:\n",
      "  default: 0\n",
      "  description: When having matching groups, match neighboring groups.\n",
      "  max: 100\n",
      "  min: 0\n",
      "  type: spinbox\n",
      "match_p_min:\n",
      "  default: 0.05\n",
      "  description: Minimum probability cutoff for matching.\n",
      "  max: 1.0\n",
      "  min: 0.001\n",
      "  type: doublespinbox\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['matching']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Isobaric Labeling  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isobaric_label = {}\n",
    "\n",
    "isobaric_label[\"label\"] = {'type':'combobox', 'value':['None','TMT10plex'], 'default':'None', 'description':\"Type of isobaric label present.\"}\n",
    "isobaric_label[\"reporter_frag_tolerance\"] = {'type':'spinbox', 'min':1, 'max':500, 'default':15, 'description':\"Maximum fragment mass tolerance for a reporter.\"}\n",
    "isobaric_label[\"reporter_frag_tolerance_ppm\"] = {'type':'checkbox', 'default':True, 'description':\"Use ppm instead of Dalton.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"isobaric_label\"] = isobaric_label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantification  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Quantification\n",
    "\n",
    "quantification = {}\n",
    "quantification[\"max_lfq\"] = {'type':'checkbox', 'default':True, 'description':\"Perform max lfq type quantification.\"}\n",
    "quantification[\"lfq_ratio_min\"] = {'type':'spinbox', 'min':1, 'max':10, 'default':1, 'description':\"Minimum number of ratios for LFQ.\"}\n",
    "quantification[\"mode\"] = {'type':'combobox', 'value':['ms1_int_sum_apex'], 'default':'ms1_int_sum_apex', 'description':\"Column to perform quantification on.\"}\n",
    "\n",
    "SETTINGS_TEMPLATE[\"quantification\"] = quantification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lfq_ratio_min:\n",
      "  default: 1\n",
      "  description: Minimum number of ratios for LFQ.\n",
      "  max: 10\n",
      "  min: 1\n",
      "  type: spinbox\n",
      "max_lfq:\n",
      "  default: true\n",
      "  description: Perform max lfq type quantification.\n",
      "  type: checkbox\n",
      "mode:\n",
      "  default: ms1_int_sum_apex\n",
      "  description: Column to perform quantification on.\n",
      "  type: combobox\n",
      "  value:\n",
      "  - ms1_int_sum_apex\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(yaml.dump(SETTINGS_TEMPLATE['quantification']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import sys\n",
    "import hashlib\n",
    "\n",
    "def hash_file(path):\n",
    "    \"\"\"\n",
    "    Helper function to hash a file\n",
    "    Taken from https://stackoverflow.com/questions/22058048/hashing-a-file-in-python\n",
    "    \"\"\"\n",
    "\n",
    "    BUF_SIZE = 65536  # lets read stuff in 64kb chunks!\n",
    "\n",
    "    md5 = hashlib.md5()\n",
    "    sha1 = hashlib.sha1()\n",
    "\n",
    "    with open(path, 'rb') as f:\n",
    "        while True:\n",
    "            data = f.read(BUF_SIZE)\n",
    "            if not data:\n",
    "                break\n",
    "            md5.update(data)\n",
    "            sha1.update(data)\n",
    "\n",
    "    return md5.hexdigest(), sha1.hexdigest()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "\n",
    "def create_default_settings():\n",
    "    \n",
    "    settings = {}\n",
    "    \n",
    "    for category in SETTINGS_TEMPLATE.keys():\n",
    "\n",
    "        temp_settings = {}\n",
    "\n",
    "        for key in SETTINGS_TEMPLATE[category].keys():\n",
    "            temp_settings[key] = SETTINGS_TEMPLATE[category][key]['default']\n",
    "\n",
    "        settings[category] = temp_settings\n",
    "            \n",
    "    md5, sha1 = hash_file(modfile_path)\n",
    "    settings['general']['modfile_hash'] = md5\n",
    "\n",
    "    save_settings(settings, DEFAULT_SETTINGS_PATH) #Save in home folder to be able to modify\n",
    "    save_settings(SETTINGS_TEMPLATE,  os.path.join(AP_PATH, 'settings_template.yaml'))\n",
    "    \n",
    "\n",
    "import os\n",
    "import logging\n",
    "\n",
    "md5, sha1 = hash_file(modfile_path)\n",
    "\n",
    "HOME = os.path.expanduser(\"~\")\n",
    "AP_PATH = os.path.join(HOME, \".alphapept\")\n",
    "DEFAULT_SETTINGS_PATH = os.path.join(AP_PATH, 'default_settings.yaml')\n",
    "\n",
    "skip = False\n",
    "\n",
    "previous_md5 = None\n",
    "if os.path.isfile(DEFAULT_SETTINGS_PATH):\n",
    "    s_ = load_settings(DEFAULT_SETTINGS_PATH)\n",
    "    if 'modfile_hash' in s_['general']:\n",
    "        previous_md5 = s_['general']['modfile_hash'] \n",
    "\n",
    "if previous_md5 is not None:\n",
    "    if previous_md5 == md5:\n",
    "        skip = True\n",
    "                \n",
    "if not skip:     \n",
    "    logging.info('Creating default settings.')\n",
    "    create_default_settings()\n",
    "else:\n",
    "    logging.info('Using existing settings.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "import nbdev; nbdev.nbdev_export()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}