[ PARENT ]

EDIT :: 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))

SAVE CANCEL