xonsh.tools

Shared utility functions and helpers for the xonsh shell.

This module is the grab-bag of small, broadly-useful helpers used across the xonsh codebase — anything that doesn’t naturally fit into one of the more focused subsystems (parser, execer, environ, procs, completers, prompt, history) ends up here. Downstream code — including xontribs — can import from xonsh.tools as a stable public API.

The module groups its helpers roughly by topic:

• Exceptions and error handling — XonshError, XonshCalledProcessError, print_exception(), format_std_prepost().

• Type conversion and validation — the is_* / to_* / *_or_default family used by Env to validate and normalise environment variables (bools, ints, paths, lists, dicts, history units, log levels, color schemes, etc.).

• Path and file utilities — expand_path(), expanduser_abs_path(), is_writable_file(), executables_in(), iglobpath(), cross-platform path normalisation helpers.

• String, token and AST helpers — quoting/escaping, subexpr_from_unbalanced(), find_next_break(), regex constants for string prefixes and history tuples, the FlexibleFormatter for prompt/format-string rendering.

• Subprocess and signal helpers — on_main_thread(), suggest_commands(), signal-safe context managers, PTY helpers.

• Terminal and color handling — ANSI/ANSI256/RGB color parsing, PTK_NEW_OLD_COLOR_MAP, WIN10_COLOR_MAP and related lookup tables, print_color() / format_color().

• Collections and functional helpers — LazyObject, LazyDict, DefaultNotGivenType, always_true, always_false, all_permutations, small functional shims.

• Platform and environment probes — Windows/POSIX conditionals, locale detection, terminal-size queries, shell-level (SHLVL) adjustment.

A handful of the oldest helpers (decode, encode, cast_unicode, safe_hasattr, indent) were originally forked from the IPython project and retain their upstream copyrights:

• Copyright (c) 2008-2014, IPython Development Team

• Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>

• Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>

• Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>

exception xonsh.tools.XonshCalledProcessError(returncode, command, output=None, stderr=None, completed_command=None)

Raised when there’s an error with a called process

Inherits from XonshError and subprocess.CalledProcessError, catching either will also catch this error.

Raised after iterating over stdout of a captured command, if the returncode of the command is nonzero.

add_note(object, /)

Exception.add_note(note) – add a note to the exception

with_traceback(object, /)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

property stdout

Alias for output attribute, to match stderr

exception xonsh.tools.XonshError

add_note(object, /)

Exception.add_note(note) – add a note to the exception

with_traceback(object, /)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

class xonsh.tools.DefaultNotGivenType

Singleton for representing when no default value is given.

class xonsh.tools.FlexibleFormatter

Support nested fields inside conditional formatters

e.g. template {user:| {RED}{}{RESET}} will become | {RED}user{RESET} when user=user.

check_unused_args(used_args, args, kwargs)

convert_field(value, conversion)

format(format_string, /, *args, **kwargs)

format_field(value, format_spec)

get_field(field_name, args, kwargs)

get_value(key: int | str, args, kwargs) → str

parse(format_string)

vformat(format_string, args, kwargs)

class xonsh.tools.redirect_stderr(new_target)

Context manager for temporarily redirecting stderr to another file.

class xonsh.tools.redirect_stdout(new_target)

Context manager for temporarily redirecting stdout to another file:

# How to send help() to stderr
with redirect_stdout(sys.stderr):
    help(dir)

# How to write help() to a file
with open('help.txt', 'w') as f:
    with redirect_stdout(f):
        help(pow)

Mostly for backwards compatibility.

xonsh.tools.abs_path_to_str(x)

Converts an absolute path to a string.

xonsh.tools.adjust_shlvl(old_lvl: int, change: int)

Adjusts an $SHLVL integer according to bash’s behaviour (variables.c::adjust_shell_level).

xonsh.tools.all_permutations(iterable)

Yeilds all permutations, not just those of a specified length

xonsh.tools.always_false(x)

Returns False

xonsh.tools.always_none(x)

Returns None

xonsh.tools.always_true(x)

Returns True

xonsh.tools.ansicolors_to_ptk1_names(stylemap)

