@datagrok/bio 2.1.12 → 2.4.3

package/.eslintrc.json

@@ -1,7 +1,7 @@
 {
   "env": {
     "browser": true,
-    "es2021": true
+    "es2022": true
   },
   "extends": [
     "google"

package/README.md

@@ -4,7 +4,7 @@ Bio is a bioinformatics support [package](https://datagrok.ai/help/develop/devel
 [Datagrok](https://datagrok.ai) platform with an extensive toolset supporting SAR analisys for small molecules
 and antibodies.
 
-# Notations
+## Notations
 
 [@datagrok/bio](https://github.com/datagrok-ai/public/tree/master/packages/Bio) can ingest data in multiple file
 formats (such as fasta o csv) and multiple notations for natural and modified residues, aligned and non-aligned forms,
@@ -18,7 +18,7 @@ See:
 * [detectMacromolecule()](../Bio/detectors.js)
 * [class NotationConverter](../../libraries/bio/src/utils/notation-converter.ts)
 
-# Atomic-Level structures from sequences
+## Atomic-Level structures from sequences
 
 For linear sequences, the linear form (see the illustration below) of molecules is reproduced. This is useful
 for better visual inspection of sequence and duplex comparison. Structure at atomic level could be saved in available
@@ -34,11 +34,10 @@ See:
 
 * [getMolfilesFromSeq()](./src/utils/atomic-works.ts)
 
-# MSA
+## MSA
 
 For multiple-sequence alignment, Datagrok uses the “kalign” that relies on Wu-Manber string-matching algorithm
-[Lassmann, Timo. _Kalign 3: multiple sequence alignment of large data sets._ **Bioinformatics** (2019).[pdf](
-https://academic.oup.com/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btz795/30314127/btz795.pdf)].
+[Lassmann, Timo. _Kalign 3: multiple sequence alignment of large data sets._ **Bioinformatics** (2019).pdf](https://academic.oup.com/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btz795/30314127/btz795.pdf).
 “kalign“ is suited for sequences containing only natural monomers. Sequences of a particular column can be analyzed
 using MSA algorithm available at the top menu. Aligned sequences can be inspected for base composition
 at the position of MSA result.
@@ -52,7 +51,7 @@ See:
 
 TODO: MSA with PepSeA
 
-# Splitting to monomers
+## Splitting to monomers
 
 Splitting to monomers allows splitting aligned sequences in separate monomers.
 
@@ -62,7 +61,7 @@ See:
 
 * [splitAlignedSequences()](../../libraries/bio/src/utils/splitter.ts)
 
-# Web Logo
+## Web Logo
 
 Web Logo visualizes a graphical representation of multiple sequence alignment (amino acids or nucleotides or
 modified residues with multi-char labels). Each logo consists of stacks of symbols, one for each position
@@ -81,13 +80,13 @@ You can customize the look of the viewer with properties. Properties ```startPos
 allow to display multiple alignment partially. If property  ```startPosition``` (```endPosition```)
 is not specified, then the Logo will be plotted from the first (till the last) position of sequences.
 
-## General
+### General
 
 |             |              |
 |-------------|--------------|
 | Right click | Context menu |
 
-## Properties
+### Properties
 
 | Property name        | Default  | Description                                                                                                             |
 |----------------------|----------|-------------------------------------------------------------------------------------------------------------------------|
@@ -116,7 +115,7 @@ See also:
 * [Viewers](../../help/visualize/viewers.md)
 * [Table view](../../help/datagrok/table-view.md)
 
-# Sequence space
+## Sequence space
 
 Datagrok allows visualizing multidimensional sequence space using a dimensionality reduction approach.
 Several distance-based dimensionality reduction algorithms are available, such as UMAP or t-SNE.
@@ -132,7 +131,7 @@ See:
 
 * [sequenceSpace()](src/utils/sequence-space.ts)
 
-# Sequence activity cliffs
+## Sequence activity cliffs
 
 Activity cliffs tool finds pairs of sequences where small changes in the sequence yield significant
 changes in activity or any other numerical property. open the tool from a top menu by selecting.
@@ -145,4 +144,4 @@ To launch the analysis from the top menu, select Bio | Sequence Activity Cliffs.
 
 See:
 
-* [getActivityCliffs()](../../libraries/ml/src/viewers/activity-cliffs.ts)
+* [getActivityCliffs()](../../libraries/ml/src/viewers/activity-cliffs.ts)

package/css/helm.css

@@ -1,3 +1,13 @@
 .d4-g-cell[semType="Macromolecule"] * {
     pointer-events: none !important;
 }
+
+.helm-substructure-filter {
+    border: 1px solid var(--grey-2);
+    height: 25px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    padding-left: 0px;
+    margin-left: 0px;
+}

package/detectors.js

@@ -45,23 +45,28 @@ const isUrlRe = /[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9
 
 class BioPackageDetectors extends DG.Package {
 
-  PeptideFastaAlphabet = new Set([
+  /** Parts of the column name required in the column's name under the detector. It must be in lowercase. */
+  likelyColNamePartList = ['seq', 'msa', 'dna', 'rna', 'fasta', 'helm', 'sense', 'protein'];
+
+  peptideFastaAlphabet = new Set([
     'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
     'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
     'MeNle', 'MeA', 'MeG', 'MeF',
   ]);
 
-  DnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+  dnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+
+  rnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
 
-  RnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
+  numbersRawAlphabet = new Set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']);
 
-  SmilesRawAlphabet = new Set([
+  smilesRawAlphabet = new Set([
     'A', 'B', 'C', 'E', 'F', 'H', 'I', 'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'Z',
     'a', 'c', 'e', 'g', 'i', 'l', 'n', 'o', 'r', 's', 't', 'u',
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
     '+', '-', '.', , '/', '\\', '@', '[', ']', '(', ')', '#', '%', '=']);
 
-  SmartsRawAlphabet = new Set([
+  smartsRawAlphabet = new Set([
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
     '!', '#', '$', '&', '(', ')', '*', '+', ',', '-', '.', ':', ';', '=', '@', '~', '[', ']',
     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M',
@@ -83,6 +88,11 @@ class BioPackageDetectors extends DG.Package {
   detectMacromolecule(col) {
     const t1 = Date.now();
     try {
+      const colName = col.name;
+      const colNameLikely = this.likelyColNamePartList.some(
+        (requiredColNamePart) => colName.toLowerCase().includes(requiredColNamePart));
+      const seqMinLength = colNameLikely ? 3 : 5;
+
       // Fail early
       if (col.type !== DG.TYPE.STRING) return null;
 
@@ -92,7 +102,7 @@ class BioPackageDetectors extends DG.Package {
       // To collect alphabet freq three strategies can be used:
       // as chars, as fasta (single or within square brackets), as with the separator.
       if (
-        !(col.categories.length == 1 && !col.categories[0]) && // TODO: Remove with tests for single empty category value
+        !(col.categories.length === 1 && !col.categories[0]) && // TODO: Remove with tests for single empty category
         DG.Detector.sampleCategories(col, (s) => this.isHelm(s), 1, SEQ_SAMPLE_LIMIT)
       ) {
         const statsAsHelm = this.getStats(categoriesSample, 2,
@@ -109,14 +119,15 @@ class BioPackageDetectors extends DG.Package {
       }
 
       const decoyAlphabets = [
-        ['SMILES', this.SmilesRawAlphabet, 0.30],
-        ['SMARTS', this.SmartsRawAlphabet, 0.43],
+        ['NUMBERS', this.numbersRawAlphabet, 0.25],
+        ['SMILES', this.smilesRawAlphabet, 0.25],
+        ['SMARTS', this.smartsRawAlphabet, 0.43],
       ];
 
       const candidateAlphabets = [
-        [ALPHABET.PT, this.PeptideFastaAlphabet, 0.50],
-        [ALPHABET.DNA, this.DnaFastaAlphabet, 0.55],
-        [ALPHABET.RNA, this.RnaFastaAlphabet, 0.55],
+        [ALPHABET.PT, this.peptideFastaAlphabet, 0.50],
+        [ALPHABET.DNA, this.dnaFastaAlphabet, 0.55],
+        [ALPHABET.RNA, this.rnaFastaAlphabet, 0.55],
       ];
 
       // Check for url column, maybe it is too heavy check
@@ -136,57 +147,67 @@ class BioPackageDetectors extends DG.Package {
 
       // TODO: Detect HELM sequence
       // TODO: Lazy calculations could be helpful for performance and convenient for expressing classification logic.
-      const statsAsChars = this.getStats(categoriesSample, 5,
+      const statsAsChars = this.getStats(categoriesSample, seqMinLength,
         this.getSplitterAsChars(SEQ_SAMPLE_LENGTH_LIMIT));
       // Empty statsAsShars.freq alphabet means no strings of enough length presented in the data
       if (Object.keys(statsAsChars.freq).length === 0) return null;
 
       const decoy = this.detectAlphabet(statsAsChars.freq, decoyAlphabets, null);
-      if (decoy != ALPHABET.UN) return null;
+      if (decoy !== ALPHABET.UN) return null;
 
       const separator = this.detectSeparator(statsAsChars.freq);
+      if (this.checkForbiddenSeparator(separator)) return null;
+
       const units = separator ? NOTATION.SEPARATOR : NOTATION.FASTA;
       const gapSymbol = separator ? '' : '-';
       const splitter = separator ? this.getSplitterWithSeparator(separator, SEQ_SAMPLE_LENGTH_LIMIT) :
         this.getSplitterAsFasta(SEQ_SAMPLE_LENGTH_LIMIT);
 
       if (statsAsChars.sameLength) {
-        const stats = this.getStats(categoriesSample, 5, splitter);
-        const alphabet = this.detectAlphabet(stats.freq, candidateAlphabets, '-');
-        if (alphabet === ALPHABET.UN) return null;
+        const stats = this.getStats(categoriesSample, seqMinLength, splitter);
+        const alphabet = this.detectAlphabet(stats.freq, candidateAlphabets, '-', colNameLikely);
+        if (alphabet === ALPHABET.UN && !colNameLikely) return null;
 
         col.setTag(DG.TAGS.UNITS, units);
         if (separator) col.setTag(UnitsHandler.TAGS.separator, separator);
         col.setTag(UnitsHandler.TAGS.aligned, ALIGNMENT.SEQ_MSA);
         col.setTag(UnitsHandler.TAGS.alphabet, alphabet);
+        if (alphabet === ALPHABET.UN) {
+          const alphabetIsMultichar = Object.keys(stats.freq).some((m) => m.length > 1);
+          col.setTag(UnitsHandler.TAGS.alphabetIsMultichar, alphabetIsMultichar ? 'true' : 'false');
+        }
         return DG.SEMTYPE.MACROMOLECULE;
       } else {
-        const stats = this.getStats(categoriesSample, 5, splitter);
+        const stats = this.getStats(categoriesSample, seqMinLength, splitter);
+        const alphabetIsMultichar = Object.keys(stats.freq).some((m) => m.length > 1);
         // Empty monomer alphabet is not allowed
         if (Object.keys(stats.freq).length === 0) return null;
         // Long monomer names for sequences with separators have constraints
-        if (separator && this.checkForbiddenWithSeparators(stats.freq)) return null;
+        if (
+          ((units === NOTATION.SEPARATOR || (units === NOTATION.FASTA && alphabetIsMultichar)) &&
+            this.checkForbiddenMultichar(stats.freq)) ||
+          ((units === NOTATION.FASTA && !alphabetIsMultichar) &&
+            this.checkForbiddenSinglechar(stats.freq))
+        ) return null;
 
         const aligned = stats.sameLength ? ALIGNMENT.SEQ_MSA : ALIGNMENT.SEQ;
 
         // TODO: If separator detected, then extra efforts to detect alphabet are allowed.
-        const alphabet = this.detectAlphabet(stats.freq, candidateAlphabets, gapSymbol);
+        const alphabet = this.detectAlphabet(stats.freq, candidateAlphabets, gapSymbol, colNameLikely);
+        /* Likely column name allows detecting 'fasta' notation with 'UN' alphabet, 2023-04-13, atanas, askalkin */
+        if (units === NOTATION.FASTA && alphabet === ALPHABET.UN && !alphabetIsMultichar && !colNameLikely) return null;
 
         // const forbidden = this.checkForbiddenWoSeparator(stats.freq);
-        if (separator || alphabet != 'UN') {
-          col.setTag(DG.TAGS.UNITS, units);
-          if (separator) col.setTag(UnitsHandler.TAGS.separator, separator);
-          col.setTag(UnitsHandler.TAGS.aligned, aligned);
-          col.setTag(UnitsHandler.TAGS.alphabet, alphabet);
-          if (alphabet === ALPHABET.UN) {
-            // alphabetSize calculated on (sub)sample of data is incorrect
-            // const alphabetSize = Object.keys(stats.freq).length;
-            const alphabetIsMultichar = Object.keys(stats.freq).some((m) => m.length > 1);
-            // col.setTag(UnitsHandler.TAGS.alphabetSize, alphabetSize.toString());
-            col.setTag(UnitsHandler.TAGS.alphabetIsMultichar, alphabetIsMultichar ? 'true' : 'false');
-          }
-          return DG.SEMTYPE.MACROMOLECULE;
+        col.setTag(DG.TAGS.UNITS, units);
+        if (separator) col.setTag(UnitsHandler.TAGS.separator, separator);
+        col.setTag(UnitsHandler.TAGS.aligned, aligned);
+        col.setTag(UnitsHandler.TAGS.alphabet, alphabet);
+        if (alphabet === ALPHABET.UN) {
+          // alphabetSize calculated on (sub)sample of data is incorrect
+          const alphabetIsMultichar = Object.keys(stats.freq).some((m) => m.length > 1);
+          col.setTag(UnitsHandler.TAGS.alphabetIsMultichar, alphabetIsMultichar ? 'true' : 'false');
         }
+        return DG.SEMTYPE.MACROMOLECULE;
       }
     } finally {
       const t2 = Date.now();
@@ -207,15 +228,15 @@ class BioPackageDetectors extends DG.Package {
     // !!! What is the difference between the gap symbol and separator symbol in stats terms?
     // const noSeparatorRe = /[a-z\d]+$/i;
     const noSeparatorChemRe = /[HBCNOFPSKVYI]/i; // Mendeleev's periodic table single char elements
-    const noSeparatorAlphaDigitRe = /[\dA-Z,& _\r\n]/i; // ..., comma, ampersand, space, underscore, CR, LF
+    const noSeparatorAlphaDigitRe = /[\dA-Z]/i;
     const noSeparatorBracketsRe = /[\[\]()<>{}]/i;
     const cleanFreq = Object.assign({}, ...Object.entries(freq)
       .filter(([m, f]) =>
         !noSeparatorChemRe.test(m) && !noSeparatorAlphaDigitRe.test(m) && !noSeparatorBracketsRe.test(m) &&
-        !this.PeptideFastaAlphabet.has(m) &&
-        !this.DnaFastaAlphabet.has(m))
+        !this.peptideFastaAlphabet.has(m) &&
+        !this.dnaFastaAlphabet.has(m))
       .map(([m, f]) => ({[m]: f})));
-    if (Object.keys(cleanFreq).length == 0) return null;
+    if (Object.keys(cleanFreq).length === 0) return null;
 
     const maxFreq = Math.max(...Object.values(cleanFreq));
 
@@ -227,12 +248,24 @@ class BioPackageDetectors extends DG.Package {
     return sepFreq / otherSumFreq > freqThreshold ? sep : null;
   }
 
-  /** With a separator, spaces are nor allowed in monomer names.
+  checkForbiddenSeparator(separator) {
+    // dot, comma, ampersand, space, underscore, CR, LF
+    const forbiddenSepRe = / |\.|,|&|_|\r\n|\n/i;
+    return forbiddenSepRe.test(separator);
+  }
+
+  /** Spaces, dots and colons are nor allowed in multichar monomer names.
    * The monomer name/label cannot contain digits only.
    */
-  checkForbiddenWithSeparators(freq) {
-    const forbiddenRe = /[ ]|^\d+$/i;
-    return Object.keys(freq).filter((m) => forbiddenRe.test(m)).length > 0;
+  checkForbiddenMultichar(freq) {
+    const forbiddenRe = /[ .:]|^\d+$/i;
+    return Object.keys(freq).some((m) => forbiddenRe.test(m));
+  }
+
+  /** Space, dot, colon, semicolon, digit, underscore are not allowed as singe char monomer names.*/
+  checkForbiddenSinglechar(freq) {
+    const forbiddenRe = /[ .:;\d_]/i;
+    return Object.keys(freq).some((m) => forbiddenRe.test(m));
   }
 
   // /** Without a separator, special symbols or digits are not allowed as monomers. */
@@ -250,17 +283,16 @@ class BioPackageDetectors extends DG.Package {
     for (const seq of values) {
       const mSeq = splitter(seq);
 
-      if (firstLength == null) {
+      if (firstLength === null) {
+        //
         firstLength = mSeq.length;
       } else if (mSeq.length !== firstLength) {
         sameLength = false;
       }
 
-      if (mSeq.length > minLength) {
+      if (mSeq.length >= minLength) {
         for (const m of mSeq) {
-          if (!(m in freq)) {
-            freq[m] = 0;
-          }
+          if (!(m in freq)) freq[m] = 0;
           freq[m] += 1;
         }
       }
@@ -271,17 +303,18 @@ class BioPackageDetectors extends DG.Package {
   /** Detects alphabet for freq by freq similarity to alphabet monomer set.
    * @param freq       frequencies of monomers in sequence set
    * @param candidates  an array of pairs [name, monomer set]
-   * */
-  detectAlphabet(freq, candidates, gapSymbol) {
+   * @param {boolean} colNameLikely The column name suggests the column is Macromolecule more likely
+   */
+  detectAlphabet(freq, candidates, gapSymbol, colNameLikely = false) {
     const candidatesSims = candidates.map((c) => {
-      const sim = this.getAlphabetSimilarity(freq, c[1], gapSymbol);
+      const sim = this.getAlphabetSimilarity(freq, c[1], gapSymbol) + (colNameLikely ? 0.15 : 0);
       return [c[0], c[1], c[2], freq, sim];
     });
 
     let alphabetName;
     const maxSim = Math.max(...candidatesSims.map((cs) => cs[4] > cs[2] ? cs[4] : -1));
     if (maxSim > 0) {
-      const sim = candidatesSims.find((cs) => cs[4] == maxSim);
+      const sim = candidatesSims.find((cs) => cs[4] === maxSim);
       alphabetName = sim[0];
     } else {
       alphabetName = ALPHABET.UN;
@@ -306,20 +339,19 @@ class BioPackageDetectors extends DG.Package {
 
   vectorLength(v) {
     let sqrSum = 0;
-    for (let i = 0; i < v.length; i++) {
+    for (let i = 0; i < v.length; i++)
       sqrSum += v[i] * v[i];
-    }
     return Math.sqrt(sqrSum);
   }
 
   vectorDotProduct(v1, v2) {
-    if (v1.length != v2.length) {
+    if (v1.length !== v2.length)
       throw Error('The dimensionality of the vectors must match');
-    }
+
     let prod = 0;
-    for (let i = 0; i < v1.length; i++) {
+    for (let i = 0; i < v1.length; i++)
       prod += v1[i] * v2[i];
-    }
+
     return prod;
   }
 
@@ -327,7 +359,7 @@ class BioPackageDetectors extends DG.Package {
   getSplitterAsChars(lengthLimit) {
     return function(seq) {
       return seq.split('', lengthLimit);
-    }.bind(this);
+    };
   }
 
   getSplitterWithSeparator(separator, lengthLimit) {
@@ -346,11 +378,11 @@ class BioPackageDetectors extends DG.Package {
       // } else {
       return seq.split(separator, lengthLimit);
       // }
-    }.bind(this);
+    };
   }
 
   // Multichar monomer names in square brackets, single char monomers or gap symbol
-  monomerRe = /\[(\w+)\]|(\w)|(-)/g;
+  monomerRe = /\[(\w+)\]|(.)/g;
 
   /** Split sequence for single character monomers, square brackets multichar monomer names or gap symbol. */
   getSplitterAsFasta(lengthLimit) {
@@ -360,11 +392,11 @@ class BioPackageDetectors extends DG.Package {
         .map((ma) => {
           let mRes;
           const m = ma[0];
-          if (m.length > 1) {
+          if (m.length > 1)
             mRes = ma[1];
-          } else {
+          else
             mRes = m;
-          }
+
           return mRes;
         }).toArray();
 
@@ -391,11 +423,10 @@ class BioPackageDetectors extends DG.Package {
       const mmPostProcess = (mm) => {
         this.helmPp1Re.lastIndex = 0;
         const pp1M = this.helmPp1Re.exec(mm);
-        if (pp1M && pp1M.length >= 2) {
+        if (pp1M && pp1M.length >= 2)
           return pp1M[1];
-        } else {
+        else
           return mm;
-        }
       };
 
       const mmList = inSeq ? inSeq.split('.') : [];
@@ -405,16 +436,13 @@ class BioPackageDetectors extends DG.Package {
   }
 
   sample(src, n) {
-    if (src.length < n) {
+    if (src.length < n)
       throw new Error('Sample source is less than n requested.');
-    }
 
     const idxSet = new Set();
     while (idxSet.size < n) {
       const idx = Math.floor(Math.random() * src.length);
-      if (!idxSet.has(idx)) {
-        idxSet.add(idx);
-      }
+      if (!idxSet.has(idx)) idxSet.add(idx);
     }
 
     return [...idxSet].map((idx) => src[idx]);