@datagrok/peptides 0.6.1 → 0.8.6

package/src/viewers/subst-viewer.ts

@@ -160,9 +160,9 @@ export class SubstViewer extends DG.JsViewer {
       },
     );
 
-    for (const col of table.columns.names()) {
+    for (const col of table.columns.names())
       this.viewerGrid.col(col)!.width = this.viewerGrid.props.rowHeight;
-    }
+
 
     this.viewerGrid.onCellRender.subscribe((args) => {
       if (args.cell.isRowHeader && args.cell.gridColumn.visible) {
@@ -200,9 +200,9 @@ export class SubstViewer extends DG.JsViewer {
 
         this.casesGrid = tempDf.plot.grid();
         this.casesGrid.props.allowEdit = false;
-      } else {
+      } else
         this.casesGrid = null;
-      }
+
       this.render();
     });
 
@@ -245,12 +245,12 @@ export class SubstViewer extends DG.JsViewer {
       currentSplitPeptide = splitPeptidesArray[i];
       nTerminal = currentSplitPeptide.pop()!; // it is guaranteed that there will be at least one element
       currentLength = currentSplitPeptide.length;
-      if (currentLength !== modeMonomerCount) {
+      if (currentLength !== modeMonomerCount)
         invalidIndexes.push(i);
-      }
-      for (let j = 0; j < modeMonomerCount; j++) {
+
+      for (let j = 0; j < modeMonomerCount; j++)
         splitColumns[j].push(j < currentLength ? currentSplitPeptide[j] : '-');
-      }
+
       splitColumns[modeMonomerCount].push(nTerminal);
     }
     modeMonomerCount--; // minus C-terminal
