Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 579 insertions, 579 deletions

diff --git a/contrib/tools/python3/src/Lib/pprint.py b/contrib/tools/python3/src/Lib/pprint.py
index 7c1118a484..72b4cbd9cc 100644
--- a/contrib/tools/python3/src/Lib/pprint.py
+++ b/contrib/tools/python3/src/Lib/pprint.py
@@ -1,347 +1,347 @@
-#  Author:      Fred L. Drake, Jr.
-#               fdrake@acm.org
-#
-#  This is a simple little module I wrote to make life easier.  I didn't
-#  see anything quite like it in the library, though I may have overlooked
-#  something.  I wrote this when I was trying to read some heavily nested
-#  tuples with fairly non-descriptive content.  This is modeled very much
-#  after Lisp/Scheme - style pretty-printing of lists.  If you find it
-#  useful, thank small children who sleep at night.
-
-"""Support to pretty-print lists, tuples, & dictionaries recursively.
-
-Very simple, but useful, especially in debugging data structures.
-
-Classes
--------
-
-PrettyPrinter()
-    Handle pretty-printing operations onto a stream using a configured
-    set of formatting parameters.
-
-Functions
----------
-
-pformat()
-    Format a Python object into a pretty-printed representation.
-
-pprint()
-    Pretty-print a Python object to a stream [default is sys.stdout].
-
-saferepr()
-    Generate a 'standard' repr()-like value, but protect against recursive
-    data structures.
-
-"""
-
-import collections as _collections
-import re
-import sys as _sys
-import types as _types
-from io import StringIO as _StringIO
-
-__all__ = ["pprint","pformat","isreadable","isrecursive","saferepr",
+#  Author:      Fred L. Drake, Jr. 
+#               fdrake@acm.org 
+# 
+#  This is a simple little module I wrote to make life easier.  I didn't 
+#  see anything quite like it in the library, though I may have overlooked 
+#  something.  I wrote this when I was trying to read some heavily nested 
+#  tuples with fairly non-descriptive content.  This is modeled very much 
+#  after Lisp/Scheme - style pretty-printing of lists.  If you find it 
+#  useful, thank small children who sleep at night. 
+ 
+"""Support to pretty-print lists, tuples, & dictionaries recursively. 
+ 
+Very simple, but useful, especially in debugging data structures. 
+ 
+Classes 
+------- 
+ 
+PrettyPrinter() 
+    Handle pretty-printing operations onto a stream using a configured 
+    set of formatting parameters. 
+ 
+Functions 
+--------- 
+ 
+pformat() 
+    Format a Python object into a pretty-printed representation. 
+ 
+pprint() 
+    Pretty-print a Python object to a stream [default is sys.stdout]. 
+ 
+saferepr() 
+    Generate a 'standard' repr()-like value, but protect against recursive 
+    data structures. 
+ 
+""" 
+ 
+import collections as _collections 
+import re 
+import sys as _sys 
+import types as _types 
+from io import StringIO as _StringIO 
+ 
+__all__ = ["pprint","pformat","isreadable","isrecursive","saferepr", 
            "PrettyPrinter", "pp"]
-
-
-def pprint(object, stream=None, indent=1, width=80, depth=None, *,
+ 
+ 
+def pprint(object, stream=None, indent=1, width=80, depth=None, *, 
            compact=False, sort_dicts=True):
-    """Pretty-print a Python object to a stream [default is sys.stdout]."""
-    printer = PrettyPrinter(
-        stream=stream, indent=indent, width=width, depth=depth,
+    """Pretty-print a Python object to a stream [default is sys.stdout].""" 
+    printer = PrettyPrinter( 
+        stream=stream, indent=indent, width=width, depth=depth, 
         compact=compact, sort_dicts=sort_dicts)
-    printer.pprint(object)
-
+    printer.pprint(object) 
+ 
 def pformat(object, indent=1, width=80, depth=None, *,
             compact=False, sort_dicts=True):
-    """Format a Python object into a pretty-printed representation."""
-    return PrettyPrinter(indent=indent, width=width, depth=depth,
+    """Format a Python object into a pretty-printed representation.""" 
+    return PrettyPrinter(indent=indent, width=width, depth=depth, 
                          compact=compact, sort_dicts=sort_dicts).pformat(object)
-
+ 
 def pp(object, *args, sort_dicts=False, **kwargs):
     """Pretty-print a Python object"""
     pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
 
-def saferepr(object):
-    """Version of repr() which can handle recursive data structures."""
+def saferepr(object): 
+    """Version of repr() which can handle recursive data structures.""" 
     return _safe_repr(object, {}, None, 0, True)[0]
-
-def isreadable(object):
-    """Determine if saferepr(object) is readable by eval()."""
+ 
+def isreadable(object): 
+    """Determine if saferepr(object) is readable by eval().""" 
     return _safe_repr(object, {}, None, 0, True)[1]
-
-def isrecursive(object):
-    """Determine if object requires a recursive representation."""
+ 
+def isrecursive(object): 
+    """Determine if object requires a recursive representation.""" 
     return _safe_repr(object, {}, None, 0, True)[2]
-
-class _safe_key:
-    """Helper function for key functions when sorting unorderable objects.
-
-    The wrapped-object will fallback to a Py2.x style comparison for
-    unorderable types (sorting first comparing the type name and then by
-    the obj ids).  Does not work recursively, so dict.items() must have
-    _safe_key applied to both the key and the value.
-
-    """
-
-    __slots__ = ['obj']
-
-    def __init__(self, obj):
-        self.obj = obj
-
-    def __lt__(self, other):
-        try:
-            return self.obj < other.obj
-        except TypeError:
-            return ((str(type(self.obj)), id(self.obj)) < \
-                    (str(type(other.obj)), id(other.obj)))
-
-def _safe_tuple(t):
-    "Helper function for comparing 2-tuples"
-    return _safe_key(t[0]), _safe_key(t[1])
-
-class PrettyPrinter:
-    def __init__(self, indent=1, width=80, depth=None, stream=None, *,
+ 
+class _safe_key: 
+    """Helper function for key functions when sorting unorderable objects. 
+ 
+    The wrapped-object will fallback to a Py2.x style comparison for 
+    unorderable types (sorting first comparing the type name and then by 
+    the obj ids).  Does not work recursively, so dict.items() must have 
+    _safe_key applied to both the key and the value. 
+ 
+    """ 
+ 
+    __slots__ = ['obj'] 
+ 
+    def __init__(self, obj): 
+        self.obj = obj 
+ 
+    def __lt__(self, other): 
+        try: 
+            return self.obj < other.obj 
+        except TypeError: 
+            return ((str(type(self.obj)), id(self.obj)) < \ 
+                    (str(type(other.obj)), id(other.obj))) 
+ 
+def _safe_tuple(t): 
+    "Helper function for comparing 2-tuples" 
+    return _safe_key(t[0]), _safe_key(t[1]) 
+ 
+class PrettyPrinter: 
+    def __init__(self, indent=1, width=80, depth=None, stream=None, *, 
                  compact=False, sort_dicts=True):
-        """Handle pretty printing operations onto a stream using a set of
-        configured parameters.
-
-        indent
-            Number of spaces to indent for each level of nesting.
-
-        width
-            Attempted maximum number of columns in the output.
-
-        depth
-            The maximum depth to print out nested structures.
-
-        stream
-            The desired output stream.  If omitted (or false), the standard
-            output stream available at construction will be used.
-
-        compact
-            If true, several items will be combined in one line.
-
+        """Handle pretty printing operations onto a stream using a set of 
+        configured parameters. 
+ 
+        indent 
+            Number of spaces to indent for each level of nesting. 
+ 
+        width 
+            Attempted maximum number of columns in the output. 
+ 
+        depth 
+            The maximum depth to print out nested structures. 
+ 
+        stream 
+            The desired output stream.  If omitted (or false), the standard 
+            output stream available at construction will be used. 
+ 
+        compact 
+            If true, several items will be combined in one line. 
+ 
         sort_dicts
             If true, dict keys are sorted.
 
-        """
-        indent = int(indent)
-        width = int(width)
-        if indent < 0:
-            raise ValueError('indent must be >= 0')
-        if depth is not None and depth <= 0:
-            raise ValueError('depth must be > 0')
-        if not width:
-            raise ValueError('width must be != 0')
-        self._depth = depth
-        self._indent_per_level = indent
-        self._width = width
-        if stream is not None:
-            self._stream = stream
-        else:
-            self._stream = _sys.stdout
-        self._compact = bool(compact)
+        """ 
+        indent = int(indent) 
+        width = int(width) 
+        if indent < 0: 
+            raise ValueError('indent must be >= 0') 
+        if depth is not None and depth <= 0: 
+            raise ValueError('depth must be > 0') 
+        if not width: 
+            raise ValueError('width must be != 0') 
+        self._depth = depth 
+        self._indent_per_level = indent 
+        self._width = width 
+        if stream is not None: 
+            self._stream = stream 
+        else: 
+            self._stream = _sys.stdout 
+        self._compact = bool(compact) 
         self._sort_dicts = sort_dicts
-
-    def pprint(self, object):
-        self._format(object, self._stream, 0, 0, {}, 0)
-        self._stream.write("\n")
-
-    def pformat(self, object):
-        sio = _StringIO()
-        self._format(object, sio, 0, 0, {}, 0)
-        return sio.getvalue()
-
-    def isrecursive(self, object):
-        return self.format(object, {}, 0, 0)[2]
-
-    def isreadable(self, object):
-        s, readable, recursive = self.format(object, {}, 0, 0)
-        return readable and not recursive
-
-    def _format(self, object, stream, indent, allowance, context, level):
-        objid = id(object)
-        if objid in context:
-            stream.write(_recursion(object))
-            self._recursive = True
-            self._readable = False
-            return
-        rep = self._repr(object, context, level)
-        max_width = self._width - indent - allowance
-        if len(rep) > max_width:
-            p = self._dispatch.get(type(object).__repr__, None)
-            if p is not None:
-                context[objid] = 1
-                p(self, object, stream, indent, allowance, context, level + 1)
-                del context[objid]
-                return
-            elif isinstance(object, dict):
-                context[objid] = 1
-                self._pprint_dict(object, stream, indent, allowance,
-                                  context, level + 1)
-                del context[objid]
-                return
-        stream.write(rep)
-
-    _dispatch = {}
-
-    def _pprint_dict(self, object, stream, indent, allowance, context, level):
-        write = stream.write
-        write('{')
-        if self._indent_per_level > 1:
-            write((self._indent_per_level - 1) * ' ')
-        length = len(object)
-        if length:
+ 
+    def pprint(self, object): 
+        self._format(object, self._stream, 0, 0, {}, 0) 
+        self._stream.write("\n") 
+ 
+    def pformat(self, object): 
+        sio = _StringIO() 
+        self._format(object, sio, 0, 0, {}, 0) 
+        return sio.getvalue() 
+ 
+    def isrecursive(self, object): 
+        return self.format(object, {}, 0, 0)[2] 
+ 
+    def isreadable(self, object): 
+        s, readable, recursive = self.format(object, {}, 0, 0) 
+        return readable and not recursive 
+ 
+    def _format(self, object, stream, indent, allowance, context, level): 
+        objid = id(object) 
+        if objid in context: 
+            stream.write(_recursion(object)) 
+            self._recursive = True 
+            self._readable = False 
+            return 
+        rep = self._repr(object, context, level) 
+        max_width = self._width - indent - allowance 
+        if len(rep) > max_width: 
+            p = self._dispatch.get(type(object).__repr__, None) 
+            if p is not None: 
+                context[objid] = 1 
+                p(self, object, stream, indent, allowance, context, level + 1) 
+                del context[objid] 
+                return 
+            elif isinstance(object, dict): 
+                context[objid] = 1 
+                self._pprint_dict(object, stream, indent, allowance, 
+                                  context, level + 1) 
+                del context[objid] 
+                return 
+        stream.write(rep) 
+ 
+    _dispatch = {} 
+ 
+    def _pprint_dict(self, object, stream, indent, allowance, context, level): 
+        write = stream.write 
+        write('{') 
+        if self._indent_per_level > 1: 
+            write((self._indent_per_level - 1) * ' ') 
+        length = len(object) 
+        if length: 
             if self._sort_dicts:
                 items = sorted(object.items(), key=_safe_tuple)
             else:
                 items = object.items()
-            self._format_dict_items(items, stream, indent, allowance + 1,
-                                    context, level)
-        write('}')
-
-    _dispatch[dict.__repr__] = _pprint_dict
-
-    def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level):
-        if not len(object):
-            stream.write(repr(object))
-            return
-        cls = object.__class__
-        stream.write(cls.__name__ + '(')
-        self._format(list(object.items()), stream,
-                     indent + len(cls.__name__) + 1, allowance + 1,
-                     context, level)
-        stream.write(')')
-
-    _dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict
-
-    def _pprint_list(self, object, stream, indent, allowance, context, level):
-        stream.write('[')
-        self._format_items(object, stream, indent, allowance + 1,
-                           context, level)
-        stream.write(']')
-
-    _dispatch[list.__repr__] = _pprint_list
-
-    def _pprint_tuple(self, object, stream, indent, allowance, context, level):
-        stream.write('(')
-        endchar = ',)' if len(object) == 1 else ')'
-        self._format_items(object, stream, indent, allowance + len(endchar),
-                           context, level)
-        stream.write(endchar)
-
-    _dispatch[tuple.__repr__] = _pprint_tuple
-
-    def _pprint_set(self, object, stream, indent, allowance, context, level):
-        if not len(object):
-            stream.write(repr(object))
-            return
-        typ = object.__class__
-        if typ is set:
-            stream.write('{')
-            endchar = '}'
-        else:
-            stream.write(typ.__name__ + '({')
-            endchar = '})'
-            indent += len(typ.__name__) + 1
-        object = sorted(object, key=_safe_key)
-        self._format_items(object, stream, indent, allowance + len(endchar),
-                           context, level)
-        stream.write(endchar)
-
-    _dispatch[set.__repr__] = _pprint_set
-    _dispatch[frozenset.__repr__] = _pprint_set
-
-    def _pprint_str(self, object, stream, indent, allowance, context, level):
-        write = stream.write
-        if not len(object):
-            write(repr(object))
-            return
-        chunks = []
-        lines = object.splitlines(True)
-        if level == 1:
-            indent += 1
-            allowance += 1
-        max_width1 = max_width = self._width - indent
-        for i, line in enumerate(lines):
-            rep = repr(line)
-            if i == len(lines) - 1:
-                max_width1 -= allowance
-            if len(rep) <= max_width1:
-                chunks.append(rep)
-            else:
-                # A list of alternating (non-space, space) strings
-                parts = re.findall(r'\S*\s*', line)
-                assert parts
-                assert not parts[-1]
-                parts.pop()  # drop empty last part
-                max_width2 = max_width
-                current = ''
-                for j, part in enumerate(parts):
-                    candidate = current + part
-                    if j == len(parts) - 1 and i == len(lines) - 1:
-                        max_width2 -= allowance
-                    if len(repr(candidate)) > max_width2:
-                        if current:
-                            chunks.append(repr(current))
-                        current = part
-                    else:
-                        current = candidate
-                if current:
-                    chunks.append(repr(current))
-        if len(chunks) == 1:
-            write(rep)
-            return
-        if level == 1:
-            write('(')
-        for i, rep in enumerate(chunks):
-            if i > 0:
-                write('\n' + ' '*indent)
-            write(rep)
-        if level == 1:
-            write(')')
-
-    _dispatch[str.__repr__] = _pprint_str
-
-    def _pprint_bytes(self, object, stream, indent, allowance, context, level):
-        write = stream.write
-        if len(object) <= 4:
-            write(repr(object))
-            return
-        parens = level == 1
-        if parens:
-            indent += 1
-            allowance += 1
-            write('(')
-        delim = ''
-        for rep in _wrap_bytes_repr(object, self._width - indent, allowance):
-            write(delim)
-            write(rep)
-            if not delim:
-                delim = '\n' + ' '*indent
-        if parens:
-            write(')')
-
-    _dispatch[bytes.__repr__] = _pprint_bytes
-
-    def _pprint_bytearray(self, object, stream, indent, allowance, context, level):
-        write = stream.write
-        write('bytearray(')
-        self._pprint_bytes(bytes(object), stream, indent + 10,
-                           allowance + 1, context, level + 1)
-        write(')')
-
-    _dispatch[bytearray.__repr__] = _pprint_bytearray
-
-    def _pprint_mappingproxy(self, object, stream, indent, allowance, context, level):
-        stream.write('mappingproxy(')
-        self._format(object.copy(), stream, indent + 13, allowance + 1,
-                     context, level)
-        stream.write(')')
-
-    _dispatch[_types.MappingProxyType.__repr__] = _pprint_mappingproxy
-
+            self._format_dict_items(items, stream, indent, allowance + 1, 
+                                    context, level) 
+        write('}') 
+ 
+    _dispatch[dict.__repr__] = _pprint_dict 
+ 
+    def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level): 
+        if not len(object): 
+            stream.write(repr(object)) 
+            return 
+        cls = object.__class__ 
+        stream.write(cls.__name__ + '(') 
+        self._format(list(object.items()), stream, 
+                     indent + len(cls.__name__) + 1, allowance + 1, 
+                     context, level) 
+        stream.write(')') 
+ 
+    _dispatch[_collections.OrderedDict.__repr__] = _pprint_ordered_dict 
+ 
+    def _pprint_list(self, object, stream, indent, allowance, context, level): 
+        stream.write('[') 
+        self._format_items(object, stream, indent, allowance + 1, 
+                           context, level) 
+        stream.write(']') 
+ 
+    _dispatch[list.__repr__] = _pprint_list 
+ 
+    def _pprint_tuple(self, object, stream, indent, allowance, context, level): 
+        stream.write('(') 
+        endchar = ',)' if len(object) == 1 else ')' 
+        self._format_items(object, stream, indent, allowance + len(endchar), 
+                           context, level) 
+        stream.write(endchar) 
+ 
+    _dispatch[tuple.__repr__] = _pprint_tuple 
+ 
+    def _pprint_set(self, object, stream, indent, allowance, context, level): 
+        if not len(object): 
+            stream.write(repr(object)) 
+            return 
+        typ = object.__class__ 
+        if typ is set: 
+            stream.write('{') 
+            endchar = '}' 
+        else: 
+            stream.write(typ.__name__ + '({') 
+            endchar = '})' 
+            indent += len(typ.__name__) + 1 
+        object = sorted(object, key=_safe_key) 
+        self._format_items(object, stream, indent, allowance + len(endchar), 
+                           context, level) 
+        stream.write(endchar) 
+ 
+    _dispatch[set.__repr__] = _pprint_set 
+    _dispatch[frozenset.__repr__] = _pprint_set 
+ 
+    def _pprint_str(self, object, stream, indent, allowance, context, level): 
+        write = stream.write 
+        if not len(object): 
+            write(repr(object)) 
+            return 
+        chunks = [] 
+        lines = object.splitlines(True) 
+        if level == 1: 
+            indent += 1 
+            allowance += 1 
+        max_width1 = max_width = self._width - indent 
+        for i, line in enumerate(lines): 
+            rep = repr(line) 
+            if i == len(lines) - 1: 
+                max_width1 -= allowance 
+            if len(rep) <= max_width1: 
+                chunks.append(rep) 
+            else: 
+                # A list of alternating (non-space, space) strings 
+                parts = re.findall(r'\S*\s*', line) 
+                assert parts 
+                assert not parts[-1] 
+                parts.pop()  # drop empty last part 
+                max_width2 = max_width 
+                current = '' 
+                for j, part in enumerate(parts): 
+                    candidate = current + part 
+                    if j == len(parts) - 1 and i == len(lines) - 1: 
+                        max_width2 -= allowance 
+                    if len(repr(candidate)) > max_width2: 
+                        if current: 
+                            chunks.append(repr(current)) 
+                        current = part 
+                    else: 
+                        current = candidate 
+                if current: 
+                    chunks.append(repr(current)) 
+        if len(chunks) == 1: 
+            write(rep) 
+            return 
+        if level == 1: 
+            write('(') 
+        for i, rep in enumerate(chunks): 
+            if i > 0: 
+                write('\n' + ' '*indent) 
+            write(rep) 
+        if level == 1: 
+            write(')') 
+ 
+    _dispatch[str.__repr__] = _pprint_str 
+ 
+    def _pprint_bytes(self, object, stream, indent, allowance, context, level): 
+        write = stream.write 
+        if len(object) <= 4: 
+            write(repr(object)) 
+            return 
+        parens = level == 1 
+        if parens: 
+            indent += 1 
+            allowance += 1 
+            write('(') 
+        delim = '' 
+        for rep in _wrap_bytes_repr(object, self._width - indent, allowance): 
+            write(delim) 
+            write(rep) 
+            if not delim: 
+                delim = '\n' + ' '*indent 
+        if parens: 
+            write(')') 
+ 
+    _dispatch[bytes.__repr__] = _pprint_bytes 
+ 
+    def _pprint_bytearray(self, object, stream, indent, allowance, context, level): 
+        write = stream.write 
+        write('bytearray(') 
+        self._pprint_bytes(bytes(object), stream, indent + 10, 
+                           allowance + 1, context, level + 1) 
+        write(')') 
+ 
+    _dispatch[bytearray.__repr__] = _pprint_bytearray 
+ 
+    def _pprint_mappingproxy(self, object, stream, indent, allowance, context, level): 
+        stream.write('mappingproxy(') 
+        self._format(object.copy(), stream, indent + 13, allowance + 1, 
+                     context, level) 
+        stream.write(')') 
+ 
+    _dispatch[_types.MappingProxyType.__repr__] = _pprint_mappingproxy 
+ 
     def _pprint_simplenamespace(self, object, stream, indent, allowance, context, level):
         if type(object) is _types.SimpleNamespace:
             # The SimpleNamespace repr is "namespace" instead of the class
@@ -369,270 +369,270 @@ class PrettyPrinter:
 
     _dispatch[_types.SimpleNamespace.__repr__] = _pprint_simplenamespace
 
-    def _format_dict_items(self, items, stream, indent, allowance, context,
-                           level):
-        write = stream.write
-        indent += self._indent_per_level
-        delimnl = ',\n' + ' ' * indent
-        last_index = len(items) - 1
-        for i, (key, ent) in enumerate(items):
-            last = i == last_index
-            rep = self._repr(key, context, level)
-            write(rep)
-            write(': ')
-            self._format(ent, stream, indent + len(rep) + 2,
-                         allowance if last else 1,
-                         context, level)
-            if not last:
-                write(delimnl)
-
-    def _format_items(self, items, stream, indent, allowance, context, level):
-        write = stream.write
-        indent += self._indent_per_level
-        if self._indent_per_level > 1:
-            write((self._indent_per_level - 1) * ' ')
-        delimnl = ',\n' + ' ' * indent
-        delim = ''
-        width = max_width = self._width - indent + 1
-        it = iter(items)
-        try:
-            next_ent = next(it)
-        except StopIteration:
-            return
-        last = False
-        while not last:
-            ent = next_ent
-            try:
-                next_ent = next(it)
-            except StopIteration:
-                last = True
-                max_width -= allowance
-                width -= allowance
-            if self._compact:
-                rep = self._repr(ent, context, level)
-                w = len(rep) + 2
-                if width < w:
-                    width = max_width
-                    if delim:
-                        delim = delimnl
-                if width >= w:
-                    width -= w
-                    write(delim)
-                    delim = ', '
-                    write(rep)
-                    continue
-            write(delim)
-            delim = delimnl
-            self._format(ent, stream, indent,
-                         allowance if last else 1,
-                         context, level)
-
-    def _repr(self, object, context, level):
-        repr, readable, recursive = self.format(object, context.copy(),
-                                                self._depth, level)
-        if not readable:
-            self._readable = False
-        if recursive:
-            self._recursive = True
-        return repr
-
-    def format(self, object, context, maxlevels, level):
-        """Format object for a specific context, returning a string
-        and flags indicating whether the representation is 'readable'
-        and whether the object represents a recursive construct.
-        """
+    def _format_dict_items(self, items, stream, indent, allowance, context, 
+                           level): 
+        write = stream.write 
+        indent += self._indent_per_level 
+        delimnl = ',\n' + ' ' * indent 
+        last_index = len(items) - 1 
+        for i, (key, ent) in enumerate(items): 
+            last = i == last_index 
+            rep = self._repr(key, context, level) 
+            write(rep) 
+            write(': ') 
+            self._format(ent, stream, indent + len(rep) + 2, 
+                         allowance if last else 1, 
+                         context, level) 
+            if not last: 
+                write(delimnl) 
+ 
+    def _format_items(self, items, stream, indent, allowance, context, level): 
+        write = stream.write 
+        indent += self._indent_per_level 
+        if self._indent_per_level > 1: 
+            write((self._indent_per_level - 1) * ' ') 
+        delimnl = ',\n' + ' ' * indent 
+        delim = '' 
+        width = max_width = self._width - indent + 1 
+        it = iter(items) 
+        try: 
+            next_ent = next(it) 
+        except StopIteration: 
+            return 
+        last = False 
+        while not last: 
+            ent = next_ent 
+            try: 
+                next_ent = next(it) 
+            except StopIteration: 
+                last = True 
+                max_width -= allowance 
+                width -= allowance 
+            if self._compact: 
+                rep = self._repr(ent, context, level) 
+                w = len(rep) + 2 
+                if width < w: 
+                    width = max_width 
+                    if delim: 
+                        delim = delimnl 
+                if width >= w: 
+                    width -= w 
+                    write(delim) 
+                    delim = ', ' 
+                    write(rep) 
+                    continue 
+            write(delim) 
+            delim = delimnl 
+            self._format(ent, stream, indent, 
+                         allowance if last else 1, 
+                         context, level) 
+ 
+    def _repr(self, object, context, level): 
+        repr, readable, recursive = self.format(object, context.copy(), 
+                                                self._depth, level) 
+        if not readable: 
+            self._readable = False 
+        if recursive: 
+            self._recursive = True 
+        return repr 
+ 
+    def format(self, object, context, maxlevels, level): 
+        """Format object for a specific context, returning a string 
+        and flags indicating whether the representation is 'readable' 
+        and whether the object represents a recursive construct. 
+        """ 
         return _safe_repr(object, context, maxlevels, level, self._sort_dicts)
-
-    def _pprint_default_dict(self, object, stream, indent, allowance, context, level):
-        if not len(object):
-            stream.write(repr(object))
-            return
-        rdf = self._repr(object.default_factory, context, level)
-        cls = object.__class__
-        indent += len(cls.__name__) + 1
-        stream.write('%s(%s,\n%s' % (cls.__name__, rdf, ' ' * indent))
-        self._pprint_dict(object, stream, indent, allowance + 1, context, level)
-        stream.write(')')
-
-    _dispatch[_collections.defaultdict.__repr__] = _pprint_default_dict
-
-    def _pprint_counter(self, object, stream, indent, allowance, context, level):
-        if not len(object):
-            stream.write(repr(object))
-            return
-        cls = object.__class__
-        stream.write(cls.__name__ + '({')
-        if self._indent_per_level > 1:
-            stream.write((self._indent_per_level - 1) * ' ')
-        items = object.most_common()
-        self._format_dict_items(items, stream,
-                                indent + len(cls.__name__) + 1, allowance + 2,
-                                context, level)
-        stream.write('})')
-
-    _dispatch[_collections.Counter.__repr__] = _pprint_counter
-
-    def _pprint_chain_map(self, object, stream, indent, allowance, context, level):
-        if not len(object.maps):
-            stream.write(repr(object))
-            return
-        cls = object.__class__
-        stream.write(cls.__name__ + '(')
-        indent += len(cls.__name__) + 1
-        for i, m in enumerate(object.maps):
-            if i == len(object.maps) - 1:
-                self._format(m, stream, indent, allowance + 1, context, level)
-                stream.write(')')
-            else:
-                self._format(m, stream, indent, 1, context, level)
-                stream.write(',\n' + ' ' * indent)
-
-    _dispatch[_collections.ChainMap.__repr__] = _pprint_chain_map
-
-    def _pprint_deque(self, object, stream, indent, allowance, context, level):
-        if not len(object):
-            stream.write(repr(object))
-            return
-        cls = object.__class__
-        stream.write(cls.__name__ + '(')
-        indent += len(cls.__name__) + 1
-        stream.write('[')
-        if object.maxlen is None:
-            self._format_items(object, stream, indent, allowance + 2,
-                               context, level)
-            stream.write('])')
-        else:
-            self._format_items(object, stream, indent, 2,
-                               context, level)
-            rml = self._repr(object.maxlen, context, level)
-            stream.write('],\n%smaxlen=%s)' % (' ' * indent, rml))
-
-    _dispatch[_collections.deque.__repr__] = _pprint_deque
-
-    def _pprint_user_dict(self, object, stream, indent, allowance, context, level):
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserDict.__repr__] = _pprint_user_dict
-
-    def _pprint_user_list(self, object, stream, indent, allowance, context, level):
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserList.__repr__] = _pprint_user_list
-
-    def _pprint_user_string(self, object, stream, indent, allowance, context, level):
-        self._format(object.data, stream, indent, allowance, context, level - 1)
-
-    _dispatch[_collections.UserString.__repr__] = _pprint_user_string
-
-# Return triple (repr_string, isreadable, isrecursive).
-
+ 
+    def _pprint_default_dict(self, object, stream, indent, allowance, context, level): 
+        if not len(object): 
+            stream.write(repr(object)) 
+            return 
+        rdf = self._repr(object.default_factory, context, level) 
+        cls = object.__class__ 
+        indent += len(cls.__name__) + 1 
+        stream.write('%s(%s,\n%s' % (cls.__name__, rdf, ' ' * indent)) 
+        self._pprint_dict(object, stream, indent, allowance + 1, context, level) 
+        stream.write(')') 
+ 
+    _dispatch[_collections.defaultdict.__repr__] = _pprint_default_dict 
+ 
+    def _pprint_counter(self, object, stream, indent, allowance, context, level): 
+        if not len(object): 
+            stream.write(repr(object)) 
+            return 
+        cls = object.__class__ 
+        stream.write(cls.__name__ + '({') 
+        if self._indent_per_level > 1: 
+            stream.write((self._indent_per_level - 1) * ' ') 
+        items = object.most_common() 
+        self._format_dict_items(items, stream, 
+                                indent + len(cls.__name__) + 1, allowance + 2, 
+                                context, level) 
+        stream.write('})') 
+ 
+    _dispatch[_collections.Counter.__repr__] = _pprint_counter 
+ 
+    def _pprint_chain_map(self, object, stream, indent, allowance, context, level): 
+        if not len(object.maps): 
+            stream.write(repr(object)) 
+            return 
+        cls = object.__class__ 
+        stream.write(cls.__name__ + '(') 
+        indent += len(cls.__name__) + 1 
+        for i, m in enumerate(object.maps): 
+            if i == len(object.maps) - 1: 
+                self._format(m, stream, indent, allowance + 1, context, level) 
+                stream.write(')') 
+            else: 
+                self._format(m, stream, indent, 1, context, level) 
+                stream.write(',\n' + ' ' * indent) 
+ 
+    _dispatch[_collections.ChainMap.__repr__] = _pprint_chain_map 
+ 
+    def _pprint_deque(self, object, stream, indent, allowance, context, level): 
+        if not len(object): 
+            stream.write(repr(object)) 
+            return 
+        cls = object.__class__ 
+        stream.write(cls.__name__ + '(') 
+        indent += len(cls.__name__) + 1 
+        stream.write('[') 
+        if object.maxlen is None: 
+            self._format_items(object, stream, indent, allowance + 2, 
+                               context, level) 
+            stream.write('])') 
+        else: 
+            self._format_items(object, stream, indent, 2, 
+                               context, level) 
+            rml = self._repr(object.maxlen, context, level) 
+            stream.write('],\n%smaxlen=%s)' % (' ' * indent, rml)) 
+ 
+    _dispatch[_collections.deque.__repr__] = _pprint_deque 
+ 
+    def _pprint_user_dict(self, object, stream, indent, allowance, context, level): 
+        self._format(object.data, stream, indent, allowance, context, level - 1) 
+ 
+    _dispatch[_collections.UserDict.__repr__] = _pprint_user_dict 
+ 
+    def _pprint_user_list(self, object, stream, indent, allowance, context, level): 
+        self._format(object.data, stream, indent, allowance, context, level - 1) 
+ 
+    _dispatch[_collections.UserList.__repr__] = _pprint_user_list 
+ 
+    def _pprint_user_string(self, object, stream, indent, allowance, context, level): 
+        self._format(object.data, stream, indent, allowance, context, level - 1) 
+ 
+    _dispatch[_collections.UserString.__repr__] = _pprint_user_string 
+ 
+# Return triple (repr_string, isreadable, isrecursive). 
+ 
 def _safe_repr(object, context, maxlevels, level, sort_dicts):
-    typ = type(object)
-    if typ in _builtin_scalars:
-        return repr(object), True, False
-
-    r = getattr(typ, "__repr__", None)
-    if issubclass(typ, dict) and r is dict.__repr__:
-        if not object:
-            return "{}", True, False
-        objid = id(object)
-        if maxlevels and level >= maxlevels:
-            return "{...}", False, objid in context
-        if objid in context:
-            return _recursion(object), False, True
-        context[objid] = 1
-        readable = True
-        recursive = False
-        components = []
-        append = components.append
-        level += 1
+    typ = type(object) 
+    if typ in _builtin_scalars: 
+        return repr(object), True, False 
+ 
+    r = getattr(typ, "__repr__", None) 
+    if issubclass(typ, dict) and r is dict.__repr__: 
+        if not object: 
+            return "{}", True, False 
+        objid = id(object) 
+        if maxlevels and level >= maxlevels: 
+            return "{...}", False, objid in context 
+        if objid in context: 
+            return _recursion(object), False, True 
+        context[objid] = 1 
+        readable = True 
+        recursive = False 
+        components = [] 
+        append = components.append 
+        level += 1 
         if sort_dicts:
             items = sorted(object.items(), key=_safe_tuple)
         else:
             items = object.items()
-        for k, v in items:
+        for k, v in items: 
             krepr, kreadable, krecur = _safe_repr(k, context, maxlevels, level, sort_dicts)
             vrepr, vreadable, vrecur = _safe_repr(v, context, maxlevels, level, sort_dicts)
-            append("%s: %s" % (krepr, vrepr))
-            readable = readable and kreadable and vreadable
-            if krecur or vrecur:
-                recursive = True
-        del context[objid]
-        return "{%s}" % ", ".join(components), readable, recursive
-
-    if (issubclass(typ, list) and r is list.__repr__) or \
-       (issubclass(typ, tuple) and r is tuple.__repr__):
-        if issubclass(typ, list):
-            if not object:
-                return "[]", True, False
-            format = "[%s]"
-        elif len(object) == 1:
-            format = "(%s,)"
-        else:
-            if not object:
-                return "()", True, False
-            format = "(%s)"
-        objid = id(object)
-        if maxlevels and level >= maxlevels:
-            return format % "...", False, objid in context
-        if objid in context:
-            return _recursion(object), False, True
-        context[objid] = 1
-        readable = True
-        recursive = False
-        components = []
-        append = components.append
-        level += 1
-        for o in object:
+            append("%s: %s" % (krepr, vrepr)) 
+            readable = readable and kreadable and vreadable 
+            if krecur or vrecur: 
+                recursive = True 
+        del context[objid] 
+        return "{%s}" % ", ".join(components), readable, recursive 
+ 
+    if (issubclass(typ, list) and r is list.__repr__) or \ 
+       (issubclass(typ, tuple) and r is tuple.__repr__): 
+        if issubclass(typ, list): 
+            if not object: 
+                return "[]", True, False 
+            format = "[%s]" 
+        elif len(object) == 1: 
+            format = "(%s,)" 
+        else: 
+            if not object: 
+                return "()", True, False 
+            format = "(%s)" 
+        objid = id(object) 
+        if maxlevels and level >= maxlevels: 
+            return format % "...", False, objid in context 
+        if objid in context: 
+            return _recursion(object), False, True 
+        context[objid] = 1 
+        readable = True 
+        recursive = False 
+        components = [] 
+        append = components.append 
+        level += 1 
+        for o in object: 
             orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level, sort_dicts)
