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)
class TestPrimer1(ut.TestCase):
def setUp(self):
self.primer = Primer(7)
def test_check_prime(self):
self.assertTrue(self.primer.check_prime(2))
self.assertTrue(self.primer.check_prime(3))
self.assertTrue(self.primer.check_prime(5))
self.assertFalse(self.primer.check_prime(10))
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_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 create_primers_pair(self, target):
"""
Creates a primers_pair from a target instance
:param target: target instance
:return: a primers_pair instance (in target sequence)
"""
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)
right_primer = Primer(primers_pair["PRIMER_RIGHT_0_SEQUENCE"], "right",
primers_pair["PRIMER_RIGHT_0"][0], target.range,
target)
return PrimersPair(left_primer, right_primer)
class TestPrimer2(ut.TestCase):
def setUp(self):
self.primer = Primer(7)
def test_generate_0(self):
expected = list(self.primer.generate(0))
self.assertEqual(expected, [])
def test_generate_num_within_limit(self):
expected = list(self.primer.generate(2))
self.assertEqual(expected, [2, 3])
@ut.skip('not now')
def test_generate_num_exact_limit(self):
expected = list(self.primer.generate(4))
self.assertEqual(expected, [2, 3, 5, 7])
def test_generate_num_exceed_limit(self):
expected = list(self.primer.generate(5))
self.assertEqual(expected, [2, 3, 5, 7])
def generate_primers(self):
forward_homology = self.forward_homology_arm(self.fwd_ha_len)
reverse_homology = self.reverse_homology_arm(self.rev_ha_len)
forward_primer, reverse_primer = Primer.from_sequence(
self.sequence,
forward_overhang=forward_homology + self.degeneracy,
reverse_overhang=reverse_homology.reverse_complement()
)
return forward_primer, reverse_primer
def __init__(self,
sequence,
seqLocation,
alignLocation,
parent,
primer=None):
self.parent = [parent]
self.seqLocation = [seqLocation]
self.alignLocation = alignLocation
self.sequence = sequence
if primer is None:
self.primer = Primer(self.sequence)
else:
self.primer = primer
def find_primers(target_dna, user_parameters, search_range):
primers = []
if target_dna.len < 500:
ideal_len = (16, 18)
elif target_dna.len > 2500:
ideal_len = (20, 24)
else:
ideal_len = (17, 22)
search_start = max(0, target_dna.start-search_range)
for i in range(search_start, target_dna.start+1):
for j in range(ideal_len[0], ideal_len[1]+1):
primer = Primer(target_dna, i, i+j)
parameters = primer.parameters()
if user_parameters[0][0] <= parameters[0] <= user_parameters[0][1] and\
user_parameters[1][0] <= parameters[1] <= user_parameters[1][1] and\
not parameters[3] and not parameters[4] and parameters[5]:
if user_parameters[2] == None:
primers.append(primer)
else:
if user_parameters[2] == parameters[2]:
primers.append(primer)
return primers
def compute_optimal_primers_pairs(self):
"""
Computes a list of primers pairs containing primersPair instance
Use this function to get a list of primers pairs respecting all constraints
with no post-treatment (no BLAST, no sort,...)
:return: a list of primersPair instance.
"""
all_primers_pairs = []
result = self.compute_optimal_raw_primers_pairs()
all_raw_primers_pairs = result[0]
ranges_left = result[1]
SNP = self.get_snp()
for i in range(len(all_raw_primers_pairs)):
left_primer = Primer(
all_raw_primers_pairs[i]["PRIMER_LEFT_0_SEQUENCE"], "left",
all_raw_primers_pairs[i]["PRIMER_LEFT_0"][0], ranges_left[i],
self, all_raw_primers_pairs[i]["PRIMER_LEFT_0_PENALTY"])
right_primer = Primer(
all_raw_primers_pairs[i]["PRIMER_RIGHT_0_SEQUENCE"], "right",
all_raw_primers_pairs[i]["PRIMER_RIGHT_0"][0], ranges_left[i],
self, all_raw_primers_pairs[i]["PRIMER_RIGHT_0_PENALTY"])
if not left_primer.dinucleotides_repeats(
) and not right_primer.dinucleotides_repeats():
if math.fabs(right_primer.TFGP - left_primer.TFGP) <= 90:
if right_primer.check_snp_in_primer(SNP) == 0 and \
left_primer.check_snp_in_primer(SNP) == 0:
primers_pair = PrimersPair(left_primer, right_primer)
if primers_pair not in all_primers_pairs:
all_primers_pairs.append(primers_pair)
self.all_primers_pairs = all_primers_pairs
return all_primers_pairs
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 setUp(self):
self.primer = Primer(7)
from primer import Primer
if __name__ == '__main__':
prime = Primer(20)
for p in prime.generate(9):
print(p)
