@datagrok/bio 2.11.23 → 2.11.26

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.11.23",
+  "version": "2.11.26",
   "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.39.16",
+    "@datagrok-libraries/bio": "^5.39.18",
     "@datagrok-libraries/chem-meta": "^1.2.1",
-    "@datagrok-libraries/ml": "^6.3.68",
+    "@datagrok-libraries/ml": "^6.4.0",
     "@datagrok-libraries/tutorials": "^1.3.11",
     "@datagrok-libraries/utils": "^4.1.36",
     "@datagrok-libraries/math": "^1.0.7",
@@ -66,7 +66,7 @@
     "webpack-bundle-analyzer": "latest",
     "webpack-cli": "^4.9.1",
     "@datagrok/chem": "^1.8.8",
-    "@datagrok/helm": "^2.1.22",
+    "@datagrok/helm": "^2.1.24",
     "@datagrok/dendrogram": "^1.2.22"
   },
   "scripts": {

package/src/analysis/sequence-space.ts

@@ -1,12 +1,9 @@
 import * as DG from 'datagrok-api/dg';
-import {reduceDimensinalityWithNormalization} from '@datagrok-libraries/ml/src/sequence-space';
-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 * as grok from 'datagrok-api/grok';
+import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {mmDistanceFunctionArgs} from '@datagrok-libraries/ml/src/macromolecule-distance-functions/types';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {getMonomerSubstitutionMatrix} 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';
 
 export interface ISequenceSpaceResult {
@@ -14,47 +11,6 @@ export interface ISequenceSpaceResult {
   coordinates: DG.ColumnList;
 }
 
-export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
-  // code deprecated since seqCol is encoded
-  /*    let preparedData: any;
-  if (!(spaceParams.seqCol!.tags[DG.TAGS.UNITS] === 'HELM')) {
-    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))
-      preparedData = spaceParams.seqCol.toList().map((v: string) => v.replace(regex, '')) as string[];
-    else
-      preparedData = spaceParams.seqCol.toList().map((v: string) => v.replace(regex, '')) as string[];
-  } else {
-    preparedData = spaceParams.seqCol.toList();
-  }  */
-
-  const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
-    spaceParams.seqCol.toList(),
-    spaceParams.methodName,
-    spaceParams.similarityMetric as StringMetrics | BitArrayMetrics,
-    spaceParams.options);
-  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)};
-}
-
-export async function sequenceSpaceByFingerprints(spaceParams: ISequenceSpaceParams): Promise<ISequenceSpaceResult> {
-  if (spaceParams.seqCol.version !== spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
-    //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],
-    methodName: spaceParams.methodName,
-    similarityMetric: spaceParams.similarityMetric,
-    xAxis: spaceParams.embedAxesNames[0],
-    yAxis: spaceParams.embedAxesNames[1],
-    options: spaceParams.options,
-  });
-  return result;
-}
-
 export async function getEncodedSeqSpaceCol(
   seqCol: DG.Column, similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames, fingerprintType: string = 'Morgan'
 ): Promise<{seqList:string[], options: {[_:string]: any}}> {
@@ -118,32 +74,3 @@ export async function getEncodedSeqSpaceCol(
   }
   return {seqList, options};
 }
-
-export async function getSequenceSpace(spaceParams: ISequenceSpaceParams,
-  progressFunc?: (epochNum: number, epochsLength: number, embedding: number[][]) => void
-): Promise<ISequenceSpaceResult> {
-  const ncUH = UnitsHandler.getOrCreate(spaceParams.seqCol);
-  if (ncUH.isHelm())
-    return await sequenceSpaceByFingerprints(spaceParams);
-
-
-  const {seqList, options} = await getEncodedSeqSpaceCol(spaceParams.seqCol, spaceParams.similarityMetric);
-
-  spaceParams.options = spaceParams.options ?? {};
-  spaceParams.options.distanceFnArgs = options;
-  const sequenceSpaceResult = await reduceDimensinalityWithNormalization(
-    seqList,
-    spaceParams.methodName,
-    spaceParams.similarityMetric,
-    spaceParams.options,
-    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)};
-}
-
-export function getEmbeddingColsNames(df: DG.DataFrame) {
-  const axes = ['Embed_X', 'Embed_Y'];
-  const colNameInd = df.columns.names().filter((it: string) => it.includes(axes[0])).length + 1;
-  return axes.map((it) => `${it}_${colNameInd}`);
-}

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

@@ -10,9 +10,9 @@ import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree
 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';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {getClusterMatrixWorker} from '@datagrok-libraries/math';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 const dataFn: string = 'data/sample_FASTA_PT_activity.csv';
 
