Refactor to start using getattr_static for python3

rybarczykj · rybarczykj · commit 2ca6b7c2b0eb · 2020-07-30T09:16:26.000-05:00
Avoids having to use AttrCleaner in many contexts
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -356,16 +356,15 @@ def attr_matches(self, text, namespace):
             obj = safe_eval(expr, namespace)
         except EvaluationError:
             return []
-        with inspection.AttrCleaner(obj):
-            matches = self.attr_lookup(obj, expr, attr)
+        matches = self.attr_lookup(obj, expr, attr)
         return matches
 
     def attr_lookup(self, obj, expr, attr):
         """Second half of original attr_matches method factored out so it can
         be wrapped in a safe try/finally block in case anything bad happens to
         restore the original __getattribute__ method."""
         words = self.list_attributes(obj)
-        if hasattr(obj, "__class__"):
+        if inspection.has_attr_safe(obj, "__class__"):
             words.append("__class__")
             words = words + rlcompleter.get_class_members(obj.__class__)
             if not isinstance(obj.__class__, abc.ABCMeta):
@@ -537,10 +536,9 @@ def matches(self, cursor_offset, line, **kwargs):
             obj = evaluate_current_expression(cursor_offset, line, locals_)
         except EvaluationError:
             return set()
-        with inspection.AttrCleaner(obj):
-            #          strips leading dot
-            matches = [m[1:] for m in self.attr_lookup(obj, "", attr.word)]
 
+        # strips leading dot
+        matches = [m[1:] for m in self.attr_lookup(obj, "", attr.word)]
         return set(m for m in matches if few_enough_underscores(attr.word, m))
 
 
@@ -679,7 +677,7 @@ def get_completer_bpython(cursor_offset, line, **kwargs):
 
 def _callable_postfix(value, word):
     """rlcompleter's _callable_postfix done right."""
-    with inspection.AttrCleaner(value):
-        if inspection.is_callable(value):
-            word += "("
+    # TODO: do we need this done within an AttrCleaner?
+    if inspection.is_callable(value):
+        word += "("
     return word
diff --git a/bpython/inspection.py b/bpython/inspection.py
@@ -33,6 +33,7 @@
 from six.moves import range
 
 from pygments.token import Token
+from types import MemberDescriptorType
 
 from ._py3compat import PythonLexer, py3
 from .lazyre import LazyReCompile
@@ -214,7 +215,7 @@ def getpydocspec(f, func):
     if s is None:
         return None
 
-    if not hasattr(f, "__name__") or s.groups()[0] != f.__name__:
+    if not has_attr_safe(f, "__name__") or s.groups()[0] != f.__name__:
         return None
 
     args = list()
@@ -276,8 +277,7 @@ def getfuncprops(func, f):
         argspec = ArgSpec(*argspec)
         fprops = FuncProps(func, argspec, is_bound_method)
     except (TypeError, KeyError, ValueError):
-        with AttrCleaner(f):
-            argspec = getpydocspec(f, func)
+        argspec = getpydocspec(f, func)
         if argspec is None:
             return None
         if inspect.ismethoddescriptor(f):
@@ -392,6 +392,47 @@ def get_encoding_file(fname):
     return "ascii"
 
 
+if not py3:
+
+    def get_attr_safe(obj, name):
+        """side effect free getattr"""
+        if not is_new_style(obj):
+            return getattr(obj, name)
+
+        with AttrCleaner(obj):
+            to_look_through = (
+                obj.__mro__
+                if inspect.isclass(obj)
+                else (obj,) + type(obj).__mro__
+            )
+            for cls in to_look_through:
+                if hasattr(cls, "__dict__") and name in cls.__dict__:
+                    result = cls.__dict__[name]
+                    if isinstance(result, MemberDescriptorType):
+                        result = getattr(obj, name)
+                    return result
+            raise AttributeError(name)
+
+
+else:
+
+    def get_attr_safe(obj, name):
+        """side effect and AttrCleaner free getattr (calls getattr_static)."""
+        result = inspect.getattr_static(obj, name)
+        # Slots are a MemberDescriptorType
+        if isinstance(result, MemberDescriptorType):
+            result = getattr(obj, name)
+        return result
+
+
+def has_attr_safe(obj, name):
+    try:
+        get_attr_safe(obj, name)
+        return True
+    except AttributeError:
+        return False
+
+
 if py3:
 
     def get_source_unicode(obj):
