| import copy |
| |
| from typing import Any |
| from typing import Dict |
| from typing import Iterator |
| from typing import List |
| from typing import Optional |
| from typing import Tuple |
| from typing import Union |
| |
| 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[Key, int] = {} |
| self._body: List[Tuple[Optional[Key], Item]] = [] |
| self._parsed = parsed |
| self._table_keys = [] |
| |
| @property |
| def body(self) -> List[Tuple[Optional[Key], 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 isinstance(v, Item): |
| 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: Union[Key, Item, str], item: Optional[Item] = 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: |
| names = tuple(iter(key)) |
| name = names[0] |
| name._dotted = True |
| if name in self: |
| if not isinstance(value, Table): |
| table = Table(Container(True), Trivia(), False, is_super_table=True) |
| _table = table |
| for i, _name in enumerate(names[1:]): |
| if i == len(names) - 2: |
| _name.sep = key.sep |
| |
| _table.append(_name, value) |
| else: |
| _name._dotted = True |
| _table.append( |
| _name, |
| Table( |
| Container(True), |
| Trivia(), |
| False, |
| is_super_table=i < len(names) - 2, |
| ), |
| ) |
| |
| _table = _table[_name] |
| |
| value = table |
| |
| self.append(name, value) |
| |
| return |
| else: |
| table = Table(Container(True), Trivia(), False, is_super_table=True) |
| self.append(name, table) |
| |
| for i, _name in enumerate(names[1:]): |
| if i == len(names) - 2: |
| _name.sep = key.sep |
| |
| table.append(_name, value) |
| else: |
| _name._dotted = True |
| if _name in table.value: |
| table = table.value[_name] |
| else: |
| table.append( |
| _name, |
| Table( |
| Container(True), |
| Trivia(), |
| False, |
| is_super_table=i < len(names) - 2, |
| ), |
| ) |
| |
| table = table[_name] |
| |
| def append(self, key: Union[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): |
| 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 not isinstance(current_idx, tuple): |
| current_idx = (current_idx,) |
| |
| self._map[key] = current_idx + (len(self._body),) |
| self._body.append((key, item)) |
| self._table_keys.append(key) |
| |
| # 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: |
| # 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 |
| key_after = None |
| 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 not is_table and isinstance(v, (Table, AoT)): |
| break |
| |
| key_after = k or i # last scalar, Array or InlineTable value |
| |
| if key_after is not None: |
| if isinstance(key_after, int): |
| if key_after + 1 < len(self._body): |
| return self._insert_at(key_after + 1, key, item) |
| else: |
| previous_item = self._body[-1][1] |
| if not ( |
| isinstance(previous_item, Whitespace) |
| or ends_with_whitespace(previous_item) |
| or is_table |
| or "\n" in previous_item.trivia.trail |
| ): |
| previous_item.trivia.trail += "\n" |
| else: |
| return self._insert_after(key_after, key, item) |
| else: |
| return self._insert_at(0, key, item) |
| |
| if key in self._map: |
| current_idx = self._map[key] |
| if isinstance(current_idx, tuple): |
| current_idx = current_idx[-1] |
| |
| current = self._body[current_idx][1] |
| if key is not None and not isinstance(current, Table): |
| raise KeyAlreadyPresent(key) |
| |
| # Adding sub tables to a currently existing table |
| if not isinstance(current_idx, tuple): |
| current_idx = (current_idx,) |
| |
| 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: Union[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: Union[Key, str], other_key: Union[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: Union[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 |
| |
| self._map[key] = idx |
| self._body.insert(idx, (key, item)) |
| |
| if key is not None: |
| dict.__setitem__(self, key.key, item.value) |
| |
| return self |
| |
| def item(self, key: Union[Key, str]) -> Item: |
| """Get an item for the given key.""" |
| if not isinstance(key, Key): |
| key = SingleKey(key) |
| |
| idx = self._map.get(key, None) |
| 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) -> Optional[Item]: |
| """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: Optional[str] = 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: Optional[str] = None) -> str: |
| cur = "" |
| |
| _key = prefix or "" |
| |
| if not table.is_super_table(): |
| 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: Union[Key, str]) -> Union[Item, "Container"]: |
| if not isinstance(key, Key): |
| key = SingleKey(key) |
| |
| idx = self._map.get(key, None) |
| 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: Union[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: Union[Key, str]) -> None: |
| self.remove(key) |
| |
| def setdefault(self, key: Union[Key, str], default: Any) -> Any: |
| super().setdefault(key, default=default) |
| return self[key] |
| |
| def _replace( |
| self, key: Union[Key, str], new_key: Union[Key, str], value: Item |
| ) -> None: |
| if not isinstance(key, Key): |
| key = SingleKey(key) |
| |
| idx = self._map.get(key, None) |
| if idx is None: |
| raise NonExistentKey(key) |
| |
| self._replace_at(idx, new_key, value) |
| |
| def _replace_at( |
| self, idx: Union[int, Tuple[int]], new_key: Union[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: Optional[int] = None, ignore=(Null,) |
| ) -> Optional[Tuple[int, Item]]: |
| """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: Optional[int] = None, ignore=(Null,) |
| ) -> Optional[Item]: |
| """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: Union[Key, str]) -> Any: |
| if key not in self._internal_container: |
| raise NonExistentKey(key) |
| |
| return self._internal_container[key] |
| |
| def __setitem__(self, key: Union[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: Union[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: Union[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)) |
