Various cleanup (#163)

* Fix typehints
* Documentation formatting cross-referencing
* Formatting
* ...

Co-authored-by: Dilan Pathirana <59329744+dilpath@users.noreply.github.com>

Author: dweindl

petab/conditions.py

@@ -93,9 +93,8 @@ def get_parametric_overrides(condition_df: pd.DataFrame) -> List[str]:
     Returns:
         List of parameter IDs that are mapped in a condition-specific way
     """
-    constant_parameters = list(
-        set(condition_df.columns.values.tolist()) - {CONDITION_ID,
-                                                     CONDITION_NAME})
+    constant_parameters = (set(condition_df.columns.values.tolist())
+                           - {CONDITION_ID, CONDITION_NAME})
     result = []
 
     for column in constant_parameters:
@@ -104,7 +103,5 @@ def get_parametric_overrides(condition_df: pd.DataFrame) -> List[str]:
 
         floatified = condition_df.loc[:, column].apply(core.to_float_if_float)
 
-        for x in floatified:
-            if not isinstance(x, float):
-                result.append(x)
+        result.extend(x for x in floatified if not isinstance(x, float))
     return result

petab/core.py

@@ -91,7 +91,8 @@ def get_notnull_columns(df: pd.DataFrame, candidates: Iterable):
 
 
 def flatten_timepoint_specific_output_overrides(
-        petab_problem: 'petab.problem.Problem') -> None:
+        petab_problem: 'petab.problem.Problem',
+) -> None:
     """Flatten timepoint-specific output parameter overrides.
 
     If the PEtab problem definition has timepoint-specific

petab/lint.py

@@ -60,9 +60,7 @@ def _check_df(df: pd.DataFrame, req_cols: Iterable, name: str) -> None:
     Raises:
           AssertionError: if a column is missing
     """
-    cols_set = df.columns.values
-    missing_cols = set(req_cols) - set(cols_set)
-    if missing_cols:
+    if missing_cols := set(req_cols) - set(df.columns.values):
         raise AssertionError(
             f"DataFrame {name} requires the columns {missing_cols}.")
 
@@ -105,7 +103,7 @@ def check_condition_df(
     _check_df(df, req_cols, "condition")
 
     # Check for correct index
-    if not df.index.name == CONDITION_ID:
+    if df.index.name != CONDITION_ID:
         raise AssertionError(
             f"Condition table has wrong index {df.index.name}."
             f"expected {CONDITION_ID}.")
@@ -161,14 +159,9 @@ def check_measurement_df(df: pd.DataFrame,
                 df[column_name].values, column_name)
 
     if observable_df is not None:
-        # Check all observables are defined
-        observables_defined = set(observable_df.index.values)
-        observables_used = set(df[OBSERVABLE_ID])
-        observables_undefined = observables_used - observables_defined
-        if observables_undefined:
-            raise ValueError(f"Observables {observables_undefined} used in "
-                             "measurement table but not defined in "
-                             "observables table.")
+        assert_measured_observables_defined(df, observable_df)
+        measurements.assert_overrides_match_parameter_count(
+            df, observable_df)
 
         if OBSERVABLE_TRANSFORMATION in observable_df:
             # Check for positivity of measurements in case of
@@ -183,11 +176,6 @@ def check_measurement_df(df: pd.DataFrame,
                                      f'transformation {trafo} must be '
                                      f'positive, but {measurement} <= 0.')
 
-    if observable_df is not None:
-        assert_measured_observables_defined(df, observable_df)
-        measurements.assert_overrides_match_parameter_count(
-            df, observable_df)
-
     assert_measurements_not_null(df)
     assert_measurements_numeric(df)
 
@@ -213,7 +201,7 @@ def check_parameter_df(
 
     _check_df(df, PARAMETER_DF_REQUIRED_COLS[1:], "parameter")
 
-    if not df.index.name == PARAMETER_ID:
+    if df.index.name != PARAMETER_ID:
         raise AssertionError(
             f"Parameter table has wrong index {df.index.name}."
             f"expected {PARAMETER_ID}.")
@@ -239,10 +227,11 @@ def check_parameter_df(
                                  f"but column {NOMINAL_VALUE} is missing.")
         try:
             df.loc[non_estimated_par_ids, NOMINAL_VALUE].apply(float)
-        except ValueError:
-            raise AssertionError("Expected numeric values for "
-                                 f"`{NOMINAL_VALUE}` in parameter table for "
-                                 "all non-estimated parameters.")
+        except ValueError as e:
+            raise AssertionError(
+                f"Expected numeric values for `{NOMINAL_VALUE}` in parameter "
+                "table for all non-estimated parameters."
+            ) from e
 
     assert_parameter_id_is_string(df)
     assert_parameter_scale_is_valid(df)
@@ -292,8 +281,9 @@ def check_observable_df(observable_df: pd.DataFrame) -> None:
         try:
             sp.sympify(obs)
         except sp.SympifyError as e:
-            raise AssertionError(f"Cannot parse expression '{obs}' "
-                                 f"for observable {row.Index}: {e}")
+            raise AssertionError(
+                f"Cannot parse expression '{obs}' "
+                f"for observable {row.Index}: {e}") from e
 
         noise = getattr(row, NOISE_FORMULA)
         try:
@@ -304,9 +294,10 @@ def check_observable_df(observable_df: pd.DataFrame) -> None:
                 raise AssertionError(f"No or non-finite {NOISE_FORMULA} "
                                      f"given for observable {row.Index}.")
         except sp.SympifyError as e:
-            raise AssertionError(f"Cannot parse expression '{noise}' "
-                                 f"for noise model for observable "
-                                 f"{row.Index}: {e}")
+            raise AssertionError(
+                f"Cannot parse expression '{noise}' "
+                f"for noise model for observable " f"{row.Index}: {e}"
+            ) from e
 
 
 def assert_all_parameters_present_in_parameter_df(
@@ -353,7 +344,8 @@ def assert_all_parameters_present_in_parameter_df(
 
 def assert_measured_observables_defined(
         measurement_df: pd.DataFrame,
-        observable_df: pd.DataFrame) -> None:
+        observable_df: pd.DataFrame
+) -> None:
     """Check if all observables in the measurement table have been defined in
     the observable table
 
@@ -367,12 +359,11 @@ def assert_measured_observables_defined(
 
     used_observables = set(measurement_df[OBSERVABLE_ID].values)
     defined_observables = set(observable_df.index.values)
-    undefined_observables = used_observables - defined_observables
-
-    if undefined_observables:
+    if undefined_observables := (used_observables - defined_observables):
         raise AssertionError(
-            "Undefined observables in measurement file: "
-            f"{undefined_observables}.")
+            f"Observables {undefined_observables} used in "
+            "measurement table but not defined in observables table."
+        )
 
 
 def condition_table_is_parameter_free(condition_df: pd.DataFrame) -> bool:
@@ -547,9 +538,10 @@ def assert_parameter_prior_parameters_are_valid(
                 pars = tuple(
                     float(val) for val in pars_str.split(PARAMETER_SEPARATOR)
                 )
-            except ValueError:
+            except ValueError as e:
                 raise AssertionError(
-                    f"Could not parse prior parameters '{pars_str}'.")
+                    f"Could not parse prior parameters '{pars_str}'.") from e
+
             # all distributions take 2 parameters
             if len(pars) != 2:
                 raise AssertionError(
@@ -933,9 +925,7 @@ def assert_measurement_conditions_present_in_condition_table(
         used_conditions |= \
             set(measurement_df[PREEQUILIBRATION_CONDITION_ID].dropna().values)
     available_conditions = set(condition_df.index.values)
-    missing_conditions = used_conditions - available_conditions
-
-    if missing_conditions:
+    if missing_conditions := (used_conditions - available_conditions):
         raise AssertionError("Measurement table references conditions that "
                              "are not specified in the condition table: "
                              + str(missing_conditions))

petab/measurements.py

@@ -2,6 +2,7 @@
 # noqa: F405
 
 import itertools
+import math
 import numbers
 from pathlib import Path
 from typing import Dict, List, Union
@@ -201,7 +202,7 @@ def create_measurement_df() -> pd.DataFrame:
         Created DataFrame
     """
 
-    df = pd.DataFrame(data={
+    return pd.DataFrame(data={
         OBSERVABLE_ID: [],
         PREEQUILIBRATION_CONDITION_ID: [],
         SIMULATION_CONDITION_ID: [],
@@ -213,8 +214,6 @@ def create_measurement_df() -> pd.DataFrame:
         REPLICATE_ID: []
     })
 
-    return df
-
 
 def measurements_have_replicates(measurement_df: pd.DataFrame) -> bool:
     """Tests whether the measurements come with replicates
@@ -235,15 +234,15 @@ def measurements_have_replicates(measurement_df: pd.DataFrame) -> bool:
 
 def assert_overrides_match_parameter_count(
         measurement_df: pd.DataFrame,
-        observable_df: pd.DataFrame) -> None:
+        observable_df: pd.DataFrame
+) -> None:
     """Ensure that number of parameters in the observable definition matches
     the number of overrides in ``measurement_df``
 
     Arguments:
         measurement_df: PEtab measurement table
         observable_df: PEtab observable table
     """
-
     # sympify only once and save number of parameters
     observable_parameters_count = {
         obs_id: len(observables.get_formula_placeholders(
@@ -260,10 +259,11 @@ def assert_overrides_match_parameter_count(
         # check observable parameters
         try:
             expected = observable_parameters_count[row[OBSERVABLE_ID]]
-        except KeyError:
+        except KeyError as e:
             raise ValueError(
                 f"Observable {row[OBSERVABLE_ID]} used in measurement table "
-                f"is not defined.")
+                f"is not defined.") from e
+
         actual = len(split_parameter_replacement_list(
             row.get(OBSERVABLE_PARAMETERS, None)))
         # No overrides are also allowed
@@ -289,7 +289,7 @@ def assert_overrides_match_parameter_count(
         except KeyError:
             # no overrides defined, but a numerical sigma can be provided
             # anyways
-            if not len(replacements) == 1 \
+            if len(replacements) != 1 \
                     or not isinstance(replacements[0], numbers.Number):
                 raise AssertionError(
                     f'No placeholders have been specified in the noise model '

petab/observables.py

@@ -3,7 +3,7 @@
 import re
 from collections import OrderedDict
 from pathlib import Path
-from typing import List, Union
+from typing import List, Union, Literal
 
 import pandas as pd
 import sympy as sp
@@ -105,17 +105,20 @@ def get_output_parameters(
     return list(output_parameters.keys())
 
 
-def get_formula_placeholders(formula_string: str, observable_id: str,
-                             override_type: str) -> List[str]:
+def get_formula_placeholders(
+        formula_string: str,
+        observable_id: str,
+        override_type: Literal['observable', 'noise'],
+) -> List[str]:
     """
     Get placeholder variables in noise or observable definition for the
     given observable ID.
 
     Arguments:
         formula_string: observable formula
         observable_id: ID of current observable
-        override_type: 'observable' or 'noise', depending on whether `formula`
-            is for observable or for noise model
+        override_type: ``'observable'`` or ``'noise'``, depending on whether
+            ``formula`` is for observable or for noise model
 
     Returns:
         List of placeholder parameter IDs in the order expected in the
@@ -192,6 +195,4 @@ def create_observable_df() -> pd.DataFrame:
         Created DataFrame
     """
 
-    df = pd.DataFrame(data={col: [] for col in OBSERVABLE_DF_COLS})
-
-    return df
+    return pd.DataFrame(data={col: [] for col in OBSERVABLE_DF_COLS})