diff --git a/bpython/simpleeval.py b/bpython/simpleeval.py
@@ -38,7 +38,7 @@
 
 from . import line as line_properties
 from ._py3compat import py3
-from .inspection import is_new_style, AttrCleaner
+from .inspection import get_attr_safe
 
 _string_type_nodes = (ast.Str, ast.Bytes) if py3 else (ast.Str,)
 _numeric_types = (int, float, complex) + (() if py3 else (long,))
@@ -163,14 +163,15 @@ def _convert(node):
         if isinstance(node, ast.Attribute):
             obj = _convert(node.value)
             attr = node.attr
-            return safe_get_attribute(obj, attr)
+            return get_attr_safe(obj, attr)
 
         raise ValueError("malformed string")
 
     return _convert(node_or_string)
 
 
 def safe_getitem(obj, index):
+    """ Safely tries to access obj[index] """
     if type(obj) in (list, tuple, dict, bytes) + string_types:
         try:
             return obj[index]
@@ -251,44 +252,3 @@ def evaluate_current_attribute(cursor_offset, line, namespace=None):
             "can't lookup attribute %s on %r" % (attr.word, obj)
         )
 
-
-def safe_get_attribute(obj, attr):
-    """Gets attributes without triggering descriptors on new-style classes"""
-    if is_new_style(obj):
-        with AttrCleaner(obj):
-            result = safe_get_attribute_new_style(obj, attr)
-            if isinstance(result, member_descriptor):
-                # will either be the same slot descriptor or the value
-                return getattr(obj, attr)
-            return result
-    return getattr(obj, attr)
-
-
-class _ClassWithSlots(object):
-    __slots__ = ["a"]
-
-
-member_descriptor = type(_ClassWithSlots.a)
-
-
-def safe_get_attribute_new_style(obj, attr):
-    """Returns approximately the attribute returned by getattr(obj, attr)
-
-    The object returned ought to be callable if getattr(obj, attr) was.
-    Fake callable objects may be returned instead, in order to avoid executing
-    arbitrary code in descriptors.
-
-    If the object is an instance of a class that uses __slots__, will return
-    the member_descriptor object instead of the value.
-    """
-    if not is_new_style(obj):
-        raise ValueError("%r is not a new-style class or object" % obj)
-    to_look_through = (
-        obj.__mro__ if inspect.isclass(obj) else (obj,) + type(obj).__mro__
-    )
-
-    for cls in to_look_through:
-        if hasattr(cls, "__dict__") and attr in cls.__dict__:
-            return cls.__dict__[attr]
-
-    raise AttributeError()
diff --git a/bpython/test/test_inspection.py b/bpython/test/test_inspection.py
@@ -155,5 +155,57 @@ def test_get_source_file(self):
         self.assertEqual(encoding, "utf-8")
 
 
+    class TestSafeGetAttribute(unittest.TestCase):
+        def test_lookup_on_object(self):
+            a = A()
+            a.x = 1
+            self.assertEqual(get_attr_safe(a, "x"), 1)
+            self.assertEqual(get_attr_safe(a, "a"), "a")
+            b = B()
+            b.y = 2
+            self.assertEqual(get_attr_safe(b, "y"), 2)
+            self.assertEqual(get_attr_safe(b, "a"), "a")
+            self.assertEqual(get_attr_safe(b, "b"), "b")
+
+        def test_avoid_running_properties(self):
+            p = Property()
+            self.assertEqual(get_attr_safe(p, "prop"), Property.prop)
+        
+        def test_lookup_with_slots(self):
+            s = Slots()
+            s.s1 = "s1"
+            self.assertEqual(get_attr_safe(s, "s1"), "s1")
+            with self.assertRaises(AttributeError):
+                get_attr_safe(s, "s2")
+
+        def test_lookup_on_slots_classes(self):
+            sga = get_attr_safe
+            s = SlotsSubclass()
+            self.assertIsInstance(sga(Slots, "s1"), member_descriptor)
+            self.assertIsInstance(sga(SlotsSubclass, "s1"), member_descriptor)
+            self.assertIsInstance(sga(SlotsSubclass, "s4"), property)
+            self.assertIsInstance(sga(s, "s4"), property)
+
+        @unittest.skipIf(py3, "Py 3 doesn't allow slots and prop in same class")
+        def test_lookup_with_property_and_slots(self):
+            sga = get_attr_safe
+            s = SlotsSubclass()
+            self.assertIsInstance(sga(Slots, "s3"), property)
+            self.assertEqual(get_attr_safe(s, "s3"), Slots.__dict__["s3"])
+            self.assertIsInstance(sga(SlotsSubclass, "s3"), property)
+
+        def test_lookup_on_overridden_methods(self):
+            sga = get_attr_safe
+            self.assertEqual(sga(OverriddenGetattr(), "a"), 1)
+            self.assertEqual(sga(OverriddenGetattribute(), "a"), 1)
+            self.assertEqual(sga(OverriddenMRO(), "a"), 1)
+            with self.assertRaises(AttributeError):
+                sga(OverriddenGetattr(), "b")
+            with self.assertRaises(AttributeError):
+                sga(OverriddenGetattribute(), "b")
+            with self.assertRaises(AttributeError):
+                sga(OverriddenMRO(), "b")
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/bpython/test/test_simpleeval.py b/bpython/test/test_simpleeval.py
@@ -7,8 +7,6 @@
     simple_eval,
     evaluate_current_expression,
     EvaluationError,
