diff --git a/changelog.d/+placeholders-own-observable.breaking.md b/changelog.d/+placeholders-own-observable.breaking.md new file mode 100644 index 00000000..bdaea7f3 --- /dev/null +++ b/changelog.d/+placeholders-own-observable.breaking.md @@ -0,0 +1,8 @@ +PEtab v1 validation: `lint_problem` now reports an error for placeholder +parameters that are model entities, condition table columns, mapping table +entries or observable IDs, or that are used in another observable, the +condition table or the measurement table, and for noise placeholders used in +the observable formula +(new `assert_placeholders_only_used_in_own_observable`). +As `petab1to2` validates its input, it now rejects such problems +([#605](https://github.com/PEtab-dev/libpetab-python/pull/605)) diff --git a/doc/example/example_Fujita/Fujita_model.xml b/doc/example/example_Fujita/Fujita_model.xml index 0b1a6d60..804ffd1c 100644 --- a/doc/example/example_Fujita/Fujita_model.xml +++ b/doc/example/example_Fujita/Fujita_model.xml @@ -39,18 +39,6 @@ - - - - - - - - - - - - @@ -70,58 +58,6 @@ - - - - noiseParameter1_pAkt_tot - - - - - noiseParameter1_pEGFR_tot - - - - - noiseParameter1_pS6_tot - - - - - - - observableParameter1_pEGFR_tot - - - pEGFR - pEGFR_Akt - - - - - - - - - observableParameter1_pAkt_tot - - - pAkt - pAkt_S6 - - - - - - - - - pS6 - observableParameter1_pS6_tot - - - - diff --git a/petab/v1/lint.py b/petab/v1/lint.py index d723f4a2..9d142af8 100644 --- a/petab/v1/lint.py +++ b/petab/v1/lint.py @@ -4,7 +4,7 @@ import logging import numbers import re -from collections import Counter +from collections import Counter, defaultdict from collections.abc import Iterable from typing import Any @@ -35,6 +35,7 @@ "assert_parameter_prior_parameters_are_valid", "assert_parameter_prior_type_is_valid", "assert_parameter_scale_is_valid", + "assert_placeholders_only_used_in_own_observable", "assert_unique_observable_ids", "assert_unique_parameter_ids", "check_condition_df", @@ -349,6 +350,111 @@ def check_observable_df(observable_df: pd.DataFrame) -> None: ) from e +def assert_placeholders_only_used_in_own_observable( + problem: "petab.Problem", +) -> None: + """Check that placeholders are not defined or used elsewhere. + + Placeholder parameters are overridden per measurement. A model entity, + a condition table column, a mapping table entry, or an observable with + the same ID conflicts with that, as does the use of the placeholder in + another observable, the condition table, or the measurement table. + Noise placeholders must not be used in the observable formula. + Missing tables or a missing model are skipped. + + Arguments: + problem: PEtab problem to check + + Raises: + AssertionError: in case of problems + """ + from .observables import get_formula_placeholders + + if (observable_df := problem.observable_df) is None: + return + model = problem.model + condition_df = problem.condition_df + mapping_df = problem.mapping_df + measurement_df = problem.measurement_df + + def symbols(expression) -> set[str]: + if not isinstance(expression, str): + return set() + return {str(s) for s in sympify_petab(expression).free_symbols} + + # placeholder -> ID of the observable that declares it + placeholders: dict[str, str] = {} + # ID -> (where it is used or defined, observable ID or None) + uses: dict[str, list[tuple[str, str | None]]] = defaultdict(list) + + for observable_id, row in observable_df.iterrows(): + uses[observable_id].append(("observable ID", None)) + formula = row.get(OBSERVABLE_FORMULA) + noise_formula = row.get(NOISE_FORMULA) + formula_symbols = symbols(formula) + for symbol in formula_symbols | symbols(noise_formula): + uses[symbol].append( + (f"used in observable `{observable_id}`", observable_id) + ) + noise_placeholders = get_formula_placeholders( + noise_formula, observable_id, "noise" + ) + for placeholder in ( + get_formula_placeholders(formula, observable_id, "observable") + + noise_placeholders + ): + placeholders[placeholder] = observable_id + for placeholder in formula_symbols.intersection(noise_placeholders): + uses[placeholder].append(("used in the observable formula", None)) + + if condition_df is not None: + for column in condition_df.columns.drop( + CONDITION_NAME, errors="ignore" + ): + uses[column].append(("condition table column", None)) + for value in condition_df[column].unique(): + for symbol in symbols(value): + uses[symbol].append(("used in the condition table", None)) + + if mapping_df is not None: + for petab_id in mapping_df.index: + uses[petab_id].append(("mapping table petabEntityId", None)) + + if measurement_df is not None: + for column in (OBSERVABLE_PARAMETERS, NOISE_PARAMETERS): + if column not in measurement_df: + continue + for value in measurement_df[column].unique(): + for override in measurements.split_parameter_replacement_list( + value + ): + if isinstance(override, str): + uses[override].append( + ("used in the measurement table", None) + ) + + clashes = [] + for placeholder, observable_id in placeholders.items(): + where = [ + use + for use, owner in dict.fromkeys(uses.get(placeholder, [])) + if owner != observable_id + ] + if model is not None and model.has_entity_with_id(placeholder): + where.append("model entity") + if where: + clashes.append( + f"`{placeholder}` of observable `{observable_id}` " + f"({', '.join(where)})" + ) + + if clashes: + raise AssertionError( + "Placeholder parameters must only be used in their own " + "observable: " + "; ".join(clashes) + ) + + def assert_all_parameters_present_in_parameter_df( parameter_df: pd.DataFrame, model: Model, @@ -929,6 +1035,11 @@ def lint_problem(problem: "petab.Problem") -> bool: except AssertionError as e: logger.error(e) errors_occurred = True + try: + assert_placeholders_only_used_in_own_observable(problem) + except AssertionError as e: + logger.error(e) + errors_occurred = True if problem.model is not None: for obs_id in problem.observable_df.index: if problem.model.has_entity_with_id(obs_id): diff --git a/tests/v1/test_lint.py b/tests/v1/test_lint.py index e0b6ae1c..e62b5505 100644 --- a/tests/v1/test_lint.py +++ b/tests/v1/test_lint.py @@ -610,6 +610,166 @@ def test_check_observable_df(): lint.check_observable_df(bad_observable_df) +def _placeholder_problem( + model: str = "species x = 1; k = 1; p = 1", +) -> petab.Problem: + """A valid problem with placeholders of observable `obs1`.""" + from petab.v1.models.sbml_model import SbmlModel + + return petab.Problem( + model=SbmlModel.from_antimony(model), + condition_df=pd.DataFrame( + {CONDITION_ID: ["c1"], "k": [1.0]} + ).set_index(CONDITION_ID), + observable_df=pd.DataFrame( + { + OBSERVABLE_ID: ["obs1"], + OBSERVABLE_FORMULA: ["observableParameter1_obs1 * x"], + NOISE_FORMULA: ["noiseParameter1_obs1"], + } + ).set_index(OBSERVABLE_ID), + measurement_df=pd.DataFrame( + { + OBSERVABLE_ID: ["obs1"], + SIMULATION_CONDITION_ID: ["c1"], + TIME: [1.0], + MEASUREMENT: [1.0], + OBSERVABLE_PARAMETERS: ["2"], + NOISE_PARAMETERS: ["1"], + } + ), + parameter_df=pd.DataFrame( + { + PARAMETER_ID: ["p"], + PARAMETER_SCALE: [LIN], + LOWER_BOUND: [0.0], + UPPER_BOUND: [10.0], + NOMINAL_VALUE: [1.0], + ESTIMATE: [1], + } + ).set_index(PARAMETER_ID), + ) + + +def _set_column(table: str, column: str, value): + """Get a function that sets a column of a table of a problem.""" + + def modify(problem): + getattr(problem, table)[column] = value + + return modify + + +def _add_observable(problem, observable_id, formula): + problem.observable_df.loc[observable_id] = [formula, "1"] + + +@pytest.mark.parametrize( + "modify, expected", + [ + ( + lambda p: setattr( + p, + "model", + _placeholder_problem( + "species x = 1; k = 1; p = 1; noiseParameter1_obs1 = 1" + ).model, + ), + "`noiseParameter1_obs1` of observable `obs1` (model entity)", + ), + ( + _set_column("condition_df", "observableParameter1_obs1", 1.0), + ( + "`observableParameter1_obs1` of observable `obs1` " + "(condition table column)" + ), + ), + ( + lambda p: setattr( + p, + "mapping_df", + pd.DataFrame( + { + PETAB_ENTITY_ID: ["observableParameter1_obs1"], + MODEL_ENTITY_ID: ["k"], + } + ).set_index(PETAB_ENTITY_ID), + ), + ( + "`observableParameter1_obs1` of observable `obs1` " + "(mapping table petabEntityId)" + ), + ), + ( + lambda p: _add_observable(p, "observableParameter1_obs1", "x"), + "`observableParameter1_obs1` of observable `obs1` (observable ID)", + ), + ( + lambda p: _add_observable(p, "obs2", "noiseParameter1_obs1 * x"), + ( + "`noiseParameter1_obs1` of observable `obs1` " + "(used in observable `obs2`)" + ), + ), + ( + _set_column("condition_df", "k", "observableParameter1_obs1 + 1"), + ( + "`observableParameter1_obs1` of observable `obs1` " + "(used in the condition table)" + ), + ), + ( + _set_column( + "measurement_df", NOISE_PARAMETERS, "observableParameter1_obs1" + ), + ( + "`observableParameter1_obs1` of observable `obs1` " + "(used in the measurement table)" + ), + ), + ( + _set_column( + "observable_df", + OBSERVABLE_FORMULA, + "observableParameter1_obs1 * x * noiseParameter1_obs1", + ), + ( + "`noiseParameter1_obs1` of observable `obs1` " + "(used in the observable formula)" + ), + ), + ], +) +def test_assert_placeholders_only_used_in_own_observable(modify, expected): + problem = _placeholder_problem() + lint.assert_placeholders_only_used_in_own_observable(problem) + + modify(problem) + with pytest.raises(AssertionError) as excinfo: + lint.assert_placeholders_only_used_in_own_observable(problem) + assert str(excinfo.value).endswith(expected) + + +def test_assert_placeholders_only_used_in_own_observable_missing_column(): + problem = _placeholder_problem() + problem.observable_df = problem.observable_df.drop(columns=NOISE_FORMULA) + lint.assert_placeholders_only_used_in_own_observable(problem) + + +def test_lint_problem_placeholders_only_used_in_own_observable(): + assert lint.lint_problem(_placeholder_problem()) is False + problem = _placeholder_problem( + "species x = 1; k = 1; p = 1; observableParameter1_obs1 = 1" + ) + with patch.object(lint.logger, "error") as error: + assert lint.lint_problem(problem) is True + assert any( + "`observableParameter1_obs1` of observable `obs1` (model entity)" + in str(call.args[0]) + for call in error.call_args_list + ) + + def test_condition_ids_are_unique(): condition_df = pd.DataFrame( data={