@datagrok/sequence-translator 1.4.2 → 1.4.4

package/files/polytool-rules/rules_example.json

@@ -23,6 +23,16 @@
       "secondSubstitution": "D"
     }
   },
+  {
+    "type": "reaction",
+    "code": "3",
+    "monomericSubstitution": {
+      "firstMonomer": "azG",
+      "secondMonomer": "aG",
+      "reaction": "[C:1]N=[N+]=[N-].[C:2]C#C>>[C:1]N1-N=NC=C1[C:2]",
+      "name": "GGaz"
+    }
+  },
   {
     "type": "fragmentDuplication",
     "code": "#3"

package/files/samples/cyclized.csv

@@ -4,3 +4,5 @@ n,seqs
 3,R-F-C(1)-T-G-H-F-Y-P-C(1)
 4,C(1)-T-G-H-F-H-P-C(1)
 5,R-F-D(2)-T-G-H-F-Y-P-NH2(2)
+6,R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI
+7,R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI

package/files/tests/polytool-reaction-lib.json

@@ -0,0 +1,40 @@
+[
+  {
+    "monomerType": "Backbone",
+    "smiles": "[H:1]NC(C([OH:2])=O)c1cn(C(N[H:3])C([OH:4])=O)nn1",
+    "name": "GGaz",
+    "author": "Datagrok",
+    "molfile": "\n  MJ201900                      \n\n 17 17  0  0  0  0  0  0  0  0999 V2000\n   18.8168  -12.6760    0.0000 N   0  0  0  0  0  0  0  0  0  0  0  0\n   19.5312  -13.0885    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   20.2457  -12.6760    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   20.9602  -13.0885    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0\n   20.2457  -11.8510    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0\n   19.1403  -15.8019    0.0000 N   0  0  0  0  0  0  0  0  0  0  0  0\n   19.8547  -16.2144    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   20.5692  -15.8019    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   21.2837  -16.2144    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0\n   20.5692  -14.9769    0.0000 O   0  0  0  0  0  0  0  0  0  0  0  0\n   19.5083  -13.8885    0.0000 N   0  0  0  0  0  0  0  0  0  0  0  0\n   18.8409  -14.3735    0.0000 N   0  0  0  0  0  0  0  0  0  0  0  0\n   19.0958  -15.1581    0.0000 N   0  0  0  0  0  0  0  0  0  0  0  0\n   19.9208  -15.1581    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   20.1757  -14.3735    0.0000 C   0  0  0  0  0  0  0  0  0  0  0  0\n   18.4258  -16.2144    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0\n   18.1023  -13.0885    0.0000 R#  0  0  0  0  0  0  0  0  0  0  0  0\n  2  3  1  0  0  0  0\n  3  5  2  0  0  0  0\n  7  8  1  0  0  0  0\n  8 10  2  0  0  0  0\n  3  4  1  0  0  0  0\n  8  9  1  0  0  0  0\n 14 15  2  0  0  0  0\n 11 15  1  0  0  0  0\n 11 12  1  0  0  0  0\n 13 14  1  0  0  0  0\n 12 13  2  0  0  0  0\n  2 11  1  0  0  0  0\n  7 14  1  0  0  0  0\n  1  2  1  0  0  0  0\n  1 17  1  0  0  0  0\n  6  7  1  0  0  0  0\n  6 16  1  0  0  0  0\nM  RGP  4   4   2   9   4  16   3  17   1\nM  END\n",
+    "naturalAnalog": "G",
+    "rgroups": [
+      {
+        "capGroupSMILES": "[*:1][H]",
+        "alternateId": "R1-H",
+        "capGroupName": "H",
+        "label": "R1"
+      },
+      {
+        "capGroupSMILES": "O[*:2]",
+        "alternateId": "R2-OH",
+        "capGroupName": "OH",
+        "label": "R2"
+      },
+      {
+        "capGroupSMILES": "[*:3][H]",
+        "alternateId": "R3-H",
+        "capGroupName": "H",
+        "label": "R3"
+      },
+      {
+        "capGroupSMILES": "O[*:4]",
+        "alternateId": "R4-OH",
+        "capGroupName": "OH",
+        "label": "R4"
+      }
+    ],
+    "createDate": null,
+    "id": 0,
+    "polymerType": "PEPTIDE",
+    "symbol": "GGaz"
+  }
+]

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "author": {
-    "name": "Alexey Choposky",
+    "name": "Alexey Chopovsky",
     "email": "achopovsky@datagrok.ai"
   },
   "description": "SequenceTranslator translates [oligonucleotide](https://en.wikipedia.org/wiki/Oligonucleotide) sequences between [different representations](https://github.com/datagrok-ai/public/tree/master/packages/SequenceTranslator#sequence-representations).",
@@ -22,10 +22,10 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.44.0",
+    "@datagrok-libraries/bio": "^5.44.2",
     "@datagrok-libraries/chem-meta": "^1.2.7",
     "@datagrok-libraries/tutorials": "^1.4.0",
-    "@datagrok-libraries/utils": "^4.3.0",
+    "@datagrok-libraries/utils": "^4.3.5",
     "@types/react": "^18.0.15",
     "cash-dom": "^8.1.0",
     "datagrok-api": "^1.21.1",
@@ -41,9 +41,9 @@
   "devDependencies": {
     "@datagrok-libraries/helm-web-editor": "^1.1.11",
     "@datagrok-libraries/js-draw-lite": "^0.0.8",
-    "@datagrok/bio": "^2.15.3",
-    "@datagrok/helm": "^2.5.0",
-    "@datagrok/chem": "^1.12.0",
+    "@datagrok/bio": "^2.15.6",
+    "@datagrok/helm": "^2.5.3",
+    "@datagrok/chem": "^1.12.1",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",

package/src/package-test.ts

@@ -2,15 +2,17 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {runTests, tests, TestContext, initAutoTests as initTests } from '@datagrok-libraries/utils/src/test';
+import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/utils/src/test';
 
 import './tests/formats-to-helm';
 import './tests/helm-to-nucleotides';
 import './tests/formats-support';
 import './tests/files-tests';
 import './tests/polytool-convert-tests';
+import './tests/polytool-unrule-tests';
 import './tests/polytool-enumerate-tests';
 import './tests/polytool-enumerate-breadth-tests';
+import './tests/toAtomicLevel-tests';
 
 import {OligoToolkitTestPackage} from './tests/utils';
 

package/src/package.ts

@@ -25,6 +25,7 @@ import {PolyToolCsvLibHandler} from './polytool/csv-to-json-monomer-lib-converte
 import {ITranslationHelper} from './types';
 import {addContextMenuUI} from './utils/context-menu';
 import {PolyToolConvertFuncEditor} from './polytool/pt-convert-editor';
+import {polyToolUnruleUI} from './polytool/pt-unrule';
 
 export const _package: OligoToolkitPackage = new OligoToolkitPackage({debug: true}/**/);
 
@@ -162,6 +163,13 @@ export async function polyToolConvertTopMenu(): Promise<void> {
   await polyToolConvertUI();
 }
 
+// //top-menu: Bio | PolyTool | Unrule...
+// //name: polyToolUnrule
+// //description: Perform uncyclization of polymers by rules
+// export async function polyToolUnruleTopMenu(): Promise<void> {
+//   await polyToolUnruleUI();
+// }
+
 //name: getPolyToolConvertEditor
 //tags: editor
 //input: funccall call

package/src/polytool/const.ts

@@ -34,5 +34,6 @@ export const PT_UI_GET_HELM = 'Get HELM';
 export const PT_UI_ADD_HELM = 'Add HELM column';
 export const PT_UI_USE_CHIRALITY = 'Chirality engine';
 export const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';
+export const PT_UI_DIALOG_UNRULE = 'Poly Tool Unrule';
 export const PT_UI_DIALOG_ENUMERATION = 'Poly Tool Enumeration';
 export const PT_UI_RULES_USED = 'Rules used';

package/src/polytool/pt-conversion.ts

@@ -1,27 +1,35 @@
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {IMonomerLib, IMonomerLibBase, Monomer, MonomerLibData, RGroup} from '@datagrok-libraries/bio/src/types';
+import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {HELM_REQUIRED_FIELD, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
-import {Rules, RuleLink, getRules} from './pt-rules';
+import {Rules, RuleLink, RuleReaction} from './pt-rules';
+import {InvalidReactionError, MonomerNotFoundError} from './types';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {_package} from '../package';
 
 export const RULES_DIMER = '(#2)';
 export const RULES_HETERODIMER = '($2)';
 
-function addCommonTags(col: DG.Column): void {
-  col.semType = DG.SEMTYPE.MACROMOLECULE;
-  col.setTag('aligned', ALIGNMENT.SEQ);
-  col.setTag('alphabet', ALPHABET.PT);
-}
+// function addCommonTags(col: DG.Column): void {
+//   col.semType = DG.SEMTYPE.MACROMOLECULE;
+//   col.setTag('aligned', ALIGNMENT.SEQ);
+//   col.setTag('alphabet', ALPHABET.PT);
+// }
 
 export class Chain {
-  linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[];
+  linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[];
   monomers: string[][];
 
   constructor(
     monomers: string[][],
-    linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[]) {
+    linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[]) {
     this.linkages = linkages;
     this.monomers = monomers;
   }
@@ -32,7 +40,14 @@ export class Chain {
     const rawLinkages = fragmentation[1].split('|');
 
     const monomers = new Array<Array<string>>(rawFragments.length);
-    const linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //HELM parsing
     for (let i = 0; i < rawFragments.length; i++) {
@@ -66,15 +81,22 @@ export class Chain {
     return new Chain(monomers, linkages);
   }
 
-  static fromNotation(sequence: string, rules: Rules) {
+  static fromNotation(sequence: string, rules: Rules): Chain {
     const heterodimerCode = rules.heterodimerCode;
     const homodimerCode = rules.homodimerCode;
     const mainFragments: string[] = [];
 
-    const linkages: {fChain: number, sChain: number, fMonomer:number, sMonomer:number, fR:number, sR:number}[] = [];
+    const linkages: {
+      fChain: number,
+      sChain: number,
+      fMonomer: number,
+      sMonomer: number,
+      fR: number,
+      sR: number
+    }[] = [];
 
     //NOTICE: this works only with simple single heterodimers
-    const heterodimeric = heterodimerCode !== null? sequence.split(`(${rules.heterodimerCode!})`) : '';
+    const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
     if (heterodimerCode !== null && heterodimeric.length > 1) {
       linkages.push({fChain: 0, sChain: 1, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
       mainFragments.push(heterodimeric[1].replaceAll('{', '').replaceAll('}', ''));
@@ -99,17 +121,32 @@ export class Chain {
       }
     }
 
+    for (let i = 0; i < mainFragments.length; i++) {
+      if (homodimerCode !== null && mainFragments[i].includes(`(${homodimerCode!})`)) {
+        const idxSequence = mainFragments.length;
+
+        linkages.push({fChain: i, sChain: idxSequence, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
+        const rawDimer = mainFragments[i].replace(`(${homodimerCode!})`, '');
+        const idx = rawDimer.indexOf('{');
+        const linker = rawDimer.slice(0, idx);
+        const body = rawDimer.replace(linker, '').replaceAll('{', '').replaceAll('}', '');
+
+        mainFragments[i] = linker + body;
+        mainFragments.push(body);
+      }
+    }
+
     const monomers = new Array<Array<string>>(mainFragments.length);
 
     for (let i = 0; i < mainFragments.length; i++) {
       const rawMonomers = mainFragments[i].split('-');
       const linkedPositions = this.getLinkedPositions(rawMonomers, rules.linkRules);
       const [monomersCycled, allPos1, allPos2, allAttaches1, allAttaches2] =
-      this.getAllCycles(rules.linkRules, rawMonomers, linkedPositions);
+        this.getAllCycles(rules.linkRules, rawMonomers, linkedPositions);
 
       const monomersReady = new Array<string>(monomersCycled.length);
-      for (let j = 0; j < monomersCycled.length; j++)
-        monomersReady[j] = `[${monomersCycled[j]}]`;
+      // for (let j = 0; j < monomersCycled.length; j++)
+      //   monomersReady[j] = `[${monomersCycled[j]}]`;
 
       for (let j = 0; j < allPos1.length; j++) {
         linkages.push({
@@ -122,10 +159,72 @@ export class Chain {
         });
       }
 
-      monomers[i] = monomersReady;
+      monomers[i] = monomersCycled;
     }
 
-    return new Chain(monomers, linkages);
+    const monomersAll: string[][] = [];
+
+    for (let i = 0; i < monomers.length; i++) {
+      const linkedPositions = this.getLinkedPositions(monomers[i], rules.reactionRules);
+      const [monomersCycled, allPos1, allPos2, ruleN] =
+        this.getAllReactants(rules.reactionRules, monomers[i], linkedPositions);
+
+      if (allPos1.length >= 1) {
+        const ch1 = new Array<string>(allPos2[0] - 1);
+        const ch2 = new Array<string>(monomersCycled.length - allPos2[0]);
+        for (let j = 0; j < allPos2[0] - 1; j++)
+          ch1[j] = monomersCycled[j];
+
+        for (let j = allPos2[0]; j < monomersCycled.length; j++)
+          ch2[j - allPos2[0]] = monomersCycled[j];
+
+
+        ch1[allPos1[0] - 1] = rules.reactionRules[ruleN[0]].name;
+
+        for (let j = 0; j < linkages.length; j++) {
+          if (linkages[j].fMonomer > allPos2[0]) {
+            linkages[j].fMonomer -= allPos2[0];
+            linkages[j].fChain++;
+          }
+          if (linkages[j].sMonomer > allPos2[0]) {
+            linkages[j].sMonomer -= allPos2[0];
+            linkages[j].sChain++;
+          }
+        }
+        linkages.push({
+          fChain: 0,
+          sChain: 0,
+          fMonomer: allPos1[0],
+          sMonomer: allPos2[0] - 1,
+          fR: 3,
+          sR: 2,
+        });
+
+        linkages.push({
+          fChain: 0,
+          sChain: 1,
+          fMonomer: allPos1[0],
+          sMonomer: 1,
+          fR: 4,
+          sR: 1,
+        });
+
+        const monomersReady1 = new Array<string>(ch1.length);
+        for (let j = 0; j < ch1.length; j++)
+          monomersReady1[j] = `[${ch1[j]}]`;
+        const monomersReady2 = new Array<string>(ch2.length);
+        for (let j = 0; j < ch2.length; j++)
+          monomersReady2[j] = `[${ch2[j]}]`;
+
+        monomersAll.push(ch1);
+        monomersAll.push(ch2);
+      } else {
+        monomersAll.push(monomers[i]);
+      }
+    }
+
+    const chain = new Chain(monomersAll, linkages);
+    return chain;
   }
 
   getHelmChanged(changeNumber: number, monomer: string): string {
@@ -134,17 +233,17 @@ export class Chain {
     let idx1 = 0;
     let idx2 = 0;
     loop1:
-    for (let i = 0; i < this.monomers.length; i++) {
-      loop2:
-      for (let j = 0; j < this.monomers[i].length; j++) {
-        if (counter == changeNumber) {
-          idx1 = i;
-          idx2 = j;
-          break loop1;
-        }
-        counter++;
+      for (let i = 0; i < this.monomers.length; i++) {
+        loop2:
+          for (let j = 0; j < this.monomers[i].length; j++) {
+            if (counter == changeNumber) {
+              idx1 = i;
+              idx2 = j;
+              break loop1;
+            }
+            counter++;
+          }
       }
-    }
 
     const previous = this.monomers[idx1][idx2];
 
@@ -166,7 +265,8 @@ export class Chain {
       for (let j = 0; j < this.monomers[i].length; j++) {
         if (j > 0)
           helm += '.';
-        helm += this.monomers[i][j];
+        const symbol = this.monomers[i][j];
+        helm += symbol.length > 1 ? `[${symbol}]` : symbol;
       }
       helm += `}`;
     }
@@ -185,8 +285,13 @@ export class Chain {
     return helm;
   }
 
-  protected static getLinkedPositions(monomers: string[], rules: RuleLink[]): [number, number][] {
-    const result: [number, number][] = new Array<[number, number]>(rules.length);
+  getNotation(rules: Rules): string {
+    return 'not implemented';
+  }
+
+  protected static getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []):
+    [number, number, number][] {
+    const result: [number, number, number][] = new Array<[number, number, number]>(rules.length);
 
     for (let i = 0; i < rules.length; i++) {
       let firstFound = false;
@@ -226,19 +331,18 @@ export class Chain {
       }
 
       if (!(firstFound && secondFound))
-        result[i] = [-1, -1];
+        result[i] = [-1, -1, -1];
       else if (firstIsFirst)
-        result[i] = [firstEntryIndex, secondEntryIndex];
+        result[i] = [firstEntryIndex, secondEntryIndex, i];
       else
-        result[i] = [secondEntryIndex, firstEntryIndex];
+        result[i] = [secondEntryIndex, firstEntryIndex, i];
     }
 
-
     return result;
   }
 
-  protected static getAllCycles(rules: RuleLink[], monomers: string [], positions: [number, number][]) :
-  [string [], number [], number [], number [], number []] {
+  protected static getAllCycles(rules: RuleLink[], monomers: string [], positions: [number, number, number][]):
+    [string [], number [], number [], number [], number []] {
     const allPos1: number [] = [];
     const allPos2: number [] = [];
     const allAttaches1: number [] = [];
@@ -251,7 +355,6 @@ export class Chain {
 
       const firstMonomer = monomers[positions[i][0]];
       const secondMonomer = monomers[positions[i][1]];
-
       monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstSubstitution);
       monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondSubstitution);
 
@@ -263,17 +366,185 @@ export class Chain {
 
     return [monomers, allPos1, allPos2, allAttaches1, allAttaches2];
   }
+
+  protected static getAllReactants(rules: RuleReaction[], monomers: string [], positions: [number, number, number][]):
+    [string [], number [], number [], number []] {
+    const allPos1: number [] = [];
+    const allPos2: number [] = [];
+    const rule: number [] = [];
+    const ruleCount = rules.length;
+
+    for (let i = 0; i < ruleCount; i++) {
+      if (positions[i][0] == -1)
+        continue;
+
+      const firstMonomer = monomers[positions[i][0]];
+      const secondMonomer = monomers[positions[i][1]];
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstMonomer);
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondMonomer);
+
+      allPos1.push(positions[i][0] + 1);
+      allPos2.push(positions[i][1] + 1);
+      rule.push(positions[i][2]);
+    }
+
+    return [monomers, allPos1, allPos2, rule];
+  }
 }
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
 export function doPolyToolConvert(sequences: string[], rules: Rules): string[] {
   const helms = new Array<string>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
-    if (sequences[i] === undefined) { helms[i] = ''; } else {
-      const chain = Chain.fromNotation(sequences[i], rules);
-      helms[i] = chain.getHelm();
+    try {
+      if (sequences[i] == null) { helms[i] = ''; } else {
+        const chain = Chain.fromNotation(sequences[i], rules);
+        helms[i] = chain.getHelm();
+      }
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      helms[i] = '';
     }
   }
-
   return helms;
 }
+
+function getMonomersMolBlocks(monomer1: Monomer, monomer2: Monomer): [string, string] {
+  const mb1 = monomer1.molfile;
+  let mb2 = monomer2.molfile;
+  const addGroups = monomer1.rgroups.length;
+
+  //mol v2000 monomer
+  const rgpIdx = mb2.indexOf('M  RGP');
+  if (rgpIdx !== -1) {
+    const groupsCountStr = mb2.substring(rgpIdx + 6, rgpIdx + 9);
+    const groupsCount = Number(groupsCountStr);
+
+    for (let i = 0; i < groupsCount; i++) {
+      const start = rgpIdx + 9 + 4 + i * 8;
+      const end = rgpIdx + 9 + 8 + i * 8;
+      const rGroupSpecifier = mb2.substring(start, end);
+      const groupPosition = Number(rGroupSpecifier) + addGroups;
+      const digits = Math.floor(Math.log10(groupPosition) + 1);
+      const newSpecifier = ' '.repeat(4 - digits) + String(groupPosition);
+      mb2 = mb2.substring(0, start) + newSpecifier + mb2.substring(end, mb2.length);
+    }
+  }
+
+  //TODO: same for v3000 monomer
+
+  return [mb1, mb2];
+}
+
+function getSyntheticMolBlock(rdkit: RDModule, reaction: string,
+  mb1: string, mb2: string, monomerName: string): string {
+  let rxn: RDReaction | null = null;
+  let mols: MolList | null = null;
+  let mol1: RDMol | null = null;
+  let mol2: RDMol | null = null;
+  let rctns: RDReactionResult | null = null;
+  let molP: RDMol | null = null;
+  let molBlock = '';
+
+  try {
+    rxn = rdkit.get_rxn(reaction);
+    if (!rxn) throw new InvalidReactionError(reaction);
+    mols = new rdkit.MolList();
+    mol1 = rdkit.get_mol(mb1!);
+    mol2 = rdkit.get_mol(mb2!);
+    mols.append(mol1!);
+    mols.append(mol2!);
+
+    rctns = rxn.run_reactants(mols, 1);
+    //const size = rctns.size();
+    const element = rctns.get(0);
+
+    molP = element.next();
+    molBlock = molP?.get_molblock();//molP?.get_v3Kmolblock();//
+  } catch (err: any) {
+    const [errMsg, _errStack] = errInfo(err);
+    grok.shell.error(`Can not assemble monomer '${monomerName}': ${errMsg}.`);
+    throw err;
+  } finally {
+    rxn?.delete();
+    mols?.delete();
+    mol1?.delete();
+    mol2?.delete();
+    rctns?.delete();
+    molP?.delete();
+  }
+
+  return molBlock;
+}
+
+function getNewGroups(monomer1: Monomer, monomer2: Monomer): RGroup[] {
+  const groups = new Array<RGroup>(monomer1?.rgroups.length! + monomer2?.rgroups.length!);
+  const length1 = monomer1?.rgroups.length!;
+  const length2 = monomer2?.rgroups.length!;
+
+  for (let i = 0; i < length1; i++)
+    groups[i] = monomer1?.rgroups[i]!;
+
+  for (let i = 0; i < length2; i++) {
+    const rGroupSpecifier = monomer2?.rgroups[i]!.label.replace('R', '');
+    const groupPosition = Number(rGroupSpecifier) + length1;
+    const group: RGroup = {
+      //@ts-ignore
+      [HELM_RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE]: monomer2?.rgroups[i].capGroupSMILES.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.ALTERNATE_ID]: monomer2?.rgroups[i].alternateId.replace(rGroupSpecifier, String(groupPosition)),
+      [HELM_RGROUP_FIELDS.CAP_GROUP_NAME]: monomer2?.rgroups[i].capGroupName,
+      [HELM_RGROUP_FIELDS.LABEL]: monomer2?.rgroups[i].label.replace(rGroupSpecifier, String(groupPosition)),
+    };
+
+    groups[i + length1] = group;
+  }
+
+  return groups;
+}
+
+export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReaction): [string, Monomer] {
+  const reacSmarts = rule.reaction;
+  const monomerName = rule.name;
+
+  const monomer1 = mLib.getMonomer('PEPTIDE', rule.firstMonomer);
+  if (!monomer1) throw new MonomerNotFoundError('PEPTIDE', rule.firstMonomer);
+  const monomer2 = mLib.getMonomer('PEPTIDE', rule.secondMonomer);
+  if (!monomer2) throw new MonomerNotFoundError('PEPTIDE', rule.secondMonomer);
+
+  const [mb1, mb2] = getMonomersMolBlocks(monomer1!, monomer2!);
+  const molBlock = getSyntheticMolBlock(rdkit, reacSmarts, mb1, mb2, monomerName);
+  const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
+
+  const resMonomer: Monomer = {
+    [HELM_REQUIRED_FIELD.SYMBOL]: monomerName,
+    [HELM_REQUIRED_FIELD.NAME]: monomerName,
+    [HELM_REQUIRED_FIELD.MOLFILE]: molBlock,
+    [HELM_REQUIRED_FIELD.AUTHOR]: '',
+    [HELM_REQUIRED_FIELD.ID]: 0,
+    [HELM_REQUIRED_FIELD.RGROUPS]: groups,
+    [HELM_REQUIRED_FIELD.SMILES]: '',
+    [HELM_REQUIRED_FIELD.POLYMER_TYPE]: 'PEPTIDE',
+    [HELM_REQUIRED_FIELD.MONOMER_TYPE]: 'Backbone',
+    [HELM_REQUIRED_FIELD.CREATE_DATE]: null,
+  };
+
+  return [monomerName, resMonomer];
+}
+
+export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBase> {
+  const monomerLibHelper = await getMonomerLibHelper();
+  const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+  const rdkit = await getRdKitModule();
+  const argLib: { [symbol: string]: Monomer } = {};
+
+  for (let i = 0; i < rules.reactionRules.length; i++) {
+    const [name, monomer] = getNewMonomer(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    argLib[name] = monomer;
+  }
+
+  const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
+  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+  return overriddenMonomerLib;
+}