@teselagen/sequence-utils 0.1.22 → 0.1.23

package/src/getSequenceDataBetweenRange.test.js

@@ -0,0 +1,474 @@
+//tnr: half finished test.
+
+
+import chai from "chai";
+import chaiSubset from "chai-subset";
+
+import getSequenceDataBetweenRange from "./getSequenceDataBetweenRange";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("getSequenceDataBetweenRange", () => {
+  it("should handle range.overlapsSelf flag", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        circular: true,
+        //         0123456789012
+        //         ffffffff gg
+        sequence: "tttggggaaaccc",
+        //          ttg
+        parts: [
+          {
+            start: 1,
+            end: 3,
+            name: "iOverlapMyself",
+            overlapsSelf: true
+          }
+        ],
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          },
+          {
+            start: 9,
+            end: 10,
+            name: "grumpy"
+          }
+        ]
+      },
+      {
+        start: 1,
+        end: 3,
+        overlapsSelf: true
+      }
+    );
+    res.parts[0].overlapsSelf.should.equal(false); //if the range perfectly overlaps the selfOverlapped annotation, the annotation should no longer be wrapping
+    res.should.containSubset({
+      sequence: "ttggggaaaccctttg",
+      parts: [
+        {
+          start: 0,
+          end: 15,
+          name: "iOverlapMyself"
+        }
+      ],
+      features: [
+        {
+          start: 0,
+          end: 6,
+          name: "happy"
+        },
+        {
+          start: 12,
+          end: 15,
+          name: "happy"
+        },
+        {
+          start: 8,
+          end: 9,
+          name: "grumpy"
+        }
+      ]
+    });
+  });
+
+  it("should set circular to false if a sub range is selected of a circular sequence", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        circular: true,
+        sequence: "atgcatgc"
+      },
+      {
+        start: 1,
+        end: 5
+      }
+    );
+    res.should.containSubset({
+      circular: false
+    });
+  });
+  it("should maintain circularity if the full entire sequence is selected from a circular sequence", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        circular: true,
+        sequence: "atgcatgc"
+      },
+      {
+        start: 3,
+        end: 2
+      }
+    );
+    res.should.containSubset({
+      circular: true
+    });
+  });
+  it("should maintain circular=false if the full entire sequence is selected from a linear sequence", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        circular: false,
+        sequence: "atgcatgc"
+      },
+      {
+        start: 3,
+        end: 2
+      }
+    );
+    res.should.containSubset({
+      circular: false
+    });
+  });
+  it("should return an empty sequence if given an invalid range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        isProtein: true,
+        sequence: "atgcatgc",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: -1,
+        end: -1
+      }
+    );
+    res.should.containSubset({
+      sequence: "",
+      isProtein: true,
+      proteinSequence: "",
+      features: [],
+      parts: []
+    });
+  });
+  it("protein sequence non circular feature, non circular range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        sequence: "atgcatgcatgc",
+        proteinSequence: "MHAC",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 3,
+        end: 8
+      }
+    );
+    res.should.containSubset({
+      sequence: "catgca",
+      proteinSequence: "HA",
+      features: [
+        {
+          start: 0,
+          end: 4,
+          name: "happy"
+        }
+      ]
+    });
+  });
+  it("non circular feature, non circular range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        sequence: "atgcatgca",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 2,
+        end: 3
+      }
+    );
+    res.should.containSubset({
+      sequence: "gc",
+      features: [
+        {
+          start: 0,
+          end: 1,
+          name: "happy"
+        }
+      ]
+    });
+  });
+  it("feature with locations, non circular range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        sequence: "atgcatgca",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            locations: [
+              { start: 0, end: 1 },
+              { start: 2, end: 5 },
+              { start: 6, end: 7 }
+            ],
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 2,
+        end: 3
+      }
+    );
+    res.should.containSubset({
+      sequence: "gc",
+      features: [
+        {
+          start: 0,
+          end: 1,
+          locations: [
+            {
+              start: 0,
+              end: 1
+            }
+          ],
+          name: "happy"
+        }
+      ]
+    });
+  });
+  it("feature with locations, non circular enclosing range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        sequence: "gggatgcatgca",
+        //         012345678901
+        //              ffffff
+        //              ll  ll
+        //            ccccccccc
+        //            012345678
+        features: [
+          {
+            start: 5,
+            end: 10,
+            locations: [
+              { start: 5, end: 6 },
+              { start: 9, end: 10 }
+            ],
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 3,
+        end: 11
+      }
+    );
+    res.should.containSubset({
+      sequence: "atgcatgca",
+      features: [
+        {
+          start: 2,
+          end: 7,
+          locations: [
+            { start: 2, end: 3 },
+            { start: 6, end: 7 }
+          ],
+          name: "happy"
+        }
+      ]
+    });
+  });
+  it.only("feature with locations, non circular, non-fully enclosing range - it should trim the start/end correctly to match the location", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        sequence: "gggatgcatgca",
+        //         012345678901
+        //              ffffff
+        //              ll  ll
+        //                sssss
+        //                01234
+        features: [
+          {
+            start: 5,
+            end: 10,
+            locations: [
+              { start: 5, end: 6 },
+              { start: 9, end: 10 }
+            ],
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 7,
+        end: 11
+      }
+    );
+
+    res.should.containSubset({
+      sequence: "atgca",
+      features: [
+        {
+          start: 2,
+          end: 3,
+          name: "happy",
+          locations: undefined
+        }
+      ]
+    });
+  });
+  it("non circular feature, circular range", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        //ssss sss
+        //01234567
+        sequence: "atgcatgc",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ],
+        parts: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 5,
+        end: 3
+      }
+    );
+    res.should.containSubset({
+      sequence: "tgcatgc",
+      features: [
+        {
+          start: 0,
+          end: 2,
+          name: "happy"
+        },
+        {
+          start: 3,
+          end: 6,
+          name: "happy"
+        }
+      ],
+      parts: [
+        {
+          start: 0,
+          end: 2,
+          name: "happy"
+        },
+        {
+          start: 3,
+          end: 6,
+          name: "happy"
+        }
+      ]
+    });
+  });
+  it("non circular feature, circular range, with partial parts excluded", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        //ssss sss
+        //01234567
+        sequence: "atgcatgc",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ],
+        parts: {
+          "2asf23": {
+            start: 0,
+            id: "2asf23",
+            end: 7,
+            name: "happy"
+          }
+        }
+      },
+      {
+        start: 5,
+        end: 3
+      },
+      {
+        excludePartial: {
+          parts: true
+        }
+      }
+    );
+    res.should.containSubset({
+      sequence: "tgcatgc",
+      features: [
+        {
+          start: 0,
+          end: 2,
+          name: "happy"
+        },
+        {
+          start: 3,
+          end: 6,
+          name: "happy"
+        }
+      ],
+      parts: []
+    });
+  });
+  it("non circular feature, circular range, with features excluded", () => {
+    const res = getSequenceDataBetweenRange(
+      {
+        //ssss sss
+        //01234567
+        sequence: "atgcatgc",
+        features: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ],
+        parts: [
+          {
+            start: 0,
+            end: 7,
+            name: "happy"
+          }
+        ]
+      },
+      {
+        start: 5,
+        end: 3
+      },
+      { exclude: { features: true } }
+    );
+    res.features.length.should.equal(0);
+    res.should.containSubset({
+      sequence: "tgcatgc",
+      features: [],
+      parts: [
+        {
+          start: 0,
+          end: 2,
+          name: "happy"
+        },
+        {
+          start: 3,
+          end: 6,
+          name: "happy"
+        }
+      ]
+    });
+  });
+});

