From 41be0080c11c54e3663e63f67f54b3bd5401e26e Mon Sep 17 00:00:00 2001 From: Michael Harms Date: Tue, 17 Sep 2024 12:48:41 -0700 Subject: [PATCH] global model now correctly fits itc data --- docs/badges/coverage-badge.svg | 2 +- docs/badges/ghwf.svg | 22 +- docs/badges/tests-badge.svg | 2 +- notebooks/data/itc_binding_expt.csv | 71 +- notebooks/data/itc_blank_expt.csv | 53 +- notebooks/global-fit.ipynb | 610 +++-- reports/flake.txt | 2192 +++++++++-------- reports/junit/junit.xml | 2 +- src/linkage/__version__.py | 2 +- src/linkage/experiment/experiment.py | 4 +- src/linkage/global_model/global_model.py | 2 +- tests/conftest.py | 8 +- tests/data/simulated_itc/binding_expt.csv | 2 +- tests/data/simulated_itc/blank_expt.csv | 2 +- tests/data/simulated_itc/generate_itc_data.py | 8 +- tests/data/simulated_itc/simulated_itc.pdf | Bin 13903 -> 13903 bytes tests/linkage/experiment/test_experiment.py | 6 +- tests/linkage/experiment/test_titrator.py | 2 - tests/linkage/models/test_ca_edta.py | 12 +- 19 files changed, 1748 insertions(+), 1254 deletions(-) diff --git a/docs/badges/coverage-badge.svg b/docs/badges/coverage-badge.svg index 239ca49..0d660de 100644 --- a/docs/badges/coverage-badge.svg +++ b/docs/badges/coverage-badge.svg @@ -1 +1 @@ -coverage: 67.27%coverage67.27% \ No newline at end of file +coverage: 85.67%coverage85.67% \ No newline at end of file diff --git a/docs/badges/ghwf.svg b/docs/badges/ghwf.svg index 0b6100d..8f37796 100644 --- a/docs/badges/ghwf.svg +++ b/docs/badges/ghwf.svg @@ -1,32 +1,32 @@ - - dataprob - failing + + linkage - passing - - + + - + - + - dataprob + linkage - - + + - failing + passing diff --git a/docs/badges/tests-badge.svg b/docs/badges/tests-badge.svg index cd16718..37c07b2 100644 --- a/docs/badges/tests-badge.svg +++ b/docs/badges/tests-badge.svg @@ -1 +1 @@ -tests: 34tests34 \ No newline at end of file +tests: 46tests46 \ No newline at end of file diff --git a/notebooks/data/itc_binding_expt.csv b/notebooks/data/itc_binding_expt.csv index a2a84f9..1f6e252 100644 --- a/notebooks/data/itc_binding_expt.csv +++ b/notebooks/data/itc_binding_expt.csv @@ -1,27 +1,44 @@ -injection,heat -0.0, -2.0,-0.6698887856953665 -2.0,-0.6653981051510617 -2.0,-0.6628770104848354 -2.0,-0.6572600039805307 -2.0,-0.6544483711885344 -2.0,-0.6504849636862378 -2.0,-0.6404583989405751 -2.0,-0.6376838389904914 -2.0,-0.6378359001575715 -2.0,-0.633540956451369 -2.0,-0.6251375384830915 -2.0,-0.6201433401680164 -2.0,-0.6151452055627816 -2.0,-0.5484958725734232 -2.0,-0.2920939813000814 -2.0,-0.23494590560590042 -2.0,-0.22694817238908618 -2.0,-0.22704683549278215 -2.0,-0.2229765373934299 -2.0,-0.22315231943129848 -2.0,-0.2261348200467626 -2.0,-0.22047538531018618 -2.0,-0.21948399323774065 -2.0,-0.21865938338939592 -2.0,-0.2160287541946412 +injection,obs_heat,std_heat,ignore_point +2.35e-6,-43.55239e-6,0.01,True +1.5001e-6,-55.15164e-6,0.01,False +1.5001e-6,-55.24487e-6,0.01,False +1.5001e-6,-55.11563e-6,0.01,False +1.5001e-6,-52.6072e-6,0.01,False +1.5001e-6,-55.83644e-6,0.01,False +1.5001e-6,-54.91872e-6,0.01,False +1.5001e-6,-55.06646e-6,0.01,False +1.5001e-6,-55.40612e-6,0.01,False +1.5001e-6,-55.7207e-6,0.01,False +1.5001e-6,-55.19716e-6,0.01,False +1.5001e-6,-54.87701e-6,0.01,False +1.5001e-6,-54.82708e-6,0.01,False +1.5001e-6,-54.7709e-6,0.01,False +1.5001e-6,-54.71221e-6,0.01,False +1.5001e-6,-54.40994e-6,0.01,False +0.5001e-6,-17.93324e-6,0.01,False +0.5001e-6,-17.89662e-6,0.01,False +0.5001e-6,-17.85996e-6,0.01,False +0.5001e-6,-17.79867e-6,0.01,False +0.5001e-6,-17.78522e-6,0.01,False +0.5001e-6,-17.73078e-6,0.01,False +0.5001e-6,-17.80013e-6,0.01,False +0.5001e-6,-17.52538e-6,0.01,False +0.5001e-6,-17.28763e-6,0.01,False +0.5001e-6,-16.42499e-6,0.01,False +0.5001e-6,-13.54416e-6,0.01,False +0.5001e-6,-5.9964e-6,0.01,False +0.5001e-6,-1.48915e-6,0.01,False +0.5001e-6,-0.56002e-6,0.01,False +0.5001e-6,-0.30253e-6,0.01,False +0.5001e-6,-0.18791e-6,0.01,False +0.5001e-6,-0.09908e-6,0.01,False +0.5001e-6,-0.09056e-6,0.01,False +0.5001e-6,-0.07653e-6,0.01,False +0.5001e-6,0.00793e-6,0.01,False +0.5001e-6,-0.03339e-6,0.01,False +0.5001e-6,-0.04315e-6,0.01,False +0.5001e-6,0.0484e-6,0.01,False +0.5001e-6,-0.04435e-6,0.01,False +0.5001e-6,-0.01707e-6,0.01,False +0.5001e-6,-0.05095e-6,0.01,False +0.5001e-6,-0.03682e-6,0.01,False diff --git a/notebooks/data/itc_blank_expt.csv b/notebooks/data/itc_blank_expt.csv index 0c60f8a..7d6cfb7 100644 --- a/notebooks/data/itc_blank_expt.csv +++ b/notebooks/data/itc_blank_expt.csv @@ -1,27 +1,26 @@ -injection,heat -0.0, -2.0,-0.2442462588685921 -2.0,-0.24295005228246766 -2.0,-0.23557114377762883 -2.0,-0.23844502898873843 -2.0,-0.23933754638183913 -2.0,-0.2443435490673292 -2.0,-0.23589295931746368 -2.0,-0.2380656119509871 -2.0,-0.2330682723652203 -2.0,-0.2279854541512425 -2.0,-0.23190528384682552 -2.0,-0.23464743869038096 -2.0,-0.2366097006847176 -2.0,-0.22320395204965413 -2.0,-0.22823351798594146 -2.0,-0.2300511120307936 -2.0,-0.2209894117300196 -2.0,-0.21866333693069204 -2.0,-0.223161934647072 -2.0,-0.21805199016761126 -2.0,-0.21495030878756455 -2.0,-0.2142776639631268 -2.0,-0.20871828135605286 -2.0,-0.2174045643244037 -2.0,-0.21417738451534674 +injection,obs_heat,heat_std,ignore_point +2.35e-6,-1.7491e-6,0,True +1.5e-6,0.08709e-6,0,False +1.5e-6,-0.05587e-6,0,False +1.5e-6,0.01021e-6,0,False +1.5e-6,1.75655e-6,0,False +1.5e-6,-1.86322e-6,0,False +1.5e-6,-0.01909e-6,0,False +1.5e-6,-0.09784e-6,0,False +1.5e-6,-0.14389e-6,0,False +1.5e-6,-0.17952e-6,0,False +1.5e-6,-0.09946e-6,0,False +1.5e-6,-0.01915e-6,0,False +1.5e-6,-0.02182e-6,0,False +1.5e-6,-0.03853e-6,0,False +1.5e-6,-0.03838e-6,0,False +1.5e-6,-0.0531e-6,0,False +1.5e-6,-0.05101e-6,0,False +1.5e-6,-0.07015e-6,0,False +1.5e-6,-0.02583e-6,0,False +1.5e-6,0.00199e-6,0,False +1.5e-6,-0.01206e-6,0,False +1.5e-6,-0.08337e-6,0,False +1.5e-6,-0.08477e-6,0,False +1.5e-6,-0.01629e-6,0,False +1.5e-6,-0.05862e-6,0,False diff --git a/notebooks/global-fit.ipynb b/notebooks/global-fit.ipynb index d5e5f32..cfb0c94 100644 --- a/notebooks/global-fit.ipynb +++ b/notebooks/global-fit.ipynb @@ -36,17 +36,19 @@ "\n", "blank = linkage.experiment.Experiment(\"data/itc_blank_expt.csv\",\n", " cell_contents={},\n", - " syringe_contents={\"ET\":5e-3},\n", - " cell_volume=280)\n", - "blank.define_itc_observable(obs_column=\"heat\",\n", - " obs_stdev=0.01)\n", + " syringe_contents={\"ET\":4e-3},\n", + " cell_volume=201.3e-6,\n", + " conc_to_float=\"ET\")\n", + "blank.define_itc_observable(obs_column=\"obs_heat\",\n", + " obs_std=1e-6)\n", "\n", "binding = linkage.experiment.Experiment(\"data/itc_binding_expt.csv\",\n", " cell_contents={\"CT\":0.5e-3},\n", - " syringe_contents={\"ET\":5e-3},\n", - " cell_volume=280)\n", - "binding.define_itc_observable(obs_column=\"heat\",\n", - " obs_stdev=0.01)\n" + " syringe_contents={\"ET\":3e-3},\n", + " cell_volume=201.3e-6,\n", + " conc_to_float=\"ET\")\n", + "binding.define_itc_observable(obs_column=\"obs_heat\",\n", + " obs_std=1e-6)\n" ] }, { @@ -72,78 +74,334 @@ }, { "cell_type": "markdown", - "id": "bda19ab6-4db2-47c3-83d7-3c8486f3a1f2", + "id": "293deeb5-170a-4b1d-9261-8366c78b2423", "metadata": {}, "source": [ - "#### Plot data" + "#### Do fit" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "e82c93f3-c3f8-44c9-b1a8-73f6b86ee6fe", + "execution_count": 12, + "id": "4ac7eaa7-d428-497a-8bb9-1e6d36580023", "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nameestimatestdlow_95high_95guessfixedlower_boundupper_boundprior_meanprior_std
name
KEKE17.2684260.26089016.74691417.78993917.0False0.025.0NaNNaN
dH_EdH_E-11074.85532945.697703-11166.203736-10983.5069230.0False-infinfNaNNaN
nuisance_dil_ETnuisance_dil_ET-1.77720532.914516-67.57238564.0179760.0False-infinfNaNNaN
nuisance_expt_0_ET_fudgenuisance_expt_0_ET_fudge1.100000NaNNaNNaN1.1True-infinfNaNNaN
nuisance_expt_1_ET_fudgenuisance_expt_1_ET_fudge1.100000NaNNaNNaN1.1True-infinfNaNNaN
\n", + "
" + ], "text/plain": [ - "Text(0, 0.5, 'heat')" + " name estimate std \\\n", + "name \n", + "KE KE 17.268426 0.260890 \n", + "dH_E dH_E -11074.855329 45.697703 \n", + "nuisance_dil_ET nuisance_dil_ET -1.777205 32.914516 \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 1.100000 NaN \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 1.100000 NaN \n", + "\n", + " low_95 high_95 guess fixed \\\n", + "name \n", + "KE 16.746914 17.789939 17.0 False \n", + "dH_E -11166.203736 -10983.506923 0.0 False \n", + "nuisance_dil_ET -67.572385 64.017976 0.0 False \n", + "nuisance_expt_0_ET_fudge NaN NaN 1.1 True \n", + "nuisance_expt_1_ET_fudge NaN NaN 1.1 True \n", + "\n", + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "KE 0.0 25.0 NaN NaN \n", + "dH_E -inf inf NaN NaN \n", + "nuisance_dil_ET -inf inf NaN NaN \n", + "nuisance_expt_0_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_1_ET_fudge -inf inf NaN NaN " ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "style = {\"s\":50,\n", - " \"facecolor\":\"none\",\n", - " \"edgecolor\":\"black\"}\n", + "f = dataprob.setup(gm.model_normalized,\n", + " vector_first_arg=True,\n", + " fit_parameters=gm.parameter_names)\n", "\n", - "color_order = [\"red\",\"black\"]\n", - "fig, ax = plt.subplots(1,figsize=(6,6))\n", - "for i in range(len(gm._expt_list)):\n", - " style[\"edgecolor\"] = color_order[i]\n", - " ax.scatter(np.arange(len(gm._expt_list[i].expt_data[\"heat\"])),\n", - " gm._expt_list[i].expt_data[\"heat\"],**style)\n", - "plt.xlabel(\"injection\")\n", - "plt.ylabel(\"heat\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "293deeb5-170a-4b1d-9261-8366c78b2423", - "metadata": {}, - "source": [ - "#### Do fit" + "f.param_df.loc[\"KE\",\"guess\"] = 17\n", + "f.param_df.loc[\"KE\",\"upper_bound\"] = 25\n", + "f.param_df.loc[\"KE\",\"lower_bound\"] = 0\n", + "\n", + "f.param_df.loc[\"nuisance_expt_0_ET_fudge\",\"guess\"] = 1.1\n", + "f.param_df.loc[\"nuisance_expt_0_ET_fudge\",\"fixed\"] = True\n", + "\n", + "f.param_df.loc[\"nuisance_expt_1_ET_fudge\",\"guess\"] = 1.1\n", + "f.param_df.loc[\"nuisance_expt_1_ET_fudge\",\"fixed\"] = True\n", + "\n", + "f.fit(y_obs=gm.y_obs_normalized,\n", + " y_std=gm.y_std_normalized)\n", + "\n", + "f.fit_df" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "f09830f6-3078-45bd-97eb-e82b4204556e", + "execution_count": 13, + "id": "b113d0dc-7f14-469e-b604-a78a235cceac", "metadata": {}, - "outputs": [], + "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", + "
descriptionis_goodvaluemessage
name
successfit success statusTrueTrue
num_obsnumber of observationsTrue66
num_paramnumber of fit parametersTrue3There are 63 more observations than fit parame...
lnLlog likelihoodTrue129.67464
chi2chi^2 goodness-of-fitTrue1.0A p-value of 1.000e+00 for the a goodness-of-f...
reduced_chi2reduced chi^2False0.280023A reduced chi^2 value of 0.280 may mean the mo...
mean0_residt-test for residual mean != 0True0.189692A p-value of 1.897e-01 for the one-sample t-te...
durbin-watsonDurbin-Watson test for correlated residualsTrue1.830258A Durbin-Watson test-statistic of 1.830 is con...
ljung-boxLjung-Box test for correlated residualsTrue0.998879A p-value of 9.989e-01 for the Ljung-Box test ...
\n", + "
" + ], + "text/plain": [ + " description is_good \\\n", + "name \n", + "success fit success status True \n", + "num_obs number of observations True \n", + "num_param number of fit parameters True \n", + "lnL log likelihood True \n", + "chi2 chi^2 goodness-of-fit True \n", + "reduced_chi2 reduced chi^2 False \n", + "mean0_resid t-test for residual mean != 0 True \n", + "durbin-watson Durbin-Watson test for correlated residuals True \n", + "ljung-box Ljung-Box test for correlated residuals True \n", + "\n", + " value message \n", + "name \n", + "success True \n", + "num_obs 66 \n", + "num_param 3 There are 63 more observations than fit parame... \n", + "lnL 129.67464 \n", + "chi2 1.0 A p-value of 1.000e+00 for the a goodness-of-f... \n", + "reduced_chi2 0.280023 A reduced chi^2 value of 0.280 may mean the mo... \n", + "mean0_resid 0.189692 A p-value of 1.897e-01 for the one-sample t-te... \n", + "durbin-watson 1.830258 A Durbin-Watson test-statistic of 1.830 is con... \n", + "ljung-box 0.998879 A p-value of 9.989e-01 for the Ljung-Box test ... " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#BayesianFitter does a Bayesian sampling rather than maximum likelihood fit\n", - "\n", - "F = dataprob.MLFitter()\n", - "#F = dataprob.BayesianFitter()\n", - "F.fit(model=gm.model_normalized,\n", - " guesses=[5,-11000,0,0],\n", - " names=gm.parameter_names,\n", - " y_obs=gm.y_obs_normalized,\n", - " y_stdev=gm.y_stdev_normalized)" + "f.fit_quality" ] }, { @@ -156,8 +414,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "a6680df0-9b17-40fe-89c2-b9d6b6b110a1", + "execution_count": 14, + "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a", "metadata": {}, "outputs": [ { @@ -181,88 +439,143 @@ " \n", " \n", " \n", - " param\n", + " name\n", " estimate\n", - " stdev\n", + " std\n", " low_95\n", " high_95\n", " guess\n", + " fixed\n", " lower_bound\n", " upper_bound\n", + " prior_mean\n", + " prior_std\n", + " \n", + " \n", + " name\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " 0\n", + " KE\n", " KE\n", - " 6.971177\n", - " 0.087264\n", - " 6.795418\n", - " 7.146936\n", - " 5.0\n", - " -inf\n", - " inf\n", + " 17.268426\n", + " 0.260890\n", + " 16.746914\n", + " 17.789939\n", + " 17.0\n", + " False\n", + " 0.0\n", + " 25.0\n", + " NaN\n", + " NaN\n", " \n", " \n", - " 1\n", + " dH_E\n", " dH_E\n", - " -11949.660405\n", - " 97.575492\n", - " -12146.187535\n", - " -11753.133275\n", - " -11000.0\n", + " -11074.855329\n", + " 45.697703\n", + " -11166.203736\n", + " -10983.506923\n", + " 0.0\n", + " False\n", " -inf\n", " inf\n", + " NaN\n", + " NaN\n", " \n", " \n", - " 2\n", - " nuisance_dil_CT\n", - " -0.682905\n", - " 6.055914\n", - " -12.880141\n", - " 11.514331\n", + " nuisance_dil_ET\n", + " nuisance_dil_ET\n", + " -1.777205\n", + " 32.914516\n", + " -67.572385\n", + " 64.017976\n", " 0.0\n", + " False\n", " -inf\n", " inf\n", + " NaN\n", + " NaN\n", " \n", " \n", - " 3\n", - " nuisance_dil_ET\n", - " -49.841584\n", - " 0.308075\n", - " -50.462079\n", - " -49.221089\n", - " 0.0\n", + " nuisance_expt_0_ET_fudge\n", + " nuisance_expt_0_ET_fudge\n", + " 1.100000\n", + " NaN\n", + " NaN\n", + " NaN\n", + " 1.1\n", + " True\n", " -inf\n", " inf\n", + " NaN\n", + " NaN\n", + " \n", + " \n", + " nuisance_expt_1_ET_fudge\n", + " nuisance_expt_1_ET_fudge\n", + " 1.100000\n", + " NaN\n", + " NaN\n", + " NaN\n", + " 1.1\n", + " True\n", + " -inf\n", + " inf\n", + " NaN\n", + " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " param estimate stdev low_95 high_95 \\\n", - "0 KE 6.971177 0.087264 6.795418 7.146936 \n", - "1 dH_E -11949.660405 97.575492 -12146.187535 -11753.133275 \n", - "2 nuisance_dil_CT -0.682905 6.055914 -12.880141 11.514331 \n", - "3 nuisance_dil_ET -49.841584 0.308075 -50.462079 -49.221089 \n", + " name estimate std \\\n", + "name \n", + "KE KE 17.268426 0.260890 \n", + "dH_E dH_E -11074.855329 45.697703 \n", + "nuisance_dil_ET nuisance_dil_ET -1.777205 32.914516 \n", + "nuisance_expt_0_ET_fudge nuisance_expt_0_ET_fudge 1.100000 NaN \n", + "nuisance_expt_1_ET_fudge nuisance_expt_1_ET_fudge 1.100000 NaN \n", + "\n", + " low_95 high_95 guess fixed \\\n", + "name \n", + "KE 16.746914 17.789939 17.0 False \n", + "dH_E -11166.203736 -10983.506923 0.0 False \n", + "nuisance_dil_ET -67.572385 64.017976 0.0 False \n", + "nuisance_expt_0_ET_fudge NaN NaN 1.1 True \n", + "nuisance_expt_1_ET_fudge NaN NaN 1.1 True \n", "\n", - " guess lower_bound upper_bound \n", - "0 5.0 -inf inf \n", - "1 -11000.0 -inf inf \n", - "2 0.0 -inf inf \n", - "3 0.0 -inf inf " + " lower_bound upper_bound prior_mean prior_std \n", + "name \n", + "KE 0.0 25.0 NaN NaN \n", + "dH_E -inf inf NaN NaN \n", + "nuisance_dil_ET -inf inf NaN NaN \n", + "nuisance_expt_0_ET_fudge -inf inf NaN NaN \n", + "nuisance_expt_1_ET_fudge -inf inf NaN NaN " ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGwCAYAAACjPMHLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABze0lEQVR4nO3dd1hTVwMG8DdsZKMgy73ALbi1deCkVVtt1Ra1bqpSB26rxdGvtlbrqrut1jpate4q7q11gFvEXQcgKspQZJ7vj2MiKIQAgRB8f8+TR3Jzc3LuNXpfzroKIYQAEREREQEADHRdASIiIqLChOGIiIiIKB2GIyIiIqJ0GI6IiIiI0mE4IiIiIkqH4YiIiIgoHYYjIiIionSMdF2Bwi4tLQ3h4eGwsrKCQqHQdXWIiIhIA0IIxMXFwcXFBQYGOWsLYjjKRnh4OEqVKqXrahAREVEu3Lt3D25ubjl6D8NRNqysrADIk2ttba3j2hAREZEmYmNjUapUKdV1PCcYjrKh7EqztrZmOCIiItIzuRkSwwHZREREROkwHBERERGlw3BERERElA7DEREREVE6DEdERERE6TAcEREREaXDcERERESUDsMRERERUToMR0RERETpMBwRERERpcNwRERERJSO3oSj6Oho+Pr6wtraGra2tujXrx/i4+PV7v/VV1+hSpUqMDc3R+nSpTF06FDExMQUYK2JiIhI3+hNOPL19cXly5exZ88ebN++HYcPH8bAgQOz3D88PBzh4eGYOXMmLl26hBUrViAoKAj9+vUrwFoTERGRvlEIIYSuK5Gd0NBQVK1aFadPn0bdunUBAEFBQfDx8cH9+/fh4uKiUTnr169Hjx498Pz5cxgZGWn0ntjYWNjY2CAmJgbW1ta5PgYiIqICFxEhH1lxdpaPIigv12/NEoKOnThxAra2tqpgBACtWrWCgYEBTp48iY8//lijcpQnSF0wSkxMRGJioup5bGxs7itORESkS0uWAFOmZP16YCAweXKBVUdf6EU4ioyMhKOjY4ZtRkZGsLe3R2RkpEZlPH78GNOmTVPbFQcA06dPxxR1XyQiIiJ94ecH1KgBbNkCXLkCBAcDAwYAX3wBmJsX2VajvNLpmKNx48ZBoVCofVy9ejXPnxMbG4sPPvgAVatWxeRsEvL48eMRExOjety7dy/Pn09ERFTgEhOBsWOBTz4Bdu4ETEzk9mXLgA4dZHcbw1GmdNpyNHLkSPTu3VvtPuXLl4eTkxOioqIybE9JSUF0dDScnJzUvj8uLg7t2rWDlZUVNm3aBGNjY7X7m5qawtTUVKP6ExERAdDu2B5tlCUE0LMnsHUrsHQp0KsXcPky4OUlW5F++QX46CNgzx6geXPN6qUtejAOSqfhyMHBAQ4ODtnu16hRIzx79gzBwcHw8vICAOzfvx9paWlo0KBBlu+LjY1F27ZtYWpqiq1bt8LMzExrdSciIlLR5tgebZR14gSwfj2wZg3w2WcZX3NzA/7+W4aisWOBkyc1q5eWRMyciYiffsrydeeAADjPmlWANXqbXow58vDwQLt27TBgwAAsXrwYycnJ8Pf3R/fu3VUz1R48eABvb2+sXLkS9evXR2xsLNq0aYMXL15g1apViI2NVQ2udnBwgKGhoS4PiYiIdE2bLRh+fkDHjsCzZ8A//wA//QT8739Au3avy9KUnx/g7g5s2ACEhAC3bwPe3nKsUKVKmpW1ZAlQoQLQrVvmrxsby2DUqRNw9ixQp072ZWrpfC0BoG5kbyCAydnXJl/pRTgCgNWrV8Pf3x/e3t4wMDBAly5dMG/ePNXrycnJCAsLw4sXLwAAISEhOPkqDVesWDFDWbdv30bZsmULrO5ERO+8wtiVos3WHiMjYP58YO1aOdYHAL7+Gti0CZg2DfD01Kyc1FS5/6JFgIsLULeuDEfnzwPduwP+/sDcudmXc/ky4O2NiIcPEaE876GhGf8sUQLOAJwvXdIoHGmrxcevUiV0MDLCRSMj7Le2xh9RURhQvDg6PXkCZycnOH/0UbZl5De9CUf29vZYs2ZNlq+XLVsW6Zdsat68OfRgCSciosJLm4GmME4pV7b2AMCxY8DQocDChYByuIamxxYVBbz3HvD0qTzG6tWBDz8EZs+W43t8fIBVq4DPP8++rPHjEbF4MSLGjgU6dwauX5fjhmbNAi5dAn78Ec4KBZzTNQ5kysAASErCkiVL3p6B3aOH6sdAAJM17EnRuMUnJQWIj3/7ERcHnD4Nw2+/xWFzczx98QJVX12nrWNi0NHAAL0SErDI1xe4cAGwtdWoXvlCkFoxMTECgIiJidF1VYiIClZgoBByaG/mj8BAzcsKDxdi7VohunYVompV+f5u3YTYu1eI4GD5ekFLSxNizRoh6tfPeFxt2wqxb5/m5Xz+uRCOjkLcuCGfBwfLcoKDhUhNFeKLL4QwNRUiMlJ9OZGRQhgbi8DmzQWALB+BhoZCPHqkvqzhw4UoUUKE37olgoODxcGDB8VPQ4cKAOKPadNEcHCwCJ40SYQDQly8KEREhBDXrgkREiLEoUNC/POPEH/+KcQvvwgxZ44QEyaI+6VKiW2AWKpQiGkKhQAglgDitKmpCHZ0FOH29kKYman/zrzxCH51TKc8PMT8+fOFuZmZ8FEoRMqsWZqf/yzk5fqtFytk6xJXyCaiLBXGriJtUh5fWhrw77/AV18Bv/8uW0YAzY8vMRHo1w9YvVp2FVWrJmdJGRvLFo6FC4G+fTWv1rlziLh8OcvXnatVg3Pt2uoLEQIRfn6IWLYMaNhQdl/9/DPQv79sRQoNhfMPP8B5zBj15URGAqVLAzNmAMOHy20hIXJWWHCw7E57+hRwdQUmTgQmTMi6rJkzgUmTEBEcjAcvXuDMmTM4u2kTlu7ejSl9+uCDIUOgePwYzh06wHn8eDmeKC7udatM+p//+w9YuBBPq1ZF2PPneHr3LqKFQA8AOw0M0NTCAhbx8VDkMgKEAPACEAxAww5D9eVUqADPGzewc+dO+Pj44O/SpdH5v//yUHIer995jmZFHFuOiChL2mxZKYzi4oSYPl2IMmVeH5O9vRBff519y0V6n38uW05++02IpKTXLSv79gnRv7/8ed06jYsLbNZMfctKs2bZF7JmjQhUUwYAEahs/cmmHAFkPB/pW45evpSvtW8vhKenEMeOCREUJMSGDUIsXy7EvHlCfPedEOPHC1GtmhD29iKiaVNxuFgxcQwQm1/V5QAgXioUOWqVyaqVJjgPZWRWVoJCIaIAkWRlJUSNGkI0bixEmzZCdO4sW82GDBFi7FiR0KuXGAmIbS1bylapf/4RwRMnynJmz1advkZlyojWhoYafx+ywpajfMSWIyLKUkSEHBuxc6dcfXjPHmDSJDkDSKHQ75aj6GigVSt5XJ99BtSsCQQEAF27Ajt2AI6OwIEDstVEnXPn5GDf5csB5bp26VtW6tSR6+1cuiTH1xhkvzZx+Nmz2LtsGY5u345njx9jfUICJtapgw+++gomJiaatRzVr48ICwuEz5yJixcvYu+yZVh9/Dh6v/ceOvbtizJ2dnAeOBDOdesCw4a9bplJ/4iPl8dy/Dgi3nsPEc+eAc+fAzExwJMngKGhHGANyIHP2R7Z27TVQvNmWVWNjHArNRWWJUuidNWqgJUVYGn5+s90P28bMwbLY2Px8x9/wKVKFcDSEqd37UL94cOxa+5clGjaFG2bNkWTlBT4b96M+KQkPH/+/K3HzTNnsH7vXrStXx9GDg54/vw5Ht29i8u3bqFTs2bYfPAgAGB6ixb48dAhRKel5el483L9ZjjKBsMRvXOKeleRtiQlASNGyAX2jI1ld9HNm/K1OnXkrKUqVXRbx7z4+GNEHDqEiEWL5PTx0FA5kHfVKsDGBhg4EM6OjnA+e1YGwawMGQJs3oyIf/9FxKNHclv6sjw8gAsX4NynD5x37wZat1ZbrYe3buGj+vXx75MncDcwQH0TE6x8+RINARgZGmLBtGmo2aDB6wATG/t2qHn4ENixAy/Ll8e9iAgYJSTgLoDmyH0ImYz8mZ4eYmwMr+RkBDs4oI6zM67cvo2ouDg0a9IEBpUrvx1qXv25ed8+zFyyBGu3b0cxW1s8P3gQp/buxaf792Nx375w/fhj/PLLL9i1axemTp2K5ORkVYiJj49//XNcHI4fPAgzc3PYOjqqtickJOTiaLJWt2pVnL58GUhNxffFi2NGQgKi093nNDcYjvIRwxG9cyZPLnyzigobIWRrysaNci2bAQOAW7dka8jPP8sxNI8eycX1ypXLvrzCFkhv3gQqVsTkjh0xZevWLHcLBDD5yBGgadOsy2rZEnB0xGR3d7X3rQw0MMDkXr1kWemDTLpwk/rsGa4eOwaztDS4FSsGE4UCZ58/1+7Yl1yWE/HqkWpigotCoF9yMpba2KB2mTIwTE2F8+XLcG7XTq5fZGX1+vEq0CSbm2P7wYMYPX065lesCIf58xFvbIxzO3dixKxZmNivH4pXrowbs2djQWQk2rdrBydnZ8THx6vCTPqfIyMjkZaWVuhnbSsUCggh0KhGDRw/fx4IDETTadNgVr8+9uZxcUqGo3zEcETvnIgIIDwcuHtXdolMnfr6N3yALUcAsHevbOH488/Xi+yl7yoqXVoOxG3aVK5QnB1tBlJtBK3vvwf+9z88OHcOf23Zgg0bNiAmOBhXkpLwoYsLWn/0ERrWqIFSEyfC2ctL3rsrfQuN8ufYWLlSc1oawm1scPfJEyhevMANAD0ArALgoawWdNPtlGZqCgNra1nOo0cIrlwZnhUq4ElSEjbv24cGxsaoPm7c61YZKyukWVgg3sgIcQYGiFMoEL9/P87PmoXvrK1xKzYWpU1NcTcxESUAxBoZoQ6AinZ2iG/UCPHpQkz6R2IeW0nym4lCATtHR1hYWMDCwgJISMDFGzfQzMsLrlWqIPrYMQT99x8G+/nBrUwZWFhYwNLSUrW/8vH9d9/h6I4dOACg3MCBCHV1Rd0JExA8bhw8L1/G7m3b0BbAhg0b0KVLlzzVmeEoHzEc0Tvnr7+AH3+UF3ml8uXlLJu+fdV3oaRX2FpDtKlLF+DaNTneSHk+3pyh9NNPwLhxwP37cnyOOhERwO7dsitu7145TsXICGjTRq6N07Kl5ucqu6D1+edybZ83Q0z6ny9cQNqjR3hkZATDFy9go1DgohD5MvYlp2WlAjC0tVUFlZDERHjdvIngunXhWa0azh44gN1378J/1ChYlCmj2i+1WDHEGRoiVqHAo5cv8UGnTnjf2hpdFi5EbHw8rhw8iDlr1sC3XTuYu7kh/tkz7P/7b7wwMkKl6tURFxeHuLg4VctMYWRoaAgrKytYWFjg2bNnMDAwQJ1q1WBpaAjLYsXwMjERWw8fRu8OHVDBzQ0Jz5/j55Ur8eWYMWjSpIkqwKQPNZaWlvCpUwdp167hcLpWwpDVq+HVoweCV62CZ4MG6OPhgQMWFrj55InaO1DcvXsXDRo0gG1yMuYnJ8MuNhZ1ARwDcNHZGQHR0WjarBn++ecfGBnlbSnGvFy/9WYRSCJSQ1tBRHlhbdcO2LwZSE4GPv0UKFNGTnE+e1auAqxJQCqMi/5py+nT8qae6s5Dx47AyJEyQLVqpb687dvlgoQVKgCDB8tz7Osrg1JQEDBqFFC/fsYg82awUT5/+lQunhcXpxoMnMGaNRq1ZhkAKJmUJJ/k8XfoJACxACydnWHm4AAkJADXryOtfn1cSE7G3rNn0cTODg0mTJBhxto6Q9dTmqUlYoRABXd39G7aFB9MnoynT5/i6dOnuLR/P3DzJmbY28MMwL2SJbH/7l2s/PtvpJqYqG4dlVmgWf/sGda/sTDj6qCgjDslJ+Ps2bN5Ov7MKINH+kd0dDSuXr2KTz/9FI6OjrB8+RKxFy5g4alTmNilC6p98glevnyJfv36YfTo0ejVq5fqvRYWFjAxMYHi1Xdy1apV6NmzJxb/9hs8XrX6hoSEYKuXF76aPBmenp748ssvUczJCd9++63am7IPmTwZXT//HBtbt0bnOXMyLCKJf//FqeHDsTY1FZOHDcv21lylS5fGoUOH0LVrV7Q+fx6NrayAuDj4m5riXGQkPv/8cyxdujTPwSiv2HKUDbYckV7QRreMsqvou++A8ePltvStIWfOyAt4+q4kdZSB7c4deZPLNWvk2JwePWQXRUHfpVybSpUCvvgC+Pbb19tOnpTr5WzZIrvVrl6V45LGj5fhMn2ISf8ID5czwiws5EytuLg8VU059iUrmnZfvYQcP2NRqpRsoXn5El5XryK4USN41qiB0OBgrA0OxqAePeDcrFnGQKP82doah8+eRbPWrfEPgDYffYSo/v1x4OxZ9Jg0CdPbtIHt+fP49fFjXDExQffPPkNsbKwq+CgfMTExOh07Y2RkBCsrK1haWsLKyirDIy0tDVu2bMFHrVqhbuXKsDQ3R/TNm5i6eTPm9eyJ2s2awcTQED2GDUPL7t0xa9YsFCtWDAaZzMp79uwZXFxcMKZnT0z28wMAhOzYAa9JkxA8bRo8fXwwc+ZMLN6yBSEREWqvSS9fvkTVqlVhbm6OXbt2wc3NDSEhIfDy8kJwcDDOnTuHfv36YcaMGRg9erTa409LS8Nnn36KjZs2YbQQ+NLCAo+treEVEYHJAGYaGqKmpyf2HjoEc3Pz7E9oRAREeDjOnj2LHcuXY9Lx45jRogU+HzECrq6uWvv3zG61fPROhKPCduEpzArruYqIkAvXbdkiL8rKIPPFF4CpqWb16tRJLhyXfvbRm11F3t5yQb+jR7Ov04MHshtu927AzAx4+VKWa2Ehp0ZPmSKnOmsiv8bkCCFnnT1/Lh/x8fJ8GRtnHWZiY+W5fvFCzlBTbisMY0YMDTE5NVX9rCkrK0yeNAmws3sdZNKFGVhZYf6KFRg9ZgwiLCxgt2cP0KBBxm4ULy8ktWyJ0o8fo9ewYZg6bRoiIyMRERHx1mPXrl14/PgxbM3MEBUTg4K64CgUClhbW2f6sLCwwNq1a+Hp6YlPGjSA9cmTeHL6NMalpOBXc3PU7dwZVv37o/+0aYiNjcWpU6dULTJv+uOPP9CrVy8kjh8Pk+nTAWTebbipZk3MKFYMJ06cUFvvH374AQnjxqlmtmVW1vHWrdF49+5sz0FYWBhatWqFJ0+eoHv37nBzc8O0adPg4eGB0NBQ+Pn5YdGiRVkeW3opKSmYNGkSFvz8M+Li41HTwAAX0tJQ3dAQDfv0wezZs2FpaZltOQAQMXKk6h5tochk/JmG92jLDrvVKG+KcveHtmnzXGkraCUkyO6btWvl2JYKFV7X9e+/5fbsbnqZkiK7dmbNUt9V1KeP7E56/BgoUSLr/R4+lGMTUlPlYO4KFYBGjeT6OIcPA9Ony5WFly3TrIvOz0/en+rwYWDfPtnV1KuXvPcUIMPXgQMZA0xMTObPr12Tn60Nyqn7eWVmBhQvLsOJoaFc86dlS9kCZW0NXLwoj33uXBlq0oeZ9D83awY/hQId58/H09hY7Fm2DD/89Rem9euHdl9+CYNz5+A8YABQubIMw1m49/Ah3MqUgZ2LC9CkCZ61b48jr7ro5owZg7TISESYmSHOyAhz5s7FjzNnZnuID3MYHg0NDWFraws7OzvVI/HePRwKDcWHDRrg/S5dYGdnh+iLFzF23jz8PmUK7MqUwWe9e2NAjRqYde5cpq0zSiVKlMC2pUvRbfx4uPbsiZAdOzBu0iTUnjABNX18cPbsWVzZvx/f/fab2vCQ+uq8iIED5cB04O2lCgAc+fFHpN26le1xjxkzBnOePEG9WbNgYmICt8qVgQsX0MfEBKapqfDz80Pfr7/W6BxWqVIFZ8+exdKlS7Fs2TLcuXMHAGBnZ4ft27fDx8dHo2AEyNaz6UOHYqKPD44cOYJrR49i2M6dWDBmDN7/5BP570rD/7Myu0dbuo66XC97oFV5XoKyiHsnVsi+f1+I2bPlqqaWlnIF1GrVhPjxRyFOncrZPY/Cw+WqsFk9dFWWtoSHC3HwoBCjRwtRt648V+3aydVuc1onbayunJYmRKdOQpiby9WHExNfr867aZO8R5SpqRDHj6svJzZWvmft2ozb06/0K4QQu3fL57duqS9v4EAhHByE+O+/t8tJTparAgNCLFsmxOHDQmzbJsTq1UIsXCjE99/L1YKHDBGiRw8hOnaUq+4aG8v3GBjkeXVfrTyUqxUXLy7rV7u2fF6/vtxmZibE0KHyvlS//Sa/I7t3C/Hvv0JcuSLEvXtCXL4s37NzZ9bnXAgh1q+X2548yfqcX7ggBCAe//676NWrlzAxMRFVXq1iXAUQlSpVEqtXrxaiQQMhfHzU/vWNHTtWFCtWTAzx8xO1XF2FIpuVpLN7KBQK4ebsLOpVqyY6NmsmutSrJwCI4e3aiV+/+Uas+fZbYQ+Ib775Rvz3338iNjZWpKWlvVWvtKQk0dfVVRgAYpS3t7h96ZIIXrVKABDTvb1FcQMDUcPYWDwLDVX//RRCPHr0SMy1s1O7evTyMmVEYmKi2nKCg4MFALF169a3tgW/+jtMTk4WpUqVEv3798+2Xkr3798XU6ZMEc1erQb+5ZdfivBc/J8XHh4u76MWHCxWrlwpAIhVq1aptuWkzPCAABH86hytenW+Vr16HgyI8ICAHNcps0dujjMzebl+Mxxlo8iHo5cv5cUVEKJePSEGDZI/16wp/2zTRojnzzUvT5u3UyiMt2ZYu1YICwshjIzk+QKEsLWVf37xhQwnmlKGv6NH5S0aAHkRzUn4279fvu/vv19ve/PWBV5eQmR3O4XUVCGsrYWYMCHj9vRlpaXJ2xwYGQlx5oy8yO/eLS/cv/wixE8/yb+TQYOEMDSUNxdt1UqGBeXtJ3J4U8p8eRgby8CYfpuRkRAeHkL07SvE2LFC/O9/QsyfL8TKlUJs3izP85kz8sackZFCvHghH717y5Bkbf36ZqqAEO7uQpw/n/3fX2ysfP/ixZmfc6WZM2Udk5KyLuvvv8UTQHhUriyKFy8uZsyYIfb+/LO8gE2cKD7++GMBQMxu3lyISpUyvPW///4Tf/zxhxgwYICoUqVKjoKPk5OTaNKkifjkk0/EV199Jb777juxfPlyERQUJM6fPy++//57YWBgIGJGjFAbRCYD4u7du9mespS4OBFYs6aweVVG7Vd/egCim729eBISkv15f+XBmTOiX506og4g6llaCgCijpmZ8ATE2NatRfz16xqVU69ePdGoUSOR9Orv581w9Ouvv2Z4np304WHVq/CX20ATGBio9u8vMAf/jwYGBKgvS8NwVFAYjvJRkQ9HAwbIC8WWLfJ5+v+Yd+0SolgxIT77TPPybt6UF8gaNV63QjVuLMSKFblrOTpzRl6gAgJkWcpydNFytG2bvJB9/rkQDx68PlcnTgixZIkQJiaypUNT9+8LMXjw6/MECGFlJY81KkqzMrp1kxf19L9lv3lx/fNP+fzkSdmSc+GCEEeOCLF9e8bWGi8v2QLVrZsQH34oxHvvCVG5snyvtbUMPLoMNUZGskXG1VU+9/SU9axWTf69+PvLUPPzzxlDTXCwENevC/HwoTwHdnZClColj3nVKllWjx7yGD08ND/3SrdvCzFlyutfMhYskGFTUz4+8twr/w7f/PtLTZVhq2tX9eVs3y76A8Le1laEhYXJol5dWINXrRJpaWli9OjRAoDYVaaMWLZsmejZs6coU6aM2gueAhB1APHZq+eLAHEFEE8BMc/eXqRmc6wxMTHC2tpa9GrdWiT9+68QwcEZ6nV382bRunhx0bd9e83PmRAi/vJlsebTT8XUihUFALEnICDjv4McCAkJEX379hUAxKBBg8TNmzdz9P5Dhw4JY2Nj4ePjI8LCwlTh6OjRo2LOnDnC2NhYfPHFFxqXp81Ao81WmoJq8dEWhqN8VGjDkTa6nO7flxe8n356ve3N/5iXLpXPb9zQrE41asgLVfv2slsEeH0xGz06Z/95LV8uRJUqGS+Q9vbyQqTuN+j8kJYmL1Bt276+8L15rn77TT7X5DfXa9eEcHERwtFRiEmT5LECQvTqJVuiKlSQfz9CCJGSIkR0tLwInzsnxKFDQmzdKsQffwjh5CREo0ZCjBkjhJ+fEN27C9GkiSyrQgUh3Nwyhi9dPBSK13WoUEGG5fbthaheXYaxUaOEmDZNiLlz5XnYuFGIvXuFOH1aiN9/l+/bvTvr8PD0qSxn2jT15zw5WYiyZWUQiY5+u6ywMCFKlpTdeJpK/+9QGbRWrcrZv8M9e+T7JkyQx5i+TqmpQgwbJs/hsWNqi4m+eVOYA+LbNm1U25Qh5M/vvhPz588XnT/6KNsuMiMjI9GoUSMxePBgUal4cdHU2lr83LevWD9tmgAgvunaVbR1cBAtbW1F6P79Gp2mHTt2CBMTE+Hp6Sn++OMPsWPHDqHsKipRooSoVKmSiIyM1KgsIYQIP3tWBK9aJYJXrRKrBg0SAMSqQYNU28LPntWsHC220AQFBQkHBwcBQHh4eAgAwtLSUigUCuHn56dqVcppvfQhhBRWDEf5SKvhSJtjaLTR5TRjhmwZSn9sb154XryQF+tvvlFfVkqK/E3e1fV1d4KyrNOnZQAD5AVQE5Mmyf07d5a//SvHunTtKlsQOnaUFztNaOO8HzokP//Agdfb3jxXycny+P38Xu+TmirEs2cZW2y2bpUtF46OcmzNmDFCdOkiy2rSRF68jYxki56ug42ytcjAQF6gq1cX4qOPZBfiV18JMXGiHJu2ZIlsodq5U7ZCGhjIVpyYGHkOMusqatpUCG9v9ef9hx9ki466ljEhZGjt1El9WX//Ld+X/sL5Zlm//iqPU9OWA211/f74o9zfy0ve8R6Q3Xu1ar1ujcrG9u3bBQBxy85OiBs3RFpamujToYPaIARAmJmZiRYtWojAwECxb98+8TxdN3pkZKQYMmSIsLKyUu1vYmIievfunePWlWPHjglvb++3PnvAgAEiKoetdYGvxuFk2bKSXTeyshwtttAIIURCQoJYuXKl+PDDDwUA0b9/f3H79u0clUHak5frN2erFSRtznTy85OzgTZvBvbvl7MjGjWSU7fr1pVTjLNz/76875O6KY7m5vLmmffvqy8rKEhO+z5yRN69Oz0DA3mDzsuX5W0JBg2SU6WzcuQIMG2a3HfsWLktJET+OXasvLN3hw7yHlbDh2d3lLk/70LImWAxMXKGlEIhp6P/9Zfcdvmy3O+HH+TxxMTIaeGrVsm7tCtnRwmR9We/mvqrcuzY659TUvI2PdzMTM5sSkuTs8fef1/OZrOxyfiwts74PCEB2LRJPh4+lM99feV5Us6Ey06nTsDvvwNDh2Z+l/XDh+VyAOvX5/740tPgTu7YtEneEFbd3dq7d5c3St26VbPvlp+fXOwxK5ou6zBqFFCrFjB7trxXGwDMmCG/53PnAs2aZVuE8vYT1vb2QOPGONK1K5Zv2/bWfiaGhjAyNcWkSZPw/vvvo27dujAxMcm0zJIlS+Lnn3/G999/j82bN6Nnz57YvXs3mmlQnzc1btwYe/fuxc2bN/HPP/9g2LBhCAoKylVZfnPmoKPy318mnKtV06wcPz90VPP355yDZTmUSxdUq1YN3bt3x/bt29G8eXNER0cjOjoazs7OOSqPdIvhqCD5+QFNmshAs20bcO8eULasnI7csaOcXqupffvkisUKhQxFoaFyWviXX8opwH//nX0ZlpZySnZqatbrzQghL5ANGqgva8UKeeFp0iTrfYYOBX79Va5788EHWe/388/y5oxjxmT+evv2QNeu8uaeWV18AXlcsbFyf1dXYM8eGT7Cw2V4dHeXYeHqVXk7iJgY4NmzjH8mJ7/92W9at+7tbXm9vUCxYjKUFC8uA0n68GJr+/rn2Fhg4kT59z5woNx2545cj+jYMblYYf368jumyXcCkN+jHj3kQzkluW1beT5CQjSbrjt1qvxetm8PLF78entKigxEAwfKsPbRR+rL8fR8va5QVjc3jYkBDh16HaSzEheXfb2LFZPnNzZW/X5K2lzXqnVr+Th0CGjeHDh4UJ4jDVV4FVyPT56MDjt24IcFC1SvNQTQzd4e7w8dCv9du2BjY4Nx48ZlW6bygg9ANeX7/v37CHn1y0pOLvjpyypevHieynKuXRvO6kKuhrQZWJYsWfLWjXV7pFtJOjAwEJO5JIr+yIeWrCJFq91qQUGym8TcXI65AGS3gpGRnPZ86pRm5WzfLpv+v/hCTu1Vdg2cOSPEjh2yG6x58+wHhf77r3zfP/+83vZmN8PBg/L5vn3qy2rQQIg+fTJue7OstDRZ7yVL1JdlaSm7ZBIT5SDaa9fkAFtADqJdulSIfv3kc19fOZj2ww9lN02NGrLLyspKd11RRkZy7ErlynKmVuvWQnzyiaxzQICc8l2unBxcvmmT7Kpbvfr1eVaOTXB3F2LECPXnSgg5lguQ08Zv33593mfMkHVwdNS8m0gI7XUVnTghx1UBcqAzIOsCyEHIz55lX0ZqqhAVK8pZb8pu1De/VxMnyu6/Bw/Ul/Xll3LMUfp/F2+WFREhy1q2TLNj1BZtjF0SQtStW1c0b95cnDt3LkP30L9jxgiRkiKOHTsmAIi/089uVEOrM5203IVV2HCcUOGTl+s3V8jOhtZWyL54Uf4G37Kl7Ha5ffv1ysNOTrLl4vp1eRd0N7esyxFC/jZtby9bQgwM3l7FePdu+Zv+rl3yxpXqymrYUN6L6fBhWY837yzesqXslrl4Uf1ifa1by5WFt29/ve3ECaBxY2DDBtlyc/euvO1Enz6yq+7Zs9cPZWvNs2eytcLY+O1Wm4JgYPC6ZebNP/ftk605AQHyXEVHA6NHA3/8If9u58yRXXj//af+73DcOOC332RXpbI7482/w9hY2SIxebL8DHWEkF0w06fL9xUvLlsEAdmSt2IFULGi5udAm6uAJyXJltIVK2RXY7duskUwu0Up09u1S7Y0+vjIY0xMlOdq1y75b2DmTNlt+s036stRfh+3bQM+/FBue/O8T5kiu0kfPJBdkgVFSyuABwUFoW/79nBwc8OFdF3hZ6ZNg8LJCWPGjIFx6dLYduaMRveuSt/ak5ncthzltSwiTeTp+q31qFbEaK3lqEcP2VqQkCCfv/kb65MnQtjYyEGY6pw+Ld+nbtG4tDQ5kLNLl+zrdeOG/O3eyUmIb799Pe176FA5uLh4cdmydPKknNr/559yTZbvvxdi3Dj523j37q9bBipUkK0mb64jU1APMzN5LO7uQjRsKOtiZSVE//5y4LNyBt2338rjWrdOtvQEBgoRF6d+Nt2VK3IaeLVqcnDvyZOyrD//lH+/QMaZf1m5eFHuu3p11n+H8+bJFox797IvTyk+XrawDRwoy3pzQceCpqXWECGEXEahZElZRrlyr1vozM3lGlGazIJMS5Mtqg4Or89z+vO+YYMsUxdrtWhxskZQ27bC6FVrjA3eXk8oftSofDwQosKDs9XykVbCUVycXANnxozX2zKbcTNsmPyPW91/9GvWyPfFxakvy99fziyKjparGQcHyy6bv/+WC/bNnClnxQwZIsTHH8sp34Vh5WFLSzk7SaGQXVIffiiDR9eu8vVhw4RYtEjWt0kT2RUZFia7316+zHiuHj2SAWPePPXnqnt3uYCfJi5dklPngYwB0MlJnldNdegguz9PnHi7Xnv3yot+796al6fNIKIt2uqeU0pMlIFP+V0YPfr1lHxNPXokZ4QpFLJrb+RIWZZyAceuXQt+mQgtGz5ggKqrqrKdnQAgetStKw7PmSNScrriPZEe42y1wi4yUnYv1K2rfr+6deXMlJcv5SwxQHbjPH0qu5uePpXdWwAwb54ccPzsGXDjhtw2cKDc9vSpHHScnCy73wqasTFQsqScBXXlClC+vBx8bm8PfPWV7JKxtX37YW0NGBkBjx7JGW9JScCCBbJ7LyREDnz++GNg/nwgKkoOMK5XL+t6/PefPB/qBokD8vWNGzU7tmrVgOPHZffnH38AP/0ku3WGDlU/A+9Nf/whBys3biy7QGvUkNsHDpRdPG3ayAHnmspsRl66waA6uT+etmZyAa+7+ipXlmWuWydnd92+LR+advWVKCFnQ65ZI8/Zvn1yu42NvGnvhx9qNvOtkIqOjsbS1asBAKamphj+v/9h8ODBaDd8OCw8PHAegPOrBxFljeGoIBQrJv988kT+mZYmpxUD8uJvZiYDzblzcpun5+tAlNVU7sxuPBgcnPe6mprKz3RzkxcSKys5o0sZaOzsMg82ynE5wcHyIr1z5+vp/48eyfDwzTfqlw1QcnCQ40nat5fBqkOH1yGvXTs59mndOjnOJ7tjAbKfeRQbK/8ONJF+PI5y3IyT0+vQqulF2sZG3ih17Vpg0SI5hRuQ3401a4BPP5VBUVPaDCLaos2ZXNoMf8+eyZmVixe/no03ZIj8zp87p916F7CFCxfixYsXAOTU/sGDBwPgrCminOKA7GxoZUC2EPI/4zJl5G+nQsiBuCkp2q0sIFsvjI2BFy/kei4lS2YMNJn9vHKlnD6fldy0Oty7J9c+GjhQTsNu3DjnxxIbKwevr1wpW4EiI2V5gYGareOUkiKXSvDxAZYuldveHIArBFC9upzWr8lUdy0NnAWQMWhlchdvfb5Ia502B4lr8++wEElISECZMmXw6NEjGBgYYNOmTXDLZGIABz7TuyIv12+2HBUEhQLw95cX9r//ljPTrK3lbKfMWFm9Di52dhl/trWVaxLNnSu7jL74QnYv9O4tf7vetUt2Ec2erdkidoD8jblPn6xfz033B/C6xez27dctMzm5iD1/LmfTNWz4Ojy8/74MSZGR2ZdlZCTX//n2W3l+MgtoCxfKrr/58zWrkzZbaApjV1hhpc2gWBhb2bRgxYoVePToEQCga9euahc3JKJsaH0EVBGjtdlqqanyhp4GBnI20eDBcgDoiBHyzveAnPml6WDQ8HA5G+3Nm4GWLy/vuaUr2hyEq42yEhKEeP99eZuUSZPkrCflTLG+feXPw4fn+oaVeaLN28nQOy05OVmUL19eNRA7JAd3picqqrjOUT7S2jpHgGzpmTlTDqYOD3+9vUIFuZbNwIHq1xLKzP37wPLlcjzPokWyDF0OKNVm94e2ynrxAhg/Xq4tFB//erurqzzvQ4fm/LwTFSLr1q1Dt27dAACtW7fG7t27dVwjIt3Ly/Wb4SgbWg1HSsnJ8r5TAwbIxfF69sx5oOF4lZyLi5NdWaNHyzFWfn45G/RMVAgJIVC3bl3VbTj27NmDVq1a6bhWRLrHMUf6In2gUU7VNzJ6PUstJ4GG41U0l/68K8+vrS1w4cLrbQySpKf279+vCkaenp7w9vbWcY2I9B/DUUHSZqApooNK8wWDJBVhP/zwg+rnsWPHqm4QS0S5x261bGi1W02b43FIczzvVESdPXsWnq/W2ypfvjzCwsI0umca0buA3Wr6ghdh3eB5pyJqxowZqp9HjRrFYESkJfq7Tj4R0Tvs9u3bWLduHQDAwcEBvXv31m2FiIoQhiMiIj00a9YspKWlAQCGDh0Kc+UkDyLKM4YjIiI98+jRI/z2228AAAsLC9U91IhIOxiOiIj0zM8//4yEhAQAwIABA2CvvDEzEWkFwxERkR55/vw5fn51o2gjIyOMGDFCxzUiKnoYjoiI9Mivv/6K6Fc3rf7ss89QunRpHdeIqOhhOCIi0hPJycmYNWuW6vno0aN1WBuioovhiIhIT6xbtw53794FAPj4+KBGjRo6rhFR0cRwRESkB4QQGRZ9HDt2rA5rQ1S0MRwREemBXbt24cKrmyU3aNAA7733no5rRFR0MRwREekB3mCWqOAwHBERFXKnTp3CwYMHAQCVK1dGx44ddVshoiKO4YiIqJBLP9Zo9OjRMDQ01GFtiIo+hiMiokLs+vXr2LhxIwDAyckJPXr00HGNiIo+hiMiokJs5syZEEIAAIYPHw4zMzMd14io6DPSdQWIiN51ERERiIiIeGv748ePsWLFCgCAlZUV/Pz8CrhmRO8mhiMiIh1bsmQJpkyZonafL7/8Era2tgVTIaJ3HLvViIh0zM/PD8HBwdizZw/69u0LAOjVqxcsLCwAAMbGxhg2bJguq0j0TmHLERGRjllbW2PSpEn4448/kJKSAgBYuXKl6vXPP/8crq6uuqoe0TuHLUdERDqUmJgIHx8f/Pnnn/j222+xZ88eAECJEiVU+9y4cQPJycm6qiLRO4fhiIhIhxYvXozjx49j165dGD16tGpc0ePHjwEAjRs3xvHjx/H777/rsJZE7xaGIyIiHRFCYNGiRejSpQuaNGkCAEhLS8uwz8yZM+Hj44OFCxfqoopE7ySGIyIiHXn06BHCwsLw6aefqrYdPXpU9XPTpk3RqFEjdO3aFWfPnsXz5891UU2idw7DERGRjijHEaVf2HH16tWqn8eOHZvhdeVgbSLKXwxHREQ64ujoiOLFi2P//v0AZDfbxYsXAQDOzs7w8fEBAOzbtw+urq6wtrbWWV2J3iV6E46io6Ph6+sLa2tr2Nraol+/foiPj1f7Hj8/P1SoUAHm5uZwcHBAp06dcPXq1QKqMRGResbGxujTpw9+++03REREICYmBomJiQCA0qVLw8DAAHfv3sWqVaswYMAAKBQKHdeY6N2gN+HI19cXly9fxp49e7B9+3YcPnwYAwcOVPseLy8vLF++HKGhodi1axeEEGjTpg1SU1MLqNZEROoFBASgWLFi8Pb2xq5du1TbHRwccOLECbRs2RKOjo4YMmSIDmtJ9G5RCOUdDQux0NBQVK1aFadPn0bdunUBAEFBQfDx8cH9+/fh4uKiUTkXLlxArVq1cOPGDVSoUEGj98TGxsLGxgYxMTFs0iaifBEWFoaOHTvi2rVrqm12dnZ4+vQpqlWrhm3btqFcuXI6rCGR/snL9VsvWo5OnDgBW1tbVTACgFatWsHAwAAnT57UqIznz59j+fLlKFeuHEqVKpXlfomJiYiNjc3wICLKT1WqVMGVK1fw1VdfqbY5Oztjx44duHDhAoMRUQHTi3AUGRkJR0fHDNuMjIxgb2+PyMhIte9duHAhLC0tYWlpiZ07d2LPnj0wMTHJcv/p06fDxsZG9VAXpIiItCEiIgLnz5/PMButTZs2KFmyJM6dO4eIiAgd1o7o3aPTcDRu3DgoFAq1j7wOoPb19cXZs2dx6NAhVK5cGV27dsXLly+z3H/8+PGIiYlRPe7du5enzyciys6SJUvg5eWFRYsWqbbNmTMHXl5e8PLywpIlS3RYO6J3j05vPDty5Ej07t1b7T7ly5eHk5MToqKiMmxPSUlBdHQ0nJyc1L5f2QJUqVIlNGzYEHZ2dti0aRM+++yzTPc3NTWFqalpjo6DiCgv/Pz80LFjRwQEBODQoUMA5LhKBwcHALKLjYgKjk7DkYODg+ofvzqNGjXCs2fPEBwcDC8vLwDA/v37kZaWhgYNGmj8eUIICCFUU2WJiAoDZ2dnODs7q5YnMTAwgLe3N4yMdPpfNNE7Sy/GHHl4eKBdu3YYMGAATp06hWPHjsHf3x/du3dXzVR78OAB3N3dcerUKQDArVu3MH36dAQHB+Pu3bs4fvw4Pv30U5ibm6sWViMiKkwePHgAAHBycmIwItIhvQhHgFxS393dHd7e3vDx8UHTpk2xdOlS1evJyckICwvDixcvAMjl9o8cOQIfHx9UrFgR3bp1g5WVFY4fP/7W4G4iIl1LTk7Gw4cPAQCurq46rg3Ru01vfjWxt7fHmjVrsny9bNmySL9kk4uLC3bs2FEQVSMiyrOHDx+q/g9jOCLSLb1pOSIiKsqUXWoAwxGRrjEcEREVAunDkaar/hNR/mA4IiIqBNhyRFR4MBwRERUCDEdEhQfDERFRIRAeHq76meGISLcYjoiICgG2HBEVHgxHRESFgDIcWVhYwMrKSse1IXq3MRwRERUCynDk6uoKhUKh49oQvdsYjoiIdCwuLk51XzV2qRHpHsMREZGOcbwRUeHCcEREpGNcAJKocGE4IiLSMbYcERUuDEdERDrGcERUuDAcERHpGBeAJCpcGI6IiHSMLUdEhQvDERGRjinDkUKhgJOTk45rQ0QMR0REOqYMR46OjjA2NtZxbYiI4YiISIdSU1MRGRkJgF1qRIUFwxERkQ5FRUUhNTUVAMMRUWHBcEREpEMcjE1U+DAcERHpEFfHJip8GI6IiHSILUdEhQ/DERGRDnEBSKLCh+GIiEiH2HJEVPgwHBER6RDDEVHhw3BERKRDynBkZmYGW1tb3VaGiAAwHBER6ZQyHLm6ukKhUOi4NkQEMBwREenM8+fPERMTA4BdakSFCcMREZGOcKYaUeHEcEREpCNcAJKocGI4IiLSEc5UIyqcGI6IiHSE4YiocGI4IiLSEY45IiqcGI6IiHSELUdEhRPDERGRjqQPR87OzjqsCRGlx3BERKQjynBUokQJmJqa6rg2RKTEcEREpANpaWmqMUfsUiMqXBiOiIh04PHjx0hJSQHAcERU2DAcERHpAAdjExVeDEdERDrA1bGJCi+GIyIiHWDLEVHhxXBERKQDXACSqPBiOCIi0gG2HBEVXgxHREQ6wHBEVHgxHBER6YAyHJmYmKB48eI6rg0RpcdwRESkA8pw5OLiAoVCoePaEFF6DEdERAXs5cuXiI6OBsAuNaLCiOGIiKiAcaYaUeHGcEREVMC4ACRR4cZwRERUwDhTjahwYzgiIipgDEdEhRvDERFRAeOYI6LCjeGIiKiAseWIqHBjOCIiKmAckE1UuDEcEREVMGU4srOzg7m5uY5rQ0RvYjgiIipAQgjVmCN2qREVTgxHREQFKDo6GomJiQAYjogKK4YjIqICxMHYRIUfwxERUQHiYGyiwk9vwlF0dDR8fX1hbW0NW1tb9OvXD/Hx8Rq9VwiB9u3bQ6FQYPPmzflbUSIiNdhyRFT46U048vX1xeXLl7Fnzx5s374dhw8fxsCBAzV675w5c6BQKPK5hkRE2eMCkESFn5GuK6CJ0NBQBAUF4fTp06hbty4AYP78+fDx8cHMmTPVNk2fO3cOs2bNwpkzZ+Ds7JztZyUmJqoGSwJAbGxs3g+AiOgVthwRFX560XJ04sQJ2NraqoIRALRq1QoGBgY4efJklu978eIFPv/8cyxYsABOTk4afdb06dNhY2OjepQqVSrP9SciUmI4Iir89CIcRUZGwtHRMcM2IyMj2NvbIzIyMsv3jRgxAo0bN0anTp00/qzx48cjJiZG9bh3716u601E9CZlODIyMoKDg4OOa0NEmdFpOBo3bhwUCoXax9WrV3NV9tatW7F//37MmTMnR+8zNTWFtbV1hgcRkbYow5GzszMMDPTi91Oid45OxxyNHDkSvXv3VrtP+fLl4eTkhKioqAzbU1JSEB0dnWV32f79+3Hz5k3Y2tpm2N6lSxe89957OHjwYB5qTkSUc0lJSXj06BEAdqkRFWY6DUcODg4aNSs3atQIz549Q3BwMLy8vADI8JOWloYGDRpk+p5x48ahf//+GbbVqFEDs2fPRocOHfJeeSKiHIqIiFD9zHBEVHjpxWw1Dw8PtGvXDgMGDMDixYuRnJwMf39/dO/eXTVT7cGDB/D29sbKlStRv359ODk5ZdqqVLp0aZQrV66gD4GIiAtAEukJvenwXr16Ndzd3eHt7Q0fHx80bdoUS5cuVb2enJyMsLAwvHjxQoe1JCLKGmeqEekHvWg5AgB7e3usWbMmy9fLli0LIYTaMrJ7nYgoPzEcEekHvWk5IiLSd1wdm0g/MBwRERUQthwR6QeGIyKiAsIB2UT6geGIiKiAKMORtbU1LC0tdVwbIsoKwxERUQEQQqjGHLFLjahwYzgiIioAMTExqqVGGI6ICjeGIyKiAsDB2ET6g+GIiKgAcDA2kf7IVTgyNDR860awAPDkyRMYGhrmuVJEREUNW46I9EeuwlFWK00nJibCxMQkTxUiIiqKuAAkkf7I0e1D5s2bBwBQKBT45ZdfMkxFTU1NxeHDh+Hu7q7dGhIRFQFsOSLSHzkKR7NnzwYgW44WL16coQvNxMQEZcuWxeLFi7VbQyKiIoDhiEh/5Cgc3b59GwDQokULbNy4EXZ2dvlSKSKiokYZjgwMDODo6Kjj2hCROjkKR0oHDhzQdj2IiIo0ZThycnKCkVGu/uslogKS63+h9+/fx9atW3H37l0kJSVleO2nn37Kc8WIiIqKlJQUPHz4EAC71Ij0Qa7C0b59+9CxY0eUL18eV69eRfXq1XHnzh0IIeDp6antOhIR6bXIyEjVLF+GI6LCL1dT+cePH49Ro0bh4sWLMDMzw99//4179+6hWbNm+PTTT7VdRyIivcYFIIn0S67CUWhoKHr16gUAMDIyQkJCAiwtLTF16lT88MMPWq0gEZG+40w1Iv2Sq3BkYWGhGmfk7OyMmzdvql57/PixdmpGRFREcAFIIv2SqzFHDRs2xNGjR+Hh4QEfHx+MHDkSFy9exMaNG9GwYUNt15GISK+x5YhIv+QqHP3000+Ij48HAEyZMgXx8fH466+/UKlSJc5UIyJ6A8MRkX7JVTgqX7686mcLCwuuik1EpAYHZBPpl1yNOQKAZ8+e4ZdffsH48eMRHR0NAAgJCcnwnwAREb0ORxYWFrC2ttZxbYgoO7lqObpw4QJatWoFGxsb3LlzBwMGDIC9vT02btyIu3fvYuXKldquJxGR3lIOyHZ1dYVCodBxbYgoO7lqOQoICEDv3r1x/fp1mJmZqbb7+Pjg8OHDWqscEZG+i4uLQ1xcHACONyLSF7kKR6dPn4afn99b211dXREZGZnnShERFRUcjE2kf3IVjkxNTREbG/vW9mvXrsHBwSHPlSIiKio4GJtI/+QqHHXs2BFTp05FcnIyAEChUODu3bsYO3YsunTpotUKEhHpM7YcEemfXIWjWbNmIT4+Ho6OjkhISECzZs1QsWJFWFpa4n//+5+260hEpLe4OjaR/snVbDUbGxvs2bMHx44dw/nz5xEfHw9PT0+0atVK2/UjItJrbDki0j+5CkcAsG/fPuzbtw9RUVFIS0vD1atXsWbNGgDAb7/9prUKEhHpM4YjIv2Tq3A0ZcoUTJ06FXXr1oWzszPX7SAiyoIyHCkUCjg5Oem4NkSkiVyFo8WLF2PFihXo2bOntutDRFSkKMORo6MjjI2NdVwbItJErgZkJyUloXHjxtquCxFRkZKamqpa+41dakT6I1fhqH///qrxRURElLmoqCikpqYCYDgi0icad6sFBASofk5LS8PSpUuxd+9e1KxZ862m4p9++kl7NSQi0lNcAJJIP2kcjs6ePZvhee3atQEAly5dyrCdg7OJiCTOVCPSTxqHowMHDuRnPYiIihwuAEmkn3I15oiIiLLHliMi/cRwRESUTxiOiPQTwxERUT7hgGwi/cRwRESUT5ThyMzMDHZ2djquDRFpiuGIiCifKAdku7q6ciYvkR5hOCIiygcvXrzAs2fPAHC8EZG+YTgiIsoHHIxNpL8YjoiI8gEHYxPpL4YjIqJ8wJYjIv3FcERElA+4OjaR/mI4IiLKB2w5ItJfDEdERPmA4YhIfzEcERHlg/ThyNnZWYc1IaKcYjgiIsoHyjFHJUqUgKmpqY5rQ0Q5wXBERKRlaWlpGVbHJiL9wnBERKRljx8/RnJyMgCGIyJ9xHBERKRlXACSSL8xHBERaRlnqhHpN4YjIiIt4wKQRPqN4YiISMvYckSk3xiOiIi0jOGISL/pTTiKjo6Gr68vrK2tYWtri379+iE+Pl7te5o3bw6FQpHh8eWXXxZQjYnoXcUB2UT6zUjXFdCUr68vIiIisGfPHiQnJ6NPnz4YOHAg1qxZo/Z9AwYMwNSpU1XPixUrlt9VJaJ3nDIcmZiYoESJEjquDRHllF6Eo9DQUAQFBeH06dOoW7cuAGD+/Pnw8fHBzJkz1f5mVqxYMTg5OWn8WYmJiUhMTFQ9j42NzX3FieidpByQ7eLiAoVCoePaEFFO6UW32okTJ2Bra6sKRgDQqlUrGBgY4OTJk2rfu3r1apQoUQLVq1fH+PHj8eLFC7X7T58+HTY2NqpHqVKltHIMRPRuePnyJZ48eQKA442I9JVetBxFRkbC0dExwzYjIyPY29sjMjIyy/d9/vnnKFOmDFxcXHDhwgWMHTsWYWFh2LhxY5bvGT9+PAICAlTPY2NjGZCISGOcxk+k/3QajsaNG4cffvhB7T6hoaG5Ln/gwIGqn2vUqAFnZ2d4e3vj5s2bqFChQqbvMTU15U0iiSjXOBibSP/pNByNHDkSvXv3VrtP+fLl4eTkhKioqAzbU1JSEB0dnaPxRA0aNAAA3LhxI8twRESUF5zGT6T/dBqOHBwc4ODgkO1+jRo1wrNnzxAcHAwvLy8AwP79+5GWlqYKPJo4d+4cAMDZ2TlX9SUiyg671Yj0n14MyPbw8EC7du0wYMAAnDp1CseOHYO/vz+6d++uarZ+8OAB3N3dcerUKQDAzZs3MW3aNAQHB+POnTvYunUrevXqhffffx81a9bU5eEQURHGliMi/acX4QiQs87c3d3h7e0NHx8fNG3aFEuXLlW9npycjLCwMNVsNBMTE+zduxdt2rSBu7s7Ro4ciS5dumDbtm26OgQiegcwHBHpP4UQQui6EoVZbGwsbGxsEBMTA2tra11Xh4gKuffeew9Hjx4FALx48QLm5uY6rhHRuykv12+9aTkiItIHyjFHdnZ2DEZEeorhiIhIS4QQqm41dqkR6S+GIyIiLYmOjlbdfojhiEh/MRwREWkJF4AkKhoYjoiItIQz1YiKBoYjIiIt4QKQREUDwxERkZaw5YioaGA4IiLSEoYjoqKB4YiISEs4IJuoaGA4IiLSEmU4MjIygqOjo45rQ0S5xXBERKQlygHZzs7OMDDgf69E+or/eomItCApKQlRUVEAON6ISN8xHBERaUFERITqZ4YjIv3GcEREpAUcjE1UdDAcERFpAReAJCo6GI6IiLSAaxwRFR0MR0REWsBwRFR0MBwREWkBwxFR0WGk6woQEemriIgI1Sy1sLAw1faoqCjEx8fD2dkZzs7OuqoeEeUSW46IiHJpyZIl8PLygpeXF4KDg1Xb33vvPXh5eWHJkiU6rB0R5RZbjoiIcsnPzw/t27fH8ePHMWbMGKSkpMDJyQn//PMPALDViEhPseWIiCgXhBBYv349PvroIwQEBCAlJQUAEBkZiRkzZqB06dIMR0R6iuGIiCgXJkyYgGHDhuHDDz/Epk2bVNurVauG/fv34/3330d0dLQOa0hEucVwRESUQ2fOnMH333+PGTNmYNmyZShWrJjqtfr16+Po0aOIjIzEpEmTdFhLIsothiMiohxauHAhypQpg4CAAAAZV8d2dHRE5cqV4e/vj5UrVyI2NlZX1SSiXGI4IiLKoQMHDuDTTz+FoaEhgIxrHDk4OAAAunfvjvj4eISEhOikjkSUewxHREQ5lJSUlKErLX04cnR0BABYWFio9iUi/cJwRESUQ1WqVMHhw4dVzy9cuKD6WdlydOjQIQBApUqVCrZyRJRnXOeIiCiHBg4ciM8++wynTp2CiYkJjh07pnrNwcEBSUlJmDNnDtq0aYNy5crpsKZElBsMR0REOdS5c2fUq1cPHTp0QJ06dTK89ujRI3zyySe4fPmyqvWIiPSLQgghdF2Jwiw2NhY2NjaIiYmBtbW1rqtDRIXE48eP8cEHH+DUqVMAACMjI6SkpMDAwACWlpb4888/0b59ex3XkujdlZfrN8ccERHlQokSJfDhhx+qntvb2wMARo0ahXv37jEYEekxhiMiolxISkrCggULAAAGBgYYP348AKBmzZq4ceMGQkJCEBERocsqElEuMRwREeXChg0b8PDhQwBAWloaRowYAQDo0aMHvLy84OXlhSVLluiyikSUSxyQTUSUC3PnzlX9vHTpUnh5eb21D288S6SfGI6IiHLo33//VQ3ErlWrFvr37w+FQqHjWhGRtrBbjYgoh9K3Gg0bNozBiKiIYTgiIsqBBw8eYMOGDQDkgo+fffaZjmtERNrGcERElAMLFy5ESkoKAMDPzw9mZmY6rhERaRvDERGRhhISElQz0IyMjDBo0CAd14iI8gPDERGRhtasWYMnT54AALp27QoXFxcd14iI8gPDERGRBoQQbw3EJqKiieGIiEgDBw8exMWLFwEADRs2RP369XVcIyLKLwxHREQamDdvnupnthoRFW0MR0RE2bh9+za2bNkCAHB1dUWXLl10XCMiyk8MR0RE2fj5558hhAAADB48GMbGxjquERHlJ4YjIiI14uPj8euvvwIAzMzMMHDgQB3XiIjyG8MREZEav//+O2JiYgAAvr6+KFGihI5rRET5jeGIiCgLaWlpHIhN9A5iOCIiysKuXbtw7do1AECLFi1Qo0YNHdeIiAoCwxERURa46CPRu4nhiIgoE1evXsWuXbsAAOXKlcOHH36o4xoRUUFhOCIiykT6sUZfffUVDA0NdVgbIipIDEdERG94+vQpfv/9dwCAhYUF+vbtq+MaEVFBYjgiInrDr7/+ihcvXgAAevfuDRsbGx3XiIgKEsMREVE6KSkp+Pnnn1XPv/rqKx3Whoh0geGIiCidrVu34r///gMAtG/fHlWqVNFxjYiooDEcERGlw+n7RMRwRET0yrlz53D48GEAgLu7O9q0aaPjGhGRLuhNOIqOjoavry+sra1ha2uLfv36IT4+Ptv3nThxAi1btoSFhQWsra3x/vvvIyEhoQBqTET6Jn2r0dChQ6FQKHRYGyLSFb0JR76+vrh8+TL27NmD7du34/Dhw9neHfvEiRNo164d2rRpg1OnTuH06dPw9/eHgYHeHDYRFZCoqCisWbMGAGBra4tevXrpuEZEpCtGuq6AJkJDQxEUFITTp0+jbt26AID58+fDx8cHM2fOhIuLS6bvGzFiBIYOHYpx48aptmU3uDIxMRGJiYmq57GxsVo4AiIq7JYsWYKkpCQAQP/+/WFhYaHjGhGRruhFE8qJEydga2urCkYA0KpVKxgYGODkyZOZvicqKgonT56Eo6MjGjdujJIlS6JZs2Y4evSo2s+aPn06bGxsVI9SpUpp9ViIqPBJSkrCwoULAQAGBgbw9/fXcY2ISJf0IhxFRkbC0dExwzYjIyPY29sjMjIy0/fcunULADB58mQMGDAAQUFB8PT0hLe3N65fv57lZ40fPx4xMTGqx71797R3IERUKK1fv171f8lHH32EMmXK6LhGRKRLOg1H48aNg0KhUPu4evVqrspOS0sDAPj5+aFPnz6oU6cOZs+ejSpVquC3337L8n2mpqawtrbO8CCioksIwen7RJSBTsccjRw5Er1791a7T/ny5eHk5ISoqKgM21NSUhAdHQ0nJ6dM3+fs7AwAqFq1aobtHh4euHv3bu4rTUR6LSIiAhEREarnFy5cwOnTpwHIMYkVK1bUVdWIqJDQaThycHCAg4NDtvs1atQIz549Q3BwMLy8vAAA+/fvR1paGho0aJDpe8qWLQsXFxeEhYVl2H7t2jW0b98+75UnIr20ZMkSTJkyJdPXwsLCsHTpUkyePLlgK0VEhYpezFbz8PBAu3btMGDAACxevBjJycnw9/dH9+7dVTPVHjx4AG9vb6xcuRL169eHQqHA6NGjERgYiFq1aqF27dr4/fffcfXqVWzYsEHHR0REutK/f3/Y2tpi48aNuHTpEp4+fQoAsLKywq5du1C2bFndVpCIdE4vwhEArF69Gv7+/vD29oaBgQG6dOmCefPmqV5PTk5GWFiY6k7aADB8+HC8fPkSI0aMQHR0NGrVqoU9e/agQoUKujgEIsqlN7vC3uTs7KzqSlcnPj4effv2xZ49e+Dl5QU3NzdVOIqLi8PatWsxZ84cbVWbiPSUQgghdF2Jwiw2NhY2NjaIiYnh4GwiHZk8eXKWXWEAEBgYqFFX2Mcff4x9+/Zh/fr1aNy4MUqVKoWYmBgYGRlhypQpmDhxIqZMmYJJkyZpsfZEpAt5uX4zHGWD4YhI95QtR/fu3UNQUBAWL16MKVOm4IMPPoBCodCo5ejcuXOoU6cOAgIC8PDhQ2zZskV1C6L27dtjx44dGDVqFJYtW4YHDx7A0tKyIA6NiPIJw1E+Yjgi0r1r165h2LBhCAoKyrC9du3a+OGHH9TeIDYpKQl79+7FyJEjERYWhsz+y1u1ahV8fX1x9+5dlC1bFitWrODtQ4j0XF6u33oz5oiI9Iu2xgldvXoVTZs2hb29PZYvX46KFSvivffew/z58/H333/Dx8cH69atQ+fOnVXvSU5Oxv79+7Fu3Tps2rRJNa4oPVtbW7z//vvYunUrPDw8AAClS5eGo6Mj7ty5k/MDJqIig+GIiPKFuinzgObjhPr37w8HBwccO3YM9vb2CAkJAQA0btwYgwYNQvfu3dGnTx+0aNECwcHBWLduHTZu3IgnT568VZahoSF8fX3RtWtXtG7dGpcuXcLWrVtVryclJSEuLg7FihXL+QETUZHBcERE+cLPzw+1a9fG+vXrsXfvXkRFRaFcuXLo1q0bfHx8NFps8fz58zh27Bg2bNgAe3v7TPf59NNPsWHDBpQuXVo1hig9S0tLdOzYESVLlsTs2bMxYcKELG9AvXHjRrx48QI+Pj45O1giKlL04t5qRKR/duzYgU8++QS7du1C8+bNAQBlypTBjBkz0LNnT8TGxmZbxr59+1CsWDF06tRJtU15a6AZM2bAzc0N3bp1A4AMwahYsWLo1q0bNm7ciKioKKxevRrfffcdSpYsicGDByMhIeGtzwoPD8eECRPQsmXLt1bWJ6J3C8MREWldUFAQBgwYgAEDBuD+/fsYO3YsAGDWrFm4fv06ihUrhrZt22YbkF6+fAljY2P8+eefGDlyJFq0aIGWLVsCAP76668MN542MDDAJ598gnXr1uHRo0f4888/8fHHH8Pc3BwAYGZmhr/++gsnTpxA/fr1sWLFCtVtiX7//XfUq1cPycnJau+9SETvBs5WywZnqxHlXNOmTWFgYICDBw/CwMAAISEh8PLyQnBwMDw9PXH79m1UqlQJc+fOxZAhQwAAiYmJuHTpEkJCQnD27FnVn0lJSVl+jqmpKdq1a4cDBw6gZ8+e+Pnnn7OtW3BwMCZOnJhh5puRkRG6d++O6dOnw83NLe8ngIh0jrPViEhr8jrL7Nq1azh27BjWr18PA4PMG6dLlCiBJk2a4Pvvv8eZM2cQEhKCK1euICUlJdv6OTg44NGjR5g2bRqGDh2K9evXY8uWLRg8eHD2BwfAy8sLO3fuxO3bt7F161YMHz4cQUFB8Pb21uj9RFT0MRwRUQZ5nWV27949AICnpyfS0tJw7949HDt2DAAwfvx43LlzB9evX1etN7RixYosy6pQoQKsra1x9uxZdOvWDdOnT8fTp0/h5eWFtm3bYtu2bfD390ePHj00HieUPvyVKFECABAZGamaBafpEgNEVHQxHBHpiLbWAdK25s2b4+LFi9i5c6dq4HLTpk3x5ZdfwsPDI9M6paam4s6dO7hy5Yqqu+rDDz/E3bt38fz5c9V+u3fvzvQzDQ0N4eHhgTp16sDT0xN16tRB7dq1YWNjAwD4/vvvMWHCBOzatQuNGjUCAHTq1AkRERHo2rUrli1bpvHxZRb+evToofpZ0yUGiKjo4pijbHDMEeUXbd0vDNBe0NqwYQN8fX3h4OCAvn37wtjYGN988w1cXFwQGRmJhQsXonnz5rhy5UqGx9WrV/Hy5UuN6mpqaooaNWrg0qVLaNiwIX744QfUqFFDNXA6K7dv38bixYsRFBSECxcuoEOHDvj6669Rv359KBQKjT4bKLyhlIi0i7cPyUcMR5SeNi+syrKSk5Nx4sQJjBgxAr///juqV6+e47K0EbQuXrwILy8vdOnSBUuWLMF///2HHTt2YNy4cWjVqhVCQkIQHR2tUX2UXF1d4eXlBXt7e6xYsUI1g2zMmDGYN28eLl26pFF3WPrzHhoaih49emDVqlWqla0ZaIjoTXm6fgtSKyYmRgAQMTExuq4KFQKBgYECQJaPwMBAjcuKiooSY8eOFSVKlFC9v0SJEiIwMFA8e/YsR/U6d+6c6NevX4ayatSoIWbPni3OnDkjwsPDs6zD4cOHxdKlS0X16tWFmZmZKFeunFAoFGqPM/3D0NBQuLu7i86dO4uJEyeKNWvWiFOnTokWLVoIU1NT4e/vL1atWiUAiJ9++km0bNlSABALFizQ+Pi0ed6J6N2Ql+s3W46ywZYjSk/ZgpGSkoL9+/dj/PjxWLx4MerVqwdA8xaMu3fvonnz5oiOjkafPn1QsWJF+Pv7o0uXLti5cyfKlSuHAwcOwMHBIduyLly4gNatWyMhIQE9e/aEk5MTvvnmG1SrVg2XL1+Gn5+f6qarV69ezfDI7BYbWTE2NoaDgwPCw8Mxfvx41KlTB1WrVkWlSpVgYmLy1v6JiYn43//+hyVLlqjWEwKAevXqYeLEiejYsaPGn82uMCLKKbYc5SO2HFF68fHx4ptvvhHOzs6qVgsjIyPRvXt3cenSJY3KSEtLE/Xr1xdly5YVd+7cEUIIERwcLACI4OBgERoaKkqWLCnatWuXbVlxcXHCxcVF1KlTR9y4cUOcOnVKTJs2TQAQ3t7ewsXFReMWIOXD0tJS1K1bV/To0UMMGjRIABB///23SEpKEnv27BEAxK1btzQ+Z4mJieKXX34RAMT69es1fh8RUV7k5frN2WpEGoqLi0OrVq1w8eJF9O7dG56enhgwYACGDh2KzZs3o2HDhtixYwfee+89teUcP34cp06dQlBQEMqUKfPW6+7u7pg1axZ69OiB0NBQ1bgaAKqp8cqWn02bNiE8PBypqalv3ats3759auvh5uYGd3d3uLu7o3LlyhgxYgTGjRuHadOmqQY4h4SEYNGiRShbtiyMjY1x9+5dAFDNIlMnfWuPmZkZANmaxCnzRFTYMRwRaWjEiBG4evUqjhw5Ai8vL9VF3tfXF1OnTsWHH36Izp07486dO7CwsMiynPXr16N06dJo3bp1lvu0a9cOlpaW+Oabb1C1alVcvXoVYWFhuHbtWqb3BXv48GGm5ZiYmKBUqVK4efMmevTogXbt2qnCkJWVVYZ9jx49ig0bNmDq1KmZzv4SQuCXX36Bt7d3ljeBTY9T5olIXzEcEWng8ePHWLVqFaZMmQIvL6+3XrewsMDy5ctRvnx5rF27Fv3798+yrKdPn8LNzQ0KhQL379/H1atXsWfPHgDA4MGD8eDBA9y/fx+AnFqvCQcHB7i7u6NKlSqwsLDA3LlzsXnzZnz44Yd4/vw5bGxs8MEHH6B79+5ZljF8+HA0btwYo0ePxsyZMzMEJCEEvvvuO5w4cQLbt2/XqE5+fn5qxxWx1YiICiuGIyrytDGYNygoCImJiejbt2+W+5QtWxbe3t7YuHFjhnD08uVL3LhxQ9UVdvr0aVy/fh3W1tYZ7iQPACdPnsyyfCMjI1SoUEEVgpTdbxUqVMCWLVtU+4WEhGDu3LkoVaoUDA0NVV1hdnZ2ao+xUaNGmD9/Pr766iscOnQIX375pWoV6379+uH8+fOYMmUKPvjgA7XlKLHbjIj0FcMRFXl5vR0GAMTExMDIyCjL2WNCCDx+/BiGhoa4du0aRo4cqeoKu337NtLS0t56z5vBSMnOzg52dna4desWxo4di0aNGsHd3R3ly5eHsbFxhn2fPn2KcePG4eHDhyhZsmSm5f3yyy8oUaIEmjVrpvYYAcDf3x8eHh6YNWsWBg4cqApHxsbG2Lp1Kzp06JBtGURE+o5T+bPBqfz6T9lyJITAgQMHMHr0aMyfPx+NGzcGoFkLx8aNG9GlSxdcvnwZJiYmCA0Nxb59+zB37lzUqlUL9+7dy/ECiQYGBmjSpAnq168PMzMz/O9//8PevXthbm6Odu3awcfHB3/++afaMqKjo1G+fHnUq1cPmzdvhoWFBUJCQuDl5YXg4GBERETgo48+woQJE9QGxMw8efIEhw8fRufOnREcHAxPT88cvZ+ISJfycv1myxEVWtpa28bJyQnbt2/H3LlzcfnyZQDAV199hZYtW2LcuHGZXvSfP3+uWhcoNDQUly9fhqGhIWrUqPFWK9D58+ez/GxLS0vVjDBlV5i7uztsbW3RoUMHnDhxAk5OTqpVoqdOnYqjR4+icePGGt0vzN7eXjW2qGrVqhg0aJCq+2zUqFE4dOgQOnTogIkTJ2ZbllL68/7ixQsAclVqJXaXEVGRp8UlBYokrnOkO9pYFTktLU306dNHABAff/yxmDNnjgAgpk6dKho0aCAAiICAALF48WIxbNgw0bZtW1G6dOkcrw3k7OwszMzMRPHixcW8efPE3r17xf3790VaWlqWdYuPjxfz5s0THh4eqnIqV64slixZIl6+fJmjc3X58mXRu3dvYWZmpiqrfPnyYsGCBSI5OTlHZXE1aiIqCrhCdj5it1rOaPveY7du3cKRI0dw+fJlrFq1CgsXLkSDBg00Lmvp0qXw8/PDrFmzUKVKFezZswdz585FzZo1ce/ePTx9+lTjYzM2NoalpSWePn0KR0dH1KpVC3v27EGzZs1w9OhRVKxYEXv27EGpUqU0Pj7luVKunZTX+4XFx8dj7969+Pjjj3HmzJlMZ9blpF6ZYcsREekDdqtRoaGNwc8AkJqaisWLF2Pu3LmIiYmBqakpAGDo0KHo0aMH5s6d+9aXPSkpCdevX0doaCiuXLmC0NBQbNq0CQYGBhg5cmSGfS9cuJDlZ9vY2MDDwwMeHh5wd3dX/VmuXDkYGhpi9+7dWLBgAfbu3QsAePDgAebMmYMvvvjirbWD1NHmOkDpA83z588BAFevXlVNx89JoGH4IaJ3HVuOssGWo5yJiIjA3bt3ceTIEZw5cwZ//fUXpk+fjjZt2gDQ7MIrhFC1ogQEBGDIkCGIjo6Gl5cXhg8fjl9//RVubm4YMWIEbt26hdDQUISGhuLmzZtITU3VuK6lSpWCu7s7nj59itDQUGzfvh3u7u4oWbJkposgKo9PW3eH12YLzeTJk7USSomIioq8XL8ZjrLBcJQzy5YtwzfffIPIyEhYWVkhLi4OANC0aVMsW7YM7u7u2Zaxfft2dOjQAYsXL0a1atVw5coVHDx4EGvXrkXJkiWzXA06K2XLlkXt2rXh4eGBYsWKYdKkSThy5AiaNm0KAFiwYAFGjBiBpKSkbMsqrCGEXWFERBkxHOWjdyEcaevCOnPmTIwePRpffPEFRo0ahaSkJHh5eWHGjBlYvnw5Hj58iOPHj6NKlSqq9wgh8OjRI1y5ckX1WLt2LWJjY5GSkqLxMZibm6NKlSrw8PBA1apV4eHhATs7O3h7e+OPP/5QdVeln+aunKU2ePBg/PPPP/jvv/+y/RyGECIi/ZCn67fWhoUXUe/CbDVtzE7677//hIGBgRgzZoxqW/o7zT958kSUL19eeHp6ijlz5oiBAweK9957TxQvXjxHs8KsrKxEo0aNhI+PjwAgFi1aJG7duiVSU1MzrVeLFi1Ew4YNVa+nr5MQQjx9+lRYWVmJiRMn5v1EEhFRoZGX6zcHZOspbbZg+Pn5wcfHB4cOHcLhw4exfft2DBkyBD179oSxsbFG5SxduhQWFhaYOHEi7t69iytXrmDXrl0AgN69e+O///5DbGwsAKhu2KqOtbU1PD09UbVqVVStWhWGhoYYNGgQDhw4AC8vL5w6dQo7duxAo0aNUK5cuSzLGTduHNq2bYvhw4fjp59+yvDas2fP8NFHH8HAwABffvlltnUiIqJ3A8ORntLWrDAA+Pfff+Hv74/w8HBVEFqwYAHWr1+P2bNnZ7pIohAC9+/fx+XLl3H58mX88ssvMDY2hqurq2qckdLFixez/GxXV1dVAFI++vfvj9q1a2dYHVoZqJQDpQ8ePAhTU1OULVtW7bG1adMGixYtwpAhQ7Bp0ybVwPDp06dj165dMDQ0xPbt2+Hq6pr9iSIioncCw5Ge8vPzQ5MmTbB582bs27cPYWFhaNSoEXr16oV69erBxcVFo3I2bdqELl26oGPHjpg6dSpSUlLg5eWF9evXY8OGDfD19cXjx49RpUoVVRBSjg1StgRpomzZsvDw8MDOnTvRq1cvDBo0CB4eHrCxsXlr38GDB2PkyJG4du0aKleu/NbrsbGxWLBgAbp165bp+9/05ZdfomHDhliwYAHWrVsHADhy5AiGDh2KQYMGMRgREVEGHJCdDW0OyNZmV9gff/yB/v37w9DQEI0aNcL+/ftRrlw53L59Gy1atMDGjRtha2urtoykpCSULl0ajRs3xvr16/Hw4UNs2rQJ/v7+6NSpEx4+fIjg4GAkJydrfIzlypVD1apVUa1aNVhYWCAwMBBHjx5FkyZNsHfvXrRu3Vr1PCtxcXGoV68eEhISsGbNGjRu3Bhnz56Fl5cXNm3ahB9//BGXL1/GyZMnMwzuzoo2p98TEZF+4IDsfKTNAdnaui3Dtm3bhEKhEL179xbR0dGqQcZnzpwRO3fuFHZ2dqJZs2ZZDlJ+9OiROHjwoOjbt68AIDw9PYWdnV2OBkaXLVtWfPDBB2L06NFixYoV4vfffxcAxMqVK1Wfk37wc0pKimjVqpWoXr262ltqKN27d0/Url1bABC1atUSbdu2VX22k5OT+PfffzU6V0LwdhhERO8iDsjWE35+fujQoQNOnz6NDRs2YN++fWjTpg18fX1RrVo1jbrChBD4+uuv0bJlS/z6668wMDDA7du3AcjxOO3atcNff/2FNm3aYPPmzXB2dsalS5dw6dIlXL58GZcuXXprnSB1A6TLlCmDp0+fomzZshgxYgSqVasGDw8PWFpavrXvzp07MWDAACQlJaFnz56q7Y8ePULPnj2xf/9+bNu2LcsFFtNzc3NDcHAwdu3ahZUrV+L69esAgClTpmDMmDEwMzPLtgwlPz8/dOzYMcvX2WpERETpMRwVoISEBPTr1w/nz5+Hm5sbAHlH9927d6NZs2aq8TDqBAcH48KFC9i5cycMDAwAAC9fvgQgF0/8888/cenSJRgbG6NLly4a183NzQ3Vq1dHiRIlsGrVKvz+++/4+OOPYWVlhbp168LT0xO9e/dWW8aKFStgbGyM/v374+uvv1Z1efn4+KBYsWJYu3YtfHx8NK7Tw4cPUbJkSYwePVrVHVahQgVcuXIFgObdYew2IyKiHNF+Q1bRoq1utcjISFGqVClRsWJFsX//fnHmzBkBQJw6dUps2bJFODk5iRo1aoi4uLgsy0hJSREzZ84UAMS4ceNE586dRaVKlYRCodC4O8zBwUG0aNFCfPXVV6J3794CgAgJCVF9xpvrAN2/f18YGhqKBQsWaHysly5dEsOHDxdNmzYVAMSYMWNydf7YHUZERLnFbjU9MHPmTMTFxeH48eNwc3NTdWUZGhqiY8eOqFChAmrXro1ffvkFw4YNQ3h4OC5evIhLly7h4sWLuHjxIkJDQ1WtRN9//73azzM2NoapqSk+//xzVK9eHdWrV0e1atXg6Oio2ichIQFbtmzB3LlzsXz58ky7u6ZPnw4zM7MMN0RVJyIiAomJiejZsyfq1q2Lo0ePombNmrhx4waAnK+/xO4wIiIqcPkQ1ooUbbQcJSYmCnt7ezFy5EjVNmULzcGDB8WRI0fEokWLRMWKFYW5uXmOBkebmZkJDw8PAUAMGzZM7Ny5U4SFhQlra2sxduzYbOv222+/CQCif//+4t69e6p6BQUFCX9/fwFAzJ07V+NjZWsPEREVBnm5fnMqfza0MZX/1q1bqFChAnbv3o3WrVsjOjoaHTt2xLFjxzQuw8DAABUrVkSNGjVw7do13Lt3Dxs3bsT777+P8+fPq+4XVqdOHYwaNQpz5szBzZs3s10kEZA3iw0ICEBCQgKqVKmCK1euwNDQEKamppg+fTqGDh2qcT157zEiIioM8nL9ZrdaAVAOnFbeSNXGxgZnzpzJcn8XFxfUqFEDNWrUQPXq1VGjRg14eHjA3NwcABAZGYnGjRvD19cXEyZMQI0aNQDIwd3ffvstNm3ahLlz52oUjABgwIAB6N69O1atWoWdO3fiypUrCAgIwIQJE7JdK+lNDD9ERKTvGI4KgJubG1xdXbF582a0b98ehoaGKF++PEJDQ1GrVi00bNgQNWrUwKpVq/DixQucP39ebXlOTk44fvw4hg4diuHDhyM1NRUA0LdvX1SoUAGrV6/G559/rnH9lK09DRo0gLW1NbZt24ZatWrh1q1bABh4iIjoHaP1Tr4iRluz1aZMmSLMzc3FpUuXhBBCHDx4MMOssEOHDgmFQiGWLVuWo3Lv378vpk2bJgCIxYsXZ7nwozocJ0REREUNZ6vpgeHDh+Pvv/9G8+bN8eOPP6ruGRYfH4/58+dj/PjxaNGiBXr16qVReenH9ijvSm9paYlz584B4KwwIiKi3OKA7Gxo895qT548Qd++fbF161aYm5sjISEBpqamSElJQY8ePbBgwQJYWFhoVNbkyZMxZcqULF8PDAzE5MmT81RfIiIifZWX6zfDUTa0GY6Ubty4gfnz52PevHkICAhAQEBAju8Mz1lhREREWeNsNT2RPtDUr18fAODp6YmHDx/i4cOHOQo0DD9ERET5g+GoAC1ZsuStrrD0K0+zK4yIiEj3GI4KEAc+ExERFX4MRwWIXWFERESFn4GuK0BERERUmDAcEREREaXDcERERESUDsMRERERUToMR0RERETpMBwRERERpcNwRERERJSO3oSj6Oho+Pr6wtraGra2tujXrx/i4+Oz3P/OnTtQKBSZPtavX1+ANSciIiJ9ojfhyNfXF5cvX8aePXuwfft2HD58GAMHDsxy/1KlSqnuZaZ8TJkyBZaWlmjfvn0B1pyIiIj0iUIIIXRdieyEhoaiatWqOH36NOrWrQsACAoKgo+PD+7fvw8XFxeNyqlTpw48PT3x66+/avzZebmrLxEREelGXq7fetFydOLECdja2qqCEQC0atUKBgYGOHnypEZlBAcH49y5c+jXr5/a/RITExEbG5vhQURERO8OvQhHkZGRcHR0zLDNyMgI9vb2iIyM1KiMX3/9FR4eHmjcuLHa/aZPnw4bGxvVo1SpUrmuNxEREekfnYajcePGZTloWvm4evVqnj8nISEBa9asybbVCADGjx+PmJgY1ePevXt5/nwiIiLSH0a6/PCRI0eid+/eavcpX748nJycEBUVlWF7SkoKoqOj4eTklO3nbNiwAS9evECvXr2y3dfU1BSmpqaq58ohWexeIyIi0h/K63ZuhlbrNBw5ODjAwcEh2/0aNWqEZ8+eITg4GF5eXgCA/fv3Iy0tDQ0aNMj2/b/++is6duyo0We9KS4uDgDYvUZERKSH4uLiYGNjk6P36MVsNQBo3749Hj58iMWLFyM5ORl9+vRB3bp1sWbNGgDAgwcP4O3tjZUrV6J+/fqq9924cQOVK1fGjh070K5duxx/blpaGsLDw2FlZQWFQqG144mNjUWpUqVw7949zoIrQDzvusHzrhs877rB864bb553IQTi4uLg4uICA4OcjSLSactRTqxevRr+/v7w9vaGgYEBunTpgnnz5qleT05ORlhYGF68eJHhfb/99hvc3NzQpk2bXH2ugYEB3Nzc8lR3daytrfmPRwd43nWD5103eN51g+ddN9Kf95y2GCnpTctRUcP1k3SD5103eN51g+ddN3jedUOb510vpvITERERFRSGIx0xNTVFYGBghplxlP943nWD5103eN51g+ddN7R53tmtRkRERJQOW46IiIiI0mE4IiIiIkqH4YiIiIgoHYYjIiIionQYjnRkwYIFKFu2LMzMzNCgQQOcOnVK11Uq0iZPnvzWTY3d3d11Xa0i5/Dhw+jQoQNcXFygUCiwefPmDK8LIfDNN9/A2dkZ5ubmaNWqFa5fv66byhYh2Z333r17v/X9z80dA+i16dOno169erCysoKjoyM++ugjhIWFZdjn5cuXGDJkCIoXLw5LS0t06dIFDx8+1FGNiwZNznvz5s3f+r5/+eWXOfochiMd+OuvvxAQEIDAwECEhISgVq1aaNu27Vs31yXtqlatGiIiIlSPo0eP6rpKRc7z589Rq1YtLFiwINPXZ8yYgXnz5mHx4sU4efIkLCws0LZtW7x8+bKAa1q0ZHfeAaBdu3YZvv9r164twBoWPYcOHcKQIUPw77//Ys+ePUhOTkabNm3w/Plz1T4jRozAtm3bsH79ehw6dAjh4eHo3LmzDmut/zQ57wAwYMCADN/3GTNm5OyDBBW4+vXriyFDhqiep6amChcXFzF9+nQd1qpoCwwMFLVq1dJ1Nd4pAMSmTZtUz9PS0oSTk5P48ccfVduePXsmTE1Nxdq1a3VQw6LpzfMuhBBffPGF6NSpk07q866IiooSAMShQ4eEEPK7bWxsLNavX6/aJzQ0VAAQJ06c0FU1i5w3z7sQQjRr1kwMGzYsT+Wy5aiAJSUlITg4GK1atVJtMzAwQKtWrXDixAkd1qzou379OlxcXFC+fHn4+vri7t27uq7SO+X27duIjIzM8N23sbFBgwYN+N0vAAcPHoSjoyOqVKmCQYMG4cmTJ7quUpESExMDALC3twcABAcHIzk5OcP33d3dHaVLl+b3XYvePO9Kq1evRokSJVC9enWMHz/+rfuuZkdvbjxbVDx+/BipqakoWbJkhu0lS5bE1atXdVSroq9BgwZYsWIFqlSpgoiICEyZMgXvvfceLl26BCsrK11X750QGRkJAJl+95WvUf5o164dOnfujHLlyuHmzZuYMGEC2rdvjxMnTsDQ0FDX1dN7aWlpGD58OJo0aYLq1asDkN93ExMT2NraZtiX33ftyey8A8Dnn3+OMmXKwMXFBRcuXMDYsWMRFhaGjRs3alw2wxG9E9q3b6/6uWbNmmjQoAHKlCmDdevWoV+/fjqsGVH+6969u+rnGjVqoGbNmqhQoQIOHjwIb29vHdasaBgyZAguXbrEcYwFLKvzPnDgQNXPNWrUgLOzM7y9vXHz5k1UqFBBo7LZrVbASpQoAUNDw7dmLDx8+BBOTk46qtW7x9bWFpUrV8aNGzd0XZV3hvL7ze++7pUvXx4lSpTg918L/P39sX37dhw4cABubm6q7U5OTkhKSsKzZ88y7M/vu3Zkdd4z06BBAwDI0fed4aiAmZiYwMvLC/v27VNtS0tLw759+9CoUSMd1uzdEh8fj5s3b8LZ2VnXVXlnlCtXDk5OThm++7GxsTh58iS/+wXs/v37ePLkCb//eSCEgL+/PzZt2oT9+/ejXLlyGV738vKCsbFxhu97WFgY7t69y+97HmR33jNz7tw5AMjR953dajoQEBCAL774AnXr1kX9+vUxZ84cPH/+HH369NF11YqsUaNGoUOHDihTpgzCw8MRGBgIQ0NDfPbZZ7quWpESHx+f4bez27dv49y5c7C3t0fp0qUxfPhwfPvtt6hUqRLKlSuHSZMmwcXFBR999JHuKl0EqDvv9vb2mDJlCrp06QInJyfcvHkTY8aMQcWKFdG2bVsd1lq/DRkyBGvWrMGWLVtgZWWlGkdkY2MDc3Nz2NjYoF+/fggICIC9vT2sra3x1VdfoVGjRmjYsKGOa6+/sjvvN2/exJo1a+Dj44PixYvjwoULGDFiBN5//33UrFlT8w/K01w3yrX58+eL0qVLCxMTE1G/fn3x77//6rpKRVq3bt2Es7OzMDExEa6urqJbt27ixo0buq5WkXPgwAEB4K3HF198IYSQ0/knTZokSpYsKUxNTYW3t7cICwvTbaWLAHXn/cWLF6JNmzbCwcFBGBsbizJlyogBAwaIyMhIXVdbr2V2vgGI5cuXq/ZJSEgQgwcPFnZ2dqJYsWLi448/FhEREbqrdBGQ3Xm/e/eueP/994W9vb0wNTUVFStWFKNHjxYxMTE5+hzFqw8jIiIiInDMEREREVEGDEdERERE6TAcEREREaXDcERERESUDsMRERERUToMR0RERETpMBwRERERpcNwRERERJQOwxERFRrNmzfH8OHDNd5foVBg8+bN+VYfAJg8eTJq166dr59BRIULV8gmokIjOjoaxsbGsLKy0mj/yMhI2NnZwdTUVCufr1AosGnTpgz3eouPj0diYiKKFy+ulc8gosKPN54lokLD3t4+R/s7OTnlU01es7S0hKWlZb5/DhEVHuxWI6JCI323WtmyZfHdd9+hb9++sLKyQunSpbF06dIM+7/ZrXbv3j107doVtra2sLe3R6dOnXDnzp0M7/ntt99QrVo1mJqawtnZGf7+/qrPA4CPP/4YCoVC9fzNbrW0tDRMnToVbm5uMDU1Re3atREUFKR6/c6dO1AoFNi4cSNatGiBYsWKoVatWjhx4oRWzhER5T+GIyIqtGbNmoW6devi7NmzGDx4MAYNGoSwsLBM901OTkbbtm1hZWWFI0eO4NixY7C0tES7du2QlJQEAFi0aBGGDBmCgQMH4uLFi9i6dSsqVqwIADh9+jQAYPny5YiIiFA9f9PcuXMxa9YszJw5ExcuXEDbtm3RsWNHXL9+PcN+X3/9NUaNGoVz586hcuXK+Oyzz5CSkqKtU0NE+UkQERUSzZo1E8OGDRNCCFGmTBnRo0cP1WtpaWnC0dFRLFq0SLUNgNi0aZMQQog//vhDVKlSRaSlpaleT0xMFObm5mLXrl1CCCFcXFzE119/neXnpy9PKTAwUNSqVUv13MXFRfzvf//LsE+9evXE4MGDhRBC3L59WwAQv/zyi+r1y5cvCwAiNDQ0+5NARDrHliMiKrRq1qyp+lmhUMDJyQlRUVGZ7nv+/HncuHEDVlZWqnFC9vb2ePnyJW7evImoqCiEh4fD29s71/WJjY1FeHg4mjRpkmF7kyZNEBoammXdnZ2dASDLuhNR4cIB2URUaBkbG2d4rlAokJaWlum+8fHx8PLywurVq996zcHBAQYGBfu7YPq6KxQKAMiy7kRUuLDliIiKBE9PT1y/fh2Ojo6oWLFihoeNjQ2srKxQtmxZ7Nu3L8syjI2NkZqamuXr1tbWcHFxwbFjxzJsP3bsGKpWraq1YyEi3WI4IqIiwdfXFyVKlECnTp1w5MgR3L59GwcPHsTQoUNx//59AHLm2axZszBv3jxcv34dISEhmD9/vqoMZXiKjIzE06dPM/2c0aNH44cffsBff/2FsLAwjBs3DufOncOwYcMK5DiJKP+xW42IioRixYrh8OHDGDt2LDp37oy4uDi4urrC29sb1tbWAIAvvvgCL1++xOzZszFq1CiUKFECn3zyiaqMWbNmISAgAMuWLYOrq+tbywAAwNChQxETE4ORI0ciKioKVatWxdatW1GpUqWCOlQiymdcIZuI9FJiYiLMzMywZ88etGrVStfVIaIihC1HRKR3YmNjsXHjRhgYGMDd3V3X1SGiIobhiIj0TmBgINasWYMffvgBbm5uuq4OERUx7FYjIiIiSoez1YiIiIjSYTgiIiIiSofhiIiIiCgdhiMiIiKidBiOiIiIiNJhOCIiIiJKh+GIiIiIKB2GIyIiIqJ0/g/wCUg1GlS8DAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -270,66 +583,81 @@ } ], "source": [ - "\n", - "df = gm.as_df\n", - "\n", "style = {\"s\":50,\n", " \"facecolor\":\"none\",\n", " \"edgecolor\":\"black\"}\n", + "err_style = {\"lw\":0,\n", + " \"elinewidth\":1,\n", + " \"capsize\":2}\n", + "\n", "color_order = [\"red\",\"black\"]\n", + "fig, ax = plt.subplots(1,figsize=(6,6))\n", "\n", - "for expt in np.unique(df[\"expt_id\"]):\n", - " this_df = df.loc[df[\"expt_id\"] == expt,:]\n", + "out_df = gm.as_df.copy()\n", + "y_calc = gm.model(np.array(f.fit_df[\"estimate\"]))\n", "\n", - " x = np.arange(len(this_df))\n", + "for i in np.unique(out_df.expt_id):\n", + " \n", + " style[\"edgecolor\"] = color_order[i]\n", + " err_style[\"color\"] = color_order[i]\n", + "\n", + " mask = out_df[\"expt_id\"] == i\n", + " this_df = out_df.loc[mask,:]\n", + " \n", + " x_values = np.cumsum(this_df[\"injection\"])\n", + " y_values = np.array(this_df[\"y_obs\"])\n", + " y_err = np.array(this_df[\"y_std\"])/np.mean(this_df[\"injection\"])\n", + " this_y_calc = y_calc[mask]/this_df[\"injection\"]\n", + "\n", + " y_values = y_values/this_df[\"injection\"]\n", + " \n", + " ax.scatter(x_values,y_values,**style)\n", + " ax.errorbar(x=x_values,\n", + " y=y_values,\n", + " yerr=y_err,\n", + " **err_style)\n", + "\n", + " ax.plot(x_values,this_y_calc,'-',color=color_order[i])\n", + " \n", "\n", - " style[\"edgecolor\"] = color_order[expt]\n", - " plt.scatter(x,this_df[\"y_obs\"],**style)\n", - " plt.errorbar(x=x,\n", - " y=this_df[\"y_obs\"],\n", - " yerr=this_df[\"y_stdev\"],\n", - " ls=\"none\",\n", - " lw=1,\n", - " capsize=3,\n", - " color=color_order[expt])\n", - " plt.plot(np.arange(len(this_df)),\n", - " this_df[\"y_calc\"],\n", - " '-',\n", - " lw=2,\n", - " color=color_order[expt])\n", "plt.xlabel(\"injection\")\n", "plt.ylabel(\"heat\")\n", "\n", - "F.fit_to_df" + "f.fit_df" ] }, { - "cell_type": "markdown", - "id": "05c00ad5-e78d-473d-9b75-912a24b41f63", + "cell_type": "code", + "execution_count": 15, + "id": "d72d8bfd-d925-445e-967d-4f6603621a2d", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#### Corner plot to look for parameter correlations" + "fig = dataprob.plot_corner(f)" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "7e403511-ccb0-4181-9e3a-efa381aacf6a", + "execution_count": 16, + "id": "0ea45b60-d8f5-42cc-88ca-3afc0f6a8f3b", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "not doing corner plot for parameter nuisance_dil_CT\n", - "not doing corner plot for parameter nuisance_dil_ET\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -337,21 +665,13 @@ } ], "source": [ - "_ = F.corner_plot(filter_params=\"nuisance\")" + "fig = dataprob.plot_summary(f)\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "6ffe58ee-d894-4cb5-9d91-a261a9d9e48a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d72d8bfd-d925-445e-967d-4f6603621a2d", + "id": "81dc68e5-756e-4b53-8b09-704f935525e7", "metadata": {}, "outputs": [], "source": [] diff --git a/reports/flake.txt b/reports/flake.txt index 46ed83b..fe165f1 100644 --- a/reports/flake.txt +++ b/reports/flake.txt @@ -1,14 +1,7 @@ ./build/lib/linkage/__init__.py:2:1: F401 'linkage.experiment.Experiment' imported but unused -./build/lib/linkage/__init__.py:3:1: F401 'linkage.organizer.GlobalModel' imported but unused +./build/lib/linkage/__init__.py:3:1: F401 'linkage.global_model.GlobalModel' imported but unused ./build/lib/linkage/__init__.py:12:52: E231 missing whitespace after ',' ./build/lib/linkage/__init__.py:13:36: W292 no newline at end of file -./build/lib/linkage/cli.py:2:1: F401 'linkage' imported but unused -./build/lib/linkage/cli.py:7:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/cli.py:8:1: W293 blank line contains whitespace -./build/lib/linkage/cli.py:15:1: W293 blank line contains whitespace -./build/lib/linkage/cli.py:16:5: F841 local variable 'args' is assigned to but never used -./build/lib/linkage/cli.py:20:1: W293 blank line contains whitespace -./build/lib/linkage/cli.py:20:5: W292 no newline at end of file ./build/lib/linkage/experiment/__init__.py:2:1: F401 'linkage.experiment.experiment.Experiment' imported but unused ./build/lib/linkage/experiment/__init__.py:3:1: W391 blank line at end of file ./build/lib/linkage/experiment/baseline_corrector.py:4:1: E302 expected 2 blank lines, found 1 @@ -58,173 +51,302 @@ ./build/lib/linkage/experiment/experiment.py:97:75: W291 trailing whitespace ./build/lib/linkage/experiment/experiment.py:98:50: W291 trailing whitespace ./build/lib/linkage/experiment/experiment.py:104:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:118:43: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:131:76: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:133:34: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:135:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:143:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:149:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:155:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:156:34: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:162:49: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:164:42: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:172:54: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:173:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:178:24: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:182:65: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:187:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:188:48: E231 missing whitespace after ':' -./build/lib/linkage/experiment/experiment.py:189:56: E231 missing whitespace after ':' -./build/lib/linkage/experiment/experiment.py:192:5: E303 too many blank lines (2) -./build/lib/linkage/experiment/experiment.py:198:63: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:199:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:204:24: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:208:65: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:210:78: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:211:39: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:219:76: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:225:77: W291 trailing whitespace -./build/lib/linkage/experiment/experiment.py:231:45: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:234:40: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:244:48: E231 missing whitespace after ':' -./build/lib/linkage/experiment/experiment.py:245:56: E231 missing whitespace after ':' -./build/lib/linkage/experiment/experiment.py:246:56: E231 missing whitespace after ':' +./build/lib/linkage/experiment/experiment.py:106:50: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:111:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:118:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:119:43: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:132:74: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:134:34: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:136:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:144:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:150:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:156:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:157:34: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:163:49: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:165:42: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:173:54: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:174:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:179:24: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:183:65: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:187:72: E127 continuation line over-indented for visual indent +./build/lib/linkage/experiment/experiment.py:188:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:189:48: E231 missing whitespace after ':' +./build/lib/linkage/experiment/experiment.py:190:54: E231 missing whitespace after ':' +./build/lib/linkage/experiment/experiment.py:193:5: E303 too many blank lines (2) +./build/lib/linkage/experiment/experiment.py:199:63: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:200:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:205:24: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:209:65: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:211:78: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:212:39: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:220:76: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:226:77: W291 trailing whitespace +./build/lib/linkage/experiment/experiment.py:232:45: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:235:40: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:245:48: E231 missing whitespace after ':' +./build/lib/linkage/experiment/experiment.py:246:54: E231 missing whitespace after ':' ./build/lib/linkage/experiment/experiment.py:247:56: E231 missing whitespace after ':' -./build/lib/linkage/experiment/experiment.py:248:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:249:34: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:249:45: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experiment.py:260:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:276:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experiment.py:279:43: W292 no newline at end of file -./build/lib/linkage/experiment/experimental_point.py:3:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/experimental_point.py:6:13: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:8:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:18:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:38:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:48:1: E303 too many blank lines (3) -./build/lib/linkage/experiment/experimental_point.py:50:66: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:51:67: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:63:47: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:64:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:92:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:95:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:96:24: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:96:30: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:98:75: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:102:49: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:103:42: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:111:49: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:124:38: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:125:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:142:75: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:149:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:155:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:159:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:160:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:161:5: E303 too many blank lines (2) -./build/lib/linkage/experiment/experimental_point.py:161:24: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:161:35: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:161:41: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:165:17: W291 trailing whitespace -./build/lib/linkage/experiment/experimental_point.py:174:41: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:174:76: E231 missing whitespace after ',' -./build/lib/linkage/experiment/experimental_point.py:175:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/experimental_point.py:176:35: W292 no newline at end of file -./build/lib/linkage/experiment/point/__init__.py:1:1: W391 blank line at end of file -./build/lib/linkage/experiment/point/experimental_point.py:1:1: F401 'numpy as np' imported but unused -./build/lib/linkage/experiment/point/experimental_point.py:3:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/point/experimental_point.py:6:13: W291 trailing whitespace -./build/lib/linkage/experiment/point/experimental_point.py:8:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/experimental_point.py:19:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/experimental_point.py:40:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/experimental_point.py:47:1: W391 blank line at end of file -./build/lib/linkage/experiment/point/itc_point.py:6:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/point/itc_point.py:9:49: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:25:38: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:26:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:42:78: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:46:75: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:53:76: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:56:75: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:59:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:66:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:76:60: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:79:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:80:24: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:80:35: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:80:41: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:84:17: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:93:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:97:74: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:98:53: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:101:20: E221 multiple spaces before operator -./build/lib/linkage/experiment/point/itc_point.py:101:51: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:102:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/itc_point.py:103:72: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:104:42: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:107:73: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:109:78: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:110:71: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:115:32: W291 trailing whitespace -./build/lib/linkage/experiment/point/itc_point.py:117:71: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/itc_point.py:119:26: W292 no newline at end of file -./build/lib/linkage/experiment/point/spec_point.py:6:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/point/spec_point.py:8:66: W291 trailing whitespace -./build/lib/linkage/experiment/point/spec_point.py:9:67: W291 trailing whitespace -./build/lib/linkage/experiment/point/spec_point.py:22:47: W291 trailing whitespace -./build/lib/linkage/experiment/point/spec_point.py:23:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/spec_point.py:39:78: W291 trailing whitespace -./build/lib/linkage/experiment/point/spec_point.py:55:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/spec_point.py:58:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/spec_point.py:59:24: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/spec_point.py:59:30: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/spec_point.py:61:75: W291 trailing whitespace -./build/lib/linkage/experiment/point/spec_point.py:65:49: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/spec_point.py:66:42: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/spec_point.py:70:1: W391 blank line at end of file -./build/lib/linkage/experiment/point/test_itc_point.py:6:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/point/test_itc_point.py:12:30: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:12:34: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:13:30: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:13:33: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:17:26: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:18:21: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:19:21: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:22:26: E231 missing whitespace after ',' -./build/lib/linkage/experiment/point/test_itc_point.py:34:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/test_itc_point.py:40:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/point/test_itc_point.py:46:1: W391 blank line at end of file +./build/lib/linkage/experiment/experiment.py:248:56: E231 missing whitespace after ':' +./build/lib/linkage/experiment/experiment.py:249:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:250:34: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:250:45: E231 missing whitespace after ',' +./build/lib/linkage/experiment/experiment.py:261:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:277:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:281:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/experiment.py:284:45: W292 no newline at end of file ./build/lib/linkage/experiment/titrator.py:6:1: E302 expected 2 blank lines, found 1 ./build/lib/linkage/experiment/titrator.py:9:79: W291 trailing whitespace ./build/lib/linkage/experiment/titrator.py:16:74: W291 trailing whitespace ./build/lib/linkage/experiment/titrator.py:18:77: W291 trailing whitespace ./build/lib/linkage/experiment/titrator.py:19:1: W293 blank line contains whitespace ./build/lib/linkage/experiment/titrator.py:23:40: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:29:42: E231 missing whitespace after ',' -./build/lib/linkage/experiment/titrator.py:33:45: E231 missing whitespace after ',' -./build/lib/linkage/experiment/titrator.py:40:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:45:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:56:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/titrator.py:74:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:83:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/experiment/titrator.py:88:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:98:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:117:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:120:1: E303 too many blank lines (3) -./build/lib/linkage/experiment/titrator.py:127:55: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:128:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:135:32: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:140:32: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:145:51: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:147:90: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:148:67: W291 trailing whitespace -./build/lib/linkage/experiment/titrator.py:149:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:160:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:162:47: E231 missing whitespace after ',' -./build/lib/linkage/experiment/titrator.py:163:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:25:78: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:33:42: E231 missing whitespace after ',' +./build/lib/linkage/experiment/titrator.py:37:45: E231 missing whitespace after ',' +./build/lib/linkage/experiment/titrator.py:52:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:57:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:68:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/experiment/titrator.py:85:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:94:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/experiment/titrator.py:99:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:102:5: F841 local variable 'meas_vol_dilution' is assigned to but never used +./build/lib/linkage/experiment/titrator.py:107:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:125:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:128:1: E303 too many blank lines (3) +./build/lib/linkage/experiment/titrator.py:135:55: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:136:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:143:32: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:148:32: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:153:51: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:155:90: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:156:67: W291 trailing whitespace +./build/lib/linkage/experiment/titrator.py:157:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:168:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:170:47: E231 missing whitespace after ',' ./build/lib/linkage/experiment/titrator.py:171:1: W293 blank line contains whitespace -./build/lib/linkage/experiment/titrator.py:173:5: E303 too many blank lines (2) -./build/lib/linkage/experiment/titrator.py:185:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:178:1: W293 blank line contains whitespace +./build/lib/linkage/experiment/titrator.py:191:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/__init__.py:1:1: F401 'linkage.global_model.global_model.GlobalModel' imported but unused +./build/lib/linkage/global_model/__init__.py:1:58: W292 no newline at end of file +./build/lib/linkage/global_model/global_model.py:10:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/global_model/global_model.py:13:74: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:15:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:18:76: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:22:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:25:78: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:28:37: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:31:80: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:33:36: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:41:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:53:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:57:59: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:64:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:70:61: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:72:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:78:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:79:59: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:81:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:82:58: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:89:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:103:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:106:77: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:107:42: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:112:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:123:78: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:124:74: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:125:44: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:130:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:131:5: E303 too many blank lines (2) +./build/lib/linkage/global_model/global_model.py:136:49: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:139:13: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:142:81: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:143:34: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:148:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:150:58: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:153:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:157:27: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:160:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:169:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:170:58: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:198:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:205:46: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:207:83: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:209:48: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:242:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:247:5: C901 'GlobalModel._get_enthalpy_param' is too complex (13) +./build/lib/linkage/global_model/global_model.py:247:5: E303 too many blank lines (2) +./build/lib/linkage/global_model/global_model.py:249:44: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:250:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:252:71: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:253:72: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:255:66: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:258:71: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:259:68: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:260:72: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:266:41: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:272:32: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:273:19: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:277:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:283:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:285:32: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:300:75: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:301:43: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:303:53: E127 continuation line over-indented for visual indent +./build/lib/linkage/global_model/global_model.py:311:29: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:314:33: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:321:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:323:66: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:324:25: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:334:59: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:335:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:337:60: E221 multiple spaces before operator +./build/lib/linkage/global_model/global_model.py:338:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:343:52: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:346:70: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:349:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:351:33: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:357:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:360:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:361:61: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:362:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:365:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:367:5: E303 too many blank lines (2) +./build/lib/linkage/global_model/global_model.py:367:24: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:367:34: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:367:43: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:372:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:374:58: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:375:61: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:377:39: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:379:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:380:30: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:381:35: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:382:34: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:383:38: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:384:38: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:385:42: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:386:39: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:387:43: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:391:54: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:398:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:400:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:418:70: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:419:76: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:420:41: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:433:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:436:49: E127 continuation line over-indented for visual indent +./build/lib/linkage/global_model/global_model.py:437:48: E127 continuation line over-indented for visual indent +./build/lib/linkage/global_model/global_model.py:440:57: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:445:78: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:452:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:453:51: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:456:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:463:79: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:469:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:470:30: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:473:74: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:475:27: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:476:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:480:73: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:482:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:486:70: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:491:67: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:492:78: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:494:20: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:506:19: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:509:32: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:514:73: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:516:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:524:48: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:527:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:529:78: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:540:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:545:36: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:550:74: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:554:40: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:555:100: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:583:69: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:587:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:591:71: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:592:71: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:602:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:609:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:616:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:620:75: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:621:15: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:624:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:628:75: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:629:15: W291 trailing whitespace +./build/lib/linkage/global_model/global_model.py:632:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:636:25: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:637:27: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:638:26: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:639:24: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:640:27: E231 missing whitespace after ':' +./build/lib/linkage/global_model/global_model.py:649:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:652:34: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:658:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:659:36: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:672:52: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:675:52: E231 missing whitespace after ',' +./build/lib/linkage/global_model/global_model.py:676:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:684:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/global_model.py:684:9: W292 no newline at end of file +./build/lib/linkage/global_model/point/__init__.py:1:1: W391 blank line at end of file +./build/lib/linkage/global_model/point/experimental_point.py:6:13: W291 trailing whitespace +./build/lib/linkage/global_model/point/experimental_point.py:8:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/experimental_point.py:21:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/experimental_point.py:30:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/experimental_point.py:32:5: E303 too many blank lines (2) +./build/lib/linkage/global_model/point/experimental_point.py:45:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/experimental_point.py:52:1: W391 blank line at end of file +./build/lib/linkage/global_model/point/itc_point.py:6:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/global_model/point/itc_point.py:9:49: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:27:38: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:28:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:44:78: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:55:76: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:58:75: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:62:23: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:64:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:74:37: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:84:60: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:91:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:92:5: E303 too many blank lines (2) +./build/lib/linkage/global_model/point/itc_point.py:92:24: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:92:35: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:92:41: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:96:17: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:105:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:107:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:108:49: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:111:74: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:112:53: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:115:20: E221 multiple spaces before operator +./build/lib/linkage/global_model/point/itc_point.py:115:51: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:116:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:117:74: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:118:77: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:122:73: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:124:78: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:125:71: W291 trailing whitespace +./build/lib/linkage/global_model/point/itc_point.py:134:55: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/itc_point.py:136:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/itc_point.py:137:26: W292 no newline at end of file +./build/lib/linkage/global_model/point/spec_point.py:6:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/global_model/point/spec_point.py:8:66: W291 trailing whitespace +./build/lib/linkage/global_model/point/spec_point.py:9:67: W291 trailing whitespace +./build/lib/linkage/global_model/point/spec_point.py:24:47: W291 trailing whitespace +./build/lib/linkage/global_model/point/spec_point.py:25:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/spec_point.py:41:78: W291 trailing whitespace +./build/lib/linkage/global_model/point/spec_point.py:63:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/spec_point.py:66:1: W293 blank line contains whitespace +./build/lib/linkage/global_model/point/spec_point.py:67:24: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/spec_point.py:67:30: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/spec_point.py:69:75: W291 trailing whitespace +./build/lib/linkage/global_model/point/spec_point.py:73:49: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/spec_point.py:74:42: E231 missing whitespace after ',' +./build/lib/linkage/global_model/point/spec_point.py:78:1: W391 blank line at end of file ./build/lib/linkage/models/__init__.py:2:1: F401 'linkage.models.six_state_edta.SixStateEDTA' imported but unused ./build/lib/linkage/models/__init__.py:3:1: F401 'linkage.models.ca_edta.CaEDTA' imported but unused ./build/lib/linkage/models/base.py:7:1: E302 expected 2 blank lines, found 1 @@ -285,45 +407,49 @@ ./build/lib/linkage/models/base.py:320:28: E231 missing whitespace after ',' ./build/lib/linkage/models/base.py:320:34: E231 missing whitespace after ',' ./build/lib/linkage/models/base.py:322:54: W291 trailing whitespace -./build/lib/linkage/models/base.py:336:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:340:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:341:61: W291 trailing whitespace -./build/lib/linkage/models/base.py:344:26: W291 trailing whitespace +./build/lib/linkage/models/base.py:335:79: W291 trailing whitespace +./build/lib/linkage/models/base.py:337:48: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:337:65: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:344:59: E231 missing whitespace after ',' ./build/lib/linkage/models/base.py:345:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:348:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:349:73: W291 trailing whitespace -./build/lib/linkage/models/base.py:350:75: W291 trailing whitespace -./build/lib/linkage/models/base.py:352:48: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:356:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:359:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:360:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:361:5: E303 too many blank lines (2) -./build/lib/linkage/models/base.py:361:23: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:361:35: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:364:76: W291 trailing whitespace -./build/lib/linkage/models/base.py:365:57: W291 trailing whitespace -./build/lib/linkage/models/base.py:366:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:369:77: W291 trailing whitespace -./build/lib/linkage/models/base.py:370:79: W291 trailing whitespace -./build/lib/linkage/models/base.py:374:77: W291 trailing whitespace -./build/lib/linkage/models/base.py:375:72: W291 trailing whitespace -./build/lib/linkage/models/base.py:376:73: W291 trailing whitespace -./build/lib/linkage/models/base.py:383:27: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:388:70: W291 trailing whitespace -./build/lib/linkage/models/base.py:389:76: W291 trailing whitespace -./build/lib/linkage/models/base.py:390:55: W291 trailing whitespace -./build/lib/linkage/models/base.py:392:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:396:30: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:401:70: W291 trailing whitespace -./build/lib/linkage/models/base.py:402:78: W291 trailing whitespace -./build/lib/linkage/models/base.py:403:52: W291 trailing whitespace -./build/lib/linkage/models/base.py:409:30: E231 missing whitespace after ',' -./build/lib/linkage/models/base.py:410:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:414:74: W291 trailing whitespace -./build/lib/linkage/models/base.py:416:34: W291 trailing whitespace -./build/lib/linkage/models/base.py:423:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:427:1: W293 blank line contains whitespace -./build/lib/linkage/models/base.py:434:29: W292 no newline at end of file +./build/lib/linkage/models/base.py:349:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:350:61: W291 trailing whitespace +./build/lib/linkage/models/base.py:353:26: W291 trailing whitespace +./build/lib/linkage/models/base.py:354:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:357:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:358:73: W291 trailing whitespace +./build/lib/linkage/models/base.py:359:75: W291 trailing whitespace +./build/lib/linkage/models/base.py:361:48: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:365:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:368:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:369:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:370:5: E303 too many blank lines (2) +./build/lib/linkage/models/base.py:370:23: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:370:35: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:373:76: W291 trailing whitespace +./build/lib/linkage/models/base.py:374:57: W291 trailing whitespace +./build/lib/linkage/models/base.py:375:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:378:77: W291 trailing whitespace +./build/lib/linkage/models/base.py:379:79: W291 trailing whitespace +./build/lib/linkage/models/base.py:383:77: W291 trailing whitespace +./build/lib/linkage/models/base.py:384:72: W291 trailing whitespace +./build/lib/linkage/models/base.py:385:73: W291 trailing whitespace +./build/lib/linkage/models/base.py:392:27: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:397:70: W291 trailing whitespace +./build/lib/linkage/models/base.py:398:76: W291 trailing whitespace +./build/lib/linkage/models/base.py:399:55: W291 trailing whitespace +./build/lib/linkage/models/base.py:401:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:405:30: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:410:70: W291 trailing whitespace +./build/lib/linkage/models/base.py:411:78: W291 trailing whitespace +./build/lib/linkage/models/base.py:412:52: W291 trailing whitespace +./build/lib/linkage/models/base.py:418:30: E231 missing whitespace after ',' +./build/lib/linkage/models/base.py:419:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:423:74: W291 trailing whitespace +./build/lib/linkage/models/base.py:425:34: W291 trailing whitespace +./build/lib/linkage/models/base.py:432:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:436:1: W293 blank line contains whitespace +./build/lib/linkage/models/base.py:443:29: W292 no newline at end of file ./build/lib/linkage/models/ca_edta.py:6:1: E302 expected 2 blank lines, found 1 ./build/lib/linkage/models/ca_edta.py:15:1: W293 blank line contains whitespace ./build/lib/linkage/models/ca_edta.py:16:23: E231 missing whitespace after ',' @@ -338,6 +464,59 @@ ./build/lib/linkage/models/ca_edta.py:39:33: E231 missing whitespace after ',' ./build/lib/linkage/models/ca_edta.py:47:30: E231 missing whitespace after ',' ./build/lib/linkage/models/ca_edta.py:48:1: W293 blank line contains whitespace +./build/lib/linkage/models/head_to_head.py:6:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/models/head_to_head.py:17:1: W293 blank line contains whitespace +./build/lib/linkage/models/head_to_head.py:18:23: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:18:35: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:26:32: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:26:34: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:26:37: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:26:39: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:26:42: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:27:1: W293 blank line contains whitespace +./build/lib/linkage/models/head_to_head.py:32:31: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:32:33: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:32:35: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:32:37: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:33:1: W293 blank line contains whitespace +./build/lib/linkage/models/head_to_head.py:45:32: E225 missing whitespace around operator +./build/lib/linkage/models/head_to_head.py:49:52: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:50:1: W293 blank line contains whitespace +./build/lib/linkage/models/head_to_head.py:57:27: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:57:30: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:57:32: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:57:35: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:57:38: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:61:30: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:65:30: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:65:35: E231 missing whitespace after ',' +./build/lib/linkage/models/head_to_head.py:66:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:8:1: E302 expected 2 blank lines, found 1 +./build/lib/linkage/models/receptor_competitor.py:20:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:22:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:23:23: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:23:35: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:26:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:29:32: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:29:35: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:39:32: E225 missing whitespace around operator +./build/lib/linkage/models/receptor_competitor.py:43:50: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:44:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:53:27: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:29: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:31: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:33: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:36: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:40: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:53:44: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:57:29: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:57:34: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:61:30: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:61:35: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:61:40: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:62:1: W293 blank line contains whitespace +./build/lib/linkage/models/receptor_competitor.py:65:50: E231 missing whitespace after ',' +./build/lib/linkage/models/receptor_competitor.py:65:56: E231 missing whitespace after ',' ./build/lib/linkage/models/six_state_edta.py:25:25: E231 missing whitespace after ',' ./build/lib/linkage/models/six_state_edta.py:25:28: E231 missing whitespace after ',' ./build/lib/linkage/models/six_state_edta.py:25:31: E231 missing whitespace after ',' @@ -394,203 +573,8 @@ ./build/lib/linkage/models/six_state_edta.py:114:35: E231 missing whitespace after ',' ./build/lib/linkage/models/six_state_edta.py:115:1: W293 blank line contains whitespace ./build/lib/linkage/models/six_state_edta.py:119:1: W391 blank line at end of file -./build/lib/linkage/organizer/__init__.py:1:1: F401 'linkage.organizer.global_model.GlobalModel' imported but unused -./build/lib/linkage/organizer/__init__.py:1:55: W292 no newline at end of file -./build/lib/linkage/organizer/global_fit.py:10:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/organizer/global_fit.py:12:22: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:12:32: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:15:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:37:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:48:61: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:50:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:56:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:57:59: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:59:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:60:58: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:67:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:73:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:81:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:85:15: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:87:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:89:53: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:99:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:100:47: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:115:41: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:122:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:125:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:133:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:135:5: E303 too many blank lines (2) -./build/lib/linkage/organizer/global_fit.py:137:69: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:140:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:146:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:149:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:150:61: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:151:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:154:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:164:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:173:57: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:176:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:178:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:180:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:182:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:183:75: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:184:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:187:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:200:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:202:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:210:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:215:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:220:48: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:224:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:225:5: E303 too many blank lines (2) -./build/lib/linkage/organizer/global_fit.py:225:19: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:226:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:229:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:241:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:243:59: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:246:56: W291 trailing whitespace -./build/lib/linkage/organizer/global_fit.py:247:53: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:250:40: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:257:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:263:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:275:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:279:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:283:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:287:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:291:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:295:25: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_fit.py:296:27: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_fit.py:297:26: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_fit.py:306:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:309:34: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:315:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:316:36: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:326:52: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:329:52: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_fit.py:330:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:337:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_fit.py:337:9: W292 no newline at end of file -./build/lib/linkage/organizer/global_model.py:10:1: E302 expected 2 blank lines, found 1 -./build/lib/linkage/organizer/global_model.py:19:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:45:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:57:61: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:59:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:65:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:66:59: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:68:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:69:58: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:76:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:82:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:90:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:95:77: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:97:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:107:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:108:47: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:123:41: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:130:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:133:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:135:77: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:136:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:138:72: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:141:77: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:142:74: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:143:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:146:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:162:79: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:163:47: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:178:68: E221 multiple spaces before operator -./build/lib/linkage/organizer/global_model.py:179:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:181:5: E303 too many blank lines (2) -./build/lib/linkage/organizer/global_model.py:183:69: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:186:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:192:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:195:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:196:61: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:197:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:200:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:203:79: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:204:75: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:206:73: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:207:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:208:52: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:211:81: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:212:34: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:216:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:218:58: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:221:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:225:76: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:226:19: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:229:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:231:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:240:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:245:5: E303 too many blank lines (2) -./build/lib/linkage/organizer/global_model.py:245:24: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:245:34: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:245:43: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:250:71: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:251:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:254:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:266:48: E127 continuation line over-indented for visual indent -./build/lib/linkage/organizer/global_model.py:268:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:273:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:307:5: E303 too many blank lines (2) -./build/lib/linkage/organizer/global_model.py:328:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:332:14: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:335:49: E127 continuation line over-indented for visual indent -./build/lib/linkage/organizer/global_model.py:336:48: E127 continuation line over-indented for visual indent -./build/lib/linkage/organizer/global_model.py:339:57: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:343:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:350:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:351:51: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:354:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:365:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:372:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:377:48: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:378:59: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:379:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:380:30: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:382:75: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:383:73: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:384:68: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:386:71: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:388:46: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:400:19: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:403:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:406:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:418:78: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:420:59: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:423:56: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:424:53: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:427:40: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:439:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:448:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:475:71: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:479:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:483:71: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:484:67: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:494:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:501:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:508:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:512:75: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:513:15: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:516:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:520:75: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:521:15: W291 trailing whitespace -./build/lib/linkage/organizer/global_model.py:524:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:528:25: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_model.py:529:27: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_model.py:530:26: E231 missing whitespace after ':' -./build/lib/linkage/organizer/global_model.py:539:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:542:34: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:548:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:549:36: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:559:52: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:562:52: E231 missing whitespace after ',' -./build/lib/linkage/organizer/global_model.py:563:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:570:1: W293 blank line contains whitespace -./build/lib/linkage/organizer/global_model.py:570:9: W292 no newline at end of file ./src/linkage/__init__.py:2:1: F401 'linkage.experiment.Experiment' imported but unused -./src/linkage/__init__.py:3:1: F401 'linkage.organizer.GlobalModel' imported but unused +./src/linkage/__init__.py:3:1: F401 'linkage.global_model.GlobalModel' imported but unused ./src/linkage/__init__.py:12:52: E231 missing whitespace after ',' ./src/linkage/__init__.py:13:36: W292 no newline at end of file ./src/linkage/experiment/__init__.py:2:1: F401 'linkage.experiment.experiment.Experiment' imported but unused @@ -642,127 +626,302 @@ ./src/linkage/experiment/experiment.py:97:75: W291 trailing whitespace ./src/linkage/experiment/experiment.py:98:50: W291 trailing whitespace ./src/linkage/experiment/experiment.py:104:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:118:43: W291 trailing whitespace -./src/linkage/experiment/experiment.py:131:76: W291 trailing whitespace -./src/linkage/experiment/experiment.py:133:34: W291 trailing whitespace -./src/linkage/experiment/experiment.py:135:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:143:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:149:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:155:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:156:34: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:162:49: W291 trailing whitespace -./src/linkage/experiment/experiment.py:164:42: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:172:54: W291 trailing whitespace -./src/linkage/experiment/experiment.py:173:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:178:24: W291 trailing whitespace -./src/linkage/experiment/experiment.py:182:65: W291 trailing whitespace -./src/linkage/experiment/experiment.py:187:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:188:48: E231 missing whitespace after ':' -./src/linkage/experiment/experiment.py:189:56: E231 missing whitespace after ':' -./src/linkage/experiment/experiment.py:192:5: E303 too many blank lines (2) -./src/linkage/experiment/experiment.py:198:63: W291 trailing whitespace -./src/linkage/experiment/experiment.py:199:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:204:24: W291 trailing whitespace -./src/linkage/experiment/experiment.py:208:65: W291 trailing whitespace -./src/linkage/experiment/experiment.py:210:78: W291 trailing whitespace -./src/linkage/experiment/experiment.py:211:39: W291 trailing whitespace -./src/linkage/experiment/experiment.py:219:76: W291 trailing whitespace -./src/linkage/experiment/experiment.py:225:77: W291 trailing whitespace -./src/linkage/experiment/experiment.py:231:45: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:234:40: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:244:48: E231 missing whitespace after ':' -./src/linkage/experiment/experiment.py:245:56: E231 missing whitespace after ':' -./src/linkage/experiment/experiment.py:246:56: E231 missing whitespace after ':' +./src/linkage/experiment/experiment.py:106:50: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:111:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:118:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:119:43: W291 trailing whitespace +./src/linkage/experiment/experiment.py:132:74: W291 trailing whitespace +./src/linkage/experiment/experiment.py:134:34: W291 trailing whitespace +./src/linkage/experiment/experiment.py:136:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:144:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:150:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:156:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:157:34: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:163:49: W291 trailing whitespace +./src/linkage/experiment/experiment.py:165:42: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:173:54: W291 trailing whitespace +./src/linkage/experiment/experiment.py:174:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:179:24: W291 trailing whitespace +./src/linkage/experiment/experiment.py:183:65: W291 trailing whitespace +./src/linkage/experiment/experiment.py:187:72: E127 continuation line over-indented for visual indent +./src/linkage/experiment/experiment.py:188:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:189:48: E231 missing whitespace after ':' +./src/linkage/experiment/experiment.py:190:54: E231 missing whitespace after ':' +./src/linkage/experiment/experiment.py:193:5: E303 too many blank lines (2) +./src/linkage/experiment/experiment.py:199:63: W291 trailing whitespace +./src/linkage/experiment/experiment.py:200:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:205:24: W291 trailing whitespace +./src/linkage/experiment/experiment.py:209:65: W291 trailing whitespace +./src/linkage/experiment/experiment.py:211:78: W291 trailing whitespace +./src/linkage/experiment/experiment.py:212:39: W291 trailing whitespace +./src/linkage/experiment/experiment.py:220:76: W291 trailing whitespace +./src/linkage/experiment/experiment.py:226:77: W291 trailing whitespace +./src/linkage/experiment/experiment.py:232:45: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:235:40: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:245:48: E231 missing whitespace after ':' +./src/linkage/experiment/experiment.py:246:54: E231 missing whitespace after ':' ./src/linkage/experiment/experiment.py:247:56: E231 missing whitespace after ':' -./src/linkage/experiment/experiment.py:248:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:249:34: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:249:45: E231 missing whitespace after ',' -./src/linkage/experiment/experiment.py:260:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:276:1: W293 blank line contains whitespace -./src/linkage/experiment/experiment.py:279:43: W292 no newline at end of file -./src/linkage/experiment/point/__init__.py:1:1: W391 blank line at end of file -./src/linkage/experiment/point/experimental_point.py:1:1: F401 'numpy as np' imported but unused -./src/linkage/experiment/point/experimental_point.py:3:1: E302 expected 2 blank lines, found 1 -./src/linkage/experiment/point/experimental_point.py:6:13: W291 trailing whitespace -./src/linkage/experiment/point/experimental_point.py:8:1: W293 blank line contains whitespace -./src/linkage/experiment/point/experimental_point.py:19:1: W293 blank line contains whitespace -./src/linkage/experiment/point/experimental_point.py:40:1: W293 blank line contains whitespace -./src/linkage/experiment/point/experimental_point.py:47:1: W391 blank line at end of file -./src/linkage/experiment/point/itc_point.py:6:1: E302 expected 2 blank lines, found 1 -./src/linkage/experiment/point/itc_point.py:9:49: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:25:38: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:26:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:42:78: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:46:75: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:53:76: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:56:75: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:59:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:66:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:76:60: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:79:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:80:24: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:80:35: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:80:41: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:84:17: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:93:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:97:74: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:98:53: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:101:20: E221 multiple spaces before operator -./src/linkage/experiment/point/itc_point.py:101:51: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:102:1: W293 blank line contains whitespace -./src/linkage/experiment/point/itc_point.py:103:72: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:104:42: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:107:73: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:109:78: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:110:71: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:115:32: W291 trailing whitespace -./src/linkage/experiment/point/itc_point.py:117:71: E231 missing whitespace after ',' -./src/linkage/experiment/point/itc_point.py:119:26: W292 no newline at end of file -./src/linkage/experiment/point/spec_point.py:6:1: E302 expected 2 blank lines, found 1 -./src/linkage/experiment/point/spec_point.py:8:66: W291 trailing whitespace -./src/linkage/experiment/point/spec_point.py:9:67: W291 trailing whitespace -./src/linkage/experiment/point/spec_point.py:22:47: W291 trailing whitespace -./src/linkage/experiment/point/spec_point.py:23:1: W293 blank line contains whitespace -./src/linkage/experiment/point/spec_point.py:39:78: W291 trailing whitespace -./src/linkage/experiment/point/spec_point.py:55:1: W293 blank line contains whitespace -./src/linkage/experiment/point/spec_point.py:58:1: W293 blank line contains whitespace -./src/linkage/experiment/point/spec_point.py:59:24: E231 missing whitespace after ',' -./src/linkage/experiment/point/spec_point.py:59:30: E231 missing whitespace after ',' -./src/linkage/experiment/point/spec_point.py:61:75: W291 trailing whitespace -./src/linkage/experiment/point/spec_point.py:65:49: E231 missing whitespace after ',' -./src/linkage/experiment/point/spec_point.py:66:42: E231 missing whitespace after ',' -./src/linkage/experiment/point/spec_point.py:70:1: W391 blank line at end of file +./src/linkage/experiment/experiment.py:248:56: E231 missing whitespace after ':' +./src/linkage/experiment/experiment.py:249:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:250:34: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:250:45: E231 missing whitespace after ',' +./src/linkage/experiment/experiment.py:261:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:277:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:281:1: W293 blank line contains whitespace +./src/linkage/experiment/experiment.py:284:45: W292 no newline at end of file ./src/linkage/experiment/titrator.py:6:1: E302 expected 2 blank lines, found 1 ./src/linkage/experiment/titrator.py:9:79: W291 trailing whitespace ./src/linkage/experiment/titrator.py:16:74: W291 trailing whitespace ./src/linkage/experiment/titrator.py:18:77: W291 trailing whitespace ./src/linkage/experiment/titrator.py:19:1: W293 blank line contains whitespace ./src/linkage/experiment/titrator.py:23:40: W291 trailing whitespace -./src/linkage/experiment/titrator.py:29:42: E231 missing whitespace after ',' -./src/linkage/experiment/titrator.py:33:45: E231 missing whitespace after ',' -./src/linkage/experiment/titrator.py:40:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:45:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:56:1: E302 expected 2 blank lines, found 1 -./src/linkage/experiment/titrator.py:74:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:83:1: E302 expected 2 blank lines, found 1 -./src/linkage/experiment/titrator.py:88:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:98:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:117:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:120:1: E303 too many blank lines (3) -./src/linkage/experiment/titrator.py:127:55: W291 trailing whitespace -./src/linkage/experiment/titrator.py:128:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:135:32: W291 trailing whitespace -./src/linkage/experiment/titrator.py:140:32: W291 trailing whitespace -./src/linkage/experiment/titrator.py:145:51: W291 trailing whitespace -./src/linkage/experiment/titrator.py:147:90: W291 trailing whitespace -./src/linkage/experiment/titrator.py:148:67: W291 trailing whitespace -./src/linkage/experiment/titrator.py:149:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:160:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:162:47: E231 missing whitespace after ',' -./src/linkage/experiment/titrator.py:163:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:25:78: W291 trailing whitespace +./src/linkage/experiment/titrator.py:33:42: E231 missing whitespace after ',' +./src/linkage/experiment/titrator.py:37:45: E231 missing whitespace after ',' +./src/linkage/experiment/titrator.py:52:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:57:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:68:1: E302 expected 2 blank lines, found 1 +./src/linkage/experiment/titrator.py:85:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:94:1: E302 expected 2 blank lines, found 1 +./src/linkage/experiment/titrator.py:99:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:102:5: F841 local variable 'meas_vol_dilution' is assigned to but never used +./src/linkage/experiment/titrator.py:107:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:125:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:128:1: E303 too many blank lines (3) +./src/linkage/experiment/titrator.py:135:55: W291 trailing whitespace +./src/linkage/experiment/titrator.py:136:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:143:32: W291 trailing whitespace +./src/linkage/experiment/titrator.py:148:32: W291 trailing whitespace +./src/linkage/experiment/titrator.py:153:51: W291 trailing whitespace +./src/linkage/experiment/titrator.py:155:90: W291 trailing whitespace +./src/linkage/experiment/titrator.py:156:67: W291 trailing whitespace +./src/linkage/experiment/titrator.py:157:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:168:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:170:47: E231 missing whitespace after ',' ./src/linkage/experiment/titrator.py:171:1: W293 blank line contains whitespace -./src/linkage/experiment/titrator.py:173:5: E303 too many blank lines (2) -./src/linkage/experiment/titrator.py:185:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:178:1: W293 blank line contains whitespace +./src/linkage/experiment/titrator.py:191:1: W293 blank line contains whitespace +./src/linkage/global_model/__init__.py:1:1: F401 'linkage.global_model.global_model.GlobalModel' imported but unused +./src/linkage/global_model/__init__.py:1:58: W292 no newline at end of file +./src/linkage/global_model/global_model.py:10:1: E302 expected 2 blank lines, found 1 +./src/linkage/global_model/global_model.py:13:74: W291 trailing whitespace +./src/linkage/global_model/global_model.py:15:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:18:76: W291 trailing whitespace +./src/linkage/global_model/global_model.py:22:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:25:78: W291 trailing whitespace +./src/linkage/global_model/global_model.py:28:37: W291 trailing whitespace +./src/linkage/global_model/global_model.py:31:80: W291 trailing whitespace +./src/linkage/global_model/global_model.py:33:36: W291 trailing whitespace +./src/linkage/global_model/global_model.py:41:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:53:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:57:59: W291 trailing whitespace +./src/linkage/global_model/global_model.py:64:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:70:61: W291 trailing whitespace +./src/linkage/global_model/global_model.py:72:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:78:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:79:59: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:81:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:82:58: W291 trailing whitespace +./src/linkage/global_model/global_model.py:89:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:103:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:106:77: W291 trailing whitespace +./src/linkage/global_model/global_model.py:107:42: W291 trailing whitespace +./src/linkage/global_model/global_model.py:112:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:123:78: W291 trailing whitespace +./src/linkage/global_model/global_model.py:124:74: W291 trailing whitespace +./src/linkage/global_model/global_model.py:125:44: W291 trailing whitespace +./src/linkage/global_model/global_model.py:130:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:131:5: E303 too many blank lines (2) +./src/linkage/global_model/global_model.py:136:49: W291 trailing whitespace +./src/linkage/global_model/global_model.py:139:13: W291 trailing whitespace +./src/linkage/global_model/global_model.py:142:81: W291 trailing whitespace +./src/linkage/global_model/global_model.py:143:34: W291 trailing whitespace +./src/linkage/global_model/global_model.py:148:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:150:58: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:153:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:157:27: W291 trailing whitespace +./src/linkage/global_model/global_model.py:160:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:169:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:170:58: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:198:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:205:46: W291 trailing whitespace +./src/linkage/global_model/global_model.py:207:83: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:209:48: W291 trailing whitespace +./src/linkage/global_model/global_model.py:242:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:247:5: C901 'GlobalModel._get_enthalpy_param' is too complex (13) +./src/linkage/global_model/global_model.py:247:5: E303 too many blank lines (2) +./src/linkage/global_model/global_model.py:249:44: W291 trailing whitespace +./src/linkage/global_model/global_model.py:250:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:252:71: W291 trailing whitespace +./src/linkage/global_model/global_model.py:253:72: W291 trailing whitespace +./src/linkage/global_model/global_model.py:255:66: W291 trailing whitespace +./src/linkage/global_model/global_model.py:258:71: W291 trailing whitespace +./src/linkage/global_model/global_model.py:259:68: W291 trailing whitespace +./src/linkage/global_model/global_model.py:260:72: W291 trailing whitespace +./src/linkage/global_model/global_model.py:266:41: W291 trailing whitespace +./src/linkage/global_model/global_model.py:272:32: W291 trailing whitespace +./src/linkage/global_model/global_model.py:273:19: W291 trailing whitespace +./src/linkage/global_model/global_model.py:277:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:283:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:285:32: W291 trailing whitespace +./src/linkage/global_model/global_model.py:300:75: W291 trailing whitespace +./src/linkage/global_model/global_model.py:301:43: W291 trailing whitespace +./src/linkage/global_model/global_model.py:303:53: E127 continuation line over-indented for visual indent +./src/linkage/global_model/global_model.py:311:29: W291 trailing whitespace +./src/linkage/global_model/global_model.py:314:33: W291 trailing whitespace +./src/linkage/global_model/global_model.py:321:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:323:66: W291 trailing whitespace +./src/linkage/global_model/global_model.py:324:25: W291 trailing whitespace +./src/linkage/global_model/global_model.py:334:59: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:335:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:337:60: E221 multiple spaces before operator +./src/linkage/global_model/global_model.py:338:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:343:52: W291 trailing whitespace +./src/linkage/global_model/global_model.py:346:70: W291 trailing whitespace +./src/linkage/global_model/global_model.py:349:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:351:33: W291 trailing whitespace +./src/linkage/global_model/global_model.py:357:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:360:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:361:61: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:362:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:365:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:367:5: E303 too many blank lines (2) +./src/linkage/global_model/global_model.py:367:24: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:367:34: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:367:43: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:372:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:374:58: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:375:61: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:377:39: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:379:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:380:30: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:381:35: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:382:34: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:383:38: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:384:38: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:385:42: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:386:39: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:387:43: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:391:54: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:398:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:400:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:418:70: W291 trailing whitespace +./src/linkage/global_model/global_model.py:419:76: W291 trailing whitespace +./src/linkage/global_model/global_model.py:420:41: W291 trailing whitespace +./src/linkage/global_model/global_model.py:433:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:436:49: E127 continuation line over-indented for visual indent +./src/linkage/global_model/global_model.py:437:48: E127 continuation line over-indented for visual indent +./src/linkage/global_model/global_model.py:440:57: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:445:78: W291 trailing whitespace +./src/linkage/global_model/global_model.py:452:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:453:51: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:456:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:463:79: W291 trailing whitespace +./src/linkage/global_model/global_model.py:469:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:470:30: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:473:74: W291 trailing whitespace +./src/linkage/global_model/global_model.py:475:27: W291 trailing whitespace +./src/linkage/global_model/global_model.py:476:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:480:73: W291 trailing whitespace +./src/linkage/global_model/global_model.py:482:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:486:70: W291 trailing whitespace +./src/linkage/global_model/global_model.py:491:67: W291 trailing whitespace +./src/linkage/global_model/global_model.py:492:78: W291 trailing whitespace +./src/linkage/global_model/global_model.py:494:20: W291 trailing whitespace +./src/linkage/global_model/global_model.py:506:19: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:509:32: W291 trailing whitespace +./src/linkage/global_model/global_model.py:514:73: W291 trailing whitespace +./src/linkage/global_model/global_model.py:516:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:524:48: W291 trailing whitespace +./src/linkage/global_model/global_model.py:527:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:529:78: W291 trailing whitespace +./src/linkage/global_model/global_model.py:540:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:545:36: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:550:74: W291 trailing whitespace +./src/linkage/global_model/global_model.py:554:40: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:555:100: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:583:69: W291 trailing whitespace +./src/linkage/global_model/global_model.py:587:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:591:71: W291 trailing whitespace +./src/linkage/global_model/global_model.py:592:71: W291 trailing whitespace +./src/linkage/global_model/global_model.py:602:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:609:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:616:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:620:75: W291 trailing whitespace +./src/linkage/global_model/global_model.py:621:15: W291 trailing whitespace +./src/linkage/global_model/global_model.py:624:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:628:75: W291 trailing whitespace +./src/linkage/global_model/global_model.py:629:15: W291 trailing whitespace +./src/linkage/global_model/global_model.py:632:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:636:25: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:637:27: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:638:26: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:639:24: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:640:27: E231 missing whitespace after ':' +./src/linkage/global_model/global_model.py:649:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:652:34: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:658:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:659:36: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:672:52: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:675:52: E231 missing whitespace after ',' +./src/linkage/global_model/global_model.py:676:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:684:1: W293 blank line contains whitespace +./src/linkage/global_model/global_model.py:684:9: W292 no newline at end of file +./src/linkage/global_model/point/__init__.py:1:1: W391 blank line at end of file +./src/linkage/global_model/point/experimental_point.py:6:13: W291 trailing whitespace +./src/linkage/global_model/point/experimental_point.py:8:1: W293 blank line contains whitespace +./src/linkage/global_model/point/experimental_point.py:21:1: W293 blank line contains whitespace +./src/linkage/global_model/point/experimental_point.py:30:1: W293 blank line contains whitespace +./src/linkage/global_model/point/experimental_point.py:32:5: E303 too many blank lines (2) +./src/linkage/global_model/point/experimental_point.py:45:1: W293 blank line contains whitespace +./src/linkage/global_model/point/experimental_point.py:52:1: W391 blank line at end of file +./src/linkage/global_model/point/itc_point.py:6:1: E302 expected 2 blank lines, found 1 +./src/linkage/global_model/point/itc_point.py:9:49: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:27:38: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:28:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:44:78: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:55:76: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:58:75: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:62:23: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:64:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:74:37: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:84:60: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:91:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:92:5: E303 too many blank lines (2) +./src/linkage/global_model/point/itc_point.py:92:24: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:92:35: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:92:41: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:96:17: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:105:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:107:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:108:49: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:111:74: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:112:53: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:115:20: E221 multiple spaces before operator +./src/linkage/global_model/point/itc_point.py:115:51: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:116:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:117:74: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:118:77: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:122:73: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:124:78: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:125:71: W291 trailing whitespace +./src/linkage/global_model/point/itc_point.py:134:55: E231 missing whitespace after ',' +./src/linkage/global_model/point/itc_point.py:136:1: W293 blank line contains whitespace +./src/linkage/global_model/point/itc_point.py:137:26: W292 no newline at end of file +./src/linkage/global_model/point/spec_point.py:6:1: E302 expected 2 blank lines, found 1 +./src/linkage/global_model/point/spec_point.py:8:66: W291 trailing whitespace +./src/linkage/global_model/point/spec_point.py:9:67: W291 trailing whitespace +./src/linkage/global_model/point/spec_point.py:24:47: W291 trailing whitespace +./src/linkage/global_model/point/spec_point.py:25:1: W293 blank line contains whitespace +./src/linkage/global_model/point/spec_point.py:41:78: W291 trailing whitespace +./src/linkage/global_model/point/spec_point.py:63:1: W293 blank line contains whitespace +./src/linkage/global_model/point/spec_point.py:66:1: W293 blank line contains whitespace +./src/linkage/global_model/point/spec_point.py:67:24: E231 missing whitespace after ',' +./src/linkage/global_model/point/spec_point.py:67:30: E231 missing whitespace after ',' +./src/linkage/global_model/point/spec_point.py:69:75: W291 trailing whitespace +./src/linkage/global_model/point/spec_point.py:73:49: E231 missing whitespace after ',' +./src/linkage/global_model/point/spec_point.py:74:42: E231 missing whitespace after ',' +./src/linkage/global_model/point/spec_point.py:78:1: W391 blank line at end of file ./src/linkage/models/__init__.py:2:1: F401 'linkage.models.six_state_edta.SixStateEDTA' imported but unused ./src/linkage/models/__init__.py:3:1: F401 'linkage.models.ca_edta.CaEDTA' imported but unused ./src/linkage/models/base.py:7:1: E302 expected 2 blank lines, found 1 @@ -823,45 +982,49 @@ ./src/linkage/models/base.py:320:28: E231 missing whitespace after ',' ./src/linkage/models/base.py:320:34: E231 missing whitespace after ',' ./src/linkage/models/base.py:322:54: W291 trailing whitespace -./src/linkage/models/base.py:336:1: W293 blank line contains whitespace -./src/linkage/models/base.py:340:1: W293 blank line contains whitespace -./src/linkage/models/base.py:341:61: W291 trailing whitespace -./src/linkage/models/base.py:344:26: W291 trailing whitespace +./src/linkage/models/base.py:335:79: W291 trailing whitespace +./src/linkage/models/base.py:337:48: E231 missing whitespace after ',' +./src/linkage/models/base.py:337:65: E231 missing whitespace after ',' +./src/linkage/models/base.py:344:59: E231 missing whitespace after ',' ./src/linkage/models/base.py:345:1: W293 blank line contains whitespace -./src/linkage/models/base.py:348:1: W293 blank line contains whitespace -./src/linkage/models/base.py:349:73: W291 trailing whitespace -./src/linkage/models/base.py:350:75: W291 trailing whitespace -./src/linkage/models/base.py:352:48: E231 missing whitespace after ',' -./src/linkage/models/base.py:356:1: W293 blank line contains whitespace -./src/linkage/models/base.py:359:1: W293 blank line contains whitespace -./src/linkage/models/base.py:360:1: W293 blank line contains whitespace -./src/linkage/models/base.py:361:5: E303 too many blank lines (2) -./src/linkage/models/base.py:361:23: E231 missing whitespace after ',' -./src/linkage/models/base.py:361:35: E231 missing whitespace after ',' -./src/linkage/models/base.py:364:76: W291 trailing whitespace -./src/linkage/models/base.py:365:57: W291 trailing whitespace -./src/linkage/models/base.py:366:1: W293 blank line contains whitespace -./src/linkage/models/base.py:369:77: W291 trailing whitespace -./src/linkage/models/base.py:370:79: W291 trailing whitespace -./src/linkage/models/base.py:374:77: W291 trailing whitespace -./src/linkage/models/base.py:375:72: W291 trailing whitespace -./src/linkage/models/base.py:376:73: W291 trailing whitespace -./src/linkage/models/base.py:383:27: E231 missing whitespace after ',' -./src/linkage/models/base.py:388:70: W291 trailing whitespace -./src/linkage/models/base.py:389:76: W291 trailing whitespace -./src/linkage/models/base.py:390:55: W291 trailing whitespace -./src/linkage/models/base.py:392:1: W293 blank line contains whitespace -./src/linkage/models/base.py:396:30: E231 missing whitespace after ',' -./src/linkage/models/base.py:401:70: W291 trailing whitespace -./src/linkage/models/base.py:402:78: W291 trailing whitespace -./src/linkage/models/base.py:403:52: W291 trailing whitespace -./src/linkage/models/base.py:409:30: E231 missing whitespace after ',' -./src/linkage/models/base.py:410:1: W293 blank line contains whitespace -./src/linkage/models/base.py:414:74: W291 trailing whitespace -./src/linkage/models/base.py:416:34: W291 trailing whitespace -./src/linkage/models/base.py:423:1: W293 blank line contains whitespace -./src/linkage/models/base.py:427:1: W293 blank line contains whitespace -./src/linkage/models/base.py:434:29: W292 no newline at end of file +./src/linkage/models/base.py:349:1: W293 blank line contains whitespace +./src/linkage/models/base.py:350:61: W291 trailing whitespace +./src/linkage/models/base.py:353:26: W291 trailing whitespace +./src/linkage/models/base.py:354:1: W293 blank line contains whitespace +./src/linkage/models/base.py:357:1: W293 blank line contains whitespace +./src/linkage/models/base.py:358:73: W291 trailing whitespace +./src/linkage/models/base.py:359:75: W291 trailing whitespace +./src/linkage/models/base.py:361:48: E231 missing whitespace after ',' +./src/linkage/models/base.py:365:1: W293 blank line contains whitespace +./src/linkage/models/base.py:368:1: W293 blank line contains whitespace +./src/linkage/models/base.py:369:1: W293 blank line contains whitespace +./src/linkage/models/base.py:370:5: E303 too many blank lines (2) +./src/linkage/models/base.py:370:23: E231 missing whitespace after ',' +./src/linkage/models/base.py:370:35: E231 missing whitespace after ',' +./src/linkage/models/base.py:373:76: W291 trailing whitespace +./src/linkage/models/base.py:374:57: W291 trailing whitespace +./src/linkage/models/base.py:375:1: W293 blank line contains whitespace +./src/linkage/models/base.py:378:77: W291 trailing whitespace +./src/linkage/models/base.py:379:79: W291 trailing whitespace +./src/linkage/models/base.py:383:77: W291 trailing whitespace +./src/linkage/models/base.py:384:72: W291 trailing whitespace +./src/linkage/models/base.py:385:73: W291 trailing whitespace +./src/linkage/models/base.py:392:27: E231 missing whitespace after ',' +./src/linkage/models/base.py:397:70: W291 trailing whitespace +./src/linkage/models/base.py:398:76: W291 trailing whitespace +./src/linkage/models/base.py:399:55: W291 trailing whitespace +./src/linkage/models/base.py:401:1: W293 blank line contains whitespace +./src/linkage/models/base.py:405:30: E231 missing whitespace after ',' +./src/linkage/models/base.py:410:70: W291 trailing whitespace +./src/linkage/models/base.py:411:78: W291 trailing whitespace +./src/linkage/models/base.py:412:52: W291 trailing whitespace +./src/linkage/models/base.py:418:30: E231 missing whitespace after ',' +./src/linkage/models/base.py:419:1: W293 blank line contains whitespace +./src/linkage/models/base.py:423:74: W291 trailing whitespace +./src/linkage/models/base.py:425:34: W291 trailing whitespace +./src/linkage/models/base.py:432:1: W293 blank line contains whitespace +./src/linkage/models/base.py:436:1: W293 blank line contains whitespace +./src/linkage/models/base.py:443:29: W292 no newline at end of file ./src/linkage/models/ca_edta.py:6:1: E302 expected 2 blank lines, found 1 ./src/linkage/models/ca_edta.py:15:1: W293 blank line contains whitespace ./src/linkage/models/ca_edta.py:16:23: E231 missing whitespace after ',' @@ -876,6 +1039,59 @@ ./src/linkage/models/ca_edta.py:39:33: E231 missing whitespace after ',' ./src/linkage/models/ca_edta.py:47:30: E231 missing whitespace after ',' ./src/linkage/models/ca_edta.py:48:1: W293 blank line contains whitespace +./src/linkage/models/head_to_head.py:6:1: E302 expected 2 blank lines, found 1 +./src/linkage/models/head_to_head.py:17:1: W293 blank line contains whitespace +./src/linkage/models/head_to_head.py:18:23: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:18:35: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:26:32: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:26:34: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:26:37: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:26:39: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:26:42: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:27:1: W293 blank line contains whitespace +./src/linkage/models/head_to_head.py:32:31: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:32:33: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:32:35: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:32:37: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:33:1: W293 blank line contains whitespace +./src/linkage/models/head_to_head.py:45:32: E225 missing whitespace around operator +./src/linkage/models/head_to_head.py:49:52: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:50:1: W293 blank line contains whitespace +./src/linkage/models/head_to_head.py:57:27: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:57:30: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:57:32: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:57:35: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:57:38: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:61:30: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:65:30: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:65:35: E231 missing whitespace after ',' +./src/linkage/models/head_to_head.py:66:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:8:1: E302 expected 2 blank lines, found 1 +./src/linkage/models/receptor_competitor.py:20:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:22:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:23:23: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:23:35: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:26:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:29:32: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:29:35: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:39:32: E225 missing whitespace around operator +./src/linkage/models/receptor_competitor.py:43:50: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:44:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:53:27: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:29: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:31: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:33: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:36: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:40: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:53:44: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:57:29: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:57:34: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:61:30: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:61:35: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:61:40: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:62:1: W293 blank line contains whitespace +./src/linkage/models/receptor_competitor.py:65:50: E231 missing whitespace after ',' +./src/linkage/models/receptor_competitor.py:65:56: E231 missing whitespace after ',' ./src/linkage/models/six_state_edta.py:25:25: E231 missing whitespace after ',' ./src/linkage/models/six_state_edta.py:25:28: E231 missing whitespace after ',' ./src/linkage/models/six_state_edta.py:25:31: E231 missing whitespace after ',' @@ -932,127 +1148,6 @@ ./src/linkage/models/six_state_edta.py:114:35: E231 missing whitespace after ',' ./src/linkage/models/six_state_edta.py:115:1: W293 blank line contains whitespace ./src/linkage/models/six_state_edta.py:119:1: W391 blank line at end of file -./src/linkage/organizer/__init__.py:1:1: F401 'linkage.organizer.global_model.GlobalModel' imported but unused -./src/linkage/organizer/__init__.py:1:55: W292 no newline at end of file -./src/linkage/organizer/global_model.py:10:1: E302 expected 2 blank lines, found 1 -./src/linkage/organizer/global_model.py:19:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:45:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:57:61: W291 trailing whitespace -./src/linkage/organizer/global_model.py:59:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:65:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:66:59: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:68:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:69:58: W291 trailing whitespace -./src/linkage/organizer/global_model.py:76:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:82:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:90:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:95:77: W291 trailing whitespace -./src/linkage/organizer/global_model.py:97:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:107:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:108:47: W291 trailing whitespace -./src/linkage/organizer/global_model.py:123:41: W291 trailing whitespace -./src/linkage/organizer/global_model.py:130:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:133:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:135:77: W291 trailing whitespace -./src/linkage/organizer/global_model.py:136:78: W291 trailing whitespace -./src/linkage/organizer/global_model.py:138:72: W291 trailing whitespace -./src/linkage/organizer/global_model.py:141:77: W291 trailing whitespace -./src/linkage/organizer/global_model.py:142:74: W291 trailing whitespace -./src/linkage/organizer/global_model.py:143:78: W291 trailing whitespace -./src/linkage/organizer/global_model.py:146:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:162:79: W291 trailing whitespace -./src/linkage/organizer/global_model.py:163:47: W291 trailing whitespace -./src/linkage/organizer/global_model.py:178:68: E221 multiple spaces before operator -./src/linkage/organizer/global_model.py:179:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:181:5: E303 too many blank lines (2) -./src/linkage/organizer/global_model.py:183:69: W291 trailing whitespace -./src/linkage/organizer/global_model.py:186:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:192:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:195:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:196:61: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:197:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:200:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:203:79: W291 trailing whitespace -./src/linkage/organizer/global_model.py:204:75: W291 trailing whitespace -./src/linkage/organizer/global_model.py:206:73: W291 trailing whitespace -./src/linkage/organizer/global_model.py:207:78: W291 trailing whitespace -./src/linkage/organizer/global_model.py:208:52: W291 trailing whitespace -./src/linkage/organizer/global_model.py:211:81: W291 trailing whitespace -./src/linkage/organizer/global_model.py:212:34: W291 trailing whitespace -./src/linkage/organizer/global_model.py:216:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:218:58: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:221:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:225:76: W291 trailing whitespace -./src/linkage/organizer/global_model.py:226:19: W291 trailing whitespace -./src/linkage/organizer/global_model.py:229:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:231:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:240:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:245:5: E303 too many blank lines (2) -./src/linkage/organizer/global_model.py:245:24: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:245:34: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:245:43: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:250:71: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:251:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:254:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:266:48: E127 continuation line over-indented for visual indent -./src/linkage/organizer/global_model.py:268:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:273:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:307:5: E303 too many blank lines (2) -./src/linkage/organizer/global_model.py:328:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:332:14: W291 trailing whitespace -./src/linkage/organizer/global_model.py:335:49: E127 continuation line over-indented for visual indent -./src/linkage/organizer/global_model.py:336:48: E127 continuation line over-indented for visual indent -./src/linkage/organizer/global_model.py:339:57: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:343:78: W291 trailing whitespace -./src/linkage/organizer/global_model.py:350:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:351:51: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:354:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:365:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:372:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:377:48: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:378:59: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:379:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:380:30: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:382:75: W291 trailing whitespace -./src/linkage/organizer/global_model.py:383:73: W291 trailing whitespace -./src/linkage/organizer/global_model.py:384:68: W291 trailing whitespace -./src/linkage/organizer/global_model.py:386:71: W291 trailing whitespace -./src/linkage/organizer/global_model.py:388:46: W291 trailing whitespace -./src/linkage/organizer/global_model.py:400:19: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:403:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:406:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:418:78: W291 trailing whitespace -./src/linkage/organizer/global_model.py:420:59: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:423:56: W291 trailing whitespace -./src/linkage/organizer/global_model.py:424:53: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:427:40: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:439:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:448:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:475:71: W291 trailing whitespace -./src/linkage/organizer/global_model.py:479:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:483:71: W291 trailing whitespace -./src/linkage/organizer/global_model.py:484:67: W291 trailing whitespace -./src/linkage/organizer/global_model.py:494:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:501:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:508:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:512:75: W291 trailing whitespace -./src/linkage/organizer/global_model.py:513:15: W291 trailing whitespace -./src/linkage/organizer/global_model.py:516:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:520:75: W291 trailing whitespace -./src/linkage/organizer/global_model.py:521:15: W291 trailing whitespace -./src/linkage/organizer/global_model.py:524:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:528:25: E231 missing whitespace after ':' -./src/linkage/organizer/global_model.py:529:27: E231 missing whitespace after ':' -./src/linkage/organizer/global_model.py:530:26: E231 missing whitespace after ':' -./src/linkage/organizer/global_model.py:539:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:542:34: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:548:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:549:36: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:559:52: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:562:52: E231 missing whitespace after ',' -./src/linkage/organizer/global_model.py:563:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:570:1: W293 blank line contains whitespace -./src/linkage/organizer/global_model.py:570:9: W292 no newline at end of file ./tests/conftest.py:11:1: E302 expected 2 blank lines, found 1 ./tests/conftest.py:42:63: E231 missing whitespace after ',' ./tests/conftest.py:56:49: E231 missing whitespace after ',' @@ -1090,9 +1185,9 @@ ./tests/conftest.py:127:57: E231 missing whitespace after ',' ./tests/conftest.py:128:37: E231 missing whitespace after ',' ./tests/conftest.py:130:41: E231 missing whitespace after ':' -./tests/conftest.py:131:35: E231 missing whitespace after ':' -./tests/conftest.py:131:54: E231 missing whitespace after ',' -./tests/conftest.py:131:56: E231 missing whitespace after ',' +./tests/conftest.py:131:39: E231 missing whitespace after ':' +./tests/conftest.py:131:58: E231 missing whitespace after ',' +./tests/conftest.py:131:60: E231 missing whitespace after ',' ./tests/conftest.py:134:5: E303 too many blank lines (2) ./tests/conftest.py:136:37: E128 continuation line under-indented for visual indent ./tests/conftest.py:136:56: E231 missing whitespace after ':' @@ -1114,9 +1209,9 @@ ./tests/data/simulated_itc/generate_itc_data.py:16:21: E231 missing whitespace after ',' ./tests/data/simulated_itc/generate_itc_data.py:19:14: W291 trailing whitespace ./tests/data/simulated_itc/generate_itc_data.py:20:41: E231 missing whitespace after ':' -./tests/data/simulated_itc/generate_itc_data.py:21:36: E231 missing whitespace after ':' -./tests/data/simulated_itc/generate_itc_data.py:21:55: E231 missing whitespace after ',' -./tests/data/simulated_itc/generate_itc_data.py:21:57: E231 missing whitespace after ',' +./tests/data/simulated_itc/generate_itc_data.py:21:40: E231 missing whitespace after ':' +./tests/data/simulated_itc/generate_itc_data.py:21:59: E231 missing whitespace after ',' +./tests/data/simulated_itc/generate_itc_data.py:21:61: E231 missing whitespace after ',' ./tests/data/simulated_itc/generate_itc_data.py:22:1: W293 blank line contains whitespace ./tests/data/simulated_itc/generate_itc_data.py:23:74: W291 trailing whitespace ./tests/data/simulated_itc/generate_itc_data.py:27:61: E231 missing whitespace after ':' @@ -1156,94 +1251,6 @@ ./tests/data/simulated_itc/generate_itc_data.py:87:48: E231 missing whitespace after ',' ./tests/data/simulated_itc/generate_itc_data.py:89:1: E305 expected 2 blank lines after class or function definition, found 1 ./tests/data/simulated_itc/generate_itc_data.py:89:23: W292 no newline at end of file -./tests/linkage/experiment/point/test_experimental_point.py:6:1: E302 expected 2 blank lines, found 1 -./tests/linkage/experiment/point/test_experimental_point.py:21:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_experimental_point.py:29:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:6:1: E302 expected 2 blank lines, found 1 -./tests/linkage/experiment/point/test_itc_point.py:13:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:13:34: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:14:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:14:33: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:15:38: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:15:41: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:19:26: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:20:21: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:21:21: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:24:26: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:37:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:43:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:50:76: W291 trailing whitespace -./tests/linkage/experiment/point/test_itc_point.py:51:15: W291 trailing whitespace -./tests/linkage/experiment/point/test_itc_point.py:59:1: E302 expected 2 blank lines, found 1 -./tests/linkage/experiment/point/test_itc_point.py:67:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:67:33: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:70:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:70:33: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:73:34: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:73:37: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:76:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:77:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:80:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:81:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:91:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:94:39: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:94:44: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:94:50: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:94:56: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:94:63: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:95:39: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:95:45: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:95:50: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:95:56: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:95:63: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:96:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:98:5: E303 too many blank lines (2) -./tests/linkage/experiment/point/test_itc_point.py:114:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:118:26: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:118:45: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:119:26: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:119:45: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:122:39: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_itc_point.py:125:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_itc_point.py:129:1: W391 blank line at end of file -./tests/linkage/experiment/point/test_spec_point.py:6:1: E302 expected 2 blank lines, found 1 -./tests/linkage/experiment/point/test_spec_point.py:12:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:12:34: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:13:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:13:33: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:14:35: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:14:38: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:15:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:16:27: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:28:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:40:1: E302 expected 2 blank lines, found 1 -./tests/linkage/experiment/point/test_spec_point.py:43:5: E303 too many blank lines (2) -./tests/linkage/experiment/point/test_spec_point.py:46:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:46:34: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:47:30: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:47:33: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:48:35: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:48:38: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:49:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:51:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:52:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:55:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:56:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:59:27: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:73:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:75:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:77:5: E303 too many blank lines (2) -./tests/linkage/experiment/point/test_spec_point.py:85:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:87:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:89:5: E303 too many blank lines (2) -./tests/linkage/experiment/point/test_spec_point.py:90:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:91:18: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:93:27: E231 missing whitespace after ',' -./tests/linkage/experiment/point/test_spec_point.py:105:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:107:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:109:5: E303 too many blank lines (2) -./tests/linkage/experiment/point/test_spec_point.py:117:1: W293 blank line contains whitespace -./tests/linkage/experiment/point/test_spec_point.py:118:44: W292 no newline at end of file ./tests/linkage/experiment/test_experiment.py:13:1: E302 expected 2 blank lines, found 1 ./tests/linkage/experiment/test_experiment.py:18:18: E231 missing whitespace after ':' ./tests/linkage/experiment/test_experiment.py:18:21: E231 missing whitespace after ',' @@ -1330,9 +1337,9 @@ ./tests/linkage/experiment/test_experiment.py:118:48: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:118:61: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:118:70: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:118:90: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:118:94: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:118:74: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:120:43: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:130:52: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:131:50: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:131:55: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:131:59: E231 missing whitespace after ',' @@ -1345,127 +1352,140 @@ ./tests/linkage/experiment/test_experiment.py:147:21: E128 continuation line under-indented for visual indent ./tests/linkage/experiment/test_experiment.py:148:21: E128 continuation line under-indented for visual indent ./tests/linkage/experiment/test_experiment.py:149:21: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:151:1: E302 expected 2 blank lines, found 1 +./tests/linkage/experiment/test_experiment.py:150:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:152:24: W291 trailing whitespace ./tests/linkage/experiment/test_experiment.py:153:42: E231 missing whitespace after ':' ./tests/linkage/experiment/test_experiment.py:153:45: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:153:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:154:36: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:154:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:154:41: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:155:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:155:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:155:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:156:25: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:157:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:168:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:177:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:181:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:186:52: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:186:57: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:186:61: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:192:52: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:192:57: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:192:61: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:196:17: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:197:17: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:198:17: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:199:17: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:200:17: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:201:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:202:76: W291 trailing whitespace -./tests/linkage/experiment/test_experiment.py:204:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:205:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:210:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:212:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:212:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:212:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:213:36: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:213:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:213:46: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:214:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:214:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:214:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:215:25: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:216:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:230:33: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:230:38: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:235:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:235:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:235:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:236:36: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:236:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:236:41: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:237:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:237:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:237:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:238:25: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:239:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:250:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:256:64: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:258:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:269:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:270:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:271:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:272:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:276:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:277:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:278:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:279:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:285:52: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:285:57: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:285:61: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:288:5: E303 too many blank lines (2) -./tests/linkage/experiment/test_experiment.py:298:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:299:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:300:41: E128 continuation line under-indented for visual indent -./tests/linkage/experiment/test_experiment.py:301:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:307:64: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:318:67: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:320:64: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:320:76: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:323:5: E303 too many blank lines (2) -./tests/linkage/experiment/test_experiment.py:339:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:339:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:339:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:340:36: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:340:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:340:41: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:341:42: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:341:47: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:341:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:342:25: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:343:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:348:77: W291 trailing whitespace -./tests/linkage/experiment/test_experiment.py:349:74: W291 trailing whitespace -./tests/linkage/experiment/test_experiment.py:356:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:359:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:363:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:367:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:154:25: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:155:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:155:31: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:155:35: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:173:52: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:174:50: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:174:55: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:174:59: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:179:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:179:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:179:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:180:36: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:180:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:180:41: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:181:40: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:181:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:181:49: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:182:25: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:183:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:194:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:196:65: E127 continuation line over-indented for visual indent +./tests/linkage/experiment/test_experiment.py:203:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:207:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:212:50: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:212:55: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:212:59: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:214:65: E127 continuation line over-indented for visual indent +./tests/linkage/experiment/test_experiment.py:218:50: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:218:55: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:218:59: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:222:17: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:223:17: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:224:17: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:225:17: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:226:17: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:227:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:228:76: W291 trailing whitespace +./tests/linkage/experiment/test_experiment.py:230:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:231:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:235:69: E127 continuation line over-indented for visual indent +./tests/linkage/experiment/test_experiment.py:236:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:238:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:238:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:238:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:239:36: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:239:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:239:46: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:240:40: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:240:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:240:49: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:241:25: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:242:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:256:33: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:256:38: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:261:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:261:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:261:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:262:36: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:262:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:262:41: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:263:40: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:263:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:263:49: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:264:25: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:265:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:276:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:282:64: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:284:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:295:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:296:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:297:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:298:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:302:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:303:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:304:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:305:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:311:50: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:311:55: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:311:59: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:314:5: E303 too many blank lines (2) +./tests/linkage/experiment/test_experiment.py:324:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:325:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:326:41: E128 continuation line under-indented for visual indent +./tests/linkage/experiment/test_experiment.py:327:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:333:64: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:344:67: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:346:64: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:346:76: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:349:5: E303 too many blank lines (2) +./tests/linkage/experiment/test_experiment.py:365:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:365:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:365:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:366:36: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:366:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:366:41: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:367:40: E231 missing whitespace after ':' ./tests/linkage/experiment/test_experiment.py:367:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:367:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:367:49: E231 missing whitespace after ',' ./tests/linkage/experiment/test_experiment.py:368:25: E231 missing whitespace after ':' ./tests/linkage/experiment/test_experiment.py:369:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_experiment.py:380:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:383:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:383:48: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:383:68: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:383:72: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:383:76: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:384:54: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:386:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:386:69: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:386:71: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:39: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:48: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:68: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:72: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:76: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:388:89: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:389:48: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:389:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:389:53: E231 missing whitespace after ',' -./tests/linkage/experiment/test_experiment.py:391:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_experiment.py:391:5: W292 no newline at end of file +./tests/linkage/experiment/test_experiment.py:374:77: W291 trailing whitespace +./tests/linkage/experiment/test_experiment.py:375:74: W291 trailing whitespace +./tests/linkage/experiment/test_experiment.py:382:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:385:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:389:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:393:42: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:393:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:393:47: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:394:25: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:395:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_experiment.py:406:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:409:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:409:48: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:409:52: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:409:56: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:410:54: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:412:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:412:69: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:412:71: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:414:39: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:414:48: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:414:52: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:414:56: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:414:69: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:415:48: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:415:51: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:415:53: E231 missing whitespace after ',' +./tests/linkage/experiment/test_experiment.py:417:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_experiment.py:417:5: W292 no newline at end of file ./tests/linkage/experiment/test_titrator.py:12:1: E302 expected 2 blank lines, found 1 ./tests/linkage/experiment/test_titrator.py:13:1: W293 blank line contains whitespace ./tests/linkage/experiment/test_titrator.py:14:35: E231 missing whitespace after ':' @@ -1487,8 +1507,8 @@ ./tests/linkage/experiment/test_titrator.py:29:31: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:31:46: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:36:16: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:36:18: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:36:22: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:36:19: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:36:23: E231 missing whitespace after ':' ./tests/linkage/experiment/test_titrator.py:37:19: E231 missing whitespace after ':' ./tests/linkage/experiment/test_titrator.py:37:22: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:37:26: E231 missing whitespace after ':' @@ -1496,29 +1516,27 @@ ./tests/linkage/experiment/test_titrator.py:42:34: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:42:39: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:42:43: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:55:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:59:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:63:16: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:63:18: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:63:22: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:63:24: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:63:28: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:64:19: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:64:22: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:64:26: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:64:28: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:64:32: E231 missing whitespace after ':' -./tests/linkage/experiment/test_titrator.py:65:32: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:83:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:43:31: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:56:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:60:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:64:16: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:64:18: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:64:22: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:64:24: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:64:28: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:65:19: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:65:22: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:65:26: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:65:28: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:65:32: E231 missing whitespace after ':' +./tests/linkage/experiment/test_titrator.py:66:32: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:84:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:85:5: E303 too many blank lines (2) -./tests/linkage/experiment/test_titrator.py:85:43: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:86:40: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:86:45: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:86:49: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:87:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:87:54: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:87:56: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:85:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:86:5: E303 too many blank lines (2) +./tests/linkage/experiment/test_titrator.py:86:43: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:87:40: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:87:45: E231 missing whitespace after ',' +./tests/linkage/experiment/test_titrator.py:87:49: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:100:1: W293 blank line contains whitespace ./tests/linkage/experiment/test_titrator.py:104:16: E231 missing whitespace after ':' ./tests/linkage/experiment/test_titrator.py:104:18: E231 missing whitespace after ',' @@ -1536,14 +1554,243 @@ ./tests/linkage/experiment/test_titrator.py:126:40: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:126:45: E231 missing whitespace after ',' ./tests/linkage/experiment/test_titrator.py:126:49: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:127:51: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:127:54: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:127:62: E231 missing whitespace after ',' -./tests/linkage/experiment/test_titrator.py:128:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:130:5: E303 too many blank lines (2) -./tests/linkage/experiment/test_titrator.py:134:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:139:1: W293 blank line contains whitespace -./tests/linkage/experiment/test_titrator.py:145:1: W391 blank line at end of file +./tests/linkage/experiment/test_titrator.py:127:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:129:5: E303 too many blank lines (2) +./tests/linkage/experiment/test_titrator.py:133:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:138:1: W293 blank line contains whitespace +./tests/linkage/experiment/test_titrator.py:144:1: W391 blank line at end of file +./tests/linkage/global_model/point/test_experimental_point.py:6:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/point/test_experimental_point.py:25:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_experimental_point.py:33:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_experimental_point.py:37:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_experimental_point.py:37:5: W292 no newline at end of file +./tests/linkage/global_model/point/test_itc_point.py:6:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/point/test_itc_point.py:13:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:13:34: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:14:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:14:33: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:15:38: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:15:41: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:21:26: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:23:21: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:24:21: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:27:26: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:29:38: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:29:44: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:29:51: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:44:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:61:43: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:63:76: W291 trailing whitespace +./tests/linkage/global_model/point/test_itc_point.py:64:15: W291 trailing whitespace +./tests/linkage/global_model/point/test_itc_point.py:70:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/point/test_itc_point.py:78:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:78:33: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:81:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:81:33: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:84:34: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:84:37: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:87:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:88:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:91:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:92:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:102:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:105:39: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:105:44: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:105:50: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:105:56: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:105:63: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:106:39: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:106:45: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:106:50: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:106:56: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:106:63: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:107:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:108:39: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:108:45: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:108:51: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:111:5: E303 too many blank lines (2) +./tests/linkage/global_model/point/test_itc_point.py:130:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:137:16: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:138:29: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:138:48: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:140:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:142:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:146:39: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_itc_point.py:149:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_itc_point.py:153:1: W391 blank line at end of file +./tests/linkage/global_model/point/test_spec_point.py:6:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/point/test_spec_point.py:12:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:12:34: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:13:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:13:33: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:14:35: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:14:38: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:17:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:18:27: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:32:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:47:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/point/test_spec_point.py:52:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:52:34: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:53:30: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:53:33: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:54:35: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:54:38: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:55:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:57:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:58:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:61:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:62:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:68:27: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:84:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:86:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:88:5: E303 too many blank lines (2) +./tests/linkage/global_model/point/test_spec_point.py:98:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:100:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:102:5: E303 too many blank lines (2) +./tests/linkage/global_model/point/test_spec_point.py:103:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:104:18: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:106:27: E231 missing whitespace after ',' +./tests/linkage/global_model/point/test_spec_point.py:120:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:122:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:124:5: E303 too many blank lines (2) +./tests/linkage/global_model/point/test_spec_point.py:134:1: W293 blank line contains whitespace +./tests/linkage/global_model/point/test_spec_point.py:135:44: W292 no newline at end of file +./tests/linkage/global_model/test_global_model.py:7:1: F401 'linkage.global_model.point.spec_point.SpecPoint' imported but unused +./tests/linkage/global_model/test_global_model.py:8:1: F401 'linkage.global_model.point.itc_point.ITCPoint' imported but unused +./tests/linkage/global_model/test_global_model.py:10:1: F401 'linkage.experiment.experiment.Experiment' imported but unused +./tests/linkage/global_model/test_global_model.py:16:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:25:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:36:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:38:35: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:43:51: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:49:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:53:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:62:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:63:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:70:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:71:68: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:72:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:72:48: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:74:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:81:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:89:59: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:89:62: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:90:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:91:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:92:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:99:38: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:100:38: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:101:44: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:102:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:103:45: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:104:49: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:105:49: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:107:77: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:112:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:117:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:123:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:130:24: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:148:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:149:5: E303 too many blank lines (2) +./tests/linkage/global_model/test_global_model.py:158:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:159:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:160:39: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:161:38: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:162:40: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:163:44: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:164:44: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:172:5: E303 too many blank lines (2) +./tests/linkage/global_model/test_global_model.py:177:39: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:177:48: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:177:53: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:178:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:181:39: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:181:48: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:181:53: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:181:58: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:182:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:185:46: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:195:22: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:196:22: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:197:22: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:198:22: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:199:22: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:201:23: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:201:30: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:201:37: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:201:44: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:201:51: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:205:35: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:206:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:208:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:208:35: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:208:37: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:208:39: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:208:41: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:213:38: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:213:48: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:216:27: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:38: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:41: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:45: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:47: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:218:49: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:221:47: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:221:54: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:221:60: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:228:26: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:229:26: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:230:26: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:231:26: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:232:26: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:234:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:247:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:256:59: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:258:51: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:261:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:310:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:313:59: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:314:55: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:317:46: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:317:50: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:318:32: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:319:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:323:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:329:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:332:59: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:333:45: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:336:35: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:336:39: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:337:32: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:338:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:348:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:351:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:358:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:369:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:372:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:379:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:390:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:401:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:404:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:411:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:422:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:423:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:433:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:434:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:436:1: E302 expected 2 blank lines, found 1 +./tests/linkage/global_model/test_global_model.py:438:79: W291 trailing whitespace +./tests/linkage/global_model/test_global_model.py:446:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:448:31: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:450:37: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:455:43: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:456:42: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:456:46: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:461:1: W293 blank line contains whitespace +./tests/linkage/global_model/test_global_model.py:462:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:463:33: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:464:44: E231 missing whitespace after ',' +./tests/linkage/global_model/test_global_model.py:465:44: E231 missing whitespace after ',' ./tests/linkage/models/test_base.py:15:1: E302 expected 2 blank lines, found 1 ./tests/linkage/models/test_base.py:18:33: E231 missing whitespace after ',' ./tests/linkage/models/test_base.py:18:38: E231 missing whitespace after ',' @@ -1971,115 +2218,28 @@ ./tests/linkage/models/test_ca_edta.py:81:48: E231 missing whitespace after ',' ./tests/linkage/models/test_ca_edta.py:81:52: E231 missing whitespace after ',' ./tests/linkage/models/test_ca_edta.py:81:59: W292 no newline at end of file -./tests/linkage/organizer/test_global_model.py:10:1: F401 'linkage.experiment.experiment.Experiment' imported but unused -./tests/linkage/organizer/test_global_model.py:13:1: F401 'pandas as pd' imported but unused -./tests/linkage/organizer/test_global_model.py:16:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:25:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:36:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:38:35: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:43:51: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:46:5: E303 too many blank lines (2) -./tests/linkage/organizer/test_global_model.py:50:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:54:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:58:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:59:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:66:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:69:39: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:69:48: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:69:68: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:69:73: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:70:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:73:39: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:73:48: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:73:68: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:73:73: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:73:78: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:74:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:77:46: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:79:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:91:46: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:100:46: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:102:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:112:23: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:112:30: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:112:37: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:112:44: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:112:51: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:113:34: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:113:52: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:115:35: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:116:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:118:33: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:118:35: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:118:37: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:118:39: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:118:41: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:123:38: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:123:48: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:126:27: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:38: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:41: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:43: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:45: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:47: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:128:49: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:140:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:153:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:161:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:163:66: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:163:74: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:164:66: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:164:74: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:165:65: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:165:73: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:167:78: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:170:73: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:171:63: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:171:66: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:176:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:177:44: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:178:64: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:179:65: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:191:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:193:19: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:201:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:202:44: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:203:64: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:204:65: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:206:1: E302 expected 2 blank lines, found 1 -./tests/linkage/organizer/test_global_model.py:215:59: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:217:51: W291 trailing whitespace -./tests/linkage/organizer/test_global_model.py:220:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:248:39: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:249:38: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:251:46: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:251:56: E231 missing whitespace after ',' -./tests/linkage/organizer/test_global_model.py:263:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:267:1: W293 blank line contains whitespace -./tests/linkage/organizer/test_global_model.py:272:22: E128 continuation line under-indented for visual indent -./tests/linkage/organizer/test_global_model.py:272:47: W292 no newline at end of file -2 C901 '_parse_linkage_docstring' is too complex (14) +4 C901 'GlobalModel._get_enthalpy_param' is too complex (13) 4 E114 indentation is not a multiple of 4 (comment) 1 E116 unexpected indentation (comment) 15 E122 continuation line missing indentation or outdented -8 E127 continuation line over-indented for visual indent -33 E128 continuation line under-indented for visual indent +13 E127 continuation line over-indented for visual indent +32 E128 continuation line under-indented for visual indent 4 E221 multiple spaces before operator -2 E225 missing whitespace around operator -1049 E231 missing whitespace after ',' +6 E225 missing whitespace around operator +1170 E231 missing whitespace after ',' 1 E261 at least two spaces before inline comment 1 E266 too many leading '#' for block comment 56 E302 expected 2 blank lines, found 1 -39 E303 too many blank lines (2) +37 E303 too many blank lines (2) 1 E305 expected 2 blank lines after class or function definition, found 1 6 E714 test for object identity should be 'is not' 2 E722 do not use bare 'except' 2 E741 ambiguous variable name 'I' -17 F401 'linkage.experiment.Experiment' imported but unused +15 F401 'linkage.experiment.Experiment' imported but unused 1 F541 f-string is missing placeholders -2 F841 local variable 'args' is assigned to but never used -332 W291 trailing whitespace -21 W292 no newline at end of file -448 W293 blank line contains whitespace -13 W391 blank line at end of file -2060 +3 F841 local variable 'meas_vol_dilution' is assigned to but never used +372 W291 trailing whitespace +18 W292 no newline at end of file +444 W293 blank line contains whitespace +12 W391 blank line at end of file +2220 diff --git a/reports/junit/junit.xml b/reports/junit/junit.xml index ed9889a..39c4e2e 100644 --- a/reports/junit/junit.xml +++ b/reports/junit/junit.xml @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/src/linkage/__version__.py b/src/linkage/__version__.py index 7341562..dfd69f9 100644 --- a/src/linkage/__version__.py +++ b/src/linkage/__version__.py @@ -1,3 +1,3 @@ -VERSION = (0, 1, 0) +VERSION = (0, 2, 0) __version__ = '.'.join(map(str, VERSION)) diff --git a/src/linkage/experiment/experiment.py b/src/linkage/experiment/experiment.py index d884bcf..5244058 100644 --- a/src/linkage/experiment/experiment.py +++ b/src/linkage/experiment/experiment.py @@ -135,11 +135,11 @@ def _define_generic_observable(self, """ if obs_column not in self._expt_data.columns: - err = "column_name should be one of the columns in the experimental data\n" + err = f"obs_column '{obs_column}' should be one of the columns in the experimental data\n" raise ValueError(err) if obs_column == "injection": - err = "column_name cannot be injection\n" + err = "obs_column cannot be 'injection'\n" raise ValueError(err) # Deal with uncertainty diff --git a/src/linkage/global_model/global_model.py b/src/linkage/global_model/global_model.py index d409f8c..10c77c6 100644 --- a/src/linkage/global_model/global_model.py +++ b/src/linkage/global_model/global_model.py @@ -659,7 +659,7 @@ def as_df(self): elif issubclass(type(p),ITCPoint): out["expt_type"].append("itc") - out["expt_obs"].append("heat") + out["expt_obs"].append("obs_heat") else: err = "point class not recognized\n" diff --git a/tests/conftest.py b/tests/conftest.py index 9c84224..f5098d7 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -102,14 +102,14 @@ def simulated_itc(): cell_contents={}, syringe_contents={"ET":5e-3}, cell_volume=280) - blank.define_itc_observable(obs_column="heat", + blank.define_itc_observable(obs_column="obs_heat", obs_std=0.003) expt = linkage.Experiment(expt_data=files["binding_expt.csv"], cell_contents={"CT":0.5e-3}, syringe_contents={"ET":5e-3}, cell_volume=280) - expt.define_itc_observable(obs_column="heat", + expt.define_itc_observable(obs_column="obs_heat", obs_std=0.003) guesses = np.array([7,-11900,0,-50]) @@ -128,7 +128,7 @@ def fake_spec_and_itc_data(): expt_data.loc[expt_data.index[0],"injection"] = 0.0 itc_data = pd.DataFrame({"injection":25*np.ones(50), - "heat":np.random.normal(0,1,50)}) + "obs_heat":np.random.normal(0,1,50)}) # Load spec data @@ -154,7 +154,7 @@ def fake_spec_and_itc_data(): syringe_contents={"ET":1e-3}, conc_to_float=None, cell_volume=1800) - f.define_itc_observable(obs_column="heat", + f.define_itc_observable(obs_column="obs_heat", obs_std=0.1) expt_list = [e,f] diff --git a/tests/data/simulated_itc/binding_expt.csv b/tests/data/simulated_itc/binding_expt.csv index 59189f0..eef7cb2 100644 --- a/tests/data/simulated_itc/binding_expt.csv +++ b/tests/data/simulated_itc/binding_expt.csv @@ -1,4 +1,4 @@ -injection,heat +injection,obs_heat 0.0, 2.0,-41.26981040346301 2.0,-39.568130738688254 diff --git a/tests/data/simulated_itc/blank_expt.csv b/tests/data/simulated_itc/blank_expt.csv index e50fe65..b61ea27 100644 --- a/tests/data/simulated_itc/blank_expt.csv +++ b/tests/data/simulated_itc/blank_expt.csv @@ -1,4 +1,4 @@ -injection,heat +injection,obs_heat 0.0, 2.0,0.0039806914860178325 2.0,0.0035288209569689774 diff --git a/tests/data/simulated_itc/generate_itc_data.py b/tests/data/simulated_itc/generate_itc_data.py index 56f5e50..82f236f 100644 --- a/tests/data/simulated_itc/generate_itc_data.py +++ b/tests/data/simulated_itc/generate_itc_data.py @@ -18,7 +18,7 @@ def create_fake_itc_data(): # Create fake data that has the number of injections we want, but no sane # values. itc_data = pd.DataFrame({"injection":2*np.ones(25), - "heat":np.random.normal(0,1,25)}) + "obs_heat":np.random.normal(0,1,25)}) # Create an experiment from the fake data where we titrate ET into an # empty cell @@ -27,7 +27,7 @@ def create_fake_itc_data(): syringe_contents={"ET":5e-3}, conc_to_float=None, cell_volume=280) - a.define_itc_observable(obs_column="heat", + a.define_itc_observable(obs_column="obs_heat", obs_std=0.1) @@ -38,7 +38,7 @@ def create_fake_itc_data(): syringe_contents={"ET":5e-3}, conc_to_float=None, cell_volume=280) - b.define_itc_observable(obs_column="heat", + b.define_itc_observable(obs_column="obs_heat", obs_std=0.1) # Create a linkage model using the CaEDTA binding model and these two @@ -80,7 +80,7 @@ def create_fake_itc_data(): out = {} out["injection"] = np.array(inj) - out["heat"] = np.array(heat) + out["obs_heat"] = np.array(heat) out_df = pd.DataFrame(out) diff --git a/tests/data/simulated_itc/simulated_itc.pdf b/tests/data/simulated_itc/simulated_itc.pdf index 27ca361bd022905c879da75273b98adcda2b791f..4ba6a7ec586b872cb14c25e4faacae8b136137c2 100644 GIT binary patch delta 19 acmX?~b3SK-kP(}qk%6V5>1GKda~1$ds0G^q delta 19 acmX?~b3SK-kP(}KrHQ4n@n#7la~1$e2?gZ< diff --git a/tests/linkage/experiment/test_experiment.py b/tests/linkage/experiment/test_experiment.py index 2d6cb9f..b337175 100644 --- a/tests/linkage/experiment/test_experiment.py +++ b/tests/linkage/experiment/test_experiment.py @@ -115,7 +115,7 @@ def test_Experiment(): assert e._syringe_contents["A"] == 0 assert e._syringe_contents["B"] == 10 assert issubclass(type(e._expt_concs),pd.DataFrame) - assert np.array_equal(e._expt_concs.columns,["injection","volume","meas_vol_dilution","A","B"]) + assert np.array_equal(e._expt_concs.columns,["injection","volume","A","B"]) assert e._conc_to_float is None assert issubclass(type(e._observables),dict) assert len(e._observables) == 0 @@ -406,12 +406,12 @@ def test_add_expt_column(): e.add_expt_conc_column(new_column="new_column") assert np.array_equal(e._expt_concs.columns, - ["injection","volume","meas_vol_dilution","A","B","new_column"]) + ["injection","volume","A","B","new_column"]) assert np.array_equal(e._expt_concs["new_column"],np.zeros(3)) e.add_expt_conc_column(new_column="blah",conc_vector=np.array([3,2,1])) assert np.array_equal(e._expt_concs.columns, - ["injection","volume","meas_vol_dilution","A","B","new_column","blah"]) + ["injection","volume","A","B","new_column","blah"]) assert np.array_equal(e._expt_concs["blah"],[3,2,1]) \ No newline at end of file diff --git a/tests/linkage/experiment/test_titrator.py b/tests/linkage/experiment/test_titrator.py index 00ec0ae..0dadd1f 100644 --- a/tests/linkage/experiment/test_titrator.py +++ b/tests/linkage/experiment/test_titrator.py @@ -85,7 +85,6 @@ def test__titr_constant_volume(): assert np.array_equal(out["injection"],injection_array) assert np.array_equal(out["volume"],[100,100,100]) - assert np.array_equal(out["meas_vol_dilution"],[1,1,1]) assert np.allclose(out["A"], [1, ((100 - 1)*1 + 10*1)/100, @@ -125,7 +124,6 @@ def test__titr_increase_volume(): assert np.array_equal(out["injection"],injection_array) assert np.array_equal(out["volume"],[100,101,111]) - assert np.array_equal(out["meas_vol_dilution"],[1,1-1/100,1-10/100]) assert np.allclose(out["A"], diff --git a/tests/linkage/models/test_ca_edta.py b/tests/linkage/models/test_ca_edta.py index 5ea0f5c..797c72a 100644 --- a/tests/linkage/models/test_ca_edta.py +++ b/tests/linkage/models/test_ca_edta.py @@ -22,27 +22,27 @@ def _check_with_log(bm,param_array,macro_array,expected_values): print("basic check") _check_with_log(bm=bm, - param_array=np.array([1e7]), + param_array=np.array([np.log(1e7)]), macro_array=np.array([1e-7,1e-10]), expected_values=np.array([-16.119, -23.719, -23.719])) print("another arbitrary conc check") _check_with_log(bm=bm, - param_array=np.array([1e7]), + param_array=np.array([np.log(1e7)]), macro_array=np.array([1e-3,1e-3]), expected_values=np.array([-11.518, -11.518, -6.918])) print("zero checks") - concs = bm.get_concs(param_array=np.array([1e7]), + concs = bm.get_concs(param_array=np.array([np.log(1e7)]), macro_array=np.array([0,1e-10])) assert np.allclose(concs,np.array([0,1e-10,0])) - concs = bm.get_concs(param_array=np.array([1e7]), + concs = bm.get_concs(param_array=np.array([np.log(1e7)]), macro_array=np.array([1e-7,0])) assert np.allclose(concs,np.array([1e-7,0,0])) - concs = bm.get_concs(param_array=np.array([1e7]), + concs = bm.get_concs(param_array=np.array([np.log(1e7)]), macro_array=np.array([0,0])) assert np.allclose(concs,np.array([0,0,0])) @@ -54,7 +54,7 @@ def _check_with_log(bm,param_array,macro_array,expected_values): assert np.array_equal(concs,np.nan*np.ones(3,dtype=float),equal_nan=True) with pytest.warns(): - concs = bm.get_concs(param_array=np.array([1e7]), + concs = bm.get_concs(param_array=np.array([np.log(1e7)]), macro_array=np.array([np.nan,1e-10])) assert np.array_equal(concs,np.nan*np.ones(3,dtype=float),equal_nan=True)