pythonthings
diff --git a/‎bpython/repl.py‎
Lines changed: 10 additions & 3 deletions b/‎bpython/repl.py‎
Lines changed: 10 additions & 3 deletions
diff --git a/‎bpython/simpleeval.py‎
Lines changed: 18 additions & 3 deletions b/‎bpython/simpleeval.py‎
Lines changed: 18 additions & 3 deletions
@@ -51,6 +51,7 @@
 from bpython.paste import PasteHelper, PastePinnwand, PasteFailed
 from bpython.patch_linecache import filename_for_console_input
 from bpython.translations import _, ngettext
+from bpython import simpleeval
 
 
 class RuntimeTimer(object):
@@ -518,7 +519,15 @@ def get_args(self):
             return False
 
         try:
-            f = self.get_object(func)
+            if inspection.is_eval_safe_name(func):
+                f = self.get_object(func)
+            else:
+                try:
+                    fake_cursor = self.current_line.index(func) + len(func)
+                    f = simpleeval.evaluate_current_attribute(
+                            fake_cursor, self.current_line, self.interp.locals)
+                except simpleeval.EvaluationError:
+                    return False
         except Exception:
             # another case of needing to catch every kind of error
             # since user code is run in the case of descriptors
@@ -624,8 +633,6 @@ def complete(self, tab=False):
             current_block='\n'.join(self.buffer + [self.current_line]),
             complete_magic_methods=self.config.complete_magic_methods,
             history=self.history)
-        # TODO implement completer.shown_before_tab == False (filenames
-        # shouldn't fill screen)
 
         if len(matches) == 0:
             self.matches_iter.clear()
 
@@ -8,7 +8,6 @@
 import ast
 from six import string_types
 from six.moves import builtins
-from numbers import Number
 
 from bpython import line as line_properties
 from bpython._py3compat import py3
@@ -136,14 +135,16 @@ def find_attribute_with_name(node, name):
                 return r
 
 
-def evaluate_current_expression(cursor_offset, line, namespace={}):
+def evaluate_current_expression(cursor_offset, line, namespace=None):
     """
-    Return evaluted expression to the right of the dot of current attribute.
+    Return evaluated expression to the right of the dot of current attribute.
 
     build asts from with increasing numbers of characters.
     Find the biggest valid ast.
     Once our attribute access is a subtree, stop
     """
+    if namespace is None:
+        namespace = {}
 
     # in case attribute is blank, e.g. foo.| -> foo.xxx|
     temp_line = line[:cursor_offset] + 'xxx' + line[cursor_offset:]
@@ -174,3 +175,17 @@ def parse_trees(cursor_offset, line):
         return simple_eval(largest_ast, namespace)
     except ValueError:
         raise EvaluationError("Could not safely evaluate")
+
+
+def evaluate_current_attribute(cursor_offset, line, namespace=None):
+    # this function runs user code in case of custom descriptors,
+    # so could fail in any way
+
+    obj = evaluate_current_expression(cursor_offset, line, namespace)
+    attr = line_properties.current_expression_attribute(cursor_offset, line)
+    if attr is None:
+        raise EvaluationError("No attribute found to look up")
+    try:
+        return getattr(obj, attr.word)
+    except AttributeError:
+        raise EvaluationError("can't lookup attribute %s on %r" % (attr.word, obj))