feat: refactored task preprocessing

Author: jonrkarr

biosimulators/Dockerfile

@@ -1,7 +1,7 @@
 # Base OS
 FROM python:3.9-slim-buster
 
-ARG VERSION=0.0.3
+ARG VERSION=0.0.4
 ARG SIMULATOR_VERSION=1.4.0
 ARG LIBSBML_VERSION=5.19.0
 

biosimulators/biosimulators_libsbmlsim/_version.py

@@ -1 +1 @@
-__version__ = '0.0.3'
+__version__ = '0.0.4'

biosimulators/biosimulators_libsbmlsim/core.py

@@ -12,15 +12,17 @@
 from biosimulators_utils.log.data_model import CombineArchiveLog, TaskLog, StandardOutputErrorCapturerLevel  # noqa: F401
 from biosimulators_utils.viz.data_model import VizFormat  # noqa: F401
 from biosimulators_utils.report.data_model import ReportFormat, VariableResults, SedDocumentResults  # noqa: F401
-from biosimulators_utils.sedml.data_model import (Task, ModelLanguage, UniformTimeCourseSimulation,  # noqa: F401
+from biosimulators_utils.sedml.data_model import (Task, ModelLanguage, ModelAttributeChange, UniformTimeCourseSimulation,  # noqa: F401
                                                   Algorithm, Variable, Symbol)
 from biosimulators_utils.sedml import validation
 from biosimulators_utils.sedml.exec import exec_sed_doc as base_exec_sed_doc
+from biosimulators_utils.sedml.utils import apply_changes_to_xml_model
 from biosimulators_utils.simulator.utils import get_algorithm_substitution_policy
 from biosimulators_utils.utils.core import raise_errors_warnings
 from biosimulators_utils.warnings import warn, BioSimulatorsWarning
 from kisao.data_model import AlgorithmSubstitutionPolicy, ALGORITHM_SUBSTITUTION_POLICY_LEVELS
 from kisao.utils import get_preferred_substitute_algorithm_by_ids
+import copy
 import libsbmlsim
 import lxml.etree
 import os
@@ -128,70 +130,44 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
     model = task.model
     sim = task.simulation
 
-    if config.VALIDATE_SEDML:
-        raise_errors_warnings(validation.validate_task(task),
-                              error_summary='Task `{}` is invalid.'.format(task.id))
-        raise_errors_warnings(validation.validate_model_language(model.language, ModelLanguage.SBML),
-                              error_summary='Language for model `{}` is not supported.'.format(model.id))
-        raise_errors_warnings(validation.validate_model_change_types(model.changes, ()),
+    # change model
+    if model.changes:
+        raise_errors_warnings(validation.validate_model_change_types(model.changes, (ModelAttributeChange,)),
                               error_summary='Changes for model `{}` are not supported.'.format(model.id))
-        raise_errors_warnings(*validation.validate_model_changes(task.model),
-                              error_summary='Changes for model `{}` are invalid.'.format(model.id))
-        raise_errors_warnings(validation.validate_simulation_type(sim, (UniformTimeCourseSimulation, )),
-                              error_summary='{} `{}` is not supported.'.format(sim.__class__.__name__, sim.id))
-        raise_errors_warnings(*validation.validate_simulation(sim),
-                              error_summary='Simulation `{}` is invalid.'.format(sim.id))
-        raise_errors_warnings(*validation.validate_data_generator_variables(variables),
-                              error_summary='Data generator variables for task `{}` are invalid.'.format(task.id))
 
-    if not os.path.isfile(model.source):
-        raise FileNotFoundError('Model source `{}` is not a file.'.format(model.source))
-    model_etree = lxml.etree.parse(model.source)
-    target_x_paths_to_sbml_ids = validation.validate_target_xpaths(variables, model_etree, attr='id')
+        model_etree = preprocessed_task['model']['etree']
 
-    if config.VALIDATE_SEDML_MODELS:
-        raise_errors_warnings(*validation.validate_model(model, [], working_dir='.'),
-                              error_summary='Model `{}` is invalid.'.format(model.id),
-                              warning_summary='Model `{}` may be invalid.'.format(model.id))
+        model = copy.deepcopy(model)
+        for change in model.changes:
+            change.new_value = str(change.new_value)
+
+        apply_changes_to_xml_model(model, model_etree, sed_doc=None, working_dir=None)
+
+        model_file, model_filename = tempfile.mkstemp(suffix='.xml')
+        os.close(model_file)
+
+        model_etree.write(model_filename,
+                          xml_declaration=True,
+                          encoding="utf-8",
+                          standalone=False,
+                          pretty_print=False)
+    else:
+        model_filename = model.source
 
     # validate time course
     if sim.initial_time != 0:
         msg = 'Initial time must be zero, not `{}`.'.format(sim.initial_time)
-        raise NotImplementedError(msg)
 
-    # determine the simulation algorithm
-    algorithm_substitution_policy = get_algorithm_substitution_policy(config=config)
-    exec_kisao_id = get_preferred_substitute_algorithm_by_ids(
-        sim.algorithm.kisao_id, KISAO_ALGORITHMS_MAP.keys(),
-        substitution_policy=algorithm_substitution_policy)
-    if exec_kisao_id == sim.algorithm.kisao_id:
-        if (
-            ALGORITHM_SUBSTITUTION_POLICY_LEVELS[algorithm_substitution_policy]
-            > ALGORITHM_SUBSTITUTION_POLICY_LEVELS[AlgorithmSubstitutionPolicy.NONE]
-        ):
-            changes = []
-            unsupported_changes = []
-            for change in sim.algorithm.changes:
-                if change.kisao_id in ['KISAO_0000594', 'KISAO_0000483']:
-                    changes.append(change)
-                else:
-                    unsupported_changes.append(change.kisao_id)
-            if unsupported_changes:
-                warn('{} unsuported algorithm parameters were ignored:\n  {}'.format(
-                    len(unsupported_changes), '\n  '.join(sorted(unsupported_changes))),
-                    BioSimulatorsWarning)
-        else:
-            changes = sim.algorithm.changes
-    else:
-        changes = []
-    algorithm = Algorithm(kisao_id=exec_kisao_id, changes=changes)
+        if model.changes:
+            os.remove(model_filename)
 
-    # determine the simulation method and its parameters
-    integrator, time_step = get_integrator(algorithm)
+        raise NotImplementedError(msg)
+
+    # determine the number of simulation steps
+    time_step = preprocessed_task['simulation']['time_step']
 
     if time_step is None:
         time_step = (sim.output_end_time - sim.output_start_time) / sim.number_of_steps / 1e2
-    use_lazy_newton_method = 0
 
     number_of_steps = (sim.output_end_time - sim.initial_time) / time_step
     if abs(number_of_steps - round(number_of_steps)) > 1e-8:
@@ -210,6 +186,10 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
             sim.number_of_steps,
             time_step,
         )
+
+        if model.changes:
+            os.remove(model_filename)
+
         raise ValueError(msg)
 
     print_interval = (sim.output_end_time - sim.output_start_time) / sim.number_of_steps / time_step
@@ -229,16 +209,24 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
             sim.number_of_steps,
             time_step,
         )
