@datagrok/bio 1.4.2 → 1.5.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.4.2",
+  "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,11 +11,11 @@
   },
   "dependencies": {
     "@biowasm/aioli": ">=2.4.0",
-    "@datagrok-libraries/bio": "^2.2.0",
-    "@datagrok-libraries/utils": "^0.4.2",
-    "@datagrok-libraries/ml": "^2.0.4",
+    "@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"
@@ -41,7 +41,8 @@
     "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",

package/src/package-test.ts

@@ -7,6 +7,7 @@ import './tests/Palettes-test';
 import './tests/detectors-test';
 import './tests/msa-tests';
 import './tests/sequence-space-test';
+import './tests/activity-cliffs-tests';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -2,17 +2,21 @@
 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 {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 {TableView} from 'datagrok-api/dg';
-import { getEmbeddingColsNames, sequenceSpace } from './utils/sequence-space';
-import { AvailableMetrics } from '@datagrok-libraries/ml/src/typed-metrics';
+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']}
@@ -48,12 +52,31 @@ 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...
@@ -64,18 +87,24 @@ export async function activityCliffs(df: DG.DataFrame, smiles: DG.Column, activi
 //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> {
-    const embedColsNames = getEmbeddingColsNames(table);
-    const sequenceSpaceRes = await sequenceSpace(macroMolecule, methodName, similarityMetric, embedColsNames);
-    const embeddings = sequenceSpaceRes.coordinates;
-    for (const col of embeddings)
-      table.columns.add(col);
-    if (plotEmbeddings) {
-      for (let v of grok.shell.views) {
-        if (v.name === table.name)
-          (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1]});
-      }
-    } 
+  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...
@@ -100,7 +129,7 @@ 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;
     }
@@ -122,10 +151,10 @@ function parseMacromolecule(
 //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(fileContent: string): DG.DataFrame [] {
-  const regex = /^>(.*)$/gm; // match the line starting with >
+  const regex = /^>(.*)$/gm; // match lines starting with >
   const descriptionsArray = [];
   const sequencesArray: string[] = [];
   let startOfSequence = 0;
@@ -141,6 +170,22 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
   const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
   const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
   sequenceCol.semType = 'Macromolecule';
+
+  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))],
+  ];
+  // Calculate likelihoods for alphabet_candidates
+  const alphabetCandidatesSim: number[] = alphabetCandidates.map(
+    (c) => WebLogo.getAlphabetSimilarity(stats.freq, c[1]));
+  const maxCos = Math.max(...alphabetCandidatesSim);
+  const alphabet = maxCos > 0.65 ? alphabetCandidates[alphabetCandidatesSim.indexOf(maxCos)][0] : 'UN';
+  sequenceCol.semType = mmSemType;
+  const units: string = `fasta:${seqType}:${alphabet}`;
+  sequenceCol.setTag(DG.TAGS.UNITS, units);
+
   return [DG.DataFrame.fromColumns([
     descriptionsArrayCol,
     sequenceCol,
@@ -153,4 +198,4 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
 //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

@@ -1,24 +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 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;
 
-    let testFastaDf: DG.DataFrame;
-  
-    before(async () => {
-        //@ts-ignore
-        testFastaDf = await readDataframe('sample_FASTA.csv');
-    });
-  
-  
-    test('sequenceSpaceOpens', async () => {
-         //@ts-ignore
-        const res = await sequenceSpace(testFastaDf.col('Sequence')!, 't-SNE', 'Levenshtein', ['Embed_X', 'Embed_Y']);
-        expect(res.coordinates != undefined, true); 
-        expect(res.distance != undefined, true); 
-    });
-  
-  });
+  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,8 +1,8 @@
 import * as DG from 'datagrok-api/dg';
-import * as grok from "datagrok-api/grok";
+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';
+import {_package} from '../package-test';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);
@@ -15,6 +15,13 @@ export async function readDataframe(tableName: string): Promise<DG.DataFrame> {
   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.
@@ -35,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

@@ -2,23 +2,22 @@ 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));
+  const choices = ui.choiceInput('convert to', '', notations.filter((e) => e !== current));
 
   ui.dialog('Convert sequence')
-  .add(
+    .add(
       ui.div([
         ui.h1('current notation'),
         ui.div(current),
         choices.root
       ])
-  )
-  .onOK(() => {
-    //TODO: create new converted column
-    //col.dataFrame.columns.add();
-  })
-  .show();
+    )
+    .onOK(() => {
+      //TODO: create new converted column
+      //col.dataFrame.columns.add();
+    })
+    .show();
 }

package/src/utils/multiple-sequence-alignment.ts

@@ -56,7 +56,7 @@ export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.
 
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
   const alignedCol = DG.Column.fromStrings(`msa(${col.name})`, aligned);
-  alignedCol.setTag(DG.TAGS.UNITS, ''); 
+  alignedCol.setTag(DG.TAGS.UNITS, '');
   alignedCol.semType = C.SEM_TYPES.Macro_Molecule;
   return alignedCol;
 }

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

@@ -0,0 +1,30 @@
+import {IDrawTooltipParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+export async function sequenceGetSimilarities(col: DG.Column, seq: string): Promise<DG.Column | null> {
+  return null;
+}
+
+export function drawTooltip(params: IDrawTooltipParams) {
+  params.tooltips[params.line.id] = ui.divH([]);
+  const columnNames = ui.divV([
+    ui.divText('sequense'),
+    ui.divText(params.activity.name),
+  ]);
+  columnNames.style.fontWeight = 'bold';
+  columnNames.style.display = 'flex';
+  columnNames.style.justifyContent = 'space-between';
+  params.tooltips[params.line.id].append(columnNames);
+  params.line.mols.forEach((mol: number) => {
+    const seq = ui.divText(params.df.get(params.seqCol.name, mol));
+    const activity = ui.divText(params.df.get(params.activity.name, mol).toFixed(2));
+    activity.style.display = 'flex';
+    activity.style.justifyContent = 'left';
+    activity.style.paddingLeft = '30px';
+    params.tooltips[params.line.id].append(ui.divV([
+      seq,
+      activity,
+    ], {style: {paddingLeft: '5px'}}));
+  });
+}