Mercurial > repos > yufei-luo > s_mart
comparison smart_toolShed/SMART/Java/Python/structure/test/Test_TranscriptListsComparator.py @ 0:e0f8dcca02ed
Uploaded S-MART tool. A toolbox manages RNA-Seq and ChIP-Seq data.
| author | yufei-luo |
|---|---|
| date | Thu, 17 Jan 2013 10:52:14 -0500 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| -1:000000000000 | 0:e0f8dcca02ed |
|---|---|
| 1 import os | |
| 2 import unittest | |
| 3 from SMART.Java.Python.structure.TranscriptListsComparator import TranscriptListsComparator | |
| 4 from SMART.Java.Python.structure.TranscriptContainer import TranscriptContainer | |
| 5 from commons.core.writer.Gff3Writer import Gff3Writer | |
| 6 from commons.core.parsing.GffParser import GffParser | |
| 7 from commons.core.utils.FileUtils import FileUtils | |
| 8 | |
| 9 SMART_PATH = os.environ["REPET_PATH"] + "/SMART" | |
| 10 | |
| 11 class Test_TranscriptListsComparator(unittest.TestCase): | |
| 12 | |
| 13 | |
| 14 def test_compareTranscriptList(self): | |
| 15 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptList1.bed" % SMART_PATH, "bed", 0) | |
| 16 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptList2.bed" % SMART_PATH, "bed", 0) | |
| 17 outputContainer = "output.gff3" | |
| 18 comparator = TranscriptListsComparator(None, 0) | |
| 19 comparator.computeOdds(True) | |
| 20 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 21 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 22 comparator.setOutputWriter(Gff3Writer(outputContainer, 0)) | |
| 23 comparator.compareTranscriptList() | |
| 24 parser = GffParser("output.gff3", 0) | |
| 25 self.assertEqual(parser.getNbTranscripts(), 2) | |
| 26 cpt = 0 | |
| 27 for transcript in parser.getIterator(): | |
| 28 if cpt == 0: | |
| 29 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 30 self.assertEqual(transcript.getStart(), 1000) | |
| 31 self.assertEqual(transcript.getEnd(), 1999) | |
| 32 self.assertEqual(transcript.getDirection(), 1) | |
| 33 elif cpt == 1: | |
| 34 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 35 self.assertEqual(transcript.getStart(), 1000) | |
| 36 self.assertEqual(transcript.getEnd(), 1999) | |
| 37 self.assertEqual(transcript.getDirection(), -1) | |
| 38 cpt += 1 | |
| 39 | |
| 40 | |
| 41 def test_compareTranscriptListDistanceSimple(self): | |
| 42 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testCompareTranscriptListDistanceSimple1.gff3" % SMART_PATH, "gff", 0) | |
| 43 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testCompareTranscriptListDistanceSimple2.gff3" % SMART_PATH, "gff", 0) | |
| 44 | |
| 45 comparator = TranscriptListsComparator(None, 0) | |
| 46 comparator.computeOdds(True) | |
| 47 comparator.setMaxDistance(1000) | |
| 48 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 49 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 50 distances = comparator.compareTranscriptListDistance() | |
| 51 | |
| 52 self.assertEqual(distances, {0: 1}) | |
| 53 | |
| 54 comparator = TranscriptListsComparator(None, 0) | |
| 55 comparator.computeOdds(True) | |
| 56 comparator.setMaxDistance(1000) | |
| 57 comparator.setInputTranscriptContainer(comparator.QUERY, container2) | |
| 58 comparator.setInputTranscriptContainer(comparator.REFERENCE, container1) | |
| 59 distances = comparator.compareTranscriptListDistance() | |
| 60 | |
| 61 self.assertEqual(distances, {0: 1, -1000: 1}) | |
| 62 | |
| 63 | |
| 64 def test_compareTranscriptListDistanceAntisense(self): | |
| 65 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testCompareTranscriptListDistanceAntisense1.gff3" % SMART_PATH, "gff", 0) | |
| 66 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testCompareTranscriptListDistanceAntisense2.gff3" % SMART_PATH, "gff", 0) | |
| 67 | |
| 68 comparator = TranscriptListsComparator(None, 0) | |
| 69 comparator.computeOdds(True) | |
| 70 comparator.setMaxDistance(10000) | |
| 71 comparator.getAntisenseOnly(True) | |
| 72 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 73 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 74 distances = comparator.compareTranscriptListDistance() | |
| 75 | |
| 76 self.assertEqual(distances, {1000: 1}) | |
| 77 | |
| 78 | |
| 79 | |
| 80 def test_compareTranscriptListMergeSimple(self): | |
| 81 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeSimple1.bed" % SMART_PATH, "bed", 0) | |
| 82 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeSimple2.bed" % SMART_PATH, "bed", 0) | |
| 83 outputContainer = 'output.gff3' | |
| 84 comparator = TranscriptListsComparator(None, 0) | |
| 85 comparator.computeOdds(True) | |
| 86 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 87 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 88 comparator.setOutputWriter(Gff3Writer(outputContainer, 0)) | |
| 89 comparator.compareTranscriptListMerge() | |
| 90 | |
| 91 parser = GffParser(outputContainer, 0) | |
| 92 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 93 for transcript in parser.getIterator(): | |
| 94 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 95 self.assertEqual(transcript.getStart(), 1000) | |
| 96 self.assertEqual(transcript.getEnd(), 3999) | |
| 97 self.assertEqual(transcript.getDirection(), 1) | |
| 98 self.assertEqual(transcript.getSize(), 3000) | |
| 99 | |
| 100 def test_compareTranscriptListMergeSenseAntiSenseAway(self): | |
| 101 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeSenseAntiSenseAway1.bed" % SMART_PATH, "bed", 0) | |
| 102 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeSenseAntiSenseAway2.bed" % SMART_PATH, "bed", 0) | |
| 103 outputContainer = 'output.gff3' | |
| 104 comparator = TranscriptListsComparator(None, 0) | |
| 105 comparator.restrictToStart(comparator.QUERY, 2) | |
| 106 comparator.restrictToStart(comparator.REFERENCE, 2) | |
| 107 comparator.extendFivePrime(comparator.REFERENCE, 150) | |
| 108 comparator.getAntisenseOnly(True) | |
| 109 comparator.computeOdds(True) | |
| 110 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 111 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 112 comparator.setOutputWriter(Gff3Writer(outputContainer, 0)) | |
| 113 comparator.compareTranscriptListMerge() | |
| 114 | |
| 115 parser = GffParser(outputContainer, 0) | |
| 116 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 117 for transcript in parser.getIterator(): | |
| 118 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 119 self.assertEqual(transcript.getStart(), 10000048) | |
| 120 self.assertEqual(transcript.getEnd(), 10000199) | |
| 121 self.assertEqual(transcript.getSize(), 152) | |
| 122 self.assertEqual(transcript.getNbExons(), 1) | |
| 123 | |
| 124 | |
| 125 def test_compareTranscriptListMergeAggregation(self): | |
| 126 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeAggregation1.bed" % SMART_PATH, "bed", 0) | |
| 127 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListMergeAggregation2.bed" % SMART_PATH, "bed", 0) | |
| 128 outputContainer = 'output.gff3' | |
| 129 comparator = TranscriptListsComparator(None, 0) | |
| 130 comparator.getColinearOnly(True) | |
| 131 comparator.computeOdds(True) | |
| 132 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 133 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 134 comparator.aggregate(True) | |
| 135 comparator.setOutputWriter(Gff3Writer(outputContainer, 0)) | |
| 136 comparator.compareTranscriptListMerge() | |
| 137 | |
| 138 parser = GffParser(outputContainer, 0) | |
| 139 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 140 for transcript in parser.getIterator(): | |
| 141 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 142 self.assertEqual(transcript.getStart(), 10000000) | |
| 143 self.assertEqual(transcript.getEnd(), 10000199) | |
| 144 self.assertEqual(transcript.getSize(), 200) | |
| 145 self.assertEqual(transcript.getNbExons(), 1) | |
| 146 | |
| 147 | |
| 148 def test_compareTranscriptListSelfMerge(self): | |
| 149 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListSelfMerge1.gff3" % SMART_PATH, "gff", 0) | |
| 150 | |
| 151 comparator = TranscriptListsComparator(None, 0) | |
| 152 comparator.computeOdds(True) | |
| 153 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 154 comparator.setOutputWriter(Gff3Writer("output.gff3", 0)) | |
| 155 comparator.compareTranscriptListSelfMerge() | |
| 156 | |
| 157 parser = GffParser("output.gff3", 0) | |
| 158 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 159 for transcript in parser.getIterator(): | |
| 160 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 161 self.assertEqual(transcript.getStart(), 1000) | |
| 162 self.assertEqual(transcript.getEnd(), 2000) | |
| 163 self.assertEqual(transcript.getDirection(), 1) | |
| 164 self.assertEqual(transcript.getNbExons(), 1) | |
| 165 self.assertEqual(transcript.getSize(), 1001) | |
| 166 self.assertEqual(float(transcript.getTagValue("nbElements")), 3) | |
| 167 | |
| 168 | |
| 169 def test_compareTranscriptListSelfMergeSense(self): | |
| 170 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListSelfMerge1.gff3" % SMART_PATH, "gff", 0) | |
| 171 | |
| 172 comparator = TranscriptListsComparator(None, 0) | |
| 173 comparator.getColinearOnly(True) | |
| 174 comparator.computeOdds(True) | |
| 175 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 176 comparator.setOutputWriter(Gff3Writer("output.gff3", 0)) | |
| 177 comparator.compareTranscriptListSelfMerge() | |
| 178 | |
| 179 parser = GffParser("%s/SMART/Java/Python/structure/test/output.gff3" % os.environ["REPET_PATH"], 0) | |
| 180 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 181 for transcript in parser.getIterator(): | |
| 182 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 183 self.assertEqual(transcript.getStart(), 1000) | |
| 184 self.assertEqual(transcript.getEnd(), 2000) | |
| 185 self.assertEqual(transcript.getDirection(), 1) | |
| 186 self.assertEqual(transcript.getNbExons(), 1) | |
| 187 self.assertEqual(transcript.getSize(), 1001) | |
| 188 | |
| 189 def test_compareTranscriptListSelfMergeDifferentClusters(self): | |
| 190 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListSelfMergeDifferentClusters1.bed" % SMART_PATH, "bed", 0) | |
| 191 comparator = TranscriptListsComparator(None, 0) | |
| 192 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 193 comparator.setOutputWriter(Gff3Writer("output.gff3", 0)) | |
| 194 comparator.compareTranscriptListSelfMerge() | |
| 195 | |
| 196 parser = GffParser("output.gff3", 0) | |
| 197 self.assertEquals(parser.getNbTranscripts(), 1) | |
| 198 for transcript in parser.getIterator(): | |
| 199 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 200 self.assertEqual(transcript.getStart(), 100) | |
| 201 self.assertEqual(transcript.getEnd(), 100099) | |
| 202 self.assertEqual(transcript.getDirection(), 1) | |
| 203 self.assertEqual(transcript.getNbExons(), 1) | |
| 204 self.assertEqual(transcript.getSize(), 100000) | |
| 205 | |
| 206 | |
| 207 def test_compareTranscriptListgetDifferenceTranscriptList(self): | |
| 208 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListGetDifference1.gff3" % SMART_PATH, "gff", 0) | |
| 209 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListGetDifference2.gff3" % SMART_PATH, "gff", 0) | |
| 210 | |
| 211 comparator = TranscriptListsComparator(None, 0) | |
| 212 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 213 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 214 comparator.setOutputWriter(Gff3Writer("output.gff3", 0)) | |
| 215 comparator.getDifferenceTranscriptList() | |
| 216 | |
| 217 parser = GffParser("output.gff3", 0) | |
| 218 self.assertEqual(parser.getNbTranscripts(), 1) | |
| 219 for transcript in parser.getIterator(): | |
| 220 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 221 self.assertEqual(transcript.getStart(), 1000) | |
| 222 self.assertEqual(transcript.getEnd(), 4000) | |
| 223 self.assertEqual(transcript.getDirection(), 1) | |
| 224 self.assertEqual(transcript.getNbExons(), 2) | |
| 225 exon1, exon2 = transcript.getExons() | |
| 226 self.assertEqual(exon1.getStart(), 1000) | |
| 227 self.assertEqual(exon1.getEnd(), 1999) | |
| 228 self.assertEqual(exon2.getStart(), 3001) | |
| 229 self.assertEqual(exon2.getEnd(), 4000) | |
| 230 | |
| 231 | |
| 232 | |
| 233 def test_compareTranscriptListgetDifferenceTranscriptListSplit(self): | |
| 234 container1 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListGetDifference1.gff3" % SMART_PATH, "gff", 0) | |
| 235 container2 = TranscriptContainer("%s/Java/Python/TestFiles/testTranscriptListsComparatorCompareTranscriptListGetDifference2.gff3" % SMART_PATH, "gff", 0) | |
| 236 | |
| 237 comparator = TranscriptListsComparator(None, 0) | |
| 238 comparator.setInputTranscriptContainer(comparator.QUERY, container1) | |
| 239 comparator.setInputTranscriptContainer(comparator.REFERENCE, container2) | |
| 240 comparator.setSplitDifference(True) | |
| 241 comparator.setOutputWriter(Gff3Writer("output.gff3", 0)) | |
| 242 comparator.getDifferenceTranscriptList() | |
| 243 | |
| 244 parser = GffParser("output.gff3", 0) | |
| 245 self.assertEqual(parser.getNbTranscripts(), 2) | |
| 246 for id, transcript in enumerate(parser.getIterator()): | |
| 247 if id == 0: | |
| 248 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 249 self.assertEqual(transcript.getStart(), 1000) | |
| 250 self.assertEqual(transcript.getEnd(), 1999) | |
| 251 self.assertEqual(transcript.getDirection(), 1) | |
| 252 self.assertEqual(transcript.getNbExons(), 1) | |
| 253 else: | |
| 254 self.assertEqual(transcript.getChromosome(), "arm_X") | |
| 255 self.assertEqual(transcript.getStart(), 3001) | |
| 256 self.assertEqual(transcript.getEnd(), 4000) | |
| 257 self.assertEqual(transcript.getDirection(), 1) | |
| 258 self.assertEqual(transcript.getNbExons(), 1) | |
| 259 | |
| 260 | |
| 261 if __name__ == '__main__': | |
| 262 unittest.main() |