def test_eq(self):
target = get_data_from_csv(data_1)[0]
primers_pair1 = self.create_primers_pair(target)
primers_pair2 = self.create_primers_pair(target)
self.assertTrue(primers_pair1 == primers_pair2)
target2 = get_data_from_csv(data_16)[0]
primers_pair3 = self.create_primers_pair(target2)
self.assertTrue(primers_pair3 != primers_pair2)
l = [primers_pair1]
self.assertTrue(primers_pair1 in l)
self.assertTrue(primers_pair2 in l)
self.assertTrue(primers_pair3 not in l)
def test_get_target_sequence(self):
"""
Tests if the correct target sequence is grabbed
"""
target = get_data_from_csv(data_1)[0]
target.get_target_sequence(100)
self.assertTrue(len(target.sequence) == 201)
def compute_thermofisher_good_pos(self,
file_data_path,
range_left=100,
range_right=100):
target = get_data_from_csv(file_data_path)[0]
target.get_target_sequence(target.range)
sequence = ""
if range_right == 100:
sequence = target.sequence[(target.range - range_left):]
else:
sequence = target.sequence[(
target.range - range_left):-(target.range - range_right)]
primers_pair = target.design_primers(range_left, sequence)
left_primer = Primer(primers_pair["PRIMER_LEFT_0_SEQUENCE"], "left",
primers_pair["PRIMER_LEFT_0"][0], range_left,
target)
right_primer = Primer(primers_pair["PRIMER_RIGHT_0_SEQUENCE"], "right",
primers_pair["PRIMER_RIGHT_0"][0], range_left,
target)
self.assertTrue(
left_primer.TFGP < target.mutation_pos < right_primer.TFGP)
self.assertTrue(target.mutation_pos - left_primer.TFGP == range_left +
1 - (primers_pair["PRIMER_LEFT_0"][0] +
primers_pair["PRIMER_LEFT_0"][1]))
self.assertTrue(
right_primer.TFGP -
target.mutation_pos == (primers_pair["PRIMER_RIGHT_0"][0] -
primers_pair["PRIMER_RIGHT_0"][1]) -
range_left + 1)
def test_run_blast(self):
"""
Tests if blast hits are correct respect to our constraint.
"""
target = get_data_from_csv(data_1)[0]
target.compute_optimal_primers_pairs()
blast = Blast(target.all_primers_pairs)
u_l_primers, u_r_primers = blast.get_unique_primers()
blast.run_blast(u_l_primers[0])
with open(blast_output_file_path, "r") as o:
for line in o:
blast_result = line.split()
self.assertTrue(float(blast_result[2]) == 100.)
self.assertTrue(float(blast_result[-2]) < 1)
self.assertTrue(
int(blast_result[3]) / float(blast_result[7]) >= 0.8)
blast.run_blast(u_r_primers[0])
with open(blast_output_file_path, "r") as o:
for line in o:
blast_result = line.split()
self.assertTrue(float(blast_result[2]) == 100.)
self.assertTrue(float(blast_result[-2]) < 1)
self.assertTrue(
int(blast_result[3]) / float(blast_result[7]) >= 0.8)
def test_compute_optimal_raw_primers_pairs_helper(file_data_path):
target = get_data_from_csv(file_data_path)[0]
result = target.compute_optimal_raw_primers_pairs()
raw_primers_pairs = result[0]
ranges_left = result[1]
for i in range(len(raw_primers_pairs)):
variant_position = ranges_left[i] + 1
self.primers_caract(raw_primers_pairs[i], variant_position)
def create_targets(self):
"""
Creates and save targets for not re-execute the whole creation of primers pair
execute only one time.
"""
targets = get_data_from_csv(data1_10)
for target in targets:
target.compute_list_primers_pairs()
return targets
def test_design_primers(self):
"""
Tests if designed primers pair are compatible with constraints
"""
target = get_data_from_csv(data_1)[0]
target.get_target_sequence(100)
primers_pair = target.design_primers(target.range, target.sequence)
print(primers_pair)
self.primers_caract(primers_pair, target.range)
def add_hybridization_sites(self):
"""
Tests succinctly the main function of BLAST class
"""
target = get_data_from_csv(data_16)[0]
target.compute_optimal_primers_pairs()
primers_pair = target.all_primers_pairs
blast = Blast(target.all_primers_pairs)
blast.add_hybridization_sites()
print(len(primers_pair))
def test_sort_by_penalty(self):
"""
Tests if primers pairs instance have been correctly sorted by penalty.
"""
target = get_data_from_csv(data_1)[0]
target.compute_optimal_primers_pairs()
target.sort_by_penalty()
global_penalty = target.all_primers_pairs[0].penalty
for primers_pair in target.all_primers_pairs[1:]:
self.assertTrue(primers_pair.penalty >= global_penalty)
global_penalty = primers_pair.penalty
def test_sort_by_tfgr(self):
"""
Tests if primers pairs instance have been correctly sorted by TFGR.
"""
target = get_data_from_csv(data_1)[0]
target.compute_optimal_primers_pairs()
target.sort_by_tfgr()
amplicon_range = target.all_primers_pairs[0].amplicon_range
for primers_pair in target.all_primers_pairs[1:]:
self.assertTrue(primers_pair.amplicon_range >= amplicon_range)
amplicon_range = primers_pair.amplicon_range
def test_remove_primers_pair_with_hybridisation(self):
"""
Tests if the function remove all primers_pair with any hybridisation sites.
"""
target = get_data_from_csv(data_1)[0]
target.compute_optimal_primers_pairs()
target.remove_primers_pair_with_hybridisation()
for primers_pair in target.all_primers_pairs:
self.assertTrue(
not primers_pair.left_primer.primer_hybridization_sites)
self.assertTrue(
not primers_pair.right_primer.primer_hybridization_sites)
def test_get_data_from_csv_damaging(self):
"""
Tests if a target with a damaging variant is correctly initialise
"""
result = get_data_from_csv(data_21)
self.assertTrue(len(result) == 1)
target = result[0]
self.assertTrue(target.no_chromosome == "chr10")
self.assertTrue(target.mutation_pos == 89720807)
self.assertTrue(target.var_freq == 0.2705)
self.assertTrue(target.bio_imp == "Damaging")
self.assertTrue(target.var_key == "CHR10_89720808_T_TA")
def test_get_data_from_csv_polymorphism(self):
"""
Tests if a target with a probably polymorphism variant is correctly initialise
"""
result = get_data_from_csv(data_1)
self.assertTrue(len(result) == 1)
target = result[0]
self.assertTrue(target.no_chromosome == "chr6")
self.assertTrue(target.mutation_pos == 117622183)
self.assertTrue(target.var_freq == 0.5105)
self.assertTrue(target.bio_imp == "Probably Polymorphism")
self.assertTrue(target.var_key == "CHR6_117622184_G_C")
def test_get_data_from_csv_unknown(self):
"""
Tests if a target with a unknown variant is correctly initialise
"""
result = get_data_from_csv(data_16)
self.assertTrue(len(result) == 1)
target = result[0]
self.assertTrue(target.no_chromosome == "chr11")
self.assertTrue(target.mutation_pos == 314206)
self.assertTrue(target.var_freq == 0.9159)
self.assertTrue(target.bio_imp == "Unknown")
self.assertTrue(target.var_key == "CHR11_314207_C_G")
def test_dinucleotides_repeats(self):
"""
Tests if the function detects di-nucleotides repeats
"""
target = get_data_from_csv(data_1)[0]
target.get_target_sequence(target.range)
primers_pair = target.design_primers(target.range, target.sequence)
left_primer = Primer(primers_pair["PRIMER_LEFT_0_SEQUENCE"], "left",
primers_pair["PRIMER_LEFT_0"][0], target.range,
target)
self.assertFalse(left_primer.dinucleotides_repeats())
left_primer.sequence = "GTTCAGTT" + "GCGCGCGCGC" + "CACAGTGCAGCG"
self.assertTrue(left_primer.dinucleotides_repeats())
def test_get_unique_primers(self):
"""
Tests if the function get correctly each unique primers and\
each primer has not been forgotten.
"""
target = get_data_from_csv(data_1)[0]
target.compute_optimal_primers_pairs()
blast = Blast(target.all_primers_pairs)
u_l_primers, u_r_primers = blast.get_unique_primers()
self.assertTrue(len(u_l_primers) == len(set(u_l_primers)))
self.assertTrue(len(u_r_primers) == len(set(u_r_primers)))
for primers_pair in target.all_primers_pairs:
self.assertTrue(primers_pair.right_primer in u_r_primers)
self.assertTrue(primers_pair.left_primer in u_l_primers)
def test_eq(self):
"""
Tests equality and inequality between two primers
"""
target = get_data_from_csv(data_1)[0]
target.get_target_sequence(target.range)
primers_pair = target.design_primers(target.range, target.sequence)
left_primer = Primer(primers_pair["PRIMER_LEFT_0_SEQUENCE"], "left",
primers_pair["PRIMER_LEFT_0"][0], 100, target)
right_primer = Primer(primers_pair["PRIMER_RIGHT_0_SEQUENCE"], "right",
primers_pair["PRIMER_RIGHT_0"][0], 100, target)
self.assertTrue(right_primer == right_primer)
self.assertTrue(left_primer == left_primer)
self.assertTrue(right_primer != left_primer)
def test_check_snp_in_primer(self):
"""
Tests snp and no snp in primer sequence
"""
target = get_data_from_csv(data_1)[0]
target.get_target_sequence(target.range)
snp = target.get_snp()
primers_pair = target.design_primers(target.range, target.sequence)
left_primer = Primer(primers_pair["PRIMER_LEFT_0_SEQUENCE"], "left",
primers_pair["PRIMER_LEFT_0"][0], target.range,
target)
right_primer = Primer(primers_pair["PRIMER_RIGHT_0_SEQUENCE"], "right",
primers_pair["PRIMER_RIGHT_0"][0], target.range,
target)
self.assertTrue(left_primer.check_snp_in_primer(snp) == 0)
self.assertTrue(right_primer.check_snp_in_primer(snp) == 0)
def launch(path_of_data_file):
"""
Launches the algorithm.
:param path_of_data_file: the path of the data file
:return: nothing but creates a bed file corresponding to good chromosomic range.
"""
print("Welcome to primers design program!")
print("-------------------------------------------------------------")
print("Documentation of the program in pydoc/_build/html/index.html")
print("-------------------------------------------------------------")
print("Processing...")
start_time = time.time()
targets = get_data_from_csv(path_of_data_file)
size = len(targets)
res = []
good_targets = []
for target in targets:
target.compute_list_primers_pairs()
if target.all_primers_pairs:
print("target design successfully: " + target.no_chromosome + " " +
str(target.mutation_pos) + " " + target.bio_imp)
res.append(target.all_primers_pairs[0])
good_targets.append(target)
else:
print("fail to design target: " + target.no_chromosome + " " +
str(target.mutation_pos) + " " + target.bio_imp)
if len(good_targets) > 1:
pt = PostTreatments(good_targets)
if overlap:
print("checking overlap ...")
res = pt.check_overlap()
elif size > 1 and multiplex:
print("multiplex in progress ...")
res = pt.run_multiplex()
elif size > 1 and pseudo_multiplex:
print("pseudo multiplex in progress ...")
res = pt.run_pseudo_multiplex()
if not multiplex:
create_bed_file_chromosome(res)
if multiplex:
create_bed_file_chromosome(res.components)
print("program finish in: " + seconds_to_str(time.time() - start_time))
def test_search_hybridization_site_rr_ll(self):
"""
Tests if the function detects well rr or ll hybridisation
Tests the function is_primers_compatible as well.
"""
target = get_data_from_csv(data_16)[0]
target.compute_optimal_primers_pairs()
blast = Blast(target.all_primers_pairs)
u_l_primers, u_r_primers = blast.get_unique_primers()
blast.parse_blast_output(u_l_primers[0])
self.assertFalse(blast.search_hybridization_site_rr_ll(u_l_primers[0]))
u_l_primers[0].primer_hybridization_sites["chr20"].append(
[50283620, 50283640, 1])
self.assertTrue(blast.search_hybridization_site_rr_ll(u_l_primers[0]))
blast.parse_blast_output(u_r_primers[0])
self.assertFalse(blast.search_hybridization_site_rr_ll(u_r_primers[0]))
u_r_primers[0].primer_hybridization_sites["chr11"].append(
[60672820, 60672805, -1])
self.assertTrue(blast.search_hybridization_site_rr_ll(u_r_primers[0]))
def test_search_hybridization_sites_lr_rl(self):
"""
Tests if the function detects well lr or rl hybridisation
"""
target = get_data_from_csv(data_16)[0]
target.compute_optimal_primers_pairs()
blast = Blast(target.all_primers_pairs)
u_l_primers, u_r_primers = blast.get_unique_primers()
blast.parse_blast_output(u_l_primers[0])
blast.parse_blast_output(u_r_primers[0])
self.assertFalse(
blast.search_hybridization_sites_lr_rl(
u_l_primers[0].primer_hybridization_sites,
u_r_primers[0].primer_hybridization_sites))
u_r_primers[0].primer_hybridization_sites["chr20"] = [[
50283620, 50283640, 1
]]
self.assertTrue(
blast.search_hybridization_sites_lr_rl(
u_l_primers[0].primer_hybridization_sites,
u_r_primers[0].primer_hybridization_sites))
