def test_str_to_from_xml_node(self): for text in [ 'test', 'line1\nline2', 'line1<br/>line2', '<p>line1</p>\n<p>line2</p>' ]: node = LibSbmlInterface.str_to_xml_node(text) self.assertEqual(LibSbmlInterface.str_from_xml_node(node), text)
def test_parse_units(self): self.sbml_model.setTimeUnits('second') self.sbml_model.setSubstanceUnits('mole') self.sbml_model.setExtentUnits('mole') self.sbml_model.setVolumeUnits('litre') units = [ unit_registry.parse_units('g'), unit_registry.parse_units('l'), unit_registry.parse_units('molecule'), unit_registry.parse_units('g/l'), unit_registry.parse_units('g/s'), unit_registry.parse_units('g/s**2'), unit_registry.parse_units('g/(l * ms)^2'), unit_registry.parse_units('gDCW / s'), ] for unit in units: LibSbmlInterface.create_unit(unit, self.sbml_model) exp_units = { 'second': unit_registry.parse_units('second'), 'mole': unit_registry.parse_units('molecule'), 'litre': unit_registry.parse_units('liter'), 'unit_gram_per_liter': units[3], 'unit_gram_per_second': units[4], 'unit_gram_per_second_pow_2': units[5], 'unit_gram_per_liter_pow_2_per_millisecond_pow_2': units[6], 'unit_gDCW_per_second': units[7], } parsed_units = LibSbmlInterface.parse_units(self.sbml_model) self.assertEqual(parsed_units.keys(), exp_units.keys()) for key in exp_units: self.assertTrue( are_units_equivalent(parsed_units[key], exp_units[key]), '{} != {}'.format(str(parsed_units[key]), str(exp_units[key])))
def run(cls, model): """ Encode a `wc_lang` model with at most 1 submodel into SBML * Validate model * Create SBML document * Create SBML model * Encode model objects in SBML and add to SBML model in dependent order Args: model (:obj:`wc_lang.core.Model`): `wc_lang` model with at most 1 submodel Returns: :obj:`libsbml.SBMLDocument`: SBML document with SBML-encoded model Raises: :obj:`ValueError`: if the model cannot be exported to SBML because it contains multiple submodels """ # verify model has at most 1 submodel if len(model.submodels) > 1: raise ValueError( 'Only 1 submodel can be encoded to SBML at a time') # validate model error = wc_lang.core.Validator().run(model) if error: warnings.warn('Model is invalid: ' + str(error), wc_lang.core.WcLangWarning) # determine SBML packages needed to export model packages = {} for submodel in model.submodels: if submodel.framework == onto['WC:dynamic_flux_balance_analysis']: packages['fbc'] = 2 # create an SBML document sbml_doc = LibSbmlInterface.create_doc(packages=packages) # create a SBML model sbml_model = LibSbmlInterface.init_model(model, sbml_doc, packages=packages) # add objects to SBML model related_objs = model.get_related() sbml_objs = [] for obj in related_objs: sbml_obj = obj.export_to_sbml(sbml_model) sbml_objs.append(sbml_obj) # add object relationships to SBML for obj, sbml_obj in zip(related_objs, sbml_objs): obj.export_relations_to_sbml(sbml_model, sbml_obj) # verify document is compatible with SBML, valid SBML, and consistent LibSbmlInterface.verify_doc(sbml_doc) # return SBML document return sbml_doc
def test_SBML_fbc(self): # create an SBMLDocument that uses version 2 of the 'Flux Balance Constraints' extension document = LibSbmlInterface.create_doc(packages={'fbc': 2}) id = 'x' self.assertEqual( LibSbmlInterface.call_libsbml(document.setIdAttribute, id), LIBSBML_OPERATION_SUCCESS)
def test_gen_unit_id(self): self.assertEqual( LibSbmlInterface.gen_unit_id( unit_registry.parse_units('meter / second')), 'unit_meter_per_second') self.assertEqual( LibSbmlInterface.gen_unit_id(unit_registry.parse_units('second')), 'second') with self.assertRaisesRegex(ValueError, 'Cannot generate SBML id'): LibSbmlInterface.gen_unit_id(None)
def test_parse_parameter(self): units = unit_registry.parse_units('s^-1') LibSbmlInterface.create_unit(units, self.sbml_model) parameter = LibSbmlInterface.create_parameter(self.sbml_model, 'parameter_1', 1.5, units) id, name, value, units = LibSbmlInterface.parse_parameter(parameter) self.assertEqual(id, 'parameter_1') self.assertEqual(name, '') self.assertEqual(value, 1.5) self.assertEqual(units, unit_registry.parse_expression('s^-1'))
def test_raise_if_error(self): with self.assertWarnsRegex(WcLangWarning, 'My warning message'): with mock.patch( 'wc_lang.sbml.util.LibSbmlInterface.get_errors_warnings', return_value=(None, ['\n msg1'], None, [])): LibSbmlInterface.raise_if_error(None, 'My warning message') with self.assertRaisesRegex(LibSbmlError, 'My error message'): with mock.patch( 'wc_lang.sbml.util.LibSbmlInterface.get_errors_warnings', return_value=(['\n msg1'], None, [], None)): LibSbmlInterface.raise_if_error(None, 'My error message')
def test_str_to_xml_node(self): node = LibSbmlInterface.str_to_xml_node('') self.assertEqual(node.getNumChildren(), 0) node = LibSbmlInterface.str_to_xml_node('test') self.assertEqual(node.getNumChildren(), 1) self.assertEqual(node.getChild(0).getCharacters(), 'test') node = LibSbmlInterface.str_to_xml_node('<test') self.assertEqual(node.getNumChildren(), 1) self.assertEqual(node.getChild(0).toXMLString(), '<test') self.assertEqual(node.getChild(0).getCharacters(), '<test')
def normalize_unit_kind(self): self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('meter')), 'metre') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('liter')), 'litre') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('mole')), 'mole') self.assertEqual( LibSbmlInterface.normalize_unit_kind( unit_registry.parse_units('item')), 'item')
def test_gen_nested_attr_paths(self): self.assertEqual( LibSbmlInterface.gen_nested_attr_paths( ['version', 'wc_lang_version']), { 'version': [('version', )], 'wc_lang_version': [('wc_lang_version', )] }) self.assertEqual( LibSbmlInterface.gen_nested_attr_paths( ['model.version', 'model.wc_lang_version']), { 'model.version': [('model', ), ('version', )], 'model.wc_lang_version': [('model', ), ('wc_lang_version', )] })
def test_get_errors_warnings(self): sbml_doc = LibSbmlInterface.create_doc() error = mock.Mock(getSeverityAsString=lambda: 'ERROR', getShortMessage=lambda: 'Short message', getMessage=lambda: 'Full message', getSeverity=lambda: libsbml.LIBSBML_SEV_INFO) with mock.patch.object(sbml_doc, 'getNumErrors', return_value=1): with mock.patch.object(sbml_doc, 'getError', return_value=error): errors, warns, log_errors, log_warns = LibSbmlInterface.get_errors_warnings( sbml_doc) self.assertEqual(errors, []) self.assertNotEqual(warns, []) self.assertEqual(log_errors, []) self.assertEqual(log_warns, []) sbml_doc = LibSbmlInterface.create_doc() error = mock.Mock(getSeverityAsString=lambda: 'ERROR', getShortMessage=lambda: 'Short message', getMessage=lambda: 'Full message', getSeverity=lambda: libsbml.LIBSBML_SEV_ERROR) with mock.patch.object(sbml_doc, 'getNumErrors', return_value=1): with mock.patch.object(sbml_doc, 'getError', return_value=error): errors, warns, log_errors, log_warns = LibSbmlInterface.get_errors_warnings( sbml_doc) self.assertNotEqual(errors, []) self.assertEqual(warns, []) self.assertEqual(log_errors, []) self.assertEqual(log_warns, []) sbml_doc = LibSbmlInterface.create_doc() error = mock.Mock(getSeverityAsString=lambda: 'ERROR', getShortMessage=lambda: 'Short message', getMessage=lambda: 'Full message', getSeverity=lambda: libsbml.LIBSBML_SEV_INFO) error_log = mock.Mock(getNumErrors=lambda: 1, getError=lambda x: error) with mock.patch.object(sbml_doc, 'getErrorLog', return_value=error_log): errors, warns, log_errors, log_warns = LibSbmlInterface.get_errors_warnings( sbml_doc) self.assertEqual(errors, []) self.assertEqual(warns, []) self.assertEqual(log_errors, []) self.assertNotEqual(log_warns, []) sbml_doc = LibSbmlInterface.create_doc() error = mock.Mock(getSeverityAsString=lambda: 'ERROR', getShortMessage=lambda: 'Short message', getMessage=lambda: 'Full message', getSeverity=lambda: libsbml.LIBSBML_SEV_ERROR) error_log = mock.Mock(getNumErrors=lambda: 1, getError=lambda x: error) with mock.patch.object(sbml_doc, 'getErrorLog', return_value=error_log): errors, warns, log_errors, log_warns = LibSbmlInterface.get_errors_warnings( sbml_doc) self.assertEqual(errors, []) self.assertEqual(warns, []) self.assertNotEqual(log_errors, []) self.assertEqual(log_warns, [])
def test_set_get_math(self): model = Model(version='1.2.3', wc_lang_version='4.5.6') spec_1_c = Species(id='spec_1[c]') spec_2_c = Species(id='spec_2[c]') model_objs = {Species: {spec_1_c.id: spec_1_c, spec_2_c.id: spec_2_c}} expression, error = ObservableExpression.deserialize( 'spec_1[c] + spec_2[c]', model_objs) assert error is None, str(error) sbml_doc = LibSbmlInterface.create_doc() sbml_model = LibSbmlInterface.init_model(model, sbml_doc) rule = LibSbmlInterface.call_libsbml(sbml_model.createAssignmentRule) LibSbmlInterface.set_math(rule.setMath, expression) self.assertEqual( libsbml.formulaToL3String( LibSbmlInterface.call_libsbml(rule.getMath)), 'Species__spec_1__RB__c__LB__ + Species__spec_2__RB__c__LB__') expression_2 = LibSbmlInterface.get_math(rule.getMath, ObservableExpression, model_objs) self.assertTrue(expression_2.is_equal(expression)) self.assertEqual(expression_2._parsed_expression._obj_tables_tokens, expression._parsed_expression._obj_tables_tokens)
def setUp(self): sbmlns = LibSbmlInterface.call_libsbml(SBMLNamespaces, 3, 2, "fbc", 2) self.sbml_document = LibSbmlInterface.call_libsbml( SBMLDocument, sbmlns) LibSbmlInterface.call_libsbml(self.sbml_document.setPackageRequired, 'fbc', False) self.sbml_model = LibSbmlInterface.call_libsbml( self.sbml_document.createModel) plugin = LibSbmlInterface.call_libsbml(self.sbml_model.getPlugin, 'fbc') LibSbmlInterface.call_libsbml(plugin.setStrict, True)
def run(self, dirname): """ Read `wc_lang` models from SBML-encoded XML files, one for each submodel Args: dirname (:obj:`str`): path to directory that contains SBML-encoded submodels of a model Returns: model (:obj:`wc_lang.core.Model`): `wc_lang` model """ merged_model = None sbml_reader = LibSbmlInterface.call_libsbml(libsbml.SBMLReader) paths = glob.glob(os.path.join(dirname, '*.xml')) core_path = os.path.join(dirname, 'core.xml') if core_path in paths: paths.remove(core_path) paths.insert(0, core_path) for path in paths: # read model from XML file sbml_doc = LibSbmlInterface.call_libsbml( sbml_reader.readSBMLFromFile, path) LibSbmlInterface.raise_if_error( sbml_doc, 'Model could not be read from {}'.format(path)) # convert SBML-encoded model to wc_lang model = SbmlImporter.run(sbml_doc) error = obj_tables.Validator().run(model, get_related=True) assert error is None, str(error) # merge models if merged_model is None: merged_model = model else: merged_model.merge(model) # return merged model return merged_model
def test_SBML_wrap_libsbml_with_debug(self): with capturer.CaptureOutput() as capture_output: LibSbmlInterface.call_libsbml(self.document.setIdAttribute, 'id', debug=True) self.assertRegex(capture_output.get_text(), 'libSBML call:') self.assertRegex(capture_output.get_text(), 'libSBML returns:') sbml_model = LibSbmlInterface.call_libsbml(self.document.createModel) unit_def = LibSbmlInterface.call_libsbml( sbml_model.createUnitDefinition) unit = LibSbmlInterface.create_base_unit('avogadro_unit_def', unit_def, 'avogadro') with self.assertWarnsRegex(WcLangWarning, 'unknown error code'): with capturer.CaptureOutput() as capture_output: LibSbmlInterface.call_libsbml(unit.getKind, returns_int=False, debug=True) self.assertRegex(capture_output.get_text(), 'libSBML returns:') with capturer.CaptureOutput() as capture_output: LibSbmlInterface.call_libsbml(self.document.getIdAttribute, debug=True) self.assertRegex(capture_output.get_text(), 'libSBML returns:')
def test_init_model(self): model = Model() model.parameters.create(units=unit_registry.parse_units('s^-1')) model.parameters.create(units=unit_registry.parse_units('g / l')) model.parameters.create(units=unit_registry.parse_units('m')) sbml_model = LibSbmlInterface.init_model(model, self.document, packages={'fbc': 2}) # check the SBML document LibSbmlInterface.verify_doc(self.document) return_val = LibSbmlInterface.call_libsbml( self.document.checkConsistency, returns_int=True) self.assertEqual(return_val, 0) LibSbmlInterface.verify_doc_is_compatible(self.document) # check seconds unit unit_def = LibSbmlInterface.call_libsbml(sbml_model.getUnitDefinition, 'unit_1_per_second') units = LibSbmlInterface.call_libsbml(UnitDefinition.printUnits, unit_def, True) self.assertEqual(units, '(1 second)^-1')
def test_export_import_comments(self): for comments in [ '', 'My comments', 'My\ncomments', 'My<br/>comments', '<p>My</p>\n<p>comments</p>' ]: sbml_doc = LibSbmlInterface.create_doc() sbml_model = LibSbmlInterface.create_model(sbml_doc) model = Model(comments=comments) LibSbmlInterface.set_commments(model, sbml_model) model_2 = Model() LibSbmlInterface.get_commments(model_2, sbml_model) self.assertEqual(model_2.comments, comments)
def test_verify_doc_is_consistent(self): self.setUp() self.sbml_model.setTimeUnits('second') LibSbmlInterface.verify_doc_is_consistent(self.sbml_document) self.setUp() self.sbml_model.setTimeUnits('metre') with self.assertRaisesRegex(LibSbmlError, 'inconsistent'): LibSbmlInterface.verify_doc_is_consistent(self.sbml_document, strict_units=True) self.setUp() self.sbml_model.setTimeUnits('hour') with self.assertRaisesRegex(LibSbmlError, 'inconsistent'): LibSbmlInterface.verify_doc_is_consistent(self.sbml_document, strict_units=False)
def test_export_import_annotations(self): model = Model() sbml_doc = LibSbmlInterface.create_doc() sbml_model = LibSbmlInterface.init_model(model, sbml_doc) LibSbmlInterface.set_annotations(model, { 'version': 'version', 'wc_lang_version': 'wc_lang_version' }, sbml_model) model_2 = Model() LibSbmlInterface.get_annotations(model_2, { 'version': 'version', 'wc_lang_version': 'wc_lang_version' }, sbml_model) self.assertEqual(model_2.version, model.version) self.assertEqual(model_2.wc_lang_version, model.wc_lang_version) model_3 = Model() LibSbmlInterface.get_annotations(model_3, { 'version': [('version', )], 'wc_lang_version': [('wc_lang_version', )] }, sbml_model) self.assertEqual(model_3.version, model.version) self.assertEqual(model_3.wc_lang_version, model.wc_lang_version)
def run(self, model, dirname): """ Write the submodels of a `wc_lang` model to separate SBML-encoded XML files. Args: model (:obj:`wc_lang.core.Model`): `wc_lang` model dirname (:obj:`str`): path to directory to save SBML-encoded XML files for each submodel Raises: :obj:`ValueError`: if the model could not be written to a SBML-encoded file """ # validate model model = PrepForSbmlTransform().run(model.copy()) error = wc_lang.core.Validator().run(model) if error: warnings.warn('Model is invalid: ' + str(error), wc_lang.core.WcLangWarning) # split submodels into separate models core, submodels = model.submodels.gen_models() all_models = [core] + submodels all_models_ids = ['core'] + [m.submodels[0].id for m in submodels] # create a directory to save SBML-encoded XML documents for model if not os.path.isdir(dirname): os.makedirs(dirname) # encode models in SBML and save to XML file for model, model_id in zip(all_models, all_models_ids): # encode models in SBML sbml_doc = SbmlExporter.run(model) # save SBML-encoded model to XML file path = os.path.join(dirname, model_id + '.xml') if not LibSbmlInterface.call_libsbml( libsbml.writeSBMLToFile, sbml_doc, path, returns_int=True): raise ValueError( "Submodel '{}' could not be written to SBML at '{}'.". format(model_id, path))
def test_verify_doc(self): LibSbmlInterface.verify_doc(self.sbml_document)
def run(cls, sbml_doc): """ Import a `wc_lang` model from an SBML-encoded model Args: sbml_doc (:obj:`libsbml.SBMLDocument`): SBML document with SBML-encoded model Returns: :obj:`wc_lang.core.Model`: `wc_lang` model """ LibSbmlInterface.verify_doc(sbml_doc) sbml_model = LibSbmlInterface.call_libsbml(sbml_doc.getModel) # initialize model and submodel model = wc_lang.core.Model(created=None, updated=None) if LibSbmlInterface.call_libsbml(sbml_model.getNumReactions, returns_int=True): submodel = model.submodels.create() submodel.import_from_sbml(sbml_model) else: model.import_from_sbml(sbml_model) types = [ ((wc_lang.core.Compartment, 'compartments'), (sbml_model, 'getNumCompartments', 'getCompartment')), ((wc_lang.core.Species, 'species'), (sbml_model, 'getNumSpecies', 'getSpecies')), ((wc_lang.core.Parameter, 'parameters'), (sbml_model, 'getNumParameters', 'getParameter')), ((wc_lang.core.Observable, 'observables'), (sbml_model, 'getNumRules', 'getRule')), ((wc_lang.core.Function, 'functions'), (sbml_model, 'getNumRules', 'getRule')), ((wc_lang.core.Reaction, 'reactions'), (sbml_model, 'getNumReactions', 'getReaction')), ] if LibSbmlInterface.call_libsbml(sbml_doc.isSetPackageRequired, 'fbc'): sbml_plugin = LibSbmlInterface.call_libsbml( sbml_model.getPlugin, 'fbc') types.append(((wc_lang.core.DfbaObjReaction, 'dfba_obj_reactions'), (sbml_model, 'getNumReactions', 'getReaction'))) types.append(((wc_lang.core.DfbaObjective, 'dfba_objs'), (sbml_plugin, 'getNumObjectives', 'getObjective'))) # create model objects idx_to_wc_lang_obj = {} id_to_wc_lang_obj = {} for (wc_lang_type, wc_lang_type_container), (sbml_root, sbml_type_counter, sbml_type_getter) in types: n_sbml_objs = LibSbmlInterface.call_libsbml(getattr( sbml_root, sbml_type_counter), returns_int=True) idx_to_wc_lang_obj[wc_lang_type] = {} id_to_wc_lang_obj[wc_lang_type] = {} for i_sbml_obj in range(n_sbml_objs): sbml_obj = LibSbmlInterface.call_libsbml( getattr(sbml_root, sbml_type_getter), i_sbml_obj) if not LibSbmlInterface.call_libsbml( sbml_obj.getIdAttribute).startswith( wc_lang_type.__name__ + '__'): continue wc_lang_obj = getattr(model, wc_lang_type_container).create() wc_lang_obj.import_from_sbml(sbml_obj) idx_to_wc_lang_obj[wc_lang_type][i_sbml_obj] = wc_lang_obj id_to_wc_lang_obj[wc_lang_type][wc_lang_obj.id] = wc_lang_obj # link model objects if LibSbmlInterface.call_libsbml(sbml_model.getNumReactions, returns_int=True): submodel.import_relations_from_sbml(sbml_model, id_to_wc_lang_obj) else: model.import_relations_from_sbml(sbml_model, id_to_wc_lang_obj) for (wc_lang_type, wc_lang_type_container), (sbml_root, sbml_type_counter, sbml_type_getter) in types: for i_sbml_obj, wc_lang_obj in idx_to_wc_lang_obj[ wc_lang_type].items(): sbml_obj = getattr(sbml_root, sbml_type_getter)(i_sbml_obj) wc_lang_obj.import_relations_from_sbml(sbml_obj, id_to_wc_lang_obj) # return model return model
def test_returns_int(self): sbml_model = LibSbmlInterface.call_libsbml(self.document.createModel) avogadro_unit_def = LibSbmlInterface.call_libsbml( sbml_model.createUnitDefinition) avogadro_unit = LibSbmlInterface.create_base_unit( 'avogadro_unit_def', avogadro_unit_def, 'avogadro') # All 4 cases: # {returns_int == {T, F}} x {returns_int should be set in {T, F}} # 1. returns_int == True && returns_int should NOT be set # inconsequential because returns_int is not used self.assertEqual( LibSbmlInterface.call_libsbml(self.document.getModel, returns_int=True), sbml_model) # 2. returns_int == False && returns_int should NOT be set # correct usage # explicitly set returns_int = False self.assertEqual( LibSbmlInterface.call_libsbml(self.document.getModel, returns_int=False), sbml_model) # use default returns_int = False self.assertEqual(LibSbmlInterface.call_libsbml(self.document.getModel), sbml_model) # 3. returns_int == True && returns_int should be set # correct usage self.assertEqual( LibSbmlInterface.call_libsbml(avogadro_unit.getKind, returns_int=True, debug=True), UNIT_KIND_AVOGADRO) # 4. returns_int == False && returns_int should be set # 4a. libsbml call returns int == LIBSBML_OPERATION_SUCCESS # fails to raise warning because UNIT_KIND_AMPERE == LIBSBML_OPERATION_SUCCESS == 0 # this situation cannot be avoided by wrap_libsbm, but causes no harm ampere_unit_def = LibSbmlInterface.call_libsbml( sbml_model.createUnitDefinition) ampere_unit = LibSbmlInterface.create_base_unit( 'ampere_unit_def', ampere_unit_def, 'ampere') self.assertEqual( LibSbmlInterface.call_libsbml(ampere_unit.getKind, returns_int=False), UNIT_KIND_AMPERE) # 4b. libsbml call returns int error code, NOT known by OperationReturnValue_toString() # raises warning because UNIT_KIND_AVOGADRO == 1 and LIBSBML_OPERATION_SUCCESS == 0 with warnings.catch_warnings(record=True) as w: self.assertEqual( LibSbmlInterface.call_libsbml(avogadro_unit.getKind, returns_int=False), UNIT_KIND_AVOGADRO) self.assertEqual(len(w), 1) self.assertIn("Perhaps an integer value is being returned; ", str(w[-1].message)) # 4c. libsbml call returns int error code, KNOWN by OperationReturnValue_toString() # raises warning in case the libsbml call returns an int value strange_unit = LibSbmlInterface.call_libsbml( sbml_model.createUnitDefinition) unit = LibSbmlInterface.call_libsbml(strange_unit.createUnit) with self.assertRaises(LibSbmlError) as context: unit_kind = -1 LibSbmlInterface.call_libsbml(unit.setKind, unit_kind) self.assertIn( "WARNING: if this libSBML call returns an int value, then this error may be incorrect", str(context.exception))
def test_create_unit(self): per_second = LibSbmlInterface.call_libsbml( self.sbml_model.createUnitDefinition) LibSbmlInterface.call_libsbml(per_second.setIdAttribute, 'per_second') self.assertTrue( LibSbmlInterface.call_libsbml(per_second.hasRequiredAttributes)) exp = -1 default_scale = 0 default_multiplier = 1.0 unit = LibSbmlInterface.create_base_unit('per_second', per_second, 'second', exponent=exp) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getExponent, returns_int=True), exp) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getKind, returns_int=True), UNIT_KIND_SECOND) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getScale, returns_int=True), default_scale) self.assertEqual(LibSbmlInterface.call_libsbml(unit.getMultiplier), default_multiplier) strange_unit = LibSbmlInterface.call_libsbml( self.sbml_model.createUnitDefinition) LibSbmlInterface.call_libsbml(strange_unit.setIdAttribute, 'strange_unit') self.assertTrue( LibSbmlInterface.call_libsbml(strange_unit.hasRequiredAttributes)) exp = -4 scale = 3 mult = 1.23 unit = LibSbmlInterface.create_base_unit('strange_unit', strange_unit, 'mole', exponent=exp, scale=scale, multiplier=mult) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getExponent, returns_int=True), exp) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getKind, returns_int=True), UNIT_KIND_MOLE) self.assertEqual( LibSbmlInterface.call_libsbml(unit.getScale, returns_int=True), scale) self.assertEqual(LibSbmlInterface.call_libsbml(unit.getMultiplier), mult) with self.assertRaisesRegex(AttributeError, 'no attribute'): LibSbmlInterface.create_base_unit('strange_unit', strange_unit, 'NOT_A_UNIT')
def test_parse_units_error(self): with self.assertRaisesRegex(LibSbmlError, 'units must be set'): LibSbmlInterface.parse_units(self.sbml_model)
def setUp(self): # create an SBMLDocument that uses version 2 of the 'Flux Balance Constraints' extension self.document = LibSbmlInterface.create_doc(packages={'fbc': 2})
def test_create_parameter(self): self.per_second_id = 'unit_1_per_second' self.per_second = LibSbmlInterface.call_libsbml( self.sbml_model.createUnitDefinition) LibSbmlInterface.call_libsbml(self.per_second.setIdAttribute, self.per_second_id) LibSbmlInterface.create_base_unit('unit_1_per_second', self.per_second, 'second', exponent=-1) id = 'id1' name = 'name1' value = 13.0 constant = False parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('dimensionless'), name=name, constant=constant) self.assertTrue( LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes)) self.assertEqual( LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName), name) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetValue)) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits)) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getValue), value) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant), constant) # test defaults id = 'id2' parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('dimensionless')) self.assertEqual( LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName), '') self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant), True) # test units id = 'id3' parameter = LibSbmlInterface.create_parameter( self.sbml_model, id, value, unit_registry.parse_units('s^-1')) self.assertTrue( LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes)) self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits)) self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getUnits), self.per_second_id)
def test_SBML_wrap_libsbml(self): id = u'test_id' self.assertEqual( LibSbmlInterface.call_libsbml(self.document.setIdAttribute, id), LIBSBML_OPERATION_SUCCESS) self.assertEqual( str(LibSbmlInterface.call_libsbml(self.document.getIdAttribute)), str(id)) model = LibSbmlInterface.call_libsbml(self.document.createModel) self.assertEqual( LibSbmlInterface.call_libsbml(model.setTimeUnits, 'second'), LIBSBML_OPERATION_SUCCESS) self.assertEqual( LibSbmlInterface.call_libsbml(model.setTimeUnits, 'second', debug=True, returns_int=False), LIBSBML_OPERATION_SUCCESS) self.assertEqual( LibSbmlInterface.call_libsbml(self.document.getNumErrors, returns_int=True), 0) with self.assertRaises(LibSbmlError) as context: LibSbmlInterface.call_libsbml(self.document.getNumErrors, 'no arg') self.assertIn('Error', str(context.exception)) self.assertIn("in libSBML method call", str(context.exception)) with self.assertRaises(LibSbmlError) as context: LibSbmlInterface.call_libsbml(self.document.setIdAttribute, '..') self.assertIn('LibSBML returned error code', str(context.exception)) self.assertIn("when executing", str(context.exception)) with self.assertRaises(LibSbmlError) as context: LibSbmlInterface.call_libsbml(self.document.getAnnotation) self.assertIn('libSBML returned None when executing', str(context.exception))
def test_str_to_xml_node_error(self): with self.assertRaisesRegex(LibSbmlError, 'libSBML returned None'): with mock.patch('libsbml.XMLNode.convertStringToXMLNode', return_value=None): LibSbmlInterface.str_to_xml_node('test')