Add pretty print based __repr__() for BaseFigure and BasePlotlyType

Author: Jon M. Mease

plotly/basedatatypes.py

@@ -4,6 +4,7 @@
 import warnings
 from contextlib import contextmanager
 from copy import deepcopy
+from pprint import PrettyPrinter
 from typing import Dict, Tuple, Union, Callable, List
 
 from plotly.optional_imports import get_module
@@ -15,6 +16,7 @@
 from plotly import animation
 from plotly.callbacks import (Points, BoxSelector, LassoSelector,
                               InputDeviceState)
+from plotly.utils import ElidedPrettyPrinter
 from plotly.validators import (DataValidator, LayoutValidator, FramesValidator)
 
 # Optional imports
@@ -242,6 +244,17 @@ def __eq__(self, other):
             return BasePlotlyType._vals_equal(self.to_plotly_json(),
                                               other.to_plotly_json())
 
+    def __repr__(self):
+        """
+        Customize Figure representation when displayed in the
+        terminal/notebook
+        """
+        repr_str = BasePlotlyType._build_repr_for_class(
+            props=self.to_plotly_json(),
+            class_name=self.__class__.__name__)
+
+        return repr_str
+
     def update(self, dict1=None, **kwargs):
         """
         Update the properties of the figure with a dict and/or with
@@ -2556,8 +2569,53 @@ def __eq__(self, other):
 
             # Use _vals_equal instead of `==` to handle cases where
             # underlying dicts contain numpy arrays
-            return BasePlotlyType._vals_equal(self.to_plotly_json(),
-                                              other.to_plotly_json())
+            return BasePlotlyType._vals_equal(self._props,
+                                              other._props)
+
+    @staticmethod
+    def _build_repr_for_class(props, class_name, parent_path_str=None):
+        """
+        Helper to build representation string for a class
+
+        Parameters
+        ----------
+        class_name : str
+            Name of the class being represented
+        parent_path_str : str of None (default)
+            Name of the class's parent package to display
+        props : dict
+            Properties to unpack into the constructor
+
+        Returns
+        -------
+        str
+            The representation string
+        """
+        if parent_path_str:
+            class_name = parent_path_str + '.' + class_name
+
+        pprinter = ElidedPrettyPrinter(threshold=200, width=120)
+        pprint_res = pprinter.pformat(props)
+
+        # pprint_res is indented by 1 space. Add extra 3 spaces for PEP8
+        # complaint indent
+        body = '   ' + pprint_res[1:-1].replace('\n', '\n   ')
+
+        repr_str = class_name + '(**{\n ' + body + '\n})'
+
+        return repr_str
+
+    def __repr__(self):
+        """
+        Customize object representation when displayed in the
+        terminal/notebook
+        """
+        repr_str = BasePlotlyType._build_repr_for_class(
+            props=self._props,
+            class_name=self.__class__.__name__,
+            parent_path_str=self._parent_path_str)
+
+        return repr_str
 
     def _raise_on_invalid_property_error(self, *args):
         """

plotly/callbacks.py

@@ -146,9 +146,12 @@ def __repr__(self):
        ys={ys},
        trace_name={trace_name},
        trace_index={trace_index})""".format(
-            point_inds=_list_repr_elided(self.point_inds),
-            xs=_list_repr_elided(self.xs),
-            ys=_list_repr_elided(self.ys),
+            point_inds=_list_repr_elided(self.point_inds,
+                                         indent=len('Points(point_inds=')),
+            xs=_list_repr_elided(self.xs,
+                                 indent=len('       xs=')),
+            ys=_list_repr_elided(self.ys,
+                                 indent=len('       ys=')),
             trace_name=repr(self.trace_name),
             trace_index=repr(self.trace_index))
 
@@ -265,8 +268,10 @@ def __repr__(self):
         return """\
 LassoSelector(xs={xs},
               ys={ys})""".format(
-            xs=_list_repr_elided(self.xs, 8),
-            ys=_list_repr_elided(self.ys, 8))
+            xs=_list_repr_elided(self.xs,
+                                 indent=len('LassoSelector(xs=')),
+            ys=_list_repr_elided(self.ys,
+                                 indent=len('              ys=')))
 
     @property
     def type(self):

plotly/utils.py

@@ -10,9 +10,11 @@
 import os.path
 import re
 import sys
+import textwrap
 import threading
 import decimal
 from collections import deque
+from pprint import PrettyPrinter
 
 import pytz
 from decorator import decorator
@@ -492,7 +494,7 @@ def _memoize(*all_args, **kwargs):
     return decorator(_memoize)
 
 
-def _list_repr_elided(v, n=20):
+def _list_repr_elided(v, threshold=200, edgeitems=3, indent=0, width=80):
     """
     Return a string representation for of a list where list is elided if
     it has more than n elements
