def test_optimization_2():
sequence_path = os.path.join("tests", "data",
"test_optimization_sequence_2.fa")
sequence = str(load_record(sequence_path).seq)[:5500]
deluxe_dna = CommercialDnaOffer(
name="DeluxeDNA.com",
sequence_constraints=[SequenceLengthConstraint(max_length=4000)],
pricing=PerBasepairPricing(0.20),
lead_time=10,
)
cheap_dna = CommercialDnaOffer(
name="CheapDNA.com",
sequence_constraints=[
NoPatternConstraint(enzyme="BsaI"),
EnforceGCContent(0.3, 0.7, window=60),
],
pricing=PerBasepairPricing(0.10),
lead_time=15,
)
# BLOCKS TO CHUNKS ASSEMBLY
gibson_blocks_assembly_station = DnaAssemblyStation(
name="Gibson Blocks Assembly",
assembly_method=GibsonAssemblyMethod(
overhang_selector=FixedSizeSegmentSelector(10),
min_segment_length=1000,
max_segment_length=6000,
duration=8,
cost=16,
),
supplier=[deluxe_dna, cheap_dna],
coarse_grain=30,
fine_grain=False,
memoize=True,
# a_star_factor="auto",
)
quote_before = gibson_blocks_assembly_station.get_quote(sequence)
assert quote_before.price > 850
objective = OptimizeManufacturability(gibson_blocks_assembly_station)
problem = DnaOptimizationProblem(
sequence=sequence,
constraints=[EnforceTranslation(location=(0, 4998))],
objectives=[objective],
)
problem.randomization_threshold = 0 # Forces "random search" mode
problem.max_random_iters = 5
problem.optimize()
print("OPTIMIZATION DONE, GENERATING REPORT")
quote_after = gibson_blocks_assembly_station.get_quote(problem.sequence)
assert quote_after.price < 580
def test_emma_construct():
emma_collection = GoldenGatePartsLibrary("EMMA",
fasta_file=EMMA_PATH,
memoize=True)
company_ingen = CommercialDnaOffer(
name="InGen",
pricing=PerBasepairPricing(0.14),
sequence_constraints=[SequenceLengthConstraint(max_length=2400)])
company_tdi = CommercialDnaOffer(
name="TDI",
pricing=PerBasepairPricing(0.08),
sequence_constraints=[SequenceLengthConstraint(max_length=600)])
assembly_station = DnaAssemblyStation(
name='GoldenGate Assembly Station',
assembly_method=GoldenGateAssemblyMethod(
min_segment_length=40,
max_segment_length=5000,
enzyme='BsmBI',
# max_fragments=8
),
supplier=[company_ingen, emma_collection, company_tdi],
coarse_grain=100,
fine_grain=10,
logger='bar',
a_star_factor='auto')
record = load_record(SEQUENCE_PATH)
sequence = str(record.seq)
quote = assembly_station.get_quote(sequence, with_assembly_plan=True)
emma_parts = [
p for p in list(quote.assembly_plan.values())
if p.source.name == 'EMMA'
]
assert len(emma_parts) == 6
def test_simple_gibson_assembly_station():
dna_provider = CommercialDnaOffer(name="Company InGen",
pricing=PerBasepairPricing(0.08))
assembly_station = DnaAssemblyStation(
name='Gibson Assembly Station',
assembly_method=GibsonAssemblyMethod(
overhang_selector=TmOverhangSelector(),
min_segment_length=300,
max_segment_length=1200),
dna_source=dna_provider,
coarse_grain=10,
)
sequence = random_dna_sequence(5000, seed=1234)
quote = assembly_station.get_quote(sequence, with_assembly_plan=True)
assert quote.accepted
assert 405.7 < quote.price < 405.8
min_segment_length=10,
max_segment_length=3000,
),
dna_source=DnaSourcesComparator([
yeastfab_library, dna_company, yeast_genome
]),
a_star_factor=0.02,
progress_bars=True)
promoter = parts_by_name['YOR314W_P'][7:-7]
orf = parts_by_name['YOR314W'][11:-7]
terminator = parts_by_name['YOR314W_T'][11:-7]
expression_unit_1 = promoter + orf + terminator
inter_region = random_dna_sequence(800)
with open("./cerevisiae_genome/cerevisiae_genome.fa", "r") as f:
expression_unit_2 = f.read()[50000:52000].replace("\n", "").upper()
sequence = expression_unit_1 + inter_region + expression_unit_2
t0 = time.time()
yeast_genome.pre_blast(sequence)
quote = gg_station.get_quote(sequence, with_ordering_plan=True)
print quote.ordering_plan.summary()
print time.time() - t0
tree = quote.compute_assembly_tree()
from bokeh.io import output_file
from bokeh.plotting import show
plot = plot_ordering_tree(tree)
output_file("test.html")
show(plot)
enzyme="BsmBI"),
supplier=[
company_ingen,
emma_collection,
mouse_pcr_station,
company_tdi,
],
coarse_grain=100,
fine_grain=None,
logger="bar",
)
for station, color in [
(company_ingen, "#fdfdb3"),
(company_oligo, "#b8b6e6"),
(company_tdi, "#c8f8c4"),
(mouse_pcr_station, "#eff5f5"),
(emma_collection, "#f8c3c3"),
]:
station.report_color = color
# LOAD THE SEQUENCE AND PREPARE THE NETWORK FOR IT. HERE THE
# PREPARATION WILL ONLY MAKE THE PCR STATION PRE-BLAST THE SEQUENCE
record = load_record("example_sequence.gb")
assembly_station.prepare_network_on_sequence(record)
quote = assembly_station.get_quote(record, with_assembly_plan=True)
assembly_report = quote.to_assembly_plan_report()
assembly_report.write_full_report("EMMA_assembly_report")
print("Success! See figure assembly_plans.png.")
)
assembly_station = DnaAssemblyStation(
name='GoldenGate Assembly Station',
assembly_method=GoldenGateAssemblyMethod(
min_segment_length=50,
max_segment_length=2000
),
dna_source=company,
coarse_grain=50,
logger='bars'
)
sequence = random_dna_sequence(4000, seed=123)
sites_locations = enzyme_pattern("AarI").find_matches(sequence)
enzyme_sites_centres = [(l.start + l.end) // 2 for l in sites_locations]
print ("AarI site(s) were found around position(s) %s" % enzyme_sites_centres)
quote = assembly_station.get_quote(sequence, with_assembly_plan=True)
print (quote)
if quote.accepted:
print (quote.assembly_step_summary())
# This will print:
# ----------------
#
# BsaI site found around positions [(1237, 1244)]
# Ordering plan:
# (0, 1240) Company InGen 125.60$
# (1240, 5000) Company InGen 377.60$
# Total:503$
def test_full_report():
# OLIGO COMPANIES
a_star_factor = 'auto'
memoize = True
oligo_com = CommercialDnaOffer(
name="Oligo.com",
sequence_constraints=[SequenceLengthConstraint(max_length=200)],
pricing=PerBasepairPricing(0.10),
lead_time=7
)
deluxe_dna_com = CommercialDnaOffer(
name="DeluxeDNA.com",
sequence_constraints=[SequenceLengthConstraint(max_length=4000)],
pricing=PerBasepairPricing(0.20),
lead_time=10
)
cheap_dna_com = CommercialDnaOffer(
name="CheapDNA.com",
sequence_constraints=[SequenceLengthConstraint(max_length=4000),
NoPatternConstraint(enzyme='AarI'),
NoPatternConstraint(enzyme='BsaI'),
lambda seq: (0.4 < gc_content(seq) < 0.6)
],
pricing=PerBasepairPricing(0.10),
lead_time=15
)
# OLIGOS TO BLOCKS ASSEMBLY
oligo_assembly_station = DnaAssemblyStation(
name="Oligo Assembly Station",
assembly_method=BuildAGenomeAssemblyMethod(
overhang_selector=TmOverhangSelector(
min_size=15, max_size=25, min_tm=50, max_tm=70),
min_segment_length=40,
max_segment_length=200,
sequence_constraints=[SequenceLengthConstraint(max_length=1500)],
duration=8,
cost=2
),
dna_source=oligo_com,
coarse_grain=20,
fine_grain=False,
a_star_factor=a_star_factor
)
# BLOCKS TO CHUNKS ASSEMBLY
blocks_sources_comparator = DnaSourcesComparator(
name='bs_comparator',
suppliers=[
oligo_assembly_station,
cheap_dna_com,
deluxe_dna_com
],
memoize=memoize
)
gibson_blocks_assembly_station = DnaAssemblyStation(
name="Gibson Blocks Assembly",
assembly_method=GibsonAssemblyMethod(
overhang_selector=FixedSizeOverhangSelector(80),
min_segment_length=1000,
max_segment_length=4000,
duration=8,
cost=16
),
dna_source=blocks_sources_comparator,
coarse_grain=300,
fine_grain=False,
memoize=memoize,
a_star_factor=a_star_factor
)
goldengate_blocks_assembly_station = DnaAssemblyStation(
name="Golden Gate Blocks Assembly",
assembly_method=GoldenGateAssemblyMethod(
enzyme='BsmBI',
wildcard_basepair="A",
min_segment_length=1000,
max_segment_length=4000,
duration=5,
cost=6
),
dna_source=blocks_sources_comparator,
coarse_grain=400,
fine_grain=False,
memoize=memoize,
a_star_factor=a_star_factor
)
ecoli_genome = PcrOutStation(
"E. coli Genome (PCR)",
primers_dna_source=oligo_com,
blast_database=ECOLI_DB_PATH,
max_amplicon_length=10000,
extra_time=3,
extra_cost=1
)
# CHUNKS TO MEGACHUNKS ASSEMBLY
chunks_assembly_station = DnaAssemblyStation(
name="Chunks assembly (Gibson)",
assembly_method=GibsonAssemblyMethod(
overhang_selector=FixedSizeOverhangSelector(300),
min_segment_length=7000,
max_segment_length=25000,
duration=8
),
dna_source=DnaSourcesComparator([
ecoli_genome,
goldengate_blocks_assembly_station,
gibson_blocks_assembly_station,
]),
coarse_grain=1000,
fine_grain=None,
logger='bars',
a_star_factor=a_star_factor,
memoize=memoize
)
with open(SEQUENCE_PATH, "r") as f:
sequence = f.read()
import time
t0 = time.time()
ecoli_genome.pre_blast(sequence)
quote = chunks_assembly_station.get_quote(
sequence, with_assembly_plan=True)
t1 = time.time()
print("ELAPSED:", "%.02f" % (t1 - t0))
print(quote)
if quote.accepted:
print(quote.assembly_step_summary())
assert (3500 < quote.price < 3600)
quote.compute_full_assembly_tree()
quote.compute_fragments_final_locations()
json_quote = JsonQuote.from_dnaweaver_quote(quote)
autocolor_quote_sources(json_quote)
data = make_folder_report(json_quote, '@memory')
if min(location, len(sequence) - location) < 20:
return True
subsequence = sequence[location - 10:location + 10]
melting_temperature = primer3.calcTm(subsequence)
return 50 < melting_temperature < 55
def has_weak_secondary_structure(segment):
"""Return False if the segment corresponds to an oligo with a
secondary structure that is too stable"""
fragment = assembly_method.compute_fragment_sequence(segment, sequence)
return RNA.fold(fragment)[1] > -40
assembly_station = DnaAssemblyStation(
name="Oligo Assembly Station",
assembly_method=BuildAGenomeAssemblyMethod(homology_arm_length=20,
min_segment_length=40,
max_segment_length=100,
duration=7),
dna_source=CommercialDnaOffer(name="Oligos Company",
pricing=lambda seq: 0.10 * len(seq)),
nucleotide_resolution=10,
refine_resolution=1)
quote = assembly_station.get_quote(sequence, with_ordering_plan=True)
print(quote)
if quote.accepted:
print(quote.ordering_plan.summary())
assembly_station = DnaAssemblyStation(
"Golden Gate Assembly Station",
assembly_method=GoldenGateAssemblyMethod(
left_overhang="[BsaI]A",
min_segment_length=100,
max_segment_length=3500,
force_cuts=force_cuts
),
dna_source=cheap_dna_com,
coarse_grain=10,
fine_grain=1
)
quote = assembly_station.get_quote(sequence)
print (quote)
if quote.accepted:
print (quote.ordering_plan.summary())
# This will print:
# ----------------
#
# Pattern [C][A][C][C][T][G][C] (AarI) found at locations [(1237, 1244)]
# Pattern [G][G][G][G][G][G][G][G][G] found at locations [(3247, 3256)]
# Ordering plan:
# (0, 1240) Company 1 127.00$
# (1240, 3251) Company 1 204.30$
# (3251, 5000) Company 1 177.90$
# Total:509$
name="Gibson Blocks Assembly",
assembly_method=GibsonAssemblyMethod(
overhang_selector=TmSegmentSelector(),
min_segment_length=1000,
max_segment_length=6000,
duration=8,
cost=16,
),
supplier=[deluxe_dna, cheap_dna],
coarse_grain=30,
fine_grain=False,
memoize=True,
a_star_factor="auto",
)
quote_before = gibson_blocks_assembly_station.get_quote(
sequence, with_assembly_plan=True)
print("LOCATING PRICE-DRIVING REGIONS AND OPTIMIZING... PLEASE WAIT")
objective = OptimizeManufacturability(gibson_blocks_assembly_station)
problem = dnachisel.DnaOptimizationProblem(
sequence=sequence,
constraints=[dnachisel.EnforceTranslation(location=(0, 9999))],
objectives=[objective])
problem.randomization_threshold = 0 # Forces "random search" mode
problem.max_random_iters = 5
problem.optimize()
print("OPTIMIZATION DONE, GENERATING REPORT")
def test_lead_time_limit():
# OLIGO COMPANIES
a_star_factor = "auto"
memoize = True
oligo_com = CommercialDnaOffer(
name="Oligo.com",
sequence_constraints=[SequenceLengthConstraint(max_length=200)],
pricing=PerBasepairPricing(0.10),
lead_time=7,
)
deluxe_dna_com = CommercialDnaOffer(
name="DeluxeDNA.com",
sequence_constraints=[SequenceLengthConstraint(max_length=4000)],
pricing=PerBasepairPricing(0.20),
lead_time=10,
)
cheap_dna_com = CommercialDnaOffer(
name="CheapDNA.com",
sequence_constraints=[
SequenceLengthConstraint(max_length=4000),
NoPatternConstraint(enzyme="AarI"),
NoPatternConstraint(enzyme="BsaI"),
lambda seq: (0.4 < gc_content(seq) < 0.6),
],
pricing=PerBasepairPricing(0.10),
lead_time=15,
)
# OLIGOS TO BLOCKS ASSEMBLY
oligo_assembly_station = DnaAssemblyStation(
name="Oligo Assembly Station",
assembly_method=OligoAssemblyMethod(
overhang_selector=TmSegmentSelector(min_size=15,
max_size=25,
min_tm=50,
max_tm=70),
min_segment_length=40,
max_segment_length=200,
sequence_constraints=[SequenceLengthConstraint(max_length=1500)],
duration=8,
cost=2,
),
supplier=oligo_com,
coarse_grain=20,
fine_grain=False,
a_star_factor=a_star_factor,
)
# BLOCKS TO CHUNKS ASSEMBLY
blocks_sources_comparator = DnaSuppliersComparator(
name="bs_comparator",
suppliers=[oligo_assembly_station, cheap_dna_com, deluxe_dna_com],
memoize=memoize,
)
gibson_blocks_assembly_station = DnaAssemblyStation(
name="Gibson Blocks Assembly",
assembly_method=GibsonAssemblyMethod(
overhang_selector=FixedSizeSegmentSelector(80),
min_segment_length=1000,
max_segment_length=4000,
duration=8,
cost=16,
),
supplier=blocks_sources_comparator,
coarse_grain=300,
fine_grain=False,
memoize=memoize,
a_star_factor=a_star_factor,
)
goldengate_blocks_assembly_station = DnaAssemblyStation(
name="Golden Gate Blocks Assembly",
assembly_method=GoldenGateAssemblyMethod(
enzyme="BsmBI",
wildcard_basepair="A",
min_segment_length=1000,
max_segment_length=4000,
duration=5,
cost=6,
),
supplier=blocks_sources_comparator,
coarse_grain=400,
fine_grain=False,
memoize=memoize,
a_star_factor=a_star_factor,
)
ecoli_genome = PcrExtractionStation(
"E. coli Genome (PCR)",
primers_supplier=oligo_com,
homology_selector=TmSegmentSelector(min_size=18,
max_size=22,
min_tm=55,
max_tm=65),
blast_database=ECOLI_DB_PATH,
max_amplicon_length=10000,
extra_time=3,
extra_cost=1,
)
# CHUNKS TO MEGACHUNKS ASSEMBLY
chunks_assembly_station = DnaAssemblyStation(
name="Chunks assembly (Gibson)",
assembly_method=GibsonAssemblyMethod(
overhang_selector=FixedSizeSegmentSelector(300),
min_segment_length=7000,
max_segment_length=25000,
duration=8,
),
supplier=DnaSuppliersComparator([
ecoli_genome,
goldengate_blocks_assembly_station,
gibson_blocks_assembly_station,
]),
coarse_grain=1000,
fine_grain=None,
a_star_factor=a_star_factor,
memoize=memoize,
)
with open(SEQUENCE_PATH, "r") as f:
sequence = f.read()
import time
t0 = time.time()
chunks_assembly_station.prepare_network_on_sequence(sequence)
quote = chunks_assembly_station.get_quote(sequence,
max_lead_time=28,
with_assembly_plan=True)
t1 = time.time()
print("ELAPSED:", "%.02f" % (t1 - t0))
print(quote)
if quote.accepted:
print(quote.assembly_step_summary())
assert 5540 < quote.price < 5550