def test_ordered_polymer_species_contains(self):
a = Species("A")
b = Species("B")
bf = Species("B").set_dir("forward")
c = Complex([a, a])
p = OrderedPolymerSpecies([bf, b, c])
#In these cases, parent doesn't matter
self.assertTrue(a in p[2])
self.assertTrue(a in c)
self.assertTrue(b in p)
self.assertTrue(c in p)
p2 = OrderedPolymerSpecies([bf, a, c])
#In these cases parents matter
self.assertFalse(p[0] in p2)
self.assertFalse(p2[0] in p)
#In this case, direciton matters
self.assertFalse(b in p2)
def test_add_species(self):
species = Species('test_species')
mixture = Mixture()
mixture.add_species(species)
# test that the new mixture only contain one species
self.assertEqual([species], mixture.added_species)
# adding invalid species
with self.assertRaisesRegex(AssertionError,'only Species type is accepted!'):
mixture.add_species(['ok', 'ok'])
def test_species_initialization(self):
# tests naming convention repr without species type or attributes
species = Species(name='test_species')
self.assertEqual(repr(species), species.name)
# tests material type
species = Species(name='test_species', material_type="dna")
self.assertTrue(species.material_type == "dna")
# tests emtpy attributes
self.assertTrue(isinstance(species.attributes, list))
# tests naming convention via repr without attributes
self.assertEqual(repr(species),
species.material_type + "_" + species.name)
# tests adding attributes
attr_list = ['atr1', 'atr2']
species = Species(name='test_species', attributes=attr_list)
self.assertEqual(attr_list, species.attributes)
# tests naming convention with attributes and no material
correct_name = species.name
for attribute in species.attributes:
correct_name += "_" + attribute
self.assertEqual(repr(species), correct_name)
# tests initial condition by default should be 0
species = Species(name='test_species')
self.assertTrue(species.initial_concentration == 0)
# tests setting correct initial concentration
initial_concentration = 10
species = Species(name='test_species',
initial_concentration=initial_concentration)
self.assertEqual(species.initial_concentration, initial_concentration)
#test OrderedMonomer subclass
self.assertTrue(species.parent is None)
self.assertTrue(species.position is None)
self.assertTrue(species.direction is None)
def test_add_species(self):
from biocrnpyler import Mixture
from biocrnpyler import Species
species = Species('test_species')
mixture = Mixture()
mixture.add_species(species)
self.assertEqual([species], mixture.added_species)
with self.assertRaises(AssertionError):
mixture.add_species(['ok', 'ok'])
def test_species_equality(self):
# testing species equality
s1 = Species(name='a', material_type='mat1', attributes=['red'])
s2 = Species(name='a', material_type='mat1', attributes=['red'])
# if two species have the same name, material_type and attributes, then they are the same
self.assertTrue(s1 == s2)
s3 = Species(name='b', material_type='mat1', attributes=['red'])
# different species name: not the same species
self.assertFalse(s1 == s3)
s4 = Species(name='a', material_type='mat2', attributes=['red'])
# different material type: not the same species
self.assertFalse(s1 == s4)
s5 = Species(name='a',
material_type='mat1',
attributes=['red', 'large'])
# different attributes: not the same species
self.assertFalse(s1 == s5)
s6 = Species(name='a',
material_type='mat1',
attributes=['red'],
compartment='test_compartment')
# same species name in different compartments: not the same species
self.assertFalse(s1 == s6)
def test_initialization(self):
from biocrnpyler import CombinatorialPromoter, Protein, Species, Combinatorial_Cooperative_Binding
#initializing with one regulator that has no list
newprom = CombinatorialPromoter("testprom","treg1")
self.assertTrue(newprom.regulators == [Species("treg1",material_type="protein")])
#initializing with a list of strings
newprom2 = CombinatorialPromoter("testprom",["treg1","treg2"])
#it should convert strings into proteins
self.assertTrue(newprom2.regulators == [Species("treg1",material_type="protein"),
Species("treg2",material_type="protein")])
#by default, all complexes are tx capable
print(newprom2.tx_capable_list)
self.assertTrue(newprom2.tx_capable_list==[{"treg1"},{"treg2"},{"treg1","treg2"}])
#you should be able to define a tx_capable_list
newprom3 = CombinatorialPromoter("testprom",["treg1","treg2"],\
tx_capable_list=[["treg1","treg2"],["treg2"]])
self.assertTrue(newprom3.tx_capable_list==[{"treg1","treg2"},{"treg2"}])
#if you define it with a species in the regulators it should work
newprom4 = CombinatorialPromoter("testprom",["treg1",Species("treg2",material_type="rna")])
print(newprom4.tx_capable_list)
self.assertTrue(newprom4.tx_capable_list == [{"treg1"},{"treg2"},{"treg1","treg2"}])
self.assertTrue(newprom4.regulators == [Species("treg1",material_type="protein"),
Species("treg2",material_type="rna")])
#make sure the default mechanism is the correct one
self.assertTrue(isinstance(newprom4.mechanisms["binding"],Combinatorial_Cooperative_Binding))
def test_ordered_polymer_species_initialization(self):
a = Species("A")
x = OrderedPolymerSpecies([Species("A"),[Species("B"),"forward"],\
Species("C").set_dir("reverse")],attributes=["ooga"])
#repr
revtest = OrderedPolymerSpecies([Species("A",direction="forward"),Species("A")])
r1 = str(revtest)
revtest.reverse()
r2 = str(revtest)
self.assertEqual(type(r1),str)
self.assertNotEqual(r1,r2)
#pretty_print
self.assertEqual(type(x.pretty_print()),str)
#make sure we're copying
self.assertEqual(a.parent,None)
#make sure we're setting the properties of the components
self.assertEqual(x[0].parent,x)
self.assertEqual(x[1].parent,x)
self.assertEqual(x[2].parent,x)
self.assertEqual(x[1].direction,"forward")
self.assertEqual(x[2].direction,"reverse")
self.assertEqual(x[0].position,0)
self.assertEqual(x[1].position,1)
self.assertEqual(x[2].position,2)
#circularity
x.circular = True
self.assertEqual(x.circular, True)
self.assertIn("circular",x.attributes)
x.circular = False
self.assertEqual(x.circular, False)
self.assertNotIn("circular",x.attributes)
def test_species_initialization(self):
s1 = Species(name='s1')
s2 = Species(name='s2', material_type="m2")
# Check invalidity of ComplexSpecies with fewer than 2 component
with self.assertRaisesRegexp(ValueError,'chemical_reaction_network.complex requires '
'2 or more species in its constructor'):
ComplexSpecies([s1])
# Check invalidity of OrderedComplexSpecies with fewer than 2 component
with self.assertRaisesRegexp(ValueError, 'chemical_reaction_network.complex requires 2 '
'or more species in its constructor.'):
OrderedComplexSpecies([s1])
# Check invalidity of multimers with fewer than 2 component
with self.assertRaisesRegexp(ValueError, 'chemical_reaction_network.complex requires 2 '
'or more species in its constructor'):
Multimer(s1, 1)
# Check the naming conventions
oc1 = OrderedComplexSpecies([s2, s1])
c1 = ComplexSpecies([s2, s1])
m1 = Multimer(s1, 2)
c3 = ComplexSpecies([s1, s1])
# Check validity of ComplexSpecies, Multimers and OrderedComplexSpecies with strings instead of species
self.assertEqual(OrderedComplexSpecies([s2, "s1"]), oc1)
self.assertEqual(ComplexSpecies([s2, "s1"]), c1)
self.assertEqual(Multimer("s1", 2), m1)
# ComplexSpecies should sort the species added alphabetically by representation
self.assertEqual(repr(c1), "complex_"+repr(s2)+"_"+repr(s1))
# OrderedComplexSpecies do not sort their internal species
self.assertEqual(repr(oc1), "ordered_complex_"+repr(s2)+"_"+repr(s1))
# Multimers are just complexes with multiplicity
self.assertEqual(repr(m1), "complex_2x_"+repr(s1))
self.assertEqual(repr(c3), repr(m1))
def test_default_filtering(self):
#No filter dictionary used in these tests
s1 = Species("s1", material_type="m1", attributes=["a1"])
s2 = Species("s2", material_type="m2", attributes=["a2"])
c1 = Complex([s1, s2], name="c1")
c2 = Complex([c1, s2], name="c2")
#Always ON for all species
mech_default_on = GlobalMechanism(name=self.mech_name,
mechanism_type="dummy",
default_on=True)
self.assertTrue(
False not in
[mech_default_on.apply_filter(s) for s in [s1, s2, c1, c2]])
#Always OFF for all species
mech_default_off = GlobalMechanism(name=self.mech_name,
mechanism_type="dummy",
default_on=False)
self.assertTrue(
True not in
[mech_default_off.apply_filter(s) for s in [s1, s2, c1, c2]])
def test_update_species(self):
species = Species(name='H2O')
mixture = Mixture(species=[species])
self.assertTrue(species in mixture.update_species())
dna = DNA(name='test_DNA')
mixture.add_components(dna)
crn_list = mixture.update_species()
for s_dna in dna.update_species():
self.assertTrue(s_dna in crn_list)
def test_species_initial_condition_defaulting():
S1 = Species("S1")
S2 = Species("S2")
C = ChemicalComplex([S1, S2], name="C")
S3 = C.get_species()
mixture_name = "M"
key1 = ParameterKey(mechanism="initial concentration",
part_id=mixture_name,
name=str(S1))
key2 = ParameterKey(mechanism="initial concentration",
part_id=mixture_name,
name=str(S2))
key3 = ParameterKey(mechanism="initial concentration",
part_id=mixture_name,
name=str(S3))
C = ChemicalComplex([S1, S2],
name="C",
parameters={
key1: .11,
key2: .22
},
initial_concentration=.33)
M = Mixture(name=mixture_name,
components=[C],
parameters={
key1: 1.1,
key2: 2.2,
key3: 3.3
})
#Initial condition found under the Species name, in the Component, not Mixture
assert parameter_to_value(M.get_initial_concentration(S1, C)[S1]) == .11
assert parameter_to_value(M.get_initial_concentration(S2, C)[S2]) == .22
assert parameter_to_value(M.get_initial_concentration(S3, C)[S3]) == .33
def test_merging_weighted_species():
s1 = Species(name='a')
ws1 = WeightedSpecies(species=s1, stoichiometry=2)
ws2 = WeightedSpecies(species=s1, stoichiometry=5)
ws_list = [ws1, ws2]
freq_dict = WeightedSpecies._count_weighted_species(ws_list)
assert len(freq_dict) == 1
ws_merged = list(freq_dict.values())
assert ws_merged[0] == 7
s2 = Species(name='b')
ws1 = WeightedSpecies(species=s1, stoichiometry=2)
ws2 = WeightedSpecies(species=s2, stoichiometry=5)
ws_list = [ws1, ws2]
freq_dict = WeightedSpecies._count_weighted_species(ws_list)
assert len(freq_dict) == 2
ws_merged = list(freq_dict.values())
assert ws_merged[0] == 2
assert ws_merged[1] == 5
def test_compile_crn(self):
a = Species(name='a')
b = Species(name='b')
species_list = [a, b]
# creating a mock update function to decouple the update process from the rest of the code
def mock_update_reactions():
rxn = Reaction(inputs=[a], outputs=[b], k=0.1)
return [rxn]
rxn = Reaction(inputs=[a], outputs=[b], k=0.1)
CRN = ChemicalReactionNetwork(species_list, [rxn])
mixture = Mixture(species=species_list)
mixture.update_reactions = mock_update_reactions
crn_from_mixture = mixture.compile_crn()
# test that the mixture has the same species as the manually build CRN object
self.assertEqual(CRN.species, crn_from_mixture.species)
# test that the mixture has the same reactions as the manually build CRN object
self.assertEqual(CRN.reactions, crn_from_mixture.reactions)
def test_add_components(self):
mixture = Mixture()
# test that new mixture has no components
self.assertTrue(len(mixture.components) == 0)
component = Component('test_comp')
mixture.add_components(component)
# test that the new components was added to the mixture
self.assertTrue(component in mixture.components)
species = Species('test_species')
# species are invalid components
with self.assertRaisesRegexp(AssertionError,f'the object: {species} passed into mixture as component must be of the class Component'):
mixture.add_components(species)
def test_add_species_to_crn(self):
species = Species(name='H2O')
mixture = Mixture(species=[species])
mixture.add_species_to_crn(species, None)
self.assertTrue(species in mixture.crn.species)
dna = DNA(name='test_DNA')
mixture.add_components(dna)
mixture.add_species_to_crn(dna.update_species(), dna)
for s_dna in dna.update_species():
self.assertTrue(s_dna in mixture.crn.species)
def test_deg_tagged_degredation(self):
M = Mixture(parameters = {"kdeg":1, "kb":1, "ku":1})
protease = Species("P")
tagged_protein = Species("X", attributes = ["degtagged"])
untagged_protein = Species("Y")
#compare deg_Tagged_Degredation to MichaelisMenten
MM = MichaelisMenten(name = "name", mechanism_type = "type")
dtd = Deg_Tagged_Degredation(protease)
#test default global mechanism parameters
self.assertTrue(dtd.recursive_species_filtering is False)
self.assertTrue(dtd.default_on is False)
self.assertTrue("degtagged" in dtd.filter_dict)
self.assertTrue(dtd.filter_dict["degtagged"] is True)
self.assertTrue(len(dtd.filter_dict)==1)
#test default functionality on a tagged species
species = dtd.update_species(tagged_protein, M)
rxns = dtd.update_reactions(tagged_protein, M)
species_mm = MM.update_species(Enzyme = protease, Sub = tagged_protein, Prod = None)
rxns_mm = MM.update_reactions(Enzyme = protease, Sub = tagged_protein, Prod = None, kb=1, ku=1, kcat=1)
#species
self.assertTrue(species_mm == species)
#reactions
self.assertTrue(all([str(rxns[i]) == str(rxns_mm[i]) for i in range(len(rxns))]))
#Overwrite default_on, recursive_species_filtering, and filter_dict
dtd2 = Deg_Tagged_Degredation(protease, default_on = True, recursive_species_filtering = True, filter_dict = {"test":True})
self.assertTrue(dtd2.recursive_species_filtering is True)
self.assertTrue(dtd2.default_on is True)
self.assertTrue("degtagged" not in dtd2.filter_dict)
self.assertTrue("test" in dtd2.filter_dict and dtd2.filter_dict["test"] is True)
self.assertTrue(len(dtd2.filter_dict)==1)
def test_CombinatorialComplex_compute_species_to_add():
X, Y, Z = Species("X"), Species("Y"), Species("Z")
C = Complex([X, X, Y, Z])
CC = CombinatorialComplex(final_states = [C])
#A single X, Y, and Z should be added
species_to_add = CC.compute_species_to_add(X, C)
assert set(species_to_add) == set([X, Y, Z])
assert species_to_add.count(X) == 1 and species_to_add.count(Y) == 1 and species_to_add.count(Z) == 1
#Two X's, and Z should be added
species_to_add = CC.compute_species_to_add(Y, C)
assert set(species_to_add) == set([X, Z])
assert species_to_add.count(X) == 2 and species_to_add.count(Z) == 1
#Try with s0 as a ComplexSpecies
species_to_add = CC.compute_species_to_add(Complex([X, X]), C)
assert set(species_to_add) == set([Y, Z])
assert species_to_add.count(Y) == 1 and species_to_add.count(Z) == 1
#If sf is not a ComplexSpecies, there is an error
with pytest.raises(ValueError):
species_to_add = CC.compute_species_to_add(C, X)
#In the following cases, sf cannot be created by adding species to s0, so None is returned
#C contains more species than Complex([X, X])
species_to_add = CC.compute_species_to_add(C, Complex([X, Y]))
assert species_to_add is None
#C contains more species than Complex([X, X])
species_to_add = CC.compute_species_to_add(C, Complex([X, X]))
assert species_to_add is None
#S is not in C
species_to_add = CC.compute_species_to_add(Species("S"), C)
assert species_to_add is None
species_to_add = CC.compute_species_to_add(Complex([Species("S"), X]), C)
assert species_to_add is None
def pass_test_CombinatorialConformation_compute_complexes_to_add_to_polymer():
X, Y, Z = Species("X"), Species("Y"), Species("Z")
p0 = OrderedPolymerSpecies([X])
p1 = OrderedPolymerSpecies([X, Y, Z])
p2 = OrderedPolymerSpecies([Z, Y, X])
p3 = OrderedPolymerSpecies([Complex([X, X]), Y, Complex([X, Z])])
CC = CombinatorialConformation(initial_states=[], final_states=[])
#An empty list is returned if the Polymers are the same ("Nothing to add")
complexes_to_add = CC.compute_complexes_to_add_to_polymer(p0, p0)
assert len(complexes_to_add) == 0
#None is returned if the Polymers cannot be converted
complexes_to_add = CC.compute_complexes_to_add_to_polymer(p0, p1)
assert complexes_to_add == None
complexes_to_add = CC.compute_complexes_to_add_to_polymer(p1, p2)
assert complexes_to_add == None
#Basic Case
complexes_to_add = CC.compute_complexes_to_add_to_polymer(p1, p3)
assert len(complexes_to_add) == 2
assert (0, [X]) in complexes_to_add and (2, [X]) in complexes_to_add
#Nested Complex Case
p4 = OrderedPolymerSpecies(
[Complex([X, X]), Y, Complex([Z, Complex([X, X])])])
complexes_to_add = CC.compute_complexes_to_add_to_polymer(p1, p4)
assert len(complexes_to_add) == 2
assert (0, [X]) in complexes_to_add and (2, [Complex([X, X])
]) in complexes_to_add
#These cases should give errors
with pytest.raises(ValueError):
CC.compute_complexes_to_add_to_polymer(X, p4)
with pytest.raises(ValueError):
CC.compute_complexes_to_add_to_polymer(p1, X)
def test_add_attribute(self):
from biocrnpyler import Species
species = Species(name='test_species')
with self.assertRaises(AssertionError):
species.add_attribute({'k': 'v'})
species.add_attribute('attribute')
def test_add_attribute(self):
species = Species(name='test_species')
# an attribute must be a string
with self.assertRaisesRegexp(AssertionError,f'must be an alpha-numeric string'):
species.add_attribute({'k': 'v'})
species.add_attribute('attribute')
# testing whether a valid attribute has been added to the attribute list
self.assertTrue('attribute' in species.attributes)
def test_update_species(self):
from biocrnpyler import CombinatorialPromoter, Protein, Species, Combinatorial_Cooperative_Binding, \
DNAassembly,Transcription_MM, Translation_MM, Complex
#make a complicated promoter
newprom = CombinatorialPromoter("testprom",["treg1",Species("treg2",material_type="rna")],\
tx_capable_list = [["treg1","treg2"]],cooperativity={"testprom_treg2":1},leak=True)
sp_rnap = Species("RNAP",material_type="protein")
ribosome = Species("Ribo", material_type = "protein")
newdna = DNAassembly("testDNA",promoter=newprom)
newdna.add_mechanisms({"transcription":Transcription_MM(rnap = sp_rnap), "translation":Translation_MM(ribosome = ribosome)})
newdna.update_parameters(parameters={"cooperativity":2,"kb":100, "ku":10, "ktx":.05, "ktl":.2, "kdeg":2})
#Promoters are copied when added to DNAassemblies
newprom_copy = newdna.promoter
newprom_spec = newprom_copy.update_species()
sp_treg1 = Species("treg1",material_type="protein")
sp_treg2 = Species("treg2",material_type="rna")
sp_dna = Species("testDNA",material_type="dna")
sp_rna = Species("testDNA",material_type="rna")
cp_dna_rnap = Complex([sp_dna,sp_rnap])
cp_dna_treg1 = Complex([sp_dna,sp_treg1,sp_treg1])
cp_dna_treg2 = Complex([sp_dna,sp_treg2])
cp_dna_treg1_rnap = Complex([cp_dna_treg1,sp_rnap])
cp_dna_treg2_rnap = Complex([cp_dna_treg2,sp_rnap])
cp_dna_treg1_treg2 = Complex([sp_dna,sp_treg1,sp_treg1,sp_treg2])
cp_dna_treg1_treg2_rnap = Complex([cp_dna_treg1_treg2,sp_rnap])
knownspecies = [sp_dna,sp_rnap,sp_rna,cp_dna_rnap,cp_dna_treg1,\
cp_dna_treg2,cp_dna_treg1_treg2,cp_dna_treg1_rnap, \
cp_dna_treg2_rnap,cp_dna_treg1_treg2_rnap,sp_treg1,sp_treg2]
#these are the species that should come out
test_set = set([str(a) for a in newprom_spec])
mistake_found = False
error_txt = ""
for known_spec in knownspecies:
#go through and check each species if it's in the set generated by the promoter
if(str(known_spec) not in test_set):
error_txt += "\ncouldn't find "+str(known_spec)
mistake_found = True
if mistake_found:
raise ValueError(f"Mistake found in Species output:{error_txt}. Returned Species: {test_set}.")
#we should have the correct length of species
self.assertTrue(len(test_set)==len(knownspecies))
self.assertTrue(not mistake_found)
def test_promoter_terminator_DNAconstruct():
P = Promoter("pconst") #constitutive promoter
T = Terminator("term")
parameters = {
"cooperativity": 2,
"kb": 100,
"ku": 10,
"ktx": .05,
"ktl": .2,
"kdeg": 2,
"kint": .05
}
mechs = {
"transcription":
Transcription_MM(Species("RNAP", material_type="protein"))
}
#minimal RNA transcription
x = DNA_construct([P, T], mechanisms=mechs, parameters=parameters)
y = x.enumerate_components()
assert (y[0] == x[0]) #correct promoter is returned
assert (
x[0].transcript == y[1].get_species()
) #promoter in the DNA_construct has the correct transcript species
assert (y[1].promoter == x[0]
) #rna is linked back to the DNA_construct's promoter
assert (y[1].promoter == y[0]
) #correct promoter is returned by enumerate_constructs
#"incoherent" transcription
x = DNA_construct([[P, "reverse"], T],
mechanisms=mechs,
parameters=parameters)
y = x.enumerate_components()
assert (y == [x[0]]) #correct promoter is returned
#transcription in reverse works as well
x = DNA_construct([T, [P, "reverse"]],
mechanisms=mechs,
parameters=parameters)
y = x.enumerate_components()
assert (y[0] == x[1]) #correct promoter is returned
assert (
x[1].transcript == y[1].get_species()
) #promoter in the DNA_construct has the correct transcript species
assert (y[1].promoter == x[1]
) #rna is linked back to the DNA_construct's promoter
assert (y[1].promoter == y[0]
) #correct promoter is returned by enumerate_constructs
def test_complex_set_equality(self):
from biocrnpyler import Reaction
from biocrnpyler import Species
rxn1 = Reaction(inputs=[], outputs=[], k=0.1)
rxn2 = Reaction(inputs=[], outputs=[], k=0.1)
rtn = Reaction.complex_set_equality(c1=rxn1.inputs,
c1_coefs=rxn1.input_coefs,
c2=rxn2.inputs,
c2_coefs=rxn2.output_coefs)
self.assertTrue(rtn)
sp1 = Species(name='test_species_a')
sp2 = Species(name='test_species_b')
rxn1 = Reaction(inputs=[sp1], outputs=[], k=0.1)
rxn2 = Reaction(inputs=[sp2], outputs=[], k=0.1)
rtn2 = Reaction.complex_set_equality(c1=rxn1.inputs,
c1_coefs=rxn1.input_coefs,
c2=rxn2.inputs,
c2_coefs=rxn2.output_coefs)
self.assertFalse(rtn2)
def test_reaction_protection(self):
#tests that Reactions cannot be changed once they are in a CRN
S = Species("S")
S2 = Species("S2")
R = Reaction.from_massaction([S], [S2], k_forward=1.0)
R2 = Reaction.from_massaction([S2], [S], k_forward=1.0)
CRN = ChemicalReactionNetwork([S, S2], [R])
#Internal reactions copied correctly to return
assert R in CRN.reactions
assert not R is CRN._reactions[0]
#Returned list does not effect internal reactions
CRN.reactions[0] = R2
assert R2 not in CRN.reactions
#add reactions effects internal reaction list
CRN.add_reactions(R2)
assert R2 in CRN.reactions
assert not R2 is CRN._reactions[1]
with self.assertRaisesRegex(
AttributeError,
"The reactions in a CRN cannot be removed or modified*"):
CRN.reactions = []
#test bypassing reaction protection
CRN = ChemicalReactionNetwork([], [])
CRN.add_reactions([R], copy_reactions=False)
assert R is CRN._reactions[0]
assert S in CRN.species
#test bypassing reaction protection
CRN = ChemicalReactionNetwork([], [])
CRN.add_reactions([R], add_species=False)
assert not S in CRN.species
def test_reaction_initialization(self):
# warns if both input and output species are empty
mak = MassAction(k_forward=0.1)
with self.assertWarns(Warning):
Reaction(inputs=[], outputs=[], propensity_type=mak)
# test for invalid propensity type
with self.assertRaises(ValueError):
Reaction(inputs=[], outputs=[], propensity_type=Species)
# input must be a valid species object
with self.assertRaises(TypeError):
Reaction(inputs=['a'], outputs=[], propensity_type=mak)
# output must be a valid species object
with self.assertRaises(TypeError):
Reaction(inputs=[], outputs=['b'], propensity_type=mak)
rxn = Reaction.from_massaction(inputs=[], outputs=[], k_forward=0.1, k_reverse=1)
# test whether the reaction is registered as reversible
self.assertTrue(rxn.is_reversible)
# test whether the reaction is registered as massaction
self.assertTrue(isinstance(rxn.propensity_type, MassAction))
# test WeightedSpecies inputs
sp1 = Species(name='test_species_a')
sp2 = Species(name='test_species_b')
chem_com_sp1 = WeightedSpecies(species=sp1, stoichiometry=2)
chem_com_sp2 = WeightedSpecies(species=sp2, stoichiometry=1)
Reaction(inputs=[chem_com_sp1], outputs=[chem_com_sp2], propensity_type=MassAction(k_forward=1))
# test different input and output lists
Reaction(inputs=[chem_com_sp1], outputs=[sp2], propensity_type=MassAction(k_forward=1))
# mixing WeightedSpecies and Species is not allowed
with self.assertRaises(TypeError):
Reaction(inputs=[chem_com_sp1, sp2], outputs=[sp1], propensity_type=MassAction(k_forward=1))
def test_add_components(self):
from biocrnpyler import Mixture
from biocrnpyler import Component
from biocrnpyler import Species
mixture = Mixture()
self.assertTrue(len(mixture.components) == 0)
component = Component('test_comp')
mixture.add_components(component)
self.assertTrue(component in mixture.components)
species = Species('test_species')
with self.assertRaises(AssertionError):
mixture.add_components(species)
def test_rna_degredation_mm(self):
M = Mixture(parameters = {"kdeg":1, "kb":1, "ku":1})
rnaase = Species("P")
rna = Species("X", material_type = "rna")
#compare deg_Tagged_Degredation to MichaelisMenten
MM = MichaelisMenten(name = "name", mechanism_type = "type")
rdmm = Degredation_mRNA_MM(rnaase)
#test default global mechanism parameters
self.assertTrue(rdmm.recursive_species_filtering is True)
self.assertTrue(rdmm.default_on is False)
self.assertTrue("rna" in rdmm.filter_dict)
self.assertTrue(rdmm.filter_dict["rna"] is True)
self.assertTrue(len(rdmm.filter_dict)==2)
#test default functionality on a tagged species
species = rdmm.update_species(rna, M)
rxns = rdmm.update_reactions(rna, M)
species_mm = MM.update_species(Enzyme = rnaase, Sub = rna, Prod = None)
rxns_mm = MM.update_reactions(Enzyme = rnaase, Sub = rna, Prod = None, kb=1, ku=1, kcat=1)
#species
self.assertTrue(species_mm == species)
#reactions
self.assertTrue(all([str(rxns[i]) == str(rxns_mm[i]) for i in range(len(rxns))]))
#Overwrite default_on, recursive_species_filtering, and filter_dict
rdmm2 = Degredation_mRNA_MM(rnaase, default_on = True, recursive_species_filtering = False, filter_dict = {"test":True})
self.assertTrue(rdmm2.recursive_species_filtering is False)
self.assertTrue(rdmm2.default_on is True)
self.assertTrue("rna" not in rdmm2.filter_dict)
self.assertTrue("test" in rdmm2.filter_dict and rdmm2.filter_dict["test"] is True)
self.assertTrue(len(rdmm2.filter_dict)==1)
def test_degenerate_polymer_conformation():
S = Species("S")
p = OrderedPolymerSpecies([S, S, S])
pc = PolymerConformation(polymer=p)
c1 = Complex([pc.polymers[0][0], pc.polymers[0][1]])
pc1 = c1.parent
c2 = Complex([pc.polymers[0][1], pc.polymers[0][2]])
pc2 = c2.parent
c3 = Complex([pc.polymers[0][0], pc.polymers[0][2]])
pc3 = c3.parent
assert pc1 != pc2 != pc3
def test_update_species(self):
from biocrnpyler import CombinatorialPromoter, Protein, Species, Combinatorial_Cooperative_Binding, \
DNAassembly,Transcription_MM, Translation_MM, Multimer, ComplexSpecies
#make a complicated promoter
newprom = CombinatorialPromoter("testprom",["treg1",Species("treg2",material_type="rna")],\
tx_capable_list = [["treg1","treg2"]],cooperativity={"testprom_treg2":1},leak=True)
newdna = DNAassembly("testDNA", promoter=newprom)
newdna.update_mechanisms(mechanisms={
"transcription": Transcription_MM(),
"translation": Translation_MM()
})
newdna.update_parameters(
parameters={
"cooperativity": 2,
"kb": 100,
"ku": 10,
"ktx": .05,
"ktl": .2,
"kdeg": 2
})
newprom_spec = newprom.update_species()
sp_treg1 = Species("treg1", material_type="protein")
sp_treg2 = Species("treg2", material_type="rna")
#mu_treg2 = Multimer(sp_treg2,2)
sp_dna = Species("testDNA", material_type="dna")
sp_rnap = Species("RNAP", material_type="protein")
sp_rna = Species("testDNA", material_type="rna")
cp_dna_rnap = ComplexSpecies([sp_dna, sp_rnap])
cp_dna_treg1 = ComplexSpecies([sp_dna, sp_treg1, sp_treg1])
cp_dna_treg2 = ComplexSpecies([sp_dna, sp_treg2])
cp_dna_treg1_rnap = ComplexSpecies([cp_dna_treg1, sp_rnap])
cp_dna_treg2_rnap = ComplexSpecies([cp_dna_treg2, sp_rnap])
cp_dna_treg1_treg2 = ComplexSpecies(
[sp_dna, sp_treg1, sp_treg1, sp_treg2])
cp_dna_treg1_treg2_rnap = ComplexSpecies([cp_dna_treg1_treg2, sp_rnap])
knownspecies = [sp_dna,sp_rnap,sp_rna,cp_dna_rnap,cp_dna_treg1,\
cp_dna_treg2,cp_dna_treg1_treg2,cp_dna_treg1_rnap, \
cp_dna_treg2_rnap,cp_dna_treg1_treg2_rnap]
#these are the species that should come out
test_set = set([str(a) for a in newprom_spec])
mistake_found = False
#we should have the correct length of species
self.assertTrue(len(test_set) == len(knownspecies))
for known_spec in knownspecies:
#go through and check each species if it's in the set generated by the promoter
if (str(known_spec) not in test_set):
print("couldn't find " + str(known_spec))
mistake_found = True
break
self.assertTrue(not mistake_found)
def test_weighted_species_init():
s1 = Species(name='a')
# normal operations
ws1 = WeightedSpecies(species=s1)
assert ws1.species == s1
assert ws1.stoichiometry == 1
with pytest.raises(ValueError,
match='Stoichiometry must be positive integer!'):
WeightedSpecies(species=s1, stoichiometry=0)
with pytest.raises(ValueError,
match='Stoichiometry must be positive integer!'):
WeightedSpecies(species=s1, stoichiometry=-1)
ws2 = WeightedSpecies(species=s1, stoichiometry=1.34)
assert ws2.stoichiometry == 1