@@ -264,9 +264,9 @@ export class SubstViewer extends DG.JsViewer {
     if (filter) {
       splitColumns = splitColumns.filter((positionArray, index) => {
         const isRetained = new Set(positionArray).size > 1;
-        if (!isRetained) {
+        if (!isRetained)
           columnNames.splice(index, 1);
-        }
+
         return isRetained;
       });
     }

package/src/widgets/analyze-peptides.ts

@@ -2,6 +2,7 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {Peptides} from '../peptides';
+import '../styles.css';
 
 /**
  * Peptide analysis widget.
@@ -17,11 +18,11 @@ export async function analyzePeptidesWidget(
   col: DG.Column, view: DG.TableView, tableGrid: DG.Grid, currentDf: DG.DataFrame,
 ): Promise<DG.Widget> {
   let tempCol = null;
-  for (const column of currentDf.columns.numerical) {
+  for (const column of currentDf.columns.numerical)
     tempCol = column.type === DG.TYPE.FLOAT ? column : null;
-  }
+
   const defaultColumn: DG.Column = currentDf.col('activity') || currentDf.col('IC50') || tempCol;
-  const histogramHost = ui.div([]);
+  const histogramHost = ui.div([], {id: 'pep-hist-host'});
 
   let hist: DG.Viewer;
 
@@ -51,6 +52,7 @@ export async function analyzePeptidesWidget(
         showXAxis: true,
         showColumnSelector: false,
         showRangeSlider: false,
+        showBinSelector: false,
       // bins: b,
       });
       histogramHost.lastChild?.remove();
@@ -81,17 +83,24 @@ export async function analyzePeptidesWidget(
       };
 
       const peptides = new Peptides();
-      await peptides.init(tableGrid, view, currentDf, options, col, activityColumnChoice.value.name);
+      await peptides.init(tableGrid, view, currentDf, options, col);
 
       progress.close();
-    } else {
+    } else
       grok.shell.error('The activity column must be of floating point number type!');
-    }
   });
+  startBtn.style.alignSelf = 'center';
 
   const viewer = await currentDf.plot.fromType('peptide-logo-viewer');
 
   return new DG.Widget(
-    ui.divV([viewer.root, ui.inputs([activityColumnChoice, activityScalingMethod]), startBtn, histogramHost]),
+    ui.divV([
+      viewer.root,
+      ui.splitH([
+        ui.splitV([ui.inputs([activityColumnChoice, activityScalingMethod]), startBtn]),
+        histogramHost,
+      ], {style: {height: 'unset'}}),
+      // histogramHost,
+    ]),
   );
 }

package/src/widgets/manual-alignment.ts

@@ -1,8 +1,9 @@
 import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
-import {model} from '../viewers/model';
+import {Peptides} from '../peptides';
 import {splitAlignedPeptides} from '../utils/split-aligned';
 import '../styles.css';
 
@@ -24,12 +25,14 @@ export function manualAlignmentWidget(alignedSequenceCol: DG.Column, currentDf:
 
     alignedSequenceCol.set(affectedRowIndex, newSequence);
     for (const part of splitSequence.columns) {
-      if (currentDf.col(part.name) !== null) {
+      if (currentDf.col(part.name) !== null)
         currentDf.set(part.name, affectedRowIndex, part.get(0));
-      }
     }
+    const temp = grok.shell.o;
+    grok.shell.o = null;
+    grok.shell.o = temp;
 
-    await model.updateDefault();
+    await Peptides.recalculate();
   });
 
   const resetBtn = ui.button(

package/src/widgets/peptide-molecule.ts

@@ -13,19 +13,11 @@ import {ChemPalette} from '../utils/chem-palette';
 export async function peptideMoleculeWidget(pep: string): Promise<DG.Widget> {
   const pi = DG.TaskBarProgressIndicator.create('Creating NGL view');
 
-  const split = pep.split('-');
-  const mols = [];
-  for (let i = 1; i < split.length - 1; i++) {
-    if (split[i] in ChemPalette.AASmiles) {
-      const aar = ChemPalette.AASmiles[split[i]];
-      mols[i] = aar.substr(0, aar.length - 1);
-    } else if (!split[i] || split[i] == '-') {
-      mols[i] = '';
-    } else {
-      return new DG.Widget(ui.divH([]));
-    }
-  }
-  const smiles = mols.join('') + 'O';
+  const smiles = getMolecule(pep);
+  if (smiles == '')
+    return new DG.Widget(ui.divH([]));
+
+
   let molfileStr = (await grok.functions.call('Peptides:SmiTo3D', {smiles}));
 
   molfileStr = molfileStr.replaceAll('\\n', '\n'); ;
@@ -47,3 +39,19 @@ export async function peptideMoleculeWidget(pep: string): Promise<DG.Widget> {
 
   return new DG.Widget(ui.div([panel, nglHost]));
 }
+
+export function getMolecule(pep: string): string {
+  const split = pep.split('-');
+  const mols = [];
+  for (let i = 1; i < split.length - 1; i++) {
+    if (split[i] in ChemPalette.AASmiles) {
+      const aar = ChemPalette.AASmiles[split[i]];
+      mols[i] = aar.substr(0, aar.length - 1);
+    } else if (!split[i] || split[i] == '-')
+      mols[i] = '';
+    else
+      return '';
+  }
+  const smiles = mols.join('') + 'O';
+  return smiles;
+}

package/src/workers/dimensionality-reducer.ts

@@ -1,4 +1,4 @@
-import {DimensionalityReducer} from '@datagrok-libraries/utils/src/reduce-dimensionality';
+import {DimensionalityReducer, KnownMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
 
 /**
@@ -10,7 +10,7 @@ import {Coordinates} from '@datagrok-libraries/utils/src/type-declarations';
  * @param {number} cyclesCount Number of cycles to repeat.
  * @return {Coordinates} Embedding.
  */
-function onMessage(columnData: [], method: string, measure: string, cyclesCount: number): Coordinates {
+function onMessage(columnData: [], method: KnownMethods, measure: string, cyclesCount: number): Coordinates {
   const reducer = new DimensionalityReducer(
     columnData,
     method,

package/tsconfig.json

@@ -6,7 +6,7 @@
     // "incremental": true,                         /* Enable incremental compilation */
     "target": "es2018",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
     "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    "lib": ["es2020", "dom"],      /* Specify library files to be included in the compilation. */
+    "lib": ["es2020", "dom", "ES2021.String"],      /* Specify library files to be included in the compilation. */
     // "allowJs": true,                             /* Allow javascript files to be compiled. */
     // "checkJs": true,                             /* Report errors in .js files. */
     // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */

package/webpack.config.js

@@ -1,10 +1,20 @@
 const path = require('path');
+const packageName = path.parse(require('./package.json').name).name.toLowerCase().replace(/-/g, '');
 
 module.exports = {
   mode: 'development',
   entry: {
-    package: './src/package.ts',
+    package: ['./src/package.ts'],
+    test: {
+      filename: 'package-test.js',
+      library: {type: 'var', name: `${packageName}_test`},
+      import: './src/package-test.ts',
+    },
   },
+  devServer: {
+    contentBase: './dist',
+  },
+  target: 'web',
   module: {
     rules: [
       {
@@ -19,7 +29,7 @@ module.exports = {
     ],
   },
   resolve: {
-    extensions: ['.tsx', '.js', '.ts'],
+    extensions: ['.mjs', '.js', '.json', '.ts', '.tsx'],
   },
   devtool: 'inline-source-map',
   externals: {
@@ -36,4 +46,8 @@ module.exports = {
     libraryTarget: 'var',
     path: path.resolve(__dirname, 'dist'),
   },
+  experiments: {
+    asyncWebAssembly: true,
+    topLevelAwait: true,
+  },
 };

package/src/utils/correlation-analysis.ts

@@ -1,204 +0,0 @@
-/* Do not change these import lines. Datagrok will import API library in exactly the same manner */
-import * as DG from 'datagrok-api/dg';
-
-import {AlignedSequenceEncoder} from '@datagrok-libraries/utils/src/sequence-encoder';
-import {assert} from '@datagrok-libraries/utils/src/operations';
-import {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.
- */
-function matrix2DataFrame(matrix: Matrix): DG.DataFrame {
-  return DG.DataFrame.fromColumns(matrix.map((v, i) => DG.Column.fromFloat32Array(`${i+1}`, v)));
-}
-
-/**
- * Encodes sequence into a certain scale.
- *
- * @param {DG.DataFrame} df A data frame containing the sequences.
- * @param {string[]} [positionColumns] If given instructs which columns to consider as sequences containing.
- * @return {DG.DataFrame} The data frame with seqences encoded.
- */
-function encodeSequences(df: DG.DataFrame, positionColumns?: string[]): DG.DataFrame {
-  const [nCols, nRows] = [positionColumns ? positionColumns.length : df.columns.length, df.rowCount];
-  const enc = new AlignedSequenceEncoder('WimleyWhite');
-  const positions = new Array(nCols).fill(0).map((_) => new Float32Array(nRows));
-
-  for (let i = 0; i < nCols; ++i) {
-    const col: DG.Column = positionColumns ? df.getCol(positionColumns[i]) : df.columns.byIndex(i);
-
-    for (let j = 0; j < nRows; ++j) {
-      const letter = col.get(j);
-      positions[i][j] = enc.encodeLettter(letter);
-    }
-  }
-  const posDF = DG.DataFrame.fromColumns(positions.map((v, i) => DG.Column.fromFloat32Array(df.columns.names()[i], v)));
-  return posDF;
-}
-
-/**
- * Formats an adjacency matrix into <category1>-<category2>-<value> format.
- *
- * @param {DG.DataFrame} adjMatrix A data matrix to deal with.
- * @return {DG.DataFrame} The resulting data frame.
- */
-function createNetwork(adjMatrix: DG.DataFrame): DG.DataFrame {
-  const nCols = adjMatrix.columns.length;
-  const nRows = adjMatrix.rowCount;
-
-  assert(nCols == nRows);
-
-  const pos1: Array<number> = [];
-  const pos2: Array<number> = [];
-  const weight: Array<number> = [];
-
-  for (let i = 0; i < nCols; ++i) {
-    const c = adjMatrix.columns.byIndex(i);
-
-    for (let j = i+1; j < nRows; ++j) {
-      const r = c.getRawData()[j];
-
-      if (Math.abs(r) > 0) {
-        pos1.push(i+1);
-        pos2.push(j+1);
-        weight.push(r);
-      }
-    }
-  }
-
-  const pos1Col = DG.Column.fromList('int', 'pos1', pos1);
-  const pos2Col = DG.Column.fromList('int', 'pos2', pos2);
-  const weightCol = DG.Column.fromList('double', 'weight', weight);
-
-  return DG.DataFrame.fromColumns([pos1Col, pos2Col, weightCol]);
-}
-
-/**
- * Calculates Kendall's tau rank correlation matrix.
- *
- * @param {DG.DataFrame} df A data frame to process.
- * @param {number} [alpha=0.05] The significance threshold.
- * @param {number} [rAbsCutoff=0.5] The absolute R cutoff.
- * @return {DG.DataFrame} The correlation matrix.
- */
-function calcKendallTauMatrix(df: DG.DataFrame, alpha: number = 0.05, rAbsCutoff = 0.5): 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) && (Math.abs(res.test) >= rAbsCutoff) ? res.test : 0;
-      tau[j][i] = tau[i][j];
-    }
-  }
-  return matrix2DataFrame(tau);
-}
-
-/**
- * Calculates a correlation matrix via method chosen.
- *
- * @param {DG.DataFrame} df A data frame.
- * @return {DG.DataFrame} The correlation matrix.
- */
-function calcCorrelationMatrix(df: DG.DataFrame): DG.DataFrame {
-  return calcKendallTauMatrix(df);
-}
-
-type Weights = {[pos: number]: number};
-type Guide = {[pos: number]: Weights};
-
-/**
- * Calculates a dictionary with the keys containing the first correlating positions.
- * Values correspond to a dictionary containing the positions and corresponding R-value
- * which the given position correlating with.
- *
- * @param {DG.DataFrame} network A network to process.
- * @return {Guide} The formatted dictionary.
- */
-function calcGuide(network: DG.DataFrame): Guide {
-  assert(network.columns.length == 3);
-
-  const guide: Guide = {};
-  let [pos1Col, pos2Col, weightCol] = Array.from(network.columns);
-
-  pos1Col = pos1Col.getRawData();
-  pos2Col = pos2Col.getRawData();
-  weightCol = weightCol.getRawData();
-
-  function _addWeight(pos1: number, pos2: number, weight: number) {
-    if (guide[pos1] == undefined) {
-      guide[pos1] = {};
-    }
-    guide[pos1][pos2] = weight;
-  }
-
-  for (let i = 0; i < network.rowCount; ++i) {
-    const [pos1, pos2, weight] = [pos1Col[i], pos2Col[i], weightCol[i]];
-    _addWeight(pos1, pos2, weight);
-    _addWeight(pos2, pos1, weight);
-  }
-  return guide;
-}
-
-function calcCorrelations(df: DG.DataFrame, positionColumns?: string[]): Guide {
-  const posDF = encodeSequences(df, positionColumns);
-  const ccDF = calcCorrelationMatrix(posDF);
-  const nwDF = createNetwork(ccDF);
-  const guide = calcGuide(nwDF);
-  return guide;
-}
-
-/**
- * Formats correlating positions to place in the corresponding tooltips.
- * Higlights correlating positions' headers.
- *
- * @export
- * @class CorrelationAnalysisVisualizer
- */
-export class CorrelationAnalysisVisualizer {
-  protected guide: Guide;
-  protected highlightedColumns: number[];
-
-  /**
-   * Creates an instance of CorrelationAnalysisVisualizer.
-   * @param {DG.DataFrame} df A data frame to take sequences from.
-   * @param {string[]} positionColumns Optional columns list to take the sequences from.
-   * @memberof CorrelationAnalysisVisualizer
-   */
-  constructor(df: DG.DataFrame, positionColumns: string[]) {
-    if (df) {
-      this.guide = calcCorrelations(df, positionColumns);
-      this.highlightedColumns = Object.keys(this.guide).map((v) => parseInt(v));
-    } else {
-      throw new Error('Dataframe was not found in the grid.');
-    }
-  }
-
-  /**
-   * Returns a dictionary with the correlating positions and their R-value.
-   *
-   * @readonly
-   * @type {Guide} The dictionary.
-   * @memberof CorrelationAnalysisVisualizer
-   */
-  get path(): Guide {
-    return this.guide;
-  }
-
-  /**
-   * Checks if the position column name is found among correlelating ones.
-   *
-   * @param {string} name The name of the column.
-   * @return {boolean} True if the position is correlating with any oter.
-   * @memberof CorrelationAnalysisVisualizer
-   */
-  public isPositionCorrelating(name: string): boolean {
-    return this.highlightedColumns.includes(parseInt(name));
-  }
-}

package/src/viewers/spiral-plot.ts

@@ -1,97 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import {_toJson} from 'datagrok-api/src/utils';
-
-import {assert, argSort} from '@datagrok-libraries/utils/src/operations';
-import {Options} from '@datagrok-libraries/utils/src/type-declarations';
-
-const api = <any>window;
-
-/**
- * Draws 2D scatter plot from 1D series.
- *
- * @export
- * @class SpiralPlot
- * @extends {DG.ScatterPlotViewer}
- */
-export class SpiralPlot extends DG.ScatterPlotViewer {
-    static axesNames = ['~X', '~Y'];
-    static valuesKey = 'valuesColumnName';
-
-    /**
-     * Calculates coordinates of the projection into a spiral.
-     *
-     * @static
-     * @param {DG.DataFrame} t Source data frame.
-     * @param {Options} options Options to read values column name from. Must include {valuesColumnName: string}.
-     * @return {DG.DataFrame} Updated dataframe.
-     * @memberof SpiralPlot
-     */
-    static updateCoordinates(t: DG.DataFrame, options: Options): DG.DataFrame {
-      assert(options[SpiralPlot.valuesKey] != undefined);
-
-      const values = t.getCol(options[SpiralPlot.valuesKey]).getRawData() as Float32Array;
-      const columns = _calcSpiralProjection(values);
-      const cdf = DG.DataFrame.fromColumns(
-        Array.from(columns).map((v, i) => DG.Column.fromFloat32Array(SpiralPlot.axesNames[i], v)),
-      );
-      return _updateCoordinates(t, cdf);
-    }
-
-    /**
-     * Creates new SpiralPlot from a data frame with selected values column.
-     *
-     * @static
-     * @param {DG.DataFrame} t A data frame.
-     * @param {Options} options Controlling options.
-     * @return {SpiralPlot} The plot.
-     * @memberof SpiralPlot
-     */
-    static fromTable(t: DG.DataFrame, options: Options): SpiralPlot {
-      t = SpiralPlot.updateCoordinates(t, options);
-      [options.x, options.y] = SpiralPlot.axesNames;
-      options.color = options[SpiralPlot.valuesKey];
-      return new SpiralPlot(api.grok_Viewer_ScatterPlot(t.dart, _toJson(options)));
-    }
-}
-
-/**
- * Calculates 2D projection of 1D series as a spiral.
- *
- * @param {(number[] | Float32Array)} values The series.
- * @return {[Float32Array, Float32Array]} X and Y componenets of the projection.
- */
-function _calcSpiralProjection(values: number[] | Float32Array): [Float32Array, Float32Array] {
-  const nItems = values.length;
-  const order = argSort(Array.from(values), true);
-  const maxV = values[order[0]];
-  const X = new Float32Array(nItems).fill(0);
-  const Y = new Float32Array(nItems).fill(0);
-
-  for (const i of order) {
-    const v = maxV - values[i];
-    X[i] = v * Math.cos(Math.PI * v) - Math.random() * 1.5 + 0.75;
-    Y[i] = v * Math.sin(Math.PI * v) - Math.random() * 1.5 + 0.75;
-  }
-  return [X, Y];
-}
-
-/**
- * Adds new columns from one data frame into another one.
- *
- * @param {DG.DataFrame} table Destination data frame.
- * @param {DG.DataFrame} coords Source data frame.
- * @return {DG.DataFrame} Updated data frame.
- */
-function _updateCoordinates(table: DG.DataFrame, coords: DG.DataFrame): DG.DataFrame {
-  const coordsColNames: string[] = coords.columns.names();
-  const tableColNames: string[] = table.columns.names();
-  const restColNames = tableColNames.filter((v: string) => !coordsColNames.includes(v));
-
-  if (tableColNames.length == restColNames.length) {
-    for (const col of coords.columns) {
-      table.columns.add(col);
-    }
-    return table;
-  }
-  return table.join(coords, coordsColNames, coordsColNames, restColNames, [], 'right', false);
-}