@datagrok/bio 2.4.31 → 2.4.40

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.4.31",
+  "version": "2.4.40",
   "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",
@@ -14,11 +14,11 @@
   },
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.30.0",
+    "@datagrok-libraries/bio": "^5.32.1",
     "@datagrok-libraries/chem-meta": "^1.0.1",
-    "@datagrok-libraries/ml": "^6.3.27",
+    "@datagrok-libraries/ml": "^6.3.37",
     "@datagrok-libraries/tutorials": "^1.3.2",
-    "@datagrok-libraries/utils": "^4.0.8",
+    "@datagrok-libraries/utils": "^4.0.11",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
     "datagrok-api": "^1.13.3",

package/scripts/sequence_generator.py

@@ -13,21 +13,34 @@
 # input: bool disable_cliffs = False [Disable generation of cliffs]
 # input: double cliff_probability = 0.01 [Probability to make activity cliff of a sequence]
 # input: double cliff_strength = 4.0 [Strength of cliff]
+# input: double fasta_separator = '' [Separator for a FASTA notation]
 # output: dataframe sequences
 
 import random
 import argparse
 import sys
+from enum import Enum
 
 from typing import List, Tuple, Dict, Iterator, Any
 
-alphabet_type = List[str]
 
-letter_choice_type = List[str]
-motif_template_type = List[letter_choice_type]
+# --- Type definitions ---
 
-sequence_record_type = Tuple[int, str, float, bool]
-sequence_record_cluster_type = Tuple[int, str, str, float, bool]
+Letter = str
+Alphabet = List[str]
+
+LetterChoice = List[Letter]
+MotifTemplate = List[LetterChoice]
+
+Sequence = List[Letter]  # The sequence in a form of list
+SequenceSquashed = str  # Sequence, joined together in string form
+
+SequenceRecord = Tuple[int, Sequence, float, bool]
+ClusterSequenceRecord = Tuple[int, str, Sequence, float, bool]
+
+# --- constants ---
+
+HelmConnectionMode = Enum("HelmConnectionMode", ["linear", "cyclic", "mixed"])
 
 alphabets: Dict[str, str] = {
     "PT": "A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y",
@@ -42,10 +55,10 @@ def mean_range(mean: int, disp: int) -> int:
 
 def generate_motif_template(
     motif_length: int,
-    alphabet: alphabet_type,
+    alphabet: Alphabet,
     max_variants_cluster: int,
     prob_any: float = 0.2,
-) -> motif_template_type:
+) -> MotifTemplate:
     motif_template = []
     for position in range(motif_length):
         # Selecting letters for position i
@@ -53,20 +66,20 @@ def generate_motif_template(
             letters = ["?"]  # this stands for any symbol
         else:
             n_variants = random.randrange(max_variants_cluster) + 1
-            letters = [random.choice(alphabet) for i in range(n_variants)]
+            letters = list(set((random.choice(alphabet) for i in range(n_variants))))
         motif_template.append(letters)
     return motif_template
 
 
-def generate_motif(template: motif_template_type, alphabet: alphabet_type) -> str:
+def generate_motif(template: MotifTemplate, alphabet: Alphabet) -> Sequence:
     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])
+    return [random.choice(letters) for letters in template_with_any]
 
 
-def motif_notation(motif_template: motif_template_type) -> str:
-    def motif_notation_code(letter_choice: letter_choice_type) -> str:
+def motif_notation(motif_template: MotifTemplate) -> str:
+    def motif_notation_code(letter_choice: LetterChoice) -> str:
         if len(letter_choice) == 1:
             return letter_choice[0]
         else:
@@ -77,21 +90,51 @@ def motif_notation(motif_template: motif_template_type) -> str:
     )
 
 
-def generate_random(n: int, alphabet: alphabet_type) -> str:
-    return "".join([random.choice(alphabet) for i in range(n)])
+def generate_random(n: int, alphabet: Alphabet) -> Sequence:
+    return [random.choice(alphabet) for i in range(n)]
 
 
 def make_cliff(
-    motif_template: motif_template_type, alphabet: alphabet_type, motif: str
-) -> str:
+    motif_template: MotifTemplate, alphabet: Alphabet, motif: Sequence
+) -> Sequence:
     # Mutate conservative letter in motif
