feat: add --direction option

RELEASE.md

@@ -1,5 +1,9 @@
 # Release history
 
+## 2.0.0
+### 18 May, 2021
+- feat: add --direction option to specify the direction of the transformation to complete
+
 ## 1.2.0
 ### 10 May, 2021
 - fit to new release of rr_cache

rxn_rebuild/Args.py

@@ -49,6 +49,16 @@ def add_arguments(parser: ArgumentParser) -> ArgumentParser:
         type=str,
         help='Template (original) reaction identifier'
     )
+    parser.add_argument(
+        '--direction',
+        type=str,
+        default='reverse',
+        choices=[
+            'forward', 'fwd',
+            'reverse', 'rev'
+        ],
+        help='Direction of the transformation to complete (default: reverse)'
+    )
     parser.add_argument(
         '--version', '-v',
         action='version',

rxn_rebuild/__main__.py

@@ -100,6 +100,7 @@ def entry_point():
               cache = cache,
         rxn_rule_id = args.rxn_rule_id,
             transfo = args.transfo,
+          direction = args.direction,
         tmpl_rxn_id = args.tmpl_rxn_id,
              logger = logger
     )

rxn_rebuild/_version.py

@@ -1 +1 @@
-__version__ = "1.2.1"
+__version__ = "2.0.0"

rxn_rebuild/rxn_rebuild.py

@@ -19,13 +19,18 @@
 def rebuild_rxn(
     rxn_rule_id: str,
     transfo: str,
+    direction: str = 'reverse',
     tmpl_rxn_id: str = None,
     cache: 'rrCache' = None,
     logger: Logger = getLogger(__name__)
 ) -> str:
 
     ## INPUT TRANSFORMATION
     trans_input = build_trans_input(transfo.replace(' ', ''))  # remove whitespaces
+    # # If input transfo is provided in forward direction,
+    # # swap left and right sides
+    # if direction == 'forward' or direction == 'fwd':
+    #     trans_input['left'], trans_input['right'] = trans_input['right'], trans_input['left']
 
     ## LOAD CACHE
     if cache is None:
@@ -37,21 +42,25 @@ def rebuild_rxn(
 
     ## COMPLETE TRANSFORMATION
     completed_transfos = {}
-    if tmpl_rxn_id is not None:
+    if not tmpl_rxn_id is None:
         completed_transfos[tmpl_rxn_id] = complete_transfo(
-            trans_input,
-            cache.get('rr_reactions')[rxn_rule_id][tmpl_rxn_id],
-            tmpl_rxn_id,
-            cache,
+            trans_input=trans_input,
+            direction=direction,
+            rxn_rule=cache.get('rr_reactions')[rxn_rule_id][tmpl_rxn_id],
+            tmpl_rxn=cache.get('template_reactions')[tmpl_rxn_id],
+            tmpl_rxn_id=tmpl_rxn_id,
+            compounds=cache.get('cid_strc'),
             logger=logger
         )
     else:  # One completed transformation per template reaction
         for tpl_rxn_id, rxn_rule in cache.get('rr_reactions')[rxn_rule_id].items():
             completed_transfos[tpl_rxn_id] = complete_transfo(
-                trans_input,
-                rxn_rule,
-                tpl_rxn_id,
-                cache,
+                trans_input=trans_input,
+                direction=direction,
+                rxn_rule=rxn_rule,
+                tmpl_rxn=cache.get('template_reactions')[tpl_rxn_id],
+                tmpl_rxn_id=tpl_rxn_id,
+                compounds=cache.get('cid_strc'),
                 logger=logger
             )
 
@@ -61,15 +70,24 @@ def rebuild_rxn(
 def complete_transfo(
     trans_input: Dict,
     rxn_rule: Dict,
+    tmpl_rxn: Dict,
     tmpl_rxn_id: str,
-    cache: 'rrCache',
+    compounds: Dict,
+    direction: str = 'reverse',
     logger: Logger = getLogger(__name__)
 ) -> Dict:
 
     completed_transfo = {}
 
     logger.debug('REACTION RULE:'+str(dumps(rxn_rule, indent=4)))
 
+    # If input transfo is provided in forward direction,
+    # swap left and right sides of reaction rule, and
+    # change 'rel_direction'
+    if direction == 'forward' or direction == 'fwd':
+        rxn_rule['left'], rxn_rule['right'] = rxn_rule['right'], rxn_rule['left']
+        rxn_rule['rel_direction'] *= -1
+
     ## CHECK 1/2
     # Check if the number of structures in the right part of SMILES of transformation to complete
     # is equal to the number of products of the template reaction used to build the reaction rule.
@@ -84,18 +102,14 @@ def complete_transfo(
     )
 
     ## TEMPLATE REACTION
-    tmpl_rxn = load_tmpl_rxn(
-        cache.get('template_reactions'),
-        tmpl_rxn_id,
-        rxn_rule['rel_direction'],
-        logger=logger
-    )
+    if rxn_rule['rel_direction'] == -1:
+        tmpl_rxn = swap_sides(tmpl_rxn, logger=logger)
 
     ## ADD MISSING COMPOUNDS TO THE FINAL TRANSFORMATION
     missing_compounds = detect_missing_compounds(
         tmpl_rxn,
         rxn_rule,
-        cache.get('cid_strc'),
+        compounds,
         logger=logger
     )
 
@@ -214,38 +228,29 @@ def build_trans_input(
     return trans_input
 
 
-def load_tmpl_rxn(
-    tmplt_rxns: Dict,
-    rxn_id: str,
-    rr_direction: int,
+def swap_sides(
+    rxn: Dict,
     logger: Logger = getLogger(__file__)
 ) -> Dict:
     """
-    Seeks for the template reaction of ID rxn_id in the cache.
+    Swaps left and right sides.
 
     Parameters
     ----------
-    tmplt_rxns: Dict
-        Template (original) reactions.
-    rxn_id: str
-        ID of the template reaction.
-    rr_direction: int
-        Direction of the reaction used to build the rule.
+    rxn: Dict
+        The reactions to swap sides of.
     logger : Logger
         The logger object.
 
     Returns
     -------
-    tmpl_rxn: Dict
-        template reaction looked for.
+    rxn: Dict
+        The reaction with swapped sides.
     """
-    rxn = tmplt_rxns[rxn_id]
-    if rr_direction == -1:
-        left = dict(rxn['left'])
-        rxn['left']  = rxn['right']
-        rxn['right'] = left
-    logger.debug('TEMPLATE REACTION:'+str(dumps(rxn, indent=4)))
-    return rxn
+    return {
+        'left': rxn['right'],
+        'right': rxn['left']
+    }
 
 
 def detect_missing_compounds(

tests/test_main.py

@@ -195,3 +195,37 @@ def test_all_cmpds_ok_wocache(self):
                 }
             }
         )
+
+    def test_forward_direction(self):
+        rule_id = 'RR-02-a0cc0be463ff412f-16-F'
+        transfo = '[H]Oc1c([H])c([H])c([H])c([H])c1O[H].O=O>>[H]OC(=O)C([H])=C([H])C([H])=C([H])C(=O)O[H]'
+        direction = 'forward'
+        self.assertEqual(
+            rebuild_rxn(
+                rxn_rule_id = rule_id,
+                transfo = transfo,
+                direction = direction,
+                logger = self.logger
+            ),
+            {
+                "MNXR96458": {
+                    "full_transfo": "[H]Oc1c([H])c([H])c([H])c([H])c1O[H].O=O>>[H]OC(=O)C([H])=C([H])C([H])=C([H])C(=O)O[H].[H+].[H+]",
+                    "added_cmpds": {
+                        "left": {},
+                        "right": {
+                            "MNXM1": {
+                                "stoichio": 2,
+                                "formula": "H",
+                                "smiles": "[H+]",
+                                "inchi": "InChI=1S/p+1",
+                                "inchikey": "GPRLSGONYQIRFK-UHFFFAOYSA-N",
+                                "cid": "MNXM1",
+                                "name": "H(+)"
+                            }
+                        },
+                        "left_nostruct": {},
+                        "right_nostruct": {}
+                    }
+                }
+            }
+        )