response stringlengths 1 33.1k | instruction stringlengths 22 582k |
|---|---|
Uses various mechanism to suggest packages for a command that cannot
currently be found. | def command_not_found(cmd, env):
"""Uses various mechanism to suggest packages for a command that cannot
currently be found.
"""
if ON_LINUX:
rtn = debian_command_not_found(cmd)
else:
rtn = ""
conda = conda_suggest_command_not_found(cmd, env)
if conda:
rtn = rtn + ... |
Suggests alternative commands given an environment and aliases. | def suggest_commands(cmd, env):
"""Suggests alternative commands given an environment and aliases."""
if not env.get("SUGGEST_COMMANDS"):
return ""
thresh = env.get("SUGGEST_THRESHOLD")
max_sugg = env.get("SUGGEST_MAX_NUM")
if max_sugg < 0:
max_sugg = float("inf")
cmd = cmd.lower... |
Returns if the given variable is manually set as well as it's value. | def _get_manual_env_var(name, default=None):
"""Returns if the given variable is manually set as well as it's value."""
env = getattr(xsh, "env", None)
if env is None:
env = os_environ
manually_set = name in env
else:
manually_set = env.is_manually_set(name)
value = env.get... |
Print warnings with/without traceback. | def print_warning(msg):
"""Print warnings with/without traceback."""
manually_set_trace, show_trace = _get_manual_env_var("XONSH_SHOW_TRACEBACK", False)
manually_set_logfile, log_file = _get_manual_env_var("XONSH_TRACEBACK_LOGFILE")
if (not manually_set_trace) and (not manually_set_logfile):
# N... |
Print given exception (or current if None) with/without traceback and set sys.last_type, sys.last_value, sys.last_traceback accordingly. | def print_exception(msg=None, exc_info=None, source_msg=None):
"""Print given exception (or current if None) with/without traceback and set sys.last_type, sys.last_value, sys.last_traceback accordingly."""
# is no exec_info() triple is given, use the exception beeing handled at the moment
if exc_info is No... |
Prints the error message of the given sys.exc_info() triple on stderr. | def display_error_message(exc_info, strip_xonsh_error_types=True):
"""
Prints the error message of the given sys.exc_info() triple on stderr.
"""
exc_type, exc_value, exc_traceback = exc_info
exception_only = traceback.format_exception_only(exc_type, exc_value)
if exc_type is XonshError and stri... |
Checks if a filepath is valid for writing. | def is_writable_file(filepath):
"""
Checks if a filepath is valid for writing.
"""
filepath = expand_path(filepath)
# convert to absolute path if needed
if not os.path.isabs(filepath):
filepath = os.path.abspath(filepath)
# cannot write to directories
if os.path.isdir(filepath):... |
Calculates the Levenshtein distance between a and b. | def levenshtein(a, b, max_dist=float("inf")):
"""Calculates the Levenshtein distance between a and b."""
n, m = len(a), len(b)
if abs(n - m) > max_dist:
return float("inf")
if n > m:
# Make sure n <= m, to use O(min(n,m)) space
a, b = b, a
n, m = m, n
current = range(... |
Returns a score (lower is better) for x based on how similar
it is to y. Used to rank suggestions. | def suggestion_sort_helper(x, y):
"""Returns a score (lower is better) for x based on how similar
it is to y. Used to rank suggestions."""
x = x.lower()
y = y.lower()
lendiff = len(x) + len(y)
inx = len([i for i in x if i not in y])
iny = len([i for i in y if i not in x])
return lendiff... |
Returns a string that is usable by the Windows cmd.exe.
The escaping is based on details here and empirical testing:
http://www.robvanderwoude.com/escapechars.php | def escape_windows_cmd_string(s):
"""Returns a string that is usable by the Windows cmd.exe.
The escaping is based on details here and empirical testing:
http://www.robvanderwoude.com/escapechars.php
"""
for c in '^()%!<>&|"':
s = s.replace(c, "^" + c)
return s |
Returns an argument quoted in such a way that that CommandLineToArgvW
on Windows will return the argument string unchanged.
This is the same thing Popen does when supplied with an list of arguments.
Arguments in a command line should be separated by spaces; this
function does not add these spaces. This implementation f... | def argvquote(arg, force=False):
"""Returns an argument quoted in such a way that that CommandLineToArgvW
on Windows will return the argument string unchanged.
This is the same thing Popen does when supplied with an list of arguments.
Arguments in a command line should be separated by spaces; this
f... |
Checks if we are on the main thread or not. | def on_main_thread():
"""Checks if we are on the main thread or not."""
return threading.current_thread() is threading.main_thread() |
Swaps a current variable name in a namespace for another value, and then
replaces it when the context is exited. | def swap(namespace, name, value, default=_DEFAULT_SENTINEL):
"""Swaps a current variable name in a namespace for another value, and then
replaces it when the context is exited.
"""
old = getattr(namespace, name, default)
setattr(namespace, name, value)
yield value
if old is default:
... |
Updates a dictionary (or other mapping) with values from another mapping,
and then restores the original mapping when the context is exited. | def swap_values(d, updates, default=_DEFAULT_SENTINEL):
"""Updates a dictionary (or other mapping) with values from another mapping,
and then restores the original mapping when the context is exited.
"""
old = {k: d.get(k, default) for k in updates}
d.update(updates)
yield
for k, v in old.it... |
This assumes that the object has a detype method, and calls that. | def detype(x):
"""This assumes that the object has a detype method, and calls that."""
return x.detype() |
Tests if something is an integer | def is_int(x):
"""Tests if something is an integer"""
return isinstance(x, int) |
Tests if something is a float | def is_float(x):
"""Tests if something is a float"""
return isinstance(x, float) |
Tests if something is a string | def is_string(x):
"""Tests if something is a string"""
return isinstance(x, str) |
Tests if something is a slice | def is_slice(x):
"""Tests if something is a slice"""
return isinstance(x, slice) |
Tests if something is callable | def is_callable(x):
"""Tests if something is callable"""
return callable(x) |
Tests if something is a string or callable | def is_string_or_callable(x):
"""Tests if something is a string or callable"""
return is_string(x) or is_callable(x) |
Tests if something is a class | def is_class(x):
"""Tests if something is a class"""
return isinstance(x, type) |
Returns True | def always_true(x):
"""Returns True"""
return True |
Returns False | def always_false(x):
"""Returns False"""
return False |
Returns None | def always_none(x):
"""Returns None"""
return None |
Returns a string if x is not a string, and x if it already is. If x is None, the empty string is returned. | def ensure_string(x):
"""Returns a string if x is not a string, and x if it already is. If x is None, the empty string is returned."""
return str(x) if x is not None else "" |
This tests if something is a path. | def is_path(x):
"""This tests if something is a path."""
return isinstance(x, pathlib.Path) |
This tests if something is an environment path, ie a list of strings. | def is_env_path(x):
"""This tests if something is an environment path, ie a list of strings."""
return isinstance(x, EnvPath) |
Converts a string to a path. | def str_to_path(x):
"""Converts a string to a path."""
if x is None or x == "":
return None
elif isinstance(x, str):
return pathlib.Path(x)
elif isinstance(x, pathlib.Path):
return x
elif isinstance(x, EnvPath) and len(x) == 1:
return pathlib.Path(x[0]) if x[0] else N... |
Converts a string to an environment path, ie a list of strings,
splitting on the OS separator. | def str_to_env_path(x):
"""Converts a string to an environment path, ie a list of strings,
splitting on the OS separator.
"""
# splitting will be done implicitly in EnvPath's __init__
return EnvPath(x) |
Converts a path to a string. | def path_to_str(x):
"""Converts a path to a string."""
return str(x) if x is not None else "" |
Converts an environment path to a string by joining on the OS
separator. | def env_path_to_str(x):
"""Converts an environment path to a string by joining on the OS
separator.
"""
return os.pathsep.join(x) |
Tests if something is a boolean. | def is_bool(x):
"""Tests if something is a boolean."""
return isinstance(x, bool) |
Tests if something is a boolean or None. | def is_bool_or_none(x):
"""Tests if something is a boolean or None."""
return (x is None) or isinstance(x, bool) |
Checks if x is a valid $XONSH_TRACEBACK_LOGFILE option. Returns False
if x is not a writable/creatable file or an empty string or None. | def is_logfile_opt(x):
"""
Checks if x is a valid $XONSH_TRACEBACK_LOGFILE option. Returns False
if x is not a writable/creatable file or an empty string or None.
"""
if x is None:
return True
if not isinstance(x, str):
return False
else:
return is_writable_file(x) o... |
Converts a $XONSH_TRACEBACK_LOGFILE option to either a str containing
the filepath if it is a writable file or None if the filepath is not
valid, informing the user on stderr about the invalid choice. | def to_logfile_opt(x):
"""Converts a $XONSH_TRACEBACK_LOGFILE option to either a str containing
the filepath if it is a writable file or None if the filepath is not
valid, informing the user on stderr about the invalid choice.
"""
if isinstance(x, os.PathLike): # type: ignore
x = str(x)
... |
Detypes a $XONSH_TRACEBACK_LOGFILE option. | def logfile_opt_to_str(x):
"""
Detypes a $XONSH_TRACEBACK_LOGFILE option.
"""
if x is None:
# None should not be detyped to 'None', as 'None' constitutes
# a perfectly valid filename and retyping it would introduce
# ambiguity. Detype to the empty string instead.
return "... |
Converts to a boolean in a semantically meaningful way. | def to_bool(x):
"""Converts to a boolean in a semantically meaningful way."""
if isinstance(x, bool):
return x
elif isinstance(x, str):
return False if x.lower() in _FALSES else True
else:
return bool(x) |
Converts to a boolean or none in a semantically meaningful way. | def to_bool_or_none(x):
"""Converts to a boolean or none in a semantically meaningful way."""
if x is None or isinstance(x, bool):
return x
elif isinstance(x, str):
low_x = x.lower()
if low_x == "none":
return None
else:
return False if x.lower() in _... |
No conversion, returns itself. | def to_itself(x):
"""No conversion, returns itself."""
return x |
Convert the given value to integer if possible. Otherwise return None | def to_int_or_none(x) -> tp.Optional[int]:
"""Convert the given value to integer if possible. Otherwise return None"""
if isinstance(x, str) and x.lower() == "none":
return None
else:
return int(x) |
Converts a bool to an empty string if False and the string '1' if
True. | def bool_to_str(x):
"""Converts a bool to an empty string if False and the string '1' if
True.
"""
return "1" if x else "" |
Converts a bool or None value to a string. | def bool_or_none_to_str(x):
"""Converts a bool or None value to a string."""
if x is None:
return "None"
else:
return "1" if x else "" |
Returns whether a value is a boolean or integer. | def is_bool_or_int(x):
"""Returns whether a value is a boolean or integer."""
return is_bool(x) or is_int(x) |
Converts a value to a boolean or an integer. | def to_bool_or_int(x):
"""Converts a value to a boolean or an integer."""
if isinstance(x, str):
return int(x) if x.isdigit() else to_bool(x)
elif is_int(x): # bools are ints too!
return x
else:
return bool(x) |
Converts a boolean or integer to a string. | def bool_or_int_to_str(x):
"""Converts a boolean or integer to a string."""
return bool_to_str(x) if is_bool(x) else str(x) |
Converts a value to an $SHLVL integer according to bash's behaviour (variables.c::adjust_shell_level). | def to_shlvl(x):
"""Converts a value to an $SHLVL integer according to bash's behaviour (variables.c::adjust_shell_level)."""
if x is None:
return 0
else:
x = str(x)
try:
return adjust_shlvl(max(0, int(x)), 0)
except ValueError:
return 0 |
Checks whether a variable is a proper $SHLVL integer. | def is_valid_shlvl(x):
"""Checks whether a variable is a proper $SHLVL integer."""
return isinstance(x, int) and to_shlvl(x) == x |
Adjusts an $SHLVL integer according to bash's behaviour (variables.c::adjust_shell_level). | def adjust_shlvl(old_lvl: int, change: int):
"""Adjusts an $SHLVL integer according to bash's behaviour (variables.c::adjust_shell_level)."""
new_level = old_lvl + change
if new_level < 0:
new_level = 0
elif new_level >= 1000:
new_level = 1
return new_level |
Try to convert an object into a slice, complain on failure | def ensure_slice(x):
"""Try to convert an object into a slice, complain on failure"""
if not x and x != 0:
return slice(None)
elif is_slice(x):
return x
try:
x = int(x)
if x != -1:
s = slice(x, x + 1)
else:
s = slice(-1, None, None)
ex... |
Yield from portions of an iterable.
Parameters
----------
it : iterable
slices : a slice or a list of slice objects | def get_portions(it, slices):
"""Yield from portions of an iterable.
Parameters
----------
it : iterable
slices : a slice or a list of slice objects
"""
if is_slice(slices):
slices = [slices]
if len(slices) == 1:
s = slices[0]
try:
yield from itertoo... |
Test if string x is a slice. If not a string return False. | def is_slice_as_str(x):
"""
Test if string x is a slice. If not a string return False.
"""
try:
x = x.strip("[]()")
m = SLICE_REG.fullmatch(x)
if m:
return True
except AttributeError:
pass
return False |
Test if string x is an integer. If not a string return False. | def is_int_as_str(x):
"""
Test if string x is an integer. If not a string return False.
"""
try:
return x.isdecimal()
except AttributeError:
return False |
Tests if something is a set of strings | def is_string_set(x):
"""Tests if something is a set of strings"""
return isinstance(x, cabc.Set) and all(isinstance(a, str) for a in x) |
Convert a comma-separated list of strings to a set of strings. | def csv_to_set(x):
"""Convert a comma-separated list of strings to a set of strings."""
if not x:
return set()
else:
return set(x.split(",")) |
Convert a set of strings to a comma-separated list of strings. | def set_to_csv(x):
"""Convert a set of strings to a comma-separated list of strings."""
return ",".join(x) |
Converts a os.pathsep separated string to a set of strings. | def pathsep_to_set(x):
"""Converts a os.pathsep separated string to a set of strings."""
if not x:
return set()
else:
return set(x.split(os.pathsep)) |
Converts a set to an os.pathsep separated string. The sort kwarg
specifies whether to sort the set prior to str conversion. | def set_to_pathsep(x, sort=False):
"""Converts a set to an os.pathsep separated string. The sort kwarg
specifies whether to sort the set prior to str conversion.
"""
if sort:
x = sorted(x)
return os.pathsep.join(x) |
Tests if something is a sequence of strings | def is_string_seq(x):
"""Tests if something is a sequence of strings"""
return isinstance(x, cabc.Sequence) and all(isinstance(a, str) for a in x) |
Tests if something is a sequence of strings, where the top-level
sequence is not a string itself. | def is_nonstring_seq_of_strings(x):
"""Tests if something is a sequence of strings, where the top-level
sequence is not a string itself.
"""
return (
isinstance(x, cabc.Sequence)
and not isinstance(x, str)
and all(isinstance(a, str) for a in x)
) |
Converts a os.pathsep separated string to a sequence of strings. | def pathsep_to_seq(x):
"""Converts a os.pathsep separated string to a sequence of strings."""
if not x:
return []
else:
return x.split(os.pathsep) |
Converts a sequence to an os.pathsep separated string. | def seq_to_pathsep(x):
"""Converts a sequence to an os.pathsep separated string."""
return os.pathsep.join(x) |
Converts a os.pathsep separated string to a sequence of
uppercase strings. | def pathsep_to_upper_seq(x):
"""Converts a os.pathsep separated string to a sequence of
uppercase strings.
"""
if not x:
return []
else:
return x.upper().split(os.pathsep) |
Converts a sequence to an uppercase os.pathsep separated string. | def seq_to_upper_pathsep(x):
"""Converts a sequence to an uppercase os.pathsep separated string."""
return os.pathsep.join(x).upper() |
Tests if an object is a sequence of bools. | def is_bool_seq(x):
"""Tests if an object is a sequence of bools."""
return isinstance(x, cabc.Sequence) and all(isinstance(y, bool) for y in x) |
Takes a comma-separated string and converts it into a list of bools. | def csv_to_bool_seq(x):
"""Takes a comma-separated string and converts it into a list of bools."""
return [to_bool(y) for y in csv_to_set(x)] |
Converts a sequence of bools to a comma-separated string. | def bool_seq_to_csv(x):
"""Converts a sequence of bools to a comma-separated string."""
return ",".join(map(str, x)) |
Setter function for $PROMPT_TOOLKIT_COLOR_DEPTH. Also
updates os.environ so prompt toolkit can pickup the value. | def ptk2_color_depth_setter(x):
"""Setter function for $PROMPT_TOOLKIT_COLOR_DEPTH. Also
updates os.environ so prompt toolkit can pickup the value.
"""
x = str(x)
if x in {
"DEPTH_1_BIT",
"MONOCHROME",
"DEPTH_4_BIT",
"ANSI_COLORS_ONLY",
"DEPTH_8_BIT",
... |
Enumerated values of ``$COMPLETIONS_DISPLAY`` | def is_completions_display_value(x):
"""Enumerated values of ``$COMPLETIONS_DISPLAY``"""
return x in {"none", "single", "multi"} |
Convert user input to value of ``$COMPLETIONS_DISPLAY`` | def to_completions_display_value(x):
"""Convert user input to value of ``$COMPLETIONS_DISPLAY``"""
x = str(x).lower()
if x in {"none", "false"}:
x = "none"
elif x in {"multi", "true"}:
x = "multi"
elif x in {"single", "readline"}:
pass
else:
msg = f'"{x}" is... |
Enumerated values of $COMPLETION_MODE | def is_completion_mode(x):
"""Enumerated values of $COMPLETION_MODE"""
return x in CANONIC_COMPLETION_MODES |
Convert user input to value of $COMPLETION_MODE | def to_completion_mode(x):
"""Convert user input to value of $COMPLETION_MODE"""
y = str(x).casefold().replace("_", "-")
y = (
"default"
if y in ("", "d", "xonsh", "none", "def")
else "menu-complete"
if y in ("m", "menu", "menu-completion")
else y
)
if y no... |
Converts a string to a dictionary | def to_dict(x):
"""Converts a string to a dictionary"""
if isinstance(x, dict):
return x
try:
x = ast.literal_eval(x)
except (ValueError, SyntaxError):
msg = f'"{x}" can not be converted to Python dictionary.'
warnings.warn(msg, RuntimeWarning, stacklevel=2)
x = d... |
Converts a string to Token:str dictionary | def to_tok_color_dict(x):
"""Converts a string to Token:str dictionary"""
if is_tok_color_dict(x):
return x
x = to_dict(x)
if not is_tok_color_dict(x):
msg = f'"{x}" can not be converted to Token:str dictionary.'
warnings.warn(msg, RuntimeWarning, stacklevel=2)
x = dict()... |
Converts a dictionary to a string | def dict_to_str(x):
"""Converts a dictionary to a string"""
if not x or len(x) == 0:
return ""
return str(x) |
Tests if something is a proper history value, units tuple. | def is_history_tuple(x):
"""Tests if something is a proper history value, units tuple."""
if (
isinstance(x, cabc.Sequence)
and len(x) == 2
and isinstance(x[0], (int, float))
and x[1].lower() in CANON_HISTORY_UNITS
):
return True
return False |
Tests if something is a valid regular expression. | def is_regex(x):
"""Tests if something is a valid regular expression."""
try:
re.compile(x)
return True
except re.error:
pass
return False |
Tests if something is a valid history backend. | def is_history_backend(x):
"""Tests if something is a valid history backend."""
return is_string(x) or is_class(x) or isinstance(x, object) |
Determine if the input is a valid input for the DYNAMIC_CWD_WIDTH
environment variable. | def is_dynamic_cwd_width(x):
"""Determine if the input is a valid input for the DYNAMIC_CWD_WIDTH
environment variable.
"""
return (
isinstance(x, tuple)
and len(x) == 2
and isinstance(x[0], float)
and x[1] in set("c%")
) |
Convert to a canonical cwd_width tuple. | def to_dynamic_cwd_tuple(x):
"""Convert to a canonical cwd_width tuple."""
unit = "c"
if isinstance(x, str):
if x[-1] == "%":
x = x[:-1]
unit = "%"
else:
unit = "c"
return (float(x), unit)
else:
return (float(x[0]), x[1]) |
Convert a canonical cwd_width tuple to a string. | def dynamic_cwd_tuple_to_str(x):
"""Convert a canonical cwd_width tuple to a string."""
if x[1] == "%":
return str(x[0]) + "%"
else:
return str(x[0]) |
Converts to a canonical history tuple. | def to_history_tuple(x):
"""Converts to a canonical history tuple."""
if not isinstance(x, (cabc.Sequence, float, int)):
raise ValueError("history size must be given as a sequence or number")
if isinstance(x, str):
m = RE_HISTORY_TUPLE.match(x.strip().lower())
return to_history_tupl... |
Converts a valid history tuple to a canonical string. | def history_tuple_to_str(x):
"""Converts a valid history tuple to a canonical string."""
return "{} {}".format(*x) |
Yeilds all permutations, not just those of a specified length | def all_permutations(iterable):
"""Yeilds all permutations, not just those of a specified length"""
for r in range(1, len(iterable) + 1):
yield from itertools.permutations(iterable, r=r) |
Formats strings that may contain colors. This simply dispatches to the
shell instances method of the same name. The results of this function should
be directly usable by print_color(). | def format_color(string, **kwargs):
"""Formats strings that may contain colors. This simply dispatches to the
shell instances method of the same name. The results of this function should
be directly usable by print_color().
"""
if hasattr(xsh.shell, "shell"):
return xsh.shell.shell.format_co... |
Prints a string that may contain colors. This dispatched to the shell
method of the same name. Colors will be formatted if they have not already
been. | def print_color(string, **kwargs):
"""Prints a string that may contain colors. This dispatched to the shell
method of the same name. Colors will be formatted if they have not already
been.
"""
if hasattr(xsh.shell, "shell"):
xsh.shell.shell.print_color(string, **kwargs)
else:
# ... |
Returns an iterable of all available style names. | def color_style_names():
"""Returns an iterable of all available style names."""
return xsh.shell.shell.color_style_names() |
Returns the current color map. | def color_style():
"""Returns the current color map."""
return xsh.shell.shell.color_style() |
Register custom style.
Parameters
----------
name : str
Style name.
styles : dict
Token -> style mapping.
highlight_color : str
Hightlight color.
background_color : str
Background color.
base : str, optional
Base style to use as default.
Returns
-------
style : The style object created, None if no... | def register_custom_style(
name, styles, highlight_color=None, background_color=None, base="default"
):
"""Register custom style.
Parameters
----------
name : str
Style name.
styles : dict
Token -> style mapping.
highlight_color : str
Hightlight color.
background... |
yields tokens attr, and index from a stylemap | def _token_attr_from_stylemap(stylemap):
"""yields tokens attr, and index from a stylemap"""
import prompt_toolkit as ptk
if xsh.shell.shell_type == "prompt_toolkit1":
style = ptk.styles.style_from_dict(stylemap)
for token in stylemap:
yield token, style.token_to_attrs[token]
... |
Returns the prompt_toolkit win32 ColorLookupTable | def _get_color_lookup_table():
"""Returns the prompt_toolkit win32 ColorLookupTable"""
if xsh.shell.shell_type == "prompt_toolkit1":
from prompt_toolkit.terminal.win32_output import ColorLookupTable
else:
from prompt_toolkit.output.win32 import ColorLookupTable
return ColorLookupTable() |
Generates the color and windows color index for a style | def _get_color_indexes(style_map):
"""Generates the color and windows color index for a style"""
table = _get_color_lookup_table()
for token, attr in _token_attr_from_stylemap(style_map):
if attr.color:
index = table.lookup_fg_color(attr.color)
try:
rgb = (
... |
Map dark ansi colors to lighter version. | def _win_bold_color_map():
"""Map dark ansi colors to lighter version."""
return {
"ansiblack": "ansibrightblack",
"ansiblue": "ansibrightblue",
"ansigreen": "ansibrightgreen",
"ansicyan": "ansibrightcyan",
"ansired": "ansibrightred",
"ansimagenta": "ansibrightmag... |
Replace all ansi colors with hardcoded colors to avoid unreadable defaults
in conhost.exe | def hardcode_colors_for_win10(style_map):
"""Replace all ansi colors with hardcoded colors to avoid unreadable defaults
in conhost.exe
"""
modified_style = {}
if not xsh.env["PROMPT_TOOLKIT_COLOR_DEPTH"]:
xsh.env["PROMPT_TOOLKIT_COLOR_DEPTH"] = "DEPTH_24_BIT"
# Replace all ansi colors wi... |
Converts ansicolor names in a stylemap to old PTK1 color names | def ansicolors_to_ptk1_names(stylemap):
"""Converts ansicolor names in a stylemap to old PTK1 color names"""
if pygments_version_info() and pygments_version_info() >= (2, 4, 0):
return stylemap
modified_stylemap = {}
for token, style_str in stylemap.items():
for color, ptk1_color in ANS... |
Returns a modified style to where colors that maps to dark
colors are replaced with brighter versions. | def intensify_colors_for_cmd_exe(style_map):
"""Returns a modified style to where colors that maps to dark
colors are replaced with brighter versions.
"""
modified_style = {}
replace_colors = {
1: "ansibrightcyan", # subst blue with bright cyan
2: "ansibrightgreen", # subst green w... |
Resets the style when setting the INTENSIFY_COLORS_ON_WIN
environment variable. | def intensify_colors_on_win_setter(enable):
"""Resets the style when setting the INTENSIFY_COLORS_ON_WIN
environment variable.
"""
enable = to_bool(enable)
if xsh.shell is not None and hasattr(xsh.shell.shell.styler, "style_name"):
delattr(xsh.shell.shell.styler, "style_name")
return ena... |
Formats a template prefix/postfix string for a standard buffer.
Returns a string suitable for prepending or appending. | def format_std_prepost(template, env=None):
"""Formats a template prefix/postfix string for a standard buffer.
Returns a string suitable for prepending or appending.
"""
if not template:
return ""
env = xsh.env if env is None else env
invis = "\001\002"
if xsh.shell is None:
... |
Gets rid of single quotes, double quotes, single triple quotes, and
single double quotes from a string, if present front and back of a string.
Otherwiswe, does nothing. | def strip_simple_quotes(s):
"""Gets rid of single quotes, double quotes, single triple quotes, and
single double quotes from a string, if present front and back of a string.
Otherwiswe, does nothing.
"""
starts_single = s.startswith("'")
starts_double = s.startswith('"')
if not starts_single... |
Returns the starting index (inclusive), ending index (exclusive), and
starting quote string of the most recent Python string found in the input.
check_for_partial_string(x) -> (startix, endix, quote)
Parameters
----------
x : str
The string to be checked (representing a line of terminal input)
Returns
-------
st... | def check_for_partial_string(x):
"""Returns the starting index (inclusive), ending index (exclusive), and
starting quote string of the most recent Python string found in the input.
check_for_partial_string(x) -> (startix, endix, quote)
Parameters
----------
x : str
The string to be che... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.