mxlpy 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

mxlpy/mca.py

@@ -38,6 +38,73 @@ if TYPE_CHECKING:
     from mxlpy.types import IntegratorType
 
 
+def _response_coefficient_worker(
+    parameter: str,
+    *,
+    model: Model,
+    y0: dict[str, float] | None,
+    normalized: bool,
+    rel_norm: bool,
+    displacement: float = 1e-4,
+    integrator: IntegratorType,
+) -> tuple[pd.Series, pd.Series]:
+    """Calculate response coefficients for a single parameter.
+
+    Internal helper function that computes concentration and flux response
+    coefficients using finite differences. The function:
+    1. Perturbs the parameter up and down by a small displacement
+    2. Calculates steady states for each perturbation
+    3. Computes response coefficients from the differences
+    4. Optionally normalizes the results
+
+    Args:
+        parameter: Name of the parameter to analyze
+        model: Metabolic model instance
+        y0: Initial conditions as a dictionary {species: value}
+        normalized: Whether to normalize the coefficients
+        rel_norm: Whether to use relative normalization
+        displacement: Relative perturbation size (default: 1e-4)
+        integrator: Integrator function to use for steady state calculation
+
+    Returns:
+        tuple[pd.Series, pd.Series]: Tuple containing:
+            - Series of concentration response coefficients
+            - Series of flux response coefficients
+
+    """
+    old = model.parameters[parameter]
+    if y0 is not None:
+        model.update_variables(y0)
+
+    model.update_parameters({parameter: old * (1 + displacement)})
+    upper = _steady_state_worker(
+        model,
+        rel_norm=rel_norm,
+        integrator=integrator,
+    )
+
+    model.update_parameters({parameter: old * (1 - displacement)})
+    lower = _steady_state_worker(
+        model,
+        rel_norm=rel_norm,
+        integrator=integrator,
+    )
+
+    conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
+    flux_resp = (upper.fluxes - lower.fluxes) / (2 * displacement * old)
+    # Reset
+    model.update_parameters({parameter: old})
+    if normalized:
+        norm = _steady_state_worker(
+            model,
+            rel_norm=rel_norm,
+            integrator=integrator,
+        )
+        conc_resp *= old / norm.variables
+        flux_resp *= old / norm.fluxes
+    return conc_resp, flux_resp
+
+
 ###############################################################################
 # Non-steady state
 ###############################################################################
