@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/getPossiblePartsFromSequenceAndEnzymes.test.js

@@ -0,0 +1,208 @@
+import chai from "chai";
+import chaiSubset from "chai-subset";
+import getPossiblePartsFromSequenceAndEnzymes from "./getPossiblePartsFromSequenceAndEnzymes";
+import enzymeList from "./aliasedEnzymesByName";
+chai.should();
+chai.use(chaiSubset);
+describe("getPossiblePartsFromSequenceAndEnzymes", () => {
+  //bamhi
+  // "bamhi": {
+  //     "name": "bamhi",
+  //     "site": "ggatcc",
+  //     "forwardRegex": "g{2}atc{2}",
+  //     "reverseRegex": "g{2}atc{2}",
+  //     "topSnipOffset": 1,
+  //     "bottomSnipOffset": 5,
+  //     "usForward": 0,
+  //     "usReverse": 0
+  // },
+  it("cuts using a single palindromic enzyme", () => {
+    const sequence = {
+      sequence:
+        "tggttgtagtagttagttgatgttatagggatcctgtagtatttatgtagtagtatgatgtagagtagtagtggatcctattatatata",
+      circular: true
+    };
+    const parts = getPossiblePartsFromSequenceAndEnzymes(sequence, [
+      enzymeList["bamhi"]
+    ]);
+    // eslint-disable-next-line no-unused-expressions
+    parts.should.be.an("array");
+    parts.length.should.equal(2);
+    parts[0].start.should.equal(29);
+    parts[0].end.should.equal(76);
+    parts[0].firstCutOffset.should.equal(4);
+    parts[0].firstCutOverhang.should.equal("gatc");
+    parts[0].firstCutOverhangTop.should.equal("gatc");
+    parts[0].secondCutOffset.should.equal(4);
+    parts[0].secondCutOverhang.should.equal("gatc");
+    parts[0].secondCutOverhangTop.should.equal("");
+
+    parts[1].start.should.equal(73);
+    parts[1].end.should.equal(32);
+    parts.should.containSubset([
+      {
+        start: 29,
+        end: 76,
+        start1Based: 30,
+        end1Based: 77,
+        firstCut: {
+          start: 28,
+          end: 33,
+          topSnipPosition: 29,
+          bottomSnipPosition: 33,
+          topSnipBeforeBottom: true,
+          overhangBps: "gatc",
+          forward: true
+        },
+        firstCutOffset: 4,
+        firstCutOverhang: "gatc",
+        firstCutOverhangTop: "gatc",
+        firstCutOverhangBottom: "",
+        secondCut: {
+          start: 72,
+          end: 77,
+          topSnipPosition: 73,
+          bottomSnipPosition: 77,
+          topSnipBeforeBottom: true,
+          overhangBps: "gatc",
+          forward: true
+        },
+        secondCutOffset: 4,
+        secondCutOverhang: "gatc",
+        secondCutOverhangTop: "",
+        secondCutOverhangBottom: "ctag"
+      },
+      {
+        start: 73,
+        end: 32,
+        start1Based: 74,
+        end1Based: 33,
+        firstCut: {
+          start: 72,
+          end: 77,
+          topSnipPosition: 73,
+          bottomSnipPosition: 77,
+          topSnipBeforeBottom: true,
+          overhangBps: "gatc",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: true
+        },
+        firstCutOffset: 4,
+        firstCutOverhang: "gatc",
+        firstCutOverhangTop: "gatc",
+        firstCutOverhangBottom: "",
+        secondCut: {
+          start: 28,
+          end: 33,
+          topSnipPosition: 29,
+          bottomSnipPosition: 33,
+          topSnipBeforeBottom: true,
+          overhangBps: "gatc",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: true
+        },
+        secondCutOffset: 4,
+        secondCutOverhang: "gatc",
+        secondCutOverhangTop: "",
+        secondCutOverhangBottom: "ctag"
+      }
+    ]);
+  });
+  it("cuts using two golden gate enzymes", () => {
+    const sequence = {
+      //                sapi ->
+      sequence:
+        "tggttgtagtGCTCTTCagttagttgatgttatagggatcctgtagtatttatgtagtaGGAGACCtatgatgtagggtcatcagtagtagtggatcctattatatata",
+      //     accaacatcacgagaagtcaatcaactacaatatccctaggacatcataaatacatcatcctctggatactacatcCCAGAGtcatcatcacctaggataatatatat
+      //                                                                 <- bsai
+      circular: true
+    };
+    const parts = getPossiblePartsFromSequenceAndEnzymes(sequence, [
+      enzymeList["sapi"],
+      enzymeList["bsai"]
+    ]);
+    parts.length.should.equal(2);
+    parts.should.containSubset([
+      {
+        start: 18,
+        end: 58,
+        start1Based: 19,
+        end1Based: 59,
+        firstCut: {
+          start: 10,
+          end: 20,
+          topSnipPosition: 18,
+          bottomSnipPosition: 21,
+          topSnipBeforeBottom: true,
+          overhangBps: "gtt",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: true
+        },
+        firstCutOffset: 3,
+        firstCutOverhang: "gtt",
+        firstCutOverhangTop: "gtt",
+        firstCutOverhangBottom: "",
+        secondCut: {
+          start: 55,
+          end: 65,
+          topSnipPosition: 55,
+          bottomSnipPosition: 59,
+          topSnipBeforeBottom: true,
+          overhangBps: "agta",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: false
+        },
+        secondCutOffset: 4,
+        secondCutOverhang: "agta",
+        secondCutOverhangTop: "",
+        secondCutOverhangBottom: "tcat"
+      },
+      {
+        start: 55,
+        end: 20,
+        start1Based: 56,
+        end1Based: 21,
+        firstCut: {
+          start: 55,
+          end: 65,
+          topSnipPosition: 55,
+          bottomSnipPosition: 59,
+          topSnipBeforeBottom: true,
+          overhangBps: "agta",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: false
+        },
+        firstCutOffset: 4,
+        firstCutOverhang: "agta",
+        firstCutOverhangTop: "agta",
+        firstCutOverhangBottom: "",
+        secondCut: {
+          start: 10,
+          end: 20,
+          topSnipPosition: 18,
+          bottomSnipPosition: 21,
+          topSnipBeforeBottom: true,
+          overhangBps: "gtt",
+          upstreamTopBeforeBottom: false,
+          upstreamTopSnip: null,
+          upstreamBottomSnip: null,
+          forward: true
+        },
+        secondCutOffset: 3,
+        secondCutOverhang: "gtt",
+        secondCutOverhangTop: "",
+        secondCutOverhangBottom: "caa"
+      }
+    ]);
+  });
+});

