def test_single_polymer_single_complex_instantiation(): p = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c1 = ComplexSpecies([p[0], p[1], Species("S")], called_from_complex=True) pc = PolymerConformation(complexes=[c1]) #Test naming convention assert str(pc) == f"conformation__{p}_np0l0p0l1_{c1}_" p2 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m4")]) c2 = ComplexSpecies([p[0], p2[0]], called_from_complex=True) #In these cases, TypeErrors should be raised with pytest.raises(ValueError): #Emtpy complexes is not allowed pc2 = PolymerConformation(complexes=[]) with pytest.raises(ValueError): #set a PolymerConformation as a parent of the Species. S = Species("S") S.parent = pc c3 = ComplexSpecies([p[0], S], called_from_complex=True) pc2 = PolymerConformation(complexes=[c3]) with pytest.raises(ValueError): #Cannot place an entire polymer into a Complex S = Species("S") S.parent = pc c3 = ComplexSpecies([p, S], called_from_complex=True) pc2 = PolymerConformation(complexes=[c3])
def test_complex_with_polymer_replacement(): #These tests show how the order of binding can matter. #Best practices is to put everything into a PolymerConformation before doing Complex if PolymerConformations are being used. a = Species('A') b = Species('B') s = Species("S") p = OrderedPolymerSpecies([a, b, a]) pc0 = PolymerConformation( polymer=p) #Put the polymer inside a conformation #Bind two monomers together pc = Complex([pc0.polymers[0][0], pc0.polymers[0][1]]).parent #get a PolymerConformation assert isinstance(pc, PolymerConformation) #create a Complex around an unbound element of p (from within pc) c = Complex([s, pc.polymers[0][2], s], ordered=True) assert str(c) == str( OrderedComplexSpecies([s, p[2], s], called_from_complex=True)) assert str(pc.polymers[0]) == str(c.parent.polymers[0]) assert len(c.parent.complexes) > len(pc.complexes) #Make the same thing with the replacement first #this gives a different final complex than doing things in the previous order p2 = OrderedPolymerSpecies([a, b, Complex([s, a, s], ordered=True)]) pc2 = PolymerConformation(polymer=p2) assert str(c.parent) != str(p2) assert c.parent.parent != Complex([pc2.polymers[0][0], pc2.polymers[0][1] ]).parent
def test_get_complex(): p = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c1 = ComplexSpecies([p[0], p[1], Species("S")], called_from_complex=True) pc = PolymerConformation(complexes=[c1]) assert str(pc.get_complex(c1)) == str( c1 ) #these are not technically equal because they have different parents
def test_complex_with_single_polymer(): a = Species('A') b = Species('B') p = OrderedPolymerSpecies([a, b, a]) #This should just produce a ComplexSpecies around the PolymerSpecies c2 = Complex([p, Species("S")]) assert c2 == ComplexSpecies([p, Species("S")], called_from_complex=True) #If the Polymer is in a Conformation, it cannot be Complexed. pc = PolymerConformation(polymer=p) assert str(pc.polymers[0]) == str(p) assert pc.polymers[0].parent == pc assert p.parent is None with pytest.raises(ValueError): c2 = Complex([pc.polymers[0], Species("S")]) #A monomer form the polymer can still be complexed, however c2 = Complex([pc.polymers[0][0], Species("S")]) assert isinstance(c2.parent, PolymerConformation) assert c2.parent != pc assert len(c2.parent.complexes) == 1 assert len(c2.parent.polymers) == 1 assert str(c2) == str( ComplexSpecies([pc.polymers[0][0], Species("S")], called_from_complex=True))
def test_complex_with_a_complex_in_a_conformation(): #This occurs when Complexes are formed around Complexes in PolymerConformations. #In these cases, the Complexes are merged to prevent nested Complexes inside of PolymerConformations. #Using ordered = True to test that order is preserved a = Species('A') b = Species('B') c = Species('C') p = OrderedPolymerSpecies([a, b, c]) pc0 = PolymerConformation(polymer=p) pc = Complex([pc0.polymers[0][0], pc0.polymers[0][1]], ordered=True).parent #get a PolymerConformation c = pc.complexes[0] #get a complex from the PolymerConformation c2 = Complex([c, Species("S")], ordered=True) #Create a Complex with a Complex pc2 = c2.parent assert str(c2) == str(OrderedComplexSpecies([p[0], p[1], Species("S") ])) #merging done correctly assert pc2 == Complex( [pc0.polymers[0][0], pc0.polymers[0][1], Species("S")], ordered=True).parent #check the parent PolymerConformation assert len(pc2.complexes) == 1 #Create a PolymerConformation with two complexes c3 = Complex([pc2.polymers[0][0], pc2.polymers[0][2], Species("S2")], ordered=True) pc3 = c3.parent assert len(pc3.complexes) == 2 assert str(c3) == str( OrderedComplexSpecies([p[0], p[2], Species("S2")], called_from_complex=True)) #merge the two complexes in pc3 c4 = Complex([pc3.complexes[0], pc3.complexes[1], Species("S3")], ordered=True) assert len(c4.parent.complexes) == 1 assert str(c4) == str( Complex([ pc0.polymers[0][0], pc0.polymers[0][1], Species("S"), pc0.polymers[0][0], pc0.polymers[0][2], Species("S2"), Species("S3") ], ordered=True)) assert c4.parent == Complex([ pc0.polymers[0][0], pc0.polymers[0][1], Species("S"), pc0.polymers[0][0], pc0.polymers[0][2], Species("S2"), Species("S3") ], ordered=True).parent
def test_polymer_conformation_no_complex_instantiation(): p = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) pc = PolymerConformation(polymer=p) c1 = ComplexSpecies([p[0], p[1], Species("S")], called_from_complex=True) assert str(pc) == str(p) #these should have the same name! assert str(p) == str(pc.polymers[0]) assert len(pc.complexes) == 0 pc2 = PolymerConformation( polymer=[Species("m1"), Species("m2"), Species("m3")]) assert pc2 == pc with pytest.raises(ValueError): pc = PolymerConformation(polymer=["A", None]) with pytest.raises(NotImplementedError): pc = PolymerConformation(polymer=[p, p]) with pytest.raises(ValueError): pc = PolymerConformation(polymer=p, complexes=[c1]) with pytest.raises(ValueError): pc = PolymerConformation()
def test_complex_with_multiple_polymers(): a = Species('A') b = Species('B') p = OrderedPolymerSpecies([a, b, a]) pc0 = PolymerConformation(polymer=p) p2 = OrderedPolymerSpecies([b, a, b]) pc2 = PolymerConformation(polymer=p2) #Bind one two monomers from one polymer #Polymers must be placed into a Conformation before being bound together with pytest.raises(TypeError): c = Complex([Species("S"), p[0], p[2]]) c = Complex([Species("S"), pc0.polymers[0][0], pc0.polymers[0][2]]) #Correct parent assert c.parent == PolymerConformation( [ComplexSpecies([Species("S"), p[0], p[2]], called_from_complex=True)]) #correct complex returned assert str(c) == str( ComplexSpecies([Species("S"), p[0], p[2]], called_from_complex=True)) #Ordered Case oc = Complex([Species("S"), pc0.polymers[0][0], pc0.polymers[0][2]], ordered=True) #Correct parent assert oc.parent == PolymerConformation([ OrderedComplexSpecies([Species("S"), p[0], p[2]], called_from_complex=True) ]) #correct complex returned assert str(oc) == str( OrderedComplexSpecies([Species("S"), p[0], p[2]], called_from_complex=True)) #Two polymers which bind together #Polymers must be placed into a Conformation before being bound together with pytest.raises(TypeError): c2 = Complex([Species("S"), p[0], p2[1]]) c2 = Complex([Species("S"), pc0.polymers[0][0], pc2.polymers[0][1]]) assert c2.parent == PolymerConformation([ ComplexSpecies([Species("S"), p[0], p2[1]], called_from_complex=True) ]) assert str(c2) == str( ComplexSpecies([Species("S"), p[0], p2[1]], called_from_complex=True)) #Two polymers already bound together in a Conformation interacting at a new location l1 = c2.parent.polymers[0][1] l2 = c2.parent.polymers[1][0] c3 = Complex([l1, l2], ordered=True) assert c3.parent == PolymerConformation([ ComplexSpecies([Species("S"), p[0], p2[1]], called_from_complex=True), OrderedComplexSpecies([p[1], p2[0]], called_from_complex=True) ]) assert str(c3) == str( OrderedComplexSpecies([p[1], p2[0]], called_from_complex=True))
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_multiple_polymer_multiple_complex_instantiation(): p1 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) p2 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m4")]) c1 = ComplexSpecies([p1[0], p1[1]], called_from_complex=True) c2 = ComplexSpecies([p1[0], p2[2]], called_from_complex=True) c3 = ComplexSpecies([Species("S1"), Species("S2")], called_from_complex=True) pc1 = PolymerConformation(complexes=[c1, c2]) #Check naming convention assert str(pc1) == f"conformation__{p1}_{p2}_p0l0p0l1_{c1}_p0l0p1l2_{c2}_" #check that order doesn't matter pc1_r = PolymerConformation(complexes=[c2, c1]) assert pc1 == pc1_r #check that ComplexSpecies with the same string representation but different polymers are treated differently c1b = ComplexSpecies( [p2[1], p1[0]], called_from_complex=True ) #c1 and c1b have the same string representation - but connect different polymers pc1b = PolymerConformation(complexes=[c1b, c2]) assert str(pc1b) == f"conformation__{p1}_{p2}_p0l0p1l1_{c1}_p0l0p1l2_{c2}_" assert pc1 != pc1b #Check that order doesn't matter for Complexes with the same string representation pc1br = PolymerConformation(complexes=[c2, c1b]) #reverse case assert pc1b == pc1br pc2 = PolymerConformation(complexes=[c1, c2]) pc2b = PolymerConformation(complexes=[c1b, c2]) assert pc2 != pc2b #In these cases, value errors should be raised with pytest.raises(ValueError): #c3 is not part of the conformation pc = PolymerConformation(complexes=[c1, c3]) #try 2 polymers with complexes that look the same p3 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c4 = ComplexSpecies([p1[0], p3[0]]) pc3 = PolymerConformation([c1, c4]) assert str(pc3) == f"conformation__{p1}_{p1}_p0l0p0l1_{c1}_p0l0p1l0_{c4}_" #check that order doesn't matter for polymers which look the same pc3r = PolymerConformation([c4, c1]) assert pc3 == pc3r with pytest.raises(ValueError): #duplicate Complexes are not allowed (same object case) pc4 = PolymerConformation([c1, c1]) c1b = ComplexSpecies([p1[0], p1[1]], called_from_complex=True) with pytest.raises(ValueError): #duplicate Complexes are not allowed (identical object case) pc4 = PolymerConformation([c1, c1b])
def test_polymer_conformation_ordered_polymer_species_name_equality(): p = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) pc = PolymerConformation(polymer=p) assert str(p) == str(pc)
def test_from_polymer_replacement(): #tests the classmethod .from_polymer_replacement #Produce a PolymerConformation p1 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c1 = ComplexSpecies( [p1[0], p1[1], Species("S"), Species("S")], called_from_complex=True) pc1 = PolymerConformation(complexes=[c1]) #Produce a second Polymer p2 = OrderedPolymerSpecies([Species("m3"), Species("m2"), Species("m1")]) #replace p1 with p2 pc1_replaced = PolymerConformation.from_polymer_replacement( pc1, [pc1.polymers[0]], [p2]) #This should be equivalent to creating a new PolymerConformation c2 = ComplexSpecies( [p2[0], p2[1], Species("S"), Species("S")], called_from_complex=True) pc2 = PolymerConformation(complexes=[c2]) assert pc1_replaced == pc2 #Replacing a Polymer with the same polymer is valid, but doesn't do anything pc1_replaced_b = PolymerConformation.from_polymer_replacement( pc1, [pc1.polymers[0]], [p1]) assert pc1_replaced_b == pc1 #These conditions should raise ValueErrors with pytest.raises(TypeError): PolymerConformation.from_polymer_replacement(pc1, [pc1.polymers[0]], None) with pytest.raises(ValueError): PolymerConformation.from_polymer_replacement(pc1, [None], [p2]) with pytest.raises(TypeError): PolymerConformation.from_polymer_replacement(pc1, [pc1.polymers[0]], [None]) with pytest.raises(ValueError): PolymerConformation.from_polymer_replacement(pc1, [p1], [p2]) with pytest.raises(ValueError): PolymerConformation.from_polymer_replacement(pc1, [pc1.polymers[0]], [p1, p2]) with pytest.raises(TypeError): PolymerConformation.from_polymer_replacement(None, [pc1.polymers[0]], [p1, p2])
def test_from_polymer_conformation(): #tests the classmethod .from_polymer_conformation #Produce a PolymerConformation p1 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c1 = ComplexSpecies([p1[0], p1[1]], called_from_complex=True) pc1 = PolymerConformation(complexes=[c1]) #This Complex uses the polymer inside the pc1 so there is only a single polymer in the final PolymerConformation c1b = ComplexSpecies([pc1.polymers[0][0], pc1.polymers[0][2]], called_from_complex=True) c1bb = ComplexSpecies([p1[0], p1[2]]) pc1b = PolymerConformation.from_polymer_conformation([pc1], [c1b]) #This is correct (and checking ordering effects don't matter) assert pc1b == PolymerConformation([c1, c1bb]) == PolymerConformation( [c1bb, c1]) #This is incorrect because of polymers being copied into conformations assert pc1b != PolymerConformation([c1, c1b]) #This Complex uses the old Polymer Instance which will represent the binding to a new, identical, PolymerSpecies #all three of the following therefore should be the same c1c = ComplexSpecies([p1[0], p1[2]], called_from_complex=True) pc1c = PolymerConformation.from_polymer_conformation([pc1], [c1c]) p1d = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m3")]) c1d = ComplexSpecies([p1d[0], p1d[2]], called_from_complex=True) pc1d = PolymerConformation.from_polymer_conformation([pc1], [c1c]) #Create directly pc1e = PolymerConformation([c1d, c1]) pc1er = PolymerConformation([c1, c1d]) #Order shouldn't matter assert pc1c == pc1d == pc1e == pc1er #Test from multiple PolymerConformations p2 = OrderedPolymerSpecies([Species("m1"), Species("m2"), Species("m4")]) c2 = ComplexSpecies([p2[0], p2[1]], called_from_complex=True) pc2 = PolymerConformation(complexes=[c2]) #Create a PolymerConformation that links the two Polymers together c3 = ComplexSpecies([p1[0], p1[1]], called_from_complex=True) pc3 = PolymerConformation([c3]) #Add an additional binding site connecting pc2 and pc3 c4 = ComplexSpecies([pc3.polymers[0][0], pc2.polymers[0][1] ]) #get the conformations polymers due to copying pc4 = PolymerConformation.from_polymer_conformation([pc2, pc3], [c4]) c4b = ComplexSpecies([p1[0], p2[1]]) assert pc4 == PolymerConformation([c2, c3, c4b]) == PolymerConformation( [c4b, c2, c3]) #And order doesn't matter assert pc4 != PolymerConformation( [c2, c3, c4]) #This should be different due to copying #The following should produce errors with pytest.raises(TypeError): pc1b = PolymerConformation.from_polymer_conformation(pc1, [c1b]) with pytest.raises(TypeError): pc1b = PolymerConformation.from_polymer_conformation([c1b], [c1b])
def test_CombinatorialConformation_init(): #Test getters and setters of properties via init X, Y, Z = Species("X"), Species("Y"), Species("Z") C = Complex([X, X]) p1 = OrderedPolymerSpecies([X, Y, Z]) pc0 = PolymerConformation(polymer=p1) pc1 = Complex([pc0.polymers[0][0], pc0.polymers[0][2] ]).parent #this gets the PolymerConformation CC1 = CombinatorialConformation(initial_states=[pc0], final_states=[pc1]) assert len(CC1.initial_states) == 1 and len(CC1.final_states) == 1 pc1b = Complex([pc0.polymers[0][2], Z]).parent CC1b = CombinatorialConformation(initial_states=[pc0], final_states=[pc1b]) assert len(CC1.initial_states) == 1 and len(CC1.final_states) == 1 pc1c = Complex([pc1b.polymers[0][0], pc1b.polymers[0][1]]).parent CC1c0 = CombinatorialConformation(initial_states=None, final_states=[pc1b, pc1c]) assert len(CC1c0.final_states) == 2 assert len(CC1c0.initial_states) == 1 CC1c1 = CombinatorialConformation(initial_states=[pc0, pc1b], final_states=[pc1c]) assert len(CC1c1.initial_states) == 2 #The following should produce errors: p2 = OrderedPolymerSpecies([Z, Y, X]) pc2 = Complex( [pc1.polymers[0][1], PolymerConformation(polymer=p2).polymers[0][1]]).parent with pytest.raises(ValueError): #Multiple internal polymers CC = CombinatorialConformation(initial_states=[pc1], final_states=[pc2]) with pytest.raises(ValueError): #Multiple internal polymers CC = CombinatorialConformation(initial_states=[pc0, pc1], final_states=[pc2]) with pytest.raises(ValueError): #Multiple internal polymers CC = CombinatorialConformation(initial_states=[pc0], final_states=[pc1], intermediate_states=[pc2]) with pytest.raises(ValueError): #Multiple internal polymers CC = CombinatorialConformation(initial_states=[pc0], final_states=[pc2], excluded_states=[pc1]) with pytest.raises(ValueError): #Multiple internal polymers CC = CombinatorialConformation(initial_states=[pc0], final_states=[pc1], excluded_states=[pc2]) #Non PolymerConformations passed as initial/final/intermediate states with pytest.raises(ValueError): CC = CombinatorialConformation(initial_states=[C], final_states=[pc1]) with pytest.raises(ValueError): CC = CombinatorialConformation(initial_states=[pc0], final_states=[C]) with pytest.raises(ValueError): CC = CombinatorialConformation(initial_states=[pc0], final_states=[pc1], intermediate_states=[C]) with pytest.raises(ValueError): CC = CombinatorialConformation(initial_states=[pc0], final_states=[pc1], excluded_states=[C])
def test_update_species_and_reactions(): params = {"kf": 1, "kr": 1} X, Y, Z, S = Species("X"), Species("Y"), Species("Z"), Species("S") C = Complex([X, X]) p0 = OrderedPolymerSpecies([X, Y, Z, C]) pc0 = PolymerConformation(polymer=p0) c1 = Complex([pc0.polymers[0][0], pc0.polymers[0][1]]) pc1 = c1.parent c2 = Complex( [pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], S, S]) pc2 = c2.parent c3 = Complex([pc1.polymers[0][2], pc1.polymers[0][3], Z]) pc3 = c3.parent c4 = Complex([ pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], pc0.polymers[0][3], Z ]) pc4 = c4.parent #No conformation changes are possible CC0 = CombinatorialConformation(initial_states=[], final_states=[pc0], parameters=params) species = CC0.update_species() reactions = CC0.update_reactions() assert len(species) == 0 assert len(reactions) == 0 #Only a single binding reaction can occur CC1 = CombinatorialConformation(initial_states=[], final_states=[pc1], parameters=params) species = CC1.update_species() reactions = CC1.update_reactions() assert len(species) == 2 assert pc1 in species and pc0 in species assert len(reactions) == 1 #This should be the same as above, by default CC1b = CombinatorialConformation(initial_states=[pc0], final_states=[pc1], parameters=params) species = CC1b.update_species() reactions = CC1b.update_reactions() assert len(species) == 2 assert pc1 in species and pc0 in species assert len(reactions) == 1 #Test multiple final states CC2 = CombinatorialConformation(initial_states=[pc0], final_states=[pc1, pc2], parameters=params) species = CC2.update_species() reactions = CC2.update_reactions() assert len(species) == 4 assert pc1 in species and pc0 in species and pc2 in species and S in species assert len(reactions) == 2 #Test multiple pathways CC3 = CombinatorialConformation(initial_states=[pc0], final_states=[pc3], parameters=params) species = CC3.update_species() reactions = CC3.update_reactions() assert len(species) == 5 assert pc1 in species and pc0 in species and pc3 in species and Z in species assert len(reactions) == 4 #Test intermediate states CC3b = CombinatorialConformation(initial_states=[pc0], intermediate_states=[pc1], final_states=[pc3], parameters=params) species = CC3b.update_species() reactions = CC3b.update_reactions() assert len(species) == 4 assert pc1 in species and pc0 in species and pc1 in species and Z in species and pc3 in species assert len(reactions) == 2 #Test excluded intermediate states CC3c = CombinatorialConformation(initial_states=[pc0], excluded_states=[pc1], final_states=[pc3], parameters=params) species = CC3c.update_species() reactions = CC3c.update_reactions() assert len(species) == 4 assert pc0 in species and pc1 not in species and Z in species and pc3 in species assert len(reactions) == 2 #Test adding a dead end intermediate species CC3c = CombinatorialConformation(initial_states=[pc0], intermediate_states=[pc1, pc2], final_states=[pc3], parameters=params) species = CC3c.update_species() reactions = CC3c.update_reactions() assert len(species) == 6 assert pc0 in species and pc1 in species and Z in species and pc3 in species and pc2 in species and S in species assert len(reactions) == 3 #Test expanding a pathway through intermediates CC4a = CombinatorialConformation(initial_states=[pc0], final_states=[pc4], parameters=params) species = CC4a.update_species() reactions = CC4a.update_reactions() assert len(species) == 3 assert pc0 in species and pc4 in species assert len(reactions) == 1 CC4b = CombinatorialConformation(initial_states=[pc0], intermediate_states=[pc3], final_states=[pc4], parameters=params) species = CC4b.update_species() reactions = CC4b.update_reactions() assert len(species) == 6 assert pc0 in species and pc4 in species and pc1 in species and pc3 in species assert len(reactions) == 5
def test_get_combinations_between(): X, Y, Z, S = Species("X"), Species("Y"), Species("Z"), Species("S") C = Complex([X, X]) p0 = OrderedPolymerSpecies([X, Y, Z, C]) pc0 = PolymerConformation(polymer=p0) c1 = Complex([pc0.polymers[0][0], pc0.polymers[0][1]]) pc1 = c1.parent c2 = Complex( [pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], S, S]) pc2 = c2.parent c3 = Complex([pc1.polymers[0][2], pc1.polymers[0][3], Z]) pc3 = c3.parent c4 = Complex([ pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], pc0.polymers[0][3], Z ]) pc4 = c4.parent c5a = Complex([pc0.polymers[0][0], pc0.polymers[0][2]]) pc5a = c5a.parent c5b = Complex([pc5a.polymers[0][1], pc5a.polymers[0][3]]) pc5b = c5b.parent print("pc0", pc0, "\npc1", pc1, "\npc2", pc2, "\npc3", pc3, "\npc4", pc4) #Arguments here don't matter in this test CC = CombinatorialConformation(initial_states=[], intermediate_states=[], final_states=[pc3]) #No additional species added perms = CC.get_combinations_between(s0=pc0, sf=pc1) assert len(perms) == 1 #External Species added perms = CC.get_combinations_between(s0=pc0, sf=pc2) assert len(perms) == 1 #Multiple Complexes created perms = CC.get_combinations_between(s0=pc0, sf=pc3) assert len(perms) == 4 #A single complex created, from a conformation with complexes perms = CC.get_combinations_between(s0=pc1, sf=pc3) assert len(perms) == 1 #Adding species to an existing Complex perms = CC.get_combinations_between(s0=pc1, sf=pc2) assert len(perms) == 1 #adding species (including inside the polymer) to an existing complex perms = CC.get_combinations_between(s0=pc1, sf=pc4) assert len(perms) == 1 #merging two complexes perms = CC.get_combinations_between(s0=pc3, sf=pc4) assert len(perms) == 1 #Adding an excluded_state #excluded_state matters here CC = CombinatorialConformation(initial_states=[], excluded_states=[pc1], final_states=[pc3]) perms = CC.get_combinations_between(s0=pc0, sf=pc3) assert len(perms) == 2 #Cases where compute_species_changes should return False #s0 contains more species/complexes than sf assert len(CC.get_combinations_between(s0=pc3, sf=pc0)) == 0 assert len(CC.get_combinations_between(s0=pc3, sf=pc1)) == 0 assert len(CC.get_combinations_between(s0=pc2, sf=pc1)) == 0 assert len(CC.get_combinations_between(s0=pc2, sf=pc3)) == 0 assert len(CC.get_combinations_between(s0=pc3, sf=pc2)) == 0 #Partially overlapping sets of monomers are bound assert len(CC.get_combinations_between(s0=pc3, sf=pc5a)) == 0 assert len(CC.get_combinations_between(s0=pc5a, sf=pc3)) == 0 #These ones are especially tricky because the same Monomers are bound, but in different sets of complexes assert len(CC.get_combinations_between(s0=pc3, sf=pc5b)) == 0 assert len(CC.get_combinations_between(s0=pc5b, sf=pc3)) == 0
def test_compute_species_changes(): X, Y, Z, S = Species("X"), Species("Y"), Species("Z"), Species("S") C = Complex([X, X]) p0 = OrderedPolymerSpecies([X, Y, Z, C]) pc0 = PolymerConformation(polymer=p0) c1 = Complex([pc0.polymers[0][0], pc0.polymers[0][1]]) pc1 = c1.parent ind_c1 = pc1.get_polymer_positions(c1, 0) c2 = Complex( [pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], S, S]) pc2 = c2.parent ind_c2 = pc2.get_polymer_positions(c2, 0) c3 = Complex([pc1.polymers[0][2], pc1.polymers[0][3], Z]) pc3 = c3.parent ind_c3 = pc3.get_polymer_positions(c3, 0) c4 = Complex([ pc0.polymers[0][0], pc0.polymers[0][1], pc0.polymers[0][2], pc0.polymers[0][3], Z ]) pc4 = c4.parent ind_c4 = pc4.get_polymer_positions(c4, 0) print("pc0", pc0, "\npc1", pc1, "\npc2", pc2, "\npc3", pc3, "\npc4", pc4) CC = CombinatorialConformation(initial_states=[pc0], intermediate_states=[pc1], final_states=[pc2, pc3]) #No additional species added SC, MC = CC.compute_species_changes(s0=pc0, sf=pc1) assert (c1, ind_c1) in SC assert len(SC[(c1, ind_c1)]) == 0 assert (c1, ind_c1) in MC assert len(MC[(c1, ind_c1)]) == 0 #External Species added SC, MC = CC.compute_species_changes(s0=pc0, sf=pc2) assert (c2, ind_c2) in SC assert len(SC[(c2, ind_c2)]) == 2 and S in SC[(c2, ind_c2)] assert all([len(MC[cf]) == 0 for cf in MC]) #Multiple Complexes created SC, MC = CC.compute_species_changes(s0=pc0, sf=pc3) assert (pc3.complexes[0], ind_c1) in SC and (pc3.complexes[1], ind_c3) in SC assert len(SC[pc3.complexes[0], ind_c1]) == 0 assert len(SC[pc3.complexes[1], ind_c3]) == 1 and Z in SC[pc3.complexes[1], ind_c3] assert all([len(MC[cf]) == 0 for cf in MC]) #A single complex created, from a conformation with complexes SC, MC = CC.compute_species_changes(s0=pc1, sf=pc3) assert (pc3.complexes[0], ind_c1) not in SC and (pc3.complexes[1], ind_c3) in SC assert len(SC[pc3.complexes[1], ind_c3]) == 1 and Z in SC[pc3.complexes[1], ind_c3] assert len(MC[pc3.complexes[1], ind_c3]) == 0 #Adding species to an existing Complex SC, MC = CC.compute_species_changes(s0=pc1, sf=pc2) assert (pc1.complexes[0], ind_c1) not in SC and (pc2.complexes[0], ind_c2) in SC assert len(SC[pc2.complexes[0], ind_c2]) == 2 and S in SC[pc2.complexes[0], ind_c2] assert pc1.complexes[0] in MC[pc2.complexes[0], ind_c2] #adding species (including inside the polymer) to an existing complex SC, MC = CC.compute_species_changes(s0=pc1, sf=pc4) assert (pc1.complexes[0], ind_c1) not in SC and (pc4.complexes[0], ind_c4) in SC assert Z in SC[pc4.complexes[0], ind_c4] and len(SC[pc4.complexes[0], ind_c4]) == 1 assert pc1.complexes[0] in MC[pc4.complexes[0], ind_c4] #merging two complexes SC, MC = CC.compute_species_changes(s0=pc3, sf=pc4) assert (pc3.complexes[0], ind_c1) not in SC and (pc3.complexes[1], ind_c3) not in SC and (pc4.complexes[0], ind_c4) not in SC assert pc3.complexes[0] in MC[ pc4.complexes[0], ind_c4] and pc3.complexes[1] in MC[pc4.complexes[0], ind_c4] #Cases where compute_species_changes should return False #No changes between the conformations assert not CC.compute_species_changes(s0=pc0, sf=pc0) #because s0 contains more species/complexes than sf assert not CC.compute_species_changes(s0=pc3, sf=pc0) assert not CC.compute_species_changes(s0=pc3, sf=pc1) assert not CC.compute_species_changes(s0=pc2, sf=pc1) assert not CC.compute_species_changes(s0=pc2, sf=pc3) assert not CC.compute_species_changes(s0=pc3, sf=pc2)