@datagrok/peptides 0.0.1 → 0.4.2

package/src/utils/correlation-analysis.ts

@@ -0,0 +1,126 @@
+/* Do not change these import lines. Datagrok will import API library in exactly the same manner */
+//import * as grok from 'datagrok-api/grok';
+//import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {AlignedSequenceEncoder} from '@datagrok-libraries/utils/src/sequence-encoder';
+import {assert, transposeMatrix} from '@datagrok-libraries/utils/src/operations';
+import {Vector, Matrix} from '@datagrok-libraries/utils/src/type-declarations';
+import {kendallsTau} from '@datagrok-libraries/statistics/src/correlation-coefficient';
+
+/**
+ * Converts a Matrix into a DataFrame.
+ *
+ * @export
+ * @param {Matrix} matrix A matrix.
+ * @return {DG.DataFrame} The data frame.
+ */
+export function matrix2DataFrame(matrix: Matrix): DG.DataFrame {
+  return DG.DataFrame.fromColumns(matrix.map((v, i) => DG.Column.fromFloat32Array(`${i+1}`, v)));
+}
+
+/**
+ * Encodes amino acid sequences into a numeric representation.
+ *
+ * @param {DG.Column} col A column containing the sequences.
+ * @return {DG.DataFrame} The resulting data frame.
+ */
+function calcPositions(col: DG.Column): DG.DataFrame {
+  const sequences = col.toList().map((v, _) => AlignedSequenceEncoder.clean(v));
+  const enc = new AlignedSequenceEncoder();
+  const encSeqs = sequences.map((v) => Vector.from(enc.encode(v)));
+  const positions = transposeMatrix(encSeqs);
+  return matrix2DataFrame(positions);
+}
+
+/**
+ * Unfolds a data frame into <category>-<value> format.
+ *
+ * @param {DG.DataFrame} df A data frame to unfold.
+ * @return {DG.DataFrame} The resulting data frame.
+ */
+function melt(df: DG.DataFrame): DG.DataFrame {
+  let keys: string[] = [];
+  const values: Float32Array = new Float32Array(df.columns.length*df.rowCount);
+  let i = 0;
+
+  for (const c of df.columns.toList()) {
+    keys = keys.concat(Array<string>(c.length).fill(c.name));
+    values.set(c.getRawData(), i);
+    i += df.rowCount;
+  }
+  assert(keys.length == values.length);
+  return DG.DataFrame.fromColumns([DG.Column.fromStrings('keys', keys), DG.Column.fromFloat32Array('values', values)]);
+}
+
+/**
+ * Calculates Spearman's rho rank correlation coefficient.
+ *
+ * @param {DG.DataFrame} df A data frame to process.
+ * @return {DG.DataFrame} The correlation matrix.
+ */
+// eslint-disable-next-line no-unused-vars
+function calcSpearmanRhoMatrix(df: DG.DataFrame): DG.DataFrame {
+  const nItems = df.columns.length;
+  const rho = new Array(nItems).fill(0).map((_) => new Float32Array(nItems).fill(0));
+
+  for (let i = 0; i < nItems; ++i) {
+    for (let j = i+1; j < nItems; ++j) {
+      rho[i][j] = df.columns.byIndex(i).stats.spearmanCorr(df.columns.byIndex(j));
+      rho[j][i] = rho[i][j];
+    }
+  }
+  return matrix2DataFrame(rho);
+}
+
+/**
+ * Calculates Kendall's tau rank correlation coefficient.
+ *
+ * @param {DG.DataFrame} df A data frame to process.
+ * @param {number} [alpha=0.05] The significance threshold.
+ * @return {DG.DataFrame} The correlation matrix.
+ */
+function calcKendallTauMatrix(df: DG.DataFrame, alpha: number = 0.05): DG.DataFrame {
+  const nItems = df.columns.length;
+  const tau = new Array(nItems).fill(0).map((_) => new Float32Array(nItems).fill(0));
+
+  for (let i = 0; i < nItems; ++i) {
+    for (let j = i+1; j < nItems; ++j) {
+      const res = kendallsTau(df.columns.byIndex(i).getRawData(), df.columns.byIndex(j).getRawData());
+      tau[i][j] = res.prob < alpha ? res.test : 0;
+      tau[j][i] = tau[i][j];
+    }
+  }
+  return matrix2DataFrame(tau);
+}
+
+/**
+ * Creates acorrelation plot and a box plot to perform correlation analysis.
+ *
+ * @export
+ * @param {DG.Column} sequencesColumn A column containing amino acid sequences.
+ * @return {[DG.Viewer, DG.Viewer]} These two plots.
+ */
+export function correlationAnalysisPlots(sequencesColumn: DG.Column): [DG.Viewer, DG.Viewer] {
+  const posDF = calcPositions(sequencesColumn);
+  const cpviewer = DG.Viewer.fromType(
+    DG.VIEWER.CORR_PLOT,
+    posDF,
+    {
+      'xColumnNames': posDF.columns.names(),
+      'yColumnNames': posDF.columns.names(),
+      'correlationType': 'Spearman',
+    });
+
+  const rhoDF = calcKendallTauMatrix(posDF);
+  const meltDF = melt(rhoDF);
+
+  const bpviewer = DG.Viewer.fromType(
+    DG.VIEWER.BOX_PLOT,
+    meltDF, {
+      'categoryColumnName': 'keys',
+      'valueColumnName': 'values',
+      'statistics': ['min', 'max', 'avg', 'med'],
+    });
+  return [cpviewer, bpviewer];
+}