-    pos = random.randrange(len(motif_template))
+    motif_len = len(motif_template)
+    pos = random.randrange(motif_len)
     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
+        ) % motif_len  # 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 :]
+    new_letter = random.choice(outlier_letters)
+    return (
+        motif[:pos]
+        + [
+            new_letter,
+        ]
+        + motif[pos + 1 :]
+    )
+
+
+def sequence_to_fasta(sequence: Sequence, separator: str) -> SequenceSquashed:
+    return separator.join(sequence)
+
+
+def sequence_to_helm(
+    sequence: Sequence, helm_connection_mode: str = HelmConnectionMode.linear.name
+) -> SequenceSquashed:
+    def is_cyclic(helm_connection_mode: str) -> bool:
+        return helm_connection_mode == HelmConnectionMode.cyclic.name or (
+            helm_connection_mode == HelmConnectionMode.mixed.name
+            and random.random() < 0.5
+        )
+
+    sequence_escaped: Sequence = [
+        f"[{letter}]" if len(letter) > 1 else letter for letter in sequence
+    ]
+    connection_format = ""
+    if is_cyclic(helm_connection_mode):
+        connection_format = f"PEPTIDE1,PEPTIDE1,{len(sequence_escaped)}:R2-1:R1"
+    return f"PEPTIDE1{{{sequence_to_fasta(sequence_escaped,'.')}}}${connection_format}$$$V2.0"
 
 
 def generate_cluster(
@@ -99,16 +142,17 @@ def generate_cluster(
     motif_length: int,
     prefix_length: int,
     suffix_length: int,
-    max_variants_position: int,
+    max_variants_per_position: int,
     make_cliffs: bool,
-    alphabet: alphabet_type,
+    alphabet: Alphabet,
     cliff_probability: float,
     cliff_strength: float,
-) -> Iterator[sequence_record_type]:
+) -> Iterator[SequenceRecord]:
+    # Making a motif template
     motif_template = generate_motif_template(
-        motif_length, alphabet, max_variants_position
+        motif_length, alphabet, max_variants_per_position
     )
-
+    # Setting average and dispersion for activity
     activity_average = random.random() * 10
     activity_dispersion = random.random()
     sys.stderr.write(f"Motif template: {motif_notation(motif_template)}\n")
@@ -120,11 +164,10 @@ def generate_cluster(
         prefix = generate_random(prefix_length, alphabet)
         suffix = generate_random(suffix_length, alphabet)
         seq = prefix + motif + suffix
-
-        is_cliff = make_cliffs and (random.random() <= cliff_probability)
-        sequence_record: sequence_record_type = (n_seq, seq, activity, is_cliff)
+        sequence_record: SequenceRecord = (n_seq, seq, activity, False)
         yield sequence_record
 
+        is_cliff = make_cliffs and (random.random() <= cliff_probability)
         if is_cliff:
             # Making activity cliff
             cliff_motif = make_cliff(motif_template, alphabet, motif)
@@ -146,16 +189,16 @@ def generate_sequences(
     n_clusters: int,
     n_sequences: int,
     average_motif_length: int,
-    max_variants_position: int,
+    max_variants_per_position: int,
     average_random_length: int,
     dispersion: int,
-    alphabet: alphabet_type,
+    alphabet: Alphabet,
     make_cliffs: bool,
     cliff_probability: float,
     cliff_strength: float,
-) -> Tuple[List[str], List[sequence_record_cluster_type]]:
+) -> Tuple[List[str], List[ClusterSequenceRecord]]:
     headers: List[str] = ["cluster", "sequence_id", "sequence", "activity", "is_cliff"]
-    sequences: List[sequence_record_cluster_type] = []
+    sequences: List[ClusterSequenceRecord] = []
 
     for n_cluster in range(n_clusters):
         motif_length = mean_range(average_motif_length, dispersion)
