eric: comparison src/eric7/DebugClients/Python/FlexCompleter.py

-:e9e7eca7efee
+:bf71ee032bb4
 class Completer:
 """
 Class implementing the command line completer object.
 """
 def __init__(self, namespace=None):
 """
 Constructor
 Completer([namespace]) -> completer instance.
 Completer instances should be used as the completion mechanism of
 readline via the set_completer() call:
 readline.set_completer(Completer(my_namespace).complete)
 @param namespace The namespace for the completer.
 @exception TypeError raised to indicate a wrong data structure of
 the namespace object
 """
 if namespace and not isinstance(namespace, dict):
-raise TypeError('namespace must be a dictionary')
+raise TypeError("namespace must be a dictionary")
 # Don't bind to namespace quite yet, but flag whether the user wants a
 # specific namespace or to use __main__.__dict__. This will allow us
 # to bind to __main__.__dict__ at completion time, not now.
 if namespace is None:
 """
 Public method to return the next possible completion for 'text'.
 This is called successively with state == 0, 1, 2, ... until it
 returns None.  The completion should begin with 'text'.
 @param text The text to be completed. (string)
 @param state The state of the completion. (integer)
 @return The possible completions as a list of strings.
 """
 if self.use_main_ns:
 self.namespace = __main__.__dict__
 if state == 0:
 if "." in text:
 self.matches = self.attr_matches(text)
 else:
 self.matches = self.global_matches(text)
 return None
 def _callable_postfix(self, val, word):
 """
 Protected method to check for a callable.
 @param val value to check (object)
 @param word word to ammend (string)
 @return ammended word (string)
 """
 if callable(val):
 @param text The text to be completed. (string)
 @return A list of all keywords, built-in functions and names currently
 defined in self.namespace that match.
 """
 import keyword
 matches = []
 seen = {"__builtins__"}
 n = len(text)
 for word in keyword.kwlist:
 if word[:n] == text:
 seen.add(word)
-if word in {'finally', 'try'}:
+if word in {"finally", "try"}:
-word += ':'
+word += ":"
-elif word not in {'False', 'None', 'True',
+elif word not in {
-'break', 'continue', 'pass',
+"False",
-'else'}:
+"None",
-word += ' '
+"True",
+"break",
+"continue",
+"pass",
+"else",
+}:
+word += " "
 matches.append(word)
 for nspace in [self.namespace, builtins.__dict__]:
 for word, val in nspace.items():
 if word[:n] == text and word not in seen:
 seen.add(word)
 (as revealed by dir()) are used as possible completions.  (For class
 instances, class members are are also considered.)
 <b>WARNING</b>: this can still invoke arbitrary C code, if an object
 with a __getattr__ hook is evaluated.
 @param text The text to be completed. (string)
 @return A list of all matches.
 """
 import re
 m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
 if not m:
 return []
 expr, attr = m.group(1, 3)
 try:
-thisobject = eval(expr, self.namespace)     # secok
+thisobject = eval(expr, self.namespace)  # secok
 except Exception:
 return []
 # get the content of the object, except __builtins__
 words = set(dir(thisobject))
 words.discard("__builtins__")
-if hasattr(object, '__class__'):
+if hasattr(object, "__class__"):
-words.add('__class__')
+words.add("__class__")
 words.update(get_class_members(thisobject.__class__))
 matches = []
 n = len(attr)
-if attr == '':
+if attr == "":
-noprefix = '_'
+noprefix = "_"
-elif attr == '_':
+elif attr == "_":
-noprefix = '__'
+noprefix = "__"
 else:
 noprefix = None
 while True:
 for word in words:
-if (word[:n] == attr and
+if word[:n] == attr and not (noprefix and word[: n + 1] == noprefix):
-not (noprefix and word[:n + 1] == noprefix)):
 match = "{0}.{1}".format(expr, word)
 try:
 val = getattr(thisobject, word)
-except Exception:       # secok
+except Exception:  # secok
 pass  # Include even if attribute not set
 else:
 match = self._callable_postfix(val, match)
 matches.append(match)
 if matches or not noprefix:
 break
-noprefix = '__' if noprefix == '_' else None
+noprefix = "__" if noprefix == "_" else None
 matches.sort()
 return matches
 def get_class_members(klass):
 """
 Module function to retrieve the class members.
 @param klass The class object to be analysed.
 @return A list of all names defined in the class.
 """
 ret = dir(klass)
-if hasattr(klass, '__bases__'):
+if hasattr(klass, "__bases__"):
 for base in klass.__bases__:
 ret += get_class_members(base)
 return ret
 #
 # eflag: noqa = M111

Mercurial Repositories > eric / file comparison

comparison: src/eric7/DebugClients/Python/FlexCompleter.py

src/eric7/DebugClients/Python/FlexCompleter.py