package/src/utils/molecular-measure.ts

@@ -0,0 +1,175 @@
+/**
+ * Library of molecular weights.
+ * @link https://worldwide.promega.com/resources/tools/amino-acid-chart-amino-acid-structure */
+const _lib = [
+  {
+    'Name': 'Alanine',
+    'Three-letter': 'Ala',
+    'One-letter': 'A',
+    'Weight': '89Da',
+  },
+  {
+    'Name': 'Arginine',
+    'Three-letter': 'Arg',
+    'One-letter': 'R',
+    'Weight': '174Da',
+  },
+  {
+    'Name': 'Asparagine',
+    'Three-letter': 'Asn',
+    'One-letter': 'N',
+    'Weight': '132Da',
+  },
+  {
+    'Name': 'Aspartic acid',
+    'Three-letter': 'Asp',
+    'One-letter': 'D',
+    'Weight': '133Da',
+  },
+  {
+    'Name': 'Asparagine or aspartic acid',
+    'Three-letter': 'Asx',
+    'One-letter': 'B',
+    'Weight': '133Da',
+  },
+  {
+    'Name': 'Cysteine',
+    'Three-letter': 'Cys',
+    'One-letter': 'C',
+    'Weight': '121Da',
+  },
+  {
+    'Name': 'Glutamine',
+    'Three-letter': 'Gln',
+    'One-letter': 'Q',
+    'Weight': '146Da',
+  },
+  {
+    'Name': 'Glutamic acid',
+    'Three-letter': 'Glu',
+    'One-letter': 'E',
+    'Weight': '147Da',
+  },
+  {
+    'Name': 'Glutamine or glutamic acid',
+    'Three-letter': 'Glx',
+    'One-letter': 'Z',
+    'Weight': '147Da',
+  },
+  {
+    'Name': 'Glycine',
+    'Three-letter': 'Gly',
+    'One-letter': 'G',
+    'Weight': '75Da',
+  },
+  {
+    'Name': 'Histidine',
+    'Three-letter': 'His',
+    'One-letter': 'H',
+    'Weight': '155Da',
+  },
+  {
+    'Name': 'Isoleucine',
+    'Three-letter': 'Ile',
+    'One-letter': 'I',
+    'Weight': '131Da',
+  },
+  {
+    'Name': 'Leucine',
+    'Three-letter': 'Leu',
+    'One-letter': 'L',
+    'Weight': '131Da',
+  },
+  {
+    'Name': 'Lysine',
+    'Three-letter': 'Lys',
+    'One-letter': 'K',
+    'Weight': '146Da',
+  },
+  {
+    'Name': 'Methionine',
+    'Three-letter': 'Met',
+    'One-letter': 'M',
+    'Weight': '149Da',
+  },
+  {
+    'Name': 'Phenylalanine',
+    'Three-letter': 'Phe',
+    'One-letter': 'F',
+    'Weight': '165Da',
+  },
+  {
+    'Name': 'Proline',
+    'Three-letter': 'Pro',
+    'One-letter': 'P',
+    'Weight': '115Da',
+  },
+  {
+    'Name': 'Serine',
+    'Three-letter': 'Ser',
+    'One-letter': 'S',
+    'Weight': '105Da',
+  },
+  {
+    'Name': 'Threonine',
+    'Three-letter': 'Thr',
+    'One-letter': 'T',
+    'Weight': '119Da',
+  },
+  {
+    'Name': 'Tryptophan',
+    'Three-letter': 'Trp',
+    'One-letter': 'W',
+    'Weight': '204Da',
+  },
+  {
+    'Name': 'Tyrosine',
+    'Three-letter': 'Tyr',
+    'One-letter': 'Y',
+    'Weight': '181Da',
+  },
+  {
+    'Name': 'Valine',
+    'Three-letter': 'Val',
+    'One-letter': 'V',
+    'Weight': '117Da',
+  },
+];
+
+/**
+ * Selection of the molecular weights of amino acid residues.
+ * @type {*} */
+const weightsLib : {[name: string]: number} = {};
+
+// Create a dictionary linking one-letter code with the corresponding residues weight.
+for (const d of _lib) {
+  weightsLib[d['One-letter']] = parseFloat(d.Weight.substring(0, d.Weight.length-2));
+}
+
+/**
+ * Calculates molecular weight of the given peptide in daltons.
+ *
+ * @export
+ * @param {string} sequence Peptide sequence.
+ * @return {number} Molecular weight in Da.
+ */
+export function getSequenceMolecularWeight(sequence: string): number {
+  let sum = 0;
+
+  if (sequence.startsWith('NH2')) {
+    sum += 16.02;
+    sequence = sequence.substring(3);
+  }
+
+  if (sequence.endsWith('COOH')) {
+    sum += 45.02;
+    sequence = sequence.substring(0, sequence.length-4);
+  }
+
+  for (const i of sequence) {
+    if (i in weightsLib) {
+      sum += weightsLib[i];
+    }
+  }
+  return sum;
+}

