# HG changeset patch
# User cpt
# Date 1685933131 0
# Node ID e923c686ead9f53d9f4e390668fb60a905cca5fe
# Parent 621754dd31f891e3714aeff4f57fc393b881b9f2
planemo upload commit 94b0cd1fff0826c6db3e7dc0c91c0c5a8be8bb0c
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BiopythonTranslator.py
--- a/cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BiopythonTranslator.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,130 +0,0 @@
-from .BiopythonTranslatorBase import BiopythonTranslatorBase
-
-
-class BiopythonTranslator(BiopythonTranslatorBase):
- """A translator from SeqRecords to dna_features_viewer GraphicRecord.
-
- This can be subclassed to create custom "themes" (see the example
- ``custom_biopython_translator.py`` in the docs).
-
- This class is meant to be customized by subclassing and changing the
- methods (``compute_feature_label``, etc.) and/or the attributes
- (``default_feature_color`` etc).
-
- Attributes
- ----------
-
- default_feature_color = "#7245dc"
- graphic_record_parameters
- Dictionnary containing keyword arguments that will be passed to the
- (Circular)GraphicRecord constructor
-
- ignored_features_types
- A list or tuple of strings indicating all the feature types that should
- always be ignored (i.e. not included in the graphic record) by the
- translator
-
- label_fields
- This list of strings provides the order in which the different
- attributes of a Genbank feature will be considered, when automatically
- determining the feature label. For instance if the list is
- ["label", "source", "locus_tag"] and a feature has no label but has a
- "source", the "source" will be displayed in the plots.
-
- Parameters
- ----------
-
- features_filters
- List of filters (some_biopython_feature) => True/False.
- Only features passing all the filters are kept.
- This only works if you haven't redefined ``compute_filtered_features``
-
- features_properties
- A function (feature)=> properties_dict
-
- """
-
- default_feature_color = "#7245dc"
- ignored_features_types = ()
- label_fields = [
- "label",
- "name",
- "gene",
- "product",
- "source",
- "locus_tag",
- "note",
- ]
-
- def __init__(self, features_filters=(), features_properties=None):
- self.features_filters = features_filters
- self.features_properties = features_properties
-
- def compute_feature_color(self, feature):
- """Compute a color for this feature.
-
- If the feature has a ``color`` qualifier it will be used. Otherwise,
- the classe's ``default_feature_color`` is used.
-
- To change the behaviour, create a subclass of ``BiopythonTranslator``
- and overwrite this method.
- """
- if "color" in feature.qualifiers:
- color = feature.qualifiers["color"]
- if isinstance(color[0], str):
- return "".join(feature.qualifiers["color"])
- else:
- return color
- else:
- return self.default_feature_color
-
- def compute_feature_fontdict(self, feature):
- """Compute a font dict for this feature."""
- return None
-
- def compute_feature_box_linewidth(self, feature):
- """Compute a box_linewidth for this feature."""
- return 0.3
-
- def compute_feature_box_color(self, feature):
- """Compute a box_color for this feature."""
- return "auto"
-
- def compute_feature_label_link_color(self, feature):
- """Compute the color of the line linking the label to its feature."""
- return "black"
-
- def compute_filtered_features(self, features):
- """Return the list of features minus the ignored ones.
-
- By the method keeps any feature whose type is not in
- ignored_features_types and for which all filter(f) pass
- """
- return [
- f
- for f in features
- if all([fl(f) for fl in self.features_filters])
- and f.type not in self.ignored_features_types
- ]
-
- def compute_feature_label(self, feature):
- """Compute the label of the feature."""
- label = feature.type
- for key in self.label_fields:
- if key in feature.qualifiers and len(feature.qualifiers[key]):
- label = feature.qualifiers[key]
- break
- if isinstance(label, list):
- label = "|".join(label)
- return label
-
- def compute_feature_linewidth(self, feature):
- """Compute the edge width of the feature's arrow/rectangle."""
- return 1.0
-
- def compute_feature_legend_text(self, feature):
- return None
-
- def compute_feature_html(self, feature):
- """Gets the 'label' of the feature."""
- return self.compute_feature_label(feature)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BiopythonTranslatorBase.py
--- a/cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BiopythonTranslatorBase.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,119 +0,0 @@
-from ..biotools import load_record
-from ..GraphicRecord import GraphicRecord
-from ..CircularGraphicRecord import CircularGraphicRecord
-from ..GraphicFeature import GraphicFeature
-
-
-class BiopythonTranslatorBase:
- """Base class for all BiopythonTranslators.
-
- This class needs to be complemented with methods compute_feature_label,
- compute_features_color, etc. to be usable. See BiopythonTranslator for
- an example of minimal working subclass.
-
- Parameters
- ----------
-
- features_filters
- List of filters (some_biopython_feature) => True/False.
- Only features passing all the filters are kept.
- This only works if you haven't redefined ``compute_filtered_features``
-
- features_properties
- A function (feature)=> properties_dict
-
- """
- graphic_record_parameters = {}
-
- def __init__(self, features_filters=(), features_properties=None):
- self.features_filters = features_filters
- self.features_properties = features_properties
-
- def translate_feature(self, feature):
- """Translate a Biopython feature into a Dna Features Viewer feature."""
- properties = dict(
- label=self.compute_feature_label(feature),
- color=self.compute_feature_color(feature),
- html=self.compute_feature_html(feature),
- fontdict=self.compute_feature_fontdict(feature),
- box_linewidth=self.compute_feature_box_linewidth(feature),
- box_color=self.compute_feature_box_color(feature),
- linewidth=self.compute_feature_linewidth(feature),
- label_link_color=self.compute_feature_label_link_color(feature),
- legend_text=self.compute_feature_legend_text(feature)
- )
- if self.features_properties is not None:
- other_properties = self.features_properties
- if hasattr(other_properties, '__call__'):
- other_properties = other_properties(feature)
- properties.update(other_properties)
-
- return GraphicFeature(
- start=feature.location.start,
- end=feature.location.end,
- strand=feature.location.strand,
- **properties
- )
-
- def translate_record(self, record, record_class=None):
- """Create a new GraphicRecord from a BioPython Record object.
-
- Parameters
- ----------
-
- record
- A BioPython Record object or the path to a Genbank or a GFF file.
-
- record_class
- The graphic record class to use, e.g. GraphicRecord (default) or
- CircularGraphicRecord. Strings 'circular' and 'linear' can also be
- provided.
- """
- classes = {
- "linear": GraphicRecord,
- "circular": CircularGraphicRecord,
- None: GraphicRecord,
- }
- if record_class in classes:
- record_class = classes[record_class]
-
- if isinstance(record, str) or hasattr(record, 'read'):
- record = load_record(record)
- filtered_features = self.compute_filtered_features(record.features)
- return record_class(
- sequence_length=len(record),
- sequence=str(record.seq),
- features=[
- self.translate_feature(feature)
- for feature in filtered_features
- if feature.location is not None
- ],
- **self.graphic_record_parameters
- )
-
- @classmethod
- def quick_class_plot(cls, record, figure_width=12, **kwargs):
- """Allows super quick and dirty plotting of Biopython records.
-
- This is really meant for use in a Jupyter/Ipython notebook with
- the "%matplotlib inline" setting.
-
- >>> from dna_features_viewer import BiopythonTranslator
- >>> BiopythonTranslator.quick_plot(my_record)
- """
- graphic_record = cls().translate_record(record)
- ax, _ = graphic_record.plot(figure_width=figure_width, **kwargs)
- return ax
-
- def quick_plot(self, record, figure_width=12, **kwargs):
- """Allows super quick and dirty plotting of Biopython records.
-
- This is really meant for use in a Jupyter/Ipython notebook with
- the "%matplotlib inline" setting.
-
- >>> from dna_features_viewer import BiopythonTranslator
- >>> BiopythonTranslator.quick_plot(my_record)
- """
- graphic_record = self.translate_record(record)
- ax, _ = graphic_record.plot(figure_width=figure_width, **kwargs)
- return ax
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BlackBoxlessLabelTranslator.py
--- a/cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/BlackBoxlessLabelTranslator.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-from .BiopythonTranslator import BiopythonTranslator
-
-class BlackBoxlessLabelTranslator(BiopythonTranslator):
- """Translates Biopython records into GraphicRecords where annotations
- appear black on a white background with no box. Which can be cleaner."""
-
- def compute_feature_box_linewidth(self, feature):
- """Return 0 as this translator doesn't show a box."""
- return 0
-
- def compute_feature_box_color(self, feature):
- """Return white."""
- return "white"
\ No newline at end of file
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/__init__.py
--- a/cpt_linear_genome_plot/dna_features_viewer/BiopythonTranslator/__init__.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-from .BiopythonTranslator import BiopythonTranslator
-from .BlackBoxlessLabelTranslator import BlackBoxlessLabelTranslator
-
-__all__ = ["BiopythonTranslator", "BlackBoxlessLabelTranslator"]
\ No newline at end of file
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/ArrowWedge.py
--- a/cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/ArrowWedge.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,110 +0,0 @@
-"""Implements the missing Matplotlib ArrowWedge patch class.
-
-This is a plain arrow curved alongside a protion of circle, like you would
-expect a circular genetic feature to look.
-"""
-import numpy as np
-import matplotlib.patches as mpatches
-
-
-class ArrowWedge(mpatches.Wedge):
- """Matplotlib patch shaped as a tick fraction of circle with a pointy end.
-
- This is the patch used by CircularGraphicRecord to draw features.
-
- Parameters
- ----------
-
- center
- Center of the circle around which the arrow-wedge is drawn.
-
- radius
- Radius of the circle around which the arrow-wedge is drawn.
-
- theta1
- Start angle of the wedge
-
- theta2
- End angle of the wedge
-
- width
- Width or thickness of the arrow-wedge.
-
- direction
- Determines whether the pointy end points in direct sense (+1) or
- indirect sense (-1) or no sense at all (0)
- """
-
- def __init__(
- self, center, radius, theta1, theta2, width, direction=+1, **kwargs
- ):
-
- self.direction = direction
- self.radius = radius
- mpatches.Wedge.__init__(
- self, center, radius, theta1, theta2, width, **kwargs
- )
- self._recompute_path()
-
- def _recompute_path(self):
- """Recompute the full path forming the "tick" arrowed wedge
-
- This method overwrites "mpatches.Wedge._recompute_path" in the
- super-class.
- """
-
- if self.direction not in [-1, +1]:
- return mpatches.Wedge._recompute_path(self)
-
- theta1, theta2 = self.theta1, self.theta2
- arrow_angle = min(5, abs(theta2 - theta1) / 2)
- normalized_arrow_width = self.width / 2.0 / self.radius
- if self.direction == +1:
- angle_start_arrow = theta1 + arrow_angle
- arc = mpatches.Path.arc(angle_start_arrow, theta2)
- outer_arc = arc.vertices[::-1] * (1 + normalized_arrow_width)
- inner_arc = arc.vertices * (1 - normalized_arrow_width)
- arrow_vertices = [
- outer_arc[-1],
- np.array(
- [np.cos(np.deg2rad(theta1)), np.sin(np.deg2rad(theta1))]
- ),
- inner_arc[0],
- ]
- else:
- angle_start_arrow = theta2 - arrow_angle
- arc = mpatches.Path.arc(theta1, angle_start_arrow)
- outer_arc = (
- arc.vertices * (self.radius + self.width / 2.0) / self.radius
- )
- inner_arc = (
- arc.vertices[::-1]
- * (self.radius - self.width / 2.0)
- / self.radius
- )
- arrow_vertices = [
- outer_arc[-1],
- np.array(
- [np.cos(np.deg2rad(theta2)), np.sin(np.deg2rad(theta2))]
- ),
- inner_arc[0],
- ]
- p = np.vstack([outer_arc, arrow_vertices, inner_arc])
-
- path_vertices = np.vstack([p, inner_arc[-1, :], (0, 0)])
-
- path_codes = np.hstack(
- [
- arc.codes,
- 4 * [mpatches.Path.LINETO],
- arc.codes[1:],
- mpatches.Path.LINETO,
- mpatches.Path.CLOSEPOLY,
- ]
- )
- path_codes[len(arc.codes)] = mpatches.Path.LINETO
-
- # Shift and scale the wedge to the final location.
- path_vertices *= self.r
- path_vertices += np.asarray(self.center)
- self._path = mpatches.Path(path_vertices, path_codes)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/CircularGraphicRecord.py
--- a/cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/CircularGraphicRecord.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,171 +0,0 @@
-"""Implements the CircularGraphicRecord class.
-"""
-
-import matplotlib.patches as mpatches
-import numpy as np
-
-from ..GraphicRecord import GraphicRecord
-from .ArrowWedge import ArrowWedge
-
-
-class CircularGraphicRecord(GraphicRecord):
- """Set of Genetic Features of a same DNA sequence, to be plotted together.
-
- Parameters
- ----------
-
- sequence_length
- Length of the DNA sequence, in number of nucleotides
-
- features
- list of GraphicalFeature objects.
-
- top_position
- The index in the sequence that will end up at the top of the circle
-
- feature_level_height
- Width in inches of one "level" for feature arrows.
-
- annotation_height
- Width in inches of one "level" for feature annotations.
-
- labels_spacing
- Distance in basepairs to keep between labels to avoid "quasi-collisions"
-
- **kw
- Other keyword arguments - do not use, these parameters are allowed for
- making it easier to use GraphicRecord and CircularGraphicRecord
- interchangeably.
-
- """
-
- default_elevate_outline_annotations = True
- min_y_height_of_text_line = 0.1
-
- def __init__(
- self,
- sequence_length,
- features,
- top_position=0,
- feature_level_height=0.2,
- annotation_height="auto",
- labels_spacing=12,
- **kw
- ):
-
- self.radius = 1.0
- self.sequence_length = sequence_length
- self.features = features
- self.top_position = top_position
- self.feature_level_height = feature_level_height
- self.annotation_height = annotation_height
- self.labels_spacing = labels_spacing
-
- def initialize_ax(self, ax, draw_line, with_ruler):
- """Initialize the ax with a circular line, sets limits, aspect etc.
- """
-
- if draw_line:
- circle = mpatches.Circle(
- (0, -self.radius), self.radius, facecolor="none", edgecolor="k"
- )
- ax.add_patch(circle)
- ax.axis("off")
- if with_ruler:
- # only display the xaxis ticks
- ax.set_frame_on(False)
- ax.yaxis.set_visible(False)
- ax.xaxis.tick_bottom()
- else:
- # don't display anything
- ax.axis("off")
-
- ax.set_xlim(-1.1 * self.radius, 1.1 * self.radius)
- ax.set_ylim(-self.radius, 3 * self.radius)
- ax.set_aspect("equal")
-
- def finalize_ax(
- self,
- ax,
- features_levels,
- annotations_max_level,
- auto_figure_height=False,
- ideal_yspan=None,
- annotations_are_elevated=True
- ):
- """Final display range and figure dimension tweakings."""
- annotation_height = self.determine_annotation_height(
- annotations_max_level
- )
- ymin = -2 * self.radius - self.feature_level_height * (
- features_levels + 1
- )
- ymax = (
- self.feature_level_height * (features_levels + 1)
- + annotation_height * (annotations_max_level + 1)
- )
- if ideal_yspan is not None:
- ymax = max(annotation_height * ideal_yspan + ymin, ymax)
- xmin = -self.radius - self.feature_level_height * (features_levels + 1)
- xmax = -xmin
- ax.set_xlim(xmin, xmax)
- ax.set_ylim(ymin, ymax)
- ratio = 1.0 * (ymax - ymin) / (xmax - xmin)
-
- if auto_figure_height:
- figure_width = ax.figure.get_size_inches()[0]
- ax.figure.set_size_inches(figure_width, figure_width * ratio)
-
- def plot_feature(self, ax, feature, level):
- """Plot an ArrowWedge representing the feature at the giben height
- level.
-
-
- """
- a_start = self.position_to_angle(feature.start)
- a_end = self.position_to_angle(feature.end)
- a_start, a_end = sorted([a_start, a_end])
- r = self.radius + level * self.feature_level_height
- patch = ArrowWedge(
- center=(0, -self.radius),
- radius=r,
- theta1=a_start,
- theta2=a_end,
- width=0.7 * self.feature_level_height,
- direction=feature.strand,
- edgecolor=feature.linecolor,
- linewidth=feature.linewidth,
- facecolor=feature.color,
- zorder=1,
- )
- ax.add_patch(patch)
-
- def position_to_angle(self, position):
- """Convert a sequence position into an angle in the figure."""
- a = 360.0 * (position - self.top_position) / self.sequence_length
- return 90 - a
-
- def coordinates_in_plot(self, position, level):
- """Convert a sequence position and height level to (x, y) coordinates.
- """
- r = self.radius + level * self.feature_level_height
- angle = self.position_to_angle(position)
- rad_angle = np.deg2rad(angle)
- return np.array(
- [r * np.cos(rad_angle), r * np.sin(rad_angle) - self.radius]
- )
-
- def determine_annotation_height(self, max_annotations_level):
- """Auto-select the annotations height.
-
- Annotation height is 0.2 at most, or else whatever will make
- the figure a 5*radius tall rectangle where the circular plasmid
- occupies the bottom-2 5th and the annotations occupy the top-3 5th.
- """
- return min(0.25, 3.0 * self.radius / (1.0 + max_annotations_level))
-
- def compute_padding(self, ax):
- ""
- ax_width = ax.get_window_extent(ax.figure.canvas.get_renderer()).width
- xmin, xmax = ax.get_xlim()
- return 3 * self.labels_spacing * (xmax - xmin) / (1.0 * ax_width)
\ No newline at end of file
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/__init__.py
--- a/cpt_linear_genome_plot/dna_features_viewer/CircularGraphicRecord/__init__.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-from .CircularGraphicRecord import CircularGraphicRecord
-
-__all__ = ["CircularGraphicRecord"]
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicFeature.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicFeature.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,162 +0,0 @@
-from copy import deepcopy
-
-class GraphicFeature:
- """Genetic Feature to be plotted.
-
- Parameters
- ----------
-
- start, end
- Coordinates of the feature in the final sequence.
-
- strand
- Directionality of the feature. can be +1/-1/0 for direct sense,
- anti-sense, or no directionality.
-
- label
- Short descriptive text associated and plotted with the feature
-
- color
- Color of the feature, any Matplotlib-compatible format is accepted,
- such as "white", "w", "#ffffff", (1,1,1), etc.
-
- linecolor
- Color of the feature's border, any Matplotlib-compatible format is
- accepted, such as "white", "w", "#ffffff", (1,1,1), etc.
-
- linewidth
- Width of the line (=edge) surrounding the graphic feature, in pixels.
-
- thickness
- Vertical span of the feature
-
- box_color
- Color of the label box. Set to None for no box around the label.
- Leave to "auto" for a box color that is a lightened version of the
- feature's color.
-
- data
- Any other keyword is kept into the feature.data[] dictionary.
-
- fontdict
- A Matplotlib fontdict for the font to be used in the label, e.g.
- ``size=11``, ``weight='bold'``, ``family='Helvetica'``, etc.
-
- open_left, open_right
- Set to True if this feature does not end on the right or left because it
- is a cropped version of a bigger feature.
-
- box_linewidth
- Width of the line delimiting the text box when the annotation is outside
- the graphic feature. Set to 0 for no box borders
-
- box_color
- Background color of the annotation's text box. If left to "auto" the
- color will be a lighter version of the feature's color.
-
- label_link_color
- Color of the line linking the text annotation to its respective graphic
- feature. Set to auto for the line to automatically be a darker version
- of the feature's color.
- """
-
- feature_type = "feature"
-
- def __init__(
- self,
- start=None,
- end=None,
- strand=None,
- label=None,
- color="#000080",
- thickness=14,
- linewidth=1.0,
- linecolor="#000000",
- fontdict=None,
- html=None,
- open_left=False,
- open_right=False,
- box_linewidth=1,
- box_color="auto",
- legend_text=None,
- label_link_color="black",
- **data
- ):
- self.start = start
- self.end = end
- self.strand = strand
- self.label = label
- self.color = color
- self.linecolor = linecolor
- self.data = data
- self.thickness = thickness
- self.linewidth = linewidth
- self.box_linewidth = box_linewidth
- self.box_color = box_color
- self.label_link_color = label_link_color
- self.fontdict = dict(
- [("fontsize", 11)] + list((fontdict or {}).items())
- )
- self.html = html
- self.open_left = open_left
- self.open_right = open_right
- self.legend_text = legend_text
-
- def split_in_two(self, x_coord=0):
- """Return two features by cutting this feature at x_coord."""
- copy1 = deepcopy(self)
- copy2 = deepcopy(self)
- copy1.end = x_coord
- copy2.start = x_coord + 1
- return copy1, copy2
-
- def crop(self, window):
- """Return a the fragment of the feature that is in the window.
-
- If there is no overlap between the feature location and the window,
- None is returned.
- """
- s, e = window
- if (s > self.end) or (e < self.start):
- return None
- copy = deepcopy(self)
- if s > self.start:
- copy.start = s
- copy.open_left = True
- if e < self.end:
- copy.end = e
- copy.open_right = True
- return copy
-
- def overlaps_with(self, other):
- """Return whether the feature's location overlaps with feature `other`
- """
- loc1, loc2 = (self.start, self.end), (other.start, other.end)
- loc1, loc2 = sorted(loc1), sorted(loc2)
- loc1, loc2 = sorted([loc1, loc2], key=lambda loc: loc[0])
- return loc1[1] > loc2[0]
-
- @property
- def length(self):
- """Return the length of the feature (end-start)"""
- return abs(self.end - self.start)
-
- @property
- def x_center(self):
- """Return the x-center of the feature, (start+end)/2"""
- return 0.5 * (self.start + self.end - 1)
-
- @staticmethod
- def from_biopython_feature(feature, **props):
- """Create a GraphicalFeature from a Biopython.Feature object."""
- return GraphicFeature(
- start=feature.location.start,
- end=feature.location.end,
- strand=feature.location.strand,
- **props
- )
-
- def __repr__(self):
- return ("GF(%(label)s, %(start)d-%(end)d " % self.__dict__) + (
- ")" if self.strand is None else "(%d))" % self.strand
- )
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/BokehPlottableMixin.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/BokehPlottableMixin.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,174 +0,0 @@
-try:
- from bokeh.plotting import figure, ColumnDataSource
- from bokeh.models import Range1d, HoverTool
-
- BOKEH_AVAILABLE = True
-except ImportError:
- BOKEH_AVAILABLE = False
-
-try:
- import pandas as pd
-
- PANDAS_AVAILABLE = True
-except ImportError:
- PANDAS_AVAILABLE = False
-
-import matplotlib.pyplot as plt
-
-
-class BokehPlottableMixin:
- def bokeh_feature_patch(
- self,
- start,
- end,
- strand,
- figure_width=5,
- width=0.4,
- level=0,
- arrow_width_inches=0.05,
- **kwargs
- ):
- """Return a dict with points coordinates of a Bokeh Feature arrow.
-
- Parameters
- ----------
-
- start, end, strand
-
- """
- hw = width / 2.0
- x1, x2 = (start, end) if (strand >= 0) else (end, start)
- bp_per_width = figure_width / self.sequence_length
- delta = arrow_width_inches / bp_per_width
- if strand >= 0:
- head_base = max(x1, x2 - delta)
- else:
- head_base = min(x1, x2 + delta)
- result = dict(
- xs=[x1, x1, head_base, x2, head_base, x1],
- ys=[e + level for e in [-hw, hw, hw, 0, -hw, -hw]],
- )
- result.update(kwargs)
- return result
-
- def plot_with_bokeh(self, figure_width=5, figure_height="auto", tools="auto"):
- """Plot the graphic record using Bokeh.
-
- Examples
- --------
-
- >>>
-
-
- """
- if not BOKEH_AVAILABLE:
- raise ImportError("``plot_with_bokeh`` requires Bokeh installed.")
- if not PANDAS_AVAILABLE:
- raise ImportError("``plot_with_bokeh`` requires Pandas installed.")
-
- # Set up default tools
- if tools == "auto":
- tools = [HoverTool(tooltips="@hover_html"), "xpan,xwheel_zoom,reset,tap"]
-
- # FIRST PLOT WITH MATPLOTLIB AND GATHER INFOS ON THE PLOT
- ax, (features_levels, plot_data) = self.plot(figure_width=figure_width)
- width, height = [int(100 * e) for e in ax.figure.get_size_inches()]
- plt.close(ax.figure)
- if figure_height == "auto":
- height = int(0.5 * height)
- else:
- height = 100 * figure_height
- height = max(height, 185) # Minimal height to see all icons
-
- max_y = max(
- [data["annotation_y"] for f, data in plot_data.items()]
- + list(features_levels.values())
- )
-
- # BUILD THE PLOT ()
- plot = figure(
- plot_width=width,
- plot_height=height,
- tools=tools,
- x_range=Range1d(0, self.sequence_length),
- y_range=Range1d(-1, max_y + 1),
- )
- plot.patches(
- xs="xs",
- ys="ys",
- color="color",
- line_color="#000000",
- source=ColumnDataSource(
- pd.DataFrame.from_records(
- [
- self.bokeh_feature_patch(
- feature.start,
- feature.end,
- feature.strand,
- figure_width=figure_width,
- level=level,
- color=feature.color,
- label=feature.label,
- hover_html=(
- feature.html
- if feature.html is not None
- else feature.label
- ),
- )
- for feature, level in features_levels.items()
- ]
- )
- ),
- )
-
- if plot_data != {}:
- plot.text(
- x="x",
- y="y",
- text="text",
- text_align="center",
- text_font_size="12px",
- text_font="arial",
- text_font_style="normal",
- source=ColumnDataSource(
- pd.DataFrame.from_records(
- [
- dict(
- x=feature.x_center,
- y=pdata["annotation_y"],
- text=feature.label,
- color=feature.color,
- )
- for feature, pdata in plot_data.items()
- ]
- )
- ),
- )
- plot.segment(
- x0="x0",
- x1="x1",
- y0="y0",
- y1="y1",
- line_width=0.5,
- color="#000000",
- source=ColumnDataSource(
- pd.DataFrame.from_records(
- [
- dict(
- x0=feature.x_center,
- x1=feature.x_center,
- y0=pdata["annotation_y"],
- y1=pdata["feature_y"],
- )
- for feature, pdata in plot_data.items()
- ]
- )
- ),
- )
-
- plot.yaxis.visible = False
- plot.outline_line_color = None
- plot.grid.grid_line_color = None
- plot.toolbar.logo = None
-
- return plot
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/GraphicRecord.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/GraphicRecord.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,199 +0,0 @@
-from ..biotools import find_narrowest_text_wrap
-
-from Bio.Seq import Seq
-from Bio.SeqRecord import SeqRecord
-from Bio.SeqFeature import FeatureLocation, SeqFeature
-from Bio.Alphabet import DNAAlphabet
-
-from .MatplotlibPlottableMixin import MatplotlibPlottableMixin
-from .BokehPlottableMixin import BokehPlottableMixin
-
-
-class GraphicRecord(MatplotlibPlottableMixin, BokehPlottableMixin):
- """Set of Genetic Features of a same DNA sequence, to be plotted together.
-
- Parameters
- ----------
-
- sequence_length
- Length of the DNA sequence, in number of nucleotides
-
- features
- list of GraphicalFeature objects.
-
- feature_level_height
- Width in inches of one "level" for feature arrows.
-
- annotation_height
- Width in inches of one "level" for feature annotations.
-
- first_index
- Indicates the first index to plot in case the sequence is actually a
- subsequence of a larger one. For instance, if the Graphic record
- represents the segment (400, 420) of a sequence, we will have
- ``first_index=400`` and ``sequence_length=20``.
-
- plots_indexing
- Indicates which standard to use to show nucleotide indices in the plots.
- If 'biopython', the standard python indexing is used (starting at 0).
- If 'genbank', the indexing follows the Genbank standard (starting at 1).
-
- labels_spacing
- Number of pixels that will "pad" every labels to force some horizontal
- space between two labels or between a label and the borders of a feature.
-
- ticks_resolution
- Leave to "auto" for an auto-selected number of ticks on the ruler, or set
- to e.g. 50 for a tick every 50 nucleotide.
-
- Attributes
- ----------
-
- default_font_family
- Default font to use for a feature that doesn't declare a font.
-
- default_ruler_color
- Default ruler color to use when no color is given at plot() time.
-
- default_box_color
- Default box color for non-inline annotations. If set to None, no
- boxes will be drawn unless the features declare a box_color.
- If "auto", a color (clearer version of the feature's color) will be
- computed, for all features also declaring their box_color as "auto".
-
- default_elevate_outline_annotations
- Value to use for elevate_outline_annotations when no specific value is
- given at ``graphic_record.plot(...)`` time. Set to true to have all
- text annotations appears above all features, or false else.
- """
-
- default_font_family = None
- default_ruler_color = "grey"
- default_box_color = "auto"
- min_y_height_of_text_line = 0.5
-
- def __init__(
- self,
- sequence_length=None,
- sequence=None,
- features=(),
- feature_level_height=1,
- first_index=0,
- plots_indexing="biopython",
- labels_spacing=8,
- ticks_resolution='auto'
- ):
- if sequence_length is None:
- sequence_length = len(sequence)
- self.features = features
- self.sequence_length = sequence_length
- self.feature_level_height = feature_level_height
- self.sequence = sequence
- self.first_index = first_index
- self.plots_indexing = plots_indexing
- self.labels_spacing = labels_spacing
- self.ticks_resolution = ticks_resolution
-
- @property
- def last_index(self):
- return self.first_index + self.sequence_length
-
- @property
- def span(self):
- """Return the display span (start, end) accounting for first_index."""
- return self.first_index, self.last_index
-
- def to_biopython_record(self, sequence):
- """
- Example
- -------
- from Bio import SeqIO
- gr_record = GraphicRecord(features=features, sequence_length=len(seq),
- sequence=seq)
- bio_record = gr_record.to_biopython_record()
- with open("example.gb", "w+") as f:
- SeqIO.write(record, f, "genbank")
- """
- features = [
- SeqFeature(
- FeatureLocation(f.start, f.end, f.strand),
- type=f.feature_type,
- qualifiers={"label": f.label},
- )
- for f in self.features
- ]
- if not isinstance(sequence, Seq):
- sequence = Seq(sequence, alphabet=DNAAlphabet())
- return SeqRecord(seq=sequence, features=features)
-
- def crop(self, window):
- start, end = window
- first_index = self.first_index
- if (start < first_index) or (end > self.last_index):
- raise ValueError("out-of-bound cropping")
- new_features = []
- for f in self.features:
- cropped_feature = f.crop(window)
- if cropped_feature is not None: # = has ovelap with the window
- new_features.append(cropped_feature)
-
- return GraphicRecord(
- sequence=self.sequence[start - first_index : end - first_index]
- if self.sequence is not None
- else None,
- sequence_length=end - start,
- features=new_features,
- feature_level_height=self.feature_level_height,
- first_index=start,
- plots_indexing=self.plots_indexing,
- labels_spacing=self.labels_spacing,
- ticks_resolution=self.ticks_resolution
- )
-
- def determine_annotation_height(self, levels):
- """By default the ideal annotation level height is the same as the
- feature_level_height."""
- # TODO: Improve me! ideally, annotation width would be linked to the
- # height of one line of text, so dependent on font size and ax
- # height/span.
- return self.feature_level_height
-
- def coordinates_in_plot(self, x, level):
- """Convert a sequence position and height level into a (x, y) position.
- """
- return (x, level * self.feature_level_height)
-
- def split_overflowing_features_circularly(self):
- """Split the features that overflow over the edge for circular
- constructs (inplace)."""
- new_features = []
- for f in self.features:
- if f.start < 0 < f.end:
- f1, f2 = f.split_in_two(-1)
- f1.start, f1.end = (
- f1.start + self.sequence_length,
- f1.end + self.sequence_length,
- )
- new_features += [f1, f2]
- elif f.start < self.sequence_length < f.end:
- f1, f2 = f.split_in_two(self.sequence_length - 1)
- f2.start, f2.end = (
- f2.start - self.sequence_length,
- f2.end - self.sequence_length,
- )
- new_features += [f1, f2]
- else:
- new_features.append(f)
- self.features = new_features
-
- def _format_label(self, label, max_label_length=50, max_line_length=40):
- if len(label) > max_label_length:
- label = label[: max_label_length - 1] + "…"
- if len(label) > max_line_length:
- label = find_narrowest_text_wrap(label, max_line_length)
- return label
-
- def compute_padding(self, ax):
- ax_width = ax.get_window_extent(ax.figure.canvas.get_renderer()).width
- xmin, xmax = ax.get_xlim()
- return self.labels_spacing * (xmax - xmin) / (1.0 * ax_width)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/MatplotlibPlottableMixin.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/MatplotlibPlottableMixin.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,651 +0,0 @@
-"""Useful functions for the library"""
-
-import colorsys
-
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-from matplotlib.patches import Patch
-import matplotlib.ticker as ticker
-
-from ..compute_features_levels import compute_features_levels
-from ..GraphicFeature import GraphicFeature
-from matplotlib.colors import colorConverter
-from .MultilinePlottableMixin import MultilinePlottableMixin
-from .SequenceAndTranslationMixin import SequenceAndTranslationMixin
-
-
-class MatplotlibPlottableMixin(
- MultilinePlottableMixin, SequenceAndTranslationMixin
-):
- """Class mixin for matplotlib-related methods."""
-
- default_elevate_outline_annotations = False
- default_strand_in_label_threshold = None
-
- def initialize_ax(self, ax, draw_line, with_ruler, ruler_color=None):
- """Initialize the ax: remove axis, draw a horizontal line, etc.
-
- Parameters
- ----------
-
- draw_line
- True/False to draw the horizontal line or not.
-
- with_ruler
- True/False to draw the indices indicators along the line.
-
- """
- ruler_color = ruler_color or self.default_ruler_color
- start, end = self.span
- plot_start, plot_end = start - 0.8, end - 0.2
- if draw_line:
- ax.plot([plot_start, plot_end], [0, 0], zorder=-1000, c="k")
-
- if with_ruler: # only display the xaxis ticks
- ax.set_frame_on(False)
- ax.yaxis.set_visible(False)
- ax.xaxis.tick_bottom()
- if ruler_color is not None:
- ax.tick_params(axis="x", colors=ruler_color)
- else: # don't display anything
- ax.axis("off")
-
- ax.set_xlim(plot_start, plot_end)
- if self.first_index != 0:
- ax.ticklabel_format(useOffset=False, style="plain")
- fmt = lambda x, p: "{:,}".format(int(x))
- ax.xaxis.set_major_formatter(ticker.FuncFormatter(fmt))
- if self.ticks_resolution == "auto":
- ax.xaxis.set_major_locator(ticker.MaxNLocator(integer=True))
- else:
- locator = ticker.MultipleLocator(self.ticks_resolution)
- ax.xaxis.set_major_locator(locator)
-
- def finalize_ax(
- self,
- ax,
- features_levels,
- annotations_max_level,
- auto_figure_height=False,
- ideal_yspan=None,
- annotations_are_elevated=True,
- ):
- """Prettify the figure with some last changes.
-
- Changes include redefining y-bounds and figure height.
-
- Parameters
- ==========
- ax
- ax on which the record was plotted
-
- features_levels
-
- annotations_max_level
- Number indicating to the method the maximum height for an
- annotation, so the method can set ymax accordingly
-
- auto_figure_height
- If true, the figure'height will be automatically re-set to a nice
- value (counting ~0.4inch per level in the figure).
-
- ideal_yspan
- if provided, can help the method select a better ymax to make sure
- all constraints fit.
-
- """
-
- # Compute the "natural" ymax
- annotation_height = self.determine_annotation_height(None)
- features_ymax = self.feature_level_height * (features_levels + 1)
- annotations_ymax = annotation_height * annotations_max_level
- if annotations_are_elevated:
- ymax = features_ymax + annotations_ymax
- else:
- ymax = max(features_ymax, annotations_ymax) + 1
- ymin = min(ax.get_ylim()[0], -0.5)
-
- # ymax could be even bigger if a "ideal_yspan" has been set.
- if (ideal_yspan is not None) and not (auto_figure_height):
- ymax = max(ideal_yspan + ymin, ymax)
- ax.set_ylim(ymin, ymax)
- if auto_figure_height:
- figure_width = ax.figure.get_size_inches()[0]
- ax.figure.set_size_inches(figure_width, 1 + 0.4 * ymax)
- ax.set_xticks(
- [
- t
- for t in ax.get_xticks()
- if t <= self.last_index and t >= self.first_index
- ]
- )
- if self.plots_indexing == "genbank":
- ax.set_xticklabels([int(i + 1) for i in ax.get_xticks()])
- return ideal_yspan / (ymax - ymin)
-
- @staticmethod
- def _get_ax_width(ax, unit="inch"):
- """Return the ax's width in 'inches' or 'pixel'."""
- transform = ax.figure.dpi_scale_trans.inverted()
- bbox = ax.get_window_extent().transformed(transform)
- width = bbox.width
- if unit == "pixel":
- width *= ax.figure.dpi
- return width
-
- def plot_feature(self, ax, feature, level, linewidth=1.0):
- """Create an Arrow Matplotlib patch with the feature's coordinates.
-
- The Arrow points in the direction of the feature's strand.
- If the feature has no direction (strand==0), the returned patch will
- simply be a rectangle.
-
- The x-coordinates of the patch are determined by the feature's
- `start` and `end` while the y-coordinates are determined by the `level`
- """
- x1, x2 = feature.start, feature.end
- if feature.open_left:
- x1 -= 1
- if feature.open_right:
- x2 += 1
- if feature.strand == -1:
- x1, x2 = x2, x1
- x1, x2 = x1 - 0.5, x2 - 0.5
-
- is_undirected = feature.strand not in (-1, 1)
- head_is_cut = (feature.strand == 1 and feature.open_right) or (
- feature.strand == -1 and feature.open_left
- )
- if is_undirected or head_is_cut:
- head_length = 0.001
- else:
- width_pixel = self._get_ax_width(ax, unit="pixel")
- head_length = (
- 0.5 * width_pixel * feature.length / self.sequence_length
- )
- head_length = min(head_length, 0.6 * feature.thickness)
-
- arrowstyle = mpatches.ArrowStyle.Simple(
- head_width=feature.thickness,
- tail_width=feature.thickness,
- head_length=head_length,
- )
- y = self.feature_level_height * level
- patch = mpatches.FancyArrowPatch(
- [x1, y],
- [x2, y],
- shrinkA=0.0,
- shrinkB=0.0,
- arrowstyle=arrowstyle,
- facecolor=feature.color,
- zorder=0,
- edgecolor=feature.linecolor,
- linewidth=feature.linewidth,
- )
- ax.add_patch(patch)
- return patch
-
- def autoselect_label_color(self, background_color):
- """Autselect a color for the label font.
-
- In the current method the label will be black on clear backrgounds,
- and white on dark backgrounds.
- """
- r, g, b = colorConverter.to_rgb(background_color)
- luminosity = 0.299 * r + 0.587 * g + 0.114 * b
- return "black" if (luminosity >= 0.5) else "white"
-
- def annotate_feature(
- self,
- ax,
- feature,
- level,
- inline=False,
- max_label_length=50,
- max_line_length=30,
- padding=0,
- indicate_strand_in_label=False,
- ):
- """Create a Matplotlib Text with the feature's label.
-
- The x-coordinates of the text are determined by the feature's
- `x_center` while the y-coordinates are determined by the `level`.
-
- The text is horizontally and vertically centered.
-
- The Arrow points in the direction of the feature's strand.
- If the feature has no direction (strand==0), the returned patch will
- simply be a rectangle.
-
- The x-coordinates of the patch are determined by the feature's
- `start` and `end` while the y-coordinates are determined by the `level`
- """
- x, y = self.coordinates_in_plot(feature.x_center, level)
- label = feature.label
- if indicate_strand_in_label:
- if feature.strand == -1:
- label = "⇦" + label
- if feature.strand == 1:
- label = label + "⇨"
-
- if not inline:
- label = self._format_label(
- label,
- max_label_length=max_label_length,
- max_line_length=max_line_length,
- )
- nlines = len(label.split("\n"))
- fontdict = dict(**feature.fontdict)
- if "family" not in fontdict and (self.default_font_family is not None):
- fontdict["family"] = self.default_font_family
- if inline and ("color" not in fontdict):
- color = self.autoselect_label_color(background_color=feature.color)
- fontdict["color"] = color
- box_color = feature.box_color
- if box_color == "auto":
- box_color = self.default_box_color
- bbox = None
- if (box_color is not None) and not inline:
- bg_color = change_luminosity(feature.color, min_luminosity=0.95)
- bbox = dict(
- boxstyle="round",
- fc=bg_color if box_color == "auto" else box_color,
- ec="0.5",
- lw=feature.box_linewidth,
- )
- text = ax.text(
- x,
- y,
- label,
- horizontalalignment="center",
- verticalalignment="center",
- bbox=bbox,
- fontdict=fontdict,
- zorder=2,
- )
- x1, y1, x2, y2 = get_text_box(text)
- x1 -= padding
- x2 += padding
- overflowing = (x1 < feature.start) or (x2 > feature.end)
- return text, overflowing, nlines, (x1, x2), (y2 - y1)
-
- def place_annotation(
- self,
- feature,
- ax,
- level,
- annotate_inline,
- max_line_length,
- max_label_length,
- indicate_strand_in_label=False,
- ):
- """"Place an annotation in the figure. Decide on inline vs. outline.
-
- Parameters
- ----------
-
- feature
- Graphic feature to place in the figure
-
- ax
- Matplotlib ax in which to place the feature.
-
- level
- level at which the annotation should be placed
-
- annotate_inline
- If true, the plotter will attempt to annotate inline, and fall back
- to outline annotation.
-
- max_line_length
- If an annotation label's length exceeds this number the label will
- wrap over several lines.
-
- max_label_length,
- If an annotation label's length exceeds this number the label will
- be cut with an ellipsis (...).
-
- indicate_strand_in_label
- If True, then the label will be represented as "<= label" or
- "label =>" with an arrow representing the strand.
- """
- padding = self.compute_padding(ax)
- if annotate_inline:
- # FIRST ATTEMPT TO ANNOTATE INSIDE THE FEATURE. CHECK FOR OVERFLOW
- text, overflowing, lines, (x1, x2), height = self.annotate_feature(
- ax=ax,
- feature=feature,
- level=level,
- inline=True,
- padding=padding,
- max_label_length=max_label_length,
- max_line_length=max_line_length,
- indicate_strand_in_label=indicate_strand_in_label,
- )
-
- # IF OVERFLOW, REMOVE THE TEXT AND PLACE IT AGAIN, OUTLINE.
- if overflowing:
- text.remove()
- text, _, lines, (x1, x2), height = self.annotate_feature(
- ax=ax,
- feature=feature,
- level=level,
- inline=False,
- padding=padding,
- max_label_length=max_label_length,
- max_line_length=max_line_length,
- indicate_strand_in_label=indicate_strand_in_label,
- )
- return text, overflowing, lines, (x1, x2), height
- else:
- return self.annotate_feature(
- ax=ax, feature=feature, level=level, padding=padding
- )
-
- def plot(
- self,
- ax=None,
- figure_width=8,
- draw_line=True,
- with_ruler=True,
- ruler_color=None,
- plot_sequence=False,
- annotate_inline=True,
- max_label_length=50,
- max_line_length=30,
- level_offset=0,
- strand_in_label_threshold="default",
- elevate_outline_annotations="default",
- x_lim=None,
- figure_height=None,
- sequence_params=None,
- ):
- """Plot all the features in the same Matplotlib ax
-
- Parameters
- ----------
-
- ax
- The Matplotlib ax on which to plot the graphic record. If None is
- provided, a new figure and ax is generated, the ax is returned at
- the end.
-
- figure_width
- Width of the figure (only if no ax was provided and a new figure is
- created) in inches.
-
- draw_line
- If True, a base line representing the sequence will be drawn.
-
- with_ruler
- If true, the sequence indices will be indicated at regular intervals.
-
- plot_sequence
- If True and the graphic record has a "sequence" attribute set, the
- sequence will be displayed below the base line.
-
- annotate_inline
- If true, some feature labels will be displayed inside their
- corresponding feature if there is sufficient space.
-
- level_offset
- All features and annotations will be pushed up by "level_offset". Can
- be useful when plotting several sets of features successively on a
- same ax.
-
- elevate_outline_annotations
- If true, every text annotation will be above every feature. If false,
- text annotations will be as close as possible to the features.
-
- strand_in_label_pixel_threshold
- Number N such that, when provided, every feature with a graphical
- width in pixels below N will have its strand indicated in the label
- by an a left/right arrow
-
- x_lim
- Horizontal axis limits to be set at the end.
-
- sequence_params
- parameters for plot_sequence
- """
-
- if elevate_outline_annotations == "default":
- default = self.default_elevate_outline_annotations
- elevate_outline_annotations = default
- if strand_in_label_threshold == "default":
- default = self.default_strand_in_label_threshold
- strand_in_label_threshold = default
-
- features_levels = compute_features_levels(self.features)
-
- for f in features_levels:
- features_levels[f] += level_offset
- max_level = (
- 1
- if (features_levels == {})
- else max(1, max(features_levels.values()))
- )
- auto_figure_height = (ax is None) and (figure_height is None)
- if ax is None:
- height = figure_height or max_level
- fig, ax = plt.subplots(1, figsize=(figure_width, height))
-
- def strand_in_label(f):
- """Anything under 0.1 inches in the figure"""
- if strand_in_label_threshold is None:
- return False
- width_pixel = self._get_ax_width(ax, unit="pixel")
- f_pixels = 1.0 * width_pixel * f.length / self.sequence_length
- return f_pixels < strand_in_label_threshold
-
- self.initialize_ax(ax, draw_line=draw_line, with_ruler=with_ruler)
- if x_lim is not None:
- ax.set_xlim(*x_lim)
- overflowing_annotations = []
- renderer = ax.figure.canvas.get_renderer()
- bbox = ax.get_window_extent(renderer)
- ax_height = bbox.height
- ideal_yspan = 0
-
- # sorting features from larger to smaller to make smaller features
- # appear "on top" of smaller ones, in case it happens. May be useless
- # now.
- sorted_features_levels = sorted(
- features_levels.items(), key=lambda o: -o[0].length
- )
- for feature, level in sorted_features_levels:
- self.plot_feature(ax=ax, feature=feature, level=level)
- if feature.label is None:
- continue
- (
- text,
- overflowing,
- nlines,
- (x1, x2,),
- height,
- ) = self.place_annotation(
- feature=feature,
- ax=ax,
- level=level,
- annotate_inline=annotate_inline,
- max_line_length=max_line_length,
- max_label_length=max_label_length,
- indicate_strand_in_label=strand_in_label(feature),
- )
- line_height = height / nlines
- n_text_lines_in_axis = ax_height / line_height
- min_y_height = self.min_y_height_of_text_line
- feature_ideal_span = min_y_height * n_text_lines_in_axis
- ideal_yspan = max(ideal_yspan, feature_ideal_span)
- if overflowing or not annotate_inline:
- # trick here: we are representing text annotations as
- # GraphicFeatures so we can place them using
- # compute_features_levels().
- # We are also storing all the info necessary for label plotting
- # in these pseudo-graphic-features.
- overflowing_annotations.append(
- GraphicFeature(
- start=x1,
- end=x2,
- feature=feature,
- text=text,
- feature_level=level,
- nlines=nlines,
- color=feature.color,
- label_link_color=feature.label_link_color,
- )
- )
-
- # There are two ways to plot annotations: evelated, all above all the
- # graphic feature. Or at the same levels as the graphic features (
- # every annotation above its respective feature, but some annotations
- # can be below some features).
- if elevate_outline_annotations:
-
- base_feature = GraphicFeature(
- start=-self.sequence_length,
- end=self.sequence_length,
- fixed_level=0,
- nlines=1,
- is_base=True,
- )
- overflowing_annotations.append(base_feature)
- annotations_levels = compute_features_levels(
- overflowing_annotations
- )
- else:
- for f in self.features:
- f.data.update(dict(nlines=1, fixed_level=features_levels[f]))
- annotations_levels = compute_features_levels(
- overflowing_annotations + self.features
- )
- annotations_levels = {
- f: annotations_levels[f] for f in overflowing_annotations
- }
-
- max_annotations_level = max([0] + list(annotations_levels.values()))
- annotation_height = self.determine_annotation_height(max_level)
- annotation_height = max(
- self.min_y_height_of_text_line, annotation_height
- )
- labels_data = {}
- for feature, level in annotations_levels.items():
- if "is_base" in feature.data:
- continue
- text = feature.data["text"]
- x, y = text.get_position()
- if elevate_outline_annotations:
- new_y = (max_level) * self.feature_level_height + (
- level
- ) * annotation_height
- else:
- new_y = annotation_height * level
- text.set_position((x, new_y))
- fx, fy = self.coordinates_in_plot(
- feature.data["feature"].x_center, feature.data["feature_level"]
- )
-
- # PLOT THE LABEL-TO-FEATURE LINK
- link_color = feature.label_link_color
- if link_color == "auto":
- link_color = change_luminosity(feature.color, luminosity=0.2)
- ax.plot([x, fx], [new_y, fy], c=link_color, lw=0.5, zorder=-10)
- labels_data[feature.data["feature"]] = dict(
- feature_y=fy, annotation_y=new_y
- )
-
- if plot_sequence:
- self.plot_sequence(ax, **(sequence_params or {}))
-
- self.finalize_ax(
- ax=ax,
- features_levels=max([1] + list(features_levels.values())),
- annotations_max_level=max_annotations_level,
- auto_figure_height=auto_figure_height,
- ideal_yspan=ideal_yspan,
- annotations_are_elevated=elevate_outline_annotations,
- )
- return ax, (features_levels, labels_data)
-
- def plot_legend(
- self, ax, allow_ambiguity=False, include_edge=True, **legend_kwargs
- ):
- handles = []
- features_parameters = {}
- for feature in self.features:
- text = feature.legend_text
- if text is None:
- continue
- parameters = dict(
- label=text, facecolor=feature.color, edgecolor="black",
- )
- if include_edge:
- parameters.update(
- dict(
- linewidth=feature.linewidth,
- edgecolor=feature.linecolor,
- )
- )
- if text in features_parameters:
- previous_parameters = features_parameters[text]
- if (not allow_ambiguity) and any(
- [
- parameters[k] != previous_parameters[k]
- for k in parameters
- ]
- ):
- raise ValueError(
- "Cannot generate an unambiguous legend as two"
- )
- continue
- features_parameters[text] = parameters
- handles.append(Patch(**parameters))
- ax.legend(handles=handles, **legend_kwargs)
-
-
-def change_luminosity(
- color, luminosity=None, min_luminosity=None, factor=None
-):
- """Return a version of the color with different luminosity.
-
- Parameters
- ----------
- color
- A color in any Matplotlib-compatible format such as "white", "w",
- (1,1,1), "#ffffff", etc.
- luminosity
- A float in 0-1. If provided, the returned color has this level of
- luminosity.
- factor
- Only used if `luminosity` is not set. Positive factors increase
- luminosity and negative factors decrease it. More precisely, the
- luminosity of the new color is L^(-factor), where L is the current
- luminosity, between 0 and 1.
- """
- r, g, b = colorConverter.to_rgb(color)
- h, l, s = colorsys.rgb_to_hls(r, g, b)
- new_l = l
- if luminosity is not None:
- new_l = luminosity
- if factor is not None:
- new_l = l ** (-factor)
- if min_luminosity is not None:
- new_l = max(new_l, min_luminosity)
-
- return colorsys.hls_to_rgb(h, new_l, s)
-
-
-def get_text_box(text, margin=0):
- """Return the coordinates of a Matplotlib Text.
-
- `text` is a Matplotlib text obtained with ax.text().
- This returns `(x1,y1, x2, y2)` where (x1,y1) is the lower left corner
- and (x2, y2) is the upper right corner of the text, in data coordinates.
- If a margin m is supplied, the returned result is (x1-m, y1-m, x2+m, y2+m)
- """
- renderer = text.axes.figure.canvas.get_renderer()
- bbox = text.get_window_extent(renderer) # bounding box
- __x1, y1, __x2, y2 = bbox.get_points().flatten()
- bbox = bbox.transformed(text.axes.transData.inverted())
- x1, __y1, x2, __y2 = bbox.get_points().flatten()
- return [x1, y1, x2, y2]
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/MultilinePlottableMixin.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/MultilinePlottableMixin.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,153 +0,0 @@
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_pdf import PdfPages
-import numpy
-
-
-class MultilinePlottableMixin:
- def plot_on_multiple_lines(
- self,
- n_lines=None,
- nucl_per_line=None,
- plot_sequence=False,
- figure_width="auto",
- **plot_params
- ):
- """Plot the features on different lines (one Matplotlib ax per line)
-
- Parameters
- ----------
-
- n_lines
- Number of lines on which the record will be plotted. A number of
- nucleotides per line can be provided instead (see below).
-
- nucl_per_line
- Number of nucleotides to be represented on every line (determines
- the number of lines ``n_lines``).
-
- plot_sequence
- Whether to plot the nucleotide sequence on each line
-
- figure_width
- Width of the figure in inches. Leave to auto for a width of either 10
- (if not sequence is plotted) or 0.15*nucl_per_line inches
- (if a sequence is plotted).
-
- **plot_params
- Parameters from ``graphic_record.plot()`` to be used in the plotting
- of the individual lines. This includes ``draw_line``, ``with_ruler``,
- ``annotate_inline``, ``plot_sequence``,
- ``evelate_outline_annotations``, ``strand_in_label_pixel_threshold``
-
- Returns
- -------
-
- figure, axes
- The matplotlib figure and axes generated.
- """
-
- if n_lines is None:
- n_lines = int(numpy.ceil(self.sequence_length / nucl_per_line))
- else:
- nucl_per_line = self.sequence_length // n_lines + 1
-
- if figure_width == "auto":
- if plot_sequence:
- figure_width = 0.15 * nucl_per_line
- else:
- figure_width = 10
-
- figures_heights = []
-
- def plot_line(line_index, ax=None):
- first, last = self.first_index, self.last_index
- line_start = first + line_index * nucl_per_line
- line_virtual_end = first + (line_index + 1) * nucl_per_line
- line_end = min(last, line_virtual_end)
- line_record = self.crop((line_start, line_end))
- line_ax, _ = line_record.plot(
- figure_width=figure_width,
- x_lim=(line_start, line_virtual_end),
- ax=ax,
- plot_sequence=plot_sequence,
- **plot_params
- )
- return line_ax
-
- for line_index in range(n_lines):
- line_ax = plot_line(line_index)
- figures_heights.append(line_ax.figure.get_figheight())
- plt.close(line_ax.figure)
- fig, axes = plt.subplots(
- n_lines,
- 1,
- gridspec_kw={"height_ratios": figures_heights},
- figsize=(figure_width, 0.9 * sum(figures_heights)),
- )
- if n_lines == 1:
- axes = [axes]
- for line_index, ax in enumerate(axes):
- plot_line(line_index, ax=ax)
- fig.tight_layout()
- return fig, axes
-
- def plot_on_multiple_pages(
- self,
- pdf_target,
- n_lines=None,
- nucl_per_line=None,
- lines_per_page=5,
- figure_width="auto",
- **plot_params
- ):
- """Plot the features on different lines on different pages of a PDF.
-
- This function returns None
-
- Parameters
- ----------
-
- pdf_target
- Either a path to a PDF, or a file(-like) handle.
-
- n_lines
- Number of lines on which the record will be plotted. A number of
- nucleotides per line can be provided instead (see below).
-
- nucl_per_line
- Number of nucleotides to be represented on every line (determines
- the number of lines ``n_lines``).
-
- lines_per_page
- Number of lines on each page
-
- plot_sequence
- Whether to plot the nucleotide sequence on each line
-
- figure_width
- Width of the figure in inches. Leave to auto for a width of either 10
- (if not sequence is plotted) or 0.15*nucl_per_line inches
- (if a sequence is plotted).
-
- **plot_params
- Parameters from ``graphic_record.plot()`` to be used in the plotting
- of the individual lines. This includes ``draw_line``, ``with_ruler``,
- ``annotate_inline``, ``plot_sequence``,
- ``evelate_outline_annotations``, ``strand_in_label_pixel_threshold``
- """
- nucl_per_page = nucl_per_line * lines_per_page
- number_of_pages = int(numpy.ceil(self.sequence_length / nucl_per_page))
- with PdfPages(pdf_target) as pdf:
- for page_index in range(number_of_pages):
- first, last = self.first_index, self.last_index
- page_start = first + page_index * nucl_per_page
- page_end = first + (page_index + 1) * nucl_per_page
- page_end = min(last, page_end)
- page_record = self.crop((page_start, page_end))
- fig, axes = page_record.plot_on_multiple_lines(
- nucl_per_line=nucl_per_line,
- figure_width=figure_width,
- **plot_params
- )
- pdf.savefig(fig)
- plt.close(fig)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/SequenceAndTranslationMixin.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/SequenceAndTranslationMixin.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,145 +0,0 @@
-from ..biotools import extract_graphical_translation
-
-
-class SequenceAndTranslationMixin:
- def plot_sequence(
- self, ax, location=None, y_offset=1, fontdict=None, guides_intensity=0
- ):
- """Plot a sequence of nucleotides at the bottom of the plot.
-
- Parameters
- ----------
-
- ax
- Which axes the translation should be plotted to
-
- location
- location of the segment to translate, either (start, end) or
- (start, end, strand)
-
- y_offset
- Number of text levels under the plot's base line where to draw the
- nucleotides. Should be 1 if the nucleotide sequence is to be plotted
- directly under the main line.
-
- fontdict
- Matplotlib fontdict for the text, e.g.
- ``{'size': 11, 'weight':'bold'}``
-
- background
- tuple (color1, color2) of alternate colors to plot behind each
- nucleotide position to guide vision. Leave to None for no background.
-
- guides_intensity
- Intensity of the vertical guides marking the different nucleotides
- (0 = no guides)
- """
- if self.sequence is None:
- raise ValueError("No sequence in the graphic record")
- if location is None:
- location = self.span
- location_start, location_end = location
- fontdict = dict(size=11)
- fontdict.update(fontdict or {})
- for i, nucleotide in enumerate(self.sequence):
- index = i + location_start
- if location_start <= index <= location_end:
- ax.text(
- index,
- -0.7 * self.feature_level_height * y_offset,
- nucleotide,
- ha="center",
- va="center",
- fontdict=fontdict,
- )
- if guides_intensity:
- color = (0, 0, 0, guides_intensity)
- for i in range(location_start, location_end + 1):
- ax.axvline(i - 0.5, linewidth=0.1, color=color, zorder=-10000)
- ymin = ax.get_ylim()[0]
- if ymin < -500:
- ymin = 0
- ax.set_ylim(bottom=min(ymin, -y_offset * self.feature_level_height))
-
- def plot_translation(
- self,
- ax,
- location=None,
- y_offset=2,
- fontdict=None,
- guides_intensity=0.5,
- translation=None,
- long_form_translation=True,
- ):
- """Plot a sequence of amino-acids at the bottom of the plot.
-
- Parameters
- ----------
-
- ax
- Which axes the translation should be plotted to
-
- location
- location of the segment to translate (start, end)
-
- y_offset
- Number of text levels under the plot's base line where to draw the
- amino acid names. Should be 2 if the nucleotide sequence is also
- plotted at level 1.
-
- fontdict
- Matplotlib fontdict for the text, e.g.
- ``{'size': 11, 'weight':'bold'}``
-
- background
- tuple (color1, color2) of alternate colors to plot behind each
- amino acid position to guide vision. Leave to None for no background.
-
- translation
- Sequence of amino acids either as a string ``'MAKG...'`` or as a list
- ``['Met', 'Ala', ...]``
-
-
- """
- start, end = location[0], location[1]
- strand = location[2] if (len(location) == 3) else 1
- s, e = self.span
- start = max(start, s + ((start - s) % 3))
- end = min(end, e - ((end - e) % 3))
- if translation is None:
- new_loc = start - self.first_index, end - self.first_index, strand
- translation = extract_graphical_translation(
- self.sequence,
- location=new_loc,
- long_form=long_form_translation,
- )
- texts = [
- ((start + 3 * i, start + 3 * (i + 1)), aa)
- for i, aa in enumerate(translation)
- ]
-
- y = -0.7 * y_offset * self.feature_level_height
- ymin = ax.get_ylim()[0]
- ax.set_ylim(bottom=min(ymin, -y_offset * self.feature_level_height))
- fontdict = fontdict or {}
- guides_color = (0, 0, 0, guides_intensity)
- for i, ((start, end), text) in enumerate(texts):
- ax.text(
- 0.5 * (start + end - 1),
- y,
- text,
- ha="center",
- va="center",
- fontdict=fontdict,
- )
- if guides_intensity:
- ax.axvline(
- start - 0.5,
- linewidth=0.1,
- color=guides_color,
- zorder=-10000,
- )
- if guides_intensity:
- ax.axvline(
- end - 0.5, linewidth=0.1, color=guides_color, zorder=-10000
- )
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/__init__.py
--- a/cpt_linear_genome_plot/dna_features_viewer/GraphicRecord/__init__.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3 +0,0 @@
-from .GraphicRecord import GraphicRecord
-
-__all__ = ['GraphicRecord']
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/README.md
--- a/cpt_linear_genome_plot/dna_features_viewer/README.md Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-# Code organization
-
-This document walks you trough the Geneblocks code. Please request changes if anything is unclear.
-
-- **GraphicFeature.py** implements a class for defining a *GraphicFeature*, which is an annotation (start, end, strand, label) with graphical properties (color, line width, font family...)
-
-- **GraphicRecord/** implements the *GraphicRecord* class, which can plot a set of *GraphicFeatures* using Matplotlib or Bokeh. To keep file sizes acceptable, many methods are implemented in separate files (*bokeh_plots.py*, *matplotlib_plots.py*) and added to *GraphicRecord* via class mixins.
-
-- **CircularGraphicRecord/** implements the *GraphicRecord* class, which inherits from *GraphicRecord* but draws features circularly using custom Matplotlib patches called "arrow-wedge" (defined in file *ArrowWedge.py*).
-
-- **compute_features_levels.py** implements the algorithm for deciding the levels on which the different features (and annotations) are drawn
-
-- **biotools.py** implements generic biology-related methods (reverse_complement, annotation of Biopython records, etc.)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/__init__.py
--- a/cpt_linear_genome_plot/dna_features_viewer/__init__.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-""" dna_features_viewer/__init__.py """
-
-from .GraphicRecord import GraphicRecord
-from .CircularGraphicRecord import CircularGraphicRecord
-from .GraphicFeature import GraphicFeature
-from .BiopythonTranslator import (
- BiopythonTranslator,
- BlackBoxlessLabelTranslator,
-)
-from .biotools import load_record, annotate_biopython_record
-
-from .version import __version__
-
-__all__ = [
- "GraphicRecord",
- "CircularGraphicRecord",
- "GraphicFeature",
- "BiopythonTranslator",
- "BlackBoxlessLabelTranslator",
- "annotate_biopython_record",
- "__version__",
-]
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/biotools.py
--- a/cpt_linear_genome_plot/dna_features_viewer/biotools.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,170 +0,0 @@
-import textwrap
-from Bio.Seq import Seq
-from Bio.SeqFeature import SeqFeature, FeatureLocation
-from Bio.PDB.Polypeptide import aa1, aa3
-from Bio import SeqIO
-
-try:
- from BCBio import GFF
-except ImportError:
-
- class GFF:
- def parse(*a):
- """Not available. Please install bcbio-gff."""
- raise ImportError(
- "Please install the bcbio-gff library to parse GFF data"
- )
-
-
-def complement(dna_sequence):
- """Return the complement of the DNA sequence.
-
- For instance ``complement("ATGCCG")`` returns ``"TACGGC"``.
-
- Uses BioPython for speed.
- """
- return str(Seq(dna_sequence).complement())
-
-
-def reverse_complement(sequence):
- """Return the reverse-complement of the DNA sequence.
-
- For instance ``complement("ATGCCG")`` returns ``"GCCGTA"``.
-
- Uses BioPython for speed.
- """
- return complement(sequence)[::-1]
-
-
-aa_short_to_long_form_dict = {
- _aa1: _aa3[0] + _aa3[1:].lower()
- for (_aa1, _aa3) in zip(aa1 + "*", aa3 + ["*"])
-}
-
-
-def translate(dna_sequence, long_form=False):
- """Translate the DNA sequence into an amino-acids sequence MLKYQT...
-
- If long_form is true, a list of 3-letter amino acid representations
- is returned instead (['Ala', 'Ser', ...]).
- """
- result = str(Seq(dna_sequence).translate())
- if long_form:
- result = [aa_short_to_long_form_dict[aa] for aa in result]
- return result
-
-
-def extract_graphical_translation(sequence, location, long_form=False):
- """Return a string of the "graphical" translation of a sequence's subsegment.
-
- Here "graphical" means that the amino acid sequence is always given
- left-to-right, as it will appear under the sequence in the plot. This matters
- when the location is on the -1 strand. In this case, the amino-acids are
- determined by (part of) the reverse-complement of the sequence, however
- the sequence returned will be the mirror of the translated sequence, as
- this is the left-to-right order in which the codons corresponding to the
- amino-acids appear in the sequence.
-
- Parameters
- ----------
- sequence
- An "ATGC" string.
-
- location
- Either (start, end) or (start, end, strand), with strand in (0, 1, -1).
-
- long_form
- if True, a list of 3-letter amino acid representations is returned instead
- (['Ala', 'Ser', ...]).
-
- """
- if len(location) == 3:
- start, end, strand = location
- else:
- start, end = location
- strand = 1
- subsequence = sequence[start:end]
- if strand == -1:
- subsequence = reverse_complement(subsequence)
- translation = translate(subsequence, long_form=long_form)
- if strand == -1:
- translation = translation[::-1]
- return translation
-
-
-def load_record(path):
- """Load a Genbank file """
- if isinstance(path, str):
- # Input is a file path
- if path.lower().endswith('.gff'):
- return list(GFF.parse(path))[0]
- else:
- return SeqIO.read(path, "genbank")
- else:
- # Input is a file-like object
- try:
- return SeqIO.read(path, "genbank")
- except:
- path.seek(0)
- return list(GFF.parse(path))[0]
-
-
-def annotate_biopython_record(
- seqrecord,
- location="full",
- feature_type="misc_feature",
- margin=0,
- **qualifiers
-):
- """Add a feature to a Biopython SeqRecord.
-
- Parameters
- ----------
-
- seqrecord
- The biopython seqrecord to be annotated.
-
- location
- Either (start, end) or (start, end, strand). (strand defaults to +1)
-
- feature_type
- The type associated with the feature
-
- margin
- Number of extra bases added on each side of the given location.
-
- qualifiers
- Dictionnary that will be the Biopython feature's `qualifiers` attribute.
- """
- if location == "full":
- location = (margin, len(seqrecord) - margin)
-
- strand = location[2] if len(location) == 3 else 1
- seqrecord.features.append(
- SeqFeature(
- FeatureLocation(location[0], location[1], strand),
- qualifiers=qualifiers,
- type=feature_type,
- )
- )
-
-
-def find_narrowest_text_wrap(text, max_line_length):
- """Wrap the text into a multi-line text minimizing the longest line length.
-
- This is done by first wrapping the text using max_line_length, then
- attempt new wraps by iteratively decreasing the line_length, as long as the
- number of lines stays the same as with max_line_length.
- """
- narrowest_wrap = textwrap.wrap(text, max_line_length)
- narrowest_width = max([len(l) for l in narrowest_wrap])
- for line_length in range(max_line_length - 1, 0, -1):
- wrap = textwrap.wrap(text, line_length)
- if len(wrap) <= len(narrowest_wrap):
- width = max([len(l) for l in wrap])
- if width < narrowest_width:
- narrowest_wrap = wrap
- narrowest_width = width
- else:
- break
- return "\n".join(narrowest_wrap)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/compute_features_levels.py
--- a/cpt_linear_genome_plot/dna_features_viewer/compute_features_levels.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
-"""Implements the method used for deciding which feature goes to which level
-when plotting."""
-
-import itertools
-import math
-
-
-class Graph:
- """Minimal implementation of non-directional graphs.
-
- Parameters
- ----------
-
- nodes
- A list of objects. They must be hashable
- edges
- A list of the form [(n1,n2), (n3,n4)...] where (n1, n2) represents
- an edge between nodes n1 and n2
- """
-
- def __init__(self, nodes, edges):
- self.nodes = nodes
- self.neighbors = {n: [] for n in nodes}
- for n1, n2 in edges:
- self.neighbors[n1].append(n2)
- self.neighbors[n2].append(n1)
-
-
-def compute_features_levels(features):
- """Compute the vertical levels on which the features should be displayed
- in order to avoid collisions.
-
- `features` must be a list of `dna_features_viewer.GraphicFeature`.
-
- The method used is basically a graph coloring:
- - The nodes of the graph are features and they will be colored with a level
- - Two nodes are neighbors if and only if their features's locations overlap
- - Levels are attributed to nodes iteratively starting with the nodes
- corresponding to the largest features.
- - A node receives the lowest level (starting at 0) that is not already
- the level of one of its neighbors.
- """
- edges = [
- (f1, f2)
- for f1, f2 in itertools.combinations(features, 2)
- if f1.overlaps_with(f2)
- ]
- graph = Graph(features, edges)
- levels = {
- n: n.data.get("fixed_level", None)
- for n in graph.nodes
- }
-
- def collision(node, level):
- """Return whether the node placed at base_level collides with its
- neighbors in the graph."""
- line_factor = 0.5
- nlines = node.data.get("nlines", 1)
- for neighbor in graph.neighbors[node]:
- neighbor_level = levels[neighbor]
- if neighbor_level is None:
- continue
- neighbor_lines = neighbor.data.get("nlines", 1)
- min_distance = line_factor * (nlines + neighbor_lines)
- if abs(level - neighbor_level) < min_distance:
- return True
- return False
-
- for node in sorted(graph.nodes, key=lambda f: -f.length):
- if levels[node] is None:
- level = 0
- while collision(node, level):
- level += 0.5
- levels[node] = level
- return levels
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/dna_features_viewer/version.py
--- a/cpt_linear_genome_plot/dna_features_viewer/version.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-__version__ = "3.0.1"
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/linear_genome_plot.py
--- a/cpt_linear_genome_plot/linear_genome_plot.py Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,281 +0,0 @@
-#!/usr/bin/env python
-from Bio import SeqIO
-from dna_features_viewer import BiopythonTranslator, GraphicRecord
-from matplotlib import rc_context
-import matplotlib
-import matplotlib.pyplot as plt
-from itertools import cycle
-import re
-import sys
-import argparse
-
-class CPTTranslator(BiopythonTranslator):
- """
- This is a customized translator from the dna_features_viewer module to fit Galaxy
- """
-
- global custom_feature_colors
- global box_status
- global label_fields
- global custom_name_colors
- global ignored_features_types
- global ignored_gene_labels
- global ignored_feature_labels
-
- def compute_feature_color(self, feature):
- if feature.type == "CDS":
- if "product" in feature.qualifiers:
- color_specific = any(re.search(("(\\b"+str(item)+"\\b)"),feature.qualifiers["product"][0]) for item in custom_name_colors.keys()) or any(re.search((item),feature.qualifiers["product"][0]) for item in custom_name_colors.keys())
- if color_specific:
- try:
- return custom_name_colors[feature.qualifiers["product"][0]]
- except KeyError:
- for item in custom_name_colors.keys():
- if item in feature.qualifiers["product"][0]:
- custom_name_colors[feature.qualifiers["product"][0]] = custom_name_colors[item]
- return custom_name_colors[feature.qualifiers["product"][0]]
- #print(feature.qualifiers["product"][0])
- else:
- try:
- return custom_feature_colors[feature.type]
- except KeyError:
- return BiopythonTranslator.compute_feature_color(self, feature)
- else:
- if feature.type not in ignored_features_types:
- try:
- return custom_feature_colors[feature.type]
- except KeyError:
- return BiopythonTranslator.compute_feature_color(self, feature)
-
- def compute_feature_label(self, feature): # remove the chop_blocks
- self.label_fields = label_fields
- if feature.type == "CDS":
- if "product" in feature.qualifiers:
- if ignored_gene_labels: # product name drop
- verify_chops = any(re.search(("(\\b"+str(item)+"\\b)"),feature.qualifiers["product"][0]) for item in ignored_gene_labels) or any(re.search((item), feature.qualifiers["product"][0]) for item in ignored_gene_labels)
- if verify_chops:
- return None
- else:
- return BiopythonTranslator.compute_feature_label(self, feature)
- else:
- return BiopythonTranslator.compute_feature_label(self, feature)
- elif feature.type in ignored_feature_labels:
- return None
- else:
- return BiopythonTranslator.compute_feature_label(self, feature)
-
- def compute_filtered_features(self, features):
- return [
- feature for feature in features if feature.type not in ignored_features_types
- ]
-
- def compute_feature_legend_text(self, feature):
- return feature.type
-
- def compute_feature_box_color(self, feature):
- if feature.type == "CDS":
- return "white"
-
- def compute_feature_label_link_color(self, feature):
- return "black"
-
- def compute_feature_box_linewidth(self, feature):
- if box_status:
- return 0.5
- else:
- return 0
-
-def parse_gbk(file):
- """ simple function to parse out the feature information AND products """
-
- record = SeqIO.read(file,"genbank")
- count = 0
- feature_types = {}
- product_names = []
- for feat in record.features:
- if feat.type not in feature_types:
- feature_types[feat.type] = 1
- else:
- feature_types[feat.type] += 1
- if "product" in feat.qualifiers:
- product_names.append(feat.qualifiers["product"][0])
-
- return feature_types, product_names, record
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser(description="Linear Genome Plot")
- # Input and Parameters
- parser.add_argument("input_file",type=argparse.FileType("r"),help="genbank or gff3 file")
- parser.add_argument("--plot_width",type=int,default=20)
- #parser.add_argument("--plot_height",type=int,default=4)
- parser.add_argument("--title",type=str,default="genome plot") # NEED TO ADD TO XML
- parser.add_argument("--common_features_excluded", default="", help="common features to be excluded")
- parser.add_argument("--features_excluded",default="",help="features to be excluded from plot, separate by commas")
- parser.add_argument("--common_ignore_feature_labels", default="", help="common feature labels to be excluded")
- parser.add_argument("--ignored_feature_labels",default="",help="ignore labeling of specific features")
- parser.add_argument("--common_ignore_product_labels", default="", help="common product names to not label")
- parser.add_argument("--ignore_labeling",default="",help="labeling for specific products to ignore, separate by commas")
- parser.add_argument("--feature_label_order",default="locus_tag",help="label order, where the first choice is the first feature listed to pull name labels from") # NEED TO ADD TO XML
- parser.add_argument("--label_box",action="store_true",help="Use to have label box around feature labels")
- parser.add_argument("--label_algo",action="store_true",help="use dna features spacing algo for label placement (in or above feature)")
- #parser.add_argument("--level_offset",type=int,default=0,help="All features and annotations will be pushed up by the input amount. Useful for when plotting several sets of features successively on the same axis.") # Will exclude for now
- #parser.add_argument("--custom_region",action="store_true",help="cropped region for plot")
- parser.add_argument("--sz",type=int,help="beginning location for crop")
- parser.add_argument("--ez",type=int,help="end location for crop")
- parser.add_argument("--st",type=int,help="start site of translation")
- parser.add_argument("--et",type=int,help="end site of translation")
- parser.add_argument("--translation_on",action="store_true",help="plot the translation sub-axis")
- parser.add_argument("--feature_id",nargs="*",action="append",help="feature label to have custom color") # NEED TO ADD TO XML
- parser.add_argument("--feature_id_color",nargs="*",action="append",help="feature's accompanying color")
- parser.add_argument("--gene_id",nargs="*",action="append",help="gene/cds label to have custom color")
- parser.add_argument("--gene_id_color",nargs="*",action="append",help="gene/cds's accompanying color")
- parser.add_argument("--multiline",action="store_true",help="Plot multiline plot")
- parser.add_argument("--nucl_per_line",type=int,help="nucleotides per line of multiline")
- # Output
- parser.add_argument("--file_stats",type=argparse.FileType("w"),default="out_stats.txt",help="output stat file")
- #parser.add_argument("--tmp_img",dest="tmp_img",type=argparse.FileType("wb"),default="out_tmp.svg")
- parser.add_argument("--out_img",dest="out_img",type=argparse.FileType("wb"),default="out_img.svg",help="svg genome plot")
- args = parser.parse_args()
-
-
- ## Part I ; Parse and send output of features count and the list of product names
- feature_counts, products, genome = parse_gbk(args.input_file)
- with args.file_stats as f:
- f.writelines("---::: FILE BREAKDOWN :::---\n\n")
- f.writelines("------::: Feature Count :::------\n")
- for feature, count in feature_counts.items():
- f.writelines(f"Feature: {feature} ::::: Count: {count}\n")
- f.writelines("------::: Product Names :::------\n")
- if products != []:
- for product in products:
- f.writelines(f"Product Name: {product}\n")
- else:
- f.writelines("No Annotated Product Names Found")
-
- ## Part II ; Prep Global Variables
- ## Make K:V pairs for Feature Colors
- if args.label_box:
- box_status = True
- else:
- box_status = False
-
- if args.feature_id:
- feature_ids = [f for listed_obj in args.feature_id for f in listed_obj]
- feature_ids_colors = [f for listed_obj in args.feature_id_color for f in listed_obj]
- custom_feature_colors = dict(zip(feature_ids,feature_ids_colors))
- else:
- custom_feature_colors = {}
-
- ## Make K:V pairs for Name Colors (as above)
- if args.gene_id:
- gene_ids = [g for listed_obj in args.gene_id for g in listed_obj]
- gene_ids_colors = [g for listed_obj in args.gene_id_color for g in listed_obj]
- custom_name_colors = dict(zip(gene_ids,gene_ids_colors))
- else:
- custom_name_colors = {}
-
- ## Ignored Features
- #ignored_features_types = str.split(args.features_excluded,",")
- if args.common_features_excluded:
- ignored_features_types = str.split(args.common_features_excluded, ",")
- if args.features_excluded:
- ignored_features_types += str.split(args.features_excluded,",")
- elif args.features_excluded:
- ignored_features_types = str.split(args.features_excluded,",")
- else:
- ignored_features_types = False
-
- print(ignored_features_types)
-
- ## product labels
- if args.common_ignore_product_labels:
- ignored_gene_labels = str.split(args.common_ignore_product_labels,",")
- if args.ignore_labeling:
- ignored_gene_labels += str.split(args.ignore_labeling,",")
- elif args.ignore_labeling:
- ignored_gene_labels = str.split(args.ignore_labeling,",")
- else:
- ignored_gene_labels = False
-
- print(ignored_gene_labels)
-
- if args.feature_label_order != ['']:
- label_fields = str.split(args.feature_label_order,",")
-
- #if ignored_gene_labels == ['']:
- # ignored_gene_labels = False
-
- ## Ignored Labeling
- if args.common_ignore_feature_labels:
- ignored_feature_labels = str.split(args.common_ignore_feature_labels,",")
- if args.ignored_feature_labels:
- ignored_feature_labels += str.split(args.ignored_feature_labels,",")
- elif args.ignored_feature_labels:
- ignored_feature_labels = str.split(args.ignored_feature_labels,",")
- else:
- ignored_feature_labels = False
-
- print(ignored_feature_labels)
- ## Print Statements for Debugging
- #print(custom_feature_colors)
- #print(custom_name_colors)
- #print(ignored_features_types)
- #print(ignored_gene_labels)
- #print(label_fields)
-
- ## Part III ; PLOT
- # Housekeeping
- rc_context({"font.family": ["monospace"],}) # courier-like
- matplotlib.use('Agg') # I think this has to be used...
-
- if args.label_algo:
- lab_algo = True
- else:
- lab_algo = False
-
- translator = CPTTranslator()
- graphic_record = translator.translate_record(genome)
-
- with open("tmp.svg", "wb") as img:
- img.truncate(0)
- img.close()
-
- if args.sz and not args.multiline: # if user is wanting to look at a subset region of the genome
- zoom_start, zoom_end = args.sz, args.ez
- cropped = graphic_record.crop((zoom_start,zoom_end))
- ax, _ = cropped.plot(figure_width=args.plot_width, annotate_inline=lab_algo,figure_height=None)
- if args.translation_on:
- crop_seq = (args.st - 1, args.et)
- cropped.plot_translation(ax, location=crop_seq, fontdict={'size':8, 'weight':'bold'},y_offset=1)
- ax.set_title(args.title)
- # Galaxy specific shenanigans
- tmp_fig = "./tmp.svg"
- plt.savefig(tmp_fig)
- plt.close()
- elif args.multiline:
- if args.sz:
- zoom_start, zoom_end = args.sz, args.ez
- else:
- zoom_start, zoom_end = 1, graphic_record.sequence_length
- cropped = graphic_record.crop((zoom_start,zoom_end))
- ax, _ = cropped.plot_on_multiple_lines(
- figure_width=args.plot_width,
- annotate_inline=lab_algo,
- figure_height=None,
- nucl_per_line=args.nucl_per_line,
- plot_sequence=False
- )
- #ax.set_title(args.title)
- tmp_fig = "./tmp.svg"
- plt.savefig(tmp_fig)
- plt.close()
- else:
- ax, _ = graphic_record.plot(figure_width=args.plot_width, annotate_inline=lab_algo)
- ax.set_title(args.title)
- tmp_fig = "./tmp.svg"
- # Galaxy specific shenanigans
- plt.savefig(tmp_fig)
- plt.close()
- with open("tmp.svg", "rb") as img:
- for line in img:
- args.out_img.write(line)
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/linear_genome_plot.xml
--- a/cpt_linear_genome_plot/linear_genome_plot.xml Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,289 +0,0 @@
-
- Linear Genome Plot
-
- macros.xml
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- https://doi.org/10.1101/2020.01.09.900589
-
- @unpublished{galaxyTools,
- author = {C. Ross},
- title = {CPT Galaxy Tools},
- year = {2020-},
- note = {https://github.com/tamu-cpt/galaxy-tools/}
- }
-
-
-
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/macros.xml
--- a/cpt_linear_genome_plot/macros.xml Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-
-
-
-
- python
- biopython
- cpt_gffparser
- pandas
- matplotlib
-
-
-
-
-
-
-
-
diff -r 621754dd31f8 -r e923c686ead9 cpt_linear_genome_plot/test-data/Mu50-profile.xml.xml
--- a/cpt_linear_genome_plot/test-data/Mu50-profile.xml.xml Fri Jun 17 12:59:24 2022 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-
-
-
-
-
-
-
-