Data Structures
class	Flags

class	NestedDict

class	Output

class	TOMLDecodeError

Functions
dict[str, Any]	load (BinaryIO __fp, *ParseFloat parse_float=float)

dict[str, Any]	loads (str __s, *ParseFloat parse_float=float)

Pos	skip_chars (str src, Pos pos, Iterable[str] chars)

Pos	skip_until (str src, Pos pos, str expect, *frozenset[str] error_on, bool error_on_eof)

Pos	skip_comment (str src, Pos pos)

Pos	skip_comments_and_array_ws (str src, Pos pos)

tuple[Pos, Key]	create_dict_rule (str src, Pos pos, Output out)

tuple[Pos, Key]	create_list_rule (str src, Pos pos, Output out)

Pos	key_value_rule (str src, Pos pos, Output out, Key header, ParseFloat parse_float)

tuple[Pos, Key, Any]	parse_key_value_pair (str src, Pos pos, ParseFloat parse_float)

tuple[Pos, Key]	parse_key (str src, Pos pos)

tuple[Pos, str]	parse_key_part (str src, Pos pos)

tuple[Pos, str]	parse_one_line_basic_str (str src, Pos pos)

tuple[Pos, list]	parse_array (str src, Pos pos, ParseFloat parse_float)

tuple[Pos, dict]	parse_inline_table (str src, Pos pos, ParseFloat parse_float)

tuple[Pos, str]	parse_basic_str_escape (str src, Pos pos, *bool multiline=False)

tuple[Pos, str]	parse_basic_str_escape_multiline (str src, Pos pos)

tuple[Pos, str]	parse_hex_char (str src, Pos pos, int hex_len)

tuple[Pos, str]	parse_literal_str (str src, Pos pos)

tuple[Pos, str]	parse_multiline_str (str src, Pos pos, *bool literal)

tuple[Pos, str]	parse_basic_str (str src, Pos pos, *bool multiline)

tuple[Pos, Any]	parse_value (str src, Pos pos, ParseFloat parse_float)

TOMLDecodeError	suffixed_err (str src, Pos pos, str msg)

bool	is_unicode_scalar_value (int codepoint)

ParseFloat	make_safe_parse_float (ParseFloat parse_float)

Variables
	ASCII_CTRL = frozenset(chr(i) for i in range(32)) \| frozenset(chr(127))

	ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")

	ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")

	ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS

	ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS

	ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS

	TOML_WS = frozenset(" \t")

	TOML_WS_AND_NEWLINE = TOML_WS \| frozenset("\n")

	BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")

	KEY_INITIAL_CHARS = BARE_KEY_CHARS \| frozenset("\"'")

	HEXDIGIT_CHARS = frozenset(string.hexdigits)

	BASIC_STR_ESCAPE_REPLACEMENTS

Function Documentation

◆ create_dict_rule()

tuple[Pos, Key] create_dict_rule	(	str	src,
		Pos	pos,
		Output	out
	)

Definition at line 284 of file _parser.py.

def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
    pos += 1  # Skip "["
    pos = skip_chars(src, pos, TOML_WS)
    pos, key = parse_key(src, pos)
 
    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
        raise suffixed_err(src, pos, f"Cannot declare {key} twice")
    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
    try:
        out.data.get_or_create_nest(key)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
 
    if not src.startswith("]", pos):
        raise suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
    return pos + 1, key
 
 

