@datagrok/peptides 0.8.14 → 1.0.1

package/src/widgets/distribution.ts

@@ -1,61 +1,186 @@
 import * as ui from 'datagrok-api/ui';
 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 $ from 'cash-dom';
+
+import * as C from '../utils/constants';
+import {getStats, Stats} from '../utils/filtering-statistics';
+import {PeptidesModel} from '../model';
+
+const allConst = 'All';
+const otherConst = 'Other';
+
+export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
+  const activityScaledCol = table.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
+  const rowCount = activityScaledCol.length;
+  const selectionObject = model.currentSelection;
+  const positions = Object.keys(selectionObject);
+  const positionsLen = positions.length;
+  let aarStr = allConst;
+  let otherStr = '';
+  const useSelectedStr = model.isPeptideSpaceChangingBitset;
+
+  const updateDistributionHost = () => {
+    model.splitByPos = splitByPosition.value!;
+    model.splitByAAR = splitByAAR.value!;
+    const res: HTMLDivElement[] = [];
+    if (splitByPosition.value && splitByAAR.value) {
+      otherStr = otherConst;
+      for (const position of positions) {
+        const posCol = table.getCol(position);
+        for (const aar of selectionObject[position]) {
+          aarStr = `${position} : ${aar}`;
+          const splitCol = DG.Column.bool(C.COLUMNS_NAMES.SPLIT_COL, rowCount).init((i) => posCol.get(i) == aar);
+
+          const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
+          const currentStatsDf = model.statsDf.rows.match({Pos: position, AAR: aar}).toDataFrame();
+          const stats: Stats = {
+            count: currentStatsDf.get(C.COLUMNS_NAMES.COUNT, 0),
+            ratio: currentStatsDf.get(C.COLUMNS_NAMES.RATIO, 0),
+            pValue: currentStatsDf.get(C.COLUMNS_NAMES.P_VALUE, 0),
+            meanDifference: currentStatsDf.get(C.COLUMNS_NAMES.MEAN_DIFFERENCE, 0),
+          };
+          const distributionRoot = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
+          $(distributionRoot).addClass('d4-flex-col');
+
+          res.push(distributionRoot);
+        }
+      }
+    } else if (splitByPosition.value) {
+      otherStr = otherConst;
+      const activityScaledData = activityScaledCol.getRawData();
+      for (const position of positions) {
+        const posCol = table.getCol(position);
+        const aarList = selectionObject[position];
+        aarStr = `${position}: {${aarList.join(', ')}}`;
+
+        const mask = DG.BitSet.create(rowCount, (i) => aarList.includes(posCol.get(i)));
+        const stats = getStats(activityScaledData, mask);
+        const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
+        const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
+        const distributionRoot = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
+        $(distributionRoot).addClass('d4-flex-col');
+
+        res.push(distributionRoot);
+      }
+    } else if (splitByAAR.value) {
+      const reversedSelectionObject: {[aar: string]: string[]} = {};
+      const aars = [];
+      for (const position of positions) {
+        for (const aar of selectionObject[position]) {
+          if (!reversedSelectionObject.hasOwnProperty(aar)) {
+            reversedSelectionObject[aar] = [position];
+            aars.push(aar);
+            continue;
+          }
+          if (!reversedSelectionObject[aar].includes(position))
+            reversedSelectionObject[aar].push(position);
+        }
+      }
+
+      otherStr = otherConst;
+      const activityScaledData = activityScaledCol.getRawData();
+      for (const aar of aars) {
+        const posList = reversedSelectionObject[aar];
+        aarStr = `${aar}: {${posList.join(', ')}}`;
+
+        const mask = DG.BitSet.create(rowCount, (i) => {
+          const currentRow = table.row(i);
+          for (const position of posList) {
+            if (currentRow.get(position) == aar)
+              return true;
+          }
+          return false;
+        });
+        const stats = getStats(activityScaledData, mask);
+        const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
+        const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
+        const distributionRoot = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
+        $(distributionRoot).addClass('d4-flex-col');
+
+        res.push(distributionRoot);
+      }
+    } else {
+      const splitCol = table.col(C.COLUMNS_NAMES.SPLIT_COL);
+      if (!splitCol)
+        return new DG.Widget(ui.divText('No distribution'));
+
+      otherStr = '';
+      if (useSelectedStr) {
+        aarStr = 'Selected';
+        otherStr = otherConst;
+      } else if (positionsLen) {
+        aarStr = '';
+        for (const position of positions)
+          aarStr += `${position}: {${selectionObject[position].join(', ')}}; `;
+        aarStr = aarStr.slice(0, aarStr.length - 2);
+        otherStr = otherConst;
+      }
 
-export function getDistributionPlot(df: DG.DataFrame, valueCol: string, splitCol: string) {
-  return df.plot.histogram({
-    // const hist = originalDf.plot.histogram({
+      const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
+      const stats = getStats(activityScaledCol.getRawData(), table.selection);
+      const distributionRoot = getDistributionAndStats(distributionTable, stats, aarStr, otherStr);
+      $(distributionRoot).addClass('d4-flex-col');
+
+      res.push(distributionRoot);
+    }
+    $(distributionHost).empty().append(res);
+  };
+
+  const setDefaultProperties = (input: DG.InputBase) => {
+    input.enabled = positionsLen != 0;
+    $(input.root).find('.ui-input-editor').css('margin', '0px');
+    $(input.root).find('.ui-input-bool-deco').css('left', '-35px').css('margin-right', '-35px');
+    $(input.root).find('.ui-input-description').css('padding', '0px');
+  };
+
+  const splitByPosition = ui.boolInput('', model.splitByPos, updateDistributionHost);
+  splitByPosition.addPostfix('Split by position');
+  setDefaultProperties(splitByPosition);
+  $(splitByPosition.root).css('margin-right', '10px');
+  const splitByAAR = ui.boolInput('', model.splitByAAR, updateDistributionHost);
+  splitByAAR.addPostfix('Split by monomer');
+  setDefaultProperties(splitByAAR);
+
+  const controlsHost = ui.divH([splitByPosition.root, splitByAAR.root]);
+  const distributionHost = ui.div([], 'd4-flex-wrap');
+  splitByAAR.fireChanged();
+
+  return new DG.Widget(ui.divV([controlsHost, distributionHost]));
+}
+
+export function getDistributionAndStats(
+  table: DG.DataFrame, stats: Stats, thisLabel: string, otherLabel: string = '', isTooltip: boolean = false,
+): HTMLDivElement {
+  const labels = ui.divV([
+    ui.label(thisLabel, {style: {color: DG.Color.toHtml(otherLabel == '' ? DG.Color.blue : DG.Color.orange)}}),
+    ui.label(otherLabel, {style: {color: DG.Color.toHtml(DG.Color.blue)}})]);
+
+  const histRoot = table.plot.histogram({
     filteringEnabled: false,
-    valueColumnName: valueCol,
-    splitColumnName: splitCol,
+    valueColumnName: table.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)?.name,
+    splitColumnName: C.COLUMNS_NAMES.SPLIT_COL,
     legendVisibility: 'Never',
     showXAxis: true,
     showColumnSelector: false,
     showRangeSlider: false,
-  });
-}
+    showBinSelector: !isTooltip,
+    backColor: isTooltip ? '#fdffe5' : '#fffff',
+  }).root;
+  histRoot.style.width = 'auto';
 
