Move the debug-mode TransformNode.write_graphviz out.

anntzer · anntzer · commit 172baa1fe3ea · 2019-07-09T14:17:14.000+02:00
It was only accessible by modifying the source of transforms.py to set
DEBUG to True (before the module is imported), and anyways broken
because transforms are not hashable in Py3 (so the call to hash()
fails).

Instead move it to a private module.

Example use:
```
from matplotlib._internal_utils import graphviz_dump_transform
graphviz_dump_transform(plt.gca().transAxes, "/tmp/test.png")
```

Also, stop tracking transform node children even in debug mode, as it
was only used when dumping the transform but that's not even necessary
-- one can just inspect `vars(node)` to look for children.

Also fix `AffineBase.__eq__` to check that the "other" object has a
get_matrix method, to not raise an AttributeError when comparing with
Bboxes (which don't).
diff --git a/lib/matplotlib/_internal_utils.py b/lib/matplotlib/_internal_utils.py
@@ -0,0 +1,64 @@
+"""
+Internal debugging utilities, that are not expected to be used in the rest of
+the codebase.
+
+WARNING: Code in this module may change without prior notice!
+"""
+
+from io import StringIO
+from pathlib import Path
+import subprocess
+
+from matplotlib.transforms import TransformNode
+
+
+def graphviz_dump_transform(transform, dest, *, highlight=None):
+    """
+    Generate a graphical representation of the transform tree for *transform*
+    using the :program:`dot` program (which this function depends on).  The
+    output format (png, dot, etc.) is determined from the suffix of *dest*.
+
+    Parameters
+    ----------
+    transform : `~matplotlib.transform.Transform`
+        The represented transform.
+    dst : str
+        Output filename.  The extension must be one of the formats supported
+        by :program:`dot`, e.g. png, svg, dot, ...
+        (see https://www.graphviz.org/doc/info/output.html).
+    highlight : list of `~matplotlib.transform.Transform` or None
+        The transforms in the tree to be drawn in bold.
+        If *None*, *transform* is highlighted.
+    """
+
+    if highlight is None:
+        highlight = [transform]
+    seen = set()
+
+    def recurse(root, buf):
+        if id(root) in seen:
+            return
+        seen.add(id(root))
+        props = {}
+        label = type(root).__name__
+        if root._invalid:
+            label = f'[{label}]'
+        if root in highlight:
+            props['style'] = 'bold'
+        props['shape'] = 'box'
+        props['label'] = '"%s"' % label
+        props = ' '.join(map('{0[0]}={0[1]}'.format, props.items()))
+        buf.write(f'{id(root)} [{props}];\n')
+        for key, val in vars(root).items():
+            if isinstance(val, TransformNode) and id(root) in val._parents:
+                buf.write(f'"{id(root)}" -> "{id(val)}" '
+                          f'[label="{key}", fontsize=10];\n')
+                recurse(val, buf)
+
+    buf = StringIO()
+    buf.write('digraph G {\n')
+    recurse(transform, buf)
+    buf.write('}\n')
+    subprocess.run(
+        ['dot', '-T', Path(dest).suffix[1:], '-o', dest],
+        input=buf.getvalue().encode('utf-8'), check=True)
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -178,14 +178,6 @@ def set_children(self, *children):
                                         target=child._parents: target.pop(sid))
             child._parents[id(self)] = ref
 
-    if DEBUG:
-        _set_children = set_children
-
-        def set_children(self, *children):
-            self._set_children(*children)
-            self._children = children
-        set_children.__doc__ = _set_children.__doc__
-
     def frozen(self):
         """
         Returns a frozen copy of this transform node.  The frozen copy
@@ -195,58 +187,6 @@ def frozen(self):
         """
         return self
 
-    if DEBUG:
-        def write_graphviz(self, fobj, highlight=[]):
-            """
-            For debugging purposes.
-
-            Writes the transform tree rooted at 'self' to a graphviz "dot"
-            format file.  This file can be run through the "dot" utility
-            to produce a graph of the transform tree.
-
-            Affine transforms are marked in blue.  Bounding boxes are
-            marked in yellow.
-
-            *fobj*: A Python file-like object
-
-            Once the "dot" file has been created, it can be turned into a
-            png easily with::
-
-                $> dot -Tpng -o $OUTPUT_FILE $DOT_FILE
-
-            """
-            seen = set()
-
-            def recurse(root):
-                if root in seen:
-                    return
-                seen.add(root)
-                props = {}
-                label = root.__class__.__name__
-                if root._invalid:
-                    label = '[%s]' % label
-                if root in highlight:
-                    props['style'] = 'bold'
-                props['shape'] = 'box'
-                props['label'] = '"%s"' % label
-                props = ' '.join(map('{0[0]}={0[1]}'.format, props.items()))
-
-                fobj.write('%s [%s];\n' % (hash(root), props))
-
-                if hasattr(root, '_children'):
-                    for child in root._children:
-                        name = next((key for key, val in root.__dict__.items()
-                                     if val is child), '?')
-                        fobj.write('"%s" -> "%s" [label="%s", fontsize=10];\n'
-                                    % (hash(root),
-                                    hash(child),
-                                    name))
-                        recurse(child)
-
-            fobj.write("digraph G {\n")
-            recurse(self)
-            fobj.write("}\n")
-
 
 class BboxBase(TransformNode):
     """
@@ -1670,7 +1610,7 @@ def __array__(self, *args, **kwargs):
         return self.get_matrix()
 
     def __eq__(self, other):
-        if getattr(other, "is_affine", False):
+        if getattr(other, "is_affine", False) and hasattr(other, "get_matrix"):
             return np.all(self.get_matrix() == other.get_matrix())
         return NotImplemented
 
