def test_read_without_validation(self):
# write model to file
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, self.model, data_repo_metadata=False)
# read model and verify that it validates
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
# introduce error into model file
wb = read_workbook(filename)
wb['!!Model'][4][1] = '1000'
write_workbook(filename, wb)
# read model and verify that it doesn't validate
with self.assertRaisesRegex(
ValueError,
'The model cannot be loaded because it fails to validate'):
Reader().run(filename)
env = EnvironmentVarGuard()
env.set('CONFIG__DOT__wc_lang__DOT__io__DOT__validate', '0')
with env:
model = Reader().run(filename)[Model][0]
self.assertNotEqual(model.validate(), None)
def test_export_another_model(self):
filename = 'tests/sbml/fixtures/static-model.xlsx'
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
# write SBML file
sbml_io.SbmlWriter().run(model, self.dirname)
def test_read_write(self):
fixture_filename = os.path.join(os.path.dirname(__file__), 'fixtures', 'example-model.xlsx')
model = Reader().run(fixture_filename)[Model][0]
self.assertEqual(model.validate(), None)
# compare excel files
Writer().run(self.filename, model, data_repo_metadata=False)
original = read_workbook(fixture_filename)
copy = read_workbook(self.filename)
remove_ws_metadata(original)
remove_ws_metadata(copy)
original.pop('!!' + obj_tables.core.TOC_SHEET_NAME)
copy.pop('!!' + obj_tables.core.TOC_SHEET_NAME)
# note that models must be sorted by id for this assertion to hold
for sheet in original.keys():
for i_row, (copy_row, original_row) in enumerate(zip(copy[sheet], original[sheet])):
self.assertEqual(copy_row, original_row,
msg='Rows {} of {} sheets are not equal'.format(i_row, sheet))
self.assertEqual(copy[sheet], original[sheet], msg='{} sheets are not equal'.format(sheet))
self.assertEqual(copy, original)
# compare models
model2 = Reader().run(self.filename)[Model][0]
self.assertTrue(model2.is_equal(model))
self.assertTrue(model.difference(model2) == '')
def test_write_with_optional_args(self):
# write model to file, passing models
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, self.model, models=Writer.MODELS)
# read model and verify that it validates
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
# write model to file, passing validate
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, self.model, validate=True)
# read model and verify that it validates
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
def test_write_read(self):
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, self.model, data_repo_metadata=False)
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
self.assertTrue(model.is_equal(self.model))
self.assertEqual(self.model.difference(model), '')
def test(self):
test_model = Model(id='model', version='0.0.1', wc_lang_version='0.0.1')
submodel = test_model.submodels.create(id='submodel')
filename_yaml = os.path.join(self.tempdir, 'model.yaml')
Writer().run(filename_yaml, test_model)
model = Reader().run(filename_yaml)[Model][0]
self.assertEqual(model.validate(), None)
self.assertTrue(model.is_equal(test_model))
self.assertEqual(test_model.difference(model), '')
def test_write_read_sloppy(self):
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, self.model, data_repo_metadata=False)
wb = read_workbook(filename)
row = wb['!!Model'].pop(3)
wb['!!Model'].insert(4, row)
write_workbook(filename, wb)
with self.assertRaisesRegex(ValueError, "The rows of worksheet '!!Model' must be defined in this order"):
Reader().run(filename)
env = EnvironmentVarGuard()
env.set('CONFIG__DOT__wc_lang__DOT__io__DOT__strict', '0')
with env:
model = Reader().run(filename)[Model][0]
self.assertEqual(model.validate(), None)
self.assertTrue(model.is_equal(self.model))
self.assertEqual(self.model.difference(model), '')
def test_convert_to_sbml(self):
from wc_lang.sbml import io as sbml_io
from wc_lang.io import Reader, Writer
from wc_sim.testing.utils import read_model_for_test
for model_name in self.models:
print(f'converting {model_name}')
dirname = os.path.join(os.path.dirname(__file__), 'fixtures', 'dynamic_tests')
model_filename = os.path.join(dirname, f'{model_name}.xlsx')
integration_framework = 'ordinary_differential_equations'
model = read_model_for_test(model_filename, integration_framework=f'WC:{integration_framework}')
# write wc_lang file
sbml_dirname = os.path.join(dirname, f'{model_name}_sbml')
if not os.path.isdir(sbml_dirname):
os.makedirs(sbml_dirname)
lang_filename = os.path.join(sbml_dirname, f'{model_name}.xlsx')
print(f'writing {lang_filename}')
Writer().run(lang_filename, model)
model_from_file = Reader().run(lang_filename)[Model][0]
assert model_from_file.validate() is None
# write SBML file
sbml_io.SbmlWriter().run(model_from_file, sbml_dirname)
def test_make_test_model(self):
'''
Simple SSA model tests:
no reactions: simulation terminates immediately
1 species:
one reaction consume species, at constant rate: consume all reactant, in time given by rate
2 species:
one reaction: convert all reactant into product, in time given by rate
a pair of symmetrical reactions with constant rates: maintain steady state, on average
a pair of symmetrical reactions rates given by reactant population: maintain steady state, on average
a pair of symmetrical reactions rates given by product population: exhaust on species,
with equal chance for each species
** ring of futile reactions with balanced rates: maintain steady state, on average
'''
# test get_model_type_params
expected_params_list = [(0, 0, False, RateLawType.constant),
(1, 1, False, RateLawType.constant),
(2, 1, False, RateLawType.constant),
(2, 1, True, RateLawType.constant),
(2, 1, True, RateLawType.reactant_pop),
(2, 1, True, RateLawType.product_pop)]
for model_type, expected_params in zip(self.model_types,
expected_params_list):
params = MakeModel.get_model_type_params(model_type)
self.assertEqual(params, expected_params)
# test make_test_model
for model_type in self.model_types:
for num_submodels in [1, 10]:
model = MakeModel.make_test_model(
model_type,
num_submodels=num_submodels,
transform_prep_and_check=False)
self.assertEqual(model.validate(), None)
# test round-tripping
file = model_type.replace(' ', '_').replace(',', '')
file = "{}_{}_submodels.xlsx".format(file, num_submodels)
filename = os.path.join(self.test_dir, file)
Writer().run(filename, model, data_repo_metadata=False)
round_trip_model = Reader().run(filename)[Model][0]
self.assertEqual(round_trip_model.validate(), None)
self.assertTrue(round_trip_model.is_equal(model, tol=1e-8))
self.assertEqual(model.difference(round_trip_model, tol=1e-8),
'')
# unittest one of the models made
# TODO (ARTHUR): test with multiple submodels
# TODO (ARTHUR): test observables
# TODO (ARTHUR): test functions
model = MakeModel.make_test_model(self.model_types[4])
self.assertEqual(model.id, 'test_model')
comp = model.compartments[0]
self.assertEqual(comp.id, 'compt_1')
species_type_ids = set([st.id for st in model.species_types])
self.assertEqual(species_type_ids, set(['spec_type_0', 'spec_type_1']))
species_ids = set([s.id for s in comp.species])
self.assertEqual(species_ids,
set(['spec_type_0[compt_1]', 'spec_type_1[compt_1]']))
submodel = model.submodels[0]
# reaction was split by SplitReversibleReactionsTransform
ratelaw_elements = set()
for r in submodel.reactions:
self.assertFalse(r.reversible)
rl = r.rate_laws[0]
ratelaw_elements.add((rl.direction, rl.expression.expression))
expected_rate_laws = set([
# direction, expression.expression
(RateLawDirection.forward,
'k_cat_1_1_for * spec_type_0[compt_1] / Avogadro / volume_compt_1'
), # forward
(RateLawDirection.forward,
'k_cat_1_1_bck * spec_type_1[compt_1] / Avogadro / volume_compt_1'
), # backward, but reversed
])
self.assertEqual(ratelaw_elements, expected_rate_laws)
participant_elements = set()
for r in submodel.reactions:
r_list = []
for part in r.participants:
r_list.append((part.species.id, part.coefficient))
participant_elements.add(tuple(sorted(r_list)))
expected_participants = set([
# id, coefficient
tuple(
sorted((('spec_type_0[compt_1]', -1), ('spec_type_1[compt_1]',
1)))), # forward
tuple(
sorted((('spec_type_1[compt_1]', -1), ('spec_type_0[compt_1]',
1)))), # reversed
])
self.assertEqual(participant_elements, expected_participants)
# test exceptions
with self.assertRaises(ValueError):
MakeModel.make_test_model('3 reactions')
with self.assertRaises(ValueError):
MakeModel.make_test_model(self.model_types[0], num_submodels=0)
