@datagrok/bio 2.0.31 → 2.0.33

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.0.31",
+  "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",
@@ -16,7 +16,7 @@
     "@biowasm/aioli": "^3.1.0",
     "@datagrok-libraries/bio": "^5.8.0",
     "@datagrok-libraries/chem-meta": "1.0.1",
-    "@datagrok-libraries/ml": "^6.2.1",
+    "@datagrok-libraries/ml": "^6.2.2",
     "@datagrok-libraries/utils": "^1.14.1",
     "cash-dom": "^8.0.0",
     "datagrok-api": "^1.8.1",
@@ -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/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,16 +10,16 @@ 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';
 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
@@ -168,9 +368,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 +381,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 +413,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

@@ -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);
-    await _testActivityCliffsOpen(actCliffsDf, 36, 'UMAP', 'MSA');
-    grok.shell.closeTable(actCliffsDf);
-    actCliffsTableView.close();
+    viewList.push(actCliffsTableView);
+
+    await _testActivityCliffsOpen(actCliffsDf, 57, 'UMAP', 'MSA');
   });
 
   test('activityCliffsWithEmptyRows', async () => {
     actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
+    dfList.push(actCliffsDfWithEmptyRows);
     actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
-    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 37, 'UMAP', 'MSA');
-    grok.shell.closeTable(actCliffsDfWithEmptyRows);
-    actCliffsTableViewWithEmptyRows.close();
+    viewList.push(actCliffsTableViewWithEmptyRows);
+
+    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, 'UMAP', 'MSA');
   });
 });

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

@@ -11,7 +11,7 @@ export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: nu
     df,
     df.col(colName)!,
     df.col('Activity')!,
-    90,
+    50,
     method);
 
   expect(scatterPlot != null, true);

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) {