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