@datagrok/peptides 1.0.0 → 1.1.0

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

@@ -1,106 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-
-//@ts-ignore
-import Aioli from '@biowasm/aioli';
-
-import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
-import * as C from './constants';
-
-/**
- * Converts array of sequences into simple fasta string.
- *
- * @param {string[]} sequences Input list of sequences.
- * @return {string} Fasta-formatted string.
- */
-function _stringsToFasta(sequences: string[]): string {
-  return sequences.reduce((a, v, i) => a + `>sample${i + 1}\n${v}\n`, '');
-}
-
-/**
- * Extracts array of sequences from simple fasta string.
- *
- * @param {string} fasta Fasta-formatted string.
- * @return {string[]} Output list of sequences.
- */
-function _fastaToStrings(fasta: string): string[] {
-  return fasta.replace(/>sample\d+(\r\n|\r|\n)/g, '').split('\n');
-}
-
-/**
- * Converts aligned sequence to semantic type format.
- *
- * @param {string} seq Source sequence.
- * @return {string} Formatted sequence.
- */
-function _castAligned(seq: string): string {
-  let delimited = '';
-
-  for (const char of seq)
-    delimited += char == '-' ? char : `-${char}`;
-
-  return `NH2${delimited}-COOH`;
-}
-
-/**
- * Formats a batch of sequences to correspond the semantic type.
- *
- * @param {string[]} alignment List of aligned sequences.
- * @return {string[]} Formatted sequences.
- */
-function _stringsToAligned(alignment: string[]): string[] {
-  const nItems = alignment.length;
-  const aligned = new Array<string>(nItems);
-
-  for (let i = 0; i < nItems; ++i)
-    aligned[i] = _castAligned(alignment[i]);
-
-  return aligned;
-}
-
-/**
- * Runs Aioli environment with kalign tool.
- *
- * @param {DG.Column} col Column with sequences.
- * @param {boolean} isAligned Whether the column is aligned.
- * @return {Promise<DG.Column>} Aligned sequences.
- */
-export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.Column> {
-  let sequences = col.toList();
-
-  if (isAligned)
-    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,
-  });
-
-  console.log(['fasta.length =', fasta.length]);
-
-  await CLI.fs.writeFile('input.fa', fasta);
-  const output = await CLI.exec('kalign input.fa -f fasta -o result.fasta');
-  const buf = await CLI.cat('result.fasta');
-
-  console.warn(output);
-
-  const aligned = _fastaToStrings(buf).slice(0, sequences.length);
-  const alignedCol = DG.Column.fromStrings(`(${col.name})msa`, _stringsToAligned(aligned));
-  alignedCol.semType = C.SEM_TYPES.ALIGNED_SEQUENCE;
-  return alignedCol;
-}
-
-export async function testMSAEnoughMemory(col: DG.Column): Promise<void> {
-  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

@@ -1,76 +0,0 @@
-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(
-  currentDf: DG.DataFrame,
-  options: {[name: string]: string},
-  sequencesCol: DG.Column,
-): Promise<void> {
-  const activityCol = await _scaleColumn(currentDf.getCol(options['activityColumnName']), options['scaling']);
-  const encDf = _encodeSequences(sequencesCol);
-
-  //TODO: is it correct? Is it needed?
-  _insertColumns(
-    currentDf,
-    [DG.Column.fromList('double', C.COLUMNS_NAMES.ACTIVITY_SCALED, activityCol.toList())],
-  );
-  _insertColumns(currentDf, encDf.columns.toList());
-
-  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]);
-  }
-  return DG.DataFrame.fromColumns(positions.map(
-    (v, i) => DG.Column.fromFloat32Array((i+1).toString(), v),
-  ));
-}
-
-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/viewers/stacked-barchart-viewer.ts