-    safe_get_attribute,
-    safe_get_attribute_new_style,
 )
 from bpython.test import unittest
 from bpython._py3compat import py3
@@ -189,71 +187,5 @@ def __mro__(self):
 member_descriptor = type(Slots.s1)
 
 
-class TestSafeGetAttribute(unittest.TestCase):
-    def test_lookup_on_object(self):
-        a = A()
-        a.x = 1
-        self.assertEqual(safe_get_attribute_new_style(a, "x"), 1)
-        self.assertEqual(safe_get_attribute_new_style(a, "a"), "a")
-        b = B()
-        b.y = 2
-        self.assertEqual(safe_get_attribute_new_style(b, "y"), 2)
-        self.assertEqual(safe_get_attribute_new_style(b, "a"), "a")
-        self.assertEqual(safe_get_attribute_new_style(b, "b"), "b")
-
-    def test_avoid_running_properties(self):
-        p = Property()
-        self.assertEqual(safe_get_attribute_new_style(p, "prop"), Property.prop)
-
-    @unittest.skipIf(py3, "Old-style classes not in Python 3")
-    def test_raises_on_old_style_class(self):
-        class Old:
-            pass
-
-        with self.assertRaises(ValueError):
-            safe_get_attribute_new_style(Old, "asdf")
-
-    def test_lookup_with_slots(self):
-        s = Slots()
-        s.s1 = "s1"
-        self.assertEqual(safe_get_attribute(s, "s1"), "s1")
-        self.assertIsInstance(
-            safe_get_attribute_new_style(s, "s1"), member_descriptor
-        )
-        with self.assertRaises(AttributeError):
-            safe_get_attribute(s, "s2")
-        self.assertIsInstance(
-            safe_get_attribute_new_style(s, "s2"), member_descriptor
-        )
-
-    def test_lookup_on_slots_classes(self):
-        sga = safe_get_attribute
-        s = SlotsSubclass()
-        self.assertIsInstance(sga(Slots, "s1"), member_descriptor)
-        self.assertIsInstance(sga(SlotsSubclass, "s1"), member_descriptor)
-        self.assertIsInstance(sga(SlotsSubclass, "s4"), property)
-        self.assertIsInstance(sga(s, "s4"), property)
-
-    @unittest.skipIf(py3, "Py 3 doesn't allow slots and prop in same class")
-    def test_lookup_with_property_and_slots(self):
-        sga = safe_get_attribute
-        s = SlotsSubclass()
-        self.assertIsInstance(sga(Slots, "s3"), property)
-        self.assertEqual(safe_get_attribute(s, "s3"), Slots.__dict__["s3"])
-        self.assertIsInstance(sga(SlotsSubclass, "s3"), property)
-
-    def test_lookup_on_overridden_methods(self):
-        sga = safe_get_attribute
-        self.assertEqual(sga(OverriddenGetattr(), "a"), 1)
-        self.assertEqual(sga(OverriddenGetattribute(), "a"), 1)
-        self.assertEqual(sga(OverriddenMRO(), "a"), 1)
-        with self.assertRaises(AttributeError):
-            sga(OverriddenGetattr(), "b")
-        with self.assertRaises(AttributeError):
-            sga(OverriddenGetattribute(), "b")
-        with self.assertRaises(AttributeError):
-            sga(OverriddenMRO(), "b")
-
-
 if __name__ == "__main__":
     unittest.main()