References i, pip._vendor.tomli._parser.parse_key(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.loads().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_list_rule()

tuple[Pos, Key] create_list_rule	(	str	src,
		Pos	pos,
		Output	out
	)

Definition at line 302 of file _parser.py.

def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
    pos += 2  # Skip "[["
    pos = skip_chars(src, pos, TOML_WS)
    pos, key = parse_key(src, pos)
 
    if out.flags.is_(key, Flags.FROZEN):
        raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
    # Free the namespace now that it points to another empty list item...
    out.flags.unset_all(key)
    # ...but this key precisely is still prohibited from table declaration
    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
    try:
        out.data.append_nest_to_list(key)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
 
    if not src.startswith("]]", pos):
        raise suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
    return pos + 2, key
 
 

References i, pip._vendor.tomli._parser.parse_key(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.loads().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_unicode_scalar_value()

bool is_unicode_scalar_value ( int codepoint )

Definition at line 669 of file _parser.py.

def is_unicode_scalar_value(codepoint: int) -> bool:
    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)

Referenced by pip._vendor.tomli._parser.parse_hex_char().

Here is the caller graph for this function:

◆ key_value_rule()

Pos key_value_rule	(	str	src,
		Pos	pos,
		Output	out,
		Key	header,
		ParseFloat	parse_float
	)

Definition at line 323 of file _parser.py.

) -> Pos:
    pos, key, value = parse_key_value_pair(src, pos, parse_float)
    key_parent, key_stem = key[:-1], key[-1]
    abs_key_parent = header + key_parent
 
    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
    for cont_key in relative_path_cont_keys:
        # Check that dotted key syntax does not redefine an existing table
        if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):
            raise suffixed_err(src, pos, f"Cannot redefine namespace {cont_key}")
        # Containers in the relative path can't be opened with the table syntax or
        # dotted key/value syntax in following table sections.
        out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)
 
    if out.flags.is_(abs_key_parent, Flags.FROZEN):
        raise suffixed_err(
            src, pos, f"Cannot mutate immutable namespace {abs_key_parent}"
        )
 
    try:
        nest = out.data.get_or_create_nest(abs_key_parent)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
    if key_stem in nest:
        raise suffixed_err(src, pos, "Cannot overwrite a value")
    # Mark inline table and array namespaces recursively immutable
    if isinstance(value, (dict, list)):
        out.flags.set(header + key, Flags.FROZEN, recursive=True)
    nest[key_stem] = value
    return pos
 
 

References i, pip._vendor.tomli._parser.parse_key_value_pair(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.loads().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load()

dict[str, Any] load	(	BinaryIO	__fp,
		*ParseFloat	parse_float = `float`
	)

Parse TOML from a binary file object.

Definition at line 57 of file _parser.py.

def load(__fp: BinaryIO, *, parse_float: ParseFloat = float) -> dict[str, Any]:
    """Parse TOML from a binary file object."""
    b = __fp.read()
    try:
        s = b.decode()
    except AttributeError:
        raise TypeError(
            "File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`"
        ) from None
    return loads(s, parse_float=parse_float)
 
 

◆ loads()

dict[str, Any] loads	(	str	__s,
		*ParseFloat	parse_float = `float`
	)

Parse TOML from a string.

Definition at line 69 of file _parser.py.

def loads(__s: str, *, parse_float: ParseFloat = float) -> dict[str, Any]:  # noqa: C901
    """Parse TOML from a string."""
 
    # The spec allows converting "\r\n" to "\n", even in string
    # literals. Let's do so to simplify parsing.
    src = __s.replace("\r\n", "\n")
    pos = 0
    out = Output(NestedDict(), Flags())
    header: Key = ()
    parse_float = make_safe_parse_float(parse_float)
 
    # Parse one statement at a time
    # (typically means one line in TOML source)
    while True:
        # 1. Skip line leading whitespace
        pos = skip_chars(src, pos, TOML_WS)
 
        # 2. Parse rules. Expect one of the following:
        #    - end of file
        #    - end of line
        #    - comment
        #    - key/value pair
        #    - append dict to list (and move to its namespace)
        #    - create dict (and move to its namespace)
        # Skip trailing whitespace when applicable.
        try:
            char = src[pos]
        except IndexError:
            break
        if char == "\n":
            pos += 1
            continue
        if char in KEY_INITIAL_CHARS:
            pos = key_value_rule(src, pos, out, header, parse_float)
            pos = skip_chars(src, pos, TOML_WS)
        elif char == "[":
            try:
                second_char: str | None = src[pos + 1]
            except IndexError:
                second_char = None
            out.flags.finalize_pending()
            if second_char == "[":
                pos, header = create_list_rule(src, pos, out)
            else:
                pos, header = create_dict_rule(src, pos, out)
            pos = skip_chars(src, pos, TOML_WS)
        elif char != "#":
            raise suffixed_err(src, pos, "Invalid statement")
 
        # 3. Skip comment
        pos = skip_comment(src, pos)
 
        # 4. Expect end of line or end of file
        try:
            char = src[pos]
        except IndexError:
            break
        if char != "\n":
            raise suffixed_err(
                src, pos, "Expected newline or end of document after a statement"
            )
        pos += 1
 
    return out.data.dict
 
 

References pip._vendor.tomli._parser.create_dict_rule(), pip._vendor.tomli._parser.create_list_rule(), i, pip._vendor.tomli._parser.key_value_rule(), pip._vendor.tomli._parser.make_safe_parse_float(), pip._vendor.tomli._parser.skip_chars(), pip._vendor.tomli._parser.skip_comment(), and pip._vendor.tomli._parser.suffixed_err().

Here is the call graph for this function:

◆ make_safe_parse_float()

ParseFloat make_safe_parse_float ( ParseFloat parse_float )

A decorator to make `parse_float` safe.

`parse_float` must not return dicts or lists, because these types
would be mixed with parsed TOML tables and arrays, thus confusing
the parser. The returned decorated callable raises `ValueError`
instead of returning illegal types.

Definition at line 673 of file _parser.py.

def make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat:
    """A decorator to make `parse_float` safe.
 
    `parse_float` must not return dicts or lists, because these types
    would be mixed with parsed TOML tables and arrays, thus confusing
    the parser. The returned decorated callable raises `ValueError`
    instead of returning illegal types.
    """
    # The default `float` callable never returns illegal types. Optimize it.
    if parse_float is float:  # type: ignore[comparison-overlap]
        return float
 
    def safe_parse_float(float_str: str) -> Any:
        float_value = parse_float(float_str)
        if isinstance(float_value, (dict, list)):
            raise ValueError("parse_float must not return dicts or lists")
        return float_value
 
    return safe_parse_float

References i.

Referenced by pip._vendor.tomli._parser.loads().

Here is the caller graph for this function:

◆ parse_array()

tuple[Pos, list] parse_array	(	str	src,
		Pos	pos,
		ParseFloat	parse_float
	)

Definition at line 412 of file _parser.py.

def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, list]:
    pos += 1
    array: list = []
 
    pos = skip_comments_and_array_ws(src, pos)
    if src.startswith("]", pos):
        return pos + 1, array
    while True:
        pos, val = parse_value(src, pos, parse_float)
        array.append(val)
        pos = skip_comments_and_array_ws(src, pos)
 
        c = src[pos : pos + 1]
        if c == "]":
            return pos + 1, array
        if c != ",":
            raise suffixed_err(src, pos, "Unclosed array")
        pos += 1
 
        pos = skip_comments_and_array_ws(src, pos)
        if src.startswith("]", pos):
            return pos + 1, array
 
 

References i, pip._vendor.tomli._parser.parse_value(), pip._vendor.tomli._parser.skip_comments_and_array_ws(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_basic_str()

tuple[Pos, str] parse_basic_str	(	str	src,
		Pos	pos,
		*bool	multiline
	)

Definition at line 552 of file _parser.py.

def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
    if multiline:
        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
        parse_escapes = parse_basic_str_escape_multiline
    else:
        error_on = ILLEGAL_BASIC_STR_CHARS
        parse_escapes = parse_basic_str_escape
    result = ""
    start_pos = pos
    while True:
        try:
            char = src[pos]
        except IndexError:
            raise suffixed_err(src, pos, "Unterminated string") from None
        if char == '"':
            if not multiline:
                return pos + 1, result + src[start_pos:pos]
            if src.startswith('"""', pos):
                return pos + 3, result + src[start_pos:pos]
            pos += 1
            continue
        if char == "\\":
            result += src[start_pos:pos]
            pos, parsed_escape = parse_escapes(src, pos)
            result += parsed_escape
            start_pos = pos
            continue
        if char in error_on:
            raise suffixed_err(src, pos, f"Illegal character {char!r}")
        pos += 1
 
 

References i, and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_multiline_str(), and pip._vendor.tomli._parser.parse_one_line_basic_str().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_basic_str_escape()

tuple[Pos, str] parse_basic_str_escape	(	str	src,
		Pos	pos,
		*bool	multiline = `False`
	)

Definition at line 468 of file _parser.py.

) -> tuple[Pos, str]:
    escape_id = src[pos : pos + 2]
    pos += 2
    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
        # Skip whitespace until next non-whitespace character or end of
        # the doc. Error if non-whitespace is found before newline.
        if escape_id != "\\\n":
            pos = skip_chars(src, pos, TOML_WS)
            try:
                char = src[pos]
            except IndexError:
                return pos, ""
            if char != "\n":
                raise suffixed_err(src, pos, "Unescaped '\\' in a string")
            pos += 1
        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
        return pos, ""
    if escape_id == "\\u":
        return parse_hex_char(src, pos, 4)
    if escape_id == "\\U":
        return parse_hex_char(src, pos, 8)
    try:
        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
    except KeyError:
        raise suffixed_err(src, pos, "Unescaped '\\' in a string") from None
 
 