@@ -1,339 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import * as rxjs from 'rxjs';
-import * as ui from 'datagrok-api/ui';
-import {MonomerLibrary} from '../monomer-library';
-
-import * as C from '../utils/constants';
-import * as type from '../utils/types';
-import {PeptidesModel} from '../model';
-
-export function addViewerToHeader(grid: DG.Grid, barchart: StackedBarChart): void {
-  if (grid.temp['containsBarchart'])
-    return;
-
-  const eventAction = (ev: MouseEvent): void => {
-    const cell = grid.hitTest(ev.offsetX, ev.offsetY);
-    if (cell?.isColHeader && cell.tableColumn?.semType == C.SEM_TYPES.AMINO_ACIDS) {
-      const newBarPart = barchart.findAARandPosition(cell, ev);
-      barchart._currentBarPart = newBarPart;
-      barchart.requestAction(ev, newBarPart);
-      barchart.computeData();
-    }
-  };
-
-  // The following events makes the barchart interactive
-  rxjs.fromEvent<MouseEvent>(grid.overlay, 'mousemove').subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
-  rxjs.fromEvent<MouseEvent>(grid.overlay, 'click').subscribe((mouseMove: MouseEvent) => eventAction(mouseMove));
-  rxjs.fromEvent<MouseEvent>(grid.overlay, 'mouseout').subscribe(() => barchart.unhighlight());
-
-  barchart.tableCanvas = grid.canvas;
-
-  //Setting grid options
-  grid.setOptions({'colHeaderHeight': 130});
-
-  grid.onCellTooltip((cell, x, y) => {
-    if (
-      cell.tableColumn &&
-      [C.SEM_TYPES.AMINO_ACIDS, C.SEM_TYPES.ALIGNED_SEQUENCE].includes(cell.tableColumn.semType as C.SEM_TYPES)
-    ) {
-      if (!cell.isColHeader) {
-        const monomerLib = cell.cell.dataFrame.temp[MonomerLibrary.id];
-        PeptidesModel.chemPalette.showTooltip(cell, x, y, monomerLib);
-      } else if (barchart._currentBarPart) {
-        let elements: HTMLElement[] = [];
-        elements = elements.concat([ui.divText(barchart._currentBarPart.aaName)]);
-        ui.tooltip.show(ui.divV(elements), x, y);
-      }
-    }
-    return true;
-  });
-
-  grid.onCellRender.subscribe((args) => {
-    const context = args.g;
-    const boundX = args.bounds.x;
-    const boundY = args.bounds.y;
-    const boundWidth = args.bounds.width;
-    const boundHeight = args.bounds.height;
-    const cell = args.cell;
-    context.save();
-    context.beginPath();
-    context.rect(boundX, boundY, boundWidth, boundHeight);
-    context.clip();
-
-    if (cell.isColHeader && barchart.aminoColumnNames.includes(cell.gridColumn.name)) {
-      barchart.renderBarToCanvas(context, cell, boundX, boundY, boundWidth, boundHeight);
-      args.preventDefault();
-    }
-    context.restore();
-  });
-
-  grid.temp['containsBarchart'] = true;
-  //FIXME: for some reason barchat didn't show when running analysis. This fixes it, but it's bad. Find a way to fix
-  // the problem
-  barchart.unhighlight();
-}
-
-export class StackedBarChart extends DG.JsViewer {
-  dataEmptyAA: string;
-  _currentBarPart: type.BarChart.BarPart | null = null;
-  tableCanvas: HTMLCanvasElement | undefined;
-  aminoColumnNames: string[] = [];
-  ord: { [Key: string]: number; } = {};
-  aminoColumnIndices: {[Key: string]: number} = {};
-  aggregatedFilterTables: type.DataFrameDict = {};
-  max = 0;
-  barStats: {[Key: string]: type.BarChart.BarStatsObject[]} = {};
-  selected: type.BarChart.BarPart[] = [];
-  aggregatedSelectedTables: type.DataFrameDict = {};
-  model!: PeptidesModel;
-
-  constructor() {
-    super();
-    this.dataEmptyAA = this.string('dataEmptyAA', '-');
-  }
-
-  init(): void {
-    const groups: {[key: string]: string[]} = {
-      'yellow': ['C', 'U'],
-      'red': ['G', 'P'],
-      'all_green': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
-      'light_blue': ['R', 'H', 'K'],
-      'dark_blue': ['D', 'E'],
-      'orange': ['S', 'T', 'N', 'Q'],
-    };
-    let i = 0;
-
-    for (const value of Object.values(groups)) {
-      for (const obj of value)
-        this.ord[obj] = i++;
-    }
-
-    this.aminoColumnNames = [];
-  }
-
-  // Stream subscriptions
-  async onTableAttached(): Promise<void> {
-    this.init();
-    this.model = await PeptidesModel.getInstance(this.dataFrame);
-    // this.controller.init(this.dataFrame);
-    if (this.dataFrame) {
-      this.subs.push(DG.debounce(this.dataFrame.selection.onChanged, 50).subscribe((_) => this.computeData()));
-      this.subs.push(DG.debounce(this.dataFrame.filter.onChanged, 50).subscribe((_) => this.computeData()));
-      this.subs.push(DG.debounce(this.dataFrame.onValuesChanged, 50).subscribe(() => this.computeData()));
-    }
-  }
-
-  // Cancel subscriptions when the viewer is detached
-  detach(): void {
-    this.subs.forEach((sub) => sub.unsubscribe());
-  }
-
-  computeData(): void {
-    this.aminoColumnNames = [];
-    this.aminoColumnIndices = {};
-
-    this.dataFrame.columns.names().forEach((name: string) => {
-      if (this.dataFrame.getCol(name).semType === C.SEM_TYPES.AMINO_ACIDS &&
-          !this.dataFrame.getCol(name).categories.includes('COOH') &&
-          !this.dataFrame.getCol(name).categories.includes('NH2')) {
-        this.aminoColumnIndices[name] = this.aminoColumnNames.length + 1;
-        this.aminoColumnNames.push(name);
-      }
-    });
-
-    this.aggregatedFilterTables = {};
-    this.aggregatedSelectedTables = {};
-    //TODO: optimize it, why store so many tables?
-    this.aminoColumnNames.forEach((name) => {
-      this.aggregatedFilterTables[name] = this.dataFrame
-        .groupBy([name])
-        .whereRowMask(this.dataFrame.filter)
-        .add('count', name, `${name}_count`)
-        .aggregate();
-
-      this.aggregatedSelectedTables[name] = this.dataFrame
-        .groupBy([name])
-        .whereRowMask(this.dataFrame.selection)
-        .add('count', name, `${name}_count`)
-        .aggregate();
-    });
-
-    this.barStats = {};
-
-    for (const [name, df] of Object.entries(this.aggregatedFilterTables)) {
-      const colData: {'name': string, 'count': number, 'selectedCount': number}[] = [];
-      const aminoCol = df.getCol(name);
-      const aminoCountCol = df.getCol(`${name}_count`);
-      this.barStats[name] = colData;
-
-      for (let i = 0; i < df.rowCount; i++) {
-        const amino = aminoCol.get(i);
-        const aminoCount = aminoCountCol.get(i);
-        const aminoObj = {'name': amino, 'count': aminoCount, 'selectedCount': 0};
-        const aggSelectedAminoCol = this.aggregatedSelectedTables[name].getCol(`${name}`);
-        const aggSelectedCountCol = this.aggregatedSelectedTables[name].getCol(`${name}_count`);
-
-        if (!amino || amino === this.dataEmptyAA)
-          continue;
-
-        colData.push(aminoObj);
-
-        for (let j = 0; j < aggSelectedCountCol.length; j++) {
-          const selectedAmino = aggSelectedAminoCol.get(j);
-          const curAmino = (selectedAmino);
-          if (curAmino == amino) {
-            aminoObj['selectedCount'] = aggSelectedCountCol.get(j);
-            break;
-          }
-        }
-      }
-
-      colData.sort((o1, o2) => this.ord[o2['name']] - this.ord[o1['name']]);
-    }
-
-    this.max = this.dataFrame.filter.trueCount;
-  }
-
-  renderBarToCanvas(g: CanvasRenderingContext2D, cell: DG.GridCell, x: number, y: number, w: number, h: number): void {
-    const name = cell.tableColumn!.name;
-    const colNameSize = g.measureText(name).width;
-    const barData = this.barStats[name];
-    const margin = 0.2;
-    const innerMargin = 0.02;
-    const selectLineRatio = 0.1;
-    let sum = 0;
-
-    barData.forEach((obj) => {
-      sum += obj['count'];
-    });
-
-    x = x + w * margin;
-    y = y + h * margin / 4;
-    w = w - w * margin * 2;
-    h = h - h * margin;
-    const barWidth = w - 10;
-    g.fillStyle = 'black';
-    g.textBaseline = 'top';
-    g.font = `${h * margin / 2}px`;
-    g.fillText(name, x + (w - colNameSize) / 2, y + h + h * margin / 4);
-
-    barData.forEach((obj) => {
-      const sBarHeight = h * obj['count'] / this.max;
-      const gapSize = sBarHeight * innerMargin;
-      const verticalShift = (this.max - sum) / this.max;
-      const [color, aarOuter] = PeptidesModel.chemPalette.getColorAAPivot(obj['name']);
-      const textSize = g.measureText(aarOuter);
-      const fontSize = 11;
-      const leftMargin = (w - (aarOuter.length > 1 ? fontSize : textSize.width - 8)) / 2;
-      const subBartHeight = sBarHeight - gapSize;
-      const yStart = h * verticalShift + gapSize / 2;
-      const xStart = (w - barWidth) / 2;
-      const absX = x + leftMargin;
-      const absY = y + yStart + subBartHeight / 2 + (aarOuter.length == 1 ? + 4 : 0);
-      const eps = 0.1;
-
-      g.strokeStyle = color;
-      g.fillStyle = color;
-      if (textSize.width <= subBartHeight) {
-        const origTransform = g.getTransform();
-
-        if (color != PeptidesModel.chemPalette.undefinedColor) {
-          g.fillRect(x + xStart, y + yStart, barWidth, subBartHeight);
-          g.fillStyle = 'black';
-        } else
-          g.strokeRect(x + xStart + 0.5, y + yStart, barWidth - 1, subBartHeight);
-
-        g.font = `${fontSize}px monospace`;
-        g.textAlign = 'center';
-        g.textBaseline = 'bottom';
-
-        if (aarOuter.length > 1) {
-          g.translate(absX, absY);
-          g.rotate(Math.PI / 2);
-          g.translate(-absX, -absY);
-        }
-
-        g.fillText(aarOuter, absX, absY);
-        g.setTransform(origTransform);
-      } else
-        g.fillRect(x + xStart, y + yStart, barWidth, subBartHeight);
-
-      if (obj['selectedCount'] > eps) {
-        g.fillStyle = 'rgb(255,165,0)';
-        g.fillRect(
-          x + xStart - w * selectLineRatio * 2,
-          y + yStart,
-          barWidth * selectLineRatio,
-          h * obj['selectedCount'] / this.max - gapSize,
-        );
-      }
-
-      sum -= obj['count'];
-    });
-  }
-
-  findAARandPosition(cell: DG.GridCell, mouseEvent: MouseEvent): {colName: string, aaName: string} | null {
-    if (!cell.tableColumn?.name || !this.aminoColumnNames.includes(cell.tableColumn.name))
-      return null;
-
-    const offsetX = mouseEvent.offsetX;
-    const offsetY = mouseEvent.offsetY;
-    const colName = cell.tableColumn?.name;
-    const innerMargin = 0.02;
-    const margin = 0.2;
-    const bound = cell.bounds;
-    const height = 130;
-    const x = bound.x + bound.width * margin;
-    const y = height * margin / 4;
-    const w = bound.width - bound.width * margin * 2;
-    const h = height - height * margin;
-    const barData = this.barStats[colName];
-    const barWidth = w - 10;
-    let sum = 0;
-
-    barData.forEach((obj) => {
-      sum += obj['count'];
-    });
-
-    const xStart = x + (w - barWidth) / 2;
-    for (const obj of barData) {
-      const sBarHeight = h * obj['count'] / this.max;
-      const gapSize = sBarHeight * innerMargin;
-      const verticalShift = (this.max - sum) / this.max;
-      const subBartHeight = sBarHeight - gapSize;
-      const yStart = y + h * verticalShift + gapSize / 2;
-
-      const isIntersectingX = offsetX >= xStart && offsetX <= xStart + barWidth;
-      const isIntersectingY = offsetY >= yStart && offsetY <= yStart + subBartHeight;
-
-      if (isIntersectingX && isIntersectingY)
-        return {'colName': colName, 'aaName': obj['name']};
-
-      sum -= obj['count'];
-    }
-
-    return null;
-  }
-
-  unhighlight(): void {
-    ui.tooltip.hide();
-    this.computeData();
-  }
-
-  /** Requests highlight/select/filter action based on currentBarPart */
-  requestAction(event: MouseEvent, barPart: {colName: string, aaName: string} | null): void {
-    if (!barPart)
-      return;
-    const aar = barPart['aaName'];
-    const position = barPart['colName'];
-    if (event.type === 'click') {
-      event.shiftKey ? this.model.modifyCurrentSelection(aar, position) :
-        this.model.initCurrentSelection(aar, position);
-    } else {
-      ui.tooltip.showRowGroup(this.dataFrame, (i) => {
-        const currentAAR = this.dataFrame.get(position, i);
-        return currentAAR === aar;
-      }, event.offsetX, event.offsetY);
-    }
-  }
-}

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

