@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/aminoAcidToDegenerateDnaMap.js

@@ -0,0 +1,32 @@
+const aminoAcidToDegenerateDnaMap = {
+  "-": "---",
+  ".": "...",
+  "*": "trr",
+  a: "gcn",
+  b: "ray", // D or N => aay + gay = ray
+  c: "tgy",
+  d: "gay",
+  e: "gar",
+  f: "tty",
+  g: "ggn",
+  h: "cay",
+  i: "ath",
+  j: "htn", // L or I ytn + ath => htn
+  k: "aar",
+  l: "ytn", // YTR、CTN => Y=CT, N=AGCT
+  m: "atg",
+  n: "aay",
+  o: "tag", // Pyrrolysine, https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2933860/
+  p: "ccn",
+  q: "car",
+  r: "mgn", // CGN、MGR => M=AC, N=AGCT
+  s: "wsn", // TCN、AGY => AT = w, CG = S, N is AGCT
+  t: "acn",
+  u: "tga", // Selenocysteine, https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2933860/
+  v: "gtn",
+  w: "tgg",
+  x: "nnn", // unknown aa.
+  y: "tay",
+  z: "sar" // E or Q, => gar + car = sar
+};
+export default aminoAcidToDegenerateDnaMap;

package/src/aminoAcidToDegenerateRnaMap.js

@@ -0,0 +1,32 @@
+const aminoAcidToDegenerateRnaMap = {
+  "-": "---",
+  ".": "...",
+  "*": "trr",
+  a: "gcn",
+  b: "ray",
+  c: "ugy",
+  d: "gay",
+  e: "gar",
+  f: "uuy",
+  g: "ggn",
+  h: "cay",
+  i: "auh",
+  j: "hun",
+  k: "aar",
+  l: "yun",
+  m: "aug",
+  n: "aay",
+  o: "uag",
+  p: "ccn",
+  q: "car",
+  r: "mgn",
+  s: "wsn",
+  t: "acn",
+  u: "uga",
+  v: "gun",
+  w: "ugg",
+  x: "nnn",
+  y: "uay",
+  z: "sar"
+};
+export default aminoAcidToDegenerateRnaMap;

package/src/aminoAcidToDnaRna.test.js

@@ -0,0 +1,27 @@
+import {expect} from "chai";
+import getDegenerateDnaStringFromAAString from "./getDegenerateDnaStringFromAAString";
+import getDegenerateRnaStringFromAAString from "./getDegenerateRnaStringFromAAString";
+
+describe("amino acid to RNA or DNA should be correct", () => {
+  it('should return a string with no "u/U" in it when parse AA sequence to DNA sequence.', () => {
+    const aaStr = "AQRSTFFVCL";
+    const DNASeq = getDegenerateDnaStringFromAAString(aaStr);
+    const RNASeq = getDegenerateRnaStringFromAAString(aaStr);
+    expect(DNASeq.length)
+      .equal(RNASeq.length)
+      .equal(aaStr.length * 3);
+    expect(DNASeq.toLowerCase().includes("u")).equal(false);
+    expect(DNASeq.toLowerCase().includes("t")).equal(true);
+
+    expect(RNASeq.toLowerCase().includes("t")).equal(false);
+    expect(RNASeq.toLowerCase().includes("u")).equal(true);
+
+    expect(RNASeq.toLowerCase().replace(/u/gi, "t")).equal(
+      DNASeq.toLowerCase()
+    );
+
+    expect(DNASeq.toLowerCase().replace(/t/gi, "u")).equal(
+      RNASeq.toLowerCase()
+    );
+  });
+});

package/src/annotateSingleSeq.js

