def process_input(self, character):
     self.window.window.clear()
     if character == 263 and self.buffer:     # Handle backspace
         self.buffer = self.buffer[:-1]
     elif character == 10 or character == 13: # Handle the return key
         inputs = self.buffer.split("\n")
         if "menu" in inputs:
             menu = self.window.get("menu")
             menu.hidden = False if menu.hidden else True
             menu.active = True if not menu.active else False
         # Yup... Can launch ptpython with the "python" command.
         elif "python" in inputs:
             try:
                 from ptpython.repl import embed
                 self.window.stop()
                 l = {"pane": self, "window": self.window}
                 embed(locals=l, vi_mode=True)
                 self.buffer = ""
                 self.window.start()
             except:
                 pass
         elif "exit" in inputs:
             self.window.stop()
         self.buffer = ""
     else:
         try: self.buffer += chr(character)   # Append input to buffer
         except: pass
     import random
     colours = palette(-1, random.choice(["yellow","red"]))
     self.change_content(1, self.buffer, ALIGN_LEFT, colours)

def run():
    a = docopt.docopt(__doc__)

    vi_mode = bool(a['--vi'])
    no_colors = bool(a['--no-colors'])

    # Create globals/locals dict.
    globals_, locals_ = {}, {}

    # Log history
    if a['--history']:
        history_filename = os.path.expanduser(a['--history'])
    else:
        history_filename = os.path.expanduser('~/.ptpython_history')

    # Startup path
    startup_paths = []
    if 'PYTHONSTARTUP' in os.environ:
        startup_paths.append(os.environ['PYTHONSTARTUP'])

    # --interactive
    if a['--interactive']:
        startup_paths.append(a['--interactive'])

    # Add the current directory to `sys.path`.
    sys.path.append('.')

    # When a file has been given, run that, otherwise start the shell.
    if a['<file>']:
        sys.argv = [a['<file>']] + a['<arg>']
        six.exec_(compile(open(a['<file>'], "rb").read(), a['<file>'], 'exec'))
    else:
        # Run interactive shell.
        embed(globals_, locals_, vi_mode=vi_mode, history_filename=history_filename,
              no_colors=no_colors, startup_paths=startup_paths)

    def start(self) -> None:
        try:
            from ptpython.repl import embed, run_config
        except ImportError:
            raise ShellNotAvailableError("PtPython shell not available.")
        print(self.banner)

        config_dir = Path("~/.ptpython/").expanduser()

        # Startup path
        startup_paths = []
        if "PYTHONSTARTUP" in os.environ:
            startup_paths.append(os.environ["PYTHONSTARTUP"])

        # Apply config file
        def configure(repl):
            path = config_dir / "config.py"
            if path.exists():
                run_config(repl, str(path))

        embed(
            globals=self.context,
            history_filename=config_dir / "history",
            vi_mode=self.ptpy_vi_mode,
            startup_paths=startup_paths,
            configure=configure,
        )
        return None

 def __call__(self):
     try:
         from ptpython.repl import embed
         embed(globals(), None)
     except ImportError:
         printo('Install ptpython for a better repl')
         import code
         code.interact(banner="Launching strandard python repl", readfunc=None, local=globals())

def main():
    with ExitStack() as e:
        r = Robot()
        e.enter_context(r)
        # s = Server()
        # e.enter_context(s)
    # ws = Websocket()
        embed(globals(), locals())

 def do_interact(self, args):
     """
     Interact: start interpreter.
     (Override the 'pdb' implementation. We call ptpython instead.)
     """
     print('')
     ns = self.curframe.f_globals.copy()
     ns.update(self.curframe_locals)
     embed(globals=ns)

def shell(env):
    '''Start a new interactive python session'''
    namespace = {'env': env}
    try:
        from ptpython.repl import embed
        hf = str(Path('~/.ptpython_history').expanduser())
        embed(namespace, history_filename=hf)
    except ImportError:
        from code import interact
        interact('', local=namespace)

 def __call__(self):
     try:
         from ptpython.repl import embed
         embed(globals(), None)
     except ImportError:
         try:
             from IPython import embed
             embed()
         except ImportError:
             import code
             code.interact(banner="Launching standard python repl", readfunc=None, local=globals())

