@datagrok/bio 1.4.0 → 1.5.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -11,10 +11,11 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^2.2.0",
-    "@datagrok-libraries/utils": "^0.4.2",
+    "@datagrok-libraries/bio": "^2.3.1",
+    "@datagrok-libraries/utils": "^1.0.0",
+    "@datagrok-libraries/ml": "^2.0.8",
     "cash-dom": "latest",
-    "datagrok-api": "^1.4.11",
+    "datagrok-api": "^1.4.12",
     "dayjs": "latest",
     "ts-loader": "^9.2.5",
     "typescript": "^4.4.2"
@@ -35,11 +36,13 @@
   "scripts": {
     "link-api": "npm link datagrok-api",
     "link-bio": "npm link @datagrok-libraries/bio",
-    "link-all": "npm link datagrok-api @datagrok-libraries/bio",
+    "link-ml": "npm link @datagrok-libraries/ml",
+    "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/bio @datagrok-libraries/ml",
     "debug-sequences1": "grok publish --rebuild",
     "release-sequences1": "grok publish --rebuild --release",
     "build-sequences1": "webpack",
-    "local-bio": "grok publish local",
+    "debug-local": "grok publish local",
+    "release-local": "grok publish local --release",
     "build": "webpack",
     "debug-sequences1-public": "grok publish public --rebuild",
     "release-sequences1-public": "grok publish public --rebuild --release",
@@ -48,7 +51,8 @@
     "lint": "eslint \"./src/**/*.ts\"",
     "lint-fix": "eslint \"./src/**/*.ts\" --fix",
     "test": "jest",
-    "test-local": "set HOST=localhost && jest"
+    "test-local": "set HOST=localhost && jest",
+    "build-bio-local": "npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm --prefix ./../../libraries/ml run build && npm run build && npm --prefix ./../../libraries/bio run build && npm run build"
   },
   "canEdit": [
     "Developers"

package/src/package-test.ts

@@ -6,8 +6,10 @@ import './tests/WebLogo-test';
 import './tests/Palettes-test';
 import './tests/detectors-test';
 import './tests/msa-tests';
+import './tests/sequence-space-test';
+import './tests/activity-cliffs-tests';
 
-export const _packageTest = new DG.Package();
+export const _package = new DG.Package();
 export {tests};
 
 /** For the 'test' function argument names are fixed as 'category' and 'test' because of way it is called. */

package/src/package.ts

@@ -3,17 +3,20 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {SequenceAlignment, Aligned} from './seq_align';
-
 export const _package = new DG.Package();
 
-import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {mmSemType} from './const';
+import {WebLogo, SeqColStats} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
-import {TableView} from 'datagrok-api/dg';
-import {mmSemType} from './const';
+import {SequenceAlignment, Aligned} from './seq_align';
 import {Nucleotides} from '@datagrok-libraries/bio/src/nucleotides';
 import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
+import {convert} from './utils/convert';
+import {getEmbeddingColsNames, sequenceSpace} from './utils/sequence-space';
+import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import {sequenceGetSimilarities, drawTooltip} from './utils/sequence-activity-cliffs';
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -49,23 +52,59 @@ export function vdRegionViewer() {
 //name: Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe df [Input data table]
-//input: column smiles {type:categorical; semType: Macromolecule}
+//input: column sequence {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
 //input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
-export async function activityCliffs(df: DG.DataFrame, smiles: DG.Column, activities: DG.Column,
+export async function activityCliffs(df: DG.DataFrame, sequence: DG.Column, activities: DG.Column,
   similarity: number, methodName: string): Promise<void> {
+  const axesNames = getEmbeddingColsNames(df);
+  const options = {
+    'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
+  };
+  const units = sequence!.tags[DG.TAGS.UNITS];
+  await getActivityCliffs(
+    df,
+    sequence,
+    axesNames,
+    activities,
+    similarity,
+    'Levenshtein',
+    methodName,
+    DG.SEMTYPE.MACROMOLECULE,
+    units,
+    sequenceSpace,
+    sequenceGetSimilarities,
+    drawTooltip,
+    (options as any)[methodName]);
 }
 
 //top-menu: Bio | Sequence Space...
 //name: Sequence Space
 //input: dataframe table
-//input: column smiles { semType: Macromolecule }
-//input: string methodName { choices:["UMAP", "t-SNE", "SPE", "pSPE", "OriginalSPE"] }
-//input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
+//input: column macroMolecule { semType: Macromolecule }
+//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+//input: string similarityMetric { choices:["Levenshtein", "Tanimoto"] }
 //input: bool plotEmbeddings = true
-export async function chemSpaceTopMenu(table: DG.DataFrame, smiles: DG.Column, methodName: string,
-  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean): Promise<void> {
+export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
+  similarityMetric: string = 'Levenshtein', plotEmbeddings: boolean): Promise<void> {
+  const embedColsNames = getEmbeddingColsNames(table);
+  const chemSpaceParams = {
+    seqCol: macroMolecule,
+    methodName: methodName,
+    similarityMetric: similarityMetric,
+    embedAxesNames: embedColsNames
+  };
+  const sequenceSpaceRes = await sequenceSpace(chemSpaceParams);
+  const embeddings = sequenceSpaceRes.coordinates;
+  for (const col of embeddings)
+    table.columns.add(col);
+  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]});
+    }
+  }
 };
 
 //top-menu: Bio | MSA...
