def test_primer_Design_with_linker(): ''' test_primer_design''' b = Dseqrecord( "agctactgactattaggggttattctgatcatctgatctactatctgactgtactgatcta") l = Dseqrecord("AAATTTCCCGGG") c = Dseqrecord( "tctgatctactatctgactgtactgatctattgacactgtgatcattctagtgtattactc") frags = assembly_fragments((primer_design(b), l, primer_design(c))) asm1 = Assembly(frags) assert asm1.assemble_linear()[0].seguid(), ( b + l + c).seguid() == 'l95igKB8iKAKrvvqE9CYksyNx40' frags = assembly_fragments( (primer_design(b), l, primer_design(c), primer_design(b))) b2 = pcr(frags[-1].forward_primer, frags[0].reverse_primer, b) asm2 = Assembly((b2, frags[1], frags[2])) assert (b + l + c).looped().cseguid() == asm2.assemble_circular()[0].cseguid() assert (b + l + c).looped().cseguid() == 'jdHXfQI5k4Sk2ESiZYfKv4oP2FI'
def AssembleNAnneal(graph, nodes, edges, start, end): dseq_list = enc.toDSEQ(graph, edges, nodes) p1 = Dseqrecord(nodes[start]) p2 = Dseqrecord(enc.getSeqComplement(nodes[end])) assembly = Assembly(dseq_list, limit=10, only_terminal_overlaps=True) print("\n" + str(assembly) + "\n") candidates = [] for i in range(len(assembly.linear_products)): product = assembly.linear_products[i] template = Dseqrecord(product) pcr = Anneal([p1, p2], template, limit=10) gel = len(nodes) * enc.SEQ_LEN if len(pcr.products) != 0: print(product.detailed_figure()) print(product.figure()) for p in pcr.products: if len(p.seq) == gel: p.seq = p.seq[10:] p.seq = p.seq[:-10] candidates.append(p) # print("\n" +str(nodes)) # print(str(edges) +"\n") return candidates
def test_lcs(): from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord as BSeqRecord from pydna.dseq import Dseq from pydna.dseqrecord import Dseqrecord from pydna.seqrecord import SeqRecord from pydna.seqfeature import SeqFeature from Bio.SeqFeature import FeatureLocation, ExactPosition s = SeqRecord(Seq("GGATCC")) expected = SeqFeature() expected.__dict__ = { "location": FeatureLocation(ExactPosition(0), ExactPosition(6), strand=1), "type": "read", "id": "<unknown id>", "qualifiers": { "label": ["sequence"], "ApEinfo_fwdcolor": ["#DAFFCF"], "ApEinfo_revcolor": ["#DFFDFF"], }, } assert s.lcs("GGATCC", limit=4).__dict__ == expected.__dict__ assert s.lcs(Seq("GGATCC"), limit=4).__dict__ == expected.__dict__ assert (s.lcs(BSeqRecord(Seq("GGATCC"), name="sequence"), limit=4).__dict__ == expected.__dict__) assert s.lcs(Dseq("GGATCC"), limit=4).__dict__ == expected.__dict__ assert (s.lcs(Dseqrecord(Dseq("GGATCC"), name="sequence"), limit=4).__dict__ == expected.__dict__) assert (s.lcs(Dseqrecord("GGATCC", name="sequence"), limit=4).__dict__ == expected.__dict__)
def test_primer_design_same_first_and_third_Dseqrecord(): from pydna.dseqrecord import Dseqrecord x = [primer_design(f) for f in frags] y = assembly_fragments([frags[0], x[1], frags[0]], 20) z = Assembly(y, limit=20) result = z.assemble_circular()[0] assert result.cseguid() == (frags[0] + frags[1]).looped().cseguid() a = Dseqrecord("ccaaggacacaatcgagctccgatccgtactgtcgagaaacttgtatcc", name="a") b = Dseqrecord( "ctgtcgagaaacttgtatccctctaactagtatggatagccgtgtcttcactgtgctgcggctacccatcccaaggacacaatcgagctc", name="b", ) z = Assembly((a, b, a), limit=20) result = z.assemble_linear()[0] assert ( str(result.seq) == "ccaaggacacaatcgagctccgatccgtactgtcgagaaacttgtatccctctaactagtatggatagccgtgtcttcactgtgctgcggctacccatcccaaggacacaatcgagctccgatccgtactgtcgagaaacttgtatcc" ) result = z.assemble_circular()[0] assert result.cseguid() == (frags[0] + frags[1]).looped().cseguid()
def test_add_feature(): from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord as BSeqRecord from pydna.dseq import Dseq from pydna.dseqrecord import Dseqrecord from pydna.seqrecord import SeqRecord s = SeqRecord("tttGGATCCaaa") s.add_feature(3, 9) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq="GGATCC") assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq=Seq("GGATCC")) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq=Dseq("GGATCC")) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq=SeqRecord("GGATCC")) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq=BSeqRecord("GGATCC")) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") s.add_feature(seq=Dseqrecord("GGATCC")) assert s.extract_feature(0).seq == SeqRecord("GGATCC").seq s = SeqRecord("tttGGATCCaaa") with pytest.raises(TypeError): s.add_feature(seq=Dseqrecord("GGGGGG")) s = SeqRecord("tttATGaaaTAAggg") s.add_feature(3, 12) assert s.features[0].qualifiers["label"] == ["orf9"] from Bio.Seq import Seq from pydna.seqrecord import SeqRecord a = SeqRecord(Seq("atgtaa")) a.add_feature(2, 4) assert ( a.list_features() == "+-----+---------------+-----+-----+-----+-----+------+------+\n| Ft# | Label or Note | Dir | Sta | End | Len | type | orf? |\n+-----+---------------+-----+-----+-----+-----+------+------+\n| 0 | L:ft2 | --> | 2 | 4 | 2 | misc | no |\n+-----+---------------+-----+-----+-----+-----+------+------+" ) a.features[0].qualifiers del a.features[0].qualifiers["label"] assert ( a.list_features() == "+-----+---------------+-----+-----+-----+-----+------+------+\n| Ft# | Label or Note | Dir | Sta | End | Len | type | orf? |\n+-----+---------------+-----+-----+-----+-----+------+------+\n| 0 | nd | --> | 2 | 4 | 2 | misc | no |\n+-----+---------------+-----+-----+-----+-----+------+------+" ) a.features[0].qualifiers["note"] = ["AwesomeFeature"] assert ( a.list_features() == "+-----+------------------+-----+-----+-----+-----+------+------+\n| Ft# | Label or Note | Dir | Sta | End | Len | type | orf? |\n+-----+------------------+-----+-----+-----+-----+------+------+\n| 0 | N:AwesomeFeature | --> | 2 | 4 | 2 | misc | no |\n+-----+------------------+-----+-----+-----+-----+------+------+" )
def test_editor_with_feature_label(monkeypatch): import subprocess from pydna import editor Popen = mock.MagicMock(name="subprocess.Popen") monkeypatch.setattr("subprocess.Popen", Popen) monkeypatch.setenv("pydna_ape", "path/to/ape") from pydna.dseqrecord import Dseqrecord argument = Dseqrecord("ggatcc") argument.add_feature(2, 4, label="lbl") editor.ape(argument) assert Popen.called
def test_editor_with_feature_wo_label_and_note(monkeypatch): import subprocess from pydna import editor Popen = mock.MagicMock(name="subprocess.Popen") monkeypatch.setattr("subprocess.Popen", Popen) monkeypatch.setenv("pydna_ape", "path/to/ape") from pydna.dseqrecord import Dseqrecord argument = Dseqrecord("ggatcc") argument.add_feature(2, 4) del argument.features[0].qualifiers["label"] editor.ape(argument) assert Popen.called
def toDSEQ(self, graph, edges, nodes): complements = self.generateComplements(nodes) dna = [] offset = -10 for edge in edges: seq = Dseq(edges[edge], complements[edge[1]], ovhg=offset) x = Dseqrecord(seq) x.name = edge[0] + "_" + edge[1] x.seq = seq dna.append(x) return dna
def test_olaps(): from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord as BSeqRecord from pydna.dseq import Dseq from pydna.dseqrecord import Dseqrecord from pydna.seqrecord import SeqRecord from Bio.Alphabet.IUPAC import IUPACAmbiguousDNA s = SeqRecord(Seq("GGATCC",alphabet=IUPACAmbiguousDNA())) assert "GGATCC" == str(s.olaps("GGATCC", limit = 4)[0].seq) assert "GGATCC" == str(s.olaps(Seq("GGATCC",alphabet=IUPACAmbiguousDNA()), limit = 4)[0].seq) assert "GGATCC" == str(s.olaps(BSeqRecord(Seq("GGATCC",alphabet=IUPACAmbiguousDNA())), limit = 4)[0].seq) assert "GGATCC" == str(s.olaps(Dseq("GGATCC",alphabet=IUPACAmbiguousDNA()), limit = 4)[0].seq) assert "GGATCC" == str(s.olaps(Dseqrecord(Dseq("GGATCC")), limit = 4)[0].seq) assert "GGATCC" == str(s.olaps(Dseqrecord("GGATCC"), limit = 4)[0].seq)
def test_primer_design_four_fragments(): x = [primer_design(f) for f in frags] fourth = Dseqrecord("TAAAAATAAAATTGTTGACAGCAGAAGTGATATAGAAATTTGTTAATTATTA") y = assembly_fragments(x + [fourth], 20) z = Assembly(y, limit=20) result = z.assemble_linear()[0] assert result.seq == (frags[0] + frags[1] + frags[2] + fourth).seq
def test_amplicon_dbd(): from pydna.amplify import Anneal from pydna.dseqrecord import Dseqrecord from pydna.primer import Primer from textwrap import dedent template = Dseqrecord("GCGTCCAGCGGCTGCCCGAGGCGCCAAGTGCCCGGGCCGAGCCCGCATCTGAGGCCGCCGCGGGC") p1 = Primer("GCGTCCAGCGGCTGCCCGAGG") p2 = Primer("GCCCGCGGCGGCCTCAGATGCGG") ann = Anneal((p1,p2),template) prod = ann.products[0] assert repr(prod) == 'Amplicon(65)' fig =( r''' Pfu-Sso7d (rate 15s/kb) Two-step| 30 cycles | |65bp 98.0°C |98.0C | |Tm formula: Pydna tmbresluc _____ __|_____ | |SaltC 50mM 00min30s|10s \ | |Primer1C 1.0µM | \ 72.0°C|72.0°C|Primer2C 1.0µM | \______|______|GC 81% | 0min 0s|10min |4-12°C '''[1:]) fig = dedent(fig) assert str(prod.pfu_sso7d_program()) == fig
def test_primer_Design_given_both_primers(): b = Dseqrecord( "agctactgactattaggggttattctgatcatctgatctactatctgactgtactgatcta") with pytest.raises(ValueError): primer_design(b, fp=Primer("agctactgactattag"), rp=Primer("tagatcagtacagtca"))
def test_primer_Design_multiple_products(): b = Dseqrecord( "agctactgactattaggggttaagctactgactattaggggtttctgatcatctgatctactatctgactgtactgatcta" ) from pydna import _PydnaWarning with pytest.warns(_PydnaWarning): a = primer_design(b)
def test_too_short_primers(): f, r = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") ann = Anneal((f, r), t, limit=22) assert ann.report() == ( "Template name 48 nt linear:\n" "Primer ForwardPrimer anneals forward at position 22\n" "\n" "Primer ReversePrimer anneals reverse at position 26") assert repr(ann) == "Reaction(products = 1)" p = ann.products[0] assert str(p.seq) == str(t.seq) ann = Anneal((f, r), t, limit=23) assert ann.products == [] assert ann.report() == ("Template name 48 nt linear:\n" "No forward primers anneal...\n" "\n" "No reverse primers anneal...") assert repr(ann) == "Reaction(products = 0)"
def isNewDseq(newpart, partlist): new = True dsnewpart = Dseqrecord(newpart) for part in partlist: if (len(part) != len(newpart)): continue dspart = Dseqrecord(part) if (dspart.linear == False): try: dspart = dspart.synced(dsnewpart) except Exception: continue if (dspart == dsnewpart): new = False break return new
def test_amplicon_dbd_low_gc(): from pydna.amplify import Anneal from pydna.dseqrecord import Dseqrecord from pydna.primer import Primer from textwrap import dedent template = Dseqrecord("AAAATATTTTTATACATAATACAATTGTATATTCTTAAATAAAAAATACGTCATC") p1 = Primer("AAAATATTTTTATACAT") p2 = Primer("GATGACGTATTTTTTAT") ann = Anneal((p1,p2),template) prod = ann.products[0] assert repr(prod) == 'Amplicon(55)' fig =( r''' Pfu-Sso7d (rate 15s/kb) |55bp Three-step| 30 cycles | |Tm formula: Pydna tmbresluc 98.0°C |98.0°C | |SaltC 50mM __________|_____ 72.0°C |72.0°C|Primer1C 1.0µM 00min30s |10s \ 39.0°C ________|______|Primer2C 1.0µM | \______/ 0min 0s|10min |GC 14% | 10s | |4-12°C '''[1:]) fig = dedent(fig) assert str(prod.pfu_sso7d_program()) == fig
def embl_gb_fasta(raw, ds, path=None): pattern = r"(?:>.+\n^(?:^[^>]+?)(?=\n\n|>|LOCUS|ID))|(?:(?:LOCUS|ID)(?:(?:.|\n)+?)^//)" result_list = [] rawseqs = _re.findall(pattern, _textwrap.dedent(raw + "\n\n"), flags=_re.MULTILINE) for rawseq in rawseqs: format_ = None handle = _io.StringIO(rawseq) if "circular" in rawseq.splitlines()[0]: circular = True else: circular = False try: parsed = _SeqIO.read(handle, "embl", alphabet=_IUPACAmbiguousDNA()) except ValueError: handle.seek(0) try: parsed = _SeqIO.read(handle, "genbank", alphabet=_IUPACAmbiguousDNA()) handle.seek(0) parser = _RecordParser() residue_type = parser.parse(handle).residue_type if "circular" in residue_type : circular = True else: try: if parsed.annotations["topology"] == "circular": circular = True else: circular = False except KeyError: circular = False except ValueError: handle.seek(0) try: parsed = _SeqIO.read(handle, "fasta", alphabet=_IUPACAmbiguousDNA()) except ValueError: parsed = "" else: format_= "fasta" else: format_= "genbank" else: format_ = "embl" handle.close() if parsed: from copy import deepcopy as _deepcopy ## TODO: clean up ! from pydna.seqfeature import SeqFeature as _SeqFeature nfs = [_SeqFeature() for f in parsed.features] for f, nf in zip(parsed.features, nfs): nf.__dict__ =_deepcopy(f.__dict__) parsed.features = nfs if ds and path: result_list.append( _GenbankFile.from_SeqRecord(parsed, linear=not circular, circular=circular, path=path) ) elif ds: result_list.append ( _Dseqrecord.from_SeqRecord(parsed, linear=not circular, circular=circular) ) else: result_list.append( parsed ) return result_list
def test_feature_label(): f0, r0 = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") t0.add_feature() f = f0 r = r0 t = t0 assert str(pcr( f, r, t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca"
def embl_gb_fasta(raw, ds, path=None): pattern = (r"(?:>.+\n^(?:^[^>]+?)(?=\n\n|>|" r"LOCUS|ID))|(?:(?:LOCUS|ID)(?:(?:.|\n)+?)^//)") result_list = [] rawseqs = _re.findall(pattern, _textwrap.dedent(raw + "\n\n"), flags=_re.MULTILINE) for rawseq in rawseqs: handle = _io.StringIO(rawseq) circular = False try: parsed = _SeqIO.read(handle, "embl") except ValueError: handle.seek(0) try: parsed = _SeqIO.read(handle, "genbank") if "circular" in str( parsed.annotations.get("topology")).lower(): circular = True except ValueError: handle.seek(0) try: parsed = _SeqIO.read(handle, "fasta") except ValueError: parsed = "" handle.close() if ("circular" in rawseq.splitlines()[0].lower().split() ): # hack to pick up topology from malformed files circular = True if parsed: from copy import deepcopy as _deepcopy # TODO: clean up ! from pydna.seqfeature import SeqFeature as _SeqFeature nfs = [_SeqFeature() for f in parsed.features] for f, nf in zip(parsed.features, nfs): nf.__dict__ = _deepcopy(f.__dict__) parsed.features = nfs if ds and path: result_list.append( _GenbankFile.from_SeqRecord(parsed, linear=not circular, circular=circular, path=path)) elif ds: result_list.append( _Dseqrecord.from_SeqRecord(parsed, linear=not circular, circular=circular)) else: result_list.append(parsed) return result_list
def get_all(folder='/home/pandyr/Dropbox (MIT)/Research/Plasmids'): """ Gather all sequence files in fasta folder """ all_data = {} # initialize storage # Iterate through all files in fasta folder for file in os.listdir(folder): if file.endswith(".dna"): seq = get(folder + '/' + file) seqname = get_seqname(file) all_data[seqname] = Dseqrecord(seq, linear=False) return all_data
def test_feature_note(): f0, r0 = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") t0.add_feature() del t0.features[0].qualifiers["label"] t0.features[0].qualifiers["note"] = ["note"] f = f0 r = r0 t = t0 assert str(pcr( f, r, t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca" assert pcr(f, r, t).name == "note"
def infer_ref(line): contig=line[0] kmers=contig2kmer(contig) sp_case,cov_case,sp_control,cov_control,refpairs=contig_sp_cov.loc[contig].tolist() refpairs=refpairs.split(',') if len(refpairs)==1:return (refpairs[0],sp_case,cov_case,sp_control,cov_control) try: refseq=Assembly([Dseqrecord(i) for i in refpairs],limit=15).assemble_linear(max_nodes=3)[0].seq.watson if maxoverlap(contig,refseq)[2]<15:refseq=assemDNA(refpairs)#for sake of low complexity sequences except:refseq=assemDNA(refpairs) if maxoverlap(contig,refseq)[2]<15:refseq=str(Seq(refseq).reverse_complement()) return (refseq,sp_case,cov_case,sp_control,cov_control)
def test_amplicon(): from pydna.amplify import Anneal from pydna.dseqrecord import Dseqrecord from pydna.primer import Primer template = Dseqrecord("AAAtacactcaccgtctatcattatctactatcgactgtatcatctgatagcacTTT") p1 = Primer("CCCtacactcaccgtctatcattatc") p2 = Primer("GGGgtgctatcagatgatacagtcg") ann = Anneal((p1,p2),template) prod = ann.products[0] assert repr(prod) == 'Amplicon(57)' assert prod._repr_html_() == 'Amplicon(57)' from unittest.mock import MagicMock pp = MagicMock() prod._repr_pretty_(pp, None) #assert pp.text.assert_called_with('Amplicon(57)') fig=''' 5tacactcaccgtctatcattatc...cgactgtatcatctgatagcac3 |||||||||||||||||||||| tm 55.9 (dbd) 60.5 3gctgacatagtagactatcgtgGGG5 5CCCtacactcaccgtctatcattatc3 ||||||||||||||||||||||| tm 54.6 (dbd) 58.8 3atgtgagtggcagatagtaatag...gctgacatagtagactatcgtg5''' import textwrap assert prod.figure() == textwrap.dedent(fig) assert prod.program() == prod.taq_program() assert prod.pfu_sso7d_program() == prod.dbd_program() from pydna.amplicon import Amplicon from Bio.Seq import Seq from Bio.Alphabet.IUPAC import IUPACAmbiguousDNA from pydna.seqrecord import SeqRecord arg = SeqRecord(Seq("aaa", IUPACAmbiguousDNA())) x = Amplicon.from_SeqRecord(arg)
def infer_ref_unpair(line,unpair_reads_dict): contig,refseq=line[0],'' kmers=contig2kmer(contig) sp_case,cov_case,sp_control,cov_control,refpairs=contig_sp_cov.loc[contig].tolist() refpairs=refpairs.split(',') related_reads=unpair_reads_dict[contig] refseq='NA' if len(refpairs)>2:#indels should have no more than 2 paired refs.(head and tail) try: refseq=Assembly([Dseqrecord(i) for i in refpairs],limit=15).assemble_linear(max_nodes=3)[0].seq.watson except:refseq=assemDNA(refpairs) if len(related_reads)>lowdepth/2 and len(refseq)<len(contig):refseq=CAP(contig,related_reads) if maxoverlap(contig,refseq)[2]<15:refseq=str(Seq(refseq).reverse_complement()) return (refseq,sp_case,cov_case,sp_control,cov_control)
def test_primer_Design(): ''' test_primer_design''' a = Dseqrecord( "atgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatg") b = Dseqrecord( "ccaaacccaccaggtaccttatgtaagtacttcaagtcgccagaagacttcttggtcaagttgcc") c = Dseqrecord( "tgtactggtgctgaaccttgtatcaagttgggtgttgacgccattgccccaggtggtcgtttcgtt") frags = assembly_fragments([primer_design(r) for r in (a, b, c)]) asm = Assembly(frags) assert asm.assemble_linear()[0].seguid() == "1eNv3d_1PqDPP8qJZIVoA45Www8" frags = assembly_fragments([primer_design(r) for r in (a, b, c, a)]) a2 = pcr(frags[-1].forward_primer, frags[0].reverse_primer, a) asm = Assembly((a2, frags[1], frags[2])) assert asm.assemble_circular()[0].cseguid( ) == "V3Mi8zilejgyoH833UbjJOtDMbc"
def test_Primer_arguments(): f0, r0 = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") f = f0 r = r0 t = t0 assert str(pcr( f, r, t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca"
def test_string_arguments(): f0, r0 = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") f = str(f0.seq) r = str(r0.seq) t = str(t0.seq) assert str(pcr( (f, r), t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca"
def test_no_fwdprimer_anneal(): f0, r0 = parse_primers('''>ForwardPrimer gctact >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") f = f0 r = r0 t = t0 with pytest.raises(ValueError): pcr(f, r, t)
def test_Seq_arguments(): from Bio.Seq import Seq f0, r0 = parse_primers(""">ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg""") t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") f = Seq(str(f0.seq)) r = Seq(str(r0.seq)) t = Seq(str(t0.seq)) assert str(pcr( f, r, t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca"
def test_Dseq_arguments(): from pydna.dseq import Dseq f0, r0 = parse_primers('''>ForwardPrimer gctactacacacgtactgactg >ReversePrimer tgtggttactgactctatcttg''') t0 = Dseqrecord("gctactacacacgtactgactgcctccaagatagagtcagtaaccaca") f = Dseq(str(f0.seq)) r = Dseq(str(r0.seq)) t = Dseq(str(t0.seq)) assert str(pcr( f, r, t).seq) == "gctactacacacgtactgactgcctccaagatagagtcagtaaccaca"