@datagrok/bio 2.0.13 → 2.0.16

package/src/analysis/sequence-similarity-viewer.ts

@@ -0,0 +1,107 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {SequenceSearchBaseViewer} from './sequence-search-base-viewer';
+import {getMonomericMols} from '../calculations/monomerLevelMols';
+import * as C from '../utils/constants';
+import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
+import {updateDivInnerHTML} from '../utils/ui-utils';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {TableView} from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+
+export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
+  hotSearch: boolean;
+  sketchedMolecule: string = '';
+  curIdx: number = 0;
+  molCol: DG.Column | null = null;
+  idxs: DG.Column | null = null;
+  scores: DG.Column | null = null;
+  cutoff: number;
+  gridSelect: boolean = false;
+  targetMoleculeIdx: number = 0;
+  computeCompleted = new Subject<boolean>();
+
+  constructor() {
+    super('similarity');
+    this.cutoff = this.float('cutoff', 0.01, {min: 0, max: 1});
+    this.hotSearch = this.bool('hotSearch', true);
+  }
+
+  init(): void {
+    this.hotSearch = true;
+    this.initialized = true;
+  }
+
+  async render(computeData = true): Promise<void> {
+    if (!this.beforeRender())
+      return;
+    if (this.moleculeColumn) {
+      this.curIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
+      if (computeData && !this.gridSelect) {
+        this.targetMoleculeIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
+        const monomericMols = await getMonomericMols(this.moleculeColumn);
+        //need to create df to calculate fingerprints
+        const monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
+        const df = await grok.functions.call('Chem:callChemSimilaritySearch', {
+          df: this.dataFrame,
+          col: monomericMols,
+          molecule: monomericMols.get(this.targetMoleculeIdx),
+          metricName: this.distanceMetric,
+          limit: this.limit,
+          minScore: this.cutoff,
+          fingerprint: this.fingerprint
+        });
+        this.idxs = df.getCol('indexes');
+        this.scores = df.getCol('score');
+        this.molCol = DG.Column.string('sequence',
+          this.idxs!.length).init((i) => this.moleculeColumn?.get(this.idxs?.get(i)));
+        this.molCol.semType = DG.SEMTYPE.MACROMOLECULE;
+        this.tags.forEach((tag) => this.molCol!.setTag(tag, this.moleculeColumn!.getTag(tag)));
+        const resDf = DG.DataFrame.fromColumns([this.idxs!, this.molCol!, this.scores!]);
+        resDf.onCurrentRowChanged.subscribe((_) => {
+          this.dataFrame.currentRowIdx = resDf.col('indexes')!.get(resDf.currentRowIdx);
+          this.createPropertyPanel(resDf);
+          this.gridSelect = true;
+        });
+        const grid = resDf.plot.grid();
+        grid.col('indexes')!.visible = false;
+        const targetMolRow = this.idxs?.getRawData().findIndex((it) => it == this.targetMoleculeIdx);
+        const targetScoreCell = grid.cell('score', targetMolRow!);
+        targetScoreCell.cell.value = null;
+        (grok.shell.v as TableView).grid.root.addEventListener('click', (event: MouseEvent) => {
+          this.gridSelect = false;
+        });
+        updateDivInnerHTML(this.root, grid.root);
+        this.computeCompleted.next(true);
+      }
+    }
+  }
+
+
+  createPropertyPanel(resDf: DG.DataFrame) {
+    const propPanel = ui.div();
+    const molDifferences: { [key: number]: HTMLCanvasElement } = {};
+    const units = resDf.col('sequence')!.getTag(DG.TAGS.UNITS);
+    const separator = resDf.col('sequence')!.getTag(C.TAGS.SEPARATOR);
+    const splitter = WebLogo.getSplitter(units, separator);
+    const subParts1 = splitter(this.moleculeColumn!.get(this.targetMoleculeIdx));
+    const subParts2 = splitter(resDf.get('sequence', resDf.currentRowIdx));
+    const canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
+    propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
+    if (subParts1.length !== subParts2.length) {
+      propPanel.append(ui.divV([
+        ui.divText(`Different sequence length:`, {style: {fontWeight: 'bold'}}),
+        ui.divText(`target: ${subParts1.length} monomers`),
+        ui.divText(`selected: ${subParts2.length} monomers`)
+      ], {style: {paddingBottom: '10px'}}));
+    }
+    propPanel.append(createDifferencesWithPositions(molDifferences));
+    const acc = ui.accordion();
+    const accIcon = ui.element('i');
+    accIcon.className = 'grok-icon svg-icon svg-view-layout';
+    acc.addTitle(ui.span([accIcon, ui.label(`Similarity search`)]));
+    acc.addPane('Differeces', () => propPanel, true);
+    grok.shell.o = acc.root;
+  }
+}