package/src/getVirtualDigest.js

@@ -0,0 +1,125 @@
+//UNDER CONSTRUCTION
+
+import {get} from "lodash";
+
+import {normalizePositionByRangeLength, getRangeLength} from "@teselagen/range-utils";
+
+export default function getVirtualDigest({
+  cutsites,
+  sequenceLength,
+  isCircular,
+  computePartialDigest,
+  computePartialDigestDisabled,
+  computeDigestDisabled
+}) {
+  let fragments = [];
+  const overlappingEnzymes = [];
+  const pairs = [];
+
+  const sortedCutsites = cutsites.sort((a, b) => {
+    return a.topSnipPosition - b.topSnipPosition;
+  });
+
+  sortedCutsites.forEach((cutsite1, index) => {
+    if (computePartialDigest && !computePartialDigestDisabled) {
+      sortedCutsites.forEach((cs, index2) => {
+        // if (index2 === index + 1 || index2 === 0) { //tnw: not sure if this is necessary or not. commenting out for now
+        //   return;
+        // }
+        pairs.push([cutsite1, sortedCutsites[index2]]);
+      });
+    }
+    if (!computeDigestDisabled) {
+      pairs.push([
+        cutsite1,
+        sortedCutsites[index + 1]
+          ? sortedCutsites[index + 1]
+          : sortedCutsites[0]
+      ]);
+    }
+  });
+
+  pairs.forEach(([cut1, cut2]) => {
+    const start = normalizePositionByRangeLength(
+      cut1.topSnipPosition,
+      sequenceLength
+    );
+    const end = normalizePositionByRangeLength(
+      cut2.topSnipPosition - 1,
+      sequenceLength
+    );
+
+    if (!isCircular && start > end) {
+      //we have a fragment that spans the origin so we need to split it in 2 pieces
+      const frag1 = {
+        start: start,
+        end: sequenceLength - 1,
+        cut1,
+        cut2: {
+          type: "endOfSeq",
+          restrictionEnzyme: {
+            name: "End Of Seq"
+          }
+        }
+      };
+      const frag2 = {
+        start: 0,
+        end: end,
+        cut1: {
+          type: "startOfSeq",
+          restrictionEnzyme: {
+            name: "Start Of Seq"
+          }
+        },
+        cut2: cut2
+      };
+
+      fragments.push(addSizeIdName(frag1, sequenceLength));
+      fragments.push(addSizeIdName(frag2, sequenceLength));
+    } else {
+      const frag = {
+        cut1,
+        cut2,
+        start,
+        end
+      };
+      fragments.push(addSizeIdName(frag, sequenceLength));
+    }
+  });
+  fragments = fragments.filter(fragment => {
+    if (!fragment.size) {
+      overlappingEnzymes.push(fragment);
+      return false;
+    }
+    return true;
+  });
+  return {
+    computePartialDigestDisabled,
+    computeDigestDisabled,
+    fragments,
+    overlappingEnzymes
+  };
+};
+
+function addSizeIdName(frag, sequenceLength) {
+  const size = getRangeLength(
+    { start: frag.start, end: frag.end },
+    sequenceLength
+  );
+  const name = `${get(
+    frag,
+    "cut1.restrictionEnzyme.name",
+    "Untitled Cutsite"
+  )} -- ${get(
+    frag,
+    "cut2.restrictionEnzyme.name",
+    "Untitled Cutsite"
+  )} ${size} bps`;
+
+  return {
+    ...frag,
+    size,
+    name,
+    id: frag.start + "-" + frag.end + "-" + size + "-"
+  };
+}

