def test_plot_with_gc_content(tmpdir):
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 4), sharex=True)
# Parse the genbank file, plot annotations
record = SeqIO.read(example_genbank, "genbank")
graphic_record = BiopythonTranslator().translate_record(record)
ax, levels = graphic_record.plot()
graphic_record.plot(ax=ax1, with_ruler=False)
# Plot the local GC content
def plot_local_gc_content(record, window_size, ax):
def gc_content(seq):
return 100.0 * len([c for c in seq if c in "GC"]) / len(seq)
yy = [
gc_content(record.seq[i:i + window_size])
for i in range(len(record.seq) - window_size)
]
xx = np.arange(len(record.seq) - window_size) + 25
ax.fill_between(xx, yy, alpha=0.3)
ax.set_ylabel("GC(%)")
plot_local_gc_content(record, window_size=50, ax=ax2)
# Resize the figure to the right height
target_file = os.path.join(str(tmpdir), "with_plot.png")
fig.tight_layout()
fig.savefig(target_file)
def test_from_genbank(tmpdir):
graphic_record = BiopythonTranslator().translate_record(example_genbank)
assert len(graphic_record.features) == 11
ax, _ = graphic_record.plot(figure_width=10)
ax.figure.tight_layout()
target_file = os.path.join(str(tmpdir), "from_genbank.png")
ax.figure.savefig(target_file)
def test_from_genbank_to_circular(tmpdir):
translator = BiopythonTranslator()
graphic_record = translator.translate_record(
example_genbank, record_class=CircularGraphicRecord)
ax, _ = graphic_record.plot(figure_width=7)
ax.figure.tight_layout()
target_file = os.path.join(str(tmpdir), "from_genbank.png")
ax.figure.savefig(target_file)
def test_plot_with_bokeh(tmpdir):
gb_record = SeqIO.read(example_genbank, "genbank")
record = BiopythonTranslator().translate_record(record=gb_record)
plot = record.plot_with_bokeh(figure_width=8)
target_file = os.path.join(str(tmpdir), "plot_with_bokeh.html")
with open(target_file, "w+") as f:
f.write(file_html(plot, CDN, "Example Sequence"))
with open(target_file, "r") as f:
assert len(f.read()) > 5000
def test_multiline_plot():
translator = BiopythonTranslator()
graphic_record = translator.translate_record(example_genbank)
subrecord = graphic_record.crop((1700, 2200))
fig, axes = subrecord.plot_on_multiple_lines(nucl_per_line=100,
figure_width=12,
plot_sequence=True)
assert 9.5 < fig.get_figheight() < 10
def plot(self, ax=None):
"""Plot the fragment and its features on a Matplotlib ax.
This creates a new ax if no ax is provided. The ax is returned at the
end.
"""
graphic_record = BiopythonTranslator().translate_record(self)
ax, _ = graphic_record.plot(ax=ax, strand_in_label_threshold=7)
return ax
def test_multipage_plot(tmpdir):
translator = BiopythonTranslator()
graphic_record = translator.translate_record(example_genbank)
subrecord = graphic_record.crop((1800, 2750))
subrecord.plot_on_multiple_pages(
pdf_target=os.path.join(str(tmpdir), "test.pdf"),
nucl_per_line=70,
lines_per_page=7,
plot_sequence=True,
)
def test_plot_with_bokeh_no_labels(tmpdir):
"""Bokeh has a problem with empty lists of labels."""
gb_record = SeqIO.read(example_genbank, "genbank")
record = BiopythonTranslator().translate_record(record=gb_record)
for feature in record.features:
feature.label = None
plot = record.plot_with_bokeh(figure_width=8)
target_file = os.path.join(str(tmpdir), "plot_with_bokeh.html")
with open(target_file, "w+") as f:
f.write(file_html(plot, CDN, "Example Sequence"))
with open(target_file, "r") as f:
assert len(f.read()) > 5000
def compute_feature_label(self, feature):
if feature.type == 'restriction_site':
return None
elif feature.type == "CDS":
return "CDS here"
else:
return BiopythonTranslator.compute_feature_label(self, feature)
def compute_feature_label(self, f):
if f.type != "original" and show_locations:
return str(int(f.location.start))
elif show_feature_labels and f.type == "original":
return BiopythonTranslator.compute_feature_label(f)
else:
return None
def compute_feature_label(self, feature):
if self.is_source(feature):
return "".join(feature.qualifiers["source"])
elif abs(feature.location.end - feature.location.start) > 100:
label = BiopythonTranslator.compute_feature_label(self, feature)
return abreviate_string("".join(label), 30)
else:
return None
def compute_feature_label(self, feature):
if abs(feature.location.end - feature.location.start) > 100:
label = BiopythonTranslator.compute_feature_label(
self, feature
)
return abreviate_string(label, 10)
else:
return feature.qualifiers.get("enzyme", None)
def compute_feature_label(feature):
if AssemblyTranslator.is_source(feature):
return feature.qualifiers['source']
elif abs(feature.location.end - feature.location.start) > 100:
label = BiopythonTranslator.compute_feature_label(feature)
return abreviate_string(label, 30)
else:
return None
def compute_feature_label(self, f):
is_edit = f.qualifiers.get("is_edit", "false")
if "true" in [is_edit, is_edit[0]]:
return None
default = BiopythonTranslator.compute_feature_label(self, f)
label = None if (f.type != "misc_feature") else default
if label == "misc_feature":
label = None
return label
def test_multipage_plot_with_translation(tmpdir):
# Github issue 61
translator = BiopythonTranslator()
graphic_record = translator.translate_record(example_genbank)
subrecord = graphic_record.crop((1800, 2750))
translation_params = {
"location": (1830, 1890),
"fontdict": {
"weight": "bold"
},
"long_form_translation": False,
}
subrecord.plot_on_multiple_pages(
pdf_target=os.path.join(str(tmpdir), "test_translation.pdf"),
nucl_per_line=66,
lines_per_page=7,
plot_sequence=True,
translation_params=translation_params,
)
def redraw(self, start=1, end=2000):
"""Plot the features"""
import matplotlib
import pylab as plt
from dna_features_viewer import GraphicFeature, GraphicRecord
from dna_features_viewer import BiopythonTranslator
ax = self.ax
ax.clear()
rec = self.rec
length = len(self.rec.seq)
if start < 0:
start = 1
if end <= 0:
end = start + 2000
if end - start > 100000:
end = start + 100000
if end > length:
end = length
rec = self.rec
translator = BiopythonTranslator(
features_filters=(lambda f: f.type not in ["gene", "source"], ),
features_properties=lambda f:
{"color": self.color_map.get(f.type, "white")},
)
#print (start, end, length)
graphic_record = translator.translate_record(rec)
cropped_record = graphic_record.crop((start, end))
#print (len(cropped_record.features))
cropped_record.plot(strand_in_label_threshold=7, ax=ax)
if end - start < 150:
cropped_record.plot_sequence(ax=ax, location=(start, end))
cropped_record.plot_translation(ax=ax,
location=(start, end),
fontdict={'weight': 'bold'})
plt.tight_layout()
self.canvas.draw()
self.view_range = end - start
self.loclbl.setText(str(start) + '-' + str(end))
return
def gene_plot(gbk_file, **kwargs):
"""Create gene feature plot."""
color_map = {
"rep_origin": "yellow",
"CDS": Colors.cerulean,
"regulatory": "red",
"rRNA": Colors.light_cornflower_blue,
"misc_feature": "lightblue",
}
translator = BiopythonTranslator(
features_filters=(lambda f: f.type not in ["gene", "source"], ),
features_properties=lambda f:
{"color": color_map.get(f.type, "white")})
record = translator.translate_record(gbk_file)
ax, _ = record.plot(figure_width=300,
strand_in_label_threshold=30,
**kwargs)
encoded = fig_to_base64(ax.figure)
plot = '<pre><img src="data:image/png;base64, {}"></pre>'.format(
encoded.decode('utf-8'))
return plot
def plot_seq(record, annot_residuei=8, title='', xlabel='', plotp=None):
from dna_features_viewer import BiopythonTranslator
# graphic_record = BiopythonTranslator().translate_record("seqname.gb")
graphic_record = BiopythonTranslator().translate_record(record)
ax, _ = graphic_record.plot(
figure_width=12.5,
annotate_inline=True,
level_offset=0.5,
)
graphic_record.plot_sequence(ax=ax, )
graphic_record.plot_translation(ax=ax, location=[0, 45])
ax.plot([annot_residuei * 3 - 3.5, annot_residuei * 3 - 0.5], [-2, -2],
lw=5,
color='r')
ax.set_title(title)
ax.set_xlabel(xlabel)
# ax.plot([21,23],[-2,-2])
if not plotp is None:
plt.tight_layout()
ax.figure.savefig(plotp, format='png')
import matplotlib.pyplot as plt
from dna_features_viewer import BiopythonTranslator
from Bio import SeqIO
import numpy as np
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 4), sharex=True)
# Parse the genbank file, plot annotations
record = SeqIO.read("example_sequence.gb", "genbank")
graphic_record = BiopythonTranslator().translate_record(record)
ax, levels = graphic_record.plot()
graphic_record.plot(ax=ax1, with_ruler=False)
# Plot the local GC content
def plot_local_gc_content(record, window_size, ax):
gc_content = lambda s: 100.0 * len([c for c in s if c in "GC"]) / len(s)
yy = [
gc_content(record.seq[i:i + window_size])
for i in range(len(record.seq) - window_size)
]
xx = np.arange(len(record.seq) - window_size) + 25
ax.fill_between(xx, yy, alpha=0.3)
ax.set_ylabel("GC(%)")
plot_local_gc_content(record, window_size=50, ax=ax2)
# Resize the figure to the right height
fig.tight_layout()
fig.savefig("with_plot.png")
def draw_features(rec):
from dna_features_viewer import BiopythonTranslator
graphic_record = BiopythonTranslator().translate_record(rec)
ax, _ = graphic_record.plot(figure_width=20)
plt.title(rec.id)
plt.show()
label = None
if f.type == "Mutagenesis":
label = f.qualifiers["Note"][0]
color = {
"Mutagenesis": "firebrick",
"Active site": "yellow",
"Beta strand": "lightyellow",
"Chain": "lightcyan",
"Helix": "honeydew",
"Initiator methionine": "white",
"Metal binding": "lightsteelblue",
"Turn": "moccasin",
}.get(f.type, "white")
return dict(color=color, label=label)
# GET THE RECORD FROM UNIPROT
response = urllib.request.urlopen("https://www.uniprot.org/uniprot/P0A7B8.gff")
record_file = StringIO(response.read().decode())
# TRANSLATE AND PLOT THE RECORD
translator = BiopythonTranslator(features_properties=features_properties)
graphic_record = translator.translate_record(record_file)
ax, _ = graphic_record.plot(
figure_width=15, max_label_length=100, elevate_outline_annotations=True,
)
ax.set_title("Mutation effects in P0A7B8", fontweight="bold", fontsize=16)
ax.figure.savefig("gff_record_from_the_web.png", bbox_inches="tight")
def compute_feature_label(self, f):
return BiopythonTranslator.compute_feature_label(f)[:20]
def work(self):
self.logger(message="Reading Data...")
data = self.data
must_contain = [
s.strip() for s in data.must_contain.split(',') if s.strip() != ''
]
must_not_contain = [
s.strip() for s in data.must_not_contain.split(',')
if s.strip() != ''
]
filter_feature_types = [f.lower() for f in data.keep_or_discard_types]
def feature_text(f):
return ", ".join([str(v) for v in f.qualifiers.values()])
def feature_filter(f):
ftype = f.type.lower()
keep = data.keep_or_discard == 'keep'
if filter_feature_types != []:
in_types = ftype in filter_feature_types
if (keep and not in_types) or (in_types and not keep):
return False
text = feature_text(f)
if len(must_contain) and not any([c in text
for c in must_contain]):
return False
if len(must_not_contain) and any(
[c in text for c in must_not_contain]):
return False
return True
def features_properties(f):
properties = {
'color': data.default_color,
'linewidth': data.default_thickness
}
if not data.default_display_label:
properties['label'] = None
ftype = f.type.lower()
for fl in data.custom_styles:
keep = fl.keep_or_discard == 'keep'
if (fl.selector == 'text'):
has_term = fl.feature_text in feature_text(f)
if (keep and has_term) or ((not keep) and (not has_term)):
properties['color'] = fl.color
properties['linewidth'] = fl.thickness
if fl.display_label:
properties.pop('label', '')
if (fl.selector == 'type'):
is_type = (ftype == fl.feature_type.lower())
if (keep and is_type) or ((not keep) and (not is_type)):
properties['color'] = fl.color
properties['linewidth'] = fl.thickness
if fl.display_label:
properties.pop('label', '')
return properties
display_class = {
'linear': GraphicRecord,
'circular': CircularGraphicRecord
}[data.display]
translator = BiopythonTranslator(
features_filters=(feature_filter, ),
features_properties=features_properties)
records = records_from_data_files(data.files)
figures = []
for rec in self.logger.iter_bar(record=records):
gr = translator.translate_record(rec, record_class=display_class)
if not data.plot_full_sequence:
gr = gr.crop((data.plot_from_position, data.plot_to_position))
ax, _ = gr.plot(figure_width=data.plot_width,
with_ruler=data.plot_ruler,
annotate_inline=data.inline_labels)
if data.plot_nucleotides:
gr.plot_sequence(ax)
figure = ax.figure
figure.suptitle(rec.id)
figures.append(figure)
if data.pdf_report:
pdf_io = BytesIO()
with PdfPages(pdf_io) as pdf:
for fig in figures:
pdf.savefig(fig, bbox_inches="tight")
pdf_data = ('data:application/pdf;base64,' +
b64encode(pdf_io.getvalue()).decode("utf-8"))
figures_data = {
'data': pdf_data,
'name': 'sequence_feature_plots.pdf',
'mimetype': 'application/pdf'
}
else:
figures_data = []
for _file, fig in zip(data.files, figures):
figdata = matplotlib_figure_to_svg_base64_data(
fig, bbox_inches="tight")
figures_data.append({
'img_data': figdata,
'filename': _file.name
})
return {
'pdf_report': None if not data.pdf_report else figures_data,
'figures_data': None if data.pdf_report else figures_data
}
"""
from Bio import Entrez, SeqIO
from dna_features_viewer import BiopythonTranslator
# DOWNLOAD THE PLASMID's RECORD FROM NCBI
Entrez.email = "*****@*****.**"
handle = Entrez.efetch(
db="nucleotide", id=1473096477, rettype="gb", retmode="text"
)
record = SeqIO.read(handle, "genbank")
# CREATE THE GRAPHIC RECORD WITH DNA_FEATURES_VIEWER
color_map = {
"rep_origin": "yellow",
"CDS": "orange",
"regulatory": "red",
"misc_recomb": "darkblue",
"misc_feature": "lightblue",
}
translator = BiopythonTranslator(
features_filters=(lambda f: f.type not in ["gene", "source"],),
features_properties=lambda f: {"color": color_map.get(f.type, "white")},
)
translator.max_line_length = 15
graphic_record = translator.translate_record(record)
ax, _ = graphic_record.plot(figure_width=8, strand_in_label_threshold=7)
ax.figure.savefig("translator_with_custom_colors.png", bbox_inches="tight")
def plot_sequence_sites(
sequence,
enzymes_names,
forbidden_enzymes=(),
unique_sites=True,
ax=None,
figure_width=18,
annotate_inline=True,
):
"""Plot the location of sites in the sequence.
Non-unique and forbidden sites can be highlighted in red.
Parameters
----------
sequence
The sequence of interest. ATGC string.
enzymes_names
List of names of the enzymes to plot.
forbidden_enzymes
The sites of these enzymes will also be plotted, but with a red
background.
unique_sites
If true, for each enzyme in enzyme_name with more than one site in
the sequence, these will be plotted on a red background.
ax
Matplotlib ax on which to draw the figure. If none is provided a new
figure is created and the ax is returned at the end.
figure_width
Width of the figure if no ax is provided and a new figure is returned.
annotate_inline
If True, the enzyme names will be written inside the annotations
when possible, instead of above.
"""
record = annotate_enzymes_sites(
sequence,
enzymes_names,
forbidden_enzymes=forbidden_enzymes,
unique_sites=unique_sites,
)
default_props = dict(
thickness=10,
box_color=None,
fontdict=dict(family="Impact", size=7, color="black", weight="normal"),
)
translator = BiopythonTranslator(
features_properties=lambda f: default_props)
graphic_record = translator.translate_record(record)
graphic_record.labels_spacing = 1
ax, _ = graphic_record.plot(figure_width=figure_width,
annotate_inline=annotate_inline,
ax=ax)
return ax
def generate_map():
record = SeqIO.read("Genome.gb", "genbank")
graphic_record = BiopythonTranslator().translate_record(record, record_class=CircularGraphicRecord)
graphic_record.labels_spacing = 20
ax, _ = graphic_record.plot(figure_width=15, figure_height=15, draw_line=True)
ax.figure.savefig("solution.jpg")
def full_assembly_report(
parts,
target,
enzyme="BsmBI",
max_assemblies=40,
connector_records=(),
include_fragments_plots="on_failure",
include_parts_plots="on_failure",
include_fragments_connection_graph="on_failure",
include_assembly_plots=True,
n_expected_assemblies=None,
no_skipped_parts=False,
fragments_filters="auto",
assemblies_prefix="assembly",
show_overhangs_in_graph=True,
show_overhangs_in_genbank=True,
mix_class="restriction",
):
"""Write a full assembly report in a folder or a zip.
The report contains the final sequence(s) of the assembly in Genbank format
as well as a .csv report on all assemblies produced and PDF figures
to allow a quick overview or diagnostic.
Folder ``assemblies`` contains the final assemblies, ``assembly_graph``
contains a schematic view of how the parts assemble together, folder
``fragments`` contains the details of all fragments produced by the enzyme
digestion, and folder ``provided_parts`` contains the original input
(genbanks of all parts provided for the assembly mix).
Parameters
----------
parts
List of Biopython records representing the parts, potentially on entry
vectors. All the parts provided should have different attributes ``name``
as it is used to name the files.
target
Either a path to a folder, or to a zip file, or ``@memory`` to return
a string representing zip data (the latter is particularly useful for
website backends).
enzyme
Name of the enzyme to be used in the assembly
max_assemblies
Maximal number of assemblies to consider. If there are more than this
the additional ones won't be returned.
fragments_filters
Fragments filters to be used to filter out fragments before looking for
assemblies. If left to auto, fragments containing the enzyme site will
be filtered out.
connector_records
List of connector records (a connector is a part that can bridge a gap
between two other parts), from which only the essential elements to form
an assembly will be automatically selected and added to the other parts.
assemblies_prefix
Prefix for the file names of all assemblies. They will be named
``PRE01.gb``,``PRE02.gb``, ``PRE03.gb`` where ``PRE`` is the prefix.
include_parts_plots, include_assembly_plots
These two parameters control the rendering of extra figures which are
great for troubleshooting, but not strictly necessary, and they slow
down the report generation considerably. They can be True, False, or
"on_failure" to be True only if the number of assemblies differs from
n_expected_assemblies
n_expected_assemblies
Expected number of assemblies. No exception is raised if this number is
not met, however, if parameters ``include_parts_plots`` and
``include_assembly_plots`` are set to "on_failure", then extra plots
will be plotted.
"""
# Make prefix Genbank friendly
assemblies_prefix = assemblies_prefix.replace(" ", "_")[:18]
if mix_class == "restriction":
mix_class = RestrictionLigationMix
part_names = [p.name for p in parts]
non_unique = [e for (e, count) in Counter(part_names).items() if count > 1]
non_unique = list(set(non_unique))
if len(non_unique) > 0:
raise ValueError("All parts provided should have different names. "
"Assembly (%s) contains several times the parts %s " %
(" ".join(part_names), ", ".join(non_unique)))
if fragments_filters == "auto":
fragments_filters = [NoRestrictionSiteFilter(enzyme)]
report = file_tree(target, replace=True)
assemblies_dir = report._dir("assemblies")
mix = mix_class(parts, enzyme, fragments_filters=fragments_filters)
if len(connector_records):
try:
mix.autoselect_connectors(connector_records)
except AssemblyError as err:
ax = mix.plot_slots_graph(
with_overhangs=show_overhangs_in_graph,
show_missing=True,
highlighted_parts=part_names,
)
f = report._file("parts_graph.pdf")
ax.figure.savefig(f.open("wb"), format="pdf", bbox_inches="tight")
plt.close(ax.figure)
# PLOT CONNEXIONS GRAPH (BIGGER, MORE INFOS)
ax = mix.plot_connections_graph()
f = report._file("connections_graph.pdf")
ax.figure.savefig(f.open("wb"), format="pdf", bbox_inches="tight")
plt.close(ax.figure)
raise err
# ASSEMBLIES
filters = (FragmentSetContainsPartsFilter(part_names), )
assemblies = mix.compute_circular_assemblies(
annotate_homologies=show_overhangs_in_genbank,
fragments_sets_filters=filters if no_skipped_parts else (),
)
assemblies = sorted(
[asm for (i, asm) in zip(range(max_assemblies), assemblies)],
key=lambda asm: str(asm.seq),
)
assemblies_data = []
i_asm = list(zip(range(max_assemblies), assemblies))
for i, asm in i_asm:
if len(i_asm) == 1:
name = assemblies_prefix
else:
name = "%s_%03d" % (assemblies_prefix, (i + 1))
asm.name = asm.id = name
assemblies_data.append(
dict(
assembly_name=name,
parts=" & ".join([name_fragment(f_) for f_ in asm.fragments]),
number_of_parts=len(asm.fragments),
assembly_size=len(asm),
))
write_record(asm, assemblies_dir._file(name + ".gb"), "genbank")
if include_assembly_plots:
gr_record = AssemblyTranslator().translate_record(asm)
ax, gr = gr_record.plot(figure_width=16)
ax.set_title(name)
ax.set_ylim(top=ax.get_ylim()[1] + 1)
ax.figure.savefig(
assemblies_dir._file(name + ".pdf").open("wb"),
format="pdf",
bbox_inches="tight",
)
plt.close(ax.figure)
is_failure = (len(assemblies)
== 0) or ((n_expected_assemblies is not None) and
(len(assemblies) != n_expected_assemblies))
if include_fragments_plots == "on_failure":
include_fragments_plots = is_failure
if include_parts_plots == "on_failure":
include_parts_plots = is_failure
if include_fragments_connection_graph == "on_failure":
include_fragments_connection_graph = is_failure
# PROVIDED PARTS
if include_parts_plots:
provided_parts_dir = report._dir("provided_parts")
for part in parts:
linear = record_is_linear(part, default=False)
ax, gr = plot_cuts(part, enzyme, linear=linear)
f = provided_parts_dir._file(part.name + ".pdf").open("wb")
ax.figure.savefig(f, format="pdf", bbox_inches="tight")
plt.close(ax.figure)
gb_file = provided_parts_dir._file(part.name + ".gb")
write_record(part, gb_file, "genbank")
# FRAGMENTS
if include_fragments_plots:
fragments_dir = report._dir("fragments")
seenfragments = defaultdict(lambda *a: 0)
for fragment in mix.fragments:
gr = BiopythonTranslator().translate_record(fragment)
ax, _ = gr.plot()
name = name_fragment(fragment)
seenfragments[name] += 1
file_name = "%s_%02d.pdf" % (name, seenfragments[name])
ax.figure.savefig(
fragments_dir._file(file_name).open("wb"),
format="pdf",
bbox_inches="tight",
)
plt.close(ax.figure)
# PLOT CONNEXIONS GRAPH (BIGGER, MORE INFOS)
if include_fragments_connection_graph:
ax = mix.plot_connections_graph()
f = report._file("connections_graph.pdf")
ax.figure.savefig(f.open("wb"), format="pdf", bbox_inches="tight")
plt.close(ax.figure)
graph = mix.slots_graph(with_overhangs=False)
slots_dict = {
s: "|".join(list(pts))
for s, pts in mix.compute_slots().items()
}
non_linear_slots = [(slots_dict[n],
"|".join([slots_dict[b] for b in graph.neighbors(n)]))
for n in graph.nodes() if graph.degree(n) != 2]
# PLOT SLOTS GRAPH
if len(connector_records):
highlighted_parts = part_names
else:
highlighted_parts = []
ax = mix.plot_slots_graph(
with_overhangs=show_overhangs_in_graph,
show_missing=True,
highlighted_parts=highlighted_parts,
)
f = report._file("parts_graph.pdf")
ax.figure.savefig(f.open("wb"), format="pdf", bbox_inches="tight")
plt.close(ax.figure)
if len(non_linear_slots):
report._file("non_linear_nodes.csv").write(
"\n".join(["part,neighbours"] + [
"%s,%s" % (part, neighbours)
for part, neighbours in non_linear_slots
]))
df = pandas.DataFrame.from_records(
assemblies_data,
columns=["assembly_name", "number_of_parts", "assembly_size", "parts"],
)
df.to_csv(report._file("report.csv").open("w"), index=False)
n_constructs = len(df)
if target == "@memory":
return n_constructs, report._close()
else:
if isinstance(target, str):
report._close()
return n_constructs
from Bio import SeqIO
import numpy as np
def plot_local_gc_content(record, window_size, ax):
"""Plot windowed GC content on a designated Matplotlib ax."""
def gc_content(s):
return 100.0 * len([c for c in s if c in "GC"]) / len(s)
yy = [
gc_content(record.seq[i : i + window_size])
for i in range(len(record.seq) - window_size)
]
xx = np.arange(len(record.seq) - window_size) + 25
ax.fill_between(xx, yy, alpha=0.3)
ax.set_ylim(bottom=0)
ax.set_ylabel("GC(%)")
record = SeqIO.read("example_sequence.gb", "genbank")
translator = BiopythonTranslator()
graphic_record = translator.translate_record(record)
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 5), sharex=True)
ax, levels = graphic_record.plot()
graphic_record.plot(ax=ax1, with_ruler=False)
plot_local_gc_content(record, window_size=50, ax=ax2)
fig.tight_layout() # Resize the figure to the right height
fig.savefig("with_gc_plot.png")
def compute_feature_label(self, feature):
if "homology" in str(feature.qualifiers.get("label", '')):
return None
else:
return BiopythonTranslator.compute_feature_label(feature)
def test_from_record(tmpdir):
record = load_record(example_genbank)
annotate_biopython_record(record, label="bla", color="blue")
graphic_record = BiopythonTranslator().translate_record(record)
assert len(graphic_record.features) == 12
