@datagrok/bio 2.0.30 → 2.0.32

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.30",
+  "version": "2.0.32",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.7.0",
+    "@datagrok-libraries/bio": "^5.8.0",
     "@datagrok-libraries/chem-meta": "1.0.1",
-    "@datagrok-libraries/ml": "^6.2.1",
-    "@datagrok-libraries/utils": "^1.11.1",
+    "@datagrok-libraries/ml": "^6.2.2",
+    "@datagrok-libraries/utils": "^1.14.1",
     "cash-dom": "^8.0.0",
-    "datagrok-api": "^1.7.0",
+    "datagrok-api": "^1.8.1",
     "dayjs": "^1.11.4",
     "openchemlib": "6.0.1",
     "rxjs": "^6.5.5",

package/src/analysis/sequence-activity-cliffs.ts

@@ -10,6 +10,7 @@ import {TAGS} from '../utils/constants';
 import {drawMoleculeDifferenceOnCanvas} from '../utils/cell-renderer';
 import * as C from '../utils/constants';
 import { GridColumn } from 'datagrok-api/dg';
+import { invalidateMols, MONOMERIC_COL_TAGS } from '../substructure-search/substructure-search';
 
 export async function getDistances(col: DG.Column, seq: string): Promise<Array<number>> {
   const stringArray = col.toList();
@@ -39,6 +40,23 @@ export async function getSimilaritiesMarix(dim: number, seqCol: DG.Column, df: D
   return simArr;
 }
 
+export async function getChemSimilaritiesMarix(dim: number, seqCol: DG.Column,
+  df: DG.DataFrame, colName: string, simArr: DG.Column[])
+  : Promise<DG.Column[]> {
+  if (seqCol.version !== seqCol.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
+    await invalidateMols(seqCol, false);
+  const fpDf = DG.DataFrame.create(seqCol.length);
+  fpDf.columns.addNewString(colName).init((i) => seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS].get(i));
+  const res = await grok.functions.call('Chem:getChemSimilaritiesMatrix', {
+    dim: dim,
+    col: seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
+    df: fpDf,
+    colName: colName,
+    simArr: simArr
+  });
+  return res;
+}
+
 export function createTooltipElement(params: ITooltipAndPanelParams): HTMLDivElement {
   const tooltipElement = ui.divH([]);
   const columnNames = ui.divV([

package/src/analysis/sequence-space.ts

@@ -5,6 +5,8 @@ import {BitArrayMetrics, StringMetrics} from '@datagrok-libraries/ml/src/typed-m
 import {Matrix} from '@datagrok-libraries/utils/src/type-declarations';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {ISequenceSpaceParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
+import * as grok from 'datagrok-api/grok';
 
 export interface ISequenceSpaceResult {
   distance: Matrix;
@@ -12,9 +14,8 @@ export interface ISequenceSpaceResult {
 }
 
 export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
-
-// code deprecated since seqCol is encoded
-/*    let preparedData: any;
+  // code deprecated since seqCol is encoded
+  /*    let preparedData: any;
   if (!(spaceParams.seqCol!.tags[DG.TAGS.UNITS] === 'HELM')) {
     const sep = spaceParams.seqCol.getTag(UnitsHandler.TAGS.separator);
     const sepFinal = sep ? sep === '.' ? '\\\.' : sep : '-';
@@ -37,6 +38,20 @@ export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<
   return {distance: sequenceSpaceResult.distance, coordinates: new DG.ColumnList(cols)};
 }
 
+export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
+  if (spaceParams.seqCol.version !== spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
+    await invalidateMols(spaceParams.seqCol, false);
+
+  const result = await grok.functions.call('Chem:getChemSpaceEmbeddings', {
+    col: spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
+    methodName: spaceParams.methodName,
+    similarityMetric: spaceParams.similarityMetric,
+    xAxis: spaceParams.embedAxesNames[0],
+    yAxis: spaceParams.embedAxesNames[1]
+  });
+  return result;
+}
+
 
 export function getEmbeddingColsNames(df: DG.DataFrame) {
   const axes = ['Embed_X', 'Embed_Y'];

package/src/calculations/monomerLevelMols.ts

@@ -46,7 +46,7 @@ function molV3000FromNonHelmSequence(
 M  V30 BEGIN CTAB
 `;
 
-  molV3000 += `M  V30 COUNTS ${monomers.length} ${monomers.length - 1} 0 0 0\n`;
+  molV3000 += `M  V30 COUNTS ${monomers.length} ${monomers.length ? monomers.length - 1 : 0} 0 0 0\n`;
   molV3000 += 'M  V30 BEGIN ATOM\n';
 
   for (let atomRowI = 0; atomRowI < monomers.length; atomRowI++) {

package/src/package.ts

@@ -10,9 +10,9 @@ import {MacromoleculeDifferenceCellRenderer, MonomerCellRenderer} from './utils/
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
 import {SequenceAlignment, Aligned} from './seq_align';
-import {getEmbeddingColsNames, sequenceSpace} from './analysis/sequence-space';
+import {getEmbeddingColsNames, sequenceSpace, sequenceSpaceByFingerprints} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {createLinesGrid, createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
+import {createLinesGrid, createPropPanelElement, createTooltipElement, getChemSimilaritiesMarix, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
 import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq} from '@datagrok-libraries/bio/src/utils/monomer-utils';
 import {HELM_CORE_LIB_FILENAME} from '@datagrok-libraries/bio/src/utils/const';
 import {getMacroMol} from './utils/atomic-works';
@@ -168,9 +168,6 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
   similarity: number, methodName: string): Promise<DG.Viewer | undefined> {
   if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
-  const encodedCol = encodeMonomers(macroMolecule);
-  if (!encodedCol)
-    return;
   const axesNames = getEmbeddingColsNames(df);
   const options = {
     'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
@@ -184,17 +181,17 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
   const sp = await getActivityCliffs(
     df,
     macroMolecule,
-    encodedCol,
+    null,
     axesNames,
     'Activity cliffs',
     activities,
     similarity,
-    'Levenshtein',
+    'Tanimoto',
     methodName,
     DG.SEMTYPE.MACROMOLECULE,
     tags,
-    sequenceSpace,
-    getSimilaritiesMarix,
+    sequenceSpaceByFingerprints,
+    getChemSimilaritiesMarix,
     createTooltipElement,
     createPropPanelElement,
     createLinesGrid,
@@ -216,26 +213,30 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   if (!checkInputColumnUi(macroMolecule, 'Sequence space'))
     return;
 
-  if (macroMolecule.version !== macroMolecule.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
-    await invalidateMols(macroMolecule, false);
   const embedColsNames = getEmbeddingColsNames(table);
+  const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
+  const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, macroMolecule);
 
-  await grok.functions.call('Chem:getChemSpaceEmbeddings', {
-    table: table,
-    col: macroMolecule.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
+  const chemSpaceParams = {
+    seqCol: withoutEmptyValues.col(macroMolecule.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,
-    xAxis: embedColsNames[0],
-    yAxis: embedColsNames[1]
-  });
-
+    embedAxesNames: embedColsNames
+  };
+  const sequenceSpaceRes = await sequenceSpaceByFingerprints(chemSpaceParams);
+  const embeddings = sequenceSpaceRes.coordinates;
+  for (const col of embeddings) {
+    const listValues = col.toList();
+    emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
+    table.columns.add(DG.Column.fromList('double', col.name, listValues));
+  }
   if (plotEmbeddings) {
     return grok.shell
       .tableView(table.name)
       .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
   };
 
-/*   const encodedCol = encodeMonomers(macroMolecule);
+  /*   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
     return;
   const embedColsNames = getEmbeddingColsNames(table);

package/src/tests/activity-cliffs-tests.ts

@@ -16,7 +16,7 @@ category('activityCliffs', async () => {
   test('activityCliffsOpens', async () => {
     actCliffsDf = await readDataframe('tests/sample_MSA_data.csv');
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
-    await _testActivityCliffsOpen(actCliffsDf, 36, 'UMAP', 'MSA');
+    await _testActivityCliffsOpen(actCliffsDf, 57, 'UMAP', 'MSA');
     grok.shell.closeTable(actCliffsDf);
     actCliffsTableView.close();
   });
@@ -24,7 +24,7 @@ category('activityCliffs', async () => {
   test('activityCliffsWithEmptyRows', async () => {
     actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
     actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
-    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 37, 'UMAP', 'MSA');
+    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, 'UMAP', 'MSA');
     grok.shell.closeTable(actCliffsDfWithEmptyRows);
     actCliffsTableViewWithEmptyRows.close();
   });

package/src/tests/activity-cliffs-utils.ts

@@ -1,20 +1,21 @@
 import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
 import {delay, expect} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
-import { activityCliffs } from '../package';
-import * as grok from 'datagrok-api/grok';
+import {activityCliffs} from '../package';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
   await grok.data.detectSemanticTypes(df);
   const scatterPlot = await activityCliffs(
-     df, 
-     df.col(colName)!, 
-     df.col('Activity')!, 
-     90, 
-     method);
+    df,
+    df.col(colName)!,
+    df.col('Activity')!,
+    50,
+    method);
 
-    expect(scatterPlot != null, true);
+  expect(scatterPlot != null, true);
 
-    const cliffsLink = Array.from(scatterPlot!.root.children).filter(it => it.className === 'ui-btn ui-btn-ok');
-    expect((cliffsLink[0] as HTMLElement).innerText, `${numberCliffs} cliffs`);
+  const cliffsLink = Array.from(scatterPlot!.root.children).filter(it => it.className === 'ui-btn ui-btn-ok');
+  expect((cliffsLink[0] as HTMLElement).innerText.toLowerCase(), `${numberCliffs} cliffs`);
 }

package/src/tests/renderers-test.ts

@@ -58,7 +58,7 @@ category('renderers', () => {
 
   test('setRendererManually', async () => {
     await _setRendererManually();
-  });
+  }, {skipReason: 'GROK-11212'});
 
   async function _rendererMacromoleculeFasta() {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.csv');

package/src/tests/substructure-filter-tests.ts

@@ -45,9 +45,21 @@ category('substructureFilters', async () => {
     const filter = new BioSubstructureFilter();
     await grok.data.detectSemanticTypes(helm);
     filter.attach(helm);
+
+    const helmFilterChanged = new Promise((resolve, reject) => {
+      helm.onFilterChanged.subscribe(async (_: any) => {
+        try {
+          resolve(true);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
     (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{C}$$$$V2.0';
     filter.bioFilter!.onChanged.next();
-    await delay(2000);
+    await helmFilterChanged;
+
+    //await delay(3000);
     expect(filter.dataFrame!.filter.trueCount, 2);
     expect(filter.dataFrame!.filter.get(0), true);
     expect(filter.dataFrame!.filter.get(3), true);