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"
