@datagrok/bio 2.26.4 → 2.26.5

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.26.4",
+  "version": "2.26.5",
   "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",
@@ -44,10 +44,10 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.63.3",
+    "@datagrok-libraries/bio": "^5.63.5",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
-    "@datagrok-libraries/ml": "^6.10.9",
+    "@datagrok-libraries/ml": "^6.10.11",
     "@datagrok-libraries/test": "^1.1.0",
     "@datagrok-libraries/tutorials": "^1.7.4",
     "@datagrok-libraries/utils": "^4.6.9",
@@ -77,7 +77,7 @@
     "@types/wu": "^2.1.44",
     "@typescript-eslint/eslint-plugin": "^8.8.1",
     "@typescript-eslint/parser": "^8.8.1",
-    "datagrok-tools": "^5.1.5",
+    "datagrok-tools": "^5.1.9",
     "eslint": "^8.57.1",
     "eslint-config-google": "^0.14.0",
     "eslint-plugin-rxjs": "^5.0.3",

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

@@ -15,8 +15,20 @@ import {HelmType} from '@datagrok-libraries/bio/src/helm/types';
 import {drawMoleculeDifferenceOnCanvas} from '../utils/cell-renderer';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
 
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+
 import {_package} from '../package';
 
+export type SeqActivityCliffsParams = {
+  seqColName: string,
+  activityColName: string,
+  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics,
+  similarity: number,
+  options: any,
+  isDemo?: boolean,
+}
+
 export async function getDistances(col: DG.Column, seq: string): Promise<Array<number>> {
   const stringArray = col.toList();
   const distances = new Array(stringArray.length).fill(0);

package/src/package-api.ts

@@ -192,6 +192,14 @@ export namespace funcs {
     return await grok.functions.call('Bio:ActivityCliffs', { table, molecules, activities, similarity, methodName, similarityMetric, preprocessingFunction, options, demo });
   }
 
+  export async function seqActivityCliffsInitFunction(sp: any ): Promise<void> {
+    return await grok.functions.call('Bio:SeqActivityCliffsInitFunction', { sp });
+  }
+
+  export async function seqActivityCliffsTransform(table: DG.DataFrame , molecules: DG.Column , activities: DG.Column , similarity: number , methodName: string , similarityMetric: string , options?: string , isDemo?: boolean , axesNames?: any ): Promise<void> {
+    return await grok.functions.call('Bio:SeqActivityCliffsTransform', { table, molecules, activities, similarity, methodName, similarityMetric, options, isDemo, axesNames });
+  }
+
   export async function macromoleculePreprocessingFunction(col: DG.Column , metric: string , gapOpen?: number , gapExtend?: number , fingerprintType?: string ): Promise<any> {
     return await grok.functions.call('Bio:MacromoleculePreprocessingFunction', { col, metric, gapOpen, gapExtend, fingerprintType });
   }
@@ -203,10 +211,14 @@ export namespace funcs {
   /**
   Creates 2D sequence space with projected sequences by pairwise distance
   */
-  export async function sequenceSpaceTopMenu(table: DG.DataFrame , molecules: DG.Column , methodName: string , similarityMetric: string , plotEmbeddings: boolean , preprocessingFunction?: any , options?: any , clusterEmbeddings?: boolean , isDemo?: boolean ): Promise<void> {
+  export async function sequenceSpaceTopMenu(table: DG.DataFrame , molecules: DG.Column , methodName: string , similarityMetric: string , plotEmbeddings: boolean , preprocessingFunction?: any , options?: any , clusterEmbeddings?: boolean , isDemo?: boolean ): Promise<any> {
     return await grok.functions.call('Bio:SequenceSpaceTopMenu', { table, molecules, methodName, similarityMetric, plotEmbeddings, preprocessingFunction, options, clusterEmbeddings, isDemo });
   }
 
+  export async function sequenceSpaceTransform(table: DG.DataFrame , molecules: DG.Column , methodName: string , similarityMetric: string , plotEmbeddings: boolean , options?: string , clusterEmbeddings?: boolean , embedColsNames?: any , clusterColName?: string ): Promise<any> {
+    return await grok.functions.call('Bio:SequenceSpaceTransform', { table, molecules, methodName, similarityMetric, plotEmbeddings, options, clusterEmbeddings, embedColsNames, clusterColName });
+  }
+
   /**
   Converts Peptide molecules to HELM notation by matching with monomer library
   */

package/src/package-test.ts

@@ -37,6 +37,7 @@ import './tests/mm-distance-tests';
 import './tests/activity-cliffs-tests';
 import './tests/sequence-space-test';
 import './tests/scoring';
+import './tests/projects-tests';
 
 
 export const _package = new DG.Package();

package/src/package.g.ts

@@ -270,6 +270,25 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<a
   return await PackageFunctions.activityCliffs(table, molecules, activities, similarity, methodName, similarityMetric, preprocessingFunction, options, demo);
 }
 
+//input: viewer sp 
+export async function seqActivityCliffsInitFunction(sp: any) : Promise<void> {
+  await PackageFunctions.seqActivityCliffsInitFunction(sp);
+}
+
+//input: dataframe table { description: Input data table }
+//input: column molecules { semType: Macromolecule }
+//input: column activities { type: numerical }
+//input: double similarity = 80 { description: Similarity cutoff }
+//input: string methodName 
+//input: string similarityMetric 
+//input: string options { optional: true }
+//input: bool isDemo { optional: true }
+//input: list<string> axesNames { optional: true }
+//meta.role: transform
+export async function seqActivityCliffsTransform(table: DG.DataFrame, molecules: DG.Column, activities: DG.Column, similarity: number, methodName: any, similarityMetric: any, options?: string, isDemo?: boolean, axesNames?: string[]) : Promise<void> {
+  await PackageFunctions.seqActivityCliffsTransform(table, molecules, activities, similarity, methodName, similarityMetric, options, isDemo, axesNames);
+}
+
 //name: Encode Sequences
 //tags: dim-red-preprocessing-function
 //input: column col { semType: Macromolecule }
@@ -309,12 +328,28 @@ export async function helmPreprocessingFunction(col: DG.Column<any>, _metric: an
 //input: object options { optional: true }
 //input: bool clusterEmbeddings = true { optional: true }
 //input: bool isDemo { optional: true }
+//output: viewer result
 //top-menu: Bio | Analyze | Sequence Space...
 //editor: Bio:SequenceSpaceEditor
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Column, methodName: any, similarityMetric: any, plotEmbeddings: boolean, preprocessingFunction?: any, options?: any, clusterEmbeddings?: boolean, isDemo?: boolean) : Promise<any> {
   return await PackageFunctions.sequenceSpaceTopMenu(table, molecules, methodName, similarityMetric, plotEmbeddings, preprocessingFunction, options, clusterEmbeddings, isDemo);
 }
 
+//input: dataframe table 
+//input: column molecules { semType: Macromolecule }
+//input: string methodName 
+//input: string similarityMetric 
+//input: bool plotEmbeddings = true 
+//input: string options { optional: true }
+//input: bool clusterEmbeddings { optional: true }
+//input: list<string> embedColsNames { optional: true }
+//input: string clusterColName { optional: true }
+//output: viewer result
+//meta.role: transform
+export async function sequenceSpaceTransform(table: DG.DataFrame, molecules: DG.Column, methodName: any, similarityMetric: any, plotEmbeddings: boolean, options?: string, clusterEmbeddings?: boolean, embedColsNames?: string[], clusterColName?: string) : Promise<any> {
+  return await PackageFunctions.sequenceSpaceTransform(table, molecules, methodName, similarityMetric, plotEmbeddings, options, clusterEmbeddings, embedColsNames, clusterColName);
+}
+
 //name: Molecules to HELM
 //description: Converts Peptide molecules to HELM notation by matching with monomer library
 //input: dataframe table { description: Input data table }

package/src/package.ts

@@ -9,7 +9,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {Options} from '@datagrok-libraries/utils/src/type-declarations';
 import {DimReductionBaseEditor, PreprocessFunctionReturnType} from '@datagrok-libraries/ml/src/functionEditors/dimensionality-reduction-editor';
-import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import {getActivityCliffsEmbeddings, runActivityCliffs} 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 {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -38,7 +38,7 @@ import {MacromoleculeDifferenceCellRenderer, MacromoleculeSequenceCellRenderer,}
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
 import {getEncodedSeqSpaceCol} from './analysis/sequence-space';
-import {createLinesGrid, createPropPanelElement, createTooltipElement,} from './analysis/sequence-activity-cliffs';
+import {createLinesGrid, createPropPanelElement, createTooltipElement, SeqActivityCliffsParams} from './analysis/sequence-activity-cliffs';
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
 import {invalidateMols, MONOMERIC_COL_TAGS, SubstructureSearchDialog} from './substructure-search/substructure-search';
@@ -522,38 +522,6 @@ export class PackageFunctions {
     }
     if (!checkInputColumnUI(molecules, 'Activity Cliffs'))
       return;
-    const axesNames = getEmbeddingColsNames(table);
-    const tags = {
-      'units': molecules.meta.units!,
-      'aligned': molecules.getTag(bioTAGS.aligned),
-      'separator': molecules.getTag(bioTAGS.separator),
-      'alphabet': molecules.getTag(bioTAGS.alphabet),
-    };
-    const columnDistanceMetric: MmDistanceFunctionsNames | BitArrayMetrics = similarityMetric;
-    const seqCol = molecules;
-
-    const runCliffs = async () => {
-      const sp = await getActivityCliffs(
-        table,
-        seqCol,
-        axesNames,
-        'Activity cliffs', //scatterTitle
-        activities,
-        similarity,
-        columnDistanceMetric, //similarityMetric
-        methodName,
-        {...(options ?? {})},
-        DG.SEMTYPE.MACROMOLECULE,
-        tags,
-        preprocessingFunction,
-        createTooltipElement,
-        createPropPanelElement,
-        createLinesGrid,
-        undefined,
-        demo
-      );
-      return sp;
-    };
 
     const allowedRowCount = methodName === DimReductionMethods.UMAP ? 200_000 : 20_000;
     const fastRowCount = methodName === DimReductionMethods.UMAP ? 5_000 : 2_000;
@@ -562,29 +530,125 @@ export class PackageFunctions {
       return;
     }
 
+    const axesNames = getEmbeddingColsNames(table);
+
+    const runCliffs = async (): Promise<void> => {
+      await DG.Func.find({name: 'seqActivityCliffsTransform'})[0].prepare({
+        table: table,
+        molecules: molecules,
+        activities: activities,
+        similarity: similarity,
+        methodName: methodName,
+        similarityMetric: similarityMetric,
+        options: JSON.stringify(options),
+        isDemo: demo,
+        axesNames: axesNames,
+      }).call(undefined, undefined, {processed: false});
+
+      const view = grok.shell.tv;
+
+      const description = `Molecules: ${molecules.name}, activities: ${activities.name}, method: ${methodName}, ${options ? `options: ${JSON.stringify(options)},` : ``} similarity: ${similarityMetric}, similarity cutoff: ${similarity}`;
+      view.addViewer(DG.VIEWER.SCATTER_PLOT, {
+        xColumnName: axesNames[0],
+        yColumnName: axesNames[1],
+        color: activities.name,
+        showXSelector: false,
+        showYSelector: false,
+        showSizeSelector: false,
+        showColorSelector: false,
+        markerMinSize: 5,
+        markerMaxSize: 25,
+        title: 'Activity cliffs',
+        initializationFunction: 'seqActivityCliffsInitFunction',
+        description: description,
+        descriptionVisibilityMode: 'Never',
+      }) as DG.ScatterPlotViewer;
+    };
+
     const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
-    const scRes = (await new Promise<DG.Viewer | undefined>((resolve, reject) => {
+    try {
       if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
-        ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
+        await new Promise<void>((resolve, reject) => {
+          ui.dialog().add(ui.divText(`Activity cliffs analysis might take several minutes.
     Do you want to continue?`))
-          .onOK(async () => {
-            runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
-          })
-          .onCancel(() => { resolve(undefined); })
-          .show();
+            .onOK(async () => {
+              runCliffs().then(() => resolve()).catch((err) => reject(err));
+            })
+            .onCancel(() => { resolve(); })
+            .show();
+        });
       } else
-        runCliffs().then((res) => resolve(res)).catch((err) => reject(err));
-    }).catch((err: any) => {
+        await runCliffs();
+    } catch (err: any) {
       const [errMsg, errStack] = errInfo(err);
       _package.logger.error(errMsg, undefined, errStack);
       throw err;
-    }).finally(() => { pi.close(); })) as DG.ScatterPlotViewer | undefined;
-    if (scRes?.props?.xColumnName && scRes?.props?.yColumnName && table.col(scRes.props.xColumnName) && table.col(scRes.props.yColumnName)) {
-    table.col(scRes.props.xColumnName)!.set(0, table.col(scRes.props.xColumnName)!.get(0)); // to trigger rendering
-    table.col(scRes.props.yColumnName)!.set(0, table.col(scRes.props.yColumnName)!.get(0)); // to trigger rendering
+    } finally {
+      pi.close();
     }
+  }
 
-    return scRes;
+  @grok.decorators.func({
+    name: 'seqActivityCliffsInitFunction',
+  })
+  static async seqActivityCliffsInitFunction(
+    @grok.decorators.param({type: 'viewer'}) sp: DG.ScatterPlotViewer): Promise<void> {
+    const tag = sp.dataFrame.getTag('seqActivityCliffsParams');
+    if (!tag) {
+      grok.shell.error(`Sequence activity cliffs parameters not found in table tags`);
+      return;
+    }
+    const actCliffsParams: SeqActivityCliffsParams = JSON.parse(tag);
+    const molCol = sp.dataFrame.col(actCliffsParams.seqColName)!
+    const actCol = sp.dataFrame.col(actCliffsParams.activityColName)!;
+
+    const preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
+    const encodedColWithOptions = await preprocessingFunction.apply({
+      col: molCol, metric: actCliffsParams.similarityMetric,
+    });
+
+    const axesNames = [sp.getOptions().look['xColumnName'], sp.getOptions().look['yColumnName']];
+    const tags = {
+      'units': molCol.meta.units!,
+      'aligned': molCol.getTag(bioTAGS.aligned),
+      'separator': molCol.getTag(bioTAGS.separator),
+      'alphabet': molCol.getTag(bioTAGS.alphabet),
+    };
+
+    await runActivityCliffs(sp, sp.dataFrame, molCol, encodedColWithOptions, actCol, axesNames,
+      actCliffsParams.similarity, actCliffsParams.similarityMetric, actCliffsParams.options ?? {},
+      DG.SEMTYPE.MACROMOLECULE, tags,
+      createTooltipElement, createPropPanelElement, createLinesGrid, undefined, actCliffsParams.isDemo);
+  }
+
+  @grok.decorators.func({
+    meta: {role: 'transform'},
+  })
+  static async seqActivityCliffsTransform(
+    @grok.decorators.param({options: {description: 'Input data table'}}) table: DG.DataFrame,
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}}) molecules: DG.Column,
+    @grok.decorators.param({type: 'column', options: {type: 'numerical'}}) activities: DG.Column,
+    @grok.decorators.param({options: {description: 'Similarity cutoff', initialValue: '80'}}) similarity: number,
+    @grok.decorators.param({type: 'string'}) methodName: DimReductionMethods,
+    @grok.decorators.param({type: 'string'}) similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics,
+    @grok.decorators.param({options: {optional: true}}) options?: string,
+    @grok.decorators.param({options: {optional: true}}) isDemo?: boolean,
+    @grok.decorators.param({options: {optional: true}}) axesNames?: string[]): Promise<void> {
+    await table.meta.detectSemanticTypes();  
+    const preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
+    if (!axesNames)
+      axesNames = getEmbeddingColsNames(table);
+    await getActivityCliffsEmbeddings(table, molecules, axesNames, similarity,
+      similarityMetric, methodName, JSON.parse(options ?? '{}'), preprocessingFunction);
+    const tagContent: SeqActivityCliffsParams = {
+      seqColName: molecules.name,
+      activityColName: activities.name,
+      similarityMetric: similarityMetric,
+      similarity: similarity,
+      options: options ?? {},
+      isDemo: isDemo,
+    };
+    table.setTag('seqActivityCliffsParams', JSON.stringify(tagContent));
   }
 
   @grok.decorators.func({
@@ -644,7 +708,7 @@ export class PackageFunctions {
     description: 'Creates 2D sequence space with projected sequences by pairwise distance',
     'top-menu': 'Bio | Analyze | Sequence Space...',
     editor: 'Bio:SequenceSpaceEditor',
-    outputs: [],
+    outputs: [{type: 'viewer', name: 'result'}],
   })
   static async sequenceSpaceTopMenu(
     table: DG.DataFrame,
@@ -662,22 +726,65 @@ export class PackageFunctions {
       grok.shell.error(`Table ${table.name} is not a current table view`);
       return;
     }
-    const tableView =
-      grok.shell.tv.dataFrame == table ? grok.shell.tv : undefined;
     if (!checkInputColumnUI(molecules, 'Sequence Space'))
       return;
-    if (!preprocessingFunction)
-      preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
-    options ??= {};
+    const clusterColName = table.columns.getUnusedName('Cluster (DBSCAN)');
+    const embedColsNames: string[] = getEmbeddingColsNames(table);
+    await DG.Func.find({name: 'sequenceSpaceTransform'})[0].prepare({
+      table: table,
+      molecules: molecules,
+      methodName: methodName,
+      similarityMetric: similarityMetric,
+      plotEmbeddings: false,
+      options: JSON.stringify(options),
+      clusterEmbeddings: clusterEmbeddings,
+      embedColsNames: embedColsNames,
+      clusterColName: clusterColName,
+    }).call(undefined, undefined, {processed: false});
+
+    let res: DG.ScatterPlotViewer | undefined;
+    if (plotEmbeddings) {
+      const tv = grok.shell.tv;
+      res = tv.scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
+      const description = `Molecules column: ${molecules.name}, method: ${methodName}, ${options ? `options: ${JSON.stringify(options)},` : ``} similarity: ${similarityMetric}`;
+      res.setOptions({description: description, descriptionVisibilityMode: 'Never'});
+      if (clusterEmbeddings)
+        res.props.colorColumnName = clusterColName;
+    }
+    return res;
+  }
+
+  @grok.decorators.func({
+    outputs: [{type: 'viewer', name: 'result'}],
+    meta: {role: 'transform'},
+  })
+  static async sequenceSpaceTransform(
+    table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) molecules: DG.Column,
+    @grok.decorators.param({type: 'string'}) methodName: DimReductionMethods,
+    @grok.decorators.param({type: 'string'}) similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames,
+    @grok.decorators.param({options: {initialValue: 'true'}}) plotEmbeddings: boolean,
+    @grok.decorators.param({options: {optional: true}}) options?: string,
+    @grok.decorators.param({options: {optional: true}}) clusterEmbeddings?: boolean,
+    @grok.decorators.param({options: {optional: true}}) embedColsNames?: string[],
+    @grok.decorators.param({options: {optional: true}}) clusterColName?: string,
+  ): Promise<DG.ScatterPlotViewer | undefined> {
+    await table.meta.detectSemanticTypes();
+    const preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
+    const parsedOptions: any = JSON.parse(options ?? '{}');
+    const tableView =
+      grok.shell.tv?.dataFrame == table ? grok.shell.tv : undefined;
     const res = await multiColReduceDimensionality(table, [molecules], methodName,
       [similarityMetric as KnownMetrics], [1], [preprocessingFunction], 'MANHATTAN',
       plotEmbeddings, clusterEmbeddings ?? false,
-      /* dimRedOptions */ {...options, preprocessingFuncArgs: [options.preprocessingFuncArgs ?? {}]},
+      /* dimRedOptions */ {...parsedOptions, preprocessingFuncArgs: [parsedOptions.preprocessingFuncArgs ?? {}]},
       /* uiOptions */{
         fastRowCount: 10000,
         scatterPlotName: 'Sequence space',
-        bypassLargeDataWarning: options?.[BYPASS_LARGE_DATA_WARNING],
+        bypassLargeDataWarning: parsedOptions?.[BYPASS_LARGE_DATA_WARNING],
         tableView: tableView,
+        embedColsNames: embedColsNames,
+        clusterColName: clusterColName,
       });
     return res;
   }