package/src/utils/peptide-similarity-space.ts

@@ -0,0 +1,242 @@
+/* Do not change these import lines. Datagrok will import API library in exactly the same manner */
+// eslint-disable-next-line no-unused-vars
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {getSequenceMolecularWeight} from './molecular-measure';
+import {AlignedSequenceEncoder} from '@datagrok-libraries/utils/src/sequence-encoder';
+import {DimensionalityReducer} from '@datagrok-libraries/utils/src/reduce-dimensionality';
+import {Measurer} from '@datagrok-libraries/utils/src/string-measure';
+import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
+
+function createDimensinalityReducingWorker(
+  columnData: any[],
+  method: string,
+  measure: string,
+  cyclesCount: number,
+): Promise<unknown> {
+  return new Promise(function(resolve) {
+    const worker = new Worker(new URL('../workers/dimensionality-reducer.ts', import.meta.url));
+    worker.postMessage({
+      columnData: columnData,
+      method: method,
+      measure: measure,
+      cyclesCount: cyclesCount,
+    });
+    worker.onmessage = ({data: {embedding}}) => {
+      resolve(embedding);
+    };
+  });
+}
+
+/**
+ * Finds a column with an activity.
+ *
+ * @param {DG.DataFrame} table The data frame to search for.
+ * @return {(string | null)} Column name or null if not found.
+ */
+function inferActivityColumnsName(table: DG.DataFrame): string | null {
+  const re = /activity|ic50/i;
+  for (const name of table.columns.names()) {
+    if (name.match(re)) {
+      console.log(`${name} found.`);
+      return name;
+    }
+  }
+  return null;
+}
+
+/**
+ * Creates scatter plot with sequences embeded.
+ *
+ * @export
+ * @param {DG.DataFrame} table The table containing samples.
+ * @param {DG.Column} alignedSequencesColumn Samples column.
+ * @param {string} method Embedding method to apply.
+ * @param {string} measure Distance metric.
+ * @param {number} cyclesCount Number of cycles to repeat.
+ * @param {(DG.TableView | null)} view View to add scatter plot to
+ * @param {(string | null)} [activityColumnName] Activity containing column to assign it to points radius.
+ * @param {boolean} [zoom=false] Whether to fit view.
+ * @return {Promise<DG.ScatterPlotViewer>} A viewer.
+ */
+export async function createPeptideSimilaritySpaceViewer(
+  table: DG.DataFrame,
+  alignedSequencesColumn: DG.Column,
+  method: string,
+  measure: string,
+  cyclesCount: number,
+  view: DG.TableView | null,
+  activityColumnName?: string | null,
+  zoom: boolean = false,
+): Promise<DG.ScatterPlotViewer> {
+  const pi = DG.TaskBarProgressIndicator.create('Creating embedding.');
+
+  activityColumnName = activityColumnName ?? inferActivityColumnsName(table);
+
+  const axesNames = ['~X', '~Y', '~MW'];
+  const columnData = alignedSequencesColumn.toList().map((v, _) => AlignedSequenceEncoder.clean(v));
+
+  const embcols = await createDimensinalityReducingWorker(columnData, method, measure, cyclesCount);
+
+  const columns = Array.from(
+    embcols as Coordinates,
+    (v: Float32Array, k) => (DG.Column.fromFloat32Array(axesNames[k], v)),
+  );
+
+  function _getMW(sequences = columnData) {
+    const mw: Float32Array = new Float32Array(sequences.length).fill(0);
+    let currentSequence;
+
+    for (let i = 0; i < sequences.length; ++i) {
+      currentSequence = sequences[i];
+      mw[i] = currentSequence == null ? 0 : getSequenceMolecularWeight(currentSequence);
+    }
+    return mw;
+  }
+
+  columns.push(DG.Column.fromFloat32Array('~MW', _getMW()));
+
+  const edf = DG.DataFrame.fromColumns(columns);
+
+  // Add new axes.
+  for (const axis of axesNames) {
+    const col = table.col(axis);
+
+    if (col == null) {
+      table.columns.insert(edf.getCol(axis));
+    } else {
+      table.columns.replace(col, edf.getCol(axis));
+    }
+  }
+
+  // const viewer = DG.Viewer.scatterPlot(table, {x: '~X', y: '~Y', color: activityColumnName ?? '~MW', size: '~MW'});
+  const viewerOptions = {x: '~X', y: '~Y', color: activityColumnName ?? '~MW', size: '~MW'};
+  const viewer = view !== null ?
+    view.addViewer(DG.VIEWER.SCATTER_PLOT, viewerOptions) : DG.Viewer.scatterPlot(table, viewerOptions);
+  // Fit view if needed.
+  /*if (zoom) {
+    viewer.zoom(
+      table.getCol('~X').min,
+      table.getCol('~Y').min,
+      table.getCol('~X').max,
+      table.getCol('~Y').max,
+    );
+  }*/
+  pi.close();
+  return (viewer as DG.ScatterPlotViewer);
+}
+
+/**
+ * Controls creation of the peptide similarity space viewer.
+ *
+ * @export
+ * @class PeptideSimilaritySpaceWidget
+ */
+export class PeptideSimilaritySpaceWidget {
+  protected method: string;
+  protected metrics: string;
+  protected cycles: number = 100;
+  protected currentDf: DG.DataFrame;
+  protected alignedSequencesColumn: DG.Column;
+  protected availableMethods: string[];
+  protected availableMetrics: string[];
+  protected viewer: HTMLElement;
+  view: DG.TableView;
+
+  /**
+   * Creates an instance of PeptideSimilaritySpaceWidget.
+   * @param {DG.Column} alignedSequencesColumn The column to get amino acid sequences from.
+   * @param {DG.TableView} view Current view
+   * @memberof PeptideSimilaritySpaceWidget
+   */
+  constructor(alignedSequencesColumn: DG.Column, view: DG.TableView) {
+    this.availableMethods = DimensionalityReducer.availableMethods;
+    this.availableMetrics = Measurer.availableMeasures;
+    this.method = this.availableMethods[0];
+    this.metrics = this.availableMetrics[0];
+    this.currentDf = alignedSequencesColumn.dataFrame;
+    this.alignedSequencesColumn = alignedSequencesColumn;
+    this.viewer = ui.div([]);
+    this.view = view;
+  }
+
+  /**
+   * Creates viewer itself.
+   *
+   * @return {Promise<DG.Viewer>} the viewer.
+   * @memberof PeptideSimilaritySpaceWidget
+   */
+  public async drawViewer(): Promise<DG.Viewer> {
+    const viewer = await createPeptideSimilaritySpaceViewer(
+      this.currentDf,
+      this.alignedSequencesColumn,
+      this.method,
+      this.metrics,
+      this.cycles,
+      null,
+      null,
+      true,
+    );
+    viewer.root.style.width = 'auto';
+    return viewer;
+  }
+
+  /**
+   * Updates the viewer on options changes.
+   *
+   * @protected
+   * @memberof PeptideSimilaritySpaceWidget
+   */
+  protected async updateViewer() {
+    this.viewer.lastChild?.remove();
+    const viewer = await this.drawViewer();
+    this.viewer.appendChild(viewer.root);
+  }
+
+  /**
+   * Adds input controls to manage the viewer's parameters.
+   *
+   * @protected
+   * @return {Promise<HTMLElement>} Bunch of control elements.
+   * @memberof PeptideSimilaritySpaceWidget
+   */
+  protected async drawInputs(): Promise<HTMLElement> {
+    const methodsList = ui.choiceInput('Embedding method', this.method, this.availableMethods,
+      async (currentMethod: string) => {
+        this.method = currentMethod;
+        await this.updateViewer();
+      },
+    );
+    methodsList.setTooltip('Embedding method to apply to the dataset.');
+
+    const metricsList = ui.choiceInput('Distance metric', this.metrics, this.availableMetrics,
+      async (currentMetrics: string) => {
+        this.metrics = currentMetrics;
+        await this.updateViewer();
+      },
+    );
+    metricsList.setTooltip('Custom distance metric to pass to the embedding procedure.');
+
+    const cyclesSlider = ui.intInput('Cycles count', this.cycles,
+      async (currentCycles: number) => {
+        this.cycles = currentCycles;
+        await this.updateViewer();
+      },
+    );
+    cyclesSlider.setTooltip('Number of cycles affects the embedding quality.');
+
+    return ui.inputs([methodsList, metricsList, cyclesSlider]);
+  }
+
+  /**
+   * Draws a viewer on property panel.
+   *
+   * @return {Promise<DG.Widget>} The corresponding widget.
+   * @memberof PeptideSimilaritySpaceWidget
+   */
+  public async draw(): Promise<DG.Widget> {
+    return new DG.Widget(ui.divV([(await this.drawViewer()).root, await this.drawInputs()]));
+  }
+}

