def testNotEquals(self):
mite1 = Mite("ABC", "4", "+", "132", "154", "NULL", "Unclassified",
"Unclassified", "3")
gene1 = Gene("gABC", "4", "+", "132", "154", "5", "3")
mite2 = Mite("ABC", "3", "+", "132", "154", "NULL", "Unclassified",
"Unclassified", "3")
gene2 = Gene("gABC", "4", "+", "132", "154", "5", "3")
pair1 = MiteGenePair(mite1, gene1)
pair2 = MiteGenePair(mite2, gene2)
self.assertNotEqual(pair1, pair2)
def test_pair_mites_correctly_separates_by_genome_location(self):
mite1 = Mite("ABC1", "1", "+", "1", "10", "NULL", "AA", "A", "1")
mite2 = Mite("ABC2", "1", "-", "21", "30", "NULL", "AA", "A", "1")
mite3 = Mite("ABC3", "2", "+", "41", "50", "NULL", "AA", "A", "1")
mite4 = Mite("ABC4", "2", "-", "61", "70", "NULL", "AA", "A", "1")
mite5 = Mite("ABC5", "1", "+", "81", "90", "NULL", "AA", "A", "2")
mite6 = Mite("ABC6", "1", "-", "101", "110", "NULL", "AA", "A", "2")
mite7 = Mite("ABC7", "2", "+", "121", "130", "NULL", "AA", "A", "2")
mite8 = Mite("ABC8", "2", "-", "141", "150", "NULL", "AA", "A", "2")
gene1 = Gene("gABC1", "1", "+", "126", "135", "5", "1")
gene2 = Gene("gABC2", "1", "-", "146", "155", "5", "1")
gene3 = Gene("gABC3", "2", "+", "6", "15", "5", "1")
gene4 = Gene("gABC4", "2", "-", "26", "35", "5", "1")
gene5 = Gene("gABC5", "1", "+", "46", "55", "5", "2")
gene6 = Gene("gABC6", "1", "-", "66", "75", "5", "2")
gene7 = Gene("gABC7", "2", "+", "86", "95", "5", "2")
gene8 = Gene("gABC8", "2", "-", "106", "115", "5", "2")
mites = [mite1, mite2, mite3, mite4, mite5, mite6, mite7, mite8]
genes = [gene1, gene2, gene3, gene4, gene5, gene6, gene7, gene8]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [
MiteGenePair(mite1, gene1),
MiteGenePair(mite2, gene1),
MiteGenePair(mite3, gene4),
MiteGenePair(mite4, gene4),
MiteGenePair(mite5, gene6),
MiteGenePair(mite6, gene6),
MiteGenePair(mite7, gene8),
MiteGenePair(mite8, gene8)
]
self.assertEqual(pairs, expected_pairs)
def test_parse_csv(self):
mites = self.parser.parse_csv('mock_data/test_mite.csv')
expected_mites = [
Mite("AT1M10", "1", "-", "255103", "255179", "NULL",
"Unclassified", "Unclassified", "1"),
Mite("AT1M10", "1", "-", "253498", "253574", "NULL",
"Unclassified", "Unclassified", "2"),
Mite("AT1M10", "1", "-", "255561", "255637", "NULL",
"Unclassified", "Unclassified", "3"),
Mite("AT1M10", "1", "-", "255321", "255397", "NULL",
"Unclassified", "Unclassified", "4"),
Mite("AT1M10", "1", "-", "255769", "255845", "NULL",
"Unclassified", "Unclassified", "5")
]
self.assertListEqual(expected_mites, mites)
def testEquals(self):
mite = Mite("ABC", "4", "+", "132", "154", "NULL", "Unclassified",
"Unclassified", "3")
gene = Gene("gABC", "4", "+", "132", "154", "5", "3")
pair1 = MiteGenePair(mite, gene)
pair2 = MiteGenePair(mite, gene)
self.assertEqual(pair1, pair2)
def testToRowMiteInGene(self):
mite = Mite("ABC", "4", "+", "132", "154", "NULL", "Unclassified",
"Unclassified", "3")
gene = Gene("gABC", "4", "+", "120", "160", "5", "3")
pair = MiteGenePair(mite, gene)
csv_row_string = pair.to_csv_row()
expected_string = "ABC,4,+,132,154,3,,,,gABC,4,+,120,160,3,5,0"
self.assertEqual(expected_string, csv_row_string)
def test_index_elements(self):
mite1 = Mite("ABC1", "1", "+", "1", "10", "NULL", "AA", "A", "1")
mite2 = Mite("ABC2", "1", "-", "11", "20", "NULL", "AA", "A", "1")
mite3 = Mite("ABC3", "2", "+", "21", "30", "NULL", "AA", "A", "1")
mite4 = Mite("ABC4", "2", "-", "31", "40", "NULL", "AA", "A", "1")
mite5 = Mite("ABC5", "1", "+", "41", "50", "NULL", "AA", "A", "2")
mite6 = Mite("ABC6", "1", "-", "51", "60", "NULL", "AA", "A", "2")
mite7 = Mite("ABC7", "2", "+", "61", "70", "NULL", "AA", "A", "2")
mite8 = Mite("ABC8", "2", "-", "71", "80", "NULL", "AA", "A", "2")
gene1 = Gene("gABC1", "1", "+", "76", "85", "5", "1")
gene2 = Gene("gABC2", "1", "-", "5", "15", "5", "1")
gene3 = Gene("gABC3", "2", "+", "16", "25", "5", "1")
gene4 = Gene("gABC4", "2", "-", "26", "35", "5", "1")
gene5 = Gene("gABC5", "1", "+", "36", "45", "5", "2")
gene6 = Gene("gABC6", "1", "-", "46", "55", "5", "2")
gene7 = Gene("gABC7", "2", "+", "56", "65", "5", "2")
gene8 = Gene("gABC8", "2", "-", "66", "75", "5", "2")
elements = [
mite1, mite2, mite3, mite4, gene5, gene6, gene7, gene8, gene1,
gene2, gene3, gene4, mite5, mite6, mite7, mite8
]
expected_index = {
1: {
1: {
"ABC1": mite1,
"gABC1": gene1,
"ABC2": mite2,
"gABC2": gene2
},
2: {
"ABC3": mite3,
"gABC3": gene3,
"ABC4": mite4,
"gABC4": gene4
}
},
2: {
1: {
"ABC5": mite5,
"gABC5": gene5,
"ABC6": mite6,
"gABC6": gene6
},
2: {
"ABC7": mite7,
"gABC7": gene7,
"ABC8": mite8,
"gABC8": gene8
}
}
}
index = self.indexer.index_elements(elements)
self.assertEqual(expected_index, index)
def test_pair_mites_with_genes_results_independent_of_strand(self):
mite1 = Mite("ABC", "4", "+", "132", "154", "NULL", "AA", "A", "3")
mite2 = Mite("ABC1", "4", "+", "0", "15", "NULL", "AA", "A", "3")
mite3 = Mite("ABC2", "4", "-", "190", "200", "NULL", "AA", "A", "3")
mite4 = Mite("ABC3", "4", "-", "50", "65", "NULL", "AA", "A", "3")
gene1 = Gene("gABC", "4", "-", "100", "115", "5", "3")
gene2 = Gene("gBBC", "4", "+", "160", "170", "5", "3")
mites = [mite1, mite2, mite3, mite4]
genes = [gene1, gene2]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [
MiteGenePair(mite2, gene1),
MiteGenePair(mite4, gene1),
MiteGenePair(mite1, gene2),
MiteGenePair(mite3, gene2)
]
self.assertEqual(pairs, expected_pairs)
def testConstructor(self):
mite = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "A", "3")
self.assertEqual(mite.name, "ABC")
self.assertEqual(mite.chromosome, 4)
self.assertEqual(mite.strand, "+")
self.assertEqual(mite.start, 132)
self.assertEqual(mite.end, 154)
self.assertEqual(mite.correlated_gene, "gene1")
self.assertEqual(mite.family, "AA")
self.assertEqual(mite.superfamily, "A")
self.assertEqual(mite.genome_id, 3)
def testNotEquals(self):
mite1 = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "A", "3")
mite2 = Mite("A", "4", "+", "132", "154", "gene1", "AA", "A", "3")
mite3 = Mite("ABC", "1", "+", "132", "154", "gene1", "AA", "A", "3")
mite4 = Mite("ABC", "4", "-", "132", "154", "gene1", "AA", "A", "3")
mite5 = Mite("ABC", "4", "+", "1", "154", "gene1", "AA", "A", "3")
mite6 = Mite("ABC", "4", "+", "132", "1", "gene1", "AA", "A", "3")
mite7 = Mite("ABC", "4", "+", "132", "154", "gene2", "AA", "A", "3")
mite8 = Mite("ABC", "4", "+", "132", "154", "gene1", "BB", "A", "3")
mite9 = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "B", "3")
mite10 = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "B", "1")
self.assertNotEqual(mite1, mite2)
self.assertNotEqual(mite1, mite3)
self.assertNotEqual(mite1, mite4)
self.assertNotEqual(mite1, mite5)
self.assertNotEqual(mite1, mite6)
self.assertNotEqual(mite1, mite7)
self.assertNotEqual(mite1, mite8)
self.assertNotEqual(mite1, mite9)
self.assertNotEqual(mite1, mite10)
def testConstructorUnknownValues(self):
mite = Mite("ABC", "4", "+", "132", "154", "NULL", "Unclassified", "Unclassified", "3")
self.assertEqual(mite.name, "ABC")
self.assertEqual(mite.chromosome, 4)
self.assertEqual(mite.strand, "+")
self.assertEqual(mite.start, 132)
self.assertEqual(mite.end, 154)
self.assertEqual(mite.correlated_gene, None)
self.assertEqual(mite.family, None)
self.assertEqual(mite.superfamily, None)
self.assertEqual(mite.genome_id, 3)
def test_pair_mites_prefers_nested_elements(self):
#we assume that if a mite is nested in a gene (partially or completely), then it's associated with the gene
#so we pair the two elements together rather than another gene that's not nested but may be closer
mite1 = Mite("ABC", "4", "+", "132", "154", "NULL", "AA", "A", "3")
gene1 = Gene("gABC", "4", "+", "100", "143", "5", "3")
gene2 = Gene("gBBC", "4", "+", "155", "170", "5", "3")
mites = [mite1]
genes = [gene1, gene2]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [MiteGenePair(mite1, gene1)]
self.assertEqual(pairs, expected_pairs)
def test_pair_mites_prefers_nested_elements_input_order_doesnt_matter(
self):
#sanity check
mite1 = Mite("ABC", "4", "+", "132", "154", "NULL", "AA", "A", "3")
gene1 = Gene("gABC", "4", "+", "100", "143", "5", "3")
gene2 = Gene("gBBC", "4", "+", "155", "170", "5", "3")
mites = [mite1]
genes = [gene2, gene1]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [MiteGenePair(mite1, gene1)]
self.assertEqual(pairs, expected_pairs)
def test_pair_mites_uses_correlated_gene_if_provided(self):
#we assume that correlated_gene was filled for a reason so we ignore our distance heuristic or any other heuristic
mite1 = Mite("ABC", "4", "+", "132", "154", "gABC", "AA", "A", "3")
gene1 = Gene("gABC", "4", "+", "0", "10", "5", "3")
gene2 = Gene("gBBC", "4", "+", "155", "170", "5", "3")
gene3 = Gene("gCBC", "4", "+", "100", "143", "5", "3")
mites = [mite1]
genes = [gene1, gene2, gene3]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [MiteGenePair(mite1, gene1)]
self.assertEqual(pairs, expected_pairs)
def test_pair_mites_uses_heuristics_if_correlated_not_exist(self):
#go back to heuristics if we can't find the correlated gene
mite1 = Mite("ABC", "4", "+", "132", "154", "ABC", "AA", "A", "3")
gene1 = Gene("gDBC", "4", "+", "0", "10", "5", "3")
gene2 = Gene("gBBC", "4", "+", "155", "170", "5", "3")
gene3 = Gene("gCBC", "4", "+", "100", "143", "5", "3")
mites = [mite1]
genes = [gene1, gene2, gene3]
pairs = self.pairer.pair_mites_with_genes(mites, genes)
expected_pairs = [MiteGenePair(mite1, gene3)]
self.assertEqual(pairs, expected_pairs)
def parse_csv(self, path):
csv = super(MiteCSVParser, self).parse_csv(path, has_headers=True)
name = 0
chromosome = 1
strand = 2
start = 3
end = 4
correlated_gene = 5
family = 10
superfamily = 11
genome_id = 13
mites = []
for row in csv.data:
mite = Mite(row[name], row[chromosome], row[strand], row[start], row[end], row[correlated_gene], row[family], row[superfamily], row[genome_id])
mites.append(mite)
return mites
def test_index_elements_list_names(self):
mite1 = Mite("ABC1", "1", "+", "1", "10", "NULL", "AA", "A", "1")
mite2 = Mite("ABC2", "1", "-", "11", "20", "NULL", "AA", "A", "1")
mite3 = Mite("ABC3", "2", "+", "21", "30", "NULL", "AA", "A", "1")
mite4 = Mite("ABC4", "2", "-", "31", "40", "NULL", "AA", "A", "1")
mite5 = Mite("ABC5", "1", "+", "41", "50", "NULL", "AA", "A", "2")
mite6 = Mite("ABC6", "1", "-", "51", "60", "NULL", "AA", "A", "2")
mite7 = Mite("ABC7", "2", "+", "61", "70", "NULL", "AA", "A", "2")
mite8 = Mite("ABC8", "2", "-", "71", "80", "NULL", "AA", "A", "2")
gene1 = Gene("gABC1", "1", "+", "76", "85", "5", "1")
gene2 = Gene("gABC2", "1", "-", "5", "15", "5", "1")
gene3 = Gene("gABC3", "2", "+", "16", "25", "5", "1")
gene4 = Gene("gABC4", "2", "-", "26", "35", "5", "1")
gene5 = Gene("gABC5", "1", "+", "36", "45", "5", "2")
gene6 = Gene("gABC6", "1", "-", "46", "55", "5", "2")
gene7 = Gene("gABC7", "2", "+", "56", "65", "5", "2")
gene8 = Gene("gABC8", "2", "-", "66", "75", "5", "2")
elements = [
mite1, mite2, mite3, mite4, gene5, gene6, gene7, gene8, gene1,
gene2, gene3, gene4, mite5, mite6, mite7, mite8
]
expected_index = {
1: {
1: [mite1, mite2, gene1, gene2],
2: [mite3, mite4, gene3, gene4]
},
2: {
1: [gene5, gene6, mite5, mite6],
2: [gene7, gene8, mite7, mite8]
}
}
index = self.indexer.index_elements(elements, by_name=False)
self.assertEqual(expected_index, index)
def csv_headers():
return Mite.csv_headers() + "," + Gene.csv_headers() + ",distance"
def testEquals(self):
mite1 = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "A", "3")
mite2 = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "A", "3")
self.assertEqual(mite1, mite2)
def testToRowNullCorrelatedGene(self):
mite = Mite("ABC", "4", "+", "132", "154", "NULL", "AA", "A", "3")
csv_row_string = mite.to_csv_row()
expected_string = "ABC,4,+,132,154,3,,AA,A"
self.assertEqual(expected_string, csv_row_string)
def testToRowUnclassifiedSuperfamily(self):
mite = Mite("ABC", "4", "+", "132", "154", "gene1", "AA", "Unclassified", "3")
csv_row_string = mite.to_csv_row()
expected_string = "ABC,4,+,132,154,3,gene1,AA,"
self.assertEqual(expected_string, csv_row_string)
def testHeaders(self):
headers = Mite.csv_headers()
expected_string = "mite_name,mite_chromosome,mite_strand,mite_start,mite_end,mite_genome_id," \
"mite_correlated_gene,mite_family,mite_superfamily"
self.assertEqual(expected_string, headers)
