@datagrok/bio 2.0.32 → 2.0.33

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.32",
+  "version": "2.0.33",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -47,7 +47,7 @@
     "webpack-cli": "^4.6.0"
   },
   "grokDependencies": {
-    "@datagrok/chem": "1.3.16",
+    "@datagrok/chem": "1.3.19",
     "@datagrok/helm": "latest"
   },
   "scripts": {

package/src/package.ts

@@ -19,7 +19,7 @@ import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
 import {getMacroMolColumnPropertyPanel, representationsWidget} from './widgets/representations';
-import {TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {MonomerFreqs, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule'
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/utils/to-atomic-level';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
@@ -39,9 +39,209 @@ import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
 import { getMonomericMols } from './calculations/monomerLevelMols';
 import { delay } from '@datagrok-libraries/utils/src/test';
+import {Observable, Subject} from 'rxjs';
+
+const STORAGE_NAME = 'Libraries';
+const LIB_PATH = 'libraries/';
+const expectedMonomerData = ['symbol', 'name', 'molfile', 'rgroups', 'polymerType', 'monomerType'];
+
+let monomerLib: IMonomerLib | null = null;
+export let hydrophobPalette: SeqPaletteCustom | null = null;
+
+class MonomerLib implements IMonomerLib {
+  private _monomers: { [type: string]: { [name: string]: Monomer } } = {};
+  private _onChanged = new Subject<any>();
+
+  getMonomer(monomerType: string, monomerName: string): Monomer | null {
+    if (monomerType in this._monomers! && monomerName in this._monomers![monomerType])
+      return this._monomers![monomerType][monomerName];
+    else
+      return null;
+  }
+
+  getTypes(): string[] {
+    return Object.keys(this._monomers);
+  }
+
+  getMonomersByType(type: string): {[symbol: string]: string} {
+    let res: {[symbol: string]: string} = {};
+
+    Object.keys(this._monomers[type]).forEach(monomerSymbol => {
+      res[monomerSymbol] = this._monomers[type][monomerSymbol].molfile;
+    });
+
+    return res;
+  }
+
+  get onChanged(): Observable<any> {
+    return this._onChanged;
+  }
+
+  public update(monomers: { [type: string]: { [name: string]: Monomer } }): void {
+    Object.keys(monomers).forEach(type => {
+      //could possibly rewrite -> TODO: check duplicated monomer symbol
+
+      if (!this.getTypes().includes(type))
+        this._monomers![type] = {};
+
+      Object.keys(monomers[type]).forEach(monomerName =>{
+        this._monomers[type][monomerName] = monomers[type][monomerName];
+      })
+    });
+
+    this._onChanged.next();
+  }
+}
+
+export type Monomer = {
+  symbol: string,
+  name: string,
+  molfile: string,
+  rgroups: {capGroupSmiles: string, alternateId: string, capGroupName: string, label: string }[],
+  polymerType: string,
+  monomerType: string,
+  data: {[property: string]: string}
+}
+
+//expected types: HELM_AA, HELM_BASE, HELM_CHEM, HELM_LINKER, HELM_SUGAR
+export interface IMonomerLib {
+  getMonomer(monomerType: string, monomerName: string): Monomer | null;
+  getMonomersByType(type: string): {[symbol: string]: string} | null;
+  getTypes(): string[];
+  update(monomers: { [type: string]: { [name: string]: Monomer } }): void;
+  get onChanged(): Observable<any>;
+}
+
+export class SeqPaletteCustom implements bio.SeqPalette {
+  private readonly _palette: { [m: string]: string };
+  constructor(palette: { [m: string]: string }) {
+    this._palette = palette;
+  }
+
+  public get(m: string): string {
+    return this._palette[m];
+  }
+}
 
 //tags: init
 export async function initBio() {
+  await loadLibraries();
+  let monomers: string[] = [];
+  let logPs: number[] = [];
+  const module = await grok.functions.call('Chem:getRdKitModule');
+
+    
+  const series = monomerLib!.getMonomersByType('PEPTIDE')!;
+  Object.keys(series).forEach(symbol => {
+    monomers.push(symbol);
+    const block = series[symbol].replaceAll('#R', 'O ');
+    const mol = module.get_mol(block);
+    const logP = JSON.parse(mol.get_descriptors()).CrippenClogP;
+    logPs.push(logP);
+    mol?.delete();
+  });
+
+  const sum = logPs.reduce((a, b) => a + b, 0);
+  const avg = (sum / logPs.length) || 0;
+
+  let palette: {[monomer: string]: string} = {};
+  for (let i = 0; i < monomers.length; i++) {
+    palette[monomers[i]] = logPs[i] < avg ? '#4682B4' : '#DC143C';
+  }
+
+  hydrophobPalette = new SeqPaletteCustom(palette);
+}
+
+async function loadLibraries() {
+  let uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
+  for (let i = 0; i < 1; ++i)
+    await monomerManager(uploadedLibraries[i]);
+}
+
+//name: monomerManager
+//input: string value
+export async function monomerManager(value: string) {
+  let data: any[] = [];
+  let file;
+  let dfSdf;
+  if (value.endsWith('.sdf')) {
+    const funcList: DG.Func[] = DG.Func.find({package: 'Chem', name: 'importSdf'});
+    console.debug(`Helm: initHelm() funcList.length = ${funcList.length}`);
+    if (funcList.length === 1) {
+      file = await _package.files.readAsBytes(`${LIB_PATH}${value}`);
+      dfSdf = await grok.functions.call('Chem:importSdf', {bytes: file});
+      data = createJsonMonomerLibFromSdf(dfSdf[0]);
+    } else {
+      grok.shell.warning('Chem package is not installed');
+    }
+  } else {
+    const file = await _package.files.readAsText(`${LIB_PATH}${value}`);
+    data = JSON.parse(file);
+  }
+
+  if (monomerLib == null)
+    monomerLib = new MonomerLib();
+
+  let monomers: { [type: string]: { [name: string]: Monomer } } = {};
+  const types: string[] = [];
+  //group monomers by their type
+  data.forEach(monomer => {
+    let monomerAdd: Monomer = {
+      'symbol': monomer['symbol'],
+      'name': monomer['name'],
+      'molfile': monomer['molfile'],
+      'rgroups': monomer['rgroups'],
+      'polymerType': monomer['polymerType'],
+      'monomerType': monomer['monomerType'],
+      'data': {}
+    };
+
+    Object.keys(monomer).forEach(prop => {
+      if (!expectedMonomerData.includes(prop))
+        monomerAdd.data[prop] = monomer[prop];
+    });
+    
+    if (!types.includes(monomer['polymerType'])) {
+      monomers[monomer['polymerType']] = {};
+      types.push(monomer['polymerType']);
+    } 
+
+    monomers[monomer['polymerType']][monomer['symbol']] = monomerAdd;
+  });
+
+  monomerLib!.update(monomers);
+}
+
+//name: Manage Libraries
+//tags: panel, widgets
+//input: column helmColumn {semType: Macromolecule}
+//output: widget result
+export async function libraryPanel(helmColumn: DG.Column): Promise<DG.Widget> {
+  //@ts-ignore
+  let filesButton: HTMLButtonElement = ui.button('Manage', manageFiles);
+  let divInputs: HTMLDivElement = ui.div();
+  let librariesList: string[] = (await _package.files.list(`${LIB_PATH}`, false, '')).map(it => it.fileName);
+  let uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
+  for (let i = 0; i < uploadedLibraries.length; ++i) {
+    let libraryName: string = uploadedLibraries[i];
+    divInputs.append(ui.boolInput(libraryName, true, async() => {
+      grok.dapi.userDataStorage.remove(STORAGE_NAME, libraryName, true);
+      await loadLibraries();
+      grok.shell.tv.grid.invalidate();
+    }).root);
+  }
+  let unusedLibraries: string[] = librariesList.filter(x => !uploadedLibraries.includes(x));
+  for (let i = 0; i < unusedLibraries.length; ++i) {
+    let libraryName: string = unusedLibraries[i];
+    divInputs.append(ui.boolInput(libraryName, false, () => {
+      monomerManager(libraryName);
+      grok.dapi.userDataStorage.postValue(STORAGE_NAME, libraryName, libraryName, true);
+    }).root);
+  }
+  return new DG.Widget(ui.splitV([
+    divInputs,
+    ui.divV([filesButton])
+  ]));
 }
 
 //name: fastaSequenceCellRenderer

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

@@ -13,19 +13,34 @@ category('activityCliffs', async () => {
   let actCliffsTableViewWithEmptyRows: DG.TableView;
   let actCliffsDfWithEmptyRows: DG.DataFrame;
 
+  let viewList: DG.ViewBase[] = [];
+  let dfList: DG.DataFrame[] = [];
+
+  before(async () => {
+    viewList = [];
+    dfList = [];
+  });
+
+  after(async () => {
+    for (const view of viewList) view.close();
+    for (const df of dfList) grok.shell.closeTable(df);
+  });
+
   test('activityCliffsOpens', async () => {
     actCliffsDf = await readDataframe('tests/sample_MSA_data.csv');
+    dfList.push(actCliffsDf);
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
+    viewList.push(actCliffsTableView);
+
     await _testActivityCliffsOpen(actCliffsDf, 57, 'UMAP', 'MSA');
-    grok.shell.closeTable(actCliffsDf);
-    actCliffsTableView.close();
   });
 
   test('activityCliffsWithEmptyRows', async () => {
     actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
+    dfList.push(actCliffsDfWithEmptyRows);
     actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
+    viewList.push(actCliffsTableViewWithEmptyRows);
+
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, 'UMAP', 'MSA');
-    grok.shell.closeTable(actCliffsDfWithEmptyRows);
-    actCliffsTableViewWithEmptyRows.close();
   });
 });

package/src/tests/similarity-diversity-tests.ts

@@ -4,7 +4,23 @@ import {createTableView, readDataframe} from './utils';
 import * as grok from 'datagrok-api/grok';
 import {SequenceSimilarityViewer} from '../analysis/sequence-similarity-viewer';
 
+let viewList: DG.ViewBase[];
+let dfList: DG.DataFrame[];
+
+
 category('similarity/diversity', async () => {
+
+  before(async () => {
+    viewList = [];
+    dfList = [];
+  });
+
+  after(async () => {
+    for (const view of viewList) view.close();
+    for (const df of dfList) grok.shell.closeTable(df);
+  });
+
+
   test('similaritySearchViewer', async () => {
     await _testSimilaritySearchViewer();
   });
@@ -17,27 +33,27 @@ async function _testSimilaritySearchViewer() {
   const molecules = await createTableView('tests/sample_MSA_data.csv');
   const viewer = molecules.addViewer('SequenceSimilaritySearchViewer');
   await delay(100);
-  const similaritySearchviewer = getSearchViewer(viewer, 'SequenceSimilaritySearchViewer');
-  if (!similaritySearchviewer.molCol)
-    await waitForCompute(similaritySearchviewer);
-  expect(similaritySearchviewer.fingerprint, 'Morgan');
-  expect(similaritySearchviewer.distanceMetric, 'Tanimoto');
-  expect(similaritySearchviewer.scores!.get(0), DG.FLOAT_NULL);
-  expect(similaritySearchviewer.idxs!.get(0), 0);
-  expect(similaritySearchviewer.molCol!.get(0),
+  const similaritySearchViewer = getSearchViewer(viewer, 'SequenceSimilaritySearchViewer');
+  viewList.push(similaritySearchViewer);
+  viewList.push(molecules);
+  if (!similaritySearchViewer.molCol)
+    await waitForCompute(similaritySearchViewer);
+  expect(similaritySearchViewer.fingerprint, 'Morgan');
+  expect(similaritySearchViewer.distanceMetric, 'Tanimoto');
+  expect(similaritySearchViewer.scores!.get(0), DG.FLOAT_NULL);
+  expect(similaritySearchViewer.idxs!.get(0), 0);
+  expect(similaritySearchViewer.molCol!.get(0),
     'D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
-  expect(similaritySearchviewer.scores!.get(1), 0.4722222089767456);
-  expect(similaritySearchviewer.idxs!.get(1), 11);
-  expect(similaritySearchviewer.molCol!.get(1),
+  expect(similaritySearchViewer.scores!.get(1), 0.4722222089767456);
+  expect(similaritySearchViewer.idxs!.get(1), 11);
+  expect(similaritySearchViewer.molCol!.get(1),
     'meI/hHis//Aca/meM/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
+  const waiter = waitForCompute(similaritySearchViewer); /* subscribe for computeCompleted event before start compute */
   molecules.dataFrame.currentRowIdx = 1;
-  await delay(100);
-  await waitForCompute(similaritySearchviewer);
-  expect(similaritySearchviewer.targetMoleculeIdx, 1);
-  expect(similaritySearchviewer.molCol!.get(0),
+  await waiter;
+  expect(similaritySearchViewer.targetMoleculeIdx, 1);
+  expect(similaritySearchViewer.molCol!.get(0),
     'meI/hHis/Aca/Cys_SEt/T/dK/Thr_PO3H2/Aca/Tyr_PO3H2/D-Chg/dV/Phe_ab-dehydro/N/D-Orn/D-aThr//Phe_4Me');
-  similaritySearchviewer.close();
-  molecules.close();
 }
 
 
@@ -46,14 +62,14 @@ async function _testDiversitySearchViewer() {
   const viewer = molecules.addViewer('SequenceDiversitySearchViewer');
   await delay(10);
   const diversitySearchviewer = getSearchViewer(viewer, 'SequenceDiversitySearchViewer');
+  viewList.push(diversitySearchviewer);
+  viewList.push(molecules);
   if (!diversitySearchviewer.renderMolIds)
     await waitForCompute(diversitySearchviewer);
   expect(diversitySearchviewer.fingerprint, 'Morgan');
   expect(diversitySearchviewer.distanceMetric, 'Tanimoto');
   expect(diversitySearchviewer.initialized, true);
   expect(diversitySearchviewer.renderMolIds.length > 0, true);
-  diversitySearchviewer.close();
-  molecules.close();
 }
 
 function getSearchViewer(viewer: DG.Viewer, name: string) {