@datagrok/peptides 1.3.8 → 1.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datagrok/peptides",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "author": {
     "name": "Volodymyr Dyma",
     "email": "vdyma@datagrok.ai"

package/src/model.ts

@@ -1,7 +1,6 @@
 import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 
@@ -10,15 +9,17 @@ import * as rxjs from 'rxjs';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
-import {calculateBarsData, getTypedArrayConstructor, isGridCellInvalid, scaleActivity} from './utils/misc';
-import {MutationCliffsViewer, SARViewerBase, MostPotentResiduesViewer} from './viewers/sar-viewer';
+import {isGridCellInvalid, scaleActivity} from './utils/misc';
+import {MutationCliffsViewer, MostPotentResiduesViewer} from './viewers/sar-viewer';
 import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
 import {getDistributionAndStats, getDistributionWidget} from './widgets/distribution';
 import {getStats, Stats} from './utils/statistics';
 import {LogoSummary} from './viewers/logo-summary';
 import {getSettingsDialog} from './widgets/settings';
-import {getMoomerWorks} from './package';
+import {getMonomerWorks} from './package';
+import * as bio from '@datagrok-libraries/bio';
+import {findMutations} from './utils/algorithms';
 
 export class PeptidesModel {
   static modelName = 'peptidesModel';
@@ -51,15 +52,21 @@ export class PeptidesModel {
   isChangingEdfBitset = false;
 
   monomerMap: { [key: string]: { molfile: string, fullName: string } } = {};
-  barData: type.MonomerDfStats = {};
-  barsBounds: { [position: string]: type.BarCoordinates } = {};
-  cachedBarchartTooltip: { bar: string, tooltip: null | HTMLDivElement } = {bar: '', tooltip: null};
+  monomerLib: bio.IMonomerLib | null = null; // To get monomers from lib(s)
+  monomerWorks: bio.MonomerWorks | null = null; // To get processed monomers
 
   _settings!: type.PeptidesSettings;
   isRibbonSet = false;
 
+  cp: bio.SeqPalette;
+  xorBitset?: DG.BitSet;
+  initBitset: DG.BitSet;
+  isInvariantMapTrigger: boolean = false;;
+
   private constructor(dataFrame: DG.DataFrame) {
     this.df = dataFrame;
+    this.initBitset = this.df.filter.clone();
+    this.cp = bio.pickUpPalette(this.df.getCol(C.COLUMNS_NAMES.MACROMOLECULE));
   }
 
   static async getInstance(dataFrame: DG.DataFrame): Promise<PeptidesModel> {
@@ -100,7 +107,9 @@ export class PeptidesModel {
   set invariantMapSelection(selection: type.PositionToAARList) {
     this._invariantMapSelection = selection;
     this.df.tags[C.TAGS.FILTER] = JSON.stringify(selection);
+    this.isInvariantMapTrigger = true;
     this.df.filter.fireChanged();
+    this.isInvariantMapTrigger = false;
     this.invalidateGrids();
   }
 
@@ -180,7 +189,7 @@ export class PeptidesModel {
 
   updateDefault(): void {
     if ((this.sourceGrid && !this._isUpdating) || !this.isInitialized) {
-      this.isInitialized = true;
+      // this.isInitialized = true;
       this._isUpdating = true;
       this.initializeViewersComponents();
       //FIXME: modify during the initializeViewersComponents stages
@@ -204,7 +213,7 @@ export class PeptidesModel {
     const alphabet = col.tags['alphabet'];
     const splitSeqDf = splitAlignedSequences(col);
 
-    this.barData = calculateBarsData(splitSeqDf.columns.toList(), this.df.selection);
+    // this.barData = calculateBarsData(splitSeqDf.columns.toList(), this.df.selection);
 
     const positionColumns = splitSeqDf.columns.names();
 
@@ -239,7 +248,9 @@ export class PeptidesModel {
     // SAR vertical table (naive, choose best Mean difference from pVals <= 0.01)
     const sequenceDf = this.createVerticalTable();
 
-    this.calcSubstitutions();
+    const scaledActivityCol = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+    const monomerColumns = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER);
+    this.substitutionsInfo = findMutations(scaledActivityCol, monomerColumns, this.settings);
 
     [this.mutationCliffsGrid, this.mostPotentResiduesGrid] =
       this.createGrids(matrixDf, sequenceDf, positionColumns, alphabet);
@@ -254,7 +265,7 @@ export class PeptidesModel {
 
     positionColumns.push(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
 
-    this.setBarChartInteraction();
+    // this.setBarChartInteraction();
 
     this.setCellRenderers(positionColumns);
 
@@ -268,91 +279,6 @@ export class PeptidesModel {
     this.postProcessGrids();
   }
 
-  //TODO: move out
-  calcSubstitutions(): void {
-    const activityValues: DG.Column<number> = this.df.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
-    const columnList: DG.Column<string>[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER);
-    const nCols = columnList.length;
-    if (nCols == 0)
-      throw new Error(`Couldn't find any column of semType '${C.SEM_TYPES.MONOMER}'`);
-
-    this.substitutionsInfo = new Map();
-    const nRows = this.df.rowCount;
-    for (let seq1Idx = 0; seq1Idx < nRows - 1; seq1Idx++) {
-      for (let seq2Idx = seq1Idx + 1; seq2Idx < nRows; seq2Idx++) {
-        let substCounter = 0;
-        const activityValSeq1 = activityValues.get(seq1Idx)!;
-        const activityValSeq2 = activityValues.get(seq2Idx)!;
-        const delta = activityValSeq1 - activityValSeq2;
-        if (Math.abs(delta) < (this.settings.minActivityDelta ?? 0))
-          continue;
-
-        let substCounterFlag = false;
-        const tempData: { pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number }[] =
-          [];
-        for (const currentPosCol of columnList) {
-          const seq1monomer = currentPosCol.get(seq1Idx)!;
-          const seq2monomer = currentPosCol.get(seq2Idx)!;
-          if (seq1monomer == seq2monomer)
-            continue;
-
-          substCounter++;
-          substCounterFlag = substCounter > (this.settings.maxMutations ?? 1);
-          if (substCounterFlag)
-            break;
-
-          tempData.push({
-            pos: currentPosCol.name,
-            seq1monomer: seq1monomer,
-            seq2monomer: seq2monomer,
-            seq1Idx: seq1Idx,
-            seq2Idx: seq2Idx,
-          });
-        }
-
-        if (substCounterFlag || substCounter == 0)
-          continue;
-
-        for (const tempDataElement of tempData) {
-          const position = tempDataElement.pos;
-
-          //Working with seq1monomer
-          const seq1monomer = tempDataElement.seq1monomer;
-          if (!this.substitutionsInfo.has(seq1monomer))
-            this.substitutionsInfo.set(seq1monomer, new Map());
-
-          let positionsMap = this.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);
-
-          //Working with seq2monomer
-          const seq2monomer = tempDataElement.seq2monomer;
-          if (!this.substitutionsInfo.has(seq2monomer))
-            this.substitutionsInfo.set(seq2monomer, new Map());
-
-          positionsMap = this.substitutionsInfo.get(seq2monomer)!;
-          if (!positionsMap.has(position))
-            positionsMap.set(position, new Map());
-
-          indexes = positionsMap.get(position)!;
-          !indexes.has(seq2Idx) ? indexes.set(seq2Idx, [seq1Idx]) : (indexes.get(seq2Idx)! as number[]).push(seq1Idx);
-        }
-      }
-    }
-
-    const TypedArray = getTypedArrayConstructor(nRows);
-    for (const positionMap of this.substitutionsInfo.values()) {
-      for (const indexMap of positionMap.values()) {
-        for (const [index, indexArray] of indexMap.entries())
-          indexMap.set(index, new TypedArray(indexArray));
-      }
-    }
-  }
-
   initSelections(positionColumns: string[]): void {
     const tempInvariantMapSelection: type.PositionToAARList = this.invariantMapSelection;
     const mutationCliffsSelection: type.PositionToAARList = this.mutationCliffsSelection;
@@ -362,7 +288,7 @@ export class PeptidesModel {
     }
     this.invariantMapSelection = tempInvariantMapSelection;
     this.mutationCliffsSelection = mutationCliffsSelection;
-    this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+    // this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
   }
 
   joinDataFrames(positionColumns: string[], splitSeqDf: DG.DataFrame, alphabet: string): void {
@@ -563,6 +489,9 @@ export class PeptidesModel {
       tempDfList[index] = dfSlice;
       webLogoCol.set(index, index.toString());
       membersCol.set(index, dfSlice.rowCount);
+      //TODO: user should be able to choose threshold
+      if (dfSlice.rowCount <= Math.ceil(this.clusterStatsDf.getCol(C.COLUMNS_NAMES.COUNT).stats.max * 0.70))
+        summaryTable.filter.set(index, false, false);
     }
     webLogoCol.setTag(DG.TAGS.CELL_RENDERER, 'html');
 
@@ -589,7 +518,7 @@ export class PeptidesModel {
         this.modifyClusterSelection(cluster);
       else
         this.initClusterSelection(cluster);
-      this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+      // this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
     });
     grid.onCellRender.subscribe((gridCellArgs) => {
       const gc = gridCellArgs.cell;
@@ -632,51 +561,51 @@ export class PeptidesModel {
     this.logoSummarySelection = [cluster];
   }
 
-  setBarChartInteraction(): void {
-    const eventAction = (ev: MouseEvent): void => {
-      const cell = this.sourceGrid.hitTest(ev.offsetX, ev.offsetY);
-      if (cell?.isColHeader && cell.tableColumn?.semType == C.SEM_TYPES.MONOMER) {
-        const newBarPart = this.findAARandPosition(cell, ev);
-        this.requestBarchartAction(ev, newBarPart);
-      }
-    };
-
-    // The following events makes the barchart interactive
-    rxjs.fromEvent<MouseEvent>(this.sourceGrid.overlay, 'mousemove')
-      .subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
-    rxjs.fromEvent<MouseEvent>(this.sourceGrid.overlay, 'click')
-      .subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
-  }
-
-  findAARandPosition(cell: DG.GridCell, ev: MouseEvent): { monomer: string, position: string } | null {
-    const barCoords = this.barsBounds[cell.tableColumn!.name];
-    for (const [monomer, coords] of Object.entries(barCoords)) {
-      const isIntersectingX = ev.offsetX >= coords.x && ev.offsetX <= coords.x + coords.width;
-      const isIntersectingY = ev.offsetY >= coords.y && ev.offsetY <= coords.y + coords.height;
-      if (isIntersectingX && isIntersectingY)
-        return {monomer: monomer, position: cell.tableColumn!.name};
-    }
-
-    return null;
-  }
-
-  requestBarchartAction(ev: MouseEvent, barPart: { position: string, monomer: string } | null): void {
-    if (!barPart)
-      return;
-    const monomer = barPart.monomer;
-    const position = barPart.position;
-    if (ev.type === 'click') {
-      ev.shiftKey ? this.modifyMonomerPositionSelection(monomer, position, true) :
-        this.initMonomerPositionSelection(monomer, position, true);
-      this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
-    } else {
-      const bar = `${monomer}:${position}`;
-      if (this.cachedBarchartTooltip.bar == bar)
-        ui.tooltip.show(this.cachedBarchartTooltip.tooltip!, ev.clientX, ev.clientY);
-      else
-        this.cachedBarchartTooltip = {bar: bar, tooltip: this.showTooltipAt(monomer, position, ev.clientX, ev.clientY)};
-    }
-  }
+  // setBarChartInteraction(): void {
+  //   const eventAction = (ev: MouseEvent): void => {
+  //     const cell = this.sourceGrid.hitTest(ev.offsetX, ev.offsetY);
+  //     if (cell?.isColHeader && cell.tableColumn?.semType == C.SEM_TYPES.MONOMER) {
+  //       const newBarPart = this.findAARandPosition(cell, ev);
+  //       this.requestBarchartAction(ev, newBarPart);
+  //     }
+  //   };
+
+  //   // The following events makes the barchart interactive
+  //   rxjs.fromEvent<MouseEvent>(this.sourceGrid.overlay, 'mousemove')
+  //     .subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
+  //   rxjs.fromEvent<MouseEvent>(this.sourceGrid.overlay, 'click')
+  //     .subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
+  // }
+
+  // findAARandPosition(cell: DG.GridCell, ev: MouseEvent): { monomer: string, position: string } | null {
+  //   const barCoords = this.barsBounds[cell.tableColumn!.name];
+  //   for (const [monomer, coords] of Object.entries(barCoords)) {
+  //     const isIntersectingX = ev.offsetX >= coords.x && ev.offsetX <= coords.x + coords.width;
+  //     const isIntersectingY = ev.offsetY >= coords.y && ev.offsetY <= coords.y + coords.height;
+  //     if (isIntersectingX && isIntersectingY)
+  //       return {monomer: monomer, position: cell.tableColumn!.name};
+  //   }
+
+  //   return null;
+  // }
+
+  // requestBarchartAction(ev: MouseEvent, barPart: { position: string, monomer: string } | null): void {
+  //   if (!barPart)
+  //     return;
+  //   const monomer = barPart.monomer;
+  //   const position = barPart.position;
+  //   if (ev.type === 'click') {
+  //     ev.shiftKey ? this.modifyMonomerPositionSelection(monomer, position, true) :
+  //       this.initMonomerPositionSelection(monomer, position, true);
+  //     this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+  //   } else {
+  //     const bar = `${monomer}:${position}`;
+  //     if (this.cachedBarchartTooltip.bar == bar)
+  //       ui.tooltip.show(this.cachedBarchartTooltip.tooltip!, ev.clientX, ev.clientY);
+  //     else
+  //       this.cachedBarchartTooltip = {bar: bar, tooltip: this.showTooltipAt(monomer, position, ev.clientX, ev.clientY)};
+  //   }
+  // }
 
   setCellRenderers(renderColNames: string[]): void {
     const mdCol = this.monomerPositionStatsDf.getCol(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
@@ -731,22 +660,40 @@ export class PeptidesModel {
 
     this.sourceGrid.setOptions({'colHeaderHeight': 130});
     this.sourceGrid.onCellRender.subscribe((gcArgs) => {
-      const context = gcArgs.g;
+      const ctx = gcArgs.g;
       const bounds = gcArgs.bounds;
       const col = gcArgs.cell.tableColumn;
 
-      context.save();
-      context.beginPath();
-      context.rect(bounds.x, bounds.y, bounds.width, bounds.height);
-      context.clip();
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(bounds.x, bounds.y, bounds.width, bounds.height);
+      ctx.clip();
 
       if (gcArgs.cell.isColHeader && col?.semType == C.SEM_TYPES.MONOMER) {
-        const barBounds = CR.renderBarchart(context, col, this.barData[col.name], bounds, this.df.filter.trueCount);
-        this.barsBounds[col.name] = barBounds;
+        const countStatsCol: DG.Column<number> = this.monomerPositionStatsDf.getCol(C.COLUMNS_NAMES.COUNT);
+        const monomerStatsCol: DG.Column<string> = this.monomerPositionStatsDf.getCol(C.COLUMNS_NAMES.MONOMER);
+        const positionStatsCol: DG.Column<string> = this.monomerPositionStatsDf.getCol(C.COLUMNS_NAMES.POSITION);
+        const rowMask = DG.BitSet.create(this.monomerPositionStatsDf.rowCount, (i) => positionStatsCol.get(i) === col.name);
+        //TODO: precalc on stats creation
+        const sortedStatsOrder = this.monomerPositionStatsDf.getSortedOrder([C.COLUMNS_NAMES.COUNT], [false], rowMask)
+          .sort((a, b) => {
+            if (monomerStatsCol.get(a) === '-')
+              return -1;
+            else if (monomerStatsCol.get(b) === '-')
+              return +1;
+            return 0;
+          });
+        const statsInfo: type.StatsInfo = {
+          countCol: countStatsCol,
+          monomerCol: monomerStatsCol,
+          orderedIndexes: sortedStatsOrder,
+        };
+
+        CR.drawLogoInBounds(ctx, bounds, statsInfo, this.df.rowCount, this.cp);
         gcArgs.preventDefault();
       }
 
-      context.restore();
+      ctx.restore();
     });
   }
 
@@ -787,7 +734,7 @@ export class PeptidesModel {
     const tooltipElements: HTMLDivElement[] = [];
     const monomerName = aar.toLowerCase();
 
-    let mw = getMoomerWorks();
+    let mw = getMonomerWorks();
     let mol = mw?.getCappedRotatedMonomer('PEPTIDE', aar);
 
     if (mol) {
@@ -856,7 +803,7 @@ export class PeptidesModel {
       (aar: string, position: string, isShiftPressed: boolean, isInvariantMapSelection: boolean = true): void => {
         isShiftPressed ? this.modifyMonomerPositionSelection(aar, position, isInvariantMapSelection) :
           this.initMonomerPositionSelection(aar, position, isInvariantMapSelection);
-        this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+        // this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
       };
 
     this.mutationCliffsGrid.root.addEventListener('click', (ev) => {
@@ -967,18 +914,26 @@ export class PeptidesModel {
     };
 
     selection.onChanged.subscribe(() => changeSelectionBitset(selection));
+    
     filter.onChanged.subscribe(() => {
       const positionList = Object.keys(this.invariantMapSelection);
-      for (let index = 0; index < this.df.rowCount; ++index) {
+      const invariantMapBitset = DG.BitSet.create(filter.length, (index) => {
         let result = true;
         for (const position of positionList) {
           const aarList = this.invariantMapSelection[position];
           result &&= aarList.length === 0 || aarList.includes(this.df.get(position, index));
           if (!result)
-            break;
+            return result;
         }
-        filter.set(index, filter.get(index) && result, false);
-      }
+        return result;
+      });
+
+      if (!this.isInvariantMapTrigger)
+        this.initBitset = filter.clone();
+
+      // filter.copyFrom(invariantMapBitset.and(this.initBitset), false);
+      const temp = invariantMapBitset.and(this.initBitset);
+      filter.init((i) => temp.get(i), false);
     });
     this.isBitsetChangedInitialized = true;
   }
@@ -1021,6 +976,14 @@ export class PeptidesModel {
     setViewerGridProps(this.mostPotentResiduesGrid);
     if (this.df.getTag(C.TAGS.CLUSTERS))
       setViewerGridProps(this.logoSummaryGrid);
+
+    for (let gcIndex = 0; gcIndex < this.sourceGrid.columns.length; ++gcIndex) {
+      const col = this.sourceGrid.columns.byIndex(gcIndex)!;
+      col.visible =
+        col.column?.semType === C.SEM_TYPES.MONOMER ||
+        col.column?.name === C.COLUMNS_NAMES.ACTIVITY_SCALED ||
+        Object.keys(this.settings.columns ?? {}).includes(col.column?.name ?? '');
+    }
   }
 
   getSplitColValueAt(index: number, aar: string, position: string, aarLabel: string): string {
@@ -1040,19 +1003,26 @@ export class PeptidesModel {
   async init(): Promise<void> {
     if (this.isInitialized)
       return;
+    this.isInitialized = true;
+
+    // Don't find the dataset if the analysis started from button
+    if (this.df.getTag('newAnalysis') !== '1')
+      this.currentView = wu(grok.shell.tableViews).find(({dataFrame}) => dataFrame.tags[C.PEPTIDES_ANALYSIS] === '1')!;
+
+    this.currentView ??= grok.shell.addTableView(this.df);
 
-    this.currentView = wu(grok.shell.tableViews).find(({dataFrame}) => dataFrame.tags[C.PEPTIDES_ANALYSIS] === 'true') ??
-      grok.shell.addTableView(this.df);
+    this.df.setTag('newAnalysis', '');
     if (!this.isRibbonSet) {
-      this.currentView.setRibbonPanels([[ui.icons.settings(() => getSettingsDialog(this))]], false);
+      const settingsButton = ui.bigButton('Settings', () => getSettingsDialog(this), 'Peptides analysis settings');
+      this.currentView.setRibbonPanels([[settingsButton]], false);
       this.isRibbonSet = true;
     }
     grok.shell.v = this.currentView;
     this.sourceGrid = this.currentView.grid;
-    if (this.df.tags[C.PEPTIDES_ANALYSIS] === 'true')
+    if (this.df.tags[C.PEPTIDES_ANALYSIS] === '1')
       return;
 
-    this.df.tags[C.PEPTIDES_ANALYSIS] = 'true';
+    this.df.tags[C.PEPTIDES_ANALYSIS] = '1';
     const scaledGridCol = this.sourceGrid.col(C.COLUMNS_NAMES.ACTIVITY_SCALED)!;
     scaledGridCol.name = scaledGridCol.column!.getTag('gridName');
     scaledGridCol.format = '#.000';

package/src/package.ts

@@ -2,7 +2,6 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 import * as C from './utils/constants';
 
 import {analyzePeptidesUI} from './widgets/peptides';
@@ -12,14 +11,15 @@ import {MutationCliffsViewer, MostPotentResiduesViewer} from './viewers/sar-view
 
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
 import {LogoSummary} from './viewers/logo-summary';
+import {MonomerWorks} from '@datagrok-libraries/bio';
 
-export let monomerWorks: bio.MonomerWorks | null;
+export let monomerWorks: MonomerWorks | null;
 
 export const _package = new DG.Package();
 let currentTable: DG.DataFrame;
 let alignedSequenceColumn: DG.Column;
 
-export function getMoomerWorks() {
+export function getMonomerWorks() {
   return monomerWorks;
 };
 
@@ -42,7 +42,7 @@ export async function Peptides(): Promise<void> {
   const textLink = ui.inlineText(['For more details, see our ', wikiLink, '.']);
   if (monomerWorks == null) {
     let lib = await grok.functions.call('Bio:getBioLib');
-    monomerWorks = new bio.MonomerWorks(lib);
+    monomerWorks = new MonomerWorks(lib);
   }
   const appDescription = ui.info(
     [

package/src/tests/algorithms.ts

@@ -0,0 +1,51 @@
+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 {_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 settings: type.PeptidesSettings;
+
+  before(async () => {
+    activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]);
+    monomerColumns = [
+      DG.Column.fromList('string', '1', 'ABC'.split('')),
+      DG.Column.fromList('string', '2', 'ACC'.split('')),
+      DG.Column.fromList('string', '3', 'ACD'.split('')),
+    ];
+    settings = {maxMutations: 1, minActivityDelta: 2};
+  });
+
+  test('MutationCliffs', async () => {
+    const substInfo: type.SubstitutionsInfo = findMutations(activityCol, monomerColumns, settings);
+    expect(substInfo.has('C'), true);
+    expect(substInfo.has('D'), true);
+    expect(substInfo.has('A'), false);
+
+    const c = substInfo.get('C')!;
+    const d = substInfo.get('D')!;
+    expect(c.has('3'), true);
+    expect(d.has('3'), true);
+
+    const c3 = c.get('3')!;
+    const d3 = d.get('3')!;
+    expect(c3.has(2), true);
+    expect(d3.has(3), true);
+
+    const c32 = c3.get(2)!;
+    const d33 = d3.get(3)!;
+    expect(c32[0], 3);
+    expect(d33[0], 2);
+  });
+});

package/src/tests/core.ts

@@ -1,6 +1,5 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
-import * as bio from '@datagrok-libraries/bio';
 
 import {category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
 
@@ -9,6 +8,7 @@ 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';
 
 category('Core', () => {
   let simpleTable: DG.DataFrame;
@@ -33,9 +33,9 @@ category('Core', () => {
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
     simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
-    simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, bio.ALPHABET.PT);
-    simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    simpleAlignedSeqCol.setTag(bio.TAGS.aligned, bio.ALIGNMENT.SEQ_MSA);
+    simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
+    simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
     model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');
@@ -53,9 +53,9 @@ category('Core', () => {
     complexActivityCol = complexTable.getCol(complexActivityColName);
     complexAlignedSeqCol = complexTable.getCol('MSA');
     complexAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
-    complexAlignedSeqCol.setTag(C.TAGS.ALPHABET, bio.ALPHABET.UN);
-    complexAlignedSeqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.SEPARATOR);
-    complexAlignedSeqCol.setTag(bio.TAGS.aligned, bio.ALIGNMENT.SEQ_MSA);
+    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] = '/';
     complexScaledCol = scaleActivity(complexActivityCol, '-lg');
 
@@ -75,9 +75,9 @@ category('Core', () => {
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
     simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
-    simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, bio.ALPHABET.PT);
-    simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, bio.NOTATION.FASTA);
-    simpleAlignedSeqCol.setTag(bio.TAGS.aligned, bio.ALIGNMENT.SEQ_MSA);
+    simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
+    simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
+    simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
     model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');