@@ -170,28 +213,71 @@ def generate_sequences(
             motif_length,
             prefix_length,
             suffix_length,
-            max_variants_position,
+            max_variants_per_position,
             make_cliffs,
             alphabet,
             cliff_probability,
             cliff_strength,
         ):
             sequences.append(
-                (n_cluster, f"c{n_cluster}_s{n_seq}", seq, activity, is_cliff)
+                (n_cluster, f"c{n_cluster}_s{n_seq:03d}", seq, activity, is_cliff)
             )
     return headers, sequences
 
 
+def convert_to_fasta(
+    cluster_sequence_records: List[ClusterSequenceRecord], separator: str
+) -> List[Tuple[int, str, str, float, bool]]:
+    return [
+        (n_cluster, name_cluster, sequence_to_fasta(seq, separator), activity, is_cliff)
+        for n_cluster, name_cluster, seq, activity, is_cliff in cluster_sequence_records
+    ]
+
+
+def convert_to_helm(
+    cluster_sequence_records: List[ClusterSequenceRecord], helm_connection_mode: str
+) -> List[Tuple[int, str, str, float, bool]]:
+    return [
+        (
+            n_cluster,
+            name_cluster,
+            sequence_to_helm(seq, helm_connection_mode),
+            activity,
+            is_cliff,
+        )
+        for n_cluster, name_cluster, seq, activity, is_cliff in cluster_sequence_records
+    ]
+
+
+def is_monomer_suitable(monomer: Any) -> bool:
+    return (
+        monomer["polymerType"] == "PEPTIDE"
+        and monomer["monomerType"] == "Backbone"
+        and len(monomer["rgroups"]) == 2
+    )
+
+
+def alphabet_from_helm(helm_library_file: str) -> Alphabet:
+    import json
+
+    alphabet: Alphabet = []
+    with open(helm_library_file) as helm_library:
+        for monomer in json.load(helm_library):
+            if is_monomer_suitable(monomer):
+                alphabet.append(monomer["symbol"])
+    return alphabet
+
+
 def parse_command_line_args() -> Any:
     parser = argparse.ArgumentParser(
         prog="MotifSequencesGenerator",
         description="The program generates set of sequences containing sequence motifs "
-        "for SAR fucntionality testing",
-        epilog="Utility support: Gennadii Zakharov",
+        "for SAR functionality testing",
+        epilog="Utility author and support: Gennadii Zakharov <Gennadiy.Zakharov@gmail.com>",
     )
 
     parser.add_argument(
-        "-c", "--clusters", type=int, default=5, help="Number of superclusters"
+        "-c", "--clusters", type=int, default=5, help="Number of clusters"
     )
     parser.add_argument(
         "-s",
@@ -219,6 +305,21 @@ def parse_command_line_args() -> Any:
         help="Variation of total sequence length",
     )
 
+    parser.add_argument(
+        "-h,",
+        "--helm-library-file",
+        type=str,
+        help="JSON file containing the HELM monomer library in the same format as used for Datagrok. "
+        + "The alphabet property is ignored when helm library is specified.",
+    )
+
+    parser.add_argument(
+        "--helm-connection-mode",
+        type=str,
+        default=HelmConnectionMode.linear.value,
+        help=f"HELM peptide generation mode: {'/'.join([mode.name for mode in HelmConnectionMode])}",
+    )
+
     available_alphabets = ",".join(list(alphabets.keys()) + ["custom"])
     parser.add_argument(
         "--alphabet",
@@ -251,7 +352,12 @@ def parse_command_line_args() -> Any:
         default=False,
         help="Disable generation of cliffs",
     )
-
+    parser.add_argument(
+        "--fasta-separator",
+        type=str,
+        default="",
+        help="Separator symbol for FASTA sequence",
+    )
     command_line_args = parser.parse_args()
 
     return command_line_args
@@ -274,12 +380,18 @@ if not grok:
     disable_cliffs = args.disable_cliffs
     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(",")
