@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/generateSequenceData.js

@@ -0,0 +1,206 @@
+// this is throwing a weird eslint error
+
+//
+
+import generateAnnotations from "./generateAnnotations";
+
+export default function generateSequenceData({
+  isProtein,
+  sequenceLength = 1000,
+  numFeatures,
+  numParts,
+  numPrimers,
+  numTranslations
+} = {}) {
+  const proteinSequence = isProtein && generateSequence(sequenceLength, true);
+  const sequence = !isProtein && generateSequence(sequenceLength);
+
+  return {
+    circular: isProtein ? false : Math.random() > 0.5,
+    name: "p-" + Math.floor(Math.random * 100),
+    description: "",
+    isProtein,
+    sequence,
+    proteinSequence,
+    translations: isProtein
+      ? undefined
+      : generateAnnotations(
+          numTranslations || 5,
+          0,
+          sequenceLength - 1,
+          sequenceLength / 3
+        ),
+    features: generateAnnotations(
+      numFeatures || 10,
+      0,
+      sequenceLength - 1,
+      sequenceLength / 3
+    ),
+    primers: isProtein
+      ? undefined
+      : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
+    parts: generateAnnotations(
+      numParts || 10,
+      0,
+      sequenceLength - 1,
+      sequenceLength / 3
+    )
+  };
+};
+
+// export default tidyUpSequenceData(exampleData)
+
+function generateSequence(m = 9, isProtein) {
+  let s = "";
+  const r = isProtein ? "" : "gatc";
+  for (let i = 0; i < m; i++) {
+    s += r.charAt(Math.floor(Math.random() * r.length));
+  }
+  return s;
+}
+
+// tnr: this is used to generate a very large, multi-featured sequence
+// var string = "ggggcccccgggggccc";
+// var reallyLongFakeSequence = "";
+// for (var i = 1; i < 100000; i++) {
+//   reallyLongFakeSequence += string;
+//   if (i % 100 === 0) {
+//     reallyLongFakeSequence += 'taafatg';
+//     sequenceData.features.push({
+//       id: i,
+//       start: parseInt(i * 10),
+//       end: parseInt(i * 10 + 100),
+//       name: 'cooljim',
+//       color: 'green',
+//       forward: true,
+//       annotationType: "feature"
+//     });
+//   }
+// }
+// sequenceData.sequence += reallyLongFakeSequence;
+//
+// export default function() {
+//   var baseSeqData = {
+//
+//   }
+//   function seqGen() {
+//
+//   }
+// }
+// "features" : [
+//     {
+//         "name" : "1",
+//         "type" : "misc_feature",
+//         "start" : 1,
+//         "end" : 1,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'blue'
+//     },
+//     {
+//         "name" : "2",
+//         "type" : "misc_feature",
+//         "start" : 1,
+//         "end" : 1,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'blue'
+//     },
+//     {
+//         "name" : "3",
+//         "type" : "misc_feature",
+//         "start" : 1,
+//         "end" : 1,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'blue'
+//     },
+//     {
+//         "name" : "4",
+//         "type" : "misc_feature",
+//         "start" : 1,
+//         "end" : 14,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'blue'
+//     },
+//     {
+//         "name" : "5",
+//         "type" : "misc_feature",
+//         "start" : 1,
+//         "end" : 1,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'blue'
+//     },
+//     {
+//         "name" : "6",
+//         "type" : "misc_feature",
+//         "id" : "5590c1978fafgw979df000a4f02c7a",
+//         "start" : 4,
+//         "end" : 6,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'orange'
+//     },
+//     {
+//         "name" : "housemouserousepouse",
+//         "type" : "misc_feature",
+//         "id" : "5590c197897fs9df000a4f02c7a",
+//         "start" : 4,
+//         "end" : 6,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'orange'
+//     },
+//     {
+//         "name" : "housemouserousepouse",
+//         "type" : "misc_feature",
+//         "id" : "5590c1978979dasdfaf000a4f02c7a",
+//         "start" : 4,
+//         "end" : 6,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'orange'
+//     },
+//     {
+//         "name" : "housemouserousepouse",
+//         "type" : "misc_feature",
+//         "id" : "5590c197faas8979df000a4f02c7a",
+//         "start" : 4,
+//         "end" : 6,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'orange'
+//     },
+//     {
+//         "name" : "housemouserousepouse",
+//         "type" : "misc_feature",
+//         "id" : "5590c1978979df000a4f02c7aasd",
+//         "start" : 4,
+//         "end" : 6,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'orange'
+//     },
+//     {
+//         "name" : "house",
+//         "type" : "misc_feature",
+//         "id" : "5590c1978979df000a4f02c7b",
+//         "start" : 70,
+//         "end" : 90,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'green'
+//     },
+//     {
+//         "name" : "weer",
+//         "type" : "misc_feature",
+//         "id" : "5590c1d88979df000a4f02f5c",
+//         "start" : 3,
+//         "end" : 69,
+//         "strand" : 1,
+//         "notes" : [],
+//         "color": 'red'
+//     }
+// ],