References pip._vendor.tomli._parser.parse_hex_char(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_basic_str_escape_multiline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_basic_str_escape_multiline()

tuple[Pos, str] parse_basic_str_escape_multiline	(	str	src,
		Pos	pos
	)

Definition at line 497 of file _parser.py.

def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
    return parse_basic_str_escape(src, pos, multiline=True)

References pip._vendor.tomli._parser.parse_basic_str_escape().

Here is the call graph for this function:

◆ parse_hex_char()

tuple[Pos, str] parse_hex_char	(	str	src,
		Pos	pos,
		int	hex_len
	)

Definition at line 501 of file _parser.py.

def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:
    hex_str = src[pos : pos + hex_len]
    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
        raise suffixed_err(src, pos, "Invalid hex value")
    pos += hex_len
    hex_int = int(hex_str, 16)
    if not is_unicode_scalar_value(hex_int):
        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
    return pos, chr(hex_int)
 
 

References i, pip._vendor.tomli._parser.is_unicode_scalar_value(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_basic_str_escape().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_inline_table()

tuple[Pos, dict] parse_inline_table	(	str	src,
		Pos	pos,
		ParseFloat	parse_float
	)

Definition at line 436 of file _parser.py.

def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, dict]:
    pos += 1
    nested_dict = NestedDict()
    flags = Flags()
 
    pos = skip_chars(src, pos, TOML_WS)
    if src.startswith("}", pos):
        return pos + 1, nested_dict.dict
    while True:
        pos, key, value = parse_key_value_pair(src, pos, parse_float)
        key_parent, key_stem = key[:-1], key[-1]
        if flags.is_(key, Flags.FROZEN):
            raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
        try:
            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
        except KeyError:
            raise suffixed_err(src, pos, "Cannot overwrite a value") from None
        if key_stem in nest:
            raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
        nest[key_stem] = value
        pos = skip_chars(src, pos, TOML_WS)
        c = src[pos : pos + 1]
        if c == "}":
            return pos + 1, nested_dict.dict
        if c != ",":
            raise suffixed_err(src, pos, "Unclosed inline table")
        if isinstance(value, (dict, list)):
            flags.set(key, Flags.FROZEN, recursive=True)
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)
 
 

References i, pip._vendor.tomli._parser.parse_key_value_pair(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_key()

tuple[Pos, Key] parse_key	(	str	src,
		Pos	pos
	)

Definition at line 373 of file _parser.py.

def parse_key(src: str, pos: Pos) -> tuple[Pos, Key]:
    pos, key_part = parse_key_part(src, pos)
    key: Key = (key_part,)
    pos = skip_chars(src, pos, TOML_WS)
    while True:
        try:
            char: str | None = src[pos]
        except IndexError:
            char = None
        if char != ".":
            return pos, key
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)
        pos, key_part = parse_key_part(src, pos)
        key += (key_part,)
        pos = skip_chars(src, pos, TOML_WS)
 
 

References pip._vendor.tomli._parser.parse_key_part(), and pip._vendor.tomli._parser.skip_chars().

Referenced by pip._vendor.tomli._parser.create_dict_rule(), pip._vendor.tomli._parser.create_list_rule(), and pip._vendor.tomli._parser.parse_key_value_pair().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_key_part()

