<h2>Editing File: /usr/lib64/python3.12/tomllib/_parser.py</h2><form method='post'><textarea name='content' class='file-edit'># SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
# Licensed to PSF under a Contributor Agreement.

from __future__ import annotations

from collections.abc import Iterable
import string
import sys
from types import MappingProxyType
from typing import Any, BinaryIO, NamedTuple

from ._re import (
    RE_DATETIME,
    RE_LOCALTIME,
    RE_NUMBER,
    match_to_datetime,
    match_to_localtime,
    match_to_number,
)
from ._types import Key, ParseFloat, Pos

# Pathologically excessive number of parts in a key runs into quadratic
# behavior (e.g. in Flags.is_).
# Even if keys aren't currently parsed using recursion, they name a
# recursive structure, so it makes sense to limit it using getrecursionlimit()
# and RecursionError.
MAX_KEY_PARTS = sys.getrecursionlimit()

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

# Neither of these sets include quotation mark or backslash. They are
# currently handled as separate cases in the parser functions.
ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset(&quot;\t&quot;)
ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset(&quot;\t\n&quot;)

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(&quot; \t&quot;)
TOML_WS_AND_NEWLINE = TOML_WS | frozenset(&quot;\n&quot;)
BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + &quot;-_&quot;)
KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset(&quot;\&quot;'&quot;)
HEXDIGIT_CHARS = frozenset(string.hexdigits)

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


class TOMLDecodeError(ValueError):
    &quot;&quot;&quot;An error raised if a document is not valid TOML.&quot;&quot;&quot;


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


def loads(s: str, /, *, parse_float: ParseFloat = float) -&gt; dict[str, Any]:  # noqa: C901
    &quot;&quot;&quot;Parse TOML from a string.&quot;&quot;&quot;

    # The spec allows converting &quot;\r\n&quot; to &quot;\n&quot;, even in string
    # literals. Let's do so to simplify parsing.
    src = s.replace(&quot;\r\n&quot;, &quot;\n&quot;)
    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 == &quot;\n&quot;:
            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 == &quot;[&quot;:
            try:
                second_char: str | None = src[pos + 1]
            except IndexError:
                second_char = None
            out.flags.finalize_pending()
            if second_char == &quot;[&quot;:
                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 != &quot;#&quot;:
            raise suffixed_err(src, pos, &quot;Invalid statement&quot;)

        # 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 != &quot;\n&quot;:
            raise suffixed_err(
                src, pos, &quot;Expected newline or end of document after a statement&quot;
            )
        pos += 1

    return out.data.dict


class Flags:
    &quot;&quot;&quot;Flags that map to parsed keys/namespaces.&quot;&quot;&quot;

    # Marks an immutable namespace (inline array or inline table).
    FROZEN = 0
    # Marks a nest that has been explicitly created and can no longer
    # be opened using the &quot;[table]&quot; syntax.
    EXPLICIT_NEST = 1

    def __init__(self) -&gt; None:
        self._flags: dict[str, dict] = {}
        self._pending_flags: set[tuple[Key, int]] = set()

    def add_pending(self, key: Key, flag: int) -&gt; None:
        self._pending_flags.add((key, flag))

    def finalize_pending(self) -&gt; None:
        for key, flag in self._pending_flags:
            self.set(key, flag, recursive=False)
        self._pending_flags.clear()

    def unset_all(self, key: Key) -&gt; None:
        cont = self._flags
        for k in key[:-1]:
            if k not in cont:
                return
            cont = cont[k][&quot;nested&quot;]
        cont.pop(key[-1], None)

    def set(self, key: Key, flag: int, *, recursive: bool) -&gt; None:  # noqa: A003
        cont = self._flags
        key_parent, key_stem = key[:-1], key[-1]
        for k in key_parent:
            if k not in cont:
                cont[k] = {&quot;flags&quot;: set(), &quot;recursive_flags&quot;: set(), &quot;nested&quot;: {}}
            cont = cont[k][&quot;nested&quot;]
        if key_stem not in cont:
            cont[key_stem] = {&quot;flags&quot;: set(), &quot;recursive_flags&quot;: set(), &quot;nested&quot;: {}}
        cont[key_stem][&quot;recursive_flags&quot; if recursive else &quot;flags&quot;].add(flag)

    def is_(self, key: Key, flag: int) -&gt; bool:
        if not key:
            return False  # document root has no flags
        cont = self._flags
        for k in key[:-1]:
            if k not in cont:
                return False
            inner_cont = cont[k]
            if flag in inner_cont[&quot;recursive_flags&quot;]:
                return True
            cont = inner_cont[&quot;nested&quot;]
        key_stem = key[-1]
        if key_stem in cont:
            cont = cont[key_stem]
            return flag in cont[&quot;flags&quot;] or flag in cont[&quot;recursive_flags&quot;]
        return False


class NestedDict:
    def __init__(self) -&gt; None:
        # The parsed content of the TOML document
        self.dict: dict[str, Any] = {}

    def get_or_create_nest(
        self,
        key: Key,
        *,
        access_lists: bool = True,
    ) -&gt; dict:
        cont: Any = self.dict
        for k in key:
            if k not in cont:
                cont[k] = {}
            cont = cont[k]
            if access_lists and isinstance(cont, list):
                cont = cont[-1]
            if not isinstance(cont, dict):
                raise KeyError(&quot;There is no nest behind this key&quot;)
        return cont

    def append_nest_to_list(self, key: Key) -&gt; None:
        cont = self.get_or_create_nest(key[:-1])
        last_key = key[-1]
        if last_key in cont:
            list_ = cont[last_key]
            if not isinstance(list_, list):
                raise KeyError(&quot;An object other than list found behind this key&quot;)
            list_.append({})
        else:
            cont[last_key] = [{}]


class Output(NamedTuple):
    data: NestedDict
    flags: Flags


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


def skip_until(
    src: str,
    pos: Pos,
    expect: str,
    *,
    error_on: frozenset[str],
    error_on_eof: bool,
) -&gt; 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&quot;Expected {expect!r}&quot;) 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&quot;Found invalid character {src[pos]!r}&quot;)
    return new_pos


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


def skip_comments_and_array_ws(src: str, pos: Pos) -&gt; 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


def create_dict_rule(src: str, pos: Pos, out: Output) -&gt; tuple[Pos, Key]:
    pos += 1  # Skip &quot;[&quot;
    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&quot;Cannot declare {key} twice&quot;)
    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
    try:
        out.data.get_or_create_nest(key)
    except KeyError:
        raise suffixed_err(src, pos, &quot;Cannot overwrite a value&quot;) from None

    if not src.startswith(&quot;]&quot;, pos):
        raise suffixed_err(src, pos, &quot;Expected ']' at the end of a table declaration&quot;)
    return pos + 1, key