+
+        if model.changes:
+            os.remove(model_filename)
+
         raise ValueError(msg)
     print_interval = round(print_interval)
 
-    print_amount = 0
-
     # execute the simulation
-    results = libsbmlsim.simulateSBMLFromFile(model.source,
-                                              sim.output_end_time, time_step,
-                                              print_interval, print_amount,
-                                              integrator, use_lazy_newton_method)
+    results = libsbmlsim.simulateSBMLFromFile(model_filename,
+                                              sim.output_end_time,
+                                              time_step,
+                                              print_interval,
+                                              preprocessed_task['simulation']['print_amount'],
+                                              preprocessed_task['simulation']['integrator'],
+                                              preprocessed_task['simulation']['use_lazy_newton_method'])
+
+    if model.changes:
+        os.remove(model_filename)
 
     if results.isError():
         raise ValueError(results.error_message)
@@ -251,9 +239,10 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
     os.remove(filename)
 
     # extract results
+    xpath_sbml_id_map = preprocessed_task['model']['xpath_sbml_id_map']
+    variable_results = VariableResults()
     unsupported_symbols = []
     unsupported_targets = []
-    variable_results = VariableResults()
     for variable in variables:
         if variable.symbol:
             if variable.symbol == Symbol.time.value:
@@ -263,15 +252,15 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
                 unsupported_symbols.append((variable.id, variable.symbol))
 
         else:
-            sbml_id = target_x_paths_to_sbml_ids[variable.target]
+            sbml_id = xpath_sbml_id_map[variable.target]
             if sbml_id in results_df:
                 variable_result = results_df[sbml_id]
             else:
                 variable_result = None
                 unsupported_targets.append((variable.id, variable.target))
 
         if variable_result is not None:
-            if exec_kisao_id in ['KISAO_0000086', 'KISAO_0000321']:
+            if preprocessed_task['simulation']['algorithm_kisao_id'] in ['KISAO_0000086', 'KISAO_0000321']:
                 variable_results[variable.id] = variable_result[-(sim.number_of_steps*print_interval + 1)::print_interval].to_numpy()
 
             else:
@@ -307,16 +296,16 @@ def exec_sed_task(task, variables, preprocessed_task=None, log=None, config=None
 
     # log action
     if config.LOG:
-        log.algorithm = exec_kisao_id
+        log.algorithm = preprocessed_task['simulation']['algorithm_kisao_id'],
         log.simulator_details = {
             'method': "simulateSBMLFromFile",
             'arguments': {
                 'sim_time': sim.output_end_time,
                 'dt': time_step,
                 'print_interval': print_interval,
-                'print_amount': print_amount,
-                'method': integrator,
-                'use_lazy_method': use_lazy_newton_method,
+                'print_amount': preprocessed_task['simulation']['print_amount'],
+                'method': preprocessed_task['simulation']['integrator'],
+                'use_lazy_method': preprocessed_task['simulation']['use_lazy_newton_method'],
             },
         }
 
@@ -336,4 +325,81 @@ def preprocess_sed_task(task, variables, config=None):
     Returns:
         :obj:`object`: preprocessed information about the task
     """
-    pass
+    config = config or get_config()
+
+    model = task.model
+    sim = task.simulation
+
+    # validate model and simulation
+    if config.VALIDATE_SEDML:
+        raise_errors_warnings(validation.validate_task(task),
+                              error_summary='Task `{}` is invalid.'.format(task.id))
+        raise_errors_warnings(validation.validate_model_language(model.language, ModelLanguage.SBML),
+                              error_summary='Language for model `{}` is not supported.'.format(model.id))
+        raise_errors_warnings(validation.validate_model_change_types(model.changes, (ModelAttributeChange,)),
+                              error_summary='Changes for model `{}` are not supported.'.format(model.id))
+        raise_errors_warnings(*validation.validate_model_changes(task.model),
+                              error_summary='Changes for model `{}` are invalid.'.format(model.id))
+        raise_errors_warnings(validation.validate_simulation_type(sim, (UniformTimeCourseSimulation, )),
+                              error_summary='{} `{}` is not supported.'.format(sim.__class__.__name__, sim.id))
+        raise_errors_warnings(*validation.validate_simulation(sim),
+                              error_summary='Simulation `{}` is invalid.'.format(sim.id))
+        raise_errors_warnings(*validation.validate_data_generator_variables(variables),
+                              error_summary='Data generator variables for task `{}` are invalid.'.format(task.id))
+
+    if not os.path.isfile(model.source):
+        raise FileNotFoundError('Model source `{}` is not a file.'.format(model.source))
+    model_etree = lxml.etree.parse(model.source)
+    xpath_sbml_id_map = validation.validate_target_xpaths(variables, model_etree, attr='id')
+
+    if config.VALIDATE_SEDML_MODELS:
+        raise_errors_warnings(*validation.validate_model(model, [], working_dir='.'),
+                              error_summary='Model `{}` is invalid.'.format(model.id),
+                              warning_summary='Model `{}` may be invalid.'.format(model.id))
+
+    # determine the simulation algorithm
+    algorithm_substitution_policy = get_algorithm_substitution_policy(config=config)
+    exec_kisao_id = get_preferred_substitute_algorithm_by_ids(
+        sim.algorithm.kisao_id, KISAO_ALGORITHMS_MAP.keys(),
+        substitution_policy=algorithm_substitution_policy)
+    if exec_kisao_id == sim.algorithm.kisao_id:
+        if (
+            ALGORITHM_SUBSTITUTION_POLICY_LEVELS[algorithm_substitution_policy]
+            > ALGORITHM_SUBSTITUTION_POLICY_LEVELS[AlgorithmSubstitutionPolicy.NONE]
+        ):
+            changes = []
+            unsupported_changes = []
+            for change in sim.algorithm.changes:
+                if change.kisao_id in ['KISAO_0000594', 'KISAO_0000483']:
+                    changes.append(change)
+                else:
+                    unsupported_changes.append(change.kisao_id)
+            if unsupported_changes:
+                warn('{} unsuported algorithm parameters were ignored:\n  {}'.format(
+                    len(unsupported_changes), '\n  '.join(sorted(unsupported_changes))),
+                    BioSimulatorsWarning)
+        else:
+            changes = sim.algorithm.changes
+    else:
+        changes = []
+    algorithm = Algorithm(kisao_id=exec_kisao_id, changes=changes)
+
+    # determine the simulation method and its parameters
+    integrator, time_step = get_integrator(algorithm)
+    use_lazy_newton_method = 0
+    print_amount = 0
+
+    # return preprocessed task
+    return {
+        'model': {
+            'etree': model_etree,
+            'xpath_sbml_id_map': xpath_sbml_id_map,
+        },
+        'simulation': {
+            'algorithm_kisao_id': exec_kisao_id,
+            'integrator': integrator,
+            'use_lazy_newton_method': use_lazy_newton_method,
+            'time_step': time_step,
+            'print_amount': print_amount,
+        },
+    }

biosimulators/requirements.txt

@@ -1,4 +1,4 @@
-biosimulators_utils[sbml,logging] >= 0.1.116
+biosimulators_utils[sbml,logging] >= 0.1.118
 # libsbmlsim
 lxml
 kisao