| """Word completion for GNU readline 2.0. | |
| This requires the latest extension to the readline module. The completer | |
| completes keywords, built-ins and globals in a selectable namespace (which | |
| defaults to __main__); when completing NAME.NAME..., it evaluates (!) the | |
| expression up to the last dot and completes its attributes. | |
| It's very cool to do "import sys" type "sys.", hit the | |
| completion key (twice), and see the list of names defined by the | |
| sys module! | |
| Tip: to use the tab key as the completion key, call | |
| readline.parse_and_bind("tab: complete") | |
| Notes: | |
| - Exceptions raised by the completer function are *ignored* (and | |
| generally cause the completion to fail). This is a feature -- since | |
| readline sets the tty device in raw (or cbreak) mode, printing a | |
| traceback wouldn't work well without some complicated hoopla to save, | |
| reset and restore the tty state. | |
| - The evaluation of the NAME.NAME... form may cause arbitrary | |
| application defined code to be executed if an object with a | |
| __getattr__ hook is found. Since it is the responsibility of the | |
| application (or the user) to enable this feature, I consider this an | |
| acceptable risk. More complicated expressions (e.g. function calls or | |
| indexing operations) are *not* evaluated. | |
| - GNU readline is also used by the built-in functions input() and | |
| raw_input(), and thus these also benefit/suffer from the completer | |
| features. Clearly an interactive application can benefit by | |
| specifying its own completer function and using raw_input() for all | |
| its input. | |
| - When the original stdin is not a tty device, GNU readline is never | |
| used, and this module (and the readline module) are silently inactive. | |
| """ | |
| import __builtin__ | |
| import __main__ | |
| __all__ = ["Completer"] | |
| class Completer: | |
| def __init__(self, namespace = None): | |
| """Create a new completer for the command line. | |
| Completer([namespace]) -> completer instance. | |
| If unspecified, the default namespace where completions are performed | |
| is __main__ (technically, __main__.__dict__). Namespaces should be | |
| given as dictionaries. | |
| Completer instances should be used as the completion mechanism of | |
| readline via the set_completer() call: | |
| readline.set_completer(Completer(my_namespace).complete) | |
| """ | |
| if namespace and not isinstance(namespace, dict): | |
| 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: | |
| self.use_main_ns = 1 | |
| else: | |
| self.use_main_ns = 0 | |
| self.namespace = namespace | |
| def complete(self, text, state): | |
| """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'. | |
| """ | |
| 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) | |
| try: | |
| return self.matches[state] | |
| except IndexError: | |
| return None | |
| def _callable_postfix(self, val, word): | |
| if hasattr(val, '__call__'): | |
| word = word + "(" | |
| return word | |
| def global_matches(self, text): | |
| """Compute matches when text is a simple name. | |
| Return a list of all keywords, built-in functions and names currently | |
| defined in self.namespace that match. | |
| """ | |
| import keyword | |
| matches = [] | |
| n = len(text) | |
| for word in keyword.kwlist: | |
| if word[:n] == text: | |
| matches.append(word) | |
| for nspace in [__builtin__.__dict__, self.namespace]: | |
| for word, val in nspace.items(): | |
| if word[:n] == text and word != "__builtins__": | |
| matches.append(self._callable_postfix(val, word)) | |
| return matches | |
| def attr_matches(self, text): | |
| """Compute matches when text contains a dot. | |
| Assuming the text is of the form NAME.NAME....[NAME], and is | |
| evaluatable in self.namespace, it will be evaluated and its attributes | |
| (as revealed by dir()) are used as possible completions. (For class | |
| instances, class members are also considered.) | |
| WARNING: this can still invoke arbitrary C code, if an object | |
| with a __getattr__ hook is evaluated. | |
| """ | |
| 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) | |
| except Exception: | |
| return [] | |
| # get the content of the object, except __builtins__ | |
| words = dir(thisobject) | |
| if "__builtins__" in words: | |
| words.remove("__builtins__") | |
| if hasattr(thisobject, '__class__'): | |
| words.append('__class__') | |
| words.extend(get_class_members(thisobject.__class__)) | |
| matches = [] | |
| n = len(attr) | |
| for word in words: | |
| if word[:n] == attr and hasattr(thisobject, word): | |
| val = getattr(thisobject, word) | |
| word = self._callable_postfix(val, "%s.%s" % (expr, word)) | |
| matches.append(word) | |
| return matches | |
| def get_class_members(klass): | |
| ret = dir(klass) | |
| if hasattr(klass,'__bases__'): | |
| for base in klass.__bases__: | |
| ret = ret + get_class_members(base) | |
| return ret | |
| try: | |
| import readline | |
| except ImportError: | |
| pass | |
| else: | |
| readline.set_completer(Completer().complete) |