@@ -0,0 +1,29 @@
+import {autoAnnotate} from "./autoAnnotate";
+
+function annotateSingleSeq({ fullSeq, searchSeq }) {
+  const fullSeqId = fullSeq.id || "fullSeqId";
+  const searchSeqId = searchSeq.id || "searchSeqId";
+  const results = autoAnnotate({
+    seqsToAnnotateById: {
+      [fullSeqId]: {
+        ...fullSeq,
+        id: fullSeqId
+      }
+    },
+    annotationsToCheckById: {
+      [searchSeqId]: {
+        ...searchSeq,
+        id: searchSeqId
+      }
+    },
+    compareName: false
+  });
+  if (results && results[fullSeqId]) {
+    return {
+      matches: results[fullSeqId]
+    };
+  } else {
+    return { matches: [] };
+  }
+}
+export default annotateSingleSeq;

package/src/annotateSingleSeq.test.js

@@ -0,0 +1,64 @@
+import annotateSingleSeq from "./annotateSingleSeq";
+import {expect} from "chai";
+
+describe("annotateSingleSeq", () => {
+  it(`regexes work - correctly annotates a single seq with a regex annotation`, () => {
+    const results = annotateSingleSeq({
+      fullSeq: { sequence: "AAAATTTTGGGGGCCCCCAAGT" },
+      searchSeq: { sequence: "TTTT.*CCC" }
+    });
+    // eslint-disable-next-line no-unused-expressions
+    expect(results).to.not.be.undefined;
+    //this should return an object keyed by the sequence id with the list of annotations to create
+    expect(results).to.deep.eq({
+      matches: [
+        {
+          start: 4,
+          end: 17,
+          strand: 1,
+          id: "searchSeqId"
+        }
+      ]
+    });
+
+  });
+  it(`correctly annotates a single seq with multiple matches`, () => {
+    const results = annotateSingleSeq({
+      fullSeq: { sequence: "AAAATTTTGGGGGCCCCCAAGTAAAATTTTGGGGGCCCCCAAGT" },
+      searchSeq: { sequence: "AAAATTTTGGGGGCCCCCAAGT", id: 2 }
+    });
+    // eslint-disable-next-line no-unused-expressions
+    expect(results).to.not.be.undefined;
+    //this should return an object keyed by the sequence id with the list of annotations to create
+    expect(results).to.deep.eq({
+      matches: [
+        {
+          start: 0,
+          end: 21,
+          strand: 1,
+          id: 2
+        },
+        {
+          start: 22,
+          end: 43,
+          strand: 1,
+          id: 2
+        }
+      ]
+    });
+
+  });
+  it(`correctly finds no matches when there are none`, () => {
+    const results = annotateSingleSeq({
+      fullSeq: { sequence: "AAAATTTTGGGGGCCCCCAAGTAAAATTTTGGGGGCCCCCAAGT" },
+      searchSeq: { sequence: "AAAATTTTGGGGGGGGGGCCCCCAAGT" }
+    });
+    // eslint-disable-next-line no-unused-expressions
+    expect(results).to.not.be.undefined;
+    //this should return an object keyed by the sequence id with the list of annotations to create
+    expect(results).to.deep.eq({
+      matches: []
+    });
+
+  });
+});

package/src/annotationTypes.js

@@ -0,0 +1,23 @@
+export const annotationTypes = [
+  "features",
+  "warnings",
+  "assemblyPieces",
+  "lineageAnnotations",
+  "parts",
+  "cutsites",
+  "orfs",
+  "translations",
+  "primers",
+  "guides"
+];
+
+export const modifiableTypes = [
+  "features",
+  "assemblyPieces",
+  "lineageAnnotations",
+  "warnings",
+  "parts",
+  "translations",
+  "primers",
+  "guides"
+];

package/src/autoAnnotate.js

