Merge branch 'master' into fix/542-aot-captures-dotted-sibling

Author: frostming

.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
         args: [--py39-plus]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.18
+    rev: v0.15.21
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix, --show-fixes]

CHANGELOG.md

@@ -35,6 +35,12 @@
 - Out-of-order value-vs-table and dotted-key-vs-table redefinitions are now rejected at parse time instead of being silently accepted or raising only on access. The parser also detects when a non-dotted key is a prefix of an existing dotted key, matching the stdlib `tomllib` behaviour. ([#523](https://github.com/python-poetry/tomlkit/issues/523))
 - Reject tables inserted into inline tables instead of serializing invalid TOML. ([#531](https://github.com/python-poetry/tomlkit/issues/531))
 - Fix assigning an array of tables over a dotted key (e.g. `doc["a"] = aot(...)` where `a` came from `a.b = ...`): the new `[[a]]` header kept the dotted key's inline position and swallowed the following dotted sibling on round-trip. The array of tables now renders past the inline entries it would otherwise capture, mirroring the table fix for [#513](https://github.com/python-poetry/tomlkit/issues/513). ([#542](https://github.com/python-poetry/tomlkit/issues/542))
+- Fix invalid serialization with a duplicated `[table]` header when adding a key to an out-of-order table whose concrete header is declared after its sub-tables; the new key now lands in the existing concrete part instead of giving the header-less super part a second header. ([#545](https://github.com/python-poetry/tomlkit/pull/545))
+- Fix a table's display name (its exact header spelling, including whitespace and quoting) being normalised when the table is assigned onto itself, e.g. `doc[k] = doc[k]` rewriting `[keys .'a'.'c']` to `[keys.a.'c']`. ([#291](https://github.com/python-poetry/tomlkit/issues/291))
+- Fix missing newlines when appending a key after a dotted inline table, including when the original document has no trailing newline. ([#533](https://github.com/python-poetry/tomlkit/pull/533))
+- Preserve trailing whitespace when replacing a super table, including assigning it onto itself. ([#534](https://github.com/python-poetry/tomlkit/pull/534))
+- Fix `str()` and `repr()` of out-of-order table proxies to show their merged values. ([#536](https://github.com/python-poetry/tomlkit/pull/536))
+- Reject decimal integer literals that exceed Python's integer-string conversion limit instead of coercing them to infinity. ([#538](https://github.com/python-poetry/tomlkit/pull/538))
 
 ## [0.15.0] - 2026-05-10
 

docs/requirements.txt

@@ -32,7 +32,7 @@ requests==2.33.0
     # via sphinx
 snowballstemmer==2.2.0
     # via sphinx
-soupsieve==2.5
+soupsieve==2.8.4
     # via beautifulsoup4
 sphinx==7.4.7
     # via

poetry.lock

@@ -1,10 +1,14 @@
+import sys
+
 import pytest
 
 from tomlkit.exceptions import EmptyTableNameError
 from tomlkit.exceptions import InternalParserError
+from tomlkit.exceptions import InvalidNumberError
 from tomlkit.exceptions import InvalidUnicodeValueError
 from tomlkit.exceptions import ParseError
 from tomlkit.exceptions import UnexpectedCharError
+from tomlkit.items import Integer
 from tomlkit.items import StringType
 from tomlkit.parser import Parser
 
@@ -214,3 +218,20 @@ def test_parser_rejects_aot_header_missing_second_bracket(content: str) -> None:
     parser = Parser(content)
     with pytest.raises(ParseError):
         parser.parse()
+
+
+@pytest.mark.skipif(
+    not hasattr(sys, "get_int_max_str_digits"),
+    reason="requires the int-from-string digit limit (3.9.14+/3.10.7+/3.11+)",
+)
+def test_parser_rejects_overlong_decimal_integer() -> None:
+    # A decimal integer with more digits than Python's int-from-string limit
+    # raises ValueError in int(); it must be reported as an invalid number, not
+    # silently fall through to float() and become inf.
+    parser = Parser("a = " + "9" * 4301)
+    with pytest.raises(InvalidNumberError):
+        parser.parse()
+
+    # the value just under the limit is still a normal integer
+    value = Parser("a = " + "9" * 4300).parse()["a"]
+    assert isinstance(value, Integer)

tests/test_parser.py

@@ -643,6 +643,20 @@ def test_valid_out_of_order_independent_tables() -> None:
     assert doc.as_string() == "[a]\nx=1\n[zz]\n[a.b]\nc=1\n"
 
 
+def test_set_value_on_out_of_order_table_with_empty_concrete_part() -> None:
+    # A super table defined after its sub-table (the "defining a super-table
+    # afterward is ok" spec example) leaves an empty concrete `[x]` part.
+    # Adding a plain value must land in that concrete part, not turn the
+    # header-less super part into a second `[x]` header -- which produced
+    # output with a duplicate header that no longer parsed.
+    doc = parse("[x.y.z.w]\n\n[x]\n")
+    doc["x"]["c"] = 3
+
+    assert doc["x"]["c"] == 3
+    assert doc.as_string() == "[x.y.z.w]\n\n[x]\nc = 3\n"
+    assert parse(doc.as_string()).unwrap() == {"x": {"y": {"z": {"w": {}}}, "c": 3}}
+
+
 def test_out_of_order_table_merges_aot_fragments() -> None:
     # https://github.com/python-poetry/tomlkit/issues/505
     content = """\
@@ -887,6 +901,17 @@ def test_repr() -> None:
     assert repr(doc["namespace"]) == "{'key1': 'value1', 'key2': 'value2'}"
 
 
+def test_repr_out_of_order_table_proxy() -> None:
+    doc = parse("""\
+a.b.c = "d"
+a.b.e = "f"
+""")
+    expected = "{'b': {'c': 'd', 'e': 'f'}}"
+
+    assert repr(doc["a"]) == expected
+    assert str(doc["a"]) == expected
+
+
 def test_deepcopy() -> None:
     content = """
 [tool]
@@ -1006,6 +1031,38 @@ def test_replace_preserve_sep() -> None:
     )
 
 
+def test_replace_super_table_preserves_whitespace() -> None:
+    content = """\
+[env.pro1.rst]
+name = "x7"
+
+[env2]
+name = 2
+
+[env3]
+name = 3
+"""
+    doc = parse(content)
+
+    doc["env"] = doc["env"]
+
+    assert doc.as_string() == content
+
+
+def test_replace_table_with_itself_preserves_display_name() -> None:
+    content = """\
+[keys.a]
+[keys .'a'.'c']
+  'd'	= 'e'
+"""
+    doc = parse(content)
+
+    for mode in doc["keys"]:
+        doc["keys"][mode] = doc["keys"][mode]
+
+    assert doc.as_string() == content
+
+
 def test_replace_with_table_of_nested() -> None:
     example = """\
     [a]

tests/test_toml_document.py

@@ -930,7 +930,7 @@ def _replace_at(
                 value.trivia.trail = v.trivia.trail
             self._body[idx] = (new_key, value)
 
-        if hasattr(value, "invalidate_display_name"):
+        if value is not v and hasattr(value, "invalidate_display_name"):
             value.invalidate_display_name()
 
         if isinstance(value, Table):
@@ -1125,6 +1125,12 @@ def unwrap(self) -> dict[str, Any]:
     def value(self) -> dict[str, Any]:
         return self._internal_container.value
 
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __repr__(self) -> str:
+        return repr(self.value)
+
     def __contains__(self, key: object) -> bool:
         # Native membership test. The inherited ``MutableMapping.__contains__``
         # resolves the value via ``__getitem__`` (and builds a ``NonExistentKey``
@@ -1170,7 +1176,18 @@ def _is_table_or_aot(it: Any) -> bool:
                         table[key] = value
                         break
                 else:
-                    self._tables[0][key] = value
+                    # No part holds a plain value yet, so the chosen part must
+                    # start rendering its own ``[key]`` header. Prefer a part
+                    # that is not a super table (it already renders that header):
+                    # turning a header-less super part concrete here would emit a
+                    # second, duplicate header next to an existing concrete part
+                    # and produce TOML that no longer parses.
+                    for table in self._tables:
+                        if not table.is_super_table():
+                            table[key] = value
+                            break
+                    else:
+                        self._tables[0][key] = value
             else:
                 self._tables[0][key] = value
         else:
@@ -1220,9 +1237,12 @@ def ends_with_whitespace(it: Any) -> bool:
     """Returns ``True`` if the given item ``it`` is a ``Table`` or ``AoT`` object
     ending with a ``Whitespace``.
     """
-    return (
-        isinstance(it, Table) and isinstance(it.value._previous_item(), Whitespace)
-    ) or (isinstance(it, AoT) and len(it) > 0 and isinstance(it[-1], Whitespace))
+    if isinstance(it, Whitespace):
+        return True
+    if isinstance(it, Table):
+        previous = it.value._previous_item()
+        return previous is not None and ends_with_whitespace(previous)
+    return isinstance(it, AoT) and len(it) > 0 and ends_with_whitespace(it[-1])
 
 
 def _equal_with_nan(left: Any, right: Any) -> bool:

tomlkit/container.py

@@ -783,11 +783,20 @@ def _parse_number(self, raw: str, trivia: Trivia) -> Item | None:
         try:
             return Integer(int(sign + clean, base), trivia, sign + raw)
         except ValueError:
+            pass
+
+        # Only fall back to float for an actual float literal (a fractional
+        # dot, a base-10 exponent, or inf/nan). A decimal integer whose digit
+        # count exceeds Python's int-from-string conversion limit also raises
+        # ValueError above; it must be rejected, not silently coerced to inf.
+        if base == 10 and ("." in clean or "e" in clean or clean in ("inf", "nan")):
             try:
                 return Float(float(sign + clean), trivia, sign + raw)
             except ValueError:
                 return None
 
+        return None
+
     def _parse_literal_string(self) -> String:
         with self._state:
             return self._parse_string(StringType.SLL)