@@ -1,9 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import {runKalign} from '../utils/multiple-sequence-alignment';
-
-export async function msaWidget(col: DG.Column): Promise<DG.DataFrame> {
-  const msaCol = await runKalign(col, true);
-  const table = col.dataFrame;
-  table.columns.add(msaCol);
-  return table;
-}

package/src/widgets/peptide-molecule.ts

@@ -1,82 +0,0 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-import * as C from '../utils/constants';
-import {PeptidesModel} from '../model';
-
-/**
- * 3D representation widget of peptide molecule.
- *
- * @export
- * @param {string} pep Peptide string.
- * @return {Promise<DG.Widget>} Widget.
- */
-export async function peptideMoleculeWidget(pep: string, currentTable: DG.DataFrame): Promise<DG.Widget> {
-  const pi = DG.TaskBarProgressIndicator.create('Creating NGL view');
-  const separator = currentTable.columns.bySemType(C.SEM_TYPES.ALIGNED_SEQUENCE)!.tags[C.TAGS.SEPARATOR];
-
-  let widgetHost;
-  let smiles = '';
-  let molfileStr = '';
-  try {
-    try {
-      const params = {table: currentTable};
-      const result = await grok.functions.call('Customerextensions:getPeptideStructure', params) as string[];
-      if (result.length !== 0) {
-        smiles = result[0];
-        molfileStr = result[1];
-        throw new Error(`Found structure in DB`);
-      }
-
-      smiles = getMolecule(pep, separator);
-      if (smiles == '')
-        throw new Error('Couldn\'t get smiles');
-
-      molfileStr = (await grok.functions.call('Peptides:SmiTo3D', {smiles})) as string;
-    } catch (e) {
-      console.warn(e);
-    }
-
-    try {
-      molfileStr = molfileStr.replaceAll('\\n', '\n');
-      const stringBlob = new Blob([molfileStr], {type: 'text/plain'});
-      const nglHost = ui.div([], {classes: 'd4-ngl-viewer', id: 'ngl-3d-host'});
-
-      //@ts-ignore
-      const stage = new NGL.Stage(nglHost, {backgroundColor: 'white'});
-      //@ts-ignore
-      stage.loadFile(stringBlob, {ext: 'sdf'}).then(function(comp: NGL.StructureComponent) {
-        stage.setSize(300, 300);
-        comp.addRepresentation('ball+stick');
-        comp.autoView();
-      });
-      const sketch = grok.chem.svgMol(molfileStr);
-      const panel = ui.divH([sketch]);
-
-      widgetHost = ui.div([panel, nglHost]);
-    } catch (e) {
-      widgetHost = ui.divText('Couldn\'t get peptide structure');
-    }
-  } catch (e) {
-    widgetHost = ui.divText('Couldn\'t get peptide structure');
-  }
-  pi.close();
-  return new DG.Widget(widgetHost);
-}
-
-export function getMolecule(pep: string, separator: string): string {
-  const split = pep.split(separator);
-  const mols = [];
-  const chemPalette = PeptidesModel.chemPalette;
-  for (let i = 1; i < split.length - 1; i++) {
-    if (split[i] in chemPalette.AASmiles) {
-      const aar = chemPalette.AASmiles[split[i]];
-      mols[i] = aar.substring(0, aar.length - 1);
-    } else if (!split[i] || split[i] == '-')
-      mols[i] = '';
-    else
-      return '';
-  }
-
-  return mols.join('') + 'O';
-}