def run():
    a = docopt.docopt(__doc__)

    vi_mode = bool(a['--vi'])
    config_dir = os.path.expanduser(a['--config-dir'] or '~/.ptpython/')

    # Create config directory.
    if not os.path.isdir(config_dir):
        os.mkdir(config_dir)

    # Startup path
    startup_paths = []
    if 'PYTHONSTARTUP' in os.environ:
        startup_paths.append(os.environ['PYTHONSTARTUP'])

    # --interactive
    if a['--interactive']:
        startup_paths.append(a['--interactive'])

    # Add the current directory to `sys.path`.
    if sys.path[0] != '':
        sys.path.insert(0, '')

    # When a file has been given, run that, otherwise start the shell.
    if a['<file>']:
        sys.argv = [a['<file>']] + a['<arg>']
        six.exec_(compile(open(a['<file>'], "rb").read(), a['<file>'], 'exec'))

    # Run interactive shell.
    else:
        enable_deprecation_warnings()

        # Apply config file
        def configure(repl):
            path = os.path.join(config_dir, 'conf.cfg')
            if os.path.exists(path):
                load_config(repl, path)
            path = os.path.join(config_dir, 'config.py')
            if os.path.exists(path):
                run_config(repl, path)

        # Save user settings in config file when repl is done
        def done(repl):
            path = os.path.join(config_dir, 'conf.cfg')
            # Create the file if it doesn't exist
            repl.settings.save_config(path)

        embed(vi_mode=vi_mode,
              history_filename=os.path.join(config_dir, 'history'),
              configure=configure,
              done=done,
              startup_paths=startup_paths,
              title='Python REPL (ptpython)')

def _embed_ptpython():
    """Embed a ptpython vanilla prompt."""
    try:
        from ptpython.repl import embed
    except ImportError:
        return False

    from inspect import currentframe
    caller = currentframe().f_back.f_back
    print(_embed_banner.format(filename=caller.f_code.co_filename,
                               line=caller.f_lineno))
    embed(caller.f_globals, caller.f_locals)
    return True

 def postOptions(self):
     historyFile = os.path.expanduser(self['history-file'])
     if not embed:
         interp = code.InteractiveConsole(self.namespace(), '<axiom browser>')
         if readline is not None and os.path.exists(historyFile):
             readline.read_history_file(historyFile)
         try:
             interp.interact("%s.  Autocommit is off." % (str(axiom.version),))
         finally:
             if readline is not None:
                 readline.write_history_file(historyFile)
     else:
         embed(self.namespace(), None, None, False, historyFile, '<axiom browser>')

def create_shell(ipython, ptpython, manage_dict=None, extra_vars=None):
    """Creates the shell"""
    manage_dict = manage_dict or MANAGE_DICT
    _vars = globals()
    _vars.update(locals())
    auto_imported = import_objects(manage_dict)
    if extra_vars:
        auto_imported.update(extra_vars)
    _vars.update(auto_imported)
    msgs = []
    if manage_dict['shell']['banner']['enabled']:
        msgs.append(
            manage_dict['shell']['banner']['message'].format(**manage_dict)
        )
    if auto_imported and manage_dict['shell']['auto_import']['display']:
        auto_imported_names = [
            key for key in auto_imported.keys()
            if key not in ['__builtins__', 'builtins']
        ]
        msgs.append('\tAuto imported: {0}\n'.format(auto_imported_names))

    banner_msg = u'\n'.join(msgs)

    if manage_dict['shell']['readline_enabled']:
        readline.set_completer(rlcompleter.Completer(_vars).complete)
        readline.parse_and_bind('tab: complete')

    exec_init(manage_dict, _vars)
    exec_init_script(manage_dict, _vars)

    if ptpython:
        try:
            from ptpython.repl import embed
            embed({}, _vars)
        except ImportError:
            click.echo("ptpython is not installed!")
        return

    try:
        if ipython is True:
            from IPython import start_ipython
            from traitlets.config import Config
            c = Config()
            c.TerminalInteractiveShell.banner2 = banner_msg
            start_ipython(argv=[], user_ns=_vars, config=c)
        else:
            raise ImportError
    except ImportError:
        shell = code.InteractiveConsole(_vars)
        shell.interact(banner=banner_msg)

