@datagrok/sequence-translator 1.4.5 → 1.4.6

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

@@ -3,7 +3,7 @@ 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} from '../polytool/pt-conversion';
+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';
 
@@ -20,30 +20,35 @@ category('PolyTool: Chain: parseNotation', () => {
       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: '(#2)Succ-{A(CHOL)-F-C(2)-T-G-H-Y-P-C(2)-NH2}'},
+      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{[(#2)Succ]}|PEPTIDE2{[A(CHOL)].F.[C(2)].T.G.H.Y.P.[C(2)].[NH2]}$PEPTIDE1,PEPTIDE2,1:R1-1:R1$$$V2.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: '($2)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}'},
+      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{[($2)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',
-      },
-    },
+        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);
+      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);
@@ -52,8 +57,44 @@ category('PolyTool: Chain: parseNotation', () => {
       const resMol = resChain.mol!;
       const hwe = helmHelper.createHelmWebEditor();
       hwe.editor.setMol(resMol!);
-      const resHelm = hwe.editor.getHelm();
+      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

@@ -22,7 +22,7 @@ category('PolyTool: detectors', () => {
 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`,
+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, '-')}
     },
   };

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/utils/context-menu.ts

@@ -40,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;
     }
     }

package/src/utils/cyclized.ts

@@ -13,6 +13,7 @@ import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-rende
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {Chain} from '../polytool/pt-conversion';
 
@@ -39,14 +40,11 @@ export class CyclizedNotationProvider implements INotationProvider {
       GapOriginals[NOTATION.SEPARATOR]);
   }
 
-  public async getHelm(seq: string, options?: any): Promise<DG.SemanticValue<string>> {
-    const seqChain = await Chain.parseNotation(seq);
-    const seqPseudoHelm = seqChain.getNotationHelm();
-
-    const resPseudoHelmSV = DG.SemanticValue.fromValueType(seqPseudoHelm,
-      DG.SEMTYPE.MACROMOLECULE, NOTATION.HELM);
-    resPseudoHelmSV.tags['pt-role'] = 'template';
-    return resPseudoHelmSV;
+  public async getHelm(seq: string, options?: any): Promise<string> {
+    const helmHelper = await getHelmHelper();
+    const seqChain = await Chain.parseNotation(seq, helmHelper);
+    const resPseudoHelm = seqChain.getNotationHelm();
+    return resPseudoHelm;
   }
 
   public createCellRendererBack(gridCol: DG.GridColumn | null, tableCol: DG.Column<string>): CellRendererBackBase<string> {