Beispiel #1
0
def complete(text, namespace=None):
    """Complete TEXT in NAMESPACE and print a Lisp list of completions.
    NAMESPACE is currently not used."""
    if namespace is None: namespace = __main__.__dict__
    c = rlcompleter.Completer(namespace)
    try:
        if '.' in text:
            matches = c.attr_matches(text)
        else:
            matches = c.global_matches(text)
        print '_emacs_out (',
        for elt in matches:
            print '"%s"' % elt,
        print ')'
    except:
        print '_emacs_out ()'
Beispiel #2
0
def enable_autocomplete_and_history(adir, env):
    try:
        import rlcompleter
        import atexit
        import readline
    except ImportError:
        pass
    else:
        readline.parse_and_bind("tab: complete")
        history_file = os.path.join(adir, '.pythonhistory')
        try:
            readline.read_history_file(history_file)
        except IOError:
            open(history_file, 'a').close()
        atexit.register(readline.write_history_file, history_file)
        readline.set_completer(rlcompleter.Completer(env).complete)
Beispiel #3
0
def run_classic_shell(locals, globals, first_time):
    if first_time:
        banner = "Hit Ctrl-D to return to PuDB."
    else:
        banner = ""

    ns = SetPropagatingDict([locals, globals], locals)

    if HAVE_READLINE:
        readline.set_completer(
                rlcompleter.Completer(ns).complete)

    from code import InteractiveConsole
    cons = InteractiveConsole(ns)

    cons.interact(banner)
Beispiel #4
0
def complete(self, text, state):
    """
    Return the next possible completion for text, using the current frame's
    local namespace.

    This is called successively with state == 0, 1, 2, ... until it returns
    None.  The completion should begin with 'text'.

    Reference: https://code.activestate.com/recipes/498182/
    """
    # Attached a completer class and make sure it uses the current local scope
    if not hasattr(self, 'completer'):
        self.completer = rlcompleter.Completer(self.curframe.f_locals)
    else:
        self.completer.namespace = self.curframe.f_locals
    return self.completer.complete(text, state)
Beispiel #5
0
    def prompt(self, old: Any, new: Any) -> Tuple[str, str]:
        review_env = ReviewEnvironment(old=old, new=new)

        try:
            import readline
            import rlcompleter

            readline.set_completer(rlcompleter.Completer(review_env).complete)
            readline.parse_and_bind("tab: complete")
        except ImportError:
            pass

        console = ReviewConsole(review_env)
        console.interact("\na: accept, r: reject, s: skip", "")

        return review_env.outcome or ("s", "skipping snapshot")
Beispiel #6
0
    def complete(self, statement, session):
        """Autocomplete the statement in the session's globals."""

        statement_module = new.module('__main__')
        import __builtin__
        statement_module.__builtin__ = __builtin__

        old_main = sys.modules.get('__main__')

        try:
            sys.modules['__main__'] = statement_module

            statement_module.__name__ = '__main__'

            # re-evaluate the unpicklables
            for code in session.unpicklables:
                exec code in statement_module.__dict__

            old_globals = dict(statement_module.__dict__)

            # re-initialize the globals
            session_globals_dict = session.globals_dict()

            for name, val in session_globals_dict.items():
                try:
                    statement_module.__dict__[name] = val
                except:
                    session.remove_global(name)

            __builtin__._ = session_globals_dict.get('_')

            completer = rlcompleter.Completer(statement_module.__dict__)

            if '=' in statement:
                statement = statement.split('=', 1)[1].strip()
            # XXX need a better way to do this
            if '.' in statement:
                return completer.attr_matches(statement)
            else:
                return completer.global_matches(statement)

        finally:
            sys.modules['__main__'] = old_main
            try:
                del __builtin__._
            except AttributeError:
                pass
