Import libsbml as libsbml (#2680)

Previously this was `sbml`, which was confusing because the global `sbml` was libsbml, and `SBMLImporter.sbml` was `libsbml.Model`.
Now it's also consistent across modules.

Author: dweindl

python/sdist/amici/sbml_import.py

@@ -20,7 +20,7 @@
 from collections.abc import Callable
 from collections.abc import Iterable, Sequence
 
-import libsbml as sbml
+import libsbml
 import numpy as np
 import sympy as sp
 from sympy.logic.boolalg import BooleanFalse, BooleanTrue
@@ -133,7 +133,7 @@ class SbmlImporter:
 
     def __init__(
         self,
-        sbml_source: str | Path | sbml.Model,
+        sbml_source: str | Path | libsbml.Model,
         show_sbml_warnings: bool = False,
         from_file: bool = True,
         discard_annotations: bool = False,
@@ -156,10 +156,10 @@ def __init__(
         :param discard_annotations:
             discard information contained in AMICI SBML annotations (debug).
         """
-        if isinstance(sbml_source, sbml.Model):
-            self.sbml_doc: sbml.Document = sbml_source.getSBMLDocument()
+        if isinstance(sbml_source, libsbml.Model):
+            self.sbml_doc: libsbml.Document = sbml_source.getSBMLDocument()
         else:
-            self.sbml_reader: sbml.SBMLReader = sbml.SBMLReader()
+            self.sbml_reader: libsbml.SBMLReader = libsbml.SBMLReader()
             if from_file:
                 sbml_doc = self.sbml_reader.readSBMLFromFile(str(sbml_source))
             else:
@@ -171,7 +171,7 @@ def __init__(
         # process document
         self._process_document()
 
-        self.sbml: sbml.Model = self.sbml_doc.getModel()
+        self.sbml: libsbml.Model = self.sbml_doc.getModel()
 
         # Long and short names for model components
         self.symbols: dict[SymbolId, dict[sp.Symbol, dict[str, Any]]] = {}
@@ -188,9 +188,9 @@ def __init__(
 
         # https://sbml.org/software/libsbml/5.18.0/docs/formatted/python-api/classlibsbml_1_1_l3_parser_settings.html#ab30d7ed52ca24cbb842d0a7fed7f4bfd
         # all defaults except disable unit parsing
-        self.sbml_parser_settings = sbml.L3ParserSettings()
+        self.sbml_parser_settings = libsbml.L3ParserSettings()
         self.sbml_parser_settings.setModel(self.sbml)
-        self.sbml_parser_settings.setParseUnits(sbml.L3P_NO_UNITS)
+        self.sbml_parser_settings.setParseUnits(libsbml.L3P_NO_UNITS)
 
         self._discard_annotations: bool = discard_annotations
 
@@ -212,7 +212,7 @@ def _process_document(self) -> None:
             for i_plugin in range(self.sbml_doc.getNumPlugins())
         ):
             # see libsbml CompFlatteningConverter for options
-            conversion_properties = sbml.ConversionProperties()
+            conversion_properties = libsbml.ConversionProperties()
             conversion_properties.addOption("flatten comp", True)
             conversion_properties.addOption("leave_ports", False)
             conversion_properties.addOption("performValidation", False)
@@ -221,7 +221,7 @@ def _process_document(self) -> None:
                 log_execution_time("flattening hierarchical SBML", logger)(
                     self.sbml_doc.convert
                 )(conversion_properties)
-                != sbml.LIBSBML_OPERATION_SUCCESS
+                != libsbml.LIBSBML_OPERATION_SUCCESS
             ):
                 raise SBMLException(
                     "Required SBML comp extension is currently not supported "
@@ -236,15 +236,13 @@ def _process_document(self) -> None:
         # apply several model simplifications that make our life substantially
         # easier
         if self.sbml_doc.getModel().getNumFunctionDefinitions():
-            convert_config = (
-                sbml.SBMLFunctionDefinitionConverter().getDefaultProperties()
-            )
+            convert_config = libsbml.SBMLFunctionDefinitionConverter().getDefaultProperties()
             log_execution_time("converting SBML functions", logger)(
                 self.sbml_doc.convert
             )(convert_config)
 
         convert_config = (
-            sbml.SBMLLocalParameterConverter().getDefaultProperties()
+            libsbml.SBMLLocalParameterConverter().getDefaultProperties()
         )
         log_execution_time("converting SBML local parameters", logger)(
             self.sbml_doc.convert
@@ -595,9 +593,9 @@ def _build_ode_model(
 
         self._reset_symbols()
         self.sbml_parser_settings.setParseLog(
-            sbml.L3P_PARSE_LOG_AS_LOG10
+            libsbml.L3P_PARSE_LOG_AS_LOG10
             if log_as_log10
-            else sbml.L3P_PARSE_LOG_AS_LN
+            else libsbml.L3P_PARSE_LOG_AS_LN
         )
         self._process_sbml(
             constant_parameters=constant_parameters,
@@ -822,7 +820,7 @@ def check_support(self) -> None:
             rule.isRate()
             and not isinstance(
                 self.sbml.getElementBySId(rule.getVariable()),
-                sbml.Compartment | sbml.Species | sbml.Parameter,
+                libsbml.Compartment | libsbml.Species | libsbml.Parameter,
             )
             for rule in self.sbml.getListOfRules()
         ):
@@ -1117,7 +1115,7 @@ def _process_rate_rules(self):
         # equations during the _replace_in_all_expressions call inside
         # _process_rules
         for rule in rules:
-            if rule.getTypeCode() != sbml.SBML_RATE_RULE:
+            if rule.getTypeCode() != libsbml.SBML_RATE_RULE:
                 continue
 
             variable = symbol_with_assumptions(rule.getVariable())
@@ -1407,10 +1405,10 @@ def _process_rules(self) -> None:
         """
         for rule in self.sbml.getListOfRules():
             # rate rules are processed in _process_species
-            if rule.getTypeCode() == sbml.SBML_RATE_RULE:
+            if rule.getTypeCode() == libsbml.SBML_RATE_RULE:
                 continue
 
-            if rule.getTypeCode() == sbml.SBML_ALGEBRAIC_RULE:
+            if rule.getTypeCode() == libsbml.SBML_ALGEBRAIC_RULE:
                 if self.sbml_doc.getLevel() < 3:
                     # not interested in implementing level 2 boundary condition
                     # shenanigans, see test 01787 in the sbml testsuite
@@ -1433,7 +1431,7 @@ def _process_rules(self) -> None:
                 )
             )
 
-    def _process_rule_algebraic(self, rule: sbml.AlgebraicRule):
+    def _process_rule_algebraic(self, rule: libsbml.AlgebraicRule):
         formula = self._sympy_from_sbml_math(rule)
         if formula is None:
             return
@@ -1461,7 +1459,7 @@ def _process_rule_algebraic(self, rule: sbml.AlgebraicRule):
             # must not be determined by reactions, which means that it
             # must either have the attribute boundaryCondition=“false”
             # or else not be involved in any reaction at all.
-            is_species = isinstance(sbml_var, sbml.Species)
+            is_species = isinstance(sbml_var, libsbml.Species)
             is_boundary_condition = (
                 is_species
                 and sbml_var.isSetBoundaryCondition()
@@ -1561,13 +1559,13 @@ def _process_rule_algebraic(self, rule: sbml.AlgebraicRule):
 
             self.symbols[SymbolId.ALGEBRAIC_STATE][var] = symbol
 
-    def _process_rule_assignment(self, rule: sbml.AssignmentRule):
+    def _process_rule_assignment(self, rule: libsbml.AssignmentRule):
         sbml_var = self.sbml.getElementBySId(rule.getVariable())
         sym_id = symbol_with_assumptions(rule.getVariable())
 
         # Check whether this rule is a spline rule.
         if not self._discard_annotations:
-            if rule.getTypeCode() == sbml.SBML_ASSIGNMENT_RULE:
+            if rule.getTypeCode() == libsbml.SBML_ASSIGNMENT_RULE:
                 annotation = AbstractSpline.get_annotation(rule)
                 if annotation is not None:
                     spline = AbstractSpline.from_annotation(
@@ -1590,14 +1588,14 @@ def _process_rule_assignment(self, rule: sbml.AssignmentRule):
         if formula is None:
             return
 
-        if isinstance(sbml_var, sbml.Species):
+        if isinstance(sbml_var, libsbml.Species):
             self.species_assignment_rules[sym_id] = formula
 
-        elif isinstance(sbml_var, sbml.Compartment):
+        elif isinstance(sbml_var, libsbml.Compartment):
             self.compartment_assignment_rules[sym_id] = formula
             self.compartments[sym_id] = formula
 
-        elif isinstance(sbml_var, sbml.Parameter):
+        elif isinstance(sbml_var, libsbml.Parameter):
             self.parameter_assignment_rules[sym_id] = formula
 
         self.symbols[SymbolId.EXPRESSION][sym_id] = {
@@ -2788,7 +2786,7 @@ def _clean_reserved_symbols(self) -> None:
                     }
 
     def _sympy_from_sbml_math(
-        self, var_or_math: [sbml.SBase, str]
+        self, var_or_math: [libsbml.SBase, str]
     ) -> sp.Expr | float | None:
         """
         Sympify Math of SBML variables with all sanity checks and
@@ -2799,8 +2797,8 @@ def _sympy_from_sbml_math(
         :return:
             sympfified symbolic expression
         """
-        if isinstance(var_or_math, sbml.SBase):
-            math_string = sbml.formulaToL3StringWithSettings(
+        if isinstance(var_or_math, libsbml.SBase):
+            math_string = libsbml.formulaToL3StringWithSettings(
                 var_or_math.getMath(), self.sbml_parser_settings
             )
             ele_name = var_or_math.element_name
@@ -2860,7 +2858,7 @@ def _get_element_initial_assignment(
         sym = self._make_initial(sym)
         return sym
 
-    def _get_element_stoichiometry(self, ele: sbml.SBase) -> sp.Expr:
+    def _get_element_stoichiometry(self, ele: libsbml.SBase) -> sp.Expr:
         """
         Computes the stoichiometry of a reactant or product of a reaction
 
@@ -2887,7 +2885,7 @@ def _get_element_stoichiometry(self, ele: sbml.SBase) -> sp.Expr:
 
         return sp.Integer(1)
 
-    def is_assignment_rule_target(self, element: sbml.SBase) -> bool:
+    def is_assignment_rule_target(self, element: libsbml.SBase) -> bool:
         """
         Checks if an element has a valid assignment rule in the specified
         model.
@@ -2901,7 +2899,7 @@ def is_assignment_rule_target(self, element: sbml.SBase) -> bool:
         a = self.sbml.getAssignmentRuleByVariable(element.getId())
         return a is not None and self._sympy_from_sbml_math(a) is not None
 
-    def is_rate_rule_target(self, element: sbml.SBase) -> bool:
+    def is_rate_rule_target(self, element: libsbml.SBase) -> bool:
         """
         Checks if an element has a valid assignment rule in the specified
         model.
@@ -2985,7 +2983,7 @@ def _transform_dxdt_to_concentration(
 
 
 def _check_lib_sbml_errors(
-    sbml_doc: sbml.SBMLDocument, show_warnings: bool = False
+    sbml_doc: libsbml.SBMLDocument, show_warnings: bool = False
 ) -> None:
     """
     Checks the error log in the current self.sbml_doc.
@@ -2996,17 +2994,17 @@ def _check_lib_sbml_errors(
     :param show_warnings:
         display SBML warnings
     """
-    num_warning = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_WARNING)
-    num_error = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_ERROR)
-    num_fatal = sbml_doc.getNumErrors(sbml.LIBSBML_SEV_FATAL)
+    num_warning = sbml_doc.getNumErrors(libsbml.LIBSBML_SEV_WARNING)
+    num_error = sbml_doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR)
+    num_fatal = sbml_doc.getNumErrors(libsbml.LIBSBML_SEV_FATAL)
 
     if num_warning + num_error + num_fatal:
         for i_error in range(sbml_doc.getNumErrors()):
             error = sbml_doc.getError(i_error)
             # we ignore any info messages for now
-            if error.getSeverity() >= sbml.LIBSBML_SEV_ERROR or (
+            if error.getSeverity() >= libsbml.LIBSBML_SEV_ERROR or (
                 show_warnings
-                and error.getSeverity() >= sbml.LIBSBML_SEV_WARNING
+                and error.getSeverity() >= libsbml.LIBSBML_SEV_WARNING
             ):
                 logger.error(
                     f"libSBML {error.getCategoryAsString()} "
@@ -3065,7 +3063,7 @@ def _parse_event_trigger(trigger: sp.Expr) -> sp.Expr:
 
 
 def assignmentRules2observables(
-    sbml_model: sbml.Model, filter_function: Callable = lambda *_: True
+    sbml_model: libsbml.Model, filter_function: Callable = lambda *_: True
 ):
     """
     Turn assignment rules into observables.
@@ -3086,7 +3084,7 @@ def assignmentRules2observables(
     """
     observables = {}
     for rule in sbml_model.getListOfRules():
-        if rule.getTypeCode() != sbml.SBML_ASSIGNMENT_RULE:
+        if rule.getTypeCode() != libsbml.SBML_ASSIGNMENT_RULE:
             continue
         parameter_id = rule.getVariable()
         if (p := sbml_model.getParameter(parameter_id)) and filter_function(p):
@@ -3143,7 +3141,7 @@ def _add_conservation_for_constant_species(
     return species_solver
 
 
-def _get_species_compartment_symbol(species: sbml.Species) -> sp.Symbol:
+def _get_species_compartment_symbol(species: libsbml.Species) -> sp.Symbol:
     """
     Generate compartment symbol for the compartment of a specific species.
     This function will always return the same unique python object for a
@@ -3157,7 +3155,7 @@ def _get_species_compartment_symbol(species: sbml.Species) -> sp.Symbol:
     return symbol_with_assumptions(species.getCompartment())
 
 
-def _get_identifier_symbol(var: sbml.SBase) -> sp.Symbol:
+def _get_identifier_symbol(var: libsbml.SBase) -> sp.Symbol:
     """
     Generate identifier symbol for a sbml variable.
     This function will always return the same unique python object for a
@@ -3171,7 +3169,7 @@ def _get_identifier_symbol(var: sbml.SBase) -> sp.Symbol:
     return symbol_with_assumptions(var.getId())
 
 
-def get_species_initial(species: sbml.Species) -> sp.Expr:
+def get_species_initial(species: libsbml.Species) -> sp.Expr:
     """
     Extract the initial concentration from a given species
 
@@ -3202,8 +3200,8 @@ def get_species_initial(species: sbml.Species) -> sp.Expr:
 
 
 def _get_list_of_species_references(
-    sbml_model: sbml.Model,
-) -> list[sbml.SpeciesReference]:
+    sbml_model: libsbml.Model,
+) -> list[libsbml.SpeciesReference]:
     """
     Extracts list of species references as SBML doesn't provide a native
     function for this.
@@ -3242,7 +3240,7 @@ def replace_logx(math_str: str | float | None) -> str | float | None:
 
 
 def _collect_event_assignment_parameter_targets(
-    sbml_model: sbml.Model,
+    sbml_model: libsbml.Model,
 ) -> list[sp.Symbol]:
     targets = []
     sbml_parameters = sbml_model.getListOfParameters()
@@ -3320,11 +3318,11 @@ def _check_symbol_nesting(
             )
 
 
-def _non_const_conservation_laws_supported(sbml_model: sbml.Model) -> bool:
+def _non_const_conservation_laws_supported(sbml_model: libsbml.Model) -> bool:
     """Check whether non-constant conservation laws can be handled for the
     given model."""
     if any(
-        rule.getTypeCode() == sbml.SBML_RATE_RULE
+        rule.getTypeCode() == libsbml.SBML_RATE_RULE
         for rule in sbml_model.getListOfRules()
     ):
         # see SBML semantic test suite, case 33 for an example
@@ -3337,7 +3335,7 @@ def _non_const_conservation_laws_supported(sbml_model: sbml.Model) -> bool:
         return False
 
     if any(
-        rule.getTypeCode() == sbml.SBML_ASSIGNMENT_RULE
+        rule.getTypeCode() == libsbml.SBML_ASSIGNMENT_RULE
         and sbml_model.getSpecies(rule.getVariable())
         for rule in sbml_model.getListOfRules()
     ):