@datagrok/peptides 0.8.9 → 0.8.13

package/src/tests/peptides-tests.ts

@@ -1,77 +1,48 @@
 import {after, before, category, test} from '@datagrok-libraries/utils/src/test';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
-// import {splitAlignedPeptides} from '../utils/split-aligned';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import {PeptidesController} from '../peptides';
-import {describe} from '../describe';
 import {analyzePeptidesWidget} from '../widgets/analyze-peptides';
 import {manualAlignmentWidget} from '../widgets/manual-alignment';
 import {peptideMoleculeWidget} from '../widgets/peptide-molecule';
-import * as P from '../package';
-
-// let _package = new DG.Package();
+import {_packageTest} from '../package-test';
 
 category('peptides', async () => {
   let peptidesDf: DG.DataFrame;
   let options: StringDictionary;
-  let peptidesGrid: DG.Grid;
+  // let peptidesGrid: DG.Grid;
   let asCol: DG.Column;
-  let pepView: DG.TableView;
+  // let pepView: DG.TableView;
 
   before(async () => {
-    // peptidesDf = DG.DataFrame.fromCsv(await P._package.files.readAsText('aligned.csv'));
-    const csv = `ID,AlignedSequence,IC50
-    1,NH2--A-Q-T-T-Y-K-N-Y-R-R-N-L-L--COOH,4.6411368455908086e-4
-    2,NH2-M-A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.003327324930165897
-    3,NH2--A-N-T-T-Y-K-C-Y-R-R-N-L-L--COOH,3.0748148478921324e-4
-    4,NH2--A-N-T-T-Y-K-F-Y-R-R-N-L-L--COOH,0.0015532837750281958
-    5,NH2--A-V-T-T-Y-K-N-Y-R-R-N-L-L--COOH,6.549885174778741e-4
-    6,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.00213298315038382
-    7,NH2--A-N-T-T-Y-K-N-Y-R-F-N-L-L--COOH,0.002171297321903189
-    8,NH2--A-N-T-T-Y-K-N-Y-R-R-N-H-L--COOH,0.002060711496394637
-    9,NH2-M-A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.0016058870359321516
-    10,NH2--A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.00212911675087592
-    11,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.002736311013579287
-    12,NH2--A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,5.673074652436946e-5
-    13,NH2-C-A-N-T-T-Y-K-N-Y-R-R-N-L-L--COOH,0.0032881139376902814
-    14,NH2--A-N-T-T-Y-K-N-Y-R-H-N-L-L--COOH,0.0012828163841736553
-    15,NH2-Y-A-N-T-T-Y-K-N-Y-R-D-N-L-L--COOH,7.186983807098166e-4
-    16,NH2-M-A-N-T-T-Y-K-N-Y-R-N-N-L-L--COOH,0.00659708587488309
-    17,NH2-P-A-N-T-T-Y-K-N-Y-R-G-N-L-L--COOH,3.7620528849324097e-4
-    18,NH2-Y-A-N-T--Y-K-N-Y-R-S-N-L-L--COOH,6.812868474160967e-4
-    19,NH2--A-N-T-T-Y-K-N-Y-R-S-N-L-L--COOH,0.0010148578953195436`;
-    peptidesDf = DG.DataFrame.fromCsv(csv);
+    peptidesDf = DG.DataFrame.fromCsv(await _packageTest.files.readAsText('aligned.csv'));
     options = {
-      'activityColumnName': 'IC50',
-      'scaling': '-lg',
+      activityColumnName: 'IC50',
+      scaling: '-lg',
     };
     asCol = peptidesDf.getCol('AlignedSequence');
-    pepView = grok.shell.addTableView(peptidesDf);
-    peptidesGrid = pepView.grid;
+    // pepView = grok.shell.addTableView(peptidesDf);
+    // peptidesGrid = pepView.grid;
   });
 
   test('utils.split-sequence', async () => {
     PeptidesController.splitAlignedPeptides(peptidesDf.getCol('AlignedSequence'));
   });
 
-  test('describe', async () => {
-    await describe(
-      peptidesDf, options['activityColumnName'], options['scaling'], peptidesGrid, true,
-      DG.BitSet.create(peptidesDf.rowCount, (i) => i % 2 === 0), true);
-  });
+  // test('describe', async () => {
+  //   await describe(
+  //     peptidesDf, options['activityColumnName'], options['scaling'], peptidesGrid, true,
+  //     DG.BitSet.create(peptidesDf.rowCount, (i) => i % 2 === 0), true);
+  // });
 
   test('Peptides-controller', async () => {
-    const peptides = PeptidesController.getInstance(peptidesDf);
-    peptides.init(peptidesGrid, pepView, options, asCol, peptidesDf.columns.names());
-  });
-
-  test('panel.peptides', async () => {
-    await P.peptidesPanel(asCol);
+    const peptides = await PeptidesController.getInstance(peptidesDf);
+    peptides.init(peptidesDf); //, peptidesDf.columns.names());
   });
 
   test('widgets.analyze-peptides', async () => {
-    await analyzePeptidesWidget(asCol, pepView, peptidesGrid, peptidesDf);
+    await analyzePeptidesWidget(peptidesDf, asCol);
   });
 
   test('widgets.manual-alignment', async () => {
@@ -82,40 +53,8 @@ category('peptides', async () => {
     await peptideMoleculeWidget('NH2--A-N-T-T-Y-K-N-Y-R-S-N-L-L--COOH');
   });
 
-  test('widgets.molfile', async () => {
-    await P.peptideMolfile2('');
-  });
-
-  test('renderers.aligned-sequence-cell', async () => {
-    P.alignedSequenceCellRenderer();
-  });
-
-  test('renderers.amino-acids-cell', async () => {
-    P.aminoAcidsCellRenderer();
-  });
-
-  test('viewers.logo-viewer', async () => {
-    P.logov();
-  });
-
-  test('viewers.sar-viewer', async () => {
-    P.sar();
-  });
-
-  test('viewers.sar-vertical-viewer', async () => {
-    P.sarVertical();
-  });
-
-  test('viewers.stacked-barchart-viewer', async () => {
-    P.stackedBarChart();
-  });
-
-  test('viewers.subst-viewer', async () => {
-    P.subst();
-  });
-
   after(async () => {
-    pepView.close();
+    // pepView.close();
     grok.shell.closeTable(peptidesDf);
   });
 });

package/src/tests/utils.ts

@@ -86,13 +86,7 @@ export async function _testPeptideSimilaritySpaceViewer(
 
   try {
     viewer = await createPeptideSimilaritySpaceViewer(
-      table,
-      alignedSequencesColumn,
-      method,
-      measure,
-      cyclesCount,
-      null,
-    );
+      table, method, measure, cyclesCount, undefined, alignedSequencesColumn);
     df = viewer.dataFrame!;
   } catch (error) {
     noException = false;

package/src/utils/SAR-multiple-filter.ts

@@ -0,0 +1,439 @@
+import * as DG from 'datagrok-api/dg';
+
+import * as rxjs from 'rxjs';
+
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {MultipleSelection} from './SAR-multiple-selection';
+import {FilteringStatistics, Stats as FilterStats} from './filtering-statistics';
+
+import * as C from './constants';
+
+/**
+ * Implements multiple filtering callbacks to be used in events subscription.
+ */
+export class SARMultipleFilter {
+  protected selection: MultipleSelection;
+  protected resources: Resources;
+  protected filterMode: boolean;
+  protected stats: FilteringStatistics;
+
+  /**
+   * Creates an instance of SARMultipleFilter.
+   * @param {boolean} filterMode Whether to filter or to select.
+   */
+  constructor(filterMode: boolean) {
+    this.filterMode = filterMode;
+    this.resources = new Resources();
+    this.selection = new MultipleSelection();
+    this.stats = new FilteringStatistics();
+  }
+
+  /** Makes label to display filtered residue-positions on accordion. */
+  get filterLabel() {
+    return this.selection.toString();
+  }
+
+  /** Makes query to display data frame statistics on accordion. */
+  get query(): string {
+    this.resources.assert(['residueColumnName']);
+    return this.selection.toQuery(this.resources.residueColumnName);
+  }
+
+  /**
+   * Updates filtering mode.
+   * @param {boolean} value Filtering if true or selection else.
+   */
+  set filteringMode(value: boolean) {
+    this.filterMode = value;
+  }
+
+  /** Returns bit set obtained from selection mask. */
+  get mask() {
+    this.resources.assert(['dataFrame', 'groupMapping']);
+
+    const df = this.resources.dataFrame!;
+    const mask = this.selection.eval(df, this.resources.groupMapping!);
+    return DG.BitSet.create(mask.length, (i) => mask[i]);
+  }
+
+  /** Resets selection mask. */
+  resetSelection() {
+    this.selection = new MultipleSelection();
+  }
+
+  /**
+   * Adds/updates one of objects required.
+   * @param {ResourceKey} key Resource key.
+   * @param {any} value Resource value.
+   */
+  addResource(key: ResourceKey, value: any) {
+    this.resources.add(key, value);
+  }
+
+  /**
+   * Evaluates selection into mask.
+   * @return {boolean[]} List of booleans where a true corresponds to the row selected.
+   */
+  eval(): boolean[] {
+    this.resources.assert(['dataFrame', 'groupMapping']);
+    return this.selection.eval(this.resources.dataFrame!, this.resources.groupMapping!);
+  }
+
+  /**
+   * Reacts on mouse event.
+   * @param {MouseEventType} eventType Mouse event type.
+   * @param {CellType} cellType Type of the grid cell.
+   * @param {(string | null)} colName Name of column the cell from.
+   * @param {(number | null)} rowIdx Index of the row the cell at.
+   * @param {boolean} ctrlPressed Whether CTRL-button was pressed while catching event.
+   */
+  onSARGridMouseEvent(
+    eventType: MouseEventType,
+    cellType: CellType,
+    colName: string | null,
+    rowIdx: number | null,
+    ctrlPressed: boolean,
+  ) {
+    switch (eventType) {
+    case 'mouseout':
+      this.onSARCellMouseOut();
+      break;
+    case 'click':
+      if (colName)
+        this.onSARCellClicked(colName, rowIdx, ctrlPressed);
+      break;
+    case 'mousemove':
+      this.onSARCellHover(colName, rowIdx);
+      break;
+    }
+  }
+
+  /**
+   * Reacts on click to the SAR viewer cell.
+   * @param {string} colName Name of the column which the cell is from.
+   * @param {(number | null)} rowIdx Index of the row at which the cell is.
+   * @param {boolean} ctrlPressed Whether the CTRL button was pressed.
+   */
+  onSARCellClicked(colName: string, rowIdx: number | null, ctrlPressed: boolean) {
+    this.resources.assert(['dataFrame', 'residueColumnName', 'grid']);
+
+    const residueColumnName = this.resources.residueColumnName!;
+    const grid = this.resources.grid!;
+    const isMultiposSel = colName == residueColumnName;
+    const isMultiresSel = rowIdx === null;
+
+    if (isMultiposSel && isMultiresSel)
+      return;
+
+    const changeFilter = ctrlPressed ? this.selection.input : this.selection.set;
+    const df = grid.dataFrame!;
+    const columns = df.columns as DG.ColumnList;
+    let pos: string | undefined;
+    let res: string | undefined;
+
+    if (!isMultiposSel)
+      pos = colName;
+    if (!isMultiresSel)
+      res = df.get(residueColumnName, rowIdx);
+
+    if (isMultiposSel)
+      this.selection.setRes(res!, columns.names().slice(1)); // All except the first residues column.
+    else if (isMultiresSel)
+      this.selection.setPos(pos!, df.col(residueColumnName)!.toList());
+    else
+      changeFilter.bind(this.selection)(pos!, res!);
+
+    // console.warn([ctrlPressed ? 'ctrl+click' : 'click', this.selection.filter]);
+
+    if (this.filterMode)
+      this.resources.dataFrame!.rows.requestFilter();
+    else
+      this.maskRows();
+
+    this.createSplitCol();
+    this.resources.dataFrame!.temp[C.STATS] = this.getStatistics();
+
+    grid.invalidate();
+  }
+
+  createSplitCol() {
+    this.resources.assert(['grid', 'dataFrame']);
+
+    const viewerDf = this.resources.grid!.dataFrame!;
+    const df = this.resources.dataFrame!;
+    let aarLabel = this.filterLabel;
+    if (aarLabel === '') {
+      const currentAAR: string = viewerDf.get(C.COLUMNS_NAMES.AMINO_ACID_RESIDUE, viewerDf.currentRowIdx);
+      const currentPosition = viewerDf.currentCol?.name;
+
+      aarLabel = (currentAAR && currentPosition) ?? true ? 'All' :
+        `${currentAAR === '-' ? 'Gap' : currentAAR} - ${currentPosition}`;
+    }
+
+    const splitCol = df.col(C.COLUMNS_NAMES.SPLIT_COL) ??
+    df.columns.addNew(C.COLUMNS_NAMES.SPLIT_COL, 'string') as DG.Column;
+
+    const bitset = this.filterMode ? df.filter : df.selection;
+    splitCol.init((i) => bitset.get(i) ? aarLabel : C.CATEGORIES.OTHER);
+    splitCol.setCategoryOrder([aarLabel, C.CATEGORIES.OTHER]);
+    splitCol.compact();
+
+    const colorMap: {[index: string]: string | number} = {};
+
+    colorMap[C.CATEGORIES.OTHER] = DG.Color.blue;
+    colorMap[aarLabel] = DG.Color.orange;
+    // colorMap[currentAAR] = cp.getColor(currentAAR);
+    df.getCol(C.COLUMNS_NAMES.SPLIT_COL).colors.setCategorical(colorMap);
+  }
+
+  /**
+   * Reacts on mouse hover over SAR viewer cell.
+   * @param {(string | null)} colName Name of the column which the cell is from.
+   * @param {(number | null)} rowIdx Index of the row at which the cell is.
+   */
+  onSARCellHover(colName: string | null, rowIdx: number | null) {
+    this.resources.assert(['residueColumnName', 'grid', 'dataFrame']);
+
+    const residueColumnName = this.resources.residueColumnName!;
+
+    if (!colName || !rowIdx || colName == residueColumnName)
+      return;
+
+    const df = this.resources.grid?.dataFrame!;
+
+    if (!(df.columns as DG.ColumnList).names().includes(colName))
+      return;
+
+    const res = df.get(residueColumnName, rowIdx);
+
+    this.resources.dataFrame?.rows.match({[colName]: res}).highlight();
+  }
+
+  /** Reacts on mouse out from the SAR viewer */
+  onSARCellMouseOut() {
+    this.resources.assert(['dataFrame']);
+    this.resources.dataFrame?.rows.match({}).highlight();
+  }
+
+  /** Sets up SAR viewer grid visualization. */
+  setupGridVizualization() {
+    this.resources.assert(['grid']);
+    this.resources.grid?.setOptions({
+      'showCurrentRowIndicator': false,
+      'allowBlockSelection': false,
+      'allowColSelection': false,
+      'allowRowSelection': false,
+      'showMouseOverRowIndicator': false,
+    });
+  }
+
+  /**
+   * Custom renderrer to be applied to SAR viewer cell rendering.
+   * @param {DG.GridCellRenderArgs} args Cell rendering arguments.
+   */
+  selectionCellRenderrer(args: DG.GridCellRenderArgs) {
+    if (args.cell.isTableCell) {
+      this.resources.assert(['residueColumnName', 'groupMapping']);
+
+      const residueColumnName = this.resources.residueColumnName!;
+      const cell = args.cell;
+      const pos = cell.gridColumn.name;
+
+      if (pos !== residueColumnName) {
+        const rowIdx = cell.tableRowIndex!;
+        const res = cell.cell.dataFrame.get(residueColumnName, rowIdx);
+
+        if (this.selection.test(pos, res, this.resources.groupMapping!)) {
+          const ctx = args.g;
+          ctx.lineWidth = 1;
+          ctx.strokeStyle = 'black';
+          ctx.strokeRect(args.bounds.x, args.bounds.y, args.bounds.width, args.bounds.height);
+        }
+      }
+    }
+  }
+
+  /** Reacts on SAR grid update/reloading. */
+  onSARGridChanged() {
+    this.resources.assert(['grid']);
+
+    const grid = this.resources.grid!;
+
+    addGridMouseHandler(grid, this.onSARGridMouseEvent.bind(this));
+    this.setupGridVizualization();
+    grid.onCellRender.subscribe(this.selectionCellRenderrer.bind(this));
+  }
+
+  /** Selects or filters rows depending from the filtering mode set. */
+  maskRows() {
+    this.resources.assert(['dataFrame']);
+
+    const df = this.resources.dataFrame!;
+
+    if (this.filterMode) {
+      df.filter.and(this.mask);
+      df.selection.setAll(false, false);
+
+      // console.warn(['onRowsFiltering', this.selection.filter, df.filter.trueCount]);
+    } else {
+      df.selection.copyFrom(this.mask);
+      df.filter.fireChanged();
+
+      // console.warn(['onSelectionChanged', this.selection.filter, df.selection.trueCount]);
+    }
+  }
+
+  /**
+   * Calculates statistics on the activity column.
+   * @return {FilterStats} Statistics.
+   */
+  getStatistics(): FilterStats {
+    this.resources.assert(['activityColumnName', 'dataFrame']);
+
+    const df = this.resources.dataFrame!;
+
+    this.stats.setData(df.col(this.resources.activityColumnName!)?.getRawData() as Float32Array);
+    this.stats.setMask(this.mask);
+    return this.stats.result;
+  }
+}
+
+/** Declares resources needed by the filtering. */
+interface FilterResources {
+  residueColumnName?: string;
+  activityColumnName?: string;
+  grid?: DG.Grid;
+  dataFrame?: DG.DataFrame;
+  groupMapping?: StringDictionary;
+};
+
+type ResourceKey = keyof FilterResources;
+
+/** Resources controlling helper */
+class Resources {
+  protected data: FilterResources;
+
+  /** Creates an instance of Resources. */
+  constructor() {
+    this.data = {};
+  }
+
+  /**
+   * Adds/updates the resource given.
+   * @param {ResourceKey} resource Resource key.
+   * @param {any} value Resource value.
+   */
+  add(resource: ResourceKey, value: any) {
+    this.data[resource] = value;
+  }
+
+  /**
+   * Checks if all requested resources were added previously.
+   * @param {ResourceKey[]} resources Requested resources.
+   * @return {boolean} True if all those resources are initialized.
+   */
+  enough(resources: ResourceKey[]): boolean {
+    return resources.every((k) => this.data[k] !== undefined);
+  }
+
+  /**
+   * Throws an error if one of the resources given was not set.
+   * @param {ResourceKey[]} [resources] Optional set of resources to check.
+   */
+  assert(resources?: ResourceKey[]) {
+    if (resources) {
+      if (!this.enough(resources))
+        throw new Error(`Not enough one of ${resources} or more.`);
+    } else {
+      if (!this.ready())
+        throw new Error(`Resources are not ready.`);
+    }
+  }
+
+  /**
+   * Checks if all resources were initialized.
+   * @return {boolean} True if the test was successful.
+   */
+  ready(): boolean {
+    return Object.values(this.data).every((v) => v !== undefined);
+  }
+
+  /** Data frame resource. */
+  get dataFrame() {
+    return this.data.dataFrame;
+  }
+
+  /** Grid resource. */
+  get grid() {
+    return this.data.grid;
+  }
+
+  /** Group mapping. */
+  get groupMapping() {
+    return this.data.groupMapping;
+  }
+
+  /** Residue column name. */
+  get residueColumnName() {
+    return this.data.residueColumnName;
+  }
+
+  /** Activity column name. */
+  get activityColumnName() {
+    return this.data.activityColumnName;
+  }
+}
+
+const MouseEventsSource = {
+  click: 0,
+  mousemove: 1,
+  mouseout: 2,
+};
+const MouseEvents = Object.keys(MouseEventsSource);
+export type MouseEventType = keyof typeof MouseEventsSource;
+export type CellType = 'isTableCell' | 'isColHeader' | 'unknown';
+
+  type MouseEventHandler = (
+    eventType: MouseEventType,
+    cellType: CellType,
+    colName: string | null,
+    rowIdx: number | null,
+    ctrlPressed: boolean
+  ) => void;
+
+/**
+   * Adds mouse event handler to the click event bus.
+   * @param {DG.Grid} grid Grid to add to.
+   * @param {MouseEventHandler} handler Event handler.
+   */
+export function addGridMouseHandler(grid: DG.Grid, handler: MouseEventHandler) {
+  const onMouseEvent = (mouseEvent: MouseEvent) => {
+    if (!MouseEvents.includes(mouseEvent.type))
+      return;
+
+    const mouseEventType: MouseEventType = mouseEvent.type as MouseEventType;
+    const keyPressed = mouseEvent.ctrlKey || mouseEvent.metaKey;
+    const cell = grid.hitTest(mouseEvent.offsetX, mouseEvent.offsetY);
+    let pos: string | null = null;
+    let rowIdx: number | null = null;
+    let cellType: CellType = 'unknown';
+
+    if (cell) {
+      pos = cell.gridColumn.name;
+
+      if (pos.length == 0)
+        pos = null;
+
+      if (cell.isTableCell) {
+        rowIdx = cell.tableRowIndex!;
+        cellType = 'isTableCell';
+      } else if (cell.isColHeader)
+        cellType = 'isColHeader';
+    }
+
+    handler(mouseEventType, cellType, pos, rowIdx, keyPressed);
+  };
+
+  for (const e of MouseEvents)
+    rxjs.fromEvent<MouseEvent>(grid.overlay, e).subscribe(onMouseEvent);
+}