|
6
|
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()
|
