@datagrok/bio 1.9.0 → 1.11.0

package/src/tests/splitters-test.ts

@@ -4,6 +4,8 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {WebLogo, SplitterFunc} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {splitToMonomers, _package} from '../package';
+import * as C from '../utils/constants';
 
 category('splitters', () => {
   const helm1 = 'PEPTIDE1{meI.hHis.Aca.N.T.dE.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$';
@@ -51,6 +53,19 @@ category('splitters', () => {
   test('testHelm1', async () => { await _testHelmSplitter(data.testHelm1[0], data.testHelm1[1]); });
   test('testHelm2', async () => { await _testHelmSplitter(data.testHelm2[0], data.testHelm2[1]); });
   test('testHelm3', async () => { await _testHelmSplitter(data.testHelm3[0], data.testHelm3[1]); });
+
+  test('splitToMonomers', async () => {
+    const df: DG.DataFrame = await grok.dapi.files.readCsv('System:AppData/Bio/samples/sample_MSA.csv');
+
+    const seqCol = df.getCol('MSA');
+    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+    seqCol.setTag(C.TAGS.ALIGNED, C.MSA);
+
+    splitToMonomers(seqCol);
+    expect(df.columns.names().includes('17'), true);
+  });
 });
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {

package/src/tests/test-sequnces-generators.ts

@@ -0,0 +1,45 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+export function generateManySequences(): string {
+  let csvData = `MSA,Activity
+meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me,5.30751`;
+  for (let i = 0; i < 10 ** 6; i++) {
+    csvData += `\n meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me,5.30751`;
+  }
+  return csvData;
+}
+
+export function generateLongSequence(): string {
+  let longSequence = `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`;
+  for (let i = 0; i < 10 ** 5; i++) {
+    longSequence += `/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/dv`;
+  }
+  longSequence += `//Phe_4Me,5.30751`;
+  let csvData = `MSA,Activity `;
+  for (let i = 0; i <= 10 ** 1 * 4; i++) {
+    csvData += `\n ${longSequence}`;
+  }
+  return csvData;
+}
+export function setTagsMacromolecule(col: DG.Column) {
+  col.semType = DG.SEMTYPE.MACROMOLECULE;
+  col.setTag('units', 'separator');
+  col.setTag('aligned', 'SEQ.MSA');
+  col.setTag('alphabet', 'UN');
+  col.setTag('separator', '/');
+  return col;
+}
+
+export function performanceTest(generateFunc: () => string,testName: string) {
+  const startTime: number = Date.now();
+  const csv = generateFunc();
+  const df: DG.DataFrame = DG.DataFrame.fromCsv(csv);
+  const col: DG.Column = df.columns.byName('MSA');
+  setTagsMacromolecule(col);
+  grok.shell.addTableView(df);
+
+  const endTime: number = Date.now();
+  const elapsedTime: number = endTime - startTime;
+  console.log(`Performance test: ${testName}: ${elapsedTime}ms`);
+}

package/src/utils/atomic-works.ts

@@ -1,6 +1,8 @@
 import * as OCL from 'openchemlib/full.js';
 import * as grok from 'datagrok-api/grok';
 
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
 export async function getMacroMol(monomers: any[][]): Promise<string[]> {
   let result: string[] = [];
   const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');

package/src/utils/cell-renderer.ts

@@ -6,9 +6,13 @@ import {UnknownSeqPalette, UnknownSeqPalettes} from '@datagrok-libraries/bio/src
 import {SplitterFunc, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import * as ui from 'datagrok-api/ui';
-import {printLeftOrCentered} from '@datagrok-libraries/bio/src/utils/cell-renderer';
+import {printLeftOrCentered, DrawStyle} from '@datagrok-libraries/bio/src/utils/cell-renderer';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 const undefinedColor = 'rgb(100,100,100)';
+const monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = WebLogo.monomerToShort;
+const gapRenderer = 5;
+
 
 function getPalleteByType(paletteType: string): SeqPalette {
   switch (paletteType) {
@@ -54,16 +58,13 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
   get defaultWidth(): number { return 230; }
 
   onMouseMove(gridCell: DG.GridCell, e: MouseEvent): void {
-    if (gridCell.cell.column.getTag('aligned') !== 'SEQ.MSA') {
+    if (gridCell.cell.column.getTag(UnitsHandler.TAGS.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);
+    const argsX = e.layerX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x);
     let left = 0;
     let right = maxIndex;
     let found = false;
@@ -89,7 +90,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     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);
+    (((subParts[left]?.length ?? 0) > 0)) ? ui.tooltip.show(ui.div(subParts[left]), e.x + 16, e.y + 16) : ui.tooltip.hide();
   }
 
   /**
@@ -111,6 +112,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     const grid = gridCell.gridRow !== -1 ? gridCell.grid : undefined;
     const cell = gridCell.cell;
     const [type, subtype, paletteType] = gridCell.cell.column.getTag(DG.TAGS.UNITS).split(':');
+    const minDistanceRenderer = 50;
     w = grid ? Math.min(grid.canvas.width - x, w) : g.canvas.width - x;
     g.save();
     g.beginPath();
@@ -126,25 +128,34 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     const palette = getPalleteByType(paletteType);
 
     const separator = gridCell.cell.column.getTag('separator') ?? '';
-    const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, separator);
+    const splitLimit = gridCell.bounds.width / 5;
+    const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, separator, gridCell.bounds.width / 5);
+
 
-    const columns = gridCell.cell.column.categories;
-    let monomerToShortFunction: (amino: string, maxLengthOfMonomer: number) => string = WebLogo.monomerToShort;
-    let maxLengthOfMonomer = 8;
+    const 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]);
+    if (gridCell.cell.column.getTag('.calculatedCellRender') !== splitLimit.toString()) {
+      let samples = 0;
+      while (samples < Math.min(gridCell.cell.column.length, 100)) {
+        let column = gridCell.cell.column.get(samples);
+        let subParts: string[] = splitterFunc(column);
         subParts.forEach((amino, index) => {
-          let textSizeWidth = g.measureText(monomerToShortFunction(amino, maxLengthOfMonomer));
-          if (textSizeWidth.width > (maxLengthWords[index] ?? 0)) {
-            maxLengthWords[index] = textSizeWidth.width;
+          let textSize = monomerToShortFunction(amino, maxLengthOfMonomer).length * 7 + gapRenderer;
+          if (textSize > (maxLengthWords[index] ?? 0)) {
+            maxLengthWords[index] = textSize;
           }
           if (index > (maxLengthWords['bio-maxIndex'] ?? 0)) {
             maxLengthWords['bio-maxIndex'] = index;
           }
         });
+        samples += 1;
+      }
+      let minLength = 3 * 7;
+      for (let i = 0; i <= maxLengthWords['bio-maxIndex']; i++) {
+        if (maxLengthWords[i] < minLength) {
+          maxLengthWords[i] = minLength;
+        }
       }
       let maxLengthWordSum: any = {};
       maxLengthWordSum[0] = maxLengthWords[0];
@@ -156,7 +167,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         'bio-maxIndex': maxLengthWords['bio-maxIndex'],
         'bio-maxLengthWords': maxLengthWords
       };
-      gridCell.cell.column.setTag('.calculatedCellRender', 'exist');
+      gridCell.cell.column.setTag('.calculatedCellRender', splitLimit.toString());
     } else {
       maxLengthWords = gridCell.cell.column.temp['bio-maxLengthWords'];
     }
@@ -164,15 +175,19 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     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';
+    let drawStyle = DrawStyle.classic;
+    if (gridCell.cell.column.getTag('aligned').includes('MSA') && gridCell.cell.column.getTag('units') === 'separator') {
+      drawStyle = DrawStyle.MSA;
     }
-    subParts.forEach((amino, index) => {
+    subParts.every((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);
+      if (x1 - minDistanceRenderer - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCell.bounds.x) > gridCell.bounds.width) {
+        return false;
+      }
+      return true;
     });
 
     g.restore();
@@ -269,8 +284,9 @@ export class MacromoleculeDifferenceCellRenderer extends DG.GridCellRenderer {
     // 28 is the height of the two substitutions on top of each other + space
     const updatedY = Math.max(y, y + (h - 28) / 2);
 
-    let palette: SeqPalette = units == 'HELM' ? UnknownSeqPalettes.Color :
-      getPalleteByType(gridCell.tableColumn!.tags[C.TAGS.ALPHABET]);
+    let palette: SeqPalette = UnknownSeqPalettes.Color;
+    if (units != 'HELM')
+      palette = getPalleteByType(units.substring(units.length - 2));
 
     const vShift = 7;
     for (let i = 0; i < subParts1.length; i++) {

package/src/utils/constants.ts

@@ -9,17 +9,13 @@ export enum COLUMNS_NAMES {
   MEAN_DIFFERENCE = 'Mean difference',
 }
 
-export enum CATEGORIES {
-  OTHER = 'Other',
-  ALL = 'All',
-}
-
 export enum TAGS {
   AAR = 'AAR',
   POSITION = 'Pos',
   SEPARATOR = 'separator',
   SELECTION = 'selection',
   ALPHABET = 'alphabet',
+  ALIGNED = 'aligned',
 }
 
 export enum SEM_TYPES {
@@ -30,6 +26,8 @@ export enum SEM_TYPES {
   MACROMOLECULE = 'Macromolecule',
 }
 
+export const MSA = 'MSA';
+
 export const STATS = 'stats';
 
 export const EMBEDDING_STATUS = 'embeddingStatus';

package/src/utils/convert.ts

@@ -42,7 +42,7 @@ export function convert(col: DG.Column): void {
   // set correct visibility on init
   toggleSeparator();
 
-  targetNotationInput.onChanged( () => {
+  targetNotationInput.onChanged(() => {
     toggleSeparator();
   });
 

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

@@ -9,6 +9,7 @@ import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler'
 import Aioli from '@biowasm/aioli';
 
 import {AlignedSequenceEncoder} from '@datagrok-libraries/bio/src/sequence-encoder';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 /**
  * Converts array of sequences into simple fasta string.
@@ -58,14 +59,14 @@ export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName
   // units
   const srcUnits = srcCol.getTag(DG.TAGS.UNITS);
   //aligned
-  const srcAligned = srcCol.getTag('aligned');
+  const srcAligned = srcCol.getTag(UnitsHandler.TAGS.aligned);
   const tgtAligned = srcAligned + '.MSA';
   //alphabet
-  const srcAlphabet = srcCol.getTag('alphabet');
+  const srcAlphabet = srcCol.getTag(UnitsHandler.TAGS.alphabet);
 
   tgtCol.setTag(DG.TAGS.UNITS, srcUnits);
-  tgtCol.setTag('aligned', tgtAligned);
-  tgtCol.setTag('alphabet', srcAlphabet);
+  tgtCol.setTag(UnitsHandler.TAGS.aligned, tgtAligned);
+  tgtCol.setTag(UnitsHandler.TAGS.alphabet, srcAlphabet);
   tgtCol.semType = DG.SEMTYPE.MACROMOLECULE;
   return tgtCol;
 }

package/src/utils/sequence-space.ts

@@ -12,9 +12,11 @@ export interface ISequenceSpaceResult {
 }
 
 export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
-  let preparedData: any;
+
+// code deprecated since seqCol is encoded
+/*    let preparedData: any;
   if (!(spaceParams.seqCol!.tags[DG.TAGS.UNITS] === 'HELM')) {
-    const sep = spaceParams.seqCol.getTag('separator');
+    const sep = spaceParams.seqCol.getTag(UnitsHandler.TAGS.separator);
     const sepFinal = sep ? sep === '.' ? '\\\.' : sep : '-';
     const regex = new RegExp(sepFinal, 'g');
     if (Object.keys(AvailableMetrics['String']).includes(spaceParams.similarityMetric))
@@ -23,10 +25,10 @@ export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<
       preparedData = spaceParams.seqCol.toList().map((v: string) => v.replace(regex, '')) as string[];
   } else {
     preparedData = spaceParams.seqCol.toList();
-  }
+  }  */
 
   const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
-    preparedData,
+    spaceParams.seqCol.toList(),
     spaceParams.methodName,
     spaceParams.similarityMetric as StringMetrics | BitArrayMetrics,
     spaceParams.options);

package/src/utils/utils.ts

@@ -5,6 +5,7 @@ import {
   CAP_GROUP_NAME, CAP_GROUP_SMILES, jsonSdfMonomerLibDict, MONOMER_ENCODE_MAX, MONOMER_ENCODE_MIN, MONOMER_SYMBOL,
   RGROUP_ALTER_ID, RGROUP_FIELD, RGROUP_LABEL, SDF_MONOMER_NAME
 } from '../const';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 export const HELM_CORE_LIB_FILENAME = '/samples/HELMCoreLibrary.json';
 export const HELM_CORE_LIB_MONOMER_SYMBOL = 'symbol';
@@ -16,7 +17,7 @@ export function encodeMonomers(col: DG.Column): DG.Column | null {
   let encodeSymbol = MONOMER_ENCODE_MIN;
   const monomerSymbolDict: { [key: string]: number } = {};
   const units = col.tags[DG.TAGS.UNITS];
-  const sep = col.getTag('separator');
+  const sep = col.getTag(UnitsHandler.TAGS.separator);
   const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, sep);
   const encodedStringArray = [];
   for (let i = 0; i < col.length; ++i) {
@@ -25,7 +26,7 @@ export function encodeMonomers(col: DG.Column): DG.Column | null {
     monomers.forEach((m) => {
       if (!monomerSymbolDict[m]) {
         if (encodeSymbol > MONOMER_ENCODE_MAX) {
-          grok.shell.error(`Not enougth symbols to encode monomers`);
+          grok.shell.error(`Not enough symbols to encode monomers`);
           return null;
         }
         monomerSymbolDict[m] = encodeSymbol;

package/src/widgets/representations.ts

@@ -22,7 +22,7 @@ export async function representationsWidget(macroMolecule: DG.Cell, monomersLibO
       const atomicCodes = getMolfilesFromSingleSeq(macroMolecule, monomersLibObject);
       const result = await getMacroMol(atomicCodes!);
       const molBlock2D = result[0];
-      molBlock3D = (await grok.functions.call('Bio:Embed', {molBlock2D})) as string;
+      molBlock3D = (await grok.functions.call('Bio:Embed', {molBlock2D})) as unknown as string;
     } catch (e) {
       console.warn(e);
     }