package/src/calculations/monomerLevelMols.ts

@@ -1,25 +1,69 @@
 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'
+import * as C from '../utils/constants';
+import {getHelmMonomers} from '../package';
+import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 
 const V2000_ATOM_NAME_POS = 31;
 
 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});
+  const separator: string = mcol.tags[C.TAGS.SEPARATOR];
+  const units: string = mcol.tags[DG.TAGS.UNITS];
+  const splitter = WebLogo.getSplitter(units, separator);
+  let molV3000Array;
+  const monomersDict = new Map();
+  const monomers = units === 'helm' ?
+    getHelmMonomers(mcol) : Object.keys(WebLogo.getStats(mcol, 0, splitter).freq).filter((it) => it !== '');
+
+  for (let i = 0; i < monomers.length; i++)
+    monomersDict.set(monomers[i], `${i + 1}`);
+
+  if (units === 'helm') {
+    molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});
+    molV3000Array = changeV2000ToV3000(molV3000Array, monomersDict, pattern);
+  } else {
+    molV3000Array = new Array<string>(mcol.length);
+    for (let i = 0; i < mcol.length; i++) {
+      const sequenceMonomers = splitter(mcol.get(i)).filter((it) => it !== '');
+      const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
+      molV3000Array[i] = molV3000;
+    }
+  }
+  return DG.Column.fromStrings('monomericMols', molV3000Array);
+}
+
+function molV3000FromNonHelmSequence(
+  monomers: Array<string>, monomersDict: Map<string, string>, pattern: boolean = false) {
+  let molV3000 = `
+  Datagrok macromolecule handler
+
+  0  0  0  0  0  0            999 V3000
+M  V30 BEGIN CTAB
+`;
+
+  molV3000 += `M  V30 COUNTS ${monomers.length} ${monomers.length - 1} 0 0 0\n`;
+  molV3000 += 'M  V30 BEGIN ATOM\n';
 
-  let dict = new Map(); 
-  for(let i = 0; i < monomers.length; i++)
-    dict.set(monomers[i], `${i + 1}`);
+  for (let atomRowI = 0; atomRowI < monomers.length; atomRowI++) {
+    molV3000 += pattern ?
+      `M  V30 ${atomRowI + 1} R${monomersDict.get(monomers[atomRowI])} 0.000 0.000 0 0\n` :
+      `M  V30 ${atomRowI + 1} At 0.000 0.000 0 0 MASS=${monomersDict.get(monomers[atomRowI])}\n`;
+  }
+
+  molV3000 += 'M  V30 END ATOM\n';
+  molV3000 += 'M  V30 BEGIN BOND\n';
 
-  mols = changeToV3000(mols, dict, pattern);
+  for (let bondRowI = 0; bondRowI < monomers.length - 1; bondRowI++)
+    molV3000 += `M  V30 ${bondRowI + 1} 1 ${bondRowI + 1} ${bondRowI + 2}\n`;
 
-  return DG.Column.fromStrings('monomericMols', mols);
+  molV3000 += 'M  V30 END BOND\n';
+  molV3000 += 'M  V30 END CTAB\n';
+  molV3000 += 'M  END';
+  return molV3000;
 }
 