@@ -46,8 +113,8 @@ if TYPE_CHECKING:
 def variable_elasticities(
     model: Model,
     *,
-    concs: dict[str, float] | None = None,
-    variables: list[str] | None = None,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
     time: float = 0,
     normalized: bool = True,
     displacement: float = 1e-4,
@@ -67,8 +134,8 @@ def variable_elasticities(
 
     Args:
         model: Metabolic model instance
-        concs: Initial concentrations {metabolite: value}. Uses model defaults if None
-        variables: List of variables to analyze. Uses all if None
+        to_scan: List of variables to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         time: Time point for evaluation
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
@@ -77,23 +144,23 @@ def variable_elasticities(
         DataFrame with elasticity coefficients (reactions x metabolites)
 
     """
-    concs = model.get_initial_conditions() if concs is None else concs
-    variables = model.get_variable_names() if variables is None else variables
+    variables = model.get_initial_conditions() if variables is None else variables
+    to_scan = model.get_variable_names() if to_scan is None else to_scan
     elasticities = {}
 
-    for var in variables:
-        old = concs[var]
+    for var in to_scan:
+        old = variables[var]
 
         upper = model.get_fluxes(
-            variables=concs | {var: old * (1 + displacement)}, time=time
+            variables=variables | {var: old * (1 + displacement)}, time=time
         )
         lower = model.get_fluxes(
-            variables=concs | {var: old * (1 - displacement)}, time=time
+            variables=variables | {var: old * (1 - displacement)}, time=time
         )
 
         elasticity_coef = (upper - lower) / (2 * displacement * old)
         if normalized:
-            elasticity_coef *= old / model.get_fluxes(variables=concs, time=time)
+            elasticity_coef *= old / model.get_fluxes(variables=variables, time=time)
         elasticities[var] = elasticity_coef
 
     return pd.DataFrame(data=elasticities)
@@ -101,10 +168,10 @@ def variable_elasticities(
 
 def parameter_elasticities(
     model: Model,
-    parameters: list[str] | None = None,
-    concs: dict[str, float] | None = None,
-    time: float = 0,
     *,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
+    time: float = 0,
     normalized: bool = True,
     displacement: float = 1e-4,
 ) -> pd.DataFrame:
@@ -119,8 +186,8 @@ def parameter_elasticities(
 
     Args:
         model: Metabolic model instance
-        parameters: List of parameters to analyze. Uses all if None
-        concs: Initial concentrations {metabolite: value}. Uses model defaults if None
+        to_scan: List of parameters to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         time: Time point for evaluation
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
@@ -129,26 +196,26 @@ def parameter_elasticities(
         DataFrame with parameter elasticities (reactions x parameters)
 
     """
-    concs = model.get_initial_conditions() if concs is None else concs
-    parameters = model.get_parameter_names() if parameters is None else parameters
+    variables = model.get_initial_conditions() if variables is None else variables
+    to_scan = model.get_parameter_names() if to_scan is None else to_scan
 
     elasticities = {}
 
-    concs = model.get_initial_conditions() if concs is None else concs
-    for par in parameters:
+    variables = model.get_initial_conditions() if variables is None else variables
+    for par in to_scan:
         old = model.parameters[par]
 
         model.update_parameters({par: old * (1 + displacement)})
-        upper = model.get_fluxes(variables=concs, time=time)
+        upper = model.get_fluxes(variables=variables, time=time)
 
         model.update_parameters({par: old * (1 - displacement)})
-        lower = model.get_fluxes(variables=concs, time=time)
+        lower = model.get_fluxes(variables=variables, time=time)
 
         # Reset
         model.update_parameters({par: old})
         elasticity_coef = (upper - lower) / (2 * displacement * old)
         if normalized:
-            elasticity_coef *= old / model.get_fluxes(variables=concs, time=time)
+            elasticity_coef *= old / model.get_fluxes(variables=variables, time=time)
         elasticities[par] = elasticity_coef
 
     return pd.DataFrame(data=elasticities)
@@ -159,79 +226,11 @@ def parameter_elasticities(
 # ###############################################################################
 
 
-def _response_coefficient_worker(
-    parameter: str,
-    *,
-    model: Model,
-    y0: dict[str, float] | None,
-    normalized: bool,
-    rel_norm: bool,
-    displacement: float = 1e-4,
-    integrator: IntegratorType,
-) -> tuple[pd.Series, pd.Series]:
-    """Calculate response coefficients for a single parameter.
-
-    Internal helper function that computes concentration and flux response
-    coefficients using finite differences. The function:
-    1. Perturbs the parameter up and down by a small displacement
-    2. Calculates steady states for each perturbation
-    3. Computes response coefficients from the differences
-    4. Optionally normalizes the results
-
-    Args:
-        parameter: Name of the parameter to analyze
-        model: Metabolic model instance
-        y0: Initial conditions as a dictionary {species: value}
-        normalized: Whether to normalize the coefficients
-        rel_norm: Whether to use relative normalization
-        displacement: Relative perturbation size (default: 1e-4)
-        integrator: Integrator function to use for steady state calculation
-
-    Returns:
-        tuple[pd.Series, pd.Series]: Tuple containing:
-            - Series of concentration response coefficients
-            - Series of flux response coefficients
-
-    """
-    old = model.parameters[parameter]
-
-    model.update_parameters({parameter: old * (1 + displacement)})
-    upper = _steady_state_worker(
-        model,
-        y0=y0,
-        rel_norm=rel_norm,
-        integrator=integrator,
-    )
-
-    model.update_parameters({parameter: old * (1 - displacement)})
-    lower = _steady_state_worker(
-        model,
-        y0=y0,
-        rel_norm=rel_norm,
-        integrator=integrator,
-    )
-
-    conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
-    flux_resp = (upper.fluxes - lower.fluxes) / (2 * displacement * old)
-    # Reset
-    model.update_parameters({parameter: old})
-    if normalized:
-        norm = _steady_state_worker(
-            model,
-            y0=y0,
-            rel_norm=rel_norm,
-            integrator=integrator,
-        )
-        conc_resp *= old / norm.variables
-        flux_resp *= old / norm.fluxes
-    return conc_resp, flux_resp
-
-
 def response_coefficients(
     model: Model,
-    parameters: list[str] | None = None,
     *,
-    y0: dict[str, float] | None = None,
+    to_scan: list[str] | None = None,
+    variables: dict[str, float] | None = None,
     normalized: bool = True,
     displacement: float = 1e-4,
     disable_tqdm: bool = False,
@@ -250,8 +249,8 @@ def response_coefficients(
 
     Args:
         model: Metabolic model instance
-        parameters: Parameters to analyze. Uses all if None
-        y0: Initial conditions as a dictionary {species: value}
+        to_scan: Parameters to analyze. Uses all if None
+        variables: Custom variable values. Defaults to initial conditions.
         normalized: Whether to normalize coefficients
         displacement: Relative perturbation size
         disable_tqdm: Disable progress bar
@@ -266,19 +265,19 @@ def response_coefficients(
         - Concentration response coefficients
 
     """
-    parameters = model.get_parameter_names() if parameters is None else parameters
+    to_scan = model.get_parameter_names() if to_scan is None else to_scan
 
     res = parallelise(
         partial(
             _response_coefficient_worker,
             model=model,
-            y0=y0,
+            y0=variables,
             normalized=normalized,
             displacement=displacement,
             rel_norm=rel_norm,
             integrator=integrator,
         ),
-        inputs=list(zip(parameters, parameters, strict=True)),
+        inputs=list(zip(to_scan, to_scan, strict=True)),
         cache=None,
         disable_tqdm=disable_tqdm,
         parallel=parallel,

mxlpy/meta/codegen_latex.py

@@ -326,9 +326,7 @@ class TexExport:
             parameters={gls.get(k, k): v for k, v in self.parameters.items()},
             variables={gls.get(k, k): v for k, v in self.variables.items()},
             derived={
-                gls.get(k, k): Derived(
-                    name=k, fn=v.fn, args=[gls.get(i, i) for i in v.args]
-                )
+                gls.get(k, k): Derived(fn=v.fn, args=[gls.get(i, i) for i in v.args])
                 for k, v in self.derived.items()
             },
             reactions={

mxlpy/meta/codegen_modebase.py

@@ -64,7 +64,7 @@ def generate_mxlpy_code(model: Model) -> str:
                 )
                 args = ", ".join(f'"{k}"' for k in stoich.args)
                 stoich = (  # noqa: PLW2901
-                    f"""Derived(name="{var}", fn={fn.__name__}, args=[{args}])"""
+                    f"""Derived(fn={fn.__name__}, args=[{args}])"""
                 )
             stoichiometry.append(f""""{var}": {stoich}""")
 

mxlpy/model.py

@@ -908,7 +908,7 @@ class Model:
 
         """
         self._insert_id(name=name, ctx="derived")
-        self._derived[name] = Derived(name=name, fn=fn, args=args)
+        self._derived[name] = Derived(fn=fn, args=args)
         return self
 
     def get_derived_parameter_names(self) -> list[str]:
@@ -1058,12 +1058,10 @@ class Model:
         self._insert_id(name=name, ctx="reaction")
 
         stoich: dict[str, Derived | float] = {
-            k: Derived(name=k, fn=fns.constant, args=[v]) if isinstance(v, str) else v
+            k: Derived(fn=fns.constant, args=[v]) if isinstance(v, str) else v
             for k, v in stoichiometry.items()
         }
-        self._reactions[name] = Reaction(
-            name=name, fn=fn, stoichiometry=stoich, args=args
-        )
+        self._reactions[name] = Reaction(fn=fn, stoichiometry=stoich, args=args)
         return self
 
     def get_reaction_names(self) -> list[str]:
@@ -1112,9 +1110,7 @@ class Model:
 
         if stoichiometry is not None:
             stoich = {
-                k: Derived(name=k, fn=fns.constant, args=[v])
-                if isinstance(v, str)
-                else v
+                k: Derived(fn=fns.constant, args=[v]) if isinstance(v, str) else v
                 for k, v in stoichiometry.items()
             }
             rxn.stoichiometry = stoich
@@ -1188,7 +1184,7 @@ class Model:
 
         """
         self._insert_id(name=name, ctx="readout")
-        self._readouts[name] = Readout(name=name, fn=fn, args=args)
+        self._readouts[name] = Readout(fn=fn, args=args)
         return self
 
     def get_readout_names(self) -> list[str]:
@@ -1354,7 +1350,7 @@ class Model:
 
         containers = self._derived | self._reactions | self._surrogates
         for name in cache.order:
-            containers[name].calculate_inpl(args)
+            containers[name].calculate_inpl(name, args)
 
         return args
 
@@ -1399,8 +1395,8 @@ class Model:
         )
 
         if include_readouts:
-            for ro in self._readouts.values():  # FIXME: order?
-                ro.calculate_inpl(args)
+            for name, ro in self._readouts.items():  # FIXME: order?
+                ro.calculate_inpl(name, args)
 
         return pd.Series(args, dtype=float)
 
@@ -1449,7 +1445,7 @@ class Model:
 
         containers = self._derived | self._reactions | self._surrogates
         for name in cache.order:
-            containers[name].calculate_inpl_time_course(args)
+            containers[name].calculate_inpl_time_course(name, args)
 
         if include_readouts:
             for name, ro in self._readouts.items():

mxlpy/scan.py

@@ -51,7 +51,7 @@ if TYPE_CHECKING:
     from mxlpy.types import Array
 
 
-def _update_parameters_and[T](
+def _update_parameters_and_initial_conditions[T](
     pars: pd.Series,
     fn: Callable[[Model], T],
     model: Model,
@@ -67,7 +67,9 @@ def _update_parameters_and[T](
         Result of the function execution.
 
     """
-    model.update_parameters(pars.to_dict())
+    pd = pars.to_dict()
+    model.update_variables({k: v for k, v in pd.items() if k in model._variables})  # noqa: SLF001
+    model.update_parameters({k: v for k, v in pd.items() if k in model._parameters})  # noqa: SLF001
     return fn(model)
 
 
@@ -282,7 +284,6 @@ class SteadyStateWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         *,
         rel_norm: bool,
         integrator: IntegratorType,
@@ -297,7 +298,6 @@ class TimeCourseWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         time_points: Array,
         *,
         integrator: IntegratorType,
@@ -312,7 +312,6 @@ class ProtocolWorker(Protocol):
     def __call__(
         self,
         model: Model,
-        y0: dict[str, float] | None,
         protocol: pd.DataFrame,
         *,
         integrator: IntegratorType,
@@ -324,7 +323,6 @@ class ProtocolWorker(Protocol):
 
 def _steady_state_worker(
     model: Model,
-    y0: dict[str, float] | None,
     *,
     rel_norm: bool,
     integrator: IntegratorType,
@@ -343,7 +341,7 @@ def _steady_state_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_to_steady_state(rel_norm=rel_norm)
             .get_result()
         )
@@ -354,7 +352,6 @@ def _steady_state_worker(
 
 def _time_course_worker(
     model: Model,
-    y0: dict[str, float] | None,
     time_points: Array,
     integrator: IntegratorType,
 ) -> TimeCourse:
@@ -372,7 +369,7 @@ def _time_course_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_time_course(time_points=time_points)
             .get_result()
         )
@@ -387,7 +384,6 @@ def _time_course_worker(
 
 def _protocol_worker(
     model: Model,
-    y0: dict[str, float] | None,
     protocol: pd.DataFrame,
     *,
     integrator: IntegratorType = DefaultIntegrator,
@@ -408,7 +404,7 @@ def _protocol_worker(
     """
     try:
         res = (
-            Simulator(model, y0=y0, integrator=integrator)
+            Simulator(model, integrator=integrator)
             .simulate_over_protocol(
                 protocol=protocol,
                 time_points_per_step=time_points_per_step,
@@ -432,20 +428,20 @@ def _protocol_worker(
 
 def steady_state(
     model: Model,
-    parameters: pd.DataFrame,
-    y0: dict[str, float] | None = None,
     *,
+    to_scan: pd.DataFrame,
+    y0: dict[str, float] | None = None,
     parallel: bool = True,
     rel_norm: bool = False,
     cache: Cache | None = None,
     worker: SteadyStateWorker = _steady_state_worker,
     integrator: IntegratorType = DefaultIntegrator,
 ) -> SteadyStates:
-    """Get steady-state results over supplied parameters.
+    """Get steady-state results over supplied values.
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         y0: Initial conditions as a dictionary {variable: value}.
         parallel: Whether to execute in parallel (default: True).
         rel_norm: Whether to use relative normalization (default: False).
@@ -478,39 +474,41 @@ def steady_state(
         | (2, 4) | 0.5  |   2 |
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
-                y0=y0,
                 rel_norm=rel_norm,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = pd.DataFrame({k: v.variables.T for k, v in res.items()}).T
     fluxes = pd.DataFrame({k: v.fluxes.T for k, v in res.items()}).T
     idx = (
-        pd.Index(parameters.iloc[:, 0])
-        if parameters.shape[1] == 1
-        else pd.MultiIndex.from_frame(parameters)
+        pd.Index(to_scan.iloc[:, 0])
+        if to_scan.shape[1] == 1
+        else pd.MultiIndex.from_frame(to_scan)
     )
     concs.index = idx
     fluxes.index = idx
-    return SteadyStates(variables=concs, fluxes=fluxes, parameters=parameters)
+    return SteadyStates(variables=concs, fluxes=fluxes, parameters=to_scan)
 
 
 def time_course(
     model: Model,
-    parameters: pd.DataFrame,
+    *,
+    to_scan: pd.DataFrame,
     time_points: Array,
     y0: dict[str, float] | None = None,
-    *,
     parallel: bool = True,
     cache: Cache | None = None,
     worker: TimeCourseWorker = _time_course_worker,
@@ -521,7 +519,7 @@ def time_course(
     Examples:
         >>> time_course(
         >>>     model,
-        >>>     parameters=pd.DataFrame({"k1": [1, 1.5, 2]}),
+        >>>     to_scan=pd.DataFrame({"k1": [1, 1.5, 2]}),
         >>>     time_points=np.linspace(0, 1, 3)
         >>> ).variables
 
@@ -539,7 +537,7 @@ def time_course(
 
         >>> time_course(
         >>>     model,
-        >>>     parameters=cartesian_product({"k1": [1, 2], "k2": [3, 4]}),
+        >>>     to_scan=cartesian_product({"k1": [1, 2], "k2": [3, 4]}),
         >>>     time_points=[0.0, 0.5, 1.0],
         >>> ).variables
 
@@ -553,7 +551,7 @@ def time_course(
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         time_points: Array of time points for the simulation.
         y0: Initial conditions as a dictionary {variable: value}.
         cache: Optional cache to store and retrieve results.
@@ -566,25 +564,27 @@ def time_course(
 
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
                 time_points=time_points,
-                y0=y0,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = cast(dict, {k: v.variables for k, v in res.items()})
     fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
     return TimeCourseByPars(
-        parameters=parameters,
+        parameters=to_scan,
         variables=pd.concat(concs, names=["n", "time"]),
         fluxes=pd.concat(fluxes, names=["n", "time"]),
     )
@@ -592,11 +592,11 @@ def time_course(
 
 def time_course_over_protocol(
     model: Model,
-    parameters: pd.DataFrame,
+    *,
+    to_scan: pd.DataFrame,
     protocol: pd.DataFrame,
     time_points_per_step: int = 10,
     y0: dict[str, float] | None = None,
-    *,
     parallel: bool = True,
     cache: Cache | None = None,
     worker: ProtocolWorker = _protocol_worker,
@@ -618,7 +618,7 @@ def time_course_over_protocol(
 
     Args:
         model: Model instance to simulate.
-        parameters: DataFrame containing parameter values to scan.
+        to_scan: DataFrame containing parameter or initial values to scan.
         protocol: Protocol to follow for the simulation.
         time_points_per_step: Number of time points per protocol step (default: 10).
         y0: Initial conditions as a dictionary {variable: value}.
@@ -631,26 +631,28 @@ def time_course_over_protocol(
         TimeCourseByPars: Protocol series results for each parameter set.
 
     """
+    if y0 is not None:
+        model.update_variables(y0)
+
     res = parallelise(
         partial(
-            _update_parameters_and,
+            _update_parameters_and_initial_conditions,
             fn=partial(
                 worker,
                 protocol=protocol,
-                y0=y0,
                 time_points_per_step=time_points_per_step,
                 integrator=integrator,
             ),
             model=model,
         ),
-        inputs=list(parameters.iterrows()),
+        inputs=list(to_scan.iterrows()),
         cache=cache,
         parallel=parallel,
     )
     concs = cast(dict, {k: v.variables for k, v in res.items()})
     fluxes = cast(dict, {k: v.fluxes for k, v in res.items()})
     return ProtocolByPars(
-        parameters=parameters,
+        parameters=to_scan,
         protocol=protocol,
         variables=pd.concat(concs, names=["n", "time"]),
         fluxes=pd.concat(fluxes, names=["n", "time"]),