Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __init__.py from tomlkit.api import TOMLDocument from tomlkit.api import aot from tomlkit.api import array from tomlkit.api import boolean from tomlkit.api import comment from tomlkit.api import date from tomlkit.api import datetime from tomlkit.api import document from tomlkit.api import dump from tomlkit.api import dumps from tomlkit.api import float_ from tomlkit.api import inline_table from tomlkit.api import integer from tomlkit.api import item from tomlkit.api import key from tomlkit.api import key_value from tomlkit.api import load from tomlkit.api import loads from tomlkit.api import nl from tomlkit.api import parse from tomlkit.api import string from tomlkit.api import table from tomlkit.api import time from tomlkit.api import value from tomlkit.api import ws __version__ = "0.11.8" __all__ = [ "aot", "array", "boolean", "comment", "date", "datetime", "document", "dump", "dumps", "float_", "inline_table", "integer", "item", "key", "key_value", "load", "loads", "nl", "parse", "string", "table", "time", "TOMLDocument", "value", "ws", ]	1.12 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 _compat.py from __future__ import annotations import contextlib import sys from typing import Any PY38 = sys.version_info >= (3, 8) def decode(string: Any, encodings: list[str] \| None = None): if not isinstance(string, bytes): return string encodings = encodings or ["utf-8", "latin1", "ascii"] for encoding in encodings: with contextlib.suppress(UnicodeEncodeError, UnicodeDecodeError): return string.decode(encoding) return string.decode(encodings[0], errors="ignore")	513 B	2026-01-20 12:58
📄 _utils.py from __future__ import annotations import re from collections.abc import Mapping from datetime import date from datetime import datetime from datetime import time from datetime import timedelta from datetime import timezone from typing import Collection from tomlkit._compat import decode RFC_3339_LOOSE = re.compile( "^" r"(([0-9]+)-(\d{2})-(\d{2}))?" # Date "(" "([Tt ])?" # Separator r"(\d{2}):(\d{2}):(\d{2})(\.([0-9]+))?" # Time r"(([Zz])\|([\+\|\-]([01][0-9]\|2[0-3]):([0-5][0-9])))?" # Timezone ")?" "$" ) RFC_3339_DATETIME = re.compile( "^" "([0-9]+)-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])" # Date "[Tt ]" # Separator r"([01][0-9]\|2[0-3]):([0-5][0-9]):([0-5][0-9]\|60)(\.([0-9]+))?" # Time r"(([Zz])\|([\+\|\-]([01][0-9]\|2[0-3]):([0-5][0-9])))?" # Timezone "$" ) RFC_3339_DATE = re.compile("^([0-9]+)-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$") RFC_3339_TIME = re.compile( r"^([01][0-9]\|2[0-3]):([0-5][0-9]):([0-5][0-9]\|60)(\.([0-9]+))?$" ) _utc = timezone(timedelta(), "UTC") def parse_rfc3339(string: str) -> datetime \| date \| time: m = RFC_3339_DATETIME.match(string) if m: year = int(m.group(1)) month = int(m.group(2)) day = int(m.group(3)) hour = int(m.group(4)) minute = int(m.group(5)) second = int(m.group(6)) microsecond = 0 if m.group(7): microsecond = int((f"{m.group(8):<06s}")[:6]) if m.group(9): # Timezone tz = m.group(9) if tz.upper() == "Z": tzinfo = _utc else: sign = m.group(11)[0] hour_offset, minute_offset = int(m.group(12)), int(m.group(13)) offset = timedelta(seconds=hour_offset * 3600 + minute_offset * 60) if sign == "-": offset = -offset tzinfo = timezone(offset, f"{sign}{m.group(12)}:{m.group(13)}") return datetime( year, month, day, hour, minute, second, microsecond, tzinfo=tzinfo ) else: return datetime(year, month, day, hour, minute, second, microsecond) m = RFC_3339_DATE.match(string) if m: year = int(m.group(1)) month = int(m.group(2)) day = int(m.group(3)) return date(year, month, day) m = RFC_3339_TIME.match(string) if m: hour = int(m.group(1)) minute = int(m.group(2)) second = int(m.group(3)) microsecond = 0 if m.group(4): microsecond = int((f"{m.group(5):<06s}")[:6]) return time(hour, minute, second, microsecond) raise ValueError("Invalid RFC 339 string") # https://toml.io/en/v1.0.0#string CONTROL_CHARS = frozenset(chr(c) for c in range(0x20)) \| {chr(0x7F)} _escaped = { "b": "\b", "t": "\t", "n": "\n", "f": "\f", "r": "\r", '"': '"', "\\": "\\", } _compact_escapes = { **{v: f"\\{k}" for k, v in _escaped.items()}, '"""': '""\\"', } _basic_escapes = CONTROL_CHARS \| {'"', "\\"} def _unicode_escape(seq: str) -> str: return "".join(f"\\u{ord(c):04x}" for c in seq) def escape_string(s: str, escape_sequences: Collection[str] = _basic_escapes) -> str: s = decode(s) res = [] start = 0 def flush(inc=1): if start != i: res.append(s[start:i]) return i + inc i = 0 while i < len(s): for seq in escape_sequences: seq_len = len(seq) if s[i:].startswith(seq): start = flush(seq_len) res.append(_compact_escapes.get(seq) or _unicode_escape(seq)) i += seq_len - 1 # fast-forward escape sequence i += 1 flush() return "".join(res) def merge_dicts(d1: dict, d2: dict) -> dict: for k, v in d2.items(): if k in d1 and isinstance(d1[k], dict) and isinstance(v, Mapping): merge_dicts(d1[k], v) else: d1[k] = d2[k]	3.93 KB	2026-01-20 12:58
📄 api.py from __future__ import annotations import datetime as _datetime from collections.abc import Mapping from typing import IO from typing import Iterable from tomlkit._utils import parse_rfc3339 from tomlkit.container import Container from tomlkit.exceptions import UnexpectedCharError from tomlkit.items import AoT from tomlkit.items import Array from tomlkit.items import Bool from tomlkit.items import Comment from tomlkit.items import Date from tomlkit.items import DateTime from tomlkit.items import DottedKey from tomlkit.items import Float from tomlkit.items import InlineTable from tomlkit.items import Integer from tomlkit.items import Item as _Item from tomlkit.items import Key from tomlkit.items import SingleKey from tomlkit.items import String from tomlkit.items import StringType as _StringType from tomlkit.items import Table from tomlkit.items import Time from tomlkit.items import Trivia from tomlkit.items import Whitespace from tomlkit.items import item from tomlkit.parser import Parser from tomlkit.toml_document import TOMLDocument def loads(string: str \| bytes) -> TOMLDocument: """ Parses a string into a TOMLDocument. Alias for parse(). """ return parse(string) def dumps(data: Mapping, sort_keys: bool = False) -> str: """ Dumps a TOMLDocument into a string. """ if not isinstance(data, Container) and isinstance(data, Mapping): data = item(dict(data), _sort_keys=sort_keys) try: # data should be a `Container` (and therefore implement `as_string`) # for all type safe invocations of this function return data.as_string() # type: ignore[attr-defined] except AttributeError as ex: msg = f"Expecting Mapping or TOML Container, {type(data)} given" raise TypeError(msg) from ex def load(fp: IO[str] \| IO[bytes]) -> TOMLDocument: """ Load toml document from a file-like object. """ return parse(fp.read()) def dump(data: Mapping, fp: IO[str], , sort_keys: bool = False) -> None: """ Dump a TOMLDocument into a writable file stream. :param data: a dict-like object to dump :param sort_keys: if true, sort the keys in alphabetic order """ fp.write(dumps(data, sort_keys=sort_keys)) def parse(string: str \| bytes) -> TOMLDocument: """ Parses a string or bytes into a TOMLDocument. """ return Parser(string).parse() def document() -> TOMLDocument: """ Returns a new TOMLDocument instance. """ return TOMLDocument() # Items def integer(raw: str \| int) -> Integer: """Create an integer item from a number or string.""" return item(int(raw)) def float_(raw: str \| float) -> Float: """Create an float item from a number or string.""" return item(float(raw)) def boolean(raw: str) -> Bool: """Turn `true` or `false` into a boolean item.""" return item(raw == "true") def string( raw: str, , literal: bool = False, multiline: bool = False, escape: bool = True, ) -> String: """Create a string item. By default, this function will create single line basic strings, but boolean flags (e.g. ``literal=True`` and/or ``multiline=True``) can be used for personalization. For more information, please check the spec: `<https://toml.io/en/v1.0.0#string>`__. Common escaping rules will be applied for basic strings. This can be controlled by explicitly setting ``escape=False``. Please note that, if you disable escaping, you will have to make sure that the given strings don't contain any forbidden character or sequence. """ type_ = _StringType.select(literal, multiline) return String.from_raw(raw, type_, escape) def date(raw: str) -> Date: """Create a TOML date.""" value = parse_rfc3339(raw) if not isinstance(value, _datetime.date): raise ValueError("date() only accepts date strings.") return item(value) def time(raw: str) -> Time: """Create a TOML time.""" value = parse_rfc3339(raw) if not isinstance(value, _datetime.time): raise ValueError("time() only accepts time strings.") return item(value) def datetime(raw: str) -> DateTime: """Create a TOML datetime.""" value = parse_rfc3339(raw) if not isinstance(value, _datetime.datetime): raise ValueError("datetime() only accepts datetime strings.") return item(value) def array(raw: str = None) -> Array: """Create an array item for its string representation. :Example: >>> array("[1, 2, 3]") # Create from a string [1, 2, 3] >>> a = array() >>> a.extend([1, 2, 3]) # Create from a list >>> a [1, 2, 3] """ if raw is None: raw = "[]" return value(raw) def table(is_super_table: bool \| None = None) -> Table: """Create an empty table. :param is_super_table: if true, the table is a super table :Example: >>> doc = document() >>> foo = table(True) >>> bar = table() >>> bar.update({'x': 1}) >>> foo.append('bar', bar) >>> doc.append('foo', foo) >>> print(doc.as_string()) [foo.bar] x = 1 """ return Table(Container(), Trivia(), False, is_super_table) def inline_table() -> InlineTable: """Create an inline table. :Example: >>> table = inline_table() >>> table.update({'x': 1, 'y': 2}) >>> print(table.as_string()) {x = 1, y = 2} """ return InlineTable(Container(), Trivia(), new=True) def aot() -> AoT: """Create an array of table. :Example: >>> doc = document() >>> aot = aot() >>> aot.append(item({'x': 1})) >>> doc.append('foo', aot) >>> print(doc.as_string()) [[foo]] x = 1 """ return AoT([]) def key(k: str \| Iterable[str]) -> Key: """Create a key from a string. When a list of string is given, it will create a dotted key. :Example: >>> doc = document() >>> doc.append(key('foo'), 1) >>> doc.append(key(['bar', 'baz']), 2) >>> print(doc.as_string()) foo = 1 bar.baz = 2 """ if isinstance(k, str): return SingleKey(k) return DottedKey([key(_k) for _k in k]) def value(raw: str) -> _Item: """Parse a simple value from a string. :Example: >>> value("1") 1 >>> value("true") True >>> value("[1, 2, 3]") [1, 2, 3] """ parser = Parser(raw) v = parser._parse_value() if not parser.end(): raise parser.parse_error(UnexpectedCharError, char=parser._current) return v def key_value(src: str) -> tuple[Key, _Item]: """Parse a key-value pair from a string. :Example: >>> key_value("foo = 1") (Key('foo'), 1) """ return Parser(src)._parse_key_value() def ws(src: str) -> Whitespace: """Create a whitespace from a string.""" return Whitespace(src, fixed=True) def nl() -> Whitespace: """Create a newline item.""" return ws("\n") def comment(string: str) -> Comment: """Create a comment item.""" return Comment(Trivia(comment_ws=" ", comment="# " + string))	6.9 KB	2026-01-20 12:58
📄 container.py from __future__ import annotations import copy from typing import Any from typing import Iterator from tomlkit._compat import decode from tomlkit._utils import merge_dicts from tomlkit.exceptions import KeyAlreadyPresent from tomlkit.exceptions import NonExistentKey from tomlkit.exceptions import TOMLKitError from tomlkit.items import AoT from tomlkit.items import Comment from tomlkit.items import Item from tomlkit.items import Key from tomlkit.items import Null from tomlkit.items import SingleKey from tomlkit.items import Table from tomlkit.items import Trivia from tomlkit.items import Whitespace from tomlkit.items import _CustomDict from tomlkit.items import item as _item _NOT_SET = object() class Container(_CustomDict): """ A container for items within a TOMLDocument. This class implements the `dict` interface with copy/deepcopy protocol. """ def __init__(self, parsed: bool = False) -> None: self._map: dict[SingleKey, int \| tuple[int, ...]] = {} self._body: list[tuple[Key \| None, Item]] = [] self._parsed = parsed self._table_keys = [] @property def body(self) -> list[tuple[Key \| None, Item]]: return self._body def unwrap(self) -> dict[str, Any]: unwrapped = {} for k, v in self.items(): if k is None: continue if isinstance(k, Key): k = k.key if hasattr(v, "unwrap"): v = v.unwrap() if k in unwrapped: merge_dicts(unwrapped[k], v) else: unwrapped[k] = v return unwrapped @property def value(self) -> dict[str, Any]: d = {} for k, v in self._body: if k is None: continue k = k.key v = v.value if isinstance(v, Container): v = v.value if k in d: merge_dicts(d[k], v) else: d[k] = v return d def parsing(self, parsing: bool) -> None: self._parsed = parsing for _, v in self._body: if isinstance(v, Table): v.value.parsing(parsing) elif isinstance(v, AoT): for t in v.body: t.value.parsing(parsing) def add(self, key: Key \| Item \| str, item: Item \| None = None) -> Container: """ Adds an item to the current Container. :Example: >>> # add a key-value pair >>> doc.add('key', 'value') >>> # add a comment or whitespace or newline >>> doc.add(comment('# comment')) """ if item is None: if not isinstance(key, (Comment, Whitespace)): raise ValueError( "Non comment/whitespace items must have an associated key" ) key, item = None, key return self.append(key, item) def _handle_dotted_key(self, key: Key, value: Item) -> None: if isinstance(value, (Table, AoT)): raise TOMLKitError("Can't add a table to a dotted key") name, *mid, last = key name._dotted = True table = current = Table(Container(True), Trivia(), False, is_super_table=True) for _name in mid: _name._dotted = True new_table = Table(Container(True), Trivia(), False, is_super_table=True) current.append(_name, new_table) current = new_table last.sep = key.sep current.append(last, value) self.append(name, table) return def _get_last_index_before_table(self) -> int: last_index = -1 for i, (k, v) in enumerate(self._body): if isinstance(v, Null): continue # Null elements are inserted after deletion if isinstance(v, Whitespace) and not v.is_fixed(): continue if isinstance(v, (Table, AoT)) and not k.is_dotted(): break last_index = i return last_index + 1 def append(self, key: Key \| str \| None, item: Item) -> Container: """Similar to :meth:`add` but both key and value must be given.""" if not isinstance(key, Key) and key is not None: key = SingleKey(key) if not isinstance(item, Item): item = _item(item) if key is not None and key.is_multi(): self._handle_dotted_key(key, item) return self if isinstance(item, (AoT, Table)) and item.name is None: item.name = key.key prev = self._previous_item() prev_ws = isinstance(prev, Whitespace) or ends_with_whitespace(prev) if isinstance(item, Table): if not self._parsed: item.invalidate_display_name() if ( self._body and not (self._parsed or item.trivia.indent or prev_ws) and not key.is_dotted() ): item.trivia.indent = "\n" if isinstance(item, AoT) and self._body and not self._parsed: item.invalidate_display_name() if item and not ("\n" in item[0].trivia.indent or prev_ws): item[0].trivia.indent = "\n" + item[0].trivia.indent if key is not None and key in self: current_idx = self._map[key] if isinstance(current_idx, tuple): current_body_element = self._body[current_idx[-1]] else: current_body_element = self._body[current_idx] current = current_body_element[1] if isinstance(item, Table): if not isinstance(current, (Table, AoT)): raise KeyAlreadyPresent(key) if item.is_aot_element(): # New AoT element found later on # Adding it to the current AoT if not isinstance(current, AoT): current = AoT([current, item], parsed=self._parsed) self._replace(key, key, current) else: current.append(item) return self elif current.is_aot(): if not item.is_aot_element(): # Tried to define a table after an AoT with the same name. raise KeyAlreadyPresent(key) current.append(item) return self elif current.is_super_table(): if item.is_super_table(): # We need to merge both super tables if ( self._table_keys[-1] != current_body_element[0] or key.is_dotted() or current_body_element[0].is_dotted() ): if key.is_dotted() and not self._parsed: idx = self._get_last_index_before_table() else: idx = len(self._body) if idx < len(self._body): self._insert_at(idx, key, item) else: self._raw_append(key, item) # Building a temporary proxy to check for errors OutOfOrderTableProxy(self, self._map[key]) return self # Create a new element to replace the old one current = copy.deepcopy(current) for k, v in item.value.body: current.append(k, v) self._body[ current_idx[-1] if isinstance(current_idx, tuple) else current_idx ] = (current_body_element[0], current) return self elif current_body_element[0].is_dotted(): raise TOMLKitError("Redefinition of an existing table") elif not item.is_super_table(): raise KeyAlreadyPresent(key) elif isinstance(item, AoT): if not isinstance(current, AoT): # Tried to define an AoT after a table with the same name. raise KeyAlreadyPresent(key) for table in item.body: current.append(table) return self else: raise KeyAlreadyPresent(key) is_table = isinstance(item, (Table, AoT)) if ( key is not None and self._body and not self._parsed and (not is_table or key.is_dotted()) ): # If there is already at least one table in the current container # and the given item is not a table, we need to find the last # item that is not a table and insert after it # If no such item exists, insert at the top of the table last_index = self._get_last_index_before_table() if last_index < len(self._body): return self._insert_at(last_index, key, item) else: previous_item = self._body[-1][1] if not ( isinstance(previous_item, Whitespace) or ends_with_whitespace(previous_item) or "\n" in previous_item.trivia.trail ): previous_item.trivia.trail += "\n" self._raw_append(key, item) return self def _raw_append(self, key: Key, item: Item) -> None: if key in self._map: current_idx = self._map[key] if not isinstance(current_idx, tuple): current_idx = (current_idx,) current = self._body[current_idx[-1]][1] if key is not None and not isinstance(current, Table): raise KeyAlreadyPresent(key) self._map[key] = current_idx + (len(self._body),) else: self._map[key] = len(self._body) self._body.append((key, item)) if item.is_table(): self._table_keys.append(key) if key is not None: dict.__setitem__(self, key.key, item.value) return self def _remove_at(self, idx: int) -> None: key = self._body[idx][0] index = self._map.get(key) if index is None: raise NonExistentKey(key) self._body[idx] = (None, Null()) if isinstance(index, tuple): index = list(index) index.remove(idx) if len(index) == 1: index = index.pop() else: index = tuple(index) self._map[key] = index else: dict.__delitem__(self, key.key) self._map.pop(key) def remove(self, key: Key \| str) -> Container: """Remove a key from the container.""" if not isinstance(key, Key): key = SingleKey(key) idx = self._map.pop(key, None) if idx is None: raise NonExistentKey(key) if isinstance(idx, tuple): for i in idx: self._body[i] = (None, Null()) else: self._body[idx] = (None, Null()) dict.__delitem__(self, key.key) return self def _insert_after( self, key: Key \| str, other_key: Key \| str, item: Any ) -> Container: if key is None: raise ValueError("Key cannot be null in insert_after()") if key not in self: raise NonExistentKey(key) if not isinstance(key, Key): key = SingleKey(key) if not isinstance(other_key, Key): other_key = SingleKey(other_key) item = _item(item) idx = self._map[key] # Insert after the max index if there are many. if isinstance(idx, tuple): idx = max(idx) current_item = self._body[idx][1] if "\n" not in current_item.trivia.trail: current_item.trivia.trail += "\n" # Increment indices after the current index for k, v in self._map.items(): if isinstance(v, tuple): new_indices = [] for v_ in v: if v_ > idx: v_ = v_ + 1 new_indices.append(v_) self._map[k] = tuple(new_indices) elif v > idx: self._map[k] = v + 1 self._map[other_key] = idx + 1 self._body.insert(idx + 1, (other_key, item)) if key is not None: dict.__setitem__(self, other_key.key, item.value) return self def _insert_at(self, idx: int, key: Key \| str, item: Any) -> Container: if idx > len(self._body) - 1: raise ValueError(f"Unable to insert at position {idx}") if not isinstance(key, Key): key = SingleKey(key) item = _item(item) if idx > 0: previous_item = self._body[idx - 1][1] if not ( isinstance(previous_item, Whitespace) or ends_with_whitespace(previous_item) or isinstance(item, (AoT, Table)) or "\n" in previous_item.trivia.trail ): previous_item.trivia.trail += "\n" # Increment indices after the current index for k, v in self._map.items(): if isinstance(v, tuple): new_indices = [] for v_ in v: if v_ >= idx: v_ = v_ + 1 new_indices.append(v_) self._map[k] = tuple(new_indices) elif v >= idx: self._map[k] = v + 1 if key in self._map: current_idx = self._map[key] if not isinstance(current_idx, tuple): current_idx = (current_idx,) self._map[key] = current_idx + (idx,) else: self._map[key] = idx self._body.insert(idx, (key, item)) dict.__setitem__(self, key.key, item.value) return self def item(self, key: Key \| str) -> Item: """Get an item for the given key.""" if not isinstance(key, Key): key = SingleKey(key) idx = self._map.get(key) if idx is None: raise NonExistentKey(key) if isinstance(idx, tuple): # The item we are getting is an out of order table # so we need a proxy to retrieve the proper objects # from the parent container return OutOfOrderTableProxy(self, idx) return self._body[idx][1] def last_item(self) -> Item \| None: """Get the last item.""" if self._body: return self._body[-1][1] def as_string(self) -> str: """Render as TOML string.""" s = "" for k, v in self._body: if k is not None: if isinstance(v, Table): s += self._render_table(k, v) elif isinstance(v, AoT): s += self._render_aot(k, v) else: s += self._render_simple_item(k, v) else: s += self._render_simple_item(k, v) return s def _render_table(self, key: Key, table: Table, prefix: str \| None = None) -> str: cur = "" if table.display_name is not None: _key = table.display_name else: _key = key.as_string() if prefix is not None: _key = prefix + "." + _key if not table.is_super_table() or ( any( not isinstance(v, (Table, AoT, Whitespace, Null)) for _, v in table.value.body ) and not key.is_dotted() ): open_, close = "[", "]" if table.is_aot_element(): open_, close = "[[", "]]" newline_in_table_trivia = ( "\n" if "\n" not in table.trivia.trail and len(table.value) > 0 else "" ) cur += ( f"{table.trivia.indent}" f"{open_}" f"{decode(_key)}" f"{close}" f"{table.trivia.comment_ws}" f"{decode(table.trivia.comment)}" f"{table.trivia.trail}" f"{newline_in_table_trivia}" ) elif table.trivia.indent == "\n": cur += table.trivia.indent for k, v in table.value.body: if isinstance(v, Table): if v.is_super_table(): if k.is_dotted() and not key.is_dotted(): # Dotted key inside table cur += self._render_table(k, v) else: cur += self._render_table(k, v, prefix=_key) else: cur += self._render_table(k, v, prefix=_key) elif isinstance(v, AoT): cur += self._render_aot(k, v, prefix=_key) else: cur += self._render_simple_item( k, v, prefix=_key if key.is_dotted() else None ) return cur def _render_aot(self, key, aot, prefix=None): _key = key.as_string() if prefix is not None: _key = prefix + "." + _key cur = "" _key = decode(_key) for table in aot.body: cur += self._render_aot_table(table, prefix=_key) return cur def _render_aot_table(self, table: Table, prefix: str \| None = None) -> str: cur = "" _key = prefix or "" open_, close = "[[", "]]" cur += ( f"{table.trivia.indent}" f"{open_}" f"{decode(_key)}" f"{close}" f"{table.trivia.comment_ws}" f"{decode(table.trivia.comment)}" f"{table.trivia.trail}" ) for k, v in table.value.body: if isinstance(v, Table): if v.is_super_table(): if k.is_dotted(): # Dotted key inside table cur += self._render_table(k, v) else: cur += self._render_table(k, v, prefix=_key) else: cur += self._render_table(k, v, prefix=_key) elif isinstance(v, AoT): cur += self._render_aot(k, v, prefix=_key) else: cur += self._render_simple_item(k, v) return cur def _render_simple_item(self, key, item, prefix=None): if key is None: return item.as_string() _key = key.as_string() if prefix is not None: _key = prefix + "." + _key return ( f"{item.trivia.indent}" f"{decode(_key)}" f"{key.sep}" f"{decode(item.as_string())}" f"{item.trivia.comment_ws}" f"{decode(item.trivia.comment)}" f"{item.trivia.trail}" ) def __len__(self) -> int: return dict.__len__(self) def __iter__(self) -> Iterator[str]: return iter(dict.keys(self)) # Dictionary methods def __getitem__(self, key: Key \| str) -> Item \| Container: if not isinstance(key, Key): key = SingleKey(key) idx = self._map.get(key) if idx is None: raise NonExistentKey(key) if isinstance(idx, tuple): # The item we are getting is an out of order table # so we need a proxy to retrieve the proper objects # from the parent container return OutOfOrderTableProxy(self, idx) item = self._body[idx][1] if item.is_boolean(): return item.value return item def __setitem__(self, key: Key \| str, value: Any) -> None: if key is not None and key in self: old_key = next(filter(lambda k: k == key, self._map)) self._replace(old_key, key, value) else: self.append(key, value) def __delitem__(self, key: Key \| str) -> None: self.remove(key) def setdefault(self, key: Key \| str, default: Any) -> Any: super().setdefault(key, default=default) return self[key] def _replace(self, key: Key \| str, new_key: Key \| str, value: Item) -> None: if not isinstance(key, Key): key = SingleKey(key) idx = self._map.get(key) if idx is None: raise NonExistentKey(key) self._replace_at(idx, new_key, value) def _replace_at( self, idx: int \| tuple[int], new_key: Key \| str, value: Item ) -> None: value = _item(value) if isinstance(idx, tuple): for i in idx[1:]: self._body[i] = (None, Null()) idx = idx[0] k, v = self._body[idx] if not isinstance(new_key, Key): if ( isinstance(value, (AoT, Table)) != isinstance(v, (AoT, Table)) or new_key != k.key ): new_key = SingleKey(new_key) else: # Inherit the sep of the old key new_key = k del self._map[k] self._map[new_key] = idx if new_key != k: dict.__delitem__(self, k) if isinstance(value, (AoT, Table)) != isinstance(v, (AoT, Table)): # new tables should appear after all non-table values self.remove(k) for i in range(idx, len(self._body)): if isinstance(self._body[i][1], (AoT, Table)): self._insert_at(i, new_key, value) idx = i break else: idx = -1 self.append(new_key, value) else: # Copying trivia if not isinstance(value, (Whitespace, AoT)): value.trivia.indent = v.trivia.indent value.trivia.comment_ws = value.trivia.comment_ws or v.trivia.comment_ws value.trivia.comment = value.trivia.comment or v.trivia.comment value.trivia.trail = v.trivia.trail self._body[idx] = (new_key, value) if hasattr(value, "invalidate_display_name"): value.invalidate_display_name() # type: ignore[attr-defined] if isinstance(value, Table): # Insert a cosmetic new line for tables if: # - it does not have it yet OR is not followed by one # - it is not the last item last, _ = self._previous_item_with_index() idx = last if idx < 0 else idx has_ws = ends_with_whitespace(value) next_ws = idx < last and isinstance(self._body[idx + 1][1], Whitespace) if idx < last and not (next_ws or has_ws): value.append(None, Whitespace("\n")) dict.__setitem__(self, new_key.key, value.value) def __str__(self) -> str: return str(self.value) def __repr__(self) -> str: return repr(self.value) def __eq__(self, other: dict) -> bool: if not isinstance(other, dict): return NotImplemented return self.value == other def _getstate(self, protocol): return (self._parsed,) def __reduce__(self): return self.__reduce_ex__(2) def __reduce_ex__(self, protocol): return ( self.__class__, self._getstate(protocol), (self._map, self._body, self._parsed, self._table_keys), ) def __setstate__(self, state): self._map = state[0] self._body = state[1] self._parsed = state[2] self._table_keys = state[3] for key, item in self._body: if key is not None: dict.__setitem__(self, key.key, item.value) def copy(self) -> Container: return copy.copy(self) def __copy__(self) -> Container: c = self.__class__(self._parsed) for k, v in dict.items(self): dict.__setitem__(c, k, v) c._body += self.body c._map.update(self._map) return c def _previous_item_with_index( self, idx: int \| None = None, ignore=(Null,) ) -> tuple[int, Item] \| None: """Find the immediate previous item before index ``idx``""" if idx is None or idx > len(self._body): idx = len(self._body) for i in range(idx - 1, -1, -1): v = self._body[i][-1] if not isinstance(v, ignore): return i, v return None def _previous_item(self, idx: int \| None = None, ignore=(Null,)) -> Item \| None: """Find the immediate previous item before index ``idx``. If ``idx`` is not given, the last item is returned. """ prev = self._previous_item_with_index(idx, ignore) return prev[-1] if prev else None class OutOfOrderTableProxy(_CustomDict): def __init__(self, container: Container, indices: tuple[int]) -> None: self._container = container self._internal_container = Container(True) self._tables = [] self._tables_map = {} for i in indices: _, item = self._container._body[i] if isinstance(item, Table): self._tables.append(item) table_idx = len(self._tables) - 1 for k, v in item.value.body: self._internal_container.append(k, v) self._tables_map[k] = table_idx if k is not None: dict.__setitem__(self, k.key, v) def unwrap(self) -> str: return self._internal_container.unwrap() @property def value(self): return self._internal_container.value def __getitem__(self, key: Key \| str) -> Any: if key not in self._internal_container: raise NonExistentKey(key) return self._internal_container[key] def __setitem__(self, key: Key \| str, item: Any) -> None: if key in self._tables_map: table = self._tables[self._tables_map[key]] table[key] = item elif self._tables: table = self._tables[0] table[key] = item else: self._container[key] = item self._internal_container[key] = item if key is not None: dict.__setitem__(self, key, item) def _remove_table(self, table: Table) -> None: """Remove table from the parent container""" self._tables.remove(table) for idx, item in enumerate(self._container._body): if item[1] is table: self._container._remove_at(idx) break def __delitem__(self, key: Key \| str) -> None: if key in self._tables_map: table = self._tables[self._tables_map[key]] del table[key] if not table and len(self._tables) > 1: self._remove_table(table) del self._tables_map[key] else: raise NonExistentKey(key) del self._internal_container[key] if key is not None: dict.__delitem__(self, key) def __iter__(self) -> Iterator[str]: return iter(dict.keys(self)) def __len__(self) -> int: return dict.__len__(self) def setdefault(self, key: Key \| str, default: Any) -> Any: super().setdefault(key, default=default) return self[key] 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))	27.53 KB	2026-01-20 12:58
📄 exceptions.py from __future__ import annotations from typing import Collection class TOMLKitError(Exception): pass class ParseError(ValueError, TOMLKitError): """ This error occurs when the parser encounters a syntax error in the TOML being parsed. The error references the line and location within the line where the error was encountered. """ def __init__(self, line: int, col: int, message: str \| None = None) -> None: self._line = line self._col = col if message is None: message = "TOML parse error" super().__init__(f"{message} at line {self._line} col {self._col}") @property def line(self): return self._line @property def col(self): return self._col class MixedArrayTypesError(ParseError): """ An array was found that had two or more element types. """ def __init__(self, line: int, col: int) -> None: message = "Mixed types found in array" super().__init__(line, col, message=message) class InvalidNumberError(ParseError): """ A numeric field was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid number" super().__init__(line, col, message=message) class InvalidDateTimeError(ParseError): """ A datetime field was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid datetime" super().__init__(line, col, message=message) class InvalidDateError(ParseError): """ A date field was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid date" super().__init__(line, col, message=message) class InvalidTimeError(ParseError): """ A date field was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid time" super().__init__(line, col, message=message) class InvalidNumberOrDateError(ParseError): """ A numeric or date field was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid number or date format" super().__init__(line, col, message=message) class InvalidUnicodeValueError(ParseError): """ A unicode code was improperly specified. """ def __init__(self, line: int, col: int) -> None: message = "Invalid unicode value" super().__init__(line, col, message=message) class UnexpectedCharError(ParseError): """ An unexpected character was found during parsing. """ def __init__(self, line: int, col: int, char: str) -> None: message = f"Unexpected character: {repr(char)}" super().__init__(line, col, message=message) class EmptyKeyError(ParseError): """ An empty key was found during parsing. """ def __init__(self, line: int, col: int) -> None: message = "Empty key" super().__init__(line, col, message=message) class EmptyTableNameError(ParseError): """ An empty table name was found during parsing. """ def __init__(self, line: int, col: int) -> None: message = "Empty table name" super().__init__(line, col, message=message) class InvalidCharInStringError(ParseError): """ The string being parsed contains an invalid character. """ def __init__(self, line: int, col: int, char: str) -> None: message = f"Invalid character {repr(char)} in string" super().__init__(line, col, message=message) class UnexpectedEofError(ParseError): """ The TOML being parsed ended before the end of a statement. """ def __init__(self, line: int, col: int) -> None: message = "Unexpected end of file" super().__init__(line, col, message=message) class InternalParserError(ParseError): """ An error that indicates a bug in the parser. """ def __init__(self, line: int, col: int, message: str \| None = None) -> None: msg = "Internal parser error" if message: msg += f" ({message})" super().__init__(line, col, message=msg) class NonExistentKey(KeyError, TOMLKitError): """ A non-existent key was used. """ def __init__(self, key): message = f'Key "{key}" does not exist.' super().__init__(message) class KeyAlreadyPresent(TOMLKitError): """ An already present key was used. """ def __init__(self, key): key = getattr(key, "key", key) message = f'Key "{key}" already exists.' super().__init__(message) class InvalidControlChar(ParseError): def __init__(self, line: int, col: int, char: int, type: str) -> None: display_code = "\\u00" if char < 16: display_code += "0" display_code += hex(char)[2:] message = ( "Control characters (codes less than 0x1f and 0x7f)" f" are not allowed in {type}, " f"use {display_code} instead" ) super().__init__(line, col, message=message) class InvalidStringError(ValueError, TOMLKitError): def __init__(self, value: str, invalid_sequences: Collection[str], delimiter: str): repr_ = repr(value)[1:-1] super().__init__( f"Invalid string: {delimiter}{repr_}{delimiter}. " f"The character sequences {invalid_sequences} are invalid." )	5.36 KB	2026-01-20 12:58
📄 items.py from __future__ import annotations import abc import copy import dataclasses import re import string from datetime import date from datetime import datetime from datetime import time from datetime import tzinfo from enum import Enum from typing import TYPE_CHECKING from typing import Any from typing import Collection from typing import Iterable from typing import Iterator from typing import Sequence from typing import TypeVar from typing import cast from typing import overload from tomlkit._compat import PY38 from tomlkit._compat import decode from tomlkit._utils import CONTROL_CHARS from tomlkit._utils import escape_string from tomlkit.exceptions import InvalidStringError if TYPE_CHECKING: # pragma: no cover # Define _CustomList and _CustomDict as a workaround for: # https://github.com/python/mypy/issues/11427 # # According to this issue, the typeshed contains a "lie" # (it adds MutableSequence to the ancestry of list and MutableMapping to # the ancestry of dict) which completely messes with the type inference for # Table, InlineTable, Array and Container. # # Importing from builtins is preferred over simple assignment, see issues: # https://github.com/python/mypy/issues/8715 # https://github.com/python/mypy/issues/10068 from builtins import dict as _CustomDict # noqa: N812, TC004 from builtins import list as _CustomList # noqa: N812, TC004 # Allow type annotations but break circular imports from tomlkit import container else: from collections.abc import MutableMapping from collections.abc import MutableSequence class _CustomList(MutableSequence, list): """Adds MutableSequence mixin while pretending to be a builtin list""" class _CustomDict(MutableMapping, dict): """Adds MutableMapping mixin while pretending to be a builtin dict""" ItemT = TypeVar("ItemT", bound="Item") @overload def item(value: bool, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Bool: ... @overload def item(value: int, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Integer: ... @overload def item(value: float, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Float: ... @overload def item(value: str, _parent: Item \| None = ..., _sort_keys: bool = ...) -> String: ... @overload def item( value: datetime, _parent: Item \| None = ..., _sort_keys: bool = ... ) -> DateTime: ... @overload def item(value: date, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Date: ... @overload def item(value: time, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Time: ... @overload def item( value: Sequence[dict], _parent: Item \| None = ..., _sort_keys: bool = ... ) -> AoT: ... @overload def item(value: Sequence, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Array: ... @overload def item(value: dict, _parent: Array = ..., _sort_keys: bool = ...) -> InlineTable: ... @overload def item(value: dict, _parent: Item \| None = ..., _sort_keys: bool = ...) -> Table: ... @overload def item(value: ItemT, _parent: Item \| None = ..., _sort_keys: bool = ...) -> ItemT: ... def item(value: Any, _parent: Item \| None = None, _sort_keys: bool = False) -> Item: """Create a TOML item from a Python object. :Example: >>> item(42) 42 >>> item([1, 2, 3]) [1, 2, 3] >>> item({'a': 1, 'b': 2}) a = 1 b = 2 """ from tomlkit.container import Container if isinstance(value, Item): return value if isinstance(value, bool): return Bool(value, Trivia()) elif isinstance(value, int): return Integer(value, Trivia(), str(value)) elif isinstance(value, float): return Float(value, Trivia(), str(value)) elif isinstance(value, dict): table_constructor = ( InlineTable if isinstance(_parent, (Array, InlineTable)) else Table ) val = table_constructor(Container(), Trivia(), False) for k, v in sorted( value.items(), key=lambda i: (isinstance(i[1], dict), i[0] if _sort_keys else 1), ): val[k] = item(v, _parent=val, _sort_keys=_sort_keys) return val elif isinstance(value, (list, tuple)): if ( value and all(isinstance(v, dict) for v in value) and (_parent is None or isinstance(_parent, Table)) ): a = AoT([]) table_constructor = Table else: a = Array([], Trivia()) table_constructor = InlineTable for v in value: if isinstance(v, dict): table = table_constructor(Container(), Trivia(), True) for k, _v in sorted( v.items(), key=lambda i: (isinstance(i[1], dict), i[0] if _sort_keys else 1), ): i = item(_v, _parent=table, _sort_keys=_sort_keys) if isinstance(table, InlineTable): i.trivia.trail = "" table[k] = i v = table a.append(v) return a elif isinstance(value, str): return String.from_raw(value) elif isinstance(value, datetime): return DateTime( value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond, value.tzinfo, Trivia(), value.isoformat().replace("+00:00", "Z"), ) elif isinstance(value, date): return Date(value.year, value.month, value.day, Trivia(), value.isoformat()) elif isinstance(value, time): return Time( value.hour, value.minute, value.second, value.microsecond, value.tzinfo, Trivia(), value.isoformat(), ) raise ValueError(f"Invalid type {type(value)}") class StringType(Enum): # Single Line Basic SLB = '"' # Multi Line Basic MLB = '"""' # Single Line Literal SLL = "'" # Multi Line Literal MLL = "'''" @classmethod def select(cls, literal=False, multiline=False) -> StringType: return { (False, False): cls.SLB, (False, True): cls.MLB, (True, False): cls.SLL, (True, True): cls.MLL, }[(literal, multiline)] @property def escaped_sequences(self) -> Collection[str]: # https://toml.io/en/v1.0.0#string escaped_in_basic = CONTROL_CHARS \| {"\\"} allowed_in_multiline = {"\n", "\r"} return { StringType.SLB: escaped_in_basic \| {'"'}, StringType.MLB: (escaped_in_basic \| {'"""'}) - allowed_in_multiline, StringType.SLL: (), StringType.MLL: (), }[self] @property def invalid_sequences(self) -> Collection[str]: # https://toml.io/en/v1.0.0#string forbidden_in_literal = CONTROL_CHARS - {"\t"} allowed_in_multiline = {"\n", "\r"} return { StringType.SLB: (), StringType.MLB: (), StringType.SLL: forbidden_in_literal \| {"'"}, StringType.MLL: (forbidden_in_literal \| {"'''"}) - allowed_in_multiline, }[self] @property def unit(self) -> str: return self.value[0] def is_basic(self) -> bool: return self in {StringType.SLB, StringType.MLB} def is_literal(self) -> bool: return self in {StringType.SLL, StringType.MLL} def is_singleline(self) -> bool: return self in {StringType.SLB, StringType.SLL} def is_multiline(self) -> bool: return self in {StringType.MLB, StringType.MLL} def toggle(self) -> StringType: return { StringType.SLB: StringType.MLB, StringType.MLB: StringType.SLB, StringType.SLL: StringType.MLL, StringType.MLL: StringType.SLL, }[self] class BoolType(Enum): TRUE = "true" FALSE = "false" def __bool__(self): return {BoolType.TRUE: True, BoolType.FALSE: False}[self] def __iter__(self): return iter(self.value) def __len__(self): return len(self.value) @dataclasses.dataclass class Trivia: """ Trivia information (aka metadata). """ # Whitespace before a value. indent: str = "" # Whitespace after a value, but before a comment. comment_ws: str = "" # Comment, starting with # character, or empty string if no comment. comment: str = "" # Trailing newline. trail: str = "\n" def copy(self) -> Trivia: return dataclasses.replace(self) class KeyType(Enum): """ The type of a Key. Keys can be bare (unquoted), or quoted using basic ("), or literal (') quotes following the same escaping rules as single-line StringType. """ Bare = "" Basic = '"' Literal = "'" class Key(abc.ABC): """Base class for a key""" sep: str _original: str _keys: list[SingleKey] _dotted: bool key: str @abc.abstractmethod def __hash__(self) -> int: pass @abc.abstractmethod def __eq__(self, __o: object) -> bool: pass def is_dotted(self) -> bool: """If the key is followed by other keys""" return self._dotted def __iter__(self) -> Iterator[SingleKey]: return iter(self._keys) def concat(self, other: Key) -> DottedKey: """Concatenate keys into a dotted key""" keys = self._keys + other._keys return DottedKey(keys, sep=self.sep) def is_multi(self) -> bool: """Check if the key contains multiple keys""" return len(self._keys) > 1 def as_string(self) -> str: """The TOML representation""" return self._original def __str__(self) -> str: return self.as_string() def __repr__(self) -> str: return f"<Key {self.as_string()}>" class SingleKey(Key): """A single key""" def __init__( self, k: str, t: KeyType \| None = None, sep: str \| None = None, original: str \| None = None, ) -> None: if t is None: if not k or any( c not in string.ascii_letters + string.digits + "-" + "_" for c in k ): t = KeyType.Basic else: t = KeyType.Bare self.t = t if sep is None: sep = " = " self.sep = sep self.key = k if original is None: key_str = escape_string(k) if t == KeyType.Basic else k original = f"{t.value}{key_str}{t.value}" self._original = original self._keys = [self] self._dotted = False @property def delimiter(self) -> str: """The delimiter: double quote/single quote/none""" return self.t.value def is_bare(self) -> bool: """Check if the key is bare""" return self.t == KeyType.Bare def __hash__(self) -> int: return hash(self.key) def __eq__(self, other: Any) -> bool: if isinstance(other, Key): return isinstance(other, SingleKey) and self.key == other.key return self.key == other class DottedKey(Key): def __init__( self, keys: Iterable[Key], sep: str \| None = None, original: str \| None = None, ) -> None: self._keys = list(keys) if original is None: original = ".".join(k.as_string() for k in self._keys) self.sep = " = " if sep is None else sep self._original = original self._dotted = False self.key = ".".join(k.key for k in self._keys) def __hash__(self) -> int: return hash(tuple(self._keys)) def __eq__(self, __o: object) -> bool: return isinstance(__o, DottedKey) and self._keys == __o._keys class Item: """ An item within a TOML document. """ def __init__(self, trivia: Trivia) -> None: self._trivia = trivia @property def trivia(self) -> Trivia: """The trivia element associated with this item""" return self._trivia @property def discriminant(self) -> int: raise NotImplementedError() def as_string(self) -> str: """The TOML representation""" raise NotImplementedError() @property def value(self) -> Any: return self def unwrap(self) -> Any: """Returns as pure python object (ppo)""" raise NotImplementedError() # Helpers def comment(self, comment: str) -> Item: """Attach a comment to this item""" if not comment.strip().startswith("#"): comment = "# " + comment self._trivia.comment_ws = " " self._trivia.comment = comment return self def indent(self, indent: int) -> Item: """Indent this item with given number of spaces""" if self._trivia.indent.startswith("\n"): self._trivia.indent = "\n" + " " * indent else: self._trivia.indent = " " * indent return self def is_boolean(self) -> bool: return isinstance(self, Bool) def is_table(self) -> bool: return isinstance(self, Table) def is_inline_table(self) -> bool: return isinstance(self, InlineTable) def is_aot(self) -> bool: return isinstance(self, AoT) def _getstate(self, protocol=3): return (self._trivia,) def __reduce__(self): return self.__reduce_ex__(2) def __reduce_ex__(self, protocol): return self.__class__, self._getstate(protocol) class Whitespace(Item): """ A whitespace literal. """ def __init__(self, s: str, fixed: bool = False) -> None: self._s = s self._fixed = fixed @property def s(self) -> str: return self._s @property def value(self) -> str: """The wrapped string of the whitespace""" return self._s @property def trivia(self) -> Trivia: raise RuntimeError("Called trivia on a Whitespace variant.") @property def discriminant(self) -> int: return 0 def is_fixed(self) -> bool: """If the whitespace is fixed, it can't be merged or discarded from the output.""" return self._fixed def as_string(self) -> str: return self._s def __repr__(self) -> str: return f"<{self.__class__.__name__} {repr(self._s)}>" def _getstate(self, protocol=3): return self._s, self._fixed class Comment(Item): """ A comment literal. """ @property def discriminant(self) -> int: return 1 def as_string(self) -> str: return ( f"{self._trivia.indent}{decode(self._trivia.comment)}{self._trivia.trail}" ) def __str__(self) -> str: return f"{self._trivia.indent}{decode(self._trivia.comment)}" class Integer(int, Item): """ An integer literal. """ def __new__(cls, value: int, trivia: Trivia, raw: str) -> Integer: return super().__new__(cls, value) def __init__(self, _: int, trivia: Trivia, raw: str) -> None: super().__init__(trivia) self._raw = raw self._sign = False if re.match(r"^[+\-]\d+$", raw): self._sign = True def unwrap(self) -> int: return int(self) @property def discriminant(self) -> int: return 2 @property def value(self) -> int: """The wrapped integer value""" return self def as_string(self) -> str: return self._raw def __add__(self, other): result = super().__add__(other) if result is NotImplemented: return result return self._new(result) def __radd__(self, other): result = super().__radd__(other) if result is NotImplemented: return result return self._new(result) def __sub__(self, other): result = super().__sub__(other) if result is NotImplemented: return result return self._new(result) def __rsub__(self, other): result = super().__rsub__(other) if result is NotImplemented: return result return self._new(result) def _new(self, result): raw = str(result) if self._sign: sign = "+" if result >= 0 else "-" raw = sign + raw return Integer(result, self._trivia, raw) def _getstate(self, protocol=3): return int(self), self._trivia, self._raw class Float(float, Item): """ A float literal. """ def __new__(cls, value: float, trivia: Trivia, raw: str) -> Integer: return super().__new__(cls, value) def __init__(self, _: float, trivia: Trivia, raw: str) -> None: super().__init__(trivia) self._raw = raw self._sign = False if re.match(r"^[+\-].+$", raw): self._sign = True def unwrap(self) -> float: return float(self) @property def discriminant(self) -> int: return 3 @property def value(self) -> float: """The wrapped float value""" return self def as_string(self) -> str: return self._raw def __add__(self, other): result = super().__add__(other) return self._new(result) def __radd__(self, other): result = super().__radd__(other) if isinstance(other, Float): return self._new(result) return result def __sub__(self, other): result = super().__sub__(other) return self._new(result) def __rsub__(self, other): result = super().__rsub__(other) if isinstance(other, Float): return self._new(result) return result def _new(self, result): raw = str(result) if self._sign: sign = "+" if result >= 0 else "-" raw = sign + raw return Float(result, self._trivia, raw) def _getstate(self, protocol=3): return float(self), self._trivia, self._raw class Bool(Item): """ A boolean literal. """ def __init__(self, t: int, trivia: Trivia) -> None: super().__init__(trivia) self._value = bool(t) def unwrap(self) -> bool: return bool(self) @property def discriminant(self) -> int: return 4 @property def value(self) -> bool: """The wrapped boolean value""" return self._value def as_string(self) -> str: return str(self._value).lower() def _getstate(self, protocol=3): return self._value, self._trivia def __bool__(self): return self._value __nonzero__ = __bool__ def __eq__(self, other): if not isinstance(other, bool): return NotImplemented return other == self._value def __hash__(self): return hash(self._value) def __repr__(self): return repr(self._value) class DateTime(Item, datetime): """ A datetime literal. """ def __new__( cls, year: int, month: int, day: int, hour: int, minute: int, second: int, microsecond: int, tzinfo: tzinfo \| None, _: Any, kwargs: Any, ) -> datetime: return datetime.__new__( cls, year, month, day, hour, minute, second, microsecond, tzinfo=tzinfo, kwargs, ) def __init__( self, year: int, month: int, day: int, hour: int, minute: int, second: int, microsecond: int, tzinfo: tzinfo \| None, trivia: Trivia \| None = None, raw: str \| None = None, kwargs: Any, ) -> None: super().__init__(trivia or Trivia()) self._raw = raw or self.isoformat() def unwrap(self) -> datetime: ( year, month, day, hour, minute, second, microsecond, tzinfo, _, _, ) = self._getstate() return datetime(year, month, day, hour, minute, second, microsecond, tzinfo) @property def discriminant(self) -> int: return 5 @property def value(self) -> datetime: return self def as_string(self) -> str: return self._raw def __add__(self, other): if PY38: result = datetime( self.year, self.month, self.day, self.hour, self.minute, self.second, self.microsecond, self.tzinfo, ).__add__(other) else: result = super().__add__(other) return self._new(result) def __sub__(self, other): if PY38: result = datetime( self.year, self.month, self.day, self.hour, self.minute, self.second, self.microsecond, self.tzinfo, ).__sub__(other) else: result = super().__sub__(other) if isinstance(result, datetime): result = self._new(result) return result def replace(self, args: Any, *kwargs: Any) -> datetime: return self._new(super().replace(args, *kwargs)) def astimezone(self, tz: tzinfo) -> datetime: result = super().astimezone(tz) if PY38: return result return self._new(result) def _new(self, result) -> DateTime: raw = result.isoformat() return DateTime( result.year, result.month, result.day, result.hour, result.minute, result.second, result.microsecond, result.tzinfo, self._trivia, raw, ) def _getstate(self, protocol=3): return ( self.year, self.month, self.day, self.hour, self.minute, self.second, self.microsecond, self.tzinfo, self._trivia, self._raw, ) class Date(Item, date): """ A date literal. """ def __new__(cls, year: int, month: int, day: int, _: Any) -> date: return date.__new__(cls, year, month, day) def __init__( self, year: int, month: int, day: int, trivia: Trivia, raw: str ) -> None: super().__init__(trivia) self._raw = raw def unwrap(self) -> date: (year, month, day, _, _) = self._getstate() return date(year, month, day) @property def discriminant(self) -> int: return 6 @property def value(self) -> date: return self def as_string(self) -> str: return self._raw def __add__(self, other): if PY38: result = date(self.year, self.month, self.day).__add__(other) else: result = super().__add__(other) return self._new(result) def __sub__(self, other): if PY38: result = date(self.year, self.month, self.day).__sub__(other) else: result = super().__sub__(other) if isinstance(result, date): result = self._new(result) return result def replace(self, args: Any, kwargs: Any) -> date: return self._new(super().replace(args, *kwargs)) def _new(self, result): raw = result.isoformat() return Date(result.year, result.month, result.day, self._trivia, raw) def _getstate(self, protocol=3): return (self.year, self.month, self.day, self._trivia, self._raw) class Time(Item, time): """ A time literal. """ def __new__( cls, hour: int, minute: int, second: int, microsecond: int, tzinfo: tzinfo \| None, _: Any, ) -> time: return time.__new__(cls, hour, minute, second, microsecond, tzinfo) def __init__( self, hour: int, minute: int, second: int, microsecond: int, tzinfo: tzinfo \| None, trivia: Trivia, raw: str, ) -> None: super().__init__(trivia) self._raw = raw def unwrap(self) -> time: (hour, minute, second, microsecond, tzinfo, _, _) = self._getstate() return time(hour, minute, second, microsecond, tzinfo) @property def discriminant(self) -> int: return 7 @property def value(self) -> time: return self def as_string(self) -> str: return self._raw def replace(self, args: Any, kwargs: Any) -> time: return self._new(super().replace(args, *kwargs)) def _new(self, result): raw = result.isoformat() return Time( result.hour, result.minute, result.second, result.microsecond, result.tzinfo, self._trivia, raw, ) def _getstate(self, protocol: int = 3) -> tuple: return ( self.hour, self.minute, self.second, self.microsecond, self.tzinfo, self._trivia, self._raw, ) class _ArrayItemGroup: __slots__ = ("value", "indent", "comma", "comment") def __init__( self, value: Item \| None = None, indent: Whitespace \| None = None, comma: Whitespace \| None = None, comment: Comment \| None = None, ) -> None: self.value = value self.indent = indent self.comma = comma self.comment = comment def __iter__(self) -> Iterator[Item]: return filter( lambda x: x is not None, (self.indent, self.value, self.comma, self.comment) ) def __repr__(self) -> str: return repr(tuple(self)) def is_whitespace(self) -> bool: return self.value is None and self.comment is None def __bool__(self) -> bool: try: next(iter(self)) except StopIteration: return False return True class Array(Item, _CustomList): """ An array literal """ def __init__( self, value: list[Item], trivia: Trivia, multiline: bool = False ) -> None: super().__init__(trivia) list.__init__( self, [v for v in value if not isinstance(v, (Whitespace, Comment, Null))], ) self._index_map: dict[int, int] = {} self._value = self._group_values(value) self._multiline = multiline self._reindex() def _group_values(self, value: list[Item]) -> list[_ArrayItemGroup]: """Group the values into (indent, value, comma, comment) tuples""" groups = [] this_group = _ArrayItemGroup() for item in value: if isinstance(item, Whitespace): if "," not in item.s: groups.append(this_group) this_group = _ArrayItemGroup(indent=item) else: if this_group.value is None: # when comma is met and no value is provided, add a dummy Null this_group.value = Null() this_group.comma = item elif isinstance(item, Comment): if this_group.value is None: this_group.value = Null() this_group.comment = item elif this_group.value is None: this_group.value = item else: groups.append(this_group) this_group = _ArrayItemGroup(value=item) groups.append(this_group) return [group for group in groups if group] def unwrap(self) -> list[Any]: unwrapped = [] for v in self: if hasattr(v, "unwrap"): unwrapped.append(v.unwrap()) else: unwrapped.append(v) return unwrapped @property def discriminant(self) -> int: return 8 @property def value(self) -> list: return self def _iter_items(self) -> Iterator[Item]: for v in self._value: yield from v def multiline(self, multiline: bool) -> Array: """Change the array to display in multiline or not. :Example: >>> a = item([1, 2, 3]) >>> print(a.as_string()) [1, 2, 3] >>> print(a.multiline(True).as_string()) [ 1, 2, 3, ] """ self._multiline = multiline return self def as_string(self) -> str: if not self._multiline or not self._value: return f'[{"".join(v.as_string() for v in self._iter_items())}]' s = "[\n" s += "".join( self.trivia.indent + " " 4 + v.value.as_string() + ("," if not isinstance(v.value, Null) else "") + (v.comment.as_string() if v.comment is not None else "") + "\n" for v in self._value if v.value is not None ) s += self.trivia.indent + "]" return s def _reindex(self) -> None: self._index_map.clear() index = 0 for i, v in enumerate(self._value): if v.value is None or isinstance(v.value, Null): continue self._index_map[index] = i index += 1 def add_line( self, items: Any, indent: str = " ", comment: str \| None = None, add_comma: bool = True, newline: bool = True, ) -> None: """Add multiple items in a line to control the format precisely. When add_comma is True, only accept actual values and ", " will be added between values automatically. :Example: >>> a = array() >>> a.add_line(1, 2, 3) >>> a.add_line(4, 5, 6) >>> a.add_line(indent="") >>> print(a.as_string()) [ 1, 2, 3, 4, 5, 6, ] """ new_values: list[Item] = [] first_indent = f"\n{indent}" if newline else indent if first_indent: new_values.append(Whitespace(first_indent)) whitespace = "" data_values = [] for i, el in enumerate(items): it = item(el, _parent=self) if isinstance(it, Comment) or add_comma and isinstance(el, Whitespace): raise ValueError(f"item type {type(it)} is not allowed in add_line") if not isinstance(it, Whitespace): if whitespace: new_values.append(Whitespace(whitespace)) whitespace = "" new_values.append(it) data_values.append(it.value) if add_comma: new_values.append(Whitespace(",")) if i != len(items) - 1: new_values.append(Whitespace(" ")) elif "," not in it.s: whitespace += it.s else: new_values.append(it) if whitespace: new_values.append(Whitespace(whitespace)) if comment: indent = " " if items else "" new_values.append( Comment(Trivia(indent=indent, comment=f"# {comment}", trail="")) ) list.extend(self, data_values) if len(self._value) > 0: last_item = self._value[-1] last_value_item = next( ( v for v in self._value[::-1] if v.value is not None and not isinstance(v.value, Null) ), None, ) if last_value_item is not None: last_value_item.comma = Whitespace(",") if last_item.is_whitespace(): self._value[-1:-1] = self._group_values(new_values) else: self._value.extend(self._group_values(new_values)) else: self._value.extend(self._group_values(new_values)) self._reindex() def clear(self) -> None: """Clear the array.""" list.clear(self) self._index_map.clear() self._value.clear() def __len__(self) -> int: return list.__len__(self) def __getitem__(self, key: int \| slice) -> Any: rv = cast(Item, list.__getitem__(self, key)) if rv.is_boolean(): return bool(rv) return rv def __setitem__(self, key: int \| slice, value: Any) -> Any: it = item(value, _parent=self) list.__setitem__(self, key, it) if isinstance(key, slice): raise ValueError("slice assignment is not supported") if key < 0: key += len(self) self._value[self._index_map[key]].value = it def insert(self, pos: int, value: Any) -> None: it = item(value, _parent=self) length = len(self) if not isinstance(it, (Comment, Whitespace)): list.insert(self, pos, it) if pos < 0: pos += length if pos < 0: pos = 0 idx = 0 # insert position of the self._value list default_indent = " " if pos < length: try: idx = self._index_map[pos] except KeyError as e: raise IndexError("list index out of range") from e else: idx = len(self._value) if idx >= 1 and self._value[idx - 1].is_whitespace(): # The last item is a pure whitespace(\n ), insert before it idx -= 1 if ( self._value[idx].indent is not None and "\n" in self._value[idx].indent.s ): default_indent = "\n " indent: Item \| None = None comma: Item \| None = Whitespace(",") if pos < length else None if idx < len(self._value) and not self._value[idx].is_whitespace(): # Prefer to copy the indentation from the item after indent = self._value[idx].indent if idx > 0: last_item = self._value[idx - 1] if indent is None: indent = last_item.indent if not isinstance(last_item.value, Null) and "\n" in default_indent: # Copy the comma from the last item if 1) it contains a value and # 2) the array is multiline comma = last_item.comma if last_item.comma is None and not isinstance(last_item.value, Null): # Add comma to the last item to separate it from the following items. last_item.comma = Whitespace(",") if indent is None and (idx > 0 or "\n" in default_indent): # apply default indent if it isn't the first item or the array is multiline. indent = Whitespace(default_indent) new_item = _ArrayItemGroup(value=it, indent=indent, comma=comma) self._value.insert(idx, new_item) self._reindex() def __delitem__(self, key: int \| slice): length = len(self) list.__delitem__(self, key) if isinstance(key, slice): indices_to_remove = list( range(key.start or 0, key.stop or length, key.step or 1) ) else: indices_to_remove = [length + key if key < 0 else key] for i in sorted(indices_to_remove, reverse=True): try: idx = self._index_map[i] except KeyError as e: if not isinstance(key, slice): raise IndexError("list index out of range") from e else: del self._value[idx] if ( idx == 0 and len(self._value) > 0 and "\n" not in self._value[idx].indent.s ): # Remove the indentation of the first item if not newline self._value[idx].indent = None if len(self._value) > 0: v = self._value[-1] if not v.is_whitespace(): # remove the comma of the last item v.comma = None self._reindex() def _getstate(self, protocol=3): return list(self._iter_items()), self._trivia, self._multiline AT = TypeVar("AT", bound="AbstractTable") class AbstractTable(Item, _CustomDict): """Common behaviour of both :class:`Table` and :class:`InlineTable`""" def __init__(self, value: container.Container, trivia: Trivia): Item.__init__(self, trivia) self._value = value for k, v in self._value.body: if k is not None: dict.__setitem__(self, k.key, v) def unwrap(self) -> dict[str, Any]: unwrapped = {} for k, v in self.items(): if isinstance(k, Key): k = k.key if hasattr(v, "unwrap"): v = v.unwrap() unwrapped[k] = v return unwrapped @property def value(self) -> container.Container: return self._value @overload def append(self: AT, key: None, value: Comment \| Whitespace) -> AT: ... @overload def append(self: AT, key: Key \| str, value: Any) -> AT: ... def append(self, key, value): raise NotImplementedError @overload def add(self: AT, value: Comment \| Whitespace) -> AT: ... @overload def add(self: AT, key: Key \| str, value: Any) -> AT: ... def add(self, key, value=None): if value is None: if not isinstance(key, (Comment, Whitespace)): msg = "Non comment/whitespace items must have an associated key" raise ValueError(msg) key, value = None, key return self.append(key, value) def remove(self: AT, key: Key \| str) -> AT: self._value.remove(key) if isinstance(key, Key): key = key.key if key is not None: dict.__delitem__(self, key) return self def setdefault(self, key: Key \| str, default: Any) -> Any: super().setdefault(key, default) return self[key] def __str__(self): return str(self.value) def copy(self: AT) -> AT: return copy.copy(self) def __repr__(self) -> str: return repr(self.value) def __iter__(self) -> Iterator[str]: return iter(self._value) def __len__(self) -> int: return len(self._value) def __delitem__(self, key: Key \| str) -> None: self.remove(key) def __getitem__(self, key: Key \| str) -> Item: return cast(Item, self._value[key]) def __setitem__(self, key: Key \| str, value: Any) -> None: if not isinstance(value, Item): value = item(value, _parent=self) is_replace = key in self self._value[key] = value if key is not None: dict.__setitem__(self, key, value) if is_replace: return m = re.match("(?s)^[^ ]([ ]+).$", self._trivia.indent) if not m: return indent = m.group(1) if not isinstance(value, Whitespace): m = re.match("(?s)^([^ ])(.)$", value.trivia.indent) if not m: value.trivia.indent = indent else: value.trivia.indent = m.group(1) + indent + m.group(2) class Table(AbstractTable): """ A table literal. """ def __init__( self, value: container.Container, trivia: Trivia, is_aot_element: bool, is_super_table: bool \| None = None, name: str \| None = None, display_name: str \| None = None, ) -> None: super().__init__(value, trivia) self.name = name self.display_name = display_name self._is_aot_element = is_aot_element self._is_super_table = is_super_table @property def discriminant(self) -> int: return 9 def __copy__(self) -> Table: return type(self)( self._value.copy(), self._trivia.copy(), self._is_aot_element, self._is_super_table, self.name, self.display_name, ) def append(self, key: Key \| str \| None, _item: Any) -> Table: """ Appends a (key, item) to the table. """ if not isinstance(_item, Item): _item = item(_item, _parent=self) self._value.append(key, _item) if isinstance(key, Key): key = next(iter(key)).key _item = self._value[key] if key is not None: dict.__setitem__(self, key, _item) m = re.match(r"(?s)^[^ ]([ ]+).$", self._trivia.indent) if not m: return self indent = m.group(1) if not isinstance(_item, Whitespace): m = re.match("(?s)^([^ ])(.)$", _item.trivia.indent) if not m: _item.trivia.indent = indent else: _item.trivia.indent = m.group(1) + indent + m.group(2) return self def raw_append(self, key: Key \| str \| None, _item: Any) -> Table: """Similar to :meth:`append` but does not copy indentation.""" if not isinstance(_item, Item): _item = item(_item) self._value.append(key, _item) if isinstance(key, Key): key = next(iter(key)).key _item = self._value[key] if key is not None: dict.__setitem__(self, key, _item) return self def is_aot_element(self) -> bool: """True if the table is the direct child of an AOT element.""" return self._is_aot_element def is_super_table(self) -> bool: """A super table is the intermediate parent of a nested table as in [a.b.c]. If true, it won't appear in the TOML representation.""" if self._is_super_table is not None: return self._is_super_table # If the table has only one child and that child is a table, then it is a super table. if len(self) != 1: return False only_child = next(iter(self.values())) return isinstance(only_child, (Table, AoT)) def as_string(self) -> str: return self._value.as_string() # Helpers def indent(self, indent: int) -> Table: """Indent the table with given number of spaces.""" super().indent(indent) m = re.match("(?s)^[^ ]([ ]+).$", self._trivia.indent) if not m: indent_str = "" else: indent_str = m.group(1) for _, item in self._value.body: if not isinstance(item, Whitespace): item.trivia.indent = indent_str + item.trivia.indent return self def invalidate_display_name(self): self.display_name = None for child in self.values(): if hasattr(child, "invalidate_display_name"): child.invalidate_display_name() def _getstate(self, protocol: int = 3) -> tuple: return ( self._value, self._trivia, self._is_aot_element, self._is_super_table, self.name, self.display_name, ) class InlineTable(AbstractTable): """ An inline table literal. """ def __init__( self, value: container.Container, trivia: Trivia, new: bool = False ) -> None: super().__init__(value, trivia) self._new = new @property def discriminant(self) -> int: return 10 def append(self, key: Key \| str \| None, _item: Any) -> InlineTable: """ Appends a (key, item) to the table. """ if not isinstance(_item, Item): _item = item(_item, _parent=self) if not isinstance(_item, (Whitespace, Comment)): if not _item.trivia.indent and len(self._value) > 0 and not self._new: _item.trivia.indent = " " if _item.trivia.comment: _item.trivia.comment = "" self._value.append(key, _item) if isinstance(key, Key): key = key.key if key is not None: dict.__setitem__(self, key, _item) return self def as_string(self) -> str: buf = "{" last_item_idx = next( ( i for i in range(len(self._value.body) - 1, -1, -1) if self._value.body[i][0] is not None ), None, ) for i, (k, v) in enumerate(self._value.body): if k is None: if i == len(self._value.body) - 1: if self._new: buf = buf.rstrip(", ") else: buf = buf.rstrip(",") buf += v.as_string() continue v_trivia_trail = v.trivia.trail.replace("\n", "") buf += ( f"{v.trivia.indent}" f'{k.as_string() + ("." if k.is_dotted() else "")}' f"{k.sep}" f"{v.as_string()}" f"{v.trivia.comment}" f"{v_trivia_trail}" ) if last_item_idx is not None and i < last_item_idx: buf += "," if self._new: buf += " " buf += "}" return buf def __setitem__(self, key: Key \| str, value: Any) -> None: if hasattr(value, "trivia") and value.trivia.comment: value.trivia.comment = "" super().__setitem__(key, value) def __copy__(self) -> InlineTable: return type(self)(self._value.copy(), self._trivia.copy(), self._new) def _getstate(self, protocol: int = 3) -> tuple: return (self._value, self._trivia) class String(str, Item): """ A string literal. """ def __new__(cls, t, value, original, trivia): return super().__new__(cls, value) def __init__(self, t: StringType, _: str, original: str, trivia: Trivia) -> None: super().__init__(trivia) self._t = t self._original = original def unwrap(self) -> str: return str(self) @property def discriminant(self) -> int: return 11 @property def value(self) -> str: return self def as_string(self) -> str: return f"{self._t.value}{decode(self._original)}{self._t.value}" def __add__(self: ItemT, other: str) -> ItemT: if not isinstance(other, str): return NotImplemented result = super().__add__(other) original = self._original + getattr(other, "_original", other) return self._new(result, original) def _new(self, result: str, original: str) -> String: return String(self._t, result, original, self._trivia) def _getstate(self, protocol=3): return self._t, str(self), self._original, self._trivia @classmethod def from_raw(cls, value: str, type_=StringType.SLB, escape=True) -> String: value = decode(value) invalid = type_.invalid_sequences if any(c in value for c in invalid): raise InvalidStringError(value, invalid, type_.value) escaped = type_.escaped_sequences string_value = escape_string(value, escaped) if escape and escaped else value return cls(type_, decode(value), string_value, Trivia()) class AoT(Item, _CustomList): """ An array of table literal """ def __init__( self, body: list[Table], name: str \| None = None, parsed: bool = False ) -> None: self.name = name self._body: list[Table] = [] self._parsed = parsed super().__init__(Trivia(trail="")) for table in body: self.append(table) def unwrap(self) -> list[dict[str, Any]]: unwrapped = [] for t in self._body: if hasattr(t, "unwrap"): unwrapped.append(t.unwrap()) else: unwrapped.append(t) return unwrapped @property def body(self) -> list[Table]: return self._body @property def discriminant(self) -> int: return 12 @property def value(self) -> list[dict[Any, Any]]: return [v.value for v in self._body] def __len__(self) -> int: return len(self._body) @overload def __getitem__(self, key: slice) -> list[Table]: ... @overload def __getitem__(self, key: int) -> Table: ... def __getitem__(self, key): return self._body[key] def __setitem__(self, key: slice \| int, value: Any) -> None: raise NotImplementedError def __delitem__(self, key: slice \| int) -> None: del self._body[key] list.__delitem__(self, key) def insert(self, index: int, value: dict) -> None: value = item(value, _parent=self) if not isinstance(value, Table): raise ValueError(f"Unsupported insert value type: {type(value)}") length = len(self) if index < 0: index += length if index < 0: index = 0 elif index >= length: index = length m = re.match("(?s)^[^ ]([ ]+).$", self._trivia.indent) if m: indent = m.group(1) m = re.match("(?s)^([^ ])(.*)$", value.trivia.indent) if not m: value.trivia.indent = indent else: value.trivia.indent = m.group(1) + indent + m.group(2) prev_table = self._body[index - 1] if 0 < index and length else None next_table = self._body[index + 1] if index < length - 1 else None if not self._parsed: if prev_table and "\n" not in value.trivia.indent: value.trivia.indent = "\n" + value.trivia.indent if next_table and "\n" not in next_table.trivia.indent: next_table.trivia.indent = "\n" + next_table.trivia.indent self._body.insert(index, value) list.insert(self, index, value) def invalidate_display_name(self): """Call ``invalidate_display_name`` on the contained tables""" for child in self: if hasattr(child, "invalidate_display_name"): child.invalidate_display_name() def as_string(self) -> str: b = "" for table in self._body: b += table.as_string() return b def __repr__(self) -> str: return f"<AoT {self.value}>" def _getstate(self, protocol=3): return self._body, self.name, self._parsed class Null(Item): """ A null item. """ def __init__(self) -> None: pass def unwrap(self) -> None: return None @property def discriminant(self) -> int: return -1 @property def value(self) -> None: return None def as_string(self) -> str: return "" def _getstate(self, protocol=3) -> tuple: return ()	50.48 KB	2026-01-20 12:58
📄 parser.py from __future__ import annotations import datetime import re import string from tomlkit._compat import decode from tomlkit._utils import RFC_3339_LOOSE from tomlkit._utils import _escaped from tomlkit._utils import parse_rfc3339 from tomlkit.container import Container from tomlkit.exceptions import EmptyKeyError from tomlkit.exceptions import EmptyTableNameError from tomlkit.exceptions import InternalParserError from tomlkit.exceptions import InvalidCharInStringError from tomlkit.exceptions import InvalidControlChar from tomlkit.exceptions import InvalidDateError from tomlkit.exceptions import InvalidDateTimeError from tomlkit.exceptions import InvalidNumberError from tomlkit.exceptions import InvalidTimeError from tomlkit.exceptions import InvalidUnicodeValueError from tomlkit.exceptions import ParseError from tomlkit.exceptions import UnexpectedCharError from tomlkit.exceptions import UnexpectedEofError from tomlkit.items import AoT from tomlkit.items import Array from tomlkit.items import Bool from tomlkit.items import BoolType from tomlkit.items import Comment from tomlkit.items import Date from tomlkit.items import DateTime from tomlkit.items import Float from tomlkit.items import InlineTable from tomlkit.items import Integer from tomlkit.items import Item from tomlkit.items import Key from tomlkit.items import KeyType from tomlkit.items import Null from tomlkit.items import SingleKey from tomlkit.items import String from tomlkit.items import StringType from tomlkit.items import Table from tomlkit.items import Time from tomlkit.items import Trivia from tomlkit.items import Whitespace from tomlkit.source import Source from tomlkit.toml_char import TOMLChar from tomlkit.toml_document import TOMLDocument CTRL_I = 0x09 # Tab CTRL_J = 0x0A # Line feed CTRL_M = 0x0D # Carriage return CTRL_CHAR_LIMIT = 0x1F CHR_DEL = 0x7F class Parser: """ Parser for TOML documents. """ def __init__(self, string: str) -> None: # Input to parse self._src = Source(decode(string)) self._aot_stack: list[Key] = [] @property def _state(self): return self._src.state @property def _idx(self): return self._src.idx @property def _current(self): return self._src.current @property def _marker(self): return self._src.marker def extract(self) -> str: """ Extracts the value between marker and index """ return self._src.extract() def inc(self, exception: type[ParseError] \| None = None) -> bool: """ Increments the parser if the end of the input has not been reached. Returns whether or not it was able to advance. """ return self._src.inc(exception=exception) def inc_n(self, n: int, exception: type[ParseError] \| None = None) -> bool: """ Increments the parser by n characters if the end of the input has not been reached. """ return self._src.inc_n(n=n, exception=exception) def consume(self, chars, min=0, max=-1): """ Consume chars until min/max is satisfied is valid. """ return self._src.consume(chars=chars, min=min, max=max) def end(self) -> bool: """ Returns True if the parser has reached the end of the input. """ return self._src.end() def mark(self) -> None: """ Sets the marker to the index's current position """ self._src.mark() def parse_error(self, exception=ParseError, args, kwargs): """ Creates a generic "parse error" at the current position. """ return self._src.parse_error(exception, args, **kwargs) def parse(self) -> TOMLDocument: body = TOMLDocument(True) # Take all keyvals outside of tables/AoT's. while not self.end(): # Break out if a table is found if self._current == "[": break # Otherwise, take and append one KV item = self._parse_item() if not item: break key, value = item if (key is not None and key.is_multi()) or not self._merge_ws(value, body): # We actually have a table try: body.append(key, value) except Exception as e: raise self.parse_error(ParseError, str(e)) from e self.mark() while not self.end(): key, value = self._parse_table() if isinstance(value, Table) and value.is_aot_element(): # This is just the first table in an AoT. Parse the rest of the array # along with it. value = self._parse_aot(value, key) try: body.append(key, value) except Exception as e: raise self.parse_error(ParseError, str(e)) from e body.parsing(False) return body def _merge_ws(self, item: Item, container: Container) -> bool: """ Merges the given Item with the last one currently in the given Container if both are whitespace items. Returns True if the items were merged. """ last = container.last_item() if not last: return False if not isinstance(item, Whitespace) or not isinstance(last, Whitespace): return False start = self._idx - (len(last.s) + len(item.s)) container.body[-1] = ( container.body[-1][0], Whitespace(self._src[start : self._idx]), ) return True def _is_child(self, parent: Key, child: Key) -> bool: """ Returns whether a key is strictly a child of another key. AoT siblings are not considered children of one another. """ parent_parts = tuple(parent) child_parts = tuple(child) if parent_parts == child_parts: return False return parent_parts == child_parts[: len(parent_parts)] def _parse_item(self) -> tuple[Key \| None, Item] \| None: """ Attempts to parse the next item and returns it, along with its key if the item is value-like. """ self.mark() with self._state as state: while True: c = self._current if c == "\n": # Found a newline; Return all whitespace found up to this point. self.inc() return None, Whitespace(self.extract()) elif c in " \t\r": # Skip whitespace. if not self.inc(): return None, Whitespace(self.extract()) elif c == "#": # Found a comment, parse it indent = self.extract() cws, comment, trail = self._parse_comment_trail() return None, Comment(Trivia(indent, cws, comment, trail)) elif c == "[": # Found a table, delegate to the calling function. return else: # Beginning of a KV pair. # Return to beginning of whitespace so it gets included # as indentation for the KV about to be parsed. state.restore = True break return self._parse_key_value(True) def _parse_comment_trail(self, parse_trail: bool = True) -> tuple[str, str, str]: """ Returns (comment_ws, comment, trail) If there is no comment, comment_ws and comment will simply be empty. """ if self.end(): return "", "", "" comment = "" comment_ws = "" self.mark() while True: c = self._current if c == "\n": break elif c == "#": comment_ws = self.extract() self.mark() self.inc() # Skip # # The comment itself while not self.end() and not self._current.is_nl(): code = ord(self._current) if code == CHR_DEL or code <= CTRL_CHAR_LIMIT and code != CTRL_I: raise self.parse_error(InvalidControlChar, code, "comments") if not self.inc(): break comment = self.extract() self.mark() break elif c in " \t\r": self.inc() else: raise self.parse_error(UnexpectedCharError, c) if self.end(): break trail = "" if parse_trail: while self._current.is_spaces() and self.inc(): pass if self._current == "\r": self.inc() if self._current == "\n": self.inc() if self._idx != self._marker or self._current.is_ws(): trail = self.extract() return comment_ws, comment, trail def _parse_key_value(self, parse_comment: bool = False) -> tuple[Key, Item]: # Leading indent self.mark() while self._current.is_spaces() and self.inc(): pass indent = self.extract() # Key key = self._parse_key() self.mark() found_equals = self._current == "=" while self._current.is_kv_sep() and self.inc(): if self._current == "=": if found_equals: raise self.parse_error(UnexpectedCharError, "=") else: found_equals = True if not found_equals: raise self.parse_error(UnexpectedCharError, self._current) if not key.sep: key.sep = self.extract() else: key.sep += self.extract() # Value val = self._parse_value() # Comment if parse_comment: cws, comment, trail = self._parse_comment_trail() meta = val.trivia if not meta.comment_ws: meta.comment_ws = cws meta.comment = comment meta.trail = trail else: val.trivia.trail = "" val.trivia.indent = indent return key, val def _parse_key(self) -> Key: """ Parses a Key at the current position; WS before the key must be exhausted first at the callsite. """ self.mark() while self._current.is_spaces() and self.inc(): # Skip any leading whitespace pass if self._current in "\"'": return self._parse_quoted_key() else: return self._parse_bare_key() def _parse_quoted_key(self) -> Key: """ Parses a key enclosed in either single or double quotes. """ # Extract the leading whitespace original = self.extract() quote_style = self._current key_type = next((t for t in KeyType if t.value == quote_style), None) if key_type is None: raise RuntimeError("Should not have entered _parse_quoted_key()") key_str = self._parse_string( StringType.SLB if key_type == KeyType.Basic else StringType.SLL ) if key_str._t.is_multiline(): raise self.parse_error(UnexpectedCharError, key_str._t.value) original += key_str.as_string() self.mark() while self._current.is_spaces() and self.inc(): pass original += self.extract() key = SingleKey(str(key_str), t=key_type, sep="", original=original) if self._current == ".": self.inc() key = key.concat(self._parse_key()) return key def _parse_bare_key(self) -> Key: """ Parses a bare key. """ while ( self._current.is_bare_key_char() or self._current.is_spaces() ) and self.inc(): pass original = self.extract() key = original.strip() if not key: # Empty key raise self.parse_error(EmptyKeyError) if " " in key: # Bare key with spaces in it raise self.parse_error(ParseError, f'Invalid key "{key}"') key = SingleKey(key, KeyType.Bare, "", original) if self._current == ".": self.inc() key = key.concat(self._parse_key()) return key def _parse_value(self) -> Item: """ Attempts to parse a value at the current position. """ self.mark() c = self._current trivia = Trivia() if c == StringType.SLB.value: return self._parse_basic_string() elif c == StringType.SLL.value: return self._parse_literal_string() elif c == BoolType.TRUE.value[0]: return self._parse_true() elif c == BoolType.FALSE.value[0]: return self._parse_false() elif c == "[": return self._parse_array() elif c == "{": return self._parse_inline_table() elif c in "+-" or self._peek(4) in { "+inf", "-inf", "inf", "+nan", "-nan", "nan", }: # Number while self._current not in " \t\n\r#,]}" and self.inc(): pass raw = self.extract() item = self._parse_number(raw, trivia) if item is not None: return item raise self.parse_error(InvalidNumberError) elif c in string.digits: # Integer, Float, Date, Time or DateTime while self._current not in " \t\n\r#,]}" and self.inc(): pass raw = self.extract() m = RFC_3339_LOOSE.match(raw) if m: if m.group(1) and m.group(5): # datetime try: dt = parse_rfc3339(raw) assert isinstance(dt, datetime.datetime) return DateTime( dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, dt.tzinfo, trivia, raw, ) except ValueError: raise self.parse_error(InvalidDateTimeError) if m.group(1): try: dt = parse_rfc3339(raw) assert isinstance(dt, datetime.date) date = Date(dt.year, dt.month, dt.day, trivia, raw) self.mark() while self._current not in "\t\n\r#,]}" and self.inc(): pass time_raw = self.extract() time_part = time_raw.rstrip() trivia.comment_ws = time_raw[len(time_part) :] if not time_part: return date dt = parse_rfc3339(raw + time_part) assert isinstance(dt, datetime.datetime) return DateTime( dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, dt.tzinfo, trivia, raw + time_part, ) except ValueError: raise self.parse_error(InvalidDateError) if m.group(5): try: t = parse_rfc3339(raw) assert isinstance(t, datetime.time) return Time( t.hour, t.minute, t.second, t.microsecond, t.tzinfo, trivia, raw, ) except ValueError: raise self.parse_error(InvalidTimeError) item = self._parse_number(raw, trivia) if item is not None: return item raise self.parse_error(InvalidNumberError) else: raise self.parse_error(UnexpectedCharError, c) def _parse_true(self): return self._parse_bool(BoolType.TRUE) def _parse_false(self): return self._parse_bool(BoolType.FALSE) def _parse_bool(self, style: BoolType) -> Bool: with self._state: style = BoolType(style) # only keep parsing for bool if the characters match the style # try consuming rest of chars in style for c in style: self.consume(c, min=1, max=1) return Bool(style, Trivia()) def _parse_array(self) -> Array: # Consume opening bracket, EOF here is an issue (middle of array) self.inc(exception=UnexpectedEofError) elems: list[Item] = [] prev_value = None while True: # consume whitespace mark = self._idx self.consume(TOMLChar.SPACES + TOMLChar.NL) indent = self._src[mark : self._idx] newline = set(TOMLChar.NL) & set(indent) if newline: elems.append(Whitespace(indent)) continue # consume comment if self._current == "#": cws, comment, trail = self._parse_comment_trail(parse_trail=False) elems.append(Comment(Trivia(indent, cws, comment, trail))) continue # consume indent if indent: elems.append(Whitespace(indent)) continue # consume value if not prev_value: try: elems.append(self._parse_value()) prev_value = True continue except UnexpectedCharError: pass # consume comma if prev_value and self._current == ",": self.inc(exception=UnexpectedEofError) elems.append(Whitespace(",")) prev_value = False continue # consume closing bracket if self._current == "]": # consume closing bracket, EOF here doesn't matter self.inc() break raise self.parse_error(UnexpectedCharError, self._current) try: res = Array(elems, Trivia()) except ValueError: pass else: return res def _parse_inline_table(self) -> InlineTable: # consume opening bracket, EOF here is an issue (middle of array) self.inc(exception=UnexpectedEofError) elems = Container(True) trailing_comma = None while True: # consume leading whitespace mark = self._idx self.consume(TOMLChar.SPACES) raw = self._src[mark : self._idx] if raw: elems.add(Whitespace(raw)) if not trailing_comma: # None: empty inline table # False: previous key-value pair was not followed by a comma if self._current == "}": # consume closing bracket, EOF here doesn't matter self.inc() break if ( trailing_comma is False or trailing_comma is None and self._current == "," ): # Either the previous key-value pair was not followed by a comma # or the table has an unexpected leading comma. raise self.parse_error(UnexpectedCharError, self._current) else: # True: previous key-value pair was followed by a comma if self._current == "}" or self._current == ",": raise self.parse_error(UnexpectedCharError, self._current) key, val = self._parse_key_value(False) elems.add(key, val) # consume trailing whitespace mark = self._idx self.consume(TOMLChar.SPACES) raw = self._src[mark : self._idx] if raw: elems.add(Whitespace(raw)) # consume trailing comma trailing_comma = self._current == "," if trailing_comma: # consume closing bracket, EOF here is an issue (middle of inline table) self.inc(exception=UnexpectedEofError) return InlineTable(elems, Trivia()) def _parse_number(self, raw: str, trivia: Trivia) -> Item \| None: # Leading zeros are not allowed sign = "" if raw.startswith(("+", "-")): sign = raw[0] raw = raw[1:] if len(raw) > 1 and ( raw.startswith("0") and not raw.startswith(("0.", "0o", "0x", "0b", "0e")) or sign and raw.startswith(".") ): return None if raw.startswith(("0o", "0x", "0b")) and sign: return None digits = "[0-9]" base = 10 if raw.startswith("0b"): digits = "[01]" base = 2 elif raw.startswith("0o"): digits = "[0-7]" base = 8 elif raw.startswith("0x"): digits = "[0-9a-f]" base = 16 # Underscores should be surrounded by digits clean = re.sub(f"(?i)(?<={digits})_(?={digits})", "", raw).lower() if "_" in clean: return None if ( clean.endswith(".") or not clean.startswith("0x") and clean.split("e", 1)[0].endswith(".") ): return None try: return Integer(int(sign + clean, base), trivia, sign + raw) except ValueError: try: return Float(float(sign + clean), trivia, sign + raw) except ValueError: return None def _parse_literal_string(self) -> String: with self._state: return self._parse_string(StringType.SLL) def _parse_basic_string(self) -> String: with self._state: return self._parse_string(StringType.SLB) def _parse_escaped_char(self, multiline): if multiline and self._current.is_ws(): # When the last non-whitespace character on a line is # a \, it will be trimmed along with all whitespace # (including newlines) up to the next non-whitespace # character or closing delimiter. # """\ # hello \ # world""" tmp = "" while self._current.is_ws(): tmp += self._current # consume the whitespace, EOF here is an issue # (middle of string) self.inc(exception=UnexpectedEofError) continue # the escape followed by whitespace must have a newline # before any other chars if "\n" not in tmp: raise self.parse_error(InvalidCharInStringError, self._current) return "" if self._current in _escaped: c = _escaped[self._current] # consume this char, EOF here is an issue (middle of string) self.inc(exception=UnexpectedEofError) return c if self._current in {"u", "U"}: # this needs to be a unicode u, ue = self._peek_unicode(self._current == "U") if u is not None: # consume the U char and the unicode value self.inc_n(len(ue) + 1) return u raise self.parse_error(InvalidUnicodeValueError) raise self.parse_error(InvalidCharInStringError, self._current) def _parse_string(self, delim: StringType) -> String: # only keep parsing for string if the current character matches the delim if self._current != delim.unit: raise self.parse_error( InternalParserError, f"Invalid character for string type {delim}", ) # consume the opening/first delim, EOF here is an issue # (middle of string or middle of delim) self.inc(exception=UnexpectedEofError) if self._current == delim.unit: # consume the closing/second delim, we do not care if EOF occurs as # that would simply imply an empty single line string if not self.inc() or self._current != delim.unit: # Empty string return String(delim, "", "", Trivia()) # consume the third delim, EOF here is an issue (middle of string) self.inc(exception=UnexpectedEofError) delim = delim.toggle() # convert delim to multi delim self.mark() # to extract the original string with whitespace and all value = "" # A newline immediately following the opening delimiter will be trimmed. if delim.is_multiline(): if self._current == "\n": # consume the newline, EOF here is an issue (middle of string) self.inc(exception=UnexpectedEofError) else: cur = self._current with self._state(restore=True): if self.inc(): cur += self._current if cur == "\r\n": self.inc_n(2, exception=UnexpectedEofError) escaped = False # whether the previous key was ESCAPE while True: code = ord(self._current) if ( delim.is_singleline() and not escaped and (code == CHR_DEL or code <= CTRL_CHAR_LIMIT and code != CTRL_I) ) or ( delim.is_multiline() and not escaped and ( code == CHR_DEL or code <= CTRL_CHAR_LIMIT and code not in [CTRL_I, CTRL_J, CTRL_M] ) ): raise self.parse_error(InvalidControlChar, code, "strings") elif not escaped and self._current == delim.unit: # try to process current as a closing delim original = self.extract() close = "" if delim.is_multiline(): # Consume the delimiters to see if we are at the end of the string close = "" while self._current == delim.unit: close += self._current self.inc() if len(close) < 3: # Not a triple quote, leave in result as-is. # Adding back the characters we already consumed value += close continue if len(close) == 3: # We are at the end of the string return String(delim, value, original, Trivia()) if len(close) >= 6: raise self.parse_error(InvalidCharInStringError, self._current) value += close[:-3] original += close[:-3] return String(delim, value, original, Trivia()) else: # consume the closing delim, we do not care if EOF occurs as # that would simply imply the end of self._src self.inc() return String(delim, value, original, Trivia()) elif delim.is_basic() and escaped: # attempt to parse the current char as an escaped value, an exception # is raised if this fails value += self._parse_escaped_char(delim.is_multiline()) # no longer escaped escaped = False elif delim.is_basic() and self._current == "\\": # the next char is being escaped escaped = True # consume this char, EOF here is an issue (middle of string) self.inc(exception=UnexpectedEofError) else: # this is either a literal string where we keep everything as is, # or this is not a special escaped char in a basic string value += self._current # consume this char, EOF here is an issue (middle of string) self.inc(exception=UnexpectedEofError) def _parse_table( self, parent_name: Key \| None = None, parent: Table \| None = None ) -> tuple[Key, Table \| AoT]: """ Parses a table element. """ if self._current != "[": raise self.parse_error( InternalParserError, "_parse_table() called on non-bracket character." ) indent = self.extract() self.inc() # Skip opening bracket if self.end(): raise self.parse_error(UnexpectedEofError) is_aot = False if self._current == "[": if not self.inc(): raise self.parse_error(UnexpectedEofError) is_aot = True try: key = self._parse_key() except EmptyKeyError: raise self.parse_error(EmptyTableNameError) from None if self.end(): raise self.parse_error(UnexpectedEofError) elif self._current != "]": raise self.parse_error(UnexpectedCharError, self._current) key.sep = "" full_key = key name_parts = tuple(key) if any(" " in part.key.strip() and part.is_bare() for part in name_parts): raise self.parse_error( ParseError, f'Invalid table name "{full_key.as_string()}"' ) missing_table = False if parent_name: parent_name_parts = tuple(parent_name) else: parent_name_parts = () if len(name_parts) > len(parent_name_parts) + 1: missing_table = True name_parts = name_parts[len(parent_name_parts) :] values = Container(True) self.inc() # Skip closing bracket if is_aot: # TODO: Verify close bracket self.inc() cws, comment, trail = self._parse_comment_trail() result = Null() table = Table( values, Trivia(indent, cws, comment, trail), is_aot, name=name_parts[0].key if name_parts else key.key, display_name=full_key.as_string(), is_super_table=False, ) if len(name_parts) > 1: if missing_table: # Missing super table # i.e. a table initialized like this: [foo.bar] # without initializing [foo] # # So we have to create the parent tables table = Table( Container(True), Trivia("", cws, comment, trail), is_aot and name_parts[0] in self._aot_stack, is_super_table=True, name=name_parts[0].key, ) result = table key = name_parts[0] for i, _name in enumerate(name_parts[1:]): child = table.get( _name, Table( Container(True), Trivia(indent, cws, comment, trail), is_aot and i == len(name_parts) - 2, is_super_table=i < len(name_parts) - 2, name=_name.key, display_name=full_key.as_string() if i == len(name_parts) - 2 else None, ), ) if is_aot and i == len(name_parts) - 2: table.raw_append(_name, AoT([child], name=table.name, parsed=True)) else: table.raw_append(_name, child) table = child values = table.value else: if name_parts: key = name_parts[0] while not self.end(): item = self._parse_item() if item: _key, item = item if not self._merge_ws(item, values): table.raw_append(_key, item) else: if self._current == "[": _, key_next = self._peek_table() if self._is_child(full_key, key_next): key_next, table_next = self._parse_table(full_key, table) table.raw_append(key_next, table_next) # Picking up any sibling while not self.end(): _, key_next = self._peek_table() if not self._is_child(full_key, key_next): break key_next, table_next = self._parse_table(full_key, table) table.raw_append(key_next, table_next) break else: raise self.parse_error( InternalParserError, "_parse_item() returned None on a non-bracket character.", ) if isinstance(result, Null): result = table if is_aot and (not self._aot_stack or full_key != self._aot_stack[-1]): result = self._parse_aot(result, full_key) return key, result def _peek_table(self) -> tuple[bool, Key]: """ Peeks ahead non-intrusively by cloning then restoring the initial state of the parser. Returns the name of the table about to be parsed, as well as whether it is part of an AoT. """ # we always want to restore after exiting this scope with self._state(save_marker=True, restore=True): if self._current != "[": raise self.parse_error( InternalParserError, "_peek_table() entered on non-bracket character", ) # AoT self.inc() is_aot = False if self._current == "[": self.inc() is_aot = True try: return is_aot, self._parse_key() except EmptyKeyError: raise self.parse_error(EmptyTableNameError) from None def _parse_aot(self, first: Table, name_first: Key) -> AoT: """ Parses all siblings of the provided table first and bundles them into an AoT. """ payload = [first] self._aot_stack.append(name_first) while not self.end(): is_aot_next, name_next = self._peek_table() if is_aot_next and name_next == name_first: _, table = self._parse_table(name_first) payload.append(table) else: break self._aot_stack.pop() return AoT(payload, parsed=True) def _peek(self, n: int) -> str: """ Peeks ahead n characters. n is the max number of characters that will be peeked. """ # we always want to restore after exiting this scope with self._state(restore=True): buf = "" for _ in range(n): if self._current not in " \t\n\r#,]}" + self._src.EOF: buf += self._current self.inc() continue break return buf def _peek_unicode(self, is_long: bool) -> tuple[str \| None, str \| None]: """ Peeks ahead non-intrusively by cloning then restoring the initial state of the parser. Returns the unicode value is it's a valid one else None. """ # we always want to restore after exiting this scope with self._state(save_marker=True, restore=True): if self._current not in {"u", "U"}: raise self.parse_error( InternalParserError, "_peek_unicode() entered on non-unicode value" ) self.inc() # Dropping prefix self.mark() if is_long: chars = 8 else: chars = 4 if not self.inc_n(chars): value, extracted = None, None else: extracted = self.extract() if extracted[0].lower() == "d" and extracted[1].strip("01234567"): return None, None try: value = chr(int(extracted, 16)) except (ValueError, OverflowError): value = None return value, extracted	36.95 KB	2026-01-20 12:58
📄 py.typed	0 B	2026-01-20 12:58
📄 source.py from __future__ import annotations from copy import copy from typing import Any from tomlkit.exceptions import ParseError from tomlkit.exceptions import UnexpectedCharError from tomlkit.toml_char import TOMLChar class _State: def __init__( self, source: Source, save_marker: bool \| None = False, restore: bool \| None = False, ) -> None: self._source = source self._save_marker = save_marker self.restore = restore def __enter__(self) -> _State: # Entering this context manager - save the state self._chars = copy(self._source._chars) self._idx = self._source._idx self._current = self._source._current self._marker = self._source._marker return self def __exit__(self, exception_type, exception_val, trace): # Exiting this context manager - restore the prior state if self.restore or exception_type: self._source._chars = self._chars self._source._idx = self._idx self._source._current = self._current if self._save_marker: self._source._marker = self._marker class _StateHandler: """ State preserver for the Parser. """ def __init__(self, source: Source) -> None: self._source = source self._states = [] def __call__(self, args, kwargs): return _State(self._source, args, *kwargs) def __enter__(self) -> None: state = self() self._states.append(state) return state.__enter__() def __exit__(self, exception_type, exception_val, trace): state = self._states.pop() return state.__exit__(exception_type, exception_val, trace) class Source(str): EOF = TOMLChar("\0") def __init__(self, _: str) -> None: super().__init__() # Collection of TOMLChars self._chars = iter([(i, TOMLChar(c)) for i, c in enumerate(self)]) self._idx = 0 self._marker = 0 self._current = TOMLChar("") self._state = _StateHandler(self) self.inc() def reset(self): # initialize both idx and current self.inc() # reset marker self.mark() @property def state(self) -> _StateHandler: return self._state @property def idx(self) -> int: return self._idx @property def current(self) -> TOMLChar: return self._current @property def marker(self) -> int: return self._marker def extract(self) -> str: """ Extracts the value between marker and index """ return self[self._marker : self._idx] def inc(self, exception: type[ParseError] \| None = None) -> bool: """ Increments the parser if the end of the input has not been reached. Returns whether or not it was able to advance. """ try: self._idx, self._current = next(self._chars) return True except StopIteration: self._idx = len(self) self._current = self.EOF if exception: raise self.parse_error(exception) return False def inc_n(self, n: int, exception: type[ParseError] \| None = None) -> bool: """ Increments the parser by n characters if the end of the input has not been reached. """ return all(self.inc(exception=exception) for _ in range(n)) def consume(self, chars, min=0, max=-1): """ Consume chars until min/max is satisfied is valid. """ while self.current in chars and max != 0: min -= 1 max -= 1 if not self.inc(): break # failed to consume minimum number of characters if min > 0: raise self.parse_error(UnexpectedCharError, self.current) def end(self) -> bool: """ Returns True if the parser has reached the end of the input. """ return self._current is self.EOF def mark(self) -> None: """ Sets the marker to the index's current position """ self._marker = self._idx def parse_error( self, exception: type[ParseError] = ParseError, args: Any, *kwargs: Any, ) -> ParseError: """ Creates a generic "parse error" at the current position. """ line, col = self._to_linecol() return exception(line, col, args, **kwargs) def _to_linecol(self) -> tuple[int, int]: cur = 0 for i, line in enumerate(self.splitlines()): if cur + len(line) + 1 > self.idx: return (i + 1, self.idx - cur) cur += len(line) + 1 return len(self.splitlines()), 0	4.71 KB	2026-01-20 12:58
📄 toml_char.py import string class TOMLChar(str): def __init__(self, c): super().__init__() if len(self) > 1: raise ValueError("A TOML character must be of length 1") BARE = string.ascii_letters + string.digits + "-_" KV = "= \t" NUMBER = string.digits + "+-_.e" SPACES = " \t" NL = "\n\r" WS = SPACES + NL def is_bare_key_char(self) -> bool: """ Whether the character is a valid bare key name or not. """ return self in self.BARE def is_kv_sep(self) -> bool: """ Whether the character is a valid key/value separator or not. """ return self in self.KV def is_int_float_char(self) -> bool: """ Whether the character if a valid integer or float value character or not. """ return self in self.NUMBER def is_ws(self) -> bool: """ Whether the character is a whitespace character or not. """ return self in self.WS def is_nl(self) -> bool: """ Whether the character is a new line character or not. """ return self in self.NL def is_spaces(self) -> bool: """ Whether the character is a space or not """ return self in self.SPACES	1.26 KB	2026-01-20 12:58
📄 toml_document.py from tomlkit.container import Container class TOMLDocument(Container): """ A TOML document. """	110 B	2026-01-20 12:58
📄 toml_file.py import os import re from typing import TYPE_CHECKING from tomlkit.api import loads from tomlkit.toml_document import TOMLDocument if TYPE_CHECKING: from _typeshed import StrPath as _StrPath else: from typing import Union _StrPath = Union[str, os.PathLike] class TOMLFile: """ Represents a TOML file. :param path: path to the TOML file """ def __init__(self, path: _StrPath) -> None: self._path = path self._linesep = os.linesep def read(self) -> TOMLDocument: """Read the file content as a :class:`tomlkit.toml_document.TOMLDocument`.""" with open(self._path, encoding="utf-8", newline="") as f: content = f.read() # check if consistent line endings num_newline = content.count("\n") if num_newline > 0: num_win_eol = content.count("\r\n") if num_win_eol == num_newline: self._linesep = "\r\n" elif num_win_eol == 0: self._linesep = "\n" else: self._linesep = "mixed" return loads(content) def write(self, data: TOMLDocument) -> None: """Write the TOMLDocument to the file.""" content = data.as_string() # apply linesep if self._linesep == "\n": content = content.replace("\r\n", "\n") elif self._linesep == "\r\n": content = re.sub(r"(?<!\r)\n", "\r\n", content) with open(self._path, "w", encoding="utf-8", newline="") as f: f.write(content)	1.56 KB	2026-01-20 12:58

Terminal