From 6323db48e0c57f2606f659a0cccf908be6b96e04 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 17 Nov 2026 11:17:12 +0100 Subject: [PATCH 1/2] v1 lint: placeholders must not be model entities Placeholder parameters are overridden per measurement. A model entity with the same ID is a second, conflicting definition of the same parameter. Add `assert_placeholders_not_in_model` and run it in `lint_problem`. Remove the leftover placeholder parameters and the unused observable and noise assignment rules from the Fujita example model, which violated this. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 7 +++ doc/example/example_Fujita/Fujita_model.xml | 64 --------------------- petab/v1/lint.py | 35 +++++++++++ tests/v1/test_lint.py | 22 +++++++ 4 files changed, 64 insertions(+), 64 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4f28ff40..36504d6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,13 @@ Changes that are not released yet are collected in +**Fixes** + +v1: +* `lint_problem` now reports an error for placeholder parameters that are + also model entities (new `assert_placeholders_not_in_model`) + (by @dweindl in https://github.com/PEtab-dev/libpetab-python/pull/605) + ## 0.10 series ### 0.10.0 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..2bdc1993 100644 --- a/petab/v1/lint.py +++ b/petab/v1/lint.py @@ -35,6 +35,7 @@ "assert_parameter_prior_parameters_are_valid", "assert_parameter_prior_type_is_valid", "assert_parameter_scale_is_valid", + "assert_placeholders_not_in_model", "assert_unique_observable_ids", "assert_unique_parameter_ids", "check_condition_df", @@ -349,6 +350,33 @@ def check_observable_df(observable_df: pd.DataFrame) -> None: ) from e +def assert_placeholders_not_in_model( + observable_df: pd.DataFrame, model: Model +) -> None: + """Check that no placeholder parameter is a model entity. + + Placeholders are overridden per measurement. A model entity with the + same ID would be a second, conflicting definition. + + Arguments: + observable_df: PEtab observable DataFrame + model: The model + + Raises: + AssertionError: in case of problems + """ + from .observables import get_placeholders + + if clashes := [ + placeholder + for placeholder in get_placeholders(observable_df) + if model.has_entity_with_id(placeholder) + ]: + raise AssertionError( + f"Placeholder parameters must not be model entities: {clashes}" + ) + + def assert_all_parameters_present_in_parameter_df( parameter_df: pd.DataFrame, model: Model, @@ -936,6 +964,13 @@ def lint_problem(problem: "petab.Problem") -> bool: f"Observable ID {obs_id} shadows model entity." ) errors_occurred = True + try: + assert_placeholders_not_in_model( + problem.observable_df, problem.model + ) + except AssertionError as e: + logger.error(e) + errors_occurred = True else: logger.warning("Observable table not available. Skipping.") diff --git a/tests/v1/test_lint.py b/tests/v1/test_lint.py index e0b6ae1c..56bf5474 100644 --- a/tests/v1/test_lint.py +++ b/tests/v1/test_lint.py @@ -610,6 +610,28 @@ def test_check_observable_df(): lint.check_observable_df(bad_observable_df) +@pytest.mark.parametrize( + "model_entity", ["observableParameter1_obs1", "noiseParameter1_obs1"] +) +def test_assert_placeholders_not_in_model(model_entity): + from petab.v1.models.sbml_model import SbmlModel + + observable_df = pd.DataFrame( + data={ + OBSERVABLE_ID: ["obs1"], + OBSERVABLE_FORMULA: ["observableParameter1_obs1 * x1"], + NOISE_FORMULA: ["noiseParameter1_obs1"], + } + ).set_index(OBSERVABLE_ID) + + model = SbmlModel.from_antimony("species x1 = 1") + lint.assert_placeholders_not_in_model(observable_df, model) + + model = SbmlModel.from_antimony(f"species x1 = 1; {model_entity} = 1") + with pytest.raises(AssertionError, match=model_entity): + lint.assert_placeholders_not_in_model(observable_df, model) + + def test_condition_ids_are_unique(): condition_df = pd.DataFrame( data={ From d6bbbb84dc3ca606354f287bf1a06d1e19b154b9 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Tue, 17 Nov 2026 11:41:12 +0100 Subject: [PATCH 2/2] v1 lint: placeholders must only be used in their own observable Extend the check to condition table columns and values, mapping table entries, observable IDs, measurement table overrides, the use in other observables, and noise placeholders in the observable formula. Rename it to `assert_placeholders_only_used_in_own_observable`. Test it through `lint_problem`, too. List the stricter validation under breaking changes. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 7 - .../+placeholders-own-observable.breaking.md | 8 + petab/v1/lint.py | 122 ++++++++++--- tests/v1/test_lint.py | 168 ++++++++++++++++-- 4 files changed, 260 insertions(+), 45 deletions(-) create mode 100644 changelog.d/+placeholders-own-observable.breaking.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 36504d6c..4f28ff40 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,13 +7,6 @@ Changes that are not released yet are collected in -**Fixes** - -v1: -* `lint_problem` now reports an error for placeholder parameters that are - also model entities (new `assert_placeholders_not_in_model`) - (by @dweindl in https://github.com/PEtab-dev/libpetab-python/pull/605) - ## 0.10 series ### 0.10.0 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/petab/v1/lint.py b/petab/v1/lint.py index 2bdc1993..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,7 +35,7 @@ "assert_parameter_prior_parameters_are_valid", "assert_parameter_prior_type_is_valid", "assert_parameter_scale_is_valid", - "assert_placeholders_not_in_model", + "assert_placeholders_only_used_in_own_observable", "assert_unique_observable_ids", "assert_unique_parameter_ids", "check_condition_df", @@ -350,30 +350,108 @@ def check_observable_df(observable_df: pd.DataFrame) -> None: ) from e -def assert_placeholders_not_in_model( - observable_df: pd.DataFrame, model: Model +def assert_placeholders_only_used_in_own_observable( + problem: "petab.Problem", ) -> None: - """Check that no placeholder parameter is a model entity. + """Check that placeholders are not defined or used elsewhere. - Placeholders are overridden per measurement. A model entity with the - same ID would be a second, conflicting definition. + 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: - observable_df: PEtab observable DataFrame - model: The model + problem: PEtab problem to check Raises: AssertionError: in case of problems """ - from .observables import get_placeholders + 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 clashes := [ - placeholder - for placeholder in get_placeholders(observable_df) - if model.has_entity_with_id(placeholder) - ]: + 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( - f"Placeholder parameters must not be model entities: {clashes}" + "Placeholder parameters must only be used in their own " + "observable: " + "; ".join(clashes) ) @@ -957,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): @@ -964,13 +1047,6 @@ def lint_problem(problem: "petab.Problem") -> bool: f"Observable ID {obs_id} shadows model entity." ) errors_occurred = True - try: - assert_placeholders_not_in_model( - problem.observable_df, problem.model - ) - except AssertionError as e: - logger.error(e) - errors_occurred = True else: logger.warning("Observable table not available. Skipping.") diff --git a/tests/v1/test_lint.py b/tests/v1/test_lint.py index 56bf5474..e62b5505 100644 --- a/tests/v1/test_lint.py +++ b/tests/v1/test_lint.py @@ -610,26 +610,164 @@ 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( - "model_entity", ["observableParameter1_obs1", "noiseParameter1_obs1"] + "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_not_in_model(model_entity): - from petab.v1.models.sbml_model import SbmlModel +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) - observable_df = pd.DataFrame( - data={ - OBSERVABLE_ID: ["obs1"], - OBSERVABLE_FORMULA: ["observableParameter1_obs1 * x1"], - NOISE_FORMULA: ["noiseParameter1_obs1"], - } - ).set_index(OBSERVABLE_ID) - model = SbmlModel.from_antimony("species x1 = 1") - lint.assert_placeholders_not_in_model(observable_df, model) +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) - model = SbmlModel.from_antimony(f"species x1 = 1; {model_entity} = 1") - with pytest.raises(AssertionError, match=model_entity): - lint.assert_placeholders_not_in_model(observable_df, model) + +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():