@@ -90,40 +129,53 @@ export async function compositionAnalysis(): Promise<void> {
   const wl = await col.dataFrame.plot.fromType('WebLogo', {});
 
   for (const v of grok.shell.views) {
-    if (v instanceof TableView && (v as DG.TableView).dataFrame.name === col.dataFrame.name) {
+    if (v instanceof DG.TableView && (v as DG.TableView).dataFrame.name === col.dataFrame.name) {
       (v as DG.TableView).dockManager.dock(wl.root, 'down');
       break;
     }
   }
 }
 
+// helper function for importFasta
+function parseMacromolecule(
+  fileContent: string,
+  startOfSequence: number,
+  endOfSequence: number
+): string {
+  const seq = fileContent.slice(startOfSequence, endOfSequence);
+  const seqArray = seq.split(/\s/);
+  return seqArray.join('');
+}
+
 //name: importFasta
 //description: Opens FASTA file
 //tags: file-handler
 //meta.ext: fasta, fna, ffn, faa, frn, fa
-//input: string content
+//input: string fileContent
 //output: list tables
-export function importFasta(content: string): DG.DataFrame [] {
-  const regex = /^>(.*)$/gm;
-  const descriptions = [];
-  const sequences = [];
-  let index = 0;
-  let match;
-  while (match = regex.exec(content)) {
-    descriptions.push(content.substring(match.index + 1, regex.lastIndex));
-    if (index !== 0)
-      sequences.push(content.substring(index, regex.lastIndex));
-    index = regex.lastIndex + 1;
+export function importFasta(fileContent: string): DG.DataFrame [] {
+  const regex = /^>(.*)$/gm; // match lines starting with >
+  const descriptionsArray = [];
+  const sequencesArray: string[] = [];
+  let startOfSequence = 0;
+  let match; // match.index is the beginning of the matched line
+  while (match = regex.exec(fileContent)) {
+    const description = fileContent.substring(match.index + 1, regex.lastIndex);
+    descriptionsArray.push(description);
+    if (startOfSequence !== 0)
+      sequencesArray.push(parseMacromolecule(fileContent, startOfSequence, match.index));
+    startOfSequence = regex.lastIndex + 1;
   }
-  sequences.push(content.substring(index));
-  const descriptionsCol = DG.Column.fromStrings('description', descriptions);
-  const sequenceCol = DG.Column.fromStrings('sequence', sequences);
+  sequencesArray.push(parseMacromolecule(fileContent, startOfSequence, -1));
+  const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
+  const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
+  sequenceCol.semType = 'Macromolecule';
 
-  const stats: { freq: { [m: string]: number }, sameLength: boolean } = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
+  const stats: SeqColStats = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
   const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
   const alphabetCandidates: [string, Set<string>][] = [
-    ['NT', new Set(Object.keys(Nucleotides.Names)),],
-    ['PT', new Set(Object.keys(Aminoacids.Names)),],
+    ['NT', new Set(Object.keys(Nucleotides.Names))],
+    ['PT', new Set(Object.keys(Aminoacids.Names))],
   ];
   // Calculate likelihoods for alphabet_candidates
   const alphabetCandidatesSim: number[] = alphabetCandidates.map(
@@ -131,10 +183,19 @@ export function importFasta(content: string): DG.DataFrame [] {
   const maxCos = Math.max(...alphabetCandidatesSim);
   const alphabet = maxCos > 0.65 ? alphabetCandidates[alphabetCandidatesSim.indexOf(maxCos)][0] : 'UN';
   sequenceCol.semType = mmSemType;
-  sequenceCol.setTag(DG.TAGS.UNITS, `fasta:${seqType}:${alphabet}`);
+  const units: string = `fasta:${seqType}:${alphabet}`;
+  sequenceCol.setTag(DG.TAGS.UNITS, units);
 
   return [DG.DataFrame.fromColumns([
-    descriptionsCol,
+    descriptionsArrayCol,
     sequenceCol,
   ])];
 }
+
+//name: Bio | Convert
+//friendly-name: Bio | Convert
+//tags: panel, bio
+//input: column col {semType: Macromolecule}
+export function convertPanel(col: DG.Column): void {
+  convert(col);
+}

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

@@ -0,0 +1,49 @@
+import {after, before, category, expect, expectFloat, test} from '@datagrok-libraries/utils/src/test';
+import * as DG from 'datagrok-api/dg';
+import {createTableView, readDataframe} from './utils';
+import {_package} from '../package-test';
+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';
+
+
+category('activityCliffs', async () => {
+  let actCliffsTableView: DG.TableView;
+  let actCliffsDf: DG.DataFrame;
+
+  before(async () => {
+    actCliffsTableView = await createTableView('sample_MSA.csv');
+    actCliffsDf = await readDataframe('sample_MSA.csv');
+  });
+
+  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 scatterPlot = await getActivityCliffs(
+      actCliffsDf,
+      actCliffsDf.col('MSA')!,
+      axesNames,
+      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, '101 cliffs');
+  });
+
+  after(async () => {
+    actCliffsTableView.close();
+  });
+});

package/src/tests/detectors-test.ts

@@ -7,6 +7,8 @@ import * as DG from 'datagrok-api/dg';
 import {mmSemType} from '../const';
 import {importFasta} from '../package';
 
+type DfReaderFunc = () => Promise<DG.DataFrame>;
+
 category('detectors', () => {
   const csvDf1: string = `col1
 1
@@ -87,36 +89,120 @@ YNR-WYV-KHP
 MWRSWY-CKHP
 `;
 
-  test('testDetectorsNegative1', async () => { await _testDetectorsNegative(csvDf1); });
-  test('testDetectorsNegative2', async () => { await _testDetectorsNegative(csvDf2); });
-  test('testDetectorsNegative3', async () => { await _testDetectorsNegative(csvDf3); });
-  test('testDetectorsNegativeSmiles', async () => { await _testDetectorsNegative(csvDfSmiles); });
-
-  test('testDetectorsN1', async () => { await _testDetectorsN1(csvDfN1); });
-  test('testDetectorsAA1', async () => { await _testDetectorsAA1(csvDfAA1); });
-  test('testDetectorsMsaN1', async () => { await _testDetectorsMsaN1(csvDfMsaN1); });
-  test('testDetectorsMsaAA1', async () => { await _testDetectorsMsaAA1(csvDfMsaAA1); });
-
-  test('testDetectorsSepNt', async () => { await _testDetectorsSepNt(csvDfSepNt, '*'); });
-  test('testDetectorsSepPt', async () => { await _testDetectorsSepPt(csvDfSepPt, '-'); });
-  test('testDetectorsSepUn1', async () => { await _testDetectorsSepUn(csvDfSepUn1, '-'); });
-  test('testDetectorsSepUn2', async () => { await _testDetectorsSepUn(csvDfSepUn2, '/'); });
+  const enum Samples {
+    peptidesComplex = 'PeptidesComplex',
+    fastaCsv = 'FastaCsv',
+    msaComplex = 'MsaComplex',
+  }
+
+  const samples: { [key: string]: string } = {
+    'PeptidesComplex': 'System:AppData/Bio/samples/peptides_complex_aligned.csv',
+    'FastaCsv': 'System:AppData/Bio/samples/sample_FASTA.csv',
+    'MsaComplex': 'System:AppData/Bio/samples/sample_MSA.csv',
+  };
+
+  const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
+  const readSamplesCsv: (key: string) => DfReaderFunc = (key: string) => {
+    return async () => {
+      if (!(key in _samplesDfs)) {
+        _samplesDfs[key] = (async (): Promise<DG.DataFrame> => {
+          const csv: string = await grok.dapi.files.readAsText(samples[key]);
+          const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+          await grok.data.detectSemanticTypes(df);
+          return df;
+        })();
+      }
+      return _samplesDfs[key];
+    };
+  };
+
+  const _csvDfs: { [key: string]: Promise<DG.DataFrame> } = {};
+  const readCsv: (key: string, csv: string) => DfReaderFunc = (key: string, csv: string) => {
+    return async () => {
+      if (!(key in _csvDfs)) {
+        _csvDfs[key] = (async (): Promise<DG.DataFrame> => {
+          const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+          await grok.data.detectSemanticTypes(df);
+          return df;
+        })();
+      }
+      return _csvDfs[key];
+    };
+  };
+
+  test('Negative1', async () => { await _testNeg(readCsv('csvDf1', csvDf1), 'col1'); });
+  test('Negative2', async () => { await _testNeg(readCsv('csvDf2', csvDf2), 'col1'); });
+  test('Negative3', async () => { await _testNeg(readCsv('csvDf3', csvDf3), 'col1'); });
+  test('NegativeSmiles', async () => { await _testNeg(readCsv('csvDfSmiles', csvDfSmiles), 'col1'); });
+
+  test('N1', async () => { await _testN1(csvDfN1); });
+  test('AA1', async () => { await _testAA1(csvDfAA1); });
+  test('MsaN1', async () => { await _testMsaN1(csvDfMsaN1); });
+  test('MsaAA1', async () => { await _testMsaAA1(csvDfMsaAA1); });
+
+  test('SepNt', async () => { await _testSepNt(csvDfSepNt, '*'); });
+  test('SepPt', async () => { await _testSepPt(csvDfSepPt, '-'); });
+  test('SepUn1', async () => { await _testSepUn(csvDfSepUn1, '-'); });
+  test('SepUn2', async () => { await _testSepUn(csvDfSepUn2, '/'); });
+
+  test('SepMsaN1', async () => { await _testSepMsaN1(csvDfSepMsaN1); });
+
+  test('SamplesFastaCsvPt', async () => {
+    await _testSamplesFastaCsvPt();
+  });
+  test('SamplesFastaCsvNegativeEntry', async () => {
+    await _testNeg(readSamplesCsv(Samples.fastaCsv), 'Entry');
+  });
+  test('SamplesFastaCsvNegativeLength', async () => {
+    await _testNeg(readSamplesCsv(Samples.fastaCsv), 'Length');
+  });
+  test('SamplesFastaCsvNegativeUniProtKB', async () => {
+    await _testNeg(readSamplesCsv(Samples.fastaCsv), 'UniProtKB');
+  });
+
+  test('SamplesFastaFastaPt', async () => { await _testSamplesFastaFastaPt(); });
+
+  // System:AppData/Bio/samples/peptides_complex_align.csv contains monomers with spaces
+  // test('SamplesPeptidesComplexUn', async () => {
+  //   await _testSamplesPeptidesComplexUn();
+  // });
+
+  test('samplesPeptidesComplexNegativeID', async () => {
+    await _testNeg(readSamplesCsv(Samples.peptidesComplex), 'ID');
+  });
+  test('SamplesPeptidesComplexNegativeMeasured', async () => {
+    await _testNeg(readSamplesCsv(Samples.peptidesComplex), 'Measured');
+  });
+  test('SamplesPeptidesComplexNegativeValue', async () => {
+    await _testNeg(readSamplesCsv(Samples.peptidesComplex), 'Value');
+  });
+
+  test('samplesMsaComplexUn', async () => {
+    await _testPos(readSamplesCsv(Samples.msaComplex), 'MSA', 'separator:SEQ.MSA:UN', '/');
+  });
+  test('samplesMsaComplexNegativeActivity', async () => {
+    await _testNeg(readSamplesCsv(Samples.msaComplex), 'Activity');
+  });
+});
 
-  test('testDetectorsSepMsaN1', async () => { await _testDetectorsSepMsaN1(csvDfSepMsaN1); });
+export async function _testNeg(readDf: DfReaderFunc, colName: string) {
+  const df: DG.DataFrame = await readDf();
 
-  test('testDetectorsSamplesFastaCsvPt', async () => { await _testDetectorsSamplesFastaCsvPt(); });
-  test('testDetectorsSamplesFastaFastaPt', async () => { await _testDetectorsSamplesFastaFastaPt(); });
-});
+  const col: DG.Column = df.col(colName)!;
+  expect(col.semType === mmSemType, false);
+}
 
-export async function _testDetectorsNegative(csvDf: string) {
-  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf);
-  await grok.data.detectSemanticTypes(df);
+export async function _testPos(readDf: DfReaderFunc, colName: string, units: string, separator: string) {
+  const df: DG.DataFrame = await readDf();
 
-  const col1: DG.Column = df.col('col1')!;
-  expect(col1.semType == mmSemType, false);
+  const col: DG.Column = df.col(colName)!;
+  expect(col.semType === mmSemType, true);
+  expect(col.getTag(DG.TAGS.UNITS), units);
+  if (separator)
+    expect(col.getTag('separator'), separator);
 }
 
-export async function _testDetectorsN1(csvDfN1: string) {
+export async function _testN1(csvDfN1: string) {
   const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   await grok.data.detectSemanticTypes(dfN1);
 
@@ -125,7 +211,7 @@ export async function _testDetectorsN1(csvDfN1: string) {
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:NT');
 }
 
-export async function _testDetectorsAA1(csvDfAA1: string) {
+export async function _testAA1(csvDfAA1: string) {
   const dfAA1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfAA1);
   await grok.data.detectSemanticTypes(dfAA1);
 
@@ -134,7 +220,7 @@ export async function _testDetectorsAA1(csvDfAA1: string) {
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
 }
 
-export async function _testDetectorsMsaN1(csvDfMsaN1: string) {
+export async function _testMsaN1(csvDfMsaN1: string) {
   const dfMsaN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfMsaN1);
   await grok.data.detectSemanticTypes(dfMsaN1);
 
@@ -143,7 +229,7 @@ export async function _testDetectorsMsaN1(csvDfMsaN1: string) {
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:NT');
 }
 
-export async function _testDetectorsMsaAA1(csvDfMsaAA1: string) {
+export async function _testMsaAA1(csvDfMsaAA1: string) {
   const dfMsaAA1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfMsaAA1);
   await grok.data.detectSemanticTypes(dfMsaAA1);
 
@@ -152,7 +238,7 @@ export async function _testDetectorsMsaAA1(csvDfMsaAA1: string) {
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
 }
 
-export async function _testDetectorsSepNt(csv: string, separator: string) {
+export async function _testSepNt(csv: string, separator: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   await grok.data.detectSemanticTypes(df);
 
@@ -162,7 +248,7 @@ export async function _testDetectorsSepNt(csv: string, separator: string) {
   expect(col.getTag('separator'), separator);
 }
 
-export async function _testDetectorsSepPt(csv: string, separator: string) {
+export async function _testSepPt(csv: string, separator: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   await grok.data.detectSemanticTypes(df);
 
@@ -172,7 +258,7 @@ export async function _testDetectorsSepPt(csv: string, separator: string) {
   expect(col.getTag('separator'), separator);
 }
 
-export async function _testDetectorsSepUn(csv: string, separator: string) {
+export async function _testSepUn(csv: string, separator: string) {
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   await grok.data.detectSemanticTypes(df);
 
@@ -182,7 +268,7 @@ export async function _testDetectorsSepUn(csv: string, separator: string) {
   expect(col.getTag('separator'), separator);
 }
 
-export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
+export async function _testSepMsaN1(csvDfSepMsaN1: string) {
   const dfSepMsaN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfSepMsaN1);
   await grok.data.detectSemanticTypes(dfSepMsaN1);
 
@@ -191,7 +277,7 @@ export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
   expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ.MSA:NT');
 }
 
-export async function _testDetectorsSamplesFastaCsvPt() {
+export async function _testSamplesFastaCsvPt() {
   const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.csv');
   const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
   await grok.data.detectSemanticTypes(df);
@@ -202,7 +288,7 @@ export async function _testDetectorsSamplesFastaCsvPt() {
   expect(col.getTag('separator'), null);
 }
 
-export async function _testDetectorsSamplesFastaFastaPt() {
+export async function _testSamplesFastaFastaPt() {
   const fasta: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
   const df: DG.DataFrame = importFasta(fasta)[0];
 
@@ -210,4 +296,16 @@ export async function _testDetectorsSamplesFastaFastaPt() {
   expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
   expect(col.getTag('separator'), null);
-}
+}
+
+export async function _testSamplesPeptidesComplexUn() {
+  const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/peptides_complex_aligned.csv');
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('AlignedSequence')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ.MSA:UN');
+  expect(col.getTag('separator'), '-');
+}
+

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

@@ -0,0 +1,26 @@
+import {before, category, test, expect} 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';
+
+category('sequenceSpace', async () => {
+  let testFastaDf: DG.DataFrame;
+
+  before(async () => {
+    testFastaDf = await readDataframe('sample_FASTA.csv');
+  });
+
+
+  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);
+  });
+});

package/src/tests/utils.ts

@@ -1,7 +1,27 @@
 import * as DG from 'datagrok-api/dg';
-
+import * as grok from 'datagrok-api/grok';
 import {expect} from '@datagrok-libraries/utils/src/test';
 import {runKalign} from '../utils/multiple-sequence-alignment';
+import {_package} from '../package-test';
+
+export async function loadFileAsText(name: string): Promise<string> {
+  return await _package.files.readAsText(name);
+}
+
+export async function readDataframe(tableName: string): Promise<DG.DataFrame> {
+  const file = await loadFileAsText(tableName);
+  const df = DG.DataFrame.fromCsv(file);
+  df.name = tableName.replace('.csv', '');
+  return df;
+}
+
+export async function createTableView(tableName: string): Promise<DG.TableView> {
+  const df = await readDataframe(tableName);
+  df.name = tableName.replace('.csv', '');
+  const view = grok.shell.addTableView(df);
+  return view;
+}
+
 
 /**
  * Tests if a table has non zero rows and columns.
@@ -22,5 +42,4 @@ export function _testTableIsNotEmpty(table: DG.DataFrame): void {
 export async function _testMSAIsCorrect(col: DG.Column): Promise<void> {
   const msaCol = await runKalign(col, true);
   expect(msaCol.toList().every((v, i) => (v == col.get(i) || v == null)), true);
-
 }

package/src/utils/convert.ts

@@ -0,0 +1,23 @@
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+export function convert(col: DG.Column): void {
+  const current = col.tags[DG.TAGS.UNITS];
+  //TODO: read all notations
+  const notations = ['fasta:SEQ:NT', 'fasta:SEQ:PT', 'fasta:SEQ.MSA:NT', 'fasta:SEQ.MSA:PT', 'HELM'];
+  const choices = ui.choiceInput('convert to', '', notations.filter((e) => e !== current));
+
+  ui.dialog('Convert sequence')
+    .add(
+      ui.div([
+        ui.h1('current notation'),
+        ui.div(current),
+        choices.root
+      ])
+    )
+    .onOK(() => {
+      //TODO: create new converted column
+      //col.dataFrame.columns.add();
+    })
+    .show();
+}