def replay(self, merge_envs=DEFAULT_MERGE_ENVS, target=None):
"""Replays the history specified, returns the history object where the code
was executed.
Parameters
----------
merge_env : tuple of str or Mappings, optional
Describes how to merge the environments, in order of increasing precednce.
Available strings are 'replay' and 'native'. The 'replay' env comes from the
history file that we are replaying. The 'native' env comes from what this
instance of xonsh was started up with. Instead of a string, a dict or other
mapping may be passed in as well. Defaults to ('replay', 'native').
target : str, optional
Path to new history file.
"""
shell = builtins.__xonsh_shell__
re_env = self._lj['env'].load()
new_env = self._merge_envs(merge_envs, re_env)
new_hist = xhm.construct_history(env=new_env.detype(),
locked=True,
ts=[time.time(), None],
gc=False,
filename=target)
with swap(builtins, '__xonsh_env__',
new_env), swap(builtins, '__xonsh_history__', new_hist):
for cmd in self._lj['cmds']:
inp = cmd['inp']
shell.default(inp)
if builtins.__xonsh_exit__: # prevent premature exit
builtins.__xonsh_exit__ = False
new_hist.flush(at_exit=True)
return new_hist
def __init__(self, execer, ctx=None, shell_type=None, **kwargs):
"""
Parameters
----------
execer : Execer
An execer instance capable of running xonsh code.
ctx : Mapping, optional
The execution context for the shell (e.g. the globals namespace).
If none, this is computed by loading the rc files. If not None,
this no additional context is computed and this is used
directly.
shell_type : str, optional
The shell type to start, such as 'readline', 'prompt_toolkit',
or 'random'.
"""
self.execer = execer
self.ctx = {} if ctx is None else ctx
env = builtins.__xonsh_env__
# build history backend before creating shell
builtins.__xonsh_history__ = hist = xhm.construct_history(
env=env.detype(), ts=[time.time(), None], locked=True)
# pick a valid shell -- if no shell is specified by the user,
# shell type is pulled from env
if shell_type is None:
shell_type = env.get('SHELL_TYPE')
if shell_type == 'none':
# This bricks interactive xonsh
# Can happen from the use of .xinitrc, .xsession, etc
shell_type = 'best'
if shell_type == 'best' or shell_type is None:
shell_type = best_shell_type()
elif shell_type == 'random':
shell_type = random.choice(('readline', 'prompt_toolkit'))
if shell_type == 'prompt_toolkit':
if not has_prompt_toolkit():
warnings.warn('prompt_toolkit is not available, using '
'readline instead.')
shell_type = 'readline'
elif not ptk_version_is_supported():
warnings.warn('prompt-toolkit version < v1.0.0 is not '
'supported. Please update prompt-toolkit. Using '
'readline instead.')
shell_type = 'readline'
self.shell_type = env['SHELL_TYPE'] = shell_type
# actually make the shell
if shell_type == 'none':
from xonsh.base_shell import BaseShell as shell_class
elif shell_type == 'prompt_toolkit':
from xonsh.ptk.shell import PromptToolkitShell as shell_class
elif shell_type == 'readline':
from xonsh.readline_shell import ReadlineShell as shell_class
else:
raise XonshError('{} is not recognized as a shell type'.format(
shell_type))
self.shell = shell_class(execer=self.execer,
ctx=self.ctx, **kwargs)
# allows history garbage collector to start running
if hist.gc is not None:
hist.gc.wait_for_shell = False
def replay(self, merge_envs=DEFAULT_MERGE_ENVS, target=None):
"""Replays the history specified, returns the history object where the code
was executed.
Parameters
----------
merge_env : tuple of str or Mappings, optional
Describes how to merge the environments, in order of increasing precednce.
Available strings are 'replay' and 'native'. The 'replay' env comes from the
history file that we are replaying. The 'native' env comes from what this
instance of xonsh was started up with. Instead of a string, a dict or other
mapping may be passed in as well. Defaults to ('replay', 'native').
target : str, optional
Path to new history file.
"""
shell = builtins.__xonsh_shell__
re_env = self._lj['env'].load()
new_env = self._merge_envs(merge_envs, re_env)
new_hist = xhm.construct_history(
env=new_env.detype(), locked=True, ts=[time.time(), None],
gc=False, filename=target)
with swap(builtins, '__xonsh_env__', new_env), swap(builtins, '__xonsh_history__', new_hist):
for cmd in self._lj['cmds']:
inp = cmd['inp']
shell.default(inp)
if builtins.__xonsh_exit__: # prevent premature exit
builtins.__xonsh_exit__ = False
new_hist.flush(at_exit=True)
return new_hist
def __init__(self, execer, ctx=None, shell_type=None, **kwargs):
"""
Parameters
----------
execer : Execer
An execer instance capable of running xonsh code.
ctx : Mapping, optional
The execution context for the shell (e.g. the globals namespace).
If none, this is computed by loading the rc files. If not None,
this no additional context is computed and this is used
directly.
shell_type : str, optional
The shell type to start, such as 'readline', 'prompt_toolkit',
or 'random'.
"""
self.execer = execer
self.ctx = {} if ctx is None else ctx
env = builtins.__xonsh_env__
# build history backend before creating shell
builtins.__xonsh_history__ = hist = xhm.construct_history(
env=env.detype(), ts=[time.time(), None], locked=True)
# pick a valid shell -- if no shell is specified by the user,
# shell type is pulled from env
if shell_type is None:
shell_type = env.get('SHELL_TYPE')
if shell_type == 'none':
# This bricks interactive xonsh
# Can happen from the use of .xinitrc, .xsession, etc
shell_type = 'best'
if shell_type == 'best' or shell_type is None:
shell_type = best_shell_type()
elif shell_type == 'random':
shell_type = random.choice(('readline', 'prompt_toolkit'))
if shell_type == 'prompt_toolkit':
if not has_prompt_toolkit():
warnings.warn('prompt_toolkit is not available, using '
'readline instead.')
shell_type = 'readline'
elif not ptk_version_is_supported():
warnings.warn('prompt-toolkit version < v1.0.0 is not '
'supported. Please update prompt-toolkit. Using '
'readline instead.')
shell_type = 'readline'
self.shell_type = env['SHELL_TYPE'] = shell_type
# actually make the shell
if shell_type == 'none':
from xonsh.base_shell import BaseShell as shell_class
elif shell_type == 'prompt_toolkit':
from xonsh.ptk.shell import PromptToolkitShell as shell_class
elif shell_type == 'readline':
from xonsh.readline_shell import ReadlineShell as shell_class
else:
raise XonshError(
'{} is not recognized as a shell type'.format(shell_type))
self.shell = shell_class(execer=self.execer, ctx=self.ctx, **kwargs)
# allows history garbage collector to start running
if hist.gc is not None:
hist.gc.wait_for_shell = False
def __init__(self, execer, ctx=None, shell_type=None, **kwargs):
"""
Parameters
----------
execer : Execer
An execer instance capable of running xonsh code.
ctx : Mapping, optional
The execution context for the shell (e.g. the globals namespace).
If none, this is computed by loading the rc files. If not None,
this no additional context is computed and this is used
directly.
shell_type : str, optional
The shell type to start, such as 'readline', 'prompt_toolkit1',
or 'random'.
"""
self.execer = execer
self.ctx = {} if ctx is None else ctx
env = XSH.env
# build history backend before creating shell
if env.get("XONSH_INTERACTIVE"):
XSH.history = hist = xhm.construct_history(
env=env.detype(),
ts=[time.time(), None],
locked=True,
filename=env.get("XONSH_HISTORY_FILE", None),
)
env["XONSH_HISTORY_FILE"] = hist.filename
else:
XSH.history = hist = DummyHistory()
env["XONSH_HISTORY_FILE"] = None
shell_type = self.choose_shell_type(shell_type, env)
self.shell_type = env["SHELL_TYPE"] = shell_type
# actually make the shell
if shell_type == "none":
from xonsh.base_shell import BaseShell as shell_class
elif shell_type == "prompt_toolkit":
from xonsh.ptk_shell.shell import PromptToolkitShell as shell_class
elif shell_type == "readline":
from xonsh.readline_shell import ReadlineShell as shell_class
elif shell_type == "jupyter":
from xonsh.jupyter_shell import JupyterShell as shell_class
elif shell_type == "dumb":
from xonsh.dumb_shell import DumbShell as shell_class
else:
raise XonshError(
"{} is not recognized as a shell type".format(shell_type))
self.shell = shell_class(execer=self.execer, ctx=self.ctx, **kwargs)
# allows history garbage collector to start running
if hist.gc is not None:
hist.gc.wait_for_shell = False
def create(cls) -> "Shell":
import signal
from xonsh.built_ins import load_builtins
from xonsh.built_ins import XonshSession
from xonsh.imphooks import install_import_hooks
from xonsh.main import _pprint_displayhook
from xonsh.xontribs import xontribs_load
import xonsh.history.main as xhm
ctx: Dict[str, Any] = {}
execer = Execer(xonsh_ctx=ctx)
builtins.__xonsh__ = XonshSession(ctx=ctx,
execer=execer) # type: ignore
load_builtins(ctx=ctx, execer=execer)
env = builtins.__xonsh__.env # type: ignore
env.update({"XONSH_INTERACTIVE": True, "SHELL_TYPE": "prompt_toolkit"})
builtins.__xonsh__.history = xhm.construct_history( # type: ignore
env=env.detype(),
ts=[time.time(), None],
locked=True)
builtins.__xonsh__.history.gc.wait_for_shell = False # type: ignore
setattr(sys, "displayhook", _pprint_displayhook)
install_import_hooks()
builtins.aliases.update({"ll": "ls -alF"}) # type: ignore
xontribs_load([""])
def func_sig_ttin_ttou(n: Any, f: Any) -> None:
pass
signal.signal(signal.SIGTTIN, func_sig_ttin_ttou)
signal.signal(signal.SIGTTOU, func_sig_ttin_ttou)
shell = cls(execer)
builtins.__xonsh__.shell = shell # type: ignore
builtins.__xonsh__.shell.shell = shell # type: ignore
return shell
def test_construct_history_instance(xonsh_builtins):
xonsh_builtins.__xonsh__.env["XONSH_HISTORY_BACKEND"] = DummyHistory()
assert isinstance(construct_history(), DummyHistory)
def __init__(self, execer, ctx=None, shell_type=None, **kwargs):
"""
Parameters
----------
execer : Execer
An execer instance capable of running xonsh code.
ctx : Mapping, optional
The execution context for the shell (e.g. the globals namespace).
If none, this is computed by loading the rc files. If not None,
this no additional context is computed and this is used
directly.
shell_type : str, optional
The shell type to start, such as 'readline', 'prompt_toolkit1',
or 'random'.
"""
self.execer = execer
self.ctx = {} if ctx is None else ctx
env = builtins.__xonsh__.env
# build history backend before creating shell
builtins.__xonsh__.history = hist = xhm.construct_history(
env=env.detype(), ts=[time.time(), None], locked=True)
# pick a valid shell -- if no shell is specified by the user,
# shell type is pulled from env
if shell_type is None:
shell_type = env.get("SHELL_TYPE")
if shell_type == "none":
# This bricks interactive xonsh
# Can happen from the use of .xinitrc, .xsession, etc
shell_type = "best"
shell_type = self.shell_type_aliases.get(shell_type, shell_type)
if shell_type == "best" or shell_type is None:
shell_type = best_shell_type()
elif env.get("TERM", "") == "dumb":
shell_type = "dumb"
elif shell_type == "random":
shell_type = random.choice(("readline", "prompt_toolkit"))
if shell_type == "prompt_toolkit":
if not has_prompt_toolkit():
warnings.warn("prompt_toolkit is not available, using "
"readline instead.")
shell_type = "readline"
elif not ptk_above_min_supported():
warnings.warn("prompt-toolkit version < v1.0.0 is not "
"supported. Please update prompt-toolkit. Using "
"readline instead.")
shell_type = "readline"
else:
shell_type = ptk_shell_type()
self.shell_type = env["SHELL_TYPE"] = shell_type
# actually make the shell
if shell_type == "none":
from xonsh.base_shell import BaseShell as shell_class
elif shell_type == "prompt_toolkit2":
from xonsh.ptk2.shell import PromptToolkit2Shell as shell_class
elif shell_type == "prompt_toolkit1":
from xonsh.ptk.shell import PromptToolkitShell as shell_class
elif shell_type == "readline":
from xonsh.readline_shell import ReadlineShell as shell_class
elif shell_type == "jupyter":
from xonsh.jupyter_shell import JupyterShell as shell_class
elif shell_type == "dumb":
from xonsh.dumb_shell import DumbShell as shell_class
else:
raise XonshError(
"{} is not recognized as a shell type".format(shell_type))
self.shell = shell_class(execer=self.execer, ctx=self.ctx, **kwargs)
# allows history garbage collector to start running
if hist.gc is not None:
hist.gc.wait_for_shell = False
#From https://github.com/xonsh/xonsh/issues/1614#issuecomment-483386184
import re
from xonsh.history.main import construct_history
# <command-number> <unix epoch> <command>
history_line_pat = re.compile(r'^\s*\d+ (?P<timestamp>\d{10}) (?P<command>.*)$')
# Query zsh's builtin `fc` (don't use zsh_history directly since it
# mangles unicode). To do that, we have to first force it to read the
# history (which it normally doesn't do with -c) and also force it to
# act in interactive mode (-i).
history_lines = $(zsh -i -c 'fc -R ~/.zsh_history; fc -l -t "%s" 0').splitlines()
hist = construct_history(
gc=False,
# exlictily set buffersize to prevent slowing down to a crawl because of excessive flushing
buffersize=len(history_lines)
)
for line in history_lines:
match = history_line_pat.match(line)
command = match.group('command')
timestamp = match.group('timestamp')
command = command.replace(r'\\n', '\n')
hist.append({'inp': command, 'rtn': 0, 'ts': (timestamp, timestamp)})
hist.flush()
print(hist.info()["filename"])
def test_construct_history_class(xonsh_builtins):
xonsh_builtins.__xonsh_env__['XONSH_HISTORY_BACKEND'] = DummyHistory
assert isinstance(construct_history(), DummyHistory)
def test_construct_history_instance(xonsh_builtins):
xonsh_builtins.__xonsh__.env["XONSH_HISTORY_BACKEND"] = DummyHistory()
assert isinstance(construct_history(), DummyHistory)
def test_construct_history_str(xession):
xession.env["XONSH_HISTORY_BACKEND"] = "dummy"
assert isinstance(construct_history(), DummyHistory)
def __init__(self, execer, ctx=None, shell_type=None, **kwargs):
"""
Parameters
----------
execer : Execer
An execer instance capable of running xonsh code.
ctx : Mapping, optional
The execution context for the shell (e.g. the globals namespace).
If none, this is computed by loading the rc files. If not None,
this no additional context is computed and this is used
directly.
shell_type : str, optional
The shell type to start, such as 'readline', 'prompt_toolkit1',
or 'random'.
"""
self.execer = execer
self.ctx = {} if ctx is None else ctx
env = builtins.__xonsh__.env
# build history backend before creating shell
builtins.__xonsh__.history = hist = xhm.construct_history(
env=env.detype(), ts=[time.time(), None], locked=True
)
# pick a valid shell -- if no shell is specified by the user,
# shell type is pulled from env
if shell_type is None:
shell_type = env.get("SHELL_TYPE")
if shell_type == "none":
# This bricks interactive xonsh
# Can happen from the use of .xinitrc, .xsession, etc
shell_type = "best"
shell_type = self.shell_type_aliases.get(shell_type, shell_type)
if shell_type == "best" or shell_type is None:
shell_type = best_shell_type()
elif env.get("TERM", "") == "dumb":
shell_type = "dumb"
elif shell_type == "random":
shell_type = random.choice(("readline", "prompt_toolkit"))
if shell_type == "prompt_toolkit":
if not has_prompt_toolkit():
warnings.warn(
"prompt_toolkit is not available, using " "readline instead."
)
shell_type = "readline"
elif not ptk_above_min_supported():
warnings.warn(
"prompt-toolkit version < v1.0.0 is not "
"supported. Please update prompt-toolkit. Using "
"readline instead."
)
shell_type = "readline"
else:
shell_type = ptk_shell_type()
self.shell_type = env["SHELL_TYPE"] = shell_type
# actually make the shell
if shell_type == "none":
from xonsh.base_shell import BaseShell as shell_class
elif shell_type == "prompt_toolkit2":
from xonsh.ptk2.shell import PromptToolkit2Shell as shell_class
elif shell_type == "prompt_toolkit1":
from xonsh.ptk.shell import PromptToolkitShell as shell_class
elif shell_type == "readline":
from xonsh.readline_shell import ReadlineShell as shell_class
elif shell_type == "jupyter":
from xonsh.jupyter_shell import JupyterShell as shell_class
elif shell_type == "dumb":
from xonsh.dumb_shell import DumbShell as shell_class
else:
raise XonshError("{} is not recognized as a shell type".format(shell_type))
self.shell = shell_class(execer=self.execer, ctx=self.ctx, **kwargs)
# allows history garbage collector to start running
if hist.gc is not None:
hist.gc.wait_for_shell = False
def test_construct_history_class(xonsh_builtins):
xonsh_builtins.__xonsh_env__['XONSH_HISTORY_BACKEND'] = DummyHistory
assert isinstance(construct_history(), DummyHistory)
def test_construct_history_str(xonsh_builtins):
xonsh_builtins.__xonsh_env__["XONSH_HISTORY_BACKEND"] = "dummy"
assert isinstance(construct_history(), DummyHistory)