-export function getDistributionWidget(table: DG.DataFrame): DG.Widget {
-  // const labelStr = this.multipleFilter.filterLabel;
-  const splitCol = table.col(C.COLUMNS_NAMES.SPLIT_COL);
-  if (!splitCol)
-    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 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;
-
-    hist.style.width = 'auto';
-    elements.push(hist);
-
-    const stats = (table.temp[C.STATS] as FilteringStatistics).result;
-    if (stats) {
-      const tableMap: StringDictionary = {
-        'Statistics:': '',
-        'Count': stats.count.toString(),
-        'p-value': stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(2),
-        'Mean difference': stats.meanDifference.toFixed(2),
-      };
-
-      elements.push(ui.tableFromMap(tableMap));
-    }
-    return ui.divV(elements);
+  const tableMap: StringDictionary = {
+    'Statistics:': '',
+    'Count': stats.count.toString(),
+    'Ratio': stats.ratio.toFixed(2),
+    'p-value': stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(2),
+    'Mean difference': stats.meanDifference.toFixed(2),
   };
 
-  return new DG.Widget(getContent());
+  const result = ui.divV([labels, histRoot, ui.tableFromMap(tableMap)]);
+  result.style.minWidth = '200px';
+  if (isTooltip)
+    histRoot.style.maxHeight = '150px';
+  return result;
 }

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

@@ -11,16 +11,11 @@ import {KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
  * @return {any} Embedding (and distance matrix where applicable).
  */
 function onMessage(columnData: any[], method: KnownMethods, measure: KnownMetrics, options: any): any {
-  const reducer = new DimensionalityReducer(
-    columnData,
-    method,
-    measure,
-    options,
-  );
+  const reducer = new DimensionalityReducer(columnData, method, measure, options);
   return reducer.transform(true);
 }
 
-self.onmessage = ({data: {columnData, method, measure, options}}) => {
+self.onmessage = ({data: {columnData, method, measure, options}}): void => {
   const embedding = onMessage(columnData, method, measure, options);
   self.postMessage({
     distance: embedding.distance,

package/{test-Peptides-2f94f62b59a8-c6d7c434.html → test-Peptides-34f75e5127b8-4210edfc.html}

@@ -1,4 +1,4 @@
-<html><head><meta charset="utf-8"/><title>Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=2f94f62b59a8. Commit c6d7c434.</title><style type="text/css">html,
+<html><head><meta charset="utf-8"/><title>Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=34f75e5127b8. Commit 4210edfc.</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=2f94f62b59a8. Commit c6d7c434.</h1></header><div id="metadata-container"><div id="timestamp">Started: 2022-05-09 13:23:40</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.439s</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.
+</style></head><body><div id="jesthtml-content"><header><h1 id="title">Peptides Test Report. Datagrok version datagrok/datagrok:latest SHA=34f75e5127b8. Commit 4210edfc.</h1></header><div id="metadata-container"><div id="timestamp">Started: 2022-07-08 12:49:24</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">113.293s</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.003s</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)