@teselagen/sequence-utils 0.1.21 → 0.1.23

package/src/findNearestRangeOfSequenceOverlapToPosition.test.js

@@ -0,0 +1,31 @@
+import assert from "assert";
+import findNearestRangeOfSequenceOverlapToPosition from "./findNearestRangeOfSequenceOverlapToPosition";
+describe("findNearestRangeOfSequenceOverlapToPosition", () => {
+  it("should find the nearest overlap range to the given position", () => {
+    const range = findNearestRangeOfSequenceOverlapToPosition(
+      "gagagtagagatagagtagagatagagatagagagagagccagcagacgacgagcagcctacgtcatcatagagagagaag",
+      "atagagagag",
+      17
+    );
+    assert.equal(range.start, 27);
+    assert.equal(range.end, 36);
+  });
+  it("should find the nearest overlap range to the given position at the end of the sequence", () => {
+    const range = findNearestRangeOfSequenceOverlapToPosition(
+      "gagagtagagatagagtagagatagagatagagagagagccagcagacgacgagcagcctacgtcatcatagagagagaag",
+      "atagagagag",
+      0
+    );
+    assert.equal(range.start, 68);
+    assert.equal(range.end, 77);
+  });
+  it("should find the nearest overlap range even when that range overlaps the origin", () => {
+    const range = findNearestRangeOfSequenceOverlapToPosition(
+      "agagaggagagtagagatagagtagagatagagatagagagagagccagcagacgacgagcagcctacgtcatcatagagagagaagatag",
+      "atagagagag",
+      0
+    );
+    assert.equal(range.start, 87);
+    assert.equal(range.end, 5);
+  });
+});

package/src/findOrfsInPlasmid.js

@@ -0,0 +1,26 @@
+import getOrfsFromSequence from "./getOrfsFromSequence.js";
+
+export default function findOrfsInPlasmid(
+  sequence,
+  circular,
+  minimumOrfSize,
+  useAdditionalOrfStartCodons
+) {
+  //tnr, we should do the parsing down of the orfs immediately after they're returned from this sequence
+  // const orfs1Forward = eliminateCircularOrfsThatOverlapWithNonCircularOrfs(getOrfsFromSequence(0, doubleForwardSequence, minimumOrfSize, true), maxLength);
+  const forwardOrfs = getOrfsFromSequence({
+    sequence: sequence,
+    minimumOrfSize: minimumOrfSize,
+    forward: true,
+    circular: circular,
+    useAdditionalOrfStartCodons
+  });
+  const reverseOrfs = getOrfsFromSequence({
+    sequence: sequence,
+    minimumOrfSize: minimumOrfSize,
+    forward: false,
+    circular: circular,
+    useAdditionalOrfStartCodons
+  });
+  return forwardOrfs.concat(reverseOrfs);
+};

package/src/findSequenceMatches.js

