@datagrok/sequence-translator 1.4.4 → 1.4.6

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -5,41 +5,131 @@ import * as DG from 'datagrok-api/dg';
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 import {Chain} from '../polytool/pt-conversion';
 import {getRules} from '../polytool/pt-rules';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+category('PolyTool: Chain', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper();
+  });
 
-category('PolyTool: Chain: fromNotation', () => {
   const tests = {
     'cyclized': {
-      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      data: {
+        templateSeq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[C(1)].T.G.H.F.Y.P.[C(1)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
+      },
       tgt: {
-        monomerCount: [11], linkageCount: 1,
-        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+        templateChain: {monomerCount: [11], linkageCount: 0},
+        mmChain: {monomerCount: [11], linkageCount: 1,}
       },
     },
     'reaction1': {
-      src: {seq: 'R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI'},
+      data: {
+        templateSeq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[azG(4)].T.G.H.F.Y.P.[aG(4)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$V2.0',
+      },
       tgt: {
-        monomerCount: [9, 1], linkageCount: 2,
-        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$',
+        templateChain: {monomerCount: [11], linkageCount: 0,},
+        mmChain: {monomerCount: [9, 1], linkageCount: 2,}
       }
     },
     'reaction2': {
-      src: {seq: 'R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI'},
+      data: {
+        templateSeq: 'R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[aG(4)].T.G.H.F.Y.P.[azG(4)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$V2.0',
+      },
+      tgt: {
+        templateChain: {monomerCount: [11], linkageCount: 0,},
+        mmChain: {monomerCount: [2, 8], linkageCount: 2,}
+      }
+    },
+    'dimerized1': {
+      data: {
+        templateSeq: '(#3)Succ-{A(CHOL)-F-C(1)-T-G-H-Y-P-C(1)-NH2}',
+        templateHelm: 'PEPTIDE1{[(#3)Succ]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.[C(1)].T.G.H.Y.P.[C(1)].[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+        mmHelm: 'PEPTIDE1{[Succ].[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
+          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
+          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+      },
+      tgt: {
+        templateChain: {monomerCount: [1, 10], linkageCount: 1},
+        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+      }
+    },
+    'dimerized2': {
+      data: {
+        templateSeq: '($3)Succ-{R-F-C(1)-T-G-H-F-P-C(1)-NH2}($3){A(CHOL)-F-C(1)-Y-H-G-D-N-C(1)-meI}',
+        templateHelm: 'PEPTIDE1{[($3)Succ]}' + '|' +
+          'PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '|' +
+          'PEPTIDE3{[($3)A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+        mmHelm: 'PEPTIDE1{[Succ].R.F.C.T.G.H.F.P.C.[NH2]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.C.Y.H.G.D.N.C.[meI]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
+          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
+          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+      },
       tgt: {
-        // TODO: Target test data requires clarification
-        monomerCount: [2, 8], linkageCount: 0,
-        helm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$',
+        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1,},
+        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
       }
     }
-
   };
 
-  for (const [testName, testData] of Object.entries(tests)) {
-    test(`${testName}`, async () => {
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`fromNotation-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resChain = Chain.fromNotation(testData.src.seq, rules);
-      expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
-      expect(resChain.linkages.length, testData.tgt.linkageCount);
-      expect(resChain.getHelm(), testData.tgt.helm);
+      const resMmChain = Chain.fromNotation(data.templateSeq, rules, helmHelper);
+      resMmChain.check(true);
+      expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
+      expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
+      expect(resMmChain.getHelm(), data.mmHelm);
     }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
   }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`parseNotation-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
+      resTemplateChain.check(true);
+      expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
+      expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
+      expect(resTemplateChain.getHelm(), data.templateHelm);
+      expect(resTemplateChain.getNotation(), data.templateSeq);
+    });
+  }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`parseHelm-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseHelm(data.templateHelm, helmHelper);
+      resTemplateChain.check(true);
+      expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
+      expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
+      expect(resTemplateChain.getHelm(), data.templateHelm);
+      expect(resTemplateChain.getNotation(), data.templateSeq);
+    });
+  }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`applyRules-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
+      const resMmChain = resTemplateChain.applyRules(rules);
+      resMmChain.check(true);
+      expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
+      expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
+      expect(resMmChain.getHelm(), data.mmHelm);
+    }, {skipReason: 'applyRules is not implemented'});
+  }
+
 });

package/src/tests/polytool-chain-parse-notation-tests.ts

@@ -0,0 +1,100 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {Chain, getInnerIdx, getOuterIdx} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+category('PolyTool: Chain: parseNotation', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+  });
+
+  const tests = {
+    'cyclized': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        //monomerCount: [11], linkageCount: 1,
+        helm: 'PEPTIDE1{R.F.[C(1)].T.G.H.F.Y.P.[C(1)].[meI]}$$$$V2.0',
+      }
+    },
+    'dimerized1': {
+      src: {seq: '(#3)Succ-{A(CHOL)-F-C(1)-T-G-H-Y-P-C(1)-NH2}'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        //monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{[(#3)Succ]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.[C(1)].T.G.H.Y.P.[C(1)].[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+      }
+    },
+    'dimerized2': {
+      src: {seq: '($3)Succ-{R-F-C(1)-T-G-H-F-P-C(1)-NH2}($2){A(CHOL)-F-C(1)-T-G-H-F-P-C(1)-NH2}'},
+      tgt: {
+        // TODO: Target test data requires clarification
+        //monomerCount: [2, 8], linkageCount: 0,
+        helm: 'PEPTIDE1{[($3)Succ]}' + '|' +
+          'PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '|' +
+          'PEPTIDE3{[($2)A(CHOL)].F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+      }
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resChain = await Chain.parseNotation(testData.src.seq, helmHelper);
+      //expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
+      //expect(resChain.linkages.length, testData.tgt.linkageCount);
+      // expect(resChain.getNotationHelm(), testData.tgt.helm);
+      // expect(resChain.getNotation(), testData.src.seq);
+
+      const resMol = resChain.mol!;
+      const hwe = helmHelper.createHelmWebEditor();
+      hwe.editor.setMol(resMol!);
+      const resMolHelm = hwe.editor.getHelm();
+
+      const resHelm = resChain.getNotationHelm();
+
+      expect(resMolHelm, testData.tgt.helm);
+      expect(resHelm, testData.tgt.helm);
+    }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
+  }
+
+  const innerIdxTests = {
+    '0-in-4-4-3': {inIdx: 0, spIdx: 0, outIdx: 0, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    '3-in-4-4-3': {inIdx: 3, spIdx: 0, outIdx: 3, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    '4-in-4-4-3': {inIdx: 0, spIdx: 1, outIdx: 4, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    '7-in-4-4-3': {inIdx: 3, spIdx: 1, outIdx: 7, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    '8-in-4-4-3': {inIdx: 0, spIdx: 2, outIdx: 8, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    // '11-in-4-4-3': {inIdx: 0, spIdx: 3, outIdx: 11, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    // '12-in-4-4-3': {inIdx: 1, spIdx: 3, outIdx: 12, monomers: [['0', '1', '2', '3'], ['4', '5', '6', '7'], ['8', '9', '10']]},
+    '0-in-1-1-6-3': {inIdx: 0, spIdx: 0, outIdx: 0, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+    '1-in-1-1-6-3': {inIdx: 0, spIdx: 1, outIdx: 1, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+    '2-in-1-1-6-3': {inIdx: 0, spIdx: 2, outIdx: 2, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+    '3-in-1-1-6-3': {inIdx: 1, spIdx: 2, outIdx: 3, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+    '7-in-1-1-6-3': {inIdx: 5, spIdx: 2, outIdx: 7, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+    '8-in-1-1-6-3': {inIdx: 0, spIdx: 3, outIdx: 8, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]},
+//    '11-in-1-1-6-3': {inIdx: 0, spIdx: 4}, src: {outIdx: 11, monomers: [['0'], ['1'], ['2', '3', '4', '5', '6', '7'], ['8', '9', '10']]}},
+  };
+
+  for (const [testName, {inIdx, spIdx, outIdx, monomers}] of Object.entries(innerIdxTests)) {
+    test(`innerIdx-${testName}`, async () => {
+      const [resInIdx, resSpIdx] = getInnerIdx(outIdx, monomers);
+      expect(resInIdx, inIdx);
+      expect(resSpIdx, spIdx);
+    });
+  }
+
+  for (const [testName, {inIdx, spIdx, outIdx, monomers}] of Object.entries(innerIdxTests)) {
+    test(`outerIdx-${testName}`, async () => {
+      const resOutIdx = getOuterIdx(inIdx, spIdx, monomers);
+      expect(resOutIdx, outIdx);
+    });
+  }
+});

package/src/tests/polytool-convert-tests.ts

@@ -2,25 +2,35 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
+import {before, after, category, expect, test, expectArray, testEvent, delay, expectObject} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {
   getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
-import {doPolyToolConvert} from '../polytool/pt-conversion';
+import {doPolyToolConvert, getOverriddenLibrary} from '../polytool/pt-conversion';
 import {getRules} from '../polytool/pt-rules';
 
-import {_package} from '../package-test';
 
+import {_package} from '../package-test';
 
 category('PolyTool: Convert', () => {
+  let helmHelper: IHelmHelper;
+  let seqHelper: ISeqHelper;
+  let rdKitModule: RDModule;
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings; //backup
 
   before(async () => {
+    helmHelper = await getHelmHelper();
+    seqHelper = await getSeqHelper();
+    rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
@@ -32,43 +42,107 @@ category('PolyTool: Convert', () => {
     await monomerLibHelper.loadMonomerLib(true);
   });
 
-  const tests: { [testName: string]: { src: string[], tgt: string[] } } = {
-    'cyclized': {
-      src: [
-        'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI',
-        'C(1)-T-G-H-F-Y-P-C(1)-meI',
-        'R-F-C(1)-T-G-H-F-Y-P-C(1)',
-        'C(1)-T-G-H-F-H-P-C(1)',
-        'R-F-D(2)-T-G-H-F-Y-P-NH2(2)',
-      ],
-      tgt: [
-        'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
-        'PEPTIDE1{C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
-        'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
-        'PEPTIDE1{C.T.G.H.F.H.P.C}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$',
-        'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$',
-      ]
-    }
+  const tests = {
+    'cyclized-C(1)-2-1': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
+        mol: {atomCount: 95, bondCount: 100, inchiKey: 'LMJUFVBPWWJJPN-AJJYTACESA-N',},
+      }
+    },
+    'cyclized-C(1)-0-1': {
+      src: {seq: 'C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      tgt: {
+        helm: 'PEPTIDE1{C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$V2.0',
+        mol: {atomCount: 73, bondCount: 77, inchiKey: 'KLFRBMUPPMMGJM-HXTBFBBASA-N',},
+      }
+    },
+    'cyclized-C(1)-2-0': {
+      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)'},
+      tgt: {
+        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
+        mol: {atomCount: 86, bondCount: 91, inchiKey: 'WIHSRTQGMICACU-DDDKLKPZSA-N',},
+      }
+    },
+    'cyclized-C(1)-0-0': {
+      src: {seq: 'C(1)-T-G-H-F-Y-P-C(1)'},
+      tgt: {
+        helm: 'PEPTIDE1{C.T.G.H.F.Y.P.C}$PEPTIDE1,PEPTIDE1,1:R3-8:R3$$$V2.0',
+        mol: {atomCount: 64, bondCount: 68, inchiKey: 'LOSMDBLEXLWPLB-OFZKBENXSA-N',},
+      }
+    },
+    'cyclized-D(2)-NH2(2)-3-0': {
+      src: {seq: 'R-F-D(2)-T-G-H-F-Y-P-NH2(2)'},
+      tgt: {
+        helm: 'PEPTIDE1{R.F.D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,10:R2-3:R3$$$V2.0',
+        mol: {atomCount: 81, bondCount: 86, inchiKey: 'CBMGNYKOZWNVNK-AHGCAHLCSA-N',},
+      }
+    },
+    'cyclized-D(2)-NH2(2)-0-0': {
+      src: {seq: 'D(2)-T-G-H-F-Y-P-NH2(2)'},
+      tgt: {
+        helm: 'PEPTIDE1{D.T.G.H.F.Y.P.[NH2]}$PEPTIDE1,PEPTIDE1,8:R2-1:R3$$$V2.0',
+        mol: {atomCount: 59, bondCount: 63, inchiKey: 'HGRHAUQBJXFERJ-MUFWPYSASA-N',},
+      }
+    },
+    'cyclized-azG(4)-aG(4)-2-1': {
+      src: {seq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI'},
+      tgt: {
+        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$V2.0',
+        mol: {atomCount: 97, bondCount: 103, inchiKey: 'WJSYGVBGPCCSJF-PERUNASMSA-N',},
+      }
+    },
   };
 
   for (const [testName, testData] of Object.entries(tests)) {
-    test(`${testName}`, async () => {
+    test(`toHelm-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const res = doPolyToolConvert(testData.src, rules);
-      expectArray(res, testData.tgt);
+      const res = doPolyToolConvert([testData.src.seq], rules, helmHelper);
+      expect(res[0], testData.tgt.helm);
     });
   }
 
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`toAtomicLevel-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const helmList = doPolyToolConvert([testData.src.seq], rules, helmHelper);
+
+      const lib = await getOverriddenLibrary(rules);
+
+      const helmCol = DG.Column.fromStrings('helm', helmList);
+      helmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      helmCol.meta.units = NOTATION.HELM;
+      const talRes = await seqHelper.helmToAtomicLevel(helmCol, false, false, lib);
+      if (talRes.warnings && talRes.warnings.length > 0)
+        throw new Error(talRes.warnings[0]);
+      expect(talRes.molCol != null, true, '.molCol is not null');
+      const k = 11;
+      const molfile = talRes.molCol!.get(0)!;
+      const mol = rdKitModule.get_mol(molfile);
+      try {
+        const resMol = {
+          atomCount: mol.get_num_atoms(), bondCount: mol.get_num_bonds(),
+          inchiKey: rdKitModule.get_inchikey_for_inchi(mol.get_inchi())
+        };
+        expectObject(resMol, testData.tgt.mol);
+      } finally {
+        mol.delete();
+      }
+    });
+  }
 
   test('ui-col-wo-table', async () => {
     const packageName = _package.name;
-    const seqCol = DG.Column.fromStrings('seq', tests['cyclized'].src);
+    const seqList = Object.values(tests).map((td) => td.src.seq);
+    const helmList = Object.values(tests).map((td) => td.tgt.helm);
+    const seqCol = DG.Column.fromStrings('seq', seqList);
     const helmCol: DG.Column = await grok.functions.call(`${packageName}:polyToolConvert2`, {
       seqCol: seqCol,
       generateHelm: true,
       chiralityEngine: true,
       rules: ['rules_example.json']
     });
+    expectArray(helmCol.toList(), helmList);
     expect(helmCol.semType, DG.SEMTYPE.MACROMOLECULE);
     expect(helmCol.meta.units, NOTATION.HELM);
     expect(helmCol.dataFrame, null);
@@ -76,7 +150,9 @@ category('PolyTool: Convert', () => {
 
   test('ui-col', async () => {
     const packageName = _package.name;
-    const seqCol = DG.Column.fromStrings('seq', tests['cyclized'].src);
+    const seqList = Object.values(tests).map((td) => td.src.seq);
+    const helmList = Object.values(tests).map((td) => td.tgt.helm);
+    const seqCol = DG.Column.fromStrings('seq', seqList);
     const df = DG.DataFrame.fromColumns([seqCol]);
     const tv = grok.shell.addTableView(df);
 
@@ -86,6 +162,7 @@ category('PolyTool: Convert', () => {
       chiralityEngine: true,
       rules: ['rules_example.json']
     });
+    expectArray(helmCol.toList(), helmList);
     expect(helmCol.semType, DG.SEMTYPE.MACROMOLECULE);
     expect(helmCol.meta.units, NOTATION.HELM);
     expect(helmCol.dataFrame.id, df.id);

package/src/tests/polytool-detectors-custom-notation-test.ts

@@ -0,0 +1,43 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper, getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {ALIGNMENT, ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {_testNeg, _testPos, DetectorTestData, DfReaderFunc, PosCol} from './utils/detect-macromolecule-utils';
+
+category('PolyTool: detectors', () => {
+  let seqHelper: ISeqHelper;
+
+  before(async () => {
+    seqHelper = await getSeqHelper();
+  });
+
+  const tests: DetectorTestData = {
+    'cyclized1': {
+      csv: `n,seq
+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(4)-T-G-H-F-Y-P-azG(4)-meI`,
+      pos: {'seq': new PosCol(NOTATION.CUSTOM, ALIGNMENT.SEQ, ALPHABET.UN, 13, true, '-')}
+    },
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const reader: DfReaderFunc = async (): Promise<DG.DataFrame> => {
+        return DG.DataFrame.fromCsv(testData.csv);
+      };
+      for (const negColName of testData.neg ?? [])
+        await _testNeg(reader, negColName);
+      for (const [posColName, posCol] of Object.entries(testData.pos ?? {})) {
+        await _testPos(reader, posColName, seqHelper, posCol.units, posCol.aligned,
+          posCol.alphabet, posCol.alphabetSize, posCol.alphabetIsMultichar, posCol.separator);
+      }
+    });
+  }
+});

package/src/tests/polytool-enumerate-breadth-tests.ts

@@ -41,7 +41,7 @@ category('PolyTool: Enumerate', () => {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholdersBreadth: [
+        breadthPlaceholders: [
           {start: 2, end: 4, monomers: ['K']},
         ],
       },
@@ -55,7 +55,7 @@ category('PolyTool: Enumerate', () => {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholdersBreadth: [
+        breadthPlaceholders: [
           {start: 2, end: 4, monomers: ['K']},
         ],
         keepOriginal: true,
@@ -71,7 +71,7 @@ category('PolyTool: Enumerate', () => {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholdersBreadth: [
+        breadthPlaceholders: [
           {start: 2, end: 4, monomers: ['K', 'Y']},
         ],
       },
@@ -88,7 +88,7 @@ category('PolyTool: Enumerate', () => {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholdersBreadth: [
+        breadthPlaceholders: [
           {start: 2, end: 4, monomers: ['K']},
           {start: 2, end: 4, monomers: ['Y']},
         ],

package/src/tests/toAtomicLevel-tests.ts

@@ -45,7 +45,7 @@ category('toAtomicLevel', () => {
     expect(ggazM != null, true, `Monomer 'GGaz' not found.`);
 
     const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: {'GGaz': ggazM}};
-    const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+    const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData, 'test');
 
     const seqHelper = await getSeqHelper();
 

package/src/tests/utils/detect-macromolecule-utils.ts

@@ -0,0 +1,64 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {delay, expect} from '@datagrok-libraries/utils/src/test';
+import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+
+export type DetectorTestData = { [testName: string]: { csv: string, neg?: string[], pos?: { [colName: string]: PosCol } } };
+
+export type DfReaderFunc = () => Promise<DG.DataFrame>;
+
+export class PosCol {
+  constructor(
+    public readonly units: NOTATION,
+    public readonly aligned: ALIGNMENT | null,
+    public readonly alphabet: string | null,
+    public readonly alphabetSize: number,
+    public readonly alphabetIsMultichar?: boolean,
+    public readonly separator?: string,
+  ) { };
+}
+
+export async function _testNeg(readDf: DfReaderFunc, colName: string) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.getCol(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
+    const msg = `Negative test detected semType='${col.semType}', units='${col.meta.units}'.`;
+    throw new Error(msg);
+  }
+}
+
+export async function _testPos(
+  readDf: DfReaderFunc, colName: string, seqHelper: ISeqHelper,
+  units: string, aligned: string | null, alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
+  separator: string | null = null,
+) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.col(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
+  expect(col.meta.units, units);
+  expect(col.getTag(bioTAGS.aligned), aligned);
+  expect(col.getTag(bioTAGS.alphabet), alphabet);
+  if (separator)
+    expect(col.getTag(bioTAGS.separator), separator);
+
+  const sh = seqHelper.getSeqHandler(col);
+  expect(sh.getAlphabetSize(), alphabetSize);
+  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!sh.isHelm()) {
+    expect(sh.aligned, aligned);
+    expect(sh.alphabet, alphabet);
+  }
+}
+

package/src/tests/{utils.ts → utils/index.ts}

@@ -2,8 +2,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {DEFAULT_FORMATS} from '../apps/common/model/const';
-import {ITranslationHelper} from '../types';
+import {DEFAULT_FORMATS} from '../../apps/common/model/const';
+import {ITranslationHelper} from '../../types';
 
 export class OligoToolkitTestPackage extends DG.Package {
   async getTranslationHelper(): Promise<ITranslationHelper> {

package/src/utils/context-menu.ts

@@ -2,9 +2,6 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
-import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-
 import {defaultErrorHandler} from './err-info';
 import {polyToolEnumerateHelmUI} from '../polytool/pt-enumeration-helm-dialog';
 import {polyToolEnumerateChemUI} from '../polytool/pt-dialog';
@@ -43,11 +40,11 @@ function addContextMenuForCell(gridCell: DG.GridCell, menu: DG.Menu): boolean {
   if (gridCell && gridCell.tableColumn) {
     switch (gridCell.tableColumn.semType) {
     case DG.SEMTYPE.MACROMOLECULE: {
-      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateHelmUI(gridCell.cell); });
+      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateHelmUI(gridCell.cell).then(() => {}); });
       return true;
     }
     case DG.SEMTYPE.MOLECULE: {
-      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateChemUI(gridCell.cell); });
+      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateChemUI(gridCell.cell).then(() => {}); });
       return true;
     }
     }