biotite 0.41.2__cp312-cp312-macosx_11_0_arm64.whl → 1.0.1__cp312-cp312-macosx_11_0_arm64.whl

biotite/sequence/graphics/plasmid.py

@@ -6,20 +6,29 @@ __name__ = "biotite.sequence.graphics"
 __author__ = "Patrick Kunzmann"
 __all__ = ["plot_plasmid_map"]
 
-import copy
+import re
 import warnings
-import abc
 import numpy as np
-import re
-from ...visualize import colors
-from ..annotation import Annotation, Feature, Location
-
-
-def plot_plasmid_map(axes, annotation, plasmid_size, tick_length=0.02,
-                     tick_step=200, ring_width=0.01, feature_width=0.06,
-                     spacing=0.01, arrow_head_length=0.04, label=None,
-                     face_properties=None, label_properties=None,
-                     omit_oversized_labels=True, feature_formatter=None):
+from biotite.sequence.annotation import Feature, Location
+from biotite.visualize import colors
+
+
+def plot_plasmid_map(
+    axes,
+    annotation,
+    plasmid_size,
+    tick_length=0.02,
+    tick_step=200,
+    ring_width=0.01,
+    feature_width=0.06,
+    spacing=0.01,
+    arrow_head_length=0.04,
+    label=None,
+    face_properties=None,
+    label_properties=None,
+    omit_oversized_labels=True,
+    feature_formatter=None,
+):
     """
     Plot a plasmid map using the sequence features in the given
     :class:`Annotation`.
@@ -84,26 +93,26 @@ def plot_plasmid_map(axes, annotation, plasmid_size, tick_length=0.02,
         the following tuple:
 
         - *directional* : bool
-           
+
             True, if the direction of the feature should be indicated by
             an arrow.
             Otherwise, the feature is plotted is arc.
-        
+
         - *face_color* : tuple or str, optional
-            
+
             A *Matplotlib* compatible color for the feature arrow/arc.
-        
+
         - *label_color* : tuple or str, optional
-            
+
             A *Matplotlib* compatible color for the feature label.
-        
+
         - *label* : str or None
-            
+
             The label to be displayed for this feature.
             None, if no label should be displayed.
     """
     from matplotlib.projections.polar import PolarAxes
-    
+
     if not isinstance(axes, PolarAxes):
         raise TypeError("The given axes must be a 'PolarAxes'")
 