package/src/tests/projects-tests.ts

@@ -0,0 +1,202 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {after, awaitCheck, category, delay, expect, test} from '@datagrok-libraries/test/src/test';
+import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+
+import {readDataframe} from './utils';
+
+
+category('projects', () => {
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings;
+
+  async function createTableView(tableName: string): Promise<DG.TableView> {
+    const df = await readDataframe(tableName);
+    df.name = tableName.replace('.csv', '');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+    return view;
+  }
+
+  async function saveAndOpenProject(tv: DG.TableView, dataSync?: boolean): Promise<void> {
+    const project = DG.Project.create();
+    const tableInfo = tv.dataFrame.getTableInfo();
+    if (dataSync) {
+      //@ts-ignore
+      tableInfo.tags[DG.Tags.DataSync] = 'sync';
+      //@ts-ignore
+      tableInfo.tags[DG.Tags.CreationScript] = grok.shell.tv.dataFrame.getTag(DG.Tags.CreationScript);
+    }
+    const layoutInfo = tv.getInfo();
+    project.addChild(tableInfo);
+    project.addChild(layoutInfo);
+    await grok.dapi.tables.uploadDataFrame(tv.dataFrame);
+    await grok.dapi.tables.save(tableInfo);
+    await grok.dapi.views.save(layoutInfo);
+    await grok.dapi.projects.save(project);
+    const projId = project.id;
+    grok.shell.closeAll();
+    const p = await grok.dapi.projects.find(projId);
+    await p.open();
+  }
+
+  async function dataFrameContainsColumns(colArr: string[]): Promise<void> {
+    let col = '';
+    const getError = () => `${col} hasn't been added to dataframe`;
+    await awaitCheck(() => {
+      if (!grok.shell.tv.dataFrame)
+        return false;
+      for (const colName of colArr) {
+        if (!grok.shell.tv.dataFrame.col(colName)) {
+          col = colName;
+          return false;
+        }
+      }
+      return true;
+    }, getError(), 5000);
+  }
+
+  async function checkViewerAdded(viewerType: string): Promise<void> {
+    await awaitCheck(() => {
+      for (const v of grok.shell.tv.viewers) {
+        if (v.type === viewerType)
+          return true;
+      }
+      return false;
+    }, `${viewerType} hasn\'t been added`, 5000);
+  }
+
+  async function runSaveAndOpenProjectTest(tableName: string, analysisFunc: (tv: DG.TableView) => Promise<void>,
+    colList: string[], viewerType: string, dataSync?: boolean,
+    additionalChecks?: (tv: DG.TableView) => Promise<void>) {
+    let tv;
+    if (dataSync) {
+      await DG.Func.find({name: 'OpenFile'})[0].prepare({
+        fullPath: `System:AppData/Bio/${tableName}`,
+      }).call(undefined, undefined, {processed: false});
+      tv = grok.shell.tv;
+      await grok.data.detectSemanticTypes(tv.dataFrame);
+    } else
+      tv = await createTableView(tableName);
+    await delay(100);
+    await analysisFunc(tv);
+    await delay(10);
+    await saveAndOpenProject(tv, dataSync);
+    await delay(10);
+    await dataFrameContainsColumns(colList);
+    if (viewerType)
+      await checkViewerAdded(viewerType);
+    if (additionalChecks)
+      await additionalChecks(tv);
+  }
+
+  async function runSequenceSpace(tv: DG.TableView): Promise<void> {
+    const seqCol = tv.dataFrame.col('sequence')!;
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+    await DG.Func.find({package: 'Bio', name: 'sequenceSpaceTopMenu'})[0].prepare({
+      table: tv.dataFrame,
+      molecules: seqCol,
+      methodName: 'UMAP',
+      similarityMetric: MmDistanceFunctionsNames.LEVENSHTEIN,
+      plotEmbeddings: true,
+      options: {[BYPASS_LARGE_DATA_WARNING]: true},
+      clusterEmbeddings: true,
+    }).call(undefined, undefined, {processed: false});
+    await delay(10);
+  }
+
+  async function runActivityCliffs(tv: DG.TableView): Promise<void> {
+    const seqCol = tv.dataFrame.col('sequence')!;
+    const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+    if (semType)
+      seqCol.semType = semType;
+    await DG.Func.find({package: 'Bio', name: 'activityCliffs'})[0].prepare({
+      table: tv.dataFrame,
+      molecules: seqCol,
+      activities: tv.dataFrame.col('Activity'),
+      similarity: 90,
+      methodName: 'UMAP',
+      similarityMetric: MmDistanceFunctionsNames.LEVENSHTEIN,
+      preprocessingFunction: DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0],
+      options: {[BYPASS_LARGE_DATA_WARNING]: true},
+    }).call(undefined, undefined, {processed: false});
+    await delay(10);
+  }
+
+  async function checkActivityCliffsInit(tv: DG.TableView): Promise<void> {
+    let sp: DG.Viewer | null = null;
+    for (const v of grok.shell.tv.viewers) {
+      if (v.type === DG.VIEWER.SCATTER_PLOT)
+        sp = v;
+    }
+    await awaitCheck(() => {
+      const link = sp?.root.getElementsByClassName('scatter_plot_link');
+      return !link || !link.length ? false : (link[0] as HTMLElement).innerText.toLowerCase().includes('cliffs');
+    }, 'Initialization function hasn\'t been applied on scatter plot', 5000);
+  }
+
+  test('sequence_space', async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    await monomerLibHelper.loadMonomerLibForTests();
+
+    await runSaveAndOpenProjectTest('tests/100_3_clustests.csv', runSequenceSpace,
+      ['sequence', 'Embed_X_1', 'Embed_Y_1', 'Cluster (DBSCAN)'], DG.VIEWER.SCATTER_PLOT);
+    await delay(100);
+
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  }, {timeout: 60000});
+
+  test('sequence_space_sync', async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    await monomerLibHelper.loadMonomerLibForTests();
+
+    await runSaveAndOpenProjectTest('tests/100_3_clustests.csv', runSequenceSpace,
+      ['sequence', 'Embed_X_1', 'Embed_Y_1', 'Cluster (DBSCAN)'], DG.VIEWER.SCATTER_PLOT, true);
+    await delay(100);
+
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  }, {timeout: 60000});
+
+  test('activity_cliffs', async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    await monomerLibHelper.loadMonomerLibForTests();
+
+    await runSaveAndOpenProjectTest('tests/100_3_clustests.csv', runActivityCliffs,
+      ['sequence', 'Activity', 'Embed_X_1', 'Embed_Y_1'],
+      DG.VIEWER.SCATTER_PLOT, false, checkActivityCliffsInit);
+    await delay(100);
+
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  }, {timeout: 60000});
+
+  test('activity_cliffs_sync', async () => {
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    await monomerLibHelper.loadMonomerLibForTests();
+
+    await runSaveAndOpenProjectTest('tests/100_3_clustests.csv', runActivityCliffs,
+      ['sequence', 'Activity', 'Embed_X_1', 'Embed_Y_1'],
+      DG.VIEWER.SCATTER_PLOT, true, checkActivityCliffsInit);
+    await delay(100);
+
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  }, {timeout: 60000});
+
+  after(async () => {
+    grok.shell.closeAll();
+  });
+});