@datagrok/bio 1.7.23 → 1.8.1

package/src/tests/sequence-space-test.ts

@@ -1,30 +1,35 @@
-import {after, before, category, test, expect} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, delay} from '@datagrok-libraries/utils/src/test';
 import * as DG from 'datagrok-api/dg';
-import {sequenceSpace} from '../utils/sequence-space';
 import {readDataframe} from './utils';
 import * as grok from 'datagrok-api/grok';
+import { _testSequenceSpaceReturnsResult } from './sequence-space-utils';
 
 category('sequenceSpace', async () => {
   let testFastaDf: DG.DataFrame;
+  let testFastaTableView: DG.TableView;
+  let testHelmWithEmptyRows: DG.DataFrame;
+  let testHelmWithEmptyRowsTableView: DG.TableView;
 
   before(async () => {
     testFastaDf = await readDataframe('samples/sample_FASTA.csv');
-    // await grok.data.detectSemanticTypes(testFastaDf);
+    testFastaTableView = grok.shell.addTableView(testFastaDf);
+    testHelmWithEmptyRows = await readDataframe('samples/sample_HELM_empty_vals.csv');
+    testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
   });
 
   after(async () => {
     grok.shell.closeTable(testFastaDf);
+    testFastaTableView.close();
+    grok.shell.closeTable(testHelmWithEmptyRows);
+    testHelmWithEmptyRowsTableView.close();
   });
 
   test('sequenceSpaceOpens', async () => {
-    const sequenceSpaceParams = {
-      seqCol: testFastaDf.col('Sequence')!,
-      methodName: 't-SNE',
-      similarityMetric: 'Levenshtein',
-      embedAxesNames: ['Embed_X', 'Embed_Y']
-    };
-    const res = await sequenceSpace(sequenceSpaceParams);
-    expect(res.coordinates != undefined, true);
-    expect(res.distance != undefined, true);
+    await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'Sequence');
   });
+
+  test('sequenceSpaceOpensWithEmptyRows', async () => {
+    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, 'UMAP', 'HELM');
+  });
+
 });

package/src/tests/sequence-space-utils.ts

@@ -0,0 +1,10 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import { expect } from '@datagrok-libraries/utils/src/test';
+import { sequenceSpaceTopMenu } from '../package';
+
+export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: string, colName: string) {
+  await grok.data.detectSemanticTypes(df);
+  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, 'Levenshtein', true);
+  expect(sp != null, true);
+}

package/src/utils/cell-renderer.ts