Beispiel #7
0
    def handle(self, *args, **options):

        # Set up a dictionary to serve as the environment for the shell, so
        # that tab completion works on objects that are imported at runtime.
        imported_objects = {}
        try:  # Try activating rlcompleter, because it's handy.
            import readline
        except ImportError:
            pass
        else:
            # We don't have to wrap the following import in a 'try', because
            # we already know 'readline' was imported successfully.
            import rlcompleter
            readline.set_completer(
                rlcompleter.Completer(imported_objects).complete)
            # Enable tab completion on systems using libedit (e.g. Mac OSX).
            # These lines are copied from Lib/site.py on Python 3.4.
            readline_doc = getattr(readline, '__doc__', '')
            if readline_doc is not None and 'libedit' in readline_doc:
                readline.parse_and_bind("bind ^I rl_complete")
            else:
                readline.parse_and_bind("tab:complete")

        # Get $PYTHONSTARTUP and then .pythonrc.py
        for pythonrc in (os.environ.get("PYTHONSTARTUP"), '~/.pythonrc.py'):
            if not pythonrc:
                continue
            pythonrc = os.path.expanduser(pythonrc)
            if not os.path.isfile(pythonrc):
                continue
            try:
                with open(pythonrc) as handle:
                    exec(compile(handle.read(), pythonrc, 'exec'),
                         imported_objects)
            except NameError:
                pass

        c_all = cont.Contact.objects_no_link.all()
        m_all = cont.Message.objects.all()
        v_all = cont.Visit.objects.all()
        s_all = cont.StatusChange.objects.all()

        namespace = globals()
        namespace.update(locals())
        if options['test'] is True:
            namespace.update(test_handler(namespace))
        code.interact(local=namespace)
    def handle_noargs(self, **options):
        # XXX: (Temporary) workaround for ticket #1796: force early loading of all
        # models from installed apps.
        from django.db.models.loading import get_models
        loaded_models = get_models()

        use_plain = options.get('plain', False)

        try:
            if use_plain:
                # Don't bother loading IPython, because the user wants plain Python.
                raise ImportError
            import IPython
            # Explicitly pass an empty list as arguments, because otherwise IPython
            # would use sys.argv from this script.
            shell = IPython.Shell.IPShell(argv=[])
            shell.mainloop()
        except ImportError:
            import code
            # Set up a dictionary to serve as the environment for the shell, so
            # that tab completion works on objects that are imported at runtime.
            # See ticket 5082.
            imported_objects = {}
            try:  # Try activating rlcompleter, because it's handy.
                import readline
            except ImportError:
                pass
            else:
                # We don't have to wrap the following import in a 'try', because
                # we already know 'readline' was imported successfully.
                import rlcompleter
                readline.set_completer(
                    rlcompleter.Completer(imported_objects).complete)
                readline.parse_and_bind("tab:complete")

            # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
            # conventions and get $PYTHONSTARTUP first then import user.
            if not use_plain:
                pythonrc = os.environ.get("PYTHONSTARTUP")
                if pythonrc and os.path.isfile(pythonrc):
                    try:
                        execfile(pythonrc)
                    except NameError:
                        pass
                # This will import .pythonrc.py as a side-effect
                import user
            code.interact(local=imported_objects)
Beispiel #9
0
    def get_plain(self, options):
        # Using normal Python shell
        import code
        imported_objects = self.get_imported_objects(options)
        try:
            # Try activating rlcompleter, because it's handy.
            import readline
        except ImportError:
            pass
        else:
            # We don't have to wrap the following import in a 'try', because
            # we already know 'readline' was imported successfully.
            import rlcompleter
            readline.set_completer(rlcompleter.Completer(imported_objects).complete)
            # Enable tab completion on systems using libedit (e.g. macOS).
            # These lines are copied from Lib/site.py on Python 3.4.
            readline_doc = getattr(readline, '__doc__', '')
            if readline_doc is not None and 'libedit' in readline_doc:
                readline.parse_and_bind("bind ^I rl_complete")
            else:
                readline.parse_and_bind("tab:complete")

        use_pythonrc = options['use_pythonrc']
        no_startup = options['no_startup']

        # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
        # conventions and get $PYTHONSTARTUP first then .pythonrc.py.
        if use_pythonrc or not no_startup:
            for pythonrc in OrderedSet([os.environ.get("PYTHONSTARTUP"), os.path.expanduser('~/.pythonrc.py')]):
                if not pythonrc:
                    continue
                if not os.path.isfile(pythonrc):
                    continue
                with open(pythonrc) as handle:
                    pythonrc_code = handle.read()
                # Match the behavior of the cpython shell where an error in
                # PYTHONSTARTUP prints an exception and continues.
                try:
                    exec(compile(pythonrc_code, pythonrc, 'exec'), imported_objects)
                except Exception:
                    traceback.print_exc()
                    if self.tests_mode:
                        raise

        def run_plain():
            code.interact(local=imported_objects)
        return run_plain
