[Python-checkins] cpython (merge 3.2 -> default): Issue #1785: Fix inspect and pydoc with misbehaving descriptors.

Wed Dec 21 10:01:10 CET 2011

http://hg.python.org/cpython/rev/b08bf8df8eec
changeset: 74105:b08bf8df8eec
parent: 74103:ec44f2e82707
parent: 74104:902f694a7b0e
user: Antoine Pitrou <solipsis at pitrou.net>
date: Wed Dec 21 09:59:49 2011 +0100
summary:
 Issue #1785: Fix inspect and pydoc with misbehaving descriptors.
Also fixes issue #13581: `help(type)` wouldn't display anything.
files:
 Lib/inspect.py | 79 ++++++++++++++++-----------
 Lib/pydoc.py | 29 ++++++++-
 Lib/test/test_inspect.py | 79 ++++++++++++++++++++++++++++
 Misc/NEWS | 2 +
 4 files changed, 151 insertions(+), 38 deletions(-)

diff --git a/Lib/inspect.py b/Lib/inspect.py
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -99,11 +99,11 @@
 tests return false from the ismethoddescriptor() test, simply because
 the other tests promise more -- you can, e.g., count on having the
 __func__ attribute (etc) when an object passes ismethod()."""
- return (hasattr(object, "__get__")
- and not hasattr(object, "__set__") # else it's a data descriptor
- and not ismethod(object) # mutual exclusion
- and not isfunction(object)
- and not isclass(object))
+ if isclass(object) or ismethod(object) or isfunction(object):
+ # mutual exclusion
+ return False
+ tp = type(object)
+ return hasattr(tp, "__get__") and not hasattr(tp, "__set__")
 
 def isdatadescriptor(object):
 """Return true if the object is a data descriptor.
@@ -113,7 +113,11 @@
 Typically, data descriptors will also have __name__ and __doc__ attributes
 (properties, getsets, and members have both of these attributes), but this
 is not guaranteed."""
- return (hasattr(object, "__set__") and hasattr(object, "__get__"))
+ if isclass(object) or ismethod(object) or isfunction(object):
+ # mutual exclusion
+ return False
+ tp = type(object)
+ return hasattr(tp, "__set__") and hasattr(tp, "__get__")
 
 if hasattr(types, 'MemberDescriptorType'):
 # CPython and equivalent
@@ -253,12 +257,23 @@
 def getmembers(object, predicate=None):
 """Return all members of an object as (name, value) pairs sorted by name.
 Optionally, only return members that satisfy a given predicate."""
+ if isclass(object):
+ mro = (object,) + getmro(object)
+ else:
+ mro = ()
 results = []
 for key in dir(object):
- try:
- value = getattr(object, key)
- except AttributeError:
- continue
+ # First try to get the value via __dict__. Some descriptors don't
+ # like calling their __get__ (see bug #1785).
+ for base in mro:
+ if key in base.__dict__:
+ value = base.__dict__[key]
+ break
+ else:
+ try:
+ value = getattr(object, key)
+ except AttributeError:
+ continue
 if not predicate or predicate(value):
 results.append((key, value))
 results.sort()
@@ -294,30 +309,21 @@
 names = dir(cls)
 result = []
 for name in names:
- # Get the object associated with the name.
+ # Get the object associated with the name, and where it was defined.
 # Getting an obj from the __dict__ sometimes reveals more than
 # using getattr. Static and class methods are dramatic examples.
- if name in cls.__dict__:
- obj = cls.__dict__[name]
+ # Furthermore, some objects may raise an Exception when fetched with
+ # getattr(). This is the case with some descriptors (bug #1785).
+ # Thus, we only use getattr() as a last resort.
+ homecls = None
+ for base in (cls,) + mro:
+ if name in base.__dict__:
+ obj = base.__dict__[name]
+ homecls = base
+ break
 else:
 obj = getattr(cls, name)
-
- # Figure out where it was defined.
- homecls = getattr(obj, "__objclass__", None)
- if homecls is None:
- # search the dicts.
- for base in mro:
- if name in base.__dict__:
- homecls = base
- break
-
- # Get the object again, in order to get it from the defining
- # __dict__ instead of via getattr (if possible).
- if homecls is not None and name in homecls.__dict__:
- obj = homecls.__dict__[name]
-
- # Also get the object via getattr.
- obj_via_getattr = getattr(cls, name)
+ homecls = getattr(obj, "__objclass__", homecls)
 
 # Classify the object.
 if isinstance(obj, staticmethod):
@@ -326,11 +332,18 @@
 kind = "class method"
 elif isinstance(obj, property):
 kind = "property"
- elif (isfunction(obj_via_getattr) or
- ismethoddescriptor(obj_via_getattr)):
+ elif ismethoddescriptor(obj):
 kind = "method"
+ elif isdatadescriptor(obj):
+ kind = "data"
 else:
- kind = "data"
+ obj_via_getattr = getattr(cls, name)
+ if (isfunction(obj_via_getattr) or
+ ismethoddescriptor(obj_via_getattr)):
+ kind = "method"
+ else:
+ kind = "data"
+ obj = obj_via_getattr
 
 result.append(Attribute(name, kind, homecls, obj))
 
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -748,8 +748,15 @@
 hr.maybe()
 push(msg)
 for name, kind, homecls, value in ok:
- push(self.document(getattr(object, name), name, mod,
- funcs, classes, mdict, object))
+ try:
+ value = getattr(object, name)
+ except Exception:
+ # Some descriptors may meet a failure in their __get__.
+ # (bug #1785)
+ push(self._docdescriptor(name, value, mod))
+ else:
+ push(self.document(value, name, mod,
+ funcs, classes, mdict, object))
 push('\n')
 return attrs
 
@@ -790,7 +797,12 @@
 mdict = {}
 for key, kind, homecls, value in attrs:
 mdict[key] = anchor = '#' + name + '-' + key
- value = getattr(object, key)
+ try:
+ value = getattr(object, name)
+ except Exception:
+ # Some descriptors may meet a failure in their __get__.
+ # (bug #1785)
+ pass
 try:
 # The value may not be hashable (e.g., a data attr with
 # a dict or list value).
@@ -1177,8 +1189,15 @@
 hr.maybe()
 push(msg)
 for name, kind, homecls, value in ok:
- push(self.document(getattr(object, name),
- name, mod, object))
+ try:
+ value = getattr(object, name)
+ except Exception:
+ # Some descriptors may meet a failure in their __get__.
+ # (bug #1785)
+ push(self._docdescriptor(name, value, mod))
+ else:
+ push(self.document(value,
+ name, mod, object))
 return attrs
 
 def spilldescriptors(msg, attrs, predicate):
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -425,10 +425,37 @@
 def test_class(self):
 self.assertSourceEqual(self.fodderModule.X, 1, 2)
 
+
+class _BrokenDataDescriptor(object):
+ """
+ A broken data descriptor. See bug #1785.
+ """
+ def __get__(*args):
+ raise AssertionError("should not __get__ data descriptors")
+
+ def __set__(*args):
+ raise RuntimeError
+
+ def __getattr__(*args):
+ raise AssertionError("should not __getattr__ data descriptors")
+
+
+class _BrokenMethodDescriptor(object):
+ """
+ A broken method descriptor. See bug #1785.
+ """
+ def __get__(*args):
+ raise AssertionError("should not __get__ method descriptors")
+
+ def __getattr__(*args):
+ raise AssertionError("should not __getattr__ method descriptors")
+
+
 # Helper for testing classify_class_attrs.
 def attrs_wo_objs(cls):
 return [t[:3] for t in inspect.classify_class_attrs(cls)]
 
+
 class TestClassesAndFunctions(unittest.TestCase):
 def test_newstyle_mro(self):
 # The same w/ new-class MRO.
@@ -525,6 +552,9 @@
 
 datablob = '1'
 
+ dd = _BrokenDataDescriptor()
+ md = _BrokenMethodDescriptor()
+
 attrs = attrs_wo_objs(A)
 self.assertIn(('s', 'static method', A), attrs, 'missing static method')
 self.assertIn(('c', 'class method', A), attrs, 'missing class method')
@@ -533,6 +563,8 @@
 'missing plain method: %r' % attrs)
 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+ self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+ self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
 
 class B(A):
 
@@ -545,6 +577,8 @@
 self.assertIn(('m', 'method', B), attrs, 'missing plain method')
 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+ self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+ self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
 
 
 class C(A):
@@ -559,6 +593,8 @@
 self.assertIn(('m', 'method', C), attrs, 'missing plain method')
 self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+ self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+ self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
 
 class D(B, C):
 
@@ -571,6 +607,49 @@
 self.assertIn(('m', 'method', B), attrs, 'missing plain method')
 self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
 self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+ self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+ self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
+
+ def test_classify_builtin_types(self):
+ # Simple sanity check that all built-in types can have their
+ # attributes classified.
+ for name in dir(__builtins__):
+ builtin = getattr(__builtins__, name)
+ if isinstance(builtin, type):
+ inspect.classify_class_attrs(builtin)
+
+ def test_getmembers_descriptors(self):
+ class A(object):
+ dd = _BrokenDataDescriptor()
+ md = _BrokenMethodDescriptor()
+
+ def pred_wrapper(pred):
+ # A quick'n'dirty way to discard standard attributes of new-style
+ # classes.
+ class Empty(object):
+ pass
+ def wrapped(x):
+ if '__name__' in dir(x) and hasattr(Empty, x.__name__):
+ return False
+ return pred(x)
+ return wrapped
+
+ ismethoddescriptor = pred_wrapper(inspect.ismethoddescriptor)
+ isdatadescriptor = pred_wrapper(inspect.isdatadescriptor)
+
+ self.assertEqual(inspect.getmembers(A, ismethoddescriptor),
+ [('md', A.__dict__['md'])])
+ self.assertEqual(inspect.getmembers(A, isdatadescriptor),
+ [('dd', A.__dict__['dd'])])
+
+ class B(A):
+ pass
+
+ self.assertEqual(inspect.getmembers(B, ismethoddescriptor),
+ [('md', A.__dict__['md'])])
+ self.assertEqual(inspect.getmembers(B, isdatadescriptor),
+ [('dd', A.__dict__['dd'])])
+
 
 class TestGetcallargsFunctions(unittest.TestCase):
 
diff --git a/Misc/NEWS b/Misc/NEWS
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -419,6 +419,8 @@
 Library
 -------
 
+- Issue #1785: Fix inspect and pydoc with misbehaving descriptors.
+
 - Issue #13637: "a2b" functions in the binascii module now accept ASCII-only
 unicode strings.
 
-- 
Repository URL: http://hg.python.org/cpython
