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)