Beispiel #10
0
    def __init__(self, interp, config):
        """Initialise the repl.

        interp is a Python code.InteractiveInterpreter instance

        config is a populated bpython.config.Struct.
        """

        self.config = config
        self.cut_buffer = ''
        self.buffer = []
        self.interp = interp
        self.interp.syntaxerror_callback = self.clear_current_line
        self.match = False
        self.rl_history = History(duplicates=config.hist_duplicates)
        self.s_hist = []
        self.history = []
        self.evaluating = False
        # Use the interpreter's namespace only for the readline stuff:
        self.completer = rlcompleter.Completer(self.interp.locals)
        self.completer.attr_matches = self.attr_matches
        # Gna, Py 2.6's rlcompleter searches for __call__ inside the
        # instance instead of the type, so we monkeypatch to prevent
        # side-effects (__getattr__/__getattribute__)
        self.completer._callable_postfix = self._callable_postfix
        self.matches = []
        self.matches_iter = MatchesIterator()
        self.argspec = None
        self.current_func = None
        self.highlighted_paren = None
        self.list_win_visible = False
        self._C = {}
        self.prev_block_finished = 0
        self.interact = Interaction(self.config)
        self.ps1 = '>>> '
        self.ps2 = '... '
        # previous pastebin content to prevent duplicate pastes, filled on call
        # to repl.pastebin
        self.prev_pastebin_content = ''
        self.prev_pastebin_url = ''
        # Necessary to fix mercurial.ui.ui expecting sys.stderr to have this
        # attribute
        self.closed = False

        pythonhist = os.path.expanduser(self.config.hist_file)
        if os.path.exists(pythonhist):
            self.rl_history.load(pythonhist, getpreferredencoding() or "ascii")
Beispiel #11
0
    def python(self, options):
        import code

        # Set up a dictionary to serve as the environment for the shell, so
        # that tab completion works on objects that are imported at runtime.
        imported_objects = {}
        try:  # Try activating rlcompleter, because it's handy.
            import readline
        except ImportError:
            pass
        else:
            # We don't have to wrap the following import in a 'try', because
            # we already know 'readline' was imported successfully.
            import rlcompleter

            readline.set_completer(
                rlcompleter.Completer(imported_objects).complete)
            # Enable tab completion on systems using libedit (e.g. macOS).
            # These lines are copied from Python's Lib/site.py.
            readline_doc = getattr(readline, "__doc__", "")
            if readline_doc is not None and "libedit" in readline_doc:
                readline.parse_and_bind("bind ^I rl_complete")
            else:
                readline.parse_and_bind("tab:complete")

        # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
        # conventions and get $PYTHONSTARTUP first then .pythonrc.py.
        if not options["no_startup"]:
            for pythonrc in OrderedSet([
                    os.environ.get("PYTHONSTARTUP"),
                    os.path.expanduser("~/.pythonrc.py")
            ]):
                if not pythonrc:
                    continue
                if not os.path.isfile(pythonrc):
                    continue
                with open(pythonrc) as handle:
                    pythonrc_code = handle.read()
                # Match the behavior of the cpython shell where an error in
                # PYTHONSTARTUP prints an exception and continues.
                try:
                    exec(compile(pythonrc_code, pythonrc, "exec"),
                         imported_objects)
                except Exception:
                    traceback.print_exc()

        code.interact(local=imported_objects)
Beispiel #12
0
    def run_shell(self, opts):
        """\nDebug method to run a shell"""
        import code
        import readline
        import rlcompleter
        opts['remotes'] = self.get_remotes(opts)

        data = {
            'self': self,
            'gitlab': glapi,
            'opts': opts,
        }
        readline.set_completer(rlcompleter.Completer(data).complete)
        readline.parse_and_bind("tab: complete")
        shl = code.InteractiveConsole(data)
        shl.interact()
        sys.exit(1)
