@datagrok/bio 1.7.24 → 1.8.2

package/src/__jest__/test-node.ts

@@ -68,6 +68,7 @@ export async function getBrowserPage(puppeteer: any): Promise<{ browser: any, pa
   });
 
   const page = await browser.newPage();
+  await page.setDefaultNavigationTimeout(0);
   await page.goto(`${url}/oauth/`);
   await page.setCookie({name: 'auth', value: token});
   await page.evaluate((token: any) => {
@@ -75,8 +76,8 @@ export async function getBrowserPage(puppeteer: any): Promise<{ browser: any, pa
   }, token);
   await page.goto(url);
   try {
-    await page.waitForSelector('.grok-preloader');
-    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 500000});
+    await page.waitForSelector('.grok-preloader', { timeout: 1800000 });
+    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 3600000});
   } catch (error) {
     throw error;
   }

package/src/package-test.ts

@@ -22,7 +22,6 @@ export {tests};
 //input: string category {optional: true}
 //input: string test {optional: true}
 //output: dataframe result
-//top-menu: Tools | Dev | JS API Tests
 export async function test(category: string, test: string): Promise<DG.DataFrame> {
   const data = await runTests({category, test});
   return DG.DataFrame.fromObjects(data)!;

package/src/package.ts

@@ -20,7 +20,6 @@ import {createJsonMonomerLibFromSdf, encodeMonomers, getMolfilesFromSeq, HELM_CO
 import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
-import {lru} from './utils/cell-renderer';
 import {representationsWidget} from './widgets/representations';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
@@ -28,44 +27,39 @@ import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-uti
 
 
 //tags: init
-export async function initBio(): Promise<void> {
-  // apparently HELMWebEditor requires dojo to be initialized first
-  const funcList: DG.Func[] = DG.Func.find({package: 'Helm', name: 'initHelm'});
-  console.debug(`Bio: initBio() funcList.length = ${funcList.length}`);
-  if (funcList.length === 1)
-    await grok.functions.call('Helm:initHelp');
-
-  return new Promise((resolve, reject) => {
-    // @ts-ignore
-    dojo.ready(function() { resolve(null); });
-  });
+export async function initBio() {
 }
 
-//name: Lru
-//output: object lruCache
-export function Lru() {
-  return lru;
+//name: fastaSequenceCellRenderer
+//tags: cellRenderer
+//meta.cellType: Sequence
+//meta.columnTags: units=fasta
+//output: grid_cell_renderer result
+export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+  return new MacromoleculeSequenceCellRenderer();
 }
 
-//name: macromoleculeSequenceCellRenderer
+//name: separatorSequenceCellRenderer
 //tags: cellRenderer
-//meta.cellType: Macromolecule
+//meta.cellType: Sequence
+//meta.columnTags: units=separator
 //output: grid_cell_renderer result
-export function macromoleculeSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
   return new MacromoleculeSequenceCellRenderer();
 }
 
 function checkInputColumn(col: DG.Column, name: string,
   allowedNotations: string[] = [], allowedAlphabets: string[] = []): boolean {
-  const units: string = col.getTag(DG.TAGS.UNITS);
+  const notation: string = col.getTag(DG.TAGS.UNITS);
+  const alphabet: string = col.getTag('alphabet')
   if (col.semType !== DG.SEMTYPE.MACROMOLECULE) {
     grok.shell.warning(name + ' analysis is allowed for Macromolecules semantic type');
     return false;
   } else if (
     (allowedAlphabets.length > 0 &&
-      !allowedAlphabets.some((a) => units.toUpperCase().endsWith(a.toUpperCase()))) ||
+      !allowedAlphabets.some((a) => alphabet.toUpperCase() == (a.toUpperCase()))) ||
     (allowedNotations.length > 0 &&
-      !allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase())))
+      !allowedNotations.some((n) => notation.toUpperCase() == (n.toUpperCase())))
   ) {
     const notationAdd = allowedNotations.length == 0 ? 'any notation' :
       (`notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')} `);
@@ -118,7 +112,7 @@ export function vdRegionViewer() {
 //input: double similarity = 80 [Similarity cutoff]
 //input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
 export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
-  similarity: number, methodName: string): Promise<void> {
+  similarity: number, methodName: string): Promise<DG.Viewer | undefined> {
   if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
     return;
   const encodedCol = encodeMonomers(macroMolecule);
@@ -128,8 +122,13 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
   const options = {
     'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
   };
-  const units = macroMolecule!.tags[DG.TAGS.UNITS];
-  await getActivityCliffs(
+  const tags = {
+    'units': macroMolecule.tags['units'],
+    'aligned': macroMolecule.tags['aligned'],
+    'separator': macroMolecule.tags['separator'],
+    'alphabet': macroMolecule.tags['alphabet'],
+  }
+  const sp = await getActivityCliffs(
     df,
     macroMolecule,
     encodedCol,
@@ -140,11 +139,12 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     'Levenshtein',
     methodName,
     DG.SEMTYPE.MACROMOLECULE,
-    units,
+    tags,
     sequenceSpace,
     sequenceGetSimilarities,
     drawTooltip,
     (options as any)[methodName]);
+    return sp;
 }
 
 //top-menu: Bio | Sequence Space...
@@ -155,7 +155,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
 //input: string similarityMetric { choices:["Levenshtein", "Tanimoto"] }
 //input: bool plotEmbeddings = true
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
-  similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<void> {
+  similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<DG.Viewer|undefined> {
   if (!checkInputColumn(macroMolecule, 'Activity Cliffs'))
     return;
   const encodedCol = encodeMonomers(macroMolecule);
@@ -176,14 +176,16 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   for (const col of embeddings) {
       const listValues = col.toList();
       emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
-      table.columns.add(DG.Column.fromFloat32Array(col.name, listValues));
-  }   
+      table.columns.add(DG.Column.fromList('double', col.name, listValues));
+  }
+  let sp;   
   if (plotEmbeddings) {
     for (const v of grok.shell.views) {
       if (v.name === table.name)
-        (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
+        sp = (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
     }
   }
+  return sp;
 };
 
 //top-menu: Bio | To Atomic Level...
@@ -199,22 +201,6 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
   if (!checkInputColumn(macroMolecule, 'To Atomic Level'))
     return;
 
-  let currentView: DG.TableView;
-  for (const view of grok.shell.tableViews) {
-    if (df.name === view.name)
-      currentView = view;
-  }
-
-  // Some hack to activate Chem Molecule rendering
-  const file2 = await _package.files.readAsText('tests/sar-small.csv');
-  const df2 = DG.DataFrame.fromCsv(file2);
-  const v2 = grok.shell.addTableView(df2);
-  setTimeout(() => {
-    grok.shell.closeTable(df2);
-    v2.close();
-    grok.shell.v = currentView;
-  }, 100);
-
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
   const atomicCodes = getMolfilesFromSeq(macroMolecule, monomersLibObject);
@@ -224,6 +210,7 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
   col.semType = DG.SEMTYPE.MOLECULE;
   col.tags[DG.TAGS.UNITS] = 'molblock';
   df.columns.add(col, true);
+  await grok.data.detectSemanticTypes(df);
 }
 
 
@@ -415,3 +402,4 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
   resDf.name = `datasets_detectMacromolecule_${path}`;
   return resDf;
 }
+

package/src/tests/WebLogo-positions-test.ts

@@ -1,10 +1,11 @@
-
 import {after, before, category, test, expect, 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 {PositionInfo, PositionMonomerInfo, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {Column} from 'datagrok-api/dg';
+
 category('WebLogo-positions', () => {
   let tvList: DG.TableView[];
   let dfList: DG.DataFrame[];
@@ -18,8 +19,6 @@ category('WebLogo-positions', () => {
     -TC-GCTTGC--`;
 
 
-  const resShrinkEmptyTailDf1: PositionInfo[] = [];
-
   before(async () => {
     tvList = [];
     dfList = [];
@@ -35,6 +34,9 @@ category('WebLogo-positions', () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
     const wlViewer: WebLogo = await df.plot.fromType('WebLogo') as unknown as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
@@ -57,9 +59,9 @@ category('WebLogo-positions', () => {
       new PositionInfo('11', {'-': new PositionMonomerInfo(5)}),
       new PositionInfo('12', {'-': new PositionMonomerInfo(5)})
     ];
-    console.log(positions);
-    expect(positions.length,resAllDf1.length);
-    // check all positions are equal resAllDf1
+
+    expect(positions.length, resAllDf1.length);
+
     for (let i = 0; i < positions.length; i++) {
       expect(positions[i].name, resAllDf1[i].name);
       for (const key in positions[i].freq) {
@@ -68,11 +70,27 @@ category('WebLogo-positions', () => {
     }
 
   });
-  test('positions with shrinkEmptyTail option', async () => {
-    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
+  test('positions with shrinkEmptyTail option true (filterd)', async () => {
+    let csvDf2 = `seq 
+    -TC-G-TTGC--
+    -TC-GCTTGC--
+    -T--C-GT-
+    -T--C-GT-
+    -T--C-GT-
+    -T--CCGT-`;
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf2);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
+    let seq: Column = df.getCol('seq');
+    df.filter.init((i) => {
+      return i > 2;
+    });
+    df.filter.fireChanged();
     const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'shrinkEmptyTail': true}) as unknown as WebLogo;
+
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
@@ -81,19 +99,19 @@ category('WebLogo-positions', () => {
     const positions: PositionInfo[] = wlViewer['positions'];
 
     const resAllDf1: PositionInfo[] = [
-      new PositionInfo('1', {'A': new PositionMonomerInfo(2), '-': new PositionMonomerInfo(3)}),
-      new PositionInfo('2', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('3', {'C': new PositionMonomerInfo(5)}),
-      new PositionInfo('4', {'-': new PositionMonomerInfo(5)}),
-      new PositionInfo('5', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('6', {'-': new PositionMonomerInfo(3), 'C': new PositionMonomerInfo(2)}),
-      new PositionInfo('7', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('8', {'T': new PositionMonomerInfo(5)}),
-      new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
-      new PositionInfo('10', {'C': new PositionMonomerInfo(5)})
+      new PositionInfo('1', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('2', {'T': new PositionMonomerInfo(3)}),
+      new PositionInfo('3', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('4', {'-': new PositionMonomerInfo(3)}),
+      new PositionInfo('5', {'C': new PositionMonomerInfo(3)}),
+      new PositionInfo('6', {'-': new PositionMonomerInfo(2), 'C': new PositionMonomerInfo(1)}),
+      new PositionInfo('7', {'G': new PositionMonomerInfo(3)}),
+      new PositionInfo('8', {'T': new PositionMonomerInfo(3)}),
+      new PositionInfo('9', {'-': new PositionMonomerInfo(3)}),
     ];
 
-    console.log(positions);
+    expect(positions.length, resAllDf1.length);
+
     for (let i = 0; i < positions.length; i++) {
       expect(positions[i].name, resAllDf1[i].name);
       for (const key in positions[i].freq) {
@@ -107,7 +125,10 @@ category('WebLogo-positions', () => {
     const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
     const tv: DG.TableView = grok.shell.addTableView(df);
 
-    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'skipEmptyPositions': false}) as unknown as WebLogo;
+    df.getCol('seq').semType = 'Macromolecule';
+    df.getCol('seq').setTag('units', 'fasta:SEQ.MSA:DNA');
+
+    const wlViewer: WebLogo = await df.plot.fromType('WebLogo', {'skipEmptyPositions': true}) as unknown as WebLogo;
     tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
 
     tvList.push(tv);
@@ -126,7 +147,8 @@ category('WebLogo-positions', () => {
       new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
       new PositionInfo('10', {'C': new PositionMonomerInfo(5)})
     ];
-    console.log(positions);
+
+    expect(positions.length, resAllDf1.length);
 
     for (let i = 0; i < positions.length; i++) {
       expect(positions[i].name, resAllDf1[i].name);

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

@@ -1,58 +1,39 @@
-import {after, before, category, expect, expectFloat, test} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
 
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {readDataframe} from './utils';
-import {getEmbeddingColsNames, sequenceSpace} from '../utils/sequence-space';
-import {drawTooltip, sequenceGetSimilarities} from '../utils/sequence-activity-cliffs';
-import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import {encodeMonomers} from '../utils/utils';
+import { _testActivityCliffsOpen } from './activity-cliffs-utils';
 
 
 category('activityCliffs', async () => {
   let actCliffsTableView: DG.TableView;
   let actCliffsDf: DG.DataFrame;
+  let actCliffsTableViewWithEmptyRows: DG.TableView;
+  let actCliffsDfWithEmptyRows: DG.DataFrame;
+  
 
   before(async () => {
     actCliffsDf = await readDataframe('samples/sample_MSA.csv');
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
-
-    actCliffsDf = actCliffsTableView.dataFrame;
+    actCliffsDfWithEmptyRows = await readDataframe('samples/sample_HELM_empty_vals.csv');
+    actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
   });
 
   after(async () => {
     grok.shell.closeTable(actCliffsDf);
     actCliffsTableView.close();
+    grok.shell.closeTable(actCliffsDfWithEmptyRows);
+    actCliffsTableViewWithEmptyRows.close();
   });
 
   test('activityCliffsOpen', async () => {
-    const axesNames = getEmbeddingColsNames(actCliffsDf);
-    const units = actCliffsDf.col('MSA')!.tags[DG.TAGS.UNITS];
-    const options = {
-      'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
-    };
-    const encodedCol = encodeMonomers(actCliffsDf.col('MSA')!) as DG.Column;
-    const scatterPlot = await getActivityCliffs(
-      actCliffsDf,
-      actCliffsDf.col('MSA')!,
-      encodedCol,
-      axesNames,
-      'Activity cliffs',
-      actCliffsDf.col('Activity')!,
-      50,
-      'Levenshtein',
-      't-SNE',
-      DG.SEMTYPE.MACROMOLECULE,
-      units,
-      sequenceSpace,
-      sequenceGetSimilarities,
-      drawTooltip);
-
-    expect(scatterPlot != null, true);
-
-    const cliffsLink = (Array.from(scatterPlot.root.children) as Element[])
-      .filter((it) => it.className === 'ui-btn ui-btn-ok');
-    expect((cliffsLink[0] as HTMLElement).innerText, '2362 cliffs');
+    await _testActivityCliffsOpen(actCliffsDf, 53, 'UMAP', 'MSA');
+  });
+
+  test('activityCliffsOpenWithEmptyRows', async () => {
+    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 53, 'UMAP', 'HELM');
   });
+  
 });

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

@@ -0,0 +1,19 @@
+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';
+
+
+export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
+   const scatterPlot = await activityCliffs(
+     df, 
+     df.col(colName)!, 
+     df.col('Activity')!, 
+     80, 
+     method);
+
+    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`);
+}

package/src/tests/detectors-test.ts

@@ -190,6 +190,7 @@ MWRSWY-CKHP
     };
   };
 
+
   test('NegativeEmpty', async () => { await _testNeg(readCsv('csvDfEmpty', csvDfEmpty), 'col1'); });
   test('Negative1', async () => { await _testNeg(readCsv('csvDf1', csvDf1), 'col1'); });
   test('Negative2', async () => { await _testNeg(readCsv('csvDf2', csvDf2), 'col1'); });
@@ -197,44 +198,44 @@ MWRSWY-CKHP
   test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
 
   test('Dna1', async () => {
-    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta:SEQ:DNA');
+    await _testPos(readCsv('csvDfDna1', csvDfDna1), 'seq', 'fasta', 'SEQ', 'DNA');
   });
   test('Rna1', async () => {
-    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta:SEQ:RNA');
+    await _testPos(readCsv('csvDfRna1', csvDfRna1), 'seq', 'fasta', 'SEQ', 'RNA');
   });
   test('AA1', async () => {
-    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta:SEQ:PT');
+    await _testPos(readCsv('csvDfPt1', csvDfPt1), 'seq', 'fasta', 'SEQ', 'PT');
   });
   test('MsaDna1', async () => {
-    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta:SEQ.MSA:DNA');
+    await _testPos(readCsv('csvDfMsaDna1', csvDfMsaDna1), 'seq', 'fasta', 'SEQ.MSA', 'DNA');
   });
 
   test('MsaAA1', async () => {
-    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta:SEQ.MSA:PT');
+    await _testPos(readCsv('csvDfMsaPt1', csvDfMsaPt1), 'seq', 'fasta', 'SEQ.MSA', 'PT');
   });
 
   test('SepDna', async () => {
-    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator:SEQ:DNA', '*');
+    await _testPos(readCsv('csvDfSepDna', csvDfSepDna), 'seq', 'separator', 'SEQ', 'DNA', '*');
   });
   test('SepRna', async () => {
-    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator:SEQ:RNA', '*');
+    await _testPos(readCsv('csvDfSepRna', csvDfSepRna), 'seq', 'separator', 'SEQ', 'RNA', '*');
   });
   test('SepPt', async () => {
-    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator:SEQ:PT', '-');
+    await _testPos(readCsv('csvDfSepPt', csvDfSepPt), 'seq', 'separator', 'SEQ', 'PT', '-');
   });
   test('SepUn1', async () => {
-    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator:SEQ:UN', '-');
+    await _testPos(readCsv('csvDfSepUn1', csvDfSepUn1), 'seq', 'separator', 'SEQ', 'UN', '-');
   });
   test('SepUn2', async () => {
-    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator:SEQ:UN', '/');
+    await _testPos(readCsv('csvDfSepUn2', csvDfSepUn2), 'seq', 'separator', 'SEQ', 'UN', '/');
   });
 
   test('SepMsaN1', async () => {
-    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator:SEQ.MSA:DNA', '-');
+    await _testPos(readCsv('csvDfSepMsaDna1', csvDfSepMsaDna1), 'seq', 'separator', 'SEQ.MSA', 'DNA', '-');
   });
 
   test('SamplesFastaCsvPt', async () => {
-    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaCsv), 'sequence', 'fasta', 'SEQ', 'PT');
   });
   test('SamplesFastaCsvNegativeEntry', async () => {
     await _testNeg(readSamples(Samples.fastaCsv), 'Entry');
@@ -247,7 +248,7 @@ MWRSWY-CKHP
   });
 
   test('SamplesFastaFastaPt', async () => {
-    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaFasta, readFileFasta), 'sequence', 'fasta', 'SEQ', 'PT');
   });
 
   // peptidesComplex contains monomers with spaces in AlignedSequence columns, which are forbidden
