def test_autoselect_enzyme():
parts = [
dc.load_genbank(os.path.join('tests', 'data', 'assemblies', partfile))
for partfile in ["partA.gb", "partB.gb", "partC.gb"]
]
selected = dc.autoselect_enzyme(parts, enzymes=["BsaI", "BsmBI", "BbsI"])
assert selected == "BsmBI"
def select_backbone(self):
self.logger(message="Reading Data...")
data = self.data
backbones = records_from_data_files(data.backbones)
inserts = records_from_data_files(data.inserts)
records = inserts + backbones
for record in records:
record.linear = False # Trick
if data.enzyme == "Autoselect":
possible_enzymes = ["BsaI", "BsmBI", "BbsI"]
data.enzyme = autoselect_enzyme(records, enzymes=possible_enzymes)
zip_root = flametree.file_tree('@memory')
choices = insert_parts_on_backbones(inserts,
backbones,
process_parts_with_backbone=True)
dataframe = BackboneChoice.list_to_infos_spreadsheet(choices)
dataframe.to_excel(zip_root._file('summary.xls').open('wb'),
index=False)
BackboneChoice.write_final_records(choices, zip_root._dir("records"))
return {
'file': {
'data': data_to_html_data(zip_root._close(), 'zip'),
'name': 'backbone_autoselection.zip',
'mimetype': 'application/zip'
},
'success': 'yeah!',
'summary': 'none yet'
}
def construct_data_to_assemblies_sequences(constructs_data, ice_auth, logger):
results_zip_root = file_tree('@memory')
errors = {
'no_assembly': []
}
ice_auth['root'] = 'http://*****:*****@memory", enzyme=enzyme,
assemblies_prefix=construct.name,
connector_records=connectors_records,
include_fragments_plots=False, include_parts_plots=False,
include_assembly_plots=True)
folder = results_zip_root._dir(construct.name)
ziproot = file_tree(zipdata)
for d in ziproot._dirs:
d._copy(folder)
ziproot.parts_graph_pdf.copy(folder._file('parts_graph.pdf'))
except ValueError as err:
raise (err)
name_and_error = "%s (%s)" % (construct.name, str(err))
errors['no_assembly'].append(name_and_error)
zip_data = results_zip_root._close()
return zip_data, errors
def parts_records_to_slots(parts_records, enzyme="auto"):
"""Return slots from parts records, ready to feed to other methods.
Parameters
----------
parts_records
A list of Biopython records of the parts of the assembly. Do NOT
include the backbone.
enzyme
Name of a Type-2S enzyme or "auto" to select automatically based
on restriction sites in the records sequences.
Returns
-------
slots
A list [(slot_name, left_overhang, right_overhang), ...] ready to be fed
to the other Kappagate methods.
"""
if enzyme == "auto":
enzyme = autoselect_enzyme(parts_records)
# mix = RestrictionLigationMix(parts_records, enzymes=[enzyme])
mix = generate_type2s_restriction_mix(parts=parts_records, enzyme=enzyme)
slots_parts = mix.compute_slots()
graph = mix.slots_graph(with_overhangs=False)
slots = [
(list(slots_parts[(s1, s2)])[0], s1, s2)
for s1, s2 in linear_graph_to_nodes_list(graph)
]
for i in list(range(len(slots) - 1)):
name, left, right = slots[i + 1]
if slots[i][2] != left:
if slots[i][2] == reverse_complement(right):
slots[i + 1] = (
name,
reverse_complement(right),
reverse_complement(left),
)
else:
name, left, right = slots[i]
slots[i] = (
name,
reverse_complement(right),
reverse_complement(left),
)
return (
[("backbone-left", "LEFT", slots[0][1])]
+ slots
+ [("backbone-right", slots[-1][2], "RIGHT")]
)
def one_backbone(self):
self.logger(message="Reading Data...")
data = self.data
backbone = records_from_data_files([data.backbone])[0]
inserts = [records_from_data_files([f])[0] for f in data.inserts]
records = inserts + [backbone]
for record in records:
record.linear = False # Trick
if data.enzyme == "Autoselect":
possible_enzymes = ["BsaI", "BsmBI", "BbsI"]
data.enzyme = autoselect_enzyme(records, enzymes=possible_enzymes)
zip_root = flametree.file_tree('@memory')
for insert in inserts:
record = swap_donor_vector_part(backbone, insert, data.enzyme)
record.id = insert.id
write_record(record, zip_root._file(autoname_genbank_file(record)),
'genbank')
if len(inserts) == 1:
f = zip_root._all_files[0]
data = f.read('rb')
return {
'file': {
'data': data_to_html_data(data, 'genbank'),
'name': f._name,
'mimetype': 'application/genbank'
},
'success': 'true',
'summary': 'Swapping succesful !'
}
else:
return {
'file': {
'data': data_to_html_data(zip_root._close(), 'zip'),
'name': 'donor_swap_genbanks.zip',
'mimetype': 'application/zip'
},
'success': 'yeah!',
'summary': 'none yet'
}
def test_autoselect_enzyme():
parts = [records_dict[name] for name in ["partA", "partB", "partC"]]
selected = dc.autoselect_enzyme(parts, enzymes=["BsaI", "BsmBI", "BbsI"])
assert selected == "BsmBI"
def work(self):
self.logger(message="Reading Data...")
data = self.data
records = records_from_data_files(data.parts)
if data.use_file_names_as_ids:
for r in records:
r.id = r.name = r.file_name
connector_records = records_from_data_files(data.connectors)
for r in (records + connector_records):
if not hasattr(r, 'linear'):
r.linear = False
r.seq = r.seq.upper()
if data.enzyme == "Autoselect":
possible_enzymes = ["BsaI", "BsmBI", "BbsI"]
data.enzyme = autoselect_enzyme(records, enzymes=possible_enzymes)
self.logger(message="Generating a report, be patient.")
if data.use_assembly_plan:
filelike = file_to_filelike_object(data.assembly_plan)
if data.assembly_plan.name.lower().endswith('.csv'):
content = filelike.read().decode()
dataframe = pandas.DataFrame(
[line.split(',') for line in content.split('\n')])
else:
dataframe = pandas.read_excel(filelike, header=None)
assembly_plan = AssemblyPlan.from_spreadsheet(dataframe=dataframe)
assembly_plan.parts_data = {r.id: {'record': r} for r in records}
print(assembly_plan.assemblies)
parts_without_data = assembly_plan.parts_without_data()
if len(parts_without_data):
return {'success': False, 'unknown_parts': parts_without_data}
errors, zip_data = full_assembly_plan_report(
assembly_plan.assemblies_with_records(),
target="@memory",
enzyme=data.enzyme,
assert_single_assemblies=data.single_assemblies,
logger=self.logger,
connector_records=connector_records,
fail_silently=True,
include_fragments_plots=data.include_fragments,
include_parts_plots=data.include_fragments)
infos = dict(errors=errors)
else:
nconstructs, zip_data = full_assembly_report(
records,
connector_records=connector_records,
target='@memory',
enzyme=data.enzyme,
max_assemblies=40,
fragments_filters='auto',
assemblies_prefix='assembly',
include_fragments_plots=data.include_fragments,
include_parts_plots=data.include_fragments)
infos = dict(nconstructs=nconstructs)
return {
'file': {
'data': data_to_html_data(zip_data, 'zip'),
'name': 'assemblies.zip',
'mimetype': 'application/zip'
},
'success': True,
'infos': infos
}