def test_save_to_json(self):
model = self.model_parser.parse(self.model_TS).data
vector_model = model.to_vector_model()
generated_ts = vector_model.generate_transition_system()
generated_ts.save_to_json("Testing/testing_ts.json")
loaded_ts = load_TS_from_json("Testing/testing_ts.json")
self.assertEqual(generated_ts, loaded_ts)
def test_generate_transition_system(self):
model = self.model_parser.parse(self.model_TS).data
vector_model = model.to_vector_model()
generated_ts = vector_model.generate_transition_system()
self.assertEqual(self.test_ts, generated_ts)
# bigger TS
model = self.model_parser.parse(self.model_bigger_TS).data
vector_model = model.to_vector_model()
generated_ts = vector_model.generate_transition_system()
loaded_ts = load_TS_from_json("Testing/testing_bigger_ts.json")
self.assertEqual(generated_ts, loaded_ts)
def test_generate_transition_system_interrupt(self):
model = self.model_parser.parse(self.model_even_bigger_TS).data
vector_model = model.to_vector_model()
# partially generate TS with max ~1000 states
generated_ts = vector_model.generate_transition_system(max_size=1000)
# was interrupted
generated_ts.save_to_json("Testing/TS_in_progress.json")
loaded_unfinished_ts = load_TS_from_json("Testing/TS_in_progress.json")
# continue in generating with max ~5000 states
generated_ts = vector_model.generate_transition_system(
loaded_unfinished_ts, max_size=5000)
generated_ts.save_to_json("Testing/TS_in_progress.json")
loaded_unfinished_ts = load_TS_from_json("Testing/TS_in_progress.json")
# finish the TS
generated_ts = vector_model.generate_transition_system(
loaded_unfinished_ts)
generated_ts.save_to_json("Testing/TS_finished.json")
loaded_ts = load_TS_from_json("Testing/interrupt_even_bigger_ts.json")
self.assertEqual(generated_ts, loaded_ts)
def test_handle_sinks(self):
model = self.model_parser.parse(self.model_with_sinks).data
vector_model = model.to_vector_model()
generated_ts = vector_model.generate_transition_system()
loaded_ts = load_TS_from_json("Testing/TS_with_sinks.json")
self.assertEqual(generated_ts, loaded_ts)
def test_generate_pMC(self):
model = self.model_parser.parse(self.model_parametrised).data
vector_model = model.to_vector_model()
generated_ts = vector_model.generate_transition_system()
loaded_ts = load_TS_from_json("Testing/ts_pMC.json")
self.assertEqual(generated_ts, loaded_ts)
args_parser._action_groups.pop()
required = args_parser.add_argument_group('required arguments')
optional = args_parser.add_argument_group('optional arguments')
required.add_argument('--model', type=str, required=True)
required.add_argument('--output', type=str, required=True)
optional.add_argument('--transition_file')
optional.add_argument('--max_time', type=float, default=np.inf)
optional.add_argument('--max_size', type=float, default=np.inf)
optional.add_argument('--bound', type=int, default=None)
args = args_parser.parse_args()
if args.transition_file and args.transition_file != 'None':
ts = load_TS_from_json(args.transition_file)
else:
ts = None
model_parser = Parser("model")
model_str = open(args.model, "r").read()
model = model_parser.parse(model_str)
if model.success:
if not model.data.all_rates:
raise RatesNotSpecifiedError
vm = model.data.to_vector_model(args.bound)
ts = vm.generate_transition_system(ts, args.max_time, args.max_size)
ts.save_to_json(args.output)
else: