@datagrok/bio 2.10.17 → 2.10.23

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.10.17",
+  "version": "2.10.23",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -34,9 +34,9 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.38.10",
+    "@datagrok-libraries/bio": "^5.38.12",
     "@datagrok-libraries/chem-meta": "^1.0.1",
-    "@datagrok-libraries/ml": "^6.3.44",
+    "@datagrok-libraries/ml": "^6.3.49",
     "@datagrok-libraries/tutorials": "^1.3.6",
     "@datagrok-libraries/utils": "^4.0.17",
     "cash-dom": "^8.0.0",
@@ -64,7 +64,8 @@
     "webpack-bundle-analyzer": "latest",
     "webpack-cli": "^4.9.1",
     "@datagrok/chem": "1.7.2",
-    "@datagrok/helm": "2.1.17"
+    "@datagrok/helm": "2.1.17",
+    "@datagrok/dendrogram": "^1.2.20"
   },
   "scripts": {
     "link-api": "npm link datagrok-api",

package/src/analysis/sequence-space.ts

@@ -3,7 +3,9 @@ import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/s
 import {BitArrayMetrics, StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {ISequenceSpaceParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
+import {mmDistanceFunctionArgs} from '@datagrok-libraries/ml/src/macromolecule-distance-functions/types';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {calculateMonomerSimilarity} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import * as grok from 'datagrok-api/grok';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
@@ -53,41 +55,59 @@ export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpacePar
   return result;
 }
 
-export async function getSequenceSpace(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
+export async function getSequenceSpace(spaceParams: ISequenceSpaceParams,
+  progressFunc?: (epochNum: number, epochsLength: number, embedding: number[][]) => void
+): Promise<ISequenceSpaceResult> {
   const ncUH = UnitsHandler.getOrCreate(spaceParams.seqCol);
 
-  const distanceFName = ncUH.isMsa() ? MmDistanceFunctionsNames.HAMMING : MmDistanceFunctionsNames.LEVENSHTEIN;
+  //const distanceFName = ncUH.isMsa() ? MmDistanceFunctionsNames.HAMMING : MmDistanceFunctionsNames.LEVENSHTEIN;
   const seqList = spaceParams.seqCol.toList();
-  if (ncUH.getAlphabetIsMultichar()) {
-    const splitter = ncUH.getSplitter();
-    const seqColLength = seqList.length;
-    let charCodeCounter = 36;
-    const charCodeMap = new Map<string, string>();
-    for (let i = 0; i < seqColLength; i++) {
-      const seq = seqList[i];
-      if (seqList[i] === null || spaceParams.seqCol.isNone(i)) {
-        seqList[i] = null;
-        continue;
-      }
-      seqList[i] = '';
-      const splittedSeq = splitter(seq);
-      for (let j = 0; j < splittedSeq.length; j++) {
-        const char = splittedSeq[j];
-        if (!charCodeMap.has(char)) {
-          charCodeMap.set(char, String.fromCharCode(charCodeCounter));
-          charCodeCounter++;
-        }
-        seqList[i] += charCodeMap.get(char)!;
+
+  const splitter = ncUH.getSplitter();
+  const seqColLength = seqList.length;
+  let charCodeCounter = 36;
+  const charCodeMap = new Map<string, string>();
+  for (let i = 0; i < seqColLength; i++) {
+    const seq = seqList[i];
+    if (seqList[i] === null || spaceParams.seqCol.isNone(i)) {
+      seqList[i] = null;
+      continue;
+    }
+    seqList[i] = '';
+    const splittedSeq = splitter(seq);
+    for (let j = 0; j < splittedSeq.length; j++) {
+      const char = splittedSeq[j];
+      if (!charCodeMap.has(char)) {
+        charCodeMap.set(char, String.fromCharCode(charCodeCounter));
+        charCodeCounter++;
       }
+      seqList[i] += charCodeMap.get(char)!;
     }
   }
 
+  if (spaceParams.similarityMetric === MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE) {
+    const monomers = Array.from(charCodeMap.keys());
+    const monomerRes = await calculateMonomerSimilarity(monomers);
+    // the susbstitution matrix contains similarity, but we need distances
+    monomerRes.scoringMatrix.forEach((row, i) => {
+      row.forEach((val, j) => {
+        monomerRes.scoringMatrix[i][j] = 1 - val;
+      });
+    });
+    const monomerHashToMatrixMap: {[_: string]: number} = {};
+    Object.entries(monomerRes.alphabetIndexes).forEach(([key, value]) => {
+      monomerHashToMatrixMap[charCodeMap.get(key)!] = value;
+    });
+    spaceParams.options.distanceFnArgs = {scoringMatrix: monomerRes.scoringMatrix,
+      alphabetIndexes: monomerHashToMatrixMap} satisfies mmDistanceFunctionArgs;
+  }
+
   const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
     seqList,
     spaceParams.methodName,
-    distanceFName,
+    spaceParams.similarityMetric,
     spaceParams.options,
-    true);
+    true, progressFunc);
   const cols: DG.Column[] = spaceParams.embedAxesNames.map(
     (name: string, index: number) => DG.Column.fromFloat32Array(name, sequenceSpaceResult.embedding[index]));
   return {distance: sequenceSpaceResult.distance, coordinates: new DG.ColumnList(cols)};

package/src/package.ts

@@ -69,9 +69,13 @@ import {_getEnumeratorWidget, _setPeptideColumn} from './utils/enumerator-tools'
 import {getRegionDo} from './utils/get-region';
 import {GetRegionApp} from './apps/get-region-app';
 import {GetRegionFuncEditor} from './utils/get-region-func-editor';
+import {DIMENSIONALITY_REDUCER_TERMINATE_EVENT}
+  from '@datagrok-libraries/ml/src/workers/dimensionality-reducing-worker-creator';
+import {Options} from '@datagrok-libraries/utils/src/type-declarations';
 
 export const _package = new BioPackage();
 
+export const BYPASS_LARGE_DATA_WARNING = 'bypassLargeDataWarning';
 // /** Avoid reassigning {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
 // let monomerLib: MonomerLib | null = null;
 
@@ -221,7 +225,7 @@ export function SequenceSpaceEditor(call: DG.FuncCall) {
   ui.dialog({title: 'Sequence Space'})
     .add(funcEditor.paramsUI)
     .onOK(async () => {
-      return call.func.prepare(funcEditor.funcParams).call(true);
+      return call.func.prepare(funcEditor.funcParams).call();
     })
     .show();
 }
@@ -381,8 +385,8 @@ export async function getRegionTopMenu(
 //input: object options {optional: true}
 //output: viewer result
 //editor: Bio:SeqActivityCliffsEditor
-export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
-  similarity: number, methodName: DimReductionMethods, options?: IUMAPOptions | ITSNEOptions,
+export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column<string>, activities: DG.Column,
+  similarity: number, methodName: DimReductionMethods, options?: (IUMAPOptions | ITSNEOptions) & Options,
 ): Promise<DG.Viewer | undefined> {
   if (!checkInputColumnUI(macroMolecule, 'Activity Cliffs'))
     return;
@@ -435,7 +439,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     return;
   }
 
-  if (df.rowCount > fastRowCount) {
+  if (df.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
     ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
     Do you want to continue?`))
       .onOK(async () => {
@@ -457,69 +461,128 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
 //input: dataframe table
 //input: column molecules { semType: Macromolecule }
 //input: string methodName { choices:["UMAP", "t-SNE"] }
-//input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
+//input: string similarityMetric { choices:["Hamming", "Levenshtein", "Monomer chemical distance"] }
 //input: bool plotEmbeddings = true
 //input: double sparseMatrixThreshold = 0.8 [Similarity Threshold for sparse matrix calculation]
 //input: object options {optional: true}
 //editor: Bio:SequenceSpaceEditor
 export async function sequenceSpaceTopMenu(
   table: DG.DataFrame, macroMolecule: DG.Column, methodName: DimReductionMethods,
-  similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames = BitArrayMetricsNames.Tanimoto,
-  plotEmbeddings: boolean, sparseMatrixThreshold?: number, options?: IUMAPOptions | ITSNEOptions,
+  similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames = MmDistanceFunctionsNames.LEVENSHTEIN,
+  plotEmbeddings: boolean, sparseMatrixThreshold?: number, options?: (IUMAPOptions | ITSNEOptions) & Options,
 ): Promise<DG.Viewer | undefined> {
   // Delay is required for initial function dialog to close before starting invalidating of molfiles.
   // Otherwise, dialog is freezing
   await delay(10);
   if (!checkInputColumnUI(macroMolecule, 'Sequence space')) return;
+  let scatterPlot: DG.ScatterPlotViewer | undefined = undefined;
+  const pg = DG.TaskBarProgressIndicator.create('Initializing sequence space ...');
+  // function for progress of umap
+  try {
+    function progressFunc(_nEpoch: number, epochsLength: number, embeddings: number[][]) {
+      let embedXCol: DG.Column | null = null;
+      let embedYCol: DG.Column | null = null;
+      if (!table.columns.names().includes(embedColsNames[0])) {
+        embedXCol = table.columns.add(DG.Column.float(embedColsNames[0], table.rowCount));
+        embedYCol = table.columns.add(DG.Column.float(embedColsNames[1], table.rowCount));
+        if (plotEmbeddings) {
+          scatterPlot = grok.shell
+            .tableView(table.name)
+            .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
+        }
+      } else {
+        embedXCol = table.columns.byName(embedColsNames[0]);
+        embedYCol = table.columns.byName(embedColsNames[1]);
+      }
 
-  const embedColsNames = getEmbeddingColsNames(table);
-  const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
-  const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, macroMolecule);
-
-  const chemSpaceParams: ISequenceSpaceParams = {
-    seqCol: withoutEmptyValues.col(macroMolecule.name)!,
-    methodName: methodName,
-    similarityMetric: similarityMetric,
-    embedAxesNames: embedColsNames,
-    options: {...options, sparseMatrixThreshold: sparseMatrixThreshold ?? 0.8,
-      usingSparseMatrix: table.rowCount > 20000},
-  };
+      embedXCol.init((i) => embeddings[i] ? embeddings[i][0] : undefined);
+      embedYCol.init((i) => embeddings[i] ? embeddings[i][1] : undefined);
+      const progress = (_nEpoch / epochsLength * 100);
+      pg.update(progress, `Running sequence space ... ${progress.toFixed(0)}%`);
+    }
+    const embedColsNames = getEmbeddingColsNames(table);
+    const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
+    const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, macroMolecule);
+
+    const chemSpaceParams: ISequenceSpaceParams = {
+      seqCol: withoutEmptyValues.col(macroMolecule.name)!,
+      methodName: methodName,
+      similarityMetric: similarityMetric,
+      embedAxesNames: embedColsNames,
+      options: {...options, sparseMatrixThreshold: sparseMatrixThreshold ?? 0.8,
+        usingSparseMatrix: table.rowCount > 20000},
+    };
+
+    const allowedRowCount = methodName === DimReductionMethods.UMAP ? 100000 : 15000;
+    // number of rows which will be processed relatively fast
+    const fastRowCount = methodName === DimReductionMethods.UMAP ? 5000 : 2000;
+    if (table.rowCount > allowedRowCount) {
+      grok.shell.warning(`Too many rows, maximum for sequence space is ${allowedRowCount}`);
+      return;
+    }
 
-  const allowedRowCount = methodName === DimReductionMethods.UMAP ? 100000 : 15000;
-  // number of rows which will be processed relatively fast
-  const fastRowCount = methodName === DimReductionMethods.UMAP ? 5000 : 2000;
-  if (table.rowCount > allowedRowCount) {
-    grok.shell.warning(`Too many rows, maximum for sequence space is ${allowedRowCount}`);
-    return;
-  }
+    async function getSeqSpace() {
+      let resolveF: Function | null = null;
+
+      const sub = grok.events.onViewerClosed.subscribe((args) => {
+        const v = args.args.viewer as unknown as DG.Viewer<any>;
+        if (v?.getOptions()?.look?.title && scatterPlot?.getOptions()?.look?.title &&
+          v?.getOptions()?.look?.title === scatterPlot?.getOptions()?.look?.title) {
+          grok.events.fireCustomEvent(DIMENSIONALITY_REDUCER_TERMINATE_EVENT, {});
+          sub.unsubscribe();
+          resolveF?.();
+          pg.close();
+        }
+      });
+      const sequenceSpaceResPromise = new Promise<ISequenceSpaceResult | undefined>(async (resolve) => {
+        resolveF = resolve;
+        const res = await getSequenceSpace(chemSpaceParams,
+          options?.[BYPASS_LARGE_DATA_WARNING] ? undefined : progressFunc);
+        resolve(res);
+      });
+      const sequenceSpaceRes = await sequenceSpaceResPromise;
+      pg.close();
+      sub.unsubscribe();
+      return sequenceSpaceRes ? processResult(sequenceSpaceRes) : sequenceSpaceRes;
+    }
 
-  if (table.rowCount > fastRowCount) {
-    ui.dialog().add(ui.divText(`Sequence space analysis might take several minutes.
+    if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
+      ui.dialog().add(ui.divText(`Sequence space analysis might take several minutes.
     Do you want to continue?`))
-      .onOK(async () => {
-        const progressBar = DG.TaskBarProgressIndicator.create(`Running Sequence space...`);
-        const sequenceSpaceRes = await getSequenceSpace(chemSpaceParams);
-        progressBar.close();
-        return processResult(sequenceSpaceRes);
-      })
-      .show();
-  } else {
-    const sequenceSpaceRes = await getSequenceSpace(chemSpaceParams);
-    return processResult(sequenceSpaceRes);
-  }
-
-  function processResult(sequenceSpaceRes: ISequenceSpaceResult): DG.ScatterPlotViewer | undefined {
-    const embeddings = sequenceSpaceRes.coordinates;
-    for (const col of embeddings) {
-      const listValues = col.toList();
-      emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
-      table.columns.add(DG.Column.float(col.name, table.rowCount).init((i) => listValues[i]));
+        .onOK(async () => {
+          await getSeqSpace();
+        })
+        .onCancel(() => { pg.close(); })
+        .show();
+    } else {
+      return await getSeqSpace();
     }
-    if (plotEmbeddings) {
-      return grok.shell
-        .tableView(table.name)
-        .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
+
+    function processResult(sequenceSpaceRes: ISequenceSpaceResult): DG.ScatterPlotViewer | undefined {
+      const embeddings = sequenceSpaceRes.coordinates;
+      for (const col of embeddings) {
+        const listValues = col.toList();
+        emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
+        let embedCol = table.columns.byName(col.name);
+        if (!embedCol) {
+          embedCol = DG.Column.float(col.name, listValues.length);
+          table.columns.add(embedCol);
+        }
+        embedCol.init((i) => listValues[i]);
+      //table.columns.add(DG.Column.float(col.name, table.rowCount).init((i) => listValues[i]));
+      }
+      if (plotEmbeddings) {
+        if (!scatterPlot) {
+          scatterPlot = grok.shell
+            .tableView(table.name)
+            .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
+        }
+        return scatterPlot;
+      }
     }
+  } catch (e) {
+    console.error(e);
+    pg.close();
   }
 
 
@@ -550,7 +613,7 @@ export async function sequenceSpaceTopMenu(
         sp = (v as DG.TableView).scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
     }
   } */
-};
+}
 
 //top-menu: Bio | Convert | To Atomic Level...
 //name: To Atomic Level

package/src/tests/WebLogo-positions-test.ts

@@ -1,7 +1,7 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, expect, expectArray, test, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
+import {category, expect, expectArray, test, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {
   countForMonomerAtPosition,
@@ -30,9 +30,9 @@ ATC-G-TTGC--
     seqCol.setTag(bioTAGS.aligned, 'SEQ.MSA');
 
     const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo')) as WebLogoViewer;
-    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
-
-    await awaitCheck(() => wlViewer.Length > 0, 'WebLogo.Length is zero', 100);
+    await testEvent(wlViewer.onLayoutCalculated, () => {}, () => {
+      tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+    }, 200);
     const positions: PI[] = wlViewer['positions'];
 
     const resAllDf1: PI[] = [
@@ -82,9 +82,9 @@ ATC-G-TTGC--
     df.filter.fireChanged();
     const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo',
       {'shrinkEmptyTail': true})) as WebLogoViewer;
-    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
-
-    await awaitCheck(() => wlViewer.Length > 0, 'WebLogo.Length is zero', 100);
+    await testEvent(wlViewer.onLayoutCalculated, () => {}, () => {
+      tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+    }, 200);
     const positions: PI[] = wlViewer['positions'];
 
     const resAllDf1: PI[] = [
@@ -120,9 +120,9 @@ ATC-G-TTGC--
 
     const wlViewer: WebLogoViewer = (await df.plot.fromType('WebLogo',
       {'skipEmptyPositions': true})) as WebLogoViewer;
-    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
-
-    await awaitCheck(() => wlViewer.Length > 0, 'WebLogo.Length is zero');
+    await testEvent(wlViewer.onLayoutCalculated, () => {}, () => {
+      tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+    }, 200);
     const resPosList: PI[] = wlViewer['positions'];
 
     const tgtPosList: PI[] = [
@@ -156,9 +156,9 @@ ATC-G-TTGC--
       endPositionName: '7',
       skipEmptyPositions: true,
     })) as WebLogoViewer;
-    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
-
-    await awaitCheck(() => wlViewer.Length > 0, 'WebLogo.Length is zero', 100);
+    await testEvent(wlViewer.onLayoutCalculated, () => {}, () => {
+      tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+    }, 200);
     const resPosList: PI[] = wlViewer['positions'];
     const tgtPosList: PI[] = [
       new PI(2, '3', {'C': new PMI(5)}),

package/src/tests/activity-cliffs-tests.ts

@@ -38,7 +38,7 @@ category('activityCliffs', async () => {
     const cliffsNum = DG.Test.isInBenchmark ? 6 : 3;
 
     await _testActivityCliffsOpen(actCliffsDf, cliffsNum, DimReductionMethods.UMAP, 'sequence');
-  }, {skipReason: 'GROK-13952'});
+  });
 
   test('activityCliffsWithEmptyRows', async () => {
     actCliffsDfWithEmptyRows = await readDataframe('tests/100_3_clustests_empty_vals.csv');
@@ -47,5 +47,5 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableViewWithEmptyRows);
 
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 3, DimReductionMethods.UMAP, 'sequence');
-  }, {skipReason: 'GROK-13851: Unhandled exceptions'});
+  });
 });

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

