def _wizard(ns):
    env = builtins.__xonsh__.env
    shell = builtins.__xonsh__.shell.shell
    fname = env.get("XONSHRC")[-1] if ns.file is None else ns.file
    no_wiz = os.path.join(env.get("XONSH_CONFIG_DIR"), "no-wizard")
    w = make_xonfig_wizard(
        default_file=fname, confirm=ns.confirm, no_wizard_file=no_wiz
    )
    tempenv = {"PROMPT": "", "XONSH_STORE_STDOUT": False}
    pv = wiz.PromptVisitor(w, store_in_history=False, multiline=False)

    @contextlib.contextmanager
    def force_hide():
        if env.get("XONSH_STORE_STDOUT") and hasattr(shell, "_force_hide"):
            orig, shell._force_hide = shell._force_hide, False
            yield
            shell._force_hide = orig
        else:
            yield

    with force_hide(), env.swap(tempenv):
        try:
            pv.visit()
        except (KeyboardInterrupt, Exception):
            print()
            print_exception()

 def default(self, line):
     """Implements code execution."""
     line = line if line.endswith('\n') else line + '\n'
     src, code = self.push(line)
     if code is None:
         return
     env = builtins.__xonsh_env__
     hist = builtins.__xonsh_history__  # pylint: disable=no-member
     ts1 = None
     enc = env.get('XONSH_ENCODING')
     err = env.get('XONSH_ENCODING_ERRORS')
     tee = Tee(encoding=enc, errors=err)
     try:
         ts0 = time.time()
         run_compiled_code(code, self.ctx, None, 'single')
         ts1 = time.time()
         if hist is not None and hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 0  # returncode for success
     except XonshError as e:
         print(e.args[0], file=sys.stderr)
         if hist is not None and hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     except Exception:  # pylint: disable=broad-except
         print_exception()
         if hist is not None and hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     finally:
         ts1 = ts1 or time.time()
         self._append_history(inp=src, ts=[ts0, ts1], tee_out=tee.getvalue())
         tee.close()
         self._fix_cwd()
     if builtins.__xonsh_exit__:  # pylint: disable=no-member
         return True

 def push(self, line):
     """Pushes a line onto the buffer and compiles the code in a way that
     enables multiline input.
     """
     code = None
     self.buffer.append(line)
     if self.need_more_lines:
         return None, code
     src = ''.join(self.buffer)
     try:
         code = self.execer.compile(src,
                                    mode='single',
                                    glbs=None,
                                    locs=self.ctx)
         self.reset_buffer()
     except SyntaxError:
         if line == '\n':
             self.reset_buffer()
             print_exception()
             return src, None
         self.need_more_lines = True
     except Exception:  # pylint: disable=broad-except
         self.reset_buffer()
         print_exception()
         return src, None
     return src, code

 def compile(self, src):
     """Compiles source code and returns the (possibly modified) source and
     a valid code object.
     """
     _cache = should_use_cache(self.execer, 'single')
     if _cache:
         codefname = code_cache_name(src)
         cachefname = get_cache_filename(codefname, code=True)
         usecache, code = code_cache_check(cachefname)
         if usecache:
             self.reset_buffer()
             return src, code
     try:
         code = self.execer.compile(src,
                                    mode='single',
                                    glbs=self.ctx,
                                    locs=None)
         if _cache:
             update_cache(code, cachefname)
         self.reset_buffer()
     except SyntaxError:
         partial_string_info = check_for_partial_string(src)
         in_partial_string = (partial_string_info[0] is not None and
                              partial_string_info[1] is None)
         if (src == '\n' or src.endswith('\n\n')) and not in_partial_string:
             self.reset_buffer()
             print_exception()
             return src, None
         self.need_more_lines = True
         code = None
     except Exception:  # pylint: disable=broad-except
         self.reset_buffer()
         print_exception()
         code = None
     return src, code

def transform_command(src, show_diff=True):
    """Returns the results of firing the precommand handles."""
    i = 0
    limit = sys.getrecursionlimit()
    lst = ""
    raw = src
    while src != lst:
        lst = src
        srcs = events.on_transform_command.fire(cmd=src)
        for s in srcs:
            if s != lst:
                src = s
                break
        i += 1
        if i == limit:
            print_exception(
                "Modifications to source input took more than "
                "the recursion limit number of iterations to "
                "converge."
            )
    debug_level = builtins.__xonsh__.env.get("XONSH_DEBUG")
    if show_diff and debug_level > 1 and src != raw:
        sys.stderr.writelines(
            difflib.unified_diff(
                raw.splitlines(keepends=True),
                src.splitlines(keepends=True),
                fromfile="before precommand event",
                tofile="after precommand event",
            )
        )
    return src

