diff --git a/examples/mAP_demo.ipynb b/examples/mAP_demo.ipynb index 23a8478..5f25e41 100644 --- a/examples/mAP_demo.ipynb +++ b/examples/mAP_demo.ipynb @@ -623,7 +623,7 @@ "source": [ "Here, we treat different doses of each compound as replicates and assess how well we can retrieve them by similarity against the group of negative controls (DMSO).\n", "\n", - "To ensure correct grouping of profiles, we can add a dummy column that is equal to row index for all compound replicates and to -1 for all DMSO replicates. " + "To ensure correct grouping of profiles, we can add a dummy column that is equal to row index for all DMSO replicates and to -1 for all compound replicates. " ] }, { @@ -652,7 +652,7 @@ " \n", " \n", " \n", - " Metadata_treatment_index\n", + " Metadata_reference_index\n", " Metadata_broad_sample\n", " Metadata_mg_per_ml\n", " Metadata_mmoles_per_liter\n", @@ -678,7 +678,7 @@ " \n", " \n", " 0\n", - " -1\n", + " 0\n", " DMSO\n", " 0.000000\n", " 0.000000\n", @@ -702,7 +702,7 @@ " \n", " \n", " 1\n", - " -1\n", + " 1\n", " DMSO\n", " 0.000000\n", " 0.000000\n", @@ -726,7 +726,7 @@ " \n", " \n", " 2\n", - " -1\n", + " 2\n", " DMSO\n", " 0.000000\n", " 0.000000\n", @@ -750,7 +750,7 @@ " \n", " \n", " 3\n", - " -1\n", + " 3\n", " DMSO\n", " 0.000000\n", " 0.000000\n", @@ -774,7 +774,7 @@ " \n", " \n", " 4\n", - " -1\n", + " 4\n", " DMSO\n", " 0.000000\n", " 0.000000\n", @@ -822,7 +822,7 @@ " \n", " \n", " 379\n", - " 379\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 3.248700\n", " 3.333300\n", @@ -846,7 +846,7 @@ " \n", " \n", " 380\n", - " 380\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 1.082900\n", " 1.111100\n", @@ -870,7 +870,7 @@ " \n", " \n", " 381\n", - " 381\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.360970\n", " 0.370370\n", @@ -894,7 +894,7 @@ " \n", " \n", " 382\n", - " 382\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.120320\n", " 0.123460\n", @@ -918,7 +918,7 @@ " \n", " \n", " 383\n", - " 383\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.040108\n", " 0.041152\n", @@ -946,18 +946,18 @@ "" ], "text/plain": [ - " Metadata_treatment_index Metadata_broad_sample Metadata_mg_per_ml \\\n", - "0 -1 DMSO 0.000000 \n", - "1 -1 DMSO 0.000000 \n", - "2 -1 DMSO 0.000000 \n", - "3 -1 DMSO 0.000000 \n", - "4 -1 DMSO 0.000000 \n", + " Metadata_reference_index Metadata_broad_sample Metadata_mg_per_ml \\\n", + "0 0 DMSO 0.000000 \n", + "1 1 DMSO 0.000000 \n", + "2 2 DMSO 0.000000 \n", + "3 3 DMSO 0.000000 \n", + "4 4 DMSO 0.000000 \n", ".. ... ... ... \n", - "379 379 BRD-K82746043-001-15-1 3.248700 \n", - "380 380 BRD-K82746043-001-15-1 1.082900 \n", - "381 381 BRD-K82746043-001-15-1 0.360970 \n", - "382 382 BRD-K82746043-001-15-1 0.120320 \n", - "383 383 BRD-K82746043-001-15-1 0.040108 \n", + "379 -1 BRD-K82746043-001-15-1 3.248700 \n", + "380 -1 BRD-K82746043-001-15-1 1.082900 \n", + "381 -1 BRD-K82746043-001-15-1 0.360970 \n", + "382 -1 BRD-K82746043-001-15-1 0.120320 \n", + "383 -1 BRD-K82746043-001-15-1 0.040108 \n", "\n", " Metadata_mmoles_per_liter Metadata_pert_id Metadata_pert_mfc_id \\\n", "0 0.000000 NaN NaN \n", @@ -1100,12 +1100,12 @@ "source": [ "df_activity = df.copy()\n", "# make deafult value equal to row index\n", - "df_activity[\"Metadata_treatment_index\"] = df_activity.index\n", - "# make index equal to -1 for all DMSO treatment replicates\n", - "df_activity.loc[df[\"Metadata_broad_sample\"] == \"DMSO\", \"Metadata_treatment_index\"] = -1\n", - "# now all treatment replicates differ in the index column, except for DMSO replicates\n", + "df_activity[\"Metadata_reference_index\"] = df_activity.index\n", + "# make index equal to -1 for all treatment replicates (non-DMSO)\n", + "df_activity.loc[df[\"Metadata_broad_sample\"] != \"DMSO\", \"Metadata_reference_index\"] = -1\n", + "# now all treatment replicates equal -1 in the index column, except for DMSO replicates\n", "df_activity.insert(\n", - " 0, \"Metadata_treatment_index\", df_activity.pop(\"Metadata_treatment_index\")\n", + " 0, \"Metadata_reference_index\", df_activity.pop(\"Metadata_reference_index\")\n", ")\n", "df_activity" ] @@ -1120,7 +1120,7 @@ "\n", "* In this case, profiles that form a positive pair do not need to be different in any of the metatada columns, so we keep `pos_diffby` empty. Although one could define them as being from different batches, for instance, to account for batch effects.\n", "\n", - "* Two profiles are a negative pair when one of them belongs to a group of compound replicates and another to a group of DMSO controls. That means they should be different both in the metadata column that identifies the specific compound and the treatment index columns that we created. The latter is needed to ensure that replicates of compounds are retrieved against only DMSO controls at this stage (and not against replicates of other compounds). We list these columns in `neg_diffby`.\n", + "* Two profiles are a negative pair when one of them belongs to a group of compound replicates and another to a group of DMSO controls. That means they should be different both in the metadata column that identifies the specific compound and the reference index columns that we created. The latter is needed to ensure that replicates of compounds are retrieved against only DMSO controls at this stage (and not against replicates of other compounds). We list these columns in `neg_diffby`.\n", "\n", "* Profiles that form a negative pair do not need to be same in any of the metatada columns, so we keep `neg_sameby` empty." ] @@ -1137,7 +1137,7 @@ "\n", "neg_sameby = []\n", "# negative pairs are replicates of different treatments\n", - "neg_diffby = [\"Metadata_broad_sample\", \"Metadata_treatment_index\"]" + "neg_diffby = [\"Metadata_broad_sample\", \"Metadata_reference_index\"]" ] }, { @@ -1157,7 +1157,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5d583875de81417fa8f66f87e2bfb80b", + "model_id": "51509158c2e84267b94e8d0cf5952604", "version_major": 2, "version_minor": 0 }, @@ -1171,12 +1171,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e7687333b8544cc6a2e377ac848e3457", + "model_id": "5458f7a2a5904b7685560ac4e20d3dd8", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/4 [00:00\n", " \n", " \n", - " Metadata_treatment_index\n", + " Metadata_reference_index\n", " Metadata_broad_sample\n", " Metadata_mg_per_ml\n", " Metadata_mmoles_per_liter\n", @@ -1226,7 +1226,7 @@ " \n", " \n", " 6\n", - " 6\n", + " -1\n", " BRD-K74363950-004-01-0\n", " 5.655600\n", " 10.000000\n", @@ -1242,12 +1242,12 @@ " broad_id_20170327\n", " A07\n", " 5\n", - " 383\n", - " 0.050922\n", + " 29\n", + " 0.325013\n", " \n", " \n", " 7\n", - " 7\n", + " -1\n", " BRD-K74363950-004-01-0\n", " 1.885200\n", " 3.333300\n", @@ -1263,12 +1263,12 @@ " broad_id_20170327\n", " A08\n", " 5\n", - " 383\n", - " 0.308904\n", + " 29\n", + " 0.513889\n", " \n", " \n", " 8\n", - " 8\n", + " -1\n", " BRD-K74363950-004-01-0\n", " 0.628400\n", " 1.111100\n", @@ -1284,12 +1284,12 @@ " broad_id_20170327\n", " A09\n", " 5\n", - " 383\n", - " 0.412513\n", + " 29\n", + " 0.727778\n", " \n", " \n", " 9\n", - " 9\n", + " -1\n", " BRD-K74363950-004-01-0\n", " 0.209470\n", " 0.370370\n", @@ -1305,12 +1305,12 @@ " broad_id_20170327\n", " A10\n", " 5\n", - " 383\n", - " 0.377730\n", + " 29\n", + " 0.783333\n", " \n", " \n", " 10\n", - " 10\n", + " -1\n", " BRD-K74363950-004-01-0\n", " 0.069823\n", " 0.123460\n", @@ -1326,8 +1326,8 @@ " broad_id_20170327\n", " A11\n", " 5\n", - " 383\n", - " 0.715591\n", + " 29\n", + " 0.900000\n", " \n", " \n", " ...\n", @@ -1352,7 +1352,7 @@ " \n", " \n", " 379\n", - " 379\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 3.248700\n", " 3.333300\n", @@ -1368,12 +1368,12 @@ " broad_id_20170327\n", " P20\n", " 5\n", - " 383\n", - " 0.726786\n", + " 29\n", + " 1.000000\n", " \n", " \n", " 380\n", - " 380\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 1.082900\n", " 1.111100\n", @@ -1389,12 +1389,12 @@ " broad_id_20170327\n", " P21\n", " 5\n", - " 383\n", - " 0.658824\n", + " 29\n", + " 0.966667\n", " \n", " \n", " 381\n", - " 381\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.360970\n", " 0.370370\n", @@ -1410,12 +1410,12 @@ " broad_id_20170327\n", " P22\n", " 5\n", - " 383\n", - " 0.517619\n", + " 29\n", + " 0.942857\n", " \n", " \n", " 382\n", - " 382\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.120320\n", " 0.123460\n", @@ -1431,12 +1431,12 @@ " broad_id_20170327\n", " P23\n", " 5\n", - " 383\n", - " 0.543290\n", + " 29\n", + " 1.000000\n", " \n", " \n", " 383\n", - " 383\n", + " -1\n", " BRD-K82746043-001-15-1\n", " 0.040108\n", " 0.041152\n", @@ -1452,8 +1452,8 @@ " broad_id_20170327\n", " P24\n", " 5\n", - " 383\n", - " 0.535714\n", + " 29\n", + " 1.000000\n", " \n", " \n", "\n", @@ -1461,18 +1461,18 @@ "" ], "text/plain": [ - " Metadata_treatment_index Metadata_broad_sample Metadata_mg_per_ml \\\n", - "6 6 BRD-K74363950-004-01-0 5.655600 \n", - "7 7 BRD-K74363950-004-01-0 1.885200 \n", - "8 8 BRD-K74363950-004-01-0 0.628400 \n", - "9 9 BRD-K74363950-004-01-0 0.209470 \n", - "10 10 BRD-K74363950-004-01-0 0.069823 \n", + " Metadata_reference_index Metadata_broad_sample Metadata_mg_per_ml \\\n", + "6 -1 BRD-K74363950-004-01-0 5.655600 \n", + "7 -1 BRD-K74363950-004-01-0 1.885200 \n", + "8 -1 BRD-K74363950-004-01-0 0.628400 \n", + "9 -1 BRD-K74363950-004-01-0 0.209470 \n", + "10 -1 BRD-K74363950-004-01-0 0.069823 \n", ".. ... ... ... \n", - "379 379 BRD-K82746043-001-15-1 3.248700 \n", - "380 380 BRD-K82746043-001-15-1 1.082900 \n", - "381 381 BRD-K82746043-001-15-1 0.360970 \n", - "382 382 BRD-K82746043-001-15-1 0.120320 \n", - "383 383 BRD-K82746043-001-15-1 0.040108 \n", + "379 -1 BRD-K82746043-001-15-1 3.248700 \n", + "380 -1 BRD-K82746043-001-15-1 1.082900 \n", + "381 -1 BRD-K82746043-001-15-1 0.360970 \n", + "382 -1 BRD-K82746043-001-15-1 0.120320 \n", + "383 -1 BRD-K82746043-001-15-1 0.040108 \n", "\n", " Metadata_mmoles_per_liter Metadata_pert_id Metadata_pert_mfc_id \\\n", "6 10.000000 BRD-K74363950 BRD-K74363950-004-01-0 \n", @@ -1527,17 +1527,17 @@ "383 BCL2|BCL2L1|BCL2L2 broad_id_20170327 P24 \n", "\n", " n_pos_pairs n_total_pairs average_precision \n", - "6 5 383 0.050922 \n", - "7 5 383 0.308904 \n", - "8 5 383 0.412513 \n", - "9 5 383 0.377730 \n", - "10 5 383 0.715591 \n", + "6 5 29 0.325013 \n", + "7 5 29 0.513889 \n", + "8 5 29 0.727778 \n", + "9 5 29 0.783333 \n", + "10 5 29 0.900000 \n", ".. ... ... ... \n", - "379 5 383 0.726786 \n", - "380 5 383 0.658824 \n", - "381 5 383 0.517619 \n", - "382 5 383 0.543290 \n", - "383 5 383 0.535714 \n", + "379 5 29 1.000000 \n", + "380 5 29 0.966667 \n", + "381 5 29 0.942857 \n", + "382 5 29 1.000000 \n", + "383 5 29 1.000000 \n", "\n", "[360 rows x 18 columns]" ] @@ -1575,7 +1575,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7b70f4682ff947ca875777958c499f94", + "model_id": "b55cf11c765b4af98dca44f808372955", "version_major": 2, "version_minor": 0 }, @@ -1589,7 +1589,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eed952af896e48ffaa790e3c997714fc", + "model_id": "f470ba4162d4425f8983d7f7c52ff982", "version_major": 2, "version_minor": 0 }, @@ -1634,102 +1634,102 @@ " \n", " 0\n", " BRD-A69275535-001-01-5\n", - " 0.203576\n", - " 0.012899\n", - " 0.016390\n", + " 0.575629\n", + " 0.017698\n", + " 0.023857\n", " True\n", " True\n", - " 1.785430\n", + " 1.622390\n", " \n", " \n", " 1\n", " BRD-A69636825-003-04-7\n", - " 0.269093\n", - " 0.000800\n", - " 0.001365\n", + " 0.693806\n", + " 0.003700\n", + " 0.006922\n", " True\n", " True\n", - " 2.865004\n", + " 2.159775\n", " \n", " \n", " 2\n", " BRD-A69815203-001-07-6\n", - " 0.862226\n", + " 1.000000\n", " 0.000100\n", - " 0.000276\n", + " 0.000341\n", " True\n", " True\n", - " 3.558835\n", + " 3.467064\n", " \n", " \n", " 3\n", " BRD-A70858459-001-01-7\n", - " 0.351816\n", - " 0.000200\n", - " 0.000400\n", + " 0.777173\n", + " 0.000600\n", + " 0.001289\n", " True\n", " True\n", - " 3.397983\n", + " 2.889828\n", " \n", " \n", " 4\n", " BRD-A72309220-001-04-1\n", - " 0.263986\n", - " 0.000900\n", - " 0.001491\n", + " 0.716927\n", + " 0.002200\n", + " 0.004253\n", " True\n", " True\n", - " 2.826441\n", + " 2.371314\n", " \n", " \n", " 5\n", " BRD-A72390365-001-15-2\n", - " 0.554667\n", + " 0.934444\n", " 0.000100\n", - " 0.000276\n", + " 0.000341\n", " True\n", " True\n", - " 3.558835\n", + " 3.467064\n", " \n", " \n", " 6\n", " BRD-A73368467-003-17-6\n", - " 0.788666\n", + " 0.926032\n", " 0.000100\n", - " 0.000276\n", + " 0.000341\n", " True\n", " True\n", - " 3.558835\n", + " 3.467064\n", " \n", " \n", " 7\n", " BRD-A74980173-001-11-9\n", - " 0.500600\n", - " 0.000100\n", - " 0.000276\n", + " 0.765931\n", + " 0.000600\n", + " 0.001289\n", " True\n", " True\n", - " 3.558835\n", + " 2.889828\n", " \n", " \n", " 8\n", " BRD-A81233518-004-16-1\n", - " 0.140208\n", - " 0.015598\n", - " 0.018700\n", + " 0.621183\n", + " 0.009399\n", + " 0.013978\n", " True\n", " True\n", - " 1.728154\n", + " 1.854552\n", " \n", " \n", " 9\n", " BRD-A82035391-001-02-7\n", - " 0.052362\n", - " 0.077692\n", - " 0.078692\n", + " 0.318066\n", + " 0.260374\n", + " 0.264942\n", " False\n", " False\n", - " 1.104069\n", + " 0.576849\n", " \n", " \n", "\n", @@ -1737,28 +1737,28 @@ ], "text/plain": [ " Metadata_broad_sample mean_average_precision p_value \\\n", - "0 BRD-A69275535-001-01-5 0.203576 0.012899 \n", - "1 BRD-A69636825-003-04-7 0.269093 0.000800 \n", - "2 BRD-A69815203-001-07-6 0.862226 0.000100 \n", - "3 BRD-A70858459-001-01-7 0.351816 0.000200 \n", - "4 BRD-A72309220-001-04-1 0.263986 0.000900 \n", - "5 BRD-A72390365-001-15-2 0.554667 0.000100 \n", - "6 BRD-A73368467-003-17-6 0.788666 0.000100 \n", - "7 BRD-A74980173-001-11-9 0.500600 0.000100 \n", - "8 BRD-A81233518-004-16-1 0.140208 0.015598 \n", - "9 BRD-A82035391-001-02-7 0.052362 0.077692 \n", + "0 BRD-A69275535-001-01-5 0.575629 0.017698 \n", + "1 BRD-A69636825-003-04-7 0.693806 0.003700 \n", + "2 BRD-A69815203-001-07-6 1.000000 0.000100 \n", + "3 BRD-A70858459-001-01-7 0.777173 0.000600 \n", + "4 BRD-A72309220-001-04-1 0.716927 0.002200 \n", + "5 BRD-A72390365-001-15-2 0.934444 0.000100 \n", + "6 BRD-A73368467-003-17-6 0.926032 0.000100 \n", + "7 BRD-A74980173-001-11-9 0.765931 0.000600 \n", + "8 BRD-A81233518-004-16-1 0.621183 0.009399 \n", + "9 BRD-A82035391-001-02-7 0.318066 0.260374 \n", "\n", " corrected_p_value below_p below_corrected_p -log10(p-value) \n", - "0 0.016390 True True 1.785430 \n", - "1 0.001365 True True 2.865004 \n", - "2 0.000276 True True 3.558835 \n", - "3 0.000400 True True 3.397983 \n", - "4 0.001491 True True 2.826441 \n", - "5 0.000276 True True 3.558835 \n", - "6 0.000276 True True 3.558835 \n", - "7 0.000276 True True 3.558835 \n", - "8 0.018700 True True 1.728154 \n", - "9 0.078692 False False 1.104069 " + "0 0.023857 True True 1.622390 \n", + "1 0.006922 True True 2.159775 \n", + "2 0.000341 True True 3.467064 \n", + "3 0.001289 True True 2.889828 \n", + "4 0.004253 True True 2.371314 \n", + "5 0.000341 True True 3.467064 \n", + "6 0.000341 True True 3.467064 \n", + "7 0.001289 True True 2.889828 \n", + "8 0.013978 True True 1.854552 \n", + "9 0.264942 False False 0.576849 " ] }, "execution_count": 9, @@ -1788,7 +1788,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABKH0lEQVR4nO3deVwU9f8H8Nfswi7nLiByCYIKKqgoohba16O8zaNvmamlVlaeZR6VXfrVDDv8dZhHaamVZmVpZR6ZZyhpKpR5pYJiyuHBDS6w+/n9YW6uLLi7LCwMr+fjsY8HO/OZ2ffOws6Lz3xmRhJCCBARERHJhMLRBRARERHZE8MNERERyQrDDREREckKww0RERHJCsMNERERyQrDDREREckKww0RERHJipOjC6hpBoMBFy9ehKenJyRJcnQ5REREZAEhBPLz8xEUFASFovK+mXoXbi5evIiQkBBHl0FEREQ2OH/+PIKDgyttU+/CjaenJ4DrG0ej0Ti4GiIiIrJEXl4eQkJCjPvxytS7cHPjUJRGo2G4ISIiqmMsGVLCAcVEREQkKww3REREJCsMN0RERCQrDDdEREQkKww3REREJCsMN0RERCQrDDdEREQkKww3REREJCsMN0RERCQrDDdEREQkKww3REREJCv17t5SRFT9rpSUYeqJNCTkFEDrpMRLTQNxf4AP9ucUYPrJ87hwrRQtPVzwfmRjhLu5mF3H5xev4K3UdBTqDbjbxxP/9ffBnDMXkaErRWtPVyyMbIxQV7XNNe7LLsCMk+dx7poOQgAaJyUmNPbDpMZ+Ft275mZCCCxMy8JH5y+hRAgM8fPCnPBGcFE6/v/Hs8U6PH08DX/mFyNQ7Yw3WgTjLu/rNx68VFKKKcfT8GtuIbydlHg1vBEG+XnhaEExphxPw5kiHcJcVfi/lo3RTuNmdv1XS8sw9s9U/JpTCAEgSO2MVW2aoLWn+fa3KjEYMOf0RXydmQ2lBIxp5IvpYQFQWPAZrEm/gjdTMlCg16O7jyfebhECL2fH7NbWXLyCN1IuIrvMAABQKyQ8GOCDWeFBUClq/vfgj/wiTDmehrPFJWjipsZ7LUPQ2tPNZHpTNzXe/Wd6VRz45+86rUiHMgBlAJQAHm3ki9eaV3737uoiCSGEQ17ZQfLy8qDVapGbm8sbZxJVAyEEBiedxqHcQuhvmr4wsjFmnDyPEoOAAde//BqqnJBwRyQ8nJQm6/jxUg4e//Os8bkCgAAgAcZlg1xU2NOpJVxtCBApRTr0+O0EdIbyX3/zmwdjTCNfq9b3yd+X8OKpCyb1PhzUAG+2CLG6Nnsq0hvQdf9xpJeUQi+u1+UkSdjRqQWauarR/9Bf+KOgGHpxfdsCwMrWTTDlRBryyvTQ4/q2dlMqkHBHJPzVzibrF0Jg4OFTOJhXZDLdXaHA/rgo+KpuHzRmn7qAD/++hJs/iZebBmJSqH+ly/10ORejjqQanysB3OXtiS/bNbvta9rblku5GPNnarnpEoAngn0xJ6Jmd/CXSkrRZf9xFJYZjJ+hp5MSG2LCMSjpVLnpCXdEWvRZmXOuWIfuB06g2MzfEgDMDW+EJ0Ia2vpWTFiz/3b8vxVEJCuXS8tw4JZgo5SAzy5chu6fYAMAegAZJWU4fMuOEQB+yMox+XIy4Hq4uXnZ89dKcLSg2KYaf76Si9IKvozXZ2Zbvb71mTkmzw02rsfe/swvwt+668EGuF5XmRDYdjkPF3SlSMovNs4TuP45fXrxMrL/CTbA9W2drzcgITu/3Pqzy/Tlgg0AFBoMSMwpsKjGbzKzcesnsT7r9tvu+6wc3ByJ9QB2Z+ejoExf0SLV5odLOWZ3pgLAt7f8btSEhOwC5P0TYIDr2yanTI/P06+YnW7pZ2XOzqv5uFbB3xIAfJF+xeZ1VwXDDRHZlXMFhxOcFYpyOzHgek9C+bYSLDkwZG5ZS1RUCwCoFNavU2WmXltrsycnM+9F4Pr2VZmpT6Di929uXRV91rebZ9LOyvXeYK5OCYDSAdvdSar499XS7WBPFb2muc+8svaWUElShX9LgOP+DhhuiMiuvJydMNjPy/hlrwCggIRnQ/3h6+xk/G9bCSDS3QUdtOWP9z8S2MB4GOoGlSSZLBvj6YbWHq421XhvQy28nZVmd0iPWXlICgAeD/YtV6+9uuKrItrDDe08XU22m9ZJiYENveCndkY/X41xJ6AAoISEp0P9EeaqMlmmkdoZd/uUPwzg6aTEoIbactMDVE74j7eHRTU+GVx+O401M+1WDwc2AKR/d2ISgGEBPjYdpqyqR4IaVDjPEb8H3X08EeJy02coAaEuKjwV0hDBameT6WGuKos/K3P6+Gqv/11XkGGm3ObwYnXhmBsisjudwYAFqRnYk50PH2cnPBsWgI5ad5wr1uG1MxdxrrgErT1d8XKzIPhUMAA0ITsf75/LRH6ZAT0baHBvQy3mp2bgwrUStNO44aWmgdBWYfBoatH1WpLyi1BiMKCJqwvGN26I/g29bFrfj5dysPzvyygxGDDEzxtjg32tHphcHXJLyzAvJR3JeUUIdlHhpWaBaPbPIO5regPeTM3A3px8+Do7YXqTQMRo3JClK8XcMxdxovAaItzUeLlZEIJcVGbXX2IwYM6Zi1iXkY0yIdBB4473IhuXG59TESEEPr14BV9nXIVSkjCmkS/u8/e2aNl92QV471wmcsvKcHcDDZ4NDTDbE1QT9v7z+3q2WIcyAQSonTE0wAejgxo45Pcg45/P8K/Ca2jh7oJXmgXBX+2MdF0J5p6+iFNFOpPpVXHj7/pM4TVklpahUG+Am1KBV5oFYXhgxcHPWtbsvxluiIiIqNarMwOKlyxZgujoaGg0Gmg0GsTFxWHz5s0Vtl+5ciUkSTJ5uLiYP42UiIiI6ieHXucmODgY8+fPR0REBIQQWLVqFQYPHoykpCS0atXK7DIajQYnT540Pq8N3b5ERERUezg03AwcONDk+bx587BkyRL8+uuvFYYbSZIQEBBQE+URERFRHVRrzpbS6/VYu3YtCgsLERcXV2G7goIChIaGIiQkBIMHD8bRo0crXa9Op0NeXp7Jg4iIiOTL4eHmyJEj8PDwgFqtxrhx47B+/XpERUWZbduiRQt88skn+O677/D555/DYDCgc+fO+Pvvvytcf3x8PLRarfEREuLYK4YSERFR9XL42VIlJSVIS0tDbm4u1q1bh+XLl2P37t0VBpyblZaWIjIyEsOHD8fcuXPNttHpdNDpdMbneXl5CAkJ4dlSREREdYg1Z0s5/MaZKpUK4eHhAIDY2Fj89ttveO+99/Dhhx/edllnZ2fExMTg9OnTFbZRq9VQq22/uR4RERHVLQ4/LHUrg8Fg0tNSGb1ejyNHjiAwMLCaqyIiIqK6wqE9NzNnzkS/fv3QuHFj5OfnY82aNdi1axe2bt0KABg1ahQaNWqE+Ph4AMCcOXNw5513Ijw8HDk5OXjrrbdw7tw5jB071pFvg4iIiGoRh4abrKwsjBo1Cunp6dBqtYiOjsbWrVvRq1cvAEBaWhoUin87l7Kzs/HEE08gIyMD3t7eiI2Nxb59+ywan0NERET1g8MHFNc03n6BiIio7qkzt18gIiIisjeGGyIiIpIVhhsiIiKSFYYbIiIikhWHX8SPqD77LbcQk4+dw7lrJbgxsl8lAe+0bIz7A3zs+lqbLuVg0rFzKDIIuCgkvNUiGJ20Hnj2RBqO5BejkYsKrzQNxFeZ2dh1NR+eTgq80CQQD9i5DiKi6sazpYgc5FyxDl33H4eugr/Anzs0R2tPN7u81umia/jP/hO49aX8VE64UlIGPUy7cQ03/bw6uinuacC/FSJyLJ4tRVQH/Hwlr8JgAwCrLly222utuXilXLABgKx/gg1wPdDceNygBPB9Vo7d6iAiqgkMN0QO4ixJlc53UlQ+3xoqW9clAU72K4OIqEYw3BA5SL+GWng5mf8TlACMC/Gz22uNCfKF0sxrRLipjdOVuB64pJvmQwAjAhvYrQ4ioprAcEPkIA1VztgU2wJdvT3gprgeKiQAfs5KfB8TjlBX+93NPsBFhc2xEQhWO0MtSQhUOWFDTDi+ax+BoQE+iHR3Qc8GGvzUIQKTG/uhlYcLOnt54Mt2zRCrdbdbHURENYEDiomIiKjW44BiIiIiqrcYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWGG6IiIhIVhhuiIiISFYYboiIiEhWnBxdAJHcHcgpwNLzl1Cg16O3rxaPNfKFQpIcXRYRkWwx3BBVo4O5hbgv+TSEAAwA9mQXIENXipebBTm6NCIi2eJhKaJq9MmFy8A/weaGD89fgkEIh9VERCR3DDdE1eia3mASbACgTAiUMdwQEVUbhhuiatS3oRY3xxglgB4+nlAp+KdHRFRd+A1LVI2G+nvj5aaB8FAq4CQBdzfQYFFUqKPLIiKSNQ4oJqpGkiRhUqg/JoX6QwgBiWdJERFVO/bcENUQBhsioprBcENERESywsNSRFYyCIFDeUXILi1DhJsL0q6VwCAEOmrd4eGkdHR5RET1HsMNkRVKDQKPHknBz1fzAQASYDwbKlDljPXtwxHmqnZYfURExMNSRFZZeeEytv8TbACYnOadVVKK6SfO13xRRERkguGGyAonCouhrGBcsB7A8cLiGq2HiIjKY7ghskKoqxqGCi4urPxnPhERORbDDZEVHg/2RWsPV7Pz3JQKvNE8uIYrIiKiWzk03CxZsgTR0dHQaDTQaDSIi4vD5s2bK13m66+/RsuWLeHi4oI2bdpg06ZNNVQtEeCuVOL79hFYGhWK+ObBWNeuGf6vZQgWtAjBnjtaoo2nm6NLJCKq9xx6tlRwcDDmz5+PiIgICCGwatUqDB48GElJSWjVqlW59vv27cPw4cMRHx+Pe++9F2vWrMGQIUNw+PBhtG7d2gHvgOojF6UCQ/y9HV0GERFVQBKidt2e2MfHB2+99RYef/zxcvOGDRuGwsJCbNy40TjtzjvvRLt27bB06VKz69PpdNDpdMbneXl5CAkJQW5uLjQajf3fABEREdldXl4etFqtRfvvWjPmRq/XY+3atSgsLERcXJzZNomJiejZs6fJtD59+iAxMbHC9cbHx0Or1RofISEhdq2biIiIaheHh5sjR47Aw8MDarUa48aNw/r16xEVFWW2bUZGBvz9/U2m+fv7IyMjo8L1z5w5E7m5ucbH+fO8DgkREZGcOfwKxS1atEBycjJyc3Oxbt06jB49Grt3764w4FhLrVZDrebpuURERPWFw8ONSqVCeHg4ACA2Nha//fYb3nvvPXz44Yfl2gYEBCAzM9NkWmZmJgICAmqkViIiIqr9HH5Y6lYGg8FkAPDN4uLisH37dpNp27Ztq3CMDhEREdU/Du25mTlzJvr164fGjRsjPz8fa9aswa5du7B161YAwKhRo9CoUSPEx8cDAJ555hl069YNCxYswIABA7B27VocPHgQH330kSPfBhEREdUiDg03WVlZGDVqFNLT06HVahEdHY2tW7eiV69eAIC0tDQoFP92LnXu3Blr1qzByy+/jBdffBERERHYsGEDr3FDRERERrXuOjfVzZrz5ImIiKh2qJPXuSEiIiKyB4YbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWGGyIiIpIVhhsiIiKSFYYbIiIikhWH3ziTqDqdLCjG0OQzyCotAwB08/bEyjZN4Kpkricikit+w5NsFZbpMeDwKWOwAYDd2fl45tg5B1ZFRETVjeGGZOv3/GIU6A3lpv90Nc8B1RARUU1huCHZclFIZqc7SeanExGRPDDckGxFe7qhqau63PRxwQ0dUA0REdUUDigmWSoxGLAoLQtNXFQoMRiQW6aHi0LCkyF+mNTYz9HlERFRNWK4IdnILi3DhsxspBWX4OcruThdXAIBQAnAx9kJOzq1QEOVs6PLJCKiasZwQ7JwvKAY/Q/9hWKDKDdPD+BKaRm+ycjGOPbaEBHJHsfckCw8cfSs2WBzgyQBhWbOnCIiIvlhuCFZOFusq3S+QQA9fDxrqBoiInIkhhuShSB1xWNpnCVgUVQo2mvda7AiIiJyFIYbkoVFUWFmB5AFqp2x/84o/Nffu8ZrIiIix+CAYpKFjlp3/BoXhRV/X8K5azr4Ojuhg9YDvX210DgpHV0eERHVIIYbko1gFxVeCW/k6DKIiMjBeFiKiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZMXqu4Ln5ORg/fr1+OWXX3Du3DkUFRWhYcOGiImJQZ8+fdC5c+fqqJOIiIjIIhb33Fy8eBFjx45FYGAgXnvtNRQXF6Ndu3a45557EBwcjJ07d6JXr16IiorCl19+WZ01ExEREVXI4p6bmJgYjB49GocOHUJUVJTZNsXFxdiwYQPeffddnD9/HtOnT7dboURERESWkIQQwpKGV65cQYMGDSxesbXta0peXh60Wi1yc3Oh0WgcXQ4RERFZwJr9t8WHpawNKrUx2BAREZH82Xy21GeffYYuXbogKCgI586dAwC8++67+O677+xWHBEREZG1bAo3S5YswdSpU9G/f3/k5ORAr9cDALy8vPDuu+/asz4iIiIiq9gUbhYuXIhly5bhpZdeglKpNE7v0KEDjhw5YrfiiIiIiKxlU7hJTU1FTExMuelqtRqFhYVVLoqIiIjIVjaFmyZNmiA5Obnc9C1btiAyMrKqNRERERHZzOorFAPA1KlTMXHiRFy7dg1CCBw4cABffPEF4uPjsXz5cnvXSERERGQxm8LN2LFj4erqipdffhlFRUUYMWIEgoKC8N577+Ghhx6yd41EREREFrP4In4VKSoqQkFBAfz8/OxVU7XiRfyIiIjqHmv23zb13NzMzc0Nbm5uVV0NUaVKDQKvp1zEVxlXoZQkPNrIF8+E+kMhSY4ujYiIahmbwk2TJk0gVbJTSUlJsbkgInPmp6Zj6flLuNHN+EZqBtQKBSY0rhs9hkREVHNsCjdTpkwxeV5aWoqkpCRs2bIFM2bMsEddRCbWZVzFrcdP12VcZbghIqJybAo3zzzzjNnpixYtwsGDB6tUEJE5SjM9hU4KHpIiIqLybL63lDn9+vXDN998Y89VEgEAxgY3LDftsUa+DqiEiIhquyoPKL7ZunXr4OPjY89VEgEAxoc0hFohGQcUj2nkiwcD+LtGRETl2RRuYmJiTAYUCyGQkZGBS5cuYfHixXYrjugGSZLweHBDPG6mB4eIiOhmNoWbIUOGmDxXKBRo2LAhunfvjpYtW9qjLiIiIiKbVPkifnUNL+JHRERU91iz/7Z4QHFeXp7FD0vFx8ejY8eO8PT0hJ+fH4YMGYKTJ09WuszKlSshSZLJw8XFxeLXJCIiInmz+LCUl5dXpRfuA66PvZEkCXq93qJ17t69GxMnTkTHjh1RVlaGF198Eb1798axY8fg7u5e4XIajcYkBN2uLiIiIqo/LA43O3futPuLb9myxeT5ypUr4efnh0OHDqFr164VLidJEgICAuxeDxEREdV9Foebbt26VWcdAIDc3FwAuO3p5AUFBQgNDYXBYED79u3x+uuvo1WrVmbb6nQ66HQ643NrDpsRERFR3VOlAcVFRUVIS0tDSUmJyfTo6Gir12UwGDBo0CDk5OQgISGhwnaJiYk4deoUoqOjkZubi7fffht79uzB0aNHERwcXK797Nmz8b///a/cdA4oJiIiqjusGVBsU7i5dOkSHn30UWzevNnsfEvH3Nxs/Pjx2Lx5MxISEsyGlIqUlpYiMjISw4cPx9y5c8vNN9dzExISwnBDRERUh1TL2VI3mzJlCnJycrB//364urpiy5YtWLVqFSIiIvD9999bvb5JkyZh48aN2Llzp1XBBgCcnZ0RExOD06dPm52vVquh0WhMHkRERCRfNl3Eb8eOHfjuu+/QoUMHKBQKhIaGolevXtBoNIiPj8eAAQMsWo8QApMnT8b69euxa9cuNGnSxOpa9Ho9jhw5gv79+1u9LBEREcmPTT03hYWF8PPzAwB4e3vj0qVLAIA2bdrg8OHDFq9n4sSJ+Pzzz7FmzRp4enoiIyMDGRkZKC4uNrYZNWoUZs6caXw+Z84c/PTTT0hJScHhw4fx8MMP49y5cxg7dqwtb4WIiIhkxqaemxYtWuDkyZMICwtD27Zt8eGHHyIsLAxLly5FYGCgxetZsmQJAKB79+4m01esWIExY8YAANLS0qBQ/JvBsrOz8cQTTyAjIwPe3t6IjY3Fvn37EBUVZctbISIiIpmxaUDx559/jrKyMowZMwaHDh1C3759cfXqVahUKqxcuRLDhg2rjlrtgrdfICIiqnuq/WypWxUVFeHEiRNo3LgxfH19q7q6asVwQ0REVPdU+9lSt16Hxs3NDe3bt6/1wYaIiIjkz6Zwc/fdd6NJkyZ48cUXcezYMXvXRAQA0AuBfdkF2HQpBxeuldx+ASIiItgYbi5evIhp06Zh9+7daN26Ndq1a4e33noLf//9t73ro3qqxGDAiN9T8N/k03jsz7PovP84tl/hrTOIiOj2bAo3vr6+mDRpEvbu3YszZ85g6NChWLVqFcLCwnD33Xfbu0aqhz7++zL2ZOcbn5cYBMYdPYsSg8GBVRERUV1gU7i5WZMmTfDCCy9g/vz5aNOmDXbv3m2Puqie+6voGpTSv88FgHy9AVklZQ6riYiI6oYqhZu9e/diwoQJCAwMxIgRI9C6dWv8+OOP9qqN6rEwFzUMt5zH56KQ0FBl06WZiIioHrFpTzFz5kysXbsWFy9eRK9evfDee+9h8ODBcHNzs3d9VE89EdIQmy/nIDn/+tWqlQDebdkYakWVOxuJiEjmbAo3e/bswYwZM/Dggw/y9G+qFm5KBb5rH4Ftl/OQW6ZHrNYNLd1dHV0WERHVATaFm7179xp//uKLLzBo0CC4u7vbrSgiAFArFLjXz8vRZRARUR1T5T7+p556CpmZmfaohYiIiKjKqhxu7HD3BiIiIiK74ehMIiIikpUqh5vNmzejUaNG9qiFiIiIqMqqFG6ysrIghMCBAweQlZVlr5qIiIiIbGZTuMnPz8cjjzyCRo0aoVu3bujWrRsaNWqEhx9+GLm5ufaukYiIiMhiNoWbsWPHYv/+/di4cSNycnKQk5ODjRs34uDBg3jqqafsXSMRERGRxSRhw+lO7u7u2Lp1K+666y6T6b/88gv69u2LwsJCuxVob3l5edBqtcjNzYVGo3F0OURERGQBa/bfNvXcNGjQAFqtttx0rVYLb29vW1ZJREREZBc2hZuXX34ZU6dORUZGhnFaRkYGZsyYgVdeecVuxRERERFZy6bDUjExMTh9+jR0Oh0aN24MAEhLS4NarUZERIRJ28OHD9unUjvhYSkiIqK6x5r9t033lhoyZIgtixERERFVO5t6buoy9twQERHVPdUyoLieZSAiIiKqoywON61atcLatWtRUlJSabtTp05h/PjxmD9/fpWLIyIiIrKWxWNuFi5ciOeffx4TJkxAr1690KFDBwQFBcHFxQXZ2dk4duwYEhIScPToUUyaNAnjx4+vzrqJiIiIzLJ6zE1CQgK+/PJL/PLLLzh37hyKi4vh6+uLmJgY9OnTByNHjqzV17rhmBsiIqK6x5r9NwcUExERUa1X7VcoJiIiIqqtrL7OzeXLl/HJJ58gMTHReIXigIAAxMXF4dFHH0XDhg3tXiQRERGRpazqufntt9/QvHlzvP/++9BqtejatSu6du0KrVaLhQsXomXLljh48GB11UpERER0W1aNubnzzjvRtm1bLF26FJIkmcwTQmDcuHH4448/kJiYaPdC7YVjboiIiOqearv9wu+//46VK1eWCzYAIEkSnn32WcTExFhXLREREZEdWXVYKiAgAAcOHKhw/oEDB+Dv71/looiIiIhsZVXPzfTp0/Hkk0/i0KFDuOeee4xBJjMzE9u3b8eyZcvw9ttvV0uhRERERJawKtxMnDgRvr6+eOedd7B48WLo9XoAgFKpRGxsLFauXIkHH3ywWgolIiIisoTNF/ErLS3F5cuXAQC+vr5wdna2a2HVhQOKa68yg8Ce7HxcLS1De407mrqpHV0SERHVEtU2oPhmzs7OCAwMtHVxIhM6gwEjfk/B3pwCAICTBCyOCsMgPy/HFkZERHWOXa9QfObMGdx99932XCXVE6suXMa+f4INAJQJ4Onj51CkNziwKiIiqovsGm4KCgqwe/due66S6onTRToob7nCwDWDQFZJqWMKIiKiOsuqw1Lvv/9+pfMvXLhQpWKo/gp3U0N/0+gvCYBaIcFfVTfGchERUe1hVbiZMmUKAgMDoVKpzM4vKSmxS1FU/4xu5Iutl/OMY26UEvB+ZChclby3KxERWceqcBMaGoo33nijwtO9k5OTERsba5fCqH5RKxT4sm0z/PLP2VIxPFuKiIhsZNW/xbGxsTh06FCF8yVJgo1nlhPBSSGhRwMN7g/wYbAhIiKbWdVzM2fOHBQVFVU4PyoqCqmpqVUuioiIiMhWVoWbqKioSuc7OzsjNDS0SgURERERVQVHaxIREZGs2HSF4piYGEiSVG66JElwcXFBeHg4xowZgx49elS5QCIiIiJr2NRz07dvX6SkpMDd3R09evRAjx494OHhgTNnzqBjx45IT09Hz5498d1339m7XiIiIqJK2dRzc/nyZUybNg2vvPKKyfTXXnsN586dw08//YRZs2Zh7ty5GDx4sF0KJSIiIrKETXcF12q1OHToEMLDw02mnz59GrGxscjNzcWJEyfQsWNH5Ofn261Ye+BdwYmIiOoea/bfNh2WcnFxwb59+8pN37dvH1xcXAAABoPB+DMRERFRTbHpsNTkyZMxbtw4HDp0CB07dgQA/Pbbb1i+fDlefPFFAMDWrVvRrl07uxVKREREZAmbDksBwOrVq/HBBx/g5MmTAIAWLVpg8uTJGDFiBACguLjYePZUbcLDUkRERHWPNftvm8NNXcVwQ0REVPdYs/+26bDUDYcOHcLx48cBAK1atUJMTExVVkdERERUZTaFm6ysLDz00EPYtWsXvLy8AAA5OTno0aMH1q5di4YNG9qzRiIiIiKL2XS21OTJk5Gfn4+jR4/i6tWruHr1Kv7880/k5eXh6aeftneNRERERBazKdxs2bIFixcvRmRkpHFaVFQUFi1ahM2bN1u8nvj4eHTs2BGenp7w8/PDkCFDjAOUK/P111+jZcuWcHFxQZs2bbBp0yZb3gYRERHJkE3hxmAwwNnZudx0Z2dnGAwGi9eze/duTJw4Eb/++iu2bduG0tJS9O7dG4WFhRUus2/fPgwfPhyPP/44kpKSMGTIEAwZMgR//vmnLW+FiIiIZMams6UGDx6MnJwcfPHFFwgKCgIAXLhwASNHjoS3tzfWr19vUzGXLl2Cn58fdu/eja5du5ptM2zYMBQWFmLjxo3GaXfeeSfatWuHpUuXlmuv0+mg0+mMz/Py8hASEsKzpYiIiOqQar9C8QcffIC8vDyEhYWhWbNmaNasGZo0aYK8vDwsXLjQpqIBIDc3FwDg4+NTYZvExET07NnTZFqfPn2QmJhotn18fDy0Wq3xERISYnN9REREVPvZdLZUSEgIDh8+jJ9//hknTpwAAERGRpYLHdYwGAyYMmUKunTpgtatW1fYLiMjA/7+/ibT/P39kZGRYbb9zJkzMXXqVOPzGz03REREJE82X+dGkiT06tULvXr1skshEydOxJ9//omEhAS7rO8GtVoNtVpt13USERFR7WVxuHn//fctXqm1p4NPmjQJGzduxJ49exAcHFxp24CAAGRmZppMy8zMREBAgFWvSURERPJk8YDiJk2aWLZCSUJKSopFbYUQmDx5MtavX49du3YhIiLitssMGzYMRUVF+OGHH4zTOnfujOjoaLMDim/F2y8QERHVPdVy+4XU1FSz0xMSEtChQwebbpA5ceJErFmzBt999x08PT2N42a0Wi1cXV0BAKNGjUKjRo0QHx8PAHjmmWfQrVs3LFiwAAMGDMDatWtx8OBBfPTRR1a/PhEREcmPTWdL3ax///64ePGiTcsuWbIEubm56N69OwIDA42PL7/80tgmLS0N6enpxuedO3fGmjVr8NFHH6Ft27ZYt24dNmzYUOkgZCIiIqo/qnxXcE9PT/z+++9o2rSpvWqqVjwsRUREVPdU+3VuiIiIiGqrKoebDz/8sNx1Z4iIiIgcxebr3NwwYsQIe9RBREREZBc8LEVERESywnBDREREssJwQ0RERLLCcENERESywnBDREREssJwQ0RERLLCcENERESywnBDREREssJwQ0RERLLCcENERESywnBDREREssJwQ0RERLLCcENERESywnBDREREssJwQ0RERLLi5OgCqG65cK0El0vL0MxVDQ8npXG6zmDA6SIdXBQSAlTOOFOsg9ZJiVBXNQCg5J/5eaV6qBUSmrip4eXMXz8iIrI/7l3IIkIIzDlzEUvOXwIAeCoVWNGmCe7y9kRqkQ4P/n4G56+VAACcJaBUXF/uwQBvTA0LwIjfU5BSrDOuT62QsDgqFAMaetX0WyEiIpnjYSmyyI+Xco3BBgAK9AY8eiQVhXo9njp2Fhd1JcZ5N4INAHyVkY2Hks/g7E3BBgB0BoFxR88hQ1da7bUTEVH9wnBDFjmcVwQn6d/nAkC+3oCUIh2O5BdDL8wvp5SAtGslMJiZVyoEjhcUV0e5RERUjzHckEX81U4wmAkw/ipnNKhs7IwA3JUV/5r5q53tUB0REdG/GG7qOSEEErLz8emFy0jIzocQ5rtgHg5sgHA3NRSAsQdnapg//NTOeL15MKR/pt/o3FHi+i+Xv9oZ8c2Dzf6ijQz0QaS7i93fExER1W8cUFzPvXTqAj65cNn4/PFGvpjXPLhcO3cnJTbHNscXGVdxqaQMsRo39PbVAgAG+XkhWB2Bn6/mwVWhQIiLCicLr0HjpMSwQB/4ODshwt0Fmy/l4ETBNQS4OONOrQcG+3lBkqRyr0VERFQVkqjoX3WZysvLg1arRW5uLjQajaPLcagDOQUYlHS63PQf2kego9bdARURERGZZ83+mz039YTOYMDuq/k4W6yDBCDMVY0rpWVm254t1jHcEBFRncVwUw/kl+lxX9Jp/HnLmUmR7mqz7SPcOA6GiIjqLg4orgfeP5dp9pTrE4U63OXlYTJtRlgA2mncaqo0IiIiu2PPTT1wpkhn9jozEoBAF2fs6NgCKUU6NHVTI8rDtabLIyIisiuGm3qg2T+ncOtvmS4ANHO9HmgYaoiISC54WKoeeDrUH5Fmwkusxg1Phfg5oCIiIqLqw56besDTSYkfYyOMZ0spJAlhrmp08/aEs4LXmSEiInlhuKkn1AqF8aJ7REREcsZwI0NrLl7BxxcuoUwAQ/29MaGxHxS8EjAREdUTDDcy80X6FUw9ed74/LWUdJQIgalhAQ6sioiIqOZwQLHMrLrpPlGVTSMiIpIrhhuZMXc9G329unsYERHVdww3MjMswMfkuQRgeKCP+cZEREQyxDE3MvNYI1+UGAQ+vnAJegE8GOCDGRxvQ0RE9QjDjcxIkoTxjf0wvjEvzkdERPUTD0sRERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BAREZGsMNwQERGRrDDcEBERkaww3BBRnbdy5Up4eXk5uoxqtWvXLkiShJycHLus7+zZs5AkCcnJydWyfnuSJAkbNmxwdBlUhzDcEFGtN2bMGEiSBEmSoFKpEB4ejjlz5qCsrMzRpZUTFhaGd9991+7r7dy5M9LT06HVau2+7tpi9uzZaNeuXbnp6enp6NevX80XZIUzZ87gvvvuQ8OGDaHRaPDggw8iMzPTpM28efPQuXNnuLm5WRzGZ8+ejZYtW8Ld3R3e3t7o2bMn9u/fb9Lmr7/+wuDBg+Hr6wuNRoO77roLO3fuNM6/evUqBg4cCA8PD8TExCApKclk+YkTJ2LBggW2vfFayqHhZs+ePRg4cCCCgoIsSuY3/rO49ZGRkVEzBRORw/Tt2xfp6ek4deoUpk2bhtmzZ+Ott95ydFk1RqVSISAgAJIkObqUGhcQEAC1Wu3oMipUWFiI3r17Q5Ik7NixA3v37kVJSQkGDhwIg8FgbFdSUoKhQ4di/PjxFq+7efPm+OCDD3DkyBEkJCQgLCwMvXv3xqVLl4xt7r33XpSVlWHHjh04dOgQ2rZti3vvvde4b5w3bx7y8/Nx+PBhdO/eHU888YRx2V9//RX79+/HlClTqr4hahPhQJs2bRIvvfSS+PbbbwUAsX79+krb79y5UwAQJ0+eFOnp6caHXq+3+DVzc3MFAJGbm1vF6omopowePVoMHjzYZFqvXr3EnXfeKYQQYsWKFUKr1YotW7aIli1bCnd3d9GnTx9x8eJFk2WWLVsmWrZsKdRqtWjRooVYtGiRcV5qaqoAIL755hvRvXt34erqKqKjo8W+fftM1rFu3ToRFRUlVCqVCA0NFW+//bZxXrdu3QQAk0dBQYHw9PQUX3/9tcl61q9fL9zc3EReXp7xtb/44gsRFxcn1Gq1aNWqldi1a5ex/Y3vv+zsbOO0hIQE0a1bN+Hq6iq8vLxE7969xdWrV4UQQmzevFl06dJFaLVa4ePjIwYMGCBOnz5d7v0mJSWVW78lNZtzu9cUQojz58+Lhx56SHh7ews3NzcRGxsrfv31V7FixYpy227FihVCCGGyf4iLixPPPfecyTqzsrKEk5OT2L17txBCiGvXrolp06aJoKAg4ebmJjp16iR27txptmZ72Lp1q1AoFCb7lZycHCFJkti2bVu59jd+X21xYx/2888/CyGEuHTpkgAg9uzZY2yTl5cnABhfu1+/fmLJkiVCCCGOHTsm3NzchBBClJSUiLZt24rffvvNplpqmjX7b4f23PTr1w+vvfYa7rvvPquW8/PzQ0BAgPGhUNSPo2slBgNmn7qAmH1HEffrMXx28bKjSyJyGFdXV5SUlBifFxUV4e2338Znn32GPXv2IC0tDdOnTzfOX716NV599VXMmzcPx48fx+uvv45XXnkFq1atMlnvSy+9hOnTpyM5ORnNmzfH8OHDjYe/Dh06hAcffBAPPfQQjhw5gtmzZ+OVV17BypUrAQDffvstgoODMWfOHKSnpyM9PR3u7u546KGHsGLFCpPXWbFiBR544AF4enoap82YMQPTpk1DUlIS4uLiMHDgQFy5csXs+09OTsY999yDqKgoJCYmIiEhAQMHDoRerwdwvTdh6tSpOHjwILZv3w6FQoH77rvPpCehItbUfLPbvWZBQQG6deuGCxcu4Pvvv8fvv/+O5557DgaDAcOGDcO0adPQqlUr47YbNmxYudcYOXIk1q5dCyGEcdqXX36JoKAg/Oc//wEATJo0CYmJiVi7di3++OMPDB06FH379sWpU6cqfM/9+vWDh4dHhY9WrVpVuKxOp4MkSSa9Sy4uLlAoFEhISKhwOWuVlJTgo48+glarRdu2bQEADRo0QIsWLfDpp5+isLAQZWVl+PDDD+Hn54fY2FgAQNu2bbFjxw6UlZVh69atiI6OBgC8+eab6N69Ozp06GC3GmuN6s9aloEVPTehoaEiICBA9OzZUyQkJFS6zLVr10Rubq7xcf78+Trbc/P8iTQRsCNJ+N/0WJd+xdFlEVW7m3tuDAaD2LZtm1Cr1WL69OlCCGH8r//mXoJFixYJf39/4/NmzZqJNWvWmKx37ty5Ii4uTgjxb0/G8uXLjfOPHj0qAIjjx48LIYQYMWKE6NWrl8k6ZsyYIaKioozPQ0NDxTvvvGPSZv/+/UKpVBp7kjIzM4WTk5OxZ+bGa8+fP9+4TGlpqQgODhZvvPGGEKJ8z83w4cNFly5dLNh61934D//IkSMmr2mu58aSmm15zQ8//FB4enqKK1fMf2/NmjVLtG3bttz0m/cPN3ppbu6piIuLE88//7wQQohz584JpVIpLly4YLKOe+65R8ycObPCWv/++29x6tSpCh9nz56tcNmsrCyh0WjEM888IwoLC0VBQYGYNGmSACCefPLJcu2t7bn54YcfhLu7u5AkSQQFBYkDBw6YzD9//ryIjY0VkiQJpVIpAgMDxeHDh43zc3JyxPDhw0Xjxo1F165dxdGjR8Vff/0lIiIixOXLl8VTTz0lmjRpIoYOHSpycnIsrqum1ZmeG2sFBgZi6dKl+Oabb/DNN98gJCQE3bt3x+HDhytcJj4+Hlqt1vgICQmpwYqrRgiBfdkFWHPxCvbnFODLjKsQt7T5MuOqQ2ojqmkbN26Eh4cHXFxc0K9fPwwbNgyzZ882zndzc0OzZs2MzwMDA5GVlQXgeo/CmTNn8Pjjj5v8N/7aa6/hzJkzJq9z47/aG+sAYFzP8ePH0aVLF5P2Xbp0walTp4w9JuZ06tQJrVq1MvYSff755wgNDUXXrl1N2sXFxRl/dnJyQocOHXD8+HGz67zRc1ORU6dOYfjw4WjatCk0Gg3CwsIAAGlpaRUuY0vN1rxmcnIyYmJi4OPjY1EN5jRs2BC9e/fG6tWrAQCpqalITEzEyJEjAQBHjhyBXq9H8+bNTT7r3bt3l/usb9aoUSOEh4dX+AgNDa20pq+//ho//PADPDw8oNVqkZOTg/bt29vlyEKPHj2QnJyMffv2oW/fvnjwwQeNv5NCCEycOBF+fn745ZdfcODAAQwZMgQDBw5Eeno6AECr1WLNmjU4d+4cdu/ejaioKDz11FN46623sHr1aqSkpODkyZNwc3PDnDlzqlxvbeDk6AKs0aJFC7Ro0cL4vHPnzjhz5gzeeecdfPbZZ2aXmTlzJqZOnWp8npeXVycCjhACL576Gysu/Nslbe7DUqD+DS6k+qlHjx5YsmQJVCoVgoKC4ORk+hfh7Oxs8lySJOOhi4KCAgDAsmXLcMcdd5i0UyqVFa7nxuBdSw7l3M7YsWOxaNEivPDCC1ixYgUeffTRKg0OdnV1rXT+wIEDERoaimXLliEoKAgGgwGtW7c2OZRn75pv95q3q9lSI0eOxNNPP42FCxdizZo1aNOmDdq0aQPg+metVCpx6NChcp+th4dHhevs168ffvnllwrnh4aG4ujRoxXO7927N86cOYPLly/DyckJXl5eCAgIQNOmTa18d+W5u7sbQ9add96JiIgIfPzxx5g5cyZ27NiBjRs3Ijs7GxqNBgCwePFibNu2DatWrcILL7xQbn0rVqyAl5cXBg8ejP/+978YMmQInJ2dMXToULz66qtVrrc2qFPhxpxOnTpVekxTrVbX6lH2Ffk1t9Ak2ACAuZNeRwY1qJmCiBzsxhe8Lfz9/REUFISUlBTjf/i2iIyMxN69e02m7d27F82bNzfuSFUqldlenIcffhjPPfcc3n//fRw7dgyjR48u1+bXX3819oyUlZXh0KFDmDRpktlaoqOjsX37dvzvf/8rN+/KlSs4efIkli1bZhyHYsvYD0tqtuY1o6OjsXz5cly9etVs701F2+5WgwcPxpNPPoktW7ZgzZo1GDVqlHFeTEwM9Ho9srKyjHVYYvny5SguLq5w/q3huSK+vr4AgB07diArKwuDBg2yuAZLGQwG6HQ6ANfHmgEo10OkUCjMhvJLly5hzpw5xs9Gr9ejtLQUAFBaWmrR9q8L6ny4SU5ONnYdy0lqsc7s9P6+GvxVpIOLQoHxIQ0x0M+rZgsjqqP+97//4emnn4ZWq0Xfvn2h0+lw8OBBZGdnm/TuVmbatGno2LEj5s6di2HDhiExMREffPABFi9ebGwTFhaGPXv24KGHHoJarTbu7Ly9vfHf//4XM2bMQO/evREcHFxu/YsWLUJERAQiIyPxzjvvIDs7G4899pjZWmbOnIk2bdpgwoQJGDduHFQqFXbu3ImhQ4fCx8cHDRo0wEcffYTAwECkpaWZ/Q/+diyp+ea2t3vN4cOH4/XXX8eQIUMQHx+PwMBAJCUlISgoCHFxcQgLC0NqaiqSk5MRHBwMT09Ps/+curu7Y8iQIXjllVdw/PhxDB8+3DivefPmGDlyJEaNGoUFCxYgJiYGly5dwvbt2xEdHY0BAwaYrb9Ro0ZWb5+brVixApGRkWjYsCESExPxzDPP4NlnnzU52pCWloarV68iLS0Ner3eeAHF8PBwY69Sy5YtER8fj/vuuw+FhYWYN28eBg0ahMDAQFy+fBmLFi3ChQsXMHToUADXD2V6e3tj9OjRePXVV+Hq6oply5YhNTXV7HudMmUKpk2bZny/Xbp0wWeffYbevXvjo48+KnfYtc6q5vE/lcrPzxdJSUkiKSlJABD/93//J5KSksS5c+eEEEK88MIL4pFHHjG2f+edd8SGDRvEqVOnxJEjR8QzzzwjFAqF8ZQ4S9SVU8EP5BSYDBy+8fgjr9DRpRHVOHOngt/M3ADN9evXi1u/4lavXi3atWsnVCqV8Pb2Fl27dhXffvutEKL8AFshhMjOzhYATE4jvnEquLOzs2jcuLF46623TF4jMTFRREdHC7VaXe71t2/fLgCIr776ymT6jddes2aN6NSpk1CpVCIqKkrs2LHD2MbcqeC7du0SnTt3Fmq1Wnh5eYk+ffoY52/btk1ERkYKtVotoqOjxa5du0wG5t5uQPHtajbndq8phBBnz54V999/v9BoNMLNzU106NBB7N+/Xwhx/QSQ+++/X3h5eVV4KvgNmzZtEgBE165dy9VRUlIiXn31VREWFiacnZ1FYGCguO+++8Qff/xx2/dgq+eff174+/sLZ2dnERERIRYsWCAMBoNJm9GjR5c73f3W36+b33dxcbG47777RFBQkFCpVCIwMFAMGjSo3IDi3377TfTu3Vv4+PgIT09Pceedd4pNmzaVq3HLli2iU6dOJpdPKSwsFEOHDhWenp7innvuEZmZmfbbKHZmzf7boeHmxh/TrY/Ro0cLIa7/InTr1s3Y/o033hDNmjUTLi4uwsfHR3Tv3t3kj98SdSXcCCHE3NMXTILN2ynpji6JiKrg008/FQ0aNBA6nc5kurlgVVtUVDNRTbNm/y0JcdPFAuqBvLw8aLVa5ObmGgdf1Wa/5xchtUiHcDc1Wnu6ObocIrJBUVER0tPTMWjQIAwZMgTz5s0zmX/27Fk0adIESUlJZm8/4Ai3q5moplmz/65Tp4LXR2093TDE35vBhqgOe/PNN9GyZUsEBARg5syZji7HInWxZqIb2HNDREREtR57boiIiKjeYrghIiIiWWG4ISIiIllhuCEiIiJZqfNXKK7rCsv02HYlD8UGAzp7eSDUte7dKoKIiKg2YbhxoCslZRh4+BRS/rnVglohYXV0U9zl7engyoiIiOouHpZyoAVnM3Du2r/3kCo1CEw+lubAioiIiOo+hhsHSinSQX/TVYYMANJLSlFmqFeXHiIiIrIrhhsHauHhAuVNzxUAGruo4KSQHFUSERFRncdw40DTwgIQ6eFqfO6mVGBxVKgDKyIiIqr7OKDYgTROSvwYG4HEnAIU6Q3oqHVHQ5Wzo8siIiKq0xhuHEytUKC7D+9xRUREZC88LEVERESywnBDREREssJwQ0RERLLCMTc1TG8QOJWVDyGACD8POCmZL4mIiOyp3oabwsJCKJXKctOVSiVcXFxM2lVEoVDA1dXV4rZ/55dh6JJE5BSXwlB6DU0buGHlY3egoafp/aQkSYKbm5vxeVFREYQwf2G/W9sWFxfDYDBUWIe7u7tNba9duwa9Xm+Xtm5ubpCk69fy0el0KCsrs0tbV1dXKBTXw2JJSQlKS0vt0tbFxcX4u2JN29LSUpSUlFTYVq1Ww8nJyeq2ZWVl0Ol0FbZVqVRwdna2uq1er8e1a9cqbOvs7AyVSmV1W4PBgOLiYru0dXJyglp9/e9FCIGioiK7tLXm7746vyNubmvN3z2/I/gdUV++Iywm6pnc3FwBoMJH//79Tdq7ublV2LZbt24mbX19fStsG9M+VkS8+KMIfX6jCH1+o1Bq/CpsGxUVZbLeqKioCtuGhoaatO3QoUOFbX19fU3aduvWrcK2bm5uJm379+9f6Xa72QMPPFBp24KCAmPb0aNHV9o2KyvL2HbChAmVtk1NTTW2nT59eqVt//zzT2PbWbNmVdr2wIEDxrZvvvlmpW137txpbPvBBx9U2nbjxo3GtitWrKi07VdffWVs+9VXX1XadsWKFca2GzdurLTtBx98YGy7c+fOStu++eabxrYHDhyotO2sWbOMbf/8889K206fPt3YNjU1tdK2EyZMMLbNysqqtO3o0aONbQsKCipt+8ADD5j8DlfWtrq+Izp06GDSNjQ0tMK2/I7498HviOuP+vAdcWP/nZubK26Hx0RqSMqlApTcfK8FIiIiqhaSEBX0ZcpUXl4etFotLl68CI2m/PVlqqPLee/pSxj76WEonP89/GQovQYIIMhLje3Tepi0Z5ezbW3Z5XxdXe5y5mEpHpYC+B1xA78jTNve2H/n5uaa3X/frN6GG0s2jr18l3wBz6xNNjtvycj26NcmsEbqICIiqqus2X/zsFQNaBvsZfZmmLPujWKwISIisjOGmxoQ5uuO9x6KgYvT9c2tdlLg/eExePSuJg6ujIiISH7q7angNW1AdCDubumHjLxrCNC4wFVV/jR0IiIiqjqGmxrkqlKiia/77RsSERGRzXhYioiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkxcnRBchBdqEODyxJxJnLhZAAdG3ui0/GdIJSITm6NCIionqHPTd2cN/ifThzuRAAIADs/usypqxNcmxRRERE9RTDTRXpyvQ4e6Wo3PQdJ7McUA0REREx3FSRUjJ/6Kmi6URERFS9GG6qyEmpQMcw73LTR3Rq7IBqiIiIiOHGDtaMvQO9Iv3grlJC4+KEcd2a4oX+kY4ui4iIqF7i2VJ24OykxLLRHR1dBhEREYE9N0RERCQzDDdEREQkKww3REREJCsMN0RERCQrDDdEREQkKww3REREJCsMN0RERCQrDg03e/bswcCBAxEUFARJkrBhw4bbLrNr1y60b98earUa4eHhWLlyZbXXSURERHWHQ8NNYWEh2rZti0WLFlnUPjU1FQMGDECPHj2QnJyMKVOmYOzYsdi6dWs1V0pERER1hUOvUNyvXz/069fP4vZLly5FkyZNsGDBAgBAZGQkEhIS8M4776BPnz5ml9HpdNDpdMbneXl5VSuaiIiIarU6NeYmMTERPXv2NJnWp08fJCYmVrhMfHw8tFqt8RESElLdZRIREZED1alwk5GRAX9/f5Np/v7+yMvLQ3FxsdllZs6cidzcXOPj/PnzNVEqEREROYjsb5ypVquhVquNz4UQAHh4ioiIqC65sd++sR+vTJ0KNwEBAcjMzDSZlpmZCY1GA1dXV4vWkZ+fDwA8PEVERFQH5efnQ6vVVtqmToWbuLg4bNq0yWTatm3bEBcXZ/E6goKCcP78eXh6ekKSJHuXSGbk5eUhJCQE58+fh0ajcXQ59Qq3veNw2zsWt7/jVNe2F0IgPz8fQUFBt23r0HBTUFCA06dPG5+npqYiOTkZPj4+aNy4MWbOnIkLFy7g008/BQCMGzcOH3zwAZ577jk89thj2LFjB7766iv8+OOPFr+mQqFAcHCw3d8L3Z5Go+GXjINw2zsOt71jcfs7TnVs+9v12Nzg0AHFBw8eRExMDGJiYgAAU6dORUxMDF599VUAQHp6OtLS0oztmzRpgh9//BHbtm1D27ZtsWDBAixfvrzC08CJiIio/nFoz0337t0rHRhk7urD3bt3R1JSUjVWRURERHVZnToVnOomtVqNWbNmmZy1RjWD295xuO0di9vfcWrDtpeEJedUEREREdUR7LkhIiIiWWG4ISIiIllhuCEiIiJZYbghIiIiWWG4IbtYtGgRwsLC4OLigjvuuAMHDhyosO2yZcvwn//8B97e3vD29kbPnj0rbU+Vs2bb32zt2rWQJAlDhgyp3gJlzNptn5OTg4kTJyIwMBBqtRrNmzcvd9V1soy12/7dd99FixYt4OrqipCQEDz77LO4du1aDVUrH3v27MHAgQMRFBQESZKwYcOG2y6za9cutG/fHmq1GuHh4WYv82J3gqiK1q5dK1Qqlfjkk0/E0aNHxRNPPCG8vLxEZmam2fYjRowQixYtEklJSeL48eNizJgxQqvVir///ruGK6/7rN32N6SmpopGjRqJ//znP2Lw4ME1U6zMWLvtdTqd6NChg+jfv79ISEgQqampYteuXSI5ObmGK6/7rN32q1evFmq1WqxevVqkpqaKrVu3isDAQPHss8/WcOV136ZNm8RLL70kvv32WwFArF+/vtL2KSkpws3NTUydOlUcO3ZMLFy4UCiVSrFly5ZqrZPhhqqsU6dOYuLEicbner1eBAUFifj4eIuWLysrE56enmLVqlXVVaJs2bLty8rKROfOncXy5cvF6NGjGW5sZO22X7JkiWjatKkoKSmpqRJly9ptP3HiRHH33XebTJs6daro0qVLtdYpd5aEm+eee060atXKZNqwYcNEnz59qrEyIXhYiqqkpKQEhw4dQs+ePY3TFAoFevbsicTERIvWUVRUhNLSUvj4+FRXmbJk67afM2cO/Pz88Pjjj9dEmbJky7b//vvvERcXh4kTJ8Lf3x+tW7fG66+/Dr1eX1Nly4It275z5844dOiQ8dBVSkoKNm3ahP79+9dIzfVZYmKiyWcFAH369LF4/2CrOnVXcKp9Ll++DL1eD39/f5Pp/v7+OHHihEXreP755xEUFFTuD4AqZ8u2T0hIwMcff4zk5OQaqFC+bNn2KSkp2LFjB0aOHIlNmzbh9OnTmDBhAkpLSzFr1qyaKFsWbNn2I0aMwOXLl3HXXXdBCIGysjKMGzcOL774Yk2UXK9lZGSY/azy8vJQXFwMV1fXanld9tyQQ82fPx9r167F+vXr4eLi4uhyZC0/Px+PPPIIli1bBl9fX0eXU+8YDAb4+fnho48+QmxsLIYNG4aXXnoJS5cudXRpsrdr1y68/vrrWLx4MQ4fPoxvv/0WP/74I+bOnevo0qiasOeGqsTX1xdKpRKZmZkm0zMzMxEQEFDpsm+//Tbmz5+Pn3/+GdHR0dVZpixZu+3PnDmDs2fPYuDAgcZpBoMBAODk5ISTJ0+iWbNm1Vu0TNjyex8YGAhnZ2colUrjtMjISGRkZKCkpAQqlapaa5YLW7b9K6+8gkceeQRjx44FALRp0waFhYV48skn8dJLL0Gh4P/51SUgIMDsZ6XRaKqt1wZgzw1VkUqlQmxsLLZv326cZjAYsH37dsTFxVW43Jtvvom5c+diy5Yt6NChQ02UKjvWbvuWLVviyJEjSE5ONj4GDRqEHj16IDk5GSEhITVZfp1my+99ly5dcPr0aWOgBIC//voLgYGBDDZWsGXbFxUVlQswN0Km4O0Vq1VcXJzJZwUA27Ztq3T/YBfVOlyZ6oW1a9cKtVotVq5cKY4dOyaefPJJ4eXlJTIyMoQQQjzyyCPihRdeMLafP3++UKlUYt26dSI9Pd34yM/Pd9RbqLOs3fa34tlStrN226elpQlPT08xadIkcfLkSbFx40bh5+cnXnvtNUe9hTrL2m0/a9Ys4enpKb744guRkpIifvrpJ9GsWTPx4IMPOuot1Fn5+fkiKSlJJCUlCQDi//7v/0RSUpI4d+6cEEKIF154QTzyyCPG9jdOBZ8xY4Y4fvy4WLRoEU8Fp7pj4cKFonHjxkKlUolOnTqJX3/91TivW7duYvTo0cbnoaGhAkC5x6xZs2q+cBmwZtvfiuGmaqzd9vv27RN33HGHUKvVomnTpmLevHmirKyshquWB2u2fWlpqZg9e7Zo1qyZcHFxESEhIWLChAkiOzu75guv43bu3Gn2+/vG9h49erTo1q1buWXatWsnVCqVaNq0qVixYkW11ykJwT45IiIikg+OuSEiIiJZYbghIiIiWWG4ISIiIllhuCEiIiJZYbghIiIiWWG4ISIiIllhuCEiIiJZYbghIiIiWWG4ISIiIllhuCEi2enTpw+USiV+++23cvPGjBkDSZIgSRJUKhXCw8MxZ84clJWVOaBSIqoODDdEJCtpaWnYt28fJk2ahE8++cRsm759+yI9PR2nTp3CtGnTMHv2bLz11ls1XCkRVReGGyKqlbp3747JkydjypQp8Pb2hr+/P5YtW4bCwkI8+uij8PT0RHh4ODZv3myy3IoVK3Dvvfdi/Pjx+OKLL1BcXFxu3Wq1GgEBAQgNDcX48ePRs2dPfP/99zX11oiomjHcEFGttWrVKvj6+uLAgQOYPHkyxo8fj6FDh6Jz5844fPgwevfujUceeQRFRUUAACEEVqxYgYcffhgtW7ZEeHg41q1bd9vXcXV1RUlJSXW/HSKqIQw3RFRrtW3bFi+//DIiIiIwc+ZMuLi4wNfXF0888QQiIiLw6quv4sqVK/jjjz8AAD///DOKiorQp08fAMDDDz+Mjz/+uML1CyHw888/Y+vWrbj77rtr5D0RUfVjuCGiWis6Otr4s1KpRIMGDdCmTRvjNH9/fwBAVlYWAOCTTz7BsGHD4OTkBAAYPnw49u7dizNnzpisd+PGjfDw8ICLiwv69euHYcOGYfbs2dX8boiopjDcEFGt5ezsbPJckiSTaZIkAQAMBgOuXr2K9evXY/HixXBycoKTkxMaNWqEsrKycgOLe/TogeTkZJw6dQrFxcVYtWoV3N3dq/8NEVGNcHJ0AURE9rB69WoEBwdjw4YNJtN/+uknLFiwAHPmzIFSqQQAuLu7Izw83AFVElFNYLghIln4+OOP8cADD6B169Ym00NCQjBz5kxs2bIFAwYMcFB1RFSTeFiKiOq8M2fO4Pfff8f9999fbp5Wq8U999xT6cBiIpIXSQghHF0EERERkb2w54aIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZIXhhoiIiGSF4YaIiIhkheGGiIiIZOX/AXv7O32WPN5KAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -2479,7 +2479,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1dfaedfbdea44ec4ba89eb7d49a4d9ea", + "model_id": "d6f90c7f26924332b4a4e23ba90dd98e", "version_major": 2, "version_minor": 0 }, @@ -2493,7 +2493,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b7e2c7e2ab214da09395dab1d71b9221", + "model_id": "e6891153024b485a92a556545e04a8eb", "version_major": 2, "version_minor": 0 }, @@ -2534,43 +2534,43 @@ " \n", " \n", " \n", - " 54\n", + " 52\n", " BRD-A69636825-003-04-7\n", " 0.500000\n", " 1\n", - " 46\n", + " 42\n", " HTR3A\n", " \n", " \n", - " 34\n", + " 32\n", " BRD-A72309220-001-04-1\n", - " 0.396412\n", + " 0.406071\n", " 4\n", - " 46\n", + " 42\n", " HTR1A\n", " \n", " \n", - " 39\n", + " 37\n", " BRD-A72309220-001-04-1\n", " 0.142857\n", " 1\n", - " 43\n", + " 39\n", " HTR1B\n", " \n", " \n", - " 41\n", + " 39\n", " BRD-A72309220-001-04-1\n", " 0.142857\n", " 1\n", - " 43\n", + " 39\n", " HTR1D\n", " \n", " \n", - " 43\n", + " 41\n", " BRD-A72309220-001-04-1\n", " 0.142857\n", " 1\n", - " 43\n", + " 39\n", " HTR1E\n", " \n", " \n", @@ -2584,25 +2584,25 @@ " \n", " 16\n", " BRD-K74363950-004-01-0\n", - " 0.094538\n", + " 0.105128\n", " 2\n", - " 46\n", + " 42\n", " CHRM3\n", " \n", " \n", " 19\n", " BRD-K74363950-004-01-0\n", - " 0.094538\n", + " 0.105128\n", " 2\n", - " 46\n", + " 42\n", " CHRM4\n", " \n", " \n", " 22\n", " BRD-K74363950-004-01-0\n", - " 0.094538\n", + " 0.105128\n", " 2\n", - " 46\n", + " 42\n", " CHRM5\n", " \n", " \n", @@ -2610,50 +2610,50 @@ " BRD-K76908866-001-07-6\n", " 0.500000\n", " 1\n", - " 46\n", + " 42\n", " ERBB2\n", " \n", " \n", - " 63\n", + " 61\n", " BRD-K81258678-001-01-0\n", " 0.100000\n", " 1\n", - " 46\n", + " 42\n", " RELA\n", " \n", " \n", "\n", - "