package/src/generateSequenceData.test.js

@@ -0,0 +1,22 @@
+import generateSequenceData from "./generateSequenceData";
+import chai from "chai";
+import chaiSubset from "chai-subset";
+import {map} from "lodash";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("generateSequenceData", () => {
+  it("should generate some nice random data", () => {
+    generateSequenceData({ sequenceLength: 100 }).sequence.length.should.equal(
+      100
+    );
+  });
+  it("numFeatures should work", () => {
+    const a = generateSequenceData({
+      sequenceLength: 100,
+      numFeatures: 100
+    });
+    map(a.features).length.should.equal(100);
+  });
+});

package/src/getAllInsertionsInSeqReads.js

@@ -0,0 +1,83 @@
+// seqReads should be an array of objects [{name, seq, pos, cigar}, {name, seq, pos, cigar}, ...]
+export default function getAllInsertionsInSeqReads(seqReads) {
+  const allInsertionsInSeqReads = [];
+  seqReads.forEach(seqRead => {
+    // split cigar string at M, D, or I (match, deletion, or insertion), e.g. ["2M", "3I", "39M", "3D"...]
+    const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g);
+
+    for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
+      if (splitSeqRead[componentI].slice(-1) === "I") {
+        let bpPosOfInsertion = seqRead.pos;
+        const numberOfInsertions = Number(
+          splitSeqRead[componentI].slice(0, -1)
+        );
+        for (let i = 0; i < componentI; i++) {
+          if (splitSeqRead[i].slice(-1) !== "I") {
+            const previousComponentNumber = Number(
+              splitSeqRead[i].slice(0, -1)
+            );
+            bpPosOfInsertion += previousComponentNumber;
+          }
+        }
+        const insertionInfo = {
+          // keeping bpPos 1-based
+          bpPos: bpPosOfInsertion,
+          number: numberOfInsertions
+        };
+        allInsertionsInSeqReads.push(insertionInfo);
+      }
+    }
+  });
+  // sort insertions by ascending bp pos
+  const sortedInsertions = allInsertionsInSeqReads.sort((a, b) => {
+    return a.bpPos - b.bpPos;
+  });
+  // combine duplicate or overlapping insertions from seq reads
+  for (let i = 0; i < sortedInsertions.length - 1; i++) {
+    if (sortedInsertions[i].bpPos === sortedInsertions[i + 1].bpPos) {
+      if (sortedInsertions[i].number > sortedInsertions[i + 1].number) {
+        // remove the one with fewer number of gaps from array
+        sortedInsertions.splice(i + 1, 1);
+        i--;
+      } else if (sortedInsertions[i].number < sortedInsertions[i + 1].number) {
+        sortedInsertions.splice(i, 1);
+        i--;
+      } else if (
+        sortedInsertions[i].number === sortedInsertions[i + 1].number
+      ) {
+        sortedInsertions.splice(i, 1);
+        i--;
+      }
+    }
+  }
+  // sortedInsertions is an array of objects [{bpPos: bp pos of insertion, number: # of insertions}, {bpPos, number}, ...]
+  return sortedInsertions;
+};
+
+// function getAllInsertionsInSeqReads(seqReads) {
+//   let allInsertionBpPosInSeqReads = [];
+//   seqReads.forEach(seqRead => {
+//     // split cigar string at M, D, or I (match, deletion, or insertion)
+//     // ["2M", "3I", "39M", "3D"...]
+//     const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g)
+//     splitSeqRead.forEach(component => {
+//       // keeping bpPos 1-based
+//       let bpPosOfInsertion = seqRead.pos;
+// if (component.slice(-1) === "I") {
+//   const numberOfInsertions = Number(component.slice(0, -1));
+//   const componentIndex = splitSeqRead.indexOf(component);
+//   for (let i = 0; i < componentIndex; i++) {
+//       const previousComponentNumber = Number(splitSeqRead[i].slice(0, -1));
+//       bpPosOfInsertion += previousComponentNumber;
+//     }
+//   for (let i = 1; i <= numberOfInsertions; i++) {
+//     allInsertionBpPosInSeqReads.push(bpPosOfInsertion - i);
+//   }
+// }
+//   });
+// });
+//   // allInsertionBpPosInSeqReads should be an array of bp pos [6, 15, 9, 2, 23...]
+//   // remove duplicates, organize in ascending order
+// const uniqueInsertionBpPos = [...new Set(allInsertionBpPosInSeqReads)].sort(function(a, b) { return a - b });
+//   return uniqueInsertionBpPos;
+// }