Beispiel #13
0
    def handle_noargs(self, **options):
        use_plain = options.get('plain', False)
        no_startup = options.get('no_startup', False)
        interface = options.get('interface', None)

        try:
            if use_plain:
                # Don't bother loading IPython, because the user wants plain Python.
                raise ImportError

            self.run_shell(shell=interface)
        except ImportError:
            import code
            # Set up a dictionary to serve as the environment for the shell, so
            # that tab completion works on objects that are imported at runtime.
            # See ticket 5082.
            imported_objects = {}
            try:  # Try activating rlcompleter, because it's handy.
                import readline
            except ImportError:
                pass
            else:
                # We don't have to wrap the following import in a 'try', because
                # we already know 'readline' was imported successfully.
                import rlcompleter
                readline.set_completer(
                    rlcompleter.Completer(imported_objects).complete)
                readline.parse_and_bind("tab:complete")

            # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
            # conventions and get $PYTHONSTARTUP first then .pythonrc.py.
            if not no_startup:
                for pythonrc in (os.environ.get("PYTHONSTARTUP"),
                                 '~/.pythonrc.py'):
                    if not pythonrc:
                        continue
                    pythonrc = os.path.expanduser(pythonrc)
                    if not os.path.isfile(pythonrc):
                        continue
                    try:
                        with open(pythonrc) as handle:
                            exec(compile(handle.read(), pythonrc, 'exec'),
                                 imported_objects)
                    except NameError:
                        pass
            code.interact(local=imported_objects)
Beispiel #14
0
 def debug(self):
     """
     Use an interactive mode to debug the program.
     """
     import code
     sys.ps1 = "[cc] >>> "
     vars = globals()
     vars.update(locals())
     if hasattr(
             self,
             'subshell',
     ):
         vars.update(**self.subshell)
     import readline, rlcompleter
     readline.set_completer(rlcompleter.Completer(vars).complete)
     readline.parse_and_bind("tab: complete")
     code.interact(local=vars, banner='')
Beispiel #15
0
def copen(filename=None, interactive='True'):
    """Opens interactive console and execute the content of filename"""
    context = globals().copy()
    readline.set_completer(rlcompleter.Completer(context).complete)
    readline.parse_and_bind("tab: complete")
    shell = code.InteractiveConsole(context)
    if filename:
        with open(filename) as f:
            cmds = f.read()
        shell.runcode(START.format(path=os.path.dirname(filename)))
        shell.runcode(cmds)
    if interactive == 'True':
        shell.interact(banner='')
    else:
        txt = 'Press return to close window'
        print(f'\n{"-" * len(txt)}\n{txt}')
        input('')
Beispiel #16
0
    def __init__(self, *args, run_callback=None, **kwargs):
        super().__init__(*args, **kwargs)

        if readline is not None:
            self._histfile = os.path.expanduser("~/.glasgow-history")
            try:
                readline.read_history_file(self._histfile)
            except FileNotFoundError:
                pass

            completer = rlcompleter.Completer(self.locals)
            readline.parse_and_bind("tab: complete")
            readline.set_completer(completer.complete)

        self.locals["__name__"] = __name__.split(".")[0]
        self.run_callback = run_callback
        self._future = None
def interact(driver):
	try:
		import code
		vars = globals()
		vars.update(locals())
		if os.name != 'nt':
			import readline
			import rlcompleter
			readline.set_completer(rlcompleter.Completer(vars).complete)
			readline.parse_and_bind("tab: complete")
		shell = code.InteractiveConsole(vars)
		shell.interact()
	except:
		print("[-] Error with python repl!")
	finally:
		print("[+] Done with python repl")
		driver.quit()
Beispiel #18
0
def repl(local, histfile=None, banner=None):
    import readline
    import rlcompleter
    if 'libedit' in readline.__doc__:
        readline.parse_and_bind('bind ^I rl_complete')
    else:
        readline.parse_and_bind('tab: complete')
    if histfile is not None and os.path.exists(histfile):
        # avoid duplicate reading
        if readline.get_current_history_length() <= 0:
            readline.set_history_length(10000)
            readline.read_history_file(histfile)
    import code
    readline.set_completer(rlcompleter.Completer(local).complete)
    code.interact(local=local, banner=banner)
    if histfile is not None:
        readline.write_history_file(histfile)
Beispiel #19
0
 def __init__(self, locals=None, histfile=None, writefunc=None):
     code.InteractiveConsole.__init__(self, locals)
     self.thread = None
     self._exit = False
     if writefunc and callable(writefunc):
         self.write = writefunc
     try:
         import readline
     except ImportError:
         pass
     else:
         try:
             import rlcompleter
             readline.set_completer(rlcompleter.Completer(locals).complete)
         except ImportError:
             pass
         readline.parse_and_bind("tab: complete")
Beispiel #20
0
 def __init__(self,
              locals=None,
              filename="<console>",
              histfile=os.path.expanduser("~/.console-history")):
     code.InteractiveConsole.__init__(self, locals, filename)
     try:
         import readline
     except ImportError:
         pass
     else:
         try:
             import rlcompleter
             readline.set_completer(rlcompleter.Completer(locals).complete)
         except ImportError:
             pass
         readline.parse_and_bind("tab: complete")
     self.init_history(histfile)
