@datagrok/bio 2.4.3 → 2.4.6

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.3",
+  "version": "2.4.6",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -16,12 +16,13 @@
     "@biowasm/aioli": "^3.1.0",
     "@datagrok-libraries/bio": "^5.27.0",
     "@datagrok-libraries/chem-meta": "^1.0.1",
-    "@datagrok-libraries/ml": "^6.3.13",
+    "@datagrok-libraries/ml": "^6.3.16",
     "@datagrok-libraries/utils": "^2.1.3",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
     "datagrok-api": "^1.13.3",
     "dayjs": "^1.11.4",
+    "fastest-levenshtein": "^1.0.16",
     "openchemlib": "6.0.1",
     "rxjs": "^6.5.5",
     "source-map-loader": "^4.0.1",

package/src/demo/bio01-similarity-diversity.ts

@@ -0,0 +1,45 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {_package} from '../package';
+import {delay} from '@datagrok-libraries/utils/src/test';
+import {step} from './utils';
+
+const dataFn = 'data/sample_FASTA_DNA.csv';
+
+export async function demoBio01UI(funcPath: string) {
+  let view: DG.TableView;
+  let df: DG.DataFrame;
+
+  try {
+    await step(`Loading DNA notation 'fasta'.`, async () => {
+      df = await _package.files.readCsv(dataFn);
+      view = grok.shell.addTableView(df);
+      view.path = view.basePath = funcPath;
+    })();
+
+    await step('Sequence similarity search.', async () => {
+      const simViewer = await df.plot.fromType('Sequence Similarity Search') as DG.Viewer;
+      view.dockManager.dock(simViewer, DG.DOCK_TYPE.RIGHT, null, 'Similarity search', 0.35);
+    })();
+
+    await step('Sequence diversity search.', async () => {
+      const divViewer = await df.plot.fromType('Sequence Diversity Search') as DG.Viewer;
+      view.dockManager.dock(divViewer, DG.DOCK_TYPE.DOWN, null, 'Diversity search', 0.27);
+    })();
+
+    await step('Current row 3.', async () => {
+      df.currentRowIdx = 3;
+    })();
+
+    await step('Current row  7', async () => {
+      df.currentRowIdx = 7;
+    });
+  } catch (err: any) {
+    if (err instanceof Error)
+      _package.logger.error(err.message, undefined, err.stack);
+    else
+      _package.logger.error(err.toString());
+  }
+}

package/src/demo/bio01a-hierarchical-clustering-and-sequence-space.ts

@@ -0,0 +1,68 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {_package} from '../package';
+
+import * as lev from 'fastest-levenshtein';
+import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
+import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
+import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
+import {demoSequenceSpace, step} from './utils';
+
+const dataFn = 'data/sample_FASTA_DNA.csv';
+const seqColName = 'sequence';
+
+export async function demoBio01aUI(funcPath: string) {
+  let treeHelper: ITreeHelper;
+  let dendrogramSvc: IDendrogramService;
+  let view: DG.TableView;
+  let df: DG.DataFrame;
+  let spViewer: DG.ScatterPlotViewer;
+
+  const method: string = 'UMAP';
+  const idRows: { [id: number]: number } = {};
+  const embedCols: { [colName: string]: DG.Column<number> } = {};
+
+  try {
+    await step(`Loading DNA notation 'fasta'.`, async () => {
+      [df, treeHelper, dendrogramSvc] = await Promise.all([
+        _package.files.readCsv(dataFn),
+        getTreeHelper(),
+        getDendrogramService()
+      ]);
+      view = grok.shell.addTableView(df);
+      view.grid.props.rowHeight = 22;
+      view.path = view.basePath = funcPath;
+    })();
+
+    await step('Building sequence space.', async () => {
+      spViewer = await demoSequenceSpace(view, df, seqColName, method);
+    })();
+
+    await step('Hierarchical clustering.', async () => {
+      const seqCol: DG.Column<string> = df.getCol(seqColName);
+      const seqList = seqCol.toList();
+      const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
+        const levDistance = lev.distance(aSeq, bSeq);
+        return levDistance / ((aSeq.length + bSeq.length) / 2);
+      });
+      const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
+      dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
+    })();
+
+    await step('Selection.', async () => {
+      df.selection.init((idx: number) => [15].includes(idx));
+    })();
+
+    await step('Select bunch of sequences.', async () => {
+      df.selection.init((idx: number) => [21, 9, 58].includes(idx));
+      df.currentRowIdx = 27;
+    })();
+  } catch (err: any) {
+    if (err instanceof Error)
+      _package.logger.error(err.message, undefined, err.stack);
+    else
+      _package.logger.error(err.toString());
+  }
+}

