def test_convert_sloppy(self):
filename_xls1 = os.path.join(self.tempdir, 'model1.xlsx')
filename_xls2 = os.path.join(self.tempdir, 'model2.xlsx')
filename_csv = os.path.join(self.tempdir, 'model-*.csv')
Writer().run(filename_xls1, self.model, data_repo_metadata=False)
wb = read_workbook(filename_xls1)
row = wb['!!Model'].pop(3)
wb['!!Model'].insert(4, row)
write_workbook(filename_xls1, wb)
with self.assertRaisesRegex(ValueError, "The rows of worksheet '!!Model' must be defined in this order"):
convert(filename_xls1, filename_csv)
env = EnvironmentVarGuard()
env.set('CONFIG__DOT__wc_lang__DOT__io__DOT__strict', '0')
with env:
convert(filename_xls1, filename_csv)
self.assertTrue(os.path.isfile(os.path.join(self.tempdir, 'model-Model.csv')))
self.assertTrue(os.path.isfile(os.path.join(self.tempdir, 'model-Taxon.csv')))
model = Reader().run(filename_csv)[Model][0]
self.assertTrue(model.is_equal(self.model))
convert(filename_csv, filename_xls2)
model = Reader().run(filename_xls2)[Model][0]
self.assertTrue(model.is_equal(self.model))
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_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_normalize(self):
filename_xls_1 = path.join(self.tempdir, 'model-1.xlsx')
filename_xls_2 = path.join(self.tempdir, 'model-2.xlsx')
model = Model(id='model',
name='test model',
version='0.0.1a',
wc_lang_version='0.0.0')
Writer().run(filename_xls_1, model, data_repo_metadata=False)
# with same destination
with __main__.App(argv=['normalize', filename_xls_1]) as app:
app.run()
model2 = Reader().run(filename_xls_1)[Model][0]
self.assertTrue(model2.is_equal(model))
# with different destination
with __main__.App(
argv=['normalize', filename_xls_1, '--dest', filename_xls_2
]) as app:
app.run()
model2 = Reader().run(filename_xls_2)[Model][0]
self.assertTrue(model2.is_equal(model))
def _default(self):
args = self.app.pargs
primary_model = Reader().run(args.primary_path)[Model][0]
for secondary_path in args.secondary_paths:
secondary_model = Reader().run(secondary_path)[Model][0]
primary_model.merge(secondary_model)
Writer().run(args.out_path,
primary_model,
data_repo_metadata=False,
protected=(not args.unprotected))
def test_convert(self):
filename_xls1 = os.path.join(self.tempdir, 'model1.xlsx')
filename_xls2 = os.path.join(self.tempdir, 'model2.xlsx')
filename_csv = os.path.join(self.tempdir, 'model-*.csv')
Writer().run(filename_xls1, self.model, data_repo_metadata=False)
convert(filename_xls1, filename_csv)
self.assertTrue(os.path.isfile(os.path.join(self.tempdir, 'model-Model.csv')))
self.assertTrue(os.path.isfile(os.path.join(self.tempdir, 'model-Taxon.csv')))
model = Reader().run(filename_csv)[Model][0]
self.assertTrue(model.is_equal(self.model))
convert(filename_csv, filename_xls2)
model = Reader().run(filename_xls2)[Model][0]
self.assertTrue(model.is_equal(self.model))
def read_model_for_test(model_filename, set_std_devs_to_0=True, integration_framework=None):
""" Read a model and prepare it for tests
Args:
model_filename (:obj:`str`): `wc_lang` model file
set_std_devs_to_0 (:obj:`bool`, optional): if set, set all standard deviations in distributions
to 0
integration_framework (:obj:`str`): if provided, set all submodels to this integration framework
Returns:
:obj:`Model`: a whole-cell model
"""
# read model while ignoring missing models
all_models = Reader().run(model_filename, ignore_extra_models=True)
if set_std_devs_to_0:
# set all standard deviations to 0
models_with_std_devs = (wc_lang.InitVolume,
wc_lang.Ph,
wc_lang.DistributionInitConcentration,
wc_lang.Parameter,
wc_lang.Observation,
wc_lang.Conclusion)
for model, instances in all_models.items():
if model in models_with_std_devs:
for instance in instances:
instance.std = 0
test_wc_model = all_models[Model][0]
if integration_framework:
for submodel in test_wc_model.submodels:
submodel.framework = onto[integration_framework]
return test_wc_model
def _default(self):
args = self.app.pargs
try:
Reader().run(args.path) # reader already does validation
print('Model is valid')
except ValueError as exception:
raise SystemExit('Model is invalid: ' + str(exception))
def test_merge_models(self):
in_paths = [
path.join(self.tempdir, 'in-0.xlsx'),
path.join(self.tempdir, 'in-1.xlsx'),
]
out_path = path.join(self.tempdir, 'out.xlsx')
# write models
model_0 = Model(id='model',
name='test model',
version='0.0.1a',
wc_lang_version='0.0.1')
model_0.species_types.create(id='a')
model_1 = Model(id='model',
name='test model',
version='0.0.1a',
wc_lang_version='0.0.1')
model_1.species_types.create(id='b')
Writer().run(in_paths[0], model_0, data_repo_metadata=False)
Writer().run(in_paths[1], model_1, data_repo_metadata=False)
# merge models
with __main__.App(argv=[
'merge-models', '-p', in_paths[0], '-s', in_paths[1], '-o',
out_path
]) as app:
app.run()
# read merged model
merged_model = Reader().run(out_path)[Model][0]
# verify merged model
self.assertEqual(len(merged_model.species_types), 2)
self.assertNotEqual(merged_model.species_types.get_one(id='a'), None)
self.assertNotEqual(merged_model.species_types.get_one(id='b'), None)
def test_read(self):
filename = os.path.join(self.tempdir, 'model.xlsx')
obj_tables.io.WorkbookWriter().run(filename, [Submodel(id='submodel')],
models=Writer.MODELS,
include_all_attributes=False)
with self.assertRaisesRegex(ValueError, 'should define one model'):
Reader().run(filename)
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_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_export_import(self):
filename = path.join(path.dirname(__file__), 'fixtures',
'sbml-io.xlsx')
filename_transformed = path.join(path.dirname(__file__), 'fixtures',
'sbml-io-transformed.xlsx')
sbml_dir = self.tempdir
filename_2 = path.join(self.tempdir, 'export.xlsx')
with __main__.App(argv=['export', filename, sbml_dir]) as app:
app.run()
with __main__.App(argv=['import', sbml_dir, filename_2]) as app:
app.run()
model = Reader().run(filename_transformed)[Model][0]
model_2 = Reader().run(filename_2)[Model][0]
self.assertTrue(model_2.is_equal(model))
def _default(self):
args = self.app.pargs
model = Reader().run(args.path)[Model][0]
model.wc_lang_version = wc_lang.__version__
Writer().run(args.path,
model,
data_repo_metadata=args.data_repo_metadata,
protected=(not args.unprotected))
def test(self):
model1 = Model(id='model1', name='test model', version='0.0.1a', wc_lang_version='0.0.1')
model2 = Model(id='model2', name='test model', version='0.0.1a', wc_lang_version='0.0.1')
filename = os.path.join(self.tempdir, 'model.xlsx')
obj_tables.io.WorkbookWriter().run(filename, [model1, model2], models=Writer.MODELS, include_all_attributes=False)
with self.assertRaisesRegex(ValueError, ' should define one model$'):
Reader().run(filename)
def setUp(self):
self.model = model = Model(id='test', version='0.1')
c = model.compartments.create(id='comp')
c.init_density = model.parameters.create(id='density_compartment_1', value=1100,
units=unit_registry.parse_units('g l^-1'))
t0 = model.species_types.create(id='s0', type=onto['WC:metabolite'])
t1 = model.species_types.create(id='s1', type=onto['WC:metabolite'])
t2 = model.species_types.create(id='s2', type=onto['WC:metabolite'])
s0 = model.species.create(id='s0[comp]', species_type=t0, compartment=c)
s1 = model.species.create(id='s1[comp]', species_type=t1, compartment=c)
s2 = model.species.create(id='s2[comp]', species_type=t2, compartment=c)
self.submodel = submodel = model.submodels.create(id='submodel',
framework=onto['WC:stochastic_simulation_algorithm'])
self.r0 = r0 = model.reactions.create(id='r0', reversible=True, submodel=submodel)
r0.participants.create(species=s0, coefficient=-2)
r0.participants.create(species=s1, coefficient=3)
r0_f = r0.rate_laws.create(id='r0-forward', direction=RateLawDirection.forward, model=model)
a = model.parameters.create(id='a', value=1., units=unit_registry.parse_units('s^-1'))
r0_f.expression, error = RateLawExpression.deserialize('a', {Parameter: {'a': a}})
assert error is None, str(error)
r0_b = r0.rate_laws.create(id='r0-backward', direction=RateLawDirection.backward,
model=model)
b = model.parameters.create(id='b', value=1., units=unit_registry.parse_units('s^-1'))
r0_b.expression, error = RateLawExpression.deserialize('b', {Parameter: {'b': b}})
assert error is None, str(error)
r0.references.create(id='ref_0', model=model)
r0.identifiers.create(namespace='x', id='y')
self.r1 = r1 = model.reactions.create(id='r1', reversible=False, submodel=submodel)
r1.participants.create(species=s1, coefficient=-3)
r1.participants.create(species=s2, coefficient=4)
r1_f = r1.rate_laws.create(id='r1-forward', direction=RateLawDirection.forward, model=model)
c = model.parameters.create(id='c', value=1., units=unit_registry.parse_units('s^-1'))
r1_f.expression, error = RateLawExpression.deserialize('c', {Parameter: {'c': c}})
assert error is None, str(error)
r1.references.create(id='ref_1', model=model)
r1.identifiers.create(namespace='xx', id='yy')
self.tempdir = tempfile.mkdtemp()
# check model's integrity by writing and reading with validate=True
filename = os.path.join(self.tempdir, 'model_for_tranformation.xlsx')
Writer().run(filename, model, data_repo_metadata=False)
# turn off validate_element_charge_balance validation so that simple species and reactions validate
with EnvironUtils.temp_config_env([(['wc_lang', 'validation', 'validate_element_charge_balance'],
'False')]):
model_read = Reader().run(filename, validate=True)[Model][0]
self.assertTrue(model_read.is_equal(model))
def setUp(self):
self.model_file = os.path.join(os.path.dirname(__file__), 'fixtures',
'test_dynamic_expressions.xlsx')
self.model = Reader().run(self.model_file)[Model][0]
de_simulation_config = SimulationConfig(time_max=10)
wc_sim_config = WCSimulationConfig(de_simulation_config)
multialgorithm_simulation = MultialgorithmSimulation(
self.model, wc_sim_config)
_, self.dynamic_model = multialgorithm_simulation.build_simulation()
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 setUp(self):
# read and initialize a model
self.model = Reader().run(self.MODEL_FILENAME, ignore_extra_models=True)[Model][0]
for conc in self.model.distribution_init_concentrations:
conc.std = 0.
PrepForWcSimTransform().run(self.model)
de_simulation_config = SimulationConfig(time_max=10)
self.wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1)
self.multialgorithm_simulation = MultialgorithmSimulation(self.model, self.wc_sim_config)
self.test_dir = tempfile.mkdtemp()
self.results_dir = tempfile.mkdtemp(dir=self.test_dir)
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 _default(self):
args = self.app.pargs
if args.compare_files:
model1 = read_workbook(args.path_1)
model2 = read_workbook(args.path_2)
if not args.compare_metadata_in_files:
self.remove_metadata(model1)
self.remove_metadata(model2)
diff = model1.difference(model2)
else:
model1 = Reader().run(args.path_1)[Model][0]
model2 = Reader().run(args.path_2)[Model][0]
diff = model1.difference(model2)
if diff:
print(diff)
else:
print('Models are identical')
def _default(self):
args = self.app.pargs
model = Reader().run(args.source)[Model][0]
if args.dest:
Writer().run(args.dest,
model,
data_repo_metadata=False,
protected=(not args.unprotected))
else:
Writer().run(args.source,
model,
data_repo_metadata=False,
protected=(not args.unprotected))
def test_rate_law_expressions_with_multiple_model_types(self):
fixture_filename = os.path.join(os.path.dirname(__file__), 'fixtures', 'example-model.xlsx')
model = Reader().run(fixture_filename)[Model][0]
rate_laws = model.get_rate_laws(id='AK_AMP-backward')
self.assertEqual(len(rate_laws), 1)
rate_law = rate_laws[0]
self.assertEqual(len(rate_law.expression.species), 1)
self.assertEqual(rate_law.expression.species[0].id, 'Adk_Protein[c]')
self.assertEqual(len(rate_law.expression.parameters), 1)
self.assertEqual(rate_law.expression.parameters[0].id, 'k_cat_rev_ak')
self.assertEqual(len(rate_law.expression.observables), 1)
self.assertEqual(rate_law.expression.observables[0].id, 'AXP_c')
self.assertEqual(len(rate_law.expression.functions), 1)
self.assertEqual(rate_law.expression.functions[0].id, 'func_1')
def test_update_version_metadata(self):
filename = path.join(self.tempdir, 'model.xlsx')
model = Model(id='model',
name='test model',
version='0.0.1a',
wc_lang_version='0.0.0')
self.assertNotEqual(model.wc_lang_version, wc_lang.__version__)
Writer().run(filename, model, data_repo_metadata=False)
with __main__.App(argv=[
'update-version-metadata', filename, '--ignore-repo-metadata'
]) as app:
app.run()
model = Reader().run(filename)[Model][0]
self.assertEqual(model.wc_lang_version, wc_lang.__version__)
def test_write_with_repo_metadata(self):
# create temp git repo & write file into it
test_repo_name = 'test_wc_lang_test_io'
test_github_repo = GitHubRepoForTests(test_repo_name)
repo = test_github_repo.make_test_repo(self.tempdir)
# write data repo metadata in data_file
data_file = os.path.join(self.tempdir, 'test.xlsx')
Writer().run(data_file, self.model, data_repo_metadata=True)
# deliberately read metadata
objs_read = Reader().run(data_file, [utils.DataRepoMetadata] + list(Writer.MODELS))
data_repo_metadata = objs_read[utils.DataRepoMetadata][0]
self.assertTrue(data_repo_metadata.url.startswith('https://github.com/'))
self.assertEqual(data_repo_metadata.branch, 'master')
self.assertEqual(len(data_repo_metadata.revision), 40)
test_github_repo.delete_test_repo()
def __init__(self, model):
"""
Args:
model (:obj:`str` or `Model`): either a path to file(s) describing a `wc_lang` model, or
a `Model` instance
Raises:
:obj:`MultialgorithmError`: if `model` is invalid
"""
if isinstance(model, Model):
self.model_path = None
self.model = model
elif isinstance(model, str):
# read model
self.model_path = os.path.abspath(os.path.expanduser(model))
self.model = Reader().run(self.model_path)[Model][0]
else:
raise MultialgorithmError(
"model must be a `wc_lang Model` or a pathname for a model, "
"but its type is {}".format(type(model)))
def _default(self):
args = self.app.pargs
if not args.transforms:
raise SystemExit('Please select at least one transform')
# read model
model = Reader().run(args.source)[Model][0]
# apply transforms
transforms = transform.get_transforms()
for id in args.transforms:
cls = transforms[id]
instance = cls()
instance.run(model)
# write model
Writer().run(args.dest,
model,
data_repo_metadata=False,
protected=(not args.unprotected))
def setUp(self, std_init_concentrations=None):
self.MODEL_FILENAME = os.path.join(os.path.dirname(__file__), 'fixtures',
'test_submodel_no_shared_species.xlsx')
self.model = Reader().run(self.MODEL_FILENAME)[Model][0]
prepare_model(self.model)
if std_init_concentrations is not None:
for conc in self.model.distribution_init_concentrations:
conc.std = std_init_concentrations
self.misconfigured_dynamic_submodels = {}
self.dynamic_submodels = {}
for lang_submodel in self.model.get_submodels():
self.dynamic_submodels[lang_submodel.id] = DynamicSubmodel(
*make_dynamic_submodel_params(self.model, lang_submodel))
# create dynamic submodels that lack a dynamic compartment
id, dynamic_model, reactions, species, dynamic_compartments, local_species_pop = \
make_dynamic_submodel_params(self.model, lang_submodel)
dynamic_compartments.popitem()
self.misconfigured_dynamic_submodels[lang_submodel.id] = DynamicSubmodel(
id, None, reactions, species, dynamic_compartments, local_species_pop)
def do_test_dfba_obj_expr(self, obj_expression, reversible_rxns, expected_obj_expr,
dfba_obj_reaction_id='unused'):
model, submodel, dfba_rxn = self.prep_dfba_obj_test(obj_expression, reversible_rxns,
expected_obj_expr,
dfba_obj_reaction_id=dfba_obj_reaction_id)
SplitReversibleReactionsTransform().run(model)
self.assertEqual(len(model.dfba_objs), 1)
self.assertEqual(model.dfba_objs[0], submodel.dfba_obj)
# make DfbaObjectiveExpression & DfbaObjective from expected_obj_expr, and compare
all_reactions = {Reaction: {rxn.id: rxn for rxn in model.reactions},
DfbaObjReaction: {dfba_obj_reaction_id: dfba_rxn}}
expected_dfba_obj_expr, error = DfbaObjectiveExpression.deserialize(expected_obj_expr,
all_reactions)
self.assertEqual(error, None)
transformed_dfba_obj = submodel.dfba_obj
submodel.dfba_obj = None
dfba_obj = DfbaObjective(id='dfba-obj-submodel',
submodel=submodel,
expression=expected_dfba_obj_expr)
self.assertEqual(dfba_obj.validate(), None)
# the list of ObjTablesTokens captures the semantics of a parsed expression
self.assertEqual(dfba_obj.expression._parsed_expression._obj_tables_tokens,
transformed_dfba_obj.expression._parsed_expression._obj_tables_tokens)
# test io
model, _, _ = self.prep_dfba_obj_test(obj_expression, reversible_rxns, expected_obj_expr,
dfba_obj_reaction_id=dfba_obj_reaction_id)
SplitReversibleReactionsTransform().run(model)
filename = os.path.join(self.tempdir, 'split_rxn_model.xlsx')
Writer().run(filename, model, data_repo_metadata=False)
# turn off validate_element_charge_balance validation so that simple species and reactions validate
with EnvironUtils.temp_config_env([(['wc_lang', 'validation', 'validate_element_charge_balance'],
'False')]):
model_read = Reader().run(filename, validate=True)[Model][0]
self.assertTrue(model_read.is_equal(model))