package/src/getReverseAminoAcidStringFromSequenceString.js

@@ -0,0 +1,20 @@
+import getAminoAcidDataForEachBaseOfDna from "./getAminoAcidDataForEachBaseOfDna";
+
+export default function getReverseAminoAcidStringFromSequenceString(
+  sequenceString
+) {
+  const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
+    sequenceString,
+    false
+  );
+  const aaArray = [];
+  let aaString = "";
+  aminoAcidsPerBase.forEach(aa => {
+    if (!aa.fullCodon) {
+      return;
+    }
+    aaArray[aa.aminoAcidIndex] = aa.aminoAcid.value;
+  });
+  aaString = aaArray.join("");
+  return aaString;
+};

package/src/getReverseAminoAcidStringFromSequenceString.test.js

@@ -0,0 +1,11 @@
+import getReverseAminoAcidStringFromSequenceString from "./getReverseAminoAcidStringFromSequenceString";
+import assert from "assert";
+
+describe("getReverseAminoAcidStringFromSequenceString", () => {
+  it("computes a aa string from dna", () => {
+    assert.equal("M", getReverseAminoAcidStringFromSequenceString("cat"));
+    assert.equal("H", getReverseAminoAcidStringFromSequenceString("atg"));
+    assert.equal("HH", getReverseAminoAcidStringFromSequenceString("atgatg"));
+    assert.equal("", getReverseAminoAcidStringFromSequenceString("at"));
+  });
+});

package/src/getReverseComplementAminoAcidStringFromSequenceString.js

@@ -0,0 +1,7 @@
+
+import getAminoAcidStringFromSequenceString from './getAminoAcidStringFromSequenceString';
+import getReverseComplementSequenceString from './getReverseComplementSequenceString';
+
+export default function getReverseComplementAminoAcidStringFromSequenceString(sequenceString) {
+  return getAminoAcidStringFromSequenceString(getReverseComplementSequenceString(sequenceString))
+};