package/src/demo/bio01b-hierarchical-clustering-and-activity-cliffs.ts

@@ -0,0 +1,94 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {_package, activityCliffs,} from '../package';
+import $ from 'cash-dom';
+
+import {TEMPS as acTEMPS} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import * as lev from 'fastest-levenshtein';
+import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
+import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
+import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
+import {step} from './utils';
+
+const dataFn = 'samples/sample_FASTA.csv';
+
+export async function demoBio01bUI(funcPath: string) {
+  let treeHelper: ITreeHelper;
+  let dendrogramSvc: IDendrogramService;
+  let view: DG.TableView;
+  let df: DG.DataFrame;
+  let activityCliffsViewer: DG.ScatterPlotViewer;
+
+  const method: string = 'UMAP';
+  const idRows: { [id: number]: number } = {};
+
+  try {
+    await step('Loading DNA notation \'fasta\'.', async () => {
+      [df, treeHelper, dendrogramSvc] = await Promise.all([
+        _package.files.readCsv(dataFn),
+        getTreeHelper(),
+        getDendrogramService()
+      ]);
+
+      view = grok.shell.addTableView(df);
+      view.path = view.basePath = funcPath;
+      view.grid.props.rowHeight = 22;
+      const uniProtKbGCol = view.grid.columns.byName('UniProtKB')!;
+      uniProtKbGCol.width = 75;
+      const lengthGCol = view.grid.columns.byName('Length')!;
+      lengthGCol.width = 0;
+    })();
+
+    await step('Analyze for activity cliffs.', async () => {
+      activityCliffsViewer = (await activityCliffs(
+        df, df.getCol('Sequence'), df.getCol('Activity'),
+        80, method)) as DG.ScatterPlotViewer;
+      view.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.35);
+
+      // Show grid viewer with the cliffs
+      const cliffsLink: HTMLButtonElement = $(activityCliffsViewer.root)
+        .find('button.scatter_plot_link,cliffs_grid').get()[0] as HTMLButtonElement;
+      cliffsLink.click();
+    })();
+
+    await step('Hierarchical clustering.', async () => {
+      const seqCol: DG.Column<string> = df.getCol('sequence');
+      const seqList = seqCol.toList();
+      const distance: DistanceMatrix = DistanceMatrix.calc(seqList, (aSeq: string, bSeq: string) => {
+        const levDistance = lev.distance(aSeq, bSeq);
+        return levDistance / ((aSeq.length + bSeq.length) / 2);
+      });
+      const treeRoot = await treeHelper.hierarchicalClusteringByDistance(distance, 'ward');
+      dendrogramSvc.injectTreeForGrid(view.grid, treeRoot, undefined, 150, undefined);
+
+      // adjust for visual
+      const activityGCol = view.grid.columns.byName('Activity')!;
+      activityGCol.scrollIntoView();
+    })();
+
+    await step('Browse the cliff.', async () => {
+      //cliffsDfGrid.dataFrame.currentRowIdx = -1; // reset
+      const cliffsDfGrid: DG.Grid = activityCliffsViewer.dataFrame.temp[acTEMPS.cliffsDfGrid];
+      //cliffsDfGrid.dataFrame.selection.init((i) => i == currentCliffIdx);
+      cliffsDfGrid.dataFrame.currentRowIdx = 0;
+      //cliffsDfGrid.dataFrame.selection.set(currentCliffIdx, true, true);
+
+      // /* workaround to select rows of the cliff */
+      // const entryCol: DG.Column = df.getCol('Entry');
+      // df.selection.init((rowIdx) => ['UPI00000BFE1D', 'UPI00000BFE17'].includes(entryCol.get(rowIdx)));
+      //
+      // const selectionIdxList: Int32Array = df.selection.getSelectedIndexes();
+      // if (selectionIdxList.length > 0) {
+      //   df.currentRowIdx = selectionIdxList[0];
+      //   view.grid.scrollToCell('UniProtKB', view.grid.tableRowToGrid(selectionIdxList[0]));
+      // }
+    })();
+  } catch (err: any) {
+    if (err instanceof Error)
+      _package.logger.error(err.message, undefined, err.stack);
+    else
+      _package.logger.error(err.toString());
+  }
+}

