black

Author: nicolaskruchten

packages/python/plotly/plotly/matplotlylib/mplexporter/_py3k_compat.py

@@ -2,19 +2,22 @@
 Simple fixes for Python 2/3 compatibility
 """
 import sys
+
 PY3K = sys.version_info[0] >= 3
 
 
 if PY3K:
     import builtins
     import functools
+
     reduce = functools.reduce
     zip = builtins.zip
     xrange = builtins.range
     map = builtins.map
 else:
     import __builtin__
     import itertools
+
     builtins = __builtin__
     reduce = __builtin__.reduce
     zip = itertools.izip

packages/python/plotly/plotly/matplotlylib/mplexporter/exporter.py

@@ -12,6 +12,7 @@
 from matplotlib import transforms, collections
 from matplotlib.backends.backend_agg import FigureCanvasAgg
 
+
 class Exporter(object):
     """Matplotlib Exporter
 
@@ -44,15 +45,17 @@ def run(self, fig):
         # in the correct place.
         if fig.canvas is None:
             canvas = FigureCanvasAgg(fig)
-        fig.savefig(io.BytesIO(), format='png', dpi=fig.dpi)
+        fig.savefig(io.BytesIO(), format="png", dpi=fig.dpi)
         if self.close_mpl:
             import matplotlib.pyplot as plt
+
             plt.close(fig)
         self.crawl_fig(fig)
 
     @staticmethod
-    def process_transform(transform, ax=None, data=None, return_trans=False,
-                          force_trans=None):
+    def process_transform(
+        transform, ax=None, data=None, return_trans=False, force_trans=None
+    ):
         """Process the transform and convert data to figure or data coordinates
 
         Parameters
@@ -81,8 +84,10 @@ def process_transform(transform, ax=None, data=None, return_trans=False,
             Returned only if data is specified
         """
         if isinstance(transform, transforms.BlendedGenericTransform):
-            warnings.warn("Blended transforms not yet supported. "
-                          "Zoom behavior may not work as expected.")
+            warnings.warn(
+                "Blended transforms not yet supported. "
+                "Zoom behavior may not work as expected."
+            )
 
         if force_trans is not None:
             if data is not None:
@@ -91,10 +96,12 @@ def process_transform(transform, ax=None, data=None, return_trans=False,
 
         code = "display"
         if ax is not None:
-            for (c, trans) in [("data", ax.transData),
-                               ("axes", ax.transAxes),
-                               ("figure", ax.figure.transFigure),
-                               ("display", transforms.IdentityTransform())]:
+            for (c, trans) in [
+                ("data", ax.transData),
+                ("axes", ax.transAxes),
+                ("figure", ax.figure.transFigure),
+                ("display", transforms.IdentityTransform()),
+            ]:
                 if transform.contains_branch(trans):
                     code, transform = (c, transform - trans)
                     break
@@ -112,24 +119,23 @@ def process_transform(transform, ax=None, data=None, return_trans=False,
 
     def crawl_fig(self, fig):
         """Crawl the figure and process all axes"""
-        with self.renderer.draw_figure(fig=fig,
-                                       props=utils.get_figure_properties(fig)):
+        with self.renderer.draw_figure(fig=fig, props=utils.get_figure_properties(fig)):
             for ax in fig.axes:
                 self.crawl_ax(ax)
 
     def crawl_ax(self, ax):
         """Crawl the axes and process all elements within"""
-        with self.renderer.draw_axes(ax=ax,
-                                     props=utils.get_axes_properties(ax)):
+        with self.renderer.draw_axes(ax=ax, props=utils.get_axes_properties(ax)):
             for line in ax.lines:
                 self.draw_line(ax, line)
             for text in ax.texts:
                 self.draw_text(ax, text)
-            for (text, ttp) in zip([ax.xaxis.label, ax.yaxis.label, ax.title],
-                                   ["xlabel", "ylabel", "title"]):
-                if(hasattr(text, 'get_text') and text.get_text()):
-                    self.draw_text(ax, text, force_trans=ax.transAxes,
-                                   text_type=ttp)
+            for (text, ttp) in zip(
+                [ax.xaxis.label, ax.yaxis.label, ax.title],
+                ["xlabel", "ylabel", "title"],
+            ):
+                if hasattr(text, "get_text") and text.get_text():
+                    self.draw_text(ax, text, force_trans=ax.transAxes, text_type=ttp)
             for artist in ax.artists:
                 # TODO: process other artists
                 if isinstance(artist, matplotlib.text.Text):
@@ -145,107 +151,122 @@ def crawl_ax(self, ax):
             if legend is not None:
                 props = utils.get_legend_properties(ax, legend)
                 with self.renderer.draw_legend(legend=legend, props=props):
-                    if props['visible']:
+                    if props["visible"]:
                         self.crawl_legend(ax, legend)
 
     def crawl_legend(self, ax, legend):
         """
         Recursively look through objects in legend children
         """
-        legendElements = list(utils.iter_all_children(legend._legend_box,
-                                                      skipContainers=True))
+        legendElements = list(
+            utils.iter_all_children(legend._legend_box, skipContainers=True)
+        )
         legendElements.append(legend.legendPatch)
         for child in legendElements:
             # force a large zorder so it appears on top
-            child.set_zorder(1E6 + child.get_zorder())
+            child.set_zorder(1e6 + child.get_zorder())
 
             # reorder border box to make sure marks are visible
             if isinstance(child, matplotlib.patches.FancyBboxPatch):
-                child.set_zorder(child.get_zorder()-1)
+                child.set_zorder(child.get_zorder() - 1)
 
             try:
                 # What kind of object...
                 if isinstance(child, matplotlib.patches.Patch):
                     self.draw_patch(ax, child, force_trans=ax.transAxes)
                 elif isinstance(child, matplotlib.text.Text):
-                    if child.get_text() != 'None':
+                    if child.get_text() != "None":
                         self.draw_text(ax, child, force_trans=ax.transAxes)
                 elif isinstance(child, matplotlib.lines.Line2D):
                     self.draw_line(ax, child, force_trans=ax.transAxes)
                 elif isinstance(child, matplotlib.collections.Collection):
-                    self.draw_collection(ax, child,
-                                         force_pathtrans=ax.transAxes)
+                    self.draw_collection(ax, child, force_pathtrans=ax.transAxes)
                 else:
                     warnings.warn("Legend element %s not impemented" % child)
             except NotImplementedError:
                 warnings.warn("Legend element %s not impemented" % child)
 
     def draw_line(self, ax, line, force_trans=None):
         """Process a matplotlib line and call renderer.draw_line"""
-        coordinates, data = self.process_transform(line.get_transform(),
-                                                   ax, line.get_xydata(),
-                                                   force_trans=force_trans)
+        coordinates, data = self.process_transform(
+            line.get_transform(), ax, line.get_xydata(), force_trans=force_trans
+        )
         linestyle = utils.get_line_style(line)
-        if (linestyle['dasharray'] is None
-                and linestyle['drawstyle'] == 'default'):
+        if linestyle["dasharray"] is None and linestyle["drawstyle"] == "default":
             linestyle = None
         markerstyle = utils.get_marker_style(line)
-        if (markerstyle['marker'] in ['None', 'none', None]
-                or markerstyle['markerpath'][0].size == 0):
+        if (
+            markerstyle["marker"] in ["None", "none", None]
+            or markerstyle["markerpath"][0].size == 0
+        ):
             markerstyle = None
         label = line.get_label()
         if markerstyle or linestyle:
-            self.renderer.draw_marked_line(data=data, coordinates=coordinates,
-                                           linestyle=linestyle,
-                                           markerstyle=markerstyle,
-                                           label=label,
-                                           mplobj=line)
+            self.renderer.draw_marked_line(
+                data=data,
+                coordinates=coordinates,
+                linestyle=linestyle,
+                markerstyle=markerstyle,
+                label=label,
+                mplobj=line,
+            )
 
     def draw_text(self, ax, text, force_trans=None, text_type=None):
         """Process a matplotlib text object and call renderer.draw_text"""
         content = text.get_text()
         if content:
             transform = text.get_transform()
             position = text.get_position()
-            coords, position = self.process_transform(transform, ax,
-                                                      position,
-                                                      force_trans=force_trans)
+            coords, position = self.process_transform(
+                transform, ax, position, force_trans=force_trans
+            )
             style = utils.get_text_style(text)
-            self.renderer.draw_text(text=content, position=position,
-                                    coordinates=coords,
-                                    text_type=text_type,
-                                    style=style, mplobj=text)
+            self.renderer.draw_text(
+                text=content,
+                position=position,
+                coordinates=coords,
+                text_type=text_type,
+                style=style,
+                mplobj=text,
+            )
 
     def draw_patch(self, ax, patch, force_trans=None):
         """Process a matplotlib patch object and call renderer.draw_path"""
         vertices, pathcodes = utils.SVG_path(patch.get_path())
         transform = patch.get_transform()
-        coordinates, vertices = self.process_transform(transform,
-                                                       ax, vertices,
-                                                       force_trans=force_trans)
+        coordinates, vertices = self.process_transform(
+            transform, ax, vertices, force_trans=force_trans
+        )
         linestyle = utils.get_path_style(patch, fill=patch.get_fill())
-        self.renderer.draw_path(data=vertices,
-                                coordinates=coordinates,
-                                pathcodes=pathcodes,
-                                style=linestyle,
-                                mplobj=patch)
+        self.renderer.draw_path(
+            data=vertices,
+            coordinates=coordinates,
+            pathcodes=pathcodes,
+            style=linestyle,
+            mplobj=patch,
+        )
 
-    def draw_collection(self, ax, collection,
-                        force_pathtrans=None,
-                        force_offsettrans=None):
+    def draw_collection(
+        self, ax, collection, force_pathtrans=None, force_offsettrans=None
+    ):
         """Process a matplotlib collection and call renderer.draw_collection"""
-        (transform, transOffset,
-         offsets, paths) = collection._prepare_points()
+        (transform, transOffset, offsets, paths) = collection._prepare_points()
 
         offset_coords, offsets = self.process_transform(
-            transOffset, ax, offsets, force_trans=force_offsettrans)
-        path_coords = self.process_transform(
-            transform, ax, force_trans=force_pathtrans)
+            transOffset, ax, offsets, force_trans=force_offsettrans
+        )
+        path_coords = self.process_transform(transform, ax, force_trans=force_pathtrans)
 
         processed_paths = [utils.SVG_path(path) for path in paths]
-        processed_paths = [(self.process_transform(
-            transform, ax, path[0], force_trans=force_pathtrans)[1], path[1])
-                           for path in processed_paths]
+        processed_paths = [
+            (
+                self.process_transform(
+                    transform, ax, path[0], force_trans=force_pathtrans
+                )[1],
+                path[1],
+            )
+            for path in processed_paths
+        ]
 
         path_transforms = collection.get_transforms()
         try:
@@ -256,30 +277,34 @@ def draw_collection(self, ax, collection,
             # matplotlib 1.4: path transforms are already numpy arrays.
             pass
 
-        styles = {'linewidth': collection.get_linewidths(),
-                  'facecolor': collection.get_facecolors(),
-                  'edgecolor': collection.get_edgecolors(),
-                  'alpha': collection._alpha,
-                  'zorder': collection.get_zorder()}
+        styles = {
+            "linewidth": collection.get_linewidths(),
+            "facecolor": collection.get_facecolors(),
+            "edgecolor": collection.get_edgecolors(),
+            "alpha": collection._alpha,
+            "zorder": collection.get_zorder(),
+        }
 
-        offset_dict = {"data": "before",
-                       "screen": "after"}
+        offset_dict = {"data": "before", "screen": "after"}
         offset_order = offset_dict[collection.get_offset_position()]
 
-        self.renderer.draw_path_collection(paths=processed_paths,
-                                           path_coordinates=path_coords,
-                                           path_transforms=path_transforms,
-                                           offsets=offsets,
-                                           offset_coordinates=offset_coords,
-                                           offset_order=offset_order,
-                                           styles=styles,
-                                           mplobj=collection)
+        self.renderer.draw_path_collection(
+            paths=processed_paths,
+            path_coordinates=path_coords,
+            path_transforms=path_transforms,
+            offsets=offsets,
+            offset_coordinates=offset_coords,
+            offset_order=offset_order,
+            styles=styles,
+            mplobj=collection,
+        )
 
     def draw_image(self, ax, image):
         """Process a matplotlib image object and call renderer.draw_image"""
-        self.renderer.draw_image(imdata=utils.image_to_base64(image),
-                                 extent=image.get_extent(),
-                                 coordinates="data",
-                                 style={"alpha": image.get_alpha(),
-                                        "zorder": image.get_zorder()},
-                                 mplobj=image)
+        self.renderer.draw_image(
+            imdata=utils.image_to_base64(image),
+            extent=image.get_extent(),
+            coordinates="data",
+            style={"alpha": image.get_alpha(), "zorder": image.get_zorder()},
+            mplobj=image,
+        )