package/src/getVirtualDigest.test.js

@@ -0,0 +1,134 @@
+import chaiSubset from "chai-subset";
+import chai from "chai";
+
+//UNDER CONSTRUCTION
+import getVirtualDigest from "./getVirtualDigest";
+
+chai.should();
+chai.use(chaiSubset);
+
+describe("getVirtualDigest", () => {
+  // it('should be further developed', function() {
+
+  // })
+  it("should return the correct fragments given a set of cutsites and computePartialDigest=true", () => {
+    const { fragments } = getVirtualDigest({
+      cutsites: [{ topSnipPosition: 10 }, { topSnipPosition: 20 }],
+      sequenceLength: 100,
+      isCircular: true,
+      computePartialDigest: true
+    });
+    fragments.should.containSubset([
+      {
+        cut1: { topSnipPosition: 10 },
+        cut2: { topSnipPosition: 10 },
+        start: 10,
+        end: 9,
+        size: 100,
+        id: "10-9-100-"
+      },
+      {
+        cut1: { topSnipPosition: 10 },
+        cut2: { topSnipPosition: 20 },
+        start: 10,
+        end: 19,
+        size: 10,
+        id: "10-19-10-"
+      },
+      {
+        cut1: { topSnipPosition: 20 },
+        cut2: { topSnipPosition: 10 },
+        start: 20,
+        end: 9,
+        size: 90,
+        id: "20-9-90-"
+      },
+      {
+        cut1: { topSnipPosition: 20 },
+        cut2: { topSnipPosition: 20 },
+        start: 20,
+        end: 19,
+        size: 100,
+        id: "20-19-100-"
+      }
+    ]);
+  });
+  it("should return the correct fragments given a set of cutsites", () => {
+    const { fragments } = getVirtualDigest({
+      cutsites: [{ topSnipPosition: 10 }, { topSnipPosition: 20 }],
+      sequenceLength: 100,
+      isCircular: true,
+      computePartialDigest: false
+    });
+    fragments.should.containSubset([
+      {
+        cut1: { topSnipPosition: 10 },
+        cut2: { topSnipPosition: 20 },
+        start: 10,
+        end: 19,
+        size: 10,
+        id: "10-19-10-"
+      },
+      {
+        cut1: { topSnipPosition: 20 },
+        cut2: { topSnipPosition: 10 },
+        start: 20,
+        end: 9,
+        size: 90,
+        id: "20-9-90-"
+      }
+    ]);
+  });
+  it("should return the correct fragments given a set of cutsites and a linear sequence", () => {
+    const { fragments } = getVirtualDigest({
+      cutsites: [{ topSnipPosition: 10 }, { topSnipPosition: 20 }],
+      sequenceLength: 100,
+      isCircular: false,
+      computePartialDigest: false
+    });
+    fragments.should.containSubset([
+      {
+        cut1: {
+          topSnipPosition: 10
+        },
+        cut2: {
+          topSnipPosition: 20
+        },
+        start: 10,
+        end: 19,
+        size: 10,
+        id: "10-19-10-"
+      },
+      {
+        start: 20,
+        end: 99,
+        cut1: {
+          topSnipPosition: 20
+        },
+        cut2: {
+          restrictionEnzyme: {
+            name: "End Of Seq"
+          },
+          type: "endOfSeq"
+        },
+        size: 80,
+        id: "20-99-80-"
+      },
+      {
+        start: 0,
+        end: 9,
+        cut1: {
+          restrictionEnzyme: {
+            name: "Start Of Seq"
+          },
+          type: "startOfSeq"
+        },
+        cut2: {
+          topSnipPosition: 10
+        },
+        size: 10,
+        id: "0-9-10-"
+      }
+    ]);
+  });
+});