package/src/demo/bio05-helm-msa-sequence-space.ts

@@ -0,0 +1,59 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {_package, sequenceSpaceTopMenu} from '../package';
+import {step} from './utils';
+
+import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {pepseaMethods, runPepsea} from '../utils/pepsea';
+import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
+
+const helmFn: string = 'samples/sample_HELM.csv';
+
+export async function demoBio05UI(funcPath: string): Promise<void> {
+  let view: DG.TableView;
+  let df: DG.DataFrame;
+  let helmCol: DG.Column<string>;
+  let msaHelmCol: DG.Column<string>;
+  let wlViewer: DG.Viewer & IWebLogoViewer;
+  let ssViewer: DG.ScatterPlotViewer;
+
+  const helmColName: string = 'HELM';
+  const msaHelmColName: string = 'msa(HELM)';
+
+  try {
+    await step(`Loading peptides notation 'HELM'.`, async () => {
+      view = grok.shell.addTableView(df = await _package.files.readCsv(helmFn));
+      view.path = view.basePath = funcPath;
+    })();
+
+    await step('MSA on non-natural aminoacids with PepSeA.', async () => {
+      helmCol = df.getCol(helmColName);
+      const method: string = pepseaMethods[0];
+      const gapOpen: number = 1.53;
+      const gapExtend: number = 0;
+      msaHelmCol = await runPepsea(helmCol, msaHelmColName, method, gapOpen, gapExtend, undefined);
+      df.columns.add(msaHelmCol);
+    })();
+
+    await step('Composition analysis on MSA results', async () => {
+      wlViewer = await df.plot.fromType('WebLogo', {
+        sequenceColumnName: msaHelmColName
+      }) as DG.Viewer & IWebLogoViewer;
+      view.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.2);
+    })();
+
+    await step('Building sequence space.', async () => {
+      const method: string = 'UMAP';
+      ssViewer = (await sequenceSpaceTopMenu(df, msaHelmCol,
+        'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
+      view.dockManager.dock(ssViewer, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
+    })();
+  } catch (err: any) {
+    if (err instanceof Error)
+      _package.logger.error(err.message, undefined, err.stack);
+    else
+      _package.logger.error(err.toString());
+  }
+}

package/src/demo/utils.ts

@@ -0,0 +1,95 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {_package, sequenceSpaceTopMenu} from '../package';
+import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/sequence-space';
+import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
+import {delay} from '@datagrok-libraries/utils/src/test';
+
+export function step(message: string, action: () => Promise<void>, delayMs: number = 1600): () => Promise<void> {
+  return async function() {
+    grok.shell.info(message);
+    const pi = DG.TaskBarProgressIndicator.create(message);
+    try {
+      await action();
+    } finally {
+      pi.close();
+      await delay(delayMs);
+    }
+  };
+}
+
+enum EMBED_COL_NAMES {
+  X = 'Embed_X',
+  Y = 'Embed_Y'
+}
+
+export async function demoSequenceSpace(
+  view: DG.TableView, df: DG.DataFrame, colName: string, method: string
+): Promise<DG.ScatterPlotViewer> {
+  let resSpaceViewer: DG.ScatterPlotViewer;
+  if (true) {
+    // Custom sequence space implementation for closer resembling of hierarchical clustering results.
+    const embedColNameList = Object.values(EMBED_COL_NAMES);
+    // ensure embed columns exist
+    for (let embedI: number = 0; embedI < embedColNameList.length; embedI++) {
+      const embedColName: string = embedColNameList[embedI];
+      const embedCol: DG.Column | null = df.col(embedColName);
+      if (!embedCol) {
+        // Notification is required to reflect added data frame Embed_<X> columns to grid columns
+        // MolecularLiabilityBrowser.setView() corrects grid columns' names with .replace('_', ' ');
+        const notify: boolean = embedI == embedColNameList.length - 1; // notify on adding last Embed_<X> column
+        df.columns.add(DG.Column.float(embedColName, df.rowCount), notify);
+      }
+    }
+
+    if (df.rowCount >= 1) {
+      const seqCol: DG.Column<string> = df.getCol(colName);
+      const seqList = seqCol.toList();
+
+      const t1: number = Date.now();
+      _package.logger.debug('Bio: demoBio01aUI(), calc reduceDimensionality start...');
+      const redDimRes = await reduceDimensinalityWithNormalization( // TODO: Rename method typo
+        seqList, method, StringMetricsNames.Levenshtein, {});
+      const t2: number = Date.now();
+      _package.logger.debug('Bio: demoBio01aUI(), calc reduceDimensionality ' +
+        `ET: ${((t2 - t1) / 1000)} s`);
+
+      for (let embedI: number = 0; embedI < embedColNameList.length; embedI++) {
+        const embedColName: string = embedColNameList[embedI];
+        const embedCol: DG.Column = df.getCol(embedColName);
+        const embedColData: Float32Array = redDimRes.embedding[embedI];
+        // TODO: User DG.Column.setRawData()
+        // embedCol.setRawData(embedColData);
+        embedCol.init((rowI) => { return embedColData[rowI]; });
+      }
+
+      const rowCount: number = df.rowCount;
+      const idCol: DG.Column = df.getCol('id');
+      for (let idRowI = 0; idRowI < rowCount; idRowI++) {
+        const id = idCol.get(idRowI);
+        //idRows[id] = idRowI;
+      }
+
+      for (const embedColName of Object.values(EMBED_COL_NAMES)) {
+        const embedCol: DG.Column<number> = df.getCol(embedColName);
+        //embedCols[embedColName] = embedCol;
+      }
+
+      const t3: number = Date.now();
+      _package.logger.debug('MLB: MlbVrSpaceBrowser.buildView(), postprocess reduceDimensionality ' +
+        `ET: ${((t3 - t2) / 1000)} s`);
+    }
+    resSpaceViewer = (await df.plot.fromType(DG.VIEWER.SCATTER_PLOT, {
+      'xColumnName': EMBED_COL_NAMES.X,
+      'yColumnName': EMBED_COL_NAMES.Y,
+      'lassoTool': true,
+    })) as DG.ScatterPlotViewer;
+  } else {
+    resSpaceViewer = (await sequenceSpaceTopMenu(df, df.getCol(colName),
+      'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
+  }
+  view.dockManager.dock(resSpaceViewer!, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
+  return resSpaceViewer;
+}

package/src/package.ts

@@ -48,6 +48,10 @@ import {getMacromoleculeColumn} from './utils/ui-utils';
 import {IUMAPOptions, ITSNEOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
 import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
+import {demoBio01UI} from './demo/bio01-similarity-diversity';
+import {demoBio01aUI} from './demo/bio01a-hierarchical-clustering-and-sequence-space';
+import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-cliffs';
+import {demoBio05UI} from './demo/bio05-helm-msa-sequence-space';
 
 // /** Avoid reassinging {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
 // let monomerLib: MonomerLib | null = null;
@@ -303,7 +307,7 @@ export function SeqActivityCliffsEditor(call: DG.FuncCall) {
     .show();
 }
 
-//top-menu: Bio | Sequence Activity Cliffs...
+//top-menu: Bio | SAR | Activity Cliffs...
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe table [Input data table]
@@ -360,7 +364,7 @@ export function SequenceSpaceEditor(call: DG.FuncCall) {
     .show();
 }
 
-//top-menu: Bio | Sequence Space...
+//top-menu: Bio | Structure | Sequence Space...
 //name: Sequence Space
 //input: dataframe table
 //input: column molecules { semType: Macromolecule }
@@ -370,7 +374,8 @@ export function SequenceSpaceEditor(call: DG.FuncCall) {
 //input: object options {optional: true}
 //editor: Bio:SequenceSpaceEditor
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
-  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions): Promise<DG.Viewer | undefined> {
+  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions
+): Promise<DG.Viewer | undefined> {
   // Delay is required for initial function dialog to close before starting invalidating of molfiles.
   // Otherwise, dialog is freezing
   await delay(10);
@@ -430,7 +435,7 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   } */
 };
 
-//top-menu: Bio | To Atomic Level...
+//top-menu: Bio | Atomic Level | To Atomic Level...
 //name: To Atomic Level
 //description: returns molfiles for each monomer from HELM library
 //input: dataframe df [Input data table]
@@ -447,7 +452,7 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
   await _toAtomicLevel(df, macroMolecule, monomersLibObject);
 }
 
-//top-menu: Bio | MSA...
+//top-menu: Bio | Alignment | MSA...
 //name: MSA...
 //tags: bio, panel
 export function multipleSequenceAlignmentAny(col: DG.Column<string> | null = null): void {
@@ -515,8 +520,8 @@ export function multipleSequenceAlignmentAny(col: DG.Column<string> | null = nul
     .show();
 }
 
+//top-menu: Bio | Structure | Composition Analysis
 //name: Composition Analysis
-//top-menu: Bio | Composition Analysis
 //meta.icon: files/icons/composition-analysis.svg
 //output: viewer result
 export async function compositionAnalysis(): Promise<void> {
@@ -574,8 +579,8 @@ export async function compositionAnalysis(): Promise<void> {
   await handler(col);
 }
 
-//top-menu: Bio | SDF to JSON lib...
-//name: SDF to JSON Lib
+//top-menu: Bio | Atomic Level | SDF to JSON Library...
+//name: SDF to JSON Library
 //input: dataframe table
 export async function sdfToJsonLib(table: DG.DataFrame) {
   const jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
@@ -728,7 +733,7 @@ export function diversitySearchTopMenu() {
   view.dockManager.dock(viewer, 'down');
 }
 
-//top-menu: Bio | Substructure Search ...
+//top-menu: Bio | Structure | Substructure Search ...
 //name: bioSubstructureSearch
 export function bioSubstructureSearch(): void {
   const col = getMacromoleculeColumn();
@@ -750,3 +755,33 @@ export function saveAsFasta() {
 export function bioSubstructureFilter(): BioSubstructureFilter {
   return new BioSubstructureFilter();
 }
+
+// -- Demo --
+
+//name: demoBio01
+//meta.demoPath: Bioinformatics | Similarity & Diversity
+//description:
+export async function demoBio01(): Promise<void> {
+  await demoBio01UI('func/Bio.demoBio01');
+}
+
+//name:demoBio01a
+//meta.demoPath: Bioinformatics | Hierarchical Clustering & Sequence Space
+//description:
+export async function demoBio01a(): Promise<void> {
+  await demoBio01aUI('func/Bio.demoBio01a');
+}
+
+//name: demoBio01c
+//meta.demoPath: Bioinformatics | Hierarchical Clustering & Activity Cliffs
+//description:
+export async function demoBio01b(): Promise<void> {
+  await demoBio01bUI('func/Bio.demoBio01b');
+}
+
+//name: demoBio05
+//meta.demoPath: Bioinformatics | Helm, MSA, Sequence Space
+//description:
+export async function demoBio05(): Promise<void> {
+  await demoBio05UI('func/demoBio05');
+}

package/src/tests/detectors-weak-and-likely-tests.ts

@@ -19,8 +19,10 @@ category('detectors:weak-and-likely', () => {
     fastaPtWeak1 = 'fastaPtWeak1',
     fastaPtWeak1LikelyName = 'fastaPtWeak1LikelyName',
 
+    /* Notation 'fasta' alphabet 'UN' is forbidden for likely columns too. */
     fastaUn1 = 'fastaUn1',
     fastaUn1LikelyName = 'fastaUn1LikelyName',
+    fastaUn2LikelyName = 'fastaUn2LikelyName',
     fastaUnMsa1LikelyName = 'fastaUnMsa1LikelyName',
   }
 
@@ -72,6 +74,11 @@ category('detectors:weak-and-likely', () => {
 2,other
 3,some
 4,another
+`,
+    [csvTests.fastaUn2LikelyName]: `protein
+Boombastic
+Megafantastic
+"just-a-random-thought,oy!"
 `,
     [csvTests.fastaUnMsa1LikelyName]: `id,seq
 1,word
@@ -119,11 +126,12 @@ category('detectors:weak-and-likely', () => {
     await _testNeg(readCsv(csvTests.fastaUn1), 'colName');
   });
   test(csvTests.fastaUn1LikelyName, async () => {
-    await _testPos(readCsv(csvTests.fastaUn1LikelyName), 'seq',
-      NOTATION.FASTA, ALIGNMENT.SEQ, ALPHABET.UN, 11, false);
+    await _testNeg(readCsv(csvTests.fastaUn1LikelyName), 'seq');
+  });
+  test(csvTests.fastaUn2LikelyName, async () => {
+    await _testNeg(readCsv(csvTests.fastaUn2LikelyName), 'protein');
   });
   test(csvTests.fastaUnMsa1LikelyName, async () => {
-    await _testPos(readCsv(csvTests.fastaUnMsa1LikelyName), 'seq',
-      NOTATION.FASTA, ALIGNMENT.SEQ_MSA, ALPHABET.UN, 10, false);
+    await _testNeg(readCsv(csvTests.fastaUnMsa1LikelyName), 'seq');
   });
 });

package/src/tests/similarity-diversity-tests.ts

@@ -73,6 +73,7 @@ async function _testDiversitySearchViewer() {
 }
 
 function getSearchViewer(viewer: DG.Viewer, name: string) {
+  //@ts-ignore
   for (const v of viewer.view.viewers) {
     if (v.type === name)
       return v;

package/src/utils/pepsea.ts

@@ -6,18 +6,21 @@ import * as C from './constants';
 
 export const pepseaMethods = ['mafft --auto', 'mafft', 'linsi', 'ginsi', 'einsi', 'fftns', 'fftnsi', 'nwns', 'nwnsi'];
 const alignmentObjectMetaKeys = ['AlignedSeq', 'AlignedSubpeptide', 'HELM', 'ID', 'PolymerID'];
-type PepseaRepsonse = {
+type PepseaResponse = {
   Alignment: {
     PolymerID: string, AlignedSubpeptide: string, HELM: string, ID: string, AlignedSeq: string, [key: string]: string,
   }[],
-  AlignmentScore: {[key: string]: number | null},
+  AlignmentScore: { [key: string]: number | null },
 };
-type PepseaBodyUnit = {ID: string, HELM: string};
+type PepseaBodyUnit = { ID: string, HELM: string };
 
+/** Gets the column containing MSA sequences produced by the 'PepSeA' tool from the {@link srcCol} column.
+ * Does not add the result column to the dataframe of {@link srcCol}.
+ */
 export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   method: typeof pepseaMethods[number] = 'ginsi', gapOpen: number = 1.53, gapExtend: number = 0.0,
   clustersCol: DG.Column<string | number> | null = null,
-  ): Promise<DG.Column<string>> {
+): Promise<DG.Column<string>> {
   const peptideCount = srcCol.length;
   clustersCol ??= DG.Column.int('Clusters', peptideCount).init(0);
   if (clustersCol.type != DG.COLUMN_TYPE.STRING)
@@ -58,13 +61,14 @@ export async function runPepsea(srcCol: DG.Column<string>, unUsedName: string,
   alignedSequencesCol.setTag(bioTAGS.separator, C.PEPSEA.SEPARATOR);
   alignedSequencesCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
   alignedSequencesCol.setTag(bioTAGS.alphabet, ALPHABET.UN);
+  alignedSequencesCol.setTag(bioTAGS.alphabetIsMultichar, 'true');
   alignedSequencesCol.semType = DG.SEMTYPE.MACROMOLECULE;
 
   return alignedSequencesCol;
 }
 
 async function requestAlignedObjects(dockerfileId: string, body: PepseaBodyUnit[], method: string, gapOpen: number,
-  gapExtend: number): Promise<PepseaRepsonse> {
+  gapExtend: number): Promise<PepseaResponse> {
   const params = {
     method: 'POST',
     headers: {'Accept': 'application/json', 'Content-Type': 'application/json'},