@@ -0,0 +1,133 @@
+import {modulateRangeBySequenceLength, flipContainedRange} from "@teselagen/range-utils";
+import {reduce, uniqBy} from "lodash";
+import escapeStringRegexp from "escape-string-regexp";
+import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+import {ambiguous_dna_values, extended_protein_values} from "./bioData";
+import getReverseComplementSequenceString from "./getReverseComplementSequenceString";
+
+export default function findSequenceMatches(
+  sequence,
+  searchString,
+  options = {}
+) {
+  let matches = findSequenceMatchesTopStrand(sequence, searchString, options);
+  const { searchReverseStrand } = options;
+
+  if (searchReverseStrand) {
+    const sequenceLength = sequence.length;
+    const reverseSeq = getReverseComplementSequenceString(sequence);
+    const reverseMatches = findSequenceMatchesTopStrand(
+      reverseSeq,
+      searchString,
+      options
+    );
+    const flippedReverseMatches = reverseMatches.map(range => {
+      return {
+        ...flipContainedRange(
+          range,
+          { start: 0, end: sequenceLength - 1 },
+          sequenceLength
+        ),
+        bottomStrand: true
+      };
+    });
+    matches = [...matches, ...flippedReverseMatches];
+  }
+  return matches;
+};
+
+function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
+  const {
+    isCircular,
+    isAmbiguous,
+    isProteinSequence,
+    isProteinSearch
+  } = options;
+  let searchStringToUse = escapeStringRegexp(searchString);
+  if (isAmbiguous) {
+    if (isProteinSearch || isProteinSequence) {
+      searchStringToUse = convertAmbiguousStringToRegex(
+        searchStringToUse,
+        true
+      );
+    } else {
+      //we're searching DNA
+      searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
+    }
+  }
+  if (!searchStringToUse) return []; //short circuit if nothing is actually being searched for (eg searching for "%%"")
+  let sequenceToUse = sequence;
+  if (isCircular) {
+    sequenceToUse = sequenceToUse + sequenceToUse;
+  }
+
+  let sequencesToCheck = [{ seqToCheck: sequenceToUse, offset: 0 }];
+  if (isProteinSearch) {
+    sequencesToCheck = [
+      {
+        seqToCheck: getAminoAcidStringFromSequenceString(sequenceToUse),
+        offset: 0
+      },
+      {
+        seqToCheck: getAminoAcidStringFromSequenceString(
+          sequenceToUse.substr(1)
+        ),
+        offset: 1
+      },
+      {
+        seqToCheck: getAminoAcidStringFromSequenceString(
+          sequenceToUse.substr(2)
+        ),
+        offset: 2
+      }
+    ];
+  }
+
+  const ranges = [];
+  sequencesToCheck.forEach(({ seqToCheck, offset }) => {
+    const reg = new RegExp(searchStringToUse, "ig");
+    let match;
+    let range;
+    /* eslint-disable no-cond-assign*/
+
+    while ((match = reg.exec(seqToCheck)) !== null) {
+      range = {
+        start: match.index,
+        end: match.index + searchString.length - 1 //this should be the original searchString here j
+      };
+      if (isProteinSearch) {
+        range.start = range.start * 3 + offset;
+        range.end = range.end * 3 + 2 + offset;
+      }
+      ranges.push(modulateRangeBySequenceLength(range, sequence.length));
+      reg.lastIndex = match.index + 1;
+    }
+    /* eslint-enable no-cond-assign*/
+  });
+
+  return uniqBy(ranges, e => {
+    return e.start + "-" + e.end;
+  });
+}
+
+function convertAmbiguousStringToRegex(string, isProtein) {
+  // Search for a DNA subseq in sequence.
+  // use ambiguous values (like N = A or T or C or G, R = A or G etc.)
+  // searches only on forward strand
+  return reduce(
+    string,
+    (acc, char) => {
+      const value = isProtein
+        ? extended_protein_values[char.toUpperCase()]
+        : ambiguous_dna_values[char.toUpperCase()];
+      if (!value) return acc;
+      if (value.length === 1) {
+        acc += value;
+      } else {
+        acc += `[${value}]`;
+      }
+      return acc;
+    },
+    ""
+  );
+}

package/src/findSequenceMatches.test.js