package/src/utils/split-aligned.ts

@@ -0,0 +1,65 @@
+import * as DG from 'datagrok-api/dg';
+
+export function splitAlignedPeptides(peptideColumn: DG.Column, filter: boolean = true): [DG.DataFrame, number[]] {
+  const splitPeptidesArray: string[][] = [];
+  let currentSplitPeptide: string[];
+  let modeMonomerCount = 0;
+  let currentLength;
+  const colLength = peptideColumn.length;
+
+  // splitting data
+  const monomerLengths: {[index: string]: number} = {};
+  for (let i = 0; i < colLength; i++) {
+    currentSplitPeptide = peptideColumn.get(i).split('-').map((value: string) => value ? value : '-');
+    splitPeptidesArray.push(currentSplitPeptide);
+    currentLength = currentSplitPeptide.length;
+    monomerLengths[currentLength + ''] =
+      monomerLengths[currentLength + ''] ? monomerLengths[currentLength + ''] + 1 : 1;
+  }
+  //@ts-ignore: what I do here is converting string to number the most effective way I could find. parseInt is slow
+  modeMonomerCount = 1 * Object.keys(monomerLengths).reduce((a, b) => monomerLengths[a] > monomerLengths[b] ? a : b);
+
+  // making sure all of the sequences are of the same size
+  // and marking invalid sequences
+  let nTerminal: string;
+  const invalidIndexes: number[] = [];
+  let splitColumns: string[][] = Array.from({length: modeMonomerCount}, (_) => []);
+  modeMonomerCount--; // minus N-terminal
+  for (let i = 0; i < colLength; i++) {
+    currentSplitPeptide = splitPeptidesArray[i];
+    nTerminal = currentSplitPeptide.pop()!; // it is guaranteed that there will be at least one element
+    currentLength = currentSplitPeptide.length;
+    if (currentLength !== modeMonomerCount) {
+      invalidIndexes.push(i);
+    }
+    for (let j = 0; j < modeMonomerCount; j++) {
+      splitColumns[j].push(j < currentLength ? currentSplitPeptide[j] : '-');
+    }
+    splitColumns[modeMonomerCount].push(nTerminal);
+  }
+  modeMonomerCount--; // minus C-terminal
+
+  //create column names list
+  const columnNames = Array.from({length: modeMonomerCount}, (_, index) => `${index + 1 < 10 ? 0 : ''}${index + 1 }`);
+  columnNames.splice(0, 0, 'N-terminal');
+  columnNames.push('C-terminal');
+
+  // filter out the columns with the same values
+
+  if (filter) {
+    splitColumns = splitColumns.filter((positionArray, index) => {
+      const isRetained = new Set(positionArray).size > 1;
+      if (!isRetained) {
+        columnNames.splice(index, 1);
+      }
+      return isRetained;
+    });
+  }
+
+  return [
+    DG.DataFrame.fromColumns(splitColumns.map((positionArray, index) => {
+      return DG.Column.fromList('string', columnNames[index], positionArray);
+    })),
+    invalidIndexes,
+  ];
+}

