@datagrok/peptides 0.8.9 → 0.8.13

package/src/utils/chem-palette.ts

@@ -3,19 +3,14 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
-import {_package} from '../package';
 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.
    *
@@ -23,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);
   }
@@ -34,16 +29,22 @@ export class ChemPalette {
    * @param {DG.GridCell} cell Grid cell to show tooltip over.
    * @param {number} x x coordinate of the mouse pointer.
    * @param {number} y y coordinate of the mouse pointer.
+   * @param {MonomerLibrary} monomerLib Monomer Library instance
    */
-  async showTooltip(cell: DG.GridCell, x: number, y: number) {
-    if (!this.isInit)
-      this.monomerLib = new MonomerLibrary(await _package.files.readAsText(`HELMMonomers_June10.sdf`));
+  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 [, aarOuter, aarInner] = this.getColorAAPivot(s);
+    const [, aarOuter, aarInner] = ChemPalette.getColorAAPivot(s);
     for (const aar of [aarOuter, aarInner]) {
-      if (this.monomerLib!.monomerNames.includes(aar)) {
+      if (monomerLib.monomerNames.includes(aar)) {
         if (aar in ChemPalette.AANames)
           toDisplay = [ui.divText(ChemPalette.AANames[aar])];
 
@@ -55,7 +56,7 @@ export class ChemPalette {
           autoCropMargin: 0,
           suppressChiralText: true,
         };
-        const sketch = grok.chem.svgMol(this.monomerLib!.getMonomerMol(aar), undefined, undefined, options);
+        const sketch = grok.chem.svgMol(monomerLib.getMonomerMol(aar), undefined, undefined, options);
         if (toDisplay.length == 2)
           toDisplay.push(ui.divText('Modified'));
 
@@ -65,109 +66,77 @@ export class ChemPalette {
     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.
-   */
-  getColor(c: string): string {
-    const [color] = this.getColorPivot(c);
-    return 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
    */
-  private getInnerOuter(c: string): [string, string] {
+  static getInnerOuter(c: string): [string, string] {
     let isInner = 0;
     let inner = '';
     let outer = '';
 
-    for (let i = 0; i < c.length; ++i) {
-      if (c[i] == '(')
+    for (const char of c) {
+      if (char == '(')
         isInner++;
-      else if (c[i] == ')')
+      else if (char == ')')
         isInner--;
       else if (isInner)
-        inner += c[i];
+        inner += char;
       else
-        outer += c[i];
+        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, string, number] {
-    let [outerC, innerC] = this.getInnerOuter(c);
-    outerC = (outerC.length > 6 ? outerC.slice(0, 3) + '...' : outerC);
-    innerC = (innerC.length > 6 ? innerC.slice(0, 3) + '...' : innerC);
+  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 (c.length == 1 || c[1] == '(') {
-      const amino = c[0]?.toUpperCase()!;
-      return amino in this.cp?
-        [this.cp[amino], amino, innerC, 1]:
-        [ChemPalette.undefinedColor, outerC, innerC, 1];
+    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, innerC, 2]:
-          [ChemPalette.undefinedColor, outerC, innerC, 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, innerC, 3]:
-          [ChemPalette.undefinedColor, outerC, innerC, 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, innerC, 4]:
-            [ChemPalette.undefinedColor, outerC, innerC, 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, outerC, innerC, 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)',
@@ -191,13 +160,6 @@ export class ChemPalette {
     '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'],
@@ -207,38 +169,9 @@ export class ChemPalette {
     '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;
@@ -251,13 +184,6 @@ export class ChemPalette {
     return palette;
   }
 
-  /**
-   * Amino acid residue names.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AANames: StringDictionary = {
     'G': 'Glycine',
     'L': 'Leucine',
@@ -281,13 +207,6 @@ export class ChemPalette {
     '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',
@@ -311,13 +230,6 @@ export class ChemPalette {
     '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](*)*',
@@ -341,13 +253,6 @@ export class ChemPalette {
     'T': 'CC(O)C(*)*',
   };
 
-  /**
-   * Amino acid residue full names.
-   *
-   * @static
-   * @type {StringDictionary}
-   * @memberof ChemPalette
-   */
   static AAFullNames: StringDictionary = {
     'Ala': 'A',
     'Arg': 'R',
@@ -371,23 +276,16 @@ export class ChemPalette {
     '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/constants.ts

@@ -0,0 +1,56 @@
+export enum COLUMNS_NAMES {
+  SPLIT_COL = '~split',
+  ACTIVITY = '~activity',
+  ACTIVITY_SCALED = 'activity_scaled',
+  ALIGNED_SEQUENCE = '~aligned_sequence',
+  AMINO_ACID_RESIDUE = 'AAR',
+  POSITION = 'Pos',
+  P_VALUE = 'pValue',
+  MEAN_DIFFERENCE = 'Mean difference',
+}
+
+export enum CATEGORIES {
+  OTHER = 'Other',
+  ALL = 'All',
+}
+
+export enum TAGS {
+  AAR = 'AAR',
+  POSITION = 'Pos',
+}
+
+export enum SEM_TYPES {
+  AMINO_ACIDS = 'aminoAcids',
+  ALIGNED_SEQUENCE = 'alignedSequence',
+}
+
+export const STATS = 'stats';
+
+export const EMBEDDING_STATUS = 'embeddingStatus';
+
+export const PEPTIDES_ANALYSIS = 'isPeptidesAnalysis';
+
+export enum FLAGS {
+  CELL_CHANGING = 'isCellChanging',
+}
+
+export const aarGroups = {
+  'R': 'PC', 'H': 'PC', 'K': 'PC',
+  'D': 'NC', 'E': 'NC',
+  'S': 'U', 'T': 'U', 'N': 'U', 'Q': 'U',
+  'C': 'SC', 'U': 'SC', 'G': 'SC', 'P': 'SC',
+  'A': 'H', 'V': 'H', 'I': 'H', 'L': 'H', 'M': 'H', 'F': 'H', 'Y': 'H', 'W': 'H',
+  '-': '-',
+};
+
+export const groupDescription: {[key: string]: {'description': string, aminoAcids: string[]}} = {
+  'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
+  'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
+  'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
+  'SC': {'description': 'Special Cases', 'aminoAcids': ['C', 'U', 'G', 'P']},
+  'H': {
+    'description': 'Amino Acids with Hydrophobic Side Chain',
+    'aminoAcids': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+  },
+  '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
+};

package/src/utils/filtering-statistics.ts

@@ -0,0 +1,62 @@
+import * as DG from 'datagrok-api/dg';
+
+import {tTest} from '@datagrok-libraries/statistics/src/tests';
+
+/** Column statistics helper. */
+export class FilteringStatistics {
+  private data?: Float32Array;
+  private stats: Stats = {
+    count: 0,
+    pValue: 1.,
+    meanDifference: 0.,
+  };
+
+  /**
+   * Creates an instance of FilteringStatistics.
+   * @param {Float32Array} [data] Numeric values to consider.
+   */
+  constructor(data?: Float32Array) {this.data = data;}
+
+  /**
+   * Sets values to make statistical analysis.
+   * @param {Float32Array} data Those values.
+   */
+  setData(data: Float32Array) {this.data = data;}
+
+  /**
+   * Sets bit mask to split population into two groups.
+   * @param {DG.BitSet} mask The mask to perform splitting.
+   */
+  setMask(mask: DG.BitSet) {
+    if (!this.data)
+      return;
+    const selected = this.data.filter((_, i) => mask.get(i));
+    const rest = this.data.filter((_, i) => !mask.get(i));
+    this.stats = this.calcStats(selected, rest);
+  }
+
+  /**
+   * Calculates simple statistics on two samples.
+   * @param {Float32Array} selected First sample.
+   * @param {Float32Array} rest Second sample.
+   * @return {Stats} Statistics.
+   */
+  calcStats(selected: Float32Array, rest: Float32Array): Stats {
+    const testResult = tTest(selected, rest);
+    const currentMeanDiff = testResult['Mean difference']!;
+    return {
+      count: selected.length,
+      pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'],
+      meanDifference: currentMeanDiff,
+    };
+  }
+
+  /** Returns calculated statistics. */
+  get result(): Stats {return this.stats;}
+}
+
+export type Stats = {
+  count: number,
+  pValue: number,
+  meanDifference: number,
+};

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,79 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import * as C from './constants';
+
+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', C.COLUMNS_NAMES.ACTIVITY_SCALED, activityCol.toList())],
+  );
+  _insertColumns(currentDf, encDf.columns);
+
+  const res = await grok.functions.call('MultivariateAnalysis', {
+    table: currentDf,
+    features: encDf.columns.names(),
+    prediction: C.COLUMNS_NAMES.ACTIVITY_SCALED,
+    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;
+}
+