Coverage for SynRBL/rule_based.py: 27%

52 statements  

« prev     ^ index     » next       coverage.py v7.4.3, created at 2024-04-11 11:17 +0200

1import json 

2import logging 

3import pandas as pd 

4import importlib.resources 

5 

6 

7import SynRBL.SynRuleImputer 

8from SynRBL.SynRuleImputer import SyntheticRuleImputer 

9from SynRBL.SynRuleImputer.synthetic_rule_constraint import RuleConstraint 

10from SynRBL.SynProcessor import ( 

11 RSMIDecomposer, 

12 RSMIComparator, 

13 BothSideReact, 

14) 

15from SynRBL.rsmi_utils import ( 

16 load_database, 

17 filter_data, 

18 extract_results_by_key, 

19) 

20 

21from SynRBL.SynUtils.common import update_reactants_and_products 

22 

23logger = logging.getLogger(__name__) 

24 

25 

26class RuleBasedMethod: 

27 def __init__(self, id_col, reaction_col, output_col, rules_path=None, n_jobs=1): 

28 self.id_col = id_col 

29 self.reaction_col = reaction_col 

30 if rules_path is None: 

31 with importlib.resources.files(SynRBL.SynRuleImputer).joinpath( 

32 "rules_manager.json.gz" 

33 ).open("r") as f: 

34 self.rules = json.load(f) 

35 else: 

36 self.rules = load_database(rules_path) 

37 self.n_jobs = n_jobs 

38 self.output_col = output_col 

39 

40 def run(self, reactions, stats=None): 

41 update_reactants_and_products(reactions, self.reaction_col) 

42 decompose = RSMIDecomposer( 

43 smiles=None, # type: ignore 

44 data=reactions, # type: ignore 

45 reactant_col="reactants", 

46 product_col="products", 

47 parallel=True, 

48 n_jobs=self.n_jobs, 

49 verbose=0, 

50 ) 

51 react_dict, product_dict = decompose.data_decomposer() 

52 

53 comp = RSMIComparator( 

54 reactants=react_dict, # type: ignore 

55 products=product_dict, # type: ignore 

56 n_jobs=self.n_jobs, 

57 verbose=0, 

58 ) 

59 unbalance, diff_formula = comp.run_parallel( 

60 reactants=react_dict, products=product_dict 

61 ) 

62 

63 both_side = BothSideReact(react_dict, product_dict, unbalance, diff_formula) 

64 diff_formula, unbalance = both_side.fit(n_jobs=self.n_jobs) 

65 

66 _reactions = pd.concat( 

67 [ 

68 pd.DataFrame(reactions), 

69 pd.DataFrame([unbalance]).T.rename(columns={0: "Unbalance"}), 

70 pd.DataFrame([diff_formula]).T.rename(columns={0: "Diff_formula"}), 

71 ], 

72 axis=1, 

73 ).to_dict(orient="records") 

74 

75 cbalanced_reactions = [ 

76 _reactions[key] 

77 for key, value in enumerate(_reactions) 

78 if value["carbon_balance_check"] == "balanced" 

79 ] 

80 cunbalanced_reactions = [ 

81 _reactions[key] 

82 for key, value in enumerate(_reactions) 

83 if value["carbon_balance_check"] != "balanced" 

84 ] 

85 rule_based_reactions = filter_data( 

86 cbalanced_reactions, 

87 unbalance_values=["Reactants", "Products"], 

88 formula_key="Diff_formula", 

89 element_key=None, 

90 min_count=0, 

91 max_count=0, 

92 ) 

93 

94 both_side_cbalanced_reactions = filter_data( 

95 cbalanced_reactions, 

96 unbalance_values=["Both"], 

97 formula_key="Diff_formula", 

98 element_key=None, 

99 min_count=0, 

100 max_count=0, 

101 ) 

102 

103 imp = SyntheticRuleImputer( 

104 rule_dict=self.rules, select="all", ranking="ion_priority" 

105 ) 

106 balanced_cnt = ( 

107 len(cbalanced_reactions) 

108 - len(rule_based_reactions) 

109 - len(both_side_cbalanced_reactions) 

110 ) 

111 if stats is not None: 

112 stats["balanced_cnt"] = balanced_cnt 

113 stats["rb_applied"] = len(rule_based_reactions) 

114 logger.info("Input data contains {} balanced reactions.".format(balanced_cnt)) 

115 logger.info( 

116 "Run rule-based method on {} reactions.".format(len(rule_based_reactions)) 

117 ) 

118 expected_result = imp.parallel_impute(rule_based_reactions, n_jobs=self.n_jobs) 

119 

120 solve, unsolve = extract_results_by_key(expected_result) 

121 unsolve = cunbalanced_reactions + both_side_cbalanced_reactions + unsolve 

122 

123 constrain = RuleConstraint( 

124 solve, 

125 ban_atoms=[ 

126 "[O].[O]", 

127 "F-F", 

128 "Cl-Cl", 

129 "Br-Br", 

130 "I-I", 

131 "Cl-Br", 

132 "Cl-I", 

133 "Br-I", 

134 ], 

135 ) 

136 certain_reactions, uncertain_reactions = constrain.fit() 

137 if stats is not None: 

138 stats["rb_solved"] = len(certain_reactions) 

139 

140 for r in certain_reactions: 

141 _id = int(r[self.id_col]) 

142 reactions[_id][self.output_col] = r["new_reaction"] # type: ignore 

143 return reactions