@@ -51,9 +51,10 @@ export async function demoBio01bUI() {
         delay: 2000,
       })
       .step('Find activity cliffs', async () => {
+        const seqEncodingFunc = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
         activityCliffsViewer = (await activityCliffs(
           df, df.getCol('Sequence'), df.getCol('Activity'),
-          80, dimRedMethod, MmDistanceFunctionsNames.LEVENSHTEIN)) as DG.ScatterPlotViewer;
+          80, dimRedMethod, MmDistanceFunctionsNames.LEVENSHTEIN, seqEncodingFunc, {})) as DG.ScatterPlotViewer;
         view.dockManager.dock(activityCliffsViewer, DG.DOCK_TYPE.RIGHT, null, 'Activity Cliffs', 0.35);
 
         // Show grid viewer with the cliffs

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

@@ -5,7 +5,6 @@ import * as DG from 'datagrok-api/dg';
 import {IWebLogoViewer} from '@datagrok-libraries/bio/src/viewers/web-logo';
 import {awaitStatus, DockerContainerStatus} from '@datagrok-libraries/bio/src/utils/docker';
 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';
 
 import {Pepsea, pepseaMethods, runPepsea} from '../utils/pepsea';
@@ -13,6 +12,7 @@ import {sequenceSpaceTopMenu} from '../package';
 import {handleError} from './utils';
 
 import {_package} from '../package';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 const helmFn: string = 'samples/HELM.csv';
 

package/src/demo/utils.ts

