def test_item_dict_to_table():
t = tomlkit.item({"foo": {"bar": "baz"}})
assert t.value == {"foo": {"bar": "baz"}}
assert (t.as_string() == """[foo]
bar = "baz"
""")
def _set_toml_entry(toml, path, entry): # type: (TOMLDocument, Tuple, ConfigEntry) -> None
"""
Set config entry in a TOML document, creating additional tables if necessary
:param toml: TOML document
:param path: Path tuple (for example ``('DATABASE', 'server')`` or ``('msg',)``
:param entry: New config entry
:raise ValueError: if Path is empty
"""
if len(path) == 0:
raise ValueError('Path length cant be 0')
elif len(path) == 1:
if isinstance(entry, ConfigValue):
item = tomlkit.item(entry._val)
else:
item = tomlkit.table()
if entry._comment:
item.comment(entry._comment)
if toml.get(path[0]) is None:
toml.add(path[0], item)
else:
toml[path[0]] = item
else:
if path[0] not in toml:
toml.add(path[0], tomlkit.table())
Config._set_toml_entry(toml[path[0]], path[1:], entry)
def add_dependencies(
self,
requirements: Dict[str, Requirement],
to_section: str = "default",
dev: bool = False,
show_message: bool = True,
) -> None:
deps = self.get_pyproject_dependencies(to_section, dev)
for _, dep in requirements.items():
matched_index = next(
(i for i, r in enumerate(deps) if dep.matches(r)), None)
if matched_index is None:
deps.append(dep.as_line())
else:
req = dep.as_line()
deps[matched_index] = req
# XXX: This dirty part is for tomlkit.Array.__setitem__()
j = 0
for i in range(len(deps._value)):
if isinstance(deps._value[i], (Comment, Whitespace)):
continue
if j == matched_index:
deps._value[i] = tomlkit.item(req)
break
j += 1
deps.multiline(True)
self.write_pyproject(show_message)
def test_replace_with_comment():
content = 'a = "1"'
doc = parse(content)
a = tomlkit.item(int(doc["a"]))
a.comment("`a` should be an int")
doc["a"] = a
expected = "a = 1 # `a` should be an int"
assert doc.as_string() == expected
content = 'a = "1, 2, 3"'
doc = parse(content)
a = tomlkit.array()
a.comment("`a` should be an array")
for x in doc["a"].split(","):
a.append(int(x.strip()))
doc["a"] = a
expected = "a = [1, 2, 3] # `a` should be an array"
assert doc.as_string() == expected
doc = parse(content)
a = tomlkit.inline_table()
a.comment("`a` should be an inline-table")
for x in doc["a"].split(","):
i = int(x.strip())
a.append(chr(ord("a") + i - 1), i)
doc["a"] = a
expected = "a = {a = 1, b = 2, c = 3} # `a` should be an inline-table"
assert doc.as_string() == expected
def add_index_to_pipfile(self, index, verify_ssl=True):
"""Adds a given index to the Pipfile."""
# Read and append Pipfile.
p = self.parsed_pipfile
source = None
try:
source = self.get_source(url=index)
except SourceNotFound:
try:
source = self.get_source(name=index)
except SourceNotFound:
pass
if source is not None:
return source["name"]
source = {"url": index, "verify_ssl": verify_ssl}
source["name"] = self.src_name_from_url(index)
# Add the package to the group.
if "source" not in p:
p["source"] = [tomlkit.item(source)]
else:
p["source"].append(tomlkit.item(source))
# Write Pipfile.
self.write_toml(p)
return source["name"]
def set_lock_data(self, root: Package, packages: List[Package]) -> bool:
files = table()
packages = self._lock_packages(packages)
# Retrieving hashes
for package in packages:
if package["name"] not in files:
files[package["name"]] = []
for f in package["files"]:
file_metadata = inline_table()
for k, v in sorted(f.items()):
file_metadata[k] = v
files[package["name"]].append(file_metadata)
if files[package["name"]]:
files[package["name"]] = item(files[package["name"]]).multiline(True)
del package["files"]
lock = document()
lock["package"] = packages
if root.extras:
lock["extras"] = {
extra: [dep.pretty_name for dep in deps]
for extra, deps in sorted(root.extras.items())
}
lock["metadata"] = dict(
[
("lock-version", self._VERSION),
("python-versions", root.python_versions),
("content-hash", self._content_hash),
("files", files),
]
)
if not self.is_locked() or lock != self.lock_data:
self._write_lock_data(lock)
return True
return False
def set_lock_data(self, root: Package, packages: list[Package]) -> bool:
files: dict[str, Any] = table()
package_specs = self._lock_packages(packages)
# Retrieving hashes
for package in package_specs:
if package["name"] not in files:
files[package["name"]] = []
for f in package["files"]:
file_metadata = inline_table()
for k, v in sorted(f.items()):
file_metadata[k] = v
files[package["name"]].append(file_metadata)
if files[package["name"]]:
package_files = item(files[package["name"]])
assert isinstance(package_files, Array)
files[package["name"]] = package_files.multiline(True)
del package["files"]
lock = document()
lock["package"] = package_specs
if root.extras:
lock["extras"] = {
extra: [dep.pretty_name for dep in deps]
for extra, deps in sorted(root.extras.items())
}
lock["metadata"] = {
"lock-version": self._VERSION,
"python-versions": root.python_versions,
"content-hash": self._content_hash,
"files": files,
}
if not self.is_locked() or lock != self.lock_data:
self._write_lock_data(lock)
return True
return False
def set_lock_data(self, root, packages): # type: (...) -> bool
files = table()
packages = self._lock_packages(packages)
# Retrieving hashes
for package in packages:
if package["name"] not in files:
files[package["name"]] = []
for f in package["files"]:
file_metadata = inline_table()
for k, v in sorted(f.items()):
file_metadata[k] = v
files[package["name"]].append(file_metadata)
if files[package["name"]]:
files[package["name"]] = item(files[package["name"]]).multiline(True)
del package["files"]
lock = document()
lock.add(comment("@" + "generated"))
lock["package"] = packages
if root.extras:
lock["extras"] = {
extra: [dep.pretty_name for dep in deps]
for extra, deps in root.extras.items()
}
lock["metadata"] = {
"lock-version": self._VERSION,
"python-versions": root.python_versions,
"content-hash": self._content_hash,
"files": files,
}
if not self.is_locked() or lock != self.lock_data:
self._write_lock_data(lock)
return True
return False
def test_token_date(dt, content):
item = tomlkit.item(dt)
assert item.as_string() == content
def test_build_example(example):
content = example("example")
doc = document()
doc.add(comment("This is a TOML document. Boom."))
doc.add(nl())
doc.add("title", "TOML Example")
owner = table()
owner.add("name", "Tom Preston-Werner")
owner.add("organization", "GitHub")
owner.add("bio", "GitHub Cofounder & CEO\\nLikes tater tots and beer.")
owner.add("dob", datetime.datetime(1979, 5, 27, 7, 32, tzinfo=_utc))
owner["dob"].comment("First class dates? Why not?")
doc.add("owner", owner)
database = table()
database["server"] = "192.168.1.1"
database["ports"] = [8001, 8001, 8002]
database["connection_max"] = 5000
database["enabled"] = True
doc["database"] = database
servers = table()
servers.add(nl())
c = comment(
"You can indent as you please. Tabs or spaces. TOML don't care."
).indent(2)
c.trivia.trail = ""
servers.add(c)
alpha = table()
servers.append("alpha", alpha)
alpha.indent(2)
alpha.add("ip", "10.0.0.1")
alpha.add("dc", "eqdc10")
beta = table()
servers.append("beta", beta)
beta.add("ip", "10.0.0.2")
beta.add("dc", "eqdc10")
beta.add("country", "中国")
beta["country"].comment("This should be parsed as UTF-8")
beta.indent(2)
doc["servers"] = servers
clients = table()
doc.add("clients", clients)
clients["data"] = item(
[["gamma", "delta"],
[1, 2]]).comment("just an update to make sure parsers support it")
clients.add(nl())
clients.add(comment("Line breaks are OK when inside arrays"))
clients["hosts"] = array("""[
"alpha",
"omega"
]""")
doc.add(nl())
doc.add(comment("Products"))
products = aot()
doc["products"] = products
hammer = table().indent(2)
hammer["name"] = "Hammer"
hammer["sku"] = 738594937
nail = table().indent(2)
nail["name"] = "Nail"
nail["sku"] = 284758393
nail["color"] = "gray"
products.append(hammer)
products.append(nail)
assert content == doc.as_string()
def test_item_mixed_aray():
example = [{"a": 3}, "b", 42]
expected = '[{a = 3}, "b", 42]'
t = tomlkit.item(example)
assert t.as_string().strip() == expected
assert dumps({"x": {"y": example}}).strip() == "[x]\ny = " + expected
def test__resolve() -> None:
current_file = pathlib.Path(__file__)
setting = SourceEntrySetting(glob=False)
assert _resolve(BASE_DIR, current_file.name, setting) == [current_file.absolute()]
assert _resolve(BASE_DIR, current_file.absolute(), setting) == [
current_file.absolute()
]
assert _resolve(BASE_DIR, str(current_file.name), setting) == [
current_file.absolute()
]
assert _resolve(BASE_DIR, str(current_file.absolute()), setting) == [
current_file.absolute()
]
override_base = pathlib.Path("/opt/pysen")
setting = SourceEntrySetting(glob=False, base_dir=override_base)
assert _resolve(BASE_DIR, current_file.name, setting) == [
override_base / current_file.name
]
assert _resolve(BASE_DIR, current_file.absolute(), setting) == [
current_file.absolute()
]
assert _resolve(BASE_DIR, str(current_file.name), setting) == [
override_base / current_file.name
]
assert _resolve(BASE_DIR, str(current_file.absolute()), setting) == [
current_file.absolute()
]
setting = SourceEntrySetting(glob=True)
with pytest.raises(RuntimeError):
_resolve(BASE_DIR, pathlib.Path("**/*"), setting)
resolved = _resolve(BASE_DIR, "**/*.py", setting)
assert len(resolved) > 1
assert all(str(x).startswith(str(BASE_DIR)) and x.suffix == ".py" for x in resolved)
# NOTE(igarashi): check base_dir of glob is overridden by setting
setting = SourceEntrySetting(glob=True, base_dir=BASE_DIR / "fakes")
resolved_with_base = _resolve(BASE_DIR, "**/*.py", setting)
assert len(resolved_with_base) > 1
assert len(resolved) > len(resolved_with_base)
assert all(
str(x).startswith(str(BASE_DIR / "fakes")) and x.suffix == ".py"
for x in resolved_with_base
)
# test if _resolve doesn't raise an error though we specify an invalid pattern
resolved = _resolve(BASE_DIR, "hoge!%&#'/+*hoge", setting)
assert len(resolved) == 0
# Test if _resolve doesn't raise an error though we use a string-like object.
# This case is intended to check that _resolve converts a string-like object
# to the Python string object since pathlib.glob(x) now raises an error
# if x is not a Python string object due to sys.intern(x).
str_like = tomlkit.item("build")
assert isinstance(str_like, str)
assert type(str_like) is not str
resolved = _resolve(BASE_DIR, str_like, setting)
assert len(resolved) == 0