tuple[Pos, str] parse_key_part	(	str	src,
		Pos	pos
	)

Definition at line 391 of file _parser.py.

def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char in BARE_KEY_CHARS:
        start_pos = pos
        pos = skip_chars(src, pos, BARE_KEY_CHARS)
        return pos, src[start_pos:pos]
    if char == "'":
        return parse_literal_str(src, pos)
    if char == '"':
        return parse_one_line_basic_str(src, pos)
    raise suffixed_err(src, pos, "Invalid initial character for a key part")
 
 

References pip._vendor.tomli._parser.parse_literal_str(), pip._vendor.tomli._parser.parse_one_line_basic_str(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_key_value_pair()

tuple[Pos, Key, Any] parse_key_value_pair	(	str	src,
		Pos	pos,
		ParseFloat	parse_float
	)

Definition at line 357 of file _parser.py.

) -> tuple[Pos, Key, Any]:
    pos, key = parse_key(src, pos)
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char != "=":
        raise suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
    pos += 1
    pos = skip_chars(src, pos, TOML_WS)
    pos, value = parse_value(src, pos, parse_float)
    return pos, key, value
 
 

References pip._vendor.tomli._parser.parse_key(), pip._vendor.tomli._parser.parse_value(), pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.key_value_rule(), and pip._vendor.tomli._parser.parse_inline_table().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_literal_str()

tuple[Pos, str] parse_literal_str	(	str	src,
		Pos	pos
	)

Definition at line 512 of file _parser.py.

def parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]:
    pos += 1  # Skip starting apostrophe
    start_pos = pos
    pos = skip_until(
        src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
    )
    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
 
 

References pip._vendor.tomli._parser.skip_until().

Referenced by pip._vendor.tomli._parser.parse_key_part(), and pip._vendor.tomli._parser.parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_multiline_str()

tuple[Pos, str] parse_multiline_str	(	str	src,
		Pos	pos,
		*bool	literal
	)

Definition at line 521 of file _parser.py.

def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]:
    pos += 3
    if src.startswith("\n", pos):
        pos += 1
 
    if literal:
        delim = "'"
        end_pos = skip_until(
            src,
            pos,
            "'''",
            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
            error_on_eof=True,
        )
        result = src[pos:end_pos]
        pos = end_pos + 3
    else:
        delim = '"'
        pos, result = parse_basic_str(src, pos, multiline=True)
 
    # Add at maximum two extra apostrophes/quotes if the end sequence
    # is 4 or 5 chars long instead of just 3.
    if not src.startswith(delim, pos):
        return pos, result
    pos += 1
    if not src.startswith(delim, pos):
        return pos, result + delim
    pos += 1
    return pos, result + (delim * 2)
 
 

References i, pip._vendor.tomli._parser.parse_basic_str(), and pip._vendor.tomli._parser.skip_until().

Referenced by pip._vendor.tomli._parser.parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_one_line_basic_str()

tuple[Pos, str] parse_one_line_basic_str	(	str	src,
		Pos	pos
	)

Definition at line 407 of file _parser.py.

def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:
    pos += 1
    return parse_basic_str(src, pos, multiline=False)
 
 

References pip._vendor.tomli._parser.parse_basic_str().

Referenced by pip._vendor.tomli._parser.parse_key_part(), and pip._vendor.tomli._parser.parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_value()

tuple[Pos, Any] parse_value	(	str	src,
		Pos	pos,
		ParseFloat	parse_float
	)

