@datagrok/bio 1.3.1 → 1.4.0

package/src/package.ts

@@ -2,12 +2,18 @@
 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 {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 {Nucleotides} from '@datagrok-libraries/bio/src/nucleotides';
+import {Aminoacids} from '@datagrok-libraries/bio/src/aminoacids';
 
 //name: sequenceAlignment
 //input: string alignType {choices: ['Local alignment', 'Global alignment']}
@@ -38,3 +44,97 @@ 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 smiles { semType: Macromolecule }
+//input: string methodName { choices:["UMAP", "t-SNE", "SPE", "pSPE", "OriginalSPE"] }
+//input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
+//input: bool plotEmbeddings = true
+export async function chemSpaceTopMenu(table: DG.DataFrame, smiles: DG.Column, methodName: string,
+  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean): Promise<void> {
+};
+
+//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;
+    }
+  }
+}
+
+//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(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;
+  }
+  sequences.push(content.substring(index));
+  const descriptionsCol = DG.Column.fromStrings('description', descriptions);
+  const sequenceCol = DG.Column.fromStrings('sequence', sequences);
+
+  const stats: { freq: { [m: string]: number }, sameLength: boolean } = 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;
+  sequenceCol.setTag(DG.TAGS.UNITS, `fasta:${seqType}:${alphabet}`);
+
+  return [DG.DataFrame.fromColumns([
+    descriptionsCol,
+    sequenceCol,
+  ])];
+}

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,24 +4,33 @@ 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 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
@@ -78,36 +87,41 @@ YNR-WYV-KHP
 MWRSWY-CKHP
 `;
 
-  // test('testDetectors1', async () => { await _testDetectors(csvDf1); });
-  // test('testDetectors2', async () => { await _testDetectors(csvDf2); });
-  // test('testDetectors3', async () => { await _testDetectors(csvDf3); });
+  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 _testDetectors(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, null);
-//   expect(col1.getTag(DG.TAGS.UNITS), null);
-// }
+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');
 }
 
@@ -116,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');
 }
 
@@ -125,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');
 }
 
@@ -134,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 _testDetectorsSepPt(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:PT');
+  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 _testDetectorsSepUn(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:UN');
+  expect(col.getTag('separator'), separator);
 }
 
 export async function _testDetectorsSepMsaN1(csvDfSepMsaN1: string) {
@@ -161,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/utils.ts

@@ -0,0 +1,26 @@
+import * as DG from 'datagrok-api/dg';
+
+import {expect} from '@datagrok-libraries/utils/src/test';
+import {runKalign} from '../utils/multiple-sequence-alignment';
+
+/**
+ * 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/multiple-sequence-alignment.ts

@@ -0,0 +1,107 @@
+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');
+}
+
+/**
+ * Converts aligned sequence to semantic type format.
+ *
+ * @param {string} seq Source sequence.
+ * @return {string} Formatted sequence.
+ */
+function _castAligned(seq: string): string {
+  let delimited = '';
+
+  for (const char of seq)
+    delimited += char == '-' ? char : `-${char}`;
+
+  return delimited;
+}
+
+/**
+ * Formats a batch of sequences to correspond the semantic type.
+ *
+ * @param {string[]} alignment List of aligned sequences.
+ * @return {string[]} Formatted sequences.
+ */
+function _stringsToAligned(alignment: string[]): string[] {
+  const nItems = alignment.length;
+  const aligned = new Array<string>(nItems);
+
+  for (let i = 0; i < nItems; ++i)
+    aligned[i] = _castAligned(alignment[i]);
+
+  return aligned;
+}
+
+/**
+ * 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})`, _stringsToAligned(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}'`);
+    }
+  }
+}