def testEmptyCoverageCounts(self): """ When no intervals are added, coverageCounts should return an empty Counter. """ ri = ReadIntervals(100) self.assertEqual({}, ri.coverageCounts())
def testEmptyCoverageCountsOnZeroLengthSequence(self): """ When no intervals are added, coverageCounts should return an empty Counter. """ ri = ReadIntervals(0) self.assertEqual({}, ri.coverageCounts())
def testOneIntervalStartingBeforeZeroCoverage(self): """ If there is a single interval that starts before zero but doesn't cover the whole hit, coverage should return the correct value. """ ri = ReadIntervals(100) ri.add(-50, 50) self.assertEqual(0.5, ri.coverage())
def testOneIntervalExactCovering(self): """ If there is a single interval that spans the whole hit exactly, just that one interval should be returned by walk, and it should be full. """ ri = ReadIntervals(100) ri.add(0, 100) self.assertEqual([(self.FULL, (0, 100))], list(ri.walk()))
def testOneIntervalEndingAfterHitEndCoverage(self): """ If there is a single interval that ends after the end of the hit but doesn't start at zero, coverage should return the correct value. """ ri = ReadIntervals(100) ri.add(50, 150) self.assertEqual(0.5, ri.coverage())
def testOneIntervalCoveringAllExtendingRightCoverage(self): """ If there is a single interval that spans the whole hit, including going beyond the hit to the right, coverage should return 1.0. """ ri = ReadIntervals(100) ri.add(0, 110) self.assertEqual(1.0, ri.coverage())
def testOneIntervalExactCoveringCoverage(self): """ If there is a single interval that spans the whole hit exactly, coverage should return 1.0. """ ri = ReadIntervals(100) ri.add(0, 100) self.assertEqual(1.0, ri.coverage())
def testOneIntervalCoveringAllExtendingLeftCoverage(self): """ If there is a single interval that spans the whole hit, including going negative to the left, coverage should return 1.0. """ ri = ReadIntervals(100) ri.add(-10, 100) self.assertEqual(1.0, ri.coverage())
def testEmpty(self): """ When no intervals are added, walk should just return one empty interval that spans the entire rangoe from 0 to the sequence length. """ ri = ReadIntervals(100) self.assertEqual([(self.EMPTY, (0, 100))], list(ri.walk()))
def testNoReads(self): """ When no reads are added to an interval, the reduction should be for the full hit width. """ ri = ReadIntervals(64) adjuster = OffsetAdjuster(ri) self.assertEqual([(64, 58)], adjuster.adjustments()) self.assertEqual(6, adjuster.adjustOffset(64))
def testOneIntervalCoveringAllExtendingLeft(self): """ If there is a single interval that spans the whole hit, including going negative to the left, that one interval should be returned by walk, and it should be full. """ ri = ReadIntervals(100) ri.add(-10, 100) self.assertEqual([(self.FULL, (-10, 100))], list(ri.walk()))
def testTwoOverlappingIntervalsInMiddleCoverage(self): """ If there are two overlapping intervals in the middle of the hit, coverage should return the correct value. """ ri = ReadIntervals(100) ri.add(50, 60) ri.add(55, 70) self.assertEqual(0.2, ri.coverage())
def testOneIntervalInMiddleCoverage(self): """ If there is a single interval in the middle of the hit, coverage should return the correct value. """ ri = ReadIntervals(100) ri.add(50, 60) self.assertEqual(0.1, ri.coverage())
def testOneIntervalStartingAtZeroCoverageCounts(self): """ If there is a single interval that starts at zero but doesn't cover the whole hit, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(0, 5) c = Counter([0, 1, 2, 3, 4]) self.assertEqual(c, ri.coverageCounts())
def testOneIntervalExactCoveringCoverageCounts(self): """ If there is a single interval that spans the whole hit exactly, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(0, 10) c = Counter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) self.assertEqual(c, ri.coverageCounts())
def testOneIntervalInMiddleCoverageCounts(self): """ If there is a single interval in the middle of the hit, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(5, 6) c = Counter([5]) self.assertEqual(c, ri.coverageCounts())
def testOneIntervalCoveringAllExtendingBoth(self): """ If there is a single interval that spans the whole hit, including starting before zero and also going beyond the hit to the right, that one interval should be returned by walk, and it should be full. """ ri = ReadIntervals(100) ri.add(-10, 110) self.assertEqual([(self.FULL, (-10, 110))], list(ri.walk()))
def coverageCounts(self): """ For each location in the title sequence, return a count of how many times that location is covered by a read. """ intervals = ReadIntervals(self.subjectLength) for hsp in self.hsps(): intervals.add(hsp.subjectStart, hsp.subjectEnd) return intervals.coverageCounts()
def testOneIntervalCoveringAllExtendingBothCoverage(self): """ If there is a single interval that spans the whole hit, including starting before zero and also going beyond the hit to the right, coverage should return 1.0 """ ri = ReadIntervals(100) ri.add(-10, 110) self.assertEqual(1.0, ri.coverage())
def testTwoOverlappingIntervalsInMiddleCoverageCounts(self): """ If there are two overlapping intervals in the middle of the hit, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(5, 7) ri.add(6, 8) c = Counter([5, 6, 6, 7]) self.assertEqual(c, ri.coverageCounts())
def testOneReadThatExactlyCoversHit(self): """ When one read is given that exactly covers the hit, there should be no length reductions. """ ri = ReadIntervals(106) ri.add(0, 106) adjuster = OffsetAdjuster(ri) self.assertEqual([], adjuster.adjustments()) self.assertEqual(106, adjuster.adjustOffset(106))
def testOneReadThatExceedsHitOnBothEnds(self): """ When one read is given that exceeds the hit at both ends, there should be no length reductions. """ ri = ReadIntervals(106) ri.add(-100, 200) adjuster = OffsetAdjuster(ri) self.assertEqual([], adjuster.adjustments()) self.assertEqual(106, adjuster.adjustOffset(106))
def testOneIntervalEndingAtHitEndCoverageCounts(self): """ If there is a single interval that ends at the end of the hit but doesn't start at zero, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(5, 10) c = Counter([5, 6, 7, 8, 9]) self.assertEqual(c, ri.coverageCounts())
def testOneIntervalCoveringAllExtendingRightCoverageCounts(self): """ If there is a single interval that spans the whole hit, including going beyond the hit to the right, coverageCounts should return the correct result. """ ri = ReadIntervals(10) ri.add(0, 12) c = Counter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) self.assertEqual(c, ri.coverageCounts())
def coverage(self): """ Get the fraction of this title sequence that is matched by its reads. @return: The C{float} fraction of the title sequence matched by its reads. """ intervals = ReadIntervals(self.subjectLength) for hsp in self.hsps(): intervals.add(hsp.subjectStart, hsp.subjectEnd) return intervals.coverage()
def testOneIntervalEndingAtHitEnd(self): """ If there is a single interval that ends at the end of the hit but doesn't start at zero, we should get 2 intervals back from walk, an empty then a full. """ ri = ReadIntervals(100) ri.add(50, 100) self.assertEqual([ (self.EMPTY, (0, 50)), (self.FULL, (50, 100)), ], list(ri.walk()))
def testOneIntervalStartingBeforeZero(self): """ If there is a single interval that starts before zero but doesn't cover the whole hit, we should get 2 intervals back from walk, a full one and then an empty. """ ri = ReadIntervals(100) ri.add(-50, 50) self.assertEqual([ (self.FULL, (-50, 50)), (self.EMPTY, (50, 100)), ], list(ri.walk()))
def testOneReadBeforeStart(self): """ When one read is added to the start of an interval before zero, there should be one reduction for the empty section after the read. """ ri = ReadIntervals(228) ri.add(-10, 100) adjuster = OffsetAdjuster(ri) self.assertEqual([ (228, 121), ], adjuster.adjustments()) self.assertEqual(107, adjuster.adjustOffset(228))
def testOneReadAtEnd(self): """ When one read is added to the end of an interval, there should be one reduction for the empty section before the read. """ ri = ReadIntervals(228) ri.add(128, 228) adjuster = OffsetAdjuster(ri) self.assertEqual([ (128, 121), ], adjuster.adjustments()) self.assertEqual(107, adjuster.adjustOffset(228))
def testTwoReadsInMiddle(self): """ When two reads are added to the middle of an interval, there should be three reductions (after first empty area, after 2nd empty area, after final empty area. """ ri = ReadIntervals(132) ri.add(32, 42) ri.add(58, 68) adjuster = OffsetAdjuster(ri) self.assertEqual([ (32, 27), (58, 12), (132, 58), ], adjuster.adjustments()) self.assertEqual(132 - 27 - 12 - 58, adjuster.adjustOffset(132)) # Test an HSP at the beginning is unchanged. hsp = HSP(10, readEndInSubject=10, readStartInSubject=0, subjectEnd=10, subjectStart=0) adjuster.adjustHSP(hsp) self.assertEqual(10, hsp.readEndInSubject) self.assertEqual(0, hsp.readStartInSubject) self.assertEqual(10, hsp.subjectEnd) self.assertEqual(0, hsp.subjectStart) # Test an HSP in the first read region. hsp = HSP(10, readEndInSubject=42, readStartInSubject=32, subjectEnd=40, subjectStart=35) adjuster.adjustHSP(hsp) self.assertEqual(15, hsp.readEndInSubject) self.assertEqual(5, hsp.readStartInSubject) self.assertEqual(13, hsp.subjectEnd) self.assertEqual(8, hsp.subjectStart) # Test an HSP in the second read region. hsp = HSP(10, readEndInSubject=68, readStartInSubject=58, subjectEnd=66, subjectStart=60) adjuster.adjustHSP(hsp) self.assertEqual(29, hsp.readEndInSubject) self.assertEqual(19, hsp.readStartInSubject) self.assertEqual(27, hsp.subjectEnd) self.assertEqual(21, hsp.subjectStart)