@datagrok/bio 1.3.0 → 1.4.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@datagrok/bio",
   "beta": false,
   "friendlyName": "Bio",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Bio is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform",
   "repository": {
     "type": "git",
@@ -10,10 +10,12 @@
     "directory": "packages/Bio"
   },
   "dependencies": {
-    "@datagrok-libraries/bio": "^2.1.1",
+    "@biowasm/aioli": ">=2.4.0",
+    "@datagrok-libraries/bio": "^2.2.0",
     "@datagrok-libraries/utils": "^0.4.2",
+    "@datagrok-libraries/ml": "^2.0.2",
     "cash-dom": "latest",
-    "datagrok-api": "^1.3.5",
+    "datagrok-api": "^1.4.11",
     "dayjs": "latest",
     "ts-loader": "^9.2.5",
     "typescript": "^4.4.2"
@@ -34,7 +36,8 @@
   "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",
@@ -47,7 +50,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/setup.cmd

@@ -0,0 +1,10 @@
+cd ../../js-api
+call npm install
+call npm link
+cd ../libraries/bio
+call npm install
+call npm link
+cd ../../packages/Bio
+call npm install
+call npm link datagrok-api @datagrok-libraries/bio
+webpack

package/src/const.ts

@@ -0,0 +1,5 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+export const mmSemType = 'Macromolecule';

package/src/package-test.ts

@@ -5,8 +5,10 @@ import {runTests, tests} from '@datagrok-libraries/utils/src/test';
 import './tests/WebLogo-test';
 import './tests/Palettes-test';
 import './tests/detectors-test';
+import './tests/msa-tests';
+import './tests/sequence-space-test';
 
-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

@@ -8,6 +8,11 @@ export const _package = new DG.Package();
 
 import {WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
+import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
+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';
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -38,3 +43,114 @@ export function webLogoViewer() {
 export function vdRegionViewer() {
   return new VdRegionsViewer();
 }
+
+//top-menu: Bio | Activity Cliffs...
+//name: Activity Cliffs
+//description: detect activity cliffs
+//input: dataframe df [Input data table]
+//input: column smiles {type:categorical; 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,
+  similarity: number, methodName: string): Promise<void> {
+}
+
+//top-menu: Bio | Sequence Space...
+//name: Sequence Space
+//input: dataframe table
+//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 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]});
+      }
+    } 
+};
+
+//top-menu: Bio | MSA...
+//name: MSA
+//input: dataframe table
+//input: column sequence { semType: Macromolecule }
+export async function multipleSequenceAlignmentAny(table: DG.DataFrame, col: DG.Column): Promise<void> {
+  const msaCol = await runKalign(col, false);
+  table.columns.add(msaCol);
+}
+
+//name: Composition Analysis
+//top-menu: Bio | Composition Analysis
+//output: viewer result
+export async function compositionAnalysis(): Promise<void> {
+  const col = grok.shell.t.columns.bySemType('Macromolecule');//DG.SEMTYPE.MACROMOLECULE);
+  if (col === null) {
+    grok.shell.error('Current table does not contain sequences');
+    return;
+  }
+
+  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) {
+      (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
+//output: list tables
+export function importFasta(fileContent: string): DG.DataFrame [] {
+  const regex = /^>(.*)$/gm; // match the line 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;
+  }
+  sequencesArray.push(parseMacromolecule(fileContent, startOfSequence, -1));
+  const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
+  const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
+  sequenceCol.semType = 'Macromolecule';
+  return [DG.DataFrame.fromColumns([
+    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/WebLogo-test.ts

@@ -52,6 +52,7 @@ XZJ{}2
 `;
 
   // anonymous functions specified in test() registering must return Promise<any>
+  test('testGetStats', async () => { await _testGetStats(csvDfN1); });
   test('testGetAlphabetSimilarity', async () => { await _testGetAlphabetSimilarity(); });
 
   test('testPickupPaletteN1', async () => { await _testPickupPaletteN1(csvDfN1); });
@@ -61,16 +62,18 @@ XZJ{}2
 });
 
 
-export async function _testGetAlphabetFreqs(dfN1: DG.DataFrame) {
+export async function _testGetStats(csvDfN1: string) {
+  const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   const seqCol: DG.Column = dfN1.col('seq')!;
-  const mFreq = WebLogo.getAlphabetFreqs(seqCol);
+  const stats = WebLogo.getStats(seqCol, 5, WebLogo.splitterAsFasta);
 
-  expectObject(mFreq, {
+  expectObject(stats.freq, {
     'A': 4,
     'C': 5,
     'G': 3,
     'T': 6
   });
+  expect(stats.sameLength, true);
 }
 
 export async function _testGetAlphabetSimilarity() {

package/src/tests/detectors-test.ts

@@ -4,7 +4,34 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import {mmSemType} from '../const';
+import {importFasta} from '../package';
+
 category('detectors', () => {
+  const csvDf1: string = `col1
+1
+2
+3`;
+
+  const csvDf2: string = `col1
+4
+5
+6
+7`;
+
+  const csvDf3: string = `col1
+8
+9
+10
+11
+12`;
+
+  const csvDfSmiles: string = `col1
+CCCCN1C(=O)CN=C(c2cc(F)ccc12)C3CCCCC3
+C1CCCCC1
+CCCCCC
+`;
+
   const csvDfN1: string = `seq
 ACGTC
 CAGTGT
@@ -60,23 +87,41 @@ 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('testDetectorsSepUn1', async () => { await _testDetectorsSepUn1(csvDfSepUn1); });
-  test('testDetectorsSepUn2', async () => { await _testDetectorsSepUn2(csvDfSepUn2); });
+  test('testDetectorsSepNt', async () => { await _testDetectorsSepNt(csvDfSepNt, '*'); });
+  test('testDetectorsSepPt', async () => { await _testDetectorsSepPt(csvDfSepPt, '-'); });
+  test('testDetectorsSepUn1', async () => { await _testDetectorsSepUn(csvDfSepUn1, '-'); });
+  test('testDetectorsSepUn2', async () => { await _testDetectorsSepUn(csvDfSepUn2, '/'); });
 
   test('testDetectorsSepMsaN1', async () => { await _testDetectorsSepMsaN1(csvDfSepMsaN1); });
+
+  test('testDetectorsSamplesFastaCsvPt', async () => { await _testDetectorsSamplesFastaCsvPt(); });
+  test('testDetectorsSamplesFastaFastaPt', async () => { await _testDetectorsSamplesFastaFastaPt(); });
 });
 
+export async function _testDetectorsNegative(csvDf: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf);
+  await grok.data.detectSemanticTypes(df);
+
+  const col1: DG.Column = df.col('col1')!;
+  expect(col1.semType == mmSemType, false);
+}
+
 export async function _testDetectorsN1(csvDfN1: string) {
   const dfN1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfN1);
   await grok.data.detectSemanticTypes(dfN1);
 
   const col: DG.Column = dfN1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:NT');
 }
 
@@ -85,7 +130,7 @@ export async function _testDetectorsAA1(csvDfAA1: string) {
   await grok.data.detectSemanticTypes(dfAA1);
 
   const col: DG.Column = dfAA1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
 }
 
@@ -94,7 +139,7 @@ export async function _testDetectorsMsaN1(csvDfMsaN1: string) {
   await grok.data.detectSemanticTypes(dfMsaN1);
 
   const col: DG.Column = dfMsaN1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:NT');
 }
 
@@ -103,26 +148,38 @@ export async function _testDetectorsMsaAA1(csvDfMsaAA1: string) {
   await grok.data.detectSemanticTypes(dfMsaAA1);
 
   const col: DG.Column = dfMsaAA1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ.MSA:PT');
 }
 
-export async function _testDetectorsSepUn1(csvDfSepUn1: string) {
-  const dfSepUn1: DG.DataFrame = DG.DataFrame.fromCsv(csvDfSepUn1);
-  await grok.data.detectSemanticTypes(dfSepUn1);
+export async function _testDetectorsSepNt(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
 
-  const col: DG.Column = dfSepUn1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
-  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:UN');
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:NT');
+  expect(col.getTag('separator'), separator);
 }
 
-export async function _testDetectorsSepUn2(csvDfSepUn2: string) {
-  const dfSepUn2: DG.DataFrame = DG.DataFrame.fromCsv(csvDfSepUn2);
-  await grok.data.detectSemanticTypes(dfSepUn2);
+export async function _testDetectorsSepPt(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
 
-  const col: DG.Column = dfSepUn2.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:PT');
+  expect(col.getTag('separator'), separator);
+}
+
+export async function _testDetectorsSepUn(csv: string, separator: string) {
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  await grok.data.detectSemanticTypes(df);
+
+  const col: DG.Column = df.col('seq')!;
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ:UN');
+  expect(col.getTag('separator'), separator);
 }
 
 export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
@@ -130,6 +187,27 @@ export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
   await grok.data.detectSemanticTypes(dfSepMsaN1);
 
   const col: DG.Column = dfSepMsaN1.col('seq')!;
-  expect(col.semType, 'MACROMOLECULE');
+  expect(col.semType, mmSemType);
   expect(col.getTag(DG.TAGS.UNITS), 'separator:SEQ.MSA:NT');
 }
+
+export async function _testDetectorsSamplesFastaCsvPt() {
+  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);
+
+  const col: DG.Column = df.col('sequence')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+  expect(col.getTag('separator'), null);
+}
+
+export async function _testDetectorsSamplesFastaFastaPt() {
+  const fasta: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/sample_FASTA.fasta');
+  const df: DG.DataFrame = importFasta(fasta)[0];
+
+  const col: DG.Column = df.col('sequence')!;
+  expect(col.semType, mmSemType);
+  expect(col.getTag(DG.TAGS.UNITS), 'fasta:SEQ:PT');
+  expect(col.getTag('separator'), null);
+}

package/src/tests/msa-tests.ts

@@ -0,0 +1,34 @@
+import {category, test} from '@datagrok-libraries/utils/src/test';
+import {
+  _testMSAIsCorrect,
+  _testTableIsNotEmpty,
+} from './utils';
+
+import * as DG from 'datagrok-api/dg';
+//import * as grok from 'datagrok-api/grok';
+
+export const _package = new DG.Package();
+
+
+category('MSA', async () => {
+  //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
+  const fromCsv = `seq
+  FWRWYVKHP
+  YNRWYVKHP
+  MWRSWYCKHP`;
+  const toCsv = `seq
+  -F-W-R--W-Y-V-K-H-P
+  -Y-N-R--W-Y-V-K-H-P
+  -M-W-R-S-W-Y-C-K-H-P`;
+  const table: DG.DataFrame = DG.DataFrame.fromCsv(fromCsv);
+  const toTable: DG.DataFrame = DG.DataFrame.fromCsv(toCsv);
+  const alignedSequencesColumn = toTable.getCol('seq');
+
+  test('test_table.is_not_empty', async () => {
+    await _testTableIsNotEmpty(table);
+  });
+
+  test('is_correct', async () => {
+    await _testMSAIsCorrect(alignedSequencesColumn);
+  });
+});

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

@@ -0,0 +1,24 @@
+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 () => {
+        //@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); 
+    });
+  
+  });