def run():
    a = docopt.docopt(__doc__)

    vi_mode = bool(a['--vi'])
    config_dir = os.path.expanduser(a['--config-dir'] or '~/.ptpython/')

    # Create config directory.
    if not os.path.isdir(config_dir):
        os.mkdir(config_dir)

    # Startup path
    startup_paths = []
    if 'PYTHONSTARTUP' in os.environ:
        startup_paths.append(os.environ['PYTHONSTARTUP'])

    # --interactive
    if a['--interactive']:
        startup_paths.append(a['--interactive'])
        sys.argv = [a['--interactive']] + a['<arg>']

    # Add the current directory to `sys.path`.
    if sys.path[0] != '':
        sys.path.insert(0, '')

    # When a file has been given, run that, otherwise start the shell.
    if a['<arg>'] and not a['--interactive']:
        sys.argv = a['<arg>']
        path = a['<arg>'][0]
        with open(path, 'rb') as f:
            code = compile(f.read(), path, 'exec')
            six.exec_(code)

    # Run interactive shell.
    else:
        enable_deprecation_warnings()

        # Apply config file
        def configure(repl):
            path = os.path.join(config_dir, 'config.py')
            if os.path.exists(path):
                run_config(repl, path)

        import __main__
        embed(vi_mode=vi_mode,
              history_filename=os.path.join(config_dir, 'history'),
              configure=configure,
              locals=__main__.__dict__,
              globals=__main__.__dict__,
              startup_paths=startup_paths,
              title='Python REPL (ptpython)')

        def run_interactive_shell():

            def configure(repl):
                """Apply config file"""
                path = os.path.join(args['config_dir'], 'config.py')
                if os.path.exists(path):
                    repl.run_config(repl, path)

            from ptpython import repl
            repl.enable_deprecation_warnings()
            repl.embed(
                vi_mode=args.get('--vi', True),
                history_filename=os.path.join(args['config_dir'], 'history'),
                configure=configure,
                startup_paths=args.get('startup_paths', []),
                title=u'Pym REPL (pym)')

 def start_shell(self):
     try:
         from ptpython.repl import embed
     except ImportError:
         log.error("Unable to start a shell: the ptpython module must be installed!")
         return
     yield from embed(globals(), locals(), return_asyncio_coroutine=True, patch_stdout=True, history_filename=".gns3_shell_history")

def ptipython_shell_runner(env, help):
    try:
        from ptpython.ipython import embed
    except ImportError:
        print('You need to install the ipython package for ptipython to work')
        return

    return embed(user_ns=env, banner2=help)

    def start(self):
        coroutine = embed(self.namespace, self.namespace, title='Tin Bot Console',
                          patch_stdout=True, history_filename='.tin_bot_history',
                          return_asyncio_coroutine=True)

        # HACK: nasty hack to gain access to the command line interface wrapper
        self.cli = coroutine.gi_frame.f_locals['cli']

        future = asyncio.ensure_future(coroutine)
        return future

def interactive_shell():
    """
    Coroutine that starts a Python REPL from which we can access the global
    counter variable.
    """
    print('You should be able to read and update the "counter[0]" variable from this shell.')
    yield from embed(globals=globals(), return_asyncio_coroutine=True, patch_stdout=True)

    # Stop the loop when quitting the repl. (Ctrl-D press.)
    loop.stop()

def run():
    a = docopt.docopt(__doc__)

    vi_mode = bool(a['--vi'])
    config_dir = os.path.expanduser(a['--config-dir'] or '~/.ptpython/')

    # Create config directory.
    if not os.path.isdir(config_dir):
        os.mkdir(config_dir)

    # Startup path
    startup_paths = []
    if 'PYTHONSTARTUP' in os.environ:
        startup_paths.append(os.environ['PYTHONSTARTUP'])

    # --interactive
    if a['--interactive']:
        startup_paths.append(a['--interactive'])

    # Add the current directory to `sys.path`.
    sys.path.append('.')

    # When a file has been given, run that, otherwise start the shell.
    if a['<file>']:
        sys.argv = [a['<file>']] + a['<arg>']
        six.exec_(compile(open(a['<file>'], "rb").read(), a['<file>'], 'exec'))

    # Run interactive shell.
    else:
        enable_deprecation_warnings()

        # Apply config file
        def configure(repl):
            path = os.path.join(config_dir, 'config.py')
            if os.path.exists(path):
                run_config(repl, path)

        embed(vi_mode=vi_mode,
              history_filename=os.path.join(config_dir, 'history'),
              configure=configure,
              startup_paths=startup_paths)

    def start(self):
        self.running = True

        coroutine = embed(self.namespace, self.namespace, title='Jaspy Console',
                          patch_stdout=True, history_filename=self.history,
                          return_asyncio_coroutine=True)

        # HACK: nasty hack to gain access to the command line interface wrapper
        self.cli = coroutine.gi_frame.f_locals['cli']

        future = asyncio.ensure_future(coroutine)
        future.add_done_callback(self.on_closed)
        return future