@datagrok/sequence-translator 1.0.17 → 1.1.0

package/src/model/parsing-validation/format-detector.ts

@@ -0,0 +1,57 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {sortByReverseLength} from '../helpers';
+import {DEFAULT_FORMATS} from '../const';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
+import {SequenceValidator} from './sequence-validator';
+
+export class FormatDetector {
+  constructor (private sequence: string) {
+    this.libWrapper = MonomerLibWrapper.getInstance();
+    this.formats = Object.keys(codesToHelmDictionary);
+  };
+
+  private libWrapper: MonomerLibWrapper;
+  private formats: string[];
+
+  getFormat(): string | null {
+    // todo: reliable criterion
+    if (this.sequence.startsWith('RNA'))
+      return DEFAULT_FORMATS.HELM;
+    const possibleFormats = this.getListOfPossibleSynthesizersByFirstMatchedCode();
+    if (possibleFormats.length === 0)
+      return null;
+
+    const validator = new SequenceValidator(this.sequence);
+    const outputIndices = Array(possibleFormats.length).fill(0);
+    for (let i = 0; i < possibleFormats.length; ++i) {
+      const format = possibleFormats[i];
+      outputIndices[i] = validator.getInvalidCodeIndex(format);
+    }
+    const formatIdx = (outputIndices.some((idx) => idx === -1)) ? -1 : Math.max(...outputIndices);
+    return possibleFormats[outputIndices.indexOf(formatIdx)];
+  }
+
+  // todo: rename
+  private getListOfPossibleSynthesizersByFirstMatchedCode(): string[] {
+    const sequence = this.sequence;
+    let synthesizers: string[] = [];
+    for (const format of this.formats) {
+      let codes = sortByReverseLength(this.libWrapper.getCodesByFormat(format));
+      let start = 0;
+      for (let i = 0; i < sequence.length; i++) {
+        if (sequence[i] === ')' && i !== sequence.length - 1) {
+          start = i + 1;
+          break;
+        }
+      }
+      if (codes.some((s: string) => s === sequence.slice(start, start + s.length)))
+        synthesizers.push(format);
+    }
+    return synthesizers;
+  }
+}

package/src/model/parsing-validation/sequence-validator.ts