@@ -7,7 +7,6 @@ import {SplitterFunc, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-log
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import * as ui from 'datagrok-api/ui';
 
-export const lru = new DG.LruCache<any, any>();
 const undefinedColor = 'rgb(100,100,100)';
 const grayColor = '#808080';
 
@@ -62,78 +61,112 @@ export function processSequence(subParts: string[]): [string[], boolean] {
  * @param {boolean} [last=false] Is checker if element last or not.
  * @return {number} x coordinate to start printing at.
  */
-function printLeftOrCentered(
+export function printLeftOrCentered(
   x: number, y: number, w: number, h: number,
   g: CanvasRenderingContext2D, s: string, color = undefinedColor,
   pivot: number = 0, left = false, transparencyRate: number = 1.0,
-  separator: string = '', last: boolean = false, drawStyle: string = 'classic', maxWord:any={}, maxWordIdx:number=0, gridCell:any = {}): number {
+  separator: string = '', last: boolean = false, drawStyle: string = 'classic', maxWord: any = {}, maxWordIdx: number = 0, gridCell: any = {}): number {
   g.textAlign = 'start';
   const colorPart = s.substring(0);
   let grayPart = last ? '' : separator;
   if (drawStyle === 'msa') {
-    grayPart = ' ';
+    grayPart = '';
   }
 
   let textSize: any = g.measureText(colorPart + grayPart);
   const indent = 5;
 
+  let maxColorTextSize = g.measureText(colorPart).width;
   let colorTextSize = g.measureText(colorPart).width;
   const dy = (textSize.fontBoundingBoxAscent + textSize.fontBoundingBoxDescent) / 2;
   textSize = textSize.width;
   if (drawStyle === 'msa') {
-    if (colorTextSize > maxWord) {
-      maxWord[maxWordIdx] = colorTextSize;
+    maxColorTextSize = maxWord[maxWordIdx];
+    textSize = maxWord[maxWordIdx];
+    if (maxColorTextSize > maxWord) {
+      maxWord[maxWordIdx] = maxColorTextSize;
+      gridCell.cell.column.temp = maxWord;
+    }
+    if (maxWordIdx > (maxWord['bio-maxIndex'] ?? 0)) {
+      maxWord['bio-maxIndex'] = maxWordIdx;
       gridCell.cell.column.temp = maxWord;
     }
-    colorTextSize = maxWord[maxWordIdx];
-    textSize = maxWord[maxWordIdx];
   }
 
   function draw(dx1: number, dx2: number): void {
     g.fillStyle = color;
     g.globalAlpha = transparencyRate;
-    g.fillText(colorPart, x + dx1, y + dy);
     if (drawStyle === 'classic') {
+      g.fillText(colorPart, x + dx1, y + dy);
       g.fillStyle = grayColor;
       g.fillText(grayPart, x + dx2, y + dy);
     }
+    if (drawStyle === 'msa') {
+      g.fillStyle = color;
+      g.fillText(colorPart, x + dx1 + ((maxWord[maxWordIdx] - colorTextSize) / 2), y + dy);
+    }
   }
 
   if (left || textSize > w) {
-    draw(indent, indent + colorTextSize);
-    return x + colorTextSize + g.measureText(grayPart).width;
+    draw(indent, indent + maxColorTextSize);
+    return x + maxColorTextSize + g.measureText(grayPart).width;
+
   } else {
     const dx = (w - textSize) / 2;
-    draw(dx, dx + colorTextSize);
-    return x + dx + colorTextSize;
+    draw(dx, dx + maxColorTextSize);
+    return x + dx + maxColorTextSize;
   }
 }
 
-function findMonomers(helmString: string) {
-  //@ts-ignore
-  const types = Object.keys(org.helm.webeditor.monomerTypeList());
-  const monomers: any = [];
-  const monomer_names: any = [];
-  for (var i = 0; i < types.length; i++) {
-    //@ts-ignore
-    monomers.push(new scil.helm.Monomers.getMonomerSet(types[i]));
-    Object.keys(monomers[i]).forEach(k => {
-      monomer_names.push(monomers[i][k].id);
-    });
-  }
-  const split_string = WebLogo.splitterAsHelm(helmString);
-  return new Set(split_string.filter(val => !monomer_names.includes(val)));
-}
 
 export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
-  get name(): string { return 'macromoleculeSequence'; }
+  get name(): string { return 'sequence'; }
 
-  get cellType(): string { return C.SEM_TYPES.MACROMOLECULE; }
+  get cellType(): string { return 'sequence'; }
 
   get defaultHeight(): number { return 30; }
 
   get defaultWidth(): number { return 230; }
 
+  onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
+    if (gridCell.cell.column.getTag('aligned') !== 'SEQ.MSA') {
+      return;
+    }
+    const maxLengthWordsSum = gridCell.cell.column.temp['bio-sum-maxLengthWords'];
+    if (maxLengthWordsSum == null) {
+      gridCell.cell.column.setTag('.calculatedCellRender', 'unexist');
+    }
+    const maxIndex = gridCell.cell.column.temp['bio-maxIndex'];
+    //@ts-ignore
+    const argsX = e.layerX - gridCell.gridColumn.left - ((gridCell.bounds.x<0) ? gridCell.bounds.x : 0);
+    let left = 0;
+    let right = maxIndex;
+    let found = false;
+    maxLengthWordsSum[maxIndex + 1] = argsX + 1;
+    let mid = 0;
+    if (argsX > maxLengthWordsSum[0]) {
+      while (!found) {
+        mid = Math.floor((right + left) / 2);
+        if (argsX >= maxLengthWordsSum[mid] && argsX <= maxLengthWordsSum[mid + 1]) {
+          left = mid;
+          found = true;
+        } else if (argsX < maxLengthWordsSum[mid]) {
+          right = mid - 1;
+        } else if (argsX > maxLengthWordsSum[mid + 1]) {
+          left = mid + 1;
+        }
+        if (left == right) {
+          found = true;
+        }
+      }
+    }
+    left = (argsX >= maxLengthWordsSum[left]) ? left + 1 : left;
+    const separator = gridCell.cell.column.getTag('separator') ?? '';
+    const splitterFunc: SplitterFunc = WebLogo.getSplitter('separator', separator);
+    const subParts: string[] = splitterFunc(gridCell.cell.value);
+    ui.tooltip.show(ui.div(subParts[left]), e.x + 16, e.y + 16);
+  }
+
   /**
    * Cell renderer function.
    *
@@ -152,116 +185,73 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   ): void {
     const grid = gridCell.gridRow !== -1 ? gridCell.grid : undefined;
     const cell = gridCell.cell;
-    const tag = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-    if (tag === 'HELM') {
-      const monomers = findMonomers(cell.value);
-      if (monomers.size == 0) {
-        const host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
-        host.setAttribute('dataformat', 'helm');
-        host.setAttribute('data', gridCell.cell.value);
-        gridCell.element = host;
-        //@ts-ignore
-        const canvas = new JSDraw2.Editor(host, {width: w, height: h, skin: 'w8', viewonly: true});
-        const formula = canvas.getFormula(true);
-        if (!formula) {
-          gridCell.element = ui.divText(gridCell.cell.value, {style: {color: 'red'}});
-        }
-        const molWeight = Math.round(canvas.getMolWeight() * 100) / 100;
-        const coef = Math.round(canvas.getExtinctionCoefficient(true) * 100) / 100;
-        const molfile = canvas.getMolfile();
-        const result = formula + ', ' + molWeight + ', ' + coef + ', ' + molfile;
-        lru.set(gridCell.cell.value, result);
-        return;
-      }
-      if (monomers.size > 0) {
-        w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-        g.save();
-        g.beginPath();
-        g.rect(x, y, w, h);
-        g.clip();
-        g.font = '12px monospace';
-        g.textBaseline = 'top';
-        let x1 = x;
-        const s: string = cell.value ?? '';
-        let subParts: string[] = WebLogo.splitterAsHelm(s);
+    const [type, subtype, paletteType] = gridCell.cell.column.getTag(DG.TAGS.UNITS).split(':');
+    w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
+    g.save();
+    g.beginPath();
+    g.rect(x, y, w, h);
+    g.clip();
+    g.font = '12px monospace';
+    g.textBaseline = 'top';
+    const s: string = cell.value ?? '';
+
+    //TODO: can this be replaced/merged with splitSequence?
+    const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
+
+    const palette = getPalleteByType(paletteType);
+
+    const separator = gridCell.cell.column.getTag('separator') ?? '';
+    const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, separator);
+
+    const columns = gridCell.cell.column.categories;
+    let monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = WebLogo.monomerToShort;
+    let maxLengthOfMonomer = 8;
+
+    let maxLengthWords: any = {};
+    if (gridCell.cell.column.getTag('.calculatedCellRender') !== 'exist') {
+      for (let i = 0; i < columns.length; i++) {
+        let subParts: string[] = splitterFunc(columns[i]);
         subParts.forEach((amino, index) => {
-          let color = monomers.has(amino) ? 'red' : grayColor;
-          g.fillStyle = undefinedColor;
-          let last = index === subParts.length - 1;
-          x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, 1.0, '/', last);
+          let textSizeWidth = g.measureText(monomerToShortFunction(amino, maxLengthOfMonomer));
+          if (textSizeWidth.width > (maxLengthWords[index] ?? 0)) {
+            maxLengthWords[index] = textSizeWidth.width;
+          }
+          if (index > (maxLengthWords['bio-maxIndex'] ?? 0)) {
+            maxLengthWords['bio-maxIndex'] = index;
+          }
         });
-        g.restore();
-        return;
       }
-    } else {
-      const [type, subtype, paletteType] = gridCell.cell.column.getTag(DG.TAGS.UNITS).split(':');
-      w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
-      g.save();
-      g.beginPath();
-      g.rect(x, y, w, h);
-      g.clip();
-      g.font = '12px monospace';
-      g.textBaseline = 'top';
-      const s: string = cell.value ?? '';
-
-      //TODO: can this be replaced/merged with splitSequence?
-      const units = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-
-      const palette = getPalleteByType(paletteType);
-
-      const separator = gridCell.cell.column.getTag('separator') ?? '';
-      const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, gridCell.cell.column.getTag('separator'));
-
-      // обработка новых елементов
-      const columns = gridCell.cell.column.categories;
-      let maxLengthWords = {};
-      // check if gridCell.cell.column.temp is array
-      if (gridCell.cell.column.getTag('.calculatedCellRender') !== 'exist') {
-        for (let i = 0; i < columns.length; i++) {
-          let subParts: string[] = splitterFunc(columns[i]);
-          subParts.forEach((amino, index) => {
-            //@ts-ignore
-            let textSizeWidth = g.measureText(WebLogo.monomerToText(amino) + ' ');
-            //@ts-ignore
-            if (textSizeWidth.width > (maxLengthWords[index] ?? 0)) {
-              //@ts-ignore
-              maxLengthWords[index] = textSizeWidth.width;
-            }
-          });
-        }
-        gridCell.cell.column.temp = maxLengthWords;
-        gridCell.cell.column.setTag('.calculatedCellRender', 'exist');
-      } else {
-        maxLengthWords = gridCell.cell.column.temp;
+      let maxLengthWordSum: any = {};
+      maxLengthWordSum[0] = maxLengthWords[0];
+      for (let i = 1; i <= maxLengthWords['bio-maxIndex']; i++) {
+        maxLengthWordSum[i] = maxLengthWordSum[i - 1] + maxLengthWords[i];
       }
+      gridCell.cell.column.temp = {
+        'bio-sum-maxLengthWords': maxLengthWordSum,
+        'bio-maxIndex': maxLengthWords['bio-maxIndex'],
+        'bio-maxLengthWords': maxLengthWords
+      };
+      gridCell.cell.column.setTag('.calculatedCellRender', 'exist');
+    } else {
+      maxLengthWords = gridCell.cell.column.temp['bio-maxLengthWords'];
+    }
 
-      const subParts: string[] = splitterFunc(cell.value);
-      let x1 = x;
-      let color = undefinedColor;
-      // get max length word in subParts
-      let tagUnits = gridCell.cell.column.getTag(DG.TAGS.UNITS);
-      let maxLength = 0;
-      let maxWord = '';
-      let drawStyle = 'classic';
-      if (tagUnits.includes('MSA')) {
-        subParts.forEach(part => {
-          if (part.length > maxLength) {
-            maxLength = part.length;
-            maxWord = part;
-            drawStyle = 'msa';
-          }
-        });
-      }
-      subParts.forEach((amino, index) => {
-        color = palette.get(amino);
-        g.fillStyle = undefinedColor;
-        let last = index === subParts.length - 1;
-        x1 = printLeftOrCentered(x1, y, w, h, g, WebLogo.monomerToText(amino), color, 0, true, 1.0, separator, last, drawStyle, maxLengthWords, index, gridCell);
-      });
-
-      g.restore();
-      return;
+    const subParts: string[] = splitterFunc(cell.value);
+    let x1 = x;
+    let color = undefinedColor;
+    let drawStyle = 'classic';
+    if (gridCell.cell.column.getTag('aligned').includes('MSA')) {
+      drawStyle = 'msa';
     }
+    subParts.forEach((amino, index) => {
+      color = palette.get(amino);
+      g.fillStyle = undefinedColor;
+      let last = index === subParts.length - 1;
+      x1 = printLeftOrCentered(x1, y, w, h, g, monomerToShortFunction(amino, maxLengthOfMonomer), color, 0, true, 1.0, separator, last, drawStyle, maxLengthWords, index, gridCell);
+    });
+
+    g.restore();
+    return;
   }
 }
 

package/src/utils/convert.ts

@@ -49,7 +49,17 @@ export function convert(col: DG.Column): void {
   if (convertDialog == null) {
     convertDialog = ui.dialog('Convert sequence notation')
       .add(ui.div([
-        ui.h1('Current notation: ' + currentNotation),
+        ui.divText(
+          'Current notation: ' + currentNotation,
+          {
+            style: {
+              'text-align': 'center',
+              'font-weight': 'bold',
+              'font-size': '14px',
+              'padding': '5px',
+            }
+          }
+        ),
         targetNotationInput.root,
         separatorInput.root
       ]))
@@ -59,7 +69,7 @@ export function convert(col: DG.Column): void {
 
         await convertDo(col, targetNotation, separator);
       })
-      .show();
+      .show({x: 350, y: 100});
 
     convertDialogSubs.push(convertDialog.onClose.subscribe((value) => {
       convertDialogSubs.forEach((s) => { s.unsubscribe(); });

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

@@ -57,9 +57,15 @@ export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName
 
   // units
   const srcUnits = srcCol.getTag(DG.TAGS.UNITS);
-  const tgtUnits = srcUnits.split(':').map((p, i) => i == 1 ? p + '.MSA' : p).join(':');
+  //aligned
+  const srcAligned = srcCol.getTag('aligned');
+  const tgtAligned = srcAligned + '.MSA';
+  //alphabet
+  const srcAlphabet = srcCol.getTag('alphabet');
 
-  tgtCol.setTag(DG.TAGS.UNITS, tgtUnits);
+  tgtCol.setTag(DG.TAGS.UNITS, srcUnits);
+  tgtCol.setTag('aligned', tgtAligned);
+  tgtCol.setTag('alphabet', srcAlphabet);
   tgtCol.semType = DG.SEMTYPE.MACROMOLECULE;
   return tgtCol;
 }

package/src/utils/sequence-activity-cliffs.ts

@@ -8,7 +8,7 @@ export async function sequenceGetSimilarities(col: DG.Column, seq: string): Prom
   const stringArray = col.toList();
   const distances = new Array(stringArray.length).fill(0.0);
   for (let i = 0; i < stringArray.length; ++i)
-    distances[i] = getSimilarityFromDistance(AvailableMetrics['String']['Levenshtein'](stringArray[i], seq));
+    distances[i] = stringArray[i] ? getSimilarityFromDistance(AvailableMetrics['String']['Levenshtein'](stringArray[i], seq)) : 0;
   return DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'distances', distances);
 }
 

package/src/viewers/vd-regions-viewer.ts

@@ -51,6 +51,7 @@ export class VdRegionsViewer extends DG.JsViewer {
   public sequenceColumnNamePostfix: string;
 
   public skipEmptyPositions: boolean;
+  public positionWidth: number;
 
 
   public get df(): DG.DataFrame {
@@ -77,6 +78,7 @@ export class VdRegionsViewer extends DG.JsViewer {
     this.sequenceColumnNamePostfix = this.string('sequenceColumnNamePostfix', 'chain sequence');
 
     this.skipEmptyPositions = this.bool('skipEmptyPositions', false);
+    this.positionWidth = this.float('positionWidth', 16);
   }
 
   public async init() {
@@ -135,6 +137,10 @@ export class VdRegionsViewer extends DG.JsViewer {
         await this.destroyView();
         await this.buildView();
         break;
+      case 'positionWidth':
+        await this.destroyView();
+        await this.buildView();
+        break;
       }
     }
   }
@@ -205,6 +211,7 @@ export class VdRegionsViewer extends DG.JsViewer {
           endPositionName: region!.positionEndName,
           fixWidth: true,
           skipEmptyPositions: this.skipEmptyPositions,
+          positionWidth: this.positionWidth,
         })) as unknown as WebLogo;
       }
       // WebLogo creation fires onRootSizeChanged event even before control being added to this.logos