-)
+    fasta_separator = args.fasta_separator
+    helm_library_file = args.helm_library_file
+    helm_connection_mode = args.helm_connection_mode
+
+if helm_library_file is None:
+    alphabet: Alphabet = (
+        alphabets[alphabet_key].split(",")
+        if alphabet_key in alphabets
+        else alphabet_key.split(",")
+    )
+else:
+    alphabet = alphabet_from_helm(helm_library_file)
 
 # Running sequence generator
 header, data = generate_sequences(
@@ -294,17 +406,21 @@ header, data = generate_sequences(
     cliff_probability,
     cliff_strength,
 )
+if helm_library_file is None:
+    data_formatted = convert_to_fasta(data, fasta_separator)
+else:
+    data_formatted = convert_to_helm(data, helm_connection_mode)
 
 if grok:
-    # Exporting data to Datagrok as a pandas dataframe
+    # Exporting data to Datagrok as a Pandas dataframe
     import pandas as pd
 
-    sequences = pd.DataFrame.from_records(data, columns=header)
+    sequences = pd.DataFrame.from_records(data_formatted, columns=header)
 else:
     # Writing results to stdout - no need to work with big and heavy Pandas
     import csv
 
     csv_writer = csv.writer(sys.stdout, delimiter="\t", quoting=csv.QUOTE_MINIMAL)
     csv_writer.writerow(header)
-    for line in data:
+    for line in data_formatted:
         csv_writer.writerow(line)

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

@@ -6,8 +6,6 @@ import {ITooltipAndPanelParams} from '@datagrok-libraries/ml/src/viewers/activit
 import {getSimilarityFromDistance} from '@datagrok-libraries/ml/src/distance-metrics-methods';
 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';
 import {invalidateMols, MONOMERIC_COL_TAGS} from '../substructure-search/substructure-search';
 import {getSplitter, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
@@ -24,7 +22,7 @@ export async function getDistances(col: DG.Column, seq: string): Promise<Array<n
 }
 
 export async function getSimilaritiesMatrix(
-  dim: number, seqCol: DG.Column, df: DG.DataFrame, colName: string, simArr: DG.Column[]
+  dim: number, seqCol: DG.Column, df: DG.DataFrame, colName: string, simArr: DG.Column[],
 ): Promise<DG.Column[]> {
   const distances = new Array(simArr.length).fill(null);
   for (let i = 0; i != dim - 1; ++i) {
@@ -54,7 +52,7 @@ export async function getChemSimilaritiesMatrix(dim: number, seqCol: DG.Column,
     col: seqCol.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS],
     df: fpDf,
     colName: colName,
-    simArr: simArr
+    simArr: simArr,
   });
   return res;
 }
@@ -69,7 +67,7 @@ export function createTooltipElement(params: ITooltipAndPanelParams): HTMLDivEle
   columnNames.style.display = 'flex';
   columnNames.style.justifyContent = 'space-between';
   tooltipElement.append(columnNames);