@@ -0,0 +1,52 @@
+import {NUCLEOTIDES} from '../const';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+import {sortByReverseLength} from '../helpers';
+import {DEFAULT_FORMATS} from '../const';
+
+export class SequenceValidator {
+  constructor(private sequence: string) {
+    this.libWrapper = MonomerLibWrapper.getInstance();
+  };
+  private libWrapper: MonomerLibWrapper;
+
+  getInvalidCodeIndex(format: string): number {
+    if (format === DEFAULT_FORMATS.HELM)
+      return this.sequence.length;
+    const firstUniqueCharacters = ['r', 'd']; // what for?
+    const codes = sortByReverseLength(
+      this.libWrapper.getCodesByFormat(format)
+    );
+    let indexOfFirstInvalidChar = 0;
+    while (indexOfFirstInvalidChar < this.sequence.length) {
+      const matchedCode = codes.find((code) => {
+        const subSequence = this.sequence.substring(indexOfFirstInvalidChar, indexOfFirstInvalidChar + code.length);
+        return code === subSequence;
+      });
+
+      if (!matchedCode) break;
+
+      // todo: refactor the vague condition
+      if ( // for mistake pattern 'rAA'
+        indexOfFirstInvalidChar > 1 &&
+        NUCLEOTIDES.includes(this.sequence[indexOfFirstInvalidChar]) &&
+        firstUniqueCharacters.includes(this.sequence[indexOfFirstInvalidChar - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(this.sequence[indexOfFirstInvalidChar + 1]) &&
+        NUCLEOTIDES.includes(this.sequence[indexOfFirstInvalidChar])
+      ) {
+        indexOfFirstInvalidChar++;
+        break;
+      }
+      indexOfFirstInvalidChar += matchedCode.length;
+    }
+    if (indexOfFirstInvalidChar === this.sequence.length)
+      indexOfFirstInvalidChar = -1
+    return indexOfFirstInvalidChar;
+  }
+
+  isValidSequence(format: string): boolean {
+    return this.getInvalidCodeIndex(format) === -1;
+  }
+}

package/src/model/sequence-to-structure-utils/const.ts

@@ -0,0 +1 @@
+export const PHOSPHATE_SYMBOL = 'p';

package/src/{utils/structures-works → model/sequence-to-structure-utils}/mol-transformations.ts

@@ -29,9 +29,6 @@ export function linkStrandsV3000(
   let nbond = 0;
   let xShift = 0;
 
-  // if (twoChains && molBlocks.length > 1)
-  //   molBlocks[1] = invertNucleotidesV3000(molBlocks[1]);
-
   if (strands.antiStrands.length > 0) {
     for (let i = 0; i < strands.antiStrands.length; i++)
       strands.antiStrands[i] = invertNucleotidesV3000(strands.antiStrands[i]);
@@ -39,25 +36,35 @@ export function linkStrandsV3000(
 
   let inverted = false;
   const molBlocks = strands.senseStrands.concat(strands.antiStrands);
+  /** Minimal value of AS and AS2 shift  */
+  let ssYShift = 0;
 
   for (let i = 0; i < molBlocks.length; i++) {
-    if (i >= strands.senseStrands.length && inverted === false) {
-      inverted = true;
-      xShift = 0;
-    }
-
     molBlocks[i] = molBlocks[i].replaceAll('(-\nM  V30 ', '(')
       .replaceAll('-\nM  V30 ', '').replaceAll(' )', ')');
     const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);
     const coordinates = extractAtomDataV3000(molBlocks[i]);
 
+    if (i >= strands.senseStrands.length) {
+      if (inverted === false) {
+        // AS strand
+        inverted = true;
+        xShift = 0;
+      }
+    } else {
+      // SS strands
+      ssYShift = Math.min(ssYShift, Math.min(
+        ...coordinates.y.filter((item) => item < 0)
+      ));
+    }
+
     if (inverted) {
       const xShiftRight = Math.min(...coordinates.x) - xShift;
-      const yShift = !inverted ? Math.min(...coordinates.y) - 1 : Math.max(...coordinates.y) + 15;
+      const yShift = Math.max(...coordinates.y) + 5;
       for (let j = 0; j < coordinates.x.length; j++)
         coordinates.x[j] -= xShiftRight;
       for (let j = 0; j < coordinates.y.length; j++)
-        coordinates.y[j] -= yShift;
+        coordinates.y[j] -= yShift - ssYShift;
     }
 
     let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
@@ -141,7 +148,7 @@ export function linkStrandsV3000(
 
     natom += true ? numbers.natom : numbers.natom - 1;
     nbond += numbers.nbond;
-    xShift += Math.max(...coordinates.x) + 1;//twoChains ? 0 : coordinates.x[numbers.natom - 1] - coordinates.x[0];
+    xShift += Math.max(...coordinates.x) + 5;//twoChains ? 0 : coordinates.x[numbers.natom - 1] - coordinates.x[0];
   }
 
   const entries = 4;
@@ -167,7 +174,7 @@ export function linkStrandsV3000(
   macroMolBlock += 'M  V30 BEGIN BOND\n';
   macroMolBlock += bondBlock;
   macroMolBlock += 'M  V30 END BOND\n';
-  if (useChirality) {
+  if (useChirality && collection.length > 0) {
     macroMolBlock += 'M  V30 BEGIN COLLECTION\n';
     macroMolBlock += collectionBlock;
     macroMolBlock += 'M  V30 END COLLECTION\n';
@@ -219,7 +226,7 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
         indexEnd = molBlocks[i].indexOf(' ', index);
         let atomNumber = 0;
         if (isBoundary) {
-          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd))
+          atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
           if (atomNumber === 1)
             atomNumber = specLength;
           else if (atomNumber === specLength)
@@ -275,7 +282,7 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
       indexEnd = molBlocks[i].indexOf(' ', index);
       let atomNumber = 0;
       if (isBoundary) {
-        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd))
+        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
         if (atomNumber === 1)
           atomNumber = specLength;
         else if (atomNumber === specLength)
@@ -290,7 +297,7 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
       indexEnd = Math.min(molBlocks[i].indexOf('\n', index), molBlocks[i].indexOf(' ', index));
       atomNumber = 0;
       if (isBoundary) {
-        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd))
+        atomNumber = parseInt(molBlocks[i].substring(index, indexEnd));
         if (atomNumber === 1)
           atomNumber = specLength;
         else if (atomNumber === specLength)
@@ -331,14 +338,6 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
   const entries = 4;
   const collNumber = Math.ceil(collection.length / entries);
 
-  //if (oclRender) {
-  // collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length;
-
-  // for (let j = 0; j < collection.length; j++)
-  //   collectionBlock += ' ' + collection[j];
-
-  // collectionBlock += ')\n';
-  //} else {
   collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\n';
   for (let i = 0; i < collNumber; i++) {
     collectionBlock += 'M  V30 ';
@@ -360,12 +359,11 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
   macroMolBlock += 'M  V30 BEGIN BOND\n';
   macroMolBlock += bondBlock;
   macroMolBlock += 'M  V30 END BOND\n';
-  if (useChirality) {
+  if (useChirality && collection.length > 0) {
     macroMolBlock += 'M  V30 BEGIN COLLECTION\n';
     macroMolBlock += collectionBlock;
     macroMolBlock += 'M  V30 END COLLECTION\n';
-  } else
-    macroMolBlock = macroMolBlock.replace(/ CFG=\d/g, ' ');
+  } else { macroMolBlock = macroMolBlock.replace(/ CFG=\d/g, ' '); }
 
   macroMolBlock += 'M  V30 END CTAB\n';
   macroMolBlock += 'M  END';
@@ -373,9 +371,7 @@ export function linkV3000(molBlocks: string[], useChirality: boolean = true): st
   return macroMolBlock;
 }
 
-function rotateNucleotidesV3000(molecule: string): string {
-  // @ts-ignore
-  let molBlock = molecule.includes('M  END') ? molecule : OCL.Molecule.fromSmiles(molecule).toMolfileV3();
+function rotateNucleotidesV3000(molBlock: string): string {
   const coordinates = extractAtomDataV3000(molBlock);
   const natom = coordinates.atomIndex.length;
 
@@ -396,15 +392,15 @@ function rotateNucleotidesV3000(molecule: string): string {
   }
 
   let angle = 0;
-  if (coordinates.x[indexFivePrime] === 0)
+  if (coordinates.x[indexFivePrime] === 0) {
     angle = coordinates.y[indexFivePrime] > coordinates.y[indexThreePrime] ? Math.PI / 2 : 3 * Math.PI / 2;
-  else if (coordinates.y[indexFivePrime] === 0)
+  } else if (coordinates.y[indexFivePrime] === 0) {
     angle = coordinates.x[indexFivePrime] > coordinates.x[indexThreePrime] ? Math.PI : 0;
-  else {
+  } else {
     const derivative = coordinates.y[indexFivePrime] / coordinates.x[indexFivePrime];
-    angle = derivative > 0
-      ? (coordinates.x[indexFivePrime] > 0 ? Math.PI - Math.atan(derivative) : Math.PI * 2 - Math.atan(derivative))
-      : (coordinates.x[indexFivePrime] > 0 ? -Math.PI - Math.atan(derivative) : Math.atan(derivative));
+    angle = derivative > 0 ?
+      (coordinates.x[indexFivePrime] > 0 ? Math.PI - Math.atan(derivative) : Math.PI * 2 - Math.atan(derivative)) :
+      (coordinates.x[indexFivePrime] > 0 ? -Math.PI - Math.atan(derivative) : Math.atan(derivative));
   }
 
   const cos = Math.cos(angle);
@@ -442,9 +438,7 @@ function rotateNucleotidesV3000(molecule: string): string {
   return molBlock;
 }
 
-function reflect(molecule: string): string {
-  // @ts-ignore
-  let molBlock = molecule.includes('M  END') ? molecule : OCL.Molecule.fromSmiles(molecule).toMolfileV3();
+function reflect(molBlock: string): string {
   const coordinates = extractAtomDataV3000(molBlock);
   const natom = coordinates.atomIndex.length;
 
@@ -491,9 +485,7 @@ function reflect(molecule: string): string {
 }
 
 
-function invertNucleotidesV3000(molecule: string) {
-  // @ts-ignore
-  let molBlock = molecule.includes('M  END') ? molecule : OCL.Molecule.fromSmiles(molecule).toMolfileV3();
+function invertNucleotidesV3000(molBlock: string) {
   const coordinates = extractAtomDataV3000(molBlock);
   const natom = coordinates.atomIndex.length;
 

package/src/model/sequence-to-structure-utils/monomer-code-parser.ts

@@ -0,0 +1,92 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {PHOSPHATE_SYMBOL} from './const';
+import {sortByReverseLength} from '../helpers';
+import {MonomerLibWrapper} from '../monomer-lib/lib-wrapper';
+import {monomersWithPhosphateLinkers} from '../data-loading-utils/json-loader';
+
+/** Wrapper for parsing a strand and getting a sequence of monomer IDs (with
+ * omitted linkers, if needed)  */
+export class MonomerSequenceParser {
+  constructor(
+    private sequence: string, private invert: boolean = false,
+    // todo: remove from the list of parameters
+    private codeMap: Map<string, string>
+  ) {
+    this.lib = MonomerLibWrapper.getInstance();
+  }
+
+  private lib: MonomerLibWrapper;
+
+  /** Get sequence of parsed monomer symbols, which are unique short names for
+   * the monomers within the Monomer Library */
+  parseSequence(): string[] {
+    const parsedRawCodes = this.parseRawSequence();
+    return this.addLinkers(parsedRawCodes);
+  }
+
+  private addLinkers(parsedRawCodes: string[]) {
+    const monomerSymbolSequence: string[] = [];
+    parsedRawCodes.forEach((code, i) => {
+      const monomerSymbol = this.getSymbolForCode(code);
+      if (i > 0 && monomerHasLeftPhosphateLinker(monomerSymbol))
+        monomerSymbolSequence.pop();
+
+      monomerSymbolSequence.push(monomerSymbol);
+
+      const isPhosphate = monomerIsPhosphateLinker(monomerSymbol);
+      const lastMonomer = i === parsedRawCodes.length - 1;
+      const nextMonomerIsPhosphate = (i + 1 < parsedRawCodes.length && monomerIsPhosphateLinker(this.getSymbolForCode(parsedRawCodes[i + 1])));
+
+      // todo: refactor as molfile-specific
+      if (!isPhosphate && !monomerHasRightPhosphateLinker(monomerSymbol) && !nextMonomerIsPhosphate && !lastMonomer) {
+        monomerSymbolSequence.push(PHOSPHATE_SYMBOL);
+      }
+    });
+    return monomerSymbolSequence;
+  }
+
+  private getSymbolForCode(code: string): string {
+    let monomerSymbol = this.codeMap.get(code);
+    // todo: remove as a legacy workaround, codeMap must contain all the
+    // symbols, and symbols are not codes
+    monomerSymbol ??= code;
+    return monomerSymbol;
+  }
+
+  private parseRawSequence(): string[] {
+    const allCodesOfFormat = this.getAllCodesOfFormat();
+    const parsedCodes = [];
+    let i = 0;
+    while (i < this.sequence.length) {
+      const code = allCodesOfFormat.find(
+        (s: string) => s === this.sequence.substring(i, i + s.length)
+      )!;
+      this.invert ? parsedCodes.unshift(code) : parsedCodes.push(code);
+      i += code.length;
+    }
+    return parsedCodes;
+  }
+
+  // todo: port to monomer handler
+  private getAllCodesOfFormat(): string[] {
+    let allCodesInTheFormat = Array.from(this.codeMap.keys());
+    return sortByReverseLength(allCodesInTheFormat);
+  }
+}
+
+// todo: to be eliminated after full helm support
+function monomerHasLeftPhosphateLinker(monomerSymbol: string): boolean {
+  return monomersWithPhosphateLinkers['left'].includes(monomerSymbol);
+}
+
+function monomerHasRightPhosphateLinker(monomerSymbol: string): boolean {
+  return monomersWithPhosphateLinkers['right'].includes(monomerSymbol);
+}
+
+function monomerIsPhosphateLinker(monomerSymbol: string): boolean {
+  return monomersWithPhosphateLinkers['phosphate'].includes(monomerSymbol);
+}

package/src/model/sequence-to-structure-utils/sdf-tab.ts

@@ -0,0 +1,94 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
+
+import {download} from '../helpers';
+import {SequenceToMolfileConverter} from './sequence-to-molfile';
+import {linkStrandsV3000} from './mol-transformations';
+import {DEFAULT_FORMATS} from '../const';
+
+export type StrandData = {
+  strand: string,
+  invert: boolean
+}
+
+/** Get a molfile for a single strand */
+export function getMolfileForStrand(strand: string, invert: boolean): string {
+  if (strand === '')
+    return '';
+  const format = DEFAULT_FORMATS.AXOLABS;
+  let molfile = '';
+  try {
+    molfile = (new SequenceToMolfileConverter(strand, invert, format)).convert();
+  } catch (err) {
+    const errStr = errorToConsole(err);
+    console.error(errStr);
+  }
+  return molfile;
+}
+
+/** Get molfile for single strand or linked strands */
+export function getLinkedMolfile(
+  ss: StrandData, as: StrandData, as2: StrandData, useChiral: boolean
+): string {
+  const nonEmptyStrands = [ss, as, as2].filter((item) => item.strand !== '');
+  if (nonEmptyStrands.length === 1) {
+    return getMolfileForStrand(nonEmptyStrands[0].strand, nonEmptyStrands[0].invert);
+  } else {
+    const ssMol = getMolfileForStrand(ss.strand, ss.invert);
+    const asMol = getMolfileForStrand(as.strand, as.invert);
+    const as2Mol = getMolfileForStrand(as2.strand, as2.invert);
+
+    // select only the non-empty anti-strands
+    const antiStrands = [asMol, as2Mol].filter((item) => item !== '');
+    const resultingMolfile = linkStrandsV3000({senseStrands: [ssMol], antiStrands: antiStrands}, useChiral);
+
+    return resultingMolfile;
+  }
+}
+
+/** Save sdf in case ss and as (and optionally as2) strands entered */
+export function saveSdf(
+  ss: StrandData, as: StrandData, as2: StrandData, useChiral: boolean,
+  oneEntity: boolean
+): void {
+  const nonEmptyStrands = [ss.strand, as.strand, as2.strand].filter((item) => item !== '');
+  if (
+    nonEmptyStrands.length === 0 ||
+    nonEmptyStrands.length === 1 && ss.strand === ''
+  ) {
+    grok.shell.warning('Enter SS and AS/AS2 to save SDF');
+  } else {
+    let result: string;
+    if (oneEntity) {
+      result = getLinkedMolfile(ss, as, as2, useChiral) + '\n$$$$\n';
+    } else {
+      const ssMol = getMolfileForStrand(ss.strand, ss.invert);
+      const asMol = getMolfileForStrand(as.strand, as.invert);
+      const as2Mol = getMolfileForStrand(as2.strand, as2.invert);
+      result = ssMol + '\n' +
+        `> <Sequence>\nSense Strand\n$$$$\n`;
+      if (asMol) {
+        result += asMol + '\n' +
+        `> <Sequence>\nAnti Sense\n$$$$\n`;
+      }
+      if (as2Mol) {
+        result += as2Mol + '\n' +
+          `> <Sequence>\nAnti Sense 2\n$$$$\n`;
+      }
+    }
+
+    // construct date-time in the form yyyy-mm-dd_hh-mm-ss
+    const date = new Date();
+    function pad(x: number): string {
+      return (x >= 10) ? x.toString() : '0' + x.toString();
+    }
+    const dateString: string = date.getFullYear() + '-' + pad(date.getMonth() + 1) +
+      '-' + pad(date.getDate()) + '_' + pad(date.getHours()) + '-' +
+      pad(date.getMinutes()) + '-' + pad(date.getSeconds());
+
+    download(`SequenceTranslator-${dateString}.sdf`, encodeURIComponent(result));
+  }
+}