package/src/tests/utils.ts

@@ -0,0 +1,39 @@
+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;
+}
+
+
+/**
+ * Tests if a table has non zero rows and columns.
+ *
+ * @param {DG.DataFrame} table Target table.
+ */
+export function _testTableIsNotEmpty(table: DG.DataFrame): void {
+  expect(table.columns.length > 0 && table.rowCount > 0, true);
+}
+
+
+/**
+ * Tests if MSA works and returns consistent result.
+ *
+ * @export
+ * @param {DG.Column} col Aligned sequences column.
+ */
+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/constants.ts

@@ -0,0 +1,62 @@
+export enum COLUMNS_NAMES {
+  SPLIT_COL = '~split',
+  ACTIVITY = '~activity',
+  ACTIVITY_SCALED = 'activity_scaled',
+  ALIGNED_SEQUENCE = '~aligned_sequence',
+  AMINO_ACID_RESIDUE = 'AAR',
+  POSITION = 'Pos',
+  P_VALUE = 'pValue',
+  MEAN_DIFFERENCE = 'Mean difference',
+}
+
+export enum CATEGORIES {
+  OTHER = 'Other',
+  ALL = 'All',
+}
+
+export enum TAGS {
+  AAR = 'AAR',
+  POSITION = 'Pos',
+  SEPARATOR = 'monomer-separator',
+  SELECTION = 'selection',
+}
+
+export enum SEM_TYPES {
+  AMINO_ACIDS = 'aminoAcids',
+  ALIGNED_SEQUENCE = 'alignedSequence',
+  ALIGNED_SEQUENCE_DIFFERENCE = 'alignedSequenceDifference',
+  ACTIVITY = 'activity',
+  ACTIVITY_SCALED = 'activityScaled',
+  Macro_Molecule = 'Macromolecule',
+}
+
+export const STATS = 'stats';
+
+export const EMBEDDING_STATUS = 'embeddingStatus';
+
+export const PEPTIDES_ANALYSIS = 'isPeptidesAnalysis';
+
+export enum FLAGS {
+  CELL_CHANGING = 'isCellChanging',
+}
+
+export const aarGroups = {
+  'R': 'PC', 'H': 'PC', 'K': 'PC',
+  'D': 'NC', 'E': 'NC',
+  'S': 'U', 'T': 'U', 'N': 'U', 'Q': 'U',
+  'C': 'SC', 'U': 'SC', 'G': 'SC', 'P': 'SC',
+  'A': 'H', 'V': 'H', 'I': 'H', 'L': 'H', 'M': 'H', 'F': 'H', 'Y': 'H', 'W': 'H',
+  '-': '-',
+};
+
+export const groupDescription: {[key: string]: {'description': string, aminoAcids: string[]}} = {
+  'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
+  'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
+  'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
+  'SC': {'description': 'Special Cases', 'aminoAcids': ['C', 'U', 'G', 'P']},
+  'H': {
+    'description': 'Amino Acids with Hydrophobic Side Chain',
+    'aminoAcids': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+  },
+  '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
+};

