@datagrok/bio 2.4.29 → 2.4.31

package/dockerfiles/Dockerfile

@@ -24,7 +24,7 @@ RUN savedAptMark="$(apt-mark showmanual)" ; \
     ; \
     apt-mark auto '.*' > /dev/null ; \
     [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark ; \
-	wget https://mafft.cbrc.jp/alignment/software/mafft_7.511-1_amd64.deb -O mafft.deb; \
+	wget https://mafft.cbrc.jp/alignment/software/mafft_7.520-1_amd64.deb -O mafft.deb; \
 	apt install -y ./mafft.deb; \
 	rm -rf mafft.deb; \
     wget https://github.com/Merck/PepSeA/archive/refs/heads/main.zip -O PepSeA.zip; \

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.29",
+  "version": "2.4.31",
   "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",
@@ -16,9 +16,9 @@
     "@biowasm/aioli": "^3.1.0",
     "@datagrok-libraries/bio": "^5.30.0",
     "@datagrok-libraries/chem-meta": "^1.0.1",
-    "@datagrok-libraries/ml": "^6.3.23",
+    "@datagrok-libraries/ml": "^6.3.27",
     "@datagrok-libraries/tutorials": "^1.3.2",
-    "@datagrok-libraries/utils": "^2.1.3",
+    "@datagrok-libraries/utils": "^4.0.8",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
     "datagrok-api": "^1.13.3",

package/scripts/sequence_generator.py

@@ -3,8 +3,8 @@
 # description: Create the model peptides/DNA sequences with peptides data
 # language: python
 # tags: template, demo
-# input: int clusters = 1 [Number of superclusters]
-# input: int num_sequences = 500 [Number of sequences in each supercluster]
+# input: int clusters = 5 [Number of superclusters]
+# input: int num_sequences = 50 [Number of sequences in each supercluster]
 # input: int motif_length = 12 [Average length of motif]
 # input: int max_variants_position = 3 [Maximum number of different letters in conservative position in motif]
 # input: int random_length = 3 [Average length of random sequence parts before and after motif]
@@ -59,7 +59,9 @@ def generate_motif_template(
 
 
 def generate_motif(template: motif_template_type, alphabet: alphabet_type) -> str:
-    template_with_any = [(letters if not "?" in letters else alphabet) for letters in template]
+    template_with_any = [
+        (letters if not "?" in letters else alphabet) for letters in template
+    ]
     return "".join([random.choice(letters) for letters in template_with_any])
 
 
@@ -70,18 +72,24 @@ def motif_notation(motif_template: motif_template_type) -> str:
         else:
             return f"[{''.join(letter_choice)}]"
 
-    return "".join([motif_notation_code(letter_choice) for letter_choice in motif_template])
+    return "".join(
+        [motif_notation_code(letter_choice) for letter_choice in motif_template]
+    )
 
 
 def generate_random(n: int, alphabet: alphabet_type) -> str:
     return "".join([random.choice(alphabet) for i in range(n)])
 
 
-def make_cliff(motif_template: motif_template_type, alphabet: alphabet_type, motif: str) -> str:
+def make_cliff(
+    motif_template: motif_template_type, alphabet: alphabet_type, motif: str
+) -> str:
     # Mutate conservative letter in motif
     pos = random.randrange(len(motif_template))
     while "?" in motif_template[pos]:
-        pos = (pos + 1) % len(motif_template)  # always will find letters since ends of motif can't be any symbol
+        pos = (pos + 1) % len(
+            motif_template
+        )  # always will find letters since ends of motif can't be any symbol
     outlier_letters = list(set(alphabet) - set(motif_template[pos]))
     return motif[:pos] + random.choice(outlier_letters) + motif[pos + 1 :]
 
@@ -97,7 +105,9 @@ def generate_cluster(
     cliff_probability: float,
     cliff_strength: float,
 ) -> Iterator[sequence_record_type]:
-    motif_template = generate_motif_template(motif_length, alphabet, max_variants_position)
+    motif_template = generate_motif_template(
+        motif_length, alphabet, max_variants_position
+    )
 
     activity_average = random.random() * 10
     activity_dispersion = random.random()
@@ -166,7 +176,9 @@ def generate_sequences(
             cliff_probability,
             cliff_strength,
         ):
-            sequences.append((n_cluster, f"c{n_cluster}_s{n_seq}", seq, activity, is_cliff))
+            sequences.append(
+                (n_cluster, f"c{n_cluster}_s{n_seq}", seq, activity, is_cliff)
+            )
     return headers, sequences
 
 
@@ -178,15 +190,19 @@ def parse_command_line_args() -> Any:
         epilog="Utility support: Gennadii Zakharov",
     )
 
-    parser.add_argument("-c", "--clusters", type=int, default=1, help="Number of superclusters")
+    parser.add_argument(
+        "-c", "--clusters", type=int, default=5, help="Number of superclusters"
+    )
     parser.add_argument(
         "-s",
         "--sequences",
         type=int,
-        default=500,
+        default=50,
         help="Number of sequences in each supercluster",
     )
-    parser.add_argument("-m,", "--motif-length", type=int, default=12, help="Average length of motif")
+    parser.add_argument(
+        "-m,", "--motif-length", type=int, default=12, help="Average length of motif"
+    )
 
     parser.add_argument(
         "-r,",
@@ -208,7 +224,8 @@ def parse_command_line_args() -> Any:
         "--alphabet",
         type=str,
         default=list(alphabets.keys())[0],
-        help=f"Sequence alphabet: {available_alphabets}. Custom alphabet is a list of values separated " f"by comma",
+        help=f"Sequence alphabet: {available_alphabets}. Custom alphabet is a list of values separated "
+        f"by comma",
     )
     parser.add_argument(
         "--max-variants-position",
@@ -258,7 +275,11 @@ if not grok:
     cliff_probability = args.cliff_probability
     cliff_strength = args.cliff_strength
 
-alphabet: alphabet_type = alphabets[alphabet_key].split(",") if alphabet_key in alphabets else alphabet_key.split(",")
+alphabet: alphabet_type = (
+    alphabets[alphabet_key].split(",")
+    if alphabet_key in alphabets
+    else alphabet_key.split(",")
+)
 
 # Running sequence generator
 header, data = generate_sequences(

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

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {ITooltipAndPanelParams} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {getSimilarityFromDistance} from '@datagrok-libraries/ml/src/distance-metrics-methods';
-import {AvailableMetrics, AvailableMetricsTypes, StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
+import {AvailableMetrics, DistanceMetricsSubjects, StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {drawMoleculeDifferenceOnCanvas} from '../utils/cell-renderer';
 import * as C from '../utils/constants';
 import {GridColumn} from 'datagrok-api/dg';
@@ -15,7 +15,7 @@ export async function getDistances(col: DG.Column, seq: string): Promise<Array<n
   const stringArray = col.toList();
   const distances = new Array(stringArray.length).fill(0);
   const distanceMethod: (x: string, y: string) => number =
-    AvailableMetrics[AvailableMetricsTypes.String][StringMetricsNames.Levenshtein];
+    AvailableMetrics[DistanceMetricsSubjects.String][StringMetricsNames.Levenshtein];
   for (let i = 0; i < stringArray.length; ++i) {
     const distance = stringArray[i] ? distanceMethod(stringArray[i], seq) : null;
     distances[i] = distance ? distance / Math.max((stringArray[i] as string).length, seq.length) : null;

package/src/analysis/sequence-diversity-viewer.ts

@@ -2,14 +2,13 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
-import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {getDiverseSubset} from '@datagrok-libraries/utils/src/similarity-metrics';
-import $ from 'cash-dom';
-import {ArrayUtils} from '@datagrok-libraries/utils/src/array-utils';
 import {SequenceSearchBaseViewer} from './sequence-search-base-viewer';
 import {getMonomericMols} from '../calculations/monomerLevelMols';
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
+import {calcMmDistanceMatrix, dmLinearIndex} from './workers/mm-distance-worker-creator';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
   diverseColumnLabel: string | null; // Use postfix Label to prevent activating table column selection editor
@@ -28,15 +27,9 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
       return;
     if (this.dataFrame) {
       if (computeData && this.moleculeColumn) {
-        const monomericMols = await getMonomericMols(this.moleculeColumn);
-        //need to create df to calculate fingerprints
-        const monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
-        this.renderMolIds = await grok.functions.call('Chem:callChemDiversitySearch', {
-          col: monomericMols,
-          metricName: this.distanceMetric,
-          limit: this.limit,
-          fingerprint: this.fingerprint
-        });
+        const uh = new UnitsHandler(this.moleculeColumn);
+        await (uh.isFasta() ? this.computeByMM() : this.computeByChem());
+
         const diverseColumnName: string = this.diverseColumnLabel != null ? this.diverseColumnLabel :
           `diverse (${this.moleculeColumnName})`;
         const resCol = DG.Column.string(diverseColumnName, this.renderMolIds!.length)
@@ -49,4 +42,24 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
       }
     }
   }
+
+  private async computeByChem() {
+    const monomericMols = await getMonomericMols(this.moleculeColumn!);
+    //need to create df to calculate fingerprints
+    const _monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
+    this.renderMolIds = await grok.functions.call('Chem:callChemDiversitySearch', {
+      col: monomericMols,
+      metricName: this.distanceMetric,
+      limit: this.limit,
+      fingerprint: this.fingerprint
+    });
+  }
+
+  private async computeByMM() {
+    const distanceMatrixData = await calcMmDistanceMatrix(this.moleculeColumn!);
+    const len = this.moleculeColumn!.length;
+    const linearizeFunc = dmLinearIndex(len);
+    this.renderMolIds = getDiverseSubset(len, Math.min(len, this.limit),
+      (i1: number, i2: number) => distanceMatrixData[linearizeFunc(i1, i2)]);
+  }
 }

package/src/analysis/sequence-similarity-viewer.ts

@@ -9,6 +9,8 @@ import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence
 import {updateDivInnerHTML} from '../utils/ui-utils';
 import {Subject} from 'rxjs';
 import {TAGS as bioTAGS, getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {calcMmDistanceMatrix, dmLinearIndex} from './workers/mm-distance-worker-creator';
 
 export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
   cutoff: number;
@@ -23,6 +25,8 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
   gridSelect: boolean = false;
   targetMoleculeIdx: number = 0;
   computeCompleted = new Subject<boolean>();
+  distanceMatrixComputed: boolean = false;
+  mmDistanceMatrix: Float32Array;
 
   constructor() {
     super('similarity');
@@ -43,20 +47,9 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
       this.curIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
       if (computeData && !this.gridSelect) {
         this.targetMoleculeIdx = this.dataFrame!.currentRowIdx == -1 ? 0 : this.dataFrame!.currentRowIdx;
-        const monomericMols = await getMonomericMols(this.moleculeColumn);
-        //need to create df to calculate fingerprints
-        const monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
-        const df = await grok.functions.call('Chem:callChemSimilaritySearch', {
-          df: this.dataFrame,
-          col: monomericMols,
-          molecule: monomericMols.get(this.targetMoleculeIdx),
-          metricName: this.distanceMetric,
-          limit: this.limit,
-          minScore: this.cutoff,
-          fingerprint: this.fingerprint
-        });
-        this.idxs = df.getCol('indexes');
-        this.scores = df.getCol('score');
+        const uh = new UnitsHandler(this.moleculeColumn!);
+
+        await (uh.isFasta() ? this.computeByMM() : this.computeByChem());
         const similarColumnName: string = this.similarColumnLabel != null ? this.similarColumnLabel :
           `similar (${this.moleculeColumnName})`;
         this.molCol = DG.Column.string(similarColumnName,
@@ -83,15 +76,51 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
     }
   }
 
+  private async computeByChem() {
+    const monomericMols = await getMonomericMols(this.moleculeColumn!);
+    //need to create df to calculate fingerprints
+    const _monomericMolsDf = DG.DataFrame.fromColumns([monomericMols]);
+    const df = await grok.functions.call('Chem:callChemSimilaritySearch', {
+      df: this.dataFrame,
+      col: monomericMols,
+      molecule: monomericMols.get(this.targetMoleculeIdx),
+      metricName: this.distanceMetric,
+      limit: this.limit,
+      minScore: this.cutoff,
+      fingerprint: this.fingerprint
+    });
+    this.idxs = df.getCol('indexes');
+    this.scores = df.getCol('score');
+  }
+
+  private async computeByMM() {
+    if (!this.distanceMatrixComputed) {
+      this.mmDistanceMatrix = await calcMmDistanceMatrix(this.moleculeColumn!);
+      this.distanceMatrixComputed = true;
+    }
+    const len = this.moleculeColumn!.length;
+    const linearizeFunc = dmLinearIndex(len);
+    // array that keeps track of the indexes and scores together
+    const indexWScore = Array(len).fill(0)
+      .map((_, i) => ({idx: i, score: i === this.targetMoleculeIdx ? 1 :
+        1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)]}));
+    indexWScore.sort((a, b) => b.score - a.score);
+    // get the most similar molecules
+    const actualLimit = Math.min(this.limit, len);
+    const mostSimilar = indexWScore.slice(0, actualLimit);
+    this.idxs = DG.Column.int('indexes', actualLimit).init((i) => mostSimilar[i].idx);
+    this.scores = DG.Column.float('score', actualLimit).init((i) => mostSimilar[i].score);
+  }
 
   createPropertyPanel(resDf: DG.DataFrame) {
     const propPanel = ui.div();
     const molDifferences: { [key: number]: HTMLCanvasElement } = {};
-    const units = resDf.col('sequence')!.getTag(DG.TAGS.UNITS);
-    const separator = resDf.col('sequence')!.getTag(bioTAGS.separator);
+    const molColName = this.molCol?.name!;
+    const units = resDf.col(molColName)!.getTag(DG.TAGS.UNITS);
+    const separator = resDf.col(molColName)!.getTag(bioTAGS.separator);
     const splitter = getSplitter(units, separator);
     const subParts1 = splitter(this.moleculeColumn!.get(this.targetMoleculeIdx));
-    const subParts2 = splitter(resDf.get('sequence', resDf.currentRowIdx));
+    const subParts2 = splitter(resDf.get(molColName, resDf.currentRowIdx));
     const canvas = createDifferenceCanvas(subParts1, subParts2, units, molDifferences);
     propPanel.append(ui.div(canvas, {style: {width: '300px', overflow: 'scroll'}}));
     if (subParts1.length !== subParts2.length) {

package/src/analysis/sequence-space.ts

@@ -44,7 +44,7 @@ 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);
+    await invalidateMols(spaceParams.seqCol as unknown as DG.Column<string>, false); //we expect only string columns here
 
   const result = await grok.functions.call('Chem:getChemSpaceEmbeddings', {
     col: spaceParams.seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],

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

@@ -0,0 +1,31 @@
+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 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 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);
+    };
+  });
+}
+
+// gets index of compressed distance matrix from 2d coordinates
+export function dmLinearIndex(size: number) {
+  return (i: number, j: number) => {
+    const getLinearIndex = (i: number, j: number) => {
+      return size * i + j - Math.floor(((i + 2) * (i + 1)) / 2);
+    };
+    if (i <= j) return getLinearIndex(i, j);
+    else return getLinearIndex(j, i);
+  };
+}

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

@@ -0,0 +1,16 @@
+import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/distance-matrix';
+import {mmDistanceFunctions, MmDistanceFunctionsNames}
+  from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+
+onmessage = (event) => {
+  const {values, fnName} = event.data;
+  const data: { error?: any; distanceMatrixData?: Float32Array } = {};
+  try {
+    const distanceMatrix = DistanceMatrix.calc(values, mmDistanceFunctions[fnName as MmDistanceFunctionsNames]());
+    distanceMatrix.normalize();
+    data.distanceMatrixData = distanceMatrix.data;
+  } catch (e) {
+    data.error = e;
+  }
+  postMessage(data);
+};

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

@@ -12,6 +12,7 @@ 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';
 
 const dataFn: string = 'data/sample_FASTA_PT_activity.csv';
 
@@ -23,7 +24,7 @@ export async function demoBio01bUI() {
   let view: DG.TableView;
   let activityCliffsViewer: DG.ScatterPlotViewer;
 
-  const dimRedMethod: string = 'UMAP';
+  const dimRedMethod: DimReductionMethods = DimReductionMethods.UMAP;
   const idRows: { [id: number]: number } = {};
 
   try {

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(
@@ -52,7 +53,7 @@ export async function demoBio05UI(): Promise<void> {
       })
       .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.',

package/src/demo/utils.ts

@@ -6,6 +6,8 @@ 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',
@@ -63,7 +65,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.ts

@@ -10,7 +10,7 @@ import {
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
 import {SequenceAlignment} from './seq_align';
 import {getEmbeddingColsNames, sequenceSpaceByFingerprints, getSequenceSpace} from './analysis/sequence-space';
-import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
+import {ISequenceSpaceParams, getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {
   createLinesGrid,
   createPropPanelElement,
@@ -43,7 +43,7 @@ import {
   LIB_STORAGE_NAME, LibSettings, getUserLibSettings, setUserLibSetting, getLibFileNameList
 } from './utils/monomer-lib';
 import {getMacromoleculeColumn} from './utils/ui-utils';
-import {ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {DimReductionMethods, ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
 import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
 import {demoBio01UI} from './demo/bio01-similarity-diversity';
@@ -53,6 +53,8 @@ import {demoBio03UI} from './demo/bio03-atomic-level';
 import {demoBio05UI} from './demo/bio05-helm-msa-sequence-space';
 import {checkInputColumnUI} from './utils/check-input-column';
 import {multipleSequenceAlignmentUI} from './utils/multiple-sequence-alignment-ui';
+import { MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import { BitArrayMetrics, BitArrayMetricsNames, StringMetricsNames } from '@datagrok-libraries/ml/src/typed-metrics';
 import { NotationConverter } from '@datagrok-libraries/bio/src/utils/notation-converter';
 
 export const _package = new DG.Package();
@@ -280,7 +282,7 @@ export function SeqActivityCliffsEditor(call: DG.FuncCall) {
 //output: viewer result
 //editor: Bio:SeqActivityCliffsEditor
 export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
-  similarity: number, methodName: string, options?: IUMAPOptions | ITSNEOptions
+  similarity: number, methodName: DimReductionMethods, options?: IUMAPOptions | ITSNEOptions
 ): Promise<DG.Viewer | undefined> {
   if (!checkInputColumnUI(macroMolecule, 'Activity Cliffs'))
     return;
@@ -292,7 +294,7 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     'alphabet': macroMolecule.getTag(bioTAGS.alphabet),
   };
   const nc = new NotationConverter(macroMolecule);
-  let columnDistanceMetric = 'Tanimoto';
+  let columnDistanceMetric: BitArrayMetricsNames | MmDistanceFunctionsNames = BitArrayMetricsNames.Tanimoto;
   let seqCol = macroMolecule;
   if (nc.isFasta() || (nc.isSeparator() && nc.alphabet && nc.alphabet !== ALPHABET.UN)){
     if (nc.isFasta()){
@@ -347,8 +349,8 @@ export function SequenceSpaceEditor(call: DG.FuncCall) {
 //input: bool plotEmbeddings = true
 //input: object options {optional: true}
 //editor: Bio:SequenceSpaceEditor
-export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
-  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions
+export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: DimReductionMethods,
+  similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames = BitArrayMetricsNames.Tanimoto, plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions
 ): Promise<DG.Viewer | undefined> {
   // Delay is required for initial function dialog to close before starting invalidating of molfiles.
   // Otherwise, dialog is freezing
@@ -360,7 +362,7 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
   const withoutEmptyValues = DG.DataFrame.fromColumns([macroMolecule]).clone();
   const emptyValsIdxs = removeEmptyStringRows(withoutEmptyValues, macroMolecule);
 
-  const chemSpaceParams = {
+  const chemSpaceParams: ISequenceSpaceParams = {
     seqCol: withoutEmptyValues.col(macroMolecule.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,

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

@@ -6,6 +6,7 @@ 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';
 
 
 category('activityCliffs', async () => {
@@ -33,7 +34,7 @@ category('activityCliffs', async () => {
     actCliffsTableView = grok.shell.addTableView(actCliffsDf);
     viewList.push(actCliffsTableView);
 
-    await _testActivityCliffsOpen(actCliffsDf, 57, 'UMAP', 'MSA');
+    await _testActivityCliffsOpen(actCliffsDf, 57, DimReductionMethods.UMAP, 'MSA');
   }, {skipReason: 'GROK-12774'});
 
   test('activityCliffsWithEmptyRows', async () => {
@@ -42,6 +43,6 @@ category('activityCliffs', async () => {
     actCliffsTableViewWithEmptyRows = grok.shell.addTableView(actCliffsDfWithEmptyRows);
     viewList.push(actCliffsTableViewWithEmptyRows);
 
-    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, 'UMAP', 'MSA');
+    await _testActivityCliffsOpen(actCliffsDfWithEmptyRows, 57, DimReductionMethods.UMAP, 'MSA');
   }, {skipReason: 'GROK-12774'});
 });

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

@@ -3,8 +3,9 @@ import * as grok from 'datagrok-api/grok';
 
 import {delay, expect} from '@datagrok-libraries/utils/src/test';
 import {activityCliffs} from '../package';
+import { DimReductionMethods } from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
-export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: string, colName: string) {
+export async function _testActivityCliffsOpen(df: DG.DataFrame, numberCliffs: number, method: DimReductionMethods, colName: string) {
   await grok.data.detectSemanticTypes(df);
   const scatterPlot = await activityCliffs(
     df, df.getCol(colName), df.getCol('Activity'),

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

@@ -5,6 +5,7 @@ import * as DG from 'datagrok-api/dg';
 import {after, before, category, test, expect, delay} 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';
 
 category('sequenceSpace', async () => {
   let testFastaDf: DG.DataFrame;
@@ -15,7 +16,7 @@ category('sequenceSpace', async () => {
   test('sequenceSpaceOpens', async () => {
     testFastaDf = await readDataframe('tests/sample_MSA_data.csv');
     testFastaTableView = grok.shell.addTableView(testFastaDf);
-    await _testSequenceSpaceReturnsResult(testFastaDf, 'UMAP', 'MSA');
+    await _testSequenceSpaceReturnsResult(testFastaDf, DimReductionMethods.UMAP, 'MSA');
     grok.shell.closeTable(testFastaDf);
     testFastaTableView.close();
   }, {skipReason: 'GROK-12775'});
@@ -23,7 +24,7 @@ category('sequenceSpace', async () => {
   test('sequenceSpaceWithEmptyRows', async () => {
     testHelmWithEmptyRows = await readDataframe('tests/sample_MSA_data_empty_vals.csv');
     testHelmWithEmptyRowsTableView = grok.shell.addTableView(testHelmWithEmptyRows);
-    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, 'UMAP', 'MSA');
+    await _testSequenceSpaceReturnsResult(testHelmWithEmptyRows, DimReductionMethods.UMAP, 'MSA');
     grok.shell.closeTable(testHelmWithEmptyRows);
     testHelmWithEmptyRowsTableView.close();
   }, {skipReason: 'GROK-12775'});

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

@@ -2,14 +2,16 @@ 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 { MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
+import { DimReductionMethods } from '@datagrok-libraries/ml/src/reduce-dimensionality';
 
-export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: string, colName: string) {
+export async function _testSequenceSpaceReturnsResult(df: DG.DataFrame, algorithm: DimReductionMethods, colName: string) {
   // await grok.data.detectSemanticTypes(df);
   const col: DG.Column = df.getCol(colName);
   const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: col});
   if (semType)
     col.semType = semType;
 
-  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, 'Levenshtein', true);
+  const sp = await sequenceSpaceTopMenu(df, df.col(colName)!, algorithm, MmDistanceFunctionsNames.LEVENSHTEIN, true);
   expect(sp != null, true);
 }

package/src/tests/viewers.ts

@@ -1,8 +1,8 @@
 import * as DG from 'datagrok-api/dg';
-// import * as grok from 'datagrok-api/grok';
+import * as grok from 'datagrok-api/grok';
 //import * as ui from 'datagrok-api/ui';
 
-import {category, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {category, delay, test, testViewer} from '@datagrok-libraries/utils/src/test';
 import {readDataframe} from './utils';
 
 
@@ -10,7 +10,12 @@ category('viewers', () => {
   const viewers = DG.Func.find({package: 'Bio', tags: ['viewer']}).map((f) => f.friendlyName);
   for (const v of viewers) {
     test(v, async () => {
-      await testViewer(v, await readDataframe('data/sample_FASTA_DNA.csv'), true);
+      const df = await readDataframe('data/sample_FASTA_DNA.csv');
+      const tv = grok.shell.addTableView(df);
+      await grok.data.detectSemanticTypes(df);
+      tv.addViewer(v);
+      await delay(2000);
+      // await testViewer(v, df, {detectSemanticTypes: true});
     });
   }
 });