def create_list_rule(src: str, pos: Pos, out: Output) -&gt; tuple[Pos, Key]:
    pos += 2  # Skip &quot;[[&quot;
    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&quot;Cannot mutate immutable namespace {key}&quot;)
    # 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, &quot;Cannot overwrite a value&quot;) from None

    if not src.startswith(&quot;]]&quot;, pos):
        raise suffixed_err(src, pos, &quot;Expected ']]' at the end of an array declaration&quot;)
    return pos + 2, key


def key_value_rule(
    src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
) -&gt; 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&quot;Cannot redefine namespace {cont_key}&quot;)
        # 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&quot;Cannot mutate immutable namespace {abs_key_parent}&quot;
        )

    try:
        nest = out.data.get_or_create_nest(abs_key_parent)
    except KeyError:
        raise suffixed_err(src, pos, &quot;Cannot overwrite a value&quot;) from None
    if key_stem in nest:
        raise suffixed_err(src, pos, &quot;Cannot overwrite a value&quot;)
    # 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


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


def parse_key(src: str, pos: Pos) -&gt; 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 != &quot;.&quot;:
            return pos, key
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)
        pos, key_part = parse_key_part(src, pos)
        key += (key_part,)
        if len(key) &gt; MAX_KEY_PARTS:
            raise RecursionError(
                f&quot;TOML key has more than the allowed {MAX_KEY_PARTS} parts&quot;
            )
        pos = skip_chars(src, pos, TOML_WS)


def parse_key_part(src: str, pos: Pos) -&gt; 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 == &quot;'&quot;:
        return parse_literal_str(src, pos)
    if char == '&quot;':
        return parse_one_line_basic_str(src, pos)
    raise suffixed_err(src, pos, &quot;Invalid initial character for a key part&quot;)


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


def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -&gt; tuple[Pos, list]:
    pos += 1
    array: list = []

    pos = skip_comments_and_array_ws(src, pos)
    if src.startswith(&quot;]&quot;, 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 == &quot;]&quot;:
            return pos + 1, array
        if c != &quot;,&quot;:
            raise suffixed_err(src, pos, &quot;Unclosed array&quot;)
        pos += 1

        pos = skip_comments_and_array_ws(src, pos)
        if src.startswith(&quot;]&quot;, pos):
            return pos + 1, array


def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -&gt; tuple[Pos, dict]:
    pos += 1
    nested_dict = NestedDict()
    flags = Flags()

    pos = skip_chars(src, pos, TOML_WS)
    if src.startswith(&quot;}&quot;, 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&quot;Cannot mutate immutable namespace {key}&quot;)
        try:
            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
        except KeyError:
            raise suffixed_err(src, pos, &quot;Cannot overwrite a value&quot;) from None
        if key_stem in nest:
            raise suffixed_err(src, pos, f&quot;Duplicate inline table key {key_stem!r}&quot;)
        nest[key_stem] = value
        pos = skip_chars(src, pos, TOML_WS)
        c = src[pos : pos + 1]
        if c == &quot;}&quot;:
            return pos + 1, nested_dict.dict
        if c != &quot;,&quot;:
            raise suffixed_err(src, pos, &quot;Unclosed inline table&quot;)
        if isinstance(value, (dict, list)):
            flags.set(key, Flags.FROZEN, recursive=True)
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)


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


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


def parse_hex_char(src: str, pos: Pos, hex_len: int) -&gt; 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, &quot;Invalid hex value&quot;)
    pos += hex_len
    hex_int = int(hex_str, 16)
    if not is_unicode_scalar_value(hex_int):
        raise suffixed_err(src, pos, &quot;Escaped character is not a Unicode scalar value&quot;)
    return pos, chr(hex_int)


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


def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -&gt; tuple[Pos, str]:
    pos += 3
    if src.startswith(&quot;\n&quot;, pos):
        pos += 1

    if literal:
        delim = &quot;'&quot;
        end_pos = skip_until(
            src,
            pos,
            &quot;'''&quot;,
            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
            error_on_eof=True,
        )
        result = src[pos:end_pos]
        pos = end_pos + 3
    else:
        delim = '&quot;'
        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)


def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -&gt; 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 = &quot;&quot;
    start_pos = pos
    while True:
        try:
            char = src[pos]
        except IndexError:
            raise suffixed_err(src, pos, &quot;Unterminated string&quot;) from None
        if char == '&quot;':
            if not multiline:
                return pos + 1, result + src[start_pos:pos]
            if src.startswith('&quot;&quot;&quot;', pos):
                return pos + 3, result + src[start_pos:pos]
            pos += 1
            continue
        if char == &quot;\\&quot;:
            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&quot;Illegal character {char!r}&quot;)
        pos += 1


def parse_value(  # noqa: C901
    src: str, pos: Pos, parse_float: ParseFloat
) -&gt; 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 == '&quot;':
        if src.startswith('&quot;&quot;&quot;', pos):
            return parse_multiline_str(src, pos, literal=False)
        return parse_one_line_basic_str(src, pos)

    # Literal strings
    if char == &quot;'&quot;:
        if src.startswith(&quot;'''&quot;, pos):
            return parse_multiline_str(src, pos, literal=True)
        return parse_literal_str(src, pos)

    # Booleans
    if char == &quot;t&quot;:
        if src.startswith(&quot;true&quot;, pos):
            return pos + 4, True
    if char == &quot;f&quot;:
        if src.startswith(&quot;false&quot;, pos):
            return pos + 5, False

    # Arrays
    if char == &quot;[&quot;:
        return parse_array(src, pos, parse_float)

    # Inline tables
    if char == &quot;{&quot;:
        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, &quot;Invalid date or datetime&quot;) 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 &quot;normal&quot; 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 {&quot;inf&quot;, &quot;nan&quot;}:
        return pos + 3, parse_float(first_three)
    first_four = src[pos : pos + 4]
    if first_four in {&quot;-inf&quot;, &quot;+inf&quot;, &quot;-nan&quot;, &quot;+nan&quot;}:
        return pos + 4, parse_float(first_four)

    raise suffixed_err(src, pos, &quot;Invalid value&quot;)


def suffixed_err(src: str, pos: Pos, msg: str) -&gt; TOMLDecodeError:
    &quot;&quot;&quot;Return a `TOMLDecodeError` where error message is suffixed with
    coordinates in source.&quot;&quot;&quot;

    def coord_repr(src: str, pos: Pos) -&gt; str:
        if pos &gt;= len(src):
            return &quot;end of document&quot;
        line = src.count(&quot;\n&quot;, 0, pos) + 1
        if line == 1:
            column = pos + 1
        else:
            column = pos - src.rindex(&quot;\n&quot;, 0, pos)
        return f&quot;line {line}, column {column}&quot;

    return TOMLDecodeError(f&quot;{msg} (at {coord_repr(src, pos)})&quot;)


def is_unicode_scalar_value(codepoint: int) -&gt; bool:
    return (0 &lt;= codepoint &lt;= 55295) or (57344 &lt;= codepoint &lt;= 1114111)


def make_safe_parse_float(parse_float: ParseFloat) -&gt; ParseFloat:
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;
    # 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) -&gt; Any:
        float_value = parse_float(float_str)
        if isinstance(float_value, (dict, list)):
            raise ValueError(&quot;parse_float must not return dicts or lists&quot;)
        return float_value

    return safe_parse_float
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib64%2Fpython3.12%2Ftomllib'>Back to Directory</a>