@datagrok/sequence-translator 0.0.5 → 0.0.9

package/src/structures-works/sequence-codes-tools.ts

@@ -0,0 +1,236 @@
+import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from './map';
+import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
+  asoGapmersBioSpringToNucleotides, asoGapmersBioSpringToGcrs, asoGapmersGcrsToNucleotides,
+  asoGapmersGcrsToBioSpring, gcrsToMermade12, siRnaNucleotideToBioSpringSenseStrand,
+  siRnaNucleotideToAxolabsSenseStrand, siRnaNucleotidesToGcrs, siRnaBioSpringToNucleotides,
+  siRnaBioSpringToAxolabs, siRnaBioSpringToGcrs, siRnaAxolabsToNucleotides,
+  siRnaAxolabsToBioSpring, siRnaAxolabsToGcrs, siRnaGcrsToNucleotides,
+  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides} from './converters';
+
+const noTranslationTableAvailable = 'No translation table available';
+export const undefinedInputSequence = 'Type of input sequence is undefined';
+
+export function isValidSequence(sequence: string): {
+  indexOfFirstNotValidCharacter: number,
+  expectedSynthesizer: string | null,
+  expectedTechnology: string | null
+} {
+  const possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
+  if (possibleSynthesizers.length == 0)
+    return {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+
+  let outputIndices = Array(possibleSynthesizers.length).fill(0);
+
+  const firstUniqueCharacters = ['r', 'd'];
+  const nucleotides = ['A', 'U', 'T', 'C', 'G'];
+
+  possibleSynthesizers.forEach((synthesizer, synthesizerIndex) => {
+    const codes = getAllCodesOfSynthesizer(synthesizer);
+    while (outputIndices[synthesizerIndex] < sequence.length) {
+      const matchedCode = codes
+        .find((c) => c == sequence.slice(outputIndices[synthesizerIndex], outputIndices[synthesizerIndex] + c.length));
+
+      if (matchedCode == null)
+        break;
+
+      if ( // for mistake pattern 'rAA'
+        outputIndices[synthesizerIndex] > 1 &&
+        nucleotides.includes(sequence[outputIndices[synthesizerIndex]]) &&
+        firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] + 1]) &&
+        nucleotides.includes(sequence[outputIndices[synthesizerIndex]])
+      ) {
+        outputIndices[synthesizerIndex]++;
+        break;
+      }
+
+      outputIndices[synthesizerIndex] += matchedCode.length;
+    }
+  });
+
+  const indexOfExpectedSythesizer = Math.max(...outputIndices);
+  const indexOfFirstNotValidCharacter = (indexOfExpectedSythesizer == sequence.length) ? -1 : indexOfExpectedSythesizer;
+  const expectedSynthesizer = possibleSynthesizers[outputIndices.indexOf(indexOfExpectedSythesizer)];
+  if (indexOfFirstNotValidCharacter != -1) {
+    return {
+      indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
+      expectedSynthesizer: expectedSynthesizer,
+      expectedTechnology: null,
+    };
+  }
+
+  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, expectedSynthesizer);
+  if (possibleTechnologies.length == 0)
+    return {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+
+  outputIndices = Array(possibleTechnologies.length).fill(0);
+
+  possibleTechnologies.forEach((technology: string, technologyIndex: number) => {
+    const codes = Object.keys(map[expectedSynthesizer][technology]);
+    while (outputIndices[technologyIndex] < sequence.length) {
+      const matchedCode = codes
+        .find((c) => c == sequence.slice(outputIndices[technologyIndex], outputIndices[technologyIndex] + c.length));
+
+      if (matchedCode == null)
+        break;
+
+      if ( // for mistake pattern 'rAA'
+        outputIndices[technologyIndex] > 1 &&
+        nucleotides.includes(sequence[outputIndices[technologyIndex]]) &&
+        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] + 1]) &&
+        nucleotides.includes(sequence[outputIndices[technologyIndex]])
+      ) {
+        outputIndices[technologyIndex]++;
+        break;
+      }
+
+      outputIndices[technologyIndex] += matchedCode.length;
+    }
+  });
+
+  const indexOfExpectedTechnology = Math.max(...outputIndices);
+  const expectedTechnology = possibleTechnologies[outputIndices.indexOf(indexOfExpectedTechnology)];
+
+  return {
+    indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
+    expectedSynthesizer: expectedSynthesizer,
+    expectedTechnology: expectedTechnology,
+  };
+}
+
+function getAllCodesOfSynthesizer(synthesizer: string): string[] {
+  let codes: string[] = [];
+  for (const technology of Object.keys(map[synthesizer]))
+    codes = codes.concat(Object.keys(map[synthesizer][technology]));
+  return codes.concat(Object.keys(MODIFICATIONS));
+}
+
+function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): string[] {
+  const synthesizers: string[] = [];
+  Object.keys(map).forEach((synthesizer: string) => {
+    const codes = getAllCodesOfSynthesizer(synthesizer);
+    //TODO: get first non-dropdown code when there are two modifications
+    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(synthesizer);
+  });
+  return synthesizers;
+}
+
+function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synthesizer: string): string[] {
+  const technologies: string[] = [];
+  Object.keys(map[synthesizer]).forEach((technology: string) => {
+    const codes = Object.keys(map[synthesizer][technology]).concat(Object.keys(MODIFICATIONS));
+    if (codes.some((s) => s == sequence.slice(0, s.length)))
+      technologies.push(technology);
+  });
+  return technologies;
+}
+
+export function convertSequence(text: string) {
+  text = text.replace(/\s/g, '');
+  const seq = text;
+  const output = isValidSequence(seq);
+  if (output.indexOfFirstNotValidCharacter != -1) {
+    return {
+      // type: '',
+      indexOfFirstNotValidCharacter: JSON.stringify(output),
+      Error: undefinedInputSequence,
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.DNA) {
+    return {
+      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.DNA,
+      Nucleotides: seq,
+      BioSpring: asoGapmersNucleotidesToBioSpring(seq),
+      GCRS: asoGapmersNucleotidesToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS) {
+    return {
+      type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.ASO_GAPMERS,
+      Nucleotides: asoGapmersBioSpringToNucleotides(seq),
+      BioSpring: seq,
+      GCRS: asoGapmersBioSpringToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS) {
+    return {
+      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.ASO_GAPMERS,
+      Nucleotides: asoGapmersGcrsToNucleotides(seq),
+      BioSpring: asoGapmersGcrsToBioSpring(seq),
+      Mermade12: gcrsToMermade12(seq),
+      GCRS: seq,
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.RNA) {
+    return {
+      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.RNA,
+      Nucleotides: seq,
+      BioSpring: siRnaNucleotideToBioSpringSenseStrand(seq),
+      Axolabs: siRnaNucleotideToAxolabsSenseStrand(seq),
+      GCRS: siRnaNucleotidesToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaBioSpringToNucleotides(seq),
+      BioSpring: seq,
+      Axolabs: siRnaBioSpringToAxolabs(seq),
+      GCRS: siRnaBioSpringToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.AXOLABS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaAxolabsToNucleotides(seq),
+      BioSpring: siRnaAxolabsToBioSpring(seq),
+      Axolabs: seq,
+      GCRS: siRnaAxolabsToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaGcrsToNucleotides(seq),
+      BioSpring: siRnaGcrsToBioSpring(seq),
+      Axolabs: siRnaGcrsToAxolabs(seq),
+      MM12: gcrsToMermade12(seq),
+      GCRS: seq,
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS) {
+    return {
+      type: SYNTHESIZERS.GCRS,
+      Nucleotides: gcrsToNucleotides(seq),
+      GCRS: seq,
+      Mermade12: gcrsToMermade12(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.MERMADE_12) {
+    return {
+      type: SYNTHESIZERS.MERMADE_12,
+      Nucleotides: noTranslationTableAvailable,
+      GCRS: noTranslationTableAvailable,
+      Mermade12: seq,
+    };
+  }
+  return {
+    type: undefinedInputSequence,
+    Nucleotides: undefinedInputSequence,
+  };
+}

package/src/tests/smiles-tests.ts

@@ -1,5 +1,5 @@
 import {category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {sequenceToSmiles} from '../package';
+import {sequenceToSmiles} from '../structures-works/from-monomers';
 
 category('sequence-translator', () => {
   test('AGGTCCTCTTGACTTAGGCC', async () => {

package/src/users.ts

@@ -0,0 +1,3 @@
+export const USERS_CSV = `DISPLAY
+NO DATA
+`;

package/test-SequenceTranslator-2e08c8e54bde-1367d435.html

@@ -0,0 +1,245 @@
+<html><head><meta charset="utf-8"/><title>SequenceTranslator Test Report. Datagrok version datagrok/datagrok:latest SHA=2e08c8e54bde. Commit 1367d435.</title><style type="text/css">html,
+body {
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: 1rem;
+  margin: 0;
+  padding: 0;
+  color: #333;
+}
+body {
+  padding: 2rem 1rem;
+  font-size: 0.85rem;
+}
+#jesthtml-content {
+  margin: 0 auto;
+  max-width: 70rem;
+}
+header {
+  display: flex;
+  align-items: center;
+}
+#title {
+  margin: 0;
+  flex-grow: 1;
+}
+#logo {
+  height: 4rem;
+}
+#timestamp {
+  color: #777;
+  margin-top: 0.5rem;
+}
+
+/** SUMMARY */
+#summary {
+  color: #333;
+  margin: 2rem 0;
+  display: flex;
+  font-family: monospace;
+  font-size: 1rem;
+}
+#summary > div {
+  margin-right: 2rem;
+  background: #eee;
+  padding: 1rem;
+  min-width: 15rem;
+}
+#summary > div:last-child {
+  margin-right: 0;
+}
+@media only screen and (max-width: 720px) {
+  #summary {
+    flex-direction: column;
+  }
+  #summary > div {
+    margin-right: 0;
+    margin-top: 2rem;
+  }
+  #summary > div:first-child {
+    margin-top: 0;
+  }
+}
+
+.summary-total {
+  font-weight: bold;
+  margin-bottom: 0.5rem;
+}
+.summary-passed {
+  color: #4f8a10;
+  border-left: 0.4rem solid #4f8a10;
+  padding-left: 0.5rem;
+}
+.summary-failed,
+.summary-obsolete-snapshots {
+  color: #d8000c;
+  border-left: 0.4rem solid #d8000c;
+  padding-left: 0.5rem;
+}
+.summary-pending {
+  color: #9f6000;
+  border-left: 0.4rem solid #9f6000;
+  padding-left: 0.5rem;
+}
+.summary-empty {
+  color: #999;
+  border-left: 0.4rem solid #999;
+}
+
+.test-result {
+  padding: 1rem;
+  margin-bottom: 0.25rem;
+}
+.test-result:last-child {
+  border: 0;
+}
+.test-result.passed {
+  background-color: #dff2bf;
+  color: #4f8a10;
+}
+.test-result.failed {
+  background-color: #ffbaba;
+  color: #d8000c;
+}
+.test-result.pending {
+  background-color: #ffdf61;
+  color: #9f6000;
+}
+
+.test-info {
+  display: flex;
+  justify-content: space-between;
+}
+.test-suitename {
+  width: 20%;
+  text-align: left;
+  font-weight: bold;
+  word-break: break-word;
+}
+.test-title {
+  width: 40%;
+  text-align: left;
+  font-style: italic;
+}
+.test-status {
+  width: 20%;
+  text-align: right;
+}
+.test-duration {
+  width: 10%;
+  text-align: right;
+  font-size: 0.75rem;
+}
+
+.failureMessages {
+  padding: 0 1rem;
+  margin-top: 1rem;
+  border-top: 1px dashed #d8000c;
+}
+.failureMessages.suiteFailure {
+  border-top: none;
+}
+.failureMsg {
+  white-space: pre-wrap;
+  white-space: -moz-pre-wrap;
+  white-space: -pre-wrap;
+  white-space: -o-pre-wrap;
+  word-wrap: break-word;
+}
+
+.suite-container {
+  margin-bottom: 2rem;
+}
+.suite-info {
+  padding: 1rem;
+  background-color: #eee;
+  color: #777;
+  display: flex;
+  align-items: center;
+  margin-bottom: 0.25rem;
+}
+.suite-info .suite-path {
+  word-break: break-all;
+  flex-grow: 1;
+  font-family: monospace;
+  font-size: 1rem;
+}
+.suite-info .suite-time {
+  margin-left: 0.5rem;
+  padding: 0.2rem 0.3rem;
+  font-size: 0.75rem;
+}
+.suite-info .suite-time.warn {
+  background-color: #d8000c;
+  color: #fff;
+}
+
+/* CONSOLE LOGS */
+.suite-consolelog {
+  margin-bottom: 0.25rem;
+  padding: 1rem;
+  background-color: #efefef;
+}
+.suite-consolelog-header {
+  font-weight: bold;
+}
+.suite-consolelog-item {
+  padding: 0.5rem;
+}
+.suite-consolelog-item pre {
+  margin: 0.5rem 0;
+  white-space: pre-wrap;
+  white-space: -moz-pre-wrap;
+  white-space: -pre-wrap;
+  white-space: -o-pre-wrap;
+  word-wrap: break-word;
+}
+.suite-consolelog-item-origin {
+  color: #777;
+  font-weight: bold;
+}
+.suite-consolelog-item-message {
+  color: #000;
+  font-size: 1rem;
+  padding: 0 0.5rem;
+}
+
+/* OBSOLETE SNAPSHOTS */
+.suite-obsolete-snapshots {
+  margin-bottom: 0.25rem;
+  padding: 1rem;
+  background-color: #ffbaba;
+  color: #d8000c;
+}
+.suite-obsolete-snapshots-header {
+  font-weight: bold;
+}
+.suite-obsolete-snapshots-item {
+  padding: 0.5rem;
+}
+.suite-obsolete-snapshots-item pre {
+  margin: 0.5rem 0;
+  white-space: pre-wrap;
+  white-space: -moz-pre-wrap;
+  white-space: -pre-wrap;
+  white-space: -o-pre-wrap;
+  word-wrap: break-word;
+}
+.suite-obsolete-snapshots-item-message {
+  color: #000;
+  font-size: 1rem;
+  padding: 0 0.5rem;
+}
+</style></head><body><div id="jesthtml-content"><header><h1 id="title">SequenceTranslator Test Report. Datagrok version datagrok/datagrok:latest SHA=2e08c8e54bde. Commit 1367d435.</h1></header><div id="metadata-container"><div id="timestamp">Started: 2022-04-20 13:02:23</div><div id="summary"><div id="suite-summary"><div class="summary-total">Suites (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div><div id="test-summary"><div class="summary-total">Tests (1)</div><div class="summary-passed summary-empty">0 passed</div><div class="summary-failed">1 failed</div><div class="summary-pending summary-empty">0 pending</div></div></div></div><div id="suite-1" class="suite-container"><div class="suite-info"><div class="suite-path">/home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/remote.test.ts</div><div class="suite-time warn">18.061s</div></div><div class="suite-tests"><div class="test-result failed"><div class="test-info"><div class="test-suitename"> </div><div class="test-title">TEST</div><div class="test-status">failed</div><div class="test-duration">0.524s</div></div><div class="failureMessages"> <pre class="failureMsg">Error: Evaluation failed: Unable to find JS function "test"
+    at ExecutionContext._evaluateInternal (/home/runner/work/public/public/packages/SequenceTranslator/node_modules/puppeteer/src/common/ExecutionContext.ts:273:13)
+    at processTicksAndRejections (internal/process/task_queues.js:97:5)
+    at ExecutionContext.evaluate (/home/runner/work/public/public/packages/SequenceTranslator/node_modules/puppeteer/src/common/ExecutionContext.ts:140:12)</pre></div></div></div><div class="suite-consolelog"><div class="suite-consolelog-header">Console Log</div><div class="suite-consolelog-item"><pre class="suite-consolelog-item-origin">    at Object.&lt;anonymous&gt; (/home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/test-node.ts:62:11)
+    at Generator.next (&lt;anonymous&gt;)
+    at fulfilled (/home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/test-node.ts:24:58)
+    at processTicksAndRejections (internal/process/task_queues.js:97:5)</pre><pre class="suite-consolelog-item-message">Using web root: http://localhost:8080</pre></div><div class="suite-consolelog-item"><pre class="suite-consolelog-item-origin">    at /home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/remote.test.ts:24:11
+    at Generator.next (&lt;anonymous&gt;)
+    at /home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/remote.test.ts:27:71
+    at new Promise (&lt;anonymous&gt;)
+    at Object.&lt;anonymous&gt;.__awaiter (/home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/remote.test.ts:23:12)
+    at Object.&lt;anonymous&gt; (/home/runner/work/public/public/packages/SequenceTranslator/src/__jest__/remote.test.ts:22:23)
+    at Promise.then.completed (/home/runner/work/public/public/packages/SequenceTranslator/node_modules/jest-circus/build/utils.js:391:28)
+    at new Promise (&lt;anonymous&gt;)</pre><pre class="suite-consolelog-item-message">Testing SequenceTranslator package</pre></div></div></div></div></body></html>

package/tsconfig.json

@@ -10,7 +10,8 @@
     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
     "lib": [
       "es2020",
-      "dom"
+      "dom",
+      "ES2021.String"
     ],
     /* Specify library files to be included in the compilation. */
     // "allowJs": true,                             /* Allow javascript files to be compiled. */

package/src/save-sense-antisense.ts

@@ -1,36 +0,0 @@
-import * as ui from 'datagrok-api/ui';
-import {sequenceToSmiles} from './package';
-import * as OCL from 'openchemlib/full.js';
-
-export function saveSenseAntiSense() {
-  const ssInput = ui.textInput('Sense Strand 5\' ->3\'', '');
-  const asInput = ui.textInput('Anti Sense 3\' ->5\'', '');
-  const saveBtn = ui.button('Save SDF', () => {
-    const smiSS = sequenceToSmiles(ssInput.value);
-    const smiAS = sequenceToSmiles(asInput.value, true);
-    const result =
-      `${OCL.Molecule.fromSmiles(smiSS).toMolfile()}\n` +
-      `>  <Sequence>\nSense Strand\n\n$$$$\n` +
-      `${OCL.Molecule.fromSmiles(smiAS).toMolfile()}\n` +
-      `>  <Sequence>\nAnti Sense\n\n$$$$\n`;
-    const element = document.createElement('a');
-    element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
-    element.setAttribute('download', ssInput.value.replace(/\s/g, '') + '.sdf');
-    element.click();
-  });
-
-  const saveSection = ui.panel([
-    ui.div([
-      ui.div([
-        ui.divH([ui.h1('Inputs')]),
-        ui.divV([
-          ui.div([ssInput.root]),
-          ui.div([asInput.root]),
-          ui.buttonsInput([saveBtn]),
-        ], 'ui-form'),
-      ], 'ui-form'),
-    ], 'ui-form'),
-  ]);
-
-  return saveSection;
-}