Definition at line 584 of file _parser.py.

) -> tuple[Pos, Any]:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
 
    # IMPORTANT: order conditions based on speed of checking and likelihood
 
    # Basic strings
    if char == '"':
        if src.startswith('"""', pos):
            return parse_multiline_str(src, pos, literal=False)
        return parse_one_line_basic_str(src, pos)
 
    # Literal strings
    if char == "'":
        if src.startswith("'''", pos):
            return parse_multiline_str(src, pos, literal=True)
        return parse_literal_str(src, pos)
 
    # Booleans
    if char == "t":
        if src.startswith("true", pos):
            return pos + 4, True
    if char == "f":
        if src.startswith("false", pos):
            return pos + 5, False
 
    # Arrays
    if char == "[":
        return parse_array(src, pos, parse_float)
 
    # Inline tables
    if char == "{":
        return parse_inline_table(src, pos, parse_float)
 
    # Dates and times
    datetime_match = RE_DATETIME.match(src, pos)
    if datetime_match:
        try:
            datetime_obj = match_to_datetime(datetime_match)
        except ValueError as e:
            raise suffixed_err(src, pos, "Invalid date or datetime") from e
        return datetime_match.end(), datetime_obj
    localtime_match = RE_LOCALTIME.match(src, pos)
    if localtime_match:
        return localtime_match.end(), match_to_localtime(localtime_match)
 
    # Integers and "normal" floats.
    # The regex will greedily match any type starting with a decimal
    # char, so needs to be located after handling of dates and times.
    number_match = RE_NUMBER.match(src, pos)
    if number_match:
        return number_match.end(), match_to_number(number_match, parse_float)
 
    # Special floats
    first_three = src[pos : pos + 3]
    if first_three in {"inf", "nan"}:
        return pos + 3, parse_float(first_three)
    first_four = src[pos : pos + 4]
    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
        return pos + 4, parse_float(first_four)
 
    raise suffixed_err(src, pos, "Invalid value")
 
 

References i, pip._vendor.tomli._parser.parse_array(), pip._vendor.tomli._parser.parse_inline_table(), pip._vendor.tomli._parser.parse_literal_str(), pip._vendor.tomli._parser.parse_multiline_str(), pip._vendor.tomli._parser.parse_one_line_basic_str(), and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_array(), and pip._vendor.tomli._parser.parse_key_value_pair().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skip_chars()

Pos skip_chars	(	str	src,
		Pos	pos,
		Iterable[str]	chars
	)

Definition at line 232 of file _parser.py.

def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
    try:
        while src[pos] in chars:
            pos += 1
    except IndexError:
        pass
    return pos
 
 

Referenced by pip._vendor.tomli._parser.create_dict_rule(), pip._vendor.tomli._parser.create_list_rule(), pip._vendor.tomli._parser.loads(), pip._vendor.tomli._parser.parse_basic_str_escape(), pip._vendor.tomli._parser.parse_inline_table(), pip._vendor.tomli._parser.parse_key(), pip._vendor.tomli._parser.parse_key_part(), pip._vendor.tomli._parser.parse_key_value_pair(), and pip._vendor.tomli._parser.skip_comments_and_array_ws().

Here is the caller graph for this function:

◆ skip_comment()

Pos skip_comment	(	str	src,
		Pos	pos
	)

Definition at line 263 of file _parser.py.

def skip_comment(src: str, pos: Pos) -> Pos:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char == "#":
        return skip_until(
            src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
        )
    return pos
 
 

References pip._vendor.tomli._parser.skip_until().

Referenced by pip._vendor.tomli._parser.loads(), and pip._vendor.tomli._parser.skip_comments_and_array_ws().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skip_comments_and_array_ws()

Pos skip_comments_and_array_ws	(	str	src,
		Pos	pos
	)

Definition at line 275 of file _parser.py.

def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
    while True:
        pos_before_skip = pos
        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
        pos = skip_comment(src, pos)
        if pos == pos_before_skip:
            return pos
 
 

References pip._vendor.tomli._parser.skip_chars(), and pip._vendor.tomli._parser.skip_comment().

Referenced by pip._vendor.tomli._parser.parse_array().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skip_until()

Pos skip_until	(	str	src,
		Pos	pos,
		str	expect,
		*frozenset[str]	error_on,
		bool	error_on_eof
	)

Definition at line 241 of file _parser.py.

) -> Pos:
    try:
        new_pos = src.index(expect, pos)
    except ValueError:
        new_pos = len(src)
        if error_on_eof:
            raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None
 
    if not error_on.isdisjoint(src[pos:new_pos]):
        while src[pos] not in error_on:
            pos += 1
        raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
    return new_pos
 
 

References i, and pip._vendor.tomli._parser.suffixed_err().