Converts ansicolor names in a stylemap to old PTK1 color names

xonsh.tools.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 function does not add these spaces. This implementation follows the suggestions outlined here: https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/

xonsh.tools.backup_file(fname)

Moves an existing file to a new name that has the current time right before the extension.

xonsh.tools.balanced_parens(line, mincol=0, maxcol=None, lexer=None)

Determines if parentheses are balanced in an expression.

xonsh.tools.bool_or_int_to_str(x)

Converts a boolean or integer to a string.

xonsh.tools.bool_or_none_to_str(x)

Converts a bool or None value to a string.

xonsh.tools.bool_seq_to_csv(x)

Converts a sequence of bools to a comma-separated string.

xonsh.tools.bool_to_str(x)

Converts a bool to an empty string if False and the string ‘1’ if True.

xonsh.tools.capturable(f)

Decorator that specifies that a callable alias should be run with capturing. This is the default behavior.

xonsh.tools.carriage_return()

Writes a carriage return to stdout, and nothing else.

xonsh.tools.cast_unicode(s, encoding=None)

xonsh.tools.chdir(adir, mkdir=False, expanduser=True)

Context manager for switching current directory to another. Note! You can use with p'/path'.cd(): $[ls] to achieve the same.

xonsh.tools.check_bad_str_token(tok)

Checks if a token is a bad string.

xonsh.tools.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:

xstr

The string to be checked (representing a line of terminal input)

Returns:

startixint (or None)

The index where the most recent Python string found started (inclusive), or None if no strings exist in the input

endixint (or None)

The index where the most recent Python string found ended (exclusive), or None if no strings exist in the input OR if the input ended in the middle of a Python string

quotestr (or None)

A string containing the quote used to start the string (e.g., b”, “, ‘’’), or None if no string was found.