-            append(orepr)
-            if not oreadable:
-                readable = False
-            if orecur:
-                recursive = True
-        del context[objid]
-        return format % ", ".join(components), readable, recursive
-
-    rep = repr(object)
-    return rep, (rep and not rep.startswith('<')), False
-
-_builtin_scalars = frozenset({str, bytes, bytearray, int, float, complex,
-                              bool, type(None)})
-
-def _recursion(object):
-    return ("<Recursion on %s with id=%s>"
-            % (type(object).__name__, id(object)))
-
-
-def _perfcheck(object=None):
-    import time
-    if object is None:
-        object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000
-    p = PrettyPrinter()
-    t1 = time.perf_counter()
+            append(orepr) 
+            if not oreadable: 
+                readable = False 
+            if orecur: 
+                recursive = True 
+        del context[objid] 
+        return format % ", ".join(components), readable, recursive 
+ 
+    rep = repr(object) 
+    return rep, (rep and not rep.startswith('<')), False 
+ 
+_builtin_scalars = frozenset({str, bytes, bytearray, int, float, complex, 
+                              bool, type(None)}) 
+ 
+def _recursion(object): 
+    return ("<Recursion on %s with id=%s>" 
+            % (type(object).__name__, id(object))) 
+ 
+ 
+def _perfcheck(object=None): 
+    import time 
+    if object is None: 
+        object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000 
+    p = PrettyPrinter() 
+    t1 = time.perf_counter() 
     _safe_repr(object, {}, None, 0, True)
