@datagrok/sequence-translator 1.4.1 → 1.4.3

package/files/polytool-rules/rules_example.json

@@ -23,6 +23,16 @@
       "secondSubstitution": "D"
     }
   },
+  {
+    "type": "reaction",
+    "code": "3",
+    "monomericSubstitution": {
+      "firstMonomer": "aG",
+      "secondMonomer": "azG",
+      "reaction": "[H:1]NC(C([OH:2])=O)c1cn(C(N[H:3])C([OH:4])=O)nn1",
+      "name": "GGaz"
+    }
+  },
   {
     "type": "fragmentDuplication",
     "code": "#3"

package/files/samples/cyclized.csv

@@ -1,6 +1,7 @@
 n,seqs
-1,R-F-C(1)-T-G-H-F-Y-P-C(1)-meI
+1,R-F-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-C(1)-meI
 2,C(1)-T-G-H-F-Y-P-C(1)-meI
 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-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,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"
@@ -22,10 +22,10 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.42.15",
-    "@datagrok-libraries/chem-meta": "^1.2.5",
+    "@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.1",
-    "@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,14 +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} 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';
 
@@ -25,3 +28,8 @@ export async function test(category: string, test: string, testContext: TestCont
   const data = await runTests({category, test, testContext, verbose: true});
   return DG.DataFrame.fromObjects(data)!;
 }
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

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,27 @@
-import * as grok from 'datagrok-api/grok';
-import * as DG from 'datagrok-api/dg';
+// import * as grok from 'datagrok-api/grok';
+// 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 {Rules, RuleLink, getRules} from './pt-rules';
+//import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+import {Rules, RuleLink, RuleReaction} from './pt-rules';
 
 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 +32,7 @@ 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 +66,15 @@ 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 +99,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 +137,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 +211,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 +243,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 +263,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 +309,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 +333,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 +344,40 @@ 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 {
+    if (sequences[i] == null) { helms[i] = ''; } else {
       const chain = Chain.fromNotation(sequences[i], rules);
       helms[i] = chain.getHelm();
     }
   }
-
   return helms;
 }

package/src/polytool/pt-dialog.ts

@@ -9,6 +9,7 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 
 import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {doPolyToolConvert} from './pt-conversion';