def run_debug_console(simulation, show_banner=True):
    """
    Run a debug console with some useful variables available
    """
    banner = ['Ocellaris interactive console\n']

    # Everything from dolfin should be available
    import dolfin

    debug_locals = dict(**dolfin.__dict__)

    # All variables in the data dict should be available
    debug_locals.update(simulation.data)

    # The simulation object shoule be available
    debug_locals['simulation'] = simulation

    # Create a banner to show before the console
    banner.append('Available variables:')
    names = list(simulation.data.keys()) + ['simulation']
    for i, name in enumerate(sorted(names)):
        if i % 4 == 0:
            banner[-1] += '\n'
        banner[-1] += '  %-18s' % name
    banner.append(
        '\n\nPress Ctrl+D to continue running the simulation.'
        '\nRunning exit() or quit() will stop Ocellaris.'
    )

    # Add some convenience functions
    funcs, info = define_convenience_functions(simulation)
    debug_locals.update(funcs)
    banner.extend(info)

    # Setup tab completion
    readline.set_completer(rlcompleter.Completer(debug_locals).complete)
    readline.parse_and_bind("tab: complete")

    if not show_banner:
        banner = []

    print('=== OCELLARIS CONSOLE === ' * 3)
    banner.append('\n>>> from dolfin import *')
    code.interact('\n'.join(banner), local=debug_locals)
    print('= OCELLARIS CONSOLE ====' * 3)
Beispiel #22
0
def main():
    args = parse_args()

    global_vars = {}

    if args.main:
        global_vars['__name__'] = "__main__"

    for script_filename in args.FILE:
        if args.verbose:
            print("loading file '{}'".format(script_filename))

        with open(script_filename) as fin:
            func = compile(fin.read(), script_filename, 'exec')
            exec(func, global_vars)
    if args.verbose and args.FILE:
        print()

    if args.command is not None:
        for command in args.command:
            if args.verbose:
                print("executing: '{}'".format(command))
            func = compile(command, "command", 'exec')
            exec(func, global_vars)

    if args.verbose and args.command:
        print()

    readline.set_completer(rlcompleter.Completer(global_vars).complete)
    readline.parse_and_bind("tab: complete")

    if args.verbose:
        for k, v in global_vars.items():
            if k != "__builtins__":
                print("{} = {}".format(k, v))
        print()

    if not args.quit:
        history_file = os.path.expanduser("~/.ipy_history")
        if os.path.exists(history_file):
            readline.read_history_file(history_file)

        code.interact(banner="", local=global_vars)

        readline.write_history_file(history_file)
    def get_plain(self, options):
        # Using normal Python shell
        import code
        imported_objects = self.get_imported_objects(options)
        try:
            # Try activating rlcompleter, because it's handy.
            import readline
        except ImportError:
            pass
        else:
            # We don't have to wrap the following import in a 'try', because
            # we already know 'readline' was imported successfully.
            import rlcompleter
            readline.set_completer(
                rlcompleter.Completer(imported_objects).complete)
            readline.parse_and_bind("tab:complete")

        use_pythonrc = options.get('use_pythonrc', False)
        no_startup = options.get('no_startup', False)

        # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
        # conventions and get $PYTHONSTARTUP first then .pythonrc.py.
        if use_pythonrc or not no_startup:
            for pythonrc in OrderedSet([
                    os.environ.get("PYTHONSTARTUP"),
                    os.path.expanduser('~/.pythonrc.py')
            ]):
                if not pythonrc:
                    continue
                if not os.path.isfile(pythonrc):
                    continue
                with open(pythonrc) as handle:
                    pythonrc_code = handle.read()
                # Match the behavior of the cpython shell where an error in
                # PYTHONSTARTUP prints an exception and continues.
                try:
                    exec(compile(pythonrc_code, pythonrc, 'exec'),
                         imported_objects)
                except Exception:
                    traceback.print_exc()

        def run_plain():
            code.interact(local=imported_objects)

        return run_plain