` are ignored)

and # inside string literals (which are part of the string, not a comment). Known limitations / cases NOT covered:

• PEP 701 f-strings with nested quotes of the same kind, e.g. f"{ "hi" }" (Python 3.12+). The scanner sees this as two separate strings (f"{ " and " }") instead of one f-string. Quotes of a different kind nested inside f-string expressions work fine.

• Brace-balancing inside f-string expressions in general — anything that relies on knowing where { ... } starts and ends is out of scope.

• Comment characters that are not # (xonsh has no others, but other shells’ line-comment markers are not recognized).

• Line continuation inside # comments — irrelevant since Python comments always end at the next newline regardless of any trailing backslash.

• Arbitrary Python tokenization errors: malformed input (e.g. four double-quotes in a row) may be reported as a partial triple-quoted string rather than a syntax error; downstream code is responsible for validating syntax.

Improvements are welcome!

xonsh.tools.check_quotes(s)

Checks a string to make sure that if it starts with quotes, it also ends with quotes.

xonsh.tools.color_style()

Returns the current color map.

xonsh.tools.color_style_names()

Returns an iterable of all available style names.

xonsh.tools.columnize(elems, width=80, newline='\n')

Takes an iterable of strings and returns a list of lines with the elements placed in columns. Each line will be at most width columns. The newline character will be appended to the end of each line.

xonsh.tools.command_not_found(cmd, env)

Uses various mechanism to suggest packages for a command that cannot currently be found.

xonsh.tools.conda_suggest_command_not_found(cmd, env)

Uses conda-suggest to suggest packages for a command that cannot currently be found.

xonsh.tools.csv_to_bool_seq(x)

Takes a comma-separated string and converts it into a list of bools.

xonsh.tools.csv_to_set(x)

Convert a comma-separated list of strings to a set of strings.

xonsh.tools.debian_command_not_found(cmd)

Uses the debian/ubuntu command-not-found utility to suggest packages for a command that cannot currently be found.

xonsh.tools.decode(s, encoding=None)

xonsh.tools.decode_bytes(b)

Tries to decode the bytes using XONSH_ENCODING if available, otherwise using sys.getdefaultencoding().

xonsh.tools.deprecated(deprecated_in=None, removed_in=None)

Parametrized decorator that deprecates a function in a graceful manner.

Updates the decorated function’s docstring to mention the version that deprecation occurred in and the version it will be removed in if both of these values are passed.

When removed_in is not a release equal to or less than the current release, call warnings.warn with details, while raising DeprecationWarning.

When removed_in is a release equal to or less than the current release, raise an AssertionError.

Parameters:

deprecated_instr

The version number that deprecated this function.

removed_instr

The version number that this function will be removed in.

xonsh.tools.describe_waitpid_status(status)

Describes pid, status = os.waitpid(pid, opt) status.

xonsh.tools.detype(x)

This assumes that the object has a detype method, and calls that.

xonsh.tools.dict_to_str(x)

Converts a dictionary to a string

xonsh.tools.display_colored_error_message(exc_info, strip_xonsh_error_types=True, limit=None)

xonsh.tools.display_error_message(exc_info, strip_xonsh_error_types=True)

Prints the error message of the given sys.exc_info() triple on stderr.

xonsh.tools.dynamic_cwd_tuple_to_str(x)

Convert a canonical cwd_width tuple to a string.

xonsh.tools.encode(u, encoding=None)

xonsh.tools.ends_with_colon_token(line, lexer=None)

Determines whether a line ends with a colon token, ignoring comments.

xonsh.tools.endswith_newline(s: str)

Force one new line character end to string.

xonsh.tools.ensure_slice(x)

Try to convert an object into a slice, complain on failure

xonsh.tools.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.

xonsh.tools.ensure_timestamp(t, datetime_format=None)

xonsh.tools.env_path_to_str(x)

Converts an environment path to a string by joining on the OS separator.

xonsh.tools.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

xonsh.tools.expand_case_matching(s)

Expands a string to a case insensitive globable string.

xonsh.tools.expand_path(s, expand_user=True)

Takes a string path and expands ~ to home if expand_user is set and environment vars if EXPAND_ENV_VARS is set.

xonsh.tools.expanduser_abs_path(inp)

Provides user expanded absolute path

xonsh.tools.expandvars(path)

Expand shell variables of the forms $var, ${var} and %var%. Unknown variables are left unchanged.

xonsh.tools.fallback(cond, backup)

Decorator for returning the object if cond is true and a backup if cond is false.

xonsh.tools.find_next_break(line, mincol=0, lexer=None)

Returns the column number of the next logical break in subproc mode. This function may be useful in finding the maxcol argument of subproc_toks().

xonsh.tools.findfirst(s, substrs)

Finds whichever of the given substrings occurs first in the given string and returns that substring, or returns None if no such strings occur.

xonsh.tools.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().

xonsh.tools.format_datetime(dt)

Format datetime object to string base on $XONSH_DATETIME_FORMAT Env.

xonsh.tools.format_std_prepost(template, env=None)

Formats a template prefix/postfix string for a standard buffer. Returns a string suitable for prepending or appending.

xonsh.tools.get_line_continuation()

The line continuation characters used in subproc mode. In interactive mode on Windows the backslash must be preceded by a space. This is because paths on Windows may end in a backslash.

xonsh.tools.get_logical_line(lines, idx)

Returns a single logical line (i.e. one without line continuations) from a list of lines. This line should begin at index idx. This also returns the number of physical lines the logical line spans. The lines should not contain newlines

xonsh.tools.get_portions(it, slices)

Yield from portions of an iterable.

Parameters:

ititerable

slicesa slice or a list of slice objects

xonsh.tools.get_sep()

Returns the appropriate filepath separator char depending on OS and xonsh options set

xonsh.tools.get_signal_name(signum)

Return a signal name by the signal number.

xonsh.tools.globpath(s, ignore_case=False, return_empty=False, sort_result=None, include_dotfiles=None)

Simple wrapper around glob that also expands home and env vars.

xonsh.tools.hardcode_colors_for_win10(style_map)

Replace all ansi colors with hardcoded colors to avoid unreadable defaults in conhost.exe

xonsh.tools.history_tuple_to_str(x)

Converts a valid history tuple to a canonical string.

xonsh.tools.iglobpath(s, ignore_case=False, sort_result=None, include_dotfiles=None)

Simple wrapper around iglob that also expands home and env vars.

xonsh.tools.indent(instr, nspaces=4, ntabs=0, flatten=False)

Indent a string a given number of spaces or tabstops.

indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.

Parameters:

instrbasestring

The string to be indented.

nspacesint (default: 4)

The number of spaces to be indented.

ntabsint (default: 0)

The number of tabs to be indented.

flattenbool (default: False)

Whether to scrub existing indentation. If True, all lines will be aligned to the same indentation. If False, existing indentation will be strictly increased.

Returns:

outstrstring indented by ntabs and nspaces.

xonsh.tools.intensify_colors_for_cmd_exe(style_map)

Returns a modified style to where colors that maps to dark colors are replaced with brighter versions.

xonsh.tools.intensify_colors_on_win_setter(enable)

Resets the style when setting the INTENSIFY_COLORS_ON_WIN environment variable.

xonsh.tools.is_balanced(expr, ltok, rtok)

Determines whether an expression has unbalanced opening and closing tokens.

xonsh.tools.is_bool(x)

Tests if something is a boolean.

xonsh.tools.is_bool_or_int(x)

Returns whether a value is a boolean or integer.

xonsh.tools.is_bool_or_none(x)

Tests if something is a boolean or None.

xonsh.tools.is_bool_seq(x)

Tests if an object is a sequence of bools.

xonsh.tools.is_callable(x)

Tests if something is callable

xonsh.tools.is_class(x)

Tests if something is a class

xonsh.tools.is_completion_mode(x)

Enumerated values of $COMPLETION_MODE

xonsh.tools.is_completions_display_value(x)

Enumerated values of $COMPLETIONS_DISPLAY

xonsh.tools.is_dynamic_cwd_width(x)

Determine if the input is a valid input for the DYNAMIC_CWD_WIDTH environment variable.

xonsh.tools.is_float(x)

Tests if something is a float

xonsh.tools.is_history_backend(x)

Tests if something is a valid history backend.

xonsh.tools.is_history_tuple(x)

Tests if something is a proper history value, units tuple.

xonsh.tools.is_int(x)

Tests if something is an integer

xonsh.tools.is_int_as_str(x)

Test if string x is an integer. If not a string return False.

xonsh.tools.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.

xonsh.tools.is_nonstring_seq_of_strings(x)

Tests if something is a sequence of strings, where the top-level sequence is not a string itself.

xonsh.tools.is_path(x)

This tests if something is a path.

xonsh.tools.is_regex(x)

Tests if something is a valid regular expression.

xonsh.tools.is_slice(x)

Tests if something is a slice

xonsh.tools.is_slice_as_str(x)

Test if string x is a slice. If not a string return False.

xonsh.tools.is_string(x)

Tests if something is a string

xonsh.tools.is_string_or_callable(x)

Tests if something is a string or callable

xonsh.tools.is_string_seq(x)

Tests if something is a sequence of strings

xonsh.tools.is_string_set(x)

Tests if something is a set of strings

xonsh.tools.is_superuser()

xonsh.tools.is_tok_color_dict(x)

xonsh.tools.is_valid_shlvl(x)

Checks whether a variable is a proper $SHLVL integer.

xonsh.tools.is_writable_file(filepath)

Checks if a filepath is valid for writing.

xonsh.tools.levenshtein(a, b, max_dist=inf)

Calculates the Levenshtein distance between a and b.

xonsh.tools.logfile_opt_to_str(x)

Detypes a $XONSH_TRACEBACK_LOGFILE option.

xonsh.tools.normabspath(p)

Returns as normalized absolute path, namely, normcase(abspath(p))

xonsh.tools.on_main_thread()

Checks if we are on the main thread or not.

xonsh.tools.path_to_str(x)

Converts a path to a string.

xonsh.tools.pathsep_to_seq(x)

Converts a os.pathsep separated string to a sequence of strings.

xonsh.tools.pathsep_to_set(x)

Converts a os.pathsep separated string to a set of strings.

xonsh.tools.pathsep_to_upper_seq(x)

Converts a os.pathsep separated string to a sequence of uppercase strings.

xonsh.tools.print_above_prompt(msg)

Print a message above the active prompt when using prompt_toolkit, otherwise fall back to stderr. Safe to call from background threads.

xonsh.tools.print_color(string, color=None, **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.

xonsh.tools.print_exception(msg=None, exc_info=None, source_msg=None)

Print given exception (or current if None) with/without traceback and set sys.last_exc accordingly.

xonsh.tools.print_warning(msg)

Print warnings with/without traceback.

xonsh.tools.ptk2_color_depth_setter(x)

Setter function for $PROMPT_TOOLKIT_COLOR_DEPTH. Also updates os.environ so prompt toolkit can pickup the value.

xonsh.tools.ptk_cursor_shape_vi_modal()

xonsh.tools.qualified_name(obj) → str

Return fully qualified class name, e.g. ‘xonsh.environ.VarPattern’.

xonsh.tools.register_custom_style(name, styles, highlight_color=None, background_color=None, base='default')

Register custom style.

Parameters:

namestr

Style name.

stylesdict

Token -> style mapping.

highlight_colorstr

Hightlight color.

background_colorstr

Background color.

basestr, optional

Base style to use as default.

Returns:

styleThe style object created, None if not succeeded

xonsh.tools.replace_logical_line(lines, logical, idx, n)

Replaces lines at idx that may end in line continuation with a logical line that spans n lines.

xonsh.tools.safe_hasattr(obj, attr)

In recent versions of Python, hasattr() only catches AttributeError. This catches all errors.

xonsh.tools.seq_to_pathsep(x)

Converts a sequence to an os.pathsep separated string.

xonsh.tools.seq_to_upper_pathsep(x)

Converts a sequence to an uppercase os.pathsep separated string.

xonsh.tools.set_to_csv(x)

Convert a set of strings to a comma-separated list of strings.

xonsh.tools.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.

xonsh.tools.simple_random_choice(lst)

Returns random element from the list with length less than 1 million elements.

xonsh.tools.starting_whitespace(s)

Returns the whitespace at the start of a string

xonsh.tools.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.

xonsh.tools.subexpr_before_unbalanced(expr, ltok, rtok)

Obtains the expression prior to last unbalanced left token.

xonsh.tools.subexpr_from_unbalanced(expr, ltok, rtok)

Attempts to pull out a valid subexpression for unbalanced grouping, based on opening tokens, eg. ‘(’, and closing tokens, eg. ‘)’. This does not do full tokenization, but should be good enough for tab completion.

xonsh.tools.subproc_toks(line, mincol=-1, maxcol=None, lexer=None, returnline=False, greedy=False)

Encapsulates tokens in a source code line in a uncaptured subprocess ![] starting at a minimum column. If there are no tokens (ie in a comment line) this returns None. If greedy is True, it will encapsulate normal parentheses. Greedy is False by default.

xonsh.tools.suggest_commands(cmd, env)

Suggests alternative commands given an environment and aliases.

xonsh.tools.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.

xonsh.tools.swap(namespace, name, value, default=<object object>)

Swaps a current variable name in a namespace for another value, and then replaces it when the context is exited.

xonsh.tools.swap_values(d, updates, default=<object object>)

Updates a dictionary (or other mapping) with values from another mapping, and then restores the original mapping when the context is exited.

xonsh.tools.threadable(f)

Decorator that specifies that a callable alias should be run in a background thread. This is the default behavior.

xonsh.tools.to_bool(x)

Converts to a boolean in a semantically meaningful way.

xonsh.tools.to_bool_or_break(x)

xonsh.tools.to_bool_or_int(x)

Converts a value to a boolean or an integer.

xonsh.tools.to_bool_or_none(x)

Converts to a boolean or none in a semantically meaningful way.

xonsh.tools.to_completion_mode(x)

Convert user input to value of $COMPLETION_MODE

xonsh.tools.to_completions_display_value(x)

Convert user input to value of $COMPLETIONS_DISPLAY

xonsh.tools.to_dict(x)

Converts a string to a dictionary

xonsh.tools.to_dynamic_cwd_tuple(x)

Convert to a canonical cwd_width tuple.

xonsh.tools.to_history_tuple(x)

Converts to a canonical history tuple.

xonsh.tools.to_int_or_none(x) → int | None

Convert the given value to integer if possible. Otherwise return None

xonsh.tools.to_itself(x)

No conversion, returns itself.

xonsh.tools.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.

xonsh.tools.to_ptk_cursor_shape(x)

xonsh.tools.to_ptk_cursor_shape_display_value(x)

xonsh.tools.to_repr_pretty_(inst, p, cycle)

xonsh.tools.to_shlvl(x)

Converts a value to an $SHLVL integer according to bash’s behaviour (variables.c::adjust_shell_level).

xonsh.tools.to_tok_color_dict(x)

Converts a string to Token:str dictionary

xonsh.tools.uncapturable(f)

Decorator that specifies that a callable alias should not be run with any capturing. This is often needed if the alias call interactive subprocess, like pagers and text editors.

xonsh.tools.unquote(s: str, chars='\'"')

Strip paired quotes from string once.

xonsh.tools.unthreadable(f)

Decorator that specifies that a callable alias should be run only on the main thread process. This is often needed for debuggers and profilers.

xonsh.tools.HISTORY_UNITS = {'': ('commands', <class 'int'>), 'b': ('b', <class 'int'>), 'byte': ('b', <class 'int'>), 'bytes': ('b', <class 'int'>), 'c': ('commands', <class 'int'>), 'cmd': ('commands', <class 'int'>), 'cmds': ('commands', <class 'int'>), 'command': ('commands', <class 'int'>), 'commands': ('commands', <class 'int'>), 'd': ('s', <function <lambda>>), 'day': ('s', <function <lambda>>), 'days': ('s', <function <lambda>>), 'f': ('files', <class 'int'>), 'files': ('files', <class 'int'>), 'gb': ('b', <function <lambda>>), 'gig': ('b', <function <lambda>>), 'gigabyte': ('b', <function <lambda>>), 'gigabytes': ('b', <function <lambda>>), 'gigs': ('b', <function <lambda>>), 'h': ('s', <function <lambda>>), 'hour': ('s', <function <lambda>>), 'hours': ('s', <function <lambda>>), 'hr': ('s', <function <lambda>>), 'kb': ('b', <function <lambda>>), 'kilobyte': ('b', <function <lambda>>), 'kilobytes': ('b', <function <lambda>>), 'm': ('s', <function <lambda>>), 'mb': ('b', <function <lambda>>), 'meg': ('b', <function <lambda>>), 'megabyte': ('b', <function <lambda>>), 'megabytes': ('b', <function <lambda>>), 'megs': ('b', <function <lambda>>), 'min': ('s', <function <lambda>>), 'mins': ('s', <function <lambda>>), 'mon': ('s', <function <lambda>>), 'month': ('s', <function <lambda>>), 'months': ('s', <function <lambda>>), 's': ('s', <class 'float'>), 'sec': ('s', <class 'float'>), 'second': ('s', <class 'float'>), 'seconds': ('s', <class 'float'>), 'tb': ('b', <function <lambda>>), 'terabyte': ('b', <function <lambda>>), 'terabytes': ('b', <function <lambda>>), 'y': ('s', <function <lambda>>), 'year': ('s', <function <lambda>>), 'years': ('s', <function <lambda>>), 'yr': ('s', <function <lambda>>), 'yrs': ('s', <function <lambda>>)}

Maps lowercase unit names to canonical name and conversion utilities.

xonsh.tools.RE_BEGIN_STRING = re.compile('([bBprRuUf]*("""|\'\'\'|"|\'))')

Regular expression matching the start of a string, including quotes and leading characters (r, b, or u)

xonsh.tools.RE_STRING_CONT = <xonsh.lib.lazyasd.LazyDict object>

Dictionary mapping starting quote sequences to regular expressions that match the contents of a string beginning with those quotes (not including the terminating quotes)

xonsh.tools.RE_STRING_START = re.compile('[bBprRuUf]*')

Regular expression matching the characters before the quotes when starting a string (r, b, or u, case insensitive)