@@ -23,6 +24,17 @@ import {
 
 import {_package} from '../package';
 
+type PolyToolConvertSerialized = {
+  generateHelm: boolean;
+  chiralityEngine: boolean;
+  rules: string[];
+};
+
+type PolyToolEnumerateChemSerialized = {
+  mol: string;
+  screenLibrary: string | null;
+}
+
 export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
   getPolyToolEnumerationChemDialog(cell)
     .then((dialog) => {
@@ -45,45 +57,52 @@ export async function polyToolConvertUI(): Promise<void> {
   }
 }
 
-export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<DG.Dialog> {
+export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.Dialog> {
   const subs: Unsubscribable[] = [];
   const destroy = () => {
     for (const sub of subs) sub.unsubscribe();
   };
   try {
-    const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
-    if (!targetColumns)
-      throw new Error(PT_ERROR_DATAFRAME);
-
-    const targetColumnInput = ui.input.column('Column', {
-      table: grok.shell.t, value: targetColumns[0],
-      filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE
+    let srcColVal: DG.Column<string> | undefined = srcCol;
+    if (!srcColVal) {
+      const srcColList = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+      if (srcColList.length < 1)
+        throw new Error(PT_ERROR_DATAFRAME);
+      srcColVal = srcColList[0];
+    }
+    const srcColInput = ui.input.column('Column', {
+      table: srcColVal.dataFrame, value: srcColVal,
+      filter: (col: DG.Column) => {
+        if (col.semType !== DG.SEMTYPE.MACROMOLECULE) return false;
+        const sh = SeqHandler.forColumn(col);
+        return sh.notation === NOTATION.CUSTOM;
+      }
     });
 
-    targetColumnInput.value = targetCol ? targetCol : targetColumnInput.value;
-
-    const generateHelmChoiceInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
-    ui.tooltip.bind(generateHelmChoiceInput.root, PT_UI_ADD_HELM);
+    const generateHelmInput = ui.input.bool(PT_UI_GET_HELM, {value: true});
+    ui.tooltip.bind(generateHelmInput.root, PT_UI_ADD_HELM);
 
     const chiralityEngineInput = ui.input.bool(PT_UI_USE_CHIRALITY, {value: false});
-    const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json');
+    let ruleFileList: string[];
+    const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.json', {
+      onValueChanged: (value: string[]) => { ruleFileList = value;}
+    });
     const rulesHeader = ui.inlineText([PT_UI_RULES_USED]);
     ui.tooltip.bind(rulesHeader, 'Add or specify rules to use');
     const rulesForm = await ruleInputs.getForm();
 
-    const div = ui.div([
-      targetColumnInput,
-      generateHelmChoiceInput,
+    const div = ui.divV([
+      srcColInput,
+      generateHelmInput,
       chiralityEngineInput,
       rulesHeader,
       rulesForm
     ]);
 
-
     const exec = async (): Promise<void> => {
       try {
         const ruleFileList = await ruleInputs.getActive();
-        await polyToolConvert(targetColumnInput.value!, generateHelmChoiceInput.value!, chiralityEngineInput.value!, ruleFileList);
+        await polyToolConvert(srcColInput.value!, generateHelmInput.value!, chiralityEngineInput.value!, ruleFileList);
       } catch (err: any) {
         defaultErrorHandler(err);
       }
@@ -95,7 +114,19 @@ export async function getPolyToolConvertDialog(targetCol?: DG.Column): Promise<D
     subs.push(dialog.onClose.subscribe(() => {
       destroy();
     }));
-
+    dialog.history(
+      /* getInput */ (): PolyToolConvertSerialized => {
+        return {
+          generateHelm: generateHelmInput.value,
+          chiralityEngine: chiralityEngineInput.value,
+          rules: ruleFileList,
+        };
+      },
+      /* applyInput */ (x: PolyToolConvertSerialized): void => {
+        generateHelmInput.value = x.generateHelm;
+        chiralityEngineInput.value = x.chiralityEngine;
+        ruleInputs.setActive(ruleFileList);
+      });
     return dialog;
   } catch (err: any) {
     destroy(); // on failing to build a dialog
@@ -133,15 +164,15 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
     molInput.setMolFile(molfileValue);
 
     //const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
-    const screenLibrary = ui.input.choice('Library to use', {value: null, items: libList});
+    const screenLibraryInput = ui.input.choice('Library to use', {value: null, items: libList});
 
     molInput.root.setAttribute('style', `min-width:250px!important;`);
     molInput.root.setAttribute('style', `max-width:250px!important;`);
-    screenLibrary.input.setAttribute('style', `min-width:250px!important;`);
+    screenLibraryInput.input.setAttribute('style', `min-width:250px!important;`);
 
     const div = ui.div([
       molInput.root,
-      screenLibrary.root
+      screenLibraryInput.root
     ]);
 
     subs.push(grok.events.onCurrentCellChanged.subscribe(() => {
@@ -160,7 +191,7 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
         } else if (!molString.includes('R#')) {
           grok.shell.warning('PolyTool: no R group was provided');
         } else {
-          const molecules = await getEnumerationChem(molString, screenLibrary.value!);
+          const molecules = await getEnumerationChem(molString, screenLibraryInput.value!);
           const molCol = DG.Column.fromStrings('Enumerated', molecules);
           const df = DG.DataFrame.fromColumns([molCol]);
           grok.shell.addTableView(df);
@@ -182,6 +213,17 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
     subs.push(dialog.onClose.subscribe(() => {
       destroy();
     }));
+    dialog.history(
+      /* getInput */ (): PolyToolEnumerateChemSerialized => {
+        return {
+          mol: molInput.getMolFile(),
+          screenLibrary: screenLibraryInput.value,
+        };
+      },
+      /* applyInput */ (x: PolyToolEnumerateChemSerialized): void => {
+        molInput.setMolFile(x.mol);
+        screenLibraryInput.value = x.screenLibrary;
+      });
     return dialog;
   } catch (err: any) {
     destroy();
@@ -215,7 +257,27 @@ export async function polyToolConvert(
 
     const seqHelper: ISeqHelper = await getSeqHelper();
     const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm);
-    const resMolCol = toAtomicLevelRes.molCol;
+    const resMolCol = toAtomicLevelRes.molCol!;
+
+    // const rdkit = await grok.functions.call('Chem:getRdKitModule');
+    // for (let i = 0; i < rules.reactionRules.length; i++) {
+    //   const reacSmarts = rules.reactionRules[i].reaction;
+    //   const rxn = rdkit.get_rxn(reacSmarts);
+
+    //   for (let j = 0; j < resMolCol.length; j++) {
+    //     const mols = new rdkit.MolList();
+    //     const mol = rdkit.get_mol(resMolCol.get(j));
+    //     mols.append(mol!);
+    //     const rctns = rxn.run_reactants(mols, 1);
+    //     const size = rctns.size();
+    //     const element = rctns.get(0);
+    //     let molP: RDMol | null = null;
+    //     molP = element.next();
+    //     const molBlock = molP?.get_v3Kmolblock();
+    //     resMolCol.set(j, molBlock!);
+    //   }
+    // }
+
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
     if (table) {