@datagrok/bio 2.4.30 → 2.4.39

package/src/analysis/sequence-space.ts

@@ -1,19 +1,17 @@
 import * as DG from 'datagrok-api/dg';
-import {AvailableMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/sequence-space';
 import {BitArrayMetrics, StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {Matrix} from '@datagrok-libraries/utils/src/type-declarations';
-import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {ISequenceSpaceParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import * as grok from 'datagrok-api/grok';
-import { NotationConverter } from '@datagrok-libraries/bio/src/utils/notation-converter';
-import { ALPHABET, NOTATION } from '@datagrok-libraries/bio/src/utils/macromolecule';
-import { MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import {NotationConverter} from '@datagrok-libraries/bio/src/utils/notation-converter';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
 export interface ISequenceSpaceResult {
-  distance: Matrix;
+  distance?: Float32Array;
   coordinates: DG.ColumnList;
 }
 
@@ -44,7 +42,8 @@ export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<
 
 export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
   if (spaceParams.seqCol.version !== spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
-    await invalidateMols(spaceParams.seqCol, false);
+    //we expect only string columns here
+    await invalidateMols(spaceParams.seqCol as unknown as DG.Column<string>, false);
 
   const result = await grok.functions.call('Chem:getChemSpaceEmbeddings', {
     col: spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
@@ -52,7 +51,7 @@ export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpacePar
     similarityMetric: spaceParams.similarityMetric,
     xAxis: spaceParams.embedAxesNames[0],
     yAxis: spaceParams.embedAxesNames[1],
-    options: spaceParams.options
+    options: spaceParams.options,
   });
   return result;
 }
@@ -65,17 +64,21 @@ export async function getSequenceSpace(spaceParams: ISequenceSpaceParams): Promi
     if (nc.isSeparator()) {
       const fastaCol = nc.convert(NOTATION.FASTA);
       seqList = fastaCol.toList();
-      const uh = new UnitsHandler(fastaCol);
+      const uh = UnitsHandler.getOrCreate(fastaCol);
       distanceFName = uh.getDistanceFunctionName();
-    }
-    else {
+    } else {
       distanceFName = nc.getDistanceFunctionName();
     }
+    for (let i = 0; i < seqList.length; i++) {
+      // toList puts empty values in array and it causes downstream errors. replace with null
+      seqList[i] = spaceParams.seqCol.isNone(i) ? null : seqList[i];
+    }
     const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
       seqList,
       spaceParams.methodName,
       distanceFName,
-      spaceParams.options);
+      spaceParams.options,
+      true);
     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/analysis/workers/mm-distance-array-service.ts

@@ -0,0 +1,48 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+
+export async function calculateMMDistancesArray(
+  macromoleculeCol: DG.Column, templateIdx: number
+): Promise<Float32Array> {
+  const values = macromoleculeCol.toList();
+  if (macromoleculeCol.semType !== DG.SEMTYPE.MACROMOLECULE)
+    throw new Error('Column has to be of macromolecule type');
+  const uh = UnitsHandler.getOrCreate(macromoleculeCol);
+  const fnName = uh.getDistanceFunctionName();
+  const threadCount = Math.min(Math.max(navigator.hardwareConcurrency - 2, 1), values.length);
+  const workers = new Array(threadCount).fill(null).map((_i) =>
+    new Worker(new URL('mm-distance-array-worker', import.meta.url)));
+  const res = new Float32Array(values.length);
+  let lmin = 0;
+  let lmax = Number.MIN_VALUE;
+  const promises = workers.map((worker, i) => {
+    const start = Math.floor(i * values.length / threadCount);
+    const end = i === workers.length - 1 ? Math.floor((i + 1) * values.length / threadCount) : values.length;
+    return new Promise<void>((resolve, reject) => {
+      worker.onmessage = ({data: {error, distanceArrayData, min, max}}) => {
+        if (error) {
+          reject(error);
+        } else {
+          lmin = Math.min(lmin, min);
+          lmax = Math.max(lmax, max);
+          res.set(distanceArrayData, start);
+          resolve();
+        }
+      };
+      worker.postMessage({fnName, values, templateIdx, start, end});
+    });
+  });
+
+  try {
+    await Promise.all(promises);
+    res.forEach((value, index) => { res[index] = (value - lmin) / (lmax - lmin); });
+    workers.forEach((worker) => worker.terminate());
+  } catch (e) {
+    workers.forEach((worker) => worker.terminate());
+    throw e;
+  }
+
+  return res;
+}

package/src/analysis/workers/mm-distance-array-worker.ts

@@ -0,0 +1,29 @@
+import {isNil} from '@datagrok-libraries/ml/src/distance-matrix';
+import {mmDistanceFunctions} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+
+onmessage = (event) => {
+  const {fnName, values, templateIdx, start, end} = event.data;
+  const data: { error?: any, distanceArrayData?: Float32Array, min?: number, max?: number} = {};
+  try {
+    let lmin = 0;
+    let lmax = Number.MIN_VALUE;
+    const retVal = new Float32Array(end - start);
+    const distanceFn = mmDistanceFunctions[fnName as keyof typeof mmDistanceFunctions]();
+
+    for (let i = start; i < end; i++) {
+      const value = !isNil(values[i]) && !isNil(values[templateIdx]) ?
+        distanceFn(values[i], values[templateIdx]) : 1;
+      retVal[i - start] = value;
+      if (value < lmin)
+        lmin = value;
+      if (value > lmax)
+        lmax = value;
+    }
+    data.distanceArrayData = retVal;
+    data.min = lmin;
+    data.max = lmax;
+  } catch (e) {
+    data.error = e;
+  }
+  postMessage(data);
+};

package/src/analysis/workers/mm-distance-worker-creator.ts

@@ -2,21 +2,18 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {DistanceMatrixService} from '@datagrok-libraries/ml/src/distance-matrix';
 
 export async function calcMmDistanceMatrix(column: DG.Column<any>): Promise<Float32Array> {
   const values = column.toList();
-  const worker = new Worker(new URL('./mm-distance-worker.ts', import.meta.url));
   if (column.semType !== DG.SEMTYPE.MACROMOLECULE)
     throw new Error('Column has to be of macromolecule type');
-  const uh = new UnitsHandler(column);
+  const uh = UnitsHandler.getOrCreate(column);
   const fnName = uh.getDistanceFunctionName();
-  worker.postMessage({values, fnName});
-  return new Promise((resolve, reject) => {
-    worker.onmessage = ({data: {error, distanceMatrixData}}): void => {
-      worker.terminate();
-      error ? reject(error) : resolve(distanceMatrixData);
-    };
-  });
+  const distanceMatrixService = new DistanceMatrixService(true, false);
+  const dm = await distanceMatrixService.calc(values, fnName);
+  distanceMatrixService.terminate();
+  return dm;
 }
 
 // gets index of compressed distance matrix from 2d coordinates

package/src/apps/web-logo-app.ts

@@ -0,0 +1,34 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
+import {_package} from '../package';
+
+export class WebLogoApp {
+  private _funcName: string = '';
+
+  df: DG.DataFrame;
+  view: DG.TableView;
+
+  constructor() {}
+
+  async init(df: DG.DataFrame, funcName: string): Promise<void> {
+    this._funcName = funcName;
+    this.df = df;
+
+    await this.buildView();
+  }
+
+  // -- View --
+
+  async buildView(): Promise<void> {
+    this.view = grok.shell.addTableView(this.df);
+    this.view.path = this.view.basePath = `func/${_package.name}.${this._funcName}`;
+
+    const viewer: DG.Viewer & IWebLogoViewer = (await this.view.dataFrame.plot.fromType('WebLogo', {
+      sequenceColumnName: 'sequence',
+    }));
+    this.view.dockManager.dock(viewer, DG.DOCK_TYPE.DOWN, null, 'WebLogo', 0.35);
+  }
+}

package/src/calculations/monomerLevelMols.ts

@@ -1,35 +1,33 @@
 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 {getHelmMonomers} from '../package';
-import {TAGS as bioTAGS, getSplitter, getStats} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {TAGS as bioTAGS, getSplitter, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 const V2000_ATOM_NAME_POS = 31;
 
-export async function getMonomericMols(mcol: DG.Column<string>,
-  pattern: boolean = false, monomersDict?: Map<string, string>): Promise<DG.Column> {
-  const separator: string = mcol.tags[bioTAGS.separator];
-  const units: string = mcol.tags[DG.TAGS.UNITS];
-  const splitter = getSplitter(units, separator);
+export async function getMonomericMols(
+  mcol: DG.Column<string>, pattern: boolean = false, monomersDict?: Map<string, string>
+): Promise<DG.Column> {
+  const uh = UnitsHandler.getOrCreate(mcol);
   let molV3000Array;
   monomersDict ??= new Map();
-  const monomers = units === 'helm' ?
-    getHelmMonomers(mcol) : Object.keys(getStats(mcol, 0, splitter).freq).filter((it) => it !== '');
+  const monomers = uh.units === NOTATION.HELM ?
+    getHelmMonomers(mcol) : Object.keys(uh.stats.freq).filter((it) => it !== '');
 
   for (let i = 0; i < monomers.length; i++) {
     if (!monomersDict.has(monomers[i]))
       monomersDict.set(monomers[i], `${monomersDict.size + 1}`);
   }
 
-  if (units === 'helm') {
+  if (uh.units === NOTATION.HELM) {
     molV3000Array = await grok.functions.call('HELM:getMolFiles', {col: mcol});
     molV3000Array = changeV2000ToV3000(molV3000Array, monomersDict, pattern);
   } else {
     molV3000Array = new Array<string>(mcol.length);
     for (let i = 0; i < mcol.length; i++) {
-      const sequenceMonomers = splitter(mcol.get(i)!).filter((it) => it !== '');
+      const sequenceMonomers = uh.splitted[i].filter((it) => it !== '');
       const molV3000 = molV3000FromNonHelmSequence(sequenceMonomers, monomersDict, pattern);
       molV3000Array[i] = molV3000;
     }

package/src/demo/bio01-similarity-diversity.ts

@@ -4,7 +4,6 @@ import * as DG from 'datagrok-api/dg';
 
 import {_package} from '../package';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
-import {delay} from '@datagrok-libraries/utils/src/test';
 import {handleError} from './utils';
 import {SequenceDiversityViewer} from '../analysis/sequence-diversity-viewer';
 import {SequenceSimilarityViewer} from '../analysis/sequence-similarity-viewer';
@@ -36,7 +35,7 @@ export async function demoBio01UI() {
         // TODO: Fix column width
       }, {
         description: `Load dataset with macromolecules of 'fasta' notation, 'DNA' alphabet.`,
-        delay: 2000
+        delay: 2000,
       })
       .step('Find the most similar sequences to the current one', async () => {
         const simViewer = await df.plot.fromType('Sequence Similarity Search', {
@@ -46,17 +45,17 @@ export async function demoBio01UI() {
         view.dockManager.dock(simViewer, DG.DOCK_TYPE.RIGHT, null, 'Similarity search', 0.35);
       }, {
         description: `Add 'Sequence Similarity Search' viewer.`,
-        delay: 2000
+        delay: 2000,
       })
       .step('Explore most diverse sequences in a dataset', async () => {
         const divViewer = await df.plot.fromType('Sequence Diversity Search', {
           moleculeColumnName: 'sequence',
-          diverseColumnLabel: 'Top diverse sequences of all data'
+          diverseColumnLabel: 'Top diverse sequences of all data',
         }) as SequenceDiversityViewer;
         view.dockManager.dock(divViewer, DG.DOCK_TYPE.DOWN, null, 'Diversity search', 0.27);
       }, {
         description: `Add 'Sequence Deversity Search' viewer.`,
-        delay: 2000
+        delay: 2000,
       })
       .step('Choose another sequence for similarity search', async () => {
         df.currentRowIdx = 3;

package/src/demo/bio01a-hierarchical-clustering-and-sequence-space.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 import {_package} from '../package';
 
 import * as lev from 'fastest-levenshtein';
-import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
+import {DistanceMatrix} from '@datagrok-libraries/ml/src/distance-matrix';
 import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
 import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
 import {demoSequenceSpace, handleError} from './utils';
@@ -19,11 +19,9 @@ export async function demoBio01aUI() {
   let dendrogramSvc: IDendrogramService;
   let view: DG.TableView;
   let df: DG.DataFrame;
-  let spViewer: DG.ScatterPlotViewer;
+  let _spViewer: DG.ScatterPlotViewer;
 
   const dimRedMethod: string = 'UMAP';
-  const idRows: { [id: number]: number } = {};
-  const embedCols: { [colName: string]: DG.Column<number> } = {};
 
   try {
     const demoScript = new DemoScript(
@@ -34,7 +32,7 @@ export async function demoBio01aUI() {
         [df, treeHelper, dendrogramSvc] = await Promise.all([
           _package.files.readCsv(dataFn),
           getTreeHelper(),
-          getDendrogramService()
+          getDendrogramService(),
         ]);
         view = grok.shell.addTableView(df);
         view.grid.props.rowHeight = 22;
@@ -49,10 +47,10 @@ export async function demoBio01aUI() {
         delay: 2000,
       })
       .step('Build sequence space', async () => {
-        spViewer = await demoSequenceSpace(view, df, seqColName, dimRedMethod);
+        _spViewer = await demoSequenceSpace(view, df, seqColName, dimRedMethod);
       }, {
         description: `Reduce sequence space dimensionality to display on 2D representation.`,
-        delay: 2000
+        delay: 2000,
       })
       .step('Cluster sequences', async () => {
         const seqCol: DG.Column<string> = df.getCol(seqColName);
@@ -80,6 +78,7 @@ export async function demoBio01aUI() {
         });
         df.currentRowIdx = 27;
       }, {
+        // eslint-disable-next-line max-len
         description: 'Selecting a group of rows from a data frame to show their similarity and proximity to each other on a viewer..',
         delay: 2000,
       })

package/src/demo/bio01b-hierarchical-clustering-and-activity-cliffs.ts

@@ -2,16 +2,17 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {_package, activityCliffs,} from '../package';
+import {_package, activityCliffs} from '../package';
 import $ from 'cash-dom';
 
 import {TEMPS as acTEMPS} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import * as lev from 'fastest-levenshtein';
-import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
+import {DistanceMatrix} from '@datagrok-libraries/ml/src/distance-matrix';
 import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
 import {getDendrogramService, IDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
 import {handleError} from './utils';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
 const dataFn: string = 'data/sample_FASTA_PT_activity.csv';
 
@@ -23,8 +24,7 @@ export async function demoBio01bUI() {
   let view: DG.TableView;
   let activityCliffsViewer: DG.ScatterPlotViewer;
 
-  const dimRedMethod: string = 'UMAP';
-  const idRows: { [id: number]: number } = {};
+  const dimRedMethod: DimReductionMethods = DimReductionMethods.UMAP;
 
   try {
     const demoScript = new DemoScript(
@@ -38,7 +38,7 @@ export async function demoBio01bUI() {
         [df, treeHelper, dendrogramSvc] = await Promise.all([
           _package.files.readCsv(dataFn),
           getTreeHelper(),
-          getDendrogramService()
+          getDendrogramService(),
         ]);
 
         view = grok.shell.addTableView(df);
@@ -62,7 +62,7 @@ export async function demoBio01bUI() {
         cliffsLink.click();
       }, {
         description: 'Reveal similar sequences with a cliff of activity.',
-        delay: 2000
+        delay: 2000,
       })
       .step('Cluster sequences', async () => {
         const seqCol: DG.Column<string> = df.getCol('sequence');
@@ -79,7 +79,7 @@ export async function demoBio01bUI() {
         activityGCol.scrollIntoView();
       }, {
         description: 'Perform hierarchical clustering to reveal relationships between sequences.',
-        delay: 2000
+        delay: 2000,
       })
       .step('Browse the cliff', async () => {
         //cliffsDfGrid.dataFrame.currentRowIdx = -1; // reset
@@ -99,7 +99,7 @@ export async function demoBio01bUI() {
         // }
       }, {
         description: 'Zoom in to explore selected activity cliff details.',
-        delay: 2000
+        delay: 2000,
       })
       .start();
   } catch (err: any) {

package/src/demo/bio03-atomic-level.ts

@@ -1,10 +1,7 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-
-
 import {_package, toAtomicLevel} from '../package';
-import $ from 'cash-dom';
 import {handleError} from './utils';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 import {delay} from '@datagrok-libraries/utils/src/test';
@@ -20,7 +17,7 @@ export async function demoBio03UI(): Promise<void> {
   try {
     await new DemoScript(
       'Atomic Level',
-      'Atomic level structure of Macromolecules'
+      'Atomic level structure of Macromolecules',
     )
       .step(`Loading Macromolecules notation 'Helm'`, async () => {
         grok.shell.windows.showContextPanel = false;

package/src/demo/bio05-helm-msa-sequence-space.ts

@@ -7,8 +7,9 @@ import {handleError} from './utils';
 
 import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {pepseaMethods, runPepsea} from '../utils/pepsea';
-import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
 const helmFn: string = 'samples/sample_HELM.csv';
 
@@ -22,7 +23,7 @@ export async function demoBio05UI(): Promise<void> {
 
   const helmColName: string = 'HELM';
   const msaHelmColName: string = 'msa(HELM)';
-  const dimRedMethod: string = 'UMAP';
+  const dimRedMethod: DimReductionMethods = DimReductionMethods.UMAP;
 
   try {
     const demoScript = new DemoScript(
@@ -43,20 +44,21 @@ export async function demoBio05UI(): Promise<void> {
         const method: string = pepseaMethods[0];
         const gapOpen: number = 1.53;
         const gapExtend: number = 0;
-        msaHelmCol = await runPepsea(helmCol, msaHelmColName, method, gapOpen, gapExtend, undefined);
+        msaHelmCol = (await runPepsea(helmCol, msaHelmColName, method, gapOpen, gapExtend, undefined))!;
         df.columns.add(msaHelmCol);
         await grok.data.detectSemanticTypes(df);
       }, {
+        // eslint-disable-next-line max-len
         description: 'Multiple sequence alignment (MSA) performed with PepSeA tool operating on non-natural aminoacids as well.',
         delay: 2000,
       })
       .step('Build sequence space', async () => {
         ssViewer = (await sequenceSpaceTopMenu(df, msaHelmCol,
-          dimRedMethod, StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
+          dimRedMethod, MmDistanceFunctionsNames.LEVENSHTEIN, true)) as DG.ScatterPlotViewer;
         view.dockManager.dock(ssViewer, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
       }, {
         description: 'Reduce sequence space dimensionality to display on 2D representation.',
-        delay: 2000
+        delay: 2000,
       })
       .step('Analyse sequence composition', async () => {
         wlViewer = await df.plot.fromType('WebLogo', {
@@ -66,6 +68,7 @@ export async function demoBio05UI(): Promise<void> {
         }) as DG.Viewer & IWebLogoViewer;
         view.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.2);
       }, {
+        // eslint-disable-next-line max-len
         description: 'Composition analysis allows to reveal functional features of sequences like motifs, or variable loops.',
         delay: 2000,
       })

package/src/demo/utils.ts

@@ -5,7 +5,8 @@ import * as ui from 'datagrok-api/ui';
 import {_package, sequenceSpaceTopMenu} from '../package';
 import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/sequence-space';
 import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
-import {delay} from '@datagrok-libraries/utils/src/test';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
 enum EMBED_COL_NAMES {
   X = 'Embed_X',
@@ -13,7 +14,7 @@ enum EMBED_COL_NAMES {
 }
 
 export async function demoSequenceSpace(
-  view: DG.TableView, df: DG.DataFrame, colName: string, method: string
+  view: DG.TableView, df: DG.DataFrame, colName: string, method: string,
 ): Promise<DG.ScatterPlotViewer> {
   let resSpaceViewer: DG.ScatterPlotViewer;
   if (true) {
@@ -63,7 +64,7 @@ export async function demoSequenceSpace(
     })) as DG.ScatterPlotViewer;
   } else {
     resSpaceViewer = (await sequenceSpaceTopMenu(df, df.getCol(colName),
-      'UMAP', StringMetricsNames.Levenshtein, true)) as DG.ScatterPlotViewer;
+      DimReductionMethods.UMAP, MmDistanceFunctionsNames.LEVENSHTEIN, true)) as DG.ScatterPlotViewer;
   }
   view.dockManager.dock(resSpaceViewer!, DG.DOCK_TYPE.RIGHT, null, 'Sequence Space', 0.35);
   return resSpaceViewer;

package/src/package-test.ts

@@ -22,10 +22,9 @@ import './tests/substructure-filters-tests';
 import './tests/pepsea-tests';
 import './tests/viewers';
 import './tests/units-handler-tests';
+import './tests/units-handler-splitted-tests';
 import './tests/to-atomic-level-tests';
 import './tests/mm-distance-tests';
-
-// Tests hanging github CI
 import './tests/activity-cliffs-tests';
 import './tests/sequence-space-test';