@datagrok/peptides 1.4.0 → 1.7.1

package/src/package-test.ts

@@ -3,6 +3,8 @@ import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
 
 import './tests/core';
 import './tests/peptide-space-test';
+import './tests/algorithms';
+import './tests/viewers';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -2,28 +2,31 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as C from './utils/constants';
 
 import {analyzePeptidesUI} from './widgets/peptides';
 import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
-import {MutationCliffsViewer, MostPotentResiduesViewer} from './viewers/sar-viewer';
+import {MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
 
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
 import {LogoSummary} from './viewers/logo-summary';
-import {MonomerWorks} from '@datagrok-libraries/bio';
+import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {PeptidesModel} from './model';
 
-export let monomerWorks: MonomerWorks | null;
+let monomerWorks: MonomerWorks | null = null;
 
 export const _package = new DG.Package();
-let currentTable: DG.DataFrame;
-let alignedSequenceColumn: DG.Column;
 
-export function getMonomerWorks() {
+export function getMonomerWorks(): MonomerWorks | null {
   return monomerWorks;
-};
+}
+
+//tags: init
+export async function initPeptides(): Promise<void> {
+  monomerWorks ??= new MonomerWorks(await grok.functions.call('Bio:getBioLib'));
+}
 
-async function main(chosenFile: string): Promise<void> {
+async function openDemoData(chosenFile: string): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('Loading Peptides');
   const path = _package.webRoot + 'files/' + chosenFile;
   const peptides = await grok.data.loadTable(path);
@@ -37,13 +40,10 @@ async function main(chosenFile: string): Promise<void> {
 
 //name: Peptides
 //tags: app
-export async function Peptides(): Promise<void> {
+export function Peptides(): void {
   const wikiLink = ui.link('wiki', 'https://github.com/datagrok-ai/public/blob/master/help/domains/bio/peptides.md');
   const textLink = ui.inlineText(['For more details, see our ', wikiLink, '.']);
-  if (monomerWorks == null) {
-    let lib = await grok.functions.call('Bio:getBioLib');
-    monomerWorks = new MonomerWorks(lib);
-  }
+
   const appDescription = ui.info(
     [
       ui.list([
@@ -73,19 +73,22 @@ export async function Peptides(): Promise<void> {
     appDescription,
     ui.info([textLink]),
     ui.divH([
-      ui.button('Simple demo', () => main('aligned.csv'), ''),
-      ui.button('Complex demo', () => main('aligned_2.csv'), ''),
-      ui.button('HELM demo', () => main('aligned_3.csv'), ''),
+      ui.button('Simple demo', () => openDemoData('aligned.csv'), ''),
+      ui.button('Complex demo', () => openDemoData('aligned_2.csv'), ''),
+      ui.button('HELM demo', () => openDemoData('aligned_3.csv'), ''),
     ]),
   ]);
 }
 
 //top-menu: Bio | Peptides...
 //name: Bio Peptides
-export async function peptidesDialog(): Promise<DG.Dialog> {
-  const analyzeObject = await analyzePeptidesUI(grok.shell.t);
-  const dialog = ui.dialog('Analyze Peptides').add(analyzeObject.host).onOK(analyzeObject.callback);
-  dialog.show();
+export function peptidesDialog(): DG.Dialog {
+  const analyzeObject = analyzePeptidesUI(grok.shell.t);
+  const dialog = ui.dialog('Analyze Peptides').add(analyzeObject.host).onOK(async () => {
+    const startSuccess = analyzeObject.callback();
+    if (!startSuccess)
+      dialog.show();
+  });
   return dialog.show();
 }
 
@@ -93,9 +96,8 @@ export async function peptidesDialog(): Promise<DG.Dialog> {
 //tags: panel, widgets
 //input: column col {semType: Macromolecule}
 //output: widget result
-export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
-  [currentTable, alignedSequenceColumn] = getOrDefine(col.dataFrame, col);
-  const analyzeObject = await analyzePeptidesUI(currentTable, alignedSequenceColumn);
+export function peptidesPanel(col: DG.Column): DG.Widget {
+  const analyzeObject = analyzePeptidesUI(col.dataFrame, col);
   return new DG.Widget(analyzeObject.host);
 }
 
@@ -103,8 +105,8 @@ export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
 //description: Peptides SAR Viewer
 //tags: viewer
 //output: viewer result
-export function sar(): MutationCliffsViewer {
-  return new MutationCliffsViewer();
+export function sar(): MonomerPosition {
+  return new MonomerPosition();
 }
 
 //name: peptide-sar-viewer-vertical
@@ -135,9 +137,14 @@ export function peptideSpace(): PeptideSpaceViewer {
 //input: string _monomer {semType: Monomer}
 //output: widget result
 export function manualAlignment(_monomer: string): DG.Widget {
-  [currentTable, alignedSequenceColumn] = getOrDefine();
   //TODO: recalculate Molfile and Molecule panels on sequence update
-  return manualAlignmentWidget(alignedSequenceColumn, currentTable);
+  const df = grok.shell.t;
+  const model: PeptidesModel | null = df?.temp[PeptidesModel.modelName];
+  if (!model)
+    return new DG.Widget(ui.divText('Manual alignment works with peptides analysis'));
+
+  const col = df.getCol(model.settings.sequenceColumnName!);
+  return manualAlignmentWidget(col, df);
 }
 
 //name: Peptide Space
@@ -145,39 +152,6 @@ export function manualAlignment(_monomer: string): DG.Widget {
 //input: column col {semType: Macromolecule}
 //output: widget result
 export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
-  [currentTable, alignedSequenceColumn] = getOrDefine(col.dataFrame, col);
   const widget = new PeptideSimilaritySpaceWidget(col, grok.shell.v as DG.TableView);
   return widget.draw();
 }
-
-//name: Get Peptides Structure
-//tags: panel, widgets
-//input: column col {semType: Macromolecule}
-//output: widget result
-export function getPeptidesStructure(col: DG.Column): DG.Widget {
-  const getButtonTooltip = 'Retrieves peptides structure from customer database by special id column';
-  const getButton = ui.button('Get structure', async () => {
-    const progress = DG.TaskBarProgressIndicator.create('Getting structure...');
-    try {
-      const params = {peptidesTable: col.dataFrame};
-      const result = await grok.functions.call('Customerextensions:getPeptidesStructure', params);
-      const text = result ? 'Structure retreived' : 'Structure retreivial is not possible';
-      grok.shell.info(text);
-    } catch (e) {
-      console.warn(e);
-    } finally {
-      progress.close();
-    }
-  }, getButtonTooltip);
-  return new DG.Widget(getButton);
-}
-
-function getOrDefine(dataframe?: DG.DataFrame, column?: DG.Column | null): [DG.DataFrame, DG.Column] {
-  dataframe ??= grok.shell.t;
-  // column ??= dataframe.columns.bySemType(C.SEM_TYPES.MACROMOLECULE);
-  column ??= dataframe.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
-  if (column === null)
-    throw new Error('Table does not contain aligned sequence columns');
-
-  return [dataframe, column];
-}

package/src/styles.css

@@ -52,4 +52,11 @@
   color: #4D5261;
   text-align: center;
   width: 100%;
+  align-self: end;
+}
+
+.pep-help-icon {
+  position: absolute;
+  left: 5px;
+  top: 1px;
 }

package/src/tests/algorithms.ts

@@ -1,29 +1,27 @@
-import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, expect, delay, before} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 
 import {_package} from '../package-test';
-import {startAnalysis} from '../widgets/peptides';
-import {PeptidesModel} from '../model';
-import * as C from '../utils/constants';
-import {scaleActivity} from '../utils/misc';
-import {ALPHABET, TAGS, NOTATION, ALIGNMENT} from '@datagrok-libraries/bio';
 import {findMutations} from '../utils/algorithms';
 import * as type from '../utils/types';
 
 category('Algorithms', () => {
-  let activityCol: DG.Column<number>;
-  let monomerColumns: DG.Column<string>[];
+  let activityCol: type.RawData;
+  let monomerColumns: type.RawColumn[];
   let settings: type.PeptidesSettings;
 
   before(async () => {
-    activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]);
+    activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]).getRawData();
     monomerColumns = [
-      DG.Column.fromList('string', '1', 'ABC'.split('')),
-      DG.Column.fromList('string', '2', 'ACC'.split('')),
-      DG.Column.fromList('string', '3', 'ACD'.split('')),
-    ];
+      DG.Column.fromList('string', '1', 'AAA'.split('')),
+      DG.Column.fromList('string', '2', 'BCC'.split('')),
+      DG.Column.fromList('string', '3', 'CCD'.split('')),
+    ].map((col) => ({
+      name: col.name,
+      rawData: col.getRawData(),
+      cat: col.categories,
+    }));
     settings = {maxMutations: 1, minActivityDelta: 2};
   });
 
@@ -40,12 +38,23 @@ category('Algorithms', () => {
 
     const c3 = c.get('3')!;
     const d3 = d.get('3')!;
-    expect(c3.has(2), true);
-    expect(d3.has(3), true);
+    expect(c3.has(1), true);
+    expect(d3.has(2), true);
 
-    const c32 = c3.get(2)!;
-    const d33 = d3.get(3)!;
-    expect(c32[0], 3);
-    expect(d33[0], 2);
+    const c31 = c3.get(1)!;
+    const d32 = d3.get(2)!;
+    expect(c31[0], 2);
+    expect(d32[0], 1);
   });
+
+  test('MutationCliffs - Benchmark 5k', async () => {
+    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
+    const activityCol: type.RawData = df.getCol('Activity').getRawData();
+    const monomerCols: type.RawColumn[] = [];
+    for (let i = 1; i < 16; ++i) {
+      const col = df.getCol(i.toString());
+      monomerCols.push({name: col.name, rawData: col.getRawData(), cat: col.categories});
+    }
+    DG.time('MutationCliffs', () => findMutations(activityCol, monomerCols));
+  }, {skipReason: 'Benchmark'});
 });

package/src/tests/core.ts

@@ -8,21 +8,18 @@ import {startAnalysis} from '../widgets/peptides';
 import {PeptidesModel} from '../model';
 import * as C from '../utils/constants';
 import {scaleActivity} from '../utils/misc';
-import {ALPHABET, TAGS, NOTATION, ALIGNMENT} from '@datagrok-libraries/bio';
+import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 category('Core', () => {
   let simpleTable: DG.DataFrame;
   let simpleActivityCol: DG.Column<number>;
   let simpleAlignedSeqCol: DG.Column<string>;
   let simpleScaledCol: DG.Column<number>;
-  let scalingFormula: (x: number) => number;
-  let simpleScaledColName: string;
 
   let complexTable: DG.DataFrame;
   let complexActivityCol: DG.Column<number>;
   let complexAlignedSeqCol: DG.Column<string>;
   let complexScaledCol: DG.Column<number>;
-  let complexScaledColName: string;
   const alignedSequenceCol = 'AlignedSequence';
 
   let model: PeptidesModel | null = null;
@@ -32,19 +29,17 @@ category('Core', () => {
     simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
-    simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
-    simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
+    simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
     model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');
     expect(model instanceof PeptidesModel, true);
 
-    if (model != null) {
+    if (model != null)
       model.mutationCliffsSelection = {'11': ['D']};
-      grok.shell.closeTable(model.df);
-    }
   });
 
   test('Start analysis: сomplex', async () => {
@@ -52,21 +47,19 @@ category('Core', () => {
     complexTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned_2.csv'));
     complexActivityCol = complexTable.getCol(complexActivityColName);
     complexAlignedSeqCol = complexTable.getCol('MSA');
-    complexAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    complexAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     complexAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.UN);
     complexAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
-    complexAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
-    complexAlignedSeqCol.tags[C.TAGS.SEPARATOR] = '/';
+    complexAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
+    complexAlignedSeqCol.setTag(C.TAGS.SEPARATOR, '/');
     complexScaledCol = scaleActivity(complexActivityCol, '-lg');
 
     model = await startAnalysis(
       complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, '-lg');
     expect(model instanceof PeptidesModel, true);
 
-    if (model != null) {
+    if (model != null)
       model.mutationCliffsSelection = {'13': ['-']};
-      grok.shell.closeTable(model.df);
-    }
   });
 
   test('Save and load project', async () => {
@@ -74,10 +67,10 @@ category('Core', () => {
     simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
-    simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
-    simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
+    simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
     model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');
@@ -98,12 +91,57 @@ category('Core', () => {
     grok.shell.closeTable(d);
     await delay(500);
 
-    await grok.dapi.projects.open('Peptides project unique test');
+    await sp.open();
     v = grok.shell.getTableView('Peptides analysis');
-    grok.shell.closeTable(v.dataFrame);
 
     await grok.dapi.layouts.delete(sl);
     await grok.dapi.tables.delete(sti);
     await grok.dapi.projects.delete(sp);
   });
+
+  test('Cluster stats - Benchmark HELM 5k', async () => {
+    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k_2.d42'))[0];
+    const activityCol = df.getCol('Activity');
+    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const clustersCol = df.getCol('Cluster');
+    const sequenceCol = df.getCol('HELM');
+    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, 'none');
+
+    for (let i = 0; i < 5; ++i)
+      DG.time('Cluster stats', () => model?.calculateClusterStatistics());
+  }, {skipReason: 'Benchmark'});
+
+  test('Monomer Position stats - Benchmark HELM 5k', async () => {
+    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
+    const activityCol = df.getCol('Activity');
+    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const clustersCol = df.getCol('Cluster');
+    const sequenceCol = df.getCol('HELM');
+    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, 'none');
+
+    for (let i = 0; i < 5; ++i)
+      DG.time('Monomer position stats', () => model?.calculateMonomerPositionStatistics());
+  }, {skipReason: 'Benchmark'});
+
+  test('Analysis start - Benchmark HELM 5k', async () => {
+    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
+    const activityCol = df.getCol('Activity');
+    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const clustersCol = df.getCol('Cluster');
+    const sequenceCol = df.getCol('HELM');
+    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+
+    for (let i = 0; i < 5; ++i) {
+      await DG.timeAsync('Analysis start', async () => {
+        const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, 'none');
+        if (model)
+          grok.shell.closeTable(model.df);
+      });
+    }
+  }, {skipReason: 'Benchmark'});
 });

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

@@ -1,10 +1,5 @@
 import {/*before, after, */after, category, test} from '@datagrok-libraries/utils/src/test';
-import {
-  _testViewerIsDrawing,
-  _testDimensionalityReducer,
-  _testPeptideSimilaritySpaceViewer,
-  _testTableIsNotEmpty,
-} from './utils';
+import * as utils from './utils';
 import {DimensionalityReducer} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {cleanAlignedSequencesColumn} from '../utils/peptide-similarity-space';
 import {aligned1} from './test-data';
@@ -12,7 +7,6 @@ import {aligned1} from './test-data';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import {StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {computeWeights} from '../viewers/peptide-space-viewer';
 import {_package} from '../package-test';
 
 let table: DG.DataFrame;
@@ -22,12 +16,12 @@ category('Peptide space', async () => {
   table = DG.DataFrame.fromCsv(aligned1);
 
   test('test_table.is_not_empty', async () => {
-    _testTableIsNotEmpty(table);
+    utils._testTableIsNotEmpty(table);
   });
 
   test('PeptideSimilaritySpaceWidget.is_drawing', async () => {
     view = grok.shell.addTableView(table);
-    await _testViewerIsDrawing(table, view);
+    await utils._testViewerIsDrawing(table, view);
   });
 
   const alignedSequencesColumn = table.getCol('AlignedSequence');
@@ -37,7 +31,7 @@ category('Peptide space', async () => {
     for (const method of DimensionalityReducer.availableMethods) {
       for (const measure of DimensionalityReducer.availableMetricsByType('String')) {
         test(`peptide_space.DimensinalityReducer.${method}.${measure}.is_numeric`, async () => {
-          await _testDimensionalityReducer(columnData, method as StringMetrics, measure);
+          await utils._testDimensionalityReducer(columnData, method as StringMetrics, measure);
         });
       }
     }
@@ -47,51 +41,9 @@ category('Peptide space', async () => {
     for (const method of DimensionalityReducer.availableMethods) {
       for (const measure of DimensionalityReducer.availableMetricsByType('String')) {
         test(`peptide_space.PeptideSimilaritySpaceViewer.${method}.${measure}.is_proper`, async () => {
-          await _testPeptideSimilaritySpaceViewer(table, alignedSequencesColumn, method, measure, 100);//, view);
+          await utils._testPeptideSimilaritySpaceViewer(table, alignedSequencesColumn, method, measure, 100);//, view);
         });
       }
     }
   });
-
-  after(async () => {
-    view?.close();
-  });
 });
-
-// category('Peptide Space Performance', () => {
-//   test('test_compute_weights_performance', async () => {
-//     const table = DG.DataFrame.fromCsv(await _package.files.readAsText('peptides_large.csv'));
-//     const results: {[key: string]: {[key: string]: {[key: string]: number}}} = {};
-//     const sliceVolumes = [1, 2, 3, 4, 5, 7, 10];
-//     const methods = DimensionalityReducer.availableMethods;
-//     const metrics = DimensionalityReducer.availableMetricsByType('String');
-//     const totalRuns = sliceVolumes.length * methods.length * metrics.length;
-//     console.log('Started Peptide Space Performance benchmark...');
-
-//     let run = 0;
-//     for (const slice of sliceVolumes) {
-//       const bitset = DG.BitSet.create(table.rowCount, (i) => i < slice * 1000);
-//       const tableSlice = table.clone(bitset);
-//       const col = tableSlice.getCol('sequence');
-//       const methodObj: {[key: string]: {[key: string]: number}} = {};
-
-//       for (const method of methods) {
-//         const measureObj: {[key: string]: number} = {};
-
-//         for (const metric of metrics) {
-//           console.log(`Run ${run++}/${totalRuns}`);
-
-//           const start = new Date();
-//           await computeWeights(tableSlice, method, metric, 100, col);
-//           const stop = new Date();
-
-//           measureObj[metric] = stop.getTime() - start.getTime();
-//         }
-//         methodObj[method] = measureObj;
-//       }
-//       results[`${slice}k`] = methodObj;
-//     }
-//     console.log('Peptide Space Performance benchmark finished...');
-//     console.log(results);
-//   });
-// });

package/src/tests/utils.ts

@@ -45,8 +45,8 @@ export async function _testDimensionalityReducer(
 
   const [X, Y] = embcols as Array<Float32Array>;
 
-  expect(X.every((v) => v !== null && v !== NaN), true);
-  expect(Y.every((v) => v !== null && v !== NaN), true);
+  expect(X.every((v) => v !== null && !Number.isNaN(v)), true);
+  expect(Y.every((v) => v !== null && !Number.isNaN(v)), true);
 }
 
 /**
@@ -64,12 +64,12 @@ export async function _testDimensionalityReducer(
 export async function _testPeptideSimilaritySpaceViewer(table: DG.DataFrame, alignedSequencesColumn: DG.Column,
   method: string, measure: string, cyclesCount: number): Promise<void> {
   const viewer = await createPeptideSimilaritySpaceViewer(
-    table, method, measure, cyclesCount, undefined, alignedSequencesColumn);
+    table, method, measure, cyclesCount, alignedSequencesColumn, undefined);
   const df = viewer.dataFrame;
 
   const axesNames = ['~X', '~Y', '~MW'];
   const axes = axesNames.map((v) => df.getCol(v).getRawData() as Float32Array);
 
   for (const ax of axes)
-    expect(ax.every((v) => v !== null && v !== NaN), true);
+    expect(ax.every((v) => v !== null && !Number.isNaN(v)), true);
 }

package/src/tests/viewers.ts

@@ -0,0 +1,17 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+//import * as ui from 'datagrok-api/ui';
+
+import {category, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {aligned1} from './test-data';
+
+
+category('Viewers', () => {
+  const df = DG.DataFrame.fromCsv(aligned1);
+  const viewers = DG.Func.find({package: 'Peptides', tags: ['viewer']}).map((f) => f.friendlyName);
+  for (const v of viewers) {
+    test(v, async () => {
+      await testViewer(v, df.clone(), true);
+    }, {skipReason: 'GROK-11534'});
+  }
+});

package/src/utils/algorithms.ts

@@ -1,34 +1,32 @@
-import * as DG from 'datagrok-api/dg';
-
 import * as C from './constants';
 import * as type from './types';
 import {getTypedArrayConstructor} from './misc';
 
-//TODO: move out
-export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG.Column<string>[],
+type MutationCliffInfo = {pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number};
+
+export function findMutations(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
   settings: type.PeptidesSettings = {}): type.SubstitutionsInfo {
-  const nCols = monomerColumns.length;
+  const nCols = monomerInfoArray.length;
   if (nCols == 0)
     throw new Error(`PepAlgorithmError: Couldn't find any column of semType '${C.SEM_TYPES.MONOMER}'`);
 
   const substitutionsInfo: type.SubstitutionsInfo = new Map();
-  const nRows = activityCol.length;
+  const nRows = activityArray.length;
   for (let seq1Idx = 0; seq1Idx < nRows - 1; seq1Idx++) {
     for (let seq2Idx = seq1Idx + 1; seq2Idx < nRows; seq2Idx++) {
       let substCounter = 0;
-      const activityValSeq1 = activityCol.get(seq1Idx)!;
-      const activityValSeq2 = activityCol.get(seq2Idx)!;
+      const activityValSeq1 = activityArray[seq1Idx];
+      const activityValSeq2 = activityArray[seq2Idx];
       const delta = activityValSeq1 - activityValSeq2;
       if (Math.abs(delta) < (settings.minActivityDelta ?? 0))
         continue;
 
       let substCounterFlag = false;
-      const tempData: { pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number }[] =
-        [];
-      for (const currentPosCol of monomerColumns) {
-        const seq1monomer = currentPosCol.get(seq1Idx)!;
-        const seq2monomer = currentPosCol.get(seq2Idx)!;
-        if (seq1monomer == seq2monomer)
+      const tempData: MutationCliffInfo[] = [];
+      for (const monomerInfo of monomerInfoArray) {
+        const seq1category = monomerInfo.rawData[seq1Idx];
+        const seq2category = monomerInfo.rawData[seq2Idx];
+        if (seq1category == seq2category)
           continue;
 
         substCounter++;
@@ -37,9 +35,9 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
           break;
 
         tempData.push({
-          pos: currentPosCol.name,
-          seq1monomer: seq1monomer,
-          seq2monomer: seq2monomer,
+          pos: monomerInfo.name,
+          seq1monomer: monomerInfo.cat![seq1category],
+          seq2monomer: monomerInfo.cat![seq2category],
           seq1Idx: seq1Idx,
           seq2Idx: seq2Idx,
         });
@@ -49,20 +47,22 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
         continue;
 
       for (const tempDataElement of tempData) {
-        const position = tempDataElement.pos;
-
         //Working with seq1monomer
         const seq1monomer = tempDataElement.seq1monomer;
         if (!substitutionsInfo.has(seq1monomer))
           substitutionsInfo.set(seq1monomer, new Map());
 
+        const position = tempDataElement.pos;
+
         let positionsMap = substitutionsInfo.get(seq1monomer)!;
         if (!positionsMap.has(position))
           positionsMap.set(position, new Map());
 
         let indexes = positionsMap.get(position)!;
-
-        !indexes.has(seq1Idx) ? indexes.set(seq1Idx, [seq2Idx]) : (indexes.get(seq1Idx)! as number[]).push(seq2Idx);
+        if (indexes.has(seq1Idx))
+          (indexes.get(seq1Idx)! as number[]).push(seq2Idx);
+        else
+          indexes.set(seq1Idx, [seq2Idx]);
 
         //Working with seq2monomer
         const seq2monomer = tempDataElement.seq2monomer;
@@ -74,7 +74,10 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
           positionsMap.set(position, new Map());
 
         indexes = positionsMap.get(position)!;
-        !indexes.has(seq2Idx) ? indexes.set(seq2Idx, [seq1Idx]) : (indexes.get(seq2Idx)! as number[]).push(seq1Idx);
+        if (indexes.has(seq2Idx))
+          (indexes.get(seq2Idx)! as number[]).push(seq1Idx);
+        else
+          indexes.set(seq2Idx, [seq1Idx]);
       }
     }
   }