@@ -118,16 +127,13 @@ def plot_plasmid_map(axes, annotation, plasmid_size, tick_length=0.02,
     if feature_formatter is None:
         feature_formatter = _default_feature_formatter
 
-
     ### Setup matplotlib ###
     # The x-coordinate is given as angle (rad)
     # Full circle -> 2*pi
-    axes.set_xlim(0, 2*np.pi)
+    axes.set_xlim(0, 2 * np.pi)
     axes.set_ylim(0, 1)
     axes.yaxis.set_visible(False)
-    axes.xaxis.set_tick_params(
-        bottom=False, labelbottom=True
-    )
+    axes.xaxis.set_tick_params(bottom=False, labelbottom=True)
     axes.set_theta_zero_location("N")
     axes.set_theta_direction("clockwise")
     axes.spines["polar"].set_visible(False)
@@ -142,32 +148,39 @@ def plot_plasmid_map(axes, annotation, plasmid_size, tick_length=0.02,
     axes.xaxis.set_ticks([_loc_to_rad(tick, plasmid_size) for tick in ticks])
     axes.xaxis.set_ticklabels(tick_labels)
     ### Draw plasmid ring with ticks and central label ###
-    
+
     # Plasmid ring
     # Use 'barh()' instead of a Rectangle patch to ensure that the axes
     # is properly initialized
     # Otherwise the feature rectangles are not curved, but straight
     axes.barh(
-        1-ring_width-tick_length, 2*np.pi, ring_width,
-        align="edge", color="black"
+        1 - ring_width - tick_length, 2 * np.pi, ring_width, align="edge", color="black"
     )
-    
+
     # Ticks (ticks itself, not the tick labels)
     for tick in ticks:
         angle = _loc_to_rad(tick, plasmid_size)
         axes.plot(
-            (angle, angle), (1-tick_length, 1),
-            color="black", linewidth=1, linestyle="-"
+            (angle, angle),
+            (1 - tick_length, 1),
+            color="black",
+            linewidth=1,
+            linestyle="-",
         )
-    
+
     # Central plasmid label
     if label is not None:
         axes.text(
-            0, 0, label, ha="center", va="center",
-            color="black", size=32, fontweight="bold"
+            0,
+            0,
+            label,
+            ha="center",
+            va="center",
+            color="black",
+            size=32,
+            fontweight="bold",
         )
 
-
     ### Draw plasmid interior ###
     inner_radius = 1 - ring_width - tick_length
     features = sorted(
@@ -177,28 +190,51 @@ def plot_plasmid_map(axes, annotation, plasmid_size, tick_length=0.02,
         ],
         # Features are sorted by the length of their location range
         # The shortest come first
-        key = lambda feature: np.diff(feature.get_location_range())[0],
-        reverse = True
+        key=lambda feature: np.diff(feature.get_location_range())[0],
+        reverse=True,
+    )
+    axes.add_artist(
+        PlasmidMap(
+            axes,
+            0,
+            features,
+            plasmid_size,
+            inner_radius,
+            feature_width,
+            spacing,
+            arrow_head_length,
+            label,
+            face_properties,
+            label_properties,
+            omit_oversized_labels,
+            feature_formatter,
+        )
     )
-    axes.add_artist(PlasmidMap(
-        axes, 0, features, plasmid_size, inner_radius, feature_width, spacing,
-        arrow_head_length, label, face_properties, label_properties,
-        omit_oversized_labels, feature_formatter
-    ))
 
 
 try:
     # Only create these classes when matplotlib is installed
     from matplotlib.artist import Artist
+    from matplotlib.patches import Polygon, Rectangle
     from matplotlib.transforms import Bbox
-    from matplotlib.patches import Rectangle, Polygon
-
 
     class PlasmidMap(Artist):
-        def __init__(self, axes, zorder, features, plasmid_size, radius,
-                     feature_width, spacing, arrow_head_length, label,
-                     face_properties, label_properties, omit_oversized_labels,
-                     feature_formatter):
+        def __init__(
+            self,
+            axes,
+            zorder,
+            features,
+            plasmid_size,
+            radius,
+            feature_width,
+            spacing,
+            arrow_head_length,
+            label,
+            face_properties,
+            label_properties,
+            omit_oversized_labels,
+            feature_formatter,
+        ):
             super().__init__()
             self._axes = axes
             self.zorder = zorder
@@ -212,30 +248,36 @@ try:
             for feature in features:
                 indicators_for_feature = []
                 for loc in feature.locs:
-                     # Set proper positions in 'draw()' method
+                    # Set proper positions in 'draw()' method
                     bbox = Bbox.from_extents(0, 0, 0, 0)
                     # Draw features as curved arrows (feature indicator)
-                    indicator = axes.add_artist(Feature_Indicator(
-                        axes, self.zorder + 1, feature, loc, bbox,
-                        arrow_head_length, face_properties, label_properties,
-                        omit_oversized_labels, feature_formatter
-                    ))
+                    indicator = axes.add_artist(
+                        FeatureIndicator(
+                            axes,
+                            self.zorder + 1,
+                            feature,
+                            loc,
+                            bbox,
+                            arrow_head_length,
+                            face_properties,
+                            label_properties,
+                            omit_oversized_labels,
+                            feature_formatter,
+                        )
+                    )
                     indicators_for_feature.append(indicator)
                 self._all_indicators.append(indicators_for_feature)
 
-        
         def draw(self, renderer, *args, **kwargs):
             # Find the maximum amount of feature rows
             # (used for overlapping features)
-            row_count = int(
-                self._radius // (self._feature_width + self._spacing)
-            )
+            row_count = int(self._radius // (self._feature_width + self._spacing))
             # Tracks the location ranges of feature that were added to
             # a row in order to check if that row is occupied
             ranges_in_row = [[] for i in range(row_count)]
             # Stores the bottom coordinate (radius) for each row
             row_bottoms = [
-                self._radius - (row+1) * (self._feature_width + self._spacing)
+                self._radius - (row + 1) * (self._feature_width + self._spacing)
                 for row in range(row_count)
             ]
 
@@ -258,11 +300,13 @@ try:
                                 # 'Normal feature'
                                 if first <= curr_last and last >= curr_first:
                                     is_occupied = True
-                            else: # first < 1
+                            else:  # first < 1
                                 # Location is over periodic boundary
-                                if first + self._plasmid_size <= curr_last \
-                                   or last >= curr_first:
-                                        is_occupied = True
+                                if (
+                                    first + self._plasmid_size <= curr_last
+                                    or last >= curr_first
+                                ):
+                                    is_occupied = True
                     if not is_occupied:
                         # Row is not occupied by another feature
                         # in the location range of the new feature
@@ -273,12 +317,10 @@ try:
                         else:
                             # Location is over periodic boundary
                             # Split into 'end' and 'start' part
-                            ranges_in_row[row_i].append((
-                                first + self._plasmid_size, self._plasmid_size
-                            ))
-                            ranges_in_row[row_i].append((
-                                1, last
-                            ))
+                            ranges_in_row[row_i].append(
+                                (first + self._plasmid_size, self._plasmid_size)
+                            )
+                            ranges_in_row[row_i].append((1, last))
                         row_bottom = row_bottoms[row_i]
                         break
                 if row_bottom is None:
@@ -288,24 +330,30 @@ try:
                         "radius or decrease the feature width or spacing"
                     )
                 else:
-                    for loc, indicator in zip(
-                        feature.locs, indicators_for_feature
-                    ):
+                    for loc, indicator in zip(feature.locs, indicators_for_feature):
                         # Calculate arrow shape parameters
-                        row_center = row_bottom + self._feature_width/2
                         row_top = row_bottom + self._feature_width
                         start_ang = _loc_to_rad(loc.first, self._plasmid_size)
-                        stop_ang  = _loc_to_rad(loc.last, self._plasmid_size)
+                        stop_ang = _loc_to_rad(loc.last, self._plasmid_size)
                         bbox = Bbox.from_extents(
                             start_ang, row_bottom, stop_ang, row_top
                         )
                         indicator.set_bbox(bbox)
 
-
-    class Feature_Indicator(Artist):
-        def __init__(self, axes, zorder, feature, loc, bbox, head_length,
-                     arrow_properties, label_properties, omit_oversized_labels,
-                     feature_formatter):
+    class FeatureIndicator(Artist):
+        def __init__(
+            self,
+            axes,
+            zorder,
+            feature,
+            loc,
+            bbox,
+            head_length,
+            arrow_properties,
+            label_properties,
+            omit_oversized_labels,
+            feature_formatter,
+        ):
             super().__init__()
             self._axes = axes
             self.zorder = zorder
@@ -313,44 +361,59 @@ try:
             self._bbox = bbox
             self._head_length = head_length
             self._omit_oversized_labels = omit_oversized_labels
-            
+
             # Determine how to draw the feature
-            directional, face_color, label_color, label \
-                = feature_formatter(feature)
-            
+            directional, face_color, label_color, label = feature_formatter(feature)
+
             # Draw arrow as composition of a rectangle and a triangle,
             # as FancyArrow does not properly work for polar plots
 
-            self._arrow_tail = axes.add_patch(Rectangle(
-                # Set positions in 'draw()' method
-                (0, 0), 0, 0,
-                # Line width is set to 1 to avoid strange artifact in
-                # the transition from rectangle (tail) to polygon (head)
-                color=face_color, linewidth=1, zorder = self.zorder + 1,
-                **arrow_properties
-            ))
-            
+            self._arrow_tail = axes.add_patch(
+                Rectangle(
+                    # Set positions in 'draw()' method
+                    (0, 0),
+                    0,
+                    0,
+                    # Line width is set to 1 to avoid strange artifact in
+                    # the transition from rectangle (tail) to polygon (head)
+                    color=face_color,
+                    linewidth=1,
+                    zorder=self.zorder + 1,
+                    **arrow_properties,
+                )
+            )
+
             if directional:
                 # Only draw any arrow head when feature has a direction,
                 # otherwise simply draw the tail (rectangle)
-                self._arrow_head = axes.add_patch(Polygon(
-                    # Set positions in 'draw()' method
-                    [(0, 0), (0, 0), (0, 0)],
-                    color=face_color, linewidth=1, zorder = self.zorder + 1,
-                    **arrow_properties
-                ))
+                self._arrow_head = axes.add_patch(
+                    Polygon(
+                        # Set positions in 'draw()' method
+                        [(0, 0), (0, 0), (0, 0)],
+                        color=face_color,
+                        linewidth=1,
+                        zorder=self.zorder + 1,
+                        **arrow_properties,
+                    )
+                )
             else:
                 self._arrow_head = None
 
             if label is not None:
                 label_properties["color"] = label_color
-                self._label = axes.add_artist(CurvedText(
-                    # Set positions in 'draw()' method
-                    axes, self.zorder + 1, 0, 0, label, label_properties
-                ))
+                self._label = axes.add_artist(
+                    CurvedText(
+                        # Set positions in 'draw()' method
+                        axes,
+                        self.zorder + 1,
+                        0,
+                        0,
+                        label,
+                        label_properties,
+                    )
+                )
             else:
                 self._label = None
-        
 
         def set_bbox(self, bbox):
             self._bbox = bbox
@@ -359,17 +422,15 @@ try:
             if self._label is not None:
                 self._label.set_position(center_x, center_y)
 
-
         def draw(self, renderer, *args, **kwargs):
             bbox = self._bbox
-            center_x = (bbox.x0 + bbox.x1) / 2
             center_y = (bbox.y0 + bbox.y1) / 2
 
             # Constant absolute width for all arrows
             # irrespective of the radius in the polar plot
             # Calculate actual angle from given absolute width
             head_length = self._head_length / center_y
-            
+
             # Check if the head should be drawn
             if self._arrow_head is None:
                 head_length = 0
@@ -382,39 +443,38 @@ try:
                 rect_pos = (bbox.x0, bbox.y0)
                 # (x0, y0), (x1, y1), (x2, y2)
                 triangle_coord = [
-                    (bbox.x1 - head_length, bbox.y0), # base 1
-                    (bbox.x1 - head_length, bbox.y1), # base 2
-                    (bbox.x1,              center_y) # tip
+                    (bbox.x1 - head_length, bbox.y0),  # base 1
+                    (bbox.x1 - head_length, bbox.y1),  # base 2
+                    (bbox.x1, center_y),  # tip
                 ]
             else:
-                rect_pos = (bbox.x0+head_length, bbox.y0)
+                rect_pos = (bbox.x0 + head_length, bbox.y0)
                 triangle_coord = [
-                    (bbox.x0 + head_length, bbox.y0), # base 1
-                    (bbox.x0 + head_length, bbox.y1), # base 2
-                    (bbox.x0,              center_y) # tip
+                    (bbox.x0 + head_length, bbox.y0),  # base 1
+                    (bbox.x0 + head_length, bbox.y1),  # base 2
+                    (bbox.x0, center_y),  # tip
                 ]
-            
+
             # Update coordinates of sub-artists
             self._arrow_tail.set_xy(rect_pos)
-            self._arrow_tail.set_width(bbox.width-head_length)
+            self._arrow_tail.set_width(bbox.width - head_length)
             self._arrow_tail.set_height(bbox.height)
             if self._arrow_head is not None:
                 self._arrow_head.set_xy(triangle_coord)
-            
+
             if self._label is not None:
                 # Do not draw the labels if it is larger than the
                 # indicator
-                if self._omit_oversized_labels \
-                   and self._label.get_total_angle(renderer) > bbox.width:
-                        self._label.set_visible(False)
+                if (
+                    self._omit_oversized_labels
+                    and self._label.get_total_angle(renderer) > bbox.width
+                ):
+                    self._label.set_visible(False)
                 else:
                     self._label.set_visible(True)
 
-
-
     class CurvedText(Artist):
-        def __init__(self, axes, zorder, angle, radius, string,
-                     text_properties):
+        def __init__(self, axes, zorder, angle, radius, string, text_properties):
             super().__init__()
             self._axes = axes
             self.zorder = zorder
@@ -425,44 +485,35 @@ try:
             for word in _split_into_words(string):
                 text = axes.text(
                     # Set position in 'draw()' method
-                    0, 0,
+                    0,
+                    0,
                     word,
-                    ha="center", va="center",
+                    ha="center",
+                    va="center",
                     zorder=self.zorder + 1,
                     **text_properties,
                 )
                 self._texts.append(text)
-        
 
         def set_visible(self, visible):
             super().set_visible(visible)
             for text in self._texts:
                 text.set_visible(visible)
 
-
         def set_position(self, angle, radius):
             self._angle = angle
             self._radius = radius
-        
 
         def get_total_angle(self, renderer):
             return np.sum(self.get_word_angles(renderer))
-        
 
         def get_word_angles(self, renderer):
             ax_px_radius = self._axes.get_window_extent(renderer).width / 2
             ax_unit_radius = self._axes.get_ylim()[1]
-            circle_px_circumference = ax_px_radius * 2*np.pi \
-                                      * (self._radius / ax_unit_radius)
+            circle_px_circumference = (
+                ax_px_radius * 2 * np.pi * (self._radius / ax_unit_radius)
+            )
 
-            rad_angle = 360 - np.rad2deg(self._angle)
-            # Avoid to draw the text upside down, when drawn on the
-            # bottom half of the map
-            if rad_angle > 90 and rad_angle < 270:
-                turn_around = True
-            else:
-                turn_around = False
-            
             angles = []
             for text in self._texts:
                 orig_rot = text.get_rotation()
@@ -477,14 +528,12 @@ try:
                 # In this case, assign a fixed width
                 if np.isnan(word_px_width):
                     word_px_width = 5.0
-                word_angle \
-                    = 2*np.pi * word_px_width / circle_px_circumference
+                word_angle = 2 * np.pi * word_px_width / circle_px_circumference
                 angles.append(word_angle)
                 # Restore
                 text.set_rotation(orig_rot)
                 text.set_visible(orig_visible)
             return angles
-        
 
         def draw(self, renderer, *args, **kwargs):
             angles = self.get_word_angles(renderer)
@@ -497,7 +546,7 @@ try:
                 turn_around = True
             else:
                 turn_around = False
-            
+
             # Now that the angle for each word is known,
             # the appropriate position and rotation can be set
             if turn_around:
@@ -526,20 +575,18 @@ except ImportError:
     pass
 
 
-
-
 def _loc_to_rad(loc, plasmid_size):
     if loc > plasmid_size:
         raise ValueError(
             f"Location {loc} is larger then the plasmid size of {plasmid_size}"
         )
     # Location starts at 1 -> (loc-1)
-    return ((loc-1) / plasmid_size) * 2*np.pi
+    return ((loc - 1) / plasmid_size) * 2 * np.pi
 
 
 def _rad_to_loc(rad, plasmid_size):
     # Location starts at 1 -> + 1
-    return rad / (2*np.pi) * plasmid_size + 1
+    return rad / (2 * np.pi) * plasmid_size + 1
 
 
 def _merge_over_periodic_boundary(feature, plasmid_size):
@@ -547,7 +594,7 @@ def _merge_over_periodic_boundary(feature, plasmid_size):
         # Only one location -> no merge possible
         return feature
     first_loc = None
-    last_loc  = None
+    last_loc = None
     # Find total first location of the feature
     for loc in feature.locs:
         if first_loc is None or loc.first < first_loc.first:
@@ -558,38 +605,43 @@ def _merge_over_periodic_boundary(feature, plasmid_size):
             last_loc = loc
     # If the first and last location meet at the periodic boundary of
     # the plasmid -> merge them
-    if first_loc.first == 1 and last_loc.last == plasmid_size \
-        and first_loc.strand == last_loc.strand:
-            new_locs = set(feature.locs)
-            new_locs.remove(first_loc)
-            new_locs.remove(last_loc)
-            new_locs.add(Location(
+    if (
+        first_loc.first == 1
+        and last_loc.last == plasmid_size
+        and first_loc.strand == last_loc.strand
+    ):
+        new_locs = set(feature.locs)
+        new_locs.remove(first_loc)
+        new_locs.remove(last_loc)
+        new_locs.add(
+            Location(
                 # the fist base is now at negative location
                 # by shifting by one plasmid 'period'
-                first  = last_loc.first - plasmid_size,
-                last   = first_loc.last,
-                strand = first_loc.strand,
-                defect = first_loc.defect | last_loc.defect
-            ))
-            return Feature(feature.key, new_locs, feature.qual)
+                first=last_loc.first - plasmid_size,
+                last=first_loc.last,
+                strand=first_loc.strand,
+                defect=first_loc.defect | last_loc.defect,
+            )
+        )
+        return Feature(feature.key, new_locs, feature.qual)
     else:
         return feature
 
 
 # ' ', '-' and '_' are word delimiters
 separators = re.compile(r"\s|_|-")
+
+
 def _split_into_words(string):
-    match_indices = sorted(
-        [match.start() for match in separators.finditer(string)]
-    )
+    match_indices = sorted([match.start() for match in separators.finditer(string)])
     current_index = 0
     words = []
     for i in match_indices:
         # Add word up to delimiter
-        words.append(string[current_index : i])
+        words.append(string[current_index:i])
         # Add delimiter
-        words.append(string[i : i+1])
-        current_index = i+1
+        words.append(string[i : i + 1])
+        current_index = i + 1
     # If there is a word after the last delimiter, add it too
     if current_index < len(string):
         words.append(string[current_index:])
@@ -618,44 +670,43 @@ def _default_feature_formatter(f):
         else:
             label = None
         return False, "black", "white", label
-    
+
     # Origin of Replication
     elif f.key == "rep_origin":
-        return False, "indigo", "white", \
-               f.qual.get("standard_name", "ori")
-    
+        return False, "indigo", "white", f.qual.get("standard_name", "ori")
+
     # Coding sequences
     elif f.key in ["gene", "CDS", "rRNA"]:
         label = f.qual.get("product")
         if label is None:
             label = f.qual.get("gene")
         return True, colors["orange"], "black", label
-    
+
     elif f.key == "regulatory":
         # Promoters
         if f.qual.get("regulatory_class") in [
             "promoter",
             "TATA_box",
             "minus_35_signal",
-            "minus_10_signal"
+            "minus_10_signal",
         ]:
             return True, colors["dimgreen"], "black", f.qual.get("note")
-        
+
         # Terminators
         elif f.qual.get("regulatory_class") in "terminator":
             return False, "firebrick", "white", f.qual.get("note")
-        
+
         # RBS
         elif f.qual.get("regulatory_class") == "ribosome_binding_site":
             return False, colors["brightorange"], "white", None
-    
+
     # Primers
     elif f.key == "primer_bind":
         return True, "royalblue", "black", f.qual.get("note")
-    
+
     # Binding proteins
     elif f.key == "protein_bind":
         return False, colors["lightgreen"], "black", f.qual.get("note")
-    
+
     # Misc
-    return True, "dimgray", "white", f.qual.get("note")
+    return True, "dimgray", "white", f.qual.get("note")