package/src/getAllInsertionsInSeqReads.test.js

@@ -0,0 +1,26 @@
+import getAllInsertionsInSeqReads from "./getAllInsertionsInSeqReads.js";
+
+describe("get bp pos of all insertions in seq reads after bowtie2 alignment", () => {
+  it("allInsertionsInSeqReads should be an array of objects [{bpPos: bp pos of insertion, number: # of insertions}, {bpPos, number}, ...]", () => {
+    const seqReads = [
+      { name: "r1", seq: "GATTGAC", pos: 3, cigar: "2M2I3M" },
+      { name: "r2", seq: "GAGAGAC", pos: 3, cigar: "7M" },
+      { name: "r3", seq: "GGGAGATCAC", pos: 1, cigar: "6M1I3M" },
+      { name: "r4", seq: "GATTGAC", pos: 3, cigar: "2M2I3M" },
+      { name: "r5", seq: "GAGC", pos: 3, cigar: "3M1D1M" },
+      { name: "r6", seq: "GAGCTTACC", pos: 3, cigar: "3M1D1M2I3M" },
+      { name: "r7", seq: "GGCATTTCC", pos: 2, cigar: "2M3D2M3I2M" },
+      { name: "r8", seq: "GGATTGACATT", pos: 1, cigar: "1D3M2I4M2I2D" },
+      { name: "r9", seq: "GGTTTGACCTTT", pos: 1, cigar: "2M3I2D1M2D3M3I" }
+    ];
+    const result = getAllInsertionsInSeqReads(seqReads);
+    expect(result).toEqual([
+      { bpPos: 3, number: 3 },
+      { bpPos: 5, number: 2 },
+      { bpPos: 7, number: 1 },
+      { bpPos: 8, number: 2 },
+      { bpPos: 9, number: 3 },
+      { bpPos: 11, number: 3 }
+    ]);
+  });
+});

package/src/getAminoAcidDataForEachBaseOfDna.js