@@ -3,10 +3,11 @@ import * as DG from 'datagrok-api/dg';
 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 {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import {getNormalizedEmbeddings} from
+  '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/embeddings-space';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 enum EMBED_COL_NAMES {
   X = 'Embed_X',
@@ -38,8 +39,8 @@ export async function demoSequenceSpace(
 
       const t1: number = Date.now();
       _package.logger.debug('Bio: demoBio01aUI(), calc reduceDimensionality start...');
-      const redDimRes = await reduceDimensinalityWithNormalization( // TODO: Rename method typo
-        seqList, method, StringMetricsNames.Levenshtein, {});
+      const redDimRes = await getNormalizedEmbeddings( // TODO: Rename method typo
+        [seqList], method as any, [StringMetricsNames.Levenshtein], [1], 'MANHATTAN', {distanceFnArgs: [{}]});
       const t2: number = Date.now();
       _package.logger.debug('Bio: demoBio01aUI(), calc reduceDimensionality ' +
         `ET: ${((t2 - t1) / 1000)} s`);
@@ -47,7 +48,7 @@ export async function demoSequenceSpace(
       for (let embedI: number = 0; embedI < embedColNameList.length; embedI++) {
         const embedColName: string = embedColNameList[embedI];
         const embedCol: DG.Column = df.getCol(embedColName);
-        const embedColData: Float32Array = redDimRes.embedding[embedI];
+        const embedColData: Float32Array = redDimRes[embedI];
         // TODO: User DG.Column.setRawData()
         // embedCol.setRawData(embedColData);
         embedCol.init((rowI) => { return embedColData[rowI]; });

package/src/package.ts

@@ -3,23 +3,14 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-
-import {delay} from '@datagrok-libraries/utils/src/test';
-import {removeEmptyStringRows} from '@datagrok-libraries/utils/src/dataframe-utils';
 import {Options} from '@datagrok-libraries/utils/src/type-declarations';
-import {DimReductionMethods, ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
-import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
 import {DimReductionBaseEditor, PreprocessFunctionReturnType}
   from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
-import {reduceDimensionality} from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reducer';
-import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
-import {
-  ISequenceSpaceParams, getActivityCliffs, SequenceSpaceFunc, CLIFFS_COL_ENCODE_FN
-} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics, KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 import {
-  TAGS as bioTAGS, ALPHABET, NOTATION,
+  TAGS as bioTAGS,
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
@@ -38,11 +29,9 @@ import {
 } from './utils/cell-renderer';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
+import {getEncodedSeqSpaceCol} from './analysis/sequence-space';
 import {
-  ISequenceSpaceResult, getEmbeddingColsNames, getEncodedSeqSpaceCol, getSequenceSpace, sequenceSpaceByFingerprints
-} from './analysis/sequence-space';
-import {
-  createLinesGrid, createPropPanelElement, createTooltipElement, getChemSimilaritiesMatrix,
+  createLinesGrid, createPropPanelElement, createTooltipElement,
 } from './analysis/sequence-activity-cliffs';
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
@@ -79,15 +68,17 @@ import {GetRegionApp} from './apps/get-region-app';
 import {GetRegionFuncEditor} from './utils/get-region-func-editor';
 import {sequenceToMolfile} from './utils/sequence-to-mol';
 import {detectMacromoleculeProbeDo} from './utils/detect-macromolecule-probe';
-
-import {SHOW_SCATTERPLOT_PROGRESS} from '@datagrok-libraries/ml/src/functionEditors/seq-space-base-editor';
-import {DIMENSIONALITY_REDUCER_TERMINATE_EVENT}
-  from '@datagrok-libraries/ml/src/workers/dimensionality-reducing-worker-creator';
+import {ActivityCliffsEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-function-editor';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
+import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
+import {getEmbeddingColsNames, multiColReduceDimensionality} from
+  '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
+import {ITSNEOptions, IUMAPOptions} from
+  '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
 
 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;
 
@@ -256,16 +247,24 @@ export function SequenceSpaceEditor(call: DG.FuncCall) {
 //tags: editor
 //input: funccall call
 export function SeqActivityCliffsEditor(call: DG.FuncCall) {
-  const funcEditor = new ActivityCliffsFunctionEditor(DG.SEMTYPE.MACROMOLECULE);
+  const funcEditor = new ActivityCliffsEditor({semtype: DG.SEMTYPE.MACROMOLECULE});
   ui.dialog({title: 'Activity Cliffs'})
-    .add(funcEditor.paramsUI)
+    .add(funcEditor.getEditor())
     .onOK(async () => {
-      return call.func.prepare(funcEditor.funcParams).call(true);
-    })
-    .show();
+      const params = funcEditor.getParams();
+      return call.func.prepare({
+        table: params.table,
+        molecules: params.col,
+        activities: params.activities,
+        similarity: params.similarityThreshold,
+        methodName: params.methodName,
+        similarityMetric: params.similarityMetric,
+        preprocessingFunction: params.preprocessingFunction,
+        options: params.options,
+      }).call();
+    }).show();
 }
 
-
 // -- Package settings editor --
 
 // //name: packageSettingsEditor
@@ -405,74 +404,57 @@ export async function getRegionTopMenu(
 //input: double similarity = 80 [Similarity cutoff]
 //input: string methodName { choices:["UMAP", "t-SNE"] }
 //input: string similarityMetric { choices:["Hamming", "Levenshtein", "Monomer chemical distance"] }
+//input: func preprocessingFunction
 //input: object options {optional: true}
 //output: viewer result
 //editor: Bio:SeqActivityCliffsEditor
-export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column<string>, activities: DG.Column,
+export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<string>, activities: DG.Column,
   similarity: number, methodName: DimReductionMethods,
-  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics,
+  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
   options?: (IUMAPOptions | ITSNEOptions) & Options): Promise<DG.Viewer | undefined> {
-  if (!checkInputColumnUI(macroMolecule, 'Activity Cliffs'))
+  if (!checkInputColumnUI(molecules, 'Activity Cliffs'))
     return;
-  const axesNames = getEmbeddingColsNames(df);
+  const axesNames = getEmbeddingColsNames(table);
   const tags = {
-    'units': macroMolecule.getTag(DG.TAGS.UNITS),
-    'aligned': macroMolecule.getTag(bioTAGS.aligned),
-    'separator': macroMolecule.getTag(bioTAGS.separator),
-    'alphabet': macroMolecule.getTag(bioTAGS.alphabet),
+    'units': molecules.getTag(DG.TAGS.UNITS),
+    'aligned': molecules.getTag(bioTAGS.aligned),
+    'separator': molecules.getTag(bioTAGS.separator),
+    'alphabet': molecules.getTag(bioTAGS.alphabet),
   };
-  let cliffsEncodeFunction: (seqCol: DG.Column, similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics) => any =
-    getEncodedSeqSpaceCol;
-  const ncUH = UnitsHandler.getOrCreate(macroMolecule);
   const columnDistanceMetric: MmDistanceFunctionsNames | BitArrayMetrics = similarityMetric;
-  const seqCol = macroMolecule;
-
-  let sequenceSpaceFunc: SequenceSpaceFunc = getSequenceSpace;
-  if (ncUH.isHelm()) {
-    sequenceSpaceFunc = sequenceSpaceByFingerprints;
-    cliffsEncodeFunction = async (seqCol: DG.Column, similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics) => {
-      await invalidateMols(seqCol, false);
-      const molecularCol = seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS];
-      const fingerPrints: DG.Column =
-        await grok.functions.call('Chem:getMorganFingerprints', {molColumn: molecularCol});
-      const fingerPrintsBitArray = fingerPrints.toList().map((f: DG.BitSet) =>
-        BitArray.fromUint32Array(f.length, new Uint32Array(f.getBuffer().buffer)));
-      return {seqList: fingerPrintsBitArray, options: {}};
-    };
-  }
+  const seqCol = molecules;
 
   const runCliffs = async () => {
     const sp = await getActivityCliffs(
-      df,
+      table,
       seqCol,
-      null,
       axesNames,
       'Activity cliffs', //scatterTitle
       activities,
       similarity,
       columnDistanceMetric, //similarityMetric
       methodName,
+      {...(options ?? {})},
       DG.SEMTYPE.MACROMOLECULE,
       tags,
-      sequenceSpaceFunc,
-      getChemSimilaritiesMatrix,
+      preprocessingFunction,
       createTooltipElement,
       createPropPanelElement,
       createLinesGrid,
-      {...(options ?? {}), [CLIFFS_COL_ENCODE_FN]: cliffsEncodeFunction});
+    );
     return sp;
   };
 
   const allowedRowCount = methodName === DimReductionMethods.UMAP ? 200_000 : 20_000;
   const fastRowCount = methodName === DimReductionMethods.UMAP ? 5_000 : 2_000;
-  if (df.rowCount > allowedRowCount) {
+  if (table.rowCount > allowedRowCount) {
     grok.shell.warning(`Too many rows, maximum for sequence activity cliffs is ${allowedRowCount}`);
     return;
   }
 
   const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
   return new Promise<DG.Viewer | undefined>((resolve, reject) => {
-    if (df.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
+    if (table.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 () => {
@@ -495,7 +477,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column<
 //meta.supportedSemTypes: Macromolecule
 //meta.supportedTypes: string
 //meta.supportedUnits: fasta,separator,helm
-//meta.supportedDistanceFunctions: Hamming,Levenshtein,Monomer chemical distance,Needlemann-Wunsch
+//meta.supportedDistanceFunctions: Levenshtein,Hamming,Monomer chemical distance,Needlemann-Wunsch
 //input: column col {semType: Macromolecule}
 //input: string metric
 //input: double gapOpen = 1 {caption: Gap open penalty; default: 1; optional: true}
@@ -506,6 +488,8 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column<
 export async function macromoleculePreprocessingFunction(
   col: DG.Column, metric: MmDistanceFunctionsNames, gapOpen: number = 1, gapExtend: number = 0.6,
   fingerprintType = 'Morgan'): Promise<PreprocessFunctionReturnType> {
+  if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
+    return {entries: col.toList(), options: {}};
   const {seqList, options} = await getEncodedSeqSpaceCol(col, metric, fingerprintType);
   return {entries: seqList, options: {...options, gapOpen, gapExtend}};
 }
@@ -558,13 +542,15 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
     return;
   if (!preprocessingFunction)
     preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
-
-  const res = await reduceDimensionality(table, molecules, methodName,
-      similarityMetric as KnownMetrics, preprocessingFunction, plotEmbeddings, clusterEmbeddings ?? false, options, {
-        fastRowCount: 10000,
-        scatterPlotName: 'Sequence space',
-        bypassLargeDataWarning: options?.[BYPASS_LARGE_DATA_WARNING],
-      });
+  options ??= {};
+  const res = await multiColReduceDimensionality(table, [molecules], methodName,
+    [similarityMetric as KnownMetrics], [1], [preprocessingFunction], 'MANHATTAN',
+    plotEmbeddings, clusterEmbeddings ?? false,
+    {...options, preprocessingFuncArgs: [options.preprocessingFuncArgs ?? {}]}, {
+      fastRowCount: 10000,
+      scatterPlotName: 'Sequence space',
+      bypassLargeDataWarning: options?.[BYPASS_LARGE_DATA_WARNING],
+    });
   return res;
 }
 

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

@@ -5,7 +5,6 @@ import {after, before, category, test} from '@datagrok-libraries/utils/src/test'
 
 import {readDataframe} from './utils';
 import {_testActivityCliffsOpen} from './activity-cliffs-utils';
-import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
@@ -15,6 +14,7 @@ import {
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 import {_package} from '../package-test';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 
 category('activityCliffs', async () => {
@@ -24,8 +24,8 @@ category('activityCliffs', async () => {
   let monomerLibHelper: IMonomerLibHelper;
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: LibSettings;
-
-
+  const seqEncodingFunc = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
+  const helmEncodingFunc = DG.Func.find({name: 'helmPreprocessingFunction', package: 'Bio'})[0];
   before(async () => {
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
@@ -57,7 +57,7 @@ category('activityCliffs', async () => {
     const cliffsNum = DG.Test.isInBenchmark ? 6 : 3;
 
     await _testActivityCliffsOpen(actCliffsDf, DimReductionMethods.UMAP,
-      'sequence', 'Activity', 90, cliffsNum, MmDistanceFunctionsNames.LEVENSHTEIN);
+      'sequence', 'Activity', 90, cliffsNum, MmDistanceFunctionsNames.LEVENSHTEIN, seqEncodingFunc);
   });
 
   test('activityCliffsWithEmptyRows', async () => {
@@ -67,14 +67,14 @@ category('activityCliffs', async () => {
     viewList.push(actCliffsTableViewWithEmptyRows);
 
     await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, DimReductionMethods.UMAP,
-      'sequence', 'Activity', 90, 3, MmDistanceFunctionsNames.LEVENSHTEIN);
+      'sequence', 'Activity', 90, 3, MmDistanceFunctionsNames.LEVENSHTEIN, seqEncodingFunc);
   });
 
   test('Helm', async () => {
     const df = await _package.files.readCsv('data/sample_HELM_50.csv');
-    const view = grok.shell.addTableView(df);
+    const _view = grok.shell.addTableView(df);
 
     await _testActivityCliffsOpen(df, DimReductionMethods.UMAP,
-      'HELM', 'Activity', 65, 4, BitArrayMetricsNames.Tanimoto);
+      'HELM', 'Activity', 65, 20, BitArrayMetricsNames.Tanimoto, helmEncodingFunc);
   });
 });

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

@@ -2,19 +2,20 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {expect} from '@datagrok-libraries/utils/src/test';
-import {activityCliffs, BYPASS_LARGE_DATA_WARNING} from '../package';
-import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {activityCliffs} from '../package';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 export async function _testActivityCliffsOpen(df: DG.DataFrame, drMethod: DimReductionMethods,
   seqColName: string, activityColName: string, similarityThr: number, tgtNumberCliffs: number,
-  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics
+  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
 ): Promise<void> {
   await grok.data.detectSemanticTypes(df);
   const scatterPlot = await activityCliffs(
     df, df.getCol(seqColName), df.getCol(activityColName),
-    similarityThr, drMethod, similarityMetric, {[`${BYPASS_LARGE_DATA_WARNING}`]: true});
+    similarityThr, drMethod, similarityMetric, preprocessingFunction, {[`${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/msa-tests.ts

@@ -81,12 +81,12 @@ MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP
   test('isCorrectHelm', async () => {
     await awaitContainerStart();
     await _testMSAOnColumn(helmFromCsv, helmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  }, {skipReason: 'GROK-13221'});
+  });
 
   test('isCorrectHelmLong', async () => {
     await awaitContainerStart();
     await _testMSAOnColumn(longHelmFromCsv, longHelmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  }, {skipReason: 'GROK-13221'});
+  });
 
   test('isCorrectSeparator', async () => {
     await _testMSAOnColumn(

package/src/tests/pepsea-tests.ts

@@ -20,5 +20,5 @@ category('PepSeA', () => {
     const alignedTestCol = table.getCol('MSA');
     for (let i = 0; i < alignedCol!.length; ++i)
       expect(alignedCol!.get(i) == alignedTestCol.get(i), true);
-  }, {skipReason: 'GROK-13221'});
+  });
 });

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

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 import {category, test} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
 import {_testSequenceSpaceReturnsResult} from './sequence-space-utils';
-import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 category('sequenceSpace', async () => {
   let testFastaDf: DG.DataFrame;

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

@@ -3,8 +3,8 @@ import * as grok from 'datagrok-api/grok';
 import {expect} from '@datagrok-libraries/utils/src/test';
 import {sequenceSpaceTopMenu} from '../package';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
-import {DimReductionMethods} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 export async function _testSequenceSpaceReturnsResult(
   df: DG.DataFrame, algorithm: DimReductionMethods, colName: string,

package/src/tests/utils.ts

@@ -35,9 +35,11 @@ export function _testTableIsNotEmpty(table: DG.DataFrame): void {
 /** Waits if container is not started
  * @param {number} ms - time to wait in milliseconds */
 export async function awaitContainerStart(ms: number = 10000): Promise<void> {
-  const pepseaContainer = await grok.dapi.docker.dockerContainers.filter('bio').first();
-  if (pepseaContainer.status !== 'started' && pepseaContainer.status !== 'checking')
+  const container = await grok.dapi.docker.dockerContainers.filter('bio').first();
+  if (container.status !== 'started' && container.status !== 'checking')
     await delay(ms);
+    // TODO: Enable with new JS API version
+    // await grok.dapi.docker.dockerContainers.run(container.id, true);
 }
 
 export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<void> {