def test_single_reaction() -> None: rxncon_sys = Quick('A_p+_B_[(r)]').rxncon_system assert state_from_str('B_[(r)]-{0}') in rxncon_sys.consumed_states assert state_from_str('B_[(r)]-{p}') in rxncon_sys.produced_states assert state_from_str('B_[(r)]-{0}') in rxncon_sys.states_for_component(spec_from_str('B')) assert state_from_str('B_[(r)]-{p}') in rxncon_sys.states_for_component(spec_from_str('B'))
def test_output_reactions() -> None: rxncon_sys = Quick("""A_p+_B_[(x)] [output]; ! B_[(x)]-{p}""").rxncon_system contingencies = rxncon_sys.contingencies_for_reaction(reaction_from_str('[output]')) assert len(contingencies) == 1 assert isinstance(contingencies[0].effector, StateEffector) assert [state_from_str('B@2_[(x)]-{p}')] == contingencies[0].effector.states
def test_non_elemental_contingency_single_state() -> None: rxncon_sys = Quick('''A_trsl_BmRNA C_p+_B_[(r1)] D_[x]_ppi_B_[y] ; ! B-{p}''').rxncon_system contingencies = rxncon_sys.contingencies_for_reaction(reaction_from_str('D_[x]_ppi+_B_[y]')) assert len(contingencies) == 1 print(contingencies[0].effector) assert contingencies[0].effector.name == 'B-{p}'
def test_inconsistent_system() -> None: with pytest.raises(AssertionError): Quick('''A_ppi_B ; ! <X> C_p+_B_[(r1)] D_p+_B_[(r2)] <X> ; AND B_[(r1)]-{p} <X> ; AND B_[(r1)]-{0}''').rxncon_system with pytest.raises(AssertionError): Quick('''A_ppi_B ; ! B_[(r1)]-{p} A_ppi_B ; ! B_[(r1)]-{0} C_p+_B_[(r1)] D_p+_B_[(r2)]''').rxncon_system
def test_bidirectional_reactions() -> None: rxncon_sys = Quick('''A_[x]_ppi_B_[y]; ! A_[(x)]-{p} C_p+_A_[(x)]''').rxncon_system # Forward direction contingencies = rxncon_sys.contingencies_for_reaction(reaction_from_str('A_[x]_ppi+_B_[y]')) assert len(contingencies) == 1 assert contingencies[0].effector.states == [state_from_str('A@0_[(x)]-{p}')] assert contingencies[0].contingency_type == ContingencyType.requirement # Reverse direction contingencies = rxncon_sys.contingencies_for_reaction(reaction_from_str('A_[x]_ppi-_B_[y]')) assert len(contingencies) == 0
def test_degradation_input_required_no_output() -> None: rxncon_sys = Quick("""Decay_DEG_Ndd1mRNA; ! [Ndd1UB]""").rxncon_system boolean_model = boolean_model_from_rxncon(rxncon_sys) # Component expressions. Ndd1mRNA = 'Ndd1mRNA' Decay = 'Decay' expected_rules = { 'Decay_deg_Ndd1mRNA': '{0} & {1} & [Ndd1UB]'.format(Ndd1mRNA, Decay), '[Ndd1UB]': '[Ndd1UB]', } rules_found = 0 for update_rule in boolean_model.update_rules: if str(update_rule.target) == 'Decay_deg_Ndd1mRNA': assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 elif str(update_rule.target) == '[Ndd1UB]': assert isinstance(update_rule.target, StateTarget) assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 assert rules_found == 2
def test_matching_input_output() -> None: boolean_model = boolean_model_from_rxncon( Quick("""A_p+_B_[(a)]; ! [global] [global]; ! B_[(a)]-{p}""" ).rxncon_system) # Component expressions. A = 'A' B = '( B_[(a)]-{0} | B_[(a)]-{p} )' expected_rules = { 'A_p+_B_[(a)]': '{0} & {1} & [global]'.format(A, B), '[global]': 'B_[(a)]-{p}' } rules_found = 0 for update_rule in boolean_model.update_rules: if str(update_rule.target) == 'A_p+_B_[(a)]': assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 elif str(update_rule.target) == '[global]': assert isinstance(update_rule.target, StateTarget) assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 assert rules_found == 2
def test_homodimer_degradation() -> None: """The degradation of homodimers should not lead to the production of the partner, but to the complete degradation of the complex.""" boolean_model = boolean_model_from_rxncon( Quick("""UC132_deg_Ste5 Ste5_[Ste7]_ppi+_Ste7_[Ste5] Ste4_[Ste5]_ppi+_Ste5_[Ste4] Ste5_[Ste5]_ppi+_Ste5_[Ste5] """).rxncon_system) num_degs = 0 for rule in (x for x in boolean_model.update_rules if isinstance(x.target, ReactionTarget)): assert isinstance(rule.target, ReactionTarget) if rule.target.degraded_targets: assert target_from_str( 'Ste5_[Ste5]--Ste5_[Ste5]') in rule.target.degraded_targets num_degs += 1 if target_from_str('Ste5_[Ste7]--Ste7_[Ste5]' ) in rule.target.consumed_targets: assert target_from_str( 'Ste7_[Ste5]--0') in rule.target.produced_targets elif target_from_str('Ste4_[Ste5]--Ste5_[Ste4]' ) in rule.target.consumed_targets: assert target_from_str( 'Ste4_[Ste5]--0') in rule.target.produced_targets else: assert False assert num_degs == 2
def test_deg_with_interaction() -> None: boolean_model = boolean_model_from_rxncon( Quick("""A_[x]_ppi+_B_[y] D_p+_A_[(r)] C_deg_A"""). rxncon_system) target_to_factor = { rule.target: rule.factor for rule in boolean_model.update_rules } A = '( ( A_[x]--B_[y] | A_[x]--0 ) & ( A_[(r)]-{p} | A_[(r)]-{0} ) )' expected_rules = { 'A_[x]--0': '( A_[x]--0 & ( A_[x]--B_[y] | A_[x]--0 ) & ( A_[(r)]-{p} | A_[(r)]-{0} ) & ' '~(( A_[x]_ppi+_B_[y] & A_[x]--0 & B_[y]--0 )) & ~( C_deg_A ))', 'B_[y]--0': '(( C_deg_A & A_[x]--B_[y] & ( B_[y]--0 | A_[x]--B_[y] )) | ( B_[y]--0 & ' '( B_[y]--0 | A_[x]--B_[y] ) & ~(( A_[x]--0 & B_[y]--0 & A_[x]_ppi+_B_[y] & ~( C_deg_A )))))', 'A_[x]--B_[y]': '{} & ~( C_deg_A ) & (( A_[x]_ppi+_B_[y] & A_[x]--0 & B_[y]--0 ) | ' '( A_[x]--B_[y] & ~( C_deg_A & A_[x]--B_[y] ) ) )'.format(A) } for target_str, factor_str in expected_rules.items(): assert target_to_factor[target_from_str(target_str)].is_equivalent_to( venn_from_str(factor_str, target_from_str))
def test_deg_with_boolean_NOT() -> None: boolean_model = boolean_model_from_rxncon( Quick("""A_[x]_ppi+_B_[y] D_p+_A_[(r)] C_deg_A; ! <x> <x>; AND A_[x]--B_[y]; AND <NOT> <NOT>; NOT A_[(r)]-{p}""" ).rxncon_system) target_to_factor = { rule.target: rule.factor for rule in boolean_model.update_rules } expected_rules = { 'C_deg_A': '( C & A_[x]--B_[y] & ~( A_[(r)]-{p} ) & ' '( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | A_[(r)]-{p} ))', 'B_[y]--0': '(( A_[x]--B_[y] & C_deg_A & ( B_[y]--0 | A_[x]--B_[y] )) | ' '( B_[y]--0 & ( B_[y]--0 | A_[x]--B_[y] ) & ~(( B_[y]--0 & A_[x]_ppi+_B_[y] & A_[x]--0 ))))', 'A_[(r)]-{p}': '(( A_[(r)]-{0} & ~( C_deg_A ) & D_p+_A_[(r)] & ( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | ' 'A_[(r)]-{p} )) | ( A_[(r)]-{p} & ( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | A_[(r)]-{p} )))', } for target_str, factor_str in expected_rules.items(): assert target_to_factor[target_from_str(target_str)].is_equivalent_to( venn_from_str(factor_str, target_from_str))
def test_layout_remains_correct_when_removing_node() -> None: """ Testing if the new graph gets tie correct layout of the old graph if we remove a node. Returns: None Raises: AssertionError: If the node coordinates of the new graph differ from expected coordinates. """ test_case = Quick("""A_[b]_ppi+_B_[a]""") reg_graph = SpeciesReactionGraph(test_case.rxncon_system) gml_system = XGMML(reg_graph.to_graph(), "remove_node") mapped_layout = map_layout2xgmml(gml_system.to_string(), NODE_LAYOUT_MANIPULATION) xmldoc_no_layout = minidom.parseString(mapped_layout) xmldoc_no_layout_info = _get_labels_and_coordinates_dict(xmldoc_no_layout) xmldoc_expected_layout = minidom.parse(NODE_LAYOUT_MANIPULATION) xmldoc_expected_layout_info = _get_labels_and_coordinates_dict( xmldoc_expected_layout) assert all(xmldoc_no_layout_info[no_layout_node] == xmldoc_expected_layout_info[no_layout_node] for no_layout_node in xmldoc_no_layout_info)
def test_trslprocat() -> None: procatdef = reaction.ReactionDef( 'pro-cat-translation', '$x_trslprocat_$y', { '$x': (Spec, LocusResolution.component), '$y': (MRNASpec, LocusResolution.component) }, '$x%# + $y%# -> $x%# + $y%# + $y.to_protein_component_spec().with_name_suffix(\'PRO\')%!$y.to_protein_component_spec().with_name_suffix(\'CAT\')%#' # pylint: disable=line-too-long '$y.to_protein_component_spec().with_name_suffix(\'PRO\').with_domain(\'PROCAT\')%--$y.to_protein_component_spec().with_name_suffix(\'CAT\').with_domain(\'CATPRO\')%!0' ) reaction.REACTION_DEFS = reaction.DEFAULT_REACTION_DEFS + [procatdef] rxn_system = Quick("""Ribo_trslprocat_Ssy5mRNA A_p+_Ssy5CAT B_deg_Ssy5PRO""").rxncon_system rbm = rule_based_model_from_rxncon(rxn_system) expected_rules = [ 'Ribo() + Ssy5mRNA() -> Ribo() + Ssy5CAT(AR~0,CATPROD!1).Ssy5PRO(PROCATD!1) + Ssy5mRNA() k', 'A() + Ssy5CAT(AR~0) -> A() + Ssy5CAT(AR~p) k', 'B() + Ssy5PRO() -> B() k' ] assert len(rbm.rules) == len(expected_rules) for actual_rule in rbm.rules: assert any(rule_from_str(rule).is_equivalent_to(actual_rule) for rule in expected_rules) reaction.REACTION_DEFS = reaction.DEFAULT_REACTION_DEFS
def test_structure_to_negative_interaction_states() -> None: rxncon_system = Quick("""Cdc28_P+_Bem2_[(cdc28)]; ! <Cdc28Cln13> <Cdc28Cln13>; OR <Cdc28Cln1>; OR <Cdc28Cln3> <Cdc28Cln1>; AND Cdc28_[cyclin]--Cln1_[cdc28] <Cdc28Cln3>; AND Cdc28_[cyclin]--Cln3_[cdc28]; AND Cdc28_[whi3]--0 Cdc28_[cyclin]_ppi_Cln1_[cdc28] Cdc28_[far1]_ppi_Far1_[cdc28] Cdc28_[cks1]_ppi_Cks1_[cdc28] Cak1_P+_Cdc28_[Tloop(T169)] Cdc28_[cyclin]_ppi_Cln2_[cdc28] Cdc28_[cyclin]_ppi_Cln3_[cdc28] Cdc28_[whi3]_ppi_Whi3_[cdc28]""").rxncon_system rbm = rule_based_model_from_rxncon(rxncon_system) rules_of_interest = [ rule_from_str( "Cdc28(whi3D) + Whi3(cdc28D) -> Cdc28(whi3D!1).Whi3(cdc28D!1) k_13 Cdc28_[whi3]_ppi+_Whi3_[cdc28]"), rule_from_str( "Cdc28(whi3D!1).Whi3(cdc28D!1) -> Cdc28(whi3D) + Whi3(cdc28D) k_14 Cdc28_[whi3]_ppi-_Whi3_[cdc28]") ] for rule_of_interest in rules_of_interest: identities = [rule.is_equivalent_to(rule_of_interest) for rule in rbm.rules] assert identities.count(True) == 1 # exactly once
def test_single_inhibition_interaction() -> None: rbm = rule_based_model_from_rxncon(Quick("""A_[b]_ppi+_B_[a]; x A_[(r)]-{p} E_[x]_ppi+_B_[a] C_p+_A_[(r)] D_ub+_A_[(r)]""").rxncon_system) expected_rules = [ 'A(rR~ub,bD) + B(aD) -> A(rR~ub,bD!1).B(aD!1) k', 'A(rR~0,bD) + B(aD) -> A(rR~0,bD!1).B(aD!1) k', 'B(aD) + E(xD) -> B(aD!1).E(xD!1) k', 'A(rR~0) + C() -> A(rR~p) + C() k', 'A(rR~0) + D() -> A(rR~ub) + D() k' ] assert len(rbm.rules) == len(expected_rules) for actual_rule in rbm.rules: assert any(rule_from_str(rule).is_equivalent_to(actual_rule) for rule in expected_rules) expected_ics = [ 'A(bD,rR~0) NumA', 'B(aD) NumB', 'D() NumD', 'C() NumC', 'E(xD) NumE' ] for actual_ic in rbm.initial_conditions: assert any(initial_condition_from_str(ic).is_equivalent_to(actual_ic) for ic in expected_ics)
def test_boolean_inhibition_interaction() -> None: rbm = rule_based_model_from_rxncon(Quick('''A_ppi+_C C_ppi+_D B_ppi+_E B_ppi+_F A_ppi+_B; x <comp1> <comp1>; OR <comp1C1> <comp1>; OR <comp2C1> <comp1C1>; AND A--C <comp1C1>; AND C--D <comp2C1>; AND B--F <comp2C1>; AND B--E''').rxncon_system) expected_rules = [ 'A(CD) + C(AD) -> A(CD!1).C(AD!1) k', 'C(DD) + D(CD) -> C(DD!1).D(CD!1) k', 'B(ED) + E(BD) -> B(ED!1).E(BD!1) k', 'B(FD) + F(BD) -> B(FD!1).F(BD!1) k', 'A(BD,CD) + B(AD,FD) -> A(BD!1,CD).B(AD!1,FD) k', 'A(BD,CD) + B(AD,ED,FD!1).F(BD!1) -> A(BD!2,CD).B(AD!2,ED,FD!1).F(BD!1) k', 'A(BD,CD!1).C(AD!1,DD) + B(AD,FD) -> A(BD!2,CD!1).B(AD!2,FD).C(AD!1,DD) k', 'A(BD,CD!1).C(AD!1,DD) + B(AD,ED,FD!2).F(BD!2) -> A(BD!3,CD!1).B(AD!3,ED,FD!2).C(AD!1,DD).F(BD!2) k', ] assert len(rbm.rules) == len(expected_rules) for actual_rule in rbm.rules: assert any(rule_from_str(rule).is_equivalent_to(actual_rule) for rule in expected_rules)
def test_deg_of_component_without_states() -> None: """ Testing degradation of component without states. Returns: None Raises: AssertionError if the expected rule is not e """ boolean_model = boolean_model_from_rxncon( Quick("""C_deg_A""").rxncon_system) target_to_factor = { rule.target: rule.factor for rule in boolean_model.update_rules } expected_rules = { 'C_deg_A': '( C & A )', 'A': '( A & ~( C_deg_A ))', 'C': 'C' } for target_str, factor_str in expected_rules.items(): assert target_to_factor[target_from_str(target_str)].is_equivalent_to( venn_from_str(factor_str, target_from_str))
def test_single_requirement_modification() -> None: rbm = rule_based_model_from_rxncon(Quick("""A_[b]_ppi+_B_[a]; ! A_[(r)]-{p} A_[b]_ppi-_B_[a] C_p+_A_[(r)] D_p-_A_[(r)]""").rxncon_system) expected_rules = [ 'A(rR~p,bD) + B(aD) -> A(rR~p,bD!1).B(aD!1) k', 'A(bD!1).B(aD!1) -> A(bD) + B(aD) k', 'C() + A(rR~0) -> C() + A(rR~p) k', 'A(rR~p) + D() -> A(rR~0) + D() k' ] assert len(rbm.rules) == len(expected_rules) for actual_rule in rbm.rules: print(actual_rule) # assert any(rule_from_str(rule).is_equivalent_to(actual_rule) for rule in expected_rules) expected_ics = [ 'A(bD,rR~0) NumA', 'B(aD) NumB', 'D() NumD', 'C() NumC' ] for actual_ic in rbm.initial_conditions: assert any(initial_condition_from_str(ic).is_equivalent_to(actual_ic) for ic in expected_ics)
def test_smooth_production_sources() -> None: """ Testing smoothing function. Note: Only the update rule for A_[b]--0 is tested. Returns: None Raises: AssertionError: If update rule for A_[b]--0 is not as expected. """ boolean_model = boolean_model_from_rxncon( Quick("""A_[b]_ppi+_B_[a]; ! A_[(r)]-{p} A_[b]_ppi-_B_[a] C_p+_A_[(r)] D_p-_A_[(r)]"""). rxncon_system, SmoothingStrategy.smooth_production_sources) expected = '(( A_[(r)]-{p} | A_[(r)]-{0} ) & ( A_[b]--0 | A_[b]--B_[a] )) & ' \ '( A_[b]_ppi-_B_[a] & ( A_[b]--B_[a] | ( A_[b]_ppi+_B_[a] & A_[b]--0 & B_[a]--0 )) | ' \ '( A_[b]--0 & ~( A_[b]_ppi+_B_[a] & A_[b]--0 & B_[a]--0 )))' for rule in boolean_model.update_rules: if rule.target == target_from_str('A_[b]--0'): assert rule.factor.is_equivalent_to( venn_from_str(expected, target_from_str))
def test_state_target_properties() -> None: """ Testing the relation between states and reactions not tested before. Returns: None """ boolean_model = boolean_model_from_rxncon( Quick("""C_deg_A C_syn_A C_p+_A_[(x)] C_p-_A_[(x)]"""). rxncon_system) neutral_state = target_from_str('A_[(x)]-{0}') assert isinstance(neutral_state, StateTarget) assert boolean_model.state_target_by_name('A_[(x)]-{p}').is_produced_by( boolean_model.reaction_target_by_name('C_p+_A_[(x)]')) assert boolean_model.state_target_by_name('A_[(x)]-{p}').is_consumed_by( boolean_model.reaction_target_by_name('C_p-_A_[(x)]')) assert boolean_model.state_target_by_name('A_[(x)]-{p}').is_degraded_by( boolean_model.reaction_target_by_name('C_deg_A')) assert boolean_model.reaction_target_by_name( 'C_syn_A').synthesises_component(neutral_state.components[0]) assert boolean_model.state_target_by_name('A_[(x)]-{0}').is_synthesised_by( boolean_model.reaction_target_by_name('C_syn_A'))
def test_trsl_trsc_deg() -> None: boolean_model = boolean_model_from_rxncon( Quick("""PolII_trsc_TargetGene Ribo_trsl_TargetmRNA Nuclease_deg_TargetmRNA Protease_deg_Target"""). rxncon_system) expected_rules = { 'PolII_trsc_TargetGene': '( PolII & TargetGene )', 'Ribo_trsl_TargetmRNA': '( Ribo & TargetmRNA )', 'Nuclease_deg_TargetmRNA': '( Nuclease & TargetmRNA )', 'Protease_deg_Target': '( Protease & Target )', 'PolII': '( PolII )', 'TargetGene': '( TargetGene )', 'Ribo': '( Ribo )', 'TargetmRNA': '( PolII_trsc_TargetGene | ( TargetmRNA & ~( Nuclease_deg_TargetmRNA )))', 'Nuclease': '( Nuclease )', 'Protease': '( Protease )', 'Target': '( Ribo_trsl_TargetmRNA | ( Target & ~( Protease_deg_Target )))' } assert len(boolean_model.update_rules) == len(expected_rules) for update_rule in boolean_model.update_rules: assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str))
def test_deg_with_boolean_NOT() -> None: """ Testing degradation with NOT Boolean. Returns: None Raises: AssertionError if a rule is not equivalent to an expected rule. """ boolean_model = boolean_model_from_rxncon( Quick("""A_[x]_ppi+_B_[y] D_p+_A_[(r)] C_deg_A; ! <x> <x>; AND A_[x]--B_[y]; AND <NOT> <NOT>; NOT A_[(r)]-{p}""" ).rxncon_system) target_to_factor = { rule.target: rule.factor for rule in boolean_model.update_rules } expected_rules = { 'C_deg_A': '( C & A_[x]--B_[y] & ~( A_[(r)]-{p} ) & ( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | A_[(r)]-{p} ))', 'B_[y]--0': '(( A_[x]--B_[y] & C_deg_A & ( B_[y]--0 | A_[x]--B_[y] )) | ( B_[y]--0 & ( B_[y]--0 | A_[x]--B_[y] ) & ~(( B_[y]--0 & A_[x]_ppi+_B_[y] & A_[x]--0 ))))', 'A_[(r)]-{p}': '(( A_[(r)]-{0} & D_p+_A_[(r)] & ( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | A_[(r)]-{p} )) | ( A_[(r)]-{p} & ( A_[x]--0 | A_[x]--B_[y] ) & ( A_[(r)]-{0} | A_[(r)]-{p} )))', } for target_str, factor_str in expected_rules.items(): assert target_to_factor[target_from_str(target_str)].is_equivalent_to( venn_from_str(factor_str, target_from_str))
def test_layout_remains_correct_when_adding_node() -> None: """ Testing if the new graph gets the correct layout of the old graph if we add an additional node. Returns: None Raises: AssertionError: If the node coordinates of the new graph differ from expected coordinates. """ test_case = Quick("""A_[b]_ppi+_B_[a]; ! A_[(c)]-{p} C_p+_A_[(c)]; ! C_[d]--D_[c] C_[d]_ppi+_D_[c]""") reg_graph = RegulatoryGraph(test_case.rxncon_system) gml_system = XGMML(reg_graph.to_graph(), "add_node") mapped_layout = map_layout2xgmml(gml_system.to_string(), NODE_LAYOUT_MANIPULATION) xmldoc_no_layout = minidom.parseString(mapped_layout) xmldoc_no_layout_info = _get_labels_and_coordinates_dict(xmldoc_no_layout) xmldoc_expected_layout = minidom.parse(NODE_LAYOUT_MANIPULATION) xmldoc_expected_layout_info = _get_labels_and_coordinates_dict(xmldoc_expected_layout) assert all(xmldoc_no_layout_info[no_layout_node] == xmldoc_expected_layout_info[no_layout_node] for no_layout_node in xmldoc_no_layout_info) assert all(xmldoc_no_layout_info[expected_layout_node] == xmldoc_expected_layout_info[expected_layout_node] for expected_layout_node in xmldoc_expected_layout_info)
def test_single_contingency() -> None: rxncon_sys = Quick('''A_p+_B_[(r)]; ! A_[(x)]-{p} C_p+_A_[(x)]''').rxncon_system assert state_from_str('A_[(x)]-{0}') in rxncon_sys.consumed_states assert state_from_str('B_[(r)]-{0}') in rxncon_sys.consumed_states assert state_from_str('A_[(x)]-{p}') in rxncon_sys.produced_states assert state_from_str('B_[(r)]-{p}') in rxncon_sys.produced_states assert state_from_str('A_[(x)]-{0}') in rxncon_sys.states_for_component(spec_from_str('A')) assert state_from_str('B_[(r)]-{0}') in rxncon_sys.states_for_component(spec_from_str('B')) assert state_from_str('A_[(x)]-{p}') in rxncon_sys.states_for_component(spec_from_str('A')) assert state_from_str('B_[(r)]-{p}') in rxncon_sys.states_for_component(spec_from_str('B')) contingencies = rxncon_sys.contingencies_for_reaction(reaction_from_str('A_p+_B_[(r)]')) assert len(contingencies) == 1 assert contingencies[0].effector.states == [state_from_str('A@0_[(x)]-{p}')] assert contingencies[0].contingency_type == ContingencyType.requirement
def test_boolnet_export() -> None: model = boolean_model_from_rxncon(Quick("""C_deg_A""").rxncon_system) boolnet_str, mapping, init_values = boolnet_from_boolean_model(model) assert 'targets, factors' in boolnet_str assert all(target in mapping.values() for target in list(model._reaction_targets.keys()) + list(model._state_targets.keys())) assert len(mapping) == len(init_values) assert all(init_values[key] == model.initial_conditions.target_to_value[ target_from_str(value)] for key, value in mapping.items())
def test_matching_non_matching_input_one_output() -> None: """ Testing if output reactions with one matching and one non matching input states. Returns: None Raises: Assertion error if the update rules are not as expected. """ boolean_model = boolean_model_from_rxncon( Quick("""A_p+_B_[(a)]; ! [global] A_p+_B_[(a1)]; ! [global_diff] [global]; ! B_[(a)]-{p}""" ).rxncon_system) # Component expressions. A = 'A' B = '( B_[(a)]-{0} | B_[(a)]-{p} ) & ( B_[(a1)]-{0} | B_[(a1)]-{p} )' expected_rules = { 'A_p+_B_[(a)]': '{0} & {1} & [global]'.format(A, B), 'A_p+_B_[(a1)]': '{0} & {1} & [global_diff]'.format(A, B), '[global]': 'B_[(a)]-{p}', '[global_diff]': '[global_diff]' } rules_found = 0 for update_rule in boolean_model.update_rules: if str(update_rule.target) == 'A_p+_B_[(a)]': assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 elif str(update_rule.target) == 'A_p+_B_[(a1)]': assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 elif str(update_rule.target) == '[global]': assert isinstance(update_rule.target, StateTarget) assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 elif str(update_rule.target) == '[global_diff]': assert isinstance(update_rule.target, StateTarget) assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str)) rules_found += 1 assert rules_found == 4
def test_set_initial_condition() -> None: boolean_model = boolean_model_from_rxncon( Quick("""C_p+_A_[(x)]""").rxncon_system) neutral_state = target_from_str('A_[(x)]-{0}') assert boolean_model.initial_conditions.target_to_value[ neutral_state] == True boolean_model.set_initial_condition(neutral_state, False) assert boolean_model.initial_conditions.target_to_value[ neutral_state] == False
def test_kplus_overlaps_with_reaction() -> None: rxncon_system = Quick("""A_p+_B_[(s)]; ! <Aphos> ; k+ A_[(r1)]-{p} ; k+ A_[(r2)]-{p} <Aphos>; OR A_[(r1)]-{p} <Aphos>; OR A_[(r2)]-{p} C_p+_A_[(r1)] D_p+_A_[(r2)]""").rxncon_system rbm = rule_based_model_from_rxncon(rxncon_system) for rule in rbm.rules: print(rule)
def test_simple_system_with_input_state() -> None: boolean_model = boolean_model_from_rxncon( Quick("""A_[b]_ppi+_B_[a]; ! A_[(r)]-{p} ; ! [BLAAT] A_[b]_ppi-_B_[a] C_p+_A_[(r)] D_p-_A_[(r)]"""). rxncon_system) # Component expressions. A = '(( A_[b]--0 | A_[b]--B_[a] ) & ( A_[(r)]-{0} | A_[(r)]-{p} ))' B = '( B_[a]--0 | A_[b]--B_[a] )' C = 'C' D = 'D' expected_rules = { 'A_[b]_ppi+_B_[a]': '{0} & {1} & A_[(r)]-{{p}} & [BLAAT]'.format(A, B), 'A_[b]_ppi-_B_[a]': '{0} & {1}'.format(A, B), 'C_p+_A_[(r)]': '{0} & {1}'.format(A, C), 'D_p-_A_[(r)]': '{0} & {1}'.format(A, D), 'A_[(r)]-{p}': '{0} & (( C_p+_A_[(r)] & A_[(r)]-{{0}} ) | ' '( A_[(r)]-{{p}} & ~( D_p-_A_[(r)] & A_[(r)]-{{p}} )))'.format(A), 'A_[(r)]-{0}': '{0} & (( D_p-_A_[(r)] & A_[(r)]-{{p}} ) | ' '( A_[(r)]-{{0}} & ~( C_p+_A_[(r)] & A_[(r)]-{{0}} )))'.format(A), 'A_[b]--0': '{0} & (( A_[b]_ppi-_B_[a] & A_[b]--B_[a] ) | ' '( A_[b]--0 & ~( A_[b]_ppi+_B_[a] & A_[b]--0 & B_[a]--0 )))'.format(A), 'A_[b]--B_[a]': '{0} & {1} & (( A_[b]_ppi+_B_[a] & A_[b]--0 & B_[a]--0 ) | ' '( A_[b]--B_[a] & ~( A_[b]_ppi-_B_[a] & A_[b]--B_[a] )))'.format(A, B), 'B_[a]--0': '{0} & (( A_[b]_ppi-_B_[a] & A_[b]--B_[a] ) | ' '( B_[a]--0 & ~( A_[b]_ppi+_B_[a] & A_[b]--0 & B_[a]--0 )))'.format(B), 'C': '{0}'.format(C), 'D': '{0}'.format(D), '[BLAAT]': '[BLAAT]' } assert len(boolean_model.update_rules) == len(expected_rules) for update_rule in boolean_model.update_rules: assert update_rule.factor.is_equivalent_to( venn_from_str(expected_rules[str(update_rule.target)], target_from_str))
def test_degradation_bond_to_homodimer() -> None: rxncon_sys = Quick("""A_[b]_ppi_B_[a] B_[b]_ppi_B_[b] C_deg_A; ! <x> <x>; AND A@1--B@2 <x>; AND B@2--B@3""").rxncon_system boolean_model = boolean_model_from_rxncon(rxncon_sys) assert boolean_model.reaction_target_by_name( 'C_deg_A').consumed_targets == [target_from_str('A_[b]--B_[a]')] assert boolean_model.reaction_target_by_name( 'C_deg_A').produced_targets == [target_from_str('B_[a]--0')]
def test_simple_system() -> None: rbm = rule_based_model_from_rxncon(Quick("""A_[b]_ppi+_B_[a]; ! A_[(r)]-{p} A_[b]_ppi-_B_[a] C_p+_A_[(r)] D_p-_A_[(r)]""").rxncon_system) expected_bngl = '''begin model begin parameters NumA 100 NumB 100 NumC 100 NumD 100 k 1.0 end parameters begin molecule types A(bD,rR~0~p) B(aD) C() D() end molecule types begin seed species A(bD,rR~0) NumA B(aD) NumB C() NumC D() NumD end seed species begin observables end observables begin reaction rules # A_[b]_ppi+_B_[a] A(bD,rR~p) + B(aD) -> A(bD!1,rR~p).B(aD!1) k # A_[b]_ppi-_B_[a] A(bD!1).B(aD!1) -> A(bD) + B(aD) k # C_p+_A_[(r)] A(rR~0) + C() -> A(rR~p) + C() k # D_p-_A_[(r)] A(rR~p) + D() -> A(rR~0) + D() k end reaction rules end model simulate_nf({t_end=>100,n_steps=>10}); ''' assert bngl_from_rule_based_model(rbm) == expected_bngl