@datagrok/bio 1.5.7 → 1.5.10

package/css/helm.css

@@ -0,0 +1,3 @@
+.d4-g-cell[semType="Macromolecule"] * {
+    pointer-events: none !important;
+}

package/detectors.js

@@ -13,17 +13,19 @@ class BioPackageDetectors extends DG.Package {
 
   static mmSemType = 'Macromolecule';
 
-  static Units = {
-    FastaSeqPt: 'fasta:SEQ:PT', FastaSeqNt: 'fasta:SEQ:NT', FastaMsaPt: 'fasta:MSA:PT', FastaMsaNt: 'fasta:MSA:NT',
-  };
-
-  static AminoacidsFastaAlphabet = new Set([
+  static PeptideFastaAlphabet = new Set([
     'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
     'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
   ]);
 
-  static NucleotidesFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+  static DnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
+
+  static RnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
 
+  static SmilesRawAlphabet = new Set([
+    'O', 'C', 'c', 'N', 'S', 'F', '(', ')',
+    '1', '2', '3', '4', '5', '6', '7',
+    '+', '-', '@', '[', ']', '/', '\\', '#', '=']);
 
   /** @param s {String} - string to check
    * @returns {boolean} */
@@ -42,17 +44,26 @@ class BioPackageDetectors extends DG.Package {
       return BioPackageDetectors.mmSemType;
     }
 
-    const alphabetCandidates = [
-      ['NT', BioPackageDetectors.NucleotidesFastaAlphabet],
-      ['PT', BioPackageDetectors.AminoacidsFastaAlphabet],
+    const decoyAlphabets = [
+      ['SMILES', BioPackageDetectors.SmilesRawAlphabet],
+    ];
+
+    const candidateAlphabets = [
+      ['PT', BioPackageDetectors.PeptideFastaAlphabet],
+      ['DNA', BioPackageDetectors.DnaFastaAlphabet],
+      ['RNA', BioPackageDetectors.RnaFastaAlphabet],
     ];
 
     // TODO: Detect HELM sequence
     // TODO: Lazy calculations could be helpful for performance and convenient for expressing classification logic.
     const statsAsChars = BioPackageDetectors.getStats(col, 5, BioPackageDetectors.splitterAsChars);
+
+    const decoy = BioPackageDetectors.detectAlphabet(statsAsChars.freq, decoyAlphabets, null, 0.5);
+    if (decoy != 'UN') return null;
+
     if (statsAsChars.sameLength) {
       if (Object.keys(statsAsChars.freq).length > 0) { // require non empty alphabet
-        const alphabet = BioPackageDetectors.detectAlphabet(statsAsChars.freq, alphabetCandidates, '-');
+        const alphabet = BioPackageDetectors.detectAlphabet(statsAsChars.freq, candidateAlphabets, '-');
         if (alphabet === 'UN') return null;
 
         const units = `fasta:SEQ.MSA:${alphabet}`;
@@ -74,10 +85,10 @@ class BioPackageDetectors extends DG.Package {
       const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
 
       // TODO: If separator detected, then extra efforts to detect alphabet are allowed.
-      const alphabet = BioPackageDetectors.detectAlphabet(stats.freq, alphabetCandidates, gapSymbol);
+      const alphabet = BioPackageDetectors.detectAlphabet(stats.freq, candidateAlphabets, gapSymbol);
 
-      const forbidden = BioPackageDetectors.checkForbiddenWoSeparator(stats.freq);
-      if (separator || !forbidden) {
+      // const forbidden = BioPackageDetectors.checkForbiddenWoSeparator(stats.freq);
+      if (separator || alphabet != 'UN') {
         const units = `${format}:${seqType}:${alphabet}`;
         col.setTag(DG.TAGS.UNITS, units);
         if (separator) col.setTag('separator', separator);
@@ -103,8 +114,8 @@ class BioPackageDetectors extends DG.Package {
     const cleanFreq = Object.assign({}, ...Object.entries(freq)
       .filter(([m, f]) => m != ' ' &&
         !noSeparatorChemRe.test(m) && !noSeparatorAlphaDigitRe.test(m) &&
-        !BioPackageDetectors.AminoacidsFastaAlphabet.has(m) &&
-        !BioPackageDetectors.NucleotidesFastaAlphabet.has(m))
+        !BioPackageDetectors.PeptideFastaAlphabet.has(m) &&
+        !BioPackageDetectors.DnaFastaAlphabet.has(m))
       .map(([m, f]) => ({[m]: f})));
     if (Object.keys(cleanFreq).length == 0) return null;
 
@@ -124,11 +135,11 @@ class BioPackageDetectors extends DG.Package {
     return Object.keys(freq).filter((m) => forbiddenRe.test(m)).length > 0;
   }
 
-  /** Without a separator, special symbols or digits are not allowed as monomers. */
-  static checkForbiddenWoSeparator(freq) {
-    const forbiddenRe = /[\d!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/i;
-    return Object.keys(freq).filter((m) => forbiddenRe.test(m)).length > 0;
-  }
+  // /** Without a separator, special symbols or digits are not allowed as monomers. */
+  // static checkForbiddenWoSeparator(freq) {
+  //   const forbiddenRe = /[\d!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/i;
+  //   return Object.keys(freq).filter((m) => forbiddenRe.test(m)).length > 0;
+  // }
 
   /** Stats of sequences with specified splitter func, returns { freq, sameLength } */
   static getStats(seqCol, minLength, splitter) {
@@ -161,7 +172,7 @@ class BioPackageDetectors extends DG.Package {
    * @param freq       frequencies of monomers in sequence set
    * @param candidates  an array of pairs [name, monomer set]
    * */
-  static detectAlphabet(freq, candidates, gapSymbol) {
+  static detectAlphabet(freq, candidates, gapSymbol, cut = 0.65) {
     const candidatesSims = candidates.map((c) => {
       const sim = BioPackageDetectors.getAlphabetSimilarity(freq, c[1], gapSymbol);
       return [c[0], c[1], freq, sim];
@@ -169,7 +180,7 @@ class BioPackageDetectors extends DG.Package {
 
     let alphabetName;
     const maxSim = Math.max(...candidatesSims.map((cs) => cs[3]));
-    if (maxSim > 0.65) {
+    if (maxSim > cut) {
       const sim = candidatesSims.find((cs) => cs[3] == maxSim);
       alphabetName = sim[0];
     } else {