@@ -0,0 +1,242 @@
+/* Copyright (C) 2018 TeselaGen Biotechnology, Inc. */
+import {forEach, omitBy} from "lodash";
+import { ambiguous_dna_values } from "./bioData";
+import aminoAcidToDegenerateDnaMap from "./aminoAcidToDegenerateDnaMap";
+import {normalizePositionByRangeLength, reversePositionInRange} from "@teselagen/range-utils";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+
+//seqsToAnnotateById must not be length = 0
+function autoAnnotate({
+  seqsToAnnotateById,
+  annotationsToCheckById,
+  compareName,
+  warnIfMoreThan
+}) {
+  const annotationsToAddBySeqId = {};
+
+  forEach(annotationsToCheckById, ann => {
+    const reg = new RegExp(ann.sequence, "gi");
+    forEach(
+      omitBy(seqsToAnnotateById, s => !s.sequence.length),
+      ({ circular, sequence }, id) => {
+        function getMatches({ seqToMatchAgainst, isReverse, seqLen }) {
+          let match;
+          let lastMatch;
+          // const matches = []
+          try {
+            while ((match = reg.exec(seqToMatchAgainst))) {
+              const { index: matchStart, 0: matchSeq } = match;
+              if (matchStart >= seqLen) return;
+              const matchEnd = matchStart + matchSeq.length;
+              if (lastMatch) {
+                if (matchStart > lastMatch.start && matchEnd <= lastMatch.end) {
+                  reg.lastIndex = match.index + 1;
+                  continue;
+                }
+              }
+              lastMatch = {
+                start: matchStart,
+                end: matchEnd
+              };
+              const range = {
+                start: matchStart,
+                end: normalizePositionByRangeLength(matchEnd - 1, seqLen)
+              };
+              if (!annotationsToAddBySeqId[id])
+                annotationsToAddBySeqId[id] = [];
+              annotationsToAddBySeqId[id].push({
+                ...(isReverse
+                  ? {
+                      start: reversePositionInRange(range.end, seqLen),
+                      end: reversePositionInRange(range.start, seqLen)
+                    }
+                  : range),
+                strand: isReverse ? -1 : 1,
+                id: ann.id
+              });
+
+              reg.lastIndex = match.index + 1;
+            }
+          } catch (error) {
+            console.error(`error:`, error);
+          }
+        }
+        const seqLen = sequence.length;
+
+        const revSeq = getReverseComplementSequenceString(sequence);
+        getMatches({
+          seqLen,
+          seqToMatchAgainst: circular ? sequence + sequence : sequence
+        });
+        getMatches({
+          seqLen,
+          isReverse: true,
+          seqToMatchAgainst: circular ? revSeq + revSeq : revSeq
+        });
+      }
+    );
+  });
+
+  //loop through all patterns and get all matches
+
+  const toReturn = {};
+
+  forEach(annotationsToAddBySeqId, (anns, id) => {
+    const origSeq = seqsToAnnotateById[id];
+    const alreadyExistingAnnsByStartEnd = {};
+    forEach(origSeq.annotations, ann => {
+      alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })] = ann;
+    });
+    const warningCounter = {};
+    const toAdd = anns
+      .filter(ann => {
+        const alreadyExistingAnn =
+          alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })];
+        if (alreadyExistingAnn) return false;
+        if (warnIfMoreThan) {
+          warningCounter[ann.id] = (warningCounter[ann.id] || 0) + 1;
+        }
+        return true;
+      })
+      .sort((a, b) => a.start - b.start);
+    if (toAdd.length) {
+      toReturn[id] = toAdd;
+    }
+    warnIfMoreThan &&
+      forEach(warningCounter, (num, annId) => {
+        if (num > warnIfMoreThan) {
+          toReturn.__more_than_warnings = toReturn.__more_than_warnings || {};
+          toReturn.__more_than_warnings[id] =
+            toReturn.__more_than_warnings[id] || [];
+          toReturn.__more_than_warnings[id].push(annId);
+        }
+      });
+  });
+  return toReturn;
+}
+
+function getStartEndStr(
+  { start, end, name, strand, forward },
+  { compareName }
+) {
+  const isReverse = strand === -1 || forward === false;
+  return `${start}-${end}-${isReverse ? "rev" : "for"}-${
+    compareName ? name : ""
+  }`;
+}
+
+function convertApELikeRegexToRegex(regString = "") {
+  let newstr = "";
+  let rightOfCaretHolder = "";
+  let afterRightCaretHolder = "";
+  let beforeRightCaret = "";
+  let prevBp;
+  let hitLeftCaret;
+  let hitRightCaret;
+
+  // eslint-disable-next-line no-unused-vars
+  for (const bp of regString.replace("(", "").replace(")", "")) {
+    /* eslint-disable no-loop-func*/
+    /* eslint-disable no-inner-declarations*/
+    function maybeHandleRightCaret(justAdded) {
+      if (hitRightCaret) {
+        rightOfCaretHolder += justAdded;
+        afterRightCaretHolder = `${rightOfCaretHolder}${
+          afterRightCaretHolder.length ? "|" : ""
+        }${afterRightCaretHolder}`;
+      }
+    }
+    /* eslint-enable no-loop-func*/
+    /* eslint-enable no-inner-declarations*/
+    const ambigVal = ambiguous_dna_values[bp.toUpperCase()];
+    if (ambigVal && ambigVal.length > 1) {
+      let valToUse;
+      if (ambigVal.length === 4) {
+        valToUse = ".";
+      } else {
+        valToUse = `[${ambigVal}]`;
+      }
+      newstr += valToUse;
+      maybeHandleRightCaret(valToUse);
+      continue;
+    }
+    if (bp === "#") {
+      if (hitRightCaret) throw new Error("Error converting regex");
+      const valToUse = prevBp ? `[^${prevBp}]*?` : `.*?`;
+      newstr += valToUse;
+      maybeHandleRightCaret(valToUse);
+      continue;
+    }
+    if (bp === "<") {
+      if (hitRightCaret) throw new Error("Error converting to regex");
+      if (hitLeftCaret) throw new Error("Error converting to regex");
+      let holder = "";
+      let stringToAdd = "";
+      let isGroupClosed = true;
+      let closingBraceHit;
+      const groups = [];
+      for (let index = 0; index < newstr.length; index++) {
+        const char = newstr[index];
+        const nextChar = newstr[index + 1];
+        if (char === "[") {
+          isGroupClosed = false;
+        } else if (char === "]" || closingBraceHit) {
+          closingBraceHit = true;
+          if (ambiguous_dna_values[nextChar] || nextChar === "[") {
+            isGroupClosed = true;
+            closingBraceHit = false;
+          }
+        }
+        holder += char;
+        if (isGroupClosed) {
+          groups.push(holder);
+          holder = "";
+        }
+      }
+      let concattedEls = "";
+      groups.reverse();
+      groups.forEach(g => {
+        concattedEls = g + concattedEls;
+        stringToAdd = `${concattedEls}${
+          stringToAdd.length ? "|" : ""
+        }${stringToAdd}`;
+      });
+      newstr = `(${stringToAdd})?`;
+      hitLeftCaret = true;
+      continue;
+    }
+    if (bp === ">") {
+      if (hitRightCaret) throw new Error("Error converting regex");
+      hitRightCaret = true;
+      beforeRightCaret = newstr;
+      continue;
+    }
+    newstr += bp;
+    maybeHandleRightCaret(bp);
+    prevBp = bp;
+  }
+  if (hitRightCaret) {
+    newstr = `${beforeRightCaret}(${afterRightCaretHolder})?`;
+  }
+  return newstr;
+}
+function convertProteinSeqToDNAIupac(sequence) {
+  let toRet = "";
+  let l;
+  for (l of sequence) {
+    const degenDna = aminoAcidToDegenerateDnaMap[l.toLowerCase()];
+    if (degenDna) {
+      toRet += degenDna;
+    } else {
+      toRet += l;
+    }
+  }
+
+  return toRet;
+}
+
+export {
+  convertProteinSeqToDNAIupac,
+  convertApELikeRegexToRegex,
+  autoAnnotate
+};