return importlib.import_module('termios') @lazyobject def fcntl(): if ON_WINDOWS: return else: return importlib.import_module('fcntl') # The following escape codes are xterm codes. # See http://rtfm.etla.org/xterm/ctlseq.html for more. MODE_NUMS = ('1049', '47', '1047') START_ALTERNATE_MODE = LazyObject( lambda: frozenset('\x1b[?{0}h'.format(i).encode() for i in MODE_NUMS), globals(), 'START_ALTERNATE_MODE') END_ALTERNATE_MODE = LazyObject( lambda: frozenset('\x1b[?{0}l'.format(i).encode() for i in MODE_NUMS), globals(), 'END_ALTERNATE_MODE') ALTERNATE_MODE_FLAGS = LazyObject( lambda: tuple(START_ALTERNATE_MODE) + tuple(END_ALTERNATE_MODE), globals(), 'ALTERNATE_MODE_FLAGS') RE_HIDDEN_BYTES = LazyObject(lambda: re.compile(b'(\001.*?\002)'), globals(), 'RE_HIDDEN') RE_COLOR = LazyObject(lambda: re.compile(b'\033\[\d+;?\d*m'), globals(), 'RE_COLOR') def _findfirst(s, substrs): """Finds whichever of the given substrings occurs first in the given string
} # XonshLexer & XonshSubprocLexer have to reference each other XonshSubprocLexer.tokens['root'] = [ (r'(\$\{)(.*)(\})', bygroups(Keyword, using(XonshLexer), Keyword)), (r'(@\()(.+)(\))', bygroups(Keyword, using(XonshLexer), Keyword)), ] + XonshSubprocLexer.tokens['root'] # # Colors and Styles # Color = Token.Color # alias to new color token namespace RE_BACKGROUND = LazyObject(lambda: re.compile('(BG#|BGHEX|BACKGROUND)'), globals(), 'RE_BACKGROUND') def norm_name(name): """Normalizes a color name.""" return name.replace('#', 'HEX').replace('BGHEX', 'BACKGROUND_HEX') def color_by_name(name, fg=None, bg=None): """Converts a color name to a color token, foreground name, and background name. Will take into consideration current foreground and background colors, if provided. Parameters ---------- name : str
import linecache import importlib import functools import typing as tp from xonsh.lazyasd import LazyObject from xonsh.platform import HAS_PYGMENTS from xonsh.tools import DefaultNotGiven, print_color, normabspath, to_bool from xonsh.inspectors import find_file from xonsh.lazyimps import pygments, pyghooks import xonsh.procs.pipelines as xpp import xonsh.prompt.cwd as prompt terminal = LazyObject( lambda: importlib.import_module("pygments.formatters.terminal"), globals(), "terminal", ) class TracerType(object): """Represents a xonsh tracer object, which keeps track of all tracing state. This is a singleton. """ _inst: tp.Optional["TracerType"] = None valid_events = frozenset(["line", "call"]) def __new__(cls, *args, **kwargs): if cls._inst is None: cls._inst = super(TracerType, cls).__new__(cls, *args, **kwargs)
def test_lazyobject_getitem(): lo = LazyObject(lambda: {'x': 1}, {}, 'lo') assert 1 == lo['x']
tokens = { 'root': [(r'^(>>>|\.\.\.) ', Generic.Prompt), (r'\n(>>>|\.\.\.)', Generic.Prompt), (r'\n(?![>.][>.][>.] )([^\n]*)', Generic.Output), (r'\n(?![>.][>.][>.] )(.*?)$', Generic.Output), inherit] } # # Colors and Styles # Color = Token.Color # alias to new color token namespace RE_BACKGROUND = LazyObject(lambda: re.compile('(BG#|BGHEX|BACKGROUND)'), globals(), 'RE_BACKGROUND') def norm_name(name): """Normalizes a color name.""" return name.replace('#', 'HEX').replace('BGHEX', 'BACKGROUND_HEX') def color_by_name(name, fg=None, bg=None): """Converts a color name to a color token, foreground name, and background name. Will take into consideration current foreground and background colors, if provided. Parameters ---------- name : str
if isinstance(comp, xct.RichCompletion) and comp.prefix_len is not None: if comp.prefix_len: comp = prefix[:-comp.prefix_len] + comp else: comp = prefix + comp elif chopped: comp = chopped + comp rendered_completions.append(comp) return rendered_completions DEDENT_TOKENS = LazyObject( lambda: frozenset(["raise", "return", "pass", "break", "continue"]), globals(), "DEDENT_TOKENS", ) class ReadlineShell(BaseShell, cmd.Cmd): """The readline based xonsh shell.""" def __init__(self, completekey="tab", stdin=None, stdout=None, **kwargs): BaseShell.__init__(self, **kwargs) # super() doesn't pass the stdin/stdout to Cmd's init method correctly. # so calling it explicitly cmd.Cmd.__init__(self, completekey=completekey, stdin=stdin, stdout=stdout)
import builtins import importlib import threading import collections from xonsh.lazyjson import LazyJSON from xonsh.lazyasd import LazyObject from xonsh.base_shell import BaseShell from xonsh.ansi_colors import ansi_partial_color_format, ansi_color_style_names, ansi_color_style from xonsh.prompt.base import partial_format_prompt, multiline_prompt from xonsh.tools import print_exception from xonsh.platform import ON_WINDOWS, ON_CYGWIN, ON_DARWIN from xonsh.lazyimps import pygments, pyghooks terminal256 = LazyObject( lambda: importlib.import_module('pygments.formatters.terminal256'), globals(), 'terminal') readline = None RL_COMPLETION_SUPPRESS_APPEND = RL_LIB = RL_STATE = None RL_CAN_RESIZE = False RL_DONE = None RL_VARIABLE_VALUE = None _RL_STATE_DONE = 0x1000000 _RL_STATE_ISEARCH = 0x0000080 _RL_PREV_CASE_SENSITIVE_COMPLETIONS = 'to-be-set' def setup_readline(): """Sets up the readline module and completion suppression, if available."""
from xonsh.tokenize import SearchPath from xonsh.inspectors import Inspector from xonsh.aliases import Aliases, make_default_aliases from xonsh.environ import Env, default_env, locate_binary from xonsh.foreign_shells import load_foreign_aliases from xonsh.jobs import add_job, wait_for_active_job from xonsh.platform import ON_POSIX, ON_WINDOWS from xonsh.proc import (ProcProxy, SimpleProcProxy, ForegroundProcProxy, SimpleForegroundProcProxy, TeePTYProc, CompletedCommand, HiddenCompletedCommand) from xonsh.tools import (suggest_commands, expandvars, CommandsCache, globpath, XonshError, XonshCalledProcessError, XonshBlockError) ENV = None BUILTINS_LOADED = False INSPECTOR = LazyObject(Inspector, globals(), 'INSPECTOR') AT_EXIT_SIGNALS = (signal.SIGABRT, signal.SIGFPE, signal.SIGILL, signal.SIGSEGV, signal.SIGTERM) SIGNAL_MESSAGES = { signal.SIGABRT: 'Aborted', signal.SIGFPE: 'Floating point exception', signal.SIGILL: 'Illegal instructions', signal.SIGTERM: 'Terminated', signal.SIGSEGV: 'Segmentation fault' } if ON_POSIX: AT_EXIT_SIGNALS += (signal.SIGTSTP, signal.SIGQUIT, signal.SIGHUP) SIGNAL_MESSAGES.update({ signal.SIGQUIT: 'Quit',
"""Lazy imports that may apply across the xonsh package.""" import importlib from xonsh.lazyasd import LazyObject pygments = LazyObject(lambda: importlib.import_module('pygments'), globals(), 'pygments') pyghooks = LazyObject(lambda: importlib.import_module('xonsh.pyghooks'), globals(), 'pyghooks')
import os import sys import queue import builtins import threading import subprocess import re import pathlib import xonsh.tools as xt from xonsh.lazyasd import LazyObject RE_REMOVE_ANSI = LazyObject( lambda: re.compile(r"(?:\x1B[@-_]|[\x80-\x9F])[0-?]*[ -/]*[@-~]"), globals(), "RE_REMOVE_ANSI", ) def _get_git_branch(q): denv = builtins.__xonsh__.env.detype() try: cmd = ["git", "rev-parse", "--abbrev-ref", "HEAD"] branch = xt.decode_bytes( subprocess.check_output(cmd, env=denv, stderr=subprocess.DEVNULL) ) branch = branch.splitlines()[0] or None except (subprocess.CalledProcessError, OSError, FileNotFoundError): q.put(None) else:
func = print_for_newline return func def _insert_text_func(s, readline): """Creates a function to insert text via readline.""" def inserter(): readline.insert_text(s) readline.redisplay() return inserter DEDENT_TOKENS = LazyObject(lambda: frozenset(['raise', 'return', 'pass', 'break', 'continue']), globals(), 'DEDENT_TOKENS') class ReadlineShell(BaseShell, cmd.Cmd): """The readline based xonsh shell.""" def __init__(self, completekey='tab', stdin=None, stdout=None, **kwargs): super().__init__(completekey=completekey, stdin=stdin, stdout=stdout, **kwargs) setup_readline() self._current_indent = '' self._current_prompt = '' self._force_hide = None
_send_signal(job, signal.SIGCONT) job["status"] = "running" def _kill(job): _send_signal(job, signal.SIGKILL) def ignore_sigtstp(): signal.signal(signal.SIGTSTP, signal.SIG_IGN) _shell_pgrp = os.getpgrp() # type:ignore _block_when_giving = LazyObject( lambda: ( signal.SIGTTOU, # type:ignore signal.SIGTTIN, # type:ignore signal.SIGTSTP, # type:ignore signal.SIGCHLD, # type:ignore ), globals(), "_block_when_giving", ) if ON_CYGWIN or ON_MSYS: # on cygwin, signal.pthread_sigmask does not exist in Python, even # though pthread_sigmask is defined in the kernel. thus, we use # ctypes to mimic the calls in the "normal" version below. LIBC.pthread_sigmask.restype = ctypes.c_int LIBC.pthread_sigmask.argtypes = [ ctypes.c_int, ctypes.POINTER(ctypes.c_ulong), ctypes.POINTER(ctypes.c_ulong), ]
class DefaultNotGivenType(object): """Singleton for representing when no default value is given.""" __inst = None def __new__(cls): if DefaultNotGivenType.__inst is None: DefaultNotGivenType.__inst = object.__new__(cls) return DefaultNotGivenType.__inst DefaultNotGiven = DefaultNotGivenType() BEG_TOK_SKIPS = LazyObject( lambda: frozenset(['WS', 'INDENT', 'NOT', 'LPAREN']), globals(), 'BEG_TOK_SKIPS') END_TOK_TYPES = LazyObject(lambda: frozenset(['SEMI', 'AND', 'OR', 'RPAREN']), globals(), 'END_TOK_TYPES') RE_END_TOKS = LazyObject(lambda: re.compile('(;|and|\&\&|or|\|\||\))'), globals(), 'RE_END_TOKS') LPARENS = LazyObject( lambda: frozenset([ 'LPAREN', 'AT_LPAREN', 'BANG_LPAREN', 'DOLLAR_LPAREN', 'ATDOLLAR_LPAREN' ]), globals(), 'LPARENS') def _is_not_lparen_and_rparen(lparens, rtok): """Tests if an RPAREN token is matched with something other than a plain old LPAREN type.
This file was forked from the IPython project: * Copyright (c) 2008-2014, IPython Development Team * Copyright (C) 2001-2007 Fernando Perez <*****@*****.**> * Copyright (c) 2001, Janko Hauser <*****@*****.**> * Copyright (c) 2001, Nathaniel Gray <*****@*****.**> """ import io import re from xonsh.lazyasd import LazyObject from xonsh.tokenize import detect_encoding, tokopen cookie_comment_re = LazyObject( lambda: re.compile(r"^\s*#.*coding[:=]\s*([-\w.]+)", re.UNICODE), globals(), "cookie_comment_re", ) def source_to_unicode(txt, errors="replace", skip_encoding_cookie=True): """Converts a bytes string with python source code to unicode. Unicode strings are passed through unchanged. Byte strings are checked for the python source file encoding cookie to determine encoding. txt can be either a bytes buffer or a string containing the source code. """ if isinstance(txt, str): return txt if isinstance(txt, bytes):
"""Lazy imports that may apply across the xonsh package.""" import importlib from xonsh.platform import ON_WINDOWS, ON_DARWIN from xonsh.lazyasd import LazyObject, lazyobject pygments = LazyObject(lambda: importlib.import_module("pygments"), globals(), "pygments") pyghooks = LazyObject(lambda: importlib.import_module("xonsh.pyghooks"), globals(), "pyghooks") @lazyobject def pty(): if ON_WINDOWS: return else: return importlib.import_module("pty") @lazyobject def termios(): if ON_WINDOWS: return else: return importlib.import_module("termios") @lazyobject def fcntl(): if ON_WINDOWS:
import sys import types import inspect import itertools import linecache from xonsh.lazyasd import LazyObject from xonsh.tokenize import detect_encoding from xonsh.openpy import read_py_file from xonsh.tools import cast_unicode, safe_hasattr, indent, print_color, format_color from xonsh.platform import HAS_PYGMENTS from xonsh.lazyimps import pygments, pyghooks from xonsh.style_tools import partial_color_tokenize # builtin docstrings to ignore _func_call_docstring = LazyObject(lambda: types.FunctionType.__call__.__doc__, globals(), "_func_call_docstring") _object_init_docstring = LazyObject(lambda: object.__init__.__doc__, globals(), "_object_init_docstring") _builtin_type_docstrings = LazyObject( lambda: { inspect.getdoc(t) for t in (types.ModuleType, types.MethodType, types.FunctionType, property) }, globals(), "_builtin_type_docstrings", ) _builtin_func_type = LazyObject(lambda: type(all), globals(), "_builtin_func_type")
import collections from token import (AMPER, AMPEREQUAL, AT, CIRCUMFLEX, CIRCUMFLEXEQUAL, COLON, COMMA, DEDENT, DOT, DOUBLESLASH, DOUBLESLASHEQUAL, DOUBLESTAR, DOUBLESTAREQUAL, ENDMARKER, EQEQUAL, EQUAL, ERRORTOKEN, GREATER, GREATEREQUAL, INDENT, LBRACE, LEFTSHIFT, LEFTSHIFTEQUAL, LESS, LESSEQUAL, LPAR, LSQB, MINEQUAL, MINUS, NAME, NEWLINE, NOTEQUAL, NUMBER, N_TOKENS, OP, PERCENT, PERCENTEQUAL, PLUS, PLUSEQUAL, RBRACE, RIGHTSHIFT, RIGHTSHIFTEQUAL, RPAR, RSQB, SEMI, SLASH, SLASHEQUAL, STAR, STAREQUAL, STRING, TILDE, VBAR, VBAREQUAL, tok_name) from xonsh.lazyasd import LazyObject from xonsh.platform import PYTHON_VERSION_INFO cookie_re = LazyObject( lambda: re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)', re.ASCII), globals(), 'cookie_re') blank_re = LazyObject(lambda: re.compile(br'^[ \t\f]*(?:[#\r\n]|$)', re.ASCII), globals(), 'blank_re') # # token modifications # import token __all__ = token.__all__ + ["COMMENT", "tokenize", "detect_encoding", "NL", "untokenize", "ENCODING", "TokenInfo", "TokenError", 'SEARCHPATH', 'ATDOLLAR', 'ATEQUAL', 'DOLLARNAME', 'IOREDIRECT'] PY35 = PYTHON_VERSION_INFO >= (3, 5, 0) if PY35:
from xonsh.platform import ON_POSIX, ON_WINDOWS from xonsh.tools import ( expand_path, globpath, XonshError, XonshCalledProcessError, print_color, ) from xonsh.commands_cache import CommandsCache from xonsh.events import events import xonsh.procs.specs import xonsh.completers.init BUILTINS_LOADED = False INSPECTOR = LazyObject(Inspector, globals(), "INSPECTOR") warnings.filterwarnings("once", category=DeprecationWarning) @lazyobject def AT_EXIT_SIGNALS(): sigs = ( signal.SIGABRT, signal.SIGFPE, signal.SIGILL, signal.SIGSEGV, signal.SIGTERM, ) if ON_POSIX: sigs += (signal.SIGTSTP, signal.SIGQUIT, signal.SIGHUP)
background_color = styler.background_color def __new__(cls, *args, **kwargs): return cls.target return XonshStyleProxy PTK_STYLE = LazyObject( lambda: { Token.Menu.Completions: "bg:ansigray ansiblack", Token.Menu.Completions.Completion: "", Token.Menu.Completions.Completion.Current: "bg:ansibrightblack ansiwhite", Token.Scrollbar: "bg:ansibrightblack", Token.Scrollbar.Button: "bg:ansiblack", Token.Scrollbar.Arrow: "bg:ansiblack ansiwhite bold", Token.AutoSuggestion: "ansibrightblack", Token.Aborted: "ansibrightblack", }, globals(), "PTK_STYLE", ) XONSH_BASE_STYLE = LazyObject( lambda: { Whitespace: "ansigray", Comment: "underline ansicyan", Comment.Preproc: "underline ansiyellow", Keyword: "bold ansigreen", Keyword.Pseudo: "nobold",
TILDE, VBAR, VBAREQUAL, tok_name, ) from xonsh.lazyasd import LazyObject from xonsh.platform import PYTHON_VERSION_INFO HAS_WALRUS = PYTHON_VERSION_INFO > (3, 8) if HAS_WALRUS: from token import COLONEQUAL cookie_re = LazyObject( lambda: re.compile(r"^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)", re.ASCII), globals(), "cookie_re", ) blank_re = LazyObject(lambda: re.compile(br"^[ \t\f]*(?:[#\r\n]|$)", re.ASCII), globals(), "blank_re") # # token modifications # tok_name = tok_name.copy() __all__ = token.__all__ + [ "COMMENT", "tokenize", "detect_encoding", "NL", "untokenize",
) from xonsh.tools import ( suggest_commands, expand_path, globpath, XonshError, XonshCalledProcessError, ) from xonsh.lazyimps import pty, termios, fcntl from xonsh.commands_cache import CommandsCache from xonsh.events import events import xonsh.completers.init BUILTINS_LOADED = False INSPECTOR = LazyObject(Inspector, globals(), "INSPECTOR") warnings.filterwarnings("once", category=DeprecationWarning) @lazyobject def AT_EXIT_SIGNALS(): sigs = ( signal.SIGABRT, signal.SIGFPE, signal.SIGILL, signal.SIGSEGV, signal.SIGTERM, ) if ON_POSIX: sigs += (signal.SIGTSTP, signal.SIGQUIT, signal.SIGHUP)
import subprocess import importlib.util from xonsh.lazyasd import LazyObject, LazyBool def _distro(): try: import distro as d except ImportError: d = None except Exception: raise return d distro = LazyObject(_distro, globals(), 'distro') del _distro # do not import any xonsh-modules here to avoid circular dependencies # # OS # ON_DARWIN = LazyBool(lambda: platform.system() == 'Darwin', globals(), 'ON_DARWIN') """ ``True`` if executed on a Darwin platform, else ``False``. """ ON_LINUX = LazyBool(lambda: platform.system() == 'Linux', globals(), 'ON_LINUX') """ ``True`` if executed on a Linux platform, else ``False``. """ ON_WINDOWS = LazyBool(lambda: platform.system() == 'Windows',
import sys import inspect import argparse import linecache import importlib import functools from xonsh.lazyasd import LazyObject from xonsh.platform import HAS_PYGMENTS from xonsh.tools import DefaultNotGiven, print_color, normabspath, to_bool from xonsh.inspectors import find_file, getouterframes from xonsh.environ import _replace_home from xonsh.lazyimps import pygments, pyghooks terminal = LazyObject( lambda: importlib.import_module('pygments.formatters.terminal'), globals(), 'terminal') class TracerType(object): """Represents a xonsh tracer object, which keeps track of all tracing state. This is a singleton. """ _inst = None valid_events = frozenset(['line', 'call']) def __new__(cls, *args, **kwargs): if cls._inst is None: cls._inst = super(TracerType, cls).__new__(cls, *args, **kwargs) return cls._inst
"""Tools for helping with ANSI color codes.""" import re import string import warnings from xonsh.lazyasd import LazyObject, LazyDict RE_BACKGROUND = LazyObject(lambda: re.compile('(bg|bg#|bghex|background)'), globals(), 'RE_BACKGROUND') def partial_color_format(template, style='default', cmap=None, hide=False): """Formats a template string but only with respect to the colors. Another template string is returned, with the color values filled in. Parameters ---------- template : str The template string, potentially with color names. style : str, optional Sytle name to look up color map from. cmap : dict, optional A color map to use, this will prevent the color map from being looked up via the style name. hide : bool, optional Whether to wrap the color codes in the \\001 and \\002 escape codes, so that the color codes are not counted against line length. Returns
rather than the type object itself. """ if dtp is None: dtp = _deferred_type_pprinters key = (type_module, type_name) oldfunc = dtp.get(key, None) if func is not None: # To support easy restoration of old pprinters, we need to ignore Nones. dtp[key] = func return oldfunc #: printers for the default singletons _singleton_pprinters = LazyObject( lambda: dict.fromkeys( map(id, [None, True, False, Ellipsis, NotImplemented]), _repr_pprint), globals(), "_singleton_pprinters", ) def _defaultdict_pprint(obj, p, cycle): name = obj.__class__.__name__ with p.group(len(name) + 1, name + "(", ")"): if cycle: p.text("...") else: p.pretty(obj.default_factory) p.text(",") p.breakable() p.pretty(dict(obj))
from xonsh.jobs import add_job from xonsh.platform import ON_POSIX, ON_WINDOWS from xonsh.proc import (PopenThread, ProcProxyThread, ProcProxy, ConsoleParallelReader, pause_call_resume, CommandPipeline, HiddenCommandPipeline, STDOUT_CAPTURE_KINDS) from xonsh.tools import (suggest_commands, expand_path, globpath, XonshError, XonshCalledProcessError) from xonsh.lazyimps import pty, termios from xonsh.commands_cache import CommandsCache from xonsh.events import events import xonsh.completers.init BUILTINS_LOADED = False INSPECTOR = LazyObject(Inspector, globals(), 'INSPECTOR') @lazyobject def AT_EXIT_SIGNALS(): sigs = (signal.SIGABRT, signal.SIGFPE, signal.SIGILL, signal.SIGSEGV, signal.SIGTERM) if ON_POSIX: sigs += (signal.SIGTSTP, signal.SIGQUIT, signal.SIGHUP) return sigs def resetting_signal_handle(sig, f): """Sets a new signal handle that will automatically restore the old value once the new handle is finished. """
events.transmogrify("on_ptk_create", "LoadEvent") events.doc( "on_ptk_create", """ on_ptk_create(prompter: Prompter, history: PromptToolkitHistory, completer: PromptToolkitCompleter, bindings: KeyBindingManager) -> Fired after prompt toolkit has been initialized """, ) # Convert new ansicolor names to names # understood by PTK1 DEFAULT_STYLE_DICT = LazyObject( lambda: ansicolors_to_ptk1_names(_DEFAULT_STYLE_DICT), globals(), "DEFAULT_STYLE_DICT", ) class PromptToolkitShell(BaseShell): """The xonsh shell.""" def __init__(self, **kwargs): super().__init__(**kwargs) if ON_WINDOWS: winutils.enable_virtual_terminal_processing() self._first_prompt = True self.prompter = Prompter() self.history = PromptToolkitHistory() self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx, self)
DEFAULT_STYLE_DICT = LazyObject( lambda: defaultdict( lambda: "", { Token: "", Token.Color.BACKGROUND_BLACK: "bg:ansiblack", Token.Color.BACKGROUND_BLUE: "bg:ansiblue", Token.Color.BACKGROUND_CYAN: "bg:ansicyan", Token.Color.BACKGROUND_GREEN: "bg:ansigreen", Token.Color.BACKGROUND_INTENSE_BLACK: "bg:ansibrightblack", Token.Color.BACKGROUND_INTENSE_BLUE: "bg:ansibrightblue", Token.Color.BACKGROUND_INTENSE_CYAN: "bg:ansibrightcyan", Token.Color.BACKGROUND_INTENSE_GREEN: "bg:ansibrightgreen", Token.Color.BACKGROUND_INTENSE_PURPLE: "bg:ansibrightmagenta", Token.Color.BACKGROUND_INTENSE_RED: "bg:ansibrightred", Token.Color.BACKGROUND_INTENSE_WHITE: "bg:ansiwhite", Token.Color.BACKGROUND_INTENSE_YELLOW: "bg:ansibrightyellow", Token.Color.BACKGROUND_PURPLE: "bg:ansimagenta", Token.Color.BACKGROUND_RED: "bg:ansired", Token.Color.BACKGROUND_WHITE: "bg:ansigray", Token.Color.BACKGROUND_YELLOW: "bg:ansiyellow", Token.Color.BLACK: "ansiblack", Token.Color.BLUE: "ansiblue", Token.Color.BOLD_BLACK: "bold ansiblack", Token.Color.BOLD_BLUE: "bold ansiblue", Token.Color.BOLD_CYAN: "bold ansicyan", Token.Color.BOLD_GREEN: "bold ansigreen", Token.Color.BOLD_INTENSE_BLACK: "bold ansibrightblack", Token.Color.BOLD_INTENSE_BLUE: "bold ansibrightblue", Token.Color.BOLD_INTENSE_CYAN: "bold ansibrightcyan", Token.Color.BOLD_INTENSE_GREEN: "bold ansibrightgreen", Token.Color.BOLD_INTENSE_PURPLE: "bold ansibrightmagenta", Token.Color.BOLD_INTENSE_RED: "bold ansibrightred", Token.Color.BOLD_INTENSE_WHITE: "bold ansiwhite", Token.Color.BOLD_INTENSE_YELLOW: "bold ansibrightyellow", Token.Color.BOLD_PURPLE: "bold ansimagenta", Token.Color.BOLD_RED: "bold ansired", Token.Color.BOLD_UNDERLINE_BLACK: "bold underline ansiblack", Token.Color.BOLD_UNDERLINE_BLUE: "bold underline ansiblue", Token.Color.BOLD_UNDERLINE_CYAN: "bold underline ansicyan", Token.Color.BOLD_UNDERLINE_GREEN: "bold underline ansigreen", Token.Color.BOLD_UNDERLINE_INTENSE_BLACK: "bold underline ansibrightblack", Token.Color.BOLD_UNDERLINE_INTENSE_BLUE: "bold underline ansibrightblue", Token.Color.BOLD_UNDERLINE_INTENSE_CYAN: "bold underline ansibrightcyan", Token.Color.BOLD_UNDERLINE_INTENSE_GREEN: "bold underline ansibrightgreen", Token.Color.BOLD_UNDERLINE_INTENSE_PURPLE: "bold underline ansibrightmagenta", Token.Color.BOLD_UNDERLINE_INTENSE_RED: "bold underline ansibrightred", Token.Color.BOLD_UNDERLINE_INTENSE_WHITE: "bold underline ansiwhite", Token.Color.BOLD_UNDERLINE_INTENSE_YELLOW: "bold underline ansibrightyellow", Token.Color.BOLD_UNDERLINE_PURPLE: "bold underline ansimagenta", Token.Color.BOLD_UNDERLINE_RED: "bold underline ansired", Token.Color.BOLD_UNDERLINE_WHITE: "bold underline ansigray", Token.Color.BOLD_UNDERLINE_YELLOW: "bold underline ansiyellow", Token.Color.BOLD_WHITE: "bold ansigray", Token.Color.BOLD_YELLOW: "bold ansiyellow", Token.Color.CYAN: "ansicyan", Token.Color.GREEN: "ansigreen", Token.Color.INTENSE_BLACK: "ansibrightblack", Token.Color.INTENSE_BLUE: "ansibrightblue", Token.Color.INTENSE_CYAN: "ansibrightcyan", Token.Color.INTENSE_GREEN: "ansibrightgreen", Token.Color.INTENSE_PURPLE: "ansibrightmagenta", Token.Color.INTENSE_RED: "ansibrightred", Token.Color.INTENSE_WHITE: "ansiwhite", Token.Color.INTENSE_YELLOW: "ansibrightyellow", Token.Color.RESET: "noinherit", Token.Color.PURPLE: "ansimagenta", Token.Color.RED: "ansired", Token.Color.UNDERLINE_BLACK: "underline ansiblack", Token.Color.UNDERLINE_BLUE: "underline ansiblue", Token.Color.UNDERLINE_CYAN: "underline ansicyan", Token.Color.UNDERLINE_GREEN: "underline ansigreen", Token.Color.UNDERLINE_INTENSE_BLACK: "underline ansibrightblack", Token.Color.UNDERLINE_INTENSE_BLUE: "underline ansibrightblue", Token.Color.UNDERLINE_INTENSE_CYAN: "underline ansibrightcyan", Token.Color.UNDERLINE_INTENSE_GREEN: "underline ansibrightgreen", Token.Color.UNDERLINE_INTENSE_PURPLE: "underline ansibrightmagenta", Token.Color.UNDERLINE_INTENSE_RED: "underline ansibrightred", Token.Color.UNDERLINE_INTENSE_WHITE: "underline ansiwhite", Token.Color.UNDERLINE_INTENSE_YELLOW: "underline ansibrightyellow", Token.Color.UNDERLINE_PURPLE: "underline ansimagenta", Token.Color.UNDERLINE_RED: "underline ansired", Token.Color.UNDERLINE_WHITE: "underline ansigray", Token.Color.UNDERLINE_YELLOW: "underline ansiyellow", Token.Color.WHITE: "ansigray", Token.Color.YELLOW: "ansiyellow", Token.Comment: "underline ansicyan", Token.Comment.Hashbang: "", Token.Comment.Multiline: "", Token.Comment.Preproc: "underline ansiyellow", Token.Comment.PreprocFile: "", Token.Comment.Single: "", Token.Comment.Special: "", Token.Error: "ansibrightred", Token.Escape: "", Token.Generic: "", Token.Generic.Deleted: "ansired", Token.Generic.Emph: "underline", Token.Generic.Error: "bold ansibrightred", Token.Generic.Heading: "bold ansiblue", Token.Generic.Inserted: "ansibrightgreen", Token.Generic.Output: "ansiblue", Token.Generic.Prompt: "bold ansiblue", Token.Generic.Strong: "", Token.Generic.Subheading: "bold ansimagenta", Token.Generic.Traceback: "ansiblue", Token.Keyword: "bold ansigreen", Token.Keyword.Constant: "", Token.Keyword.Declaration: "", Token.Keyword.Namespace: "", Token.Keyword.Pseudo: "nobold", Token.Keyword.Reserved: "", Token.Keyword.Type: "nobold ansired", Token.Literal: "", Token.Literal.Date: "", Token.Literal.Number: "ansibrightblack", Token.Literal.Number.Bin: "", Token.Literal.Number.Float: "", Token.Literal.Number.Hex: "", Token.Literal.Number.Integer: "", Token.Literal.Number.Integer.Long: "", Token.Literal.Number.Oct: "", Token.Literal.String: "ansibrightred", Token.Literal.String.Affix: "", Token.Literal.String.Backtick: "", Token.Literal.String.Char: "", Token.Literal.String.Delimiter: "", Token.Literal.String.Doc: "underline", Token.Literal.String.Double: "", Token.Literal.String.Escape: "bold ansiyellow", Token.Literal.String.Heredoc: "", Token.Literal.String.Interpol: "bold ansimagenta", Token.Literal.String.Other: "ansigreen", Token.Literal.String.Regex: "ansimagenta", Token.Literal.String.Single: "", Token.Literal.String.Symbol: "ansiyellow", Token.Name: "", Token.Name.Attribute: "ansibrightyellow", Token.Name.Builtin: "ansigreen", Token.Name.Builtin.Pseudo: "", Token.Name.Class: "bold ansibrightblue", Token.Name.Constant: "ansired", Token.Name.Decorator: "ansibrightmagenta", Token.Name.Entity: "bold ansigray", Token.Name.Exception: "bold ansibrightred", Token.Name.Function: "ansibrightblue", Token.Name.Function.Magic: "", Token.Name.Label: "ansibrightyellow", Token.Name.Namespace: "bold ansibrightblue", Token.Name.Other: "", Token.Name.Property: "", Token.Name.Tag: "bold ansigreen", Token.Name.Variable: "ansiblue", Token.Name.Variable.Class: "", Token.Name.Variable.Global: "", Token.Name.Variable.Instance: "", Token.Name.Variable.Magic: "", Token.Operator: "ansibrightblack", Token.Operator.Word: "bold ansimagenta", Token.Other: "", Token.Punctuation: "", Token.Text: "", Token.Text.Whitespace: "ansigray", Token.PTK.Aborting: "ansibrightblack", Token.PTK.AutoSuggestion: "ansibrightblack", Token.PTK.CompletionMenu: "bg:ansigray ansiblack", Token.PTK.CompletionMenu.Completion: "", Token.PTK.CompletionMenu.Completion.Current: "bg:ansibrightblack ansiwhite", Token.PTK.Scrollbar.Arrow: "bg:ansiblack ansiwhite bold", Token.PTK.Scrollbar.Background: "bg:ansibrightblack", Token.PTK.Scrollbar.Button: "bg:ansiblack", }, ), globals(), "DEFAULT_STYLE_DICT", )
# -*- coding: utf-8 -*- """Job control for the xonsh shell.""" import os import sys import time import ctypes import signal import builtins import subprocess import collections from xonsh.lazyasd import LazyObject from xonsh.platform import FD_STDERR, ON_DARWIN, ON_WINDOWS, ON_CYGWIN, ON_MSYS, LIBC from xonsh.tools import unthreadable tasks = LazyObject(collections.deque, globals(), "tasks") # Track time stamp of last exit command, so that two consecutive attempts to # exit can kill all jobs and exit. _last_exit_time = None if ON_DARWIN: def _send_signal(job, signal): # On OS X, os.killpg() may cause PermissionError when there are # any zombie processes in the process group. # See github issue #1012 for details for pid in job["pids"]: if pid is None: # the pid of an aliased proc is None continue try: os.kill(pid, signal)
target = styler styles = styler.styles def __new__(cls, *args, **kwargs): return cls.target return XonshStyleProxy PTK_STYLE = LazyObject( lambda: { Token.Menu.Completions: "bg:ansigray ansiblack", Token.Menu.Completions.Completion: "", Token.Menu.Completions.Completion.Current: "bg:ansibrightblack ansiwhite", Token.Scrollbar: "bg:ansibrightblack", Token.Scrollbar.Button: "bg:ansiblack", Token.Scrollbar.Arrow: "bg:ansiblack ansiwhite bold", Token.AutoSuggestion: "ansibrightblack", Token.Aborted: "ansibrightblack", }, globals(), "PTK_STYLE", ) XONSH_BASE_STYLE = LazyObject( lambda: { Whitespace: "ansigray", Comment: "underline ansicyan", Comment.Preproc: "underline ansiyellow", Keyword: "bold ansigreen", Keyword.Pseudo: "nobold",