package/src/{peptide-logo-viewer → viewers}/logo-viewer.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 
 import * as logojs from 'logojs-react';
-import {splitAlignedPeptides} from '../split-aligned';
+import {splitAlignedPeptides} from '../utils/split-aligned';
 import {ChemPalette} from '../utils/chem-palette';
 
 export class Logo extends DG.JsViewer {
@@ -31,6 +31,7 @@ export class Logo extends DG.JsViewer {
       'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'K': 9, 'L': 10, 'M': 11,
       'N': 12, 'P': 13, 'Q': 14, 'R': 15, 'S': 16, 'T': 17, 'U': 18, 'V': 19, 'W': 20, 'Y': 21, 'Z': 22,
     };
+    //TODO: use chem palette
     this.LET_COLORS = [
       {color: 'rgb(44,160,44)', regex: 'A'},
       {color: 'rgb(44,160,44)', regex: 'B'},
@@ -63,9 +64,10 @@ export class Logo extends DG.JsViewer {
     // this.reactHost = ui.div([]);
     console.log('INIT');
     this.target = this.dataFrame;
-    this.splitted = splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
+    [this.splitted] = splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
     this.root.style.width = 'auto';
     this.root.style.height = 'auto';
+    this.root.style.maxHeight = '200px';
   }
 
   onTableAttached() {
@@ -103,8 +105,8 @@ export class Logo extends DG.JsViewer {
         .aggregate();
     }
     if (selected) {
-      this.splitted = splitAlignedPeptides(this.target!.columns.bySemType(this.colSemType));
-    } else this.splitted = splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
+      [this.splitted] = splitAlignedPeptides(this.target!.columns.bySemType(this.colSemType));
+    } else [this.splitted] = splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
     $(this.root).empty();
 
     if (typeof this.dataFrame !== 'undefined') {