package/src/getReverseComplementAnnotation.js

@@ -0,0 +1,23 @@
+export default function getReverseComplementAnnotation(
+  annotation,
+  sequenceLength
+) {
+  //note this function assumes that the entire sequence (or subsequence) is being reverse complemented
+  //TNR: this is what is happening:
+  //0123456789
+  //-feature--   //normal
+  //--erutaef-   //reverse complemented
+
+  //sequence length = 10
+  //feature start = 1
+  //feature end = 7
+  //so, erutaef start = 2 = 10 - (7+1)
+  //and, erutaef end = 8 = 10 - (1+1)
+
+  return Object.assign({}, annotation, {
+    start: sequenceLength - (annotation.end + 1),
+    end: sequenceLength - (annotation.start + 1),
+    forward: !annotation.forward,
+    strand: annotation.strand === 1 ? -1 : 1
+  });
+};

package/src/getReverseComplementAnnotation.test.js

@@ -0,0 +1,44 @@
+import chai from "chai";
+import chaiSubset from "chai-subset";
+import getReverseComplementAnnotation from "./getReverseComplementAnnotation";
+chai.should();
+chai.use(chaiSubset);
+describe("getReverseComplementAnnotation", () => {
+  it("reverse complements an annotation ", () => {
+    //0123456789
+    //---abc----   //normal
+    //----cba---   //reverse complemented
+    const newAnn = getReverseComplementAnnotation(
+      {
+        start: 3,
+        end: 5
+      },
+      10
+    );
+    newAnn.should.deep.equal({
+      start: 4,
+      end: 6,
+      forward: true,
+      strand: 1
+    });
+  });
+  it("reverse complements an annotation crossing origin", () => {
+    //0123456789
+    //cde-----ab   //normal
+    //ab-----edc   //reverse complemented
+    const newAnn = getReverseComplementAnnotation(
+      {
+        start: 8,
+        end: 2,
+        strand: 1
+      },
+      10
+    );
+    newAnn.should.deep.equal({
+      start: 7,
+      end: 1,
+      forward: true,
+      strand: -1
+    });
+  });
+});

package/src/getReverseComplementSequenceAndAnnotations.js

@@ -0,0 +1,38 @@
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+import getReverseComplementAnnotation from "./getReverseComplementAnnotation";
+import { annotationTypes } from "./annotationTypes";
+import {map} from "lodash";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+
+
+import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getReverseComplementSequenceAndAnnoations(
+  pSeqObj,
+  options = {}
+) {
+  const seqObj = tidyUpSequenceData(
+    getSequenceDataBetweenRange(pSeqObj, options.range),
+    options
+  );
+  const newSeqObj = Object.assign(
+    {},
+    seqObj,
+    {
+      sequence: getReverseComplementSequenceString(seqObj.sequence)
+    },
+    annotationTypes.reduce((acc, type) => {
+      if (seqObj[type]) {
+        acc[type] = map(seqObj[type], annotation => {
+          return getReverseComplementAnnotation(
+            annotation,
+            seqObj.sequence.length
+          );
+        });
+      }
+      return acc;
+    }, {})
+  );
+  return tidyUpSequenceData(newSeqObj, options);
+};

package/src/getReverseComplementSequenceAndAnnotations.test.js