Beispiel #24
0
    def handle_noargs(self, **options):
        # XXX: (Temporary) workaround for ticket #1796: force early loading of all
        # models from installed apps.
        from django.apps import apps
        loaded_models = apps.get_models()

        import code
        # Set up a dictionary to serve as the environment for the shell, so
        # that tab completion works on objects that are imported at runtime.
        # See ticket 5082.
        imported_objects = {
            'datetime': datetime,
            'cache': cache,
            'reverse': reverse,
            'resolve': resolve,
            'settings': settings,
        }

        # Put all of the models into the local namespace.
        for model in loaded_models:
            imported_objects[model.__name__] = model

        try:  # Try activating rlcompleter, because it's handy.
            import readline
        except ImportError:
            pass
        else:
            # We don't have to wrap the following import in a 'try', because
            # we already know 'readline' was imported successfully.
            import rlcompleter
            readline.set_completer(
                rlcompleter.Completer(imported_objects).complete)
            readline.parse_and_bind("tab:complete")

        # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
        # conventions and get $PYTHONSTARTUP first then import user.
        pythonrc = os.environ.get("PYTHONSTARTUP")
        if pythonrc and os.path.isfile(pythonrc):
            try:
                execfile(pythonrc)
            except NameError:
                pass
        # This will import .pythonrc.py as a side-effect
        import user
        code.interact(local=imported_objects)
Beispiel #25
0
def complete_names(word, namespace):
    """Complete variable names or attributes

    :param word: word to be completed
    :type word: str
    :param namespace: namespace
    :type namespace: dict
    :returns: completion matches
    :rtype: list of str

    >>> complete_names('fo', {'foo': 'bar'})
    ['foo', 'for', 'format(']
    """
    # start completer
    completer = rlcompleter.Completer(namespace)
    # find matches with std library (don't try to implement this yourself)
    completer.complete(word, 0)
    return sorted(set(completer.matches))
Beispiel #26
0
def readline_setup(exports):
    """setup readline completion, if available.

    :param exports: the namespace to be used for completion
    :return: True on success

    """
    try:
        import readline
    except ImportError:
        # no completion for you.
        readline = None
        return False
    else:
        import rlcompleter
        readline.set_completer(
            rlcompleter.Completer(namespace=exports).complete)
        return True
Beispiel #27
0
def run_client(host="localhost", port=9901):
    import code
    import readline
    import rlcompleter
    url = "http://{host}:{port}/jsonrpc".format(host=host, port=port)
    cli = TeleniumHttpClient(url=url, timeout=5)

    print("Connecting to {}".format(url))
    while not cli.ping():
        sleep(.1)
    print("Connected!")

    vars = globals()
    vars.update(locals())
    readline.set_completer(rlcompleter.Completer(vars).complete)
    readline.parse_and_bind("tab: complete")
    shell = code.InteractiveConsole(vars)
    shell.interact()
Beispiel #28
0
def enableAutocomplete(ns=None):
    """
    Enables tab-based autocomplete. The readline module must be available.
        <ns> is the namespace which readline starts out with.
        This should generally be the same as your interpreter uses,
        but defaults to globals() if ns is not provided.
    If you need to change the namespace at a later point, simply
    set the completer manually with:
        import readline, rlcompleter
        readline.set_completer(rlcompleter.Completer(ns).complete)
    """
    if ns is None:
        ns = globals()
    if readline:
        readline.set_completer(rlcompleter.Completer(ns).complete)
        readline.parse_and_bind("tab: complete")
    else:
        print "readline module not available. Must be installed for tab-based autocomplete to work. Google it."
Beispiel #29
0
    def rpc_get_completions(self, project_root, filename, source, offset):
        """Get completions for symbol at the offset.

        Wrapper around rlcompleter.

        """
        completer = rlcompleter.Completer()
        symbol, start, end = find_dotted_symbol_backward(source, offset)
        completions = []
        i = 0
        while True:
            res = completer.complete(symbol, i)
            if res is None:
                break
            completion = res[len(symbol):].rstrip("(")
            completions.append((completion, None))
            i += 1
        return completions
Beispiel #30
0
    def __read_input(self):

        readline.set_completer(rlcompleter.Completer(self.__vars).complete)
        readline.parse_and_bind("tab: complete")

        if os.path.exists(self.HistoryFile.value):
            readline.read_history_file(self.HistoryFile.value)

        while (True):
            try:
                line = raw_input('\001' + print_green + '\002' +
                                 self.Prompt.value + '\001' + print_reset +
                                 '\002')
                self.__input_queue.put(line)
            except:
                print "Exiting GuaVe, press Ctrl-C to kill guacamole..."
                #sys.exit(0)
                break