def default(self, line):
"""Implements code execution."""
line = line if line.endswith('\n') else line + '\n'
code = self.push(line)
if code is None:
return
try:
# Temporarily redirect stdout and stderr to save results in
# history.
with redirect_stdout(self.stdout), redirect_stderr(self.stderr):
self.execer.exec(code, mode='single', glbs=self.ctx) # no locals
self.stdout.seek(0)
self.stderr.seek(0)
sys.stdout.write(self.stdout.read())
sys.stderr.write(self.stderr.read())
cmd = {}
cmd['cmd'] = self.last
self.stdout.seek(0)
cmd['stdout'] = self.stdout.read()
self.stderr.seek(0)
cmd['stderr'] = self.stderr.read()
self.stdout.seek(0)
self.stdout.truncate()
self.stderr.seek(0)
self.stderr.truncate()
builtins.__history__.add(cmd)
except XonshError as e:
print(e.args[0], file=sys.stderr, end='')
except:
traceback.print_exc()
if builtins.__xonsh_exit__:
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, 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 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 _do_execute_direct(self, code):
shell = builtins.__xonsh_shell__
env = builtins.__xonsh_env__
out = io.StringIO()
err = io.StringIO()
enc = env.get('XONSH_ENCODING')
out = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
err = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
try:
with redirect_stdout(out), redirect_stderr(err), \
swap(builtins, '__xonsh_stdout_uncaptured__', out), \
swap(builtins, '__xonsh_stderr_uncaptured__', err), \
env.swap({'XONSH_STORE_STDOUT': False}):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
output, error = '', ''
if out.tell() > 0:
out.seek(0)
output = out.read()
if err.tell() > 0:
err.seek(0)
error = err.read()
out.close()
err.close()
return output, error, interrupted
def _do_execute_direct(self, code):
shell = builtins.__xonsh_shell__
env = builtins.__xonsh_env__
out = io.StringIO()
err = io.StringIO()
enc = env.get('XONSH_ENCODING')
out = SpooledTemporaryFile(max_size=MAX_SIZE,
mode='w+t',
encoding=enc,
newline='\n')
err = SpooledTemporaryFile(max_size=MAX_SIZE,
mode='w+t',
encoding=enc,
newline='\n')
try:
with redirect_stdout(out), redirect_stderr(err), \
swap(builtins, '__xonsh_stdout_uncaptured__', out), \
swap(builtins, '__xonsh_stderr_uncaptured__', err), \
env.swap({'XONSH_STORE_STDOUT': False}):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
output, error = '', ''
if out.tell() > 0:
out.seek(0)
output = out.read()
if err.tell() > 0:
err.seek(0)
error = err.read()
out.close()
err.close()
return output, error, interrupted
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=False):
"""Execute user code."""
if len(code.strip()) == 0:
return {
'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {}
}
shell = builtins.__xonsh_shell__
hist = builtins.__xonsh_history__
out = io.StringIO()
err = io.StringIO()
try:
with redirect_stdout(out), redirect_stderr(err):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
if not silent: # stdout response
if out.tell() > 0:
out.seek(0)
response = {'name': 'stdout', 'text': out.read()}
self.send_response(self.iopub_socket, 'stream', response)
if err.tell() > 0:
err.seek(0)
response = {'name': 'stderr', 'text': err.read()}
self.send_response(self.iopub_socket, 'stream', response)
if len(hist) > 0 and out.tell() == 0 and err.tell() == 0:
response = {'name': 'stdout', 'text': hist.outs[-1]}
self.send_response(self.iopub_socket, 'stream', response)
if interrupted:
return {'status': 'abort', 'execution_count': self.execution_count}
rtn = 0 if len(hist) == 0 else hist.rtns[-1]
if 0 < rtn:
message = {
'status': 'error',
'execution_count': self.execution_count,
'ename': '',
'evalue': str(rtn),
'traceback': []
}
else:
message = {
'status': 'ok',
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {}
}
return message
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=False):
"""Execute user code."""
if len(code.strip()) == 0:
return {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
env = builtins.__xonsh_env__
shell = builtins.__xonsh_shell__
hist = builtins.__xonsh_history__
enc = env.get('XONSH_ENCODING')
out = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
err = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
try:
with redirect_stdout(out), redirect_stderr(err), \
swap(builtins, '__xonsh_stdout_uncaptured__', out), \
swap(builtins, '__xonsh_stderr_uncaptured__', err), \
env.swap({'XONSH_STORE_STDOUT': False}):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
if not silent: # stdout response
if out.tell() > 0:
out.seek(0)
self._respond_in_chunks('stdout', out.read())
if err.tell() > 0:
err.seek(0)
self._respond_in_chunks('stderr', err.read())
if hasattr(builtins, '_') and builtins._ is not None:
# rely on sys.displayhook functionality
self._respond_in_chunks('stdout', pformat(builtins._))
builtins._ = None
if len(hist) > 0 and out.tell() == 0 and err.tell() == 0:
self._respond_in_chunks('stdout', hist.outs[-1])
out.close()
err.close()
if interrupted:
return {'status': 'abort', 'execution_count': self.execution_count}
rtn = 0 if len(hist) == 0 else hist.rtns[-1]
if 0 < rtn:
message = {'status': 'error', 'execution_count': self.execution_count,
'ename': '', 'evalue': str(rtn), 'traceback': []}
else:
message = {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
return message
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=False):
"""Execute user code."""
if len(code.strip()) == 0:
return {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
env = builtins.__xonsh_env__
shell = builtins.__xonsh_shell__
hist = builtins.__xonsh_history__
enc = env.get('XONSH_ENCODING')
out = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
err = SpooledTemporaryFile(max_size=MAX_SIZE, mode='w+t',
encoding=enc, newline='\n')
try:
with redirect_stdout(out), redirect_stderr(err), \
swap(builtins, '__xonsh_stdout_uncaptured__', out), \
swap(builtins, '__xonsh_stderr_uncaptured__', err), \
env.swap({'XONSH_STORE_STDOUT': False}):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
if not silent: # stdout response
if out.tell() > 0:
out.seek(0)
self._respond_in_chunks('stdout', out.read())
if err.tell() > 0:
err.seek(0)
self._respond_in_chunks('stderr', err.read())
if hasattr(builtins, '_') and builtins._ is not None:
# rely on sys.displayhook functionality
self._respond_in_chunks('stdout', pformat(builtins._))
builtins._ = None
if hist is not None and len(hist) > 0 and out.tell() == 0 and err.tell() == 0:
self._respond_in_chunks('stdout', hist.outs[-1])
out.close()
err.close()
if interrupted:
return {'status': 'abort', 'execution_count': self.execution_count}
rtn = 0 if (hist is None or len(hist) == 0) else hist.rtns[-1]
if 0 < rtn:
message = {'status': 'error', 'execution_count': self.execution_count,
'ename': '', 'evalue': str(rtn), 'traceback': []}
else:
message = {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
return message
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False):
"""Execute user code."""
if len(code.strip()) == 0:
return {"status": "ok", "execution_count": self.execution_count, "payload": [], "user_expressions": {}}
env = builtins.__xonsh_env__
shell = builtins.__xonsh_shell__
hist = builtins.__xonsh_history__
enc = env.get("XONSH_ENCODING")
out = SpooledTemporaryFile(max_size=MAX_SIZE, mode="w+t", encoding=enc, newline="\n")
err = SpooledTemporaryFile(max_size=MAX_SIZE, mode="w+t", encoding=enc, newline="\n")
try:
with redirect_stdout(out), redirect_stderr(err), swap(builtins, "__xonsh_stdout_uncaptured__", out), swap(
builtins, "__xonsh_stderr_uncaptured__", err
), env.swap({"XONSH_STORE_STDOUT": False}):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
if not silent: # stdout response
if out.tell() > 0:
out.seek(0)
self._respond_in_chunks("stdout", out.read())
if err.tell() > 0:
err.seek(0)
self._respond_in_chunks("stderr", err.read())
if hasattr(builtins, "_") and builtins._ is not None:
# rely on sys.displayhook functionality
self._respond_in_chunks("stdout", pformat(builtins._))
builtins._ = None
if len(hist) > 0 and out.tell() == 0 and err.tell() == 0:
self._respond_in_chunks("stdout", hist.outs[-1])
out.close()
err.close()
if interrupted:
return {"status": "abort", "execution_count": self.execution_count}
rtn = 0 if len(hist) == 0 else hist.rtns[-1]
if 0 < rtn:
message = {
"status": "error",
"execution_count": self.execution_count,
"ename": "",
"evalue": str(rtn),
"traceback": [],
}
else:
message = {"status": "ok", "execution_count": self.execution_count, "payload": [], "user_expressions": {}}
return message
def _run_callable_subproc(alias,
args,
captured=True,
prev_proc=None,
stdout=None):
"""Helper for running callables as a subprocess."""
# compute stdin for callable
if prev_proc is None:
stdin = None
elif isinstance(prev_proc, ProcProxy):
stdin = prev_proc.stdout
else:
stdin = StringIO(prev_proc.communicate()[0].decode(), None)
stdin.seek(0)
stdin, _ = stdin.read(), stdin.close()
# Redirect the output streams temporarily. merge with possible
# return values from alias function.
if stdout is PIPE:
# handles captured mode
new_stdout, new_stderr = StringIO(), StringIO()
with redirect_stdout(new_stdout), redirect_stderr(new_stderr):
rtn = alias(args, stdin=stdin)
proxy_stdout = new_stdout.getvalue()
proxy_stderr = new_stderr.getvalue()
if isinstance(rtn, str):
proxy_stdout += rtn
elif isinstance(rtn, Sequence):
if rtn[0]: # not None nor ''
proxy_stdout += rtn[0]
if rtn[1]:
proxy_stderr += rtn[1]
return ProcProxy(proxy_stdout, proxy_stderr)
else:
# handles uncaptured mode
rtn = alias(args, stdin=stdin)
rtnout, rtnerr = None, None
if isinstance(rtn, str):
rtnout = rtn
sys.stdout.write(rtn)
elif isinstance(rtn, Sequence):
if rtn[0]:
rtnout = rtn[0]
sys.stdout.write(rtn[0])
if rtn[1]:
rtnerr = rtn[1]
sys.stderr.write(rtn[1])
return ProcProxy(rtnout, rtnerr)
def wrapped_simple_command(args, stdin, stdout, stderr):
try:
i = stdin.read()
with redirect_stdout(stdout), redirect_stderr(stderr):
r = f(args, i)
if isinstance(r, str):
stdout.write(r)
elif isinstance(r, Sequence):
if r[0] is not None:
stdout.write(r[0])
if r[1] is not None:
stderr.write(r[1])
elif r is not None:
stdout.write(str(r))
return True
except:
return False
def wrapped_simple_command(args, stdin, stdout, stderr):
try:
i = stdin.read()
with redirect_stdout(stdout), redirect_stderr(stderr):
r = f(args, i)
if isinstance(r, str):
stdout.write(r)
elif isinstance(r, Sequence):
if r[0] is not None:
stdout.write(r[0])
if r[1] is not None:
stderr.write(r[1])
elif r is not None:
stdout.write(str(r))
return True
except:
return False
def _run_callable_subproc(alias, args,
captured=True,
prev_proc=None,
stdout=None):
"""Helper for running callables as a subprocess."""
# compute stdin for callable
if prev_proc is None:
stdin = None
elif isinstance(prev_proc, ProcProxy):
stdin = prev_proc.stdout
else:
stdin = StringIO(prev_proc.communicate()[0].decode(), None)
stdin.seek(0)
stdin, _ = stdin.read(), stdin.close()
# Redirect the output streams temporarily. merge with possible
# return values from alias function.
if stdout is PIPE:
# handles captured mode
new_stdout, new_stderr = StringIO(), StringIO()
with redirect_stdout(new_stdout), redirect_stderr(new_stderr):
rtn = alias(args, stdin=stdin)
proxy_stdout = new_stdout.getvalue()
proxy_stderr = new_stderr.getvalue()
if isinstance(rtn, str):
proxy_stdout += rtn
elif isinstance(rtn, Sequence):
if rtn[0]: # not None nor ''
proxy_stdout += rtn[0]
if rtn[1]:
proxy_stderr += rtn[1]
return ProcProxy(proxy_stdout, proxy_stderr)
else:
# handles uncaptured mode
rtn = alias(args, stdin=stdin)
rtnout, rtnerr = None, None
if isinstance(rtn, str):
rtnout = rtn
sys.stdout.write(rtn)
elif isinstance(rtn, Sequence):
if rtn[0]:
rtnout = rtn[0]
sys.stdout.write(rtn[0])
if rtn[1]:
rtnerr = rtn[1]
sys.stderr.write(rtn[1])
return ProcProxy(rtnout, rtnerr)
def wrapped_simple_command(args, stdin, stdout, stderr):
try:
i = stdin.read()
with redirect_stdout(stdout), redirect_stderr(stderr):
r = f(args, i)
if isinstance(r, str):
stdout.write(r)
elif isinstance(r, Sequence):
if r[0] is not None:
stdout.write(r[0])
if r[1] is not None:
stderr.write(r[1])
elif r is not None:
stdout.write(str(r))
return 0 # returncode for succees
except Exception:
print_exception()
return 1 # returncode for failure
def wrapped_simple_command(args, stdin, stdout, stderr):
try:
i = stdin.read()
with redirect_stdout(stdout), redirect_stderr(stderr):
r = f(args, i)
if isinstance(r, str):
stdout.write(r)
elif isinstance(r, Sequence):
if r[0] is not None:
stdout.write(r[0])
if r[1] is not None:
stderr.write(r[1])
elif r is not None:
stdout.write(str(r))
return 0 # returncode for succees
except Exception:
print_exception()
return 1 # returncode for failure
def do_execute(self, code, silent, store_history=True, user_expressions=None,
allow_stdin=False):
"""Execute user code."""
if len(code.strip()) == 0:
return {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
shell = builtins.__xonsh_shell__
hist = builtins.__xonsh_history__
out = io.StringIO()
err = io.StringIO()
try:
with redirect_stdout(out), redirect_stderr(err):
shell.default(code)
interrupted = False
except KeyboardInterrupt:
interrupted = True
if not silent: # stdout response
if out.tell() > 0:
out.seek(0)
response = {'name': 'stdout', 'text': out.read()}
self.send_response(self.iopub_socket, 'stream', response)
if err.tell() > 0:
err.seek(0)
response = {'name': 'stderr', 'text': err.read()}
self.send_response(self.iopub_socket, 'stream', response)
if len(hist) > 0 and out.tell() == 0 and err.tell() == 0:
response = {'name': 'stdout', 'text': hist.outs[-1]}
self.send_response(self.iopub_socket, 'stream', response)
if interrupted:
return {'status': 'abort', 'execution_count': self.execution_count}
rtn = 0 if len(hist) == 0 else hist.rtns[-1]
if 0 < rtn:
message = {'status': 'error', 'execution_count': self.execution_count,
'ename': '', 'evalue': str(rtn), 'traceback': []}
else:
message = {'status': 'ok', 'execution_count': self.execution_count,
'payload': [], 'user_expressions': {}}
return message
def run(self):
arguments = self.arguments
lines = ['.. code-block:: none', '']
m, f = arguments[0].rsplit('.', 1)
mod = importlib.import_module(m)
func = getattr(mod, f)
args = ['--help'] if len(arguments) == 1 else arguments[1:]
stdout = io.StringIO()
stderr = io.StringIO()
with redirect_stdout(stdout), redirect_stderr(stderr):
try:
func(args)
except SystemExit:
pass
stdout.seek(0)
s = stdout.read()
lines += textwrap.indent(s, ' ').splitlines()
# hook to docutils
src, lineno = self.state_machine.get_source_and_line(self.lineno)
vl = ViewList(lines, source=src)
node = nodes.paragraph()
nested_parse_with_titles(self.state, vl, node)
return node.children
def run(self):
arguments = self.arguments
lines = ['.. code-block:: none', '']
m, f = arguments[0].rsplit('.', 1)
mod = importlib.import_module(m)
func = getattr(mod, f)
args = ['--help'] if len(arguments) == 1 else arguments[1:]
stdout = io.StringIO()
stderr = io.StringIO()
with redirect_stdout(stdout), redirect_stderr(stderr):
try:
func(args)
except SystemExit:
pass
stdout.seek(0)
s = stdout.read()
lines += textwrap.indent(s, ' ').splitlines()
# hook to docutils
src, lineno = self.state_machine.get_source_and_line(self.lineno)
vl = ViewList(lines, source=src)
node = nodes.paragraph()
nested_parse_with_titles(self.state, vl, node)
return node.children
def run(self):
"""Set up input/output streams and execute the child function in a new
thread. This is part of the `threading.Thread` interface and should
not be called directly.
"""
if self.f is None:
return
spec = self._wait_and_getattr("spec")
last_in_pipeline = spec.last_in_pipeline
if last_in_pipeline:
capout = spec.captured_stdout # NOQA
caperr = spec.captured_stderr # NOQA
env = builtins.__xonsh__.env
enc = env.get("XONSH_ENCODING")
err = env.get("XONSH_ENCODING_ERRORS")
if xp.ON_WINDOWS:
if self.p2cread != -1:
self.p2cread = xli.msvcrt.open_osfhandle(
self.p2cread.Detach(), 0)
if self.c2pwrite != -1:
self.c2pwrite = xli.msvcrt.open_osfhandle(
self.c2pwrite.Detach(), 0)
if self.errwrite != -1:
self.errwrite = xli.msvcrt.open_osfhandle(
self.errwrite.Detach(), 0)
# get stdin
if self.stdin is None:
sp_stdin = None
elif self.p2cread != -1:
sp_stdin = io.TextIOWrapper(io.open(self.p2cread, "rb", -1),
encoding=enc,
errors=err)
else:
sp_stdin = sys.stdin
# stdout
if self.c2pwrite != -1:
sp_stdout = io.TextIOWrapper(io.open(self.c2pwrite, "wb", -1),
encoding=enc,
errors=err)
else:
sp_stdout = sys.stdout
# stderr
if self.errwrite == self.c2pwrite:
sp_stderr = sp_stdout
elif self.errwrite != -1:
sp_stderr = io.TextIOWrapper(io.open(self.errwrite, "wb", -1),
encoding=enc,
errors=err)
else:
sp_stderr = sys.stderr
# run the function itself
try:
alias_stack = builtins.__xonsh__.env.get("__ALIAS_STACK", "")
if self.env.get("__ALIAS_NAME"):
alias_stack += ":" + self.env["__ALIAS_NAME"]
with STDOUT_DISPATCHER.register(
sp_stdout
), STDERR_DISPATCHER.register(sp_stderr), xt.redirect_stdout(
STDOUT_DISPATCHER), xt.redirect_stderr(
STDERR_DISPATCHER), builtins.__xonsh__.env.swap(
__ALIAS_STACK=alias_stack):
r = self.f(self.args, sp_stdin, sp_stdout, sp_stderr, spec,
spec.stack)
except SystemExit as e:
r = e.code if isinstance(e.code, int) else int(bool(e.code))
except OSError:
status = still_writable(self.c2pwrite) and still_writable(
self.errwrite)
if status:
# stdout and stderr are still writable, so error must
# come from function itself.
xt.print_exception()
r = 1
else:
# stdout and stderr are no longer writable, so error must
# come from the fact that the next process in the pipeline
# has closed the other side of the pipe. The function then
# attempted to write to this side of the pipe anyway. This
# is not truly an error and we should exit gracefully.
r = 0
except Exception:
xt.print_exception()
r = 1
safe_flush(sp_stdout)
safe_flush(sp_stderr)
self.returncode = parse_proxy_return(r, sp_stdout, sp_stderr)
if not last_in_pipeline and not xp.ON_WINDOWS:
# mac requires us *not to* close the handles here while
# windows requires us *to* close the handles here
return
# clean up
# scopz: not sure why this is needed, but stdin cannot go here
# and stdout & stderr must.
handles = [self.stdout, self.stderr]
for handle in handles:
safe_fdclose(handle, cache=self._closed_handle_cache)