-    t2 = time.perf_counter()
-    p.pformat(object)
-    t3 = time.perf_counter()
-    print("_safe_repr:", t2 - t1)
-    print("pformat:", t3 - t2)
-
-def _wrap_bytes_repr(object, width, allowance):
-    current = b''
-    last = len(object) // 4 * 4
-    for i in range(0, len(object), 4):
-        part = object[i: i+4]
-        candidate = current + part
-        if i == last:
-            width -= allowance
-        if len(repr(candidate)) > width:
-            if current:
-                yield repr(current)
-            current = part
-        else:
-            current = candidate
-    if current:
-        yield repr(current)
-
-if __name__ == "__main__":
-    _perfcheck()
+    t2 = time.perf_counter() 
+    p.pformat(object) 
+    t3 = time.perf_counter() 
+    print("_safe_repr:", t2 - t1) 
+    print("pformat:", t3 - t2) 
+ 
+def _wrap_bytes_repr(object, width, allowance): 
+    current = b'' 
+    last = len(object) // 4 * 4 
+    for i in range(0, len(object), 4): 
+        part = object[i: i+4] 
+        candidate = current + part 
+        if i == last: 
+            width -= allowance 
+        if len(repr(candidate)) > width: 
+            if current: 
+                yield repr(current) 
+            current = part 
+        else: 
+            current = candidate 
+    if current: 
+        yield repr(current) 
+ 
+if __name__ == "__main__": 
+    _perfcheck()