@@ -0,0 +1,163 @@
+import {translateRange, getSequenceWithinRange} from "@teselagen/range-utils";
+import revComp from "./getReverseComplementSequenceString";
+import getAA from "./getAminoAcidFromSequenceTriplet";
+
+//
+import proteinAlphabet from "./proteinAlphabet";
+
+// ac.throw([ac.string,ac.bool],arguments);
+/**
+ * @private
+ * Gets aminoAcid data, including position in string and position in codon
+ * from the sequenceString and the direction of the translation
+ * @param  {String} sequenceString The dna sequenceString.
+ * @param  {boolean} forward Should we find forward facing orfs or reverse facing orfs
+ * @param  {boolean} isProteinSequence We're passing in a sequence of AA chars instead of DNA chars (slightly confusing but we'll still use the dna indexing for rendering in OVE)
+ * @return [{
+        aminoAcid:
+        positionInCodon:
+      }]
+ */
+export default function getAminoAcidDataForEachBaseOfDna(
+  originalSequenceString,
+  forward,
+  optionalSubrangeRange,
+  isProteinSequence
+) {
+  const originalSequenceStringLength = isProteinSequence
+    ? originalSequenceString.length * 3
+    : originalSequenceString.length;
+  let sequenceString = originalSequenceString;
+  let startOffset = 0;
+  if (optionalSubrangeRange) {
+    sequenceString = getSequenceWithinRange(
+      optionalSubrangeRange,
+      originalSequenceString
+    );
+    startOffset = optionalSubrangeRange.start;
+  }
+  const sequenceStringLength = isProteinSequence
+    ? sequenceString.length * 3
+    : sequenceString.length;
+
+  // ac.throw([ac.string,ac.bool],arguments);
+  const aminoAcidDataForEachBaseOfDNA = [];
+  let codonRange;
+  let revCompGapLength = 0;
+  let aminoAcidIndex = 0;
+  if (!forward) {
+    //compute the start of the amino acid sequence, but only if translating in the reverse direction
+    aminoAcidIndex = Math.floor((sequenceStringLength - 1) / 3);
+    //because we're translating in the reverse direction, we need to
+    //check to see if there are untranslated amino acids at the start of the sequenceString
+    revCompGapLength = sequenceStringLength % 3;
+    codonRange = translateRange(
+      {
+        start: 0,
+        end: revCompGapLength - 1
+      },
+      startOffset,
+      originalSequenceStringLength
+    );
+
+    if (revCompGapLength > 0) {
+      for (let i = 0; i < revCompGapLength; i++) {
+        aminoAcidDataForEachBaseOfDNA.push({
+          aminoAcid: getAA("xxx"), //fake xxx triplet returns the ambiguous X amino acid
+          positionInCodon: revCompGapLength - i - 1,
+          aminoAcidIndex,
+          sequenceIndex: codonRange.start + i,
+          codonRange,
+          fullCodon: false
+        });
+      }
+      aminoAcidIndex--;
+    }
+  }
+
+  //compute the bulk of the sequence
+  for (
+    let index = 2 + revCompGapLength;
+    index < sequenceStringLength;
+    index += 3
+  ) {
+    let aminoAcid;
+    if (isProteinSequence) {
+      aminoAcid =
+        proteinAlphabet[sequenceString[(index - 2) / 3].toUpperCase()];
+    } else {
+      let triplet = sequenceString.slice(index - 2, index + 1);
+      if (!forward) {
+        //we reverse the triplet
+        triplet = revComp(triplet);
+      }
+      aminoAcid = getAA(triplet);
+    }
+    codonRange = translateRange(
+      {
+        start: index - 2,
+        end: index
+      },
+      startOffset,
+      originalSequenceStringLength
+    );
+
+    aminoAcidDataForEachBaseOfDNA.push({
+      aminoAcid, //gap amino acid
+      positionInCodon: forward ? 0 : 2,
+      aminoAcidIndex,
+      sequenceIndex: codonRange.start,
+      codonRange,
+      fullCodon: true
+    });
+    aminoAcidDataForEachBaseOfDNA.push({
+      aminoAcid, //gap amino acid
+      positionInCodon: 1,
+      aminoAcidIndex,
+      sequenceIndex: codonRange.start + 1,
+      codonRange,
+      fullCodon: true
+    });
+    aminoAcidDataForEachBaseOfDNA.push({
+      aminoAcid, //gap amino acid
+      positionInCodon: forward ? 2 : 0,
+      aminoAcidIndex,
+      sequenceIndex: codonRange.start + 2,
+      codonRange,
+      fullCodon: true
+    });
+    if (forward) {
+      aminoAcidIndex++;
+    } else {
+      aminoAcidIndex--;
+    }
+  }
+
+  //compute the end of the sequence
+  //we'll never hit the following logic if translating in the reverse direction
+  const lengthOfEndBpsNotCoveredByAminoAcids =
+    sequenceStringLength - aminoAcidDataForEachBaseOfDNA.length;
+  codonRange = translateRange(
+    {
+      start: sequenceStringLength - lengthOfEndBpsNotCoveredByAminoAcids,
+      end: sequenceStringLength - 1
+    },
+    startOffset,
+    originalSequenceStringLength
+  );
+  for (let j = 0; j < lengthOfEndBpsNotCoveredByAminoAcids; j++) {
+    aminoAcidDataForEachBaseOfDNA.push({
+      aminoAcid: getAA("xxx"), //fake xxx triplet returns the gap amino acid
+      positionInCodon: j,
+      aminoAcidIndex,
+      sequenceIndex: codonRange.start + j,
+      fullCodon: false,
+      codonRange
+    });
+  }
+
+  if (sequenceStringLength !== aminoAcidDataForEachBaseOfDNA.length) {
+    throw new Error("something went wrong!");
+  }
+  return aminoAcidDataForEachBaseOfDNA;
+};