@datagrok/bio 2.0.5 → 2.0.7

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",

package/src/calculations/{fingerprints.ts → monomerLevelMols.ts}

@@ -2,29 +2,24 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import { getHelmMonomers } from '../package'
+
 const V2000_ATOM_NAME_POS = 31;
 
-export async function getFingerprints(mols: Array<string>, monomers: Array<string>): Promise<Uint8Array[]> {
-  const mod = await grok.functions.call('Chem:getRdKitModule');
-  const fps: Uint8Array[] = [];
+export async function getMonomericMols(mcol: DG.Column, pattern: boolean = false): Promise<DG.Column> {
+  const monomers = getHelmMonomers(mcol);
+  let mols = await grok.functions.call('HELM:getMolFiles', {mcol: mcol});
 
   let dict = new Map(); 
   for(let i = 0; i < monomers.length; i++)
-    dict.set(monomers[i], `R${Math.pow(10,(i + 1))}`);
-
-  mols = changeToV3000(mols, dict);
+    dict.set(monomers[i], `${i + 1}`);
 
-  for(let i = 0; i< mols.length; i++) {
-    const mol = mod.get_mol(mols[i]);
-    const fp = mol.get_pattern_fp_as_uint8array();
-    fps.push(fp);
-    mol?.delete();
-  }
+  mols = changeToV3000(mols, dict, pattern);
 
-  return fps;
+  return DG.Column.fromStrings('monomericMols', mols);
 }
 
-function changeToV3000(mols: Array<string>, dict: Map<string, string>): Array<string> {
+function changeToV3000(mols: Array<string>, dict: Map<string, string>, pattern: boolean = false): Array<string> {
   for (let i = 0; i < mols.length; i++) {
     let curPos = 0;
     let endPos = 0;
@@ -50,7 +45,9 @@ M  V30 BEGIN CTAB
       curPos = mol.indexOf('\n', curPos) + 1 + V2000_ATOM_NAME_POS;
       endPos = mol.indexOf(' ', curPos);
       const monomerName: string = mol.substring(curPos, endPos);
-      molV3000 += `M  V30 ${atomRowI + 1} ${dict.get(monomerName)} 0.000 0.000 0 0\n`;
+      molV3000 += pattern ? 
+                  `M  V30 ${atomRowI + 1} R${dict.get(monomerName)} 0.000 0.000 0 0\n` :
+                  `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${dict.get(monomerName)}\n`;
     } 
 
     molV3000 += 'M  V30 END ATOM\n';

package/src/package.ts

@@ -32,7 +32,6 @@ import {
 
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 import * as C from './utils/constants';
-import {getFingerprints} from './calculations/fingerprints';
 
 //tags: init
 export async function initBio() {
@@ -56,6 +55,16 @@ export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRender
   return new MacromoleculeSequenceCellRenderer();
 }
 
+//name: MacromoleculeDifferenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: MacromoleculeDifference
+//meta.columnTags: quality=MacromoleculeDifference
+//output: grid_cell_renderer result
+export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCellRenderer {
+  return new MacromoleculeDifferenceCellRenderer();
+}
+
+
 function checkInputColumnUi(
   col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
 ): boolean {
@@ -376,15 +385,6 @@ export function monomerCellRenderer(): MonomerCellRenderer {
   return new MonomerCellRenderer();
 }
 
-//name: MacromoleculeDifferenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: MacromoleculeDifference
-//meta.columnTags: quality=MacromoleculeDifference
-//output: grid_cell_renderer result
-export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCellRenderer {
-  return new MacromoleculeDifferenceCellRenderer();
-}
-
 //name: testDetectMacromolecule
 //input: string path {choices: ['Demo:Files/', 'System:AppData/']}
 //output: dataframe result
@@ -460,11 +460,3 @@ export function getHelmMonomers(seqCol: DG.Column<string>): string[] {
   const stats = WebLogo.getStats(seqCol, 1, WebLogo.splitterAsHelm);
   return Object.keys(stats.freq);
 }
-
-export async function macromoleculesFingerprints(mcol: DG.Column): Promise<Uint8Array[]> {
-  grok.functions.call('Chem:getRdKitModule');
-  const monomers = getHelmMonomers(mcol);
-  const mols = await grok.functions.call('HELM:getMolFiles', {mcol: mcol});
-
-  return getFingerprints(mols.toList(), monomers);
-}

package/src/tests/renderers-test.ts

@@ -31,6 +31,18 @@ category('renderers', () => {
     performanceTest(generateManySequences, 'Many sequences');
   });
 
+  test('rendererMacromoleculeFasta', async () => {
+    await _rendererMacromoleculeFasta();
+  });
+
+  test('rendererMacromoleculeSeparator', async () => {
+    await _rendererMacromoleculeSeparator();
+  });
+
+  test('rendererMacromoleculeDifference', async () => {
+    await _rendererMacromoleculeDifference();
+  });
+
   test('afterMsa', async () => {
     await _testAfterMsa();
   });
@@ -39,10 +51,73 @@ category('renderers', () => {
     await _testAfterConvert();
   });
 
-  test('setRenderer', async () => {
+  test('selectRendererBySemType', async () => {
+    await _selectRendererBySemType();
+  });
+
+  test('setRendererManually', async () => {
     await _setRendererManually();
   });
 
+  async function _rendererMacromoleculeFasta() {
+    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.csv');
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+
+    const seqCol = df.getCol('Sequence');
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    // call to calculate 'cell.renderer' tag
+    await grok.data.detectSemanticTypes(df);
+
+    dfList.push(df);
+    tvList.push(tv);
+
+    const resCellRenderer = seqCol.getTag(DG.TAGS.CELL_RENDERER);
+    expect(resCellRenderer, 'sequence');
+  }
+
+  async function _rendererMacromoleculeSeparator() {
+    const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_SEPARATOR_PT.csv');
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+
+    const seqCol = df.getCol('sequence');
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    // call to calculate 'cell.renderer' tag
+    await grok.data.detectSemanticTypes(df);
+
+    dfList.push(df);
+    tvList.push(tv);
+
+    const resCellRenderer = seqCol.getTag(DG.TAGS.CELL_RENDERER);
+    expect(resCellRenderer, 'sequence');
+  }
+
+  async function _rendererMacromoleculeDifference() {
+    const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
+      ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
+    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
+    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+    const df = DG.DataFrame.fromColumns([seqDiffCol]);
+
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    // call to calculate 'cell.renderer' tag
+    await grok.data.detectSemanticTypes(df);
+
+    dfList.push(df);
+    tvList.push(tv);
+
+    const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
+    expect(resCellRenderer, 'MacromoleculeDifference');
+  }
+
   async function _testAfterMsa() {
     const fastaTxt: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
     const df: DG.DataFrame = importFasta(fastaTxt)[0];
@@ -86,36 +161,69 @@ category('renderers', () => {
   async function _testAfterConvert() {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA_PT.csv');
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
-    const tv: DG.TableView = grok.shell.addTableView(df);
 
     const srcCol: DG.Column = df.col('sequence')!;
-    // await grok.data.detectSemanticTypes(df);
     const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcCol});
     if (semType)
       srcCol.semType = semType;
+
+    const tv: DG.TableView = grok.shell.addTableView(df);
+    // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
+    tvList.push(tv);
+    dfList.push(df);
+
     const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
-    expect(tgtCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
+
+    const resCellRenderer = tgtCol.getTag(DG.TAGS.CELL_RENDERER);
+    expect(resCellRenderer, 'sequence');
 
     // check tgtCol with UnitsHandler constructor
     const uh: UnitsHandler = new UnitsHandler(tgtCol);
+  }
 
-    tvList.push(tv);
+  async function _selectRendererBySemType() {
+    /* There are renderers for semType Macromolecule and MacromoleculeDifference.
+       Misbehavior was by selecting Macromolecule renderers for MacromoleculeDifference semType column
+    /**/
+    const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
+      ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
+    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
+    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+    const df = DG.DataFrame.fromColumns([seqDiffCol]);
+    const tv = grok.shell.addTableView(df);
     dfList.push(df);
+    tvList.push(tv);
+
+    await delay(100);
+    const renderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
+    if (renderer !== 'MacromoleculeDifference') // this is value of MacromoleculeDifferenceCR.cellType
+      throw new Error(`Units 'separator', separator '/' and semType 'MacromoleculeDifference' ` +
+        `have been manually set on column but after df was added as table, ` +
+        `view renderer has set to '${renderer}' instead of correct 'MacromoleculeDifference'.`);
   }
 
   async function _setRendererManually() {
-    const df = DG.DataFrame.fromColumns([DG.Column.fromStrings(
-      'SequencesDiff', ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV'])]);
-    df.col('SequencesDiff')!.tags[DG.TAGS.UNITS] = 'separator';
-    df.col('SequencesDiff')!.tags[TAGS.SEPARATOR] = '/';
-    df.col('SequencesDiff')!.semType = SEM_TYPES.MACROMOLECULE_DIFFERENCE;
-    const tw = grok.shell.addTableView(df);
+    const seqDiffCol: DG.Column = DG.Column.fromStrings('SequencesDiff',
+      ['meI/hHis/Aca/N/T/dK/Thr_PO3H2/Aca#D-Tyr_Et/Tyr_ab-dehydroMe/meN/E/N/dV']);
+    seqDiffCol.tags[DG.TAGS.UNITS] = 'separator';
+    seqDiffCol.tags[TAGS.SEPARATOR] = '/';
+    seqDiffCol.semType = SEM_TYPES.MACROMOLECULE;
+    const tgtCellRenderer = 'MacromoleculeDifference';
+    seqDiffCol.setTag(DG.TAGS.CELL_RENDERER, tgtCellRenderer);
+    const df = DG.DataFrame.fromColumns([seqDiffCol]);
+    await grok.data.detectSemanticTypes(df);
+    const tv = grok.shell.addTableView(df);
+    dfList.push(df);
+    tvList.push(tv);
+
     await delay(100);
-    const renderer = tw.dataFrame.col('SequencesDiff')?.getTag(DG.TAGS.CELL_RENDERER);
-    if (renderer !== 'MacromoleculeDifference') // this is value of MacromoleculeDifferenceCR.cellType
-      throw new Error(`Units 'separator', separator '/' and semType 'MacromoleculeDifference' have been ` +
-        `manually set on column but after df aws added as table view renderer has been reset to '${renderer}'`);
+    const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
+    if (resCellRenderer !== tgtCellRenderer) // this is value of MacromoleculeDifferenceCR.cellType
+      throw new Error(`Tag 'cell.renderer' has been manually set to '${tgtCellRenderer}' for column ` +
+        `but after df was added as table, tag 'cell.renderer' has reset to '${resCellRenderer}' ` +
+        `instead of manual '${tgtCellRenderer}'.`);
   }
 });

package/src/tests/splitters-test.ts

@@ -1,10 +1,10 @@
-import {after, before, category, test, expect, expectArray} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, expectArray, expectObject} from '@datagrok-libraries/utils/src/test';
 
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {WebLogo, SplitterFunc} from '@datagrok-libraries/bio/src/viewers/web-logo';
-import {splitToMonomers, _package} from '../package';
+import {splitToMonomers, _package, getHelmMonomers} from '../package';
 import * as C from '../utils/constants';
 
 category('splitters', () => {
@@ -87,6 +87,30 @@ category('splitters', () => {
     splitToMonomers(seqCol);
     expect(df.columns.names().includes('17'), true);
   });
+
+  test('getHelmMonomers', async () => {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(
+      `HELM,Activity
+PEPTIDE1{hHis.N.T}$$$,5.30751
+PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
+`);
+    const expectedMonomerList = ['hHis', 'Aca', 'Cys_SEt', 'N', 'T'];
+
+    const helmCol: DG.Column = df.getCol('HELM');
+    const res = getHelmMonomers(helmCol);
+
+    const missed = expectedMonomerList.filter((m) => !res.includes(m));
+    const unexpected = res.filter((m) => !expectedMonomerList.includes(m));
+    if (missed.length > 0 || unexpected.length) {
+      const msgs = [];
+      if (missed.length > 0)
+        msgs.push(`Missed monomers ${JSON.stringify(missed)}.`);
+      if (unexpected.length > 0)
+        msgs.push(`Unexpected monomers ${JSON.stringify(unexpected)}.`);
+
+      throw new Error(msgs.join(' '));
+    }
+  });
 });
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {

package/src/utils/convert.ts

@@ -79,6 +79,7 @@ export function convert(col: DG.Column): void {
   }
 }
 
+/** Creates a new column with converted sequences and detects its semantic type */
 export async function convertDo(
   srcCol: DG.Column, targetNotation: NOTATION, separator: string | null
 ): Promise<DG.Column> {