@@ -501,15 +503,114 @@ def _list_repr_elided(v, n=20):
     ----------
     v : list
         Input list
-    n :
+    threshold :
         Maximum number of elements to display
 
     Returns
     -------
     str
     """
-    if len(v) <= n:
-        return str(v)
+    if isinstance(v, list):
+        open_char, close_char = '[', ']'
+    elif isinstance(v, tuple):
+        open_char, close_char = '(', ')'
     else:
-        disp_v = v[:n // 2 - 1] + ['...'] + v[-n // 2 + 1:]
-        return '[' + ', '.join([str(e) for e in disp_v]) + ']'
+        raise ValueError('Invalid value of type: %s' % type(v))
+
+    if len(v) <= threshold:
+        disp_v = v
+    else:
+        disp_v = (list(v[:edgeitems])
+                  + ['...'] +
+                  list(v[-edgeitems:]))
+
+    v_str = open_char + ', '.join([str(e) for e in disp_v]) + close_char
+
+    v_wrapped = '\n'.join(textwrap.wrap(v_str, width=width,
+                          initial_indent=' ' * (indent + 1),
+                          subsequent_indent =' ' * (indent + 1))).strip()
+    return v_wrapped
+
+
+class ElidedWrapper:
+    """
+    Helper class that wraps values of certain types and produces a custom
+    __repr__() that may be elided and is suitable for use during pretty
+    printing
+    """
+    def __init__(self, v, threshold, indent):
+        self.v = v
+        self.indent = indent
+        self.threshold = threshold
+
+    @staticmethod
+    def is_wrappable(v):
+        if (isinstance(v, (list, tuple)) and
+                len(v) > 0 and
+                not isinstance(v[0], dict)):
+            return True
+        elif numpy and isinstance(v, numpy.ndarray):
+            return True
+        elif isinstance(v, str):
+            return True
+        else:
+            return False
+
+    def __repr__(self):
+        if isinstance(self.v, (list, tuple)):
+            # Handle lists/tuples
+            res = _list_repr_elided(self.v,
+                                    threshold=self.threshold,
+                                    indent=self.indent)
+            return res
+        elif numpy and isinstance(self.v, numpy.ndarray):
+            # Handle numpy arrays
+
+            # Get original print opts
+            orig_opts = numpy.get_printoptions()
+
+            # Set threshold to self.max_list_elements
+            numpy.set_printoptions(
+                **dict(orig_opts,
+                       threshold=self.threshold,
+                       edgeitems=3,
+                       linewidth=80))
+
+            res = self.v.__repr__()
+
+            # Add indent to all but the first line
+            res_lines = res.split('\n')
+            res = ('\n' + ' '*self.indent).join(res_lines)
+
+            # Restore print opts
+            numpy.set_printoptions(**orig_opts)
+            return res
+        elif isinstance(self.v, str):
+            # Handle strings
+            if len(self.v) > 80:
+                return ('(' + repr(self.v[:30]) +
+                        ' ... ' + repr(self.v[-30:]) + ')')
+            else:
+                return self.v.__repr__()
+        else:
+            return self.v.__repr__()
+
+
+class ElidedPrettyPrinter(PrettyPrinter):
+    """
+    PrettyPrinter subclass that elides long lists/arrays/strings
+    """
+    def __init__(self, *args, **kwargs):
+        self.threshold = kwargs.pop('threshold', 200)
+        super().__init__(*args, **kwargs)
+
+    def _format(self, val, stream, indent, allowance, context, level):
+        if ElidedWrapper.is_wrappable(val):
+            elided_val = ElidedWrapper(
+                val, self.threshold, indent)
+
+            return self._format(
+                elided_val, stream, indent, allowance, context, level)
+        else:
+            return super()._format(
+                val, stream, indent, allowance, context, level)