def fire_precommand(src, show_diff=True):
    """Returns the results of firing the precommand handles."""
    i = 0
    limit = sys.getrecursionlimit()
    lst = ''
    raw = src
    while src != lst:
        lst = src
        srcs = events.on_precommand.fire(src)
        for s in srcs:
            if s != lst:
                src = s
                break
        i += 1
        if i == limit:
            print_exception('Modifcations to source input took more than '
                            'the recursion limit number of interations to '
                            'converge.')
    debug_level = builtins.__xonsh_env__.get('XONSH_DEBUG')
    if show_diff and debug_level > 1 and src != raw:
        sys.stderr.writelines(difflib.unified_diff(
            raw.splitlines(keepends=True),
            src.splitlines(keepends=True),
            fromfile='before precommand event',
            tofile='after precommand event',
        ))
    return src

 def default(self, line):
     """Implements code execution."""
     line = line if line.endswith('\n') else line + '\n'
     src, code = self.push(line)
     if code is None:
         return
     hist = builtins.__xonsh_history__  # pylint: disable=no-member
     ts1 = None
     store_stdout = builtins.__xonsh_env__.get('XONSH_STORE_STDOUT')  # pylint: disable=no-member
     tee = Tee() if store_stdout else io.StringIO()
     try:
         ts0 = time.time()
         run_compiled_code(code, self.ctx, None, 'single')
         ts1 = time.time()
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 0  # returncode for success
     except XonshError as e:
         print(e.args[0], file=sys.stderr)
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     except Exception:  # pylint: disable=broad-except
         print_exception()
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     finally:
         ts1 = ts1 or time.time()
         self._append_history(inp=src, ts=[ts0, ts1], tee_out=tee.getvalue())
         tee.close()
     if builtins.__xonsh_exit__:  # pylint: disable=no-member
         return True

    def wrapped_simple_command(args, stdin, stdout, stderr):
        try:
            i = stdin.read()
            if bgable:
                with redirect_stdout(stdout), redirect_stderr(stderr):
                    r = f(args, i)
            else:
                r = f(args, i)

            cmd_result = 0
            if isinstance(r, str):
                stdout.write(r)
            elif isinstance(r, abc.Sequence):
                if r[0] is not None:
                    stdout.write(r[0])
                if r[1] is not None:
                    stderr.write(r[1])
                if len(r) > 2 and r[2] is not None:
                    cmd_result = r[2]
            elif r is not None:
                stdout.write(str(r))
            return cmd_result
        except Exception:
            print_exception()
            return 1  # returncode for failure

 def default(self, line):
     """Implements code execution."""
     line = line if line.endswith('\n') else line + '\n'
     src, code = self.push(line)
     if code is None:
         return
     hist = builtins.__xonsh_history__
     ts1 = None
     tee = Tee() if builtins.__xonsh_env__.get('XONSH_STORE_STDOUT') \
                 else io.StringIO()
     try:
         ts0 = time.time()
         self.execer.exec(code, mode='single', glbs=self.ctx)  # no locals
         ts1 = time.time()
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 0  # returncode for success
     except XonshError as e:
         print(e.args[0], file=sys.stderr)
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     except Exception:
         print_exception()
         if hist.last_cmd_rtn is None:
             hist.last_cmd_rtn = 1  # return code for failure
     finally:
         ts1 = ts1 or time.time()
         self._append_history(inp=src, ts=[ts0, ts1], tee_out=tee.getvalue())
         tee.close()
     if builtins.__xonsh_exit__:
         return True

 def prompt(self):
     """Obtains the current prompt string."""
     global RL_LIB, RL_CAN_RESIZE
     if RL_CAN_RESIZE:
         # This is needed to support some system where line-wrapping doesn't
         # work. This is a bug in upstream Python, or possibly readline.
         RL_LIB.rl_reset_screen_size()
     if self.need_more_lines:
         if self.mlprompt is None:
             try:
                 self.mlprompt = multiline_prompt(curr=self._current_prompt)
             except Exception:  # pylint: disable=broad-except
                 print_exception()
                 self.mlprompt = '<multiline prompt error> '
         return self.mlprompt
     env = builtins.__xonsh_env__  # pylint: disable=no-member
     p = env.get('PROMPT')
     try:
         p = partial_format_prompt(p)
     except Exception:  # pylint: disable=broad-except
         print_exception()
     hide = True if self._force_hide is None else self._force_hide
     p = ansi_partial_color_format(p, style=env.get('XONSH_COLOR_STYLE'),
                                   hide=hide)
     self._current_prompt = p
     self.settitle()
     return p

 def push(self, line):
     """Pushes a line onto the buffer and compiles the code in a way that
     enables multiline input.
     """
     code = None
     self.buffer.append(line)
     if self.need_more_lines:
         return None, code
     src = "".join(self.buffer)
     _cache = should_use_cache(self.execer, "single")
     if _cache:
         codefname = code_cache_name(src)
         cachefname = get_cache_filename(codefname, code=True)
         usecache, code = code_cache_check(cachefname)
         if usecache:
             self.reset_buffer()
             return src, code
     try:
         code = self.execer.compile(src, mode="single", glbs=self.ctx, locs=None)
         if _cache:
             update_cache(code, cachefname)
         self.reset_buffer()
     except SyntaxError:
         if line == "\n":
             self.reset_buffer()
             print_exception()
             return src, None
         self.need_more_lines = True
     except Exception:  # pylint: disable=broad-except
         self.reset_buffer()
         print_exception()
         return src, None
     return src, code

    def fire(self, **kwargs):
        """
        Fires an event, calling registered handlers with the given arguments. A non-unique iterable
        of the results is returned.

        Each handler is called immediately. Exceptions are turned in to warnings.

        Parameters
        ----------
        **kwargs :
            Keyword arguments to pass to each handler

        Returns
        -------
        vals : iterable
            Return values of each handler. If multiple handlers return the same value, it will
            appear multiple times.
        """
        vals = []
        for handler in self._filterhandlers(self._handlers, **kwargs):
            try:
                rv = handler(**kwargs)
            except Exception:
                print_exception("Exception raised in event handler; ignored.")
            else:
                vals.append(rv)
        return vals

def _failover_template_format(template):
    if callable(template):
        try:
            # Exceptions raises from function of producing $PROMPT
            # in user's xonshrc should not crash xonsh
            return template()
        except Exception:
            xt.print_exception()
            return "$ "
    return template

 def prompt_tokens(self, cli):
     """Returns a list of (token, str) tuples for the current prompt."""
     p = builtins.__xonsh_env__.get('PROMPT')
     try:
         p = partial_format_prompt(p)
     except Exception:  # pylint: disable=broad-except
         print_exception()
     toks = partial_color_tokenize(p)
     self.settitle()
     return toks

def _wizard(ns):
    env = builtins.__xonsh_env__
    fname = env.get('XONSHCONFIG') if ns.file is None else ns.file
    wiz = make_wizard(default_file=fname, confirm=ns.confirm)
    tempenv = {'PROMPT': '', 'XONSH_STORE_STDOUT': False}
    pv = PromptVisitor(wiz, store_in_history=False, multiline=False)
    with env.swap(tempenv):
        try:
            pv.visit()
        except (KeyboardInterrupt, Exception):
            tools.print_exception()

 def _get_field_value(self, field):
     field_value = self.fields[field]
     if field_value in self.cache:
         return self.cache[field_value]
     try:
         value = field_value() if callable(field_value) else field_value
         self.cache[field_value] = value
     except Exception:
         print("prompt: error: on field {!r}" "".format(field), file=sys.stderr)
         xt.print_exception()
         value = "(ERROR:{})".format(field)
     return value

 def rprompt_tokens(self, cli):
     """Returns a list of (token, str) tuples for the current right
     prompt.
     """
     p = builtins.__xonsh_env__.get('RIGHT_PROMPT')
     if len(p) == 0:
         return []
     try:
         p = partial_format_prompt(p)
     except Exception:  # pylint: disable=broad-except
         print_exception()
     toks = partial_color_tokenize(p)
     return toks

 def bottom_toolbar_tokens(self):
     """Returns a list of (token, str) tuples for the current bottom
     toolbar.
     """
     p = builtins.__xonsh__.env.get("BOTTOM_TOOLBAR")
     if not p:
         return
     try:
         p = self.prompt_formatter(p)
     except Exception:  # pylint: disable=broad-except
         print_exception()
     toks = partial_color_tokenize(p)
     return PygmentsTokens(toks)

 def prompt_tokens(self):
     """Returns a list of (token, str) tuples for the current prompt."""
     p = builtins.__xonsh__.env.get("PROMPT")
     try:
         p = self.prompt_formatter(p)
     except Exception:  # pylint: disable=broad-except
         print_exception()
     toks = partial_color_tokenize(p)
     if self._first_prompt:
         carriage_return()
         self._first_prompt = False
     self.settitle()
     return PygmentsTokens(toks)

 def wrapper(*args, **kwargs):
     rootdir = os.path.splitdrive(os.getcwd())[0] + '\\'
     os.chdir(rootdir)
     try:
         out = func(*args, **kwargs)
     finally:
         try:
             pwd = env.get('PWD', rootdir)
             os.chdir(pwd)
         except (FileNotFoundError, NotADirectoryError):
             print_exception()
             newpath = _chdir_up(pwd)
             builtins.__xonsh_env__['PWD'] = newpath
             raise KeyboardInterrupt
     return out