@@ -0,0 +1,105 @@
+import chai from "chai";
+import chaiSubset from "chai-subset";
+import getReverseComplementSequenceAndAnnotations from "./getReverseComplementSequenceAndAnnotations";
+chai.should();
+chai.use(chaiSubset);
+describe("getReverseComplementSequenceAndAnnotations", () => {
+  it("reverse complements an annotation ", () => {
+    const newSeq = getReverseComplementSequenceAndAnnotations({
+      sequence: "aaatttcccg",
+      circular: true,
+      features: [
+        {
+          start: 3,
+          end: 5
+        },
+        {
+          start: 8,
+          end: 2
+        }
+      ]
+    });
+    newSeq.should.containSubset({
+      sequence: "cgggaaattt",
+      features: [
+        {
+          start: 4,
+          end: 6,
+          forward: true
+        },
+        {
+          start: 7,
+          end: 1,
+          forward: true
+        }
+      ]
+    });
+  });
+
+  it("handles a range option correctly and reverse complements a subset of the sequence ", () => {
+    const newSeq = getReverseComplementSequenceAndAnnotations(
+      {
+        sequence: "aaatttcccgttt",
+        circular: true,
+        features: [
+          {
+            start: 3,
+            end: 5
+          }
+        ]
+      },
+      { range: { start: 0, end: 9 } }
+    );
+    newSeq.should.containSubset({
+      sequence: "cgggaaattt",
+      features: [
+        {
+          start: 4,
+          end: 6,
+          forward: true
+        }
+      ]
+    });
+  });
+  it("handles a range option correctly and reverse complements a subset of the sequence across the origin ", () => {
+    const newSeq = getReverseComplementSequenceAndAnnotations(
+      {
+        sequence: "aaatttcccgttt",
+        //         0123456789
+        //         rrr   rrrrrrr
+        //            fffff
+        circular: true,
+        features: [
+          {
+            start: 3,
+            end: 7
+          }
+        ]
+      },
+      { range: { start: 6, end: 2 } }
+    );
+    newSeq.should.containSubset({
+      sequence: "tttaaacggg",
+      features: [
+        {
+          start: 8,
+          end: 9,
+          forward: true
+        }
+      ]
+    });
+  });
+  it("handles a range option correctly and reverse complements a subset of the sequence across the origin ", () => {
+    const newSeq = getReverseComplementSequenceAndAnnotations(
+      {
+        sequence: "cccttt"
+        //         012345
+        //         rr  rr
+      },
+      { range: { start: 4, end: 1 } }
+    );
+    newSeq.should.containSubset({
+      sequence: "ggaa"
+    });
+  });
+});

package/src/getReverseComplementSequenceString.js

@@ -0,0 +1,17 @@
+import DNAComplementMap from "./DNAComplementMap";
+
+
+// ac.throw([ac.string,ac.bool],arguments);
+export default function getReverseComplementSequenceString(sequence) {
+  // ac.throw([ac.string],arguments);
+  let reverseComplementSequenceString = "";
+  for (let i = sequence.length - 1; i >= 0; i--) {
+    let revChar = DNAComplementMap[sequence[i]];
+    if (!revChar) {
+      revChar = sequence[i];
+      // throw new Error('trying to get the reverse compelement of an invalid base');
+    }
+    reverseComplementSequenceString += revChar;
+  }
+  return reverseComplementSequenceString;
+};

package/src/getReverseComplementSequenceString.test.js

@@ -0,0 +1,11 @@
+import chai from "chai";
+import chaiSubset from "chai-subset";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+chai.should();
+chai.use(chaiSubset);
+describe("getReverseComplementSequenceAndAnnotations", () => {
+  it("handles a range option correctly and reverse complements a subset of the sequence across the origin ", () => {
+    const newSeq = getReverseComplementSequenceString("uuuucccttt");
+    newSeq.should.eq("aaagggaaaa");
+  });
+});

package/src/getReverseSequenceString.js

@@ -0,0 +1,12 @@
+export default function getReverseSequenceString(sequence) {
+  let reverseSequenceString = "";
+  for (let i = sequence.length - 1; i >= 0; i--) {
+    let revChar = sequence[i];
+    if (!revChar) {
+      revChar = sequence[i];
+      // throw new Error('trying to get the reverse of an invalid base');
+    }
+    reverseSequenceString += revChar;
+  }
+  return reverseSequenceString;
+};

package/src/getReverseSequenceString.test.js

@@ -0,0 +1,9 @@
+import chai from "chai";
+import getReverseSequenceString from "./getReverseSequenceString";
+chai.should();
+describe("getReverseSequenceAndAnnotations", () => {
+  it("handles a range option correctly and reverse complements a subset of the sequence across the origin ", () => {
+    const newSeq = getReverseSequenceString("uuuucccttt");
+    newSeq.should.eq("tttcccuuuu");
+  });
+});

package/src/getSequenceDataBetweenRange.js

