@datagrok/peptides 0.8.7 → 0.8.10

package/src/utils/chem-palette.ts

@@ -3,15 +3,13 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {MonomerLibrary} from '../monomer-library';
+
 
-/**
- * Chem palette class.
- *
- * @export
- * @class ChemPalette
- */
 export class ChemPalette {
   cp: StringDictionary = {};
+  isInit: boolean = false;
+  monomerLib: MonomerLibrary | null = null;
 
   /**
    * Creates an instance of ChemPalette.
@@ -20,7 +18,7 @@ export class ChemPalette {
    * @param {boolean} [grouping=false] Is grouping enabled.
    * @memberof ChemPalette
    */
-  constructor(scheme: string, grouping = false) {
+  private constructor(scheme: string, grouping = false) {
     if (scheme == 'grok')
       this.cp = ChemPalette.getDatagrok(grouping);
   }
@@ -32,102 +30,112 @@ export class ChemPalette {
    * @param {number} x x coordinate of the mouse pointer.
    * @param {number} y y coordinate of the mouse pointer.
    */
-  showTooltip(cell: DG.GridCell, x: number, y: number) {
+  static showTooltip(cell: DG.GridCell, x: number, y: number, monomerLib: MonomerLibrary) {
+    // if (!this.isInit) {
+    //   const validPackage = _package ?? _packageTest;
+    //   if (!validPackage)
+    //     throw new Error('No package instance found');
+    //   this.monomerLib = new MonomerLibrary(await validPackage.files.readAsText(`HELMMonomers_June10.sdf`));
+    //   this.isInit = true;
+    // }
+
     const s = cell.cell.value as string;
     let toDisplay = [ui.divText(s)];
-    const [, aar] = this.getColorAAPivot(s);
-    if (aar in ChemPalette.AASmiles) {
-      if (s in ChemPalette.AANames)
-        toDisplay = [ui.divText(ChemPalette.AANames[s])];
+    const [, aarOuter, aarInner] = ChemPalette.getColorAAPivot(s);
+    for (const aar of [aarOuter, aarInner]) {
+      if (monomerLib.monomerNames.includes(aar)) {
+        if (aar in ChemPalette.AANames)
+          toDisplay = [ui.divText(ChemPalette.AANames[aar])];
+
+        if (aar in ChemPalette.AAFullNames)
+          toDisplay = [ui.divText(ChemPalette.AANames[ChemPalette.AAFullNames[aar]])];
 
-      if (s in ChemPalette.AAFullNames)
-        toDisplay = [ui.divText(ChemPalette.AANames[ChemPalette.AAFullNames[s]])];
+        const options = {
+          autoCrop: true,
+          autoCropMargin: 0,
+          suppressChiralText: true,
+        };
+        const sketch = grok.chem.svgMol(monomerLib.getMonomerMol(aar), undefined, undefined, options);
+        if (toDisplay.length == 2)
+          toDisplay.push(ui.divText('Modified'));
 
-      const options = {
-        autoCrop: true,
-        autoCropMargin: 0,
-        suppressChiralText: true,
-      };
-      const sketch = grok.chem.svgMol(ChemPalette.AASmiles[aar], undefined, undefined, options);
-      toDisplay.push(sketch);
+        toDisplay.push(sketch);
+      }
     }
     ui.tooltip.show(ui.divV(toDisplay), x, y);
   }
 
   /**
-   * Get color for the provided amino acid residue.
-   * @param {string} c Amino acid residue string.
-   * @return {string} Color.
+   * Retursn divided amino with its content in the bracket, if the conetent is number, then its omitted
+   *
+   * @param {string} c raw amino
+   * @return {[string, string]} outer and inner content
    */
-  getColor(c: string): string {
-    const [color] = this.getColorPivot(c);
-    return color;
+  static getInnerOuter(c: string): [string, string] {
+    let isInner = 0;
+    let inner = '';
+    let outer = '';
+
+    for (const char of c) {
+      if (char == '(')
+        isInner++;
+      else if (char == ')')
+        isInner--;
+      else if (isInner)
+        inner += char;
+      else
+        outer += char;
+    }
+
+    return !isNaN(parseInt(inner)) ? [outer, ''] : [outer, inner];
   }
 
-  /**
-   * Get color for the provided amino acid residue pivot
-   * @param {string} [c=''] Amino acid residue string.
-   * @return {[string, string, number]}
-   */
-  getColorAAPivot(c: string = ''): [string, string, number] {
-    if (c.length == 1 || c[1] == '(') {
-      const amino = c[0]?.toUpperCase()!;
-      return amino in this.cp?
-        [this.cp[amino], amino, 1]:
-        [ChemPalette.undefinedColor, '', 1];
+  static getColorAAPivot(monomer: string = '', scheme: 'grok' = 'grok'): [string, string, string, number] {
+    // const chemPaletteInstance = ChemPalette.getDatagrok();
+    const chemPaletteInstance = ChemPalette.getPalette(scheme);
+    let [outerMonomer, innerMonomer] = ChemPalette.getInnerOuter(monomer);
+    outerMonomer = (outerMonomer.length > 6 ? `${outerMonomer.slice(0, 3)}...` : outerMonomer);
+    innerMonomer = (innerMonomer.length > 6 ? `${innerMonomer.slice(0, 3)}...` : innerMonomer);
+
+    if (monomer.length == 1 || monomer[1] == '(') {
+      const amino = monomer[0]?.toUpperCase()!;
+      return amino in chemPaletteInstance ?
+        [chemPaletteInstance[amino], amino, innerMonomer, 1]:
+        [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 1];
     }
 
-    if (c[0] == 'd' && c[1]! in this.cp) {
-      if (c.length == 2 || c[2] == '(') {
-        const amino = c[1]?.toUpperCase()!;
-        return amino in this.cp?
-          [this.cp[amino], amino, 2]:
-          [ChemPalette.undefinedColor, '', 2];
+    if (monomer[0] == 'd' && monomer[1]! in chemPaletteInstance) {
+      if (monomer.length == 2 || monomer[2] == '(') {
+        const amino = monomer[1]?.toUpperCase()!;
+        return amino in chemPaletteInstance ?
+          [chemPaletteInstance[amino], amino, innerMonomer, 2]:
+          [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 2];
       }
     }
 
-    if (c.substr(0, 3) in ChemPalette.AAFullNames) {
-      if (c.length == 3 || c[3] == '(') {
-        const amino = ChemPalette.AAFullNames[c.substr(0, 3)];
-        return amino in this.cp?
-          [this.cp[amino], amino, 3]:
-          [ChemPalette.undefinedColor, '', 3];
+    if (monomer.substring(0, 3) in ChemPalette.AAFullNames) {
+      if (monomer.length == 3 || monomer[3] == '(') {
+        const amino = ChemPalette.AAFullNames[monomer.substring(0, 3)];
+        return amino in chemPaletteInstance ?
+          [chemPaletteInstance[amino], amino, innerMonomer, 3]:
+          [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 3];
       }
     }
 
-    if (c[0]?.toLowerCase() == c[0]) {
-      if (c.substr(1, 3) in ChemPalette.AAFullNames) {
-        if (c.length == 4 || c[4] == '(') {
-          const amino = ChemPalette.AAFullNames[c.substr(1, 3)];
-          return amino in this.cp?
-            [this.cp[amino], amino, 4]:
-            [ChemPalette.undefinedColor, '', 4];
+    if (monomer[0]?.toLowerCase() == monomer[0]) {
+      if (monomer.substring(1, 3) in ChemPalette.AAFullNames) {
+        if (monomer.length == 4 || monomer[4] == '(') {
+          const amino = ChemPalette.AAFullNames[monomer.substring(1, 3)];
+          return amino in chemPaletteInstance ?
+            [chemPaletteInstance[amino], amino, innerMonomer, 4]:
+            [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 4];
         }
       }
     }
 
-    return [ChemPalette.undefinedColor, '', 0];
+    return [ChemPalette.undefinedColor, outerMonomer, innerMonomer, 0];
   }
 
-  /**
-   * Get color pivot.
-   *
-   * @param c
-   * @returns
-   */
-  getColorPivot(c = ''): [string, number] {
-    //TODO: merge with getColorAAPivot?
-    const [color,, pivot] = this.getColorAAPivot(c);
-    return [color, pivot];
-  };
-
-  /**
-   * Color palette
-   *
-   * @static
-   * @type {{[key: string]: string[]}}
-   * @memberof ChemPalette
-   */
   static colourPalette: {[key: string]: string[]} = {
     'orange': ['rgb(255,187,120)', 'rgb(245,167,100)', 'rgb(235,137,70)', 'rgb(205, 111, 71)'],
     'all_green': ['rgb(44,160,44)', 'rgb(74,160,74)', 'rgb(23,103,57)', 'rgb(30,110,96)', 'rgb(60,131,95)',
@@ -149,15 +157,8 @@ export class ChemPalette {
     'gray': ['rgb(127,127,127)', 'rgb(199,199,199)', 'rgb(196,156,148)', 'rgb(222, 222, 180)'],
     'yellow': ['rgb(188,189,34)'],
     'white': ['rgb(230,230,230)'],
-  }
+  };
 
-  /**
-   * Grok color scheme groups.
-   *
-   * @static
-   * @type {{[key: string]: string[]}}
-   * @memberof ChemPalette
-   */
   static grokGroups: {[key: string]: string[]} = {
     'yellow': ['C', 'U'],
     'red': ['G', 'P'],
@@ -165,40 +166,11 @@ export class ChemPalette {
     'light_blue': ['R', 'H', 'K'],
     'dark_blue': ['D', 'E'],
     'orange': ['S', 'T', 'N', 'Q'],
-  }
-
-  /**
-   * Lesk color scheme groups.
-   *
-   * @static
-   * @type {{[key: string]: string[]}}
-   * @memberof ChemPalette
-   */
-  static leskGroups: {[key: string]: string[]} = {
-    'orange': ['G', 'A', 'S', 'T'],
-    'all_green': ['C', 'V', 'I', 'L', 'P', 'F', 'Y', 'M', 'W'],
-    'magenta': ['N', 'Q', 'H'],
-    'red': ['D', 'E'],
-    'all_blue': ['K', 'R'],
-  }
+  };
 
-  /**
-   * Undefined color.
-   *
-   * @static
-   * @memberof ChemPalette
-   */
   static undefinedColor = 'rgb(100,100,100)';
 
-  /**
-   * Create palette.
-   *
-   * @param dt
-   * @param simplified Is simplified.
-   * @param grouping Is grouping enabled.
-   * @returns
-   */
-  static makePalette(dt: {[key: string]: string[]}, simplified = false, grouping = false) {
+  static makePalette(dt: {[key: string]: string[]}, simplified = false, grouping = false): StringDictionary {
     const palette: { [key: string]: string } = {};
     const groups = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
     let currentGroup = 0;
@@ -211,13 +183,6 @@ export class ChemPalette {
     return palette;
   }
 
-  /**
-   * Amino acid residue names.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AANames: StringDictionary = {
     'G': 'Glycine',
     'L': 'Leucine',
@@ -239,15 +204,8 @@ export class ChemPalette {
     'I': 'Isoleucine',
     'M': 'Methionine',
     'T': 'Threonine',
-  }
+  };
 
-  /**
-   * Amino acid residue SMILES.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AASmiles: StringDictionary = {
     'G': 'NCC(=O)O',
     'L': 'N[C@H](CC(C)C)C(=O)O',
@@ -269,15 +227,8 @@ export class ChemPalette {
     'I': 'N[C@H]([C@H](C)CC)C(=O)O',
     'M': 'NC(CCSC)C(=O)O',
     'T': 'NC(C(O)C)C(=O)O',
-  }
+  };
 
-  /**
-   * Amino acid residue truncated SMILES.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AASmilesTruncated: StringDictionary = {
     'G': '*C*',
     'L': 'CC(C)C[C@H](*)*',
@@ -299,15 +250,8 @@ export class ChemPalette {
     'I': 'CC[C@H](C)[C@H](*)*',
     'M': 'CSCCC(*)*',
     'T': 'CC(O)C(*)*',
-  }
+  };
 
-  /**
-   * Amino acid residue full names.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AAFullNames: StringDictionary = {
     'Ala': 'A',
     'Arg': 'R',
@@ -329,25 +273,18 @@ export class ChemPalette {
     'Trp': 'W',
     'Tyr': 'Y',
     'Val': 'V',
-  }
+  };
 
-  /**
-   * Get Datagrok palette.
-   *
-   * @param grouping Is grouping enabled?
-   * @returns
-   */
-  static getDatagrok(grouping = false) {
+  static getDatagrok(grouping = false): StringDictionary {
     return ChemPalette.makePalette(ChemPalette.grokGroups, false, grouping);
   }
 
-  /**
-   * Get Lesk palette.
-   *
-   * @param grouping Is grouping enabled?
-   * @returns
-   */
-  static getLesk() {
-    return ChemPalette.makePalette(ChemPalette.leskGroups);
+  static getPalette(scheme: 'grok'): StringDictionary {
+    switch (scheme) {
+    case 'grok':
+      return ChemPalette.getDatagrok();
+    default:
+      throw new Error(`ChemPalette: scheme \`${scheme}\` does not exist`);
+    }
   }
 }

package/src/utils/multiple-sequence-alignment.ts

@@ -7,6 +7,8 @@ import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encod
 //@ts-ignore
 import {SEMTYPE} from '../semantics';
 
+// let CLI: any = undefined;
+
 /**
  * Converts array of sequences into simple fasta string.
  *
@@ -73,16 +75,45 @@ export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.
     sequences = sequences.map((v: string, _) => AlignedSequenceEncoder.clean(v).replace(/\-/g, ''));
 
   const fasta = _stringsToFasta(sequences);
+  const CLI = await new Aioli({
+    tool: 'kalign',
+    version: '3.3.1',
+    reinit: true,
+  });
+
+  // if (!CLI) {
+  //   CLI = await new Aioli('kalign/3.3.1');
+  //   console.info('kalign CLI was first initialized.');
+  // } else
+  //   console.info('Initialized kalign CLI was reused.');
+
+  console.log(['fasta.length =', fasta.length]);
 
-  const CLI = await new Aioli('kalign/3.3.1');
   await CLI.fs.writeFile('input.fa', fasta);
-  const output = await CLI.exec(`kalign input.fa -f fasta -o result.fasta`);
+  const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
   const buf = await CLI.cat('result.fasta');
 
   console.warn(output);
 
+  // if (!buf)
+  //   console.warn(buf);
+
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
   const alignedCol = DG.Column.fromStrings(`(${col.name})msa`, _stringsToAligned(aligned));
   alignedCol.semType = SEMTYPE.ALIGNED;
   return alignedCol;
 }
+
+export async function testMSAEnoughMemory(col: DG.Column) {
+  const sequencesCount = col.length;
+  const delta = sequencesCount/100;
+
+  for (let i = delta; i < sequencesCount; i += delta) {
+    try {
+      await runKalign(DG.Column.fromStrings(col.name, col.toList().slice(0, Math.round(i))));
+      console.log(`runKalign succeeded on ${i}`);
+    } catch (error) {
+      console.log(`runKalign failed on ${i} with '${error}'`);
+    }
+  }
+}

package/src/utils/multivariate-analysis.ts

@@ -0,0 +1,77 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
+
+export async function callMVA(
+  tableGrid: DG.Grid,
+  view: DG.View,
+  currentDf: DG.DataFrame,
+  options: {[name: string]: string},
+  sequencesCol: DG.Column,
+) {
+  const activityCol = await _scaleColumn(currentDf.getCol(options['activityColumnName']), options['scaling']);
+  const encDf = _encodeSequences(sequencesCol);
+  const scaledColName = `${options['activityColumnName']}scaled`;
+
+  _insertColumns(
+    currentDf,
+    [DG.Column.fromList('double', scaledColName, activityCol.toList())],
+  );
+  _insertColumns(currentDf, encDf.columns);
+
+  const res = await grok.functions.call('MultivariateAnalysis', {
+    table: currentDf,
+    features: encDf.columns.names(),
+    prediction: scaledColName,
+    components: 10,
+    showScores: true,
+    showRegresCoefs: true,
+  });
+  console.log(res);
+}
+
+/**
+ * Encodes a series of sequences into a certain scale.
+ *
+ * @param {string[]} sequencesCol Column containing the sequences.
+ * @return {DG.DataFrame} The data frame with seqences encoded.
+ */
+function _encodeSequences(sequencesCol: DG.Column): DG.DataFrame {
+  const nRows = sequencesCol.length;
+  const nCols = AlignedSequenceEncoder.clean(sequencesCol.get(0)).length;
+  const enc = new AlignedSequenceEncoder('WimleyWhite');
+  const positions = new Array(nCols).fill(0).map((_) => new Float32Array(nRows));
+
+  for (let j = 0; j < nRows; ++j) {
+    const s = AlignedSequenceEncoder.clean(sequencesCol.get(j));
+    for (let i = 0; i < nCols; ++i)
+      positions[i][j] = enc.encodeLettter(s[i]);
+  }
+  const df = DG.DataFrame.fromColumns(positions.map(
+    (v, i) => DG.Column.fromFloat32Array((i+1).toString(), v),
+  ));
+  return df;
+}
+
+async function _scaleColumn(column: DG.Column, method: string): Promise<DG.Column> {
+  if (method == 'none')
+    return column;
+
+
+  const formula = (method.startsWith('-') ? '0-' : '')+'Log10(${'+column.name+'})';
+  const newCol = await column.applyFormula(formula);
+
+  if (newCol == null)
+    throw new Error('Column formula returned unexpected null.');
+
+  return newCol!;
+}
+
+function _insertColumns(targetDf: DG.DataFrame, columns: DG.Column[]): DG.DataFrame {
+  for (const col of columns)
+    targetDf.columns.add(col);
+
+  return targetDf;
+}
+

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

@@ -52,40 +52,30 @@ export function cleanAlignedSequencesColumn(col: DG.Column): Array<string> {
  * @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,
-): Promise<DG.ScatterPlotViewer> {
-  const pi = DG.TaskBarProgressIndicator.create('Creating embedding.');
+  table: DG.DataFrame, alignedSequencesColumn: DG.Column, method: string, measure: string, cyclesCount: number,
+  view: DG.TableView | null, activityColumnName?: string | null): 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({data: columnData, metric: measure as StringMetrics}, method, cyclesCount);
+  const embcols = await createDimensinalityReducingWorker(
+    {data: columnData, metric: measure as StringMetrics}, method, 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);
-    }
+    embcols as Coordinates, (v: Float32Array, k) => DG.Column.fromFloat32Array(axesNames[k], v));
+
+  function _getMW(sequences: string[]) {
+    const mw: Float32Array = new Float32Array(sequences.length);
+
+    mw.map((_, index) => getSequenceMolecularWeight(sequences[index] ?? ''));
+
     return mw;
   }
 
-  columns.push(DG.Column.fromFloat32Array('~MW', _getMW()));
+  columns.push(DG.Column.fromFloat32Array('~MW', _getMW(columnData)));
 
   const edf = DG.DataFrame.fromColumns(columns);
 
@@ -103,11 +93,11 @@ export async function createPeptideSimilaritySpaceViewer(
       table.columns.insert(newCol);
   }
 
-  const viewerOptions = {x: '~X', y: '~Y', color: activityColumnName ?? '~MW', size: '~MW'};
-  const viewer = DG.Viewer.scatterPlot(table, viewerOptions);
-
-  if (view !== null)
-    view.addViewer(viewer);
+  const viewerOptions = {
+    x: '~X', y: '~Y', color: activityColumnName ?? '~MW', size: '~MW', title: 'Peptide Space', showYSelector: false,
+    showXSelector: false, showColorSelector: false, showSizeSelector: false,
+  };
+  const viewer = table.plot.scatter(viewerOptions);
 
   pi.close();
   return viewer;

package/src/viewers/logo-viewer.ts

@@ -4,8 +4,9 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 
 import * as logojs from 'logojs-react';
-import {splitAlignedPeptides} from '../utils/split-aligned';
+// import {splitAlignedPeptides} from '../utils/split-aligned';
 import {ChemPalette} from '../utils/chem-palette';
+import {PeptidesController} from '../peptides';
 
 /**
  * Logo viewer.
@@ -80,7 +81,7 @@ export class Logo extends DG.JsViewer {
     this.initialized = true;
     console.log('INIT');
     this.target = this.dataFrame;
-    [this.splitted] = splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
+    [this.splitted] = PeptidesController.splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
     this.root.style.width = 'auto';
     this.root.style.height = 'auto';
     this.root.style.maxHeight = '200px';
@@ -142,8 +143,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] = PeptidesController.splitAlignedPeptides(this.target!.columns.bySemType(this.colSemType));
+    else [this.splitted] = PeptidesController.splitAlignedPeptides(this.dataFrame!.columns.bySemType(this.colSemType));
     $(this.root).empty();
 
     if (typeof this.dataFrame !== 'undefined')