From a814db579db9cfcaa3cf2ca7bae539cf2c80a9f0 Mon Sep 17 00:00:00 2001 From: Tim Peters Date: Mon, 14 May 2001 07:05:58 +0000 Subject: [PATCH] SF bug[ #423781: pprint.isrecursive() broken. --- Lib/pprint.py | 54 +++++++++++++++++++++---------------- Lib/test/output/test_pprint | 1 + Lib/test/test_pprint.py | 36 +++++++++++++++++++++++++ Misc/NEWS | 32 +++++++++++++++++----- 4 files changed, 93 insertions(+), 30 deletions(-) create mode 100644 Lib/test/output/test_pprint create mode 100644 Lib/test/test_pprint.py diff --git a/Lib/pprint.py b/Lib/pprint.py index 814ca48af07..48efb336568 100644 --- a/Lib/pprint.py +++ b/Lib/pprint.py @@ -49,26 +49,21 @@ def pprint(object, stream=None): printer = PrettyPrinter(stream=stream) printer.pprint(object) - def pformat(object): """Format a Python object into a pretty-printed representation.""" return PrettyPrinter().pformat(object) - -def isreadable(object): - """Determine if saferepr(object) is readable by eval().""" - return PrettyPrinter().isreadable(object) - - -def isrecursive(object): - """Determine if object requires a recursive representation.""" - return PrettyPrinter().isrecursive(object) - - def saferepr(object): """Version of repr() which can handle recursive data structures.""" return _safe_repr(object, {})[0] +def isreadable(object): + """Determine if saferepr(object) is readable by eval().""" + return _safe_repr(object, {})[1] + +def isrecursive(object): + """Determine if object requires a recursive representation.""" + return _safe_repr(object, {})[2] class PrettyPrinter: def __init__(self, indent=1, width=80, depth=None, stream=None): @@ -92,7 +87,7 @@ class PrettyPrinter: indent = int(indent) width = int(width) assert indent >= 0 - assert (not depth) or depth > 0, "depth may not be negative" + assert depth is None or depth > 0, "depth must be > 0" assert width self.__depth = depth self.__indent_per_level = indent @@ -182,23 +177,28 @@ class PrettyPrinter: del context[objid] def __repr(self, object, context, level): - repr, readable = _safe_repr(object, context, self.__depth, level) + repr, readable, recursive = _safe_repr(object, context, + self.__depth, level) if not readable: self.__readable = 0 + if recursive: + self.__recursive = 1 return repr +# Return triple (repr_string, isreadable, isrecursive). def _safe_repr(object, context, maxlevels=None, level=0): level = level + 1 typ = type(object) if not (typ in (DictType, ListType, TupleType) and object): rep = `object` - return rep, (rep and (rep[0] != '<')) + return rep, (rep and (rep[0] != '<')), 0 if context.has_key(id(object)): - return `_Recursion(object)`, 0 + return `_Recursion(object)`, 0, 1 objid = id(object) context[objid] = 1 readable = 1 + recursive = 0 if typ is DictType: if maxlevels and level >= maxlevels: s = "{...}" @@ -206,14 +206,20 @@ def _safe_repr(object, context, maxlevels=None, level=0): else: items = object.items() k, v = items[0] - krepr, kreadable = _safe_repr(k, context, maxlevels, level) - vrepr, vreadable = _safe_repr(v, context, maxlevels, level) + krepr, kreadable, krecur = _safe_repr(k, context, maxlevels, + level) + vrepr, vreadable, vrecur = _safe_repr(v, context, maxlevels, + level) readable = readable and kreadable and vreadable + recursive = recursive or krecur or vrecur s = "{%s: %s" % (krepr, vrepr) for k, v in items[1:]: - krepr, kreadable = _safe_repr(k, context, maxlevels, level) - vrepr, vreadable = _safe_repr(v, context, maxlevels, level) + krepr, kreadable, krecur = _safe_repr(k, context, maxlevels, + level) + vrepr, vreadable, vrecur = _safe_repr(v, context, maxlevels, + level) readable = readable and kreadable and vreadable + recursive = recursive or krecur or vrecur s = "%s, %s: %s" % (s, krepr, vrepr) s = s + "}" else: @@ -222,22 +228,24 @@ def _safe_repr(object, context, maxlevels=None, level=0): s = s + "..." readable = 0 else: - subrepr, subreadable = _safe_repr( + subrepr, subreadable, subrecur = _safe_repr( object[0], context, maxlevels, level) readable = readable and subreadable + recursive = recursive or subrecur s = s + subrepr tail = object[1:] if not tail: if typ is TupleType: s = s + ',' for ent in tail: - subrepr, subreadable = _safe_repr( + subrepr, subreadable, subrecur = _safe_repr( ent, context, maxlevels, level) readable = readable and subreadable + recursive = recursive or subrecur s = "%s, %s" % (s, subrepr) s = s + term del context[objid] - return s, readable + return s, readable and not recursive, recursive class _Recursion: diff --git a/Lib/test/output/test_pprint b/Lib/test/output/test_pprint new file mode 100644 index 00000000000..6f04e912f63 --- /dev/null +++ b/Lib/test/output/test_pprint @@ -0,0 +1 @@ +test_pprint diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py new file mode 100644 index 00000000000..610e989e516 --- /dev/null +++ b/Lib/test/test_pprint.py @@ -0,0 +1,36 @@ +from test_support import verify +import pprint + +# Verify that .isrecursive() and .isreadable() work. + +a = range(100) +b = range(200) +a[-12] = b + +for safe in 2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, u"yaddayadda", a, b: + verify(pprint.isrecursive(safe) == 0, "expected isrecursive == 0") + verify(pprint.isreadable(safe) == 1, "expected isreadable == 1") + +# Tie a knot. +b[67] = a +# Messy dict. +d = {} +d[0] = d[1] = d[2] = d + +for icky in a, b, d, (d, d): + verify(pprint.isrecursive(icky) == 1, "expected isrecursive == 1") + verify(pprint.isreadable(icky) == 0, "expected isreadable == 0") + +# Break the cycles. +d.clear() +del a[:] +del b[:] + +for safe in a, b, d, (d, d): + verify(pprint.isrecursive(safe) == 0, "expected isrecursive == 0") + verify(pprint.isreadable(safe) == 1, "expected isreadable == 1") + +# Not recursive but not readable anyway. +for unreadable in type(3), pprint, pprint.isrecursive: + verify(pprint.isrecursive(unreadable) == 0, "expected isrecursive == 0") + verify(pprint.isreadable(unreadable) ==0, "expected isreadable == 0") diff --git a/Misc/NEWS b/Misc/NEWS index aeb81c5d026..b6ee611aabd 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -2,22 +2,23 @@ What's New in Python 2.2a0? =========================== Core + - Some operating systems now support the concept of a default Unicode encoding for file system operations. Notably, Windows supports 'mbcs' as the default. The Macintosh will also adopt this concept in the medium - term, altough the default encoding for that platform will be other than + term, altough the default encoding for that platform will be other than 'mbcs'. - On operating system that support non-ascii filenames, it is common for + On operating system that support non-ascii filenames, it is common for functions that return filenames (such as os.listdir()) to return Python string objects pre-encoded using the default file system encoding for the platform. As this encoding is likely to be different from Python's default encoding, converting this name to a Unicode object before passing it back to the Operating System would result in a Unicode error, as Python - would attempt to use it's default encoding (generally ASCII) rather - than the default encoding for the file system. - In general, this change simply removes surprises when working with - Unicode and the file system, making these operations work as - you expect, increasing the transparency of Unicode objects in this context. + would attempt to use its default encoding (generally ASCII) rather than + the default encoding for the file system. + In general, this change simply removes surprises when working with + Unicode and the file system, making these operations work as you expect, + increasing the transparency of Unicode objects in this context. See [????] for more details, including examples. - Float (and complex) literals in source code were evaluated to full @@ -82,6 +83,23 @@ Core to crash if the element comparison routines for the dict keys and/or values mutated the dicts. Making the code bulletproof slowed it down. +Library + +- Cookie.py now sorts key+value pairs by key in output strings. + +- pprint.isrecursive(object) didn't correctly identify recursive objects. + Now it does. + +Tests + +- New test_mutants.py runs dict comparisons where the key and value + comparison operators mutute the dicts randomly during comparison. This + rapidly causes Python to crash under earlier releases (not for the faint + of heart: it can also cause Win9x to freeze or reboot!). + +- New test_pprint.py verfies that pprint.isrecursive() and + pprint.isreadable() return sensible results. + What's New in Python 2.1 (final)? =================================