def test_update_reactions(self):
from biocrnpyler import Mechanism
mech = Mechanism(name='test_mechanism', mechanism_type='dummy')
with self.assertWarns(Warning):
mech.update_reactions()
def test_get_mechanism(self):
M1_comp = Mechanism(name = "m1_comp", mechanism_type = "shared")
M1_mix = Mechanism(name = "m1_mix", mechanism_type = "shared")
M2_comp = Mechanism(name = "m2_comp", mechanism_type = "comp")
M2_mix = Mechanism(name = "m2_mix", mechanism_type = "mixture")
#Create a Mixture and Component with the above mechanisms
C = Component(name = "comp", mechanisms = [M1_comp, M2_comp])
M = Mixture(mechanisms = [M1_mix, M2_mix], components = [C])
#Get the copy of C in M
C_copy = M.get_component(component = C)
self.assertTrue(C_copy.get_mechanism("shared").name == "m1_comp")
self.assertTrue(M.get_mechanism("shared").name == "m1_mix")
self.assertTrue(C_copy.get_mechanism("comp").name == "m2_comp")
self.assertTrue(C_copy.get_mechanism("mixture").name == "m2_mix")
#Make sure the Mixture get_mechanism works as well, just in case.
self.assertTrue(M.get_mechanism("comp") is None)
#test get Mechanism with no_key_error = False (Default)
with self.assertRaisesRegex(KeyError, "Unable to find mechanism of type"):
C_copy.get_mechanism("DNE")
#test get_mechanism with no_key_error = True
self.assertTrue(C_copy.get_mechanism("DNE", optional_mechanism = True) is None)
def test_add_mechanism():
mech = Mechanism(name="mech", mechanism_type="assembly")
ass = DNAassembly(name="ass", rbs="rbs", promoter="prom")
ass.add_mechanism(mech)
#Mechanism should be added to promoter and rbs
assert mech.mechanism_type in ass.mechanisms
assert mech.mechanism_type in ass.promoter.mechanisms
assert mech.mechanism_type in ass.rbs.mechanisms
#Mechaisms which are already in the Promoter or RBS should NOT be overwritten
mech_rbs = Mechanism(name="rbs", mechanism_type="mech")
mech_promoter = Mechanism(name="promoter", mechanism_type="mech")
mech_assembly = Mechanism(name="assembly", mechanism_type="mech")
#Create promoter and assembly with their own mechanisms
prom = Promoter("prom", mechanisms=[mech_promoter])
assert mech_promoter.mechanism_type in prom.mechanisms
rbs = RBS("rbs", mechanisms=[mech_rbs])
assert mech_rbs.mechanism_type in rbs.mechanisms
ass = DNAassembly(name="ass", rbs=rbs, promoter=prom)
assert ass.rbs.mechanisms["mech"].name == mech_rbs.name
assert ass.promoter.mechanisms["mech"].name == mech_promoter.name
#Overwrite the assembly mechanism
#this should not propogate down to rbs or promoter!
ass.add_mechanism(mech_assembly)
assert mech_assembly.mechanism_type in ass.mechanisms
assert ass.rbs.mechanisms["mech"].name == mech_rbs.name
assert ass.promoter.mechanisms["mech"].name == mech_promoter.name
def test_mechanism_initialization(self):
from biocrnpyler import Mechanism
with self.assertWarns(Warning):
Mechanism(name='test_mech', mechanism_type=None)
with self.assertWarns(Warning):
Mechanism(name='test_mech')
def test_update_rbs():
T = Species("T")
D = Species("D")
P = Species("P")
rbs = RBS("rbs")
mech = Mechanism(name="mech", mechanism_type="assembly")
ass = DNAassembly("ass",
rbs=None,
promoter=None,
transcript=T,
dna=D,
protein=P,
mechanisms=[mech])
ass.update_rbs(rbs)
#test copying
assert ass.rbs != rbs
assert type(ass.rbs) == type(rbs)
assert ass.rbs.name == rbs.name
#test resetting transcript
assert ass.rbs.protein == P
#test mechanism inheritance
assert mech.mechanism_type in ass.rbs.mechanisms
def test_update_promoter():
T = Species("T")
D = Species("D")
P = Species("P")
prom = Promoter("prom")
mech = Mechanism(name="mech", mechanism_type="assembly")
ass = DNAassembly("ass",
rbs=None,
promoter=None,
transcript=T,
dna=D,
protein=P,
mechanisms=[mech])
ass.update_promoter(prom)
#test copying
assert ass.promoter != prom
assert type(ass.promoter) == type(prom)
assert ass.promoter.name == prom.name
#test resetting transcript
assert ass.promoter.transcript == T
#test mechanism inheritance
assert mech.mechanism_type in ass.promoter.mechanisms
def test_find_parameter(self):
"""Test the parameter defaulting heirarchy
Parameter defaulting heirarchy:
(mechanism_name, part_id, param_name) --> param_val. If that particular parameter key cannot be found,
the software will default to the following keys:
(mechanism_type, part_id, param_name) >> (part_id, param_name) >>
(mechanism_name, param_name) >> (mechanism_type, param_name) >>
(param_name) and give a warning. """
parameter_dict = {
(None, None, "k"): 1.0,
("M", None, "k"): 2.1,
("m", None, "k"): 2.2,
(None, "pid", "k"): 3,
("M", "pid", "k"): 4.1,
("m", "pid", "k"): 4.2,
}
M1 = Mechanism(name="m", mechanism_type="M")
M2 = Mechanism(name="m2", mechanism_type="M")
M3 = Mechanism(name="m3", mechanism_type="M2")
PD = ParameterDatabase(parameter_dictionary=parameter_dict)
self.assertEqual(
PD.find_parameter(mechanism=M3, part_id="id",
param_name="k").value, 1.0)
self.assertEqual(
PD.find_parameter(mechanism=M2, part_id="id",
param_name="k").value, 2.1)
self.assertEqual(
PD.find_parameter(mechanism=M1, part_id="id",
param_name="k").value, 2.2)
self.assertEqual(
PD.find_parameter(mechanism=M3, part_id="pid",
param_name="k").value, 3.0)
self.assertEqual(
PD.find_parameter(mechanism=M2, part_id="pid",
param_name="k").value, 4.1)
self.assertEqual(
PD.find_parameter(mechanism=M1, part_id="pid",
param_name="k").value, 4.2)