def createAlphabet(align=False, transSeq=False, extendAlphabet=False, protein=False): if not transSeq and not protein: alphabet = Alphabet.DNAAlphabet() alphabet.letters = "ACGT" if not extendAlphabet else "ACGTN" else: alphabet = Alphabet.ProteinAlphabet() alphabet.letters = IUPACProtein().letters + ('*' if not extendAlphabet else '*X') if align: alphabet.letters += '-' return alphabet
def get_flying_sequence(flight): state_alphabet = Alphabet() state_alphabet.letters = list("fs") emissions_alphabet = Alphabet() emissions_alphabet.letters = list("FS") emissions = [] for x in flight._flying_emissions(): if x == 1: emissions.append("F") else: emissions.append("S") emissions = Seq("".join(emissions), emissions_alphabet) empty_states = Seq("", state_alphabet) return TrainingSequence(emissions, empty_states)
def as_biopython_seq(seq): if isinstance(seq, Seq): return seq elif isinstance(seq, str): return Seq(seq, Alphabet()) else: raise Exception('Cannot resolve type %s as Biopython Seq' % type(seq))
def initial_markov_model_flying(): state_alphabet = Alphabet() state_alphabet.letters = list("fs") emissions_alphabet = Alphabet() emissions_alphabet.letters = list("FS") mmb = MarkovModelBuilder(state_alphabet, emissions_alphabet) mmb.set_initial_probabilities({'f': 0.20, 's': 0.80}) mmb.allow_all_transitions() mmb.set_transition_score('f', 'f', 0.99) mmb.set_transition_score('f', 's', 0.01) mmb.set_transition_score('s', 'f', 0.01) mmb.set_transition_score('s', 's', 0.99) mmb.set_emission_score('f', 'F', 0.90) mmb.set_emission_score('f', 'S', 0.10) mmb.set_emission_score('s', 'F', 0.10) mmb.set_emission_score('s', 'S', 0.90) mm = mmb.get_markov_model() return mm
def complement(self): """Returns the complement sequence. New Seq object. >>> from Bio.Seq import Seq >>> from Bio.Alphabet import IUPAC >>> my_dna = Seq("CCCCCGATAG", IUPAC.unambiguous_dna) >>> my_dna Seq('CCCCCGATAG', IUPACUnambiguousDNA()) >>> my_dna.complement() Seq('GGGGGCTATC', IUPACUnambiguousDNA()) You can of course used mixed case sequences, >>> from Bio.Seq import Seq >>> from Bio.Alphabet import generic_dna >>> my_dna = Seq("CCCCCgatA-GD", generic_dna) >>> my_dna Seq('CCCCCgatA-GD', DNAAlphabet()) >>> my_dna.complement() Seq('GGGGGctaT-CH', DNAAlphabet()) Note in the above example, ambiguous character D denotes G, A or T so its complement is H (for C, T or A). Trying to complement a protein sequence raises an exception. >>> my_protein = Seq("MAIVMGR", IUPAC.protein) >>> my_protein.complement() Traceback (most recent call last): ... ValueError: Proteins do not have complements! """ base = Alphabet._get_base_alphabet(self.alphabet) if isinstance(base, Alphabet.ProteinAlphabet): raise ValueError("Proteins do not have complements!") if isinstance(base, Alphabet.DNAAlphabet): ttable = _dna_complement_table elif isinstance(base, Alphabet.RNAAlphabet): ttable = _rna_complement_table elif ("U" in self._data or "u" in self._data) and ("T" in self._data or "t" in self._data): # TODO - Handle this cleanly? raise ValueError("Mixed RNA/DNA found") elif "U" in self._data or "u" in self._data: ttable = _rna_complement_table else: ttable = _dna_complement_table # Much faster on really long sequences than the previous loop based one. # thx to Michael Palmer, University of Waterloo return self.__class__(str(self).translate(ttable), self.alphabet)
def open_fasta(file_path, ab=Alphabet()): """ :param file_path: file of fasta file :param *alphabet: optional, alphabet used for sequences "dna" or "protein" :type path_aln: String :type *alphabet: String :return: bioseq, seq_id list of sequence id :rtype: list of BioPython sequences, list of String :exceptions: FileNotFoundError if file could not be opened raises FileNotFoundError other exception: raises general Exception (used for tracing in the main function) .. note:: requires BioPython library """ bioseq = [] seq_id = [] try: for seq_record in SeqIO.parse(file_path, "fasta", alphabet=ab): bioseq.append(seq_record) seq_id.append(seq_record.id) except FileNotFoundError as not_found_error: raise FileNotFoundError("Error while processing open_fasta function.\ \nFile not found error. {} ".format( not_found_error)) except err: raise Exception("Error while processing open_fasta function.\ \nUnable to read fasta file: {}. \nERROR: {} "\ .format(file_path, err)) return bioseq, seq_id
headerFileName = sys.argv[1] extend = int(sys.argv[2]) fastaFileName = sys.argv[3] bedFileName = sys.argv[4] with open(headerFileName) as headerFile: # read the header file data into a list of tuples headerList = [(m.group(1), int(m.group(2)), int(m.group(3)), m.group(4)) for m in [re.search(">([^:]*):(\d*)-(\d*)\(([+-])\)", line) for line in headerFile]] # build a set of all the seq ids headerIdSet = {t[0] for t in headerList} # now build a dictionary with the id as the key and the list of related tuples as the value (leave the id out of the tuple) headerDict = {id:sorted([(t[1], t[2], t[3]) for t in headerList if t[0] == id], key=lambda t:t[0]) for id in headerIdSet} # the only thing we need from the fasta file is the sequence lengths with open(fastaFileName, "r") as fastaFile: for seqRec in SeqIO.parse(fastaFile, "fasta", Alphabet()): if seqRec.id in headerDict: seqLen = len(seqRec.seq) tupleList = headerDict[seqRec.id] for i, t in enumerate(tupleList): # special case - only one value in the list if len(tupleList) == 1: tupleList[0] = (max(t[0] - extend, 0), min(t[1] + extend, seqLen), t[2]) continue # special case - first value but more than one in the list if i == 0: nextTuple = tupleList[1] tupleList[0] = (max(t[0] - extend, 0), min(t[1] + extend, nextTuple[0] - 1), t[2]) continue # special case - last value but more than one in the list if i == len(tupleList) - 1:
"""**Elia's solution**""" #INPUT PHASE lines = [] with open('input.txt','r') as handle: for l in handle.readlines(): lines.append(l) iterations = int(lines[0]) x = lines[2].strip() alphabet = lines[4].split() emission_alphabet = Alphabet() emission_alphabet.size = 1 emission_alphabet.letters = alphabet states = lines[6].split() states_alphabet = Alphabet() states_alphabet.size = 1 states_alphabet.letters = states transition_probs = np.zeros((len(states),len(states))) for i in range(len(states)): prob = lines[9+i].split() for j in range(len(states)): put = prob[1+j] transition_probs[i][j] = float(put)
def cloning_primers(template, minlength=16, maxlength=29, fp=None, rp=None, fp_tail='', rp_tail='', target_tm=55.0, primerc=1000.0, saltc=50.0, formula=tmbresluc): '''This function can design primers for PCR amplification of a given sequence. This function accepts a Dseqrecord object containing the template sequence and returns a tuple cntaining two ::mod`Bio.SeqRecord.SeqRecord` objects describing the primers. Primer tails can optionally be given in the form of strings. An predesigned primer can be given, either the forward or reverse primers. In this case this function tries to design a primer with a Tm to match the given primer. Parameters ---------- template : Dseqrecord a Dseqrecord object. minlength : int, optional Minimum length of the annealing part of the primer maxlength : int, optional Maximum length (including tail) for designed primers. fp, rp : SeqRecord, optional optional Biopython SeqRecord objects containing one primer each. fp_tail, rp_tail : string, optional optional tails to be added to the forwars or reverse primers target_tm : float, optional target tm for the primers primerc : float, optional Concentration of each primer in nM, set to 1000.0 nM by default saltc : float, optional Salt concentration (monovalet cations) :mod:`tmbresluc` set to 50.0 mM by default formula : function formula used for tm calculation this is the name of a function. built in options are: 1. :func:`pydna.amplify.tmbresluc` (default) 2. :func:`pydna.amplify.basictm` 3. :func:`pydna.amplify.tmstaluc98` 4. :func:`pydna.amplify.tmbreslauer86` These functions are imported from the :mod:`pydna.amplify` module, but can be substituted for some other custom made function. Returns ------- fp, rp : tuple fp is a :mod:Bio.SeqRecord object describing the forward primer rp is a :mod:Bio.SeqRecord object describing the reverse primer Examples -------- >>> import pydna >>> t=pydna.Dseqrecord("atgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatg") >>> t Dseqrecord(-64) >>> pf,pr = pydna.cloning_primers(t) >>> pf Primer(seq=Seq('atgactgctaacccttc', IUPACAmbiguousDNA()), id='pfw64', name='pfw64', description='pfw64', dbxrefs=[]) >>> pr Primer(seq=Seq('catcgtaagtttcgaac', IUPACAmbiguousDNA()), id='prv64', name='prv64', description='prv64', dbxrefs=[]) >>> pcr_prod = pydna.pcr(pf, pr, t) >>> pcr_prod Amplicon(64) >>> >>> print pcr_prod.figure() 5atgactgctaacccttc...gttcgaaacttacgatg3 ||||||||||||||||| tm 42.4 (dbd) 52.9 3caagctttgaatgctac5 5atgactgctaacccttc3 ||||||||||||||||| tm 44.5 (dbd) 54.0 3tactgacgattgggaag...caagctttgaatgctac5 >>> pf,pr = pydna.cloning_primers(t, fp_tail="GGATCC", rp_tail="GAATTC") >>> pf Primer(seq=Seq('GGATCCatgactgctaacccttc', IUPACAmbiguousDNA()), id='pfw64', name='pfw64', description='pfw64', dbxrefs=[]) >>> pr Primer(seq=Seq('GAATTCcatcgtaagtttcgaac', IUPACAmbiguousDNA()), id='prv64', name='prv64', description='prv64', dbxrefs=[]) >>> pcr_prod = pydna.pcr(pf, pr, t) >>> print pcr_prod.figure() 5atgactgctaacccttc...gttcgaaacttacgatg3 ||||||||||||||||| tm 42.4 (dbd) 52.9 3caagctttgaatgctacCTTAAG5 5GGATCCatgactgctaacccttc3 ||||||||||||||||| tm 44.5 (dbd) 54.0 3tactgacgattgggaag...caagctttgaatgctac5 >>> print pcr_prod.seq GGATCCatgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatgGAATTC >>> >>> from Bio.Seq import Seq >>> from Bio.SeqRecord import SeqRecord >>> pf = SeqRecord(Seq("atgactgctaacccttccttggtgttg")) >>> pf,pr = pydna.cloning_primers(t, fp = pf, fp_tail="GGATCC", rp_tail="GAATTC") >>> pf Primer(seq=Seq('GGATCCatgactgctaacccttccttggtgttg', Alphabet()), id='pfw64', name='pfw64', description='pfw64', dbxrefs=[]) >>> pr Primer(seq=Seq('GAATTCcatcgtaagtttcgaacgaaatgtcgtc', IUPACAmbiguousDNA()), id='prv64', name='prv64', description='prv64', dbxrefs=[]) >>> ampl = pydna.pcr(pf,pr,t) >>> print ampl.figure() 5atgactgctaacccttccttggtgttg...gacgacatttcgttcgaaacttacgatg3 |||||||||||||||||||||||||||| tm 57.5 (dbd) 72.2 3ctgctgtaaagcaagctttgaatgctacCTTAAG5 5GGATCCatgactgctaacccttccttggtgttg3 ||||||||||||||||||||||||||| tm 59.0 (dbd) 72.3 3tactgacgattgggaaggaaccacaac...ctgctgtaaagcaagctttgaatgctac5 >>> ''' if fp and not rp: fp = Primer(Seq(fp_tail, IUPACAmbiguousDNA())) + fp p = Anneal([fp], template).fwd_primers.pop() fp = Primer(p.footprint) fp_tail = Primer(p.tail) rp = Primer( Seq( str(template[-(maxlength * 3 - len(rp_tail)):].reverse_complement().seq), IUPACAmbiguousDNA())) target_tm = formula(str(fp.seq).upper(), primerc=primerc, saltc=saltc) elif not fp and rp: rp = Primer(Seq(rp_tail, IUPACAmbiguousDNA())) + rp p = Anneal([rp], template).rev_primers.pop() rp = Primer(p.footprint) rp_tail = Primer(p.tail) fp = Primer( Seq(str(template[:maxlength * 3 - len(fp_tail)].seq), IUPACAmbiguousDNA())) target_tm = formula(str(rp.seq).upper(), primerc=primerc, saltc=saltc) elif not fp and not rp: fp = Primer( Seq(str(template[:maxlength - len(fp_tail)].seq), IUPACAmbiguousDNA())) rp = Primer( Seq( str(template[-maxlength + len(rp_tail):].reverse_complement().seq), IUPACAmbiguousDNA())) else: raise Exception("Specify one or none of the primers, not both.") lowtm, hightm = sorted([(formula(str(fp.seq), primerc, saltc), fp, "f"), (formula(str(rp.seq), primerc, saltc), rp, "r")]) while lowtm[0] > target_tm and len(lowtm[1]) > minlength: shorter = lowtm[1][:-1] tm = formula(str(shorter.seq).upper(), primerc=primerc, saltc=saltc) lowtm = (tm, shorter, lowtm[2]) while hightm[0] > lowtm[0] + 2.0 and len(hightm[1]) > minlength: shorter = hightm[1][:-1] tm = formula(str(shorter.seq).upper(), primerc=primerc, saltc=saltc) hightm = (tm, shorter, hightm[2]) fp, rp = sorted((lowtm, hightm), key=itemgetter(2)) fp = fp_tail + fp[1] rp = rp_tail + rp[1] fp.description = "pfw{}".format(len(template)) rp.description = "prv{}".format(len(template)) fp.name = fp.description[:15] rp.name = rp.description[:15] fp.id = fp.name rp.id = rp.name #assert minlength<=len(fp)<=maxlength #assert minlength<=len(rp)<=maxlength if fp.seq.alphabet == Alphabet(): fp.seq.alphabet = IUPACAmbiguousDNA() if rp.seq.alphabet == Alphabet(): rp.seq.alphabet = IUPACAmbiguousDNA() return fp, rp
def __init__(self, seq, *args, **kwargs): if seq.alphabet == Alphabet(): seq.alphabet = IUPACAmbiguousDNA() super(Primer, self).__init__(seq, *args, **kwargs)
def cloning_primers(template, minlength=16, maxlength=29, fp=None, rp=None, fp_tail='', rp_tail='', target_tm=55.0, primerc=1000.0, saltc=50.0, formula=tmbresluc, path=u""): '''This function can design primers for PCR amplification of a given sequence. This function accepts a Dseqrecord object containing the template sequence and returns a tuple cntaining two ::mod`Bio.SeqRecord.SeqRecord` objects describing the primers. Primer tails can optionally be given in the form of strings. An predesigned primer can be given, either the forward or reverse primers. In this case this function tries to design a primer with a Tm to match the given primer. Parameters ---------- template : Dseqrecord a Dseqrecord object. minlength : int, optional Minimum length of the annealing part of the primer maxlength : int, optional Maximum length (including tail) for designed primers. fp, rp : SeqRecord, optional optional Biopython SeqRecord objects containing one primer each. fp_tail, rp_tail : string, optional optional tails to be added to the forwars or reverse primers target_tm : float, optional target tm for the primers primerc : float, optional Concentration of each primer in nM, set to 1000.0 nM by default saltc : float, optional Salt concentration (monovalet cations) :mod:`tmbresluc` set to 50.0 mM by default formula : function formula used for tm calculation this is the name of a function. built in options are: 1. :func:`pydna.amplify.tmbresluc` (default) 2. :func:`pydna.amplify.basictm` 3. :func:`pydna.amplify.tmstaluc98` 4. :func:`pydna.amplify.tmbreslauer86` These functions are imported from the :mod:`pydna.amplify` module, but can be substituted for some other custom made function. path : unicode, optional This variable can be set to a path to a text file, which will be created if it does not exist. This file (if it exists) will be parsed for sequences in fasta or genbank format and a Biopython SeqRecord object will be created for each sequence. If a SeqRecord object is found with the same description as any of the primers designed, the SeqRecord object parsed from the file will be returned by this function instead of the newly designed primer. If no sequence with the same description can be found, the primer(s) will be appended to the file in fasta format. Returns ------- fp, rp : tuple fp is a :mod:Bio.SeqRecord object describing the forward primer rp is a :mod:Bio.SeqRecord object describing the reverse primer Examples -------- >>> import pydna >>> t=pydna.Dseqrecord("atgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatg") >>> t Dseqrecord(-64) >>> pf,pr = pydna.cloning_primers(t) >>> pf Primer(seq=Seq('atgactgctaacccttc', IUPACAmbiguousDNA()), id='fw64', name='fw64', description='fw64 -', dbxrefs=[]) >>> pr Primer(seq=Seq('catcgtaagtttcgaac', IUPACAmbiguousDNA()), id='rv64', name='rv64', description='rv64 -', dbxrefs=[]) >>> pcr_prod = pydna.pcr(pf, pr, t) >>> pcr_prod Amplicon(64) >>> >>> print(pcr_prod.figure()) 5atgactgctaacccttc...gttcgaaacttacgatg3 ||||||||||||||||| tm 42.4 (dbd) 52.9 3caagctttgaatgctac5 5atgactgctaacccttc3 ||||||||||||||||| tm 44.5 (dbd) 54.0 3tactgacgattgggaag...caagctttgaatgctac5 >>> pf,pr = pydna.cloning_primers(t, fp_tail="GGATCC", rp_tail="GAATTC") >>> pf Primer(seq=Seq('GGATCCatgactgctaacccttc', IUPACAmbiguousDNA()), id='fw64', name='fw64', description='fw64 -', dbxrefs=[]) >>> pr Primer(seq=Seq('GAATTCcatcgtaagtttcgaac', IUPACAmbiguousDNA()), id='rv64', name='rv64', description='rv64 -', dbxrefs=[]) >>> pcr_prod = pydna.pcr(pf, pr, t) >>> print(pcr_prod.figure()) 5atgactgctaacccttc...gttcgaaacttacgatg3 ||||||||||||||||| tm 42.4 (dbd) 52.9 3caagctttgaatgctacCTTAAG5 5GGATCCatgactgctaacccttc3 ||||||||||||||||| tm 44.5 (dbd) 54.0 3tactgacgattgggaag...caagctttgaatgctac5 >>> print(pcr_prod.seq) GGATCCatgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatgGAATTC >>> >>> from Bio.Seq import Seq >>> from Bio.SeqRecord import SeqRecord >>> pf = SeqRecord(Seq("atgactgctaacccttccttggtgttg")) >>> pf,pr = pydna.cloning_primers(t, fp = pf, fp_tail="GGATCC", rp_tail="GAATTC") >>> pf Primer(seq=Seq('GGATCCatgactgctaacccttccttggtgttg', Alphabet()), id='fw64', name='fw64', description='fw64 -', dbxrefs=[]) >>> pr Primer(seq=Seq('GAATTCcatcgtaagtttcgaacgaaatgtcgtc', IUPACAmbiguousDNA()), id='rv64', name='rv64', description='rv64 -', dbxrefs=[]) >>> ampl = pydna.pcr(pf,pr,t) >>> print(ampl.figure()) 5atgactgctaacccttccttggtgttg...gacgacatttcgttcgaaacttacgatg3 |||||||||||||||||||||||||||| tm 57.5 (dbd) 72.2 3ctgctgtaaagcaagctttgaatgctacCTTAAG5 5GGATCCatgactgctaacccttccttggtgttg3 ||||||||||||||||||||||||||| tm 59.0 (dbd) 72.3 3tactgacgattgggaaggaaccacaac...ctgctgtaaagcaagctttgaatgctac5 >>> ''' if fp and not rp: fp = Primer(Seq(fp_tail, IUPACAmbiguousDNA())) + fp p = Anneal([fp], template).fwd_primers.pop() fp = Primer(p.footprint) fp_tail = Primer(p.tail) rp = Primer( Seq( str(template[-(maxlength * 3 - len(rp_tail)):].reverse_complement().seq), IUPACAmbiguousDNA())) target_tm = formula(str(fp.seq).upper(), primerc=primerc, saltc=saltc) elif not fp and rp: rp = Primer(Seq(rp_tail, IUPACAmbiguousDNA())) + rp p = Anneal([rp], template).rev_primers.pop() rp = Primer(p.footprint) rp_tail = Primer(p.tail) fp = Primer( Seq(str(template[:maxlength * 3 - len(fp_tail)].seq), IUPACAmbiguousDNA())) target_tm = formula(str(rp.seq).upper(), primerc=primerc, saltc=saltc) elif not fp and not rp: fp = Primer( Seq(str(template[:maxlength - len(fp_tail)].seq), IUPACAmbiguousDNA())) rp = Primer( Seq( str(template[-maxlength + len(rp_tail):].reverse_complement().seq), IUPACAmbiguousDNA())) else: raise Exception("Specify maximum one of the two primers, not both.") lowtm, hightm = sorted([(formula(str(fp.seq), primerc, saltc), fp, "f"), (formula(str(rp.seq), primerc, saltc), rp, "r")]) while lowtm[0] > target_tm and len(lowtm[1]) > minlength: shorter = lowtm[1][:-1] tm = formula(str(shorter.seq).upper(), primerc=primerc, saltc=saltc) lowtm = (tm, shorter, lowtm[2]) while hightm[0] > lowtm[0] + 2.0 and len(hightm[1]) > minlength: shorter = hightm[1][:-1] tm = formula(str(shorter.seq).upper(), primerc=primerc, saltc=saltc) hightm = (tm, shorter, hightm[2]) fp, rp = sorted((lowtm, hightm), key=itemgetter(2)) fp = fp_tail + fp[1] rp = rp_tail + rp[1] #fp.description = "fw{}".format(len(template)) #rp.description = "rv{}".format(len(template)) #fp.name = "fw{}".format(len(template))[:15] #rp.name = "rv{}".format(len(template))[:15] fp.description = "fw{}".format(len(template)) + ' ' + template.accession rp.description = "rv{}".format(len(template)) + ' ' + template.accession fp.id = "fw{}".format(len(template)) rp.id = "rv{}".format(len(template)) fp.name = fp.id rp.name = rp.id if fp.seq.alphabet == Alphabet(): fp.seq.alphabet = IUPACAmbiguousDNA() if rp.seq.alphabet == Alphabet(): rp.seq.alphabet = IUPACAmbiguousDNA() # If the path argument is supplied primers will be written to a file with that # path. If the file does not exist, it will be created and both primers will be # written to it. If the file exists, the file will be parsed for sequences in # fasta or genbank into . if path: try: with open(path, 'rU') as f: raw = f.read() except IOError: raw = u"" with open(path, 'w') as f: f.write(fp.format("fasta")) f.write(rp.format("fasta")) else: primer_dict = {x.description: x for x in parse(raw, ds=False)} try: fp = primer_dict[fp.description] except KeyError: with open(path, 'a') as f: f.write(u"\n" + fp.format("fasta").strip()) try: rp = primer_dict[rp.description] except KeyError: with open(path, 'a') as f: f.write(u"\n" + rp.format("fasta").strip()) return fp, rp
if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("fasta") parser.add_argument("slop", type=int) parser.add_argument("flagged") parser.add_argument("--primer3", action="store_true", help="output in primer3-compatible input format") parser.add_argument("--min_primer_size", type=int, default=18) parser.add_argument("--opt_primer_size", type=int, default=20) parser.add_argument("--max_primer_size", type=int, default=27) parser.add_argument("--max_primers_to_return", type=int, default=5) args = parser.parse_args() slop = args.slop alphabet = Alphabet() alphabet.letters = ["A", "T", "C", "G", "[", "]"] with open(args.flagged, "w") as fh: for seq_record in SeqIO.parse(args.fasta, "fasta"): if args.primer3: sequence = str(seq_record.seq) fh.write("SEQUENCE_ID=%s\n" % seq_record.id) fh.write("SEQUENCE_TEMPLATE=%s\n" % sequence) fh.write("SEQUENCE_TARGET=%i,%i\n" % (slop, len(sequence) - 2 * slop)) fh.write("PRIMER_OPT_SIZE=%i\n" % args.opt_primer_size) fh.write("PRIMER_MIN_SIZE=%i\n" % args.min_primer_size) fh.write("PRIMER_MAX_SIZE=%i\n" % args.max_primer_size) fh.write("PRIMER_NUM_RETURN=%i\n" % args.max_primers_to_return) fh.write("=\n") else: