Mercurial > repos > yufei-luo > s_mart
comparison SMART/Java/Python/structure/test/Test_TranscriptListsComparator.py @ 6:769e306b7933
Change the repository level.
author | yufei-luo |
---|---|
date | Fri, 18 Jan 2013 04:54:14 -0500 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
5:ea3082881bf8 | 6:769e306b7933 |
---|---|
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() |