@@ -0,0 +1,131 @@
+import {flatMap, extend, forEach, startCase} from "lodash";
+import {getRangeLength} from "@teselagen/range-utils";
+import convertDnaCaretPositionOrRangeToAa from "./convertDnaCaretPositionOrRangeToAA";
+import insertSequenceDataAtPosition from "./insertSequenceDataAtPosition";
+import {getSequenceWithinRange, getZeroedRangeOverlaps} from "@teselagen/range-utils";
+import tidyUpSequenceData from "./tidyUpSequenceData";
+import { annotationTypes } from "./annotationTypes";
+
+export default function getSequenceDataBetweenRange(
+  seqData,
+  range,
+  options = {}
+) {
+  if (!range) return seqData;
+  const { exclude = {}, excludePartial = {} } = options;
+  const seqDataToUse = tidyUpSequenceData(seqData, options);
+  annotationTypes.forEach(type => {
+    delete seqDataToUse[`filtered${startCase(type)}`];
+  });
+  const seqDataToReturn = extend(
+    {},
+    seqDataToUse,
+    {
+      circular:
+        seqDataToUse.sequence.length ===
+        getRangeLength(range, seqData.sequence.length)
+          ? seqDataToUse.circular
+          : false,
+      sequence: getSequenceWithinRange(range, seqDataToUse.sequence),
+      proteinSequence: getSequenceWithinRange(
+        convertDnaCaretPositionOrRangeToAa(range),
+        seqDataToUse.proteinSequence
+      )
+    },
+    annotationTypes.reduce((acc, type) => {
+      if (exclude[type]) {
+        acc[type] = [];
+        return acc; //return early cause we're not interested in these annotations
+      }
+      acc[type] = getAnnotationsBetweenRange(
+        seqDataToUse[type],
+        range,
+        seqDataToUse.sequence.length,
+        excludePartial[type]
+      );
+      return acc;
+    }, {})
+  );
+  if (range.overlapsSelf) {
+    const extendedSeqData = insertSequenceDataAtPosition(
+      { sequence: seqDataToReturn.sequence },
+      seqDataToUse,
+      range.start
+    );
+
+    const toRet = getSequenceDataBetweenRange(
+      extendedSeqData,
+      {
+        start: range.end + 1,
+        end: range.end
+      },
+      options
+    );
+    annotationTypes.forEach(type => {
+      //we need to go through and adjust any anns where overlapsSelf=true to no longer overlap themselves if they match the range completely
+      forEach(toRet[type], ann => {
+        if (
+          ann.overlapsSelf &&
+          ann.start === 0 &&
+          getRangeLength(ann, seqDataToUse.sequence.length) ===
+            getRangeLength(range, seqDataToUse.sequence.length)
+        ) {
+          ann.overlapsSelf = false;
+          ann.end = toRet.sequence.length - 1;
+        }
+      });
+    });
+    return tidyUpSequenceData(toRet, options);
+  }
+
+  return tidyUpSequenceData(seqDataToReturn, options);
+};
+
+function getAnnotationsBetweenRange(
+  annotationsToBeAdjusted,
+  range,
+  maxLength,
+  shouldExcludePartial
+) {
+  return flatMap(annotationsToBeAdjusted, annotation => {
+    if (annotation.locations && annotation.locations.length) {
+      annotation.locations = getAnnotationsBetweenRange(
+        annotation.locations,
+        range,
+        maxLength,
+        shouldExcludePartial
+      );
+    }
+    //map through every annotation and get the overlap of the annotation with the range
+    const overlaps = getZeroedRangeOverlaps(annotation, range, maxLength).map(
+      overlap => {
+        //we get back 1 or more overlaps here
+
+        return extend({}, annotation, overlap);
+      }
+    );
+    if (shouldExcludePartial) {
+      if (overlaps.length > 1) return []; //the annotation has multiple overlaps and thus must be a partial copy so we exclude it completely
+      if (overlaps[0]) {
+        //there is just 1 overlap, if it doesn't have the same length, it must be a partial copy so we need to exclude it
+        if (
+          getRangeLength(overlaps[0], maxLength) !==
+          getRangeLength(annotation, maxLength)
+        ) {
+          return [];
+        }
+      }
+    }
+
+    return overlaps;
+  }).map(annotation => {
+    if (annotation.locations && annotation.locations.length) {
+      annotation.start = annotation.locations[0].start;
+      annotation.end =
+        annotation.locations[annotation.locations.length - 1].end;
+
+      if (annotation.locations.length === 1) delete annotation.locations;
+    }
+    return annotation;
+  }); //filter any fully deleted ranges
+}