-  params.line.mols.forEach((molIdx: number, idx: number) => {
+  params.line.mols.forEach((molIdx: number, _idx: number) => {
     const activity = ui.divText(params.activityCol.get(molIdx).toFixed(2));
     activity.style.display = 'flex';
     activity.style.justifyContent = 'left';
@@ -82,7 +80,7 @@ export function createTooltipElement(params: ITooltipAndPanelParams): HTMLDivEle
   return tooltipElement;
 }
 
-function moleculeInfo(df: DG.DataFrame, idx: number, seqColName: string): HTMLElement {
+function _moleculeInfo(df: DG.DataFrame, idx: number, seqColName: string): HTMLElement {
   const dict: { [key: string]: string } = {};
   for (const col of df.columns) {
     if (col.name !== seqColName)
@@ -124,7 +122,7 @@ export function createPropPanelElement(params: ITooltipAndPanelParams): HTMLDivE
 function createPropPanelField(name: string, value: number): HTMLDivElement {
   return ui.divH([
     ui.divText(`${name}: `, {style: {fontWeight: 'bold', paddingRight: '5px'}}),
-    ui.divText(value.toFixed(2))
+    ui.divText(value.toFixed(2)),
   ], {style: {paddingTop: '10px'}});
 }
 
@@ -147,13 +145,13 @@ export function createDifferencesWithPositions(
     const diffsPanel = ui.divV([]);
     diffsPanel.append(ui.divH([
       ui.divText('Pos', {style: {fontWeight: 'bold', width: '30px', borderBottom: '1px solid'}}),
-      ui.divText('Difference', {style: {fontWeight: 'bold', borderBottom: '1px solid'}})
+      ui.divText('Difference', {style: {fontWeight: 'bold', borderBottom: '1px solid'}}),
     ]));
     for (const key of Object.keys(molDifferences)) {
       molDifferences[key as any].style.borderBottom = '1px solid lightgray';
       diffsPanel.append(ui.divH([
         ui.divText((parseInt(key) + 1).toString(), {style: {width: '30px', borderBottom: '1px solid lightgray'}}),
-        molDifferences[key as any]
+        molDifferences[key as any],
       ]));
     }
     div.append(diffsPanel);

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

@@ -27,7 +27,7 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
       return;
     if (this.dataFrame) {
       if (computeData && this.moleculeColumn) {
-        const uh = new UnitsHandler(this.moleculeColumn);
+        const uh = UnitsHandler.getOrCreate(this.moleculeColumn);
         await (uh.isFasta() ? this.computeByMM() : this.computeByChem());
 
         const diverseColumnName: string = this.diverseColumnLabel != null ? this.diverseColumnLabel :
@@ -37,6 +37,8 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
         resCol.semType = DG.SEMTYPE.MACROMOLECULE;
         this.tags.forEach((tag) => resCol.setTag(tag, this.moleculeColumn!.getTag(tag)));
         const resDf = DG.DataFrame.fromColumns([resCol]);
+        resDf.onCurrentRowChanged.subscribe(
+          (_) => { this.dataFrame.currentRowIdx = this.renderMolIds![resDf.currentRowIdx]; });
         updateDivInnerHTML(this.root, resDf.plot.grid().root);
         this.computeCompleted.next(true);
       }
@@ -51,7 +53,7 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
       col: monomericMols,
       metricName: this.distanceMetric,
       limit: this.limit,
-      fingerprint: this.fingerprint
+      fingerprint: this.fingerprint,
     });
   }
 
@@ -60,6 +62,9 @@ export class SequenceDiversityViewer extends SequenceSearchBaseViewer {
     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)]);
+      (i1: number, i2: number) => {
+        return this.moleculeColumn!.isNone(i1) || this.moleculeColumn!.isNone(i2) ? 0 :
+          distanceMatrixData[linearizeFunc(i1, i2)];
+      });
   }
 }

package/src/analysis/sequence-search-base-viewer.ts