package/src/utils/convert.ts

@@ -0,0 +1,24 @@
+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();
+}

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

@@ -0,0 +1,76 @@
+import * as DG from 'datagrok-api/dg';
+
+//@ts-ignore
+import Aioli from '@biowasm/aioli';
+
+import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
+import * as C from './constants';
+
+/**
+ * Converts array of sequences into simple fasta string.
+ *
+ * @param {string[]} sequences Input list of sequences.
+ * @return {string} Fasta-formatted string.
+ */
+function _stringsToFasta(sequences: string[]): string {
+  return sequences.reduce((a, v, i) => a + `>sample${i + 1}\n${v}\n`, '');
+}
+
+/**
+ * Extracts array of sequences from simple fasta string.
+ *
+ * @param {string} fasta Fasta-formatted string.
+ * @return {string[]} Output list of sequences.
+ */
+function _fastaToStrings(fasta: string): string[] {
+  return fasta.replace(/>sample\d+(\r\n|\r|\n)/g, '').split('\n');
+}
+
+/**
+ * Runs Aioli environment with kalign tool.
+ *
+ * @param {DG.Column} col Column with sequences.
+ * @param {boolean} isAligned Whether the column is aligned.
+ * @return {Promise<DG.Column>} Aligned sequences.
+ */
+export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.Column> {
+  let sequences = col.toList();
+
+  if (isAligned)
+    sequences = sequences.map((v: string, _) => AlignedSequenceEncoder.clean(v).replace(/\-/g, ''));
+
+  const fasta = _stringsToFasta(sequences);
+  const CLI = await new Aioli({
+    tool: 'kalign',
+    version: '3.3.1',
+    reinit: true,
+  });
+
+  console.log(['fasta.length =', fasta.length]);
+
+  await CLI.fs.writeFile('input.fa', fasta);
+  const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
+  const buf = await CLI.cat('result.fasta');
+
+  console.warn(output);
+
+  const aligned = _fastaToStrings(buf).slice(0, sequences.length);
+  const alignedCol = DG.Column.fromStrings(`msa(${col.name})`, aligned);
+  alignedCol.setTag(DG.TAGS.UNITS, ''); 
+  alignedCol.semType = C.SEM_TYPES.Macro_Molecule;
+  return alignedCol;
+}
+
+export async function testMSAEnoughMemory(col: DG.Column): Promise<void> {
+  const sequencesCount = col.length;
+  const delta = sequencesCount/100;
+
+  for (let i = delta; i < sequencesCount; i += delta) {
+    try {
+      await runKalign(DG.Column.fromStrings(col.name, col.toList().slice(0, Math.round(i))));
+      console.log(`runKalign succeeded on ${i}`);
+    } catch (error) {
+      console.log(`runKalign failed on ${i} with '${error}'`);
+    }
+  }
+}