@@ -265,7 +266,7 @@ MWRSWY-CKHP
   });
 
   test('samplesMsaComplexUn', async () => {
-    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator:SEQ.MSA:UN', '/');
+    await _testPos(readSamples(Samples.msaComplex), 'MSA', 'separator', 'SEQ.MSA', 'UN', '/');
   });
   test('samplesMsaComplexNegativeActivity', async () => {
     await _testNeg(readSamples(Samples.msaComplex), 'Activity');
@@ -280,7 +281,7 @@ MWRSWY-CKHP
   });
 
   test('samplesHelmCsvHELM', async () => {
-    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'HELM', null);
+    await _testPos(readSamples(Samples.helmCsv), 'HELM', 'helm', null, null, null);
   });
 
   test('samplesHelmCsvNegativeActivity', async () => {
@@ -296,7 +297,7 @@ MWRSWY-CKHP
     await _testNeg(readSamples(Samples.testHelmCsv), 'Test type');
   });
   test('samplesTestHelmPositiveHelmString', async () => {
-    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'HELM');
+    await _testPos(readSamples(Samples.testHelmCsv), 'HELM string', 'helm', null, null, null);
   });
   test('samplesTestHelmNegativeValid', async () => {
     await _testNeg(readSamples(Samples.testHelmCsv), 'Valid?');
@@ -328,7 +329,7 @@ MWRSWY-CKHP
   });
 
   test('samplesFastaPtPosSequence', async () => {
-    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta:SEQ:PT');
+    await _testPos(readSamples(Samples.fastaPtCsv), 'sequence', 'fasta', 'SEQ', 'PT');
   });
 
   test('samplesTestCerealNegativeCerealName', async () => {
@@ -383,7 +384,7 @@ export async function _testNeg(readDf: DfReaderFunc, colName: string) {
   }
 }
 
-export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, separator: string | null = null) {
+export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, aligned: string | null, alphabet: string | null, separator: string | null = null) {
   const df: DG.DataFrame = await readDf();
   const col: DG.Column = df.col(colName)!;
   const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
@@ -392,6 +393,8 @@ export async function _testPos(readDf: DfReaderFunc, colName: string, units: str
 
   expect(col.semType === DG.SEMTYPE.MACROMOLECULE, true);
   expect(col.getTag(DG.TAGS.UNITS), units);
+  expect(col.getTag('aligned'), aligned);
+  expect(col.getTag('alphabet'), alphabet);
   if (separator)
     expect(col.getTag('separator'), separator);
 }

package/src/tests/renderers-test.ts

@@ -1,4 +1,4 @@
-import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, delay, expect, test} from '@datagrok-libraries/utils/src/test';
 
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
@@ -12,6 +12,7 @@ category('renderers', () => {
   let dfList: DG.DataFrame[];
 
   before(async () => {
+    await grok.functions.call('Bio:initBio');
     tvList = [];
     dfList = [];
   });
@@ -43,15 +44,19 @@ category('renderers', () => {
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
       `cell.renderer="${srcSeqCol!.getTag('cell.renderer')}"`);
     expect(srcSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(srcSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
-    expect(srcSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    expect(srcSeqCol!.getTag(DG.TAGS.UNITS), 'fasta');
+    expect(srcSeqCol!.getTag('aligned'), 'SEQ');
+    expect(srcSeqCol!.getTag('alphabet'), 'PT');
+    expect(srcSeqCol!.getTag('cell.renderer'), 'sequence');
 
     const msaSeqCol: DG.Column | null = await multipleSequenceAlignmentAny(df, srcSeqCol!);
     tv.grid.invalidate();
-
+    
     expect(msaSeqCol!.semType, DG.SEMTYPE.MACROMOLECULE);
-    expect(msaSeqCol!.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
-    expect(msaSeqCol!.getTag('cell.renderer'), 'Macromolecule');
+    expect(msaSeqCol!.getTag(DG.TAGS.UNITS), 'fasta');
+    expect(msaSeqCol!.getTag('aligned'), 'SEQ.MSA');
+    expect(msaSeqCol!.getTag('alphabet'), 'PT');
+    expect(msaSeqCol!.getTag('cell.renderer'), 'sequence');
 
     dfList.push(df);
     tvList.push(tv);
@@ -65,7 +70,7 @@ category('renderers', () => {
 
     const srcCol: DG.Column = df.col('sequence')!;
     const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
-    expect(tgtCol.getTag('cell.renderer'), 'Macromolecule');
+    expect(tgtCol.getTag('cell.renderer'), 'sequence');
 
     tvList.push(tv);
     dfList.push(df);

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

@@ -1,30 +1,35 @@
-import {after, before, category, test, expect} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
 import * as DG from 'datagrok-api/dg';
-import {sequenceSpace} from '../utils/sequence-space';
 import {readDataframe} from './utils';
 import * as grok from 'datagrok-api/grok';
+import { _testSequenceSpaceReturnsResult } from './sequence-space-utils';
 
 category('sequenceSpace', async () => {
   let testFastaDf: DG.DataFrame;
+  let testFastaTableView: DG.TableView;
+  let testHelmWithEmptyRows: DG.DataFrame;
+  let testHelmWithEmptyRowsTableView: DG.TableView;
 
   before(async () => {
     testFastaDf = await readDataframe('samples/sample_FASTA.csv');
-    // await grok.data.detectSemanticTypes(testFastaDf);
+    testFastaTableView = grok.shell.addTableView(testFastaDf);
+    testHelmWithEmptyRows = await readDataframe('samples/sample_HELM_empty_vals.csv');
+    testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
   });
 
   after(async () => {
     grok.shell.closeTable(testFastaDf);
+    testFastaTableView.close();
+    grok.shell.closeTable(testHelmWithEmptyRows);
+    testHelmWithEmptyRowsTableView.close();
   });
 
   test('sequenceSpaceOpens', async () => {
-    const sequenceSpaceParams = {
-      seqCol: testFastaDf.col('Sequence')!,
-      methodName: 't-SNE',
-      similarityMetric: 'Levenshtein',
-      embedAxesNames: ['Embed_X', 'Embed_Y']
-    };
-    const res = await sequenceSpace(sequenceSpaceParams);
-    expect(res.coordinates != undefined, true);
-    expect(res.distance != undefined, true);
+    await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'Sequence');
   });
+
+  test('sequenceSpaceOpensWithEmptyRows', async () => {
+    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, 'UMAP', 'HELM');
+  });
+
 });

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

@@ -0,0 +1,10 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import { expect } from '@datagrok-libraries/utils/src/test';
+import { sequenceSpaceTopMenu } from '../package';
+
+export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: string, colName: string) {
+  await grok.data.detectSemanticTypes(df);
+  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, 'Levenshtein', true);
+  expect(sp != null, true);
+}