From 0f34f2389b2b579bdcf77fcde19d26e52625d727 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Mon, 1 Jul 2024 12:33:43 +0200 Subject: [PATCH] Add pre-commit and ruff config (#73) Closes #72 --- .ci_pip_reqs.txt | 2 +- .github/workflows/ci_tests.yml | 9 +- .pre-commit-config.yaml | 30 ++++ README.md | 4 +- petabtests/C.py | 20 +-- petabtests/cases/v1.0.0/sbml/0001/0001.py | 60 ++++--- petabtests/cases/v1.0.0/sbml/0002/0002.py | 73 +++++---- petabtests/cases/v1.0.0/sbml/0003/0003.py | 67 ++++---- petabtests/cases/v1.0.0/sbml/0004/0004.py | 60 ++++--- petabtests/cases/v1.0.0/sbml/0005/0005.py | 66 ++++---- petabtests/cases/v1.0.0/sbml/0006/0006.py | 65 ++++---- petabtests/cases/v1.0.0/sbml/0007/0007.py | 65 +++++--- petabtests/cases/v1.0.0/sbml/0008/0008.py | 60 ++++--- petabtests/cases/v1.0.0/sbml/0009/0009.py | 70 ++++---- petabtests/cases/v1.0.0/sbml/0010/0010.py | 67 ++++---- petabtests/cases/v1.0.0/sbml/0011/0011.py | 61 +++---- petabtests/cases/v1.0.0/sbml/0012/0012.py | 62 +++++--- petabtests/cases/v1.0.0/sbml/0013/0013.py | 66 ++++---- petabtests/cases/v1.0.0/sbml/0014/0014.py | 62 +++++--- petabtests/cases/v1.0.0/sbml/0015/0015.py | 62 +++++--- petabtests/cases/v1.0.0/sbml/0016/0016.py | 65 +++++--- petabtests/cases/v1.0.0/sbml/0017/0017.py | 83 ++++++---- petabtests/cases/v1.0.0/sbml/0018/0018.py | 82 +++++----- petabtests/cases/v1.0.0/sbml/0019/0019.py | 66 ++++---- petabtests/cases/v2.0.0/pysb/0001/0001.py | 60 ++++--- petabtests/cases/v2.0.0/pysb/0001/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0002/0002.py | 73 +++++---- petabtests/cases/v2.0.0/pysb/0002/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0003/0003.py | 67 ++++---- petabtests/cases/v2.0.0/pysb/0003/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0004/0004.py | 60 ++++--- petabtests/cases/v2.0.0/pysb/0004/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0005/0005.py | 66 ++++---- petabtests/cases/v2.0.0/pysb/0006/0006.py | 65 ++++---- petabtests/cases/v2.0.0/pysb/0006/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0007/0007.py | 65 +++++--- petabtests/cases/v2.0.0/pysb/0007/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0008/0008.py | 60 ++++--- petabtests/cases/v2.0.0/pysb/0008/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0009/0009.py | 70 ++++---- petabtests/cases/v2.0.0/pysb/0009/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0010/0010.py | 85 +++++----- petabtests/cases/v2.0.0/pysb/0010/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0011/0011.py | 71 +++++---- petabtests/cases/v2.0.0/pysb/0012/0012.py | 62 +++++--- petabtests/cases/v2.0.0/pysb/0012/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0013/0013.py | 76 +++++---- petabtests/cases/v2.0.0/pysb/0014/0014.py | 62 +++++--- petabtests/cases/v2.0.0/pysb/0014/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0015/0015.py | 62 +++++--- petabtests/cases/v2.0.0/pysb/0015/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0016/0016.py | 65 +++++--- petabtests/cases/v2.0.0/pysb/0016/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0017/0017.py | 95 ++++++----- petabtests/cases/v2.0.0/pysb/0017/_model.py | 26 +-- petabtests/cases/v2.0.0/pysb/0018/0018.py | 83 ++++++---- petabtests/cases/v2.0.0/pysb/0018/_model.py | 26 +-- petabtests/cases/v2.0.0/sbml/0001/0001.py | 60 ++++--- petabtests/cases/v2.0.0/sbml/0002/0002.py | 67 ++++---- petabtests/cases/v2.0.0/sbml/0003/0003.py | 67 ++++---- petabtests/cases/v2.0.0/sbml/0004/0004.py | 60 ++++--- petabtests/cases/v2.0.0/sbml/0005/0005.py | 66 ++++---- petabtests/cases/v2.0.0/sbml/0006/0006.py | 65 ++++---- petabtests/cases/v2.0.0/sbml/0007/0007.py | 65 +++++--- petabtests/cases/v2.0.0/sbml/0008/0008.py | 60 ++++--- petabtests/cases/v2.0.0/sbml/0009/0009.py | 70 ++++---- petabtests/cases/v2.0.0/sbml/0010/0010.py | 67 ++++---- petabtests/cases/v2.0.0/sbml/0011/0011.py | 61 +++---- petabtests/cases/v2.0.0/sbml/0012/0012.py | 62 +++++--- petabtests/cases/v2.0.0/sbml/0013/0013.py | 66 ++++---- petabtests/cases/v2.0.0/sbml/0014/0014.py | 62 +++++--- petabtests/cases/v2.0.0/sbml/0015/0015.py | 62 +++++--- petabtests/cases/v2.0.0/sbml/0016/0016.py | 65 +++++--- petabtests/cases/v2.0.0/sbml/0017/0017.py | 83 ++++++---- petabtests/cases/v2.0.0/sbml/0018/0018.py | 82 +++++----- petabtests/cases/v2.0.0/sbml/0019/0019.py | 80 ++++++---- petabtests/cases/v2.0.0/sbml/0020/0020.py | 66 ++++---- petabtests/cases/v2.0.0/sbml/0021/0021.py | 62 +++++--- petabtests/conversion_pysb.py | 26 +-- petabtests/core.py | 57 ++++--- petabtests/evaluate.py | 54 ++++--- petabtests/file.py | 167 ++++++++++++-------- petabtests/model.py | 10 +- petabtests/version.py | 2 +- pyproject.toml | 20 +++ setup.py | 8 +- test/test_evaluate.py | 44 +++--- test/test_generate.py | 5 +- 88 files changed, 2813 insertions(+), 1942 deletions(-) create mode 100644 .pre-commit-config.yaml diff --git a/.ci_pip_reqs.txt b/.ci_pip_reqs.txt index 99b0ecf..75eba8c 100644 --- a/.ci_pip_reqs.txt +++ b/.ci_pip_reqs.txt @@ -1,4 +1,4 @@ pytest -flake8 +ruff git+https://github.com/PEtab-dev/libpetab-python@develop sympy>=1.12.1 diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 4b2480c..5ccbf52 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -28,11 +28,10 @@ jobs: run: | python -m pip install --upgrade pip wheel pip install -e . + # uninstall, otherwise git+... installation from .ci_pip_reqs.txt won't do anything pip uninstall -y petab pip install -r .ci_pip_reqs.txt + - name: Check style + run: ruff check - name: Run tests - run: | - python -m flake8 \ - --exclude=build,doc,tmp,_model.py,conversion_modified_pysb.py,conversion_pysb.py \ - --extend-ignore=F403,F405 - pytest test + run: pytest test diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..b0a4548 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,30 @@ +# See https://pre-commit.com for more information +# See https://pre-commit.com/hooks.html for more hooks +exclude: | + (?x)^( + petabtests/cases/.*\.(md|tsv)| + petabtests/cases/.*/_model\.py| + petabtests/cases/.*/conversion_modified_pysb\.py| + cases/.* + )$ +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.6.0 + hooks: + - id: check-added-large-files + - id: check-merge-conflict + - id: check-yaml + args: [--allow-multiple-documents] + - id: end-of-file-fixer + - id: trailing-whitespace +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.5.0 + hooks: + # Run the linter. + - id: ruff + args: + - --fix + + # Run the formatter. + - id: ruff-format diff --git a/README.md b/README.md index 3b51b45..7f205a6 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ The PEtab test suite can be downloaded from GitHub via git clone https://github.com/petab-dev/petab_test_suite -The test suite comes with all necessary files pregenerated. +The test suite comes with all necessary files pregenerated. In the [petabtests](petabtests) subdirectory, it contains a python module for generating the tests and evaluating results. This can be installed via @@ -25,7 +25,7 @@ of enumerated tests. Each test contains a descriptive `wxyz.md` file, and a script file `wxyz.py` file that can be used to generate all problem and solution files for the test. The necessary files are in the same case-specific folder, starting with an -underscore. +underscore. In each case folder, there is a file `_wxyz.yaml` containing the parameter estimation problem description, and a file `_wxyz_solution.yaml` containing information on the expected results: chi2 value, log-likelihood, simulation diff --git a/petabtests/C.py b/petabtests/C.py index f5e1a42..7750153 100644 --- a/petabtests/C.py +++ b/petabtests/C.py @@ -5,18 +5,18 @@ # paths BASE_DIR = Path(__file__).parent -CASES_DIR = BASE_DIR / 'cases' +CASES_DIR = BASE_DIR / "cases" -DEFAULT_SBML_FILE = BASE_DIR / 'conversion.xml' -DEFAULT_PYSB_FILE = BASE_DIR / 'conversion_pysb.py' +DEFAULT_SBML_FILE = BASE_DIR / "conversion.xml" +DEFAULT_PYSB_FILE = BASE_DIR / "conversion_pysb.py" # constants -LLH = 'llh' -CHI2 = 'chi2' -SIMULATION_DFS = 'simulation_dfs' -SIMULATION_FILES = 'simulation_files' +LLH = "llh" +CHI2 = "chi2" +SIMULATION_DFS = "simulation_dfs" +SIMULATION_FILES = "simulation_files" -TOL_SIMULATIONS = 'tol_simulations' -TOL_CHI2 = 'tol_chi2' -TOL_LLH = 'tol_llh' +TOL_SIMULATIONS = "tol_simulations" +TOL_CHI2 = "tol_chi2" +TOL_LLH = "tol_llh" diff --git a/petabtests/cases/v1.0.0/sbml/0001/0001.py b/petabtests/cases/v1.0.0/sbml/0001/0001.py index 09b4fef..af42075 100644 --- a/petabtests/cases/v1.0.0/sbml/0001/0001.py +++ b/petabtests/cases/v1.0.0/sbml/0001/0001.py @@ -19,38 +19,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( diff --git a/petabtests/cases/v1.0.0/sbml/0002/0002.py b/petabtests/cases/v1.0.0/sbml/0002/0002.py index 1356101..2221585 100644 --- a/petabtests/cases/v1.0.0/sbml/0002/0002.py +++ b/petabtests/cases/v1.0.0/sbml/0002/0002.py @@ -25,42 +25,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'a0': [0.8, 0.9], - 'b0': [nan, nan], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'] * 4, - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c1', 'c1'], - TIME: [0, 10, 0, 10], - MEASUREMENT: [0.7, 0.1, 0.8, 0.2] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "a0": [0.8, 0.9], + "b0": [nan, nan], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"] * 4, + SIMULATION_CONDITION_ID: ["c0", "c0", "c1", "c1"], + TIME: [0, 10, 0, 10], + MEASUREMENT: [0.7, 0.1, 0.8, 0.2], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [*[analytical_a(t, 0.8, 1, 0.8, 0.6) - for t in [0, 10]], - *[analytical_a(t, 0.9, 1, 0.8, 0.6) - for t in [0, 10]]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + *[analytical_a(t, 0.8, 1, 0.8, 0.6) for t in [0, 10]], + *[analytical_a(t, 0.9, 1, 0.8, 0.6) for t in [0, 10]], +] case = PetabTestCase( id=2, diff --git a/petabtests/cases/v1.0.0/sbml/0003/0003.py b/petabtests/cases/v1.0.0/sbml/0003/0003.py index 92caf5f..9ff6190 100644 --- a/petabtests/cases/v1.0.0/sbml/0003/0003.py +++ b/petabtests/cases/v1.0.0/sbml/0003/0003.py @@ -25,45 +25,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A + ' - 'observableParameter2_obs_a'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: [ + "observableParameter1_obs_a * A + " "observableParameter2_obs_a" + ], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=3, brief="Simulation. Numeric observable parameter overrides in measurement " - "table.", + "table.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v1.0.0/sbml/0004/0004.py b/petabtests/cases/v1.0.0/sbml/0004/0004.py index 646692b..65ab0f1 100644 --- a/petabtests/cases/v1.0.0/sbml/0004/0004.py +++ b/petabtests/cases/v1.0.0/sbml/0004/0004.py @@ -25,38 +25,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['scaling_A * A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["scaling_A * A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'scaling_A', 'offset_A'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "scaling_A", "offset_A"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=4, diff --git a/petabtests/cases/v1.0.0/sbml/0005/0005.py b/petabtests/cases/v1.0.0/sbml/0005/0005.py index c1b0891..cf5dd2d 100644 --- a/petabtests/cases/v1.0.0/sbml/0005/0005.py +++ b/petabtests/cases/v1.0.0/sbml/0005/0005.py @@ -24,46 +24,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'offset_A': ['offset_A_c0', 'offset_A_c1'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "offset_A": ["offset_A_c0", "offset_A_c1"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [10, 10], - MEASUREMENT: [2.1, 3.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [10, 10], + MEASUREMENT: [2.1, 3.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'offset_A_c0', 'offset_A_c1'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "offset_A_c0", "offset_A_c1"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(10, 1, 0, 0.8, 0.6) + offset - for offset in [2, 3]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(10, 1, 0, 0.8, 0.6) + offset for offset in [2, 3] +] case = PetabTestCase( id=5, brief="Simulation. Condition-specific parameters only defined in " - "parameter table.", + "parameter table.", description=DESCRIPTION, - model=Path('conversion_modified.xml'), + model=Path("conversion_modified.xml"), condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v1.0.0/sbml/0006/0006.py b/petabtests/cases/v1.0.0/sbml/0006/0006.py index aecf6b0..e4b24dc 100644 --- a/petabtests/cases/v1.0.0/sbml/0006/0006.py +++ b/petabtests/cases/v1.0.0/sbml/0006/0006.py @@ -22,44 +22,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: [10, 15] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: [10, 15], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["observableParameter1_obs_a * A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [10 * analytical_a(0, 1, 0, 0.8, 0.6), - 15 * analytical_a(10, 1, 0, 0.8, 0.6)] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 10 * analytical_a(0, 1, 0, 0.8, 0.6), + 15 * analytical_a(10, 1, 0, 0.8, 0.6), +] case = PetabTestCase( id=6, brief="Simulation. Time-point specific numeric observable parameter " - "overrides.", + "overrides.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v1.0.0/sbml/0007/0007.py b/petabtests/cases/v1.0.0/sbml/0007/0007.py index 90fb392..d0ddb4c 100644 --- a/petabtests/cases/v1.0.0/sbml/0007/0007.py +++ b/petabtests/cases/v1.0.0/sbml/0007/0007.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -23,37 +27,46 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG10], - NOISE_FORMULA: [0.5, 0.6] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG10], + NOISE_FORMULA: [0.5, 0.6], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v1.0.0/sbml/0008/0008.py b/petabtests/cases/v1.0.0/sbml/0008/0008.py index 639d0b3..b71fe3e 100644 --- a/petabtests/cases/v1.0.0/sbml/0008/0008.py +++ b/petabtests/cases/v1.0.0/sbml/0008/0008.py @@ -21,38 +21,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c0'], - TIME: [0, 10, 10], - MEASUREMENT: [0.7, 0.1, 0.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0", "c0"], + TIME: [0, 10, 10], + MEASUREMENT: [0.7, 0.1, 0.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=8, diff --git a/petabtests/cases/v1.0.0/sbml/0009/0009.py b/petabtests/cases/v1.0.0/sbml/0009/0009.py index 4c9545e..4654dec 100644 --- a/petabtests/cases/v1.0.0/sbml/0009/0009.py +++ b/petabtests/cases/v1.0.0/sbml/0009/0009.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,45 +26,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k2'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [1, 0, 0.6], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k2"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [1, 0, 0.6], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) steady_state_b = analytical_b(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ analytical_a(t, steady_state_a, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + for t in simulation_df[TIME] +] case = PetabTestCase( id=9, diff --git a/petabtests/cases/v1.0.0/sbml/0010/0010.py b/petabtests/cases/v1.0.0/sbml/0010/0010.py index cc71b3c..4018a5e 100644 --- a/petabtests/cases/v1.0.0/sbml/0010/0010.py +++ b/petabtests/cases/v1.0.0/sbml/0010/0010.py @@ -23,50 +23,59 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [0, 1], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [0, 1], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, steady_state_a, 1, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, steady_state_a, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=10, brief="Simulation. Preequilibration. One species reinitialized, one not. " - "InitialAssignment to species overridden.", + "InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v1.0.0/sbml/0011/0011.py b/petabtests/cases/v1.0.0/sbml/0011/0011.py index 3b3b82b..2eaaec7 100644 --- a/petabtests/cases/v1.0.0/sbml/0011/0011.py +++ b/petabtests/cases/v1.0.0/sbml/0011/0011.py @@ -20,45 +20,52 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': [2] -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame(data={CONDITION_ID: ["c0"], "B": [2]}).set_index( + [CONDITION_ID] +) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 2, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 2, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=11, brief="Simulation. InitialAssignment to species overridden.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v1.0.0/sbml/0012/0012.py b/petabtests/cases/v1.0.0/sbml/0012/0012.py index e3e576f..b630b88 100644 --- a/petabtests/cases/v1.0.0/sbml/0012/0012.py +++ b/petabtests/cases/v1.0.0/sbml/0012/0012.py @@ -18,41 +18,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'compartment': [3], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "compartment": [3], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 1, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=12, diff --git a/petabtests/cases/v1.0.0/sbml/0013/0013.py b/petabtests/cases/v1.0.0/sbml/0013/0013.py index 64c30c4..653cdad 100644 --- a/petabtests/cases/v1.0.0/sbml/0013/0013.py +++ b/petabtests/cases/v1.0.0/sbml/0013/0013.py @@ -18,48 +18,58 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': ['par'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "B": ["par"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2', 'par'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [0.8, 0.6, 7], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2", "par"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [0.8, 0.6, 7], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 7, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 7, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=13, brief="Simulation. Species with InitialAssignment overridden by " - "parameter.", + "parameter.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v1.0.0/sbml/0014/0014.py b/petabtests/cases/v1.0.0/sbml/0014/0014.py index c2e497f..340489c 100644 --- a/petabtests/cases/v1.0.0/sbml/0014/0014.py +++ b/petabtests/cases/v1.0.0/sbml/0014/0014.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a + noiseParameter2_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a + noiseParameter2_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=14, diff --git a/petabtests/cases/v1.0.0/sbml/0015/0015.py b/petabtests/cases/v1.0.0/sbml/0015/0015.py index 7b767a3..6efdec7 100644 --- a/petabtests/cases/v1.0.0/sbml/0015/0015.py +++ b/petabtests/cases/v1.0.0/sbml/0015/0015.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['noise', 'noise'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["noise", "noise"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'noise'], - PARAMETER_SCALE: [LIN] * 5, - LOWER_BOUND: [0] * 5, - UPPER_BOUND: [10] * 5, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], - ESTIMATE: [1] * 5, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "noise"], + PARAMETER_SCALE: [LIN] * 5, + LOWER_BOUND: [0] * 5, + UPPER_BOUND: [10] * 5, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], + ESTIMATE: [1] * 5, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=15, diff --git a/petabtests/cases/v1.0.0/sbml/0016/0016.py b/petabtests/cases/v1.0.0/sbml/0016/0016.py index e520636..e3b7992 100644 --- a/petabtests/cases/v1.0.0/sbml/0016/0016.py +++ b/petabtests/cases/v1.0.0/sbml/0016/0016.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,37 +26,46 @@ """) # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG], - NOISE_FORMULA: [0.5, 0.7] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG], + NOISE_FORMULA: [0.5, 0.7], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v1.0.0/sbml/0017/0017.py b/petabtests/cases/v1.0.0/sbml/0017/0017.py index 7b97b6e..3209701 100644 --- a/petabtests/cases/v1.0.0/sbml/0017/0017.py +++ b/petabtests/cases/v1.0.0/sbml/0017/0017.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -29,51 +33,60 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [2.0, 'NaN'], - 'A': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [2.0, "NaN"], + "A": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_b = analytical_b(1000, 0, 2.0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=17, brief="Simulation. Preequilibration. One species reinitialized, one not " - "(NaN in condition table). InitialAssignment to species overridden.", + "(NaN in condition table). InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v1.0.0/sbml/0018/0018.py b/petabtests/cases/v1.0.0/sbml/0018/0018.py index c00613e..680957a 100644 --- a/petabtests/cases/v1.0.0/sbml/0018/0018.py +++ b/petabtests/cases/v1.0.0/sbml/0018/0018.py @@ -33,6 +33,7 @@ def get_model(): import simplesbml + model = simplesbml.SbmlModel() model.addParameter("a0", 1) model.addParameter("b0", 1) @@ -52,57 +53,66 @@ def get_model(): f.write(get_model().toSBML()) -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [2.0, 'NaN'], - 'A': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'] * 3 + ['obs_b'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0'] * 4, - SIMULATION_CONDITION_ID: ['c0'] * 4, - TIME: [0, 1, 10, 0], - MEASUREMENT: [0.1, 0.7, 0.1, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - NOISE_FORMULA: [0.5, 0.2] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [2.0, "NaN"], + "A": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"] * 3 + ["obs_b"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0"] * 4, + SIMULATION_CONDITION_ID: ["c0"] * 4, + TIME: [0, 1, 10, 0], + MEASUREMENT: [0.1, 0.7, 0.1, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + NOISE_FORMULA: [0.5, 0.2], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_b = analytical_b(1000, 0, 2.0, 0.3, 0.6) # use steady state as initial state simulation_df.iloc[:3, simulation_df.columns.get_loc(SIMULATION)] = [ - analytical_a(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]][:3] + analytical_a(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +][:3] simulation_df.iloc[3:, simulation_df.columns.get_loc(SIMULATION)] = [ - analytical_b(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]][3:] + analytical_b(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +][3:] case = PetabTestCase( id=18, brief="Simulation. Preequilibration and RateRules. One state " - "reinitialized, one not (NaN in condition table). InitialAssignment " - "to species overridden.", + "reinitialized, one not (NaN in condition table). InitialAssignment " + "to species overridden.", description=DESCRIPTION, model=model, condition_dfs=[condition_df], diff --git a/petabtests/cases/v1.0.0/sbml/0019/0019.py b/petabtests/cases/v1.0.0/sbml/0019/0019.py index 2042ed0..dee7ed0 100644 --- a/petabtests/cases/v1.0.0/sbml/0019/0019.py +++ b/petabtests/cases/v1.0.0/sbml/0019/0019.py @@ -21,46 +21,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'A': ["initial_A"], - 'B': ["initial_B"], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "A": ["initial_A"], + "B": ["initial_B"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2', 'initial_A', 'initial_B'], - PARAMETER_SCALE: [LIN, LIN, LOG10, LIN], - LOWER_BOUND: [0, 0, 1, 0], - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [0.8, 0.6, 2, 3], - ESTIMATE: [1] * 3 + [0], -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2", "initial_A", "initial_B"], + PARAMETER_SCALE: [LIN, LIN, LOG10, LIN], + LOWER_BOUND: [0, 0, 1, 0], + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [0.8, 0.6, 2, 3], + ESTIMATE: [1] * 3 + [0], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 2, 3, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 2, 3, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=19, brief="Simulation. Estimated initial value via conditions table.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/pysb/0001/0001.py b/petabtests/cases/v2.0.0/pysb/0001/0001.py index a4a061e..16310e4 100644 --- a/petabtests/cases/v2.0.0/pysb/0001/0001.py +++ b/petabtests/cases/v2.0.0/pysb/0001/0001.py @@ -19,38 +19,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( diff --git a/petabtests/cases/v2.0.0/pysb/0001/_model.py b/petabtests/cases/v2.0.0/pysb/0001/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0001/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0001/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0002/0002.py b/petabtests/cases/v2.0.0/pysb/0002/0002.py index f82e872..eac5df1 100644 --- a/petabtests/cases/v2.0.0/pysb/0002/0002.py +++ b/petabtests/cases/v2.0.0/pysb/0002/0002.py @@ -25,42 +25,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'a0': [0.8, 0.9], - 'b0': [nan, nan], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'] * 4, - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c1', 'c1'], - TIME: [0, 10, 0, 10], - MEASUREMENT: [0.7, 0.1, 0.8, 0.2] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "a0": [0.8, 0.9], + "b0": [nan, nan], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"] * 4, + SIMULATION_CONDITION_ID: ["c0", "c0", "c1", "c1"], + TIME: [0, 10, 0, 10], + MEASUREMENT: [0.7, 0.1, 0.8, 0.2], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [*[analytical_a(t, 0.8, 1, 0.8, 0.6) - for t in [0, 10]], - *[analytical_a(t, 0.9, 1, 0.8, 0.6) - for t in [0, 10]]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + *[analytical_a(t, 0.8, 1, 0.8, 0.6) for t in [0, 10]], + *[analytical_a(t, 0.9, 1, 0.8, 0.6) for t in [0, 10]], +] case = PetabTestCase( id=2, diff --git a/petabtests/cases/v2.0.0/pysb/0002/_model.py b/petabtests/cases/v2.0.0/pysb/0002/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0002/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0002/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0003/0003.py b/petabtests/cases/v2.0.0/pysb/0003/0003.py index b03f3bf..f88e584 100644 --- a/petabtests/cases/v2.0.0/pysb/0003/0003.py +++ b/petabtests/cases/v2.0.0/pysb/0003/0003.py @@ -25,45 +25,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A + ' - 'observableParameter2_obs_a'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: [ + "observableParameter1_obs_a * A + " "observableParameter2_obs_a" + ], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=3, brief="Simulation. Numeric observable parameter overrides in measurement " - "table.", + "table.", description=DESCRIPTION, model=DEFAULT_PYSB_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/pysb/0003/_model.py b/petabtests/cases/v2.0.0/pysb/0003/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0003/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0003/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0004/0004.py b/petabtests/cases/v2.0.0/pysb/0004/0004.py index 4e850c9..85a4c51 100644 --- a/petabtests/cases/v2.0.0/pysb/0004/0004.py +++ b/petabtests/cases/v2.0.0/pysb/0004/0004.py @@ -25,38 +25,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['scaling_A * A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["scaling_A * A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'scaling_A', 'offset_A'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "scaling_A", "offset_A"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=4, diff --git a/petabtests/cases/v2.0.0/pysb/0004/_model.py b/petabtests/cases/v2.0.0/pysb/0004/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0004/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0004/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0005/0005.py b/petabtests/cases/v2.0.0/pysb/0005/0005.py index 0d546e2..4b89b9c 100644 --- a/petabtests/cases/v2.0.0/pysb/0005/0005.py +++ b/petabtests/cases/v2.0.0/pysb/0005/0005.py @@ -23,46 +23,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'offset_A': ['offset_A_c0', 'offset_A_c1'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "offset_A": ["offset_A_c0", "offset_A_c1"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [10, 10], - MEASUREMENT: [2.1, 3.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [10, 10], + MEASUREMENT: [2.1, 3.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'offset_A_c0', 'offset_A_c1'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "offset_A_c0", "offset_A_c1"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(10, 1, 0, 0.8, 0.6) + offset - for offset in [2, 3]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(10, 1, 0, 0.8, 0.6) + offset for offset in [2, 3] +] case = PetabTestCase( id=5, brief="Simulation. Condition-specific parameters only defined in " - "parameter table.", + "parameter table.", description=DESCRIPTION, - model='conversion_modified_pysb.py', + model="conversion_modified_pysb.py", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/pysb/0006/0006.py b/petabtests/cases/v2.0.0/pysb/0006/0006.py index 452546a..39cf6bb 100644 --- a/petabtests/cases/v2.0.0/pysb/0006/0006.py +++ b/petabtests/cases/v2.0.0/pysb/0006/0006.py @@ -22,44 +22,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: [10, 15] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: [10, 15], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["observableParameter1_obs_a * A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [10 * analytical_a(0, 1, 0, 0.8, 0.6), - 15 * analytical_a(10, 1, 0, 0.8, 0.6)] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 10 * analytical_a(0, 1, 0, 0.8, 0.6), + 15 * analytical_a(10, 1, 0, 0.8, 0.6), +] case = PetabTestCase( id=6, brief="Simulation. Time-point specific numeric observable parameter " - "overrides.", + "overrides.", description=DESCRIPTION, model=DEFAULT_PYSB_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/pysb/0006/_model.py b/petabtests/cases/v2.0.0/pysb/0006/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0006/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0006/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0007/0007.py b/petabtests/cases/v2.0.0/pysb/0007/0007.py index 2d66083..b1510d9 100644 --- a/petabtests/cases/v2.0.0/pysb/0007/0007.py +++ b/petabtests/cases/v2.0.0/pysb/0007/0007.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_PYSB_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_PYSB_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -23,37 +27,46 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG10], - NOISE_FORMULA: [0.5, 0.6] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG10], + NOISE_FORMULA: [0.5, 0.6], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v2.0.0/pysb/0007/_model.py b/petabtests/cases/v2.0.0/pysb/0007/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0007/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0007/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0008/0008.py b/petabtests/cases/v2.0.0/pysb/0008/0008.py index 7e4a02a..4c71391 100644 --- a/petabtests/cases/v2.0.0/pysb/0008/0008.py +++ b/petabtests/cases/v2.0.0/pysb/0008/0008.py @@ -21,38 +21,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c0'], - TIME: [0, 10, 10], - MEASUREMENT: [0.7, 0.1, 0.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0", "c0"], + TIME: [0, 10, 10], + MEASUREMENT: [0.7, 0.1, 0.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=8, diff --git a/petabtests/cases/v2.0.0/pysb/0008/_model.py b/petabtests/cases/v2.0.0/pysb/0008/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0008/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0008/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0009/0009.py b/petabtests/cases/v2.0.0/pysb/0009/0009.py index 4102817..29a35b9 100644 --- a/petabtests/cases/v2.0.0/pysb/0009/0009.py +++ b/petabtests/cases/v2.0.0/pysb/0009/0009.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_PYSB_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_PYSB_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,45 +26,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k2'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [1, 0, 0.6], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k2"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [1, 0, 0.6], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) steady_state_b = analytical_b(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ analytical_a(t, steady_state_a, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + for t in simulation_df[TIME] +] case = PetabTestCase( id=9, diff --git a/petabtests/cases/v2.0.0/pysb/0009/_model.py b/petabtests/cases/v2.0.0/pysb/0009/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0009/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0009/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0010/0010.py b/petabtests/cases/v2.0.0/pysb/0010/0010.py index 9b0a1ba..039f45b 100644 --- a/petabtests/cases/v2.0.0/pysb/0010/0010.py +++ b/petabtests/cases/v2.0.0/pysb/0010/0010.py @@ -23,55 +23,66 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) - -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: ['A', 'B'], - MODEL_ENTITY_ID: ['A_() ** compartment', 'B_() ** compartment'], -}).set_index(PETAB_ENTITY_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) + +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: ["A", "B"], + MODEL_ENTITY_ID: ["A_() ** compartment", "B_() ** compartment"], + } +).set_index(PETAB_ENTITY_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, steady_state_a, 1, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, steady_state_a, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=10, brief="Simulation. Preequilibration. One species reinitialized, one not. " - "InitialAssignment to species overridden.", + "InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_PYSB_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/pysb/0010/_model.py b/petabtests/cases/v2.0.0/pysb/0010/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0010/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0010/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0011/0011.py b/petabtests/cases/v2.0.0/pysb/0011/0011.py index ac8ae9b..ef72dc4 100644 --- a/petabtests/cases/v2.0.0/pysb/0011/0011.py +++ b/petabtests/cases/v2.0.0/pysb/0011/0011.py @@ -20,50 +20,59 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': [2] -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame(data={CONDITION_ID: ["c0"], "B": [2]}).set_index( + [CONDITION_ID] +) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: ['A', 'B'], - MODEL_ENTITY_ID: ['A_() ** compartment', 'B_() ** compartment'], -}).set_index(PETAB_ENTITY_ID) +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: ["A", "B"], + MODEL_ENTITY_ID: ["A_() ** compartment", "B_() ** compartment"], + } +).set_index(PETAB_ENTITY_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 2, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 2, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=11, brief="Simulation. InitialAssignment to species overridden.", description=DESCRIPTION, - model='conversion_modified_pysb.py', + model="conversion_modified_pysb.py", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/pysb/0012/0012.py b/petabtests/cases/v2.0.0/pysb/0012/0012.py index ff3ddda..ead12e7 100644 --- a/petabtests/cases/v2.0.0/pysb/0012/0012.py +++ b/petabtests/cases/v2.0.0/pysb/0012/0012.py @@ -18,41 +18,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'compartment': [3], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "compartment": [3], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 1, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=12, diff --git a/petabtests/cases/v2.0.0/pysb/0012/_model.py b/petabtests/cases/v2.0.0/pysb/0012/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0012/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0012/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0013/0013.py b/petabtests/cases/v2.0.0/pysb/0013/0013.py index 8913472..bbb1440 100644 --- a/petabtests/cases/v2.0.0/pysb/0013/0013.py +++ b/petabtests/cases/v2.0.0/pysb/0013/0013.py @@ -18,53 +18,65 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': ['par'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "B": ["par"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2', 'par'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [0.8, 0.6, 7], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2", "par"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [0.8, 0.6, 7], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: ['A', 'B'], - MODEL_ENTITY_ID: ['A_() ** compartment', 'B_() ** compartment'], -}).set_index(PETAB_ENTITY_ID) +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: ["A", "B"], + MODEL_ENTITY_ID: ["A_() ** compartment", "B_() ** compartment"], + } +).set_index(PETAB_ENTITY_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 7, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 7, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=13, brief="Simulation. Species with InitialAssignment overridden by " - "parameter.", + "parameter.", description=DESCRIPTION, - model='conversion_modified_pysb.py', + model="conversion_modified_pysb.py", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/pysb/0014/0014.py b/petabtests/cases/v2.0.0/pysb/0014/0014.py index 4fd543f..40dc7ba 100644 --- a/petabtests/cases/v2.0.0/pysb/0014/0014.py +++ b/petabtests/cases/v2.0.0/pysb/0014/0014.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a + noiseParameter2_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a + noiseParameter2_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=14, diff --git a/petabtests/cases/v2.0.0/pysb/0014/_model.py b/petabtests/cases/v2.0.0/pysb/0014/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0014/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0014/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0015/0015.py b/petabtests/cases/v2.0.0/pysb/0015/0015.py index d4df7a4..2e89b56 100644 --- a/petabtests/cases/v2.0.0/pysb/0015/0015.py +++ b/petabtests/cases/v2.0.0/pysb/0015/0015.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['noise', 'noise'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["noise", "noise"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'noise'], - PARAMETER_SCALE: [LIN] * 5, - LOWER_BOUND: [0] * 5, - UPPER_BOUND: [10] * 5, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], - ESTIMATE: [1] * 5, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "noise"], + PARAMETER_SCALE: [LIN] * 5, + LOWER_BOUND: [0] * 5, + UPPER_BOUND: [10] * 5, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], + ESTIMATE: [1] * 5, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=15, diff --git a/petabtests/cases/v2.0.0/pysb/0015/_model.py b/petabtests/cases/v2.0.0/pysb/0015/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0015/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0015/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0016/0016.py b/petabtests/cases/v2.0.0/pysb/0016/0016.py index d1c8214..9b400a5 100644 --- a/petabtests/cases/v2.0.0/pysb/0016/0016.py +++ b/petabtests/cases/v2.0.0/pysb/0016/0016.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_PYSB_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_PYSB_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,37 +26,46 @@ """) # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG], - NOISE_FORMULA: [0.5, 0.7] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG], + NOISE_FORMULA: [0.5, 0.7], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v2.0.0/pysb/0016/_model.py b/petabtests/cases/v2.0.0/pysb/0016/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0016/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0016/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0017/0017.py b/petabtests/cases/v2.0.0/pysb/0017/0017.py index fa74cd1..0fc538a 100644 --- a/petabtests/cases/v2.0.0/pysb/0017/0017.py +++ b/petabtests/cases/v2.0.0/pysb/0017/0017.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_PYSB_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_PYSB_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -29,56 +33,67 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [2.0, 'NaN'], - 'A': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) - -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: ['A', 'B'], - MODEL_ENTITY_ID: ['A_() ** compartment', 'B_() ** compartment'], -}).set_index(PETAB_ENTITY_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [2.0, "NaN"], + "A": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) + +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: ["A", "B"], + MODEL_ENTITY_ID: ["A_() ** compartment", "B_() ** compartment"], + } +).set_index(PETAB_ENTITY_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_b = analytical_b(1000, 0, 2.0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=17, brief="Simulation. Preequilibration. One species reinitialized, one not " - "(NaN in condition table). InitialAssignment to species overridden.", + "(NaN in condition table). InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_PYSB_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/pysb/0017/_model.py b/petabtests/cases/v2.0.0/pysb/0017/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0017/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0017/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/pysb/0018/0018.py b/petabtests/cases/v2.0.0/pysb/0018/0018.py index fb5b8a6..a499fbd 100644 --- a/petabtests/cases/v2.0.0/pysb/0018/0018.py +++ b/petabtests/cases/v2.0.0/pysb/0018/0018.py @@ -18,44 +18,61 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['maps_to_a0', 'b0', 'maps_to_k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) - -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: ['maps_to_a0', 'maps_to_b0', 'maps_to_k1', 'maps_to_k2'], - MODEL_ENTITY_ID: ['a0', 'b0', 'k1', 'k2'], -}).set_index(PETAB_ENTITY_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["maps_to_a0", "b0", "maps_to_k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) + +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: [ + "maps_to_a0", + "maps_to_b0", + "maps_to_k1", + "maps_to_k2", + ], + MODEL_ENTITY_ID: ["a0", "b0", "k1", "k2"], + } +).set_index(PETAB_ENTITY_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( diff --git a/petabtests/cases/v2.0.0/pysb/0018/_model.py b/petabtests/cases/v2.0.0/pysb/0018/_model.py index 57ec588..71263df 100644 --- a/petabtests/cases/v2.0.0/pysb/0018/_model.py +++ b/petabtests/cases/v2.0.0/pysb/0018/_model.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/cases/v2.0.0/sbml/0001/0001.py b/petabtests/cases/v2.0.0/sbml/0001/0001.py index 09b4fef..af42075 100644 --- a/petabtests/cases/v2.0.0/sbml/0001/0001.py +++ b/petabtests/cases/v2.0.0/sbml/0001/0001.py @@ -19,38 +19,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( diff --git a/petabtests/cases/v2.0.0/sbml/0002/0002.py b/petabtests/cases/v2.0.0/sbml/0002/0002.py index a84660d..e5a6939 100644 --- a/petabtests/cases/v2.0.0/sbml/0002/0002.py +++ b/petabtests/cases/v2.0.0/sbml/0002/0002.py @@ -24,42 +24,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'a0': [0.8, 0.9], - 'b0': [nan, nan], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "a0": [0.8, 0.9], + "b0": [nan, nan], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'] * 4, - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c1', 'c1'], - TIME: [0, 10, 0, 10], - MEASUREMENT: [0.7, 0.1, 0.8, 0.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"] * 4, + SIMULATION_CONDITION_ID: ["c0", "c0", "c1", "c1"], + TIME: [0, 10, 0, 10], + MEASUREMENT: [0.7, 0.1, 0.8, 0.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [*[analytical_a(t, 0.8, 1, 0.8, 0.6) - for t in [0, 10]], - *[analytical_a(t, 0.9, 1, 0.8, 0.6) - for t in [0, 10]]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + *[analytical_a(t, 0.8, 1, 0.8, 0.6) for t in [0, 10]], + *[analytical_a(t, 0.9, 1, 0.8, 0.6) for t in [0, 10]], +] case = PetabTestCase( id=2, diff --git a/petabtests/cases/v2.0.0/sbml/0003/0003.py b/petabtests/cases/v2.0.0/sbml/0003/0003.py index 92caf5f..9ff6190 100644 --- a/petabtests/cases/v2.0.0/sbml/0003/0003.py +++ b/petabtests/cases/v2.0.0/sbml/0003/0003.py @@ -25,45 +25,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A + ' - 'observableParameter2_obs_a'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: [ + "observableParameter1_obs_a * A + " "observableParameter2_obs_a" + ], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=3, brief="Simulation. Numeric observable parameter overrides in measurement " - "table.", + "table.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/sbml/0004/0004.py b/petabtests/cases/v2.0.0/sbml/0004/0004.py index 646692b..65ab0f1 100644 --- a/petabtests/cases/v2.0.0/sbml/0004/0004.py +++ b/petabtests/cases/v2.0.0/sbml/0004/0004.py @@ -25,38 +25,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['scaling_A * A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["scaling_A * A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'scaling_A', 'offset_A'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "scaling_A", "offset_A"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 0.5, 2], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 0.5 * analytical_a(t, 1, 0, 0.8, 0.6) + 2 for t in simulation_df[TIME] +] case = PetabTestCase( id=4, diff --git a/petabtests/cases/v2.0.0/sbml/0005/0005.py b/petabtests/cases/v2.0.0/sbml/0005/0005.py index c1b0891..cf5dd2d 100644 --- a/petabtests/cases/v2.0.0/sbml/0005/0005.py +++ b/petabtests/cases/v2.0.0/sbml/0005/0005.py @@ -24,46 +24,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0', 'c1'], - 'offset_A': ['offset_A_c0', 'offset_A_c1'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0", "c1"], + "offset_A": ["offset_A_c0", "offset_A_c1"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [10, 10], - MEASUREMENT: [2.1, 3.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [10, 10], + MEASUREMENT: [2.1, 3.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A + offset_A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A + offset_A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'offset_A_c0', 'offset_A_c1'], - PARAMETER_SCALE: [LIN] * 6, - LOWER_BOUND: [0] * 6, - UPPER_BOUND: [10] * 6, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], - ESTIMATE: [1] * 6, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "offset_A_c0", "offset_A_c1"], + PARAMETER_SCALE: [LIN] * 6, + LOWER_BOUND: [0] * 6, + UPPER_BOUND: [10] * 6, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 2, 3], + ESTIMATE: [1] * 6, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(10, 1, 0, 0.8, 0.6) + offset - for offset in [2, 3]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(10, 1, 0, 0.8, 0.6) + offset for offset in [2, 3] +] case = PetabTestCase( id=5, brief="Simulation. Condition-specific parameters only defined in " - "parameter table.", + "parameter table.", description=DESCRIPTION, - model=Path('conversion_modified.xml'), + model=Path("conversion_modified.xml"), condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/sbml/0006/0006.py b/petabtests/cases/v2.0.0/sbml/0006/0006.py index aecf6b0..e4b24dc 100644 --- a/petabtests/cases/v2.0.0/sbml/0006/0006.py +++ b/petabtests/cases/v2.0.0/sbml/0006/0006.py @@ -22,44 +22,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - OBSERVABLE_PARAMETERS: [10, 15] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + OBSERVABLE_PARAMETERS: [10, 15], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['observableParameter1_obs_a * A'], - NOISE_FORMULA: [1] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["observableParameter1_obs_a * A"], + NOISE_FORMULA: [1], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [10 * analytical_a(0, 1, 0, 0.8, 0.6), - 15 * analytical_a(10, 1, 0, 0.8, 0.6)] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + 10 * analytical_a(0, 1, 0, 0.8, 0.6), + 15 * analytical_a(10, 1, 0, 0.8, 0.6), +] case = PetabTestCase( id=6, brief="Simulation. Time-point specific numeric observable parameter " - "overrides.", + "overrides.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/sbml/0007/0007.py b/petabtests/cases/v2.0.0/sbml/0007/0007.py index 90fb392..d0ddb4c 100644 --- a/petabtests/cases/v2.0.0/sbml/0007/0007.py +++ b/petabtests/cases/v2.0.0/sbml/0007/0007.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -23,37 +27,46 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG10], - NOISE_FORMULA: [0.5, 0.6] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG10], + NOISE_FORMULA: [0.5, 0.6], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v2.0.0/sbml/0008/0008.py b/petabtests/cases/v2.0.0/sbml/0008/0008.py index 639d0b3..b71fe3e 100644 --- a/petabtests/cases/v2.0.0/sbml/0008/0008.py +++ b/petabtests/cases/v2.0.0/sbml/0008/0008.py @@ -21,38 +21,48 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0', 'c0'], - TIME: [0, 10, 10], - MEASUREMENT: [0.7, 0.1, 0.2] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0", "c0"], + TIME: [0, 10, 10], + MEASUREMENT: [0.7, 0.1, 0.2], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=8, diff --git a/petabtests/cases/v2.0.0/sbml/0009/0009.py b/petabtests/cases/v2.0.0/sbml/0009/0009.py index 4c9545e..4654dec 100644 --- a/petabtests/cases/v2.0.0/sbml/0009/0009.py +++ b/petabtests/cases/v2.0.0/sbml/0009/0009.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,45 +26,55 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k2'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [1, 0, 0.6], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k2"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [1, 0, 0.6], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) steady_state_b = analytical_b(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ analytical_a(t, steady_state_a, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + for t in simulation_df[TIME] +] case = PetabTestCase( id=9, diff --git a/petabtests/cases/v2.0.0/sbml/0010/0010.py b/petabtests/cases/v2.0.0/sbml/0010/0010.py index cc71b3c..4018a5e 100644 --- a/petabtests/cases/v2.0.0/sbml/0010/0010.py +++ b/petabtests/cases/v2.0.0/sbml/0010/0010.py @@ -23,50 +23,59 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [0, 1], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [0, 1], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_a = analytical_a(1000, 1, 0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, steady_state_a, 1, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, steady_state_a, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=10, brief="Simulation. Preequilibration. One species reinitialized, one not. " - "InitialAssignment to species overridden.", + "InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/sbml/0011/0011.py b/petabtests/cases/v2.0.0/sbml/0011/0011.py index 9f5af1a..693c69a 100644 --- a/petabtests/cases/v2.0.0/sbml/0011/0011.py +++ b/petabtests/cases/v2.0.0/sbml/0011/0011.py @@ -20,45 +20,52 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': [2] -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame(data={CONDITION_ID: ["c0"], "B": [2]}).set_index( + [CONDITION_ID] +) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 2, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 2, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=11, brief="Simulation. InitialAssignment to species overridden.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/sbml/0012/0012.py b/petabtests/cases/v2.0.0/sbml/0012/0012.py index e3e576f..b630b88 100644 --- a/petabtests/cases/v2.0.0/sbml/0012/0012.py +++ b/petabtests/cases/v2.0.0/sbml/0012/0012.py @@ -18,41 +18,51 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'compartment': [3], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "compartment": [3], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2'], - PARAMETER_SCALE: [LIN] * 2, - LOWER_BOUND: [0] * 2, - UPPER_BOUND: [10] * 2, - NOMINAL_VALUE: [0.8, 0.6], - ESTIMATE: [1] * 2, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2"], + PARAMETER_SCALE: [LIN] * 2, + LOWER_BOUND: [0] * 2, + UPPER_BOUND: [10] * 2, + NOMINAL_VALUE: [0.8, 0.6], + ESTIMATE: [1] * 2, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 1, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 1, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=12, diff --git a/petabtests/cases/v2.0.0/sbml/0013/0013.py b/petabtests/cases/v2.0.0/sbml/0013/0013.py index 64c30c4..653cdad 100644 --- a/petabtests/cases/v2.0.0/sbml/0013/0013.py +++ b/petabtests/cases/v2.0.0/sbml/0013/0013.py @@ -18,48 +18,58 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'B': ['par'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "B": ["par"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2', 'par'], - PARAMETER_SCALE: [LIN] * 3, - LOWER_BOUND: [0] * 3, - UPPER_BOUND: [10] * 3, - NOMINAL_VALUE: [0.8, 0.6, 7], - ESTIMATE: [1] * 3, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2", "par"], + PARAMETER_SCALE: [LIN] * 3, + LOWER_BOUND: [0] * 3, + UPPER_BOUND: [10] * 3, + NOMINAL_VALUE: [0.8, 0.6, 7], + ESTIMATE: [1] * 3, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # in the model, concentrations are used, which do not depend on the # compartment size, so that the species values should stay the same -simulation_df[SIMULATION] = [analytical_a(t, 1, 7, 0.8, 0.6) - for t in simulation_df[TIME]] +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 7, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=13, brief="Simulation. Species with InitialAssignment overridden by " - "parameter.", + "parameter.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/sbml/0014/0014.py b/petabtests/cases/v2.0.0/sbml/0014/0014.py index c2e497f..340489c 100644 --- a/petabtests/cases/v2.0.0/sbml/0014/0014.py +++ b/petabtests/cases/v2.0.0/sbml/0014/0014.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['0.5;2', '0.5;2'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["0.5;2", "0.5;2"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a + noiseParameter2_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a + noiseParameter2_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=14, diff --git a/petabtests/cases/v2.0.0/sbml/0015/0015.py b/petabtests/cases/v2.0.0/sbml/0015/0015.py index 7b767a3..6efdec7 100644 --- a/petabtests/cases/v2.0.0/sbml/0015/0015.py +++ b/petabtests/cases/v2.0.0/sbml/0015/0015.py @@ -18,39 +18,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['noise', 'noise'] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["noise", "noise"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'noise'], - PARAMETER_SCALE: [LIN] * 5, - LOWER_BOUND: [0] * 5, - UPPER_BOUND: [10] * 5, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], - ESTIMATE: [1] * 5, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "noise"], + PARAMETER_SCALE: [LIN] * 5, + LOWER_BOUND: [0] * 5, + UPPER_BOUND: [10] * 5, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], + ESTIMATE: [1] * 5, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=15, diff --git a/petabtests/cases/v2.0.0/sbml/0016/0016.py b/petabtests/cases/v2.0.0/sbml/0016/0016.py index e520636..e3b7992 100644 --- a/petabtests/cases/v2.0.0/sbml/0016/0016.py +++ b/petabtests/cases/v2.0.0/sbml/0016/0016.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -22,37 +26,46 @@ """) # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [10, 10], - MEASUREMENT: [0.2, 0.8] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [10, 10], + MEASUREMENT: [0.2, 0.8], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - OBSERVABLE_TRANSFORMATION: [LIN, LOG], - NOISE_FORMULA: [0.5, 0.7] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + OBSERVABLE_TRANSFORMATION: [LIN, LOG], + NOISE_FORMULA: [0.5, 0.7], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) simulation_df[SIMULATION] = [ analytical_a(10, 1, 0, 0.8, 0.6), analytical_b(10, 1, 0, 0.8, 0.6), diff --git a/petabtests/cases/v2.0.0/sbml/0017/0017.py b/petabtests/cases/v2.0.0/sbml/0017/0017.py index 7b97b6e..3209701 100644 --- a/petabtests/cases/v2.0.0/sbml/0017/0017.py +++ b/petabtests/cases/v2.0.0/sbml/0017/0017.py @@ -3,8 +3,12 @@ import pandas as pd from petab.C import * -from petabtests import (DEFAULT_SBML_FILE, PetabTestCase, analytical_a, - analytical_b) +from petabtests import ( + DEFAULT_SBML_FILE, + PetabTestCase, + analytical_a, + analytical_b, +) DESCRIPTION = cleandoc(""" ## Objective @@ -29,51 +33,60 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [2.0, 'NaN'], - 'A': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0', 'preeq_c0'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [1, 10], - MEASUREMENT: [0.7, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [2.0, "NaN"], + "A": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0", "preeq_c0"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [1, 10], + MEASUREMENT: [0.7, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_b = analytical_b(1000, 0, 2.0, 0.3, 0.6) # use steady state as initial state simulation_df[SIMULATION] = [ - analytical_a(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]] + analytical_a(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=17, brief="Simulation. Preequilibration. One species reinitialized, one not " - "(NaN in condition table). InitialAssignment to species overridden.", + "(NaN in condition table). InitialAssignment to species overridden.", description=DESCRIPTION, model=DEFAULT_SBML_FILE, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/sbml/0018/0018.py b/petabtests/cases/v2.0.0/sbml/0018/0018.py index c00613e..680957a 100644 --- a/petabtests/cases/v2.0.0/sbml/0018/0018.py +++ b/petabtests/cases/v2.0.0/sbml/0018/0018.py @@ -33,6 +33,7 @@ def get_model(): import simplesbml + model = simplesbml.SbmlModel() model.addParameter("a0", 1) model.addParameter("b0", 1) @@ -52,57 +53,66 @@ def get_model(): f.write(get_model().toSBML()) -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['preeq_c0', 'c0'], - 'k1': [0.3, 0.8], - 'B': [2.0, 'NaN'], - 'A': [0, 1], -}).set_index([CONDITION_ID]) - -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'] * 3 + ['obs_b'], - PREEQUILIBRATION_CONDITION_ID: ['preeq_c0'] * 4, - SIMULATION_CONDITION_ID: ['c0'] * 4, - TIME: [0, 1, 10, 0], - MEASUREMENT: [0.1, 0.7, 0.1, 0.1] -}) - -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_b'], - OBSERVABLE_FORMULA: ['A', 'B'], - NOISE_FORMULA: [0.5, 0.2] -}).set_index([OBSERVABLE_ID]) - -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k2'], - PARAMETER_SCALE: [LIN], - LOWER_BOUND: [0], - UPPER_BOUND: [10], - NOMINAL_VALUE: [0.6], - ESTIMATE: [1], -}).set_index(PARAMETER_ID) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["preeq_c0", "c0"], + "k1": [0.3, 0.8], + "B": [2.0, "NaN"], + "A": [0, 1], + } +).set_index([CONDITION_ID]) + +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"] * 3 + ["obs_b"], + PREEQUILIBRATION_CONDITION_ID: ["preeq_c0"] * 4, + SIMULATION_CONDITION_ID: ["c0"] * 4, + TIME: [0, 1, 10, 0], + MEASUREMENT: [0.1, 0.7, 0.1, 0.1], + } +) + +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_b"], + OBSERVABLE_FORMULA: ["A", "B"], + NOISE_FORMULA: [0.5, 0.2], + } +).set_index([OBSERVABLE_ID]) + +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k2"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0], + UPPER_BOUND: [10], + NOMINAL_VALUE: [0.6], + ESTIMATE: [1], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) + columns={MEASUREMENT: SIMULATION} +) # simulate for far time point as steady state steady_state_b = analytical_b(1000, 0, 2.0, 0.3, 0.6) # use steady state as initial state simulation_df.iloc[:3, simulation_df.columns.get_loc(SIMULATION)] = [ - analytical_a(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]][:3] + analytical_a(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +][:3] simulation_df.iloc[3:, simulation_df.columns.get_loc(SIMULATION)] = [ - analytical_b(t, 1, steady_state_b, 0.8, 0.6) - for t in simulation_df[TIME]][3:] + analytical_b(t, 1, steady_state_b, 0.8, 0.6) for t in simulation_df[TIME] +][3:] case = PetabTestCase( id=18, brief="Simulation. Preequilibration and RateRules. One state " - "reinitialized, one not (NaN in condition table). InitialAssignment " - "to species overridden.", + "reinitialized, one not (NaN in condition table). InitialAssignment " + "to species overridden.", description=DESCRIPTION, model=model, condition_dfs=[condition_df], diff --git a/petabtests/cases/v2.0.0/sbml/0019/0019.py b/petabtests/cases/v2.0.0/sbml/0019/0019.py index 035ef5c..8a0a837 100644 --- a/petabtests/cases/v2.0.0/sbml/0019/0019.py +++ b/petabtests/cases/v2.0.0/sbml/0019/0019.py @@ -18,46 +18,62 @@ # problem -------------------------------------------------------------------- # TODO use mapping here -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['maps_to_A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["maps_to_A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'maps_to_b0', 'k1', 'maps_to_k2'], - PARAMETER_SCALE: [LIN] * 4, - LOWER_BOUND: [0] * 4, - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [1, 0, 0.8, 0.6], - ESTIMATE: [1] * 4, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "maps_to_b0", "k1", "maps_to_k2"], + PARAMETER_SCALE: [LIN] * 4, + LOWER_BOUND: [0] * 4, + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [1, 0, 0.8, 0.6], + ESTIMATE: [1] * 4, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] -mapping_df = pd.DataFrame(data={ - PETAB_ENTITY_ID: - ['maps_to_a0', 'maps_to_b0', 'maps_to_k1', - 'maps_to_k2', 'maps_to_A', 'maps_to_B'], - MODEL_ENTITY_ID: - ['a0', 'b0', 'k1', 'k2', 'A', 'B'], -}).set_index(PETAB_ENTITY_ID) +mapping_df = pd.DataFrame( + data={ + PETAB_ENTITY_ID: [ + "maps_to_a0", + "maps_to_b0", + "maps_to_k1", + "maps_to_k2", + "maps_to_A", + "maps_to_B", + ], + MODEL_ENTITY_ID: ["a0", "b0", "k1", "k2", "A", "B"], + } +).set_index(PETAB_ENTITY_ID) case = PetabTestCase( id=19, diff --git a/petabtests/cases/v2.0.0/sbml/0020/0020.py b/petabtests/cases/v2.0.0/sbml/0020/0020.py index 75581c9..ba48e2e 100644 --- a/petabtests/cases/v2.0.0/sbml/0020/0020.py +++ b/petabtests/cases/v2.0.0/sbml/0020/0020.py @@ -21,46 +21,56 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], - 'A': ["initial_A"], - 'B': ["initial_B"], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + "A": ["initial_A"], + "B": ["initial_B"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1] -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: [0.5] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: [0.5], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['k1', 'k2', 'initial_A', 'initial_B'], - PARAMETER_SCALE: [LIN, LIN, LOG10, LIN], - LOWER_BOUND: [0, 0, 1, 0], - UPPER_BOUND: [10] * 4, - NOMINAL_VALUE: [0.8, 0.6, 2, 3], - ESTIMATE: [1] * 3 + [0], -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["k1", "k2", "initial_A", "initial_B"], + PARAMETER_SCALE: [LIN, LIN, LOG10, LIN], + LOWER_BOUND: [0, 0, 1, 0], + UPPER_BOUND: [10] * 4, + NOMINAL_VALUE: [0.8, 0.6, 2, 3], + ESTIMATE: [1] * 3 + [0], + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 2, 3, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 2, 3, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( id=20, brief="Simulation. Estimated initial value via conditions table.", description=DESCRIPTION, - model='conversion_modified.xml', + model="conversion_modified.xml", condition_dfs=[condition_df], observable_dfs=[observable_df], measurement_dfs=[measurement_df], diff --git a/petabtests/cases/v2.0.0/sbml/0021/0021.py b/petabtests/cases/v2.0.0/sbml/0021/0021.py index eda59d6..fb04019 100644 --- a/petabtests/cases/v2.0.0/sbml/0021/0021.py +++ b/petabtests/cases/v2.0.0/sbml/0021/0021.py @@ -19,39 +19,49 @@ # problem -------------------------------------------------------------------- -condition_df = pd.DataFrame(data={ - CONDITION_ID: ['c0'], -}).set_index([CONDITION_ID]) +condition_df = pd.DataFrame( + data={ + CONDITION_ID: ["c0"], + } +).set_index([CONDITION_ID]) -measurement_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c0'], - TIME: [0, 10], - MEASUREMENT: [0.7, 0.1], - NOISE_PARAMETERS: ['noise', 'noise'], -}) +measurement_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c0"], + TIME: [0, 10], + MEASUREMENT: [0.7, 0.1], + NOISE_PARAMETERS: ["noise", "noise"], + } +) -observable_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a'], - OBSERVABLE_FORMULA: ['A'], - NOISE_FORMULA: ['noiseParameter1_obs_a * obs_a'] -}).set_index([OBSERVABLE_ID]) +observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a"], + OBSERVABLE_FORMULA: ["A"], + NOISE_FORMULA: ["noiseParameter1_obs_a * obs_a"], + } +).set_index([OBSERVABLE_ID]) -parameter_df = pd.DataFrame(data={ - PARAMETER_ID: ['a0', 'b0', 'k1', 'k2', 'noise'], - PARAMETER_SCALE: [LIN] * 5, - LOWER_BOUND: [0] * 5, - UPPER_BOUND: [10] * 5, - NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], - ESTIMATE: [1] * 5, -}).set_index(PARAMETER_ID) +parameter_df = pd.DataFrame( + data={ + PARAMETER_ID: ["a0", "b0", "k1", "k2", "noise"], + PARAMETER_SCALE: [LIN] * 5, + LOWER_BOUND: [0] * 5, + UPPER_BOUND: [10] * 5, + NOMINAL_VALUE: [1, 0, 0.8, 0.6, 5], + ESTIMATE: [1] * 5, + } +).set_index(PARAMETER_ID) # solutions ------------------------------------------------------------------ simulation_df = measurement_df.copy(deep=True).rename( - columns={MEASUREMENT: SIMULATION}) -simulation_df[SIMULATION] = [analytical_a(t, 1, 0, 0.8, 0.6) - for t in simulation_df[TIME]] + columns={MEASUREMENT: SIMULATION} +) +simulation_df[SIMULATION] = [ + analytical_a(t, 1, 0, 0.8, 0.6) for t in simulation_df[TIME] +] case = PetabTestCase( diff --git a/petabtests/conversion_pysb.py b/petabtests/conversion_pysb.py index 57ec588..71263df 100644 --- a/petabtests/conversion_pysb.py +++ b/petabtests/conversion_pysb.py @@ -1,18 +1,26 @@ -from pysb import Model, Monomer, Parameter, Compartment, Rule, Initial, Observable +from pysb import ( + Model, + Monomer, + Parameter, + Compartment, + Rule, + Initial, + Observable, +) Model() -Compartment('compartment') +Compartment("compartment") -Monomer('A_') -Monomer('B_') +Monomer("A_") +Monomer("B_") -Parameter('a0', 1.0) -Parameter('b0', 1.0) -Parameter('k1', 0.0) -Parameter('k2', 0.0) +Parameter("a0", 1.0) +Parameter("b0", 1.0) +Parameter("k1", 0.0) +Parameter("k2", 0.0) -Rule('conversion', A_() ** compartment | B_() ** compartment, k1, k2) +Rule("conversion", A_() ** compartment | B_() ** compartment, k1, k2) Initial(A_() ** compartment, a0) Initial(B_() ** compartment, b0) diff --git a/petabtests/core.py b/petabtests/core.py index 2d539ad..bff187c 100644 --- a/petabtests/core.py +++ b/petabtests/core.py @@ -9,13 +9,19 @@ from petab.calculate import calculate_chi2, calculate_llh from .C import CASES_DIR -from .file import (PetabTestCase, get_case_dir, test_id_str, write_info, - write_problem, write_solution) +from .file import ( + PetabTestCase, + get_case_dir, + test_id_str, + write_info, + write_problem, + write_solution, +) -__all__ = ['get_cases', 'create', 'clear', 'get_cases_dir'] +__all__ = ["get_cases", "create", "clear", "get_cases_dir"] -test_formats = ('sbml', 'pysb') -test_versions = ('v1.0.0', "v2.0.0") +test_formats = ("sbml", "pysb") +test_versions = ("v1.0.0", "v2.0.0") logger = logging.getLogger("petab_test_suite") @@ -28,9 +34,11 @@ def get_cases(format_: str, version: str): cases_dir = get_cases_dir(format_=format_, version=version) if not cases_dir.exists(): return [] - return sorted(f.name for f in os.scandir(cases_dir) - if f.is_dir() - and re.match(r'^\d+$', f.name)) + return sorted( + f.name + for f in os.scandir(cases_dir) + if f.is_dir() and re.match(r"^\d+$", f.name) + ) def create(): @@ -43,9 +51,10 @@ def create(): toc = "" for case_id in case_list: - case_dir = get_case_dir(format_=format_, version=version, - id_=case_id) - logger.info('# ', format_, version, case_id, case_dir) + case_dir = get_case_dir( + format_=format_, version=version, id_=case_id + ) + logger.info("# ", format_, version, case_id, case_dir) # load test case module # directory needs to be removed from path again and the module @@ -72,16 +81,20 @@ def create(): model_files=case.model, format_=format_, version=version, - mapping_df=case.mapping_df + mapping_df=case.mapping_df, ) chi2 = calculate_chi2( - case.measurement_dfs, case.simulation_dfs, case.observable_dfs, - case.parameter_df + case.measurement_dfs, + case.simulation_dfs, + case.observable_dfs, + case.parameter_df, ) llh = calculate_llh( - case.measurement_dfs, case.simulation_dfs, case.observable_dfs, - case.parameter_df + case.measurement_dfs, + case.simulation_dfs, + case.observable_dfs, + case.parameter_df, ) write_solution( test_id=case.id, @@ -92,8 +105,9 @@ def create(): version=version, ) - toc_path = get_cases_dir(format_=format_, version=version) \ - / "README.md" + toc_path = ( + get_cases_dir(format_=format_, version=version) / "README.md" + ) with open(toc_path, "w") as f: f.write(toc) @@ -104,9 +118,10 @@ def clear(): case_list = get_cases(format_=format_, version=version) for case_id in case_list: - case_dir = get_case_dir(format_=format_, version=version, - id_=case_id) + case_dir = get_case_dir( + format_=format_, version=version, id_=case_id + ) for file_ in os.scandir(case_dir): - if file_.name.startswith('_') and not file_.is_dir(): + if file_.name.startswith("_") and not file_.is_dir(): os.remove(file_.path) diff --git a/petabtests/evaluate.py b/petabtests/evaluate.py index 5cc1288..2c637d1 100644 --- a/petabtests/evaluate.py +++ b/petabtests/evaluate.py @@ -1,13 +1,16 @@ -from typing import List, Union import numpy as np import pandas as pd from petab.C import * from .C import * # noqa: F403 -__all__ = ['evaluate_llh', 'evaluate_chi2', 'evaluate_simulations', - 'absolute_simulations_distance_for_tables', - 'absolute_simulations_distance_for_array', - 'absolute_simulations_distance_for_table'] +__all__ = [ + "evaluate_llh", + "evaluate_chi2", + "evaluate_simulations", + "absolute_simulations_distance_for_tables", + "absolute_simulations_distance_for_array", + "absolute_simulations_distance_for_table", +] def evaluate_chi2(chi2: float, gt_chi2: float, tol: float = 1e-3): @@ -25,17 +28,23 @@ def evaluate_llh(llh: float, gt_llh: float, tol: float = 1e-3): def evaluate_simulations( - simulation_dfs: Union[List[pd.DataFrame], pd.DataFrame], - gt_simulation_dfs: Union[List[pd.DataFrame], pd.DataFrame], - tol: float = 1e-3): + simulation_dfs: list[pd.DataFrame] | pd.DataFrame, + gt_simulation_dfs: list[pd.DataFrame] | pd.DataFrame, + tol: float = 1e-3, +): """Evaluate whether simulations match.""" - return absolute_simulations_distance_for_tables( - simulation_dfs, gt_simulation_dfs) < tol + return ( + absolute_simulations_distance_for_tables( + simulation_dfs, gt_simulation_dfs + ) + < tol + ) def absolute_simulations_distance_for_tables( - simulation_dfs: Union[List[pd.DataFrame], pd.DataFrame], - gt_simulation_dfs: Union[List[pd.DataFrame], pd.DataFrame]): + simulation_dfs: list[pd.DataFrame] | pd.DataFrame, + gt_simulation_dfs: list[pd.DataFrame] | pd.DataFrame, +): """Compute absolute normalized distance between simulations. Parameters @@ -55,9 +64,11 @@ def absolute_simulations_distance_for_tables( distances = [] for simulation_df, gt_simulation_df in zip( - simulation_dfs, gt_simulation_dfs): + simulation_dfs, gt_simulation_dfs + ): distance = absolute_simulations_distance_for_table( - simulation_df, gt_simulation_df) + simulation_df, gt_simulation_df + ) distances.append(distance) distance = sum(distances) / len(distances) @@ -65,8 +76,8 @@ def absolute_simulations_distance_for_tables( def absolute_simulations_distance_for_table( - simulations: pd.DataFrame, - gt_simulations: pd.DataFrame): + simulations: pd.DataFrame, gt_simulations: pd.DataFrame +): """Compute absolute normalized distance between simulations.""" # grouping columns grouping_cols = [OBSERVABLE_ID, SIMULATION_CONDITION_ID, TIME] @@ -95,17 +106,16 @@ def absolute_simulations_distance_for_table( vals, gt_vals = vals.astype(str), gt_vals.astype(str) matches = (vals == gt_vals).all() if not matches: - raise AssertionError( - "Simulation dataframes do not match.") + raise AssertionError("Simulation dataframes do not match.") # compute distance return absolute_simulations_distance_for_array( - np.array(simulations[SIMULATION]), - np.array(gt_simulations[SIMULATION])) + np.array(simulations[SIMULATION]), np.array(gt_simulations[SIMULATION]) + ) def absolute_simulations_distance_for_array( - simulations: np.ndarray, - gt_simulations: np.ndarray): + simulations: np.ndarray, gt_simulations: np.ndarray +): """Compute absolute normalized distance between simulations.""" return np.abs(simulations - gt_simulations).sum() / len(simulations) diff --git a/petabtests/file.py b/petabtests/file.py index 4ad0c55..e66c0be 100644 --- a/petabtests/file.py +++ b/petabtests/file.py @@ -1,8 +1,9 @@ """File input and output.""" + import os from dataclasses import dataclass from shutil import copyfile -from typing import Callable, List, Union +from collections.abc import Callable import pandas as pd import petab @@ -11,43 +12,50 @@ from .C import * # noqa: F403 __all__ = [ - 'get_case_dir', 'load_solution', 'PetabTestCase', 'problem_yaml_name', - 'solution_yaml_name', 'test_id_str', 'write_info', 'write_problem', - 'write_solution' + "get_case_dir", + "load_solution", + "PetabTestCase", + "problem_yaml_name", + "solution_yaml_name", + "test_id_str", + "write_info", + "write_problem", + "write_solution", ] @dataclass class PetabTestCase: """A PEtab test case""" + id: int brief: str description: str model: Path - condition_dfs: List[pd.DataFrame] - observable_dfs: List[pd.DataFrame] - measurement_dfs: List[pd.DataFrame] - simulation_dfs: List[pd.DataFrame] + condition_dfs: list[pd.DataFrame] + observable_dfs: list[pd.DataFrame] + measurement_dfs: list[pd.DataFrame] + simulation_dfs: list[pd.DataFrame] parameter_df: pd.DataFrame mapping_df: pd.DataFrame = None -def get_case_dir(id_: Union[int, str], format_: str, version: str) -> Path: +def get_case_dir(id_: int | str, format_: str, version: str) -> Path: id_str = test_id_str(id_) dir_ = CASES_DIR / version / format_ / id_str dir_.mkdir(parents=True, exist_ok=True) return dir_ -def problem_yaml_name(_id: Union[int, str]) -> str: - return '_' + test_id_str(_id) + '.yaml' +def problem_yaml_name(_id: int | str) -> str: + return "_" + test_id_str(_id) + ".yaml" -def solution_yaml_name(_id: Union[int, str]) -> str: - return '_' + test_id_str(_id) + '_solution.yaml' +def solution_yaml_name(_id: int | str) -> str: + return "_" + test_id_str(_id) + "_solution.yaml" -def test_id_str(_id: Union[int, str]) -> str: +def test_id_str(_id: int | str) -> str: return f"{_id:0>4}" @@ -64,15 +72,15 @@ def write_info(case: PetabTestCase, format_: str, version: str): def write_problem( - test_id: int, - parameter_df: pd.DataFrame, - condition_dfs: Union[List[pd.DataFrame], pd.DataFrame], - observable_dfs: Union[List[pd.DataFrame], pd.DataFrame], - measurement_dfs: Union[List[pd.DataFrame], pd.DataFrame], - model_files: Union[List[Path], Path], - version: str, - mapping_df: pd.DataFrame = None, - format_: str = 'sbml' + test_id: int, + parameter_df: pd.DataFrame, + condition_dfs: list[pd.DataFrame] | pd.DataFrame, + observable_dfs: list[pd.DataFrame] | pd.DataFrame, + measurement_dfs: list[pd.DataFrame] | pd.DataFrame, + model_files: list[Path] | Path, + version: str, + mapping_df: pd.DataFrame = None, + format_: str = "sbml", ) -> None: """Write problem to files. @@ -96,7 +104,7 @@ def write_problem( observable_dfs = [observable_dfs] if isinstance(measurement_dfs, pd.DataFrame): measurement_dfs = [measurement_dfs] - if isinstance(model_files, (str, Path)): + if isinstance(model_files, str | Path): model_files = [model_files] # id to string @@ -117,23 +125,25 @@ def write_problem( MEASUREMENT_FILES: [], OBSERVABLE_FILES: [], }, - ] + ], } - if format_ == 'sbml': - suffix = '.xml' + if format_ == "sbml": + suffix = ".xml" else: - suffix = '.py' + suffix = ".py" # copy models copied_model_files = [] for i_sbml, model_file in enumerate(model_files): if len(model_files) == 1: - copied_model_file = f'_model{suffix}' + copied_model_file = f"_model{suffix}" else: - copied_model_file = f'_model{i_sbml}{suffix}' - copyfile(os.path.join(dir_, model_file), - os.path.join(dir_, copied_model_file)) + copied_model_file = f"_model{i_sbml}{suffix}" + copyfile( + os.path.join(dir_, model_file), + os.path.join(dir_, copied_model_file), + ) copied_model_files.append(copied_model_file) if version == "v1.0.0": @@ -141,37 +151,47 @@ def write_problem( else: config[PROBLEMS][0][MODEL_FILES] = {} for model_idx, model_file in enumerate(copied_model_files): - config[PROBLEMS][0][MODEL_FILES][f'model_{model_idx}'] = { + config[PROBLEMS][0][MODEL_FILES][f"model_{model_idx}"] = { MODEL_LANGUAGE: format_, MODEL_LOCATION: model_file, } # write parameters - parameters_file = '_parameters.tsv' - petab.write_parameter_df(parameter_df, - os.path.join(dir_, parameters_file)) + parameters_file = "_parameters.tsv" + petab.write_parameter_df(parameter_df, os.path.join(dir_, parameters_file)) config[PARAMETER_FILE] = parameters_file # write conditions - _write_dfs_to_files(dir_, 'conditions', - petab.write_condition_df, condition_dfs, - config[PROBLEMS][0][CONDITION_FILES]) + _write_dfs_to_files( + dir_, + "conditions", + petab.write_condition_df, + condition_dfs, + config[PROBLEMS][0][CONDITION_FILES], + ) # write observables - _write_dfs_to_files(dir_, 'observables', - petab.write_observable_df, observable_dfs, - config[PROBLEMS][0][OBSERVABLE_FILES]) + _write_dfs_to_files( + dir_, + "observables", + petab.write_observable_df, + observable_dfs, + config[PROBLEMS][0][OBSERVABLE_FILES], + ) # write measurements - _write_dfs_to_files(dir_, 'measurements', - petab.write_measurement_df, measurement_dfs, - config[PROBLEMS][0][MEASUREMENT_FILES]) + _write_dfs_to_files( + dir_, + "measurements", + petab.write_measurement_df, + measurement_dfs, + config[PROBLEMS][0][MEASUREMENT_FILES], + ) if format_version != 1 and mapping_df is not None: # write mapping table - mappings_file = '_mapping.tsv' - petab.write_mapping_df(mapping_df, - os.path.join(dir_, mappings_file)) + mappings_file = "_mapping.tsv" + petab.write_mapping_df(mapping_df, os.path.join(dir_, mappings_file)) config[PROBLEMS][0][MAPPING_FILES] = [mappings_file] # validate petab yaml @@ -180,7 +200,7 @@ def write_problem( # write yaml yaml_file = problem_yaml_name(test_id) yaml_path = os.path.join(dir_, yaml_file) - with open(yaml_path, 'w') as outfile: + with open(yaml_path, "w") as outfile: yaml.dump(config, outfile, default_flow_style=False) # FIXME Until a first libpetab with petab.v1 subpackage is released @@ -213,15 +233,15 @@ def write_problem( def write_solution( - test_id: int, - simulation_dfs: Union[List[pd.DataFrame], pd.DataFrame], - chi2: float, - llh: float, - version: str, - format_: str = 'sbml', - tol_simulations: float = 1e-3, - tol_chi2: float = 1e-3, - tol_llh: float = 1e-3 + test_id: int, + simulation_dfs: list[pd.DataFrame] | pd.DataFrame, + chi2: float, + llh: float, + version: str, + format_: str = "sbml", + tol_simulations: float = 1e-3, + tol_chi2: float = 1e-3, + tol_llh: float = 1e-3, ): """Write solution to files. @@ -250,34 +270,42 @@ def write_solution( LLH: round(float(llh), 14), TOL_SIMULATIONS: float(tol_simulations), TOL_CHI2: float(tol_chi2), - TOL_LLH: float(tol_llh) + TOL_LLH: float(tol_llh), } # write simulations - _write_dfs_to_files(dir_, "simulations", - petab.write_measurement_df, simulation_dfs, - config[SIMULATION_FILES]) + _write_dfs_to_files( + dir_, + "simulations", + petab.write_measurement_df, + simulation_dfs, + config[SIMULATION_FILES], + ) # write yaml yaml_file = solution_yaml_name(test_id) - with open(os.path.join(dir_, yaml_file), 'w') as outfile: + with open(os.path.join(dir_, yaml_file), "w") as outfile: yaml.dump(config, outfile, default_flow_style=False) def _write_dfs_to_files( - dir_: Union[Path, str], name: str, writer: Callable, - dfs: List[pd.DataFrame], config_list: List[str] = None): + dir_: Path | str, + name: str, + writer: Callable, + dfs: list[pd.DataFrame], + config_list: list[str] = None, +): """Write data frames to files and add them to config.""" for idx, df in enumerate(dfs): if len(dfs) == 1: - idx = '' + idx = "" fname = f"_{name}{idx}.tsv" writer(df, Path(dir_, fname)) if config_list is not None: config_list.append(fname) -def load_solution(test_id: Union[int, str], format: str, version: str): +def load_solution(test_id: int | str, format: str, version: str): dir_ = get_case_dir(test_id, format, version=version) # load yaml @@ -287,8 +315,9 @@ def load_solution(test_id: Union[int, str], format: str, version: str): # load data simulation_dfs = [ - pd.read_csv(os.path.join(dir_, simulation_file), sep='\t') - for simulation_file in config[SIMULATION_FILES]] + pd.read_csv(os.path.join(dir_, simulation_file), sep="\t") + for simulation_file in config[SIMULATION_FILES] + ] config.pop(SIMULATION_FILES) config[SIMULATION_DFS] = simulation_dfs diff --git a/petabtests/model.py b/petabtests/model.py index 5330f51..f093ee1 100644 --- a/petabtests/model.py +++ b/petabtests/model.py @@ -9,10 +9,12 @@ def analytical_a(t, a0=a0, b0=b0, k1=k1, k2=k2): - return k2 * (a0 + b0) / (k1 + k2) \ - + (a0 - k2 * (a0 + b0) / (k1 + k2)) * np.exp(-(k1 + k2) * t) + return k2 * (a0 + b0) / (k1 + k2) + ( + a0 - k2 * (a0 + b0) / (k1 + k2) + ) * np.exp(-(k1 + k2) * t) def analytical_b(t, a0=a0, b0=b0, k1=k1, k2=k2): - return k1 * (a0 + b0) / (k1 + k2) \ - + (b0 - k1 * (a0 + b0) / (k1 + k2)) * np.exp(-(k1 + k2) * t) + return k1 * (a0 + b0) / (k1 + k2) + ( + b0 - k1 * (a0 + b0) / (k1 + k2) + ) * np.exp(-(k1 + k2) * t) diff --git a/petabtests/version.py b/petabtests/version.py index d18f409..3b93d0b 100644 --- a/petabtests/version.py +++ b/petabtests/version.py @@ -1 +1 @@ -__version__ = '0.0.2' +__version__ = "0.0.2" diff --git a/pyproject.toml b/pyproject.toml index 89d2672..37416e7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,3 +39,23 @@ homepage = "https://github.com/PEtab-dev/petab_test_suite" [project.scripts] petabtests_create = "petabtests.core:create" petabtests_clear = "petabtests.core:clear" + + +[tool.ruff] +line-length = 79 +extend-include = ["*.ipynb"] + +[tool.ruff.lint] +extend-select = [ + "B028", + "UP", # pyupgrade +] +ignore = ["E402", "F403", "F405", "E741"] +exclude = ["petabtests/cases/**/*.md", "cases/**"] + +[tool.ruff.lint.per-file-ignores] +"petabtests/cases/v2.0.0/pysb/*/_model.py" = ["F821"] +"petabtests/cases/v2.0.0/pysb/*/conversion_modified_pysb.py" = ["F821"] +"petabtests/conversion_*pysb.py" = ["F821"] + +# add UP rules for ruff via extend-select diff --git a/setup.py b/setup.py index f4e5f62..2f0244a 100644 --- a/setup.py +++ b/setup.py @@ -7,20 +7,20 @@ def read(fname): - with open(fname, encoding='utf-8') as f: + with open(fname, encoding="utf-8") as f: return f.read() # Get the long description from the README file -long_description = read(path.join(here, 'README.md')) +long_description = read(path.join(here, "README.md")) # Get the version -exec(read(path.join(here, 'petabtests', 'version.py'))) +exec(read(path.join(here, "petabtests", "version.py"))) setup( version=__version__, # noqa: F821 long_description=long_description, - long_description_content_type='text/markdown', + long_description_content_type="text/markdown", packages=find_namespace_packages(), include_package_data=True, ) diff --git a/test/test_evaluate.py b/test/test_evaluate.py index 5bceb23..c23ddc6 100644 --- a/test/test_evaluate.py +++ b/test/test_evaluate.py @@ -14,27 +14,33 @@ def test_evaluate_llh(): def test_evaluate_simulations(): - simulations_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [0, 10], - SIMULATION: [0.7, 0.1] - }) - - gt_simulations_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [0, 10], - SIMULATION: [0.700001, 0.099999] - }) + simulations_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [0, 10], + SIMULATION: [0.7, 0.1], + } + ) + + gt_simulations_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [0, 10], + SIMULATION: [0.700001, 0.099999], + } + ) assert evaluate_simulations(simulations_df, gt_simulations_df) - gt_simulations_df = pd.DataFrame(data={ - OBSERVABLE_ID: ['obs_a', 'obs_a'], - SIMULATION_CONDITION_ID: ['c0', 'c1'], - TIME: [0, 10], - SIMULATION: [0.71, 0.099999] - }) + gt_simulations_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs_a", "obs_a"], + SIMULATION_CONDITION_ID: ["c0", "c1"], + TIME: [0, 10], + SIMULATION: [0.71, 0.099999], + } + ) assert not evaluate_simulations(simulations_df, gt_simulations_df) diff --git a/test/test_generate.py b/test/test_generate.py index 5ec5f1a..40238be 100644 --- a/test/test_generate.py +++ b/test/test_generate.py @@ -8,7 +8,8 @@ def test_check_cases_up_to_date(): sys.path.insert(0, CASES_DIR) create() - res = subprocess.run(['git', 'diff', '--exit-code', CASES_DIR], - capture_output=True) + res = subprocess.run( + ["git", "diff", "--exit-code", CASES_DIR], capture_output=True + ) has_changes = res.returncode assert not has_changes, res.stdout.decode()