@@ -0,0 +1,286 @@
+import findSequenceMatches from "./findSequenceMatches";
+
+describe("findSequenceMatches", () => {
+  it("ambiguous protein sequence with * as stop codon", () => {
+    expect(
+      findSequenceMatches("mmhlrl*", "Mxxlrl*", {
+        isAmbiguous: true,
+        isProteinSequence: true /* isProteinSearch: true */
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 6
+      }
+    ]);
+    expect(
+      findSequenceMatches("mmhlrl*", "mx", {
+        isAmbiguous: true,
+        isProteinSequence: true /* isProteinSearch: true */
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 1
+      },
+      {
+        start: 1,
+        end: 2
+      }
+    ]);
+  });
+  it("protein sequence with * as stop codon", () => {
+    expect(
+      findSequenceMatches("mmhlrl*", "mMh", {
+        isProteinSequence: true /* isProteinSearch: true */
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 2
+      }
+    ]);
+    expect(
+      findSequenceMatches("mmhlrl*", "Mmhlrl*", {
+        isProteinSequence: true /* isProteinSearch: true */
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 6
+      }
+    ]);
+  });
+  it("returns an empty array when nothing matches", () => {
+    expect([]).toEqual(findSequenceMatches("atg", "xtag"));
+  });
+  it("handles various weird characters", () => {
+    expect([]).toEqual(findSequenceMatches("atg", " . xt ** ag $#@@!"));
+  });
+  it("returns matches for non-circular, non-ambiguous, dna searches", () => {
+    expect([
+      {
+        start: 1,
+        end: 1
+      }
+    ]).toEqual(findSequenceMatches("atg", "t"));
+    expect([
+      {
+        start: 2,
+        end: 3
+      },
+      {
+        start: 3,
+        end: 4
+      },
+      {
+        start: 7,
+        end: 8
+      }
+    ]).toEqual(findSequenceMatches("atgggaagg", "gg"));
+    //atgggaagg
+    //012345678
+  });
+  it("returns matches for circular, non-ambiguous, dna searches", () => {
+    const matches = findSequenceMatches("atg", "ga", { isCircular: true });
+    expect(matches).toEqual([
+      {
+        start: 2,
+        end: 0
+      }
+    ]);
+  });
+  it("returns matches for circular, non-ambiguous, dna searches on bottom strand that cross origin", () => {
+    const matches = findSequenceMatches("atga", "ttc", {
+      isCircular: true,
+      searchReverseStrand: true
+    });
+    expect(matches).toEqual([
+      {
+        bottomStrand: true,
+        start: 2,
+        end: 0
+      }
+    ]);
+  });
+  it("returns matches for a long circular, non-ambiguous, dna searches", () => {
+    const matches = findSequenceMatches(
+      "gacgtcttatgacaacttgacggctacatcattcactttttcttcacaaccggcacggaactcgctcgggctggccccggtgcattttttaaatacccgcgagaaatagagttgatcgtcaaaaccaacattgcgaccgacggtggcgataggcatccgggtggtgctcaaaagcagcttcgcctggctgatacgttggtcctcgcgccagcttaagacgctaatccctaactgctggcggaaaagatgtgacagacgcgacggcgacaagcaaacatgctgtgcgacgctggcgatatcaaaattgctgtctgccaggtgatcgctgatgtactgacaagcctcgcgtacccgattatccatcggtggatggagcgactcgttaatcgcttccatgcgccgcagtaacaattgctcaagcagatttatcgccagcagctccgaatagcgcccttccccttgcccggcgttaatgatttgcccaaacaggtcgctgaaatgcggctggtgcgcttcatccgggcgaaagaaccccgtattggcaaatattgacggccagttaagccattcatgccagtaggcgcgcggacgaaagtaaacccactggtgataccattcgcgagcctccggatgacgaccgtagtgatgaatctctcctggcgggaacagcaaaatatcacccggtcggcaaacaaattctcgtccctgatttttcaccaccccctgaccgcgaatggtgagattgagaatataacctttcattcccagcggtcggtcgataaaaaaatcgagataaccgttggcctcaatcggcgttaaacccgccaccagatgggcattaaacgagtatcccggcagcaggggatcattttgcgcttcagccatacttttcatactcccgccattcagagaagaaaccaattgtccatattgcatcagacattgccgtcactgcgtcttttactggctcttctcgctaaccaaaccggtaaccccgcttattaaaagcattctgtaacaaagcgggaccaaagccatgacaaaaacgcgtaacaaaagtgtctataatcacggcagaaaagtccacattgattatttgcacggcgtcacactttgctatgccatagcatttttatccataagattagcggattctacctgacgctttttatcgcaactctctactgtttctccatacccgtttttttgggaatttttaagaaggagatatacatatgagtaaaggagaagaacttttcactggagttgtcccaattcttgttgaattagatggtgatgttaatgggcacaaattttctgtcagtggagagggtgaaggtgatgcaacatacggaaaacttacccttaaatttatttgcactactggaaaactacctgttccatggccaacacttgtcactactttctcttatggtgttcaatgcttttcccgttatccggatcatatgaaacggcatgactttttcaagagtgccatgcccgaaggttatgtacaggaacgcactatatctttcaaagatgacgggaactacaagacgcgtgctgaagtcaagtttgaaggtgatacccttgttaatcgtatcgagttaaaaggtattgattttaaagaagatggaaacattctcggacacaaactcgaatacaactataactcacacaatgtatacatcacggcagacaaacaaaagaatggaatcaaagctaacttcaaaattcgccacaacattgaagatggatctgttcaactagcagaccattatcaacaaaatactccaattggcgatggccctgtccttttaccagacaaccattacctgtcgacacaatctgccctttcgaaagatcccaacgaaaagcgtgaccacatggtccttcttgagtttgtaactgctgctgggattacacatggcatggatgagctcggcggcggcggcagcaaggtctacggcaaggaacagtttttgcggatgcgccagagcatgttccccgatcgctaaatcgagtaaggatctccaggcatcaaataaaacgaaaggctcagtcgaaagactgggcctttcgttttatctgttgtttgtcggtgaacgctctctactagagtcacactggctcaccttcgggtgggcctttctgcgtttatacctagggtacgggttttgctgcccgcaaacgggctgttctggtgttgctagtttgttatcagaatcgcagatccggcttcagccggtttgccggctgaaagcgctatttcttccagaattgccatgattttttccccacgggaggcgtcactggctcccgtgttgtcggcagctttgattcgataagcagcatcgcctgtttcaggctgtctatgtgtgactgttgagctgtaacaagttgtctcaggtgttcaatttcatgttctagttgctttgttttactggtttcacctgttctattaggtgttacatgctgttcatctgttacattgtcgatctgttcatggtgaacagctttgaatgcaccaaaaactcgtaaaagctctgatgtatctatcttttttacaccgttttcatctgtgcatatggacagttttccctttgatatgtaacggtgaacagttgttctacttttgtttgttagtcttgatgcttcactgatagatacaagagccataagaacctcagatccttccgtatttagccagtatgttctctagtgtggttcgttgtttttgcgtgagccatgagaacgaaccattgagatcatacttactttgcatgtcactcaaaaattttgcctcaaaactggtgagctgaatttttgcagttaaagcatcgtgtagtgtttttcttagtccgttatgtaggtaggaatctgatgtaatggttgttggtattttgtcaccattcatttttatctggttgttctcaagttcggttacgagatccatttgtctatctagttcaacttggaaaatcaacgtatcagtcgggcggcctcgcttatcaaccaccaatttcatattgctgtaagtgtttaaatctttacttattggtttcaaaacccattggttaagccttttaaactcatggtagttattttcaagcattaacatgaacttaaattcatcaaggctaatctctatatttgccttgtgagttttcttttgtgttagttcttttaataaccactcataaatcctcatagagtatttgttttcaaaagacttaacatgttccagattatattttatgaatttttttaactggaaaagataaggcaatatctcttcactaaaaactaattctaatttttcgcttgagaacttggcatagtttgtccactggaaaatctcaaagcctttaaccaaaggattcctgatttccacagttctcgtcatcagctctctggttgctttagctaatacaccataagcattttccctactgatgttcatcatctgagcgtattggttataagtgaacgataccgtccgttctttccttgtagggttttcaatcgtggggttgagtagtgccacacagcataaaattagcttggtttcatgctccgttaagtcatagcgactaatcgctagttcatttgctttgaaaacaactaattcagacatacatctcaattggtctaggtgattttaatcactataccaattgagatgggctagtcaatgataattactagtccttttcccgggtgatctgggtatctgtaaattctgctagacctttgctggaaaacttgtaaattctgctagaccctctgtaaattccgctagacctttgtgtgttttttttgtttatattcaagtggttataatttatagaataaagaaagaataaaaaaagataaaaagaatagatcccagccctgtgtataactcactactttagtcagttccgcagtattacaaaaggatgtcgcaaacgctgtttgctcctctacaaaacagaccttaaaaccctaaaggcttaagtagcaccctcgcaagctcgggcaaatcgctgaatattccttttgtctccgaccatcaggcacctgagtcgctgtctttttcgtgacattcagttcgctgcgctcacggctctggcagtgaatgggggtaaatggcactacaggcgccttttatggattcatgcaaggaaactacccataatacaagaaaagcccgtcacgggcttctcagggcgttttatggcgggtctgctatgtggtgctatctgactttttgctgttcagcagttcctgccctctgattttccagtctgaccacttcggattatcccgtgacaggtcattcagactggctaatgcacccagtaaggcagcggtatcatcaacaggcttacccgtcttactgtccctagtgcttggattctcaccaataaaaaacgcccggcggcaaccgagcgttctgaacaaatccagatggagttctgaggtcattactggatctatcaacaggagtccaagcgagctcgatatcaaattacgccccgccctgccactcatcgcagtactgttgtaattcattaagcattctgccgacatggaagccatcacaaacggcatgatgaacctgaatcgccagcggcatcagcaccttgtcgccttgcgtataatatttgcccatggtgaaaacgggggcgaagaagttgtccatattggccacgtttaaatcaaaactggtgaaactcacccagggattggctgagacgaaaaacatattctcaataaaccctttagggaaataggccaggttttcaccgtaacacgccacatcttgcgaatatatgtgtagaaactgccggaaatcgtcgtggtattcactccagagcgatgaaaacgtttcagtttgctcatggaaaacggtgtaacaagggtgaacactatcccatatcaccagctcaccgtctttcattgccatacgaaattccggatgagcattcatcaggcgggcaagaatgtgaataaaggccggataaaacttgtgcttatttttctttacggtctttaaaaaggccgtaatatccagctgaacggtctggttataggtacattgagcaactgactgaaatgcctcaaaatgttctttacgatgccattgggatatatcaacggtggtatatccagtgatttttttctccattttagcttccttagctcctgaaaatctcgataactcaaaaaatacgcccggtagtgatcttatttcattatggtgaaagttggaacctcttacgtgccgatcaacgtctcattttcgccagatatc",
+      "atgagacg",
+      { isCircular: true, searchReverseStrand: true }
+    );
+    expect(matches).toEqual([
+      {
+        bottomStrand: true,
+        end: 5284,
+        start: 5277
+      }
+    ]);
+  });
+  it("non-ambiguous, dna searches for nothing results in empty array", () => {
+    const matches = findSequenceMatches("atg", "*", {});
+    expect(matches).toEqual([]);
+  });
+  it("ambiguous, protein searches for nothing results in empty array", () => {
+    const matches = findSequenceMatches("atg", "*", {
+      isProteinSearch: true,
+      isAmbiguous: true
+    });
+    expect(matches).toEqual([]);
+  });
+  it("ambiguous, dna searches for nothing results in empty array", () => {
+    const matches = findSequenceMatches("atg", "*", { isAmbiguous: true });
+    expect(matches).toEqual([]);
+  });
+  it("ambiguous, dna searches with *", () => {
+    const matches = findSequenceMatches("atg", "", { isAmbiguous: true });
+    expect(matches).toEqual([]);
+  });
+  it(" AA with * as stop codon", () => {
+    expect(
+      findSequenceMatches("atgtaa", "M*", { isProteinSearch: true })
+    ).toEqual([
+      {
+        start: 0,
+        end: 5
+      }
+    ]);
+  });
+  it(" AA with * as stop codon", () => {
+    expect(
+      findSequenceMatches("atgtaaccc", "M**", { isProteinSearch: true })
+    ).toEqual([]);
+  });
+  it("works with ambiguous AA", () => {
+    expect(
+      findSequenceMatches("atgatg", "MX", {
+        isProteinSearch: true,
+        isAmbiguous: true
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 5
+      }
+    ]);
+  });
+  it("works with ambiguous AA with * in search string", () => {
+    expect(
+      findSequenceMatches("atgtaa", "M*", {
+        isProteinSearch: true,
+        isAmbiguous: true
+      })
+    ).toEqual([
+      {
+        start: 0,
+        end: 5
+      }
+    ]);
+  });
+  it("returns matches for non-circular, non-ambiguous, AA searches", () => {
+    expect(findSequenceMatches("atg", "M", { isProteinSearch: true })).toEqual([
+      {
+        start: 0,
+        end: 2
+      }
+    ]);
+    expect(
+      findSequenceMatches("TTTATGAGT", "MS", { isProteinSearch: true })
+    ).toEqual([
+      {
+        start: 3,
+        end: 8
+      }
+    ]);
+    expect(
+      findSequenceMatches("TTATGAGT", "MS", { isProteinSearch: true })
+    ).toEqual([
+      {
+        start: 2,
+        end: 7
+      }
+    ]);
+    expect(
+      findSequenceMatches("TTTTATGAGT", "MS", { isProteinSearch: true })
+    ).toEqual([
+      {
+        start: 4,
+        end: 9
+      }
+    ]);
+
+    // 0   1   2
+    // P   T   R
+    // 012 345 678
+    // ATG ATG ATG
+  });
+  it("returns matches for non-circular, ambiguous, dna searches", () => {
+    const matches = findSequenceMatches("atg", "m", { isAmbiguous: true });
+    expect(matches).toEqual([
+      {
+        start: 0,
+        end: 0
+      }
+    ]);
+    expect(findSequenceMatches("atg", "n", { isAmbiguous: true })).toEqual([
+      {
+        start: 0,
+        end: 0
+      },
+      {
+        start: 1,
+        end: 1
+      },
+      {
+        start: 2,
+        end: 2
+      }
+    ]);
+    expect(
+      findSequenceMatches("atgcctcc", "ccnnc", { isAmbiguous: true })
+    ).toEqual([
+      {
+        start: 3,
+        end: 7
+      }
+    ]);
+  });
+  it("returns matches for both strands for non-circular, ambiguous, dna searches", () => {
+    const matches = findSequenceMatches("atg", "m", {
+      isAmbiguous: true,
+      searchReverseStrand: true
+    });
+    expect(matches).toEqual([
+      {
+        start: 0,
+        end: 0
+      },
+      { bottomStrand: true, end: 2, start: 2 },
+      { bottomStrand: true, end: 1, start: 1 }
+    ]);
+    expect(
+      findSequenceMatches("atg", "n", {
+        isAmbiguous: true,
+        searchReverseStrand: true
+      })
+    ).toEqual([
+      { end: 0, start: 0 },
+      { end: 1, start: 1 },
+      { end: 2, start: 2 },
+      { bottomStrand: true, end: 2, start: 2 },
+      { bottomStrand: true, end: 1, start: 1 },
+      { bottomStrand: true, end: 0, start: 0 }
+    ]);
+    expect(
+      findSequenceMatches("atgcctcc", "ccnnc", {
+        isAmbiguous: true,
+        searchReverseStrand: true
+      })
+    ).toEqual([
+      {
+        start: 3,
+        end: 7
+      }
+    ]);
+  });
+});

package/src/generateAnnotations.js

@@ -0,0 +1,34 @@
+import {generateRandomRange} from "@teselagen/range-utils";
+import shortid from "shortid";
+
+function generateAnnotations(
+  numberOfAnnotationsToGenerate,
+  start,
+  end,
+  maxLength
+) {
+  const result = {};
+  for (let i = 0; i < numberOfAnnotationsToGenerate; i++) {
+    const annotation = generateAnnotation(start, end, maxLength);
+    result[annotation.id] = annotation;
+  }
+  return result;
+}
+
+function generateAnnotation(start, end, maxLength) {
+  const range = generateRandomRange(start, end, maxLength);
+  return {
+    ...range,
+    name: getRandomInt(0, 100000).toString(),
+    type: "misc_feature",
+    id: shortid(),
+    forward: Math.random() > 0.5,
+    notes: {}
+  };
+}
+
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+export default generateAnnotations;