@@ -4,8 +4,8 @@ import * as grok from 'datagrok-api/grok';
 
 import {CHEM_SIMILARITY_METRICS} from '@datagrok-libraries/ml/src/distance-metrics-methods';
 import {TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import * as C from '../utils/constants';
 
+const MAX_ROWS_FOR_DISTANCE_MATRIX = 22000;
 export class SequenceSearchBaseViewer extends DG.JsViewer {
   name: string = '';
   distanceMetric: string;
@@ -17,7 +17,7 @@ export class SequenceSearchBaseViewer extends DG.JsViewer {
   moleculeColumnName: string;
   initialized: boolean = false;
   tags = [DG.TAGS.UNITS, bioTAGS.aligned, bioTAGS.separator, bioTAGS.alphabet];
-
+  preComputeDistanceMatrix: boolean = false;
   constructor(name: string) {
     super();
     this.fingerprint = this.string('fingerprint', this.fingerprintChoices[0], {choices: this.fingerprintChoices});
@@ -39,6 +39,7 @@ export class SequenceSearchBaseViewer extends DG.JsViewer {
     this.init();
 
     if (this.dataFrame) {
+      this.preComputeDistanceMatrix = this.dataFrame.rowCount <= MAX_ROWS_FOR_DISTANCE_MATRIX;
       this.subs.push(DG.debounce(this.dataFrame.onRowsRemoved, 50).subscribe(async (_: any) => await this.render()));
       const compute = this.name !== 'diversity';
       this.subs.push(DG.debounce(this.dataFrame.onCurrentRowChanged, 50)
@@ -66,7 +67,7 @@ export class SequenceSearchBaseViewer extends DG.JsViewer {
     this.render();
   }
 
-  async render(computeData = true) {
+  async render(_computeData = true) {
 
   }
 

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

@@ -4,13 +4,13 @@ import * as DG from 'datagrok-api/dg';
 
 import {SequenceSearchBaseViewer} from './sequence-search-base-viewer';
 import {getMonomericMols} from '../calculations/monomerLevelMols';
-import * as C from '../utils/constants';
 import {createDifferenceCanvas, createDifferencesWithPositions} from './sequence-activity-cliffs';
 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';
+import {calculateMMDistancesArray} from './workers/mm-distance-array-service';
 
 export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
   cutoff: number;
@@ -47,7 +47,7 @@ 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 uh = new UnitsHandler(this.moleculeColumn!);
+        const uh = UnitsHandler.getOrCreate(this.moleculeColumn!);
 
         await (uh.isFasta() ? this.computeByMM() : this.computeByChem());
         const similarColumnName: string = this.similarColumnLabel != null ? this.similarColumnLabel :
@@ -67,7 +67,7 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
         const targetMolRow = this.idxs?.getRawData().findIndex((it) => it == this.targetMoleculeIdx);
         const targetScoreCell = grid.cell('score', targetMolRow!);
         targetScoreCell.cell.value = null;
-        (grok.shell.v as DG.TableView).grid.root.addEventListener('click', (event: MouseEvent) => {
+        (grok.shell.v as DG.TableView).grid.root.addEventListener('click', (_event: MouseEvent) => {
           this.gridSelect = false;
         });
         updateDivInnerHTML(this.root, grid.root);
@@ -87,23 +87,29 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
       metricName: this.distanceMetric,
       limit: this.limit,
       minScore: this.cutoff,
-      fingerprint: this.fingerprint
+      fingerprint: this.fingerprint,
     });
     this.idxs = df.getCol('indexes');
     this.scores = df.getCol('score');
   }
 
   private async computeByMM() {
-    if (!this.distanceMatrixComputed) {
+    let distanceArray = new Float32Array();
+    if (!this.distanceMatrixComputed && this.preComputeDistanceMatrix) {
       this.mmDistanceMatrix = await calcMmDistanceMatrix(this.moleculeColumn!);
       this.distanceMatrixComputed = true;
+    } else if (!this.preComputeDistanceMatrix) {
+      // use fast distance array calculation if matrix will take too much space
+      distanceArray = await calculateMMDistancesArray(this.moleculeColumn!, this.targetMoleculeIdx);
     }
     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)]}));
+        this.preComputeDistanceMatrix ? 1 - this.mmDistanceMatrix[linearizeFunc(this.targetMoleculeIdx, i)] :
+          1 - distanceArray[i]
+      }));
     indexWScore.sort((a, b) => b.score - a.score);
     // get the most similar molecules
     const actualLimit = Math.min(this.limit, len);
@@ -127,7 +133,7 @@ export class SequenceSimilarityViewer extends SequenceSearchBaseViewer {
       propPanel.append(ui.divV([
         ui.divText(`Different sequence length:`, {style: {fontWeight: 'bold'}}),
         ui.divText(`target: ${subParts1.length} monomers`),
-        ui.divText(`selected: ${subParts2.length} monomers`)
+        ui.divText(`selected: ${subParts2.length} monomers`),
       ], {style: {paddingBottom: '10px'}}));
     }
     propPanel.append(createDifferencesWithPositions(molDifferences));

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 as unknown as DG.Column<string>, false); //we expect only string columns here
+    //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)};