def h5py_attr_completer(context, command): """Compute possible attr matches for nested dict-like objects""" base, attr = re_attr_match.split(command)[1:3] base = base.strip() try: assert '(' not in base except AssertionError: raise ValueError() try: obj = eval(base, context.shell.user_ns) except: return [] attrs = dir(obj) try: attrs = generics.complete_object(obj, attrs) except TryNext: pass try: omit__names = ipget().readline_omit__names except AttributeError: # support <ipython-0.11 omit__names = ipget().options.readline_omit__names if omit__names == 1: attrs = [a for a in attrs if not a.startswith('__')] elif omit__names == 2: attrs = [a for a in attrs if not a.startswith('_')] readline.set_completer_delims(' =') return ["%s.%s" % (base, a) for a in attrs if a[:len(attr)] == attr]
def h5py_attr_completer(context, command): """Compute possible attr matches for nested dict-like objects""" base, attr = re_attr_match.split(command)[1:3] base = base.strip() try: obj = _retrieve_obj(base, context) except Exception: return [] attrs = dir(obj) try: attrs = generics.complete_object(obj, attrs) except TryNext: pass try: # support >=ipython-0.12 omit__names = get_ipython().Completer.omit__names except AttributeError: omit__names = 0 if omit__names == 1: attrs = [a for a in attrs if not a.startswith('__')] elif omit__names == 2: attrs = [a for a in attrs if not a.startswith('_')] return ["%s.%s" % (base, a) for a in attrs if a[:len(attr)] == attr]
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 or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ #io.rprint('Completer->attr_matches, txt=%r' % text) # dbg # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) if m: expr, attr = m.group(1, 3) elif self.greedy: m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer) if not m2: return [] expr, attr = m2.group(1, 2) else: return [] try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] if self.limit_to__all__ and hasattr(obj, '__all__'): words = get__all__entries(obj) else: words = dir2(obj) try: words = generics.complete_object(obj, words) except TryNext: pass except Exception: # Silence errors from completion function #raise # dbg pass # Build match list to return n = len(attr) res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr] return res
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 or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ #io.rprint('Completer->attr_matches, txt=%r' % text) # dbg # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) if m: expr, attr = m.group(1, 3) elif self.greedy: m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer) if not m2: return [] expr, attr = m2.group(1,2) else: return [] try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] if self.limit_to__all__ and hasattr(obj, '__all__'): words = get__all__entries(obj) else: words = dir2(obj) try: words = generics.complete_object(obj, words) except TryNext: pass except Exception: # Silence errors from completion function #raise # dbg pass # Build match list to return n = len(attr) res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ] return res
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 or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ force_complete = 1 #print 'Completer->attr_matches, txt=%r' % text # dbg lbuf = readline.get_line_buffer() # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) if m: expr, attr = m.group(1, 3) else: # force match - eval anything that ends with colon if not force_complete: return [] m2 = re.match(r"(.+)\.(\w*)$", lbuf) if not m2: return [] expr, attr = m2.group(1,2) try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] words = dir2(obj) try: words = generics.complete_object(obj, words) except TryNext: pass # Build match list to return n = len(attr) res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ] return res
def attr_matches(self, text): """Compute matches when text contains a dot. MONKEYPATCHED VERSION (ipy_greedycompleter.py) Assuming the text is of the form NAME.NAME....[NAME], and is evaluatable in self.namespace or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ import re force_complete = 1 # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) if m: expr, attr = m.group(1, 3) else: # force match - eval anything that ends with colon if not force_complete: return [] m2 = re.match(r"(.+)\.(\w*)$", self.lbuf) if not m2: return [] expr, attr = m2.group(1, 2) try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] words = dir2(obj) try: words = generics.complete_object(obj, words) except TryNext: pass # Build match list to return n = len(attr) res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr] return res
def h5py_attr_completer(context, command): """Compute possible attr matches for nested dict-like objects""" base, attr = re_attr_match.split(command)[1:3] base = base.strip() try: obj = _retrieve_obj(base, context) except: return [] attrs = dir(obj) try: attrs = generics.complete_object(obj, attrs) except TryNext: pass omit__names = None try: # support >=ipython-0.12 omit__names = get_ipython().Completer.omit__names except AttributeError: pass if omit__names is None: try: # support ipython-0.11 omit__names = get_ipython().readline_omit__names except AttributeError: pass if omit__names is None: try: # support <ipython-0.11 omit__names = get_ipython().options.readline_omit__names except AttributeError: omit__names = 0 if omit__names == 1: attrs = [a for a in attrs if not a.startswith('__')] elif omit__names == 2: attrs = [a for a in attrs if not a.startswith('_')] readline.set_completer_delims(' =') return ["%s.%s" % (base, a) for a in attrs if a[:len(attr)] == attr]
def nxattr_completer(shell, command): """Compute possible matches for NXgroup or NXfield attributes. This matches attributes at the end of NeXus dictionary references. If the entire NeXus path is defined using attribute references, then the autocompletion is handled by other completers. Parameters ---------- shell : InteractiveShell IPython shell containing the namespace to be searched. command : str Command to be autocompleted Returns ------- list of str List of possible completions. """ base, attr = re_attr_match.split(command)[1:3] base = base.strip() try: obj = _retrieve_obj(base, shell) except Exception: return [] attrs = dir(obj) try: attrs = generics.complete_object(obj, attrs) except TryNext: pass omit__names = get_ipython().Completer.omit__names if omit__names == 1: attrs = [a for a in attrs if not a.startswith('__')] elif omit__names == 2: attrs = [a for a in attrs if not a.startswith('_')] readline.set_completer_delims(' =') return [".%s" % a for a in attrs if a[:len(attr)] == attr]
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 or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ #print 'Completer->attr_matches, txt=%r' % text # dbg # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) if not m: return [] expr, attr = m.group(1, 3) try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] words = dir2(obj) try: words = generics.complete_object(obj, words) except TryNext: pass # Build match list to return n = len(attr) res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr] return res