-function changeToV3000(mols: Array<string>, dict: Map<string, string>, pattern: boolean = false): Array<string> {
+function changeV2000ToV3000(mols: DG.Column, dict: Map<string, string>, pattern: boolean = false): Array<string> {
+  const molsArray = new Array<string>(mols.length);
   for (let i = 0; i < mols.length; i++) {
     let curPos = 0;
     let endPos = 0;
@@ -30,7 +74,7 @@ function changeToV3000(mols: Array<string>, dict: Map<string, string>, pattern:
 M  V30 BEGIN CTAB
 `;
 
-    const mol = mols[i];
+    const mol = mols.get(i);
     curPos = mol.indexOf('\n', curPos) + 1;
     curPos = mol.indexOf('\n', curPos) + 1;
     curPos = mol.indexOf('\n', curPos) + 1;
@@ -45,10 +89,10 @@ 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 += 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 += 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';
     molV3000 += 'M  V30 BEGIN BOND\n';
@@ -60,13 +104,13 @@ M  V30 BEGIN CTAB
       const order = parseInt(mol.substring(curPos + 6, curPos + 9).trim());
 
       molV3000 += `M  V30 ${bondRowI + 1} ${order} ${firstMonomer} ${secondMonomer}\n`;
-    } 
+    }
 
     molV3000 += 'M  V30 END BOND\n';
     molV3000 += 'M  V30 END CTAB\n';
     molV3000 += 'M  END';
-    mols[i] = molV3000;
+    molsArray[i] = molV3000;
   }
 
-  return mols;
-}
+  return molsArray;
+}

package/src/package-test.ts

@@ -13,7 +13,8 @@ import './tests/renderers-test';
 import './tests/convert-test';
 import './tests/fasta-handler-test';
 import './tests/WebLogo-positions-test';
-import './tests/checkInputColumn-tests'
+import './tests/checkInputColumn-tests';
+import './tests/similarity-diversity-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -12,15 +12,15 @@ import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignmen
 import {SequenceAlignment, Aligned} from './seq_align';
 import {Nucleotides} from '@datagrok-libraries/bio/src/nucleotides';
 import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
-import {getEmbeddingColsNames, sequenceSpace} from './utils/sequence-space';
+import {getEmbeddingColsNames, sequenceSpace} from './analysis/sequence-space';
 import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './utils/sequence-activity-cliffs';
+import {createPropPanelElement, createTooltipElement, getSimilaritiesMarix} from './analysis/sequence-activity-cliffs';
 import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CORE_LIB_FILENAME} from './utils/utils';
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
-import {representationsWidget} from './widgets/representations';
+import {getMacroMolColumnPropertyPanel, representationsWidget} from './widgets/representations';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
 import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils';
@@ -32,6 +32,9 @@ import {
 
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 import * as C from './utils/constants';
+import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
+import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
+import { substructureSearchDialog } from './substructure-search/substructure-search';
 
 //tags: init
 export async function initBio() {
@@ -46,6 +49,14 @@ export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
+//name: Sequence Renderer
+//input: column molColumn {semType: Macromolecule}
+//tags: panel
+//output: widget result
+export function macroMolColumnPropertyPanel(molColumn: DG.Column): DG.Widget {
+  return getMacroMolColumnPropertyPanel(molColumn);
+}
+
 //name: separatorSequenceCellRenderer
 //tags: cellRenderer
 //meta.cellType: sequence
@@ -462,3 +473,46 @@ export function getHelmMonomers(seqCol: DG.Column<string>): string[] {
   const stats = WebLogo.getStats(seqCol, 1, WebLogo.splitterAsHelm);
   return Object.keys(stats.freq);
 }
+
+
+//name: SequenceSimilaritySearchViewer
+//tags: viewer
+//output: viewer result
+export function similaritySearchViewer(): SequenceSimilarityViewer {
+  return new SequenceSimilarityViewer();
+}
+
+//top-menu: Bio | Similarity Search...
+//name: similaritySearch
+//description: finds the most similar sequence
+//output: viewer result
+export function similaritySearchTopMenu(): void {
+  const view = (grok.shell.v as DG.TableView);
+  const viewer = view.addViewer('SequenceSimilaritySearchViewer');
+  view.dockManager.dock(viewer, 'down');
+}
+
+//name: SequenceDiversitySearchViewer
+//tags: viewer
+//output: viewer result
+export function diversitySearchViewer(): SequenceDiversityViewer {
+  return new SequenceDiversityViewer();
+}
+
+//top-menu: Bio | Diversity Search...
+//name: diversitySearch
+//description: finds the most diverse molecules
+//output: viewer result
+export function diversitySearchTopMenu() {
+  const view = (grok.shell.v as DG.TableView);
+  const viewer = view.addViewer('SequenceDiversitySearchViewer');
+  view.dockManager.dock(viewer, 'down');
+}
+
+//name: Bio | Substructure search ...
+//tags: panel, bio
+//input: column col {semType: Macromolecule}
+export function bioSubstructureSearch(col: DG.Column): void {
+  substructureSearchDialog(col);
+}
+

package/src/substructure-search/substructure-search.ts

@@ -0,0 +1,65 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/units-handler';
+import * as C from '../utils/constants';
+
+/**
+ * Searches substructure in each row of Macromolecule column
+ *
+ * @param {DG.column} col Column with 'Macromolecule' semantic type
+ */
+export function substructureSearchDialog(col: DG.Column): void {
+  const units = col.getTag(DG.TAGS.UNITS);
+  const separator = col.getTag(C.TAGS.SEPARATOR);
+  const notations = [NOTATION.FASTA, NOTATION.SEPARATOR];
+
+  const substructureInput = ui.textInput('Substructure', '');
+  const notationInput = ui.choiceInput('Notation', units, notations);
+  const separatorInput = ui.textInput('Separator', separator);
+
+  // hide the separator input for non-SEPARATOR target notations
+  const toggleSeparator = () => {
+    if (notationInput.value !== NOTATION.SEPARATOR)
+      separatorInput.root.hidden = true;
+    else
+      separatorInput.root.hidden = false;
+  };
+
+  toggleSeparator();
+
+  notationInput.onChanged(() => {
+    toggleSeparator();
+  });
+
+  ui.dialog('Substructure search')
+    .add(ui.inputs([
+      substructureInput,
+      notationInput,
+      separatorInput
+    ]))
+    .onOK(() => {
+      let substructure = substructureInput.value;
+      if (notationInput.value !== NOTATION.FASTA && separatorInput.value !== separator)
+        substructure = substructure.replaceAll(separatorInput.value, separator);
+      const matchesColName = `Matches: ${substructure}`;
+      const colExists = col.dataFrame.columns.names()
+        .filter((it) => it.toLocaleLowerCase() === matchesColName.toLocaleLowerCase()).length > 0;
+      if (!colExists) {
+        const matches = substructureSearch(substructure, col);
+        col.dataFrame.columns.add(DG.Column.fromBitSet(matchesColName, matches));
+      } else { grok.shell.warning(`Search ${substructure} is already performed`); }
+    })
+    .show();
+}
+
+export function substructureSearch(substructure: string, col: DG.Column): DG.BitSet {
+  const lowerCaseSubstr = substructure.toLowerCase();
+  const resultArray = DG.BitSet.create(col.length);
+  for (let i = 0; i < col.length; i++) {
+    const macromolecule = col.get(i).toLowerCase();
+    if (macromolecule.indexOf(lowerCaseSubstr) !== -1)
+      resultArray.set(i, true, false);
+  }
+  return resultArray;
+}

package/src/tests/WebLogo-test.ts

@@ -61,21 +61,21 @@ XZJ{}2
   test('testPickupPaletteX', async () => { await _testPickupPaletteX(csvDfX); });
 });
 
-category('WebLogo.monomerToText', () => {
+category('WebLogo.monomerToShort', () => {
   test('longMonomerSingle', async () => {
-    await expect(WebLogo.monomerToText('S'), 'S');
+    await expect(WebLogo.monomerToShort('S', 5), 'S');
   });
   test('longMonomerShort', async () => {
-    await expect(WebLogo.monomerToText('Short'), 'Short');
+    await expect(WebLogo.monomerToShort('Short', 5), 'Short');
   });
   test('longMonomerLong56', async () => {
-    await expect(WebLogo.monomerToText('Long56'), 'Long5…');
+    await expect(WebLogo.monomerToShort('Long56', 5), 'Long5…');
   });
   test('longMonomerComplexFirstPartShort', async () => {
-    await expect(WebLogo.monomerToText('Long-long'), 'Long…');
+    await expect(WebLogo.monomerToShort('Long-long', 5), 'Long…');
   });
   test('longMonomerComplexFirstPartLong56', async () => {
-    await expect(WebLogo.monomerToText('Long56-long'), 'Long5…');
+    await expect(WebLogo.monomerToShort('Long56-long', 5), 'Long5…');
   });
 });
 

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

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {readDataframe} from './utils';
-import { _testActivityCliffsOpen } from './activity-cliffs-utils';
+import {_testActivityCliffsOpen} from './activity-cliffs-utils';
 
 
 category('activityCliffs', async () => {
@@ -12,28 +12,20 @@ category('activityCliffs', async () => {
   let actCliffsDf: DG.DataFrame;
   let actCliffsTableViewWithEmptyRows: DG.TableView;
   let actCliffsDfWithEmptyRows: DG.DataFrame;
-  
 
-  before(async () => {
+  test('activityCliffsOpens', async () => {
     actCliffsDf = await readDataframe('tests/sample_MSA_data.csv');
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
-    actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
-    actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
-  });
-
-  after(async () => {
+    await _testActivityCliffsOpen(actCliffsDf, 102, 'UMAP', 'MSA');
     grok.shell.closeTable(actCliffsDf);
     actCliffsTableView.close();
-    grok.shell.closeTable(actCliffsDfWithEmptyRows);
-    actCliffsTableViewWithEmptyRows.close();
   });
 
-  test('activityCliffsOpen', async () => {
-    await _testActivityCliffsOpen(actCliffsDf, 102, 'UMAP', 'MSA');
-  });
-
-  test('activityCliffsOpenWithEmptyRows', async () => {
+  test('activityCliffsWithEmptyRows', async () => {
+    actCliffsDfWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
+    actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 103, 'UMAP', 'MSA');
+    grok.shell.closeTable(actCliffsDfWithEmptyRows);
+    actCliffsTableViewWithEmptyRows.close();
   });
-  
 });

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

@@ -2,10 +2,11 @@ import * as DG from 'datagrok-api/dg';
 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';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
-   const scatterPlot = await activityCliffs(
+  await grok.data.detectSemanticTypes(df);
+  const scatterPlot = await activityCliffs(
      df, 
      df.col(colName)!, 
      df.col('Activity')!, 

package/src/tests/sequence-space-test.ts

@@ -10,26 +10,19 @@ category('sequenceSpace', async () => {
   let testHelmWithEmptyRows: DG.DataFrame;
   let testHelmWithEmptyRowsTableView: DG.TableView;
 
-  before(async () => {
+  test('sequenceSpaceOpens', async () => {
     testFastaDf = await readDataframe('samples/sample_FASTA.csv');
     testFastaTableView = grok.shell.addTableView(testFastaDf);
-    testHelmWithEmptyRows = await readDataframe('data/sample_HELM_empty_vals.csv');
-    testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
-  });
-
-  after(async () => {
+    await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'Sequence');
     grok.shell.closeTable(testFastaDf);
     testFastaTableView.close();
-    grok.shell.closeTable(testHelmWithEmptyRows);
-    testHelmWithEmptyRowsTableView.close();
   });
 
-  test('sequenceSpaceOpens', async () => {
-    await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'Sequence');
-  });
-
-  test('sequenceSpaceOpensWithEmptyRows', async () => {
+  test('sequenceSpaceWithEmptyRows', async () => {
+    testHelmWithEmptyRows = await readDataframe('data/sample_HELM_empty_vals.csv');
+    testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
     await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, 'UMAP', 'HELM');
+    grok.shell.closeTable(testHelmWithEmptyRows);
+    testHelmWithEmptyRowsTableView.close();
   });
-
 });

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

@@ -0,0 +1,78 @@
+import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
+import * as DG from 'datagrok-api/dg';
+import {createTableView, readDataframe} from './utils';
+import * as grok from 'datagrok-api/grok';
+import {SequenceSimilarityViewer} from '../analysis/sequence-similarity-viewer';
+
+category('similarity/diversity', async () => {
+  test('similaritySearchViewer', async () => {
+    await _testSimilaritySearchViewer();
+  });
+  test('diversitySearchViewer', async () => {
+    await _testDiversitySearchViewer();
+  });
+});
+
+async function _testSimilaritySearchViewer() {
+  const molecules = await createTableView('samples/sample_MSA.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),
+    'meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
+  expect(similaritySearchviewer.scores!.get(1), 0.6603773832321167);
+  expect(similaritySearchviewer.idxs!.get(1), 100);
+  expect(similaritySearchviewer.molCol!.get(1),
+    'meI/hHis/Aca/N/T/W/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me');
+  molecules.dataFrame.currentRowIdx = 1;
+  await delay(100);
+  await waitForCompute(similaritySearchviewer);
+  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();
+}
+
+
+async function _testDiversitySearchViewer() {
+  const molecules = await createTableView('samples/sample_MSA.csv');
+  const viewer = molecules.addViewer('SequenceDiversitySearchViewer');
+  await delay(10);
+  const diversitySearchviewer = getSearchViewer(viewer, 'SequenceDiversitySearchViewer');
+  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) {
+  for (const v of viewer.view.viewers) {
+    if (v.type === name)
+      return v;
+  }
+}
+
+async function waitForCompute(viewer: SequenceSimilarityViewer) {
+  const t = new Promise((resolve, reject) => {
+    viewer.computeCompleted.subscribe(async (_: any) => {
+      try {
+        console.log(`!@#$%^&*()`+viewer.targetMoleculeIdx);
+        resolve(true);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+  await t;
+}