Archived
saving dependency work
This commit is contained in:
@@ -0,0 +1,907 @@
|
||||
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))
|
||||
Reference in New Issue
Block a user