@datagrok/sequence-translator 1.3.14 → 1.4.0

package/src/polytool/pt-enumeration-helm.ts

@@ -12,7 +12,8 @@ import {Chain} from './pt-conversion';
 import {getAvailableMonomers} from './utils';
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders} from './types';
 
-export const PT_HELM_EXAMPLE = 'PEPTIDE1{[R].[F].[T].[G].[H].[F].[G].[A].[A].[Y].[P].[E].[NH2]}$$$$';
+// For example keep monomers presented in HELMCoreLibrary.json only (not [NH2])
+export const PT_HELM_EXAMPLE = 'PEPTIDE1{R.[Aca].T.G.H.F.G.A.A.Y.P.E.[meI]}$$$$';
 
 /** Initialized by getHelmHelper via init Helm package */
 declare const JSDraw2: JSDraw2ModuleType;
@@ -55,7 +56,10 @@ function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders):
   return resMolList;
 }
 
-export function getPtEnumeratorHelm(helm: string, id: string, params: PolyToolEnumeratorParams): [string, string][] {
+/** Returns list of Helm with id. Covered with tests. */
+export function doPolyToolEnumerateHelm(
+  helm: string, id: string, params: PolyToolEnumeratorParams
+): [ /* helm */ string, /* id */ string][] {
   const molHandler = new JSDraw2.MolHandler<HelmType>();
   const plugin = new org.helm.webeditor.Plugin(molHandler);
   org.helm.webeditor.IO.parseHelm(plugin, helm, new JSDraw2.Point(0, 0), undefined);

package/src/polytool/pt-placeholders-input.ts

@@ -121,8 +121,7 @@ export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
     const pos = parseInt(df.get('Position', rowI));
     if (!isNaN(pos)) {
       const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
-      if (monomerSymbolList.length > 0)
-        res[pos - 1] = monomerSymbolList;
+      res[pos - 1] = monomerSymbolList;
     }
   }
   return res;

package/src/polytool/utils.ts

@@ -27,13 +27,6 @@ function addCommonTags(col: DG.Column<any>) {
   col.setTag('alphabet', ALPHABET.PT);
 }
 
-export function handleError(err: any): void {
-  const errMsg: string = err instanceof Error ? err.message : err.toString();
-  const stack: string | undefined = err instanceof Error ? err.stack : undefined;
-  grok.shell.error(errMsg);
-  _package.logger.error(err.message, undefined, stack);
-}
-
 export async function getAvailableMonomers(screenLibrary: string): Promise<string[]> {
   const monomerLibHelper: IMonomerLibHelper = await grok.functions.call('Bio:getMonomerLibHelper', {});
   const monomerLib = await monomerLibHelper.readLibrary(LIB_PATH, screenLibrary);

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

@@ -0,0 +1,99 @@
+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 {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+import {doPolyToolConvert} from '../polytool/pt-conversion';
+import {getRules} from '../polytool/pt-rules';
+
+import {_package} from '../package-test';
+
+
+category('PolyTool: Convert', () => {
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings; //backup
+
+  before(async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    // Clear settings to test default
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.loadMonomerLib(true);
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    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$$$',
+      ]
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const res = doPolyToolConvert(testData.src, rules);
+      expectArray(res, testData.tgt);
+    });
+  }
+
+
+  test('ui-col-wo-table', async () => {
+    const packageName = _package.name;
+    const seqCol = DG.Column.fromStrings('seq', tests['cyclized'].src);
+    const helmCol: DG.Column = await grok.functions.call(`${packageName}:polyToolConvert2`, {
+      seqCol: seqCol,
+      generateHelm: true,
+      chiralityEngine: true,
+      rules: ['rules_example.json']
+    });
+    expect(helmCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(helmCol.meta.units, NOTATION.HELM);
+    expect(helmCol.dataFrame, null);
+  });
+
+  test('ui-col', async () => {
+    const packageName = _package.name;
+    const seqCol = DG.Column.fromStrings('seq', tests['cyclized'].src);
+    const df = DG.DataFrame.fromColumns([seqCol]);
+    const tv = grok.shell.addTableView(df);
+
+    const helmCol: DG.Column = await grok.functions.call(`${packageName}:polyToolConvert2`, {
+      seqCol: seqCol,
+      generateHelm: true,
+      chiralityEngine: true,
+      rules: ['rules_example.json']
+    });
+    expect(helmCol.semType, DG.SEMTYPE.MACROMOLECULE);
+    expect(helmCol.meta.units, NOTATION.HELM);
+    expect(helmCol.dataFrame.id, df.id);
+
+    await testEvent(tv.grid.onAfterDrawContent, () => {}, async () => {
+      tv.grid.invalidate();
+    }, 15000);
+    expect(helmCol.getTag(DG.TAGS.CELL_RENDERER), 'helm');
+  });
+});

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

@@ -4,19 +4,35 @@ import * as DG from 'datagrok-api/dg';
 
 import {before, after, category, expect, test, expectArray} from '@datagrok-libraries/utils/src/test';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+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, setUserLibSettingsForTests
+} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
-import {getPtEnumeratorHelm} from '../polytool/pt-enumeration-helm';
+import {doPolyToolEnumerateHelm} from '../polytool/pt-enumeration-helm';
 
-category('PolyTool', () => {
+import {_package} from '../package-test';
+
+category('PolyTool: Enumerate', () => {
   let helmHelper: IHelmHelper;
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings; //backup
 
   before(async () => {
     helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    // Clear settings to test default
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.loadMonomerLib(true);
   });
 
   after(async () => {
-
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
   });
 
   const tests: {
@@ -87,8 +103,8 @@ category('PolyTool', () => {
   };
 
   for (const [testName, testData] of Object.entries(tests)) {
-    test(`enumerator-${testName}`, async () => {
-      const res = getPtEnumeratorHelm(testData.src, '', testData.params);
+    test(`${testName}`, async () => {
+      const res = doPolyToolEnumerateHelm(testData.src, '', testData.params);
       expectArray(res, testData.tgt);
     });
   }

package/src/utils/context-menu.ts

@@ -7,6 +7,7 @@ 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';
 
 import {_package} from '../package';
 
@@ -39,19 +40,15 @@ function addContextMenuForCell(gridCell: DG.GridCell, menu: DG.Menu): boolean {
   const logPrefix: string = `ST: addContextMenuForCell()`;
   _package.logger.debug(`${logPrefix}, start`);
 
-  const polyToolEnumerate = () => {
-    polyToolEnumerateHelmUI(gridCell.cell);
-  };
-
   if (gridCell && gridCell.tableColumn) {
     switch (gridCell.tableColumn.semType) {
     case DG.SEMTYPE.MACROMOLECULE: {
-      const sh = SeqHandler.forColumn(gridCell.tableColumn);
-      if (sh.notation === NOTATION.HELM) {
-        menu
-          .item('PolyTool-Enumerate', polyToolEnumerate);
-        true;
-      }
+      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateHelmUI(gridCell.cell); });
+      return true;
+    }
+    case DG.SEMTYPE.MOLECULE: {
+      menu.item('PolyTool-Enumerate', () => { polyToolEnumerateChemUI(gridCell.cell); });
+      return true;
     }
     }
   }