@datagrok/peptides 0.8.13 → 1.0.0

package/src/widgets/analyze-peptides.ts

@@ -1,44 +1,39 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {callMVA} from '../utils/multivariate-analysis';
-import {PeptidesController} from '../peptides';
 import '../styles.css';
-import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 import * as C from '../utils/constants';
-import {FilteringStatistics} from '../utils/filtering-statistics';
+import {getSeparator} from '../utils/misc';
+import {PeptidesModel} from '../model';
+import {_package} from '../package';
 
-/**
- * Peptide analysis widget.
+/** Peptide analysis widget.
  *
- * @export
- * @param {DG.Column} col Aligned sequence column.
- * @param {DG.TableView} view Working view.
- * @param {DG.Grid} tableGrid Working table grid.
- * @param {DG.DataFrame} currentDf Working table.
- * @return {Promise<DG.Widget>} Widget containing peptide analysis.
- */
+ * @param {DG.DataFrame} currentDf Working table
+ * @param {DG.Column} col Aligned sequence column
+ * @return {Promise<DG.Widget>} Widget containing peptide analysis */
 export async function analyzePeptidesWidget(currentDf: DG.DataFrame, col: DG.Column): Promise<DG.Widget> {
   let tempCol = null;
-  let tempDf: DG.DataFrame;
+  let scaledDf: DG.DataFrame;
   let newScaledColName: string;
+  const separator = getSeparator(col);
+  col.tags[C.TAGS.SEPARATOR] ??= separator;
 
   for (const column of currentDf.columns.numerical)
     tempCol = column.type === DG.TYPE.FLOAT ? column : null;
 
-  const defaultColumn: DG.Column = currentDf.col('activity') || currentDf.col('IC50') || tempCol;
+  const defaultColumn: DG.Column<number> | null = currentDf.col('activity') || currentDf.col('IC50') || tempCol;
   const histogramHost = ui.div([], {id: 'pep-hist-host'});
 
   const activityScalingMethod = ui.choiceInput(
     'Scaling', 'none', ['none', 'lg', '-lg'],
-    async (currentMethod: string) => {
-      const currentActivityCol = activityColumnChoice.value.name;
-      
+    async (currentMethod: string): Promise<void> => {
+      const currentActivityCol = activityColumnChoice.value?.name;
 
-      [tempDf, newScaledColName] = await PeptidesController.scaleActivity(
+      [scaledDf, newScaledColName] = await PeptidesModel.scaleActivity(
         currentMethod, currentDf, currentActivityCol, true);
 
-      const hist = tempDf.plot.histogram({
+      const hist = scaledDf.plot.histogram({
         filteringEnabled: false,
         valueColumnName: C.COLUMNS_NAMES.ACTIVITY_SCALED,
         legendVisibility: 'Never',
@@ -46,83 +41,66 @@ export async function analyzePeptidesWidget(currentDf: DG.DataFrame, col: DG.Col
         showColumnSelector: false,
         showRangeSlider: false,
         showBinSelector: false,
-      // bins: b,
       });
       histogramHost.lastChild?.remove();
       histogramHost.appendChild(hist.root);
     });
   activityScalingMethod.setTooltip('Function to apply for each value in activity column');
 
-  const activityScalingMethodState = function(_: any) {
-    activityScalingMethod.enabled =
-      activityColumnChoice.value && DG.Stats.fromColumn(activityColumnChoice.value, currentDf.filter).min > 0;
+  const activityScalingMethodState = (_: any): void => {
+    activityScalingMethod.enabled = (activityColumnChoice.value ?? false) &&
+      DG.Stats.fromColumn(activityColumnChoice.value!, currentDf.filter).min > 0;
     activityScalingMethod.fireChanged();
   };
-  const activityColumnChoice = ui.columnInput(
-    'Activity',
-    currentDf,
-    defaultColumn,
-    activityScalingMethodState,
-  );
+  const activityColumnChoice = ui.columnInput('Activity', currentDf, defaultColumn, activityScalingMethodState);
   activityColumnChoice.fireChanged();
   activityScalingMethod.fireChanged();
 
-  const startBtn = ui.button('Launch SAR', async () => {
-    const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
-    if (activityColumnChoice.value.type === DG.TYPE.FLOAT) {
-      const activityColumn: string = activityColumnChoice.value.name;
-      // const activityColumnScaled = `${activityColumn}Scaled`;
-      // const originalDfColumns = (currentDf.columns as DG.ColumnList).names();
-      const options: StringDictionary = {
-        'scaling': activityScalingMethod.value,
-      };
-
-      //prepare new DF
-      const newDf = currentDf.clone(currentDf.filter, [col.name, activityColumn]);
-      newDf.getCol(activityColumn).name = C.COLUMNS_NAMES.ACTIVITY;
-      newDf.getCol(col.name).name = C.COLUMNS_NAMES.ALIGNED_SEQUENCE;
-      const activityScaledCol = tempDf.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-      (newDf.columns as DG.ColumnList).add(activityScaledCol);
-      // newDf.temp[C.COLUMNS_NAMES.ACTIVITY] = activityColumn;
-      newDf.name = 'Peptides analysis';
-      newDf.temp[C.COLUMNS_NAMES.ACTIVITY_SCALED] = newScaledColName;
-      newDf.tags['isPeptidesAnalysis'] = 'true';
+  const inputsList = [activityColumnChoice, activityScalingMethod];
 
-      const peptides = await PeptidesController.getInstance(newDf);
-      await peptides.init(newDf);
-    } else
-      grok.shell.error('The activity column must be of floating point number type!');
-    progress.close();
+  const startBtn = ui.button('Launch SAR', async () => {
+    await startAnalysis(activityColumnChoice.value, col, currentDf, scaledDf, newScaledColName);
   });
   startBtn.style.alignSelf = 'center';
 
-  // const startMVABtn = ui.button('Launch MVA', async () => {
-  //   if (activityColumnChoice.value.type === DG.TYPE.FLOAT) {
-  //     const progress = DG.TaskBarProgressIndicator.create('Loading MVA...');
-
-  //     const options: {[key: string]: string} = {
-  //       'activityColumnName': activityColumnChoice.value.name,
-  //       'scaling': activityScalingMethod.value,
-  //     };
-
-  //     await callMVA(tableGrid, view, currentDf, options, col);
-
-  //     progress.close();
-  //   } else
-  //     grok.shell.error('The activity column must be of floating point number type!');
-  // });
-
-
-  const viewer = await currentDf.plot.fromType('peptide-logo-viewer');
+  const viewer = await currentDf.plot.fromType('WebLogo');
+  viewer.root.style.setProperty('height', '130px');
 
   return new DG.Widget(
     ui.divV([
       viewer.root,
       ui.splitH([
-        ui.splitV([ui.inputs([activityColumnChoice, activityScalingMethod]), startBtn]),
+        ui.splitV([ui.inputs(inputsList), startBtn]),
         histogramHost,
       ], {style: {height: 'unset'}}),
-      // histogramHost,
     ]),
   );
 }
+
+export async function startAnalysis(
+  activityColumn: DG.Column<number> | null, alignedSeqCol: DG.Column<string>, currentDf: DG.DataFrame,
+  scaledDf: DG.DataFrame, newScaledColName: string, dgPackage?: DG.Package): Promise<PeptidesModel | null> {
+  const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
+  let model = null;
+  if (activityColumn?.type === DG.TYPE.FLOAT) {
+    const activityColumnName: string = activityColumn.name;
+
+    //prepare new DF
+    const newDf = currentDf.clone(currentDf.filter, [alignedSeqCol.name, activityColumnName]);
+    const activityCol = newDf.getCol(activityColumnName);
+    activityCol.name = C.COLUMNS_NAMES.ACTIVITY;
+    activityCol.semType = C.SEM_TYPES.ACTIVITY;
+    newDf.getCol(alignedSeqCol.name).name = C.COLUMNS_NAMES.ALIGNED_SEQUENCE;
+    const activityScaledCol = scaledDf.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+    activityScaledCol.semType = C.SEM_TYPES.ACTIVITY_SCALED;
+    newDf.columns.add(activityScaledCol);
+    newDf.name = 'Peptides analysis';
+    newDf.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED] = newScaledColName;
+    // newDf.tags[C.PEPTIDES_ANALYSIS] = 'true';
+
+    model = await PeptidesModel.getInstance(newDf, dgPackage ?? _package);
+  } else
+    grok.shell.error('The activity column must be of floating point number type!');
+  progress.close();
+  return model;
+}

package/src/widgets/distribution.ts

@@ -4,10 +4,10 @@ import * as DG from 'datagrok-api/dg';
 import * as C from '../utils/constants';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 import {FilteringStatistics} from '../utils/filtering-statistics';
+import * as type from '../utils/types';
 
-export function getDistributionPlot(df: DG.DataFrame, valueCol: string, splitCol: string) {
+export function getDistributionPlot(df: DG.DataFrame, valueCol: string, splitCol: string): DG.Viewer {
   return df.plot.histogram({
-    // const hist = originalDf.plot.histogram({
     filteringEnabled: false,
     valueColumnName: valueCol,
     splitColumnName: splitCol,
@@ -18,33 +18,49 @@ export function getDistributionPlot(df: DG.DataFrame, valueCol: string, splitCol
   });
 }
 
+const allLabel = 'All';
+
 export function getDistributionWidget(table: DG.DataFrame): DG.Widget {
-  // const labelStr = this.multipleFilter.filterLabel;
   const splitCol = table.col(C.COLUMNS_NAMES.SPLIT_COL);
-  if (!splitCol)
+  const selectionObject: type.SelectionObject = JSON.parse(table.tags[C.TAGS.SELECTION]);
+  if (!splitCol || !selectionObject)
     return new DG.Widget(ui.divText('No distribution'));
-  let [aarStr, otherStr] = splitCol.categories;
-  if (typeof otherStr === 'undefined')
-    [aarStr, otherStr] = [otherStr, aarStr];
-  // const currentColor = DG.Color.toHtml(DG.Color.orange);
-  // const otherColor = DG.Color.toHtml(DG.Color.blue);
-  const currentColor = DG.Color.toHtml(DG.Color.getCategoryColor(splitCol, aarStr));
-  const otherColor = DG.Color.toHtml(DG.Color.getCategoryColor(splitCol, otherStr));
+
+  const positions = Object.keys(selectionObject);
+  let currentColor = DG.Color.toHtml(DG.Color.blue);
+  const otherColor = DG.Color.toHtml(DG.Color.blue);
+  let aarStr = allLabel;
+  let otherStr = '';
+
+  if (positions.length) {
+    aarStr = '';
+
+    for (const position of positions) {
+      aarStr += `${position}: {`;
+
+      for (const aar of selectionObject[position])
+        aarStr += `${aar}, `;
+
+      aarStr = aarStr.slice(0, aarStr.length - 2);
+      aarStr += '}; ';
+    }
+    aarStr = aarStr.slice(0, aarStr.length - 2);
+    otherStr = 'Other';
+    currentColor = DG.Color.toHtml(DG.Color.orange);
+  }
 
   const currentLabel = ui.label(aarStr, {style: {color: currentColor}});
   const otherLabel = ui.label(otherStr, {style: {color: otherColor}});
   const elements: (HTMLLabelElement | HTMLElement)[] = [currentLabel, otherLabel];
 
-  const getContent = () => {
-    // const processedDf =
-    //   table.clone(null, [C.COLUMNS_NAMES.ACTIVITY_SCALED, C.COLUMNS_NAMES.SPLIT_COL]);
-    const hist = getDistributionPlot(table, C.COLUMNS_NAMES.ACTIVITY_SCALED, C.COLUMNS_NAMES.SPLIT_COL).root;
-
+  const getContent = (): HTMLDivElement => {
+    const valueColName = table.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!.name;
+    const hist = getDistributionPlot(table, valueColName, C.COLUMNS_NAMES.SPLIT_COL).root;
     hist.style.width = 'auto';
     elements.push(hist);
-
     const stats = (table.temp[C.STATS] as FilteringStatistics).result;
-    if (stats) {
+
+    if (stats && aarStr != allLabel) {
       const tableMap: StringDictionary = {
         'Statistics:': '',
         'Count': stats.count.toString(),

package/src/widgets/manual-alignment.ts

@@ -3,25 +3,22 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
-// import {splitAlignedPeptides} from '../utils/split-aligned';
 import '../styles.css';
-import {PeptidesController} from '../peptides';
+import {PeptidesModel} from '../model';
 
-/**
- * Manual sequence alignment widget.
+/** Manual sequence alignment widget.
  *
- * @param {DG.Column} alignedSequenceCol Aligned sequence column.
- * @param {DG.DataFrame} currentDf Working table.
- * @return {DG.Widget} Widget for manual sequence alignment.
- */
-export function manualAlignmentWidget(alignedSequenceCol: DG.Column, currentDf: DG.DataFrame) {
+ * @param {DG.Column} alignedSequenceCol Aligned sequence column
+ * @param {DG.DataFrame} currentDf Working table
+ * @return {DG.Widget} Widget for manual sequence alignment */
+export function manualAlignmentWidget(alignedSequenceCol: DG.Column<string>, currentDf: DG.DataFrame): DG.Widget {
   const sequenceInput = ui.textInput('', alignedSequenceCol.get(currentDf.currentRowIdx));
   $(sequenceInput.root).addClass('pep-textinput');
 
   const applyChangesBtn = ui.button('Apply', async () => {
     const newSequence = sequenceInput.value;
     const affectedRowIndex = currentDf.currentRowIdx;
-    const [splitSequence] = PeptidesController.splitAlignedPeptides(
+    const [splitSequence] = PeptidesModel.splitAlignedPeptides(
       DG.Column.fromStrings('splitSequence', [newSequence]), false);
 
     alignedSequenceCol.set(affectedRowIndex, newSequence);
@@ -33,8 +30,7 @@ export function manualAlignmentWidget(alignedSequenceCol: DG.Column, currentDf:
     grok.shell.o = null;
     grok.shell.o = temp;
 
-    const peptidesController = await PeptidesController.getInstance(currentDf);
-    peptidesController.init(currentDf);
+    const peptidesController = await PeptidesModel.getInstance(currentDf);
     peptidesController.updateDefault();
   });
 

package/src/widgets/peptide-molecule.ts

@@ -1,8 +1,8 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-// import {ChemPalette} from '../utils/chem-palette';
-import {PeptidesController} from '../peptides';
+import * as C from '../utils/constants';
+import {PeptidesModel} from '../model';
 
 /**
  * 3D representation widget of peptide molecule.
@@ -11,40 +11,63 @@ import {PeptidesController} from '../peptides';
  * @param {string} pep Peptide string.
  * @return {Promise<DG.Widget>} Widget.
  */
-export async function peptideMoleculeWidget(pep: string): Promise<DG.Widget> {
+export async function peptideMoleculeWidget(pep: string, currentTable: DG.DataFrame): Promise<DG.Widget> {
   const pi = DG.TaskBarProgressIndicator.create('Creating NGL view');
+  const separator = currentTable.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE)!.tags[C.TAGS.SEPARATOR];
 
-  const smiles = getMolecule(pep);
-  if (smiles == '')
-    return new DG.Widget(ui.divH([]));
+  let widgetHost;
+  let smiles = '';
+  let molfileStr = '';
+  try {
+    try {
+      const params = {table: currentTable};
+      const result = await grok.functions.call('Customerextensions:getPeptideStructure', params) as string[];
+      if (result.length !== 0) {
+        smiles = result[0];
+        molfileStr = result[1];
+        throw new Error(`Found structure in DB`);
+      }
 
+      smiles = getMolecule(pep, separator);
+      if (smiles == '')
+        throw new Error('Couldn\'t get smiles');
 
-  let molfileStr = (await grok.functions.call('Peptides:SmiTo3D', {smiles}));
+      molfileStr = (await grok.functions.call('Peptides:SmiTo3D', {smiles})) as string;
+    } catch (e) {
+      console.warn(e);
+    }
 
-  molfileStr = molfileStr.replaceAll('\\n', '\n'); ;
-  const stringBlob = new Blob([molfileStr], {type: 'text/plain'});
-  const nglHost = ui.div([], {classes: 'd4-ngl-viewer', id: 'ngl-3d-host'});
+    try {
+      molfileStr = molfileStr.replaceAll('\\n', '\n');
+      const stringBlob = new Blob([molfileStr], {type: 'text/plain'});
+      const nglHost = ui.div([], {classes: 'd4-ngl-viewer', id: 'ngl-3d-host'});
 
-  //@ts-ignore
-  const stage = new NGL.Stage(nglHost, {backgroundColor: 'white'});
-  //@ts-ignore
-  stage.loadFile(stringBlob, {ext: 'sdf'}).then(function(comp: NGL.StructureComponent) {
-    stage.setSize(300, 300);
-    comp.addRepresentation('ball+stick');
-    comp.autoView();
-  });
-  const sketch = grok.chem.svgMol(smiles);
-  const panel = ui.divH([sketch]);
+      //@ts-ignore
+      const stage = new NGL.Stage(nglHost, {backgroundColor: 'white'});
+      //@ts-ignore
+      stage.loadFile(stringBlob, {ext: 'sdf'}).then(function(comp: NGL.StructureComponent) {
+        stage.setSize(300, 300);
+        comp.addRepresentation('ball+stick');
+        comp.autoView();
+      });
+      const sketch = grok.chem.svgMol(molfileStr);
+      const panel = ui.divH([sketch]);
 
+      widgetHost = ui.div([panel, nglHost]);
+    } catch (e) {
+      widgetHost = ui.divText('Couldn\'t get peptide structure');
+    }
+  } catch (e) {
+    widgetHost = ui.divText('Couldn\'t get peptide structure');
+  }
   pi.close();
-
-  return new DG.Widget(ui.div([panel, nglHost]));
+  return new DG.Widget(widgetHost);
 }
 
-export function getMolecule(pep: string): string {
-  const split = pep.split('-');
+export function getMolecule(pep: string, separator: string): string {
+  const split = pep.split(separator);
   const mols = [];
-  const chemPalette = PeptidesController.chemPalette;
+  const chemPalette = PeptidesModel.chemPalette;
   for (let i = 1; i < split.length - 1; i++) {
     if (split[i] in chemPalette.AASmiles) {
       const aar = chemPalette.AASmiles[split[i]];

package/src/widgets/subst-table.ts

@@ -1,73 +1,74 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import { PeptidesController } from '../peptides';
+import * as C from '../utils/constants';
+import * as type from '../utils/types';
+import {PeptidesModel} from '../model';
 
-export async function substitutionsWidget(table: DG.DataFrame): Promise<DG.Widget> {
-  const controller = await PeptidesController.getInstance(table);
-  controller.init(table);
-  const substTable = controller.getSubstitutions();
+export function substitutionsWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
+  const substInfo = model.substitutionsInfo;
+  const currentCell = model.currentSelection;
+  const positions = Object.keys(currentCell);
 
-  if (!substTable)
+  if (!positions.length)
     return new DG.Widget(ui.label('No substitution table generated'));
 
-  const dfRowCount = substTable.rowCount;
-  const aminoInputFrom = ui.stringInput('from', '');
-  const aminoInputTo = ui.stringInput('to', '');
-  const fromToMap: {[key: string]: DG.BitSet} = {};
-  let aminoFrom = '';
-  let aminoTo = '';
-  const initialCol: DG.Column = substTable.getCol('Initial');
-  const substitutedCol: DG.Column = substTable.getCol('Substituted');
+  const substitutionsArray: string[] = [];
+  const deltaArray: number[] = [];
+  const substitutedToArray: string[] = [];
+  const alignedSeqCol = table.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE)!;
+  const activityScaledCol = table.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
+  const seenIndexes = new Map<number, number[]>();
 
-  initialCol.semType = 'alignedSequenceDifference';
-  initialCol.name = 'Substitution';
-  // substTable.columns.remove('Substituted');
-  // const substCol = table.getCol('Substitution');
+  for (const pos of positions) {
+    for (const aar of currentCell[pos]) {
+      const substitutionsMap = substInfo.get(aar)?.get(pos) as Map<number, type.UTypedArray> | undefined;
+      if (typeof substitutionsMap === 'undefined')
+        continue;
 
-  for (let i = 0; i < dfRowCount; ++i) {
-    // const [from, to] = substCol!.get(i).split('#');
-    const from = initialCol.get(i);
-    const to = substitutedCol.get(i);
-    const aminosFrom: [] = from.split('-');
-    const aminosTo: [] = to.split('-');
+      const posCol = table.getCol(pos);
+      for (const [referenceIdx, indexArray] of substitutionsMap.entries()) {
+        const forbiddentIndexes = seenIndexes.has(referenceIdx) ? seenIndexes.get(referenceIdx)! : [];
+        const baseSequence = alignedSeqCol.get(referenceIdx);
+        const baseActivity = activityScaledCol.get(referenceIdx);
 
-    for (let j = 0; j < aminosFrom.length; ++j) {
-      if (aminosFrom[j] != aminosTo[j]) {
-        const idx = `${getAmino(aminosFrom[j])}#${getAmino(aminosTo[j])}`;
+        for (const subIdx of indexArray) {
+          if (forbiddentIndexes.includes(subIdx))
+            continue;
 
-        if (!(idx in fromToMap))
-          fromToMap[idx] = DG.BitSet.create(dfRowCount);
-        fromToMap[idx].set(i, true);
+          if (!seenIndexes.has(subIdx))
+            seenIndexes.set(subIdx, []);
+
+          seenIndexes.get(subIdx)!.push(referenceIdx);
+          substitutionsArray.push(`${baseSequence}#${alignedSeqCol.get(subIdx)}`);
+          deltaArray.push(baseActivity - activityScaledCol.get(subIdx));
+          substitutedToArray.push(posCol.get(subIdx));
+        }
       }
     }
   }
 
-  for (let i = 0; i < initialCol.length; ++i) {
-    const sequenceDifference = `${initialCol.get(i)}#${substitutedCol.get(i)}`;
-    initialCol.set(i, sequenceDifference);
-  }
+  if (!substitutionsArray.length)
+    return new DG.Widget(ui.label('No substitution table generated'));
 
-  aminoInputFrom.onInput(() => {
-    aminoFrom = getAmino(aminoInputFrom.value);
-    const fromKey = `${aminoFrom}#${aminoTo}`;
-    if (fromKey in fromToMap)
-      substTable.selection.copyFrom(fromToMap[fromKey]);
-  });
+  const substCol = DG.Column.fromStrings('Substiutions', substitutionsArray);
+  substCol.semType = C.SEM_TYPES.ALIGNED_SEQUENCE_DIFFERENCE;
+  const toColName = '~to';
+  const hiddenSubstToAarCol = DG.Column.fromStrings(toColName, substitutedToArray);
+  const substTable =
+    DG.DataFrame.fromColumns([substCol, DG.Column.fromList('double', 'Delta', deltaArray), hiddenSubstToAarCol]);
 
-  aminoInputTo.onInput(() => {
-    aminoTo = getAmino(aminoInputTo.value);
-    const toKey = `${aminoFrom}#${aminoTo}`;
-    if (toKey in fromToMap)
-      substTable.selection.copyFrom(fromToMap[toKey]);
+  const aminoToInput = ui.stringInput('Substituted to:', '', () => {
+    const substitutedToAar = aminoToInput.stringValue;
+    if (substitutedToAar != '')
+      substTable.filter.init((idx) => hiddenSubstToAarCol.get(idx) === substitutedToAar);
+    else
+      substTable.filter.setAll(true);
   });
 
   const grid = substTable.plot.grid();
   grid.props.allowEdit = false;
-  grid.root.style.width = 'auto';
-  grid.root.style.height = '150px';
-  return new DG.Widget(ui.divV([aminoInputFrom.root, aminoInputTo.root, grid.root]));
-}
-
-function getAmino(amino: string): string {
-  return amino === '' ? '-' : amino;
+  const gridRoot = grid.root;
+  gridRoot.style.width = 'auto';
+  gridRoot.style.height = '150px';
+  return new DG.Widget(ui.divV([aminoToInput.root, gridRoot]));
 }

package/src/workers/dimensionality-reducer.ts

@@ -1,6 +1,5 @@
 import {DimensionalityReducer, KnownMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
 
 /**
  * Worker thread receiving data function.
@@ -8,23 +7,19 @@ import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
  * @param {any[]} columnData Samples to process.
  * @param {string} method Embedding method.
  * @param {string} measure Distance metric.
- * @param {number} cyclesCount Number of cycles to repeat.
- * @return {Coordinates} Embedding.
+ * @param {any} options Options to pass to algorithm.
+ * @return {any} Embedding (and distance matrix where applicable).
  */
-function onMessage(columnData: any[], method: KnownMethods, measure: KnownMetrics, cyclesCount: number): Coordinates {
-  const reducer = new DimensionalityReducer(
-    columnData,
-    method,
-    measure,
-    {cycles: cyclesCount},
-  );
+function onMessage(columnData: any[], method: KnownMethods, measure: KnownMetrics, options: any): any {
+  const reducer = new DimensionalityReducer(columnData, method, measure, options);
   return reducer.transform(true);
 }
 
-self.onmessage = ({data: {columnData, method, measure, cyclesCount}}) => {
-  const embedding = onMessage(columnData, method, measure, cyclesCount);
+self.onmessage = ({data: {columnData, method, measure, options}}): void => {
+  const embedding = onMessage(columnData, method, measure, options);
   self.postMessage({
-    embedding: embedding,
+    distance: embedding.distance,
+    embedding: embedding.embedding,
   });
 };
 

package/{test-Peptides-f8114def7953-4bf59d70.html → test-Peptides-69a4761f6044-40ac3a0c.html}

@@ -1,4 +1,4 @@
-<html><head><meta charset="utf-8"/><title>Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=f8114def7953. Commit 4bf59d70.</title><style type="text/css">html,
+<html><head><meta charset="utf-8"/><title>Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=69a4761f6044. Commit 40ac3a0c.</title><style type="text/css">html,
 body {
   font-family: Arial, Helvetica, sans-serif;
   font-size: 1rem;
@@ -229,7 +229,7 @@ header {
   font-size: 1rem;
   padding: 0 0.5rem;
 }
-</style></head><body><div id="jesthtml-content"><header><h1 id="title">Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=f8114def7953. Commit 4bf59d70.</h1></header><div id="metadata-container"><div id="timestamp">Started: 2022-05-08 20:15:31</div><div id="summary"><div id="suite-summary"><div class="summary-total">Suites (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div><div id="test-summary"><div class="summary-total">Tests (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div></div></div><div id="suite-1" class="suite-container"><div class="suite-info"><div class="suite-path">/home/runner/work/public/public/packages/Peptides/src/__jest__/remote.test.ts</div><div class="suite-time warn">117.567s</div></div><div class="suite-tests"><div class="test-result failed"><div class="test-info"><div class="test-suitename"> </div><div class="test-title">TEST</div><div class="test-status">failed</div><div class="test-duration">100.001s</div></div><div class="failureMessages"> <pre class="failureMsg">Error: thrown: "Exceeded timeout of 100000 ms for a test.
+</style></head><body><div id="jesthtml-content"><header><h1 id="title">Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=69a4761f6044. Commit 40ac3a0c.</h1></header><div id="metadata-container"><div id="timestamp">Started: 2022-07-01 16:42:11</div><div id="summary"><div id="suite-summary"><div class="summary-total">Suites (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div><div id="test-summary"><div class="summary-total">Tests (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div></div></div><div id="suite-1" class="suite-container"><div class="suite-info"><div class="suite-path">/home/runner/work/public/public/packages/Peptides/src/__jest__/remote.test.ts</div><div class="suite-time warn">112.158s</div></div><div class="suite-tests"><div class="test-result failed"><div class="test-info"><div class="test-suitename"> </div><div class="test-title">TEST</div><div class="test-status">failed</div><div class="test-duration">100.002s</div></div><div class="failureMessages"> <pre class="failureMsg">Error: thrown: "Exceeded timeout of 100000 ms for a test.
 Use jest.setTimeout(newTimeout) to increase the timeout value, if this is a long-running test."
     at Object.&lt;anonymous&gt; (/home/runner/work/public/public/packages/Peptides/src/__jest__/remote.test.ts:22:1)
     at Runtime._execModule (/home/runner/work/public/public/packages/Peptides/node_modules/jest-runtime/build/index.js:1646:24)