diff --git a/directlfq/dashboard_parts.py b/directlfq/dashboard_parts.py index c805a78..61bca71 100644 --- a/directlfq/dashboard_parts.py +++ b/directlfq/dashboard_parts.py @@ -148,7 +148,7 @@ def __init__(self): self.path_protein_groups_file = pn.widgets.TextInput( name='(optional) If you are using MaxQuant evidence.txt or peptides.txt files, you can add the link to the corresponding proteinGroups.txt file (will improve peptide-to-protein mapping)', placeholder='(optional) Enter the whole path to the MaxQuant proteinGroups.txt file', - default = None, + value = None, width=900, sizing_mode='stretch_width', margin=(15, 15, 0, 15) @@ -156,11 +156,11 @@ def __init__(self): ## optional files - self.additional_headers_title = pn.pane.Markdown('* Add the names of columns that you want to keep in the directLFQ output file, separated by semicolons. Note that some basic additional columns such as gene names are always added to the output table by default.\nWARNING: Take care that columns you add are not ambigous. For example, adding the peptide sequence column will not work, because there are multiple peptide sequences per protein.') + self.additional_headers_title = pn.pane.Markdown('* Add the names of columns that you want to keep in the directLFQ output file, separated by semicolons. Note that some basic additional columns such as gene names are always added to the output table by value.\nWARNING: Take care that columns you add are not ambigous. For example, adding the peptide sequence column will not work, because there are multiple peptide sequences per protein.') self.additional_headers = pn.widgets.TextInput( name='', placeholder='(optional) Enter the names of columns that you want to keep', - default = None, + value = None, #width=900, #sizing_mode='stretch_width', #margin=(15, 15, 0, 15) @@ -169,7 +169,7 @@ def __init__(self): self.protein_subset_for_normalization_title = pn.pane.Markdown('* Specify a list of proteins (no header, seperated by linebreaks) that you want to use for normalization. This could for example be a list of housekeeping proteins:') self.protein_subset_for_normalization_file = pn.widgets.TextInput( name='', - default = None, + value = None, placeholder='(optional) Enter the whole path to the protein list file', width=900, sizing_mode='stretch_width', @@ -179,7 +179,7 @@ def __init__(self): self.yaml_filt_dict_title = pn.pane.Markdown('* In case you want to define specific filters in addition to the standard filters, you can add a yaml file where the filters are defined (see GitHub docs).') self.yaml_filt_dict_path = pn.widgets.TextInput( name='', - default = None, + value = None, placeholder='(optional) Enter the whole path to the yaml file with the filters', width=900, sizing_mode='stretch_width', diff --git a/directlfq/test_utils.py b/directlfq/test_utils.py new file mode 100644 index 0000000..7eae991 --- /dev/null +++ b/directlfq/test_utils.py @@ -0,0 +1,60 @@ +import numpy as np +import pandas as pd + +from numpy.random import MT19937 +from numpy.random import RandomState, SeedSequence + +class ProteinProfileGenerator(): + def __init__(self, peptide_profiles): + self._peptide_profiles = peptide_profiles + + self.protein_profile_dataframe = None + self._generate_protein_profile_dataframe() + + def _generate_protein_profile_dataframe(self): + collected_profiles = [x.peptide_profile_vector for x in self._peptide_profiles] + protnames_for_index = [x.protein_name for x in self._peptide_profiles] + pepnames_for_index = [f'{idx}' for idx in range(len(self._peptide_profiles))] + self.protein_profile_dataframe = pd.DataFrame(collected_profiles,index=[protnames_for_index, pepnames_for_index]) + self.protein_profile_dataframe.index.names = ['protein', 'ion'] + self.protein_profile_dataframe = np.log2(self.protein_profile_dataframe.replace(0, np.nan)) + + + +class PeptideProfile(): + def __init__(self, protein_name, fraction_zeros_in_profile, systematic_peptide_shift, add_noise, num_samples = 20, min_intensity = 1e6, max_intensity = 1e10): + + + self._fraction_zeros_in_profile = fraction_zeros_in_profile + self._systematic_peptide_shift = systematic_peptide_shift + self._add_noise = add_noise + self._min_intensity = min_intensity + self._max_intensity = max_intensity + self._num_samples = num_samples + + self.protein_name = protein_name + self.peptide_profile_vector = [] + self._define_peptide_profile_vector() + + def _define_peptide_profile_vector(self): + self.peptide_profile_vector = self._get_single_peptide_profile_template() + self._scale_profile_vector() + if self._add_noise: + self._apply_poisson_noise_to_profilevector() + self._add_zeros_to_profilevector() + + def _get_single_peptide_profile_template(self): + rs = RandomState(MT19937(SeedSequence(42312))) + return rs.randint(low=self._min_intensity, high=self._max_intensity,size=self._num_samples) + + def _scale_profile_vector(self): + self.peptide_profile_vector = self.peptide_profile_vector*self._systematic_peptide_shift + + def _apply_poisson_noise_to_profilevector(self): + self.peptide_profile_vector = np.random.poisson(lam=self.peptide_profile_vector, size=len(self.peptide_profile_vector)) + + def _add_zeros_to_profilevector(self): + num_elements_to_set_zero = int(self._num_samples*self._fraction_zeros_in_profile) + idxs_to_set_zero = np.random.choice(self._num_samples,size=num_elements_to_set_zero, replace=False) + self.peptide_profile_vector[idxs_to_set_zero] = 0 + \ No newline at end of file diff --git a/misc/loose_pip_install.sh b/misc/loose_pip_install.sh index caae6f2..72e3892 100644 --- a/misc/loose_pip_install.sh +++ b/misc/loose_pip_install.sh @@ -1,5 +1,5 @@ conda create -n directlfq python=3.8 -y conda activate directlfq -pip install -e '../.[development, gui]' +pip install -e '../.[development-stable, gui]' directlfq conda deactivate diff --git a/nbdev_nbs/01_lfq_manager.ipynb b/nbdev_nbs/01_lfq_manager.ipynb deleted file mode 100644 index 2140a66..0000000 --- a/nbdev_nbs/01_lfq_manager.ipynb +++ /dev/null @@ -1,120 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp lfq_manager" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import directlfq.normalization as lfqnorm\n", - "import directlfq.protein_intensity_estimation as lfqprot_estimation\n", - "import directlfq.utils as lfqutils\n", - "import pandas as pd\n", - "import directlfq\n", - "\n", - "import warnings\n", - "\n", - "\n", - "warnings.filterwarnings(action='once')\n", - "\n", - "\n", - "def run_lfq(input_file, columns_to_add = [], selected_proteins_file :str = None, mq_protein_groups_txt = None, min_nonan = 1, input_type_to_use = None, maximum_number_of_quadratic_ions_to_use_per_protein = 10, \n", - "number_of_quadratic_samples = 50, num_cores = None, filename_suffix = \"\", deactivate_normalization = False\n", - "):\n", - " \"\"\"Run the directLFQ pipeline on a given input file. The input file is expected to contain ion intensities. The output is a table containing protein intensities.\n", - "\n", - " Args:\n", - " input_file (_type_): the input file containing the ion intensities. Usually the output of a search engine.\n", - " columns_to_add (list, optional): additional columns to add to the LFQ intensity output table. They are extraced from the input file. Defaults to [].\n", - " selected_proteins_file (str, optional): if you want to perform normalization only on a subset of proteins, you can pass a .txt file containing the protein IDs, separeted by line breaks. No header expected. Defaults to None.\n", - " mq_protein_groups_txt (_type_, optional): In the case of using MaxQuant data, the proteinGroups.txt table is needed in order to map IDs analogous to MaxQuant. Adding this table improves protein mapping, but is not necessary. Defaults to None.\n", - " min_nonan (int, optional): Min number of ion intensities necessary in order to derive a protein intensity. Increasing the number results in more reliable protein quantification at the cost of losing IDs. Defaults to 1.\n", - " input_type_to_use (_type_, optional): If you want to parse data from the input file in a differing way than specified in the defaults (e.g. extracting MS1 intensities only from a DIANN file), you can name the parsing protocol to be used. The parsing protocols are defined in directlfq/configs/intable_configs.yaml Defaults to None.\n", - " maximum_number_of_quadratic_ions_to_use_per_protein (int, optional): How many ions are used to create the anchor intensity trace (see paper). Increasing might marginally increase performance at the cost of runtime. Defaults to 10.\n", - " number_of_quadratic_samples (int, optional): How many samples are are used to create the anchor intensity trace (see paper). Increasing might marginally increase performance at the cost of runtime. Defaults to 50.\n", - " num_cores (_type_, optional): Num cores to use. Maximum feasible number utilized if set to None. Defaults to None.\n", - " \"\"\"\n", - " print(\"Starting directLFQ analysis.\")\n", - " input_file = prepare_input_filename(input_file)\n", - " print(\"reformatting input file, for large files this might take a while.\")\n", - " input_file = lfqutils.add_mq_protein_group_ids_if_applicable_and_obtain_annotated_file(input_file, input_type_to_use,mq_protein_groups_txt, columns_to_add)\n", - " input_df = lfqutils.import_data(input_file=input_file, input_type_to_use=input_type_to_use)\n", - " input_df = lfqutils.index_and_log_transform_input_df(input_df)\n", - " input_df = lfqutils.remove_allnan_rows_input_df(input_df)\n", - " \n", - " if not deactivate_normalization:\n", - " print(\"Performing sample normalization.\")\n", - " input_df = lfqnorm.NormalizationManagerSamplesOnSelectedProteins(input_df, num_samples_quadratic=number_of_quadratic_samples, selected_proteins_file=selected_proteins_file).complete_dataframe\n", - " \n", - " print(\"Estimating lfq intensities.\")\n", - " protein_df, ion_df = lfqprot_estimation.estimate_protein_intensities(input_df,min_nonan=min_nonan,num_samples_quadratic=maximum_number_of_quadratic_ions_to_use_per_protein, num_cores = num_cores)\n", - " try:\n", - " protein_df = lfqutils.add_columns_to_lfq_results_table(protein_df, input_file, columns_to_add)\n", - " except:\n", - " print(\"Could not add additional columns to protein table, printing without additional columns.\")\n", - " \n", - " print(\"Writing results files.\")\n", - " outfile_basename = get_outfile_basename(input_file, input_type_to_use, selected_proteins_file, deactivate_normalization,filename_suffix)\n", - " save_run_config(outfile_basename, locals())\n", - " save_protein_df(protein_df,outfile_basename)\n", - " save_ion_df(ion_df,outfile_basename)\n", - " \n", - " print(\"Analysis finished!\")\n", - "\n", - "def prepare_input_filename(input_file):\n", - " input_file = fr\"{input_file}\".replace(\"\\ \", \" \").rstrip() #replace escaped spaces with normal spaces and remove trailing whitespace\n", - " return input_file\n", - "\n", - "def get_outfile_basename(input_file, input_type_to_use, selected_proteins_file, deactivate_normalization,filename_suffix):\n", - " outfile_basename = input_file\n", - " outfile_basename += \"\" if input_type_to_use is None else f\".{input_type_to_use}\"\n", - " outfile_basename += \".selected_proteins\" if selected_proteins_file is not None else \"\"\n", - " outfile_basename += \".no_norm\" if deactivate_normalization else \"\"\n", - " outfile_basename += filename_suffix\n", - " return outfile_basename\n", - "\n", - "def save_protein_df(protein_df, outfile_basename):\n", - " protein_df.to_csv(f\"{outfile_basename}.protein_intensities.tsv\", sep = \"\\t\")\n", - "\n", - "def save_ion_df(ion_df, outfile_basename):\n", - " ion_df.to_csv(f\"{outfile_basename}.ion_intensities.tsv\", sep = \"\\t\")\n", - "\n", - "\n", - "def save_run_config(outfile_basename, kwargs):\n", - " try:\n", - " df_configs = pd.DataFrame.from_dict(kwargs, orient='index', columns=['value'])\n", - " #add row with directlfq version\n", - " df_configs.loc[\"directlfq_version\"] = directlfq.__version__\n", - " df_configs.to_csv(f\"{outfile_basename}.run_config.tsv\", sep = \"\\t\")\n", - " except:\n", - " print(\"Could not save run config.\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "alphatemplate", - "language": "python", - "name": "python3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/nbdev_nbs/02_normalization.ipynb b/nbdev_nbs/02_normalization.ipynb index fb5dba5..e5f2173 100644 --- a/nbdev_nbs/02_normalization.ipynb +++ b/nbdev_nbs/02_normalization.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -96,41 +96,42 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#| include: false\n", "import numpy as np\n", - "import directlfq.normalization as norm\n", + "import directlfq.normalization as lfq_norm\n", "\n", "def test_merged_distribs():\n", " anchor_distrib = np.array([1, 1, 1, 1, 1])\n", " shift_distrib = np.array([2, 2, 2, 2, 2])\n", " counts_anchor_distrib = 4\n", " counts_shifted_distib = 1\n", - " assert (merge_distribs(anchor_distrib, shift_distrib, counts_anchor_distrib, counts_shifted_distib)== np.array([1.2, 1.2, 1.2, 1.2, 1.2])).any()\n" + " assert (lfq_norm.merge_distribs(anchor_distrib, shift_distrib, counts_anchor_distrib, counts_shifted_distib)== np.array([1.2, 1.2, 1.2, 1.2, 1.2])).any()\n", + "\n", + "\n", + "test_merged_distribs() \n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "\n", - "test_merged_distribs() " - ] + "source": [] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#| include: false\n", "import numpy as np\n", "import pandas as pd\n", + "import directlfq.normalization as lfq_norm\n", "\n", "\n", "def test_order_of_shifts():\n", @@ -142,11 +143,11 @@ " protein_profile_df = create_input_df_from_input_vals(list_of_vals)\n", " display(protein_profile_df)\n", " protein_profile_numpy = protein_profile_df.to_numpy()\n", - " sample2shift = get_normfacts(protein_profile_numpy)\n", - " print(sample2shift)\n", - " print(create_distance_matrix(protein_profile_numpy, metric = 'variance'))\n", + " sample2shift = lfq_norm.get_normfacts(protein_profile_numpy)\n", + " assert sample2shift == {1: 0.0, 2: -1.2999999999999998, 3: -2.3}\n", + " print(lfq_norm.create_distance_matrix(protein_profile_numpy, metric = 'variance'))\n", " \n", - " df_normed = pd.DataFrame(apply_sampleshifts(protein_profile_numpy, sample2shift), index = protein_profile_df.index, columns = protein_profile_df.columns)\n", + " df_normed = pd.DataFrame(lfq_norm.apply_sampleshifts(protein_profile_numpy, sample2shift), index = protein_profile_df.index, columns = protein_profile_df.columns)\n", " display(df_normed)\n", "\n", "def create_input_df_from_input_vals(list_of_vals):\n", @@ -157,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -240,7 +241,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "{1: 0.0, 2: -1.2999999999999998, 3: -2.3}\n", "[[ inf 0. 0.2025 0.2025]\n", " [ inf inf 1.21 1.21 ]\n", " [ inf inf inf 0. ]\n", @@ -333,69 +333,17 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "#| include: false\n", - "def generate_randarrays(number_arrays,size_of_array):\n", - " randarray = []\n", - " for i in range(number_arrays):\n", - " shift = np.random.uniform(low=-10, high=+10)\n", - " randarray.append(np.random.normal(loc=shift, size=size_of_array))\n", - " return np.array(randarray)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "#| include: false\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def test_sampleshift(samples):\n", - " num_samples = samples.shape[0]\n", - " merged_sample = []\n", - " for i in range(num_samples):\n", - " plt.hist(samples[i])\n", - " merged_sample.extend(samples[i])\n", - " stdev = np.std(merged_sample)\n", - " print(f\"STDev {stdev}\")\n", - " assert (stdev <=1.2) \n", - " \n", - " plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "STDev 0.9815314073218193\n" + "STDev 1.00552274962018\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -405,29 +353,52 @@ } ], "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import directlfq.normalization as lfq_norm\n", + "\n", + "def generate_randarrays(number_arrays,size_of_array):\n", + " randarray = []\n", + " for i in range(number_arrays):\n", + " shift = np.random.uniform(low=-10, high=+10)\n", + " randarray.append(np.random.normal(loc=shift, size=size_of_array))\n", + " return np.array(randarray)\n", "\n", + "def test_sampleshift(samples):\n", + " num_samples = samples.shape[0]\n", + " merged_sample = []\n", + " for i in range(num_samples):\n", + " plt.hist(samples[i])\n", + " merged_sample.extend(samples[i])\n", + " stdev = np.std(merged_sample)\n", + " print(f\"STDev {stdev}\")\n", + " assert (stdev <=1.2) \n", + " \n", + " plt.show()\n", "randarray = generate_randarrays(5, 1000)\n", - "sample2shift = get_normfacts(randarray)\n", - "normalized_randarray = apply_sampleshifts(randarray, sample2shift)\n", + "sample2shift = lfq_norm.get_normfacts(randarray)\n", + "normalized_randarray = lfq_norm.apply_sampleshifts(randarray, sample2shift)\n", "test_sampleshift(normalized_randarray)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#| include: false\n", "import directlfq.visualizations as lfq_viz\n", "import directlfq.utils as lfq_utils\n", + "import directlfq.normalization as lfq_norm\n", + "\n", "def test_normalizing_between_samples(num_samples_quadratic):\n", " input_file = \"../test_data/unit_tests/protein_normalization/peptides.txt.maxquant_peptides_benchmarking.aq_reformat.tsv\"\n", " input_df = pd.read_csv(input_file, sep = '\\t')\n", " input_df = lfq_utils.index_and_log_transform_input_df(input_df)\n", " input_df = input_df[[x for x in input_df.columns if \"Shotgun\" in x]]\n", " lfq_viz.plot_withincond_fcs(input_df)\n", - " input_df_normalized = NormalizationManagerSamples(input_df, num_samples_quadratic=num_samples_quadratic).complete_dataframe\n", + " input_df_normalized = lfq_norm.NormalizationManagerSamples(input_df, num_samples_quadratic=num_samples_quadratic).complete_dataframe\n", " lfq_viz.plot_withincond_fcs(input_df_normalized)\n", " assert_that_results_scatter_around_zero(input_df_normalized)\n", "\n", @@ -442,22 +413,88 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [ { - "ename": "KeyError", - "evalue": "'None of [None, None] are in the columns'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/Users/constantin/workspace/directlfq/nbdev_nbs/02_normalization.ipynb Cell 35\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> 1\u001b[0m test_normalizing_between_samples(\u001b[39m100\u001b[39;49m)\n\u001b[1;32m 2\u001b[0m test_normalizing_between_samples(\u001b[39m3\u001b[39m)\n\u001b[1;32m 3\u001b[0m test_normalizing_between_samples(\u001b[39m1\u001b[39m)\n", - "\u001b[1;32m/Users/constantin/workspace/directlfq/nbdev_nbs/02_normalization.ipynb Cell 35\u001b[0m line \u001b[0;36m7\n\u001b[1;32m 5\u001b[0m input_file \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m../test_data/unit_tests/protein_normalization/peptides.txt.maxquant_peptides_benchmarking.aq_reformat.tsv\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 6\u001b[0m input_df \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mread_csv(input_file, sep \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39m\\t\u001b[39;00m\u001b[39m'\u001b[39m)\n\u001b[0;32m----> 7\u001b[0m input_df \u001b[39m=\u001b[39m lfq_utils\u001b[39m.\u001b[39;49mindex_and_log_transform_input_df(input_df)\n\u001b[1;32m 8\u001b[0m input_df \u001b[39m=\u001b[39m input_df[[x \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m input_df\u001b[39m.\u001b[39mcolumns \u001b[39mif\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mShotgun\u001b[39m\u001b[39m\"\u001b[39m \u001b[39min\u001b[39;00m x]]\n\u001b[1;32m 9\u001b[0m lfq_viz\u001b[39m.\u001b[39mplot_withincond_fcs(input_df)\n", - "File \u001b[0;32m~/workspace/directlfq/directlfq/utils.py:323\u001b[0m, in \u001b[0;36mindex_and_log_transform_input_df\u001b[0;34m(data_df)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mindex_and_log_transform_input_df\u001b[39m(data_df):\n\u001b[0;32m--> 323\u001b[0m data_df \u001b[39m=\u001b[39m data_df\u001b[39m.\u001b[39;49mset_index([config\u001b[39m.\u001b[39;49mPROTEIN_ID, config\u001b[39m.\u001b[39;49mQUANT_ID])\n\u001b[1;32m 324\u001b[0m \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39mlog2(data_df\u001b[39m.\u001b[39mreplace(\u001b[39m0\u001b[39m, np\u001b[39m.\u001b[39mnan))\n", - "File \u001b[0;32m~/opt/anaconda3/envs/directlfq/lib/python3.8/site-packages/pandas/util/_decorators.py:331\u001b[0m, in \u001b[0;36mdeprecate_nonkeyword_arguments..decorate..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 325\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m num_allow_args:\n\u001b[1;32m 326\u001b[0m warnings\u001b[39m.\u001b[39mwarn(\n\u001b[1;32m 327\u001b[0m msg\u001b[39m.\u001b[39mformat(arguments\u001b[39m=\u001b[39m_format_argument_list(allow_args)),\n\u001b[1;32m 328\u001b[0m \u001b[39mFutureWarning\u001b[39;00m,\n\u001b[1;32m 329\u001b[0m stacklevel\u001b[39m=\u001b[39mfind_stack_level(),\n\u001b[1;32m 330\u001b[0m )\n\u001b[0;32m--> 331\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/directlfq/lib/python3.8/site-packages/pandas/core/frame.py:6012\u001b[0m, in \u001b[0;36mDataFrame.set_index\u001b[0;34m(self, keys, drop, append, inplace, verify_integrity)\u001b[0m\n\u001b[1;32m 6009\u001b[0m missing\u001b[39m.\u001b[39mappend(col)\n\u001b[1;32m 6011\u001b[0m \u001b[39mif\u001b[39;00m missing:\n\u001b[0;32m-> 6012\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mNone of \u001b[39m\u001b[39m{\u001b[39;00mmissing\u001b[39m}\u001b[39;00m\u001b[39m are in the columns\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 6014\u001b[0m \u001b[39mif\u001b[39;00m inplace:\n\u001b[1;32m 6015\u001b[0m frame \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\n", - "\u001b[0;31mKeyError\u001b[0m: 'None of [None, None] are in the columns'" + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGwCAYAAAB7MGXBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAADGpUlEQVR4nOzde3zbdb348Vcu3+SbtGmTNm3Xdh1bNwbbAMHBYCgoinC84uF4nKKIoPgTi1w2QeZBBEWGDOYQJigc4Iii4xynU0AdQ8GJ4+JgCruydZeu9zZJc798k/z++LZp03vadG239/Px2GPNN99bujV59/P5vN9vQzqdTiOEEEIIMUmMk30DQgghhDi+STAihBBCiEklwYgQQgghJpUEI0IIIYSYVBKMCCGEEGJSSTAihBBCiEklwYgQQgghJpV5sm9gNFKpFE1NTTgcDgwGw2TfjhBCCCFGIZ1OEwgEqKqqwmgcevxjWgQjTU1N1NTUTPZtCCGEEGIMGhoamDlz5pDPT4tgxOFwAPqLKSoqmuS7EUIIIcRo+P1+ampqMp/jQ5kWwUjP1ExRUZEEI0IIIcQ0M9ISC1nAKoQQQohJJcGIEEIIISaVBCNCCCGEmFQSjAghhBBiUkkwIoQQQohJJcGIEEIIISaVBCNCCCGEmFQSjAghhBBiUkkwIoQQQohJJcGIEEIIISaVBCNCCCGEmFQSjAghhBBiUkkwIoQQQohJJcGIEEIIISaVebJvQAgh8DVAuBPspeCsmey7EUIcZRKMCCEml68B1i2BRBgUO9S9JgGJEMcZmaYRQkyucKceiJx/k/53uHOy70gIcZRJMCKEmBqKZTREiOOVTNMIIY6unvUhoK8REUIc9yQYEUIcPX3Xh4C+RuTSRyb3noQQk06CESHE0dOzPqQnANlwtawREUJIMCKEOEp8DdCxV//aPX9y70UIMaVIMCKEmHj903ftpTIiIoTIkGBECDHx+k7PzFqq1xGRYEQI0U1Se4UQE6v/9Ez/gmZdDUf/noQQU4qMjAghJs5g0zM97KX6tr+uHvicEOK4IsGIEGLiDDY908NZo5d+7+lJI9M2Qhy3JBgRQky8waZnQN/Ws12CESGOW7JmRAgxtXTs1ad3hBDHDQlGhBBTQ88akg1X6+tMJCAR4rghwYgQYmroWUNy6SPSvVeI44ysGRFCTB1Sf0SI45KMjAghhBBiUkkwIoQQQohJJdM0QoicaL4oqZCGscCM2alO9u0IIY4BEowIIUZN80VpvW8b6UQKg2KkYsViCUiEEOMm0zRCiFFLhTTSiRSOD9SQTqSIH/ATbwyi+aKTfWtCiGlMRkaEEDmzVBdiUIx41u8BkFESIcS4SDAihMiZyalSsWIxqZCG1hbGs34PqZAGzjxfyNfQ27tmsHLyQohjggQjQogR9Sxa1drCmW1mp5r/4KOvriPw+Id7O/7WvSYBiRDHKAlGhBDD6rtoFfQpGWPBUXjr6On4e/5N8NfV+mMJRoQ4JkkwIoQYVs+i1ZJlJ2Eutx/9lN5iCUCEONZJMCKEGBVzuR1LdeFk34YQ4hgkqb1CiKmpS7r2CnG8kJERIUReZVVoHcsJ7KX6gtW/rtb/tpfm+xaFEFOMBCNCiLwZUKH187bc32ScNXrmTE9Kr3TxFeKYJ9M0Qoi86V+hNdV8cGwnctZA1emSPSPEcUJGRoQQeZFVg8Ta/fWf7wSrTLUIIYYnwYgQYlCDFTobjLHAPKA0vNEY0p/8wK1w+lkywiGEGJYEI0KIAXIpdGbuUxoe9OAkdXCH/qTzBAlEhBAjkmBECDFAroXO+peGj0/8LQohjiE5L2D961//ysc//nGqqqowGAz89re/HfGYF198kXe/+91YrVbmzZvHE088MYZbFUIcbT2FzqQbrxBiIuUcjIRCId71rnexbt26Ue1/4MABPvrRj3LBBRewfft2brjhBr785S/zpz/9KeebFUIIIcSxJ+dpmg9/+MN8+MMfHvX+Dz/8MHPmzOG+++4DYMGCBfztb3/jhz/8IRdffHGulxdCCCHEMWbC64xs3bqVCy+8MGvbxRdfzNatW4c8JhaL4ff7s/4IIaYJXwP4DuV0SDTahD/wNtFo0wTdlBBiKpvwBawtLS1UVFRkbauoqMDv9xOJRLDZbAOOWbVqFXfcccdE35oQIp98DdCxB9ZfDrFK4H5Qi0c8LBptYusrF5FKRTAabSw9ZxOqWjXx9yuEmDKmZAXWlStX0tXVlfnT0CANs4SY0nwNsG4J/Pw/9McfWa3/7Zgx4qHxhIdUKsLs2XWkUhHiCc8E3qgQYiqa8JGRGTNm0NramrWttbWVoqKiQUdFAKxWK1ardaJvTQiRL+FOSITh0kdg1lIIuYA3czqFqlZPzL0JIaa8CR8ZWbp0KS+88ELWtueff56lS5dO9KWFEEebe74UORNC5CznYCQYDLJ9+3a2b98O6Km727dv5/Dhw4A+xfKFL3whs/9Xv/pV6uvrufnmm9m9ezc//vGPefrpp7nxxhvz8wqEEEIIMa3lPE3zj3/8gwsuuCDzePny5QBcccUVPPHEEzQ3N2cCE4A5c+bw7LPPcuONN3L//fczc+ZMHn30UUnrFeI40NPXZqQKrkKI41vOwcj73/9+0un0kM8PVl31/e9/P2++mdv8sRBicmi+6IjN8UYyWPO8ihWLJSARQgxKetMIITL6NsgbrjneSPo2z9PawnjW79Eb6TnHcXMde8FeKmtShDgGSTAihMjo2yDPMqdoXCMZ/ZvnjZm9FBQ7bLha/7vuNQlIhDjGTMk6I0KIyWUut0+dKRVnjR6AXPqInj4c7pzsOxJC5JmMjAghpj5nzbiDEH9HG5F+rSVsRUUUucvHdV4hxPhJMCKEmF469up/57B+xN/RxuPLr0GLxbK2m61WrlzzkAQkQkwyCUaEENND37UjkNP6kYjfjxaL8ZFrV1BSre/vaWzguQfvI+L3SzAixCSTYEQIkTtfQ++0ib306FyzZ+1IuFMfHdlwtf51DotZS6prqKidN4E3KYQYCwlGhBC56WmKl+iuRaLY9cWloxSNNmWa4VmUkhH36dlPVav0wEMyaYQ45kgwIoTITd+meNA7QjEK0WgTW1+5iFQqAoDRaOOURWuy9olFm9i27TOZfXr2W3rOJj0gEUIccyQYEUKMjXt+zofEEx5SqQiLFuoByI6dy4knvP328Wb2sRfMJRza372fR4IRIY5REowIIY46e8HcUe1T5Dgl8zgc2t87XSOEOKZIMCKEmFTRaOOwjy1KCUajjR07l/dO1/R5PtHUhOb1Yna5UKokUBFiOpJgRAgxKXqCjIMH12E02iiwz8163LO4VVWrWHrOJny+13una7rPkWjtYP9VV5GORDDYbMx99hmUqqoBBc48jQ2T8AqFEKMlwYgQYlL0BBnxhCcz/dL/cd99B5va0Q69TToSofSar9L50MNoXi8Ri3nIAme2oqIJf11CiNxJMCKEGFajL4I3FM88VjuC5KtSh6pWDQg6RrUmpKcA2p/vBMpQnLbMU4MVOAMp/S7EVCbBiBAioy0QBWB/W4AkSTpDcb765DYiiWRmn0WGAzxrhbZgjPJC6+TcaE8BtBd/DZt+AvHggF2kwJkQ04cEI0IIQB8Buebnb/AQNq5fv529pACwKSb+56ollBZYAGjfa4GXwB9J5BSMRBPNhEP783fDzhpwnjDoU2o8gbZvH5FITBa2CjENSDAihADAG4oT0/QRkPuXnU6y3A6Aq8BCdZ9pkH0dtkGPH05C7WTbga+SSkezFqeOxUgpvsm2Ns7f04D/uhvxQ9bCViHE1CTBiBBigLnlDizVhXk7X1IJkEpHWbRwDU7nWWOqFTJYiu9g0n4/5lSagptWUFxeQdNNN6N5vRKMCDGFSTAihEDzRTG1hTkB44Rex5qqGXPRssFSfJV++8Tr60m2tQJgqpmJpXrkPjb9035loasQR58EI0Ic5zRflNb7tuFIpPgOdtJmA8aC/L01GAvMGMx6kON5cheO/7cQs1Md4ajBDZXiay52YLDZaLrpZgA0owHDCGm8tqIizFYrzz14X/a5rFauXPOQBCRCHEUSjAhxnEuFNNKJFKGLavj6pl388PNnUjPGYGEwZqdKyeULOLgb0lqKVEgDZ95Or1+j3M3cZ59B83rxNDbw24d+yKfKyyESG/KYInc5V655aEBxtOcevI+I3y/BiBBHkQQjQggAUi4re0mRdljyfm5Tns9p8kB8dz3pw72l45WqKpSqKsw2K1FL/wmcwRW5yyXoEGIKkGBECDGtaC3tlH1XoT3+TQAMphTmYsck35UQYjwkGBFCTCspXwBj3IDru9dRXD4D87NfQqlwT/ZtCSHGQYIRIcSEiEabMn1mJoI2I01iZhpDSXpAVk1/8fp6ACmAJsQUJcGIEMcxzRdFawvn/bzRaBNbX7mIVCqC0Whj7twV4z5noqkJzeuFwz4A6uvXkNDSGM90Me/Q21iiel2Uvqm6ZpcrK8tGCqAJMTVJMCLEcaB/szsAp5bG8OgO0okUBsVIypa/t4N4wkMqFeHEE29l//77eOedOzEaVEyJsa3tSDQ1sf+jHyMdiQBgUFVOec+P6ep6lXr/Izz/zE8ItjxJIqiPkfR06FXc5Zksm3h9vRRAE2KKkmBEiGNcoy/Chfe9lNXsDuBUs8JDmo3QRTVoVQW8E4kPcYaxczrPYuk5m4gnPNBpxf+nlhGPyYyA0Dutonm9pCMRqlbfg6W2NrM9tLWRZMLACR9swmCwcmL1o1jM5VmFy3qybIQQU5cEI0Ic47yhOJFEkrXLTmdeuT6V0RmKc+/P3gTg65t2ZTXFcxWMIQ23q2HIp1S1ClWtIu4P4mf4YGTACEj3tEoPS20ttkWLeh8bS9j99FwuvupcjsR+RnFlEUUO6dQrxHQjwYgQx4l55YWcUl2ceTz38++GJ3YN2xRvRPZSUOzw19X63/bSEQ/pWaNiLDAPqMTadwQEyEyrDCcRVLAaZoz+noUQU44EI0Icp8odKm2MsymeswbqXoNwpx6IOIfuBWMsMGNQjHjW7wHAoBipWLF40NLwltrasd2PEGJakmBECDE+zpphg5AeZqdKxYrFpEIaWlsYz/o9E1IaXggx/UgwIoQ4asxOVYIPIcQAEowIISbNcOtHJooUQBNi6pFgRAhx1A21fmTMAs2MVIZVCqAJMXVJMCLEMa41oZFyKLwTjZEK6CMRJYqZMfWq9TVg9e3L2tS37Luqju6Dfcj1I7mydWcHvf4InKtCoBUcpwy6q1JVJQXQhJiiJBgR4hh2JBrnSwePED+3nGsON8FhfbvNaOTPJ9SM2NMli68B1i2hJhEmnLaSVEsGlH1fes6mnAKS0awf6ZlWGVRhhf73WVcDTxLu2oGlZMGQ9yAF0ISYmoyTfQNCiInjSWhE02mUf3l4aFYVm86cz7oFs4ikUniSyZFP0Fe4ExJhGi64nwtjq0kUVmfKvs+eXUcqFSGe8BCNNhEO7R/3vfedVmm66WYMNhtml2vQfU1F8zAm0+xovp+tr1xENNo07usLIY4eGRkR4jhgCGqcqFo5xWEf97liznk00ZW1TVWr9eeiTWzb9pnMSMl4Ovb2nVaB4RecWowlLP2HF98n72BH8/3EE55Rj9AIISafBCNCiLyJJ7ykUhEWLVyD03nWuAOCXKZV1FgKu3XmuK4nhJgcEowIIfLOXjB3WoxMSJqvEFODBCNCHGeSAb07b9ITneQ7mTxDpfkKISaHBCNCTCNHonE8id4U2BLFzEx19F12NV+Uzid3wRIb/k2HqFaMGAuOv7eBodJ8sVkn+9aEOC4df+9CQkxTR6Jxznt1N5FUKrPNZjSy5eyTRx2QpEIaaPrxrs+cREVp4VGrfJoP/o42In5/5rGnsWHM55I0XyGmDglGhJgmPAmNSCrFugWzOLFA5Z1QlLpdh/EktJxGR3oo5XbMjrEHIvvagiSiQQAavZExn2e0/B1tPL78GrRYLGu72WrFVjj+LCEhxOSRYESIaebEApXT8pCiO1ZFNgWbYuKG9duZ5WjgO0vhgT+/wxcXgS8cn7DrRvx+tFiMj1y7gpLq3i7BtqIiiuJSV0SI6UyCESFETsoLrWxe8T68oTiJ6C48h+AzZ82CMIRiORZSG4OS6hoqaudlb2ySYESI6UyCESFERsATJRpMZG1TCxUcJdnTOdVOG9VOG/5AIZ5DUOaw0t32RgghcibBiBDT3DuhoVN0h3uuv4AnylO3v4IWT2VtN1uMXHb7OThGcY6U1jzq6wkhRA8JRoSYpkoUMzajkbpdh4fdTzUYSCdSw+4DEA0m0OIpLrxyISWVBQB4mkNsfnwn0WACxzDvFkaTk1jSAp2PjrsM/FTQP0vHVlREkXtMfY6FEKMgwYgQ09RM1cKWs0/OqjsymPbOCF+KHhn1eUsqCyibNZpxkF4mZQa3vvwt/vvyE1lQPWvyqq/6Do3rcFtREWarlecevC9ru9lq5co1D0lAIsQEGVMwsm7dOlavXk1LSwvvete7eOCBB1iyZMmQ+69du5aHHnqIw4cP43a7+dSnPsWqVatQ1elT30CIqWimahkxrfdtf2LY50fiN6TY3R6g1RTHlS6leoj9PNESFHUBqlo8ruuNib0UFDv8+XvwbhcEWsFxSs6nKXKXc+WahwbUMnnuwfuI+P0SjAgxQXIORtavX8/y5ct5+OGHOfvss1m7di0XX3wxe/bsobx84A/qU089xS233MJjjz3Gueeey969e/niF7+IwWBgzZo1eXkRQojhVWDA1BZGw5TTcS2BKI8VxfjJ/74JgI3VbA5oQwYkk8ZZA3WvQf3/ge9BiHaNfMwQitzlEnQIcZQZcz1gzZo1XH311Vx55ZUsXLiQhx9+GLvdzmOPPTbo/n//+995z3vew2WXXcbs2bO56KKL+OxnP8trr7025DVisRh+vz/rjxBibAyBOD+nEMf6fXjW7wHz6H7sG30R3mzuImGA7154EmsvchFBxRsZef3JpHDWgPOEyb4LIcQY5BSMxONxtm3bxoUXXth7AqORCy+8kK1btw56zLnnnsu2bdsywUd9fT3PPfccH/nIR4a8zqpVqyguLs78qampGXJfIcTwjBENGwZCF9VQ/vUzKL18wYjHNPoiXHjfS9y2eQ9KGuaYLJSmDAB4O5IEjuMme0KI/Mtpmqajo4NkMklFRUXW9oqKCnbv3j3oMZdddhkdHR28973vJZ1Oo2kaX/3qV/nWt7415HVWrlzJ8uXLM4/9fr8EJEKMU8plxVJdiGkUBUG8oTiRRJJVH11Ew//V86/1+2g1pcABz/8mxM7fvcJlt58DylG48TEIx45A4G0ALErJ5C2oFUKMyoRn07z44ovcdddd/PjHP+bss89m3759XH/99Xzve9/j29/+9qDHWK1WrFbpninEZDu11sXHvnMu0WCC3Xvf5mebYyy5wMahzTGiwQRW12TfYTaLyYExmWZH8/3QfD8ARqONpedskoBEiCksp2DE7XZjMplobW3N2t7a2sqMGTMGPebb3/42l19+OV/+8pcBOPXUUwmFQnzlK1/hv/7rvzAac162IoQ4ihwlKo4SlVaPvvi12Dl1f2ZVpYyl//ASX/bfUDafcGg/O3YuJ57wjDoYSTQ1oXm9AJhdUyzaEuIYlVMwYrFYWLx4MS+88AKf/OQnAUilUrzwwgtce+21gx4TDocHBBwmk/6mlk6nx3DLQggxNDWWQlVrx5Tam2hqYv9HP0Y6onchNthsFD30YL5vUQjRT87TNMuXL+eKK67gzDPPZMmSJaxdu5ZQKMSVV14JwBe+8AWqq6tZtWoVAB//+MdZs2YNZ5xxRmaa5tvf/jYf//jHM0GJEEJMBZrXSzoSoWr1PQA03XQzacnmE2LC5RyMLFu2jPb2dm677TZaWlo4/fTT+eMf/5hZ1Hr48OGskZBbb70Vg8HArbfeSmNjI2VlZXz84x/n+9//fv5ehRDiqPM0h1Cj+mLYcEcUR3e2zbHAUls72bcgxHFlTAtYr7322iGnZV588cXsC5jNfOc73+E73/nOWC4lhJhijsSSdFjTbFz/Nyrde6k6B3b95gBX+WcR7Yoz9SqiCSGmOulNI8Rx6l9tAbwt+siGy2jE2hEfdn+XzYiNKCu3ADawmEzUzXsZNTqDOe9fwO7fhkmEh++TM5XF6+sn+xaEOG5JMCLEcUbv9mvgG4ebM9sULc01f+ii1GJELVQgEhtwXLXDzGbrTXj//Vc0YOD6pxv44Rtfw6YYuf5sF62mIP9q6sLRaM8c4yqwUO20jeq+tLYwqdjwAdFEMLtcGGw2mm66GdAXrZpdrkxGjRBi4kkwIsRxZqZqYePMGp5+9C3O/kQtHUUmVra18Z5rTuHdpYU4SlRoHBiMAFQbOqkutzDLYebO99yFaryNb/7NwN1/2wcO4OX98Pf9mf1tionNK943bEBiLDBjUIx41u8hFWzI98sdkVJVxdxnn8lK51WqqiQYEeIokmBEiGNMoy+CN9Q7wtDkibCw3z6VikKlN8k51U6aXSZoa8M1w47DMbpO2lp7O6U2L+5VN/FwRwnNZSez5aTP8mxBgrXLTmdeeSH72oLcsH473lB82GDE7FSpWLGY+AE/7T85NJaXPG5KVRVKlRRFE2KySDAixDGkp6dMJJHMbJuPkccoxGEbuXZ7TyCzry047H5JfwCAshuuZ3aqBtsdD7AzpWfRzSsv5JTq4mHPD9lTOOmwh6SviVSgZeQXKYQ45kgwIsQUdSQax5PoXRD6Tmjk5nQ9PWV6RicATG1hWL+P8n6jHn5Dit3tAeJGfXt7V5RlP3ktE8jYFBOuAsuw11OqZ2JRRpcG2z9Q6pnCKQ97swuNqapUPhXiOCPBiBBT0JFonPNe3U0klcrabjMaKVH0H9vmYDPeWPa6ho6oXkiw7+hEHBNt/c7fEojyWFGMn/zvm1gVIywtwx9OZAUyuSw+HY2+gRKQmcIp8emFxspXfpfg1hjur5wjUyZCHGckGBFiCvIkNCKpFOsWzOLEgt4RjRLFzEzVQnOwmUs2XkJEi2QdZzWqGMw3jHh+XzRBwgBXLZ7FY9sOY0j0Bj3DTbPkQ8+ITX+WWXMw7YqgVAze50oIceySYESIKezEApXTHPYB270xLxEtwqrzVlFbrE+T1HfVs3LLSgzm0KjPX+kYZXdsXwN07B31eYcT3b9/5J2OksFGl1xWF5WFlZN0R0IcnyQYEWIaqy2uZWFp/1yZPPM1wLolkAiTiBegHfaQ6DwCQ8zgaO3tMMjIitbeDkBzdz0PLrhR3zbyutoJMdToks1sY+MlG3FOzm0JcVySYEQIgSGo0dA5xIhKuFMPRM5fzf7lPya9oY54TQpWgqnIgVl1gbV3hOXv37oT7roVj+rIOo3W3XCu7Ibr9Q3/7N5WOsrRmTwbbnTJG/NKMCLEUSTBiBDHGKOljQP+PRjVQlxWF6XoQYG3JYQxmQagq0PPzHGqir6A9S0va97yYlWMtKaTpALhzPqUHpqxjHQ0RtXqe4jXpOnw3Ii5rAzFUUXNj+7H9mg9qgHuOe0/4Vd7sJqNA28OMFd3N6/5Z/Ogzx9tR2V0SQgxLAlGhDhGuKwurEYVqtfzrdfWA/qUw68W/AIL8PxjO+jqLj/SakqBA2aVF/CLunP51GvvEEuniCpGPvfOYf1Yo5EtZ59MRWsHmkchfrgR0DvaGmalwdN7bXNZGUXpg/z8vAqa77iFyK3f5+aXO0a85/quBGoyganPNq1N75djLDBjdo6uCJsQYnqTYESIY0RlYSX3nvtzrnryJe5fdjoGaxsrt6zE5w9QDpz9iVqcC0oB2N0e4Gf/+yYFxVZOmVHM3y46bUBNk7pdh2lraiZ45TdIR8tg07pM35ZE30ikjwqbmYKuRkLFwy8EcakmrFqcm1/uYK7vCA8CHckklu6y8AAGxUjFisUSkAhxHJBgRIhjiFudQSpazZyikzCq2Sm0RW4bZbP0KZtWU3b9kpmqJWtKpkfSH9CnZs7xYvniQ5jnn41SVUUkMHgw0uXVCBfW4PfqgY09NehuVBWY+ekL91Bw/zraOwrgRQiZoGbFYlIhDa0trPeqCWnkY/FGOLQfi1KCqkr9EiGmIglGhDiGlSVcmLuGiAhyYCnSsM2fA0MUI1MLFcwWIy9t8sOZt9C6yQ8OuCRkIdoVh+qBx5RHfMwutbI/2ZuWY3aqeQk+MvetlGA02tixczlGo42l52ySgESIKWjwFWZCiGnP4E/y0/23UbI1gpZOY1An7ncPR4nKZbefwyeWlXDWP+7m/IuKAFAwkAhrIxw9cVS1iqXnbGLRwjWkUhHiicFHdIQQk0tGRoSYgjrC+uLPel895rj+O8Noi3E5UgYCzWGswQSOtJXmUyy89XKIjzuG7zOTaGpC8+oFwDTb4FVSh71uiYq5XCEYbMDo6vPWcugAEZsHrbGR/r//BP/6VxJBLWsBa1+exgYMMSXz9ah17AV7KThrUNUq7AVzc3ot9V310AUG4HD4CEF18gIqIY4HEowIMcU0B5tZ/tJyKLuVW7bcgpI4BPQW4xouIIl2xbnKb+WNR3dRbIJyh8KerSESihG1cOhFpYmmpqxmdUfmnQQrbs/L6zGtup2DwQbai6vhghsxFxWRjutdfzvu/xEqEDUpGJK9nYZDPn0E47kH7sUbb81sN1ut2IqKhr6YvRQUO2y4Wv+77jVw1oz6Xl1WFzazjZVbVjKnJc0PgFV71tJwvpF/j7ZTwbycXrsQYnQkGBFiivHGvEQ1vQ7I3efdzXy7MasY13DBSCKsYcHAyZ+cjUv1wR9DLPxPJyeethBHydBZKZpXb1ZXtfoeAPb+6Md5eS2dxhT7P/dVlrxnLpXRJDzXjLmsDIMvBoD7+us4EIG6gw4esvTeXyykF2B7z7LP41zYG0zYiooocpcPfUFnjR6AHN6qByThzkww4tUM7PEeoKB7pKm+q37A4ZWFlWy8ZKNeIn5PPTx+E1eecBm3xX5JQ9M7VKhlo78XIcSoSTAixBRW66xlYZ/eND0foIN9kPZld9uw24P61+XmrECkOdhMfVdL5jxG1Yojok8LWWprs86zL5nGXjObYHExlQmYOcr7dqkmrEZ4tiDBs61WbL9v5qaLTwKyC50Vnn8+xs4Y7W2DF0ArLp9BRW2OoxHOGj0I6aMl3MGqFpV487eyttvMNlxWV9a2ysJKKgsriRSnOQjMcp0ALfDy+ifZ7X86s5/ZauXKNQ9JQCJEHkgwIsQ00Hf6oMdgH6SDaQweIdWp/6h7o15ufPFGggEXcB23/PUWTLYmTm638N0+xxQHA9iAG/1J+NYq/XoHUvyh4C1mF5aOeM2qAjP3nlLM6y9HqVqscP+BCN99Zic2xYSrwAK+gcdojY1Edlgxu0Z+TaPWvXakKxYgnjZw25l1LJpxfubp0azDsTmKoQVO+dJnmGXXw7Gutlb+8eRTRPx+CUaEyAMJRoSYBrKmD7qN9EFapDhI0cUDbzzI/l29iz9tZhvfOvtb3HowyN0Lv4ka3ctv3n4g69gKbyfPl5oJBVvoXHc7+z/l5mnTZex6+Yd4rF5OXPyjEe/ZbTVSkTTyrmKFzSuW4A3FcRVYqHbaiDT27mcuKgKaaV97Pwe7GjHYbBTe/eDovzmD6b925D/0gGq2ozrn0u8OiwOb2caqPWuztpvPN8g6EiHyRIIRIaaJnumD0XLby2jjCHeffzepit4fdZfVRWeXHfgbhlvvo6atnuuAtKqPSvRk1MyMtWJ94XMYTozygX/C1fwFgKQR2mv35XTv1U4b1c7B2/yay8qAPVSuvoeqrkaabrqZVCiEkXFUXu2/diQeHPOp3Db3gEBw+ztbWbVnLX7NP/Z7FEJkSDAixDGutrgWS2l2qm5nV5f+RSxG+rbruaXhQe7+2P0oVVWZYIRYF4ZklEN7i3ljWTU/NtzIj50NnPjn72KMjv3DfShHHBW41KGSfMdgkLUjYxGvr8cJuF0ulO6ibzmlGQshRiTBiBDHkUZfBG8ozr62PsHE7JkcSBhgRln2zq1vAxALm+l0FPCWYT4RV/7rJLoKLNgUEzes347NZOBhm5M5eb9K7swuFwabjaabbgbAYLMx99lnMgGJECJ/JBgRYoo4Eo3jSWjUh1MklUHqp49Toy/Chfe9RCSh1/OwmQwUxUMDdwx01/X42/1QDFppesAusVh73u6r2mlj84r38foBDzes347fUpC3c4+HUlXF3GefQfN6idfX03TTzWherwQjQkwACUaEmAKOROOc9+puIqnuPjLua1ANUKLk70fUG4oTSSRZu+x05pUXYms8SPzXPgaEGlF9Ciex5LOoe54k+IkURvTqrWaTHig0Nz2NsdiBRSkZ8bqtgRhvN3ZlHrsKLPQ/qtppw1uee9XXiaZUVUnwIcRRIMGIEFOAJ6ERSaVYt2AWpkQTt2y5hYcu+MGgnXTHa155IadUFxPxmTk4zH7RaAIHUPg7IyfVrYQuUCx62u3CRWswz1w6bNO5gu5eOE++cohtu8OZ7TbFxJ8+KumwQoheEowIMYWcWKBijhtREoeosBiO6rUzhdRMXRhMabwbn6fsdFACVmzOWdDVm01SaJ8LI3S/ddn1QOobH5qP45xFAOxrC+pTMZHEkP1o8qE52Kxnv/gPgkXhYHevHyHE1CTBiBDTWM+C1B4NnvAwew+up47G/X+5CVdSnyYqvyrJrRVLYd8zlN/0DSJlZXDIO8KZesXr60l0GQEbM0vs1FQX53xfY9UcbOaSjZcQ0fQ+O1RXwp5fYzGkKbY6jtp9CCFGT4IRIaap/gtSAco1A1egUmTr/dFuCkQJNiazM2j6cNvc/P6Chyh77CMYu3viABB4hqQRjFWzR31PfTNQAoU1cOYtBOJW2g/rjfECbWEcqYkd8fHGvES0CKvOW0VtXIMNXyb0sds51LKWGXb3hF5bCDE2EowIMU31X5AKEGgO88ajuyh36AXDWkhx+c9fJ6LpIx6Zcuz9VGACLQqXPkJ9sIlb3n6IO0+6lLbQLzmtaMao76lvBkowkOTNX3Ty91/uQEm8mtnnBiCx2zuh0zSg11dZGItDPIG/sAq/eWBWkBBiapBgRIhprmdBKkB70sgbfZ7rIk1ES2UClp5y7ENyzydqsbDLaiHiqiaWzD1k6MlAsQGfLjpAy2eXQyyavdM2vW7HYH1oDjvKUUMpXKRG3ZhvtMKh/ZmvLUrJsAtwhRBHjwQjQhxjbAZItYfRjL3TIX0Dlrzo2Jv92F6qVzztR02HIRalavU9WGpreWtnB7t+e4AFn5zDGe85MStt1lVgwWYysPrMz8EODZUgvwqXMPpxmaFZTA6MRhs7di7PbDMabSw9Z5MEJEJMARKMCDGNOVIGAs1h2pN6ZVTvfh8fKDKT+N+9eACD2QBa/q6n2Up6G9D1pdj1XjCDBCQAltpabIsWEfTsxevy4S1x0Q7Q1JTZxwA8/v5C9t2zlvZLruD+I2Z8seSg58uVqpSx9JxNxBMeQB8h2bFzOfGER4IRIaYACUaEmGTNwWbqfXoPlXpfPebEwVEdF+2Kc5XfyhuP7spMzRSb4P0OBdtHa3HUFtMRCMMTr+ftXhNFM/Wgo2/Pl469enByeOvAXjABT+ZLn8/Hyy8+TdKtsXXLm2zdMsRF3nManW17gEWEY5G83buqVkngIcQUJcGIEJOoJw3VbyiHyju5ZcstKIlD2Mw2XNaB6yn6SoQ1LBg4+ZOzOW2h3lcm1R4m8b97cdQWY6kuxNw4cGQh0dREsnEXWv0OVFccg3cPJHMYPnHWZI+A2EsHHy0B8DsAPZ02HA6TTGo4fCdxyscXceqCgZktse6y63s/fx2/b4BYIj5gHyHEsUeCESEmUU8a6teXfJ3vtcDd593NfLsRl9VFZWHlqM5hd9som6V/4MdNBtqG2TfR1MShT11M7QcaUM1pHBcDm6/Un1TsemDhP5jbi3DWDBwtAX3E5NGv0ROM9DBpdoqKy6iqGvj6Il4vUa+XQoua2z0cJfF6vTCcsUOvuXI4fISdnTszz+fy7yaE6CXBiBBTQHVhNaBR66xlocM+YdfRvF5M6TBGc5r4ku9gmHkqiru7W2/PItSWbQAcibahAgd89RwY6cT9R0uOMf07+DqtFiq+CKv2rIU9azP72cw2Nl6yUQISIXIkwYgQxynL6R+AqtMHbHcphcwwJPnfQ//L5aVwy5aVHGAOVN5JR7gDHLOO2j0GIiGa+ixyBbDb7TidzqN2DzB4B9+PvzyDxbfdQkm1HoTVd9WzcstKvDGvBCNC5EiCESGOQSNVXR2Oy5xmZWWUtMmAwWjlngvW8VdfjO+1wNuBLtz23pLzJYo5L838/B1tRPx+Ys2NdNksJKNRQOH1vW9Tv++1rH0VRaGuri4TkGT60HTL9NjJs/4dfO0xM6VdFkoK9dfvCSqDXl+mboQYmQQjQhxjRlt1dSjxZIC0ycCiyutxzvkUqlpFBzugKchdDVbuauitMWIzGtly9snjCkj8HW08vvwatFhM3zC/huibr0P5B7j47Pfx7jN6p386OjrYsGEDhw8fJhwO0xZp48t//zKxVCzrnJkFwLHWMd/XSEwWhecevC/zOKhqmN9nYOWWlQPuRaZuhBieBCNCHGNyrro6BLt1ZiYVtsJioKT5m9z1vgepddYC8E4oSt2uw3gS2riCkYjfjxaL8ZFrV1AQS9B00034vvh5HmkGd0LFnS6iRdPwmw2ELCliJjsbNmwAwGvxEquOcVbbWbjSLj796U/jcDh6RyP8ExeMfGL5t0hW9pZk8zQ2wKM/4IMrbpSpGyFyJMGIEJPgSDSOJ6FRH06RUE7gcCz/fVNmBlqZa/FhNrhgDMFIf6ZkJ/PtxglbYFtSXUOJaieMifZfPw3nfonQK17+9co2Pk+QnoLyqnIqT31+ATMcFt7xv8OfX/0zl5x3CW/+8U1qLDVUlR6dWiIFThe22nlZ2wqjZk4snEtF6bwhjhJCDEaCESGOsiPROOe9uptISp9GofJO7mpIYjMaKVHy9yPZfNPNFHQ1YrDZmPvsM1nrHaaqnoWiwX0t8Fwzkdcfxf7lrxP9Z5B7LzoZs0vlhvXbsRS6qKoqxmf1ARz1Ba3Qm+ZrdrmmxfdWiKlMghEhjjJPQiOSSrFuwSxMiSZu2XILd593N2eWzc/LYtAeZTdcT1UhNN10M+Ft27B0Z4JMdUpVFWq6AGgmHWzBWKiXup/rsqOUT1za82j1T/PtCfaEEGMnwYgQk+TEAhVz3IiSOMR8uzGvgQiAuboa+7wZKCVmPHfdkNludRvzep3BBDxRos0a0dQcAoUuOtoSBKJRjEnrhF97og2W5qt5vWCb/q9NiMkiwYgQxzDFnmTuR9oxaJH+T+hFzvqJRpsIx46M65oBT5Snbn8FLZ4CfgBnAus9gIcSw5loxvz1m+mvo6Mj67E9GMY5Adfpn+YrhBgfCUaEOIa0ttQTNLzDImLYAwE4vE8PRC59BNzze3fsqbbaRzTaxNZXLiKVimBMprGYHIxFNJhAi6e48N8LsP/+WppfcVG5+h6a4lb+8Ztm9P68+aWqKoqiZLJseihmE3U4JiQgEULkjwQjQhwjWg6/Q+nvLuQSa4xLAF7v/qPYYdbSEcu1xxMeUqkIiwo/jfOFh1EXlY3rfkrcJgqNBwgGg7gNB4iYCwETBQZfTufR2vRuO0mvd8g1Iw6Hg7q6OsLh3oJsPTVJwtgkGBFiihvT5PG6deuYPXs2qqpy9tln89prrw27v8/no66ujsrKSqxWK/Pnz+e5554b0w0LIQYX9LZiN8R4MX4Db7y2hOiFj8NXXtKb2I2mb0xAr8lh/+tPUFPqoNM4OVGLwdzd8G7D1bj+rC/4/FjRA1giTcMc2IfVivepXwLQuvpetPb2IXd1Op1UVVVl/rjdA7sCCyGmppxHRtavX8/y5ct5+OGHOfvss1m7di0XX3wxe/bsoby8fMD+8XicD33oQ5SXl/N///d/VFdXc+jQoUlJxRNiKugI6+sa6n31mBMH835+e3oWBZ2vkHadBFWLRn9gtEv/+wPfhtpPjbrxXdQbo92bzDz2NIf0Lxwz4NM/g+fq4NJH8CYL4X/BbEigxL1DnC1bzY/uJ9bghZfbSMfjaH5/5rlGX4T93eXu2wIxFo4zdhJCTJ6cg5E1a9Zw9dVXc+WVetvxhx9+mGeffZbHHnuMW265ZcD+jz32GB6Ph7///e8oit67Yfbs2eO7ayGmqeZgM8tfWg5lt3LLlltQEod6S5dPFc4TRh2IFIWSbFv9T15PpLK2my1G1EIFHBX6hrL5aFEbcDCnWzGXlZFOFwBtWdsbfRH+8+GtxEyHKZgD1/x8G5uvPXlMlWaFEJMvp2AkHo+zbds2Vq7s7b1gNBq58MIL2bp166DH/O53v2Pp0qXU1dWxceNGysrKuOyyy/jmN7+JyWQa9JhYLEYs1ttrwt/ntyEhpjNvzEtU02uJ3n3e3cy3G6dNI7XCmItAY4L2UACAYCjKrHaNVCLFhVcupKSyILOvWqjgKFGJNI/vmvvagmje6IDt3lCcSCLJzf82n4f2QUxL4Q3Fcw5GwqH9WJSSTNl7IcTkyCkY6ejoIJlMUlFRkbW9oqKC3bt3D3pMfX09f/7zn/nc5z7Hc889x759+/ja175GIpHgO9/5zqDHrFq1ijvuuCOXWxNi2ql11k5YafXxCniiRIOJzOPOphjLtq/kH2908g86M9v/HTAqRqpOdOIoUUd9/qgvRvthPajxtoQHPO8qsGBTTNywfjsAKlCciNCpdWJUG2mO2DCqjRjHOKJkUUowGm3s2Lkco9HG0nM2SUAixCSa8GyaVCpFeXk5P/3pTzGZTCxevJjGxkZWr149ZDCycuVKli9fnnns9/upqRndsLEQYnxCfgO/W9tTJ6QPI5z2RRcnV+l9V94JRfnazkP89Ky5AwIRn89HOBwm2b3gtKO9HV+yKPP8gb808frzrwOQ0vSFs2F/PPN8tdPG5hXvwxuKk2gLk1y/l6ji41sN36RgToLHDkLBHFi3A6xGlaBWwL7u9SOjaQyoqlUsPWcTPt/r7Ni5nHjCI8GIEJMop2DE7XZjMplobc3uhNna2sqMGTMGPaayshJFUbKmZBYsWEBLSwvxeByLZWDVSavVitUq1QyFmAzRsFGvE9Jn6qXeV88Nr3ydi058mLJSvf5Ic8BES4sZ1ZX9s+rz+Vi3bh2JRAKXx8NFwIYNGwg4ZuHi3QAs+Pc5VJ54FgAHtu9kyy8gFtayzlPttFHttBHHRBtG3i4yEydBpHEZy3bu5Jfz3s/9y05nZnEZl+3dkxlFsSkmNq9434jVTFS1CnvB3PF9s4QQeZFTaq/FYmHx4sW88MILmW2pVIoXXniBpUuXDnrMe97zHvbt20cq1ftb1t69e6msrBw0EBFC5E7zRdE8A9dWjEdJZQFlsxyUzXLgqFYIWkeXARMOh0kkElx66aVceumlAFlfA9jdaubcRe7RrfMov+kmAFLxctztCqloNXOKTuKMqjlsXvE+nvn6e1m77HQiiSTeUDz74I694GsY1XWEEEdfztM0y5cv54orruDMM89kyZIlrF27llAolMmu+cIXvkB1dTWrVq0C4JprruHBBx/k+uuv5+tf/zrvvPMOd911F9ddd11+X4kQxylTOEHrfdvwa4fAChjSpOPByb4t3G43LpOJIOAuK0N1lNGTTdPgiRBt1FOJm70D14wMxuQaen1IzyjKYDpMM2DDf+k1Tz79MyiswG63S3kBIaaQnIORZcuW0d7ezm233UZLSwunn346f/zjHzOLWg8fPozR2DvgUlNTw5/+9CduvPFGTjvtNKqrq7n++uv55je/mb9XIcQU1RxsxhvrHVGo78p/11xjLEk6kSLRsAVOhOj2X1FEBPMwH94TzR4Kkdy7l3ggMOjz927aw44/6aMXJ4U7uAjwhGOD7tsj6cmtp43dbtdLxCc+qG/QgKc2AqAoCnV1dRgHT+gTQhxlY1rAeu2113LttdcO+tyLL744YNvSpUt55ZVXxnIpIaat5mAzl2y8hEi/JnWq7aQxna9/hku4I/u8yYBeTM1d92XmnnH+pDVyS7W28uHn/kDw988QBAw2mx4Y9VkScv9nTifqPhWA7S+9SetGCMWSg57PWGDGoBjxP38Q5oz+PpxOZ2+J+I69sOFquOBWOihhw1+2EQ6HKRxb+x0hRJ5JbxohJog35iWiRVh13ipqi2sz21u0Qi7b6cnpXNmdcHvFSWNWs3+MLTNn5hyI5KNbb490VxfmZBLbt1ZSsXgxZpdLv5/DvaMk88oKoaoYgOZilVaDg6gvlUn3hd5aJWanSsWKxbTuSMO+3O7F6XTq0zH2JChB+Mt1QDnwOQi2gkMZ/wsWQoybBCNCTLDa4loWli7MPNYCYSC3YCTTCbdPhsu+tiBfefpN/q1wfD/G/bv1Kqb81D4xzZqFbdHI5egT4RTW4i9yeEuUw1tez2w3W4xcdvs5mYDEVDKO6qrOGr1HT7gT3vkn/OVAd/l76V8jxFQgwYgQ00hPhgtAqylFwJge9zn7d+sNXOQCJq7qsUebCc0aaPooSMSTwmBQmHGGhfM//C59n+YQmx/fSTSYyKmY2rCcNfqfDh9wID/n7Bavr0ezKqjxxMg7CyEGkGBEiGlkX1uQVpM+VdN4cC+LDAdQfVYUQwMO+xgzaPp16w2oxUxEMKIWKpgV2Nx1IzziB3pHQdLpBLYSNRNojaTNPjV6+ZhdLgw2G0036R2JzzcaSLa1Qe28Sb4zIaYXCUaEmAbaAnoNket/9SZt5jRVdLDZehMXW2PwEmCFipMhnLaSVEtyO3n/br1+J5D/mhyOEpXLvlZM9OdfhksfgTJ9Ie8rW95i7+8fQbFfP6rzWI0GfnnSh7CZDLgKJrdWkVJVxdxnn0Hzeml/ZSuh1feRll5aQuRMghEhpgF/RE9F+cZFJ7FwkRu14y3sv4lRv+Rebno5QbS7qGDEWMSTFTmknPTV063XP3g6bj44ik04lHo6U81omhOAdLIV0oNfs95XT3uBvsj0QOggAD98dwmJ7/2QhQ/cNyW69CpVVShVVZgapaiaEGMlwYgQ00hNiZ2TC6y0HdKDk7deNrAteQK3GWyUvfwgC+/9Tk4f0AFPlM4WE1HvLDpVEzFzAE9zaMj9+9ZJ6dAKc77/oM9LIfDcg/fRFu17vBnF1vu4Paz3tLllyy10FPZm+VhTFubanWhdjbhbDxPZYe7N1hmHcGg/gHTwFWKSSDAixDRiCif4572v8/3k22ywwk9TUWxmI+dd6ET7zS6qCkb/I92bLuwAvt1dG1Vfx2G2GFELe9NeXVYXNrONlVtW9t6L7SQouzWn+4+FghQC7/3057EveD8A/9rVwZ6NLViLSnvvLa6PlFx7xrUsOEkf6Um0RUj+4gjVZ9RyuM86DYPNxtxnnxlTQNK3ey8gHXyFmCQSjAgxjRhjSXxaklh3F7g1H19E4cJzKGms7w4mRicabaKjtRUtnuI9Hw3RGF/DwsobKJz5AaC3xkePysJKNl6yMVNNtr6rnm+88vCYX0dReQWl3Ys8Cz0FGIyDl4SfWTgzkxYdjwZp08KYy8oy6zTi9fU03XQzmtc7pmCkp3tvPOEhHNqflw6+/rZWzPV6QRRPUKZuhBgNCUaEOAqORON4EvrUyjuh/DW0O2m2C5w2Io2jP6anrki4swz4NvbiTlTtMKUzkhQNk81SWVhJZWHl+G86D3rWaeSDqlblZSTEWqBPM/1t/c/x//5/AegsisF7YceR7Vn7uqyuKfO9FGIqkGBEiAnWGk/z0bd3E+nTudpmNFKiTM6PX09dkcrKT3MQSKSGXiMiRq/A6aId+MjXV2Cep4/67D30T/5Qfwff3b4KtvfuazPb2HjJRglIhOgmwYgQE6xLSxNJpVi3YBYnFuhTHyWKmZnq5KalWq3leT1foqkJzeslefhwXs87oXwNelVWeynkqWleSXUNtj51Rj75RBUfXHEjJdU1gD7FtXLLSrwxrwQjQnSTYESIo+TEApXTHPkptd4j0dGO5t1BvD7/3YBHKxAIcGTfHgJXXgVRfQpKM5kwFBcPeYy56wA0bQegoKuDQmMnsOAo3G0fgVZY91lIhEGxw5U/n5DLFEbNnFg4l4pSKYQmxFAkGBFiCurfoTfZWI/bvB97MErK0Mw8g75I5Mh1NxBt0ad/Mt1xj7Knn36a2vp3uCga5ZVzzsZfVESysJCr5gysd5KyOkmkjBT/7dvwN33bacACt5VXG39De7m+7sLfmb91NUOKdumByPk3wV9X9xZ/E0IcdRKMCDHF9O/QW2hs5zL311HcMfgnYIUlQNKoovnjVK1eg6W2Ni/1NsZC0zQu+MAHYNPzXPjFL2KaPx+73a53y+0nVVjJ4/sX8x83XE9pz7TFP/9B7asraHx+J//8QwwAr9qCixlZAVnmem165o0xhzTmYRXX5Oc8Qogxk2BEiCmmf4dec8dbKL+LcUusjv930Qdo33SIO4iw6oK5KE8tx1JbO6ruuBPJ5XQSBNxlZdhGCIgCmopWugCq9GmLVLveU+fdF6Zxz9LX1Ly8K82hLRCPJTPHGQvMGBQjnvV7ADAoRoo/PrpeNkKIqU2CESGmqEyHXrO+zuQtqog6FxFIm9lBiLhagTLCOaaDpFpCOG3lxO03ZTJOypjPIX6AMerJ7Gd2qlSsWEwqpKG1hfGs30M6OvauxR3BBFAOvhhQTsQ3cWXwhRDDk2BECDGpEoXVXBhbzc8+O5d5ZfqakciWv0ELGBLZacdmpwrO8V3PrlpQSLDhzXbgc7ClCfgcBX/+B+9+NwQDAYpkwEWIo0qCESHyqDnYnFWldEqLdgEuYsGDkN8kn5w14SbqPhWq9AyclE2vYBrpMtF+OHvEQi1UsI7jWs5CO3X8D+HzboMtq+G8m2DLaprPvBFf6jki0aOweFYIkUWCESHypDnYzCUbLyGiRTLbbGYbRZYiwDP0gUdB3+ycYChB1DuLyO4/ANfQHPsHdmsaS+GsMZ3ba3dwIK5RBrTFNU7Iw/2a1RQJY4yDLxdz8OXXs5+zGPnPr546rvM7CeB0WoE26P47UlSAzzeu0wohxkiCESHyxBvzEtEirDpvFbXFtYBe9rs9XcxkBiP9s3N0emM8sznFu+deh6uqBrX8zJzOa0wFsRrS/HnBmTQcPsBPgS+9fYAnFiwYd0E3S0GK9aev4vszruPU0y/ObPc0h9j8+E6iYW1c559IPTVfJiPNWojpSoIRIfKstriWooJ5eBIa7en89qIZi/7ZOcHQPnbuXM7CXX7c//FTHAsuHNN5TclO7ndHeP6Pr7LsNH2kIpZK40loeakuG7R6sZdq+iLeHO1rC+IqsFDttOV8bDx2iGi0Ked+NWaXC0O/bsJFDz045P79p/GkX404nkkwIkSeHa1eNFpjDt3x6M3OsQYU1ObDlKpeHMXjq4FeZkpTFuxijsVMcBznMZh9HPDvwajqC1gPRZvHdB5XgQWbYuKG9duxKSY2r3jfqAMSs6GQZNJEU/P3aGm9l6XnbMopIFGqqgZ0E077/QPv0erCZraxcsvKrO3Sr0YczyQYESLPJrQXjacz82X72vtxTlLV1XzqiLZQMPc+vvVadoEzWyqF01SY07mqnTY2r3gfrx/wcMP67XhD8aGDka6GrIeKqZRt/7iED35wFoHgWhqb9mBTGbKA22BG0024srCSjZdszCx0BulXI4QEI0JMkInoRUOwN7OkcvU9zJ03Y1KqruaVKYzBmCDSuIxUXG/ed0aqiQeVHxE+sSDn01U7bXjLhwli7KV6L5q/rtb/tpfqm1ULqZSTl/66l3e/GzZs2EAoWIqiKNTV1Y06IBmNysJKCTqE6EOCESGmkbZYkkPo0z/q3LkoVUM3o5suyh16ou4P//0i5hSdBEDTq1uo/FeSf/WpwDqYZFcSg60ktws6a6Dutd5uvWF9tMlZaKeuro5Oz5scPPgcl156KaFgKRs2bCAcDuc1GBFCZJNgRIhp5Cvbu4gBNpMBV0Eepn2mkLnlhSws7a4zUqwOu6/BZsKgGAm+HKLgg3eQDA0ftAzgrNH/QCYYAXA6nRhNZRw8CGVlZdjUHAMdIcSYGCf7BoQQoxdLwW3Y2Hh+xZgyRY4VZoeVihWLKXxPAQazdVxl4YUQk09GRoSYZk7ASKVNfnTNThXTCNlA+9r0HJ+xpvkKIY4OeUcTQkw7nma9Z03IoxHU0mgeDTxRHCX69E7fFF8g5zRfgHBoP4lEYuQdhRDjJsGIEMeRaLSJcGj/hF6jf5G3vKU1o/elMVuMbH58Z/YTf+zCvPnvfLpuLq4FJ2RSfL2hOPvagiOn+fZhUUowGm3s2Lkcg0HFav1IXu5dCDE0CUaEOMb07UMDvaMIsVg7b7/yCVKpCEYULIn8r7OwGg3U7Tqctc1mNLLl7JPzEpA4SlQuu/2czOuL7GnE/6c2Ot7+DTtmf5x3vnwtZ/zvT1Cqqqh22sY0NaOqVSw9ZxM+3+vs2LkcsyKN84SYaBKMCHEMGbwPjd5czmQNkEpFWPRODKfHg5pSMzU2RsPn8xEOhwHwdnlxxpz4vdkVRv/7lDl0zTsx8/idUJS6XYfzViIe9ICkZzombpqJ8YV2Cr/6eXb8sQtiMcLbtmHxejG7XGOuwaKqVdgL5ublfoUQI5NgRIgpal9bkFZTCrUjyLxRHtO/D00PtVAhrewDwB4Io370JzBraW966wh8Ph/r1q3LWkPxQT7Iq02voigKqmojCJRbzJyQ70Jvo2CZORPoAqs1qzfM3GefAXIvnCaEOLokGBFiimkL6NMC1//qTdrMaRYZDvCsFZxGI4yynEZPH5q+/IE+D9zzRx2IAITDYRKJBJdeeilut5sDXQe4Zcst3H3e3SyqXIS1sZGOUZ9t4tT86H6caiTTG0bzesEpwYgQU50EI0JMJb4Gki17cJsPcOe5lThn2Hn6D3rTOF8qhQoUawkMqmFSbs/tdlNVVYXP6sNn9eG1emlKNkHXAQxAR6SD0Yc4+WcuK8M2hi6/QojJJcGIEFOFrwHWLeG0RJjT3MC/9D9LTKAZVVamKyg9sxzD92/AdOVPJ/VW+3eendOS5gfA8heX86OTn8lb3xVboB6atvdusJfmNKIjhJgeJBgRYqoId0IizDunr+aNzQYW/Psc7G6V63+1nVXnLWT2XxXsiXZaI57JvtOBnWf31MPjNxFLxkbsPBtUNd4J7qezMw7oHWv7S1hcJFJWTtx+E2zv84Ri1/vKjCEgkQJoQkxdEowIMcl6UnHNHWFcgDdZTYdmI1S8AKPbzo50Fw0P/JySd11J+9r7MdhsmF2uyb7trM6zkeI0B0dxTGu0nd+e38T/vfkNeLN3u81sw2XtfU1xWxVPdTzAGf9RymkL3PrGjr2w4Wo9aMshGBl1AbSOvUOOvHR0DFwRY7fbpXmeEHkiwYgQk6hvKq7bvJ9lbjjwlybi1KLYe38803F9FKFq9T2o88rGnLI62fyaH82cZuVJN3D6iUsz211W14DRlGCqjFDxAqgaecpH8+iLfrVADMheMzJiATR7qT7isuHqQUdezGYzGzZsGHBNRVGoq6uTgESIPJBgRIgxag42905TMPh0w0j6puKWKyr8Dhb8+xzu/FOMDxUPrMthnTsXpapwXPc9Fcyyz2Rh6cJxn8dYYMagGPFvOgSA58ldlN1y1oD9hi2A5qzRA5DDWwcdeVn26U8DJ2Qd0tHRwYYNGwiHwxKMCJEHEowIMQbNwWYu2XgJES2Std1mtlFkKQJyW9dRUlmAy6zX57C7VQLGWL5utVegNf/nnGRmp0rFisUY9nXBoztIa2lSIS3zfLy+N0DUp7aGSPN11uhByCAKHQ6KHNNzJEqI6UKCESHGwBvzEtEirDpvFbXFtZntLquL9nQxuQYjY9G/7Dv0ln4fwNcAT18Op9nAnFvl1anO7FRRyrO/D2aXC4PNlimABnoRNO3xp4/qvSUbjlAUjpFsa4Pa0ZauE+L4I8GIEONQW1w7YLqhPRCe8OsOVfYd9NLvaqGSvTHcCVoUsMGnn8xbemyiqQnN680agZgKlKoq5j77jF70DHqLoPn9IxyZHz3BUGj1fbwX6PrKNfDThzCVlwNgKyqiyF1+VO5FiOlAghEhpqGhyr6DXvq9p3fLoBwVebmHRFMT+z/6MdIRfaoqrVrx27SstTP14YHB0tGiVFVN2kLfnmCo60A9L3z/dk6rb+TZ738Hv90KgNlq5co1D0lAIkQ3CUaEmMYGK/t+tGheL+lIhKrV92CprcVjTRB+9SuZQmgACeUEqLyTjnAHOGblfI1wR4T2w3od+57U53zY1xac8HojSlUV7qoqPvhft9P+pav5yNdXYJ43D09jA889eB8Rv1+CESG6STAixHEgmmgnbJ+YH3dLbS22RYuoBjbO2JiVYfSXtga+1wL+eG7TI4rdTJw0u397kN2/PQiQSX0O+eMUjHHAw6WaMjVHhqw3kmcFThftQEl1DbYR1o30z8gaLOVZiGORBCNCTFE9FUPHKhptIp7wkIh7+Ff99aROdmA0WLEoJXm6w4H6FkID2BtOAdrQBwxBLbbwWFGMn376DOaV66nMod1p+DvEw9qQfXgDqTQdzSGUZFo/T78pq6oCM5tXvI/XD3gG1hvp0VP8zJTzbY9Z//L6PWxmGxsv2SgBiTjmSTAixBTjCekFznoqhqpGcFlzm4qJRpvY+spFpFL6eg6jwcrpb3VR8MlfoqrjW0dxtBatBoxpHJV2yqr1127uGHoEQy1UMCtG3ggneePRHZntZouRy24/J+uNrtppw1s+SK2W/sXPrvx5vl7KiAaU10cfJVm5ZeWI5fWFOBZIMCLEFBM61AC4uWnns5w0/5M4zVZmnHYZmA0YC0b3IxtPeEilIixauAZ7wVwsnmbUlz4FStmojvf5fITDvVlBPeXQU62t7L/qS5lFqyOVpo/5A4CNYEsbrYl9dLVNTK0TR4nKf15zKk2P7aDkMyehlNvxNIfY/PhOosEEoyoT17/4WbRrQu51KP1HlYQ4nkgwIsQUkehoRwFMjz0Mi29lViLCyWYbhe8pwFLjwjK7ErNzmCyZQdgL5lLkOAUCo58q8fl8rFu3jkQiu3aHoihYY3ECfRatml2uITNW/B1tvPnIz+CS/8e/nvglrR3NdBbF4L1gLRhqomXsCoutOM0G3JUFWKoHDz96RnO0hHXwkwxT/EwIMXHGFIysW7eO1atX09LSwrve9S4eeOABlixZMuJxv/rVr/jsZz/LJZdcwm9/+9uxXFqIY1bSH0ABUp/4D2gEvnItvBrG/u75Q364ToRwOEwikeDSSy/F7XZnttvtdqyNjXTQu2h1OBG/n1RCD4JO++Jn+VDpLN4J7uf3b36DAufo1q30XTeT8o49m6Z/EbSG8lo492tjPJsQIt9yDkbWr1/P8uXLefjhhzn77LNZu3YtF198MXv27KG8fOg0tYMHD/KNb3yD8847b1w3LMSxLu0u04ORIicw8QXUhuJ2u6nqN+oRaWwc07kKZ5RTUTOPzs54VrfeofTvtAtwXuogT9rBE47lHJT0LYIWr69n353353gGIcREyjkYWbNmDVdffTVXXnklAA8//DDPPvssjz32GLfccsugxySTST73uc9xxx13sGXLFnw+37huWohjgq8Bc0cDbvN+zB0qRv/Byb6jvItYYpjjB2kKmNjZaRx1M8G+nXZ7NL2ahn9BKJYc071MRBG0nrU0Pex2+5CN83qmiJKBo7sWRYjpIKdgJB6Ps23bNlau7E0/MxqNXHjhhWzdunXI47773e9SXl7Ol770JbZs2TLidWKxGLFYb6Mw/1Eq4SzEWByJxvEketdkvBOKjnyQrwHWLcGVCLPMDfxO35zSDMTNRRNzo0dZa7SdLaf+E1fLmzzUAg91b7eZbbisI49t9O+0myrObb3MRLLb7SiKwoYNG7K2K4pCXV1dVkAyoE+O1Ypam58quEIcK3IKRjo6Okgmk1RUZP8gVVRUsHv37kGP+dvf/sZ///d/s3379lFfZ9WqVdxxxx253JoQk6I1nuajb+8mksoue24zGilRhvnxCndCIoz/fT/iD7+Oc9FVi7CFW2i47ptEzioHfBN637kaSzqvX/OTNKXwl36Vb9bO4v0Vc4GjX8irf/PAaFsCTRl9wBcO7ceilGSlRDudTurq6gZkHG3YsIFwOJwVjPSfImq66WYs2uSVyRdiKprQbJpAIMDll1/OI488krUQbiQrV65k+fLlmcd+v5+amvw09hIin7q0NJFUinULZnFiQe9v7iWKmZmqZcTjk8Un0qFF0dynkg4Uo4WnXoJb/x40I6Xz9pdUqqlyzBnQUHCiqYUKZouRzY/vHPCcYcFXcKSGDwgsJgdGo40dO5djNNpYes6mAQHJUFMy/U1mnxwhpoOc3vncbjcmk4nW1uxaAa2trcyYMWPA/vv37+fgwYN8/OMfz2xLdb8BmM1m9uzZw9y5cwccZ7VasVqHSL0TYhI0B5szBala42l2+o6QUE7gcEyv9HligcppDvuYz7+vLYgjEMQEtPpHMc0zjGi0iXBo/6j27V9PBAaug+jfg2a4dN6jwRaoh6btvRvspYN2IXaUqFx2+zlEg9kpyq3/2MNLm/zYUsN/n1WljKXnbMLne50dO5cTT3jGXTBOCDG4nIIRi8XC4sWLeeGFF/jkJz8J6MHFCy+8wLXXXjtg/5NPPpm33nora9utt95KIBDg/vvvl9EOMS00B5u5ZOMlRLQISVMpnsofgLECKu/krobkyFMyw/CE9bVR1//qTRzBBh4EnnzlEDgqsKu5n7Nv5VWj0TZs6feh6omAvvbBbs8OrkaTzjuREhYXiZSVE7ffBNv7PKHY9WJlg+TYOErUAR2Mo/tH/31V1SrsBfovTINN1wgh8iPnd7vly5dzxRVXcOaZZ7JkyRLWrl1LKBTKZNd84QtfoLq6mlWrVqGqKqecckrW8T3Dmv23CzFVeWNeIlqEVeetQlNm89V9Gt+qMXGKoxi33T3qKZnB6JkhRr5x0UksVErhRbjp/Plc/2YXxdHc1xX0rbzqdJ6lf3D6GvR+K/0MVU8Ehs8KmSxxWxVPdTzAGf9RymkLuu+3Y69eLTXcyWDByEh66pgM18HXopQMO10jhBi/nIORZcuW0d7ezm233UZLSwunn346f/zjHzOLWg8fPozRaMz7jQox2WqLa9Ess4G9vL9i7rimZfqrKbEz11bIIVsJhf/UM3O6nj9EpaKMugR8X/aCub2ByLolkAjrIwj20gH7DlZPZKoKpsoIFS+AqvEvgFVNhkwdk+E6+KpqlUzXCDHBxjS2fO211w46LQPw4osvDnvsE088MZZLCnFcMFgKoXtApGTZSVTMceVcAj5Ld9YOlz4Cs5YOurbieHXvSSmM8yo5qFn4xqZDg3fw7dZ3ukYIkX9Tb+m+EMe4gCeK1qKXNo/6YsDgH4BKuR2zUyXgiQ5YhNk/XXVE7vmTGogcjqX5V0BfKDueaa18MBcVAR748f0UBBuwTvHS8P0LxR3t1GghjgYJRoQ4igKeKE/d/grO1Dssc8OBvzQRpxbFbqYpqPFOYRltpAbsr8UHrh8xW4yohcrRvP2xScW5qyHJXQ36uhWb0ciWs0+etIDEXFYGHKRy9T0UBRumbGl4l9WFzWxj5ZaVWdttZhsbL9koAYk4pkgwIsRRFA0m0OIpzr60Fv4OC/59Dnf+Kca7jCku39hI5KzPAhFsZiOuAgtRv77/hVcupKQyu9OtWqgMyBSZiqoP/ZiVH32QWmct74Si1O06jCehTeroCIA6dy6WwNQN5ioLK9l4ycZMSjnooyQrt6zEG/NKMCKOKRKMCDEJit361IzdrRIwxvBHNCLJNN/c+SfmL7yUuZ8/hWqnjXZ/AICSygLKZjlyu8gQWTRHm1nrYr7dyMI8LfgNd0RoP6x/X8wdY+/kOx1UFlZK0CGOCxKMCDGF1IQ8nISJcsc4RzwCrfD4h4bNosm3voXhAA6Hj+T1/IrdTJw0u397kN2/PQiA27yfZW4I+eMo3bGa1qavTTEWmMe3+FcIcdRIMCLE0eBrgHAn5o4wbvN+TF0TPEUR7TqqWTR9C8P1ZdYMGNKGvFxDLbbwWFGMn376DOaVFwIQ2p2Gv0M8rGGdYcagGPGs3wOAQTFSsWLxqAOS6P79JAwzOBoTN4WxONq+fSRUu5SJFwIJRoSYeH1qfbhA79L7EqDYSaolwAS2lD9KWTR9C8PVFtcC4Gls4IX7fsifF7dnMkLqw+NrEBcwpnFU2imr1odBzB29mUhmp0rFisWkQhpaWxjP+j2kQho4Bz+XpzmEZrYRL66hXDPQ8K07KQwdZO5j90xYQGJ2ucBq5fTDbfivu5GAzcbcZ5+RgEQc9yQYEWKi9an14dVmsumxHVx01SJctTUkQkXAgfxf03co/+cchdri2kxDvNYuC69GzagmayYjJKGcAJV30hHuAMesvF/f7FSHDD56DGigV3s5VwSh5bQ6Zr/8bbSuwLiCkf69faC3oq1SVUXxT37Ms9//Du89/0LS//0EbW//C3M0jK2oiCJ3+TiuLMT0JcGIEEeLez6aNjfTpRenA0LZoyLGgnGu7Qh0N7H88/eO2lqRkax5/xoMM4oA+EtbA99rAX/cP2n307+B3r62IN996p98LGwhoRT27tixd8gmfIOx2+0oisKGDRsGPKcoCnV1dTidTgrnzSPsKuJvf93Me4HnHrgPv92K2WrlyjUPSUAijksSjAgxBRjC+gejdeG/g4kxlYAH9LUiAB/4NtR+akpUXHXb3FSUzgNgbzgFaJN7Q2Q30Gs1peg09pk+Uov1QG7D1b1N+EbxfXQ6ndTV1Q3aBXnDhg2Ew2GcTidF7nKuXPMQgTfewH/djXzk6yvw26w89+B9RPx+CUbEcUmCESGmAGM0CUBs529w3vql8WeBOE+YEoHItOSo0AOQw1t7m/CN8nvpdDpH1WCwyF2OUl2DHyiprsFss47vnoWY5iQYEWIKSYU6MRWY8n5en8836G/sw0k0NaF5vcTr64fdbyowdb0DTX3qmAT1ha1aWzinFN+GwjJKQxpznTXdnYAnXry+Hs2qoMYTI+8sxDFKghEhBtG3Zkb/3iD5oLW3EwkchrYgZWHvyAcMIxptIp7wYFFKBn3e5/Oxbt06EomBH3aKomC3DyxGlmhqYv9HP0Y6oqfqGmw2PRNkBJ7GBlq705Y9jQ25vIwxSaklJFJWil66Ts9Q6qaYbZiVh/CsHznF11VgQTXrAeAPzvwcgY2NbJ4/n+oJvnezy4XBZqPpppsBON9oINnWBrXzJvjKQkw9EowI0c9gNTNsZhsuq4v2dH6u0XDd9fg692ECfmpSOHLB42M6TzTaxNZXLiKVimA02jil8usD9gmHwyQSCS699FLcbnfWcz1ZHv1pXi/pSISq1fdgqa3F7HINm34a8nkAeO6Beyn19045mK1WbEVFY3pto5EqrOapjgf4xJdrcM3oDqo69mLYcDXuy6uJh2aPmOJb7bTx0OXv5sUH3uKKXX9g9an/pnfwzU95lCEpVVXMffYZNK+X9le2Elp9H2n/5C3sFWIySTAiRD+D1czo6ZTaHgiPcPQoxWJUrb6HxtYY9kcewbi/Ech9eiae8JBKRZg9u46DB9cRTwaG3NftdlOVYz0LS20ttkWLRtwvFtK7CL9n2eWcWXtuZvtEpKvuawtmvg60hQmmyvTspKrscvnmQgupgtGVoO+peDsj5BnV/n1Ho1R17DVClKoqlKoqTEdhFEmIqUyCESGG0LdmxkQwVZyA45UuDBfcitqRBEJgTI5qOqQ/VdUnFaKJ9jzfZW6KyyuomKBpBleBBZti4ob12zPbyjUDV6DSFohSRo69ewaRUN2UawZ27uggYIhQFD+DWV1JHH3iDZ/vdfbvvy8zGrX0nE3jCkiEEBKMCDFp0tE0hiT8MNbB+890w1tQdtt38GkO6G4E52kOjepcFsWF0WjjYOf/YUymsZjG/8E81VQ7bWxe8T68oXhm284dHbRvOIQ/Mr50YbVQwWyGztmXcEUQ2jccQg/rbsO0rovPfTeKxV6C0WjjnXfuxGi0ceKJt/LOO3cST3gkGBFinCQYEeIoagtEM18f8YZxAG9ZVc5bWIvjn//kjadb+EeiKesYs8WIWjh8TVCrWsXSczYRb3oFy/ovoS4qm4jbz5vGYCM7O42Zxz3TYCOpdtqodvaWgA80h8nHWJCjROXSz7s5cO034GvXEykpo6nLy8/+meZjYQvRYAJHSff3uHt6Jp4Y3ZTOROi/qHq03z8hpioJRoQ4StqCMa558g2WdRcbX71pL9911GI1myiyKdhSkEqkuPDKhZRUFmSOUwuVTIGu4ahqFapaC7Hx9X+ZSEWWIsDDA28+wMOJ3pL1NrONjZdsHPMHargjQnv3aJI9HKdghP0H45zlpijZQfqeb+AA/OVz6FxybdY++vdYHwWZjGDEZXVhM9sy5fV7jPf7J8Rkk2BEiAkU8ETRWvQGeS0NAQrivek4N100H7ZqPPT5d+Nz9I58lFQWUDbr2JtmAXDb3YCHu8+7m/l2fWSkvquelVtW4o15c/4wVexm4qTZ/duD7P7tQQBm2A7wH8W531vf7JZ4fT377rw/81y+1qSMV2VhJRsv2ZhJO4fxff+EmCokGBFiggQ8UZ66/RWcqXdY5oZdvznAx7S5GE2gJILMdNnpwk+5Q8VHcrJv96iqdday0DG6TJfhqMUWHiuK8dNPn8G88kI8zSG2P7l/zOfryW4BKIqHUEkAKtc8+Qa/vOX8rCmiyVJZWClBhzjmGEfeRQgxFtFgAi2e4uxP6OnBC/59Dv9TGOWsD9tQY+MrdDbdvROK8q9AmH8FwuwNp0iaxt7QL2BM46i0UzbLkTW9NV7lER9rYz8CIKolsxbOCiHyS0ZGhMg3XwOEOzF3hHGb91Oi6BVJ7W6VNnMMteD4/R2gRDFjMxqp23U4+4nKH9AaTzNxidRjU5Y+ukXIkg1HiOzYMWKROSGONRKMCJFPvgZYtwQS+jqRZW70MuWKnaRaAnQNOKQpEGVfJJbzpaLRJsKhPlMSvga97f1R0LdcPsDh8JFRHTdTtbDl7JPxJHpTcV9s3c9dDVa6tDyVt52iBusF1FMB11BUhGY0EFp9HyH08vtzn31GAhJx3JBgRIhhHInGsz443wlFh9kbvblaIgyXPoJXm8mmx3Zw0VWLcNXWkAgVAQcAaLM58XfFOYLGrT9/nYiWYpZ59D+O/cvAWyJReORD+rUVO9jHPu0xksHK5QOYNQNF5pFLv89ULcxULZnH9b4JrrueL+17wGDRv7c5dES22+0oisKGDRsGPKcoCnV1dZjKy/nrSTV88pobKYwlaLrpZjSvV4IRcdyQYESIIbTG03z07d1EUtmpsjajkRJlhB8d93w0bS4dWlQvVe50QEgfFWn3anz1wm8Se7lNPx9G/ueqJbgT8OIDb43q3nrKwC9auAan8yxUT1smCGLW0pw+LHM1WLl8T2MDL9z3QyoumEL1TTr2YkhHUAz7MHSYoWDm+L4vG64G40E92Kt7bdTV+51OJ3V1dYN2Td6wYQPhcBgTELUomOfNwzKGUTIhpjsJRoQYQpeWJpJKsW7BLE4s6K3zUaKYs36zz0UFBpL/SBAzKdyGjdlmE/OufhezTnBm6mTkwl4wt7vuhR7Y4J4/oYFIX33L5bd2WXg1OjXeTqKpItJmG4YNV6MAFVbgN/QGEbl8f8wW6BkY+8hqsPv0oCTcCY7Rv16n0zloQ0IhhG5qvHsIMYn6r3/oX93yxAKV0/KQhgpQjAFD90DLovc4WHzeqUO2thdjE0yV4bn0RUqdURLtETy/2k3pv5kw/+XrehCRSzDyoe/B77u/rjkbDAcm5J6FON5JMCKOa0Otf7CZbZlqoRPBkTIQTabx+hPgTwCj70MjRpYqrIYqB+l0kERaI+0c41udvYSJ+j8wGE9jA1r3NI2nsQFHRVneux4LMRVJMCKOa4OtfwC97HZ7upiJ+CBKpNJc5bfy9h+DvP3H17OeG00fmomUaGrKVCA9lmieKAqgBeM5veklGhuBiS90Zisqwmy18tyD91EUjvFe4LkH7iPsKuLKNQ9JQCKOeRKMCEHv+oee7Jn29CgyZ3KQaGqCvQ3MDLSRtM3CgoG5S+0svmBR1n6j7UMzERJNTez/6MdIR/RRIoPNhtnlmpR7yRdjgRmDYsS/6SA2K3ie3EXJitNGnBozu1wYbDY61t4PZ94CgNbeDhMUExS5y7lyzUNE/H60ffvwX3cj7132eZ77/f8S8fslGBHHPAlGhOh2JBrnvFezs2dGlTkzBK1d7ycbfvNNOm+/AVMkwjeLZ7HvPP3DrbCqaEr1oNG8XtKRCFWr78FSW3tMFN4yO1UqViwmfcgIv4G0liIV0sA5/HE9fWpa9rTBen10TPP7oXziCtYVucspcpcTicTwA0XlFRN2LSGmGglGhOjmSWgDsmfGmjmT6Gin4bpvw6k30vq9OykCknevZfXzLfxH9z6mKTrqYKmtxbZo0cg75lljsJGdnfqHvcvqylv/FbNThXDuUy1KVRWq5gA8lKaMhDwa7c1GSNRCs4amTZP6KEJMAxKMCNFPPrJnkv4AxPSFiJWr72HGSeXsSRdw5JW/96aKCoDMQuEH3nyAhxOHAH0B8cZLNk56Qzi1UMFogo+FLfoaHwDug0f8mBSYfVHJpN6fEMeK47dJhhB5FvBE8bboha18Ho2QfQYA6ty5eZ3uGFAGfppz290A3H3e3az/2HpWnbeKiBbJSreeLI4SldM+VsT/FEY55d8K+fTVRXy6dAUXXhggmYBkvHCyb1GIY4KMjAiRBwFPlKdufwVn6h2WueGlTV10LPwiZjN5zY4ZUAZeGfibuc/ny6r2OVhPlHzwNDbQ2mXJfD1etc5aFuapnks+WQuMtJnTtJrSlBY4cKlxSt68Hbhvsm9NiGOGBCNC5EE0mECLpzj70lr4O7zvomIOf/du5jx4byY7pi0QJUqaZsbeEG5AGXg1e8TFFwyz7vF1JBKJrO2KomC3D/5Bn2s6b8inL+h87oF7KfVbM9vNViu2opF70wylJ3upPpwiaZq43jq5cqkmrFqcm1/ugJc7sCmr+b+lUXhmsu9MiGOHBCNCjIevAcKdmDvCuM37Ke4uWFUQacERbCCCxtuNXbQFonz1yTeIk+anRLkClSLb2H/8MmXgu6/f0603HI2TSCS49NJLcbvdvft3d4ftbyzpvLGQXpztPcsu58zaczPbbUVFY0pBLVHM2IxG6nYd7t1Y+QNa42kW5ny2/KsqMPPTF+6h4P51HHFUcMP67fitlUBkxGOFEKMjwYgQY+VrgHVLIBHGBSxzA29CSjPQ8oMHQC3kc/+7hwalOXPITKOJlVg5SJpyxzjrifS5PqD3XlGLAXC73VSNYp3KeNJ5i8srqKidN+bb7zFTtbDl7JMz3ZFfbN3PXQ1WurTRjyDtawsCEGjTvxdtgShl5C9tujziY3apFdU5ddeI9G9jkM+MJCEmmgQj4rjTtxdN/zfwnIQ7M51yvdpMNj22g0U7n2BW3ZeZ+dkl7I+ZaXh6H2uXnQ7ADeu3c8dHF1Dxm0MczEdKTZ/r456vt7YPj7KVbD/DpfP2791zOHxkTNcYzkzVkkmhrveNPmXWVWDBppi4Yf12AMo1A1egcs2Tb/DLW86n2jkx1VMb/EkAfNEiCLSC45S8XyPZcISicIxkWxsME/S5rC5sZhsrt6zM2j5VMpKEGA0JRsRxZbBeNDazrbv8+xhP6p6Pps2lQ4sS9hegnLxE/2Bv7AL2Ma+897fp4mhq6POMlXs+VJ2ufx1uyuuph+rdY9YMFJnHvj4kX6qdNjaveB/eUByAQHOYNx7dRVRL4g3F8x6M9AQ/9271cwUqP/7nVSzy3cDJ//k4avmZeblGT/XX0Or7eC/Q9f++RtkfnhtyxKqysJKNl2wc0Oxx5ZaVeGNeCUbEtCDBiDiuDNaLpmc4uz0QHuHosWkLRPF26h/mXc8fwmYe2+jFZBjs++VpbOCF+35IxQVlk3x3umqnLRN0tCeNvDHC/lr3VI6xwJxzx+Se4OfwPh9vPLqLRErhjeoSvDu+wGmmhykomDdgUXGueqq/tr39L/567ypOP9yG5vUOO31WWVgpQYeY1iQYEcelnl40E2F/WxCcXZl1DNf8/A1iWgoVOOFjcylw2eCBf43vIoFW6Ogc/82OUt/vV2uXhVejU/utozRlJNAcpj2pl1Kyh+MUAAazEc/6PQAYFCOlly/EXG7LKSipdtqwlGuZoGf+viCJxbD9n1diNNpYes6mnAKS/qnXdrsdZ1UV5miYoDX36r9CTEdT+x1FiGmiLdDbVO/69dvZ79Q/YKxmIzEtxb0XnczsTUeYNcdFV3Lsqb0ZT18OvpC+aNWeexrssdqdVy1UMCpGPha28MajuzIBwwzbAf6jGEouX0CqYCGpUILOJ3fS8djbGBQjFSsWjxiQ9Hyv9Gyj3sWxTr/GvNr78VnD7Ni5nHjCM6pgxG63oygKGzZsyNquKAp1dXU5vW4hpjsJRoTIA3+kd0Hq/ctOh/knA9AWiHHVE68z12WnLJ8Fj7WovnB11lJw1uR06LHYnbeHo0TlrGsW8bXHXuf+z5zBvPJCPM0htj+pV6w1Rw9CoQUKoeJyhUS7hc7fB4ZtntezhqPpppsB/ftV/Oj/Ze2jKmXYC3J7O3U6ndTV1Q0oULdhwwbC4TDTZzJPiPGTYESIPJtbXoitWk+xfbuxa+Iu5J6fcyAC06c7b9/GeTD6VFW12EKbOY2j0k5ZtT6CEU0VkTbbMGy4OrOfGTCZbZhYN+z5etZw9IwkNd10s97Bl+7poMRM2ps1gl1pEqHcetU4nc5B6790dHRgjEVIWfXRmtZt2ygIBHHOqpmS/1ZCjJcEI0JMcdFoE/GEZ9DS7+MxWd15RzJY4zwYX6pqMFWG59IXKXX2TqfRsRfDhqsxGvwjHq9UVWUFAarN2DsdFF7BG4/o5zCYvsu73pWkaIwlTvpP3djnnIy26wCRu1YRATqsVip+8SQlp5w6tgsIMUVJMCKOW0ei8UyhLegtRz6V9O9Fc8qiNZnnfMEw4absVN7p0odmOHrjPA93n3c38+36yEg+UlVThdVQlZ9CaIUOU+90kPoI89IHabTM5eXmrxENjT19u+/UTcjn5Xdr7uLFU+dhNphQrQ7OeeVVfvudb/Kpnzwxpmq3QkxVEoyI41JrPM1H395NJJX9wWEzGilRxv9j0eiL4A3F2XPQiyNlwL+/C0VLY2wOEchhAWtPL5rZs+s4eHAd/oDexD5IAY8//QIJLTngmOH60ORqovrQjMZUbZzXIzMd9Pm7KYv/k+DvfgBANHIEf0DBopSMKc03M3VTVcXVd/+QiN9Pe2cnLzz5CwBsgRCBN97AdsppMmUjjhkSjIjjUpeWJpJKsW7BLE4s6M2iKFHMmUqgA/T0genR3Q+mv6aQxsfue4lIIokjZeBLfitvb+4ewXh0BwBmizGnbr5FjlMwGm0cPLgOo8FKImEgoSUH9KCBofvQjEW++9BMRWZDA4aOt8DQXSDNXjriWpx4fT3RYr0PEY4ZYIigdJevrz+whibf4TGl+fZX5C6nyF1OUrUTs1pJWyycfrgN/3U3ErDZmPvsMxKQiGOCBCPiuHZigcppo/ntu38fmB6DpNZ6o0kiiST3XnQytucOc5A0F3yyFldNIWaHPrqgFiqZbr6jYVWrWHrOJn3tiKcZz0tfA0bfg2a88tWHJhd9p80mpJOvvZS02UYp98Fv7uvdrtih7rVBA5K+mTXNxdVwwY3s3tOAq1rDmtCDkYUL12BzHWbHzuX4fK8P2l15LMIFBaR+sIqtP/4hF39yGaHV941YDE2I6UKCESFGo38fmB6Z36KbBxwy12VHwcRBNMoWllI2a3zrFVS1Sv9QC+Shr80UNmgXXxh3J19PcyjrsVpYhvU/X8L7xN8p+czJKGU2fbRrw9X6v/cgwUjfzBrDrnqsr8T5xqZD2MwG/i+tZ1AVFszD4azAaLSxY+fyvIyQZLhL8dutmGpmjv9cQkwhYwpG1q1bx+rVq2lpaeFd73oXDzzwAEuWLBl030ceeYSf/exnvP22Pte9ePFi7rrrriH3FyKf+jd5G1djPMjuA9Mt0dQEhw6O77wjCbTqQcgYCpxNN/27+MLYOvn2UAsVzBYjmx/fmbXdbDGy7KunkkjPI+0+FapG15G3J7PmBOCn3/8yrd9dy80vd+A3FPRes3sky+d7PadCaEIcr3IORtavX8/y5ct5+OGHOfvss1m7di0XX3wxe/bsobx84Bzyiy++yGc/+1nOPfdcVFXlBz/4ARdddBE7duyguro6Ly9CiMEM1eTNZrZl0kfHq6eAmMnkhjNvIVg8E0tMpVwzEGyPYE7lodoqZFdcvfSR/JxzCuvbxRdy6+Tbn6NE5bLbzyEaTGS2eZpDbH58J7HuYnWZfjWheE5viuURHwXF/db+BFoAB6pahb1g7pjvW4jjSc7ByJo1a7j66qu58sorAXj44Yd59tlneeyxx7jlllsG7P+LX/wi6/Gjjz7Kr3/9a1544QW+8IUvDHqNWCxGLBbLPPb7R64DIER/gzV5A7o79BYznmDEu+sQwRYvicZG/CY33v+oI30oza4TPw+/buEKVP614SAAZiW3xao9otEmwiG9cihaFM6/Cf66OnsRrRhST28g0LvtVg8yTWZQzRiU3n41FqWe8rGWPjV1pz7/4hb43N3gmEEwlCDqnUXIO/baI+PRfyRwtIXjhDjacgpG4vE427ZtY+XKlZltRqORCy+8kK1bt47qHOFwmEQiQUnJ0AWcVq1axR133JHLrQkxpMGa4o2nQ6931yF+tWYXKZMFsOkjIodSFGLgGXucTmMK1WzigY8swPS7g1RdtWjUi1V7Cpwl4h7+9dbX9PoiBiuWRBqKu9cwdE1snY/pzlVgwaaYuGH99sw2m2Ji84r3Zbr79jA4LFSsWEwqpKG1hQk8vY+x1mFXPnEn5p+1sNlTBw80AD3/Tt+m4cVOPndHNKdFy+PhsrqwmW2s3LIya/t4CscJMZFyCkY6OjpIJpNUVFRkba+oqGD37t2jOsc3v/lNqqqquPDCC4fcZ+XKlSxfvjzz2O/3U1OTe9lrISZCsMVLymThPadHKT2pCnNREc/vjxL4cwsfeU8NF5wzE1eBhbJQkjbzIQqLrSOflOwCZwBGo43T3/U4BcEY6kuf0teLKHZ9dMQ8C47tdaxjVu20sXnF+/CG4oA+QnLD+u14Q/EBwQigN8hzjv+6avVMLquLEv35l/WptLKTCIb28eYrq2l+9ctEg4m8ByN9m/f1zaqpLKxk4yUbB6yXGm/hOCEmylHNprn77rv51a9+xYsvvoiqDv1DabVasVpH9wYuxGQpPamKmgtOB0Dt3E8AqHConNLdlyYeCg598CB6CpwtWrgGe8FcvWhWNAld3aOOxTP1lNNwJwTT8NTGPL6aY0u10zZo4DHRHMUmHEo9VJqhyoE1oGAt0jOtYrF2+nb7HQ9DUdGA5n39a45UFlZK0CGmjZyCEbfbjclkorW1NWt7a2srM2bMGPbYe++9l7vvvpvNmzdz2mmn5X6nQoxT3/LvU7H0ew97wVyKHKdk1zbpqWfirNH/9CsDL6Ymi1KCwaD/YvWvt76Gu+axvGTVmMrLBzbvk5ojYhrLKRixWCwsXryYF154gU9+8pMApFIpXnjhBa699tohj7vnnnv4/ve/z5/+9CfOPPPMcd2wEGNxJBrnvFezy7/ns/R7ayCKsc82zRfNZGiMWXdtE9+//ZhwyUIImyCsByFj6UGTaGrKfHgNpX8q9OHwkdzvewKNtZPvZFHVKk479ccc2HSQdDqW1yJo/Zv3CTGd5fxOvHz5cq644grOPPNMlixZwtq1awmFQpnsmi984QtUV1ezatUqAH7wgx9w22238dRTTzF79mxaWloAKCwspLBwdHn9QozGcDVFPAltQPn3fJR+b/RFuPC+l3BEUlyBSlEkSXSvl84nd5JOpDAoRowFYw94fDhYt7mehPbOgOdy6UHTk4KcjujrUQw2G2aXK2uf5mAzn/jtJ4gms0eNzJqBIvPE9qEZyUR08s0XrbERMBLdv59I6hB4FMytHSjdcYLVWgYcxGCwjrsImrfLT1K1097ZSVLV/+2VQG7TgUJMRTm/Sy5btoz29nZuu+02WlpaOP300/njH/+YWdR6+PBhjMbe31weeugh4vE4n/rUp7LO853vfIfbb799fHcvRLfhaoroqbz641GVfx+x9LsepBzxhGk94CGSSPK5k2bAti5mbmmhY2srBsWI+6pTMJfb9AWSYxTGlpceNJrXSzoSoWr1PVhqawcseAQ40rqfaDLKedtLcQZ7U5ELsDH7ksmtlzFRnXyHNFjw2a9nTU9p+Pa198MFN9J8080UdDUCZRj++g3mPvdc1vf4tFN/jNnx1piKoNntdhRF4YW/vQxzFvJ/z/4h85y7y88Hx/QihZg6xvQr27XXXjvktMyLL76Y9fjgwYNjuYQQORmupkhlYWVuqbxDlH5PBDW0Rj+efQeBIu59fi/bnPpIzOt72rgIK5xfRfniGRgLzOMKQvrLVw8aS20ttkWLBn2upyneRz961ZRtijfRnXxT6SLSJhuGDVcPfLJfz5qe0vDBfS3wXDOVq+9hduoQ8SeuoekV14A1HFZrGdYxFkFzOp3U1dXR3tTI79bcRTKhF3BLWVSSNueYzinEVCK9acQxZbCaImPWp/R7oqmJ/cv0aY5YYQ3+s27m/LNP5IKyEu7dUs8XTq2mZWsHJVUOLNXTe/pxMpriTQXGAjMpZQYtoXWYlCAlly/AXNg9jTdEzxqlqgo1XQA0c8RRgWrQsBV3T2kFWoHBA7+xcDqdOJ1Orr77h0S6C0Hu27WTf/xpc96uIcRkkWBEHJP6Zs7A+LJnAp4ovj1t+E1u3Ldez1vhIh7b7yexOwa7faiA+y0PLYDBNtbynWI0+v47dsZzK7XftyJrYJDFxWanSsWKxcQP+PGs30OqYOGo+tX0L7JmU+/mYdtqqh75IvAEmjI7p/scSZG7PDNS1d4p1XjFsUGCEXHMGSxzBsaWPRPwRHnq9lfQ4ik48xb4G7SaYiQccOPpNZyy3cMJH5uLXbXw9qM7MDvGVh8nq/T7UTLVM2f6GqyTr2oAu2nkxoGDVWQt1wxcgUpbIEpZn9ofZqdKqjy3anJ9i6z1FFjzFxbT9LIPXq4jUFILp62A9j1g7srp3EIcLyQYEcecwTJnYITsmSEEDzShxVO85/Qo8UfXUrn6HrZoDnhhN7VlBZxEF+VzXHQlx94Qr2/lVaPRhkUZulVCvgy14HcqZM4Mpn8n33dCUep2HUY1jjxy0b8iK8DOHR20bziEP5KfMrb9i6zV3L6c2RsvI77wOvY8+jd944aroawVTjv6xdj6kn41YiqSYEQcs0aVOTOMREc7Ddd9G069kfijaylKdjDjpHLsrXnqxIseiPh8r2cqr+arBsVIBlvw62ls4IX7fkjFBWUTfv2x6N/JNxf9g4VAc5j2fN3YIMylTmwlCXD3jpR5zrgdy+7vEvUW0XkkQawggFqoSL8aIZBgRIghJf0B6O4eXbn6HmacVK5nR7Q25uX8/UdEjlYg0lffBb+tXRZejcpbQj7s82iQmo0tpqAkgphNaTZvdgCr4QgcfN4LvI7ZYuSy28/JS0AyWDG7vinc0q9GTGXyziPEKKhz56JU5bcHfN9eNAMCEV/DkIXWRLa+0w6TPeWQWZ+yyQvchW1HioeNaS79SABmzCT4h//HzgVFLFy4hlCnyks/b6arswlHSe2I5x5KzGolbbFk+tT01b9njfSrEVOVBCNi2uq7ALP/PPhE0gIJyjUDcW8Mn5bG2BwiMI41I/aCuQMDkZ6ia+PszjuaEvDTmWpWs6YdJnvKIbM+5eBb7Pv17dyQqMNvKaCwII2t0oxVPYDqclHobmfXrjXAzePqWaNaVcI2lWcuvghr9ygegNls5tIlZ+O7/XbpWSOmBQlGxLQ02ALM/tVWJ0LAE6Xt6QNcoam0bG6hBeDRHQCYLUbUQmXY40elb9E19cQxd+cdTQn46W7N+9Yww6yn7E6VKYdqp43qcgsYsqfzGgMaDdoJdEZMxBNe0mk9eEinYzlXZO3hKCygYP8OPnzDNymp1uufdHR0sGHDBrQZFeN/MUIcJRKMiGlpsAWYY6q22k/AE0VrCeMCfB6NkD27G3U0mCCtpXnGHufL587ipFc6KPnMSSjl9vwvRnTPB8Ze+XQ0JeCnO7fdzULHrMm+jYHspWBWIQ6HHeX8rauQ6za3EdHuxPJyjF/O6x3uivkrMwtagZz/Hxm1OGWlpVSM499WMmzEZJNgRExream42t0UL+SPs+knb1GUPsyHnPDSpi46Fn4Rowl21nuxtAUJd+ijDJ3GFBaXFafZgLuyIOeqq0PVFfH5fIQ7fEA5dPjoyOoFPDr9p2aGKwEvRqb5oqTbIyiAFoyP7k3TWYPriqew/XQXq8/8HGyNYzMbuLngSe4JXU5XJInJEsSkpGl+9cs0v6ovaAXGtKjV09jQ+3UOhdAkw0ZMFRKMiONbn/UZBcB/FOubk5qR2Tt+h+fEa0mh8Pav9mUOiZMmYgS7OrYfn6Hqivh8PtY9+CAJTQM+BxteBPLfnVeMnuaL0nrfNszaXiqs4P/5Joo+T2+Z+H7N8/qqPmEuz1wSZOfXV1C5+h4qK1I0/GaP/mS0C6XAwwevrGfvgadYuHANhQXz8DSH2Pz4TqLBxKiCEVtREWarlecevC+zLanaYc5CIoHAiMdLho2YKiQYOQ75O9oyvS16TKVmaEdV9/oM7YJ76Ohy8dKmLhbtfIJZdV+m6oNn8I/1Hp6xx7ny306kpkQPCBrDMQLP7aDEPraaF0Nl0YTbDpDQNC7lD7jNYfj0z6CwIi/deftXW+0Zlvc0NtDaZcl8fbwJd0RoP9z7oa0WKvRUBtG6S8anEymKPn4G6T/bKGE1PLW69wT9muf1V1VgJt7VSFVXI5aURn2w+y33H/8NC8G+7Q7UuVZKZyoUOXLP1ipyl3Plmoeyfp737drJ86+/QTwaZjTNCSTDRkwFEowcZ/wdbTy+/Bq0PivvAcxWK1eueej4DEiAhu/8iPZgNR1n3kI4VoJt6cXENAfgodOYYuEiNycXWEmFNNQ2/ZikZ+z9bmCQLJqoXircfcHXqHrXB4b8gBuNvlMzQ1ZbTRp44b4fZtUWMVut2IqmXgXWofTtVVMfTpEcRXl4AMVuJk6a3b89yO7fHsxsN1uMfGb5GRgUI571+iiGQTGiLDqZhPslvE/8nZLPnIxSZhuyeV5fZpcLg82WSbttn18JCyGaTutBTzIOjK2FQI++vWpA+tWI6UmCkeNMxO9Hi8X4yLUrMqvvPY0NPPfgfUT8/mkbjPRtjDempnixKO4broe/QfI7d7EnXUCgT2O1/Qe9xP7QQIUGHpIAdD1/iEpFwViQ5x8j1wmjCkR61oYAwy5OHa7a6qe/3JuFAdNnhGywXjUAVP6A1niakVYRqcUWHiuK8e0LT8qMeIU7Iuz+7UHiRiMVKxaTCun/n4wFZsxOlXiomkR6Hmn3qaNqoAd6V9+5zz6j/zu176X913cD0FJjZU7ajDFgyOl1C3GskmDkOFVSXXPMtIkfrDHekE3xuherZvQpLBZ0lQFBrt/UQNufD2eaqQFc//sdqMCPzp+PXzXCpt2ULDuJijkuzM6jU867r8HWhsz80Y9I+rxDHjNYtdXp+v+gf68agBdb93NXg5WdviNUWHo/5AfLDHEVWNCsRm7+8+7MtqzmebMc4BzlzfQvTtdvHYlSVaUHik0JilS9P47zMRPudgPtRcWwOElsfz2J8hIgv4X1oLcy67GYTSWOHRKMiGlvsMZ4gzbF61tMrI+0SUWLGQlF9Q+2b1x0EgsXuTPN1L5yfi1z3HbqfvcWX/mr/sFjU0yUz3FOSiAC2WtDTE4XR667joarrwaOn0Wr/XvVdISLAQ8PvPkADycOZbYPlhkyXPO8loYA5Y7ef9chU23tpfqakQ1XZ28fZh2J2ZaCOMya08Wcf19G/a9+CUDTTTfR2VFA8aP/B4CnOTTg2FxTfrvSUKKqvZVZVZXyX/2S0pNPHvU5hDhaJBgR08JQCzD7GrExXt9iYu75mc2xxk60X1ybeVxTYueU6uJMM7WTVAuLbSo/pxDTsvko5XZcBZasxmujNVRK71j1rA3JTAVw/P4G7La7AQ9fW7KKWVZ9ZKQr0sC9W28eNDOkf/O8aFecxiHWkVx2+zkDV3Y4a/Sgo/9I2wjrSACOFFWg1pyI6Vz9PstuuJ6uFQ9gTgQxW4xsfnzngGNGm/KrWlVIJXl+5y7sH7oQayxGkd/POa+8yrOr7+XDV1+Nc1bNcfl/RExdEoyIKW+oBZhjrrjqng9VpxPwRIkGE0SDECisIezPPlEyrP/W7N90CI/ZTKViHte0THZKr4rXkyAYaNKfDLbScfidMZ0X+kwFHMd61pHc1ZDMbFMNldhHuai1Zx3JTz99BvPK9TUhfVNtrSY9cNDawpl1JDhrclpo7DIEsJnS3JCog82gsorvRu5CqZ4JQKHDxGW3n0M0mMg6LpeU356qrOde9kWKy7ursHZ0kn7jTc56+WU6Xn6Zzu5pPVOJ67gIXvuuKesx6OipmDQSjIiM/qmdU2Ux42ALMGF8FVcDnihPfWcrWqI7ADnzFng1Rpw0il3/sUhH9Q+1wnMqKV86s/cDaIx6Unpnz/4eG379Fi+9OLDMu0ICu3N8ZbxHM4p0LOq/juSdUJS6XYdRjaMvSBcwpnFU2imrHrh2w1hgzmTZGBQjpZcvxFig5PT/otrQyeZzd+B99Sn2nb6SG15zEEwUZO3jKFHHVcnXVlSExWTglZ/9NGu7etp8tJJKPvnBDxK5/Y6sab2+zfSONYOtKQN9XdmWs0+WgGSKkGBEDFo4CaZeum/PAsye33La09AeCI8peyZ4oAktkWbhzicoCLcQK3QTv+Yb3PlaK+eENdoPB4j49JERY5El5wqrw6skFNrLpf/2Ptx2A3gPwV/uhAtuxT5nCc5ZC8Z85pFGkY51/deR5JPZqVKxYjFaW4TOJ3fS8djbgJ76W7Fi8cgBSfcak+rX76Laaofy3v9TEa0BzTXyEN9o1pIMVnvE09jA7x99iHBJCcpZZ1HVPa0Xr6+n6aabp2wzvbGOaPTPruu/pqwnUPUktFH9f2n0RbLWFw1lrNO3QoIRwdBvXpOZ7jtUR97hfssZNHtmCFr3az3hK8twzKthwy860f7i41NYeePRXbzRvV+cNMoYK62CPjUTT3gABqwVcW++jiqtOzVVscMoaouM1IV3pFEkMT5mp5oJSlIhDa0tjGf9Hj0N2DnCwX3XmNhL4WAz0I7BYOEd/xo8N7sIHtrFrOraAR9oaqGS01qS/rVH+psO03pjHdE4Eo3z3ld3EU31BneqwcAJRvPwa8q69Q88OkNxvvHENgzx7PuIGPWRtKx7U0xsXvE+CUjGQIKRY8hglVX7G6rK5khvXkfTsB15B8mcgWGyZ4ZI4+2hVFdD1Ry0RAcnf3I2Kzfv5kefOAXHc4c4qGncYoxyQfn414j0MBptmKPd6wG0aO9i2mHKivfIpdR7Xnr2HEP6BrQjBWb7+tSXCbQNPgWorxcZ5oJDpftmrTFpBuA05WOk/vEY1/i+RTxlxbb1L2xecUHWB5qjRB33WpLpZm9XC5FUim/VmDILkjtTdv6r3j/siMZuT4hoKo3yLw+GoD46kk6kuPyF5hEDhUZfhAvve4lIonfdkSNl4Et+KwrZNWGMipGzrlmEWqzfx762IDes3443FJdgZAwkGDlGDFVZdTBTvcrmaDryjpg5M0QaL4pd/2BgYJVKu9tGmzlNsUPBAVR8eDaB53didoytQmbPGpGqym9jsZ4AgDmaoOvX3wM+qHd1nbV01Asgx9OFt3+gejyVflfNalYjuKGawLkKLNgUEzes357Z1lN7ZP/+7PoteUn3VYuBdqyvPIaXAuIpK1cZf8djiU8M+oE23FqS/tM3w6UBd3R0ZL5OtrcDEAwE6f/xeTQ7+fZf5+SNeln+8g+h7FZ+/NpKlO5UbZPtJCi7NWtqtv8vIoGIHrDddG4tH6jSg/WeQOH1Ax685YXsj+rvk22BGPR5H/GG4kQSSdYuOz2ziDnQHOaNR3dx4ZULKanU1/f0BIEnFKqDri8SuZNgZJoa7MOlf2XVoeSyMHUyF7WO67f77jTepm3lxDq6h1etKuX/9T2MjX4SjY2AjdaIRqL7N+EGjx647POEsZPEa0gNcfLRCXY3Knvm2W2Eggf7PPNBFJMB+xeezqnS6mBdeEezWHW4FgBTOSjNl6+ffQ+lRv3ftjHYyLptq4ZM9e1fe2T3fi8NT+1n2/p9bOuzb17SfR0zgH3se/9D+DsOwhvgMvkgBVp7O1QXj/jahpq+GWzqxqBpmM0mNmzYkNnm8ni4CHj66fV87uSTcDqdw3by/eH7f4hL7R2NG0+A0rOuoyPcwfKXlhPVohhTQUxJ/Xtnsp0EwN3n3c18u5H6rnpu/vu9qAayKu8ONW1TkjJSkdS7XhssFsqMvYFmyqHAueV8ZcM/+fb7T8RpUygymQh49SBnXnkhp3R//9uTRt4ASioL9GJ4YkJIMDINDffhUr1gUc7BQv8PNIBQ2oPPnebJn92V2WaNm3CmC6bUotaRxDpSlHxrbaYw2OGv/xegp/L6z7qZz7/cRlGsjStQuXfTHjDD15/vrsq5aTc2xYSrYGwLIiNR/Y3tA8bXqMSjj4ScdTVsfQD7sv8Z1ULV4aZmRrtYdbAWADB1sqUmSk+q73/V9526rBi2ZHz/2iMAd4wi3TfLKNN9MyMxm7xAMRZjjOiiGGyH/WvqmHX7LZjLygCwKCXZfYy6DTZ9M9TUjVGL85lPfAK7uyyzLbl3L8FNz2P3eAgeOIDzjDMG7eTrjXq58cUb+ermr2Zdf6hRppEMWA9SdisAqgEeP0mhwmKgRSvksp0eap21LOwevTAlO3n8JIXSwjkAvO5p4b/q/fyjfS9+ux54tHv0c+7+7QG6vL3dtq+3Bnj3p91YChU8WpI7mvbSMreYld2jQwYtReVL7Zxi9FIe2g1Neqhp7ghTaGzP6fWJ3EkwcpT5fD7C4YHz0Ll0Zj3Ytp9Wq5/3fOHyTB2BInMRs8vnjvjhMthw6I0v3jjgAw2AJdkPrQYLH38BGnftIFLd+wY/1T/U+hYG8x3uIBpJoXk0Ei/4KIrB5Yuq4FUPl59zAvf94yAPfOhk7M83ULLsJMrnOMc9/+tMdVL1byvghe/C1m/rQ/bl45+ayXWx6nQt/T5Ww5WM79JGX5xmuHTfHj0dfnNK8+03EmOp30Tjn/W6M12XRnnz4JfhoL6v0Whj6TmbhgxIRrteJNHlwVTYm0qsuksJqirnvPIqge1XkXjuWZSqKtz+NE6v/j0yu1wo1QsHBCj1XfWs3LJy0FGmkfRdD2JKNPHAmw/wtSWruKshSWnhHBY67GiBMOAZcGwocoAKiwFv1MsDr+pTObdsuSUzlVOcfA/M+SrFSy2cOduOw+LA2uJj1p8/g/J87y9wzwLxtJWnEitpLHDx4ql2Ppdq5HPKKpSnevdzAZe5rfiD7wKkeu1EkWDkKPL5fKxbt45EIjHgOUVRqKurw6jFh12E2hpt56p/XEvsvXF+37gaGvXtPb+hDDfoPtxv0g9f+HDW8Gt/PW88HeXJCR0tORKNszecIqGcwN5wCs0SzktxooAnSmenhT/+wkMyof/mVIqRK4IqvOohTprHXjuEzWrijOpioInycgeWHAKR/oGmz+frfXLW0uxMihyzZvpOzfQni1WH1j/Vt96X38Z0fWuPwAhpvoMsaq121vQGu4YTiXd/WDofM3Had3+IdW4t4dB+duxcjs/3Ok7nWahqVSZLa6gRk/6GS9//8P0/5OXHn+CcV14lvG0bpv31HLnuuqzRuLnPPkNlVVVe1ow0B5tZ/tLyrPUgRWYbpzj0cv4960H6p+wPNn1kUPVKymHflRjDEfj/7Z13nBNl/sffSSY92WR7g6V3ROnieQqKB1gO6+kdCtafeIByKCqeyul5gg2xoFjhLBxYUFQsIIoivXeWzvbekk1P5vdHNtnNbnbZRWUpz/v1yuvFTp5MnnnIzHzmW5VOpMSjAHxa/DbvlW9AL+lZ2GE6aqWbvD7PoW/fGwB7Xi4pGyZwq+Zf4IV/bgE04JW1fFH2OM5A8GoaJ+VwmXU2OmXD63LdWB1bkQNzQDQ+PFGEGDmJOBwOvF4v1157LQkJCeHtJSUlLF68mOK8XL6e+XiTQailMW7cF3r44762/Pnav6M3m8muzuaZXc+wP2c/ckzDJ76Q1eXXpH2GLgQrexdEbA9ZS36LFOAI023qU4w/6AP2/+riRHabn8VvrMNXJzVPC5RIARbrPEy9qBMdOsfxJyVYUBDnDER5HmuaaELTaCqlXz/QU/P/2UzzfWOumeYWMzubg1Wby6bywvC/LZKC7ua4E8qwaVaa7wn0sFEXKjGpO6E390JR5kWJlt17pqBU6Ojb979s3XZrTSXfxi0mdWkqfb/YXkVxYiKyRhPRxyZu9ovovN5fXYck2u/W5QsKjVA8SKw2Fr8Uj15Z0SAeJJSyH819tKdEwcQsJ54enWq/j4GofTKP9psElhymrZrGMc8ROgKrflBQ4guJnHisujlcPb4deVKAv+/J4rWeGaSqExiiCFqc871evCU74JvZlFZlYj+qIFmjxuDwYNWVNojVuU9ZRcG2NchHTHhdwWuxy2vEqah90JN0EgmJ+nD/o5b2HDpTEWKkFUhISCAtyoldkJeHW6HiD2P/L+x+0Wl1mOuYVbcV7eLLzMdQm7uwbukmAMo15ZAOixcvJtbT0LqhVqu58cYbKfYF/Z5mj5k0VVqz3UIQ/UIQspYUxrnYdHgNFnuwjkZTLqNo8SkhMRRqePdIWxWvbZjGzD/OxK9OY8LeLNZX2Ckz6qIXOKuXwustKUbO2Ynbn0ClPgN7rgefJ0Cvi9LZ/XMuw2/sgv77Yxzw+5iLm/gNBZzTJ4WSd3Yhe4NCRKFWojQ2//SIJjSdrkyOHv0aEw0LVTVFNNdMSYyiWfEhZ3uw6vHIMFhRBHJ5uzSet0tr3DcBN2nF97P0ynktyrApsrlIxHz8NN+mglqz1tZutxeiVqkAyDInsX39VpRHSih89ll82lT06TbUY0upyttcU8l3AkePzsHjLWuWdaR++n7IWrJmwXwcnXrx1Yg/oa353bi1WrybN/N/lw4/7n6bojFrrK4mOLVuPAjQwK1W3yoa8FkJuGrHSw47vVZt4f4L40m2BG/o1RVuDizP4Q9/64FP1nGeT8F3u2cxDFjR+T0OqE1oJS3397+f+NjuHLOq2O8IsNPcFWdyV0xmAyaCD0ej1x8hzuFmlVJHxte1/auMwE0Jejb3ex0VcVglFaW5+bTdPwvvL3q+qXgInxwSGJU1r+g0t+fQmY4QI6cABoMBtVrNil9WQ4eeLN+4JfyeR+dh9E2jMZuD/uri8uAT2iWXXMLAjIEAHKg6wA/rf2DgiIG0NdY+ZVnUFkyyiUWLFvHBBx9EiJZf5F+YMGFCiwVJ3Yt1rDYWnUrHqvNKWVXHZST5FAzfmcZfJj2K0RoXHgs0ekN9ceiLFAeC0esqbx5q7zG6GpTEGE3olcrw01K6q5AB/iqSS71gU4OjBBbdEpHCqwZs/gQWFL+Cr6sOlgefBnf/nIukUZKYbMDhl3mToLCRfTK+IieyN0Dcjd2QkgzN8v3XLWjmdBVjNJVisfhJM/jBUUoV5SGX/wlR1zVTXrqnWVatszVYtbn0i2/D0vMgy1EBQJZb5ulsLY6AxOaizXR0R6aSN9Xdt8rpi/INjVDfKtaItaSLpKOjsojnBoyB/cB+O1zwdwB0ygD3lMxFowjWJ9Hp0lt8/HWpay2x2atxuV1UFhWy+qMPGHLLXaz4ZTUuV5RYsuOQb89nn62MSp9Mrj2XKkUSkwZNoqe1DcmaoBsjFJxan6Yq6EarAdJFLuVb7QOo10SK74tMwBfBf79fsy0g6Xjg6icoVmv5x8p/MGX338Pjvep2kPoUG8sKgBSgtnLrI30HcqzPKkpzinjtYBGegIzFZ+fhAx+w9UstPtkP+IF4NjIz9G3EKPOwSvmcb17AkY4T8Vna4bZ5yNtUzM86H3eOHkCMNpnv5+0h70BFOG04xNlmMRFi5HekfgxB3fz+ulitViZMmEDOgUy+fvWF8I1kX94+puycwpc/fRkxXhVQ0S6xXdi6oohRoN+s55ldz0SMC93kh48ZjsvlIrs6mx92/cAll1zC1m+34nA4GoiRlgTYpppS+eLqL8gpPIS7Ovj0X+Gt4l+7Z/Jt31y+/eWe8FitSsvfevwNp8/JxL4TSTelE6OJQaVQhaP0QxeEV7a+QkzNE39qnSBEdVUO3eaNQ+lzwqY6E1Eb4OZPwZCA6/Bh8qdORXHHQ/iKdQy7JhUpNpbl7+7hstt7ktrZitbpwwHkU+u28VUEhYmUZGhW6fdoBc369YNDh1eQvKkCfE4cFjV0NwezaAyNN2sLxYeEaKy6KjQ/PuRsC1ZtCf3i29AvPtiYbofNwdPZ+5usRVI/wybUzdlR4qQ4yxberrYHBUtEI73GaMRaolx8Fwuv0pK3+FF8/SfCxreRlC4qTfHc7ZnMi1v+jkbp5uk/pqJR//ry/iFrSagbUuHhg6xzOYi1nJgVLd+ezxVf3UZe4hOg1BLMXnqKfxeAvsjPu73bE6+RKPe6qBucGmpaGUJpz6WiLJ9qd63wKKh0McB9jFvOb0dKjRVEmV+F+mBkLAiAxiBhjKlTe6TSjysQQ6wyhVg/zO+/EJe6Gp01aInaWHqMh7Ld/PNwFTE7yzG4gy6WDAXo87Io8cjs+tDLH7zWmj3GsoxpKCRY07eSKd2TydBpcPgMuBVxaPQSRosWpT2XuMUvkJg9BULe0kQYAwR+1lN985pf3aX5TEGIkd+JxoJV1Wo1BkPDYl1WqxV3fDwql4PE+HiS09LI9mTjV/oZWDQQs7c2kt+oNNI+vn3475am4rVLbMdWtjYQRw6Hg0WLFjUZYBtNkNQ3bcfLcXw+bzbnXns1bxx9D3fATbW6mnm75gHw6tZXw3NZMnpJeO77HQHGH/Qx848zGRwbH95v+GnJ5gCfs7ZqaYg6AaFyuZoKRzJSbD+gigqNkbJyB4WqAIWqAB6nG2+RgzL8hJ51FZIC2w/ZLXLNeMr2Egg46XXAjcHmoJg4vjVcQPfuq7HpvOzqlUwAL0qFFs3fFjUaK1I/PiREU9VVBb89sy6eRYoUtDo2liUScjEW+KvwKgLs+/wo+z4/Gn7fqFEy3KION9I7br+aRmKIkowSScbD0EWCfXvgoqnw83MsvdDL13M/5oUeY+jQbT5aXct7MtW/6cOvfwKvG7t0uPIwDj+g1IYrp8ZoYlBIVm7fdZS/7qgdG4oHsZW5WPCv2pguk7KYvyVMIl4Zae3oA/zJAOyI/H6vrCWm/yWY2nUOH58PcNQYrpw2D9+8sROfp5JaRRB5s4/VxvLSlttQOmK5edOtqAPq8Lgjoe9RulnZ+wOeHv5vEg2JNe/5ePLQMR7q05XEqEUYu0PaxrDoLC9wsOzd3RwzHOVBw6v4ygoYcVdQRBkttVVrzuTKuo0hxEgLacxyUJ+SkpKowaohC0O+PT/CogAgl9oj9hFyzYy7ahxdYro02EddoomC+gIFagJRfXrUanVE8aMQarWam2++OUIwhQJss7KyIo492jwqKipY8e0a9In92b8qm2EMA8ClcXHO0G60bduJBENC+IKfWVVEnLkLaCz4vS4gi47WjqSaDI2Xc0/oCmnnRXxvyLpQvvsI6wY9RqDGNfPA0l3kSTKY4b2PtzY4Xq2kpPNd55IkSVGfZqP9fxt8lSgX3wJ99BicAWKu/gh7qR3HqhUAeHRaAnjp1XNWOPuhMerHh4RorLpqWW42hZW1T3zC/fLbkGBIoKc5o9H368c+mPrGovMakWUJZ87NxHksXOnQUHVVB9qrpeb3q2mKypobpyUoWNL00L6gCHpAdqUeV8kxSp2xVGT+REBTglYVvEH6XEErTv2qrLU35chifpJGyai7z0Fv1lBe4EGhSiJ/fzGS10TOoVJUprYc/WUXpiIvUkwMpg5p4Rt4tOJoEkqUvhKGJl8QUSW5sXiQ0sP7sAYOMPjajlgS9KgqXah/cvOYawJ/HHQBVrUOX40u0amVWPQatDoFRlPQ5aOOTwoLkbqipv4xXjXpXPRmTXht6rpHJEx8cN5rFOSWs3dDJT1usGBMjLw95gdyOLR9B4c1e8AYPFftvqAVtamKsHVFp6RzUabw0M4BGGDTe99R5tuNpFYy8u5zMKakNrsi85mGECMtoKnU3Gio1WoyMjKwWq3hDAe3y8GOvL3cvnki7kBkF0jJp+D6mPYNAg0TExNJi295JHs0gRJiwoQJzXbHhGJa6ouXaNYSh8OBz+fHUJQN1UETdkCjg/SOFLz7PVfNvIKY+Nqb5x27jlKtrs0AMgTKKLMdYE9pGXx0C/hcxPoDpPprzLXhcu611LUu2ExtCQx4mAHDEtj0Ywk+4Mnh3Uiw6PBIwYuXqsyFYXk2T+DgXzf3I6Nd5PGGaNS6Jam4WhcLuCge/gp2Q09KHCVAUIy4/nAnFLyPwdipUSFyvNTdfHs+5aW1ptvdOdsA+PqV54mvqn2CkrRaRk95BH1MMN5GZM78dtR/4q8bs1Nkc7Ov5CBzdj/J0+M64MyOp3jxMfLLXMQnBn3/5QXVGPQSeiUEqn3Nr0GiswR/5z8/F/l7rzhGjKcavYpwQK1G+QhP/eFpEpTlJD6pRipX4LakIg16rFHTf92bckigfPnK9vAYbczN7F8FsfRjSykw4GHYCmwtA8pQSkfp/2BfdLEWHvzDaxy25TM3L2hpVHlziSmdiy5gb9C4Mmo8SEU2cYuHcmOCE9bUbvap9KygG6O7D2bz3N31BIYnQkD5AGeWjbL8anyeQETZ9vCS1rP+HK/x4MC+vRpYJPLtSeh3R4ovtTYdXerMZlWEhWBNmIH39OKJeVlcp9RxmXV27ZsLQZb0lF27knK7tcFnz3SEGGkBjaXmNkboxr4/eyfvz3wYvycoPipMXtzneRi6K4XR14xHZzKR5chhRuZsuk68iRxFCZSWNJq6+VtgtVqbHbwaimmpH/8SzVoScv1cM3EKJe5cHl41jUfO+Sdrf9qB3+ttkALs8+Twz/ZBf6vNU8HsdQ8xKafmKSM56KbQKzUsueAZUvUJUWt0VGSVUKVKIOHR+/Dpk2F5FSVy7YVANkjc/8WucOBbV5S8iwmLJNEtpXHfeLT/b4fDwaKF/+NrLqEfX7P425VU23cCYDSaUCp1HC14H6VSj0YdF3W/x2t411gGguRTMOpv4+na7lwAnFWVLJn1NJ/OmB45TmTOtJi6T7YlPhNqbXrUcuj9k/qTakqlZzwkmbXM2Q2dkkw45Bhykdn3+VHyVTDUrGbd/D34VAoGm9XgDTTPdQNgSo6sSQNBUfLDUyQ5E/nK+TDlf3qR9c+/y3MDxhCruRtZNZOU159Fk60gb+qDXDsmHtI6NNh1NJdM/Qqu9ooyyotL+HblTwQCAXROJ2qPB1N1NR0PlbCn5628/NFq8uJ1lMVYgVQkjRe14xUUNRl7z3exNhqIaitzUZprx+P0oao4RowzlXW2v/GVOo6qmi64VbIBSYrHV+hsIDCiCagQkkZJWhfrcV0bjTUebGyNoKE7PGTdnde1tiLsgWoXE/ZmNdnILzXNxEFdEhc5niVWYcMYUDC6Wk2SlMtl1tlsefN/FHk7Am05sHYL2NJqWgf8NpyqgbFCjDRCNPN86EbbWGpuNPLt+YxZeRuuQZH+T51Sy6R7Z9G17TnhcbMPvcGT22bAttpx9VM3W4v64qUxawkELSaJael4/QrKLB5MKcnh90JP7j5XJRqllpjSuby5tvaz4QJstmJYfCeHRzzBtF1zKbemkRrfM2hRyN0dHl+Y7+HbxWX4BzwMvwAE3TNHV+bhQcaphOlf7EavVvHf2wehl11488opWZbNvy/vgMJRTp4j0pUVorH/7wl/uZTSL8ZyFLj22mvR67qF10Snm9RoMaq61pCmGt5FqwdTlpvNihdepOuwcyMCU+vXjgDhumkJoZLxdZ9sAXSpM5nXVR3O/oCm6/HoLBrejXHz2PButNepCXyXRf9Q/JEMlis7UvnVYTxHqggkRWbhNLCYlOyvjYkKCZIJG2DbJlj2CAllxSQU7SPfVhQcrmqHs6oNbdINZHQMzs9kVqFvZh+V+hVcEzPM6Owavs3+HNkjE2NXc/H2BDZ0KqT3Dj9Kv5shBw1wEELnm0IN54yZSlEgj1e3vopcUM36oh9QK23oYmRi1SZS9QlUV3n45vU9FLvbAMqabwwWYusTaSgGYPOig1EFRkuFRHOOuzlEszaHKsICqGoKKh6uOIzkUYbH1P3tRMvQys+388YnK7lQ1nKZdXYwG7DkFbb+qGPrj9nUjXX5tZyqgbFnvRiJJjqOF8gZLQC1Mcrd5bgCbv64LZ6/3TYtnG5Z/8IWLQg12rhThWjWkhAhi9DW/Fy86nYc9iopNlmITUjly7dfD48bnNyXLy69gufbWumTHLx5ho83bxt4vGAMpi9m7l6F07ONwmefQ3YHn2I9mhj29Pg71kBbqrSlqPwSRp8FLzLJI9ugjtNi+3o3s288j4Ed4jDiZs6cN4P/r1pg2cbjHmeD/++KbHTVuzAaqgAziYmJxJjrig5rVNdMNGuIoX//JgtJ1c2cKazUsN7V8HStXztC0DKilYwPPd2GypJDsOZEsdcX7hoNUOqpdS/GGjX4tEoe+nkdCqmaJEmig6znispkdBeYyAj4SVEpwpVa6xK2mBynOJrUdTAKnZa8dbGwbg4WaxJ6lcy0ZV7gQXTrq/js0go8bQO4/cXoaZip1dxOz+XucsoV5bx4/v2oiz1sO7aM63r9mT3t/GwrP8zI/FzSV2xCcf0lqOMzWLc9hR3zywE91zOVgp1QAHiVGhadNwO/upQlOfmk+v0MM3XkI/cLDLe8SJyUg1+pZaLzPu6/aWi4/09dogmMExESvzXRYmZCGYF1y9NDwx4+9TO0eqdb6Nn5WrIK+6JyleEocWFenM0BfQF/134UDNpP7Par51w/VqYurW0xOavFyPHKs9cP5ISW9ZCpi9WupoupE8nxjadbNhXjcSrilJxUaCvCf9cVTjkuD7dlenGlPsXUUqD/MCS/jxG7N6DzBq1EFQYzPk17qg9mE6gOnpil2LAby0iRbJgBk92D1guPHwlm4DAGan+2DhLsC7l+51SWdX2XEkMh2v33o1DEM7dvUrgLb3u9msRqPwUlpXi9Xq7oNxz12kribuqOlNh0ufeI/++KbFxvDWbteToC3c0olbpGXTH1aarHTGPUDVYVsSC/H03VtoAoTd1q0CnAoIrncOVhOlpg5i0a/r1+Nu6Ai2rgqDuWkm3TUK+CQg6iV4BGCT7gwlt7kJFmDldt9Rypgg6JSE10/FWnnUenhe/ge3M0+Fx01hbyvXQv2dYkVqS1Y+nOyzlQ9DopE10cOHIHPSsfIP+h1/CW1QotWaeFD18itl3XqJlCIQ5XHibF52PYFw+h8rm4OBbYuRyA2wBvQMUhZyLy/P8CcL7BSsy0SZg7dqXYXYGt/BDVa75hb+m9XHFwNCvafc+iirtIdMUiK4MxT3F/mU5iqkSmTcOmeUeO2//nVCPaA2TdjMCuNY37mtvDJ92qB2vw4aM4y8Yqv5KDSgeJ6sOQKkHar1+b48XKtKbF5KwWI03FgJyo6DhbiBbXULfF+H5HAJcM5pLXee78SajkeCYdLmRpnwsi9iP5fezZvYfsLZsjtrdRlXInkOSSePFNH+7Jf+eV7VWoZAN+VVDRG2QFvdxBMXFVyl+ZZ3+Of/w5nmRtR8a8tQ6XL4BOUlDywSb2+GUqFA7QgHptJYmSleR26c1uagaAoxSPwkVApadX+39iTRsZtoLUfQJtSmhE6zFT/0bQVLCqiAU5edTtkeIMBJjTI4MuRl1424S9WVg1CQ3qk8y9pLbP08be+5m/9WUm9n6cNGN7jhyuoPqHfIoV0DndFNHbJmwhSWs8m0LdvT/qx2urtqYD8ZKPrJ+m8L12Kob9dd3BD9PxEgVP+tqyJVYmvUTm3i/dPPTVBAraGMJP6o3FKJ2HGpXPxd+7P8qVHXqT5Au6FVQeN4riAvYWfMGAS0ZAfj689w2pq+5Fv9uLtVqFz63Epkhjrxwgtqov1+/sC0AFgB8UEmxV6kmT23DQEZlFeDpR/wHSp3EA+xtUlv3VROlrdCJZN43FypwKqcRntRgJ0ZIYEEGQ+nEN9euahMyVRrk0XDOkb1J8hDkcwFOQi84yFLWzCJWnEntZGVtXfk9MUo2lpKoKpSoWj9ye/tIe4sp6o5BVEfuQFX5yd++BdrDil48IuBPxSJ3or8shJeDnl4A6/EtXSxLpf+1LbHJcy4RIDT67EnWWAsmcgEoHpEV3wXRa+hXqtLQGWTMlzhJsdbJkGuuaXD9YFUQsyMkiWhyJXqlksNXUwIIyafCzxCuDFrioPW66wfMHcujR20LP+OD28h/yw2+Hett4jlQ1nQ5c/2ZUQ7GzBJvHRgfVIAyK7XwX6IH6INiu9JP2nYeBHY4iWew8MHQKbUpB8ctspnX5G4+Xf8L2Xd+zz5/AgepilNVJPNDvr2Soas+JJHshZE/jgKEdbXpeHJGmW3j4ICs+XUbMxdfgycrB/t43/Fx0E75iC+23f4Ey4AO8DNb/m4Jp03ml9CU8dbIHXepqbNvsVB+6H9lnRa9WEWv8dc0wz0QqZDMBSY+yBX2Njsep4OKKhhAjggY01T+mPnXjGuqaLEPmylkXz2pYvKwu5i7Yjx3E+P5oFDU35PNq7rceJD7asIPKEX+CA5uRAiYUsop2/RXozArUWj3meCsxiTrsmkR+WvM9G5OCcSBGgtW0jym1zNz/D7pefz5Soh6DwYBTcrLffRjqWMObE5vjLSyh8JMEEn0KinmIohqTt9lJ2AUDhBuLAZEFzXQ67tpwP7m76wUzq3TM6P04VnXQ6lFZVMim9xc0CFYVnByixZHUrx0REiz/PFwbPKxXKnm3t5FiOXpcSV2OHK6I+Nvq8GEmmA6s9NdklCjK8fvL6CzpGt6MakiseXUEHLKGJzz3kJeRADsgLbWE7+UHeLS6DJY+GvzACOiw42W+RMlnKz5m2thHcGlTSW+bzA1fj8UQiCyk5lDqcGhjG6TpOqqCwqK8wEHAo8GvUpGxLZjaLms02G6bhLuikoRF7/HG8u3sT/4LCilY90QrKbljmJH/Hnyah67WkG5MxKxXU+k/gtJ+asbItRaFcgIHbviBbuY60b11XHdnUk0SIUYEETRmsq3rgoGGHWNzXB7KZAtogvUuQgXMEgyR7q/cCmdEFLmr0sPRN3/iequT5RWTKfPG4rF/iU9lwamIxe93YarpIaOUXaCH/T++j+wvqq2xoVVhxsS7/V/BrfVT4NFw36JtPHhlLHN2P0mevoBETQVqrZsj1UeiWiLqB5iF1qKuKKs6tgWLT8HLVwV9wSGTt1al5Ulgjz/YCdYKHDi8k7S4NhFxIkcoIXfTRKZ1m0yGIViO3GW3s37ef8n88r8R87FqjcIl04ocL46kvmAp9fgaVBiFyLgSAJvaiVcRoPyH/AgLiaVOOrAtIOMJQJXCw3fd3iEmpheWQNCs7pacODW1Jei1Ki33D7ifGE0MhT4TD6sS8Lmyqch6AdteC8Mrn+fhYWZS4uJ44lgeHo1EF8cxXtv3FO/edDNoNDxTupd2H7yG4TwXWZe/SrUigUB1UFAF4tJ5N6kX2iI3xTXdp0OptQDL3lpFQGPGM/JytN7geerWanFUFhFbXsafgCvtv3Df2IfQxlgBiNGr0Zk8fHRUz5zdT0asV7Tz8GzHa0qHNEtrT+N3R4gRQQTl7nLssoEJg/5NuqmmEZe/iqdXT44oLe9XxaPRd6PAZ6KwtIrbdx1tEOBXt/031Da6ivUWEqsIXlBTvGquDlRR7O2I8cI/ojR1pHxPV4r2KZGVGvTqiF2ilOCaBx9EQXWjNTZ63DqVgCudZLcRnULLc+nzYcP82nmF0ofrCKv6AWbRRFmHAplngPM7e+jdeQp8+TKPpdzG+3uCrbhmZM4G4BngzZVP0SvbylCCIsXv13CwNGhq3/XOQvLrxIKYtFpGT6stXAbCJXM6UF+wNJaVYzT05oF1cwFQBuxY+gbQeYNxT17Jgk8yYvHFEFtyLUazBiPgIcAxR4D+BRMxuGUsjuC55VUE6Dk+ljZtgm7Muha9UP3eKpuajRU5mOUAr6sSuPdHgGpklZVHrunEhXYV7IOn/HmYE9PoqNFS6gy6pFJ1Key682ny1XFUaXR49RbyOl2HyVub4gwgK3T4FRI4vgEHKOwa3JKEUlLT49K/odYbqdi1F1iOKzGdX1Z8HfF5SZJ4//b38Wtre8+EzsO6DQvrH6PgzEWIkbOMaC6YumwsPUZZ6jP8u0BLMO4f9EoTzw/9CFUgGGhW6YfpR32UydR03ixDr1Tyvz4diddIuMrd+Kp9xEgqtIeOUewKts8uczq5yLuVOYbZSAFXMJe+4hWyZB1Zpf3he4CjgA6l7KbDEAlrr9oy+DF6iYxUc9jfWb/GRqgI2Ip5cyH9BtbNnc8YbXfOazMK3eWpxHQKFg6K1cZidKlwVgY/W2YPKp7d676j0hssA5mjtuH0OXn8vGn0ktKh0gaujcBHdNDKdMjoTpFej2nG29wD+JQK/t7hbmISEgkseJoJS71AKS41TMuaTWll8GIu+RVcfddU2iXUXmyF8DgzqC9OQq6c0tg7w9t0CniovYRFVXseuWo8OXd0rb/HYPaEVobX/WachU4KfinC7E0jxhiMvyqWodjmiHAjOSqDlscdVbczrlKLUwmHzLDa70ZZJaEyd8Yhaxm8fTrU1A1LHwIBpY69u10s6zuVt60yIf0hyS5SfAqMbhumGnFeKmmxtx/DkyPbY9WrqXB6eXrpXipkDfa1ANV0qlDyKqAvzMZdWRA+qoBGhyu9IxVHimnbofY86KLrErW8fH2rLAiBciYixMhZRGMumLqEAk//0zGGgXEpYfPzhP0VEeP0SiX/OyfYgRNqfeq2MhcLnt8evT+EwsU/rd9S7GzHatutVAdi8ck6YtRFdLq8C4rEmiDiY0fQPfko3Se/hb5X4xecaDU2bpv1OlsPF7Fo8TEun/QAKUXFGH+RqC7yYU2oKYFdlcdHs57G53aj83jxqTz06y7T+fk30dUEmevU0G+0ioov30FxoBTcNXEeKpmASUZKSaTT0q/wlZdTlpvN56+/yPUDRpHcsTPeby6iIO8ARaU5uNUqnkqovYgmxaaFC90Jzmwac+U8dKTWehI6j2RfBVWemgJi1QEMS2wofHDEpOSxPnpy9xTRzilzNEFi5cFi5toKqRt5pAUe0luJUSipKClFp+9AXPJKPjeOIEdOxK9VQjlsWXaMbFuA783PcbHXwQ6NnysdGuL8ClyBGOx5RhwKF14FTOhoQPnFYl7pPZIbL0zinGeeJbki6IqUdTqMM58nKdEQzh4797zeES5Y9u+DlXDtvffjT62tIJp96ABfrVrDN8u/j1ivaNaSphp+vj/sfcxEpruKLMjTFyFGziKiVfasTyjwdGBcSjh6ftXg7uQVVeOrrr2IWl0ltC06gNkSzGwpsrs56PRSVRzA5wlwzqUq0gwFWNbMhEsexaluy9JFMl+WR7pVVGolw/8xitSOtS4Kp76Mo01Yb5oiJiGJeLcWOEZ8eluSjDFU/3KMje+9g9MZvJB6JCWYTVxz1yTc9z8Ebjd/2gWyVkPVI7cBYH5hHg9/4gHy8CkVbOmQikdSoUzy0D4uh/zMvVjj+oJeS5Vei0tT609Sp6XRNi2NMye0THCiHM+VU2vRiIwP8qW4CFT76OT18vTRLB7rU7ceTgCdT+bW1XYkdwCHVsnHfzDxpLMi+LYhEXgezqv9hKLKg3ati5+VblSGAFUk8JUSbDIolF7GHPqJZEcZParyOWS0wpBxDOtuofr1TejPHcUL6wvRXngfS86XaJMcS8699+KYPJGj1GaPpaelkeQoDwdv+xROcgCjNRZ9nUBsfUwMlgX/xVvHrRuyluRs3kdySq1wsSDxbId/YfPVpv8WKsp56fCrPL/weQyu2gwfrV+LRWmJ2l1ccOojxMgZxPFcMKEguroZMDkuT8TFMRR4WheLI8DSKNYOSeFilPUZ9MoqFIAF8PvaAP+gx7bJJKoP49Pq2a5pj0efhnlwKZVriuh+dXv69Ax2GP1dq/4VFiBV2vAV7qb/vl3gqXmW1GqJf3oSWqeHPLc7aiEy7/C/4Csvp7qiHI9KycikJCjeT8V395CDxIp5c3GW1N4gRA0QQXM4XmBsCMmqAyt0AFalGCnz+vDbPORlVeEsdNB+awnqPsl4zUERPMLjRbG5BKVfxm3MI7/PG3TfC8aLniVgyKDY7ua+jaVU+wKgCma0PDaqG49/s5ddWjXTeg9HB7w+yEpishW+PApAkrOCz/r62VIJjxzQYE9KxfTHfmGroOfwYfKmPohj82ZUhw6Tc++9tdljWm2UIws+MNzx3MsRLtbignw++XY5qzY37KxdH4fKgaqNinXx6yK2a5VaBuQN4Kd9PzUQIzqdLtwFPZqLpyUZhILfByFGThOOJzSi1avwq+IJKCPLK+tqgk59NkfYbBwKPE13FZJeZeMSnxLNbhfFNcGnZSX+YLOqa4zo9QF2Ll7NOfov+ar80QaWjiABllfci0rhC5p+P6wEgnEjXmQyuseR2My+GXVpTmExb14e7M+mX2EmytsfJccVjPBX6HS0eestAHLuvZfS+6cGtzdSll2dloY6LY2I+qw6O3qDjRxiuXziA+i1tfEsIu5D8HsRFjBmA33TrPgqXBRuKkXeUBgek0KwrHz8LT2pqgyw03aEzrY++BdVI/v2kgwskEzw5/Yo9RKxejVJzgAdMcFlGRyqcvHQ+sOUWlOQDMGHAykmBoVej/zog5gt6TDsHxz1adDlVhJrjCU9LQ0pNhaFXk/e1AeB4PnU9q238FeUh7e5Dzds+KmPjSWmjrUkuWNnrKlpVNT0g2qMyqJCVn/0AbMvfRp9WnxYYJS7ypn842RWp6xmdebqJvehVWp5+4K3SdInhVP9G8sgPF6GHQjR8lshxMhpQLRYj6hCQ53Bg+ffj1ljjgiO61pWSFKoyqEfXqvTk2WIUsH/tUnE4rcRu3o235VOxifrWLEqsueMpHCR9stdmFUlZFjBJWv50ViELRAsh65VKZl2RQ/ijBo0egmjZTBFNhdVzsgiZwkJerq0t7Z4DZpTWMxfVk7Ovfeicjr5D0G/durMl6n8tpCE/zsfY7/gxS/0VAfN79VRn7g2bYkxixoggpNPqFBaoDry3Ao13HPmGWEf2P3XogcSbu8NgOL9PchfHA2PLwNS1RLJ/VNJKLCjW3+YB5btA0AvKbHqrKQs/AzZZ0dT7UP/RR4PLDsGy46hV6v4/v6LSU9Li3o+efPygpYRt5v8GlFSl7rnb4g2HTrRpkOnJo+98PBB1rkcJPv1xAXiQ884xJPMO/1eJr+qEI8nsuOe2+NhzeYt+P1+bGobG5M28vLilzF7zUiSxLkX9cLpc4ZT7qsdTrK9hbx0+FVWZK6grTHocHUpXTy28bFmiRZByxFi5BQgt8JJfp4dr6P24hKjl0gy69CZ1JTLkbEehR452PelXj2lmGo/728oIcaXB8AQ4BpvgPKNRnxy451/d+MFdMDDKPATo8xDqfBHjFEQ4OvyhwHwIZNxY1+md6wN/481aiIaPwEk8tv1majb2wVo1DSs0Ovxz5zNfd8e5aX/G4ohOR37uq2ok2v90CGrh0BwuhJy40RDZQ66geLUzxNz/TykrsFzvykB0wb4UIqhwhc87y0+BdL8vZTWWFvapqv57q52VEkKDhbZmbxoG+XVHtKt+qjnkzotjTYvzSZn/D2kPvcs2o61MWoh146vvLzF56E+JgZJq+XrV19o0edSJQ2yJOE0yWxP1oSLIwIsy1yGyq8g892vyPbpcbbphEPtRtVGxTO7nonYj0ah4eGMycSoaiwyGjvPZb4YTkc+Uu1C8mRxpDyA5AlamELu8RJn01afs50TEiNz5szhueeeo6CggHPPPZdXXnmFQYMGNTr+448/5rHHHuPo0aN06dKFZ555hssvv/yEJ32qYStzNdrOui5Kez7V+8ooL/LirlESlU4P76/KpoM9HRXKBvtQSdDjwkouye+BdqODClUeFX4/Azx2hgU0+HdXoEIBASXYEwE1UCs8igEJFwnSQXxydB9uCHfAhFMZS7sbL0JtUDc67kStG78FodiOaKZhVVwsUmwsmbKRQ+t8UEeACARnG5IyG8lce01pSsBIVh3nPjAwQqwEqr2Uvr+Hknd3AcFg8+7394dmeiOlxGBcmDZKP6YTJSYhqUFKf3MJpf7/eUUibo2fgEqNs00nUCrR+rUo0gw4AZVSSfyRQ/z73ClQ0zLCXlXJum070co6DhyubVrpUNrRtFdHpCPHAo8W0IB//PAP5g14lWRdcF30MTFU6/xklWThctVWvrWoLWgqTXglGzFKD+UlheQpqsPvm+223/Ax79ShxWJk0aJFTJkyhblz5zJ48GBmz57NiBEjyMzMJCmp4a90zZo1/PWvf2XGjBlceeWVLFiwgKuvvpotW7bQu3fv3+Qgfi2OSi/FPtvxB0YhVI0waiqrGnpeUU2CvQ2pWj2Bjx+g1Kfjm4qH8Mm1QZudaRsRDBredyCGbyoeYtdKC10Zz/6joXeUDKsRHCpq20BLChcj4p6jsNfd+DV1KvaZElEk9I2YW2VNXQCXr9YCopNUvDO+X6sJjeaibsQ0HCa3spVmJhCcvkQTKyFrSqi7cH3LSmsQLaW/udQXMjZ7NbIkYbTWPsAF3E4+nf4g+z/8KOKz7Q0mLhp3F1pj0D1eWVbG8tVrufTYcNyqYHB8ucHEDz0GcsnuDaQc3YvCH1yvSqOH1b3yeG3+v7BUBy1XXr2Cn/rk4JEjH2RVARXnF52PNk1LL+CTpb+g9Wsx+IOZQ22lUu4AikuK8ZJ3QutQn4pi1/EH/c60WIzMmjWLu+66i9tuC6ZAzp07l6VLl/Luu+/y8MMPNxj/0ksvMXLkSKZODQYM/vvf/2b58uW8+uqrzJ0791dO/9ej9Gv5/rXD+L2HTngfkkbJVZPORV9jHsVWgPN/E/imdDI7PjdyPcFj/6Q4+HaAAJmGLLw1rhCNUsHdw9tjTpwBQJnDzYyl+3D7A2iM2WhUDjSxawlUXsDo3j2wSfChx84YjYlOVj2pCcEfqc5gwZz6Du2b2a/gnHMSI+oCRHO1nKoIV4tA8PvTlDXldKS+kEluZFw060u0IPV2XbtGBN0e8CtY5tRgVWRhiKvNmpJVDlSBQlb3ihQPKr+KPxQMISa/GIXfh1vjZ+U5OaxOiQzCDQXdmmQTPy18CYDFixeTT9PBus1F8pqIpR82m+03da+3aA4tGezxeNi8eTPTptWapJRKJcOHD2ft2rVRP7N27VqmTJkSsW3EiBF8/vnnjX6P2+3G7a4t6VNZGXzSrToB01xT2Gw2PE4/9mo7w27uTmzyibV81hrVmOPUQE0Qh7MQrX8dV15TQqZfw/Td7zBin5Ge/f/G4Y16YoencXO/buHPWw0a0uqIgETggYyeVDiCQuGY7QBPbH6L566YxKB257LL5uDnrQeZ0rcz7et00pSBKoBmrpNZCWZz3TLPXqqqGrqbTjZOux2730+V3Y635liibWsMu62KgNuB3VZFFSps7mp0tio0VQ2tVy3CZqfKJVNdHaCqyg7yb/t7FAh+C6ps9uBv1CWDzd7s60FTeGz28Hlkx197flUpGv1MY+dsS87lVkOjQ5/QsORA/XtQTHwiMfGJte/bHAS2HuTKyy+nHcGHzWNVx5i+ZjrTukzDrKu90TttdnQ+JWndUjEba6/jf3GXkldYzKalR9kmldEmsJY1fcrwqDwkxSUx8vIrqPr4v1x21Qi88T1+k8PNyixk++eVlJQUk1BlOv4HWkBozWQ5etPIMHILyM3NlQF5zZo1EdunTp0qDxo0KOpn1Gq1vGDBgohtc+bMkZOSkhr9nunTp8sE763iJV7iJV7iJV7idZq/srOzm9QXp2Q2zbRp0yKsKYFAgLKyMuLj41EoGlfiLaGqqoq2bduSnZ1NjChWdVzEejUfsVYtQ6xX8xFr1TLEejWf32utZFnGZrORdhy3eovESEJCAiqVisLCwojthYWFpKREz1xISUlp0XgArVaLtl71vt+rvG9MTIz4kbYAsV7NR6xVyxDr1XzEWrUMsV7N5/dYK4vFctwxDXNJm0Cj0dC/f39WrFgR3hYIBFixYgVDhgyJ+pkhQ4ZEjAdYvnx5o+MFAoFAIBCcXbTYTTNlyhTGjRvHgAEDGDRoELNnz6a6ujqcXTN27FjS09OZMSOYGXLfffdx8cUX88ILL3DFFVewcOFCNm3axJtvvvnbHolAIBAIBILTkhaLkRtvvJHi4mIef/xxCgoKOO+88/j2229JTg4mSWVlZaFU1hpcLrjgAhYsWMCjjz7KI488QpcuXfj8889bvcaIVqtl+vTpDdxBguiI9Wo+Yq1ahliv5iPWqmWI9Wo+rb1WClk+Xr6NQCAQCAQCwe9Hi2JGBAKBQCAQCH5rhBgRCAQCgUDQqggxIhAIBAKBoFURYkQgEAgEAkGrIsRIDX/+85/JyMhAp9ORmprKLbfcQl7eb9MR8Uzi6NGj3HHHHXTo0AG9Xk+nTp2YPn06Ho/n+B8+C/nPf/7DBRdcgMFg+N0K953OzJkzh/bt26PT6Rg8eDAbNmxo7Smdkvz8889cddVVpKWloVAomuztdbYzY8YMBg4ciNlsJikpiauvvprMzMzWntYpy+uvv06fPn3Cxc6GDBnCN998c9LnIcRIDcOGDeOjjz4iMzOTTz/9lEOHDnH99de39rROOfbt20cgEOCNN95g9+7dvPjii8ydO5dHHnmktad2SuLxeLjhhhu45557WnsqpxyLFi1iypQpTJ8+nS1btnDuuecyYsQIioqKWntqpxzV1dWce+65zJkzp7Wncsrz008/MWHCBNatW8fy5cvxer386U9/orq6urWndkrSpk0bZs6cyebNm9m0aROXXHIJo0ePZvfu3Sd3Is1pkHc2smTJElmhUMgej6e1p3LK8+yzz8odOnRo7Wmc0sybN0+2WCytPY1TikGDBskTJkwI/+33++W0tDR5xowZrTirUx9A/uyzz1p7GqcNRUVFMiD/9NNPrT2V04bY2Fj57bffPqnfKSwjUSgrK+PDDz/kggsuQK1Wt/Z0TnkqKyuJi4tr7WkITiM8Hg+bN29m+PDh4W1KpZLhw4ezdu3aVpyZ4EyjsrISQFyjmoHf72fhwoVUV1ef9JYtQozU4aGHHsJoNBIfH09WVhZLlixp7Smd8hw8eJBXXnmFu+++u7WnIjiNKCkpwe/3hys3h0hOTqagoKCVZiU40wgEAkyePJk//OEPrV71+1Rm586dmEwmtFot48eP57PPPqNnz54ndQ5ntBh5+OGHUSgUTb727dsXHj916lS2bt3KsmXLUKlUjB07FvksKVDb0rUCyM3NZeTIkdxwww3cddddrTTzk8+JrJVAIDj5TJgwgV27drFw4cLWnsopTbdu3di2bRvr16/nnnvuYdy4cezZs+ekzuGMLgdfXFxMaWlpk2M6duyIRqNpsD0nJ4e2bduyZs2as6LDcEvXKi8vj6FDh3L++eczf/78iH5EZzon8ruaP38+kydPpqKi4nee3emBx+PBYDDwySefcPXVV4e3jxs3joqKCmGVbAKFQsFnn30WsW6ChkycOJElS5bw888/06FDh9aezmnF8OHD6dSpE2+88cZJ+84WN8o7nUhMTCQxMfGEPhsIBABwu92/5ZROWVqyVrm5uQwbNoz+/fszb968s0qIwK/7XQmCaDQa+vfvz4oVK8I31UAgwIoVK5g4cWLrTk5wWiPLMpMmTeKzzz5j5cqVQoicAIFA4KTf+85oMdJc1q9fz8aNG7nwwguJjY3l0KFDPPbYY3Tq1OmssIq0hNzcXIYOHUq7du14/vnnKS4uDr+XkpLSijM7NcnKyqKsrIysrCz8fj/btm0DoHPnzphMptadXCszZcoUxo0bx4ABAxg0aBCzZ8+murqa2267rbWndspht9s5ePBg+O8jR46wbds24uLiyMjIaMWZnXpMmDCBBQsWsGTJEsxmczgGyWKxoNfrW3l2px7Tpk1j1KhRZGRkYLPZWLBgAStXruS77747uRM5qbk7pyg7duyQhw0bJsfFxclarVZu3769PH78eDknJ6e1p3bKMW/ePBmI+hI0ZNy4cVHX6scff2ztqZ0SvPLKK3JGRoas0WjkQYMGyevWrWvtKZ2S/Pjjj1F/R+PGjWvtqZ1yNHZ9mjdvXmtP7ZTk9ttvl9u1aydrNBo5MTFRvvTSS+Vly5ad9Hmc0TEjAoFAIBAITn3OLme/QCAQCASCUw4hRgQCgUAgELQqQowIBAKBQCBoVYQYEQgEAoFA0KoIMSIQCAQCgaBVEWJEIBAIBAJBqyLEiEAgEAgEglZFiBGBQCAQCAStihAjAsFpwtChQ5k8eXJrT6PVufXWW4/bJO63WKuCggIuu+wyjEYjVqv1V+1LIBA0jRAjAsFZzOLFi7nssstITEwkJiaGIUOGnPyeFI1w9OhRFApFuJ9PiJdeeon58+f/7t//4osvkp+fz7Zt29i/f//v/n0CwdmMECMCwVnMzz//zGWXXcbXX3/N5s2bGTZsGFdddRVbt25t7ak1isViOSmWikOHDtG/f3+6dOlCUlLS7/59AsHZjBAjAsFpSnl5OWPHjiU2NhaDwcCoUaM4cOBAxJi33nqLtm3bYjAYuOaaa5g1a1bEjXz27Nk8+OCDDBw4kC5duvD000/TpUsXvvzyy0a/d/78+VitVj7//HO6dOmCTqdjxIgRZGdnR4xbsmQJ/fr1Q6fT0bFjR5544gl8Pl/4fYVCweuvv86oUaPQ6/V07NiRTz75JPx+qPV73759USgUDB06FGjopqmurmbs2LGYTCZSU1N54YUXGszZ7XbzwAMPkJ6ejtFoZPDgwaxcubLRY2zfvj2ffvop7733HgqFgltvvRWAiooK7r77bpKTk9HpdPTu3ZuvvvoKgGPHjnHVVVcRGxuL0WikV69efP31141+h0AgqEWIEYHgNOXWW29l06ZNfPHFF6xduxZZlrn88svxer0ArF69mvHjx3Pfffexbds2LrvsMv7zn/80uc9AIIDNZiMuLq7JcQ6Hg//85z+89957rF69moqKCm666abw+6tWrWLs2LHcd9997NmzhzfeeIP58+c3+P7HHnuM6667ju3btzNmzBhuuukm9u7dC8CGDRsA+P7778nPz2fx4sVR5zJ16lR++uknlixZwrJly1i5ciVbtmyJGDNx4kTWrl3LwoUL2bFjBzfccAMjR45sIN5CbNy4kZEjR/KXv/yF/Px8XnrpJQKBAKNGjWL16tV88MEH7Nmzh5kzZ6JSqYBg63q3283PP//Mzp07eeaZZzCZTE2uo0AgqOGk9wkWCAQnxMUXXyzfd999sizL8v79+2VAXr16dfj9kpISWa/Xyx999JEsy7J84403yldccUXEPsaMGSNbLJZGv+OZZ56RY2Nj5cLCwkbHzJs3TwbkdevWhbft3btXBuT169fLsizLl156qfz0009HfO7999+XU1NTw38D8vjx4yPGDB48WL7nnntkWZblI0eOyIC8devWiDHjxo2TR48eLcuyLNtsNlmj0YSPWZZlubS0VNbr9eG1OnbsmKxSqeTc3NyI/Vx66aXytGnTGj3O0aNHy+PGjQv//d1338lKpVLOzMyMOv6cc86R//WvfzW6P4FA0DhSqyohgUBwQuzduxdJkhg8eHB4W3x8PN26dQtbFjIzM7nmmmsiPjdo0KCwW6E+CxYs4IknnmDJkiXHjZGQJImBAweG/+7evTtWq5W9e/cyaNAgtm/fzurVqyMsIX6/H5fLhcPhwGAwADBkyJCI/Q4ZMqRBwGpTHDp0CI/HE7EOcXFxdOvWLfz3zp078fv9dO3aNeKzbreb+Pj4Zn/Xtm3baNOmTYP9hLj33nu55557WLZsGcOHD+e6666jT58+zd6/QHA2I8SIQCBg4cKF3HnnnXz88ccMHz78V+/PbrfzxBNPcO211zZ4T6fT/er9t3QuKpWKzZs3h10qIVriRtHr9U2+f+eddzJixAiWLl3KsmXLmDFjBi+88AKTJk06oXkLBGcTImZEIDgN6dGjBz6fj/Xr14e3lZaWkpmZSc+ePQHo1q0bGzdujPhc/b8B/ve//3Hbbbfxv//9jyuuuKJZ3+/z+di0aVP478zMTCoqKujRowcA/fr1IzMzk86dOzd4KZW1l51169ZF7HfdunXhfWg0GiBoUWmMTp06oVarI9ahvLw8IhW3b9+++P1+ioqKGswlJSWlWccL0KdPH3JycppM823bti3jx49n8eLF3H///bz11lvN3r9AcDYjLCMCwWlIly5dGD16NHfddRdvvPEGZrOZhx9+mPT0dEaPHg3ApEmTuOiii5g1axZXXXUVP/zwA9988w0KhSK8nwULFjBu3DheeuklBg8eTEFBARC0Algslka/X61WM2nSJF5++WUkSWLixImcf/75DBo0CIDHH3+cK6+8koyMDK6//nqUSiXbt29n165dPPXUU+H9fPzxxwwYMIALL7yQDz/8kA0bNvDOO+8AkJSUhF6v59tvv6VNmzbodLoGczKZTNxxxx1MnTqV+Ph4kpKS+Oc//xkheLp27cqYMWMYO3YsL7zwAn379qW4uJgVK1bQp0+fZguwiy++mIsuuojrrruOWbNm0blzZ/bt24dCoWDkyJFMnjyZUaNG0bVrV8rLy/nxxx/DwkogEByH1g5aEQgEzaNuAKssy3JZWZl8yy23yBaLRdbr9fKIESPk/fv3R3zmzTfflNPT02W9Xi9fffXV8lNPPSWnpKRE7BNo8KobuFmfefPmyRaLRf7000/ljh07ylqtVh4+fLh87NixiHHffvutfMEFF8h6vV6OiYmRBw0aJL/55pvh9wF5zpw58mWXXSZrtVq5ffv28qJFiyL28dZbb8lt27aVlUqlfPHFF8uyHBnAKsvBINabb75ZNhgMcnJysvzss882WCuPxyM//vjjcvv27WW1Wi2npqbK11xzjbxjx45Gj7N+AKssB4Njb7vtNjk+Pl7W6XRy79695a+++kqWZVmeOHGi3KlTJ1mr1cqJiYnyLbfcIpeUlDS6f4FAUItClmW5NcWQQCA4edx1113s27ePVatWnfA+5s+fz+TJk6moqPhVc1EoFHz22WfHLe0uEAjOfISbRiA4g3n++efD/VW++eYb/vvf//Laa6+19rQEAoEgAiFGBIIzmA0bNvDss89is9no2LEjL7/8MnfeeWdrT0sgEAgiEG4agUAgEAgErYpI7RUIBAKBQNCqCDEiEAgEAoGgVRFiRCAQCAQCQasixIhAIBAIBIJWRYgRgUAgEAgErYoQIwKBQCAQCFoVIUYEAoFAIBC0KkKMCAQCgUAgaFX+H5TnVN7rq3OTAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checked that close to zero\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checked that close to zero\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "checked that close to zero\n" ] } ], @@ -475,80 +512,916 @@ "outputs": [], "source": [] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Learning Tests" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import seaborn as sns\n", - "\n", - "def test_taking_the_mean_along_an_axis():\n", - "\n", - " example_set = sns.load_dataset(\"iris\").set_index(\"species\")\n", - "\n", - " example_mean = example_set.mean(axis=1)\n", - "\n", - " assert example_mean.to_numpy()[3] == np.mean([4.6, 3.1, 1.5, 0.2])\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "test_taking_the_mean_along_an_axis()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "directlfq", - "language": "python", - "name": "python3" - }, - "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.17" + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678910111213141516171819
proteinion
protA044.60296544.47424141.48908543.21630743.50570842.33840443.45421143.102621NaN43.62550843.26134040.20334944.44736444.554027NaN44.70169043.10670344.63097543.38065043.407413
1NaNNaNNaNNaNNaN32.372620NaNNaNNaNNaN33.295555NaNNaNNaNNaNNaNNaNNaNNaNNaN
229.730290NaN26.61641028.34363228.63303327.46572928.58153728.22994627.024859NaN28.38866525.33067429.57468929.68135229.81966829.82901528.23402929.75830128.50797528.534739
3NaNNaNNaN38.309416NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN38.500523
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 \\\n", + "protein ion \n", + "protA 0 44.602965 44.474241 41.489085 43.216307 43.505708 42.338404 \n", + " 1 NaN NaN NaN NaN NaN 32.372620 \n", + " 2 29.730290 NaN 26.616410 28.343632 28.633033 27.465729 \n", + " 3 NaN NaN NaN 38.309416 NaN NaN \n", + "\n", + " 6 7 8 9 10 11 \\\n", + "protein ion \n", + "protA 0 43.454211 43.102621 NaN 43.625508 43.261340 40.203349 \n", + " 1 NaN NaN NaN NaN 33.295555 NaN \n", + " 2 28.581537 28.229946 27.024859 NaN 28.388665 25.330674 \n", + " 3 NaN NaN NaN NaN NaN NaN \n", + "\n", + " 12 13 14 15 16 17 \\\n", + "protein ion \n", + "protA 0 44.447364 44.554027 NaN 44.701690 43.106703 44.630975 \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 29.574689 29.681352 29.819668 29.829015 28.234029 29.758301 \n", + " 3 NaN NaN NaN NaN NaN NaN \n", + "\n", + " 18 19 \n", + "protein ion \n", + "protA 0 43.380650 43.407413 \n", + " 1 NaN NaN \n", + " 2 28.507975 28.534739 \n", + " 3 NaN 38.500523 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678910111213141516171819
proteinion
protA044.60296544.47424141.48908543.21630743.50570842.33840443.45421143.102621NaN43.62550843.2613440.20334944.44736444.554027NaN44.7016943.10670344.63097543.3806543.407413
1NaNNaNNaNNaNNaN42.338404NaNNaNNaNNaN43.26134NaNNaNNaNNaNNaNNaNNaNNaNNaN
244.602965NaN41.48908543.21630743.50570842.33840443.45421143.10262141.897534NaN43.2613440.20334944.44736444.55402744.69234344.7016943.10670344.63097543.3806543.407413
3NaNNaNNaN43.216307NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN43.407413
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 \\\n", + "protein ion \n", + "protA 0 44.602965 44.474241 41.489085 43.216307 43.505708 42.338404 \n", + " 1 NaN NaN NaN NaN NaN 42.338404 \n", + " 2 44.602965 NaN 41.489085 43.216307 43.505708 42.338404 \n", + " 3 NaN NaN NaN 43.216307 NaN NaN \n", + "\n", + " 6 7 8 9 10 11 \\\n", + "protein ion \n", + "protA 0 43.454211 43.102621 NaN 43.625508 43.26134 40.203349 \n", + " 1 NaN NaN NaN NaN 43.26134 NaN \n", + " 2 43.454211 43.102621 41.897534 NaN 43.26134 40.203349 \n", + " 3 NaN NaN NaN NaN NaN NaN \n", + "\n", + " 12 13 14 15 16 17 \\\n", + "protein ion \n", + "protA 0 44.447364 44.554027 NaN 44.70169 43.106703 44.630975 \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 44.447364 44.554027 44.692343 44.70169 43.106703 44.630975 \n", + " 3 NaN NaN NaN NaN NaN NaN \n", + "\n", + " 18 19 \n", + "protein ion \n", + "protA 0 43.38065 43.407413 \n", + " 1 NaN NaN \n", + " 2 43.38065 43.407413 \n", + " 3 NaN 43.407413 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "array([40.20334853, 40.20334853])" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678910111213141516171819
proteinion
protA044.60296544.47424041.48908643.21630743.50570742.33840343.45421143.10262141.89753443.62550743.26134040.20335044.44736344.55402744.69234344.70169043.10670444.63097543.38065043.407413
134.63718334.50846631.52330433.25051333.53993832.37259633.48841133.13684231.93175433.65970533.29557630.23752834.48157734.58823534.72654634.73590733.14092634.66519533.41486633.441616
229.73027729.60157126.61643728.34361028.63304627.46586228.58151128.22997327.02472928.75290828.38865625.33035929.57471429.68143529.81958829.82910128.23412029.75831028.50797328.534678
339.69607339.56735136.58219538.30941838.59881837.43151438.54732238.19573036.99064538.71861838.35445135.29645439.54047139.64713439.78545239.79479938.19981139.72408738.47375338.500520
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 \\\n", + "protein ion \n", + "protA 0 44.602965 44.474240 41.489086 43.216307 43.505707 42.338403 \n", + " 1 34.637183 34.508466 31.523304 33.250513 33.539938 32.372596 \n", + " 2 29.730277 29.601571 26.616437 28.343610 28.633046 27.465862 \n", + " 3 39.696073 39.567351 36.582195 38.309418 38.598818 37.431514 \n", + "\n", + " 6 7 8 9 10 11 \\\n", + "protein ion \n", + "protA 0 43.454211 43.102621 41.897534 43.625507 43.261340 40.203350 \n", + " 1 33.488411 33.136842 31.931754 33.659705 33.295576 30.237528 \n", + " 2 28.581511 28.229973 27.024729 28.752908 28.388656 25.330359 \n", + " 3 38.547322 38.195730 36.990645 38.718618 38.354451 35.296454 \n", + "\n", + " 12 13 14 15 16 17 \\\n", + "protein ion \n", + "protA 0 44.447363 44.554027 44.692343 44.701690 43.106704 44.630975 \n", + " 1 34.481577 34.588235 34.726546 34.735907 33.140926 34.665195 \n", + " 2 29.574714 29.681435 29.819588 29.829101 28.234120 29.758310 \n", + " 3 39.540471 39.647134 39.785452 39.794799 38.199811 39.724087 \n", + "\n", + " 18 19 \n", + "protein ion \n", + "protA 0 43.380650 43.407413 \n", + " 1 33.414866 33.441616 \n", + " 2 28.507973 28.534678 \n", + " 3 38.473753 38.500520 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678910111213141516171819
proteinion
protA044.60296544.47424041.48908643.21630743.50570742.33840343.45421143.10262141.89753443.62550743.26134040.20335044.44736344.55402744.69234344.70169043.10670444.63097543.38065043.407413
144.60296644.47424841.48908643.21629543.50572142.33837843.45419343.10262541.89753643.62548743.26135940.20331144.44736044.55401744.69232844.70168943.10670844.63097843.38064943.407399
244.60294644.47424041.48910643.21627943.50571642.33853143.45418143.10264341.89739843.62557843.26132540.20302844.44738344.55410444.69225744.70177043.10679044.63098043.38064343.407348
344.60296344.47424241.48908643.21630843.50570842.33840443.45421243.10262041.89753643.62550943.26134140.20334444.44736144.55402444.69234244.70169043.10670144.63097743.38064343.407411
\n", + "
" + ], + "text/plain": [ + " 0 1 2 3 4 5 \\\n", + "protein ion \n", + "protA 0 44.602965 44.474240 41.489086 43.216307 43.505707 42.338403 \n", + " 1 44.602966 44.474248 41.489086 43.216295 43.505721 42.338378 \n", + " 2 44.602946 44.474240 41.489106 43.216279 43.505716 42.338531 \n", + " 3 44.602963 44.474242 41.489086 43.216308 43.505708 42.338404 \n", + "\n", + " 6 7 8 9 10 11 \\\n", + "protein ion \n", + "protA 0 43.454211 43.102621 41.897534 43.625507 43.261340 40.203350 \n", + " 1 43.454193 43.102625 41.897536 43.625487 43.261359 40.203311 \n", + " 2 43.454181 43.102643 41.897398 43.625578 43.261325 40.203028 \n", + " 3 43.454212 43.102620 41.897536 43.625509 43.261341 40.203344 \n", + "\n", + " 12 13 14 15 16 17 \\\n", + "protein ion \n", + "protA 0 44.447363 44.554027 44.692343 44.701690 43.106704 44.630975 \n", + " 1 44.447360 44.554017 44.692328 44.701689 43.106708 44.630978 \n", + " 2 44.447383 44.554104 44.692257 44.701770 43.106790 44.630980 \n", + " 3 44.447361 44.554024 44.692342 44.701690 43.106701 44.630977 \n", + "\n", + " 18 19 \n", + "protein ion \n", + "protA 0 43.380650 43.407413 \n", + " 1 43.380649 43.407399 \n", + " 2 43.380643 43.407348 \n", + " 3 43.380643 43.407411 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import directlfq.normalization as lfq_norm\n", + "import directlfq.test_utils as lfq_test_utils\n", + "import numpy as np\n", + "\n", + "def test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other():\n", + " peptide1= lfq_test_utils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=False)\n", + " peptide2= lfq_test_utils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=3, add_noise=False)\n", + " peptide3= lfq_test_utils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=0.1, add_noise=False)\n", + " peptide4= lfq_test_utils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=100, add_noise=False)\n", + " protein_df = lfq_test_utils.ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", + " display(protein_df)\n", + " normed_ion_profile = lfq_norm.normalize_ion_profiles(protein_df)\n", + " display(normed_ion_profile)\n", + " column_from_shifted = normed_ion_profile.iloc[:,11].dropna().to_numpy()\n", + " display(column_from_shifted)\n", + " assert np.allclose(column_from_shifted, column_from_shifted[0])\n", + "\n", + "def test_that_profiles_with_noise_are_close():\n", + " peptide1= lfq_test_utils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=3000, add_noise=True)\n", + " peptide2= lfq_test_utils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", + " peptide3= lfq_test_utils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", + " peptide4= lfq_test_utils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + "\n", + " protein_df = lfq_test_utils.ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", + " display(protein_df)\n", + " \n", + " normed_ion_profile = lfq_norm.normalize_ion_profiles(protein_df)\n", + " display(normed_ion_profile)\n", + " column_from_shifted = normed_ion_profile.iloc[:,9].dropna().to_numpy()\n", + "\n", + " assert np.allclose(column_from_shifted, column_from_shifted[0],rtol=0.01, atol=0.01)\n", + "\n", + "test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other()\n", + "test_that_profiles_with_noise_are_close()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Tests" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import seaborn as sns\n", + "\n", + "def test_taking_the_mean_along_an_axis():\n", + "\n", + " example_set = sns.load_dataset(\"iris\").set_index(\"species\")\n", + "\n", + " example_mean = example_set.mean(axis=1)\n", + "\n", + " assert example_mean.to_numpy()[3] == np.mean([4.6, 3.1, 1.5, 0.2])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "test_taking_the_mean_along_an_axis()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "directlfq", + "language": "python", + "name": "python3" } }, "nbformat": 4, diff --git a/nbdev_nbs/03_protein_intensity_estimation.ipynb b/nbdev_nbs/03_protein_intensity_estimation.ipynb index d30cbde..8e2e4d9 100644 --- a/nbdev_nbs/03_protein_intensity_estimation.ipynb +++ b/nbdev_nbs/03_protein_intensity_estimation.ipynb @@ -27,314 +27,7 @@ "source": [ "# Protein Intenstiity Estimation\n", "\n", - "This notebook implements the protein LFQ intensity estimation step. It is in principle a wrapper around the functionality of the normalization.py class, which is used to shift precursors or transition intensity traces on top of each other." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "import numpy as np\n", - "import directlfq.normalization as lfqnorm\n", - "import multiprocess\n", - "import itertools\n", - "\n", - "def estimate_protein_intensities(normed_df, min_nonan, num_samples_quadratic, num_cores):\n", - " \"derives protein pseudointensities from between-sample normalized data\"\n", - " \n", - " allprots = list(normed_df.index.get_level_values(0).unique())\n", - " print(f\"{len(allprots)} prots total\")\n", - " \n", - " list_of_tuple_w_protein_profiles_and_shifted_peptides = get_list_of_tuple_w_protein_profiles_and_shifted_peptides(allprots, normed_df, num_samples_quadratic, min_nonan, num_cores)\n", - " protein_df = get_protein_dataframe_from_list_of_protein_profiles(allprots=allprots, list_of_tuple_w_protein_profiles_and_shifted_peptides=list_of_tuple_w_protein_profiles_and_shifted_peptides, normed_df= normed_df)\n", - " ion_df = get_ion_intensity_dataframe_from_list_of_shifted_peptides(list_of_tuple_w_protein_profiles_and_shifted_peptides, allprots)\n", - "\n", - " return protein_df, ion_df\n", - "\n", - "\n", - "def get_list_of_tuple_w_protein_profiles_and_shifted_peptides(allprots, normed_df, num_samples_quadratic, min_nonan, num_cores):\n", - " if num_cores is not None and num_cores <=1:\n", - " list_of_tuple_w_protein_profiles_and_shifted_peptides = get_list_with_sequential_processing(allprots, normed_df, num_samples_quadratic, min_nonan)\n", - " else:\n", - " list_of_tuple_w_protein_profiles_and_shifted_peptides = get_list_with_multiprocessing(allprots, normed_df, num_samples_quadratic, min_nonan, num_cores)\n", - " return list_of_tuple_w_protein_profiles_and_shifted_peptides\n", - "\n", - "def get_list_with_sequential_processing(allprots, normed_df, num_samples_quadratic, min_nonan):\n", - " input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan = get_input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan(normed_df, allprots, num_samples_quadratic, min_nonan)\n", - " list_of_tuple_w_protein_profiles_and_shifted_peptides = list(map(lambda x : calculate_peptide_and_protein_intensities(*x), input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan))\n", - " return list_of_tuple_w_protein_profiles_and_shifted_peptides\n", - " \n", - "def get_list_with_multiprocessing(allprots, normed_df, num_samples_quadratic, min_nonan, num_cores):\n", - " pool = get_configured_multiprocessing_pool(num_cores)\n", - " input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan = get_input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan(normed_df, allprots, num_samples_quadratic, min_nonan)\n", - " list_of_tuple_w_protein_profiles_and_shifted_peptides = pool.starmap(calculate_peptide_and_protein_intensities, input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan)\n", - " pool.close()\n", - " return list_of_tuple_w_protein_profiles_and_shifted_peptides\n", - "\n", - "\n", - "def get_configured_multiprocessing_pool(num_cores):\n", - " multiprocess.freeze_support()\n", - " if num_cores is None:\n", - " num_cores = multiprocess.cpu_count() if multiprocess.cpu_count() < 60 else 60 #windows upper thread limit\n", - " pool = multiprocess.Pool(num_cores)\n", - " print(f\"using {pool._processes} processes\")\n", - " return pool\n", - "\n", - "\n", - "def get_input_specification_tuplelist_idx__df__num_samples_quadratic__min_nonan(normed_df, allprots, num_samples_quadratic, min_nonan):\n", - " list_of_normed_dfs = get_normed_dfs(normed_df, allprots)\n", - " return zip(range(len(list_of_normed_dfs)),list_of_normed_dfs, itertools.repeat(num_samples_quadratic), itertools.repeat(min_nonan))\n", - "\n", - "\n", - "\n", - "\n", - "def get_normed_dfs(normed_df, allprots):\n", - " list_of_normed_dfs = []\n", - " for protein in allprots:\n", - " peptide_intensity_df = pd.DataFrame(normed_df.loc[protein])#DataFrame definition to avoid pandas Series objects\n", - " if len(peptide_intensity_df.index) > 1:\n", - " peptide_intensity_df = ProtvalCutter(peptide_intensity_df, maximum_df_length=100).get_dataframe()\n", - " peptide_intensity_df = OrphanIonRemover(peptide_intensity_df).orphan_removed_df\n", - " list_of_normed_dfs.append(peptide_intensity_df)\n", - "\n", - " return list_of_normed_dfs\n", - "\n", - "\n", - "def get_ion_intensity_dataframe_from_list_of_shifted_peptides(list_of_tuple_w_protein_profiles_and_shifted_peptides, allprots):\n", - " ion_ints = [x[1] for x in list_of_tuple_w_protein_profiles_and_shifted_peptides]\n", - " ion_ints = add_protein_names_to_ion_ints(ion_ints, allprots)\n", - " ion_df = 2**pd.concat(ion_ints)\n", - " ion_df = ion_df.replace(np.nan, 0)\n", - " return ion_df\n", - "\n", - "def add_protein_names_to_ion_ints(ion_ints, allprots):\n", - " ion_ints = [add_protein_name_to_ion_df(ion_ints[idx], allprots[idx]) for idx in range(len(ion_ints))]\n", - " return ion_ints\n", - "\n", - "def add_protein_name_to_ion_df(ion_df, protein):\n", - " ion_df[\"protein\"] = protein\n", - " ion_df = ion_df.reset_index().set_index([\"protein\", \"ion\"])\n", - " return ion_df\n", - "\n", - "\n", - "def get_protein_dataframe_from_list_of_protein_profiles(allprots, list_of_tuple_w_protein_profiles_and_shifted_peptides, normed_df):\n", - " index_list = []\n", - " profile_list = []\n", - "\n", - " list_of_protein_profiles = [x[0] for x in list_of_tuple_w_protein_profiles_and_shifted_peptides]\n", - " \n", - " for idx in range(len(allprots)):\n", - " if list_of_protein_profiles[idx] is None:\n", - " continue\n", - " index_list.append(allprots[idx])\n", - " profile_list.append(list_of_protein_profiles[idx])\n", - " \n", - " index_for_protein_df = pd.Index(data=index_list, name=\"protein\")\n", - " protein_df = 2**pd.DataFrame(profile_list, index = index_for_protein_df, columns = normed_df.columns)\n", - " protein_df = protein_df.replace(np.nan, 0)\n", - " protein_df = protein_df.reset_index()\n", - " return protein_df\n", - "\n", - "\n", - "def calculate_peptide_and_protein_intensities(idx,peptide_intensity_df , num_samples_quadratic, min_nonan):\n", - " if(idx%100 ==0):\n", - " print(f\"prot {idx}\")\n", - " summed_pepint = np.nansum(2**peptide_intensity_df)\n", - " \n", - " if(peptide_intensity_df.shape[1]<2):\n", - " shifted_peptides = peptide_intensity_df\n", - " else:\n", - " shifted_peptides = lfqnorm.NormalizationManagerProtein(peptide_intensity_df, num_samples_quadratic = num_samples_quadratic).complete_dataframe\n", - " \n", - " protein_profile = get_protein_profile_from_shifted_peptides(shifted_peptides, summed_pepint, min_nonan)\n", - " \n", - " return protein_profile, shifted_peptides\n", - "\n", - "\n", - "def get_protein_profile_from_shifted_peptides(normalized_peptide_profile_df, summed_pepints, min_nonan):\n", - " intens_vec = get_list_with_protein_value_for_each_sample(normalized_peptide_profile_df, min_nonan)\n", - " intens_vec = np.array(intens_vec)\n", - " summed_intensity = np.nansum(2**intens_vec)\n", - " if summed_intensity == 0: #this means all elements in intens vec are nans\n", - " return None\n", - " intens_conversion_factor = summed_pepints/summed_intensity\n", - " scaled_vec = intens_vec+np.log2(intens_conversion_factor)\n", - " return scaled_vec\n", - "\n", - "def get_list_with_protein_value_for_each_sample(normalized_peptide_profile_df, min_nonan):\n", - " intens_vec = []\n", - " for sample in normalized_peptide_profile_df.columns:\n", - " reps = normalized_peptide_profile_df.loc[:,sample].to_numpy()\n", - " nonan_elems = sum(~np.isnan(reps))\n", - " if(nonan_elems>=min_nonan):\n", - " intens_vec.append(np.nanmedian(reps))\n", - " else:\n", - " intens_vec.append(np.nan)\n", - " return intens_vec\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Helper classes\n", - "\n", - "Below two helper classes are implemented, which are used in the protein intensity estimation above. The ProtValCutter class keeps the N most complete ion intensity traces of a protein. This is relevant when a protein has an extraordinary large number of intensity traces (>100 per default), where adding further traces is unlikely to improve the protein intensity estimation. The OprhanIonRemover removes intensity traces that are \"orphans\" in the sense that they do not have overlapping intensities with any other intensity trace of the protein." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "from numba import njit\n", - "\n", - "class ProtvalCutter():\n", - " def __init__(self, protvals_df, maximum_df_length = 100):\n", - " self._protvals_df = protvals_df\n", - " self._maximum_df_length = maximum_df_length\n", - " self._dataframe_too_long = None\n", - " self._sorted_idx = None\n", - " self._check_if_df_too_long_and_sort_index_if_so()\n", - "\n", - "\n", - " def _check_if_df_too_long_and_sort_index_if_so(self):\n", - " self._dataframe_too_long =len(self._protvals_df.index)>self._maximum_df_length\n", - " if self._dataframe_too_long:\n", - " self._determine_nansorted_df_index()\n", - "\n", - " def _determine_nansorted_df_index(self):\n", - " idxs = self._protvals_df.index\n", - " self._sorted_idx = sorted(idxs, key= lambda idx : self._get_num_nas_in_row(self._protvals_df.loc[idx].to_numpy()))\n", - " \n", - " @staticmethod\n", - " @njit\n", - " def _get_num_nas_in_row(row):\n", - " return sum(np.isnan(row))\n", - "\n", - "\n", - " def get_dataframe(self):\n", - " if self._dataframe_too_long:\n", - " return self._get_shortened_dataframe()\n", - " else:\n", - " return self._protvals_df\n", - "\n", - " def _get_shortened_dataframe(self):\n", - " shortened_index = self._sorted_idx[:self._maximum_df_length]\n", - " return self._protvals_df.loc[shortened_index]\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "class OrphanIonRemover(): #removes ions that do not have any overlap with any of the other ions\n", - " def __init__(self, protvals_df : pd.DataFrame):\n", - " self._protvals_df = protvals_df\n", - " \n", - " self._provals_is_not_na_df = None\n", - " self._count_of_nonans_per_position = None\n", - " \n", - " self._orphan_ions = []\n", - " self._non_orphan_ions = []\n", - "\n", - " self.orphan_removed_df = None\n", - "\n", - " self._define_protvals_is_not_na_df()\n", - " self._define_count_of_nonans_per_position()\n", - " self._define_orphan_ions_and_non_orphan_ions()\n", - " self._define_orphan_removed_df()\n", - "\n", - " def _define_protvals_is_not_na_df(self):\n", - " self._provals_is_not_na_df = self._protvals_df.notna()\n", - "\n", - " def _define_count_of_nonans_per_position(self):\n", - " self._count_of_nonans_per_position = self._provals_is_not_na_df.sum(axis=0)\n", - " \n", - " def _define_orphan_ions_and_non_orphan_ions(self):\n", - " for ion in self._provals_is_not_na_df.index:\n", - " is_nonan_per_position_for_ion = self._provals_is_not_na_df.loc[ion].to_numpy()\n", - " orphan_checked_ion = IonCheckedForOrphan(ion,self._count_of_nonans_per_position, is_nonan_per_position_for_ion)\n", - " self._append_to_orphan_or_non_orphan_list(orphan_checked_ion)\n", - "\n", - " def _append_to_orphan_or_non_orphan_list(self, orphan_checked_ion):\n", - " if orphan_checked_ion.is_orphan:\n", - " self._orphan_ions.append(orphan_checked_ion)\n", - " else:\n", - " self._non_orphan_ions.append(orphan_checked_ion)\n", - " \n", - " def _define_orphan_removed_df(self):\n", - " ions_to_delete = OrphanIonsForDeletionSelector(self._orphan_ions, self._non_orphan_ions).ion_accessions_for_deletion\n", - " self.orphan_removed_df = self._protvals_df.drop(ions_to_delete, axis='index')\n", - "\n", - "\n", - "\n", - "class OrphanIonsForDeletionSelector():\n", - " def __init__(self, orphan_ions : list, non_orphan_ions : list):\n", - " self._orphan_ions = orphan_ions\n", - " self._non_orphan_ions = non_orphan_ions\n", - " \n", - " self.ion_accessions_for_deletion = None\n", - "\n", - " self._define_orphan_ions_for_deletion()\n", - " \n", - " def _define_orphan_ions_for_deletion(self):\n", - " if len(self._non_orphan_ions)>0:\n", - " self.ion_accessions_for_deletion = self._get_accessions_of_list_of_ions(self._orphan_ions)\n", - " else:\n", - " if len(self._orphan_ions)>1:\n", - " self._sort_list_of_ions_by_num_nonans_descending(self._orphan_ions)\n", - " orphan_ions_to_delete = self._orphan_ions[1:]\n", - " self.ion_accessions_for_deletion = self._get_accessions_of_list_of_ions(orphan_ions_to_delete)\n", - " \n", - " def _get_accessions_of_list_of_ions(self, ions_checked_for_orphan : list):\n", - " return [ion_checked_for_orphan.ion_accession for ion_checked_for_orphan in ions_checked_for_orphan]\n", - "\n", - " def _sort_list_of_ions_by_num_nonans_descending(self, ions : list):\n", - " ions.sort(key=lambda x: x.num_nonans, reverse=True)\n", - " \n", - "\n", - "\n", - "\n", - "\n", - "class IonCheckedForOrphan():\n", - " def __init__(self, ion_accession, count_of_nonans_per_position : np.array, is_nonan_per_position_for_ion : np.array):\n", - " self.ion_accession = ion_accession\n", - " \n", - " self._count_of_nonans_per_position = count_of_nonans_per_position\n", - " self._is_nonan_per_position_for_ion = is_nonan_per_position_for_ion\n", - "\n", - " self._count_of_nonans_per_position_for_ion = None\n", - "\n", - " self.is_orphan = None\n", - " self.num_nonans = None\n", - "\n", - " self._define_count_of_nonans_per_position_for_ion()\n", - " self._check_if_is_orphan()\n", - " self._define_num_nonans()\n", - "\n", - " def _define_count_of_nonans_per_position_for_ion(self):\n", - " self._count_of_nonans_per_position_for_ion = self._count_of_nonans_per_position[self._is_nonan_per_position_for_ion]\n", - "\n", - " def _check_if_is_orphan(self):\n", - " self.is_orphan = np.max(self._count_of_nonans_per_position_for_ion) == 1\n", - " \n", - " def _define_num_nonans(self):\n", - " self.num_nonans = np.sum(self._count_of_nonans_per_position_for_ion)" + "This notebook tests the protein LFQ intensity estimation step. It is in principle a wrapper around the functionality of the normalization.py class, which is used to shift precursors or transition intensity traces on top of each other." ] }, { @@ -356,78 +49,19 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "from numpy.random import MT19937\n", - "from numpy.random import RandomState, SeedSequence\n", - "\n", - "class ProteinProfileGenerator():\n", - " def __init__(self, peptide_profiles):\n", - " self._peptide_profiles = peptide_profiles\n", - " \n", - " self.protein_profile_dataframe = None\n", - " self._generate_protein_profile_dataframe()\n", - "\n", - " def _generate_protein_profile_dataframe(self):\n", - " collected_profiles = [x.peptide_profile_vector for x in self._peptide_profiles]\n", - " protnames_for_index = [x.protein_name for x in self._peptide_profiles]\n", - " pepnames_for_index = [f'{idx}' for idx in range(len(self._peptide_profiles))]\n", - " self.protein_profile_dataframe = pd.DataFrame(collected_profiles,index=[protnames_for_index, pepnames_for_index])\n", - " self.protein_profile_dataframe.index.names = ['protein', 'ion']\n", - " self.protein_profile_dataframe = np.log2(self.protein_profile_dataframe.replace(0, np.nan))\n", - "\n", - "\n", - "\n", - "class PeptideProfile():\n", - " def __init__(self, protein_name, fraction_zeros_in_profile, systematic_peptide_shift, add_noise, num_samples = 20, min_intensity = 1e6, max_intensity = 1e10):\n", - "\n", - "\n", - " self._fraction_zeros_in_profile = fraction_zeros_in_profile\n", - " self._systematic_peptide_shift = systematic_peptide_shift\n", - " self._add_noise = add_noise\n", - " self._min_intensity = min_intensity\n", - " self._max_intensity = max_intensity\n", - " self._num_samples = num_samples\n", - "\n", - " self.protein_name = protein_name\n", - " self.peptide_profile_vector = []\n", - " self._define_peptide_profile_vector()\n", - "\n", - " def _define_peptide_profile_vector(self):\n", - " self.peptide_profile_vector = self._get_single_peptide_profile_template()\n", - " self._scale_profile_vector()\n", - " if self._add_noise:\n", - " self._apply_poisson_noise_to_profilevector()\n", - " self._add_zeros_to_profilevector()\n", - "\n", - " def _get_single_peptide_profile_template(self):\n", - " rs = RandomState(MT19937(SeedSequence(42312)))\n", - " return rs.randint(low=self._min_intensity, high=self._max_intensity,size=self._num_samples)\n", - "\n", - " def _scale_profile_vector(self):\n", - " self.peptide_profile_vector = self.peptide_profile_vector*self._systematic_peptide_shift\n", - "\n", - " def _apply_poisson_noise_to_profilevector(self):\n", - " self.peptide_profile_vector = np.random.poisson(lam=self.peptide_profile_vector, size=len(self.peptide_profile_vector))\n", - "\n", - " def _add_zeros_to_profilevector(self):\n", - " num_elements_to_set_zero = int(self._num_samples*self._fraction_zeros_in_profile)\n", - " idxs_to_set_zero = np.random.choice(self._num_samples,size=num_elements_to_set_zero, replace=False)\n", - " self.peptide_profile_vector[idxs_to_set_zero] = 0\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['C', 'B']\n" + ] + } + ], "source": [ "import pandas as pd\n", "import numpy as np\n", + "import directlfq.protein_intensity_estimation as lfq_protint\n", "#test df cutting\n", "\n", "def test_sorting_by_num_nans():\n", @@ -436,7 +70,7 @@ " vals3 = np.array([1, 2, 3,np.nan ])\n", "\n", " df = pd.DataFrame([vals1, vals2, vals3],index=[['P', 'P', 'P'],['A', 'B', 'C']])\n", - " pcutter = ProtvalCutter(df,maximum_df_length=2)\n", + " pcutter = lfq_protint.ProtvalCutter(df,maximum_df_length=2)\n", " sorted_idx = pcutter._sorted_idx\n", " df_sorted = df.loc[sorted_idx]\n", " \n", @@ -450,207 +84,15 @@ " vals3 = np.array([1, 2, 3,np.nan ])\n", "\n", " df = pd.DataFrame([vals1, vals2, vals3],index=[['A', 'B', 'C']])\n", - " pcutter = ProtvalCutter(df, maximum_df_length=2)\n", + " pcutter = lfq_protint.ProtvalCutter(df, maximum_df_length=2)\n", " cut_df = pcutter.get_dataframe()\n", " ion_idx = [x[0] for x in cut_df.index]\n", " print(ion_idx)\n", " assert ion_idx == ['C', 'B']\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['C', 'B']\n" - ] - } - ], - "source": [ "\n", "\n", "test_sorting_by_num_nans()\n", - "test_cutting_of_df()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "#test df cutting\n", - "\n", - "def test_orphan_detection():\n", - " df_one_orphan = create_test_df_one_orphan()\n", - " df_three_orphans = create_test_df_three_orphans()\n", - " df_only_orphans = create_test_df_only_orphans()\n", - "\n", - " compare_df_no_orphans = create_compare_df_no_orphans()\n", - " compare_df_for_only_orphans = create_compare_df_only_orphans()\n", - "\n", - " df_orphanremoved_one = OrphanIonRemover(df_one_orphan).orphan_removed_df\n", - " df_orphanremoved_three = OrphanIonRemover(df_three_orphans).orphan_removed_df\n", - " df_orphanremoved_only = OrphanIonRemover(df_only_orphans).orphan_removed_df\n", - " df_orphanremoved_compare_df = OrphanIonRemover(compare_df_no_orphans).orphan_removed_df\n", - "\n", - " display(df_orphanremoved_compare_df)\n", - "\n", - " assert df_orphanremoved_one.equals(compare_df_no_orphans)\n", - " assert df_orphanremoved_three.equals(compare_df_no_orphans)\n", - " assert df_orphanremoved_only.equals(compare_df_for_only_orphans)\n", - " assert df_orphanremoved_compare_df.equals(compare_df_no_orphans)\n", - " \n", - " print('test_orphan_detection passed')\n", - "\n", - "def create_test_df_one_orphan():\n", - " vals1 = np.array([5, 6, np.nan, np.nan, np.nan, np.nan, np.nan])\n", - " vals2 = np.array([1, 2, 3,np.nan, np.nan, np.nan, np.nan])\n", - " vals3 = np.array([np.nan, np.nan, np.nan, 9, np.nan, np.nan, np.nan])\n", - "\n", - " return pd.DataFrame([vals1, vals2, vals3],index=[['P', 'P', 'P'],['A', 'B', 'C']])\n", - "\n", - "def create_test_df_three_orphans():\n", - " vals1 = np.array([5, 6, np.nan, np.nan, np.nan, np.nan, np.nan])\n", - " vals2 = np.array([1, 2, 3,np.nan, np.nan, np.nan, np.nan])\n", - " vals3 = np.array([np.nan, np.nan, np.nan, 9, np.nan, np.nan, np.nan])\n", - " vals4 = np.array([np.nan, np.nan, np.nan, np.nan, 10, np.nan, np.nan])\n", - " vals5 = np.array([np.nan, np.nan, np.nan, np.nan, np.nan, 11, 12])\n", - " \n", - " return pd.DataFrame([vals1, vals2, vals3, vals4, vals5],index=[['P', 'P', 'P', 'P', 'P'],['A', 'B', 'C', 'D', 'E']])\n", - "\n", - "\n", - "def create_compare_df_no_orphans():\n", - " vals1 = np.array([5, 6, np.nan, np.nan, np.nan, np.nan, np.nan])\n", - " vals2 = np.array([1, 2, 3,np.nan, np.nan, np.nan, np.nan])\n", - " \n", - " return pd.DataFrame([vals1, vals2],index=[['P', 'P'],['A', 'B']])\n", - "\n", - "def create_test_df_only_orphans():\n", - " vals3 = np.array([np.nan, np.nan, np.nan, 9, np.nan, np.nan, np.nan])\n", - " vals4 = np.array([np.nan, np.nan, np.nan, np.nan, 10, np.nan, np.nan])\n", - " vals5 = np.array([np.nan, np.nan, np.nan, np.nan, np.nan, 11, 12])\n", - " \n", - " return pd.DataFrame([vals3, vals4, vals5],index=[['P', 'P', 'P'],['C', 'D', 'E']])\n", - "\n", - "def create_compare_df_only_orphans():\n", - " vals5 = np.array([np.nan, np.nan, np.nan, np.nan, np.nan, 11, 12])\n", - " return pd.DataFrame([ vals5],index=[[ 'P'],[ 'E']])\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
0123456
PA5.06.0NaNNaNNaNNaNNaN
B1.02.03.0NaNNaNNaNNaN
\n", - "
" - ], - "text/plain": [ - " 0 1 2 3 4 5 6\n", - "P A 5.0 6.0 NaN NaN NaN NaN NaN\n", - " B 1.0 2.0 3.0 NaN NaN NaN NaN" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "test_orphan_detection passed\n" - ] - } - ], - "source": [ - "\n", - "test_orphan_detection()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other():\n", - " peptide1= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=False)\n", - " peptide2= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=3, add_noise=False)\n", - " peptide3= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=0.1, add_noise=False)\n", - " peptide4= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=100, add_noise=False)\n", - " protein_df = ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", - " display(protein_df)\n", - " normed_ion_profile = lfqnorm.normalize_ion_profiles(protein_df)\n", - " display(normed_ion_profile)\n", - " column_from_shifted = normed_ion_profile.iloc[:,11].dropna().to_numpy()\n", - " display(column_from_shifted)\n", - " assert np.allclose(column_from_shifted, column_from_shifted[0])\n", - " " + "test_cutting_of_df()\n" ] }, { @@ -745,32 +187,32 @@ " 44.447364\n", " 44.554027\n", " 44.692343\n", - " NaN\n", + " 44.701690\n", " 43.106703\n", " 44.630975\n", " 43.380650\n", - " 43.407413\n", + " NaN\n", " \n", " \n", " 1\n", " NaN\n", " NaN\n", - " 31.523301\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 33.659723\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", + " 34.481579\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", + " 34.665191\n", " NaN\n", " NaN\n", " \n", @@ -781,15 +223,15 @@ " 26.616410\n", " 28.343632\n", " 28.633033\n", - " 27.465729\n", " NaN\n", + " 28.581537\n", " 28.229946\n", - " NaN\n", + " 27.024859\n", " 28.752833\n", " 28.388665\n", " 25.330674\n", " 29.574689\n", - " 29.681352\n", + " NaN\n", " 29.819668\n", " 29.829015\n", " 28.234029\n", @@ -803,6 +245,7 @@ " NaN\n", " NaN\n", " NaN\n", + " 38.598817\n", " NaN\n", " NaN\n", " NaN\n", @@ -810,14 +253,13 @@ " NaN\n", " NaN\n", " NaN\n", + " 39.540473\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 39.794799\n", " NaN\n", " NaN\n", - " 38.473759\n", " NaN\n", " \n", " \n", @@ -828,30 +270,30 @@ " 0 1 2 3 4 5 \\\n", "protein ion \n", "protA 0 NaN 44.474241 41.489085 43.216307 43.505708 42.338404 \n", - " 1 NaN NaN 31.523301 NaN NaN NaN \n", - " 2 29.73029 29.601566 26.616410 28.343632 28.633033 27.465729 \n", - " 3 NaN NaN NaN NaN NaN NaN \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 29.73029 29.601566 26.616410 28.343632 28.633033 NaN \n", + " 3 NaN NaN NaN NaN 38.598817 NaN \n", "\n", " 6 7 8 9 10 11 \\\n", "protein ion \n", "protA 0 43.454211 43.102621 41.897534 43.625508 43.261340 40.203349 \n", - " 1 NaN NaN NaN 33.659723 NaN NaN \n", - " 2 NaN 28.229946 NaN 28.752833 28.388665 25.330674 \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 28.581537 28.229946 27.024859 28.752833 28.388665 25.330674 \n", " 3 NaN NaN NaN NaN NaN NaN \n", "\n", " 12 13 14 15 16 17 \\\n", "protein ion \n", - "protA 0 44.447364 44.554027 44.692343 NaN 43.106703 44.630975 \n", - " 1 NaN NaN NaN NaN NaN NaN \n", - " 2 29.574689 29.681352 29.819668 29.829015 28.234029 29.758301 \n", - " 3 NaN NaN NaN 39.794799 NaN NaN \n", + "protA 0 44.447364 44.554027 44.692343 44.701690 43.106703 44.630975 \n", + " 1 34.481579 NaN NaN NaN NaN 34.665191 \n", + " 2 29.574689 NaN 29.819668 29.829015 28.234029 29.758301 \n", + " 3 39.540473 NaN NaN NaN NaN NaN \n", "\n", " 18 19 \n", "protein ion \n", - "protA 0 43.380650 43.407413 \n", + "protA 0 43.380650 NaN \n", " 1 NaN NaN \n", " 2 28.507975 28.534739 \n", - " 3 38.473759 NaN " + " 3 NaN NaN " ] }, "metadata": {}, @@ -944,32 +386,32 @@ " 44.447364\n", " 44.554027\n", " 44.692343\n", - " NaN\n", + " 44.70169\n", " 43.106703\n", " 44.630975\n", " 43.38065\n", - " 43.407413\n", + " NaN\n", " \n", " \n", " 1\n", " NaN\n", " NaN\n", - " 41.489085\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 43.625508\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", + " 44.447364\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", + " 44.630975\n", " NaN\n", " NaN\n", " \n", @@ -980,15 +422,15 @@ " 41.489085\n", " 43.216307\n", " 43.505708\n", - " 42.338404\n", " NaN\n", + " 43.454211\n", " 43.102621\n", - " NaN\n", + " 41.897534\n", " 43.625508\n", " 43.26134\n", " 40.203349\n", " 44.447364\n", - " 44.554027\n", + " NaN\n", " 44.692343\n", " 44.70169\n", " 43.106703\n", @@ -1002,6 +444,7 @@ " NaN\n", " NaN\n", " NaN\n", + " 43.505708\n", " NaN\n", " NaN\n", " NaN\n", @@ -1009,14 +452,13 @@ " NaN\n", " NaN\n", " NaN\n", + " 44.447364\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 44.70169\n", " NaN\n", " NaN\n", - " 43.38065\n", " NaN\n", " \n", " \n", @@ -1027,30 +469,30 @@ " 0 1 2 3 4 5 \\\n", "protein ion \n", "protA 0 NaN 44.474241 41.489085 43.216307 43.505708 42.338404 \n", - " 1 NaN NaN 41.489085 NaN NaN NaN \n", - " 2 44.602965 44.474241 41.489085 43.216307 43.505708 42.338404 \n", - " 3 NaN NaN NaN NaN NaN NaN \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 44.602965 44.474241 41.489085 43.216307 43.505708 NaN \n", + " 3 NaN NaN NaN NaN 43.505708 NaN \n", "\n", " 6 7 8 9 10 11 \\\n", "protein ion \n", "protA 0 43.454211 43.102621 41.897534 43.625508 43.26134 40.203349 \n", - " 1 NaN NaN NaN 43.625508 NaN NaN \n", - " 2 NaN 43.102621 NaN 43.625508 43.26134 40.203349 \n", + " 1 NaN NaN NaN NaN NaN NaN \n", + " 2 43.454211 43.102621 41.897534 43.625508 43.26134 40.203349 \n", " 3 NaN NaN NaN NaN NaN NaN \n", "\n", " 12 13 14 15 16 17 \\\n", "protein ion \n", - "protA 0 44.447364 44.554027 44.692343 NaN 43.106703 44.630975 \n", - " 1 NaN NaN NaN NaN NaN NaN \n", - " 2 44.447364 44.554027 44.692343 44.70169 43.106703 44.630975 \n", - " 3 NaN NaN NaN 44.70169 NaN NaN \n", + "protA 0 44.447364 44.554027 44.692343 44.70169 43.106703 44.630975 \n", + " 1 44.447364 NaN NaN NaN NaN 44.630975 \n", + " 2 44.447364 NaN 44.692343 44.70169 43.106703 44.630975 \n", + " 3 44.447364 NaN NaN NaN NaN NaN \n", "\n", " 18 19 \n", "protein ion \n", - "protA 0 43.38065 43.407413 \n", + "protA 0 43.38065 NaN \n", " 1 NaN NaN \n", " 2 43.38065 43.407413 \n", - " 3 43.38065 NaN " + " 3 NaN NaN " ] }, "metadata": {}, @@ -1064,41 +506,7 @@ }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - " \n", - "test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def test_that_profiles_with_noise_are_close():\n", - " peptide1= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=3000, add_noise=True)\n", - " peptide2= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", - " peptide3= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", - " peptide4= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - "\n", - " protein_df = ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", - " display(protein_df)\n", - " \n", - " normed_ion_profile = lfqnorm.normalize_ion_profiles(protein_df)\n", - " display(normed_ion_profile)\n", - " column_from_shifted = normed_ion_profile.iloc[:,9].dropna().to_numpy()\n", - "\n", - " assert np.allclose(column_from_shifted, column_from_shifted[0],rtol=0.01, atol=0.01)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ + }, { "data": { "text/html": [ @@ -1172,93 +580,93 @@ " protA\n", " 0\n", " 44.602965\n", - " 44.474241\n", - " 41.489084\n", + " 44.474240\n", + " 41.489085\n", " 43.216306\n", " 43.505708\n", " 42.338405\n", - " 43.454212\n", + " 43.454211\n", " 43.102621\n", - " 41.897534\n", - " 43.625507\n", - " 43.261339\n", - " 40.203349\n", + " 41.897533\n", + " 43.625508\n", + " 43.261340\n", + " 40.203346\n", " 44.447364\n", " 44.554027\n", " 44.692343\n", " 44.701690\n", " 43.106703\n", - " 44.630975\n", + " 44.630976\n", " 43.380650\n", " 43.407413\n", " \n", " \n", " 1\n", - " 34.637164\n", - " 34.508471\n", - " 31.523309\n", - " 33.250541\n", - " 33.539932\n", - " 32.372641\n", - " 33.488428\n", - " 33.136851\n", - " 31.931758\n", - " 33.659730\n", - " 33.295568\n", - " 30.237636\n", - " 34.481571\n", - " 34.588258\n", - " 34.726550\n", - " 34.735909\n", - " 33.140916\n", - " 34.665196\n", - " 33.414890\n", - " 33.441640\n", + " 34.637191\n", + " 34.508449\n", + " 31.523327\n", + " 33.250533\n", + " 33.539906\n", + " 32.372622\n", + " 33.488420\n", + " 33.136837\n", + " 31.931740\n", + " 33.659734\n", + " 33.295572\n", + " 30.237537\n", + " 34.481578\n", + " 34.588245\n", + " 34.726571\n", + " 34.735917\n", + " 33.140931\n", + " 34.665203\n", + " 33.414868\n", + " 33.441634\n", " \n", " \n", " 2\n", - " 29.730298\n", - " 29.601666\n", - " 26.616563\n", - " 28.343701\n", - " 28.633109\n", - " 27.465632\n", - " 28.581503\n", - " 28.229946\n", - " 27.024903\n", - " 28.752767\n", - " 28.388581\n", - " 25.330811\n", - " 29.574709\n", - " 29.681298\n", - " 29.819694\n", - " 29.829052\n", - " 28.234126\n", - " 29.758298\n", - " 28.507966\n", - " 28.534798\n", + " 29.730299\n", + " 29.601596\n", + " 26.616364\n", + " 28.343634\n", + " 28.633164\n", + " 27.465805\n", + " 28.581529\n", + " 28.229941\n", + " 27.024871\n", + " 28.752936\n", + " 28.388685\n", + " 25.330857\n", + " 29.574649\n", + " 29.681455\n", + " 29.819767\n", + " 29.828994\n", + " 28.234112\n", + " 29.758290\n", + " 28.508008\n", + " 28.534752\n", " \n", " \n", " 3\n", " 39.696074\n", " 39.567350\n", - " 36.582190\n", - " 38.309413\n", - " 38.598815\n", - " 37.431515\n", + " 36.582194\n", + " 38.309420\n", + " 38.598821\n", + " 37.431511\n", " 38.547322\n", - " 38.195731\n", - " 36.990643\n", - " 38.718618\n", - " 38.354448\n", - " 35.296460\n", - " 39.540470\n", - " 39.647135\n", - " 39.785452\n", + " 38.195732\n", + " 36.990644\n", + " 38.718614\n", + " 38.354449\n", + " 35.296454\n", + " 39.540472\n", + " 39.647136\n", + " 39.785450\n", " 39.794799\n", - " 38.199812\n", - " 39.724086\n", - " 38.473757\n", + " 38.199810\n", + " 39.724082\n", + " 38.473762\n", " 38.500524\n", " \n", " \n", @@ -1268,31 +676,31 @@ "text/plain": [ " 0 1 2 3 4 5 \\\n", "protein ion \n", - "protA 0 44.602965 44.474241 41.489084 43.216306 43.505708 42.338405 \n", - " 1 34.637164 34.508471 31.523309 33.250541 33.539932 32.372641 \n", - " 2 29.730298 29.601666 26.616563 28.343701 28.633109 27.465632 \n", - " 3 39.696074 39.567350 36.582190 38.309413 38.598815 37.431515 \n", + "protA 0 44.602965 44.474240 41.489085 43.216306 43.505708 42.338405 \n", + " 1 34.637191 34.508449 31.523327 33.250533 33.539906 32.372622 \n", + " 2 29.730299 29.601596 26.616364 28.343634 28.633164 27.465805 \n", + " 3 39.696074 39.567350 36.582194 38.309420 38.598821 37.431511 \n", "\n", " 6 7 8 9 10 11 \\\n", "protein ion \n", - "protA 0 43.454212 43.102621 41.897534 43.625507 43.261339 40.203349 \n", - " 1 33.488428 33.136851 31.931758 33.659730 33.295568 30.237636 \n", - " 2 28.581503 28.229946 27.024903 28.752767 28.388581 25.330811 \n", - " 3 38.547322 38.195731 36.990643 38.718618 38.354448 35.296460 \n", + "protA 0 43.454211 43.102621 41.897533 43.625508 43.261340 40.203346 \n", + " 1 33.488420 33.136837 31.931740 33.659734 33.295572 30.237537 \n", + " 2 28.581529 28.229941 27.024871 28.752936 28.388685 25.330857 \n", + " 3 38.547322 38.195732 36.990644 38.718614 38.354449 35.296454 \n", "\n", " 12 13 14 15 16 17 \\\n", "protein ion \n", - "protA 0 44.447364 44.554027 44.692343 44.701690 43.106703 44.630975 \n", - " 1 34.481571 34.588258 34.726550 34.735909 33.140916 34.665196 \n", - " 2 29.574709 29.681298 29.819694 29.829052 28.234126 29.758298 \n", - " 3 39.540470 39.647135 39.785452 39.794799 38.199812 39.724086 \n", + "protA 0 44.447364 44.554027 44.692343 44.701690 43.106703 44.630976 \n", + " 1 34.481578 34.588245 34.726571 34.735917 33.140931 34.665203 \n", + " 2 29.574649 29.681455 29.819767 29.828994 28.234112 29.758290 \n", + " 3 39.540472 39.647136 39.785450 39.794799 38.199810 39.724082 \n", "\n", " 18 19 \n", "protein ion \n", "protA 0 43.380650 43.407413 \n", - " 1 33.414890 33.441640 \n", - " 2 28.507966 28.534798 \n", - " 3 38.473757 38.500524 " + " 1 33.414868 33.441634 \n", + " 2 28.508008 28.534752 \n", + " 3 38.473762 38.500524 " ] }, "metadata": {}, @@ -1371,94 +779,94 @@ " protA\n", " 0\n", " 44.602965\n", - " 44.474241\n", - " 41.489084\n", + " 44.474240\n", + " 41.489085\n", " 43.216306\n", " 43.505708\n", " 42.338405\n", - " 43.454212\n", + " 43.454211\n", " 43.102621\n", - " 41.897534\n", - " 43.625507\n", - " 43.261339\n", - " 40.203349\n", + " 41.897533\n", + " 43.625508\n", + " 43.261340\n", + " 40.203346\n", " 44.447364\n", " 44.554027\n", " 44.692343\n", " 44.701690\n", " 43.106703\n", - " 44.630975\n", + " 44.630976\n", " 43.380650\n", " 43.407413\n", " \n", " \n", " 1\n", - " 44.602938\n", - " 44.474245\n", - " 41.489083\n", - " 43.216316\n", - " 43.505706\n", - " 42.338415\n", - " 43.454202\n", - " 43.102625\n", - " 41.897532\n", - " 43.625504\n", - " 43.261342\n", - " 40.203410\n", - " 44.447345\n", - " 44.554032\n", - " 44.692324\n", - " 44.701683\n", - " 43.106690\n", - " 44.630970\n", - " 43.380664\n", + " 44.602971\n", + " 44.474230\n", + " 41.489107\n", + " 43.216313\n", + " 43.505686\n", + " 42.338402\n", + " 43.454200\n", + " 43.102617\n", + " 41.897521\n", + " 43.625514\n", + " 43.261352\n", + " 40.203317\n", + " 44.447358\n", + " 44.554025\n", + " 44.692351\n", + " 44.701697\n", + " 43.106711\n", + " 44.630983\n", + " 43.380648\n", " 43.407414\n", " \n", " \n", " 2\n", - " 44.602943\n", - " 44.474311\n", - " 41.489208\n", - " 43.216346\n", - " 43.505754\n", - " 42.338277\n", - " 43.454148\n", - " 43.102591\n", - " 41.897548\n", - " 43.625412\n", - " 43.261226\n", - " 40.203456\n", - " 44.447354\n", - " 44.553943\n", - " 44.692339\n", - " 44.701697\n", + " 44.602957\n", + " 44.474255\n", + " 41.489023\n", + " 43.216293\n", + " 43.505823\n", + " 42.338464\n", + " 43.454188\n", + " 43.102600\n", + " 41.897529\n", + " 43.625595\n", + " 43.261344\n", + " 40.203515\n", + " 44.447308\n", + " 44.554114\n", + " 44.692426\n", + " 44.701652\n", " 43.106771\n", - " 44.630943\n", - " 43.380611\n", - " 43.407443\n", + " 44.630949\n", + " 43.380667\n", + " 43.407411\n", " \n", " \n", " 3\n", - " 44.602964\n", - " 44.474241\n", - " 41.489081\n", - " 43.216304\n", - " 43.505705\n", - " 42.338406\n", - " 43.454212\n", - " 43.102622\n", - " 41.897534\n", - " 43.625509\n", - " 43.261339\n", - " 40.203351\n", - " 44.447361\n", - " 44.554026\n", - " 44.692343\n", + " 44.602965\n", + " 44.474240\n", + " 41.489085\n", + " 43.216310\n", + " 43.505712\n", + " 42.338402\n", + " 43.454213\n", + " 43.102623\n", + " 41.897535\n", + " 43.625505\n", + " 43.261340\n", + " 40.203344\n", + " 44.447363\n", + " 44.554027\n", + " 44.692341\n", " 44.701690\n", - " 43.106703\n", - " 44.630977\n", - " 43.380647\n", - " 43.407415\n", + " 43.106701\n", + " 44.630973\n", + " 43.380653\n", + " 43.407414\n", " \n", " \n", "\n", @@ -1467,31 +875,31 @@ "text/plain": [ " 0 1 2 3 4 5 \\\n", "protein ion \n", - "protA 0 44.602965 44.474241 41.489084 43.216306 43.505708 42.338405 \n", - " 1 44.602938 44.474245 41.489083 43.216316 43.505706 42.338415 \n", - " 2 44.602943 44.474311 41.489208 43.216346 43.505754 42.338277 \n", - " 3 44.602964 44.474241 41.489081 43.216304 43.505705 42.338406 \n", + "protA 0 44.602965 44.474240 41.489085 43.216306 43.505708 42.338405 \n", + " 1 44.602971 44.474230 41.489107 43.216313 43.505686 42.338402 \n", + " 2 44.602957 44.474255 41.489023 43.216293 43.505823 42.338464 \n", + " 3 44.602965 44.474240 41.489085 43.216310 43.505712 42.338402 \n", "\n", " 6 7 8 9 10 11 \\\n", "protein ion \n", - "protA 0 43.454212 43.102621 41.897534 43.625507 43.261339 40.203349 \n", - " 1 43.454202 43.102625 41.897532 43.625504 43.261342 40.203410 \n", - " 2 43.454148 43.102591 41.897548 43.625412 43.261226 40.203456 \n", - " 3 43.454212 43.102622 41.897534 43.625509 43.261339 40.203351 \n", + "protA 0 43.454211 43.102621 41.897533 43.625508 43.261340 40.203346 \n", + " 1 43.454200 43.102617 41.897521 43.625514 43.261352 40.203317 \n", + " 2 43.454188 43.102600 41.897529 43.625595 43.261344 40.203515 \n", + " 3 43.454213 43.102623 41.897535 43.625505 43.261340 40.203344 \n", "\n", " 12 13 14 15 16 17 \\\n", "protein ion \n", - "protA 0 44.447364 44.554027 44.692343 44.701690 43.106703 44.630975 \n", - " 1 44.447345 44.554032 44.692324 44.701683 43.106690 44.630970 \n", - " 2 44.447354 44.553943 44.692339 44.701697 43.106771 44.630943 \n", - " 3 44.447361 44.554026 44.692343 44.701690 43.106703 44.630977 \n", + "protA 0 44.447364 44.554027 44.692343 44.701690 43.106703 44.630976 \n", + " 1 44.447358 44.554025 44.692351 44.701697 43.106711 44.630983 \n", + " 2 44.447308 44.554114 44.692426 44.701652 43.106771 44.630949 \n", + " 3 44.447363 44.554027 44.692341 44.701690 43.106701 44.630973 \n", "\n", " 18 19 \n", "protein ion \n", "protA 0 43.380650 43.407413 \n", - " 1 43.380664 43.407414 \n", - " 2 43.380611 43.407443 \n", - " 3 43.380647 43.407415 " + " 1 43.380648 43.407414 \n", + " 2 43.380667 43.407411 \n", + " 3 43.380653 43.407414 " ] }, "metadata": {}, @@ -1499,34 +907,39 @@ } ], "source": [ + "import directlfq.normalization as lfq_norm\n", + "import directlfq.test_utils as lfq_testutils\n", "\n", - "test_that_profiles_with_noise_are_close()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import directlfq.protein_intensity_estimation as intensity_estimation\n", + "def test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other():\n", + " peptide1= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=False)\n", + " peptide2= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=3, add_noise=False)\n", + " peptide3= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=0.1, add_noise=False)\n", + " peptide4= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0.9, systematic_peptide_shift=100, add_noise=False)\n", + " protein_df = lfq_testutils.ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", + " display(protein_df)\n", + " normed_ion_profile = lfq_norm.normalize_ion_profiles(protein_df)\n", + " display(normed_ion_profile)\n", + " column_from_shifted = normed_ion_profile.iloc[:,11].dropna().to_numpy()\n", + " display(column_from_shifted)\n", + " assert np.allclose(column_from_shifted, column_from_shifted[0])\n", "\n", - "def test_that_protein_intensities_are_retained():\n", - " peptide1= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=True)\n", - " peptide2= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", - " peptide3= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", - " peptide4= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - " \n", - " peptide_profiles = [peptide1, peptide2, peptide3, peptide4]\n", - " summed_intensity_protein = sum([np.nansum(x.peptide_profile_vector) for x in peptide_profiles])\n", + "def test_that_profiles_with_noise_are_close():\n", + " peptide1= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=3000, add_noise=True)\n", + " peptide2= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", + " peptide3= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", + " peptide4= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + "\n", + " protein_df = lfq_testutils.ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", + " display(protein_df)\n", " \n", - " protein_df = ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", - " protein_df_normed, _ = intensity_estimation.estimate_protein_intensities(protein_df, min_nonan=1, num_samples_quadratic=100, num_cores=1)\n", - " display(protein_df_normed)\n", - " display(protein_df_normed.iloc[0,1:].to_numpy())\n", - " summed_lfq_intensities = np.sum(protein_df_normed.iloc[0,1:].to_numpy())\n", - " assert np.allclose(summed_lfq_intensities, summed_intensity_protein)\n", - "\n" + " normed_ion_profile = lfq_norm.normalize_ion_profiles(protein_df)\n", + " display(normed_ion_profile)\n", + " column_from_shifted = normed_ion_profile.iloc[:,9].dropna().to_numpy()\n", + "\n", + " assert np.allclose(column_from_shifted, column_from_shifted[0],rtol=0.01, atol=0.01)\n", + "\n", + "test_that_profiles_without_noise_are_shifted_exactly_on_top_of_each_other()\n", + "test_that_profiles_with_noise_are_close()\n" ] }, { @@ -1535,11 +948,11 @@ "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "1 prots total\n", - "prot 0\n" + "2023-12-08 12:22:20,257 - directlfq.protein_intensity_estimation - INFO - 1 prots total\n", + "2023-12-08 12:22:20,258 - directlfq.protein_intensity_estimation - INFO - prot 0\n" ] }, { @@ -1590,26 +1003,26 @@ " \n", " 0\n", " protA\n", - " 2.568548e+13\n", - " 2.349299e+13\n", - " 2.966971e+12\n", - " 9.823451e+12\n", - " 1.200551e+13\n", - " 5.345491e+12\n", - " 1.158453e+13\n", - " 9.079027e+12\n", - " 3.937967e+12\n", + " 2.534980e+13\n", + " 2.318589e+13\n", + " 2.928181e+12\n", + " 9.695020e+12\n", + " 1.184861e+13\n", + " 5.275621e+12\n", + " 1.143313e+13\n", + " 8.960380e+12\n", + " 3.886496e+12\n", " ...\n", - " 1.013486e+13\n", - " 1.216952e+12\n", - " 2.305938e+13\n", - " 2.482878e+13\n", - " 2.732712e+13\n", - " 2.750475e+13\n", - " 9.104758e+12\n", - " 2.618913e+13\n", - " 1.100868e+13\n", - " 1.121479e+13\n", + " 1.000241e+13\n", + " 1.201040e+12\n", + " 2.275799e+13\n", + " 2.450432e+13\n", + " 2.696994e+13\n", + " 2.714526e+13\n", + " 8.985770e+12\n", + " 2.584682e+13\n", + " 1.086479e+13\n", + " 1.106823e+13\n", " \n", " \n", "\n", @@ -1618,16 +1031,16 @@ ], "text/plain": [ " protein 0 1 2 3 \\\n", - "0 protA 2.568548e+13 2.349299e+13 2.966971e+12 9.823451e+12 \n", + "0 protA 2.534980e+13 2.318589e+13 2.928181e+12 9.695020e+12 \n", "\n", " 4 5 6 7 8 ... \\\n", - "0 1.200551e+13 5.345491e+12 1.158453e+13 9.079027e+12 3.937967e+12 ... \n", + "0 1.184861e+13 5.275621e+12 1.143313e+13 8.960380e+12 3.886496e+12 ... \n", "\n", " 10 11 12 13 14 \\\n", - "0 1.013486e+13 1.216952e+12 2.305938e+13 2.482878e+13 2.732712e+13 \n", + "0 1.000241e+13 1.201040e+12 2.275799e+13 2.450432e+13 2.696994e+13 \n", "\n", " 15 16 17 18 19 \n", - "0 2.750475e+13 9.104758e+12 2.618913e+13 1.100868e+13 1.121479e+13 \n", + "0 2.714526e+13 8.985770e+12 2.584682e+13 1.086479e+13 1.106823e+13 \n", "\n", "[1 rows x 21 columns]" ] @@ -1638,47 +1051,41 @@ { "data": { "text/plain": [ - "array([25685480068798.477, 23492985729224.617, 2966971322442.3076,\n", - " 9823451227982.002, 12005507094436.135, 5345491410602.842,\n", - " 11584530276439.023, 9079026570610.525, 3937966565364.505,\n", - " 13045002854709.543, 10134862066156.398, 1216952380115.5583,\n", - " 23059382371708.06, 24828783469561.055, 27327116905724.043,\n", - " 27504745639008.09, 9104757652175.703, 26189128807181.58,\n", - " 11008676725692.262, 11214793770630.262], dtype=object)" + "array([25349795642833.24, 23185890220888.97, 2928180586448.17,\n", + " 9695020357645.807, 11848609977072.47, 5275621107950.519,\n", + " 11433132923005.893, 8960379724734.42, 3886495984197.8735,\n", + " 12874540472742.57, 10002405236736.053, 1201039877802.1846,\n", + " 22757993614330.746, 24504324707272.664, 26969944908322.53,\n", + " 27145258441058.31, 8985769914714.105, 25846821137849.547,\n", + " 10864793434866.52, 11068226808633.043], dtype=object)" ] }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "\n", - "test_that_protein_intensities_are_retained()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], "source": [ "import directlfq.protein_intensity_estimation as intensity_estimation\n", + "import directlfq.test_utils as lfq_testutils\n", "\n", - "def run_with_multiple_proteins():\n", - " peptide1= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=True)\n", - " peptide2= PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", - " peptide3= PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", - " peptide4= PeptideProfile(protein_name=\"protB\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - " peptide5= PeptideProfile(protein_name=\"protC\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - " peptide6= PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - " peptide7= PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - " peptide8= PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", - "\n", - " peptide_profiles = [peptide1, peptide2, peptide3, peptide4, peptide5, peptide6, peptide7, peptide8]\n", - " protein_df = ProteinProfileGenerator(peptide_profiles).protein_profile_dataframe\n", + "def test_that_protein_intensities_are_retained():\n", + " peptide1= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=True)\n", + " peptide2= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", + " peptide3= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", + " peptide4= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + " \n", + " peptide_profiles = [peptide1, peptide2, peptide3, peptide4]\n", + " summed_intensity_protein = sum([np.nansum(x.peptide_profile_vector) for x in peptide_profiles])\n", + " \n", + " protein_df = lfq_testutils.ProteinProfileGenerator([peptide1, peptide2, peptide3, peptide4]).protein_profile_dataframe\n", " protein_df_normed, _ = intensity_estimation.estimate_protein_intensities(protein_df, min_nonan=1, num_samples_quadratic=100, num_cores=1)\n", " display(protein_df_normed)\n", - " \n" + " display(protein_df_normed.iloc[0,1:].to_numpy())\n", + " summed_lfq_intensities = np.sum(protein_df_normed.iloc[0,1:].to_numpy())\n", + " assert np.allclose(summed_lfq_intensities, summed_intensity_protein)\n", + "\n", + "test_that_protein_intensities_are_retained()\n", + "\n" ] }, { @@ -1687,11 +1094,11 @@ "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "4 prots total\n", - "prot 0\n" + "2023-12-08 12:26:12,022 - directlfq.protein_intensity_estimation - INFO - 4 prots total\n", + "2023-12-08 12:26:12,024 - directlfq.protein_intensity_estimation - INFO - prot 0\n" ] }, { @@ -1742,98 +1149,98 @@ " \n", " 0\n", " protA\n", - " 2.299237e+13\n", - " 2.102973e+13\n", - " 2.655975e+12\n", - " 8.793380e+12\n", - " 1.074681e+13\n", - " 4.785012e+12\n", - " 1.036990e+13\n", - " 8.127093e+12\n", - " 3.525069e+12\n", + " 2.531384e+13\n", + " 2.315286e+13\n", + " 2.924049e+12\n", + " 9.681216e+12\n", + " 1.183173e+13\n", + " 5.268128e+12\n", + " 1.141686e+13\n", + " 8.947613e+12\n", + " 3.880908e+12\n", " ...\n", - " 9.072232e+12\n", - " 1.089350e+12\n", - " 2.064159e+13\n", - " 2.222575e+13\n", - " 2.446185e+13\n", - " 2.462119e+13\n", - " 8.150122e+12\n", - " 2.344313e+13\n", - " 9.854382e+12\n", - " 1.003883e+13\n", + " 9.988645e+12\n", + " 1.199318e+12\n", + " 2.272559e+13\n", + " 2.446956e+13\n", + " 2.693163e+13\n", + " 2.710675e+13\n", + " 8.972944e+12\n", + " 2.580999e+13\n", + " 1.084931e+13\n", + " 1.105253e+13\n", " \n", " \n", " 1\n", " protB\n", - " 8.906533e+11\n", - " 8.146275e+11\n", - " 1.028818e+11\n", - " 3.406307e+11\n", - " 4.162963e+11\n", - " 1.853571e+11\n", - " 4.016969e+11\n", - " 3.148185e+11\n", - " 1.365500e+11\n", + " 8.906532e+11\n", + " 8.146271e+11\n", + " 1.028814e+11\n", + " 3.406308e+11\n", + " 4.162962e+11\n", + " 1.853563e+11\n", + " 4.016973e+11\n", + " 3.148190e+11\n", + " 1.365508e+11\n", " ...\n", - " 3.514309e+11\n", - " 4.219825e+10\n", - " 7.995909e+11\n", - " 8.609494e+11\n", - " 9.475780e+11\n", - " 9.537354e+11\n", - " 3.157110e+11\n", - " 9.081153e+11\n", - " 3.817300e+11\n", - " 3.888772e+11\n", + " 3.514311e+11\n", + " 4.219781e+10\n", + " 7.995918e+11\n", + " 8.609472e+11\n", + " 9.475768e+11\n", + " 9.537363e+11\n", + " 3.157105e+11\n", + " 9.081169e+11\n", + " 3.817282e+11\n", + " 3.888771e+11\n", " \n", " \n", " 2\n", " protC\n", - " 8.906535e+11\n", - " 8.146261e+11\n", - " 1.028818e+11\n", - " 3.406302e+11\n", - " 4.162950e+11\n", - " 1.853564e+11\n", - " 4.016981e+11\n", - " 3.148191e+11\n", - " 1.365503e+11\n", + " 8.906544e+11\n", + " 8.146285e+11\n", + " 1.028819e+11\n", + " 3.406296e+11\n", + " 4.162955e+11\n", + " 1.853560e+11\n", + " 4.016979e+11\n", + " 3.148195e+11\n", + " 1.365506e+11\n", " ...\n", - " 3.514299e+11\n", - " 4.219825e+10\n", - " 7.995918e+11\n", - " 8.609489e+11\n", - " 9.475760e+11\n", - " 9.537371e+11\n", - " 3.157106e+11\n", - " 9.081160e+11\n", - " 3.817307e+11\n", - " 3.888767e+11\n", + " 3.514307e+11\n", + " 4.219777e+10\n", + " 7.995936e+11\n", + " 8.609486e+11\n", + " 9.475759e+11\n", + " 9.537344e+11\n", + " 3.157112e+11\n", + " 9.081153e+11\n", + " 3.817297e+11\n", + " 3.888760e+11\n", " \n", " \n", " 3\n", " protD\n", - " 2.671958e+12\n", + " 2.671963e+12\n", " 2.443884e+12\n", - " 3.086449e+11\n", - " 1.021891e+12\n", - " 1.248887e+12\n", - " 5.560702e+11\n", + " 3.086451e+11\n", + " 1.021892e+12\n", + " 1.248886e+12\n", + " 5.560711e+11\n", " 1.205096e+12\n", - " 9.444565e+11\n", - " 4.096535e+11\n", + " 9.444586e+11\n", + " 4.096517e+11\n", " ...\n", " 1.054292e+12\n", - " 1.265942e+11\n", - " 2.398780e+12\n", - " 2.582853e+12\n", - " 2.842733e+12\n", - " 2.861210e+12\n", - " 9.471313e+11\n", - " 2.724346e+12\n", - " 1.145187e+12\n", - " 1.166633e+12\n", + " 1.265943e+11\n", + " 2.398774e+12\n", + " 2.582846e+12\n", + " 2.842730e+12\n", + " 2.861209e+12\n", + " 9.471320e+11\n", + " 2.724343e+12\n", + " 1.145188e+12\n", + " 1.166632e+12\n", " \n", " \n", "\n", @@ -1842,28 +1249,28 @@ ], "text/plain": [ " protein 0 1 2 3 \\\n", - "0 protA 2.299237e+13 2.102973e+13 2.655975e+12 8.793380e+12 \n", - "1 protB 8.906533e+11 8.146275e+11 1.028818e+11 3.406307e+11 \n", - "2 protC 8.906535e+11 8.146261e+11 1.028818e+11 3.406302e+11 \n", - "3 protD 2.671958e+12 2.443884e+12 3.086449e+11 1.021891e+12 \n", + "0 protA 2.531384e+13 2.315286e+13 2.924049e+12 9.681216e+12 \n", + "1 protB 8.906532e+11 8.146271e+11 1.028814e+11 3.406308e+11 \n", + "2 protC 8.906544e+11 8.146285e+11 1.028819e+11 3.406296e+11 \n", + "3 protD 2.671963e+12 2.443884e+12 3.086451e+11 1.021892e+12 \n", "\n", " 4 5 6 7 8 ... \\\n", - "0 1.074681e+13 4.785012e+12 1.036990e+13 8.127093e+12 3.525069e+12 ... \n", - "1 4.162963e+11 1.853571e+11 4.016969e+11 3.148185e+11 1.365500e+11 ... \n", - "2 4.162950e+11 1.853564e+11 4.016981e+11 3.148191e+11 1.365503e+11 ... \n", - "3 1.248887e+12 5.560702e+11 1.205096e+12 9.444565e+11 4.096535e+11 ... \n", + "0 1.183173e+13 5.268128e+12 1.141686e+13 8.947613e+12 3.880908e+12 ... \n", + "1 4.162962e+11 1.853563e+11 4.016973e+11 3.148190e+11 1.365508e+11 ... \n", + "2 4.162955e+11 1.853560e+11 4.016979e+11 3.148195e+11 1.365506e+11 ... \n", + "3 1.248886e+12 5.560711e+11 1.205096e+12 9.444586e+11 4.096517e+11 ... \n", "\n", " 10 11 12 13 14 \\\n", - "0 9.072232e+12 1.089350e+12 2.064159e+13 2.222575e+13 2.446185e+13 \n", - "1 3.514309e+11 4.219825e+10 7.995909e+11 8.609494e+11 9.475780e+11 \n", - "2 3.514299e+11 4.219825e+10 7.995918e+11 8.609489e+11 9.475760e+11 \n", - "3 1.054292e+12 1.265942e+11 2.398780e+12 2.582853e+12 2.842733e+12 \n", + "0 9.988645e+12 1.199318e+12 2.272559e+13 2.446956e+13 2.693163e+13 \n", + "1 3.514311e+11 4.219781e+10 7.995918e+11 8.609472e+11 9.475768e+11 \n", + "2 3.514307e+11 4.219777e+10 7.995936e+11 8.609486e+11 9.475759e+11 \n", + "3 1.054292e+12 1.265943e+11 2.398774e+12 2.582846e+12 2.842730e+12 \n", "\n", " 15 16 17 18 19 \n", - "0 2.462119e+13 8.150122e+12 2.344313e+13 9.854382e+12 1.003883e+13 \n", - "1 9.537354e+11 3.157110e+11 9.081153e+11 3.817300e+11 3.888772e+11 \n", - "2 9.537371e+11 3.157106e+11 9.081160e+11 3.817307e+11 3.888767e+11 \n", - "3 2.861210e+12 9.471313e+11 2.724346e+12 1.145187e+12 1.166633e+12 \n", + "0 2.710675e+13 8.972944e+12 2.580999e+13 1.084931e+13 1.105253e+13 \n", + "1 9.537363e+11 3.157105e+11 9.081169e+11 3.817282e+11 3.888771e+11 \n", + "2 9.537344e+11 3.157112e+11 9.081153e+11 3.817297e+11 3.888760e+11 \n", + "3 2.861209e+12 9.471320e+11 2.724343e+12 1.145188e+12 1.166632e+12 \n", "\n", "[4 rows x 21 columns]" ] @@ -1873,7 +1280,27 @@ } ], "source": [ - "run_with_multiple_proteins()" + "import directlfq.protein_intensity_estimation as intensity_estimation\n", + "import directlfq.test_utils as lfq_testutils\n", + "\n", + "def run_with_multiple_proteins():\n", + " peptide1= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0.1, systematic_peptide_shift=3000, add_noise=True)\n", + " peptide2= lfq_testutils.PeptideProfile(protein_name=\"protA\",fraction_zeros_in_profile=0, systematic_peptide_shift=3, add_noise=True)\n", + " peptide3= lfq_testutils.PeptideProfile(protein_name=\"protA\", fraction_zeros_in_profile=0, systematic_peptide_shift=0.1, add_noise=True)\n", + " peptide4= lfq_testutils.PeptideProfile(protein_name=\"protB\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + " peptide5= lfq_testutils.PeptideProfile(protein_name=\"protC\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + " peptide6= lfq_testutils.PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + " peptide7= lfq_testutils.PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + " peptide8= lfq_testutils.PeptideProfile(protein_name=\"protD\",fraction_zeros_in_profile=0, systematic_peptide_shift=100, add_noise=True)\n", + "\n", + " peptide_profiles = [peptide1, peptide2, peptide3, peptide4, peptide5, peptide6, peptide7, peptide8]\n", + " protein_df = lfq_testutils.ProteinProfileGenerator(peptide_profiles).protein_profile_dataframe\n", + " protein_df_normed, _ = intensity_estimation.estimate_protein_intensities(protein_df, min_nonan=1, num_samples_quadratic=100, num_cores=1)\n", + " display(protein_df_normed)\n", + " assert len(protein_df_normed.index) == 4\n", + "\n", + "run_with_multiple_proteins()\n", + "\n" ] }, { diff --git a/nbdev_nbs/04_utils.ipynb b/nbdev_nbs/04_utils.ipynb index f737b51..4d6b7d8 100644 --- a/nbdev_nbs/04_utils.ipynb +++ b/nbdev_nbs/04_utils.ipynb @@ -50,1024 +50,47 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "def get_samples_used_from_samplemap_file(samplemap_file, cond1, cond2):\n", - " samplemap_df = load_samplemap(samplemap_file)\n", - " return get_samples_used_from_samplemap_df(samplemap_df, cond1, cond2)\n", - "\n", - "\n", - "def get_samples_used_from_samplemap_df(samplemap_df, cond1, cond2):\n", - " samples_c1 = samplemap_df[[cond1 == x for x in samplemap_df[\"condition\"]]][\"sample\"] #subset the df to the condition\n", - " samples_c2 = samplemap_df[[cond2 == x for x in samplemap_df[\"condition\"]]][\"sample\"]\n", - " return list(samples_c1), list(samples_c2)\n", - "\n", - "def get_all_samples_from_samplemap_df(samplemap_df):\n", - " return list(samplemap_df[\"sample\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "\n", - "def get_samplenames_from_input_df(data):\n", - " \"\"\"extracts the names of the samples of the AQ input dataframe\"\"\"\n", - " names = list(data.columns)\n", - " names.remove('protein')\n", - " names.remove('ion')\n", - " return names" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import numpy as np\n", - "def filter_df_to_minrep(quant_df_wideformat, samples_c1, samples_c2, minrep):\n", - " \"\"\"filters dataframe in directlfq format such that each column has a minimum number of replicates\n", - " \"\"\"\n", - " quant_df_wideformat = quant_df_wideformat.replace(0, np.nan)\n", - " df_c1_minrep = quant_df_wideformat[samples_c1].dropna(thresh = minrep, axis = 0)\n", - " df_c2_minrep = quant_df_wideformat[samples_c2].dropna(thresh = minrep, axis = 0)\n", - " idxs_both = df_c1_minrep.index.intersection(df_c2_minrep.index)\n", - " quant_df_reduced = quant_df_wideformat.iloc[idxs_both].reset_index()\n", - " return quant_df_reduced" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_condpairname(condpair):\n", - " return f\"{condpair[0]}_VS_{condpair[1]}\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "def get_quality_score_column(acquisition_info_df):\n", - " if \"FG.ShapeQualityScore\" in acquisition_info_df.columns:\n", - " param = \"FG.ShapeQualityScore\"\n", - " elif \"Quantity.Quality\" in acquisition_info_df.columns:\n", - " param = \"Quantity.Quality\"\n", - " return param" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import os\n", - "\n", - "def make_dir_w_existcheck(dir):\n", - " if not os.path.exists(dir):\n", - " os.makedirs(dir)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import os\n", - "def get_results_plot_dir_condpair(results_dir, condpair):\n", - " results_dir_plots = f\"{results_dir}/{condpair}_plots\"\n", - " make_dir_w_existcheck(results_dir_plots)\n", - " return results_dir_plots" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def get_middle_elem(sorted_list):\n", - " nvals = len(sorted_list)\n", - " if nvals==1:\n", - " return sorted_list[0]\n", - " middle_idx = nvals//2\n", - " if nvals%2==1:\n", - " return sorted_list[middle_idx]\n", - " return 0.5* (sorted_list[middle_idx] + sorted_list[middle_idx-1])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import numpy as np\n", - "def get_nonna_array(array_w_nas):\n", - " res = []\n", - " isnan_arr = np.isnan(array_w_nas)\n", - "\n", - " for idx in range(len(array_w_nas)):\n", - " sub_res = []\n", - " sub_array = array_w_nas[idx]\n", - " na_array = isnan_arr[idx]\n", - " for idx2 in range(len(sub_array)):\n", - " if not na_array[idx2]:\n", - " sub_res.append(sub_array[idx2])\n", - " res.append(np.array(sub_res))\n", - " return np.array(res)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import numpy as np\n", - "def get_non_nas_from_pd_df(df):\n", - " return {\n", - " pep_name: sub_vals[~np.isnan(sub_vals)] for pep_name, sub_vals in\n", - " zip( df.index.values, df.values)\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import numpy as np\n", - "def get_ionints_from_pd_df(df):\n", - " return {\n", - " pep_name: sub_vals for pep_name, sub_vals in\n", - " zip( df.index.values, df.values)\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def invert_dictionary(my_map):\n", - " inv_map = {}\n", - " for k, v in my_map.items():\n", - " inv_map[v] = inv_map.get(v, []) + [k]\n", - " return inv_map" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import statistics\n", - "\n", - "def get_z_from_p_empirical(p_emp,p2z):\n", - " p_rounded = np.format_float_scientific(p_emp, 1)\n", - " if p_rounded in p2z:\n", - " return p2z.get(p_rounded)\n", - " z = statistics.NormalDist().inv_cdf(float(p_rounded))\n", - " p2z[p_rounded] = z\n", - " return z" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def count_fraction_outliers_from_expected_fc(result_df, threshold, expected_log2fc):\n", - " num_outliers = sum([abs(x-expected_log2fc)> threshold for x in result_df[\"log2fc\"]])\n", - " fraction_outliers = num_outliers/len(result_df[\"log2fc\"])\n", - " print(f\"{round(fraction_outliers, 2)} outliers\")\n", - " return fraction_outliers" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import os\n", - "import shutil\n", - "def create_or_replace_folder(folder):\n", - " if os.path.exists(folder):\n", - " shutil.rmtree(folder)\n", - " os.makedirs(folder)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "def add_mq_protein_group_ids_if_applicable_and_obtain_annotated_file(mq_file, input_type_to_use ,mq_protein_group_file, columns_to_add):\n", - " try:\n", - " input_type = _get_input_type(mq_file, input_type_to_use)\n", - " if (\"maxquant_evidence\" in input_type or \"maxquant_peptides\" in input_type) and (\"aq_reformat\" not in mq_file) and (\"directlfq\" not in input_type_to_use) and (input_type_to_use != \"directlfq\"):\n", - " if mq_protein_group_file is None:\n", - " print(\"You provided a MaxQuant peptide or evidence file as input. To have the identical ProteinGroups as in the MaxQuant analysis, please provide the ProteinGroups.txt file as well.\")\n", - " return mq_file\n", - " else:\n", - " mq_df = load_input_file_and_de_duplicate_if_evidence(mq_file, input_type, columns_to_add)\n", - " id_column = determine_id_column_from_input_df(mq_df)\n", - " id2protein_df = create_id_to_protein_df(mq_protein_group_file, id_column)\n", - " annotated_mq_df = annotate_mq_df(mq_df, id2protein_df, id_column)\n", - " annotated_mq_filename = f\"{mq_file}.protgroup_annotated.tsv\"\n", - " save_annotated_mq_df(annotated_mq_df, annotated_mq_filename)\n", - " return annotated_mq_filename\n", - " else:\n", - " return mq_file\n", - " except:\n", - " return mq_file\n", - "\n", - "\n", - "def _get_input_type(mq_file ,input_type_to_use):\n", - " if input_type_to_use is not None:\n", - " return input_type_to_use\n", - " else:\n", - " return get_input_type_and_config_dict(mq_file)[0]\n", - " \n", - "\n", - "def load_input_file_and_de_duplicate_if_evidence(input_file, input_type, columns_to_add):\n", - " input_df = pd.read_csv(input_file, sep = \"\\t\")\n", - " if \"maxquant_evidence\" in input_type:\n", - " subset_columns = ['id','Sequence','Modified sequence', 'Experiment','Charge', 'Raw file', 'Gene names', 'Intensity', 'Reverse', 'Potential contaminant'] + columns_to_add\n", - " columns_to_group_by = ['Sequence','Modified sequence', 'Experiment','Charge', 'Raw file']\n", - " input_df = input_df[subset_columns].set_index(columns_to_group_by)\n", - " input_df_grouped = input_df.groupby(columns_to_group_by).Intensity.max()\n", - " input_df_no_intensities = input_df.drop(columns=[\"Intensity\"])\n", - "\n", - " input_df = input_df_no_intensities.merge(input_df_grouped, how= 'right', left_index=True, right_index=True).reset_index()\n", - " input_df = input_df.drop_duplicates(subset=columns_to_group_by)\n", - "\n", - " return input_df\n", - "\n", - "def create_id_to_protein_df(mq_protein_group_file, id_column): \n", - " id_mapping_df = pd.read_csv(mq_protein_group_file, sep = \"\\t\", usecols=[\"Protein IDs\", id_column])\n", - " #apply lambda function to id column to split it into a list of ids\n", - " id_mapping_df[id_column] = id_mapping_df[id_column].apply(lambda x: x.split(\";\"))\n", - " #explode the id column\n", - " id_mapping_df = id_mapping_df.explode(id_column) #https://stackoverflow.com/questions/12680754/split-explode-pandas-dataframe-string-entry-to-separate-rows\n", - " return id_mapping_df\n", - "\n", - "\n", - "def determine_id_column_from_input_df(input_df):\n", - " input_file_columns = input_df.columns\n", - " num_cols_starting_w_intensity = sum([x.startswith(\"Intensity \") for x in input_file_columns])\n", - " if num_cols_starting_w_intensity>0:\n", - " return \"Peptide IDs\"\n", - " else:\n", - " return \"Evidence IDs\"\n", - "\n", - "\n", - "def annotate_mq_df(mq_df, id2protein_df, id_column):\n", - " #set dtype of id to string\n", - " mq_df[\"id\"] = mq_df[\"id\"].astype(str)\n", - " id2protein_df = remove_ids_not_occurring_in_mq_df(id2protein_df, mq_df, id_column)\n", - " return mq_df.merge(id2protein_df, how = \"right\", left_on = \"id\", right_on = id_column, suffixes=('', '_y'))\n", - "\n", - "def remove_ids_not_occurring_in_mq_df(id2protein_df, mq_df, id_column):\n", - " mq_df_ids = set(mq_df[\"id\"])\n", - " id2protein_df = id2protein_df[id2protein_df[id_column].isin(mq_df_ids)]\n", - " return id2protein_df\n", - "\n", - "def save_annotated_mq_df(annotated_mq_df, annotated_mq_file):\n", - " annotated_mq_df.to_csv(annotated_mq_file, sep = \"\\t\", index = False)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "from distutils.command.config import config\n", - "\n", - "\n", - "def add_columns_to_lfq_results_table(lfq_results_df, input_file, columns_to_add):\n", - " input_type, config_dict, _ = get_input_type_and_config_dict(input_file)\n", - "\n", - " input_file = clean_input_filename_if_necessary(input_file)\n", - "\n", - " protein_column_input_table = get_protein_column_input_table(config_dict)\n", - " standard_columns_for_input_type = get_standard_columns_for_input_type(input_type)\n", - "\n", - " all_columns = columns_to_add + [protein_column_input_table] + standard_columns_for_input_type\n", - " all_columns = filter_columns_to_existing_columns(all_columns, input_file)\n", - "\n", - " input_df = pd.read_csv(input_file, sep=\"\\t\", usecols=all_columns).drop_duplicates(subset=protein_column_input_table)\n", - " lfq_results_df = lfq_results_df[[x is not None for x in lfq_results_df['protein']]]\n", - "\n", - " length_before = len(lfq_results_df.index)\n", - " lfq_results_df_appended = pd.merge(lfq_results_df, input_df, left_on='protein', right_on=protein_column_input_table, how='left')\n", - " length_after = len(lfq_results_df_appended.index)\n", - "\n", - " lfq_results_df_appended = lfq_results_df_appended.set_index('protein')\n", - " \n", - "\n", - " assert length_before == length_after\n", - " return lfq_results_df_appended\n", - "\n", - "def clean_input_filename_if_necessary(input_file):\n", - " if \"aq_reformat.tsv\" in input_file:\n", - " input_file = get_original_file_from_aq_reformat(input_file)\n", - " return input_file\n", - "\n", - "def get_protein_column_input_table(config_dict):\n", - " return config_dict[\"protein_cols\"][0]\n", - "\n", - "def get_standard_columns_for_input_type(input_type):\n", - " \n", - " if 'maxquant' in input_type:\n", - " return [\"Gene names\"]\n", - " elif 'diann' in input_type:\n", - " return [\"Protein.Names\", \"Genes\"]\n", - " elif 'spectronaut' in input_type:\n", - " return ['PG.Genes']\n", - " else:\n", - " return []\n", - "\n", - "def filter_columns_to_existing_columns(columns, input_file):\n", - " existing_columns = pd.read_csv(input_file, sep='\\t', nrows=1).columns\n", - " return [x for x in columns if x in existing_columns]\n", - "\n", - "\n", - "\n", - "#function that shows the differing rows between two dataframes\n", - "def show_diff(df1, df2):\n", - " return df1.merge(df2, indicator=True, how='outer').loc[lambda x : x['_merge']!='both']\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## I/O functions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def write_chunk_to_file(chunk, filepath ,write_header):\n", - " \"\"\"write chunk of pandas dataframe to a file\"\"\"\n", - " chunk.to_csv(filepath, header=write_header, mode='a', sep = \"\\t\", index = None)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def index_and_log_transform_input_df(data_df):\n", - " data_df = data_df.set_index([\"protein\", \"ion\"])\n", - " return np.log2(data_df.replace(0, np.nan))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def remove_allnan_rows_input_df(data_df):\n", - " return data_df.dropna(axis = 0, how = 'all')\n", - "\n", - "\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Input Parsers\n", - "The directlfq pipeline is run using a generic wide-table input format, as specified in the documentation. The following parsers convert long format tables as provided e.g. by Spectronaut or DIA-NN into this generic format. The configuration for the parsers is set by a yaml file." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Convert long format to wide format" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Parse .yaml file\n", - "The relevant parameters for reading and reformatting the long table are stored in the \"intable_config.yaml\" file. The functions below are for reading and reformating the config info" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import yaml\n", - "import itertools\n", - "\n", - "def get_relevant_columns(protein_cols, ion_cols, sample_ID, quant_ID, filter_dict):\n", - " filtcols = []\n", - " for filtconf in filter_dict.values():\n", - " filtcols.append(filtconf.get('param'))\n", - " relevant_cols = protein_cols + ion_cols + [sample_ID] + [quant_ID] + filtcols\n", - " relevant_cols = list(set(relevant_cols)) # to remove possible redudancies\n", - " return relevant_cols\n", - "\n", - "\n", - "def get_relevant_columns_config_dict(config_typedict):\n", - " filtcols = []\n", - " dict_ioncols = []\n", - " for filtconf in config_typedict.get('filters', {}).values():\n", - " filtcols.append(filtconf.get('param'))\n", - "\n", - " if 'ion_hierarchy' in config_typedict.keys():\n", - " for headr in config_typedict.get('ion_hierarchy').values():\n", - " ioncols = list(itertools.chain.from_iterable(headr.get(\"mapping\").values()))\n", - " dict_ioncols.extend(ioncols)\n", - "\n", - " quant_ids = get_quant_ids_from_config_dict(config_typedict)\n", - " sample_ids = get_sample_ids_from_config_dict(config_typedict)\n", - " channel_ids = get_channel_ids_from_config_dict(config_typedict)\n", - " relevant_cols = config_typedict.get(\"protein_cols\") + config_typedict.get(\"ion_cols\", []) + sample_ids + quant_ids + filtcols + dict_ioncols + channel_ids\n", - " relevant_cols = list(set(relevant_cols)) # to remove possible redudancies\n", - " return relevant_cols\n", - "\n", - "def get_quant_ids_from_config_dict(config_typedict):\n", - " quantID = config_typedict.get(\"quant_ID\")\n", - " if type(quantID) ==type(\"string\"):\n", - " return [config_typedict.get(\"quant_ID\")]\n", - " if quantID == None:\n", - " return[]\n", - " else:\n", - " return list(config_typedict.get(\"quant_ID\").values())\n", - "\n", - "def get_sample_ids_from_config_dict(config_typedict):\n", - " sampleID = config_typedict.get(\"sample_ID\")\n", - " if type(sampleID) ==type(\"string\"):\n", - " return [config_typedict.get(\"sample_ID\")]\n", - " if sampleID == None:\n", - " return []\n", - " else:\n", - " return config_typedict.get(\"sample_ID\")\n", - "\n", - "def get_channel_ids_from_config_dict(config_typedict):\n", - " return config_typedict.get(\"channel_ID\", [])\n", - "\n", - "\n", - "\n", - "def load_config(config_yaml):\n", - " with open(config_yaml, 'r') as stream:\n", - " config_all = yaml.safe_load(stream)\n", - " return config_all\n", - "\n", - "def get_type2relevant_cols(config_all):\n", - " type2relcols = {}\n", - " for type in config_all.keys():\n", - " config_typedict = config_all.get(type)\n", - " relevant_cols = get_relevant_columns_config_dict(config_typedict)\n", - " type2relcols[type] = relevant_cols\n", - " return type2relcols" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Filter and reformat" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "def filter_input(filter_dict, input):\n", - " if filter_dict == None:\n", - " return input\n", - " for filtname,filterconf in filter_dict.items():\n", - " param = filterconf.get('param')\n", - " comparator = filterconf.get('comparator')\n", - " value = filterconf.get('value')\n", - "\n", - " if comparator not in [\">\",\">=\", \"<\", \"<=\", \"==\", \"!=\"]:\n", - " raise TypeError(f\"cannot identify the filter comparator of {filtname} given in the longtable config yaml!\")\n", - "\n", - " if comparator==\"==\":\n", - " input = input[input[param] ==value]\n", - " continue\n", - " try:\n", - " input = input.astype({f\"{param}\" : \"float\"})\n", - " except:\n", - " pass\n", - "\n", - " if comparator==\">\":\n", - " input = input[input[param].astype(type(value)) >value]\n", - "\n", - " if comparator==\">=\":\n", - " input = input[input[param].astype(type(value)) >=value]\n", - "\n", - " if comparator==\"<\":\n", - " input = input[input[param].astype(type(value)) value_threshold]\n", - " #exploded_input = exploded_input.rename(columns = {'var1': split_col})\n", - " return exploded_input\n", - "\n", - "\n", - "\n", - "def add_merged_ionnames(df_subset, ion_hierarchy_local, ion_headers_grouped, quant_id_dict, hierarchy_type):\n", - " \"\"\"puts together the hierarchical ion names as a column in a given input dataframe\"\"\"\n", - " all_ion_headers = list(itertools.chain.from_iterable(ion_headers_grouped))\n", - " columns_to_index = [x for x in df_subset.columns if x not in all_ion_headers]\n", - " df_subset = df_subset.set_index(columns_to_index)\n", - "\n", - " rows = df_subset[all_ion_headers].to_numpy()\n", - " ions = []\n", - "\n", - " for row in rows: #iterate through dataframe\n", - " count = 0\n", - " ionstring = \"\"\n", - " for lvl_idx in range(len(ion_hierarchy_local)):\n", - " ionstring += f\"{ion_hierarchy_local[lvl_idx]}\"\n", - " for sublvl in ion_headers_grouped[lvl_idx]:\n", - " ionstring+= f\"_{row[count]}_\"\n", - " count+=1\n", - " ions.append(ionstring)\n", - " df_subset['ion'] = ions\n", - " df_subset = df_subset.reset_index()\n", - " if quant_id_dict!= None:\n", - " df_subset = df_subset.rename(columns = {quant_id_dict.get(hierarchy_type) : \"quant_val\"})\n", - " return df_subset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import os.path\n", - "def reformat_and_write_longtable_according_to_config(input_file, outfile_name, config_dict_for_type, sep = \"\\t\",decimal = \".\", enforce_largefile_processing = False, chunksize =1000_000):\n", - " \"\"\"Reshape a long format proteomics results table (e.g. Spectronaut or DIA-NN) to a wide format table.\n", - " :param file input_file: long format proteomic results table\n", - " :param string input_type: the configuration key stored in the config file (e.g. \"diann_precursor\")\n", - " \"\"\"\n", - " filesize = os.path.getsize(input_file)/(1024**3) #size in gigabyte\n", - " file_is_large = (filesize>10 and str(input_file).endswith(\".zip\")) or filesize>50 or enforce_largefile_processing\n", - "\n", - " if file_is_large:\n", - " tmpfile_large = f\"{input_file}.tmp.longformat.columnfilt.tsv\" #only needed when file is large\n", - " #remove potential leftovers from previous processings\n", - " if os.path.exists(tmpfile_large):\n", - " os.remove(tmpfile_large)\n", - " if os.path.exists(outfile_name):\n", - " os.remove(outfile_name)\n", - " \n", - " relevant_cols = get_relevant_columns_config_dict(config_dict_for_type)\n", - " input_df_it = pd.read_csv(input_file, sep = sep, decimal=decimal, usecols = relevant_cols, encoding ='latin1', chunksize = chunksize)\n", - " input_df_list = []\n", - " header = True\n", - " for input_df_subset in input_df_it:\n", - " input_df_subset = adapt_subtable(input_df_subset, config_dict_for_type)\n", - " if file_is_large:\n", - " write_chunk_to_file(input_df_subset,tmpfile_large, header)\n", - " else:\n", - " input_df_list.append(input_df_subset)\n", - " header = False\n", - " \n", - " if file_is_large:\n", - " process_with_dask(tmpfile_columnfilt=tmpfile_large , outfile_name = outfile_name, config_dict_for_type=config_dict_for_type)\n", - " else:\n", - " input_df = pd.concat(input_df_list)\n", - " input_reshaped = reshape_input_df(input_df, config_dict_for_type)\n", - " input_reshaped.to_csv(outfile_name, sep = \"\\t\", index = None)\n", - " \n", - "\n", - "def adapt_subtable(input_df_subset, config_dict):\n", - " input_df_subset = filter_input(config_dict.get(\"filters\", {}), input_df_subset)\n", - " if \"ion_hierarchy\" in config_dict.keys():\n", - " return merge_protein_cols_and_ion_dict(input_df_subset, config_dict)\n", - " else:\n", - " return merge_protein_and_ion_cols(input_df_subset, config_dict)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import dask.dataframe as dd\n", - "import pandas as pd\n", - "import glob\n", - "import os\n", - "import shutil \n", - "\n", - "def process_with_dask(*, tmpfile_columnfilt, outfile_name, config_dict_for_type):\n", - " df = dd.read_csv(tmpfile_columnfilt, sep = \"\\t\")\n", - " allcols = df[config_dict_for_type.get(\"sample_ID\")].drop_duplicates().compute() # the columns of the output table are the sample IDs\n", - " allcols = extend_sample_allcolumns_for_plexdia_case(allcols_samples=allcols, config_dict_for_type=config_dict_for_type)\n", - " allcols = ['protein', 'ion'] + sorted(allcols)\n", - " df = df.set_index('protein')\n", - " sorted_filedir = f\"{tmpfile_columnfilt}_sorted\"\n", - " df.to_csv(sorted_filedir, sep = \"\\t\")\n", - " #now the files are sorted and can be pivoted chunkwise (multiindex pivoting at the moment not possible in dask)\n", - " files_dask = glob.glob(f\"{sorted_filedir}/*part\")\n", - " header = True\n", - " for file in files_dask:\n", - " input_df = pd.read_csv(file, sep = \"\\t\")\n", - " if len(input_df.index) <2:\n", - " continue\n", - " input_reshaped = reshape_input_df(input_df, config_dict_for_type)\n", - " input_reshaped = sort_and_add_columns(input_reshaped, allcols)\n", - " write_chunk_to_file(input_reshaped, outfile_name, header)\n", - " header = False\n", - " os.remove(tmpfile_columnfilt)\n", - " shutil.rmtree(sorted_filedir)\n", - "\n", - "def reshape_input_df(input_df, config_dict):\n", - " input_df = input_df.astype({'quant_val': 'float'})\n", - " input_df = adapt_input_df_columns_in_case_of_plexDIA(input_df=input_df, config_dict_for_type=config_dict)\n", - " input_reshaped = pd.pivot_table(input_df, index = ['protein', 'ion'], columns = config_dict.get(\"sample_ID\"), values = 'quant_val', fill_value=0)\n", - "\n", - " input_reshaped = input_reshaped.reset_index()\n", - " return input_reshaped\n", - "\n", - "\n", - "def sort_and_add_columns(input_reshaped, allcols):\n", - " missing_cols = set(allcols) - set(input_reshaped.columns)\n", - " input_reshaped[list(missing_cols)] = 0\n", - " input_reshaped = input_reshaped[allcols]\n", - " return input_reshaped\n", - "\n", - "\n", - "def extend_sample_allcolumns_for_plexdia_case(allcols_samples, config_dict_for_type):\n", - " if is_plexDIA_table(config_dict_for_type):\n", - " new_allcols = []\n", - " channels = ['mTRAQ-n-0', 'mTRAQ-n-4', 'mTRAQ-n-8']\n", - " for channel in channels:\n", - " for sample in allcols_samples:\n", - " new_allcols.append(merge_channel_and_sample_string(sample, channel))\n", - " return new_allcols\n", - " else:\n", - " return allcols_samples" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#| export\n", - "#PLEXDIA case\n", - "\n", - "def adapt_input_df_columns_in_case_of_plexDIA(input_df,config_dict_for_type):\n", - " if is_plexDIA_table(config_dict_for_type):\n", - " input_df = extend_sampleID_column_for_plexDIA_case(input_df, config_dict_for_type)\n", - " input_df = set_mtraq_reduced_ion_column_into_dataframe(input_df)\n", - " return input_df\n", - " else:\n", - " return input_df\n", - "\n", - "\n", - "def extend_sampleID_column_for_plexDIA_case(input_df,config_dict_for_type):\n", - " channels_per_peptide = parse_channel_from_peptide_column(input_df)\n", - " return merge_sample_id_and_channels(input_df, channels_per_peptide, config_dict_for_type)\n", - "\n", - "\n", - "def set_mtraq_reduced_ion_column_into_dataframe(input_df):\n", - " new_ions = remove_mtraq_modifications_from_ion_ids(input_df['ion'])\n", - " input_df['ion'] = new_ions\n", - " return input_df\n", - "\n", - "def remove_mtraq_modifications_from_ion_ids(ions):\n", - " new_ions = []\n", - " all_mtraq_tags = [\"(mTRAQ-K-0)\", \"(mTRAQ-K-4)\", \"(mTRAQ-K-8)\", \"(mTRAQ-n-0)\", \"(mTRAQ-n-4)\", \"(mTRAQ-n-8)\"]\n", - " for ion in ions:\n", - " for tag in all_mtraq_tags:\n", - " ion = ion.replace(tag, \"\")\n", - " new_ions.append(ion)\n", - " return new_ions\n", - "\n", - "\n", - "def is_plexDIA_table(config_dict_for_type):\n", - " return config_dict_for_type.get('channel_ID') == ['Channel.0', 'Channel.4', 'Channel.8']\n", - "\n", - "\n", - "import re\n", - "def parse_channel_from_peptide_column(input_df):\n", - " channels = []\n", - " for pep in input_df['Modified.Sequence']:\n", - " pattern = \"(.*)(\\(mTRAQ-n-.\\))(.*)\"\n", - " matched = re.match(pattern, pep)\n", - " num_appearances = pep.count(\"mTRAQ-n-\")\n", - " if matched and num_appearances==1:\n", - " channels.append(matched.group(2))\n", - " else:\n", - " channels.append(\"NA\")\n", - " return channels\n", - "\n", - "def merge_sample_id_and_channels(input_df, channels, config_dict_for_type):\n", - " sample_id = config_dict_for_type.get(\"sample_ID\")\n", - " sample_ids = list(input_df[sample_id])\n", - " input_df[sample_id] = [merge_channel_and_sample_string(sample_ids[idx], channels[idx]) for idx in range(len(sample_ids))]\n", - " return input_df\n", - " \n", - "def merge_channel_and_sample_string(sample, channel):\n", - " return f\"{sample}_{channel}\"" + "## I/O functions" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#| include: false\n", - "def test_remove_remove_mtraq_modifications_from_ion_ids():\n", - " ions = [\"SEQ_IAVLLAK_MOD_(mTRAQ-n-0)IAVLLAK(mTRAQ-K-0)\", \"SEQ_IAVLLAK_MOD_(mTRAQ-n-0)IAVLLAK(mTRAQ-K-0)_CHARGE_1_FRGION_2_\", \"SEQ_IAVLLAK_MOD_(mTRAQ-n-0)I(mTRAQ-n-0)AVL(mTRAQ-K-0)LAK(mTRAQ-K-0)_CHARGE_1_FRGION_2_\"]\n", - " new_ions = remove_mtraq_modifications_from_ion_ids(ions)\n", - " for ion in new_ions:\n", - " assert 'mTRAQ' not in ion\n", - "test_remove_remove_mtraq_modifications_from_ion_ids()" + "# Input Parsers\n", + "The directlfq pipeline is run using a generic wide-table input format, as specified in the documentation. The following parsers convert long format tables as provided e.g. by Spectronaut or DIA-NN into this generic format. The configuration for the parsers is set by a yaml file." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#| export\n", - "def reformat_and_write_wideformat_table(peptides_tsv, outfile_name, config_dict):\n", - " input_df = pd.read_csv(peptides_tsv,sep=\"\\t\", encoding ='latin1')\n", - " filter_dict = config_dict.get(\"filters\")\n", - " protein_cols = config_dict.get(\"protein_cols\")\n", - " ion_cols = config_dict.get(\"ion_cols\")\n", - " input_df = filter_input(filter_dict, input_df)\n", - " #input_df = merge_protein_and_ion_cols(input_df, config_dict)\n", - " input_df = merge_protein_cols_and_ion_dict(input_df, config_dict)\n", - " if 'quant_pre_or_suffix' in config_dict.keys():\n", - " quant_pre_or_suffix = config_dict.get('quant_pre_or_suffix')\n", - " headers = ['protein', 'ion'] + list(filter(lambda x: x.startswith(quant_pre_or_suffix) or x.endswith(quant_pre_or_suffix), input_df.columns))\n", - " input_df = input_df[headers]\n", - " input_df = input_df.rename(columns = lambda x : x.replace(quant_pre_or_suffix, \"\"))\n", - "\n", - " #input_df = input_df.reset_index()\n", - " \n", - " input_df.to_csv(outfile_name, sep = '\\t', index = None)" + "## Convert long format to wide format" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "\n", - "def read_mq_peptides_table(peptides_tsv, pepheader = \"Sequence\", protheader = \"Leading razor protein\"):\n", - " peps = pd.read_csv(peptides_tsv,sep=\"\\t\", encoding ='latin1')\n", - " peps = peps[peps[\"Reverse\"] != \"+\"]\n", - " peps = peps[peps[\"Potential contaminant\"] != \"+\"]\n", - " if pepheader != None:\n", - " peps = peps.rename(columns = {pepheader : \"ion\"})\n", - " if protheader != None:\n", - " peps = peps.rename(columns = {protheader: \"protein\"})\n", - " headers = ['protein', 'ion'] + list(filter(lambda x: x.startswith(\"Intensity \"), peps.columns))\n", - " peps = peps[headers]\n", - " peps = peps.rename(columns = lambda x : x.replace(\"Intensity \", \"\"))\n", - "\n", - " return peps" + "### Parse .yaml file\n", + "The relevant parameters for reading and reformatting the long table are stored in the \"intable_config.yaml\" file. The functions below are for reading and reformating the config info" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## check for already processed files" + "### Filter and reformat" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#| export\n", - "import os\n", - "def check_for_processed_runs_in_results_folder(results_folder):\n", - " contained_condpairs = []\n", - " folder_files = os.listdir(results_folder)\n", - " result_files = list(filter(lambda x: \"results.tsv\" in x ,folder_files))\n", - " for result_file in result_files:\n", - " res_name = result_file.replace(\".results.tsv\", \"\")\n", - " if ((f\"{res_name}.normed.tsv\" in folder_files) & (f\"{res_name}.results.ions.tsv\" in folder_files)):\n", - " contained_condpairs.append(res_name)\n", - " return contained_condpairs" + "## check for already processed files" ] }, { @@ -1077,507 +100,6 @@ "## Wrapper functions" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "import os\n", - "import pathlib\n", - "\n", - "def import_data(input_file, input_type_to_use = None, samples_subset = None, results_dir = None):\n", - " \"\"\"\n", - " Function to import peptide level data. Depending on available columns in the provided file,\n", - " the function identifies the type of input used (e.g. Spectronaut, MaxQuant, DIA-NN), reformats if necessary\n", - " and returns a generic wide-format dataframe\n", - " :param file input_file: quantified peptide/ion -level data\n", - " :param file results_folder: the folder where the directlfq outputs are stored\n", - " \"\"\"\n", - "\n", - " samples_subset = add_ion_protein_headers_if_applicable(samples_subset)\n", - " if (\"aq_reformat\" in input_file) | (input_type_to_use == \"directlfq\"):\n", - " file_to_read = input_file\n", - " else:\n", - " file_to_read = reformat_and_save_input_file(input_file=input_file, input_type_to_use=input_type_to_use)\n", - " \n", - " input_reshaped = pd.read_csv(file_to_read, sep = \"\\t\", encoding = 'latin1', usecols=samples_subset)\n", - " input_reshaped = input_reshaped.drop_duplicates(subset='ion')\n", - " return input_reshaped\n", - "\n", - "\n", - "def reformat_and_save_input_file(input_file, input_type_to_use = None):\n", - " \n", - " input_type, config_dict_for_type, sep = get_input_type_and_config_dict(input_file, input_type_to_use)\n", - " print(f\"using input type {input_type}\")\n", - " format = config_dict_for_type.get('format')\n", - " outfile_name = f\"{input_file}.{input_type}.aq_reformat.tsv\"\n", - "\n", - " if format == \"longtable\":\n", - " reformat_and_write_longtable_according_to_config(input_file, outfile_name,config_dict_for_type, sep = sep)\n", - " elif format == \"widetable\":\n", - " reformat_and_write_wideformat_table(input_file, outfile_name, config_dict_for_type)\n", - " else:\n", - " raise Exception('Format not recognized!')\n", - " return outfile_name\n", - "\n", - "\n", - "\n", - "\n", - "def add_ion_protein_headers_if_applicable(samples_subset):\n", - " if samples_subset is not None:\n", - " return samples_subset + [\"ion\", \"protein\"]\n", - " else:\n", - " return None\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "import os.path\n", - "import pathlib\n", - "\n", - "def get_input_type_and_config_dict(input_file, input_type_to_use = None):\n", - " #parse the type of input (e.g. Spectronaut Fragion+MS1Iso) out of the input file\n", - "\n", - "\n", - " config_dict = load_config(INTABLE_CONFIG)\n", - " type2relevant_columns = get_type2relevant_cols(config_dict)\n", - "\n", - " if \"aq_reformat.tsv\" in input_file:\n", - " input_file = get_original_file_from_aq_reformat(input_file)\n", - "\n", - " filename = str(input_file)\n", - " if '.csv' in filename:\n", - " sep=','\n", - " if '.tsv' in filename:\n", - " sep='\\t'\n", - " if '.txt' in filename:\n", - " sep='\\t'\n", - "\n", - " if 'sep' not in locals():\n", - " raise TypeError(f\"neither of the file extensions (.tsv, .csv, .txt) detected for file {input_file}! Your filename has to contain one of these extensions. Please modify your file name accordingly.\")\n", - "\n", - "\n", - "\n", - " uploaded_data_columns = set(pd.read_csv(input_file, sep=sep, nrows=1, encoding ='latin1').columns)\n", - "\n", - " for input_type in type2relevant_columns.keys():\n", - " if (input_type_to_use is not None) and (input_type!=input_type_to_use):\n", - " continue\n", - " relevant_columns = type2relevant_columns.get(input_type)\n", - " relevant_columns = [x for x in relevant_columns if x] #filter None values\n", - " if set(relevant_columns).issubset(uploaded_data_columns):\n", - " config_dict_type = config_dict.get(input_type)\n", - " return input_type, config_dict_type, sep\n", - " raise TypeError(\"format not specified in intable_config.yaml!\")\n", - "\n", - "import re\n", - "def get_original_file_from_aq_reformat(input_file):\n", - " matched = re.match(\"(.*)(\\..*\\.)(aq_reformat\\.tsv)\",input_file)\n", - " return matched.group(1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| include: false\n", - "\n", - "def test_get_original_file_from_aq_reformat():\n", - " assert get_original_file_from_aq_reformat(\"yeast_report_fastafiltered.tsv.some.oth.erstuff.spectronaut_fragion_isotopes.aq_reformat.tsv\") == \"yeast_report_fastafiltered.tsv\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def import_config_dict():\n", - " config_dict = load_config(INTABLE_CONFIG)\n", - " return config_dict" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "import pandas as pd\n", - "\n", - "def load_samplemap(samplemap_file):\n", - " file_ext = os.path.splitext(samplemap_file)[-1]\n", - " if file_ext=='.csv':\n", - " sep=','\n", - " if (file_ext=='.tsv') | (file_ext=='.txt'):\n", - " sep='\\t'\n", - "\n", - " if 'sep' not in locals():\n", - " print(f\"neither of the file extensions (.tsv, .csv, .txt) detected for file {samplemap_file}! Trying with tab separation. In the case that it fails, please add the appropriate extension to your file name.\")\n", - " sep = \"\\t\"\n", - "\n", - " return pd.read_csv(samplemap_file, sep = sep, encoding ='latin1', dtype='str')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "def prepare_loaded_tables(data_df, samplemap_df):\n", - " \"\"\"\n", - " Integrates information from the peptide/ion data and the samplemap, selects the relevant columns and log2 transforms intensities.\n", - " \"\"\"\n", - " samplemap_df = samplemap_df[samplemap_df[\"condition\"]!=\"\"] #remove rows that have no condition entry\n", - " filtvec_not_in_data = [(x in data_df.columns) for x in samplemap_df[\"sample\"]] #remove samples that are not in the dataframe\n", - " samplemap_df = samplemap_df[filtvec_not_in_data]\n", - " headers = ['protein'] + samplemap_df[\"sample\"].to_list()\n", - " data_df = data_df.set_index(\"ion\")\n", - " for sample in samplemap_df[\"sample\"]:\n", - " data_df[sample] = np.log2(data_df[sample].replace(0, np.nan))\n", - " return data_df[headers], samplemap_df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "\n", - "#| export\n", - "class LongTableReformater():\n", - " \"\"\"Generic class to reformat tabular files in chunks. For the specific cases you can inherit the class and specify reformat and iterate function\n", - " \"\"\"\n", - " def __init__(self, input_file):\n", - " self._input_file = input_file\n", - " self._reformatting_function = None\n", - " self._iterator_function = self.__initialize_df_iterator__\n", - " self._concat_list = []\n", - "\n", - " def reformat_and_load_acquisition_data_frame(self):\n", - "\n", - " input_df_it = self._iterator_function()\n", - " \n", - " input_df_list = []\n", - " for input_df_subset in input_df_it:\n", - " input_df_subset = self._reformatting_function(input_df_subset)\n", - " input_df_list.append(input_df_subset)\n", - " input_df = pd.concat(input_df_list)\n", - " \n", - " return input_df\n", - "\n", - " def reformat_and_save_acquisition_data_frame(self, output_file):\n", - " \n", - " input_df_it = self._iterator_function()\n", - " write_header = True\n", - " \n", - " for input_df_subset in input_df_it:\n", - " input_df_subset = self._reformatting_function(input_df_subset)\n", - " self.__write_reformatted_df_to_file__(input_df_subset, output_file, write_header)\n", - " write_header = False\n", - "\n", - " def __initialize_df_iterator__(self):\n", - " return pd.read_csv(self._input_file, sep = \"\\t\", encoding ='latin1', chunksize=1000000)\n", - " \n", - " @staticmethod\n", - " def __write_reformatted_df_to_file__(reformatted_df, filepath ,write_header):\n", - " reformatted_df.to_csv(filepath, header=write_header, mode='a', sep = \"\\t\", index = None)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "import os\n", - "import re\n", - "\n", - "class AcquisitionTableHandler():\n", - " def __init__(self, results_dir, samples):\n", - " self._table_infos = AcquisitionTableInfo(results_dir=results_dir)\n", - " self._header_infos = AcquisitionTableHeaders(self._table_infos)\n", - " self._samples = self.__reformat_samples_if_necessary(samples)\n", - " \n", - " def get_acquisition_info_df(self):\n", - " return self.__get_reformated_df__()\n", - "\n", - " def save_dataframe_as_new_acquisition_dataframe(self):\n", - " self._output_paths = AcquisitionTableOutputPaths(self._table_infos)\n", - " self.__remove_possible_pre_existing_ml_table__(self._output_paths.output_file_name)\n", - " df_reformater = AcquisitionTableReformater(table_infos = self._table_infos, header_infos=self._header_infos, samples = self._samples, dataframe_already_preformated=False)\n", - " df_reformater.reformat_and_save_acquisition_data_frame(self._output_paths.output_file_name)\n", - "\n", - " def update_ml_file_location_in_method_parameters_yaml(self):\n", - " method_params = load_method_parameters(self._table_infos._results_dir)\n", - " if self._output_paths == None:\n", - " raise Exception(\"output paths not initialized! This could be because no dataframe was saved before\")\n", - " method_params[self._output_paths.ml_file_accession_in_yaml] = self._output_paths.output_file_name\n", - " save_dict_as_yaml(method_params, self._output_paths.method_parameters_yaml_path)\n", - " \n", - " def __get_reformated_df__(self):\n", - " df_reformater = AcquisitionTableReformater(table_infos = self._table_infos, header_infos=self._header_infos, samples = self._samples, dataframe_already_preformated=True)\n", - " df = df_reformater.reformat_and_load_acquisition_data_frame()\n", - " return df.convert_dtypes()\n", - "\n", - " def __reformat_samples_if_necessary(self, samples):\n", - " if \"plexDIA\" in self._table_infos._input_type:\n", - " return self.__get_plexDIA_samplenames__(samples)\n", - " else:\n", - " return samples\n", - " \n", - " def __get_plexDIA_samplenames__(self, samples):\n", - " new_samples = []\n", - " for sample in samples:\n", - " new_samples.append(self.__get_samplename_without_mtraq_tag__(sample))\n", - " return new_samples\n", - " \n", - " @staticmethod\n", - " def __get_samplename_without_mtraq_tag__(samplename):\n", - " pattern = \"(.*)(_\\(mTRAQ-n-.\\))\"\n", - " matched = re.match(pattern, samplename)\n", - " return matched.group(1)\n", - " \n", - " @staticmethod\n", - " def __remove_possible_pre_existing_ml_table__(output_file_name):\n", - " if os.path.exists(output_file_name):\n", - " os.remove(output_file_name)\n", - " print(f\"removed pre existing {output_file_name}\")\n", - "\n", - "\n", - "class AcquisitionTableInfo():\n", - " def __init__(self, results_dir, sep = \"\\t\", decimal = \".\"):\n", - " self._results_dir = results_dir\n", - " self._sep = sep\n", - " self._decimal = decimal\n", - " self._method_params_dict = load_method_parameters(results_dir)\n", - " self._input_file = self.__get_input_file__()\n", - " self._file_ending_of_formatted_table = \".ml_info_table.tsv\"\n", - " self.already_formatted = self.__check_if_input_file_is_already_formatted__()\n", - " self._input_type, self._config_dict = self.__get_input_type_and_config_dict__()\n", - " self._sample_column = self.__get_sample_column__()\n", - " self.last_ion_level_to_use = self.__get_last_ion_level_to_use__()\n", - "\n", - " def __get_input_file__(self):\n", - " if self._method_params_dict.get('ml_input_file') is None:\n", - " return self.__get_location_of_original_file__()\n", - " else:\n", - " return self._method_params_dict.get('ml_input_file')\n", - "\n", - " def __check_if_input_file_is_already_formatted__(self):\n", - " if self._file_ending_of_formatted_table in self._input_file:\n", - " return True\n", - " else:\n", - " return False\n", - "\n", - " def __get_input_type_and_config_dict__(self):\n", - " if self.already_formatted:\n", - " original_file = self.__get_location_of_original_file__()\n", - " else:\n", - " original_file = self._input_file\n", - " input_type, config_dict, _ = get_input_type_and_config_dict(original_file)\n", - " return input_type, config_dict\n", - " \n", - " def __get_location_of_original_file__(self):\n", - " input_file = self._method_params_dict.get('input_file')\n", - " return self.__get_original_filename_from_input_file__(input_file)\n", - " \n", - " @staticmethod\n", - " def __get_original_filename_from_input_file__(input_file):\n", - " pattern = \"(.*\\.tsv|.*\\.csv|.*\\.txt)(\\..*)(.aq_reformat.tsv)\"\n", - " m = re.match(pattern=pattern, string=input_file)\n", - " if m:\n", - " return m.group(1)\n", - " else:\n", - " return input_file\n", - "\n", - " \n", - " def __get_sample_column__(self):\n", - " return self._config_dict.get(\"sample_ID\")\n", - " \n", - " def __get_last_ion_level_to_use__(self):\n", - " return self._config_dict[\"ml_level\"]\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "class AcquisitionTableHeaders():\n", - " def __init__(self, acquisition_table_info):\n", - "\n", - " self._table_info = acquisition_table_info\n", - "\n", - " self._ion_hierarchy = self.__get_ordered_ion_hierarchy__()\n", - " self._included_levelnames = self.__get_included_levelnames__()\n", - " self._ion_headers_grouped = self.__get_ion_headers_grouped__()\n", - " self._ion_headers = self.__get_ion_headers__()\n", - " self._numeric_headers = self.__get_numeric_headers__()\n", - " self._relevant_headers = self.__get_relevant_headers__()\n", - " \n", - " def __get_ordered_ion_hierarchy__(self):\n", - " ion_hierarchy = self._table_info._config_dict.get(\"ion_hierarchy\")\n", - " hier_key = 'fragion' if 'fragion' in ion_hierarchy.keys() else list(ion_hierarchy.keys())[0]\n", - " ion_hierarchy_on_chosen_key = ion_hierarchy.get(hier_key)\n", - " return ion_hierarchy_on_chosen_key\n", - "\n", - " def __get_included_levelnames__(self):\n", - " levelnames = self.__get_all_levelnames__(self._ion_hierarchy)\n", - " last_ionlevel_idx = levelnames.index(self._table_info.last_ion_level_to_use)\n", - " return levelnames[:last_ionlevel_idx+1]\n", - " \n", - " @staticmethod\n", - " def __get_all_levelnames__(ion_hierarchy):\n", - " return ion_hierarchy.get('order')\n", - "\n", - " def __get_ion_headers_grouped__(self):\n", - " mapping_dict = self.__get_levelname_mapping_dict(self._ion_hierarchy)\n", - " return [mapping_dict.get(x) for x in self._included_levelnames]#on each level there can be multiple names, so it is a list of lists\n", - "\n", - " @staticmethod\n", - " def __get_levelname_mapping_dict(ion_hierarchy):\n", - " return ion_hierarchy.get('mapping')\n", - " \n", - " def __get_ion_headers__(self):\n", - " return list(itertools.chain(*self._ion_headers_grouped))\n", - "\n", - " \n", - " def __get_relevant_headers__(self):\n", - " relevant_headers = self._numeric_headers+self._ion_headers + [self._table_info._sample_column]\n", - " return self.__remove_possible_none_values_from_list__(relevant_headers)\n", - " \n", - " @staticmethod\n", - " def __remove_possible_none_values_from_list__(list):\n", - " return [x for x in list if x is not None]\n", - "\n", - " def __get_numeric_headers__(self):\n", - " df_sample = pd.read_csv(self._table_info._input_file, sep = self._table_info._sep, decimal = self._table_info._decimal, encoding='latin1', nrows=3000) #sample 3000 rows from the df to assess the types of each row\n", - " df_sample = df_sample.replace({False: 0, True: 1})\n", - " numeric_headers = list(df_sample.select_dtypes(include=np.number).columns)\n", - " numeric_headers = AcquisitionTableHeaderFilter().filter_numeric_headers_if_specified(input_type = self._table_info._input_type, numeric_headers = numeric_headers)\n", - " return numeric_headers\n", - "\n", - "\n", - "class AcquisitionTableOutputPaths():\n", - " def __init__(self, table_info):\n", - " self._table_info = table_info\n", - " self.output_file_name = self.__get_output_file_name__()\n", - " self.method_parameters_yaml_path = self.__get_method_parameters_yaml_path__()\n", - " self.ml_file_accession_in_yaml = \"ml_input_file\"\n", - "\n", - " def __get_output_file_name__(self):\n", - " old_file_name = self._table_info._input_file\n", - " new_file_name = old_file_name+self._table_info._file_ending_of_formatted_table\n", - " return new_file_name\n", - "\n", - " def __get_method_parameters_yaml_path__(self):\n", - " return f\"{self._table_info._results_dir}/aq_parameters.yaml\"\n", - "\n", - "\n", - "class AcquisitionTableReformater(LongTableReformater):\n", - " def __init__(self, table_infos, header_infos, samples, dataframe_already_preformated = False):\n", - " \n", - " LongTableReformater.__init__(self, table_infos._input_file)\n", - " self._table_infos = table_infos\n", - " self._header_infos = header_infos\n", - " self._samples = samples\n", - " self._dataframe_already_preformated = dataframe_already_preformated\n", - "\n", - " #set the two functions that specify the explicit reformatting\n", - " self._reformatting_function = self.__reformatting_function__\n", - " self._iterator_function = self.__initialize_iterator_with_specified_columns__\n", - " \n", - " def __reformatting_function__(self, input_df_subset):\n", - " input_df_subset = input_df_subset.drop_duplicates()\n", - " input_df_subset = self.__filter_reformated_df_if_necessary__(input_df_subset)\n", - " if not self._dataframe_already_preformated:\n", - " input_df_subset = add_merged_ionnames(input_df_subset, self._header_infos._included_levelnames, self._header_infos._ion_headers_grouped, None, None)\n", - " return input_df_subset\n", - "\n", - " def __filter_reformated_df_if_necessary__(self, reformatted_df):\n", - " if 'spectronaut' in self._table_infos._input_type or 'diann' in self._table_infos._input_type:\n", - " return self.__filter_reformatted_dataframe_to_relevant_samples__(reformatted_df)\n", - " else:\n", - " return reformatted_df\n", - "\n", - " def __filter_reformatted_dataframe_to_relevant_samples__(self, input_df_subset):\n", - " return input_df_subset[[x in self._samples for x in input_df_subset[self._table_infos._sample_column]]]\n", - " \n", - " def __initialize_iterator_with_specified_columns__(self):\n", - " cols_to_use = self.__get_cols_to_use__()\n", - " return pd.read_csv(self._table_infos._input_file, sep = self._table_infos._sep, decimal=self._table_infos._decimal, usecols = cols_to_use, encoding ='latin1', chunksize=1000000)\n", - "\n", - " def __get_cols_to_use__(self):\n", - " cols_to_use = self._header_infos._relevant_headers\n", - " if self._dataframe_already_preformated:\n", - " return cols_to_use+['ion']\n", - " else:\n", - " return cols_to_use\n", - "\n", - "\n", - "\n", - "\n", - "class AcquisitionTableHeaderFilter():\n", - " def __init__(self):\n", - " self._spectronaut_header_filter = lambda x : ((\"EG.\" in x) | (\"FG.\" in x)) and (\"Global\" not in x)\n", - " self._maxquant_header_filter = lambda x : (\"Intensity\" not in x) and (\"Experiment\" not in x)\n", - "\n", - " def filter_numeric_headers_if_specified(self, input_type, numeric_headers):\n", - " if 'spectronaut' in input_type:\n", - " return [x for x in numeric_headers if self._spectronaut_header_filter(x)]\n", - " elif 'maxquant' in input_type:\n", - " return [x for x in numeric_headers if self._maxquant_header_filter(x)]\n", - " else:\n", - " return numeric_headers\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "def merge_acquisition_df_parameter_df(acquisition_df, parameter_df, groupby_merge_type = 'mean'):\n", - " \"\"\"acquisition df contains details on the acquisition, parameter df are the parameters derived from the tree\n", - " \"\"\"\n", - " merged_df = parameter_df.merge(acquisition_df, how = 'left', on = 'ion')\n", - " if groupby_merge_type == 'mean':\n", - " merged_df = merged_df.groupby('ion').mean().reset_index()\n", - " if groupby_merge_type == 'min':\n", - " merged_df = merged_df.groupby('ion').min().reset_index()\n", - " if groupby_merge_type == 'max':\n", - " merged_df = merged_df.groupby('ion').max().reset_index()\n", - " merged_df = merged_df.dropna(axis=1, how='all')\n", - " return merged_df" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1676,13 +198,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "using input type diann_precursors\n", "loading ran through\n", - "using input type spectronaut_precursor_v2\n", "loading ran through\n", - "using input type spectronaut_fragion_isotopes\n", "loading ran through\n", - "using input type maxquant_peptides_leading_razor_protein\n", "loading ran through\n" ] } @@ -1827,7 +345,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "using input type spectronaut_precursor_v2\n", "['EG.ModifiedPeptide', 'FG.Charge', 'R.Label']\n", "['EG.ModifiedPeptide', 'FG.Charge', 'R.Label', 'FG.Quantity']\n" ] @@ -2050,13 +567,6 @@ "compare_generic_table_with_original(input_processed, input_file, \"../directlfq/configs/intable_config.yaml\", \"spectronaut_precursor_v2\")" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, diff --git a/nbdev_nbs/05_visualizations.ipynb b/nbdev_nbs/05_visualizations.ipynb index b56ebec..b260970 100644 --- a/nbdev_nbs/05_visualizations.ipynb +++ b/nbdev_nbs/05_visualizations.ipynb @@ -9,274 +9,6 @@ "#| default_exp visualizations" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "a4_dims = (11.7, 8.27)\n", - "a4_width_no_margin = 10.5" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import seaborn as sns\n", - "import matplotlib\n", - "import matplotlib.cm\n", - "import matplotlib.colors\n", - "import matplotlib.pyplot as plt\n", - "\n", - "class AlphaPeptColorMap():\n", - " def __init__(self):\n", - "\n", - " #colorlist = [\"#3FC5F0\", \"#42DEE1\", \"#7BEDC5\", \"#FFD479\", \"#16212B\"]\n", - " colorlist = [\"#3FC5F0\",\"#16212B\", \"#FFD479\", \"#42DEE1\", \"#7BEDC5\" ]\n", - " self.colorlist = [matplotlib.colors.to_rgba(x) for x in colorlist]\n", - " self.colorlist_hex = colorlist\n", - " self.colormap_linear = matplotlib.colors.LinearSegmentedColormap.from_list(\"alphapept\",self.colorlist)\n", - " self.colormap_discrete = matplotlib.colors.LinearSegmentedColormap.from_list(\"alphapept\",self.colorlist, N=5)\n", - " self.seaborn_mapname_linear = None\n", - " self.seaborn_mapname_linear_cut = None\n", - " \n", - "\n", - "class CmapRegistrator():\n", - " def __init__(self):\n", - " self._existing_matplotlib_cmaps = None\n", - " self._define_existing_cmaps()\n", - " \n", - " def _define_existing_cmaps(self):\n", - " self._existing_matplotlib_cmaps = [name for name in plt.colormaps() if not name.endswith('_r')]\n", - "\n", - " def register_colormap(self, name, colorlist):\n", - " linmap = matplotlib.colors.LinearSegmentedColormap.from_list(name, colorlist)\n", - " matplotlib.cm.register_cmap(name, linmap)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "import directlfq.normalization as lfq_norm\n", - "import directlfq.protein_intensity_estimation as lfq_protint\n", - "import matplotlib.pyplot as plt\n", - "\n", - "class IonTraceCompararisonPlotter():\n", - " def __init__(self, proteome_df, selected_protein, axis_unnormed, axis_normed):\n", - " self._proteome_df = proteome_df\n", - " self._selected_protein = selected_protein\n", - " self._protein_df_before_norm = None\n", - " self._protein_df_after_norm = None\n", - " \n", - " self.axis_unnormed = axis_unnormed\n", - " self.axis_normed = axis_normed\n", - "\n", - " self._prepare_data_and_plot_ion_traces_before_and_after_normalization()\n", - "\n", - " def _prepare_data_and_plot_ion_traces_before_and_after_normalization(self):\n", - " self._define_protein_dataframes()\n", - " self._plot_before_norm()\n", - " self._plot_after_norm()\n", - "\n", - " def _define_protein_dataframes(self):\n", - " self._define_protein_df_before_norm()\n", - " self._define_protein_df_after_norm()\n", - "\n", - " def _define_protein_df_before_norm(self):\n", - " self._protein_df_before_norm = pd.DataFrame(self._proteome_df.loc[self._selected_protein])\n", - " self._protein_df_before_norm = self._protein_df_before_norm.dropna(axis='columns', how='all')\n", - " \n", - " def _define_protein_df_after_norm(self):\n", - " self._protein_df_after_norm = lfq_norm.NormalizationManagerProtein(self._protein_df_before_norm.copy(), num_samples_quadratic = 10).complete_dataframe\n", - " self._protein_df_after_norm = self._protein_df_after_norm.dropna(axis='columns', how='all')\n", - "\n", - " def _plot_before_norm(self):\n", - " IonTraceVisualizer(self._protein_df_before_norm,ax= self.axis_unnormed)\n", - " \n", - " def _plot_after_norm(self):\n", - " visualizer = IonTraceVisualizer(self._protein_df_after_norm, ax=self.axis_normed)\n", - " median_list = lfq_protint.get_list_with_protein_value_for_each_sample(self._protein_df_after_norm, min_nonan=1)\n", - " visualizer.add_median_trace(median_list)\n", - "\n", - "\n", - "class IonTraceCompararisonPlotterNoDirectLFQTrace(IonTraceCompararisonPlotter):\n", - " def __init__(self, proteome_df, selected_protein, ax):\n", - " self._proteome_df = proteome_df\n", - " self._selected_protein = selected_protein\n", - " self._protein_df_before_norm = None\n", - " self._protein_df_after_norm = None\n", - " \n", - " self.axis_normed = ax\n", - " \n", - " self._prepare_data_and_plot_ion_traces_before_and_after_normalization()\n", - "\n", - " \n", - " def _prepare_data_and_plot_ion_traces_before_and_after_normalization(self):\n", - " self._define_protein_dataframes()\n", - " self._plot_after_norm()\n", - "\n", - " def _plot_after_norm(self):\n", - " visualizer = IonTraceVisualizer(self._protein_df_before_norm, ax=self.axis_normed)\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import seaborn as sns\n", - "import matplotlib.cm\n", - "import numpy as np\n", - "\n", - "class IonTraceVisualizer():\n", - " def __init__(self, protein_df, ax):\n", - " self._protein_df = protein_df\n", - " self._plot_df = None\n", - " self._num_samples = None\n", - " self._ax = ax\n", - " self._define_inputs_and_plot_ion_traces()\n", - " \n", - " def _define_inputs_and_plot_ion_traces(self):\n", - " self._define_num_samples()\n", - " self._define_prepared_dataframe()\n", - " self._plot_ion_traces()\n", - "\n", - " def _define_num_samples(self):\n", - " self._num_samples = len(self._protein_df.columns)\n", - "\n", - " def _plot_ion_traces(self):\n", - " plot_values = self._plot_df.values #row contains intensity trace\n", - " for idx in range(plot_values.shape[0]):\n", - " x_values = np.array(range(plot_values.shape[1]))\n", - " y_values = plot_values[idx]\n", - " nan_mask = np.isfinite(y_values)\n", - " self._ax.plot(x_values[nan_mask], y_values[nan_mask],color='grey', alpha=0.5)\n", - " self._ax.scatter(x_values[nan_mask], y_values[nan_mask], color='grey', marker = 'o', s = 11)\n", - " self._ax.set_xticks(range(self._num_samples))\n", - " self._annotate_x_ticks(sample_names=self._protein_df.columns)\n", - "\n", - " def _define_prepared_dataframe(self):\n", - " #drop all rows that contain less than 1 non nan value\n", - " self._plot_df = self._protein_df.copy()\n", - " self._plot_df = self._plot_df.dropna(axis='rows', thresh=1)\n", - " self._plot_df.columns = range(self._num_samples)\n", - " #self._plot_df = self._plot_df.T\n", - "\n", - " def add_median_trace(self, list_of_median_values):\n", - " sns.lineplot(x = range(len(list_of_median_values)), y = list_of_median_values, ax=self._ax,color='black', linewidth=3)\n", - " \n", - " #function that annotates x ticks of an axis with the sample names\n", - " def _annotate_x_ticks(self, sample_names):\n", - " self._ax.set_xticklabels(sample_names, rotation=90)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import seaborn as sns\n", - "\n", - "class MultiOrganismMultiMethodBoxPlot():\n", - " def __init__(self, method_ratio_results_table, ax, organisms_to_plot, fcs_to_expect):\n", - " self._method_ratio_results_table = method_ratio_results_table\n", - " self._colorlist_hex =['#bad566', '#325e7a', '#ffd479'] + AlphaPeptColorMap().colorlist_hex\n", - " self._fcs_to_expect = fcs_to_expect\n", - " self._organisms_to_plot = organisms_to_plot\n", - " \n", - " self.ax = ax\n", - "\n", - " self.plot_boxplot()\n", - " self._add_expected_fold_changes()\n", - "\n", - " def plot_boxplot(self):\n", - " color_palette = sns.color_palette(self._colorlist_hex, n_colors=len(self._fcs_to_expect))\n", - " sns.violinplot(data=self._method_ratio_results_table, x=\"method\", y = \"log2fc\", hue= \"organism\", palette=color_palette, hue_order=self._organisms_to_plot, ax=self.ax)\n", - " \n", - " def _add_expected_fold_changes(self):\n", - " if self._fcs_to_expect is not None:\n", - " for idx, fc in enumerate(self._fcs_to_expect):\n", - " color = self._colorlist_hex[idx]\n", - " self.ax.axhline(fc, color = color)\n", - " \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import itertools\n", - "\n", - "def plot_withincond_fcs(normed_intensity_df, cut_extremes = True):\n", - " \"\"\"takes a normalized intensity dataframe and plots the fold change distribution between all samples. Column = sample, row = ion\"\"\"\n", - "\n", - " samplecombs = list(itertools.combinations(normed_intensity_df.columns, 2))\n", - "\n", - " for spair in samplecombs:#compare all pairs of samples\n", - " s1 = spair[0]\n", - " s2 = spair[1]\n", - " diff_fcs = normed_intensity_df[s1].to_numpy() - normed_intensity_df[s2].to_numpy() #calculate fold changes by subtracting log2 intensities of both samples\n", - "\n", - " if cut_extremes:\n", - " cutoff = max(abs(np.nanquantile(diff_fcs,0.025)), abs(np.nanquantile(diff_fcs, 0.975))) #determine 2.5% - 97.5% interval, i.e. remove extremes\n", - " range = (-cutoff, cutoff)\n", - " else:\n", - " range = None\n", - " plt.hist(diff_fcs,80,density=True, histtype='step',range=range) #set the cutoffs to focus the visualization\n", - " plt.xlabel(\"log2 peptide fcs\")\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import matplotlib.pyplot as plt\n", - "import itertools\n", - "\n", - "def plot_relative_to_median_fcs(normed_intensity_df):\n", - "\n", - " median_intensities = normed_intensity_df.median(axis=1)\n", - " median_intensities = median_intensities.to_numpy()\n", - " \n", - " diff_fcs = []\n", - " for col in normed_intensity_df.columns:\n", - " median_fcs = normed_intensity_df[col].to_numpy() - median_intensities\n", - " diff_fcs.append(np.nanmedian(median_fcs))\n", - " plt.hist(diff_fcs,80,density=True, histtype='step')\n", - " plt.xlabel(\"log2 peptide fcs\")\n", - " plt.show()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -294,6 +26,7 @@ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import directlfq.utils as lfq_utils\n", + "import directlfq.visualizations as lfq_viz\n", "\n", "def test_that_iontracevisualized_produces_desired_plot():\n", " example_prots = \"../test_data/unit_tests/protein_normalization/example_proteins.tsv\"\n", @@ -302,7 +35,7 @@ " protein_df = protein_df.loc[\"A0A024R4E5\"]\n", "\n", " ax = plt.subplot()\n", - " pviz = IonTraceVisualizer(protein_df, ax)\n", + " pviz = lfq_viz.IonTraceVisualizer(protein_df, ax)\n", " pviz.add_median_trace([17 for x in range(len(protein_df.columns))])\n", "\n", " assert len(ax.lines) == len(protein_df.index)+1\n" @@ -339,13 +72,14 @@ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import directlfq.utils as lfq_utils\n", + "import directlfq.visualizations as lfq_viz\n", "\n", "def test_that_iontracecomparisonplotter_produces_desired_plots():\n", " example_prots = \"../test_data/unit_tests/protein_normalization/example_proteins.tsv\"\n", " _, axes = plt.subplots(1, 2)\n", " protein_df = pd.read_csv(example_prots, sep = \"\\t\")\n", " protein_df = lfq_utils.index_and_log_transform_input_df(protein_df)\n", - " complotter = IonTraceCompararisonPlotter(protein_df, selected_protein=\"A0A024R4E5\",axis_normed=axes[0],axis_unnormed= axes[1])\n", + " complotter = lfq_viz.IonTraceCompararisonPlotter(protein_df, selected_protein=\"A0A024R4E5\",axis_normed=axes[0],axis_unnormed= axes[1])\n", " assert len(complotter.axis_unnormed.lines) == len(protein_df.loc[\"A0A024R4E5\"].index)\n", " assert len(complotter.axis_normed.lines) == len(protein_df.loc[\"A0A024R4E5\"].index)+1\n" ] @@ -421,7 +155,8 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "cmap = AlphaPeptColorMap()\n" + "import directlfq.visualizations as lfq_viz\n", + "cmap = lfq_viz.AlphaPeptColorMap()\n" ] }, { @@ -483,6 +218,27 @@ "sns.lineplot(x = [1, 2, 3], y = 3*np.array([1, 2, 3]))\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/nbdev_nbs/06_benchmarking.ipynb b/nbdev_nbs/06_benchmarking.ipynb index 85bb5d3..c656fc3 100644 --- a/nbdev_nbs/06_benchmarking.ipynb +++ b/nbdev_nbs/06_benchmarking.ipynb @@ -9,809 +9,6 @@ "#| default_exp benchmarking" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "\n", - "def plot_lines(protvals, log = True):\n", - " \"\"\"plot peptide profiles for a protein\"\"\"\n", - " colors = plt.cm.tab20c(np.linspace(0,1,protvals.shape[0]))\n", - " #cmap = plt.get_cmap(\"tab20c\")\n", - " idx = 0\n", - " for row in protvals:\n", - " if not log:\n", - " row = 2**row\n", - " plt.plot(row, c= colors[idx])\n", - " idx+=1\n", - " median_row = np.nanmedian(protvals, axis=0)\n", - " print(median_row)\n", - " plt.plot(median_row, c = 'black',linewidth =3 )\n", - " plt.show()\n", - "\n", - "def plot_points(protvals, log = True):\n", - " colors = plt.cm.tab20c(np.linspace(0,1,protvals.shape[0]))\n", - " #cmap = plt.get_cmap(\"tab20c\")\n", - " idx = 0\n", - " for row in protvals:\n", - " if not log:\n", - " row = 2**row\n", - " x_coord = list(range(len(row)))\n", - " plt.scatter(x_coord,row, c= colors[idx])\n", - " idx+=1\n", - "\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import pandas as pd\n", - "def get_tps_fps(result_df, prot2org_file, thresh = 0.05, fc_thresh = 0.3):\n", - " annotated = annotate_dataframe(result_df, prot2org_file)\n", - " condpairs = result_df[\"condpair\"].drop_duplicates()\n", - "\n", - "\n", - " for condpair in condpairs:\n", - " annotated_condpair = annotated[annotated[\"condpair\"]==condpair]\n", - " num_tps = sum(annotated_condpair[\"TP\"])\n", - " num_fps = sum(annotated_condpair[\"FP\"])\n", - " annotated_fcfilt = annotated_condpair[annotated[\"log2fc\"] >fc_thresh]\n", - " num_regulated_prots = sum(annotated_fcfilt[\"fdr\"]" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAHpCAYAAABtI12YAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvIElEQVR4nO3deXiTdb7//1dYmrbQRVroIi1QRMpWEQSsjFjZKjhccuTMuKBWx8GtqNCjaGdULIynOnoEl7KMB+mMyjDjKHjc4ABKOQpVKCCgtT/pgEXtYlVaWiBge3//8EeuibRAQ9s7yef5uK5cF7lz5847t73i80ru3HFYlmUJAADAEB3sHgAAAKA9ET8AAMAoxA8AADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMErAx49lWaqtrRWnMwIAAJIB8XPo0CFFRETo0KFDdo8CAAB8QMDHDwAAwL8ifgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUTrZPYC/KSsrU3V1td1jnFZ0dLQSExPtHgMAAJ9D/LRAWVmZkgcM0JHDh+0e5bRCQkP1eXExAQQAwM8QPy1QXV2tI4cPa/oDTyomsa/d4zSrsqxUrzxxv6qrq4kfAAB+hvjxQkxiX/XsN8juMQAAgBc44BkAABiF+AEAAEYhfgAAgFGIHwAAYBSfiZ/HH39cDodDs2bNci87evSoMjMzFRUVpa5du2ratGmqrKy0b0gAAOD3fCJ+tm7dqqVLlyolJcVj+ezZs/Xmm2/q1VdfVUFBgb755htdffXVNk0JAAACge3xU1dXp+nTp+uFF17QOeec415eU1OjZcuW6emnn9bYsWM1fPhwLV++XJs3b1ZhYWGz23O5XKqtrfW4AAAAnGB7/GRmZurKK6/U+PHjPZYXFRXp+PHjHsuTk5OVmJioLVu2NLu93NxcRUREuC8JCQltNjsAAPA/tsbPypUrtX37duXm5p50W0VFhYKCghQZGemxPCYmRhUVFc1uMzs7WzU1Ne7LgQMHWntsAADgx2w7w/OBAwd07733at26dQoODm617TqdTjmdzlbbHgAACCy2vfNTVFSkqqoqDRs2TJ06dVKnTp1UUFCgZ599Vp06dVJMTIyOHTumgwcPetyvsrJSsbGx9gwNAAD8nm3v/IwbN067d+/2WHbLLbcoOTlZDzzwgBISEtS5c2dt2LBB06ZNkySVlJSorKxMqampdowMAAACgG3xExYWpsGDB3ss69Kli6KiotzLb731VmVlZalbt24KDw/X3XffrdTUVF188cV2jAwAAAKAT/+q+4IFC9ShQwdNmzZNLpdL6enpWrRokd1jAQAAP+ZT8bNx40aP68HBwcrLy1NeXp49AwEAgIBj+3l+AAAA2hPxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACjED8AAMAoxA8AADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMArxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACjED8AAMAoxA8AADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMArxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACjED8AAMAoxA8AADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMArxAwAAjGJr/CxevFgpKSkKDw9XeHi4UlNT9e6777pvT0tLk8Ph8LjccccdNk4MAAD8XSc7H7xnz556/PHH1a9fP1mWpT//+c+66qqrtGPHDg0aNEiSNGPGDM2bN899n9DQULvGBQAAAcDW+JkyZYrH9ccee0yLFy9WYWGhO35CQ0MVGxtrx3gAACAA+cwxPw0NDVq5cqXq6+uVmprqXv7KK68oOjpagwcPVnZ2tg4fPnzK7bhcLtXW1npcAAAATrD1nR9J2r17t1JTU3X06FF17dpVq1at0sCBAyVJ119/vXr16qX4+Hjt2rVLDzzwgEpKSvT66683u73c3Fzl5OS01/gAAMDP2B4//fv3186dO1VTU6N//OMfysjIUEFBgQYOHKjbbrvNvd6QIUMUFxencePGqbS0VH379m1ye9nZ2crKynJfr62tVUJCQps/DwAA4B9sj5+goCCdd955kqThw4dr69ateuaZZ7R06dKT1h01apQkae/evc3Gj9PplNPpbLuBAQCAX/OZY35OaGxslMvlavK2nTt3SpLi4uLacSIAABBIbH3nJzs7W5MmTVJiYqIOHTqkFStWaOPGjVq7dq1KS0u1YsUKTZ48WVFRUdq1a5dmz56tMWPGKCUlxc6xAQCAH7M1fqqqqnTTTTepvLxcERERSklJ0dq1azVhwgQdOHBA69ev18KFC1VfX6+EhARNmzZNDz30kJ0jAwAAP2dr/CxbtqzZ2xISElRQUNCO0wAAABP43DE/AAAAbYn4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUWyNn8WLFyslJUXh4eEKDw9Xamqq3n33XfftR48eVWZmpqKiotS1a1dNmzZNlZWVNk4MAAD8na3x07NnTz3++OMqKirStm3bNHbsWF111VX69NNPJUmzZ8/Wm2++qVdffVUFBQX65ptvdPXVV9s5MgAA8HOd7HzwKVOmeFx/7LHHtHjxYhUWFqpnz55atmyZVqxYobFjx0qSli9frgEDBqiwsFAXX3xxk9t0uVxyuVzu67W1tW33BAAAgN/xmWN+GhoatHLlStXX1ys1NVVFRUU6fvy4xo8f714nOTlZiYmJ2rJlS7Pbyc3NVUREhPuSkJDQHuMDAAA/YXv87N69W127dpXT6dQdd9yhVatWaeDAgaqoqFBQUJAiIyM91o+JiVFFRUWz28vOzlZNTY37cuDAgTZ+BgAAwJ/Y+rGXJPXv3187d+5UTU2N/vGPfygjI0MFBQVeb8/pdMrpdLbihAAAIJDYHj9BQUE677zzJEnDhw/X1q1b9cwzz+iaa67RsWPHdPDgQY93fyorKxUbG2vTtAAAwN/Z/rHXzzU2Nsrlcmn48OHq3LmzNmzY4L6tpKREZWVlSk1NtXFCAADgz2x95yc7O1uTJk1SYmKiDh06pBUrVmjjxo1au3atIiIidOuttyorK0vdunVTeHi47r77bqWmpjb7TS8AAIDTsTV+qqqqdNNNN6m8vFwRERFKSUnR2rVrNWHCBEnSggUL1KFDB02bNk0ul0vp6elatGiRnSMDAAA/Z2v8LFu27JS3BwcHKy8vT3l5ee00EQAACHQ+d8wPAABAWyJ+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGCUTnYPAKD1lJWVqbq62u4xzkh0dLQSExPtHgOAgYgfIECUlZUpecAAHTl82O5RzkhIaKg+Ly4mgAC0O+IHCBDV1dU6cviwpj/wpGIS+9o9zilVlpXqlSfuV3V1NfEDoN0RP0CAiUnsq579Btk9BgD4LA54BgAARiF+AACAUYgfAABgFFvjJzc3VyNGjFBYWJh69OihqVOnqqSkxGOdtLQ0ORwOj8sdd9xh08QAAMDf2Ro/BQUFyszMVGFhodatW6fjx49r4sSJqq+v91hvxowZKi8vd1/++Mc/2jQxAADwd7Z+22vNmjUe1/Pz89WjRw8VFRVpzJgx7uWhoaGKjY1t7/EAAEAA8qljfmpqaiRJ3bp181j+yiuvKDo6WoMHD1Z2drYOn+Ikbi6XS7W1tR4XAACAE3zmPD+NjY2aNWuWRo8ercGDB7uXX3/99erVq5fi4+O1a9cuPfDAAyopKdHrr7/e5HZyc3OVk5PTXmMDAAA/4zPxk5mZqT179uiDDz7wWH7bbbe5/z1kyBDFxcVp3LhxKi0tVd++J5/FNjs7W1lZWe7rtbW1SkhIaLvBAQCAX/GJ+Jk5c6beeustbdq0ST179jzluqNGjZIk7d27t8n4cTqdcjqdbTInAADwf7bGj2VZuvvuu7Vq1Spt3LhRffr0Oe19du7cKUmKi4tr4+kAAEAgsjV+MjMztWLFCr3xxhsKCwtTRUWFJCkiIkIhISEqLS3VihUrNHnyZEVFRWnXrl2aPXu2xowZo5SUFDtHBwAAfsrW+Fm8eLGkn05k+K+WL1+um2++WUFBQVq/fr0WLlyo+vp6JSQkaNq0aXrooYdsmBYAAAQC2z/2OpWEhAQVFBS00zQAAMAEPnWeHwAAgLZG/AAAAKMQPwAAwCjEDwAAMArxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACjeBU/SUlJ+u67705afvDgQSUlJZ31UAAAAG3Fq/jZv3+/GhoaTlrucrn09ddfn/VQAAAAbaVFP2z6P//zP+5/r127VhEREe7rDQ0N2rBhg3r37t1qwwEAALS2FsXP1KlTJUkOh0MZGRket3Xu3Fm9e/fWf/3Xf7XacAAAAK2tRfHT2NgoSerTp4+2bt2q6OjoNhkKAACgrbQofk7Yt29fa88BAADQLryKH0nasGGDNmzYoKqqKvc7Qie8+OKLZz0YAABAW/AqfnJycjRv3jxddNFFiouLk8PhaO25AAAA2oRX8bNkyRLl5+frxhtvbO15AAAA2pRX5/k5duyYLrnkktaeBQAAoM15FT+//e1vtWLFitaeBQAAoM159bHX0aNH9ac//Unr169XSkqKOnfu7HH7008/3SrDAQAAtDav4mfXrl0aOnSoJGnPnj0et3HwMwAA8GVexc/777/f2nMAAAC0C6+O+QEAAPBXXr3zc/nll5/y46333nvP64EAAADaklfxc+J4nxOOHz+unTt3as+ePSf94CkAAIAv8Sp+FixY0OTyRx99VHV1dWc1EAAAQFtq1WN+brjhBn7XCwAA+LRWjZ8tW7YoODi4NTcJAADQqrz62Ovqq6/2uG5ZlsrLy7Vt2zY9/PDDrTIYAABAW/AqfiIiIjyud+jQQf3799e8efM0ceLEVhkMAACgLXgVP8uXL2/tOQAAANrFWR3zU1RUpJdfflkvv/yyduzY0VozAQCAM5SWlqZZs2ZJknr37q2FCxfaOo8/8Oqdn6qqKl177bXauHGjIiMjJUkHDx7U5ZdfrpUrV6p79+6tOSMAADgDW7duVZcuXc5o3d69e2vWrFnucDKJV+/83H333Tp06JA+/fRTff/99/r++++1Z88e1dbW6p577mntGQEAwBno3r27QkND7R7D53kVP2vWrNGiRYs0YMAA97KBAwcqLy9P7777bqsNBwAAzty/fuxlWZYeffRRJSYmyul0Kj4+3v0GRVpamr788kvNnj1bDofjlD9ZdUJ+fr4iIyO1du1aDRgwQF27dtUVV1yh8vJy9zpbt27VhAkTFB0drYiICF122WXavn27x3YcDoeWLl2qX/7ylwoNDdWAAQO0ZcsW7d27V2lpaerSpYsuueQSlZaWetzvjTfe0LBhwxQcHKykpCTl5OToxx9/9Go/eRU/jY2N6ty580nLO3furMbGRq8GAQAAree1117TggULtHTpUn3xxRdavXq1hgwZIkl6/fXX1bNnT82bN0/l5eUeAXMqhw8f1lNPPaWXXnpJmzZtUllZme677z737YcOHVJGRoY++OADFRYWql+/fpo8ebIOHTrksZ358+frpptu0s6dO5WcnKzrr79et99+u7Kzs7Vt2zZZlqWZM2e61/+///s/3XTTTbr33nv12WefaenSpcrPz9djjz3m1b7x6pifsWPH6t5779Vf//pXxcfHS5K+/vprzZ49W+PGjfNqEAAA0HrKysoUGxur8ePHq3PnzkpMTNTIkSMlSd26dVPHjh0VFham2NjYM97m8ePHtWTJEvXt21eSNHPmTM2bN899+9ixYz3W/9Of/qTIyEgVFBTol7/8pXv5Lbfcol//+teSpAceeECpqal6+OGHlZ6eLkm69957dcstt7jXz8nJ0YMPPuj+/dCkpCTNnz9fc+bM0dy5c1uyWyR5+c7P888/r9raWvXu3Vt9+/ZV37591adPH9XW1uq555474+3k5uZqxIgRCgsLU48ePTR16lSVlJR4rHP06FFlZmYqKipKXbt21bRp01RZWenN2AAAGONXv/qVjhw5oqSkJM2YMUOrVq3y+mOiE0JDQ93hI0lxcXGqqqpyX6+srNSMGTPUr18/RUREKDw8XHV1dSorK/PYTkpKivvfMTExkuR+V+rEsqNHj6q2tlaS9Mknn2jevHnq2rWr+zJjxgyVl5fr8OHDLX4eXr3zk5CQoO3bt2v9+vX6/PPPJUkDBgzQ+PHjW7SdgoICZWZmasSIEfrxxx/1u9/9ThMnTtRnn33mPlp99uzZevvtt/Xqq68qIiJCM2fO1NVXX60PP/zQm9EBADBCQkKCSkpKtH79eq1bt0533XWXnnzySRUUFDR56MqZ+Pn9HA6HLMtyX8/IyNB3332nZ555Rr169ZLT6VRqaqqOHTvW7HZOHG/U1LITh9LU1dUpJyfnpF+YkOTVz2q1KH7ee+89zZw5U4WFhQoPD9eECRM0YcIESVJNTY0GDRqkJUuW6NJLLz2j7a1Zs8bjen5+vnr06KGioiKNGTNGNTU1WrZsmVasWOF+K2358uUaMGCACgsLdfHFF5+0TZfLJZfL5b5+ohoBADBNSEiIpkyZoilTpigzM1PJycnavXu3hg0bpqCgIDU0NLTq43344YdatGiRJk+eLEk6cOCAqqurz3q7w4YNU0lJic4777yz3pbUwo+9Fi5cqBkzZig8PPyk2yIiInT77bfr6aef9nqYmpoaST99Fin9dBLF48ePe7yjlJycrMTERG3ZsqXJbeTm5ioiIsJ9SUhI8HoeAAD8VX5+vpYtW6Y9e/bon//8p15++WWFhISoV69ekn76ZtimTZv09ddft0qgSFK/fv300ksvqbi4WB999JGmT5+ukJCQs97uI488or/85S/KycnRp59+quLiYq1cuVIPPfSQV9trUfx88sknuuKKK5q9feLEiSoqKvJqkMbGRs2aNUujR4/W4MGDJUkVFRUKCgpyn0jxhJiYGFVUVDS5nezsbNXU1LgvBw4c8GoeAAD8WWRkpF544QWNHj1aKSkpWr9+vd58801FRUVJkubNm6f9+/erb9++rXZy4mXLlumHH37QsGHDdOONN+qee+5Rjx49znq76enpeuutt/S///u/GjFihC6++GItWLDAHXIt1aKPvSorK0/5OWGnTp307bffejVIZmam9uzZow8++MCr+5/gdDrldDrPahsAAPiLjRs3uv+9f/9+97+nTp2qqVOnNnu/iy++WJ988skZP87NN9+sm2++2WPZ1KlTPY75ufDCC7V161aPdf793//d4/q/ri/99A7Uz5elpaWdtCw9Pd39bbCz1aJ3fs4991zt2bOn2dt37dqluLi4Fg8xc+ZMvfXWW3r//ffVs2dP9/LY2FgdO3ZMBw8e9Fi/srKyRV/NAwAAOKFF8TN58mQ9/PDDOnr06Em3HTlyRHPnzvX4Hv/pnDiJ0apVq/Tee++pT58+HrcPHz5cnTt31oYNG9zLSkpKVFZWptTU1JaMDgAATmHSpEkeXyX/18t//ud/2j1eq2rRx14PPfSQXn/9dZ1//vmaOXOm+vfvL0n6/PPPlZeXp4aGBv3+978/4+1lZmZqxYoVeuONNxQWFuY+jiciIkIhISGKiIjQrbfeqqysLHXr1k3h4eG6++67lZqa2uQ3vQAAgHf++7//W0eOHGnythNfRAoULYqfmJgYbd68WXfeeaeys7Pdn8c5HA6lp6crLy/PfbKiM7F48WJJP32296+WL1/u/lxxwYIF6tChg6ZNmyaXy6X09HQtWrSoJWMDAIDTOPfcc+0eod20+CSHvXr10jvvvKMffvhBe/fulWVZ6tevn84555wWP/jPD2ZqSnBwsPLy8pSXl9fi7QMAAPycV2d4lqRzzjlHI0aMaM1ZAAAA2pxXv+0FAADgr4gfAABgFK8/9gIAAL6vrKys1X6+4kxER0crMTGx3R7PG8QPAAABqqysTMkDBujI4cPt9pghoaH6vLjYpwOI+AEAIEBVV1fryOHDmv7Ak4pJ7Nvmj1dZVqpXnrhf1dXVLYqfiooKPfbYY3r77bf19ddfq0ePHho6dKhmzZqlcePGtfqcxA8AAAEuJrGvevYbZPcYTdq/f79Gjx6tyMhIPfnkkxoyZIiOHz+utWvXKjMzU59//nmrPybxAwAAbHPXXXfJ4XDo448/VpcuXdzLBw0apN/85jdt8ph82wsAANji+++/15o1a5SZmekRPidERka2yeMSPwAAwBYnfikiOTm5XR+X+AEAALY4k5+5agsc8wPANsXFxXaPcFr+cM4SwF/169dPDoejTQ5qPhXiB0C7q/3+W0nSDTfcYPMkp+cP5ywB/FW3bt2Unp6uvLw83XPPPScd93Pw4ME2Oe6H+AHQ7o7U1UqSrrz99+qfMtzmaZrn7TlLAF9TWVbqs4+Tl5en0aNHa+TIkZo3b55SUlL0448/at26dVq8eHGbvENM/ACwTVR8L5899wgQCKKjoxUSGqpXnri/3R4zJDRU0dHRZ7x+UlKStm/frscee0z/8R//ofLycnXv3l3Dhw/X4sWL22RG4gcAgACVmJioz4uLff63veLi4vT888/r+eefb6OpPBE/AAAEsMTERD62/Rm+6g4AAIxC/AAAAKMQPwAAwCjEDwAAMAoHPAPAaXAmaiCwED8A0AzORA0EJuIHAJrBmaiBwET8AMBpcCZqILBwwDMAADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMArxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACjED8AAMAoxA8AADAK8QMAAIxia/xs2rRJU6ZMUXx8vBwOh1avXu1x+8033yyHw+FxueKKK+wZFgAABARb46e+vl4XXHCB8vLyml3niiuuUHl5ufvy17/+tR0nBAAAgaaTnQ8+adIkTZo06ZTrOJ1OxcbGnvE2XS6XXC6X+3ptba3X8wGAPykuLrZ7hNOKjo5WYmKi3WPAcLbGz5nYuHGjevTooXPOOUdjx47VH/7wB0VFRTW7fm5urnJyctpxQgCwV+3330qSbrjhBpsnOb2Q0FB9XlxMAMFWPh0/V1xxha6++mr16dNHpaWl+t3vfqdJkyZpy5Yt6tixY5P3yc7OVlZWlvt6bW2tEhIS2mtkAGh3R+p+eof7ytt/r/4pw22epnmVZaV65Yn7VV1dTfzAVj4dP9dee63730OGDFFKSor69u2rjRs3aty4cU3ex+l0yul0tteIAOAzouJ7qWe/QXaPAfg8v/qqe1JSkqKjo7V37167RwEAAH7Kr+Lnq6++0nfffae4uDi7RwEAAH7K1o+96urqPN7F2bdvn3bu3Klu3bqpW7duysnJ0bRp0xQbG6vS0lLNmTNH5513ntLT022cGgAA+DNb42fbtm26/PLL3ddPHKickZGhxYsXa9euXfrzn/+sgwcPKj4+XhMnTtT8+fM5pgcAAHjN1vhJS0uTZVnN3r527dp2nAYAAJjAr475AQAAOFs+/VV3AEDg4UzUsBvxAwBoF5yJGr6C+AEAtAvORA1fQfwAANoVZ6KG3TjgGQAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABjF1vjZtGmTpkyZovj4eDkcDq1evdrjdsuy9MgjjyguLk4hISEaP368vvjiC3uGBQAAAcHW+Kmvr9cFF1ygvLy8Jm//4x//qGeffVZLlizRRx99pC5duig9PV1Hjx5t50kBAECg6GTng0+aNEmTJk1q8jbLsrRw4UI99NBDuuqqqyRJf/nLXxQTE6PVq1fr2muvbc9RAQBAgLA1fk5l3759qqio0Pjx493LIiIiNGrUKG3ZsqXZ+HG5XHK5XO7rtbW1bT4rAl9ZWZmqq6vtHuOUiouL7R4BAPyCz8ZPRUWFJCkmJsZjeUxMjPu2puTm5ionJ6dNZ4NZysrKlDxggI4cPmz3KGekrq7O7hEAwKf5bPx4Kzs7W1lZWe7rtbW1SkhIsHEi+Lvq6modOXxY0x94UjGJfe0ep1nFHxfo3T8/wzFxAHAaPhs/sbGxkqTKykrFxcW5l1dWVmro0KHN3s/pdMrpdLb1eDBQTGJf9ew3yO4xmlVZVmr3CADgF3z2PD99+vRRbGysNmzY4F5WW1urjz76SKmpqTZOBgAA/Jmt7/zU1dVp79697uv79u3Tzp071a1bNyUmJmrWrFn6wx/+oH79+qlPnz56+OGHFR8fr6lTp9o3NAAA8Gu2xs+2bdt0+eWXu6+fOFYnIyND+fn5mjNnjurr63Xbbbfp4MGD+sUvfqE1a9YoODjYrpEBAICfszV+0tLSZFlWs7c7HA7NmzdP8+bNa8epAABAIPPZY34AAADaAvEDAACM4rNfdcfZ84cz/kZHRysxMdHuMQAABiF+AlDt999Kkm644QabJzm9kNBQfV5cTAABANoN8ROAjtT99HtmV97+e/VPGW7zNM2rLCvVK0/cr+rqauIHANBuiJ8AFhXfy6fPSAwAgB044BkAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYxafj59FHH5XD4fC4JCcn2z0WAADwY53sHuB0Bg0apPXr17uvd+rk8yMDAAAf5vMl0alTJ8XGxp7x+i6XSy6Xy329tra2LcYCAAB+yqc/9pKkL774QvHx8UpKStL06dNVVlZ2yvVzc3MVERHhviQkJLTTpAAAwB/4dPyMGjVK+fn5WrNmjRYvXqx9+/bp0ksv1aFDh5q9T3Z2tmpqatyXAwcOtOPEAADA1/n0x16TJk1y/zslJUWjRo1Sr1699Pe//1233nprk/dxOp1yOp3tNSIAAPAzPv3Oz89FRkbq/PPP1969e+0eBQAA+Cm/ip+6ujqVlpYqLi7O7lEAAICf8un4ue+++1RQUKD9+/dr8+bN+rd/+zd17NhR1113nd2jAQAAP+XTx/x89dVXuu666/Tdd9+pe/fu+sUvfqHCwkJ1797d7tEAAICf8un4Wblypd0jAACAAOPTH3sBAAC0NuIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYhfgBAABGIX4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQAARiF+AACAUYgfAABgFOIHAAAYxS/iJy8vT71791ZwcLBGjRqljz/+2O6RAACAn/L5+Pnb3/6mrKwszZ07V9u3b9cFF1yg9PR0VVVV2T0aAADwQz4fP08//bRmzJihW265RQMHDtSSJUsUGhqqF1980e7RAACAH+pk9wCncuzYMRUVFSk7O9u9rEOHDho/fry2bNnS5H1cLpdcLpf7ek1NjSSptrb2rOepq6uTJH31xadyHTl81ttrK5VlpZKkiv3/n0q7hNo8TfO+/WqfJKmoqMi9b31RSUmJJP67tyZ/mZU5W5e/zHnitamurq5V/t8hSWFhYXI4HK2yLZw9h2VZlt1DNOebb77Rueeeq82bNys1NdW9fM6cOSooKNBHH3100n0effRR5eTktOeYAACcUk1NjcLDw+0eA/8/n37nxxvZ2dnKyspyX29sbNT333+vqKgoHTp0SAkJCTpw4AB/hC1UW1vLvvMS+8577Dvvse+81xb7LiwsrFW2g9bh0/ETHR2tjh07qrKy0mN5ZWWlYmNjm7yP0+mU0+n0WBYZGSlJ7rccw8PDeTHwEvvOe+w777HvvMe+8x77LnD59AHPQUFBGj58uDZs2OBe1tjYqA0bNnh8DAYAAHCmfPqdH0nKyspSRkaGLrroIo0cOVILFy5UfX29brnlFrtHAwAAfsjn4+eaa67Rt99+q0ceeUQVFRUaOnSo1qxZo5iYmBZvy+l0au7cuSd9LIbTY995j33nPfad99h33mPfBT6f/rYXAABAa/PpY34AAABaG/EDAACMQvwAAACjED8AAMAoARc/eXl56t27t4KDgzVq1Ch9/PHHp1z/1VdfVXJysoKDgzVkyBC988477TSp72nJvsvPz5fD4fC4BAcHt+O0vmPTpk2aMmWK4uPj5XA4tHr16tPeZ+PGjRo2bJicTqfOO+885efnt/mcvqil+27jxo0n/d05HA5VVFS0z8A+Ijc3VyNGjFBYWJh69OihqVOnun+D7lR4vfNu3/F6F3gCKn7+9re/KSsrS3PnztX27dt1wQUXKD09XVVVVU2uv3nzZl133XW69dZbtWPHDk2dOlVTp07Vnj172nly+7V030k/nf20vLzcffnyyy/bcWLfUV9frwsuuEB5eXlntP6+fft05ZVX6vLLL9fOnTs1a9Ys/fa3v9XatWvbeFLf09J9d0JJSYnH316PHj3aaELfVFBQoMzMTBUWFmrdunU6fvy4Jk6cqPr6+mbvw+vdT7zZdxKvdwHHCiAjR460MjMz3dcbGhqs+Ph4Kzc3t8n1f/3rX1tXXnmlx7JRo0ZZt99+e5vO6Ytauu+WL19uRUREtNN0/kOStWrVqlOuM2fOHGvQoEEey6655horPT29DSfzfWey795//31LkvXDDz+0y0z+oqqqypJkFRQUNLsOr3dNO5N9x+td4AmYd36OHTumoqIijR8/3r2sQ4cOGj9+vLZs2dLkfbZs2eKxviSlp6c3u36g8mbfSVJdXZ169eqlhIQEXXXVVfr000/bY1y/x9/d2Rs6dKji4uI0YcIEffjhh3aPY7uamhpJUrdu3Zpdh7+7pp3JvpN4vQs0ARM/1dXVamhoOOnMzzExMc0eD1BRUdGi9QOVN/uuf//+evHFF/XGG2/o5ZdfVmNjoy655BJ99dVX7TGyX2vu7662tlZHjhyxaSr/EBcXpyVLlui1117Ta6+9poSEBKWlpWn79u12j2abxsZGzZo1S6NHj9bgwYObXY/Xu5Od6b7j9S7w+PzPW8A3paamevy47CWXXKIBAwZo6dKlmj9/vo2TIZD1799f/fv3d1+/5JJLVFpaqgULFuill16ycTL7ZGZmas+ePfrggw/sHsXvnOm+4/Uu8ATMOz/R0dHq2LGjKisrPZZXVlYqNja2yfvExsa2aP1A5c2++7nOnTvrwgsv1N69e9tixIDS3N9deHi4QkJCbJrKf40cOdLYv7uZM2fqrbfe0vvvv6+ePXuecl1e7zy1ZN/9HK93/i9g4icoKEjDhw/Xhg0b3MsaGxu1YcMGj2L/V6mpqR7rS9K6deuaXT9QebPvfq6hoUG7d+9WXFxcW40ZMPi7a107d+407u/OsizNnDlTq1at0nvvvac+ffqc9j783f3Em333c7zeBQC7j7huTStXrrScTqeVn59vffbZZ9Ztt91mRUZGWhUVFZZlWdaNN95oPfjgg+71P/zwQ6tTp07WU089ZRUXF1tz5861OnfubO3evduup2Cblu67nJwca+3atVZpaalVVFRkXXvttVZwcLD16aef2vUUbHPo0CFrx44d1o4dOyxJ1tNPP23t2LHD+vLLLy3LsqwHH3zQuvHGG93r//Of/7RCQ0Ot+++/3youLrby8vKsjh07WmvWrLHrKdimpftuwYIF1urVq60vvvjC2r17t3XvvfdaHTp0sNavX2/XU7DFnXfeaUVERFgbN260ysvL3ZfDhw+71+H1rmne7Dte7wJPQMWPZVnWc889ZyUmJlpBQUHWyJEjrcLCQvdtl112mZWRkeGx/t///nfr/PPPt4KCgqxBgwZZb7/9djtP7Dtasu9mzZrlXjcmJsaaPHmytX37dhumtt+Jr1///HJif2VkZFiXXXbZSfcZOnSoFRQUZCUlJVnLly9v97l9QUv33RNPPGH17dvXCg4Otrp162alpaVZ7733nj3D26ipfSbJ4++I17umebPveL0LPA7Lsqz2e58JAADAXgFzzA8AAMCZIH4AAIBRiB8AAGAU4gcAABiF+AEAAEYhfgAAgFGIHwAAYBTiBwAAGIX4AQJcWlqaZs2aJUnq3bu3Fi5caOs8AGC3TnYPAKD9bN26VV26dGnzx9m/f7/69OmjHTt2aOjQoW3+eADQEsQPYJDu3bvbPQIA2I6PvQCD/OvHXpZl6dFHH1ViYqKcTqfi4+N1zz33uNd96aWXdNFFFyksLEyxsbG6/vrrVVVV5b79hx9+0PTp09W9e3eFhISoX79+Wr58uSSpT58+kqQLL7xQDodDaWlp7fYcAeB0eOcHMNRrr72mBQsWaOXKlRo0aJAqKir0ySefuG8/fvy45s+fr/79+6uqqkpZWVm6+eab9c4770iSHn74YX322Wd69913FR0drb179+rIkSOSpI8//lgjR47U+vXrNWjQIAUFBdnyHAGgKcQPYKiysjLFxsZq/Pjx6ty5sxITEzVy5Ej37b/5zW/c/05KStKzzz6rESNGqK6uTl27dlVZWZkuvPBCXXTRRZJ+elfphBMfr0VFRSk2NrZ9nhAAnCE+9gIM9atf/UpHjhxRUlKSZsyYoVWrVunHH390315UVKQpU6YoMTFRYWFhuuyyyyT9FE2SdOedd2rlypUaOnSo5syZo82bN9vyPACgpYgfwFAJCQkqKSnRokWLFBISorvuuktjxozR8ePHVV9fr/T0dIWHh+uVV17R1q1btWrVKknSsWPHJEmTJk3Sl19+qdmzZ+ubb77RuHHjdN9999n5lADgjPCxF2CwkJAQTZkyRVOmTFFmZqaSk5O1e/duWZal7777To8//rgSEhIkSdu2bTvp/t27d1dGRoYyMjJ06aWX6v7779dTTz3lPsanoaGhXZ8PAJwJ4gcwVH5+vhoaGjRq1CiFhobq5ZdfVkhIiHr16qXGxkYFBQXpueee0x133KE9e/Zo/vz5Hvd/5JFHNHz4cA0aNEgul0tvvfWWBgwYIEnq0aOHQkJCtGbNGvXs2VPBwcGKiIiw42kCwEn42AswVGRkpF544QWNHj1aKSkpWr9+vd58801FRUWpe/fuys/P16uvvqqBAwfq8ccf11NPPeVx/6CgIGVnZyslJUVjxoxRx44dtXLlSklSp06d9Oyzz2rp0qWKj4/XVVddZcdTBIAmOSzLsuweAgAAoL3wzg8AADAK8QMAAIxC/AAAAKMQPwAAwCjEDwAAMArxAwAAjEL8AAAAoxA/AADAKMQPAAAwCvEDAACMQvwAAACj/D/+jt5C4ZZnIgAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], diff --git a/nbdev_nbs/07_testfile_handling.ipynb b/nbdev_nbs/07_testfile_handling.ipynb deleted file mode 100644 index 5ba8d40..0000000 --- a/nbdev_nbs/07_testfile_handling.ipynb +++ /dev/null @@ -1,162 +0,0 @@ -{ - "cells": [ - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "---\n", - "output-file: testfile_handling.html\n", - "title: Downloading Testfiles\n", - "\n", - "---\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| default_exp testfile_handling" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#| export\n", - "import yaml\n", - "import glob\n", - "import subprocess\n", - "import sys\n", - "import os\n", - "import wget\n", - "import tarfile\n", - "from zipfile import ZipFile\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "class TestFolderDownloader():\n", - " def __init__(self, test_folder, links_yaml):\n", - " self._test_folder = test_folder\n", - " self._path2link = DownloadLinkConverter(links_yaml).get_path2link_from_yaml_file()\n", - "\n", - " def download_missing_files(self):\n", - " missing_paths = self.__get_missing_paths__()\n", - " print(missing_paths)\n", - " for missing_path in missing_paths:\n", - " print(missing_path)\n", - " self.__download_and_extract_compressed_file__(missing_path)\n", - "\n", - " def __get_missing_paths__(self):\n", - " all_paths = set(self._path2link.keys())\n", - " existing_paths = self.__get_existing_paths__()\n", - " return all_paths - existing_paths\n", - "\n", - " def __download_and_extract_compressed_file__(self, path):\n", - " download_link = self.__get_download_link_from_path__(path)\n", - " absolute_path = self.__convert_relative_to_absolute_path__(path)\n", - " self.__prepare_download_directory__(absolute_path)\n", - " #download a file from a web server\n", - " wget.download(download_link, absolute_path)\n", - "\n", - " with ZipFile(absolute_path, 'r') as zipObj:\n", - " # Extract all the contents of zip file in current directory\n", - " zipObj.extractall(path=os.path.dirname(absolute_path))\n", - "\n", - " \n", - "\n", - " def __get_existing_paths__(self):\n", - " all_elements = self.__get_all_elements_in_all_subdirs__(self._test_folder)\n", - " all_filepaths = self.__filter_for_files__(all_elements)\n", - " all_filepaths_relative = self.__convert_to_relative_paths__(all_filepaths, self._test_folder)\n", - " return all_filepaths_relative\n", - "\n", - " def __get_download_link_from_path__(self, path):\n", - " link = self._path2link.get(path)\n", - " return f\"{link}/download\"\n", - "\n", - " def __convert_relative_to_absolute_path__(self, path):\n", - " return f\"{self._test_folder}/{path}\"\n", - "\n", - " @staticmethod\n", - " def __prepare_download_directory__(absolute_path):\n", - " parent_directory = os.path.dirname(absolute_path)\n", - " if not os.path.exists(parent_directory):\n", - " os.makedirs(parent_directory)\n", - "\n", - "\n", - " @staticmethod\n", - " def __get_all_elements_in_all_subdirs__(base_dir):\n", - " return glob.glob(f\"{base_dir}/**\", recursive=True)\n", - " \n", - " @staticmethod\n", - " def __filter_for_files__(list_of_paths):\n", - " return (x for x in list_of_paths if os.path.isfile(x))\n", - "\n", - " @staticmethod\n", - " def __convert_to_relative_paths__(list_of_absolute_paths, base_dir):\n", - " return {x.replace(base_dir, \".\") for x in list_of_absolute_paths}\n", - " \n", - "\n", - "\n", - "class DownloadLinkConverter():\n", - " def __init__(self, links_yaml):\n", - " self._links_yaml = links_yaml\n", - "\n", - " def get_path2link_from_yaml_file(self):\n", - " yaml_dict = self.__load_dict_from_yaml_file__(self._links_yaml)\n", - " path2link_generator = self.__convert_nested_dict_to_relpath_dict__(nested_dict=yaml_dict)\n", - " path2link_dict = {path : link for path, link in path2link_generator}\n", - " return path2link_dict\n", - "\n", - " @staticmethod\n", - " def __load_dict_from_yaml_file__(yaml_file):\n", - " stream = open(yaml_file, 'r')\n", - " return yaml.safe_load(stream)\n", - "\n", - " def __convert_nested_dict_to_relpath_dict__(self, nested_dict , rel_path_so_far = \".\"):\n", - " for path, value in nested_dict.items():\n", - " updated_path = self.__get_updated_relpath__(rel_path_so_far, path)\n", - " is_dict = self.__check_if_value_is_dict__(value)\n", - " if is_dict:\n", - " yield from self.__convert_nested_dict_to_relpath_dict__(value, updated_path)\n", - " else:\n", - " yield updated_path , value\n", - "\n", - " def __recursively_call_sub_dictionary__(self, sub_dictionary, updated_path):\n", - " yield from self.__convert_nested_dict_to_relpath_dict__(sub_dictionary, updated_path) #yield from allows to recursively trigger the generator\n", - " \n", - " @staticmethod\n", - " def __get_updated_relpath__(rel_path_so_far, new_path):\n", - " return f\"{rel_path_so_far}/{new_path}\"\n", - " \n", - " @staticmethod\n", - " def __check_if_value_is_dict__(value):\n", - " return isinstance(value, dict)\n", - "\n", - " @staticmethod\n", - " def __yield_path2link_pair__(updated_path, link):\n", - " yield updated_path , link\n", - "\n", - "\n", - "\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "alphatemplate", - "language": "python", - "name": "python3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/nbdev_nbs/08_tracefilter.ipynb b/nbdev_nbs/08_tracefilter.ipynb index c6823a7..1b43c4e 100644 --- a/nbdev_nbs/08_tracefilter.ipynb +++ b/nbdev_nbs/08_tracefilter.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -15,20 +15,20 @@ " 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98\n", " 99]\n", "[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n", - "Execution time for exclude_unconnected_samples: 0.01743793487548828 seconds\n" + "Execution time for exclude_unconnected_samples: 0.015436172485351562 seconds\n" ] } ], "source": [ "import numpy as np\n", "import time\n", - "import directlfq.orphan_remover as orphan_remover\n", + "import directlfq.tracefilter as lfq_trace_filter\n", "\n", "\n", "def test_empty_matrix():\n", " lower_matrix = np.array([[]])\n", " expected = np.array([[]])\n", - " actual = orphan_remover.convert_lower_to_full_matrix(lower_matrix)\n", + " actual = lfq_trace_filter.convert_lower_to_full_matrix(lower_matrix)\n", " assert np.all(actual == expected), \"Failed on empty matrix\"\n", "\n", "def test_large_matrix_fully_connected():\n", @@ -36,7 +36,7 @@ " lower_matrix[lower_matrix == 0] = 1\n", "\n", "\n", - " actual = orphan_remover.get_unconnected_sample_idxs(lower_matrix)\n", + " actual = lfq_trace_filter.get_unconnected_sample_idxs(lower_matrix)\n", " expected = []\n", " assert np.all(expected == actual), \"Failed on large matrix\"\n", "\n", @@ -47,7 +47,7 @@ " lower_matrix[1, 0] = 1\n", " lower_matrix[2, 1] = 1\n", "\n", - " actual = orphan_remover.get_unconnected_sample_idxs(lower_matrix)\n", + " actual = lfq_trace_filter.get_unconnected_sample_idxs(lower_matrix)\n", " print(actual)\n", " expected = list(range(lower_matrix.shape[0]))\n", " expected = [item for item in expected if item not in [0, 1, 2]]\n", @@ -66,7 +66,7 @@ " [3, np.inf, 2],\n", " [np.inf, 2, np.inf]\n", " ])\n", - " actual = orphan_remover.convert_lower_to_full_matrix(lower_matrix)\n", + " actual = lfq_trace_filter.convert_lower_to_full_matrix(lower_matrix)\n", " assert np.all(actual == expected), \"Failed on patterned matrix\"\n", "\n", "def test_convert_lower_to_full_matrix():\n", @@ -83,7 +83,7 @@ " [np.inf, 1 , np.inf, np.inf],\n", " [np.inf, np.inf, np.inf, np.inf]\n", " ])\n", - " actual_full_matrix = orphan_remover.convert_lower_to_full_matrix(lower_matrix)\n", + " actual_full_matrix = lfq_trace_filter.convert_lower_to_full_matrix(lower_matrix)\n", " assert np.all(actual_full_matrix == expted_full_matrix)\n", "\n", "\n", @@ -96,7 +96,7 @@ " [np.inf, np.inf, np.inf, np.inf]\n", " ]))\n", " expected = [3]\n", - " actual = orphan_remover.get_unconnected_sample_idxs(lower_matrix)\n", + " actual = lfq_trace_filter.get_unconnected_sample_idxs(lower_matrix)\n", " assert actual == expected\n", "\n", "def test_get_unconnected_sample_idxs2():\n", @@ -107,7 +107,7 @@ " [np.inf, np.inf, np.inf, np.inf]\n", " ]))\n", " expected = [0, 1, 2, 3]\n", - " actual = orphan_remover.get_unconnected_sample_idxs(lower_matrix)\n", + " actual = lfq_trace_filter.get_unconnected_sample_idxs(lower_matrix)\n", " assert np.all(actual == expected)\n", "\n", "\n", @@ -119,7 +119,7 @@ " lower_matrix[i, np.random.randint(0, i)] = np.random.random()\n", "\n", " start_time = time.time()\n", - " orphan_remover.exclude_unconnected_samples(lower_matrix)\n", + " lfq_trace_filter.exclude_unconnected_samples(lower_matrix)\n", " end_time = time.time()\n", "\n", " print(f\"Execution time for exclude_unconnected_samples: {end_time - start_time} seconds\")\n", @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -161,7 +161,7 @@ " [np.inf, np.inf, np.inf, np.inf, np.inf],\n", " [np.inf, np.inf, np.inf, 1, np.inf]]))\n", " print(lower_matrix[4, : ] )\n", - " orphan_remover.exclude_unconnected_samples(lower_matrix)\n", + " lfq_trace_filter.exclude_unconnected_samples(lower_matrix)\n", " assert (lower_matrix[4, : ] == np.array([np.inf, np.inf, np.inf, np.inf, np.inf])).all()\n", " print(\"test_passed\")\n", "\n", @@ -174,18 +174,6 @@ "display_name": "directlfq", "language": "python", "name": "python3" - }, - "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.17" } }, "nbformat": 4,