66 rows × 5 columns

\n", + "

64 rows × 5 columns

\n", "" ], "text/plain": [ " Metadata_broad_sample average_precision n_pos_pairs n_total_pairs \\\n", - "54 BRD-A69636825-003-04-7 0.500000 1 46 \n", - "34 BRD-A72309220-001-04-1 0.396412 4 46 \n", - "39 BRD-A72309220-001-04-1 0.142857 1 43 \n", - "41 BRD-A72309220-001-04-1 0.142857 1 43 \n", - "43 BRD-A72309220-001-04-1 0.142857 1 43 \n", + "52 BRD-A69636825-003-04-7 0.500000 1 42 \n", + "32 BRD-A72309220-001-04-1 0.406071 4 42 \n", + "37 BRD-A72309220-001-04-1 0.142857 1 39 \n", + "39 BRD-A72309220-001-04-1 0.142857 1 39 \n", + "41 BRD-A72309220-001-04-1 0.142857 1 39 \n", ".. ... ... ... ... \n", - "16 BRD-K74363950-004-01-0 0.094538 2 46 \n", - "19 BRD-K74363950-004-01-0 0.094538 2 46 \n", - "22 BRD-K74363950-004-01-0 0.094538 2 46 \n", - "28 BRD-K76908866-001-07-6 0.500000 1 46 \n", - "63 BRD-K81258678-001-01-0 0.100000 1 46 \n", + "16 BRD-K74363950-004-01-0 0.105128 2 42 \n", + "19 BRD-K74363950-004-01-0 0.105128 2 42 \n", + "22 BRD-K74363950-004-01-0 0.105128 2 42 \n", + "28 BRD-K76908866-001-07-6 0.500000 1 42 \n", + "61 BRD-K81258678-001-01-0 0.100000 1 42 \n", "\n", " Metadata_target \n", - "54 HTR3A \n", - "34 HTR1A \n", - "39 HTR1B \n", - "41 HTR1D \n", - "43 HTR1E \n", + "52 HTR3A \n", + "32 HTR1A \n", + "37 HTR1B \n", + "39 HTR1D \n", + "41 HTR1E \n", ".. ... \n", "16 CHRM3 \n", "19 CHRM4 \n", "22 CHRM5 \n", "28 ERBB2 \n", - "63 RELA \n", + "61 RELA \n", "\n", - "[66 rows x 5 columns]" + "[64 rows x 5 columns]" ] }, "execution_count": 13, @@ -2700,7 +2700,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e4cf611dd48f421a92039c551475d6e8", + "model_id": "587b411cad734aa9ab356ee6ba537fd5", "version_major": 2, "version_minor": 0 }, @@ -2714,12 +2714,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "36db5ef9e7e24a55899d35ab9b7d746a", + "model_id": "c051523be08049089850e2cda87e7b5c", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/27 [00:00\n", " 0\n", " ADRA1A\n", - " 0.238095\n", - " 0.104890\n", - " 0.167542\n", + " 0.250000\n", + " 0.113389\n", + " 0.192056\n", " False\n", " False\n", - " 0.775876\n", + " 0.716573\n", " \n", " \n", " 1\n", " ADRA2A\n", - " 0.238095\n", - " 0.104890\n", - " 0.167542\n", + " 0.250000\n", + " 0.113389\n", + " 0.192056\n", " False\n", " False\n", - " 0.775876\n", + " 0.716573\n", " \n", " \n", " 2\n", " AURKA\n", " 0.625000\n", - " 0.022298\n", - " 0.100340\n", + " 0.023398\n", + " 0.101390\n", " True\n", " False\n", - " 0.998526\n", + " 0.994005\n", " \n", " \n", " 3\n", " BIRC2\n", - " 0.051316\n", - " 0.413459\n", - " 0.483152\n", + " 0.060662\n", + " 0.379062\n", + " 0.469315\n", " False\n", " False\n", - " 0.315917\n", + " 0.328536\n", " \n", " \n", " 4\n", " CHRM1\n", - " 0.091024\n", - " 0.483152\n", - " 0.483152\n", + " 0.098420\n", + " 0.484752\n", + " 0.484752\n", " False\n", " False\n", - " 0.315917\n", + " 0.314481\n", " \n", " \n", " 5\n", " CHRM2\n", - " 0.091024\n", - " 0.483152\n", - " 0.483152\n", + " 0.098420\n", + " 0.484752\n", + " 0.484752\n", " False\n", " False\n", - " 0.315917\n", + " 0.314481\n", " \n", " \n", " 6\n", " CHRM3\n", - " 0.091024\n", - " 0.483152\n", - " 0.483152\n", + " 0.098420\n", + " 0.484752\n", + " 0.484752\n", " False\n", " False\n", - " 0.315917\n", + " 0.314481\n", " \n", " \n", " 7\n", " CHRM4\n", - " 0.091024\n", - " 0.483152\n", - " 0.483152\n", + " 0.098420\n", + " 0.484752\n", + " 0.484752\n", " False\n", " False\n", - " 0.315917\n", + " 0.314481\n", " \n", " \n", " 8\n", " CHRM5\n", - " 0.091024\n", - " 0.483152\n", - " 0.483152\n", + " 0.098420\n", + " 0.484752\n", + " 0.484752\n", " False\n", " False\n", - " 0.315917\n", + " 0.314481\n", " \n", " \n", " 9\n", " DRD2\n", " 0.750000\n", " 0.000900\n", - " 0.006074\n", + " 0.005849\n", " True\n", " True\n", - " 2.216497\n", + " 2.232888\n", " \n", " \n", "\n", @@ -2862,28 +2862,28 @@ ], "text/plain": [ " Metadata_target mean_average_precision p_value corrected_p_value \\\n", - "0 ADRA1A 0.238095 0.104890 0.167542 \n", - "1 ADRA2A 0.238095 0.104890 0.167542 \n", - "2 AURKA 0.625000 0.022298 0.100340 \n", - "3 BIRC2 0.051316 0.413459 0.483152 \n", - "4 CHRM1 0.091024 0.483152 0.483152 \n", - "5 CHRM2 0.091024 0.483152 0.483152 \n", - "6 CHRM3 0.091024 0.483152 0.483152 \n", - "7 CHRM4 0.091024 0.483152 0.483152 \n", - "8 CHRM5 0.091024 0.483152 0.483152 \n", - "9 DRD2 0.750000 0.000900 0.006074 \n", + "0 ADRA1A 0.250000 0.113389 0.192056 \n", + "1 ADRA2A 0.250000 0.113389 0.192056 \n", + "2 AURKA 0.625000 0.023398 0.101390 \n", + "3 BIRC2 0.060662 0.379062 0.469315 \n", + "4 CHRM1 0.098420 0.484752 0.484752 \n", + "5 CHRM2 0.098420 0.484752 0.484752 \n", + "6 CHRM3 0.098420 0.484752 0.484752 \n", + "7 CHRM4 0.098420 0.484752 0.484752 \n", + "8 CHRM5 0.098420 0.484752 0.484752 \n", + "9 DRD2 0.750000 0.000900 0.005849 \n", "\n", " below_p below_corrected_p -log10(p-value) \n", - "0 False False 0.775876 \n", - "1 False False 0.775876 \n", - "2 True False 0.998526 \n", - "3 False False 0.315917 \n", - "4 False False 0.315917 \n", - "5 False False 0.315917 \n", - "6 False False 0.315917 \n", - "7 False False 0.315917 \n", - "8 False False 0.315917 \n", - "9 True True 2.216497 " + "0 False False 0.716573 \n", + "1 False False 0.716573 \n", + "2 True False 0.994005 \n", + "3 False False 0.328536 \n", + "4 False False 0.314481 \n", + "5 False False 0.314481 \n", + "6 False False 0.314481 \n", + "7 False False 0.314481 \n", + "8 False False 0.314481 \n", + "9 True True 2.232888 " ] }, "execution_count": 14, @@ -2913,7 +2913,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2990,7 +2990,7 @@ ], "metadata": { "kernelspec": { - "display_name": "copairs", + "display_name": "map_benchmark", "language": "python", "name": "python3" }, @@ -3004,7 +3004,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 2133055..1d0645c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,6 +17,7 @@ dependencies = [ ] [project.optional-dependencies] +dev = ["ruff"] plot = ["plotly"] test = ["scikit-learn", "pytest"] demo = ["notebook", "matplotlib"] @@ -31,4 +32,4 @@ requires = ["setuptools"] build-backend = "setuptools.build_meta" [tool.setuptools.packages.find] -where = ["src"] +where = ["src"] diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 0000000..42ebdad --- /dev/null +++ b/tests/README.md @@ -0,0 +1,25 @@ + # Unit tests + +We use `pytest` package to implement and run unit tests for copairs. + +## Getting started + +### Installation + +To install copairs with test dependencies, check out code locally and install as: +```bash +pip install -e .[test] +``` + +### Running tests +To execute all tests, run: +```bash +pytest +``` + +Each individual `test_filename.py` file implements tests for particular features in the corresponding `copairs/filename.py`. + +To run tests for a particular source file, specify its test file: +```bash +pytest tests/test_map.py +``` diff --git a/tests/__init__.py b/tests/__init__.py index e69de29..b185083 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -0,0 +1 @@ +"""Unit tests for the copairs package.""" diff --git a/tests/helpers.py b/tests/helpers.py index a7a4c25..57207a5 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -1,3 +1,5 @@ +"""Helper functions for testing.""" + from itertools import product from typing import Dict @@ -10,7 +12,7 @@ def simulate_plates(n_compounds, n_replicates, plate_size): - """Round robin creation of platemaps""" + """Round robin creation of platemaps.""" total = n_compounds * n_replicates compounds = [] @@ -35,6 +37,7 @@ def simulate_random_plates( sameby=ColumnList, diffby=ColumnList, ): + """Simulate random platemaps.""" rng = np.random.default_rng(SEED) dframe = simulate_plates(n_compounds, n_replicates, plate_size) # Shuffle values @@ -52,6 +55,7 @@ def simulate_random_dframe( diffby: ColumnList, rng: np.random.Generator, ): + """Simulate random dataframe.""" dframe = pd.DataFrame(columns=list(vocab_size.keys()), index=range(length)) for col, size in vocab_size.items(): dframe[col] = rng.integers(1, size + 1, size=length) @@ -64,9 +68,7 @@ def simulate_random_dframe( def create_dframe(n_options, n_rows): - """ - Random permutation of a fix number of elements per column - """ + """Create a dataframe with predefined number of plates, wells, and compounds.""" if isinstance(n_options, int): n_options = [n_options] * 3 colc = list(f"c{i}" for i in range(n_options[0])) diff --git a/tests/test_build_rank_multilabel.py b/tests/test_build_rank_multilabel.py index 49b6f08..210a918 100644 --- a/tests/test_build_rank_multilabel.py +++ b/tests/test_build_rank_multilabel.py @@ -1,9 +1,12 @@ +"""Test the concatenation of ranges.""" + import numpy as np from copairs.compute import concat_ranges def naive_concat_ranges(start: np.ndarray, end: np.ndarray): + """Concatenate ranges into a mask.""" mask = [] for s, e in zip(start, end): mask.extend(range(s, e)) @@ -11,6 +14,7 @@ def naive_concat_ranges(start: np.ndarray, end: np.ndarray): def test_concat_ranges(): + """Test the concatenation of ranges.""" rng = np.random.default_rng() num_range = 5, 10 start_range = 2, 10 diff --git a/tests/test_compute.py b/tests/test_compute.py index 63444c7..dfad755 100644 --- a/tests/test_compute.py +++ b/tests/test_compute.py @@ -1,3 +1,5 @@ +"""Test pairwise distance calculation functions.""" + import numpy as np from copairs import compute @@ -7,6 +9,7 @@ def corrcoef_naive(feats, pairs): + """Compute correlation coefficient between pairs of features.""" corr = np.empty((len(pairs),)) for pos, (i, j) in enumerate(pairs): corr[pos] = np.corrcoef(feats[i], feats[j])[0, 1] @@ -14,6 +17,7 @@ def corrcoef_naive(feats, pairs): def cosine_naive(feats, pairs): + """Compute cosine similarity between pairs of features.""" cosine = np.empty((len(pairs),)) for pos, (i, j) in enumerate(pairs): a, b = feats[i], feats[j] @@ -24,6 +28,7 @@ def cosine_naive(feats, pairs): def euclidean_naive(feats, pairs): + """Compute euclidean similarity between pairs of features.""" euclidean_sim = np.empty((len(pairs),)) for pos, (i, j) in enumerate(pairs): dist = np.linalg.norm(feats[i] - feats[j]) @@ -32,10 +37,12 @@ def euclidean_naive(feats, pairs): def abs_cosine_naive(feats, pairs): + """Compute absolute cosine similarity between pairs of features.""" return np.abs(cosine_naive(feats, pairs)) def test_corrcoef(): + """Test correlation coefficient computation.""" n_samples = 10 n_pairs = 20 n_feats = 5 @@ -50,6 +57,7 @@ def test_corrcoef(): def test_cosine(): + """Test cosine similarity computation.""" n_samples = 10 n_pairs = 20 n_feats = 5 @@ -64,6 +72,7 @@ def test_cosine(): def test_euclidean(): + """Test euclidean similarity computation.""" n_samples = 10 n_pairs = 20 n_feats = 5 @@ -78,6 +87,7 @@ def test_euclidean(): def test_abs_cosine(): + """Test absolute cosine similarity computation.""" n_samples = 10 n_pairs = 20 n_feats = 5 diff --git a/tests/test_map.py b/tests/test_map.py index 816d7d8..b18ca9e 100644 --- a/tests/test_map.py +++ b/tests/test_map.py @@ -1,3 +1,5 @@ +"""Tests for (mean) Average Precision calculation.""" + import numpy as np import pandas as pd import pytest @@ -13,6 +15,7 @@ def test_random_binary_matrix(): + """Test the random binary matrix generation.""" rng = np.random.default_rng(SEED) # Test with n=3, m=4, k=2 A = compute.random_binary_matrix(3, 4, 2, rng) @@ -28,6 +31,7 @@ def test_random_binary_matrix(): def test_compute_ap(): + """Test the average precision computation.""" num_pos, num_neg, num_perm = 5, 6, 100 total = num_pos + num_neg @@ -56,6 +60,7 @@ def test_compute_ap(): def test_compute_ap_contiguous(): + """Test the contiguous average precision computation.""" num_pos_range = [2, 9] num_neg_range = [10, 20] num_samples_range = [5, 30] @@ -88,6 +93,7 @@ def test_compute_ap_contiguous(): def test_pipeline(): + """Check the implementation with for mAP calculation.""" length = 10 vocab_size = {"p": 5, "w": 3, "l": 4} n_feats = 5 @@ -103,7 +109,7 @@ def test_pipeline(): def test_pipeline_multilabel(): - """Check the multilabel implementation with for mAP calculation""" + """Check the multilabel implementation with for mAP calculation.""" length = 10 vocab_size = {"p": 3, "w": 5, "l": 4} n_feats = 8 @@ -124,6 +130,7 @@ def test_pipeline_multilabel(): def test_raise_no_pairs(): + """Test the exception raised when no pairs are found.""" length = 10 vocab_size = {"p": 3, "w": 3, "l": 10} n_feats = 5 @@ -143,6 +150,7 @@ def test_raise_no_pairs(): def test_raise_nan_error(): + """Test the exception raised when there are null values.""" length = 10 vocab_size = {"p": 5, "w": 3, "l": 4} n_feats = 8 diff --git a/tests/test_map_filter.py b/tests/test_map_filter.py index 9b1b311..c49e6e2 100644 --- a/tests/test_map_filter.py +++ b/tests/test_map_filter.py @@ -1,3 +1,5 @@ +"""Tests data filtering by query.""" + import numpy as np import pytest @@ -9,6 +11,7 @@ @pytest.fixture def mock_dataframe(): + """Create a mock dataframe.""" length = 10 vocab_size = {"p": 3, "w": 3, "l": 10} pos_sameby = ["l"] @@ -20,6 +23,7 @@ def mock_dataframe(): def test_correct(mock_dataframe): + """Test correct query.""" df, parsed_cols = evaluate_and_filter(mock_dataframe, ["p == 'p1'", "w > 'w2'"]) assert not df.empty assert "p" in parsed_cols and "w" in parsed_cols @@ -27,6 +31,7 @@ def test_correct(mock_dataframe): def test_invalid_query(mock_dataframe): + """Test invalid query.""" with pytest.raises(ValueError) as excinfo: evaluate_and_filter(mock_dataframe, ['l == "lHello"']) assert "Invalid combined query expression" in str(excinfo.value) @@ -34,12 +39,14 @@ def test_invalid_query(mock_dataframe): def test_empty_result(mock_dataframe): + """Test empty result.""" with pytest.raises(ValueError) as excinfo: evaluate_and_filter(mock_dataframe, ['p == "p1"', 'p == "p2"']) assert "Duplicate queries for column" in str(excinfo.value) def test_empty_result_from_valid_query(mock_dataframe): + """Test empty result from valid query.""" with pytest.raises(ValueError) as excinfo: evaluate_and_filter(mock_dataframe, ['p == "p4"']) assert "No data matched the query" in str(excinfo.value) diff --git a/tests/test_matching.py b/tests/test_matching.py index 5bc1132..91c494f 100644 --- a/tests/test_matching.py +++ b/tests/test_matching.py @@ -1,4 +1,4 @@ -"""Test functions for Matcher""" +"""Test functions for Matcher.""" from string import ascii_letters @@ -13,7 +13,7 @@ def run_stress_sample_null(dframe, num_pairs): - """Assert every generated null pair does not match any column""" + """Assert every generated null pair does not match any column.""" matcher = Matcher(dframe, dframe.columns, seed=SEED) for _ in range(num_pairs): id1, id2 = matcher.sample_null_pair(dframe.columns) @@ -23,19 +23,19 @@ def run_stress_sample_null(dframe, num_pairs): def test_null_sample_large(): - """Test Matcher guarantees elements with different values""" + """Test Matcher guarantees elements with different values.""" dframe = create_dframe(32, 10000) run_stress_sample_null(dframe, 5000) def test_null_sample_small(): - """Test Sample with small set""" + """Test Sample with small set.""" dframe = create_dframe(3, 10) run_stress_sample_null(dframe, 100) def test_null_sample_nan_vals(): - """Test NaN values are ignored""" + """Test NaN values are ignored.""" dframe = create_dframe(4, 15) rng = np.random.default_rng(SEED) nan_mask = rng.random(dframe.shape) < 0.5 @@ -44,7 +44,7 @@ def test_null_sample_nan_vals(): def get_naive_pairs(dframe: pd.DataFrame, sameby, diffby): - """Compute valid pairs using cross product from pandas""" + """Compute valid pairs using cross product from pandas.""" cross = dframe.reset_index().merge( dframe.reset_index(), how="cross", suffixes=("_x", "_y") ) @@ -62,7 +62,7 @@ def get_naive_pairs(dframe: pd.DataFrame, sameby, diffby): def check_naive(dframe, matcher: Matcher, sameby, diffby): - """Check Matcher and naive generate same pairs""" + """Check Matcher and naive generate same pairs.""" gt_pairs = get_naive_pairs(dframe, sameby, diffby) vals = matcher.get_all_pairs(sameby, diffby) vals = sum(vals.values(), []) @@ -74,14 +74,14 @@ def check_naive(dframe, matcher: Matcher, sameby, diffby): def check_simulated_data(length, vocab_size, sameby, diffby, rng): - """Test sample of valid pairs from a simulated dataset""" + """Test sample of valid pairs from a simulated dataset.""" dframe = simulate_random_dframe(length, vocab_size, sameby, diffby, rng) matcher = Matcher(dframe, dframe.columns, seed=SEED) check_naive(dframe, matcher, sameby, diffby) def test_stress_simulated_data(): - """Run multiple tests using simulated data""" + """Run multiple tests using simulated data.""" rng = np.random.default_rng(SEED) num_cols_range = [2, 6] vocab_size_range = [5, 10] @@ -99,7 +99,7 @@ def test_stress_simulated_data(): def test_empty_sameby(): - """Test query without sameby""" + """Test query without sameby.""" dframe = create_dframe(3, 10) matcher = Matcher(dframe, dframe.columns, seed=SEED) check_naive(dframe, matcher, sameby=[], diffby=["w", "c"]) @@ -107,7 +107,7 @@ def test_empty_sameby(): def test_empty_diffby(): - """Test query without diffby""" + """Test query without diffby.""" dframe = create_dframe(3, 10) matcher = Matcher(dframe, dframe.columns, seed=SEED) matcher.get_all_pairs(["c"], []) @@ -116,7 +116,7 @@ def test_empty_diffby(): def test_raise_distjoint(): - """Test check for disjoint sameby and diffby""" + """Test check for disjoint sameby and diffby.""" dframe = create_dframe(3, 10) matcher = Matcher(dframe, dframe.columns, seed=SEED) with pytest.raises(ValueError, match="must be disjoint lists"): @@ -124,7 +124,7 @@ def test_raise_distjoint(): def test_raise_no_params(): - """Test check for at least one of sameby and diffby""" + """Test check for at least one of sameby and diffby.""" dframe = create_dframe(3, 10) matcher = Matcher(dframe, dframe.columns, seed=SEED) with pytest.raises(ValueError, match="at least one should be provided"): @@ -132,7 +132,7 @@ def test_raise_no_params(): def assert_sameby_diffby(dframe: pd.DataFrame, pairs_dict: dict, sameby, diffby): - """Assert the pairs are valid""" + """Assert the pairs are valid.""" for _, pairs in pairs_dict.items(): for id1, id2 in pairs: for col in sameby: diff --git a/tests/test_matching_any.py b/tests/test_matching_any.py index 25ccc02..b949613 100644 --- a/tests/test_matching_any.py +++ b/tests/test_matching_any.py @@ -1,3 +1,5 @@ +"""Test matching with `any` conditions using simulated data.""" + from string import ascii_letters import numpy as np @@ -10,7 +12,7 @@ def get_naive_pairs(dframe: pd.DataFrame, sameby, diffby): - """Compute valid pairs using cross product from pandas""" + """Compute valid pairs using cross product from pandas.""" cross = dframe.reset_index().merge( dframe.reset_index(), how="cross", suffixes=("_x", "_y") ) @@ -39,7 +41,7 @@ def get_naive_pairs(dframe: pd.DataFrame, sameby, diffby): def check_naive(dframe, matcher: Matcher, sameby, diffby): - """Check Matcher and naive generate same pairs""" + """Check Matcher and naive generate same pairs.""" gt_pairs = get_naive_pairs(dframe, sameby, diffby) vals = matcher.get_all_pairs(sameby, diffby) vals = sum(vals.values(), []) @@ -51,7 +53,7 @@ def check_naive(dframe, matcher: Matcher, sameby, diffby): def check_simulated_data(length, vocab_size, sameby, diffby, rng): - """Test sample of valid pairs from a simulated dataset""" + """Test sample of valid pairs from a simulated dataset.""" sameby_cols = sameby["all"] + sameby["any"] diffby_cols = diffby["all"] + diffby["any"] dframe = simulate_random_dframe(length, vocab_size, sameby_cols, diffby_cols, rng) @@ -60,7 +62,7 @@ def check_simulated_data(length, vocab_size, sameby, diffby, rng): def test_stress_simulated_data_any_all(): - """Run multiple tests using simulated data""" + """Run multiple tests using simulated data.""" rng = np.random.default_rng(SEED) num_cols_range = [2, 6] vocab_size_range = [5, 10] @@ -78,7 +80,7 @@ def test_stress_simulated_data_any_all(): def test_stress_simulated_data_all_all(): - """Run multiple tests using simulated data""" + """Run multiple tests using simulated data.""" rng = np.random.default_rng(SEED) num_cols_range = [2, 6] vocab_size_range = [5, 10] @@ -96,7 +98,7 @@ def test_stress_simulated_data_all_all(): def test_stress_simulated_data_all_any(): - """Run multiple tests using simulated data""" + """Run multiple tests using simulated data.""" rng = np.random.default_rng(SEED) num_cols_range = [2, 6] vocab_size_range = [5, 10] @@ -114,7 +116,7 @@ def test_stress_simulated_data_all_any(): def test_stress_simulated_data_any_any(): - """Run multiple tests using simulated data""" + """Run multiple tests using simulated data.""" rng = np.random.default_rng(SEED) num_cols_range = [4, 6] vocab_size_range = [5, 10] diff --git a/tests/test_matching_multilabel.py b/tests/test_matching_multilabel.py index 50f978e..0ee6538 100644 --- a/tests/test_matching_multilabel.py +++ b/tests/test_matching_multilabel.py @@ -1,3 +1,5 @@ +"""Tests for the multilabel matching implementation.""" + import pandas as pd from copairs.matching import MatcherMultilabel @@ -7,6 +9,7 @@ def get_naive_pairs(dframe: pd.DataFrame, sameby, diffby, multilabel_col: str): + """Get pairs using a naive implementation.""" dframe = dframe.copy() dframe[multilabel_col] = dframe[multilabel_col].apply(set) @@ -45,7 +48,7 @@ def any_equal(row): def check_naive(dframe, matcher: MatcherMultilabel, sameby, diffby, multilabel_col): - """Check Matcher and naive generate same pairs""" + """Check Matcher and naive generate same pairs.""" gt_pairs = get_naive_pairs(dframe, sameby, diffby, multilabel_col) vals = matcher.get_all_pairs(sameby, diffby) vals = sum(vals.values(), []) @@ -57,7 +60,7 @@ def check_naive(dframe, matcher: MatcherMultilabel, sameby, diffby, multilabel_c def test_sameby(): - """Check the multilabel implementation with sameby""" + """Check the multilabel implementation with sameby.""" multilabel_col = "c" sameby = ["c"] diffby = ["p", "w"] @@ -70,7 +73,7 @@ def test_sameby(): def test_diffby(): - """Check the multilabel implementation with sameby""" + """Check the multilabel implementation with sameby.""" multilabel_col = "c" sameby = ["p"] diffby = ["c", "w"] @@ -84,7 +87,7 @@ def test_diffby(): def test_only_diffby(): - """Check the multilabel implementation with only diffby being equal to c""" + """Check the multilabel implementation with only diffby being equal to c.""" multilabel_col = "c" sameby = [] diffby = ["c"] @@ -97,7 +100,7 @@ def test_only_diffby(): def test_only_diffby_many_cols(): - """Check the multilabel implementation with only diffby being equal to c""" + """Check the multilabel implementation with only diffby being equal to c.""" multilabel_col = "c" sameby = [] diffby = ["c", "w"] @@ -110,7 +113,7 @@ def test_only_diffby_many_cols(): def test_only_sameby_many_cols(): - """Check the multilabel implementation with only diffby being equal to c""" + """Check the multilabel implementation with only diffby being equal to c.""" multilabel_col = "c" sameby = ["c", "w"] diffby = [] diff --git a/tests/test_replicating.py b/tests/test_replicating.py index a273bbe..db9f157 100644 --- a/tests/test_replicating.py +++ b/tests/test_replicating.py @@ -1,3 +1,5 @@ +"""Tests for the replicating module.""" + from numpy.random import default_rng from copairs import Matcher @@ -12,6 +14,7 @@ def test_corr_between_replicates(): + """Test calculating correlation between replicates.""" rng = default_rng(SEED) num_samples = 10 X = rng.normal(size=[num_samples, 6]) @@ -20,6 +23,7 @@ def test_corr_between_replicates(): def test_correlation_test(): + """Test correlation test.""" rng = default_rng(SEED) num_samples = 10 X = rng.normal(size=[num_samples, 6]) @@ -31,6 +35,7 @@ def test_correlation_test(): def test_corr_from_pairs(): + """Test calculating correlation from a list of named pairs.""" num_samples = 10 sameby = ["c"] diffby = ["p", "w"]