@@ -2,7 +2,7 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {expect} from '@datagrok-libraries/utils/src/test';
-import {activityCliffs} from '../package';
+import {activityCliffs, BYPASS_LARGE_DATA_WARNING} from '../package';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: DimReductionMethods,
@@ -10,7 +10,7 @@ export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: nu
   await grok.data.detectSemanticTypes(df);
   const scatterPlot = await activityCliffs(
     df, df.getCol(colName), df.getCol('activity'),
-    90, method);
+    90, method, {[`${BYPASS_LARGE_DATA_WARNING}`]: true});
   // const scatterPlot = (await grok.functions.call('Bio:activityCliffs', {
   //   table: df, molecules: df.getCol(colName), activities: df.getCol('Activity'),
   //   similarity: 50, methodName: method

package/src/tests/detectors-benchmark-tests.ts

@@ -29,7 +29,7 @@ category('detectorsBenchmark', () => {
   });
 
   test('fastaDnaLong1e6Few50', async () => {
-    await detectMacromoleculeBenchmark(15, NOTATION.FASTA, ALPHABET.DNA, 1E6, 50);
+    await detectMacromoleculeBenchmark(20, NOTATION.FASTA, ALPHABET.DNA, 1E6, 50);
   });
 
   // -- separator --
@@ -49,7 +49,7 @@ category('detectorsBenchmark', () => {
   async function detectMacromoleculeBenchmark(
     maxET: number, notation: NOTATION, alphabet: ALPHABET, length: number, count: number, separator?: string,
   ): Promise<number> {
-    return await benchmark<DG.FuncCall, DG.Column>(10,
+    return await benchmark<DG.FuncCall, DG.Column>(maxET,
       (): DG.FuncCall => {
         const col: DG.Column = generate(notation, [...getAlphabet(alphabet)], length, count, separator);
         const funcCall: DG.FuncCall = detectFunc.prepare({col: col});

package/src/tests/detectors-tests.ts

@@ -182,7 +182,10 @@ MWRSWY-CKHP`;
           const df: DG.DataFrame = await readFile(samples[key]);
           // await grok.data.detectSemanticTypes(df);
           return df;
-        })();
+        })().catch((err: any) => {
+          delete _samplesDfs[key];
+          throw err;
+        });
       }
       return _samplesDfs[key];
     };

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

@@ -19,15 +19,15 @@ category('sequenceSpace', async () => {
     );
     testFastaTableView = grok.shell.addTableView(testFastaDf);
     await _testSequenceSpaceReturnsResult(testFastaDf, DimReductionMethods.UMAP, 'sequence');
-    grok.shell.closeTable(testFastaDf);
-    testFastaTableView.close();
+    //grok.shell.closeTable(testFastaDf);
+    //testFastaTableView.close();
   });
 
   test('sequenceSpaceWithEmptyRows', async () => {
     testHelmWithEmptyRows = await readDataframe('tests/100_3_clustests_empty_vals.csv');
     testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
     await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, DimReductionMethods.UMAP, 'sequence');
-    grok.shell.closeTable(testHelmWithEmptyRows);
-    testHelmWithEmptyRowsTableView.close();
+    //grok.shell.closeTable(testHelmWithEmptyRows);
+    //testHelmWithEmptyRowsTableView.close();
   });
 });

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

@@ -1,7 +1,7 @@
 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';
+import {BYPASS_LARGE_DATA_WARNING, sequenceSpaceTopMenu} from '../package';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
@@ -14,6 +14,7 @@ export async function _testSequenceSpaceReturnsResult(
   if (semType)
     col.semType = semType;
 
-  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true);
+  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true,
+    0.6, {[`${BYPASS_LARGE_DATA_WARNING}`]: true});
   expect(sp != null, true);
 }

package/src/utils/cell-renderer.ts

@@ -27,6 +27,7 @@ import * as C from './constants';
 import {_package, getBioLib} from '../package';
 import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
+import {errInfo} from './err-info';
 
 
 type TempType = { [tagName: string]: any };
@@ -136,8 +137,15 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
 
     // TODO: Store temp data to GridColumn
     // Now the renderer requires data frame table Column underlying GridColumn
-    const grid = gridCell.grid;
+    let grid: DG.Grid | undefined = undefined;
+    try { grid = gridCell.grid; } catch (err: any) {
+      grid = undefined;
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+    }
     const tableCol: DG.Column = gridCell.cell.column;
+    if (!grid || !tableCol) return;
+
     const tableColTemp: TempType = tableCol.temp;
 
     // Cell renderer settings

package/src/utils/err-info.ts

@@ -0,0 +1,28 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+export function errMsg(err: any): string {
+  if (typeof err === 'string' || err instanceof String)
+    return err as string;
+  else if (err.constructor.name === 'StateError')
+    return err['message'];
+  else if (err.constructor.name === 'StateError' && '$thrownJsError' in err)
+    return errMsg(err['$thrownJsError']);
+  else if (err instanceof Error)
+    return (err as Error).message;
+  else
+    return err.toString();
+}
+
+export function errStack(err: any): string | undefined {
+  if (err instanceof Error)
+    return err.stack;
+  else if (err.constructor.name === 'StateError' && '$thrownJsError' in err)
+    return errStack(err['$thrownJsError']);
+  return undefined;
+}
+
+export function errInfo(err: any): [string, string | undefined] {
+  return [errMsg(err), errStack(err)];
+}