Referenced by pip._vendor.tomli._parser.parse_literal_str(), pip._vendor.tomli._parser.parse_multiline_str(), and pip._vendor.tomli._parser.skip_comment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ suffixed_err()

TOMLDecodeError suffixed_err	(	str	src,
		Pos	pos,
		str	msg
	)

Return a `TOMLDecodeError` where error message is suffixed with
coordinates in source.

Definition at line 652 of file _parser.py.

def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
    """Return a `TOMLDecodeError` where error message is suffixed with
    coordinates in source."""
 
    def coord_repr(src: str, pos: Pos) -> str:
        if pos >= len(src):
            return "end of document"
        line = src.count("\n", 0, pos) + 1
        if line == 1:
            column = pos + 1
        else:
            column = pos - src.rindex("\n", 0, pos)
        return f"line {line}, column {column}"
 
    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
 
 

References i.

Here is the caller graph for this function:

Variable Documentation

◆ ASCII_CTRL

ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))

Definition at line 22 of file _parser.py.

◆ BARE_KEY_CHARS

BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")

Definition at line 36 of file _parser.py.

◆ BASIC_STR_ESCAPE_REPLACEMENTS

BASIC_STR_ESCAPE_REPLACEMENTS

Initial value:

=  MappingProxyType(
    {
        "\\b": "\u0008",  # backspace
        "\\t": "\u0009",  # tab
        "\\n": "\u000A",  # linefeed
        "\\f": "\u000C",  # form feed
        "\\r": "\u000D",  # carriage return
        '\\"': "\u0022",  # quote
        "\\\\": "\u005C",  # backslash
    }
)

Definition at line 40 of file _parser.py.

◆ HEXDIGIT_CHARS

HEXDIGIT_CHARS = frozenset(string.hexdigits)

Definition at line 38 of file _parser.py.

◆ ILLEGAL_BASIC_STR_CHARS

ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")

Definition at line 26 of file _parser.py.

◆ ILLEGAL_COMMENT_CHARS

ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS

Definition at line 32 of file _parser.py.

◆ ILLEGAL_LITERAL_STR_CHARS

ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS

Definition at line 29 of file _parser.py.

◆ ILLEGAL_MULTILINE_BASIC_STR_CHARS

ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")

Definition at line 27 of file _parser.py.

◆ ILLEGAL_MULTILINE_LITERAL_STR_CHARS

ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS

Definition at line 30 of file _parser.py.

◆ KEY_INITIAL_CHARS

KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")

Definition at line 37 of file _parser.py.

◆ TOML_WS

TOML_WS = frozenset(" \t")

Definition at line 34 of file _parser.py.

◆ TOML_WS_AND_NEWLINE

TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")

Definition at line 35 of file _parser.py.

Data Structures

Functions

Variables

Function Documentation

◆ create_dict_rule()

◆ create_list_rule()

◆ is_unicode_scalar_value()

◆ key_value_rule()

◆ load()

◆ loads()

◆ make_safe_parse_float()

◆ parse_array()

◆ parse_basic_str()

◆ parse_basic_str_escape()

◆ parse_basic_str_escape_multiline()

◆ parse_hex_char()

◆ parse_inline_table()

◆ parse_key()

◆ parse_key_part()

◆ parse_key_value_pair()

◆ parse_literal_str()

◆ parse_multiline_str()

◆ parse_one_line_basic_str()

◆ parse_value()

◆ skip_chars()

◆ skip_comment()

◆ skip_comments_and_array_ws()

◆ skip_until()

◆ suffixed_err()

Variable Documentation

◆ ASCII_CTRL

◆ BARE_KEY_CHARS

◆ BASIC_STR_ESCAPE_REPLACEMENTS

◆ HEXDIGIT_CHARS

◆ ILLEGAL_BASIC_STR_CHARS

◆ ILLEGAL_COMMENT_CHARS

◆ ILLEGAL_LITERAL_STR_CHARS

◆ ILLEGAL_MULTILINE_BASIC_STR_CHARS

◆ ILLEGAL_MULTILINE_LITERAL_STR_CHARS

◆ KEY_INITIAL_CHARS

◆ TOML_WS

◆ TOML_WS_AND_NEWLINE