def main(argv): global ROOT parser = argparse.ArgumentParser( description='An automatic programming contest judge.') parser.add_argument('contest', help='the contest directory') parser.add_argument('-d', "--directory", default=None, help="The root directory") opts = parser.parse_args(argv) sh_parser = Parser(lexer_table='lexer_table', yacc_table='parser_table', outputdir=os.path.join(BASE_DIR, "xonsh", "xonsh")) if opts.directory: ROOT = opts.directory else: ROOT = tempfile.mkdtemp(prefix="epsilon") os.chdir(ROOT) os.environ["USER"] = "******" shell.load_contest(opts.contest) cmd = Shell() cmd.execer.parser = sh_parser setup_shortcuts() setup_aliases() setup_env() cmd.cmdloop()
def main(argv=None): """Main entry point for xonsh cli.""" args = parser.parse_args() shell = Shell() if not args.norc else Shell(ctx={}) from xonsh import imphooks env = builtins.__xonsh_env__ if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) env['XONSH_INTERACTIVE'] = False if args.command is not None: # run a single command and exit shell.default(args.command) elif args.file is not None: # run a script contained in a file if os.path.isfile(args.file): with open(args.file) as f: code = f.read() code = code if code.endswith('\n') else code + '\n' env['ARGS'] = [args.file] + args.args code = shell.execer.compile(code, mode='exec', glbs=shell.ctx) shell.execer.exec(code, mode='exec', glbs=shell.ctx) else: print('xonsh: {0}: No such file or directory.'.format(args.file)) elif not sys.stdin.isatty(): # run a script given on stdin code = sys.stdin.read() code = code if code.endswith('\n') else code + '\n' code = shell.execer.compile(code, mode='exec', glbs=shell.ctx) shell.execer.exec(code, mode='exec', glbs=shell.ctx) else: # otherwise, enter the shell env['XONSH_INTERACTIVE'] = True ignore_sigtstp() shell.cmdloop()
def ctx(): """Create a global Shell instance to use in all the test.""" ctx = {'PATH': []} execer = Execer(xonsh_ctx=ctx) builtins.__xonsh_shell__ = Shell(execer=execer, ctx=ctx) yield del builtins.__xonsh_shell__
def ctx(): """Create a global Shell instance to use in all the test.""" ctx = {"PATH": []} execer = Execer(xonsh_ctx=ctx) builtins.__xonsh__.shell = Shell(execer=execer, ctx=ctx, shell_type="none") yield builtins.__xonsh__.shell = None
def premain(argv=None): """Setup for main xonsh entry point, returns parsed arguments.""" args, other = parser.parse_known_args(argv) if args.file is not None: real_argv = (argv or sys.argv) i = real_argv.index(args.file) args.args = real_argv[i+1:] undo_args(args) if args.help: parser.print_help() exit() if args.version: version = '/'.join(('xonsh', __version__)), print(version) exit() shell_kwargs = {'shell_type': args.shell_type} if args.norc: shell_kwargs['ctx'] = {} if args.config_path: shell_kwargs['ctx']= {'XONSHCONFIG': args.config_path} setattr(sys, 'displayhook', _pprint_displayhook) shell = builtins.__xonsh_shell__ = Shell(**shell_kwargs) from xonsh import imphooks env = builtins.__xonsh_env__ if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) if args.login: env['XONSH_LOGIN'] = True env['XONSH_INTERACTIVE'] = False return args
def test_shell_with_json_history(xession, xonsh_execer, tmpdir_factory): """ Check that shell successfully load JSON history from file. """ tempdir = str(tmpdir_factory.mktemp("history")) history_file = os.path.join(tempdir, "history.json") h = JsonHistory(filename=history_file) h.append({ "inp": "echo Hello world 1\n", "rtn": 0, "ts": [1615887820.7329783, 1615887820.7513437], }) h.append({ "inp": "echo Hello world 2\n", "rtn": 0, "ts": [1615887820.7329783, 1615887820.7513437], }) h.flush() xession.env.update( dict( XONSH_DATA_DIR=tempdir, XONSH_INTERACTIVE=True, XONSH_HISTORY_BACKEND="json", XONSH_HISTORY_FILE=history_file, # XONSH_DEBUG=1 # to show errors )) Shell(xonsh_execer, shell_type="none") assert len([i for i in xession.history.all_items()]) == 2
def start_services(shell_kwargs, args, pre_env=None): """Starts up the essential services in the proper order. This returns the environment instance as a convenience. """ if pre_env is None: pre_env = {} # create execer, which loads builtins ctx = shell_kwargs.get("ctx", {}) debug = to_bool_or_int(os.getenv("XONSH_DEBUG", "0")) events.on_timingprobe.fire(name="pre_execer_init") execer = Execer( filename="<stdin>", debug_level=debug, scriptcache=shell_kwargs.get("scriptcache", True), cacheall=shell_kwargs.get("cacheall", False), ) XSH.load(ctx=ctx, execer=execer) events.on_timingprobe.fire(name="post_execer_init") install_import_hooks(execer) env = XSH.env for k, v in pre_env.items(): env[k] = v _autoload_xontribs(env) _load_rc_files(shell_kwargs, args, env, execer, ctx) # create shell XSH.shell = Shell(execer=execer, **shell_kwargs) ctx["__name__"] = "__main__" return env
def start_services(shell_kwargs, args): """Starts up the essential services in the proper order. This returns the environment instance as a convenience. """ install_import_hooks() # create execer, which loads builtins ctx = shell_kwargs.get('ctx', {}) debug = to_bool_or_int(os.getenv('XONSH_DEBUG', '0')) events.on_timingprobe.fire(name='pre_execer_init') execer = Execer(xonsh_ctx=ctx, debug_level=debug, scriptcache=shell_kwargs.get('scriptcache', True), cacheall=shell_kwargs.get('cacheall', False)) events.on_timingprobe.fire(name='post_execer_init') # load rc files login = shell_kwargs.get('login', True) env = builtins.__xonsh_env__ rc = shell_kwargs.get('rc', None) rc = env.get('XONSHRC') if rc is None else rc if args.mode != XonshMode.interactive and not args.force_interactive: # Don't load xonshrc if not interactive shell rc = None events.on_pre_rc.fire() xonshrc_context(rcfiles=rc, execer=execer, ctx=ctx, env=env, login=login) events.on_post_rc.fire() # create shell builtins.__xonsh_shell__ = Shell(execer=execer, **shell_kwargs) ctx['__name__'] = '__main__' return env
def setup(ctx=None, shell_type='none', env=(('RAISE_SUBPROC_ERROR', True), )): """Starts up a new xonsh shell. Calling this in function in another packages __init__.py will allow xonsh to be fully used in the package in headless or headed mode. This function is primarily indended to make starting up xonsh for 3rd party packages easier. Parameters ---------- ctx : dict-like or None, optional The xonsh context to start with. If None, an empty dictionary is provided. shell_type : str, optional The type of shell to start. By default this is 'none', indicating we should start in headless mode. env : dict-like, optional Environment to update the current environment with after the shell has been initialized. """ ctx = {} if ctx is None else ctx # setup xonsh ctx and execer builtins.__xonsh_ctx__ = ctx builtins.__xonsh_execer__ = Execer(xonsh_ctx=ctx) builtins.__xonsh_shell__ = Shell(builtins.__xonsh_execer__, ctx=ctx, shell_type='none') builtins.__xonsh_env__.update(env) install_import_hooks()
def start_services(shell_kwargs, args): """Starts up the essential services in the proper order. This returns the environment instance as a convenience. """ install_import_hooks() # create execer, which loads builtins ctx = shell_kwargs.get("ctx", {}) debug = to_bool_or_int(os.getenv("XONSH_DEBUG", "0")) events.on_timingprobe.fire(name="pre_execer_init") execer = Execer( xonsh_ctx=ctx, debug_level=debug, scriptcache=shell_kwargs.get("scriptcache", True), cacheall=shell_kwargs.get("cacheall", False), ) events.on_timingprobe.fire(name="post_execer_init") # load rc files login = shell_kwargs.get("login", True) env = builtins.__xonsh__.env rc = shell_kwargs.get("rc", None) rc = env.get("XONSHRC") if rc is None else rc if args.mode != XonshMode.interactive and not args.force_interactive: # Don't load xonshrc if not interactive shell rc = None events.on_pre_rc.fire() xonshrc_context(rcfiles=rc, execer=execer, ctx=ctx, env=env, login=login) events.on_post_rc.fire() # create shell builtins.__xonsh__.shell = Shell(execer=execer, **shell_kwargs) ctx["__name__"] = "__main__" return env
def test_shell_with_dummy_history_in_not_interactive(xession, xonsh_execer): """ Check that shell use Dummy history in not interactive mode. """ xession.env["XONSH_INTERACTIVE"] = False xession.history = None Shell(xonsh_execer, shell_type="none") assert isinstance(xession.history, DummyHistory)
def test_shell_with_dummy_history_in_not_interactive(xonsh_builtins, xonsh_execer): """ Check that shell use Dummy history in not interactive mode. """ xonsh_builtins.__xonsh__.env = Env(XONSH_INTERACTIVE=False) xonsh_builtins.__xonsh__.history = None Shell(xonsh_execer, shell_type='none') assert isinstance(xonsh_builtins.__xonsh__.history, DummyHistory)
def start_services(shell_kwargs, args, pre_env=None): """Starts up the essential services in the proper order. This returns the environment instance as a convenience. """ if pre_env is None: pre_env = {} # create execer, which loads builtins ctx = shell_kwargs.get("ctx", {}) debug = to_bool_or_int(os.getenv("XONSH_DEBUG", "0")) events.on_timingprobe.fire(name="pre_execer_init") execer = Execer( debug_level=debug, scriptcache=shell_kwargs.get("scriptcache", True), cacheall=shell_kwargs.get("cacheall", False), ) XSH.load(ctx=ctx, execer=execer) events.on_timingprobe.fire(name="post_execer_init") install_import_hooks(execer) # load rc files login = shell_kwargs.get("login", True) rc_cli = shell_kwargs.get("rc") env = XSH.env for k, v in pre_env.items(): env[k] = v # determine which RC files to load, including whether any RC directories # should be scanned for such files if shell_kwargs.get("norc") or (args.mode != XonshMode.interactive and not args.force_interactive and not args.login): # if --no-rc was passed, or we're not in an interactive shell and # interactive mode was not forced, then disable loading RC files and dirs rc = () rcd = () elif rc_cli: # if an explicit --rc was passed, then we should load only that RC # file, and nothing else (ignore both XONSHRC and XONSHRC_DIR) rc = [r for r in rc_cli if os.path.isfile(r)] rcd = [r for r in rc_cli if os.path.isdir(r)] else: # otherwise, get the RC files from XONSHRC, and RC dirs from XONSHRC_DIR rc = env.get("XONSHRC") rcd = env.get("XONSHRC_DIR") events.on_pre_rc.fire() XSH.rc_files = xonshrc_context(rcfiles=rc, rcdirs=rcd, execer=execer, ctx=ctx, env=env, login=login) events.on_post_rc.fire() # create shell XSH.shell = Shell(execer=execer, **shell_kwargs) ctx["__name__"] = "__main__" return env
def premain(argv=None): """Setup for main xonsh entry point, returns parsed arguments.""" if setproctitle is not None: setproctitle(' '.join(['xonsh'] + sys.argv[1:])) builtins.__xonsh_ctx__ = {} args, other = parser.parse_known_args(argv) if args.file is not None: real_argv = (argv or sys.argv) i = real_argv.index(args.file) args.args = real_argv[i + 1:] undo_args(args) if args.help: parser.print_help() exit() if args.version: version = '/'.join(('xonsh', __version__)), print(version) exit() shell_kwargs = { 'shell_type': args.shell_type, 'completer': False, 'login': False, 'scriptcache': args.scriptcache, 'cacheall': args.cacheall, 'ctx': builtins.__xonsh_ctx__ } if args.login: shell_kwargs['login'] = True if args.config_path is None: shell_kwargs['config'] = args.config_path if args.norc: shell_kwargs['rc'] = () setattr(sys, 'displayhook', _pprint_displayhook) if args.command is not None: args.mode = XonshMode.single_command shell_kwargs['shell_type'] = 'none' elif args.file is not None: args.mode = XonshMode.script_from_file shell_kwargs['shell_type'] = 'none' elif not sys.stdin.isatty() and not args.force_interactive: args.mode = XonshMode.script_from_stdin shell_kwargs['shell_type'] = 'none' else: args.mode = XonshMode.interactive shell_kwargs['completer'] = True shell_kwargs['login'] = True from xonsh import imphooks shell = builtins.__xonsh_shell__ = Shell(**shell_kwargs) env = builtins.__xonsh_env__ env['XONSH_LOGIN'] = shell_kwargs['login'] if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) env['XONSH_INTERACTIVE'] = False if ON_WINDOWS: setup_win_unicode_console(env.get('WIN_UNICODE_CONSOLE', True)) return args
def test_prompt_toolkit_version_checks( ptk_ver, ini_shell_type, exp_shell_type, warn_snip, using_vended_ptk, monkeypatch, xonsh_builtins, ): mocked_warn = "" def mock_warning(msg): nonlocal mocked_warn mocked_warn = msg return def mock_ptk_above_min_supported(): nonlocal ptk_ver return ptk_ver and (ptk_ver[:3] >= minimum_required_ptk_version) def mock_has_prompt_toolkit(): nonlocal ptk_ver return ptk_ver is not None monkeypatch.setattr( "xonsh.shell.warnings.warn", mock_warning ) # hardwon: patch the caller! monkeypatch.setattr( "xonsh.shell.ptk_above_min_supported", mock_ptk_above_min_supported ) # have to patch both callers monkeypatch.setattr( "xonsh.platform.ptk_above_min_supported", mock_ptk_above_min_supported ) monkeypatch.setattr("xonsh.platform.has_prompt_toolkit", mock_has_prompt_toolkit) old_syspath = sys.path.copy() act_shell_type = Shell.choose_shell_type(ini_shell_type, {}) if using_vended_ptk: # ensure PTK has been unloaded and the vended version added to sys.path assert len(old_syspath) < len(sys.path) else: assert len(old_syspath) == len(sys.path) sys.path = old_syspath assert act_shell_type == exp_shell_type if warn_snip: assert warn_snip in mocked_warn pass
def setup( ctx=None, shell_type="none", env=(("RAISE_SUBPROC_ERROR", True), ), aliases=(), xontribs=(), threadable_predictors=(), ): """Starts up a new xonsh shell. Calling this in function in another packages ``__init__.py`` will allow xonsh to be fully used in the package in headless or headed mode. This function is primarily indended to make starting up xonsh for 3rd party packages easier. Here is example of using this at the top of an ``__init__.py``:: from xonsh.main import setup setup() del setup Parameters ---------- ctx : dict-like or None, optional The xonsh context to start with. If None, an empty dictionary is provided. shell_type : str, optional The type of shell to start. By default this is 'none', indicating we should start in headless mode. env : dict-like, optional Environment to update the current environment with after the shell has been initialized. aliases : dict-like, optional Aliases to add after the shell has been initialized. xontribs : iterable of str, optional Xontrib names to load. threadable_predictors : dict-like, optional Threadable predictors to start up with. These overide the defaults. """ ctx = {} if ctx is None else ctx # setup xonsh ctx and execer if not hasattr(builtins, "__xonsh__"): execer = Execer(xonsh_ctx=ctx) builtins.__xonsh__ = XonshSession(ctx=ctx, execer=execer) load_builtins(ctx=ctx, execer=execer) builtins.__xonsh__.shell = Shell(execer, ctx=ctx, shell_type=shell_type) builtins.__xonsh__.env.update(env) install_import_hooks() builtins.aliases.update(aliases) if xontribs: xontribs_load(xontribs) tp = builtins.__xonsh__.commands_cache.threadable_predictors tp.update(threadable_predictors)
def main(argv=None): """Main entry point for xonsh cli.""" args = parser.parse_args() shell_kwargs = {"shell_type": args.shell_type} if args.norc: shell_kwargs["ctx"] = {} setattr(sys, "displayhook", _pprint_displayhook) shell = Shell(**shell_kwargs) from xonsh import imphooks env = builtins.__xonsh_env__ if args.defines is not None: env.update([x.split("=", 1) for x in args.defines]) env["XONSH_INTERACTIVE"] = False if args.command is not None: # run a single command and exit shell.default(args.command) elif args.file is not None: # run a script contained in a file if os.path.isfile(args.file): with open(args.file) as f: code = f.read() code = code if code.endswith("\n") else code + "\n" env["ARGS"] = [args.file] + args.args code = shell.execer.compile(code, mode="exec", glbs=shell.ctx) shell.execer.exec(code, mode="exec", glbs=shell.ctx) else: print("xonsh: {0}: No such file or directory.".format(args.file)) elif not sys.stdin.isatty(): # run a script given on stdin code = sys.stdin.read() code = code if code.endswith("\n") else code + "\n" code = shell.execer.compile(code, mode="exec", glbs=shell.ctx) shell.execer.exec(code, mode="exec", glbs=shell.ctx) else: # otherwise, enter the shell env["XONSH_INTERACTIVE"] = True ignore_sigtstp() shell.cmdloop()
def premain(argv=None): """Setup for main xonsh entry point, returns parsed arguments.""" args = parser.parse_args(argv) shell_kwargs = {'shell_type': args.shell_type} if args.norc: shell_kwargs['ctx'] = {} setattr(sys, 'displayhook', _pprint_displayhook) shell = builtins.__xonsh_shell__ = Shell(**shell_kwargs) from xonsh import imphooks env = builtins.__xonsh_env__ if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) env['XONSH_INTERACTIVE'] = False return args
def main(argv=None): """Main entry point for xonsh cli.""" args = parser.parse_args() shell_kwargs = {'shell_type': args.shell_type} if args.norc: shell_kwargs['ctx'] = {} setattr(sys, 'displayhook', _pprint_displayhook) shell = builtins.__xonsh_shell__ = Shell(**shell_kwargs) from xonsh import imphooks env = builtins.__xonsh_env__ if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) env['XONSH_INTERACTIVE'] = False click.echo('Version: ' + gitsome_version) if args.command is not None: # run a single command and exit shell.default(args.command) elif args.file is not None: # run a script contained in a file if os.path.isfile(args.file): with open(args.file) as f: code = f.read() code = code if code.endswith('\n') else code + '\n' env['ARGS'] = [args.file] + args.args code = shell.execer.compile(code, mode='exec', glbs=shell.ctx) shell.execer.exec(code, mode='exec', glbs=shell.ctx) else: print('xonsh: {0}: No such file or directory.'.format(args.file)) elif not sys.stdin.isatty(): # run a script given on stdin code = sys.stdin.read() code = code if code.endswith('\n') else code + '\n' code = shell.execer.compile(code, mode='exec', glbs=shell.ctx) shell.execer.exec(code, mode='exec', glbs=shell.ctx) else: # otherwise, enter the shell env['XONSH_INTERACTIVE'] = True ignore_sigtstp() shell.cmdloop() del builtins.__xonsh_shell__
def setup(ctx=None, shell_type='none', env=(('RAISE_SUBPROC_ERROR', True),), aliases=(), xontribs=(), threadable_predictors=()): """Starts up a new xonsh shell. Calling this in function in another packages __init__.py will allow xonsh to be fully used in the package in headless or headed mode. This function is primarily indended to make starting up xonsh for 3rd party packages easier. Parameters ---------- ctx : dict-like or None, optional The xonsh context to start with. If None, an empty dictionary is provided. shell_type : str, optional The type of shell to start. By default this is 'none', indicating we should start in headless mode. env : dict-like, optional Environment to update the current environment with after the shell has been initialized. aliases : dict-like, optional Aliases to add after the shell has been initialized. xontribs : iterable of str, optional Xontrib names to load. threadable_predictors : dict-like, optional Threadable predictors to start up with. These overide the defaults. """ ctx = {} if ctx is None else ctx # setup xonsh ctx and execer builtins.__xonsh_ctx__ = ctx builtins.__xonsh_execer__ = Execer(xonsh_ctx=ctx) builtins.__xonsh_shell__ = Shell(builtins.__xonsh_execer__, ctx=ctx, shell_type=shell_type) builtins.__xonsh_env__.update(env) install_import_hooks() builtins.aliases.update(aliases) if xontribs: xontribs_load(xontribs) tp = builtins.__xonsh_commands_cache__.threadable_predictors tp.update(threadable_predictors)
def test_prompt_toolkit_version_checks(ptk_ver, ini_shell_type, exp_shell_type, warn_snip, monkeypatch, xonsh_builtins): mocked_warn = "" def mock_warning(msg): nonlocal mocked_warn mocked_warn = msg return def mock_ptk_above_min_supported(): nonlocal ptk_ver return ptk_ver and (ptk_ver[:2] >= minimum_required_ptk_version) def mock_has_prompt_toolkit(): nonlocal ptk_ver return ptk_ver is not None monkeypatch.setattr("xonsh.shell.warnings.warn", mock_warning) # hardwon: patch the caller! monkeypatch.setattr( "xonsh.shell.ptk_above_min_supported", mock_ptk_above_min_supported) # have to patch both callers monkeypatch.setattr("xonsh.platform.ptk_above_min_supported", mock_ptk_above_min_supported) monkeypatch.setattr("xonsh.shell.has_prompt_toolkit", mock_has_prompt_toolkit) monkeypatch.setattr("xonsh.platform.has_prompt_toolkit", mock_has_prompt_toolkit) act_shell_type = Shell.choose_shell_type(ini_shell_type, {}) assert act_shell_type == exp_shell_type if warn_snip: assert warn_snip in mocked_warn pass
def test_shell_with_sqlite_history(xonsh_builtins, xonsh_execer, tmpdir_factory): """ Check that shell successfully load SQLite history from file. """ tempdir = str(tmpdir_factory.mktemp("history")) history_file = os.path.join(tempdir, 'history.db') h = SqliteHistory(filename=history_file) h.append({"inp": "echo Hello world 1\n", "rtn": 0, "ts": [1615887820.7329783, 1615887820.7513437]}) h.append({"inp": "echo Hello world 2\n", "rtn": 0, "ts": [1615887820.7329783, 1615887820.7513437]}) h.flush() xonsh_builtins.__xonsh__.env = Env( XONSH_DATA_DIR=tempdir, XONSH_INTERACTIVE=True, XONSH_HISTORY_BACKEND='sqlite', XONSH_HISTORY_FILE=history_file, # XONSH_DEBUG=1 # to show errors ) Shell(xonsh_execer, shell_type='none') assert len([i for i in xonsh_builtins.__xonsh__.history.all_items()]) == 2
def xonsh(request): sess = builtins.__xonsh__ if sess.shell is None: from xonsh.shell import Shell sess.shell = Shell(sess.execer, ctx=sess.ctx, shell_type="none") return sess
import builtins # setup xonsh ctx and execer builtins.__xonsh_ctx__ = {} from xonsh.execer import Execer builtins.__xonsh_execer__ = Execer(xonsh_ctx=builtins.__xonsh_ctx__) from xonsh.shell import Shell builtins.__xonsh_shell__ = Shell(builtins.__xonsh_execer__, ctx=builtins.__xonsh_ctx__, shell_type='none') builtins.__xonsh_env__['RAISE_SUBPROC_ERROR'] = True # setup import hooks import xonsh.imphooks xonsh.imphooks.install_import_hooks() __version__ = '0.2.5' del xonsh, builtins, Execer, Shell
"""Tests the xonsh replay functionality.""" from __future__ import unicode_literals, print_function import os import builtins from contextlib import contextmanager import nose from nose.tools import assert_equal, assert_true from xonsh.tools import swap from xonsh.shell import Shell from xonsh.replay import Replayer from tools import ON_MAC, skip_if SHELL = Shell() HISTDIR = os.path.join(os.path.dirname(__file__), 'histories') def run_replay(re_file): with swap(builtins, '__xonsh_shell__', SHELL): r = Replayer(re_file) hist = r.replay() return hist def cleanup_replay(hist): fname = hist.filename del hist if os.path.isfile(fname): os.remove(fname)
# -*- coding: utf-8 -*- """Tests the xonsh replay functionality.""" from __future__ import unicode_literals, print_function import os import builtins from contextlib import contextmanager import pytest from xonsh.tools import swap from xonsh.shell import Shell from xonsh.replay import Replayer from tools import skip_if_on_darwin SHELL = Shell({'PATH': []}) HISTDIR = os.path.join(os.path.dirname(__file__), 'histories') def run_replay(re_file): with swap(builtins, '__xonsh_shell__', SHELL): with swap(builtins, '__xonsh_exit__', False): r = Replayer(re_file) hist = r.replay() return hist def cleanup_replay(hist): fname = hist.filename del hist if os.path.isfile(fname):
def premain(argv=None): """Setup for main xonsh entry point, returns parsed arguments.""" if setproctitle is not None: setproctitle(' '.join(['xonsh'] + sys.argv[1:])) builtins.__xonsh_ctx__ = {} args, other = parser.parse_known_args(argv) if args.file is not None: arguments = (argv or sys.argv) file_index = arguments.index(args.file) # A script-file was passed and is to be executed. The argument parser # might have parsed switches intended for the script, so reset the # parsed switches to their default values old_args = args args = parser.parse_known_args('')[0] args.file = old_args.file # Save the arguments that are intended for the script-file. Switches # and positional arguments passed before the path to the script-file are # ignored. args.args = arguments[file_index+1:] if args.help: parser.print_help() exit() if args.version: version = '/'.join(('xonsh', __version__)), print(version) exit() shell_kwargs = {'shell_type': args.shell_type, 'completer': False, 'login': False, 'scriptcache': args.scriptcache, 'cacheall': args.cacheall, 'ctx': builtins.__xonsh_ctx__} if args.login: shell_kwargs['login'] = True if args.config_path is None: shell_kwargs['config'] = args.config_path if args.norc: shell_kwargs['rc'] = () setattr(sys, 'displayhook', _pprint_displayhook) if args.command is not None: args.mode = XonshMode.single_command shell_kwargs['shell_type'] = 'none' elif args.file is not None: args.mode = XonshMode.script_from_file shell_kwargs['shell_type'] = 'none' elif not sys.stdin.isatty() and not args.force_interactive: args.mode = XonshMode.script_from_stdin shell_kwargs['shell_type'] = 'none' else: args.mode = XonshMode.interactive shell_kwargs['completer'] = True shell_kwargs['login'] = True from xonsh import imphooks shell = builtins.__xonsh_shell__ = Shell(**shell_kwargs) env = builtins.__xonsh_env__ env['XONSH_LOGIN'] = shell_kwargs['login'] if args.defines is not None: env.update([x.split('=', 1) for x in args.defines]) env['XONSH_INTERACTIVE'] = False if ON_WINDOWS: setup_win_unicode_console(env.get('WIN_UNICODE_CONSOLE', True)) return args
def ctx(): """Create a global Shell instance to use in all the test.""" builtins.__xonsh_shell__ = Shell({'PATH': []}) yield del builtins.__xonsh_shell__