def test_load_parameter_file(self):
from biocrnpyler import Parameter
import sys
from warnings import warn
with self.assertRaises(AssertionError):
Parameter.load_parameter_file(filename=None)
# TODO track down why this test fails in python 3.6!
if sys.version_info[1] >= 7:
# do NOT reformat this string below
example_csv = """mechanism_id part_id param_name param_val comments\ntranscription_mm ptet_tetR kb 10. extra columns are okay!\ntranscription_mm ptet_tetR ku .1 These are the parameters for transcription"""
with patch('builtins.open',
mock_open(read_data=example_csv),
create=True):
rtn_dict = Parameter.load_parameter_file(filename='test_file')
right_dict = {
('transcription_mm', 'ptet_tetR', 'kb'): 10.0,
('transcription_mm', 'ptet_tetR', 'ku'): 0.1
}
self.assertEqual(rtn_dict, right_dict)
else:
warn('version below 3.6 was detected! This test was skipped')
def test_parameter_initialization(self):
from biocrnpyler import Parameter
with self.assertRaises(ValueError):
Parameter(name='test_param', param_type='Nothing', value=0)
with self.assertRaises(AssertionError):
Parameter(name='test_param', param_type=[], value=0)
def test_parameter_initialization(self):
# test unknown parameter type
with self.assertRaisesRegexp(ValueError,
"can't parse value of parameter"):
Parameter(name='test_param', param_type='Nothing', value=0)
# test invalid parameter type
with self.assertRaisesRegexp(ValueError,
'parameter_type must be a string'):
Parameter(name='test_param', param_type=[], value=0)
def test__get_field_names(self):
from biocrnpyler import Parameter
with self.assertRaises(AssertionError):
Parameter._get_field_names(field_names=None,
accepted_field_names=None)
with self.assertRaises(AssertionError):
Parameter._get_field_names(field_names={}, accepted_field_names={})
accepted_field_names = {
'mechanism': ['mechanism', 'mechanism_id'],
'param_name':
["parameter_name", "parameter", "param", "param_name"],
'part_id': ['part_id', 'part'],
'param_val': ["val", "value", "param_val", "parameter_value"]
}
ret_dict = Parameter._get_field_names(
field_names=[''], accepted_field_names=accepted_field_names)
self.assertEqual(accepted_field_names.keys(), ret_dict.keys())
field_names = ['part_id']
with self.assertWarns(Warning):
Parameter._get_field_names(field_names, accepted_field_names)
accepted_field_names = {
'dummy': ['dumb', 'dumber'],
}
with self.assertWarns(Warning):
Parameter._get_field_names(field_names, accepted_field_names)
def test_create_parameter_dictionary(self):
from biocrnpyler import Parameter
parameters = Parameter.create_parameter_dictionary(parameters=None,
parameter_file=None)
self.assertEqual(parameters, None)
with self.assertRaises(FileNotFoundError):
Parameter.create_parameter_dictionary(parameters={},
parameter_file='dummy_file')
def test_create_parameter_dictionary(self):
# test that no parameter dictionary or parameter files are given empty parameter dict is returned
empty_dict = {}
parameters = Parameter.create_parameter_dictionary(parameters=None,
parameter_file=None)
self.assertEqual(parameters, empty_dict)
# test that no parameter file is given then the supplied parameter dictionary is returned
param_dict = {'kb': 10.0}
parameters = Parameter.create_parameter_dictionary(
parameters=param_dict, parameter_file=None)
self.assertEqual(parameters, param_dict)
with self.assertRaises(FileNotFoundError):
Parameter.create_parameter_dictionary(parameters={},
parameter_file='dummy_file')
def test_parameter(self):
# test parameter name
with self.assertRaisesRegex(ValueError,
f"parameter_name must be a string"):
Parameter(parameter_name=None, parameter_value=1.0)
# test parameter value
with self.assertRaisesRegex(ValueError,
f"parameter_value must be a float or int"):
Parameter(parameter_name="None", parameter_value=None)
# test invalid value string
with self.assertRaisesRegex(
ValueError, f"No valid parameter value! Accepted format"):
Parameter(parameter_name="None", parameter_value='2ba')
# test string parameter values
self.assertTrue(
Parameter(parameter_name="None", parameter_value="1.0").value ==
1.0)
self.assertTrue(
Parameter(parameter_name="None", parameter_value="1/2").value ==
0.5)
self.assertTrue(
Parameter(parameter_name="None", parameter_value="1e2").value ==
100)
# testing invalid parameter name
with self.assertRaisesRegex(
ValueError,
f"parameter_name should be at least one character and cannot start with a number!"
):
Parameter(parameter_name="2", parameter_value=2)
def test_parameter_entry(self):
#Valid ParameterEntry Construction
#With unit
P0 = ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key={"part_id": "id"},
parameter_info={
"comment": "comment",
"unit": "M"
})
P1 = ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key={"part_id": "id"},
parameter_info={"comment": "comment"},
unit="M")
#Without unit
P2 = ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key={"part_id": "id"},
parameter_info={"comment": "comment"})
#Assert unit is passed through to Parameter.unit from the parameter_info_dictionary
self.assertTrue(P0.unit == "M")
self.assertTrue(P1.unit == "M")
self.assertTrue(P2.unit == "")
#Test duplication of parameter information error
with self.assertRaisesRegex(ValueError,
"Recieved multiple parameter units"):
P0 = ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key={"part_id": "id"},
parameter_info={
"comment": "comment",
"unit": "M"
},
unit="m")
#Invalid keys
param_keys = Parameter(parameter_name="None", parameter_value=1.0)
with self.assertRaisesRegex(ValueError, "parameter_key must be"):
ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key=param_keys)
#Invalid info
param_info = "blah blah"
with self.assertRaisesRegex(
ValueError, f"parameter_info must be None or a dictionary"):
ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_info=param_info)
def test_model_parameter(self):
#valid ModelParameter Construction
ModelParameter(parameter_name="None",
parameter_value=1.0,
search_key=("that", "this", "k"),
found_key=("this", None, "k"))
#Invalid keys
k = Parameter(parameter_name="None", parameter_value="1.0")
with self.assertRaisesRegex(ValueError, "parameter_key must be None"):
ModelParameter(parameter_name="None",
parameter_value=1.0,
search_key=k,
found_key=("this", None, "k"))
with self.assertRaisesRegex(ValueError, "parameter_key must be None"):
ModelParameter(parameter_name="None",
parameter_value=1.0,
search_key=("that", "this", "k"),
found_key=k)
def test_parameter_entry(self):
#Valid ParameterEntry Construction
ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key={"part_id": "id"},
parameter_info={"comment": "comment"})
#Invalid keys
param_keys = Parameter(parameter_name="None", parameter_value=1.0)
with self.assertRaisesRegex(ValueError, "parameter_key must be"):
ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_key=param_keys)
#Invalid info
param_info = "blah blah"
with self.assertRaisesRegex(
ValueError, f"parameter_info must be None or a dictionary"):
ParameterEntry(parameter_name="None",
parameter_value=1.0,
parameter_info=param_info)
def test__get_field_names(self):
test_accepted_field_names = {
'mechanism': ['mechanism', 'mechanism_id']
}
valid_field_names = ['part_id']
# test None as field_names
with self.assertRaisesRegexp(ValueError,
'field_names must be a list of strings'):
Parameter._get_field_names(
field_names=None,
accepted_field_names=test_accepted_field_names)
# test invalid field_names type
with self.assertRaisesRegexp(ValueError,
'field_names must be a list of strings'):
Parameter._get_field_names(
field_names={}, accepted_field_names=test_accepted_field_names)
# test empty field_names list
with self.assertRaisesRegexp(ValueError,
'field_names cannot be empty list!'):
Parameter._get_field_names(
field_names=[], accepted_field_names=test_accepted_field_names)
# test None as accepted_field_names
with self.assertRaisesRegexp(
ValueError, 'accepted_field_names must be a dictionary'):
Parameter._get_field_names(field_names=valid_field_names,
accepted_field_names=None)
# test invalid accepted_field_names type
with self.assertRaisesRegexp(
ValueError, 'accepted_field_names must be a dictionary'):
Parameter._get_field_names(field_names=valid_field_names,
accepted_field_names=[])
# test empty field_names list
with self.assertRaisesRegexp(
ValueError, 'accepted_field_names cannot be empty dictionary'):
Parameter._get_field_names(field_names=valid_field_names,
accepted_field_names={})
accepted_field_names = {
'mechanism': ['mechanism', 'mechanism_id'],
'param_name':
["parameter_name", "parameter", "param", "param_name"],
'part_id': ['part_id', 'part'],
'param_val': ["val", "value", "param_val", "parameter_value"]
}
ret_dict = Parameter._get_field_names(
field_names=[''], accepted_field_names=accepted_field_names)
self.assertEqual(accepted_field_names.keys(), ret_dict.keys())
with self.assertWarns(Warning):
Parameter._get_field_names(valid_field_names, accepted_field_names)
accepted_field_names = {
'dummy': ['dumb', 'dumber'],
}
with self.assertWarns(Warning):
Parameter._get_field_names(valid_field_names, accepted_field_names)
