def to_toml( self, filename: Optional[Union[str, PathLike]] = None, encoding: str = "utf-8", errors: str = "strict", ) -> Optional[str]: """Convert to a toml string or save it to toml file Args: filename: The filename to save the toml to, if not given a toml string will be returned encoding: The encoding for saving to file errors: The errors handling for saveing to file See python's open function Returns: The toml string with filename is not given """ try: import rtoml # type: ignore[import] except ImportError as exc: # pragma: no cover raise ImportError( "You need rtoml installed to export Diot as toml.") from exc toml_dump = self.to_dict() if not filename: return rtoml.dumps(toml_dump) with open(filename, "w", encoding=encoding, errors=errors) as ftml: rtoml.dump(toml_dump, ftml) return None
def project_with_setuptools_pep621_backend(tmp_path_factory): """ Returns a temporary directory containing a PEP 621 pyproject.toml configured to use setuptools as the build backend. """ # Create the folder and pyproject.toml file folder: Path = tmp_path_factory.mktemp("myrepo") pyproject_toml = folder.joinpath("pyproject.toml") pyproject_toml.touch() build_system = { "build-system": { "requires": [ "setuptools>=61", "wheel>=0.37.1", ], "build-backend": "setuptools.build_meta", } } with open(pyproject_toml, mode="w", encoding="utf-8") as f: rtoml.dump(build_system, f) return folder
def fix_manifest(file): # file is the absolute path to a manifest print(f" Patching {file}...") try: manifest = rtoml.load(Path(file)) except rtoml.TomlParsingError as ex: print(f"FAILED to patch {file}: " + str(ex)) raise if "origin" not in manifest: print(f" WARNING: manifest without origin? {file}") return origin = dict() url = fix_url(manifest.pop("origin")) # Move any '@commit' info to a separate key origin["url"] = url.split('@')[0] if '@' in url: origin["commit"] = url.split('@')[1] if "origin-hashes" in manifest: origin["hashes"] = manifest.pop("origin-hashes") if "archive-name" in manifest: origin["archive-name"] = manifest.pop("archive-name") manifest["origin"] = origin # Rewrite patched manifest with open(file, "wt") as file: rtoml.dump(utils.fix_manifest_order(manifest), file)
def create_variable_file(df, fn_variables): keys = df.keys() data = dict() for k in keys: data[k] = {"category": "general", "description": "", "unit": ""} with open(fn_variables, "w") as f: toml.dump(data, f)
def write(self): if not os.path.exists(self.directory): os.makedirs(self.directory, exist_ok=True) lexicon_dict = { "words": [(word[0], word[1]) for word in self.words], } with open(self.toml_path, "w") as toml_file: toml.dump(lexicon_dict, toml_file)
def write(self): if not os.path.exists(self.directory): os.makedirs(self.directory) report_dict = { "corpus_name": self.corpus_name, "lexicon_names": self.lexicon_names, "complete": self.complete, } with open(self.toml_path, "w") as toml_file: toml.dump(report_dict, toml_file)
def write(self) -> None: """Serialize and write the report to disk""" if not os.path.exists(self.directory): os.makedirs(self.directory) report_dict = { "corpus_name": self.corpus_name, "lexicon_names": self.lexicon_names, "complete": self.complete, } with open(self.toml_path, "w", encoding="utf-8") as toml_file: toml.dump(report_dict, toml_file)
def write(self, path: Path = defaults.CONFIG_FILE) -> None: """ Overwrites the config file at `path` with the attributes from the calling instance. Args: path (Path, optional): Config file to overwrite. Defaults to defaults.CONFIG_FILE. """ with open(path, mode="w", encoding="utf-8") as f: rtoml.dump({"pytoil": self.to_dict()}, f, pretty=True)
def write_externals(crate_dirname, name, general, external): print(f" Writing externals for {name}...") crate = deepcopy(general) crate["name"] = name crate["external"] = external fix_order(crate) with open(os.path.join(crate_dirname, name + "-external.toml"), "wt") as file: rtoml.dump(crate, file)
def migrate(path): print(f"Migrating {path}...") # Visit all nested TOML files. We do not check for proper placement. for file in glob.iglob(os.path.join(path, '**/*.toml'), recursive=True): if "/index.toml" not in file and "-external.toml" not in file: fix_manifest(file) # Finalize by updating the index version with open(os.path.join(path, "index.toml"), "wt") as file: rtoml.dump(INTO_VERSION, file)
def write(self): if not os.path.exists(self.directory): os.makedirs(self.directory, exist_ok=True) corpus_dict = { "type": RedditCorpus.corpus_type, "subreddits": self.subreddits, "start_time": self.start_time.isoformat(), "end_time": self.end_time.isoformat(), "compiled": self.compiled, } with open(self.toml_path, "w") as toml_file: toml.dump(corpus_dict, toml_file)
def migrate(path): print(f"Migrating {path}...") # All two-letter folders will contain crates... with os.scandir(path) as contents: for entry in contents: if len(entry.name) == 2 and entry.is_dir(): split_contents(entry.path) elif entry.name != "index.toml": print(f"EXTRANEOUS entry looking for shelves: {entry.path}") # Finalize by updating the index version with open(os.path.join(path, "index.toml"), "wt") as file: rtoml.dump(INTO_VERSION, file)
def write_release(crate_dirname, name, general, version, release): print(f" Writing release {name}={version}...") crate = deepcopy(general) crate["name"] = name crate["version"] = version # Ensure proper merging for key in release: if key in crate: if isinstance(crate[key], dict) and isinstance(release[key], dict): # Merge these dicts: crate[key].update(release[key]) elif isinstance(crate[key], list) and isinstance( release[key], list): # Merge arrays crate[key] += release[key] else: raise RuntimeError( f"Key {key} is both in general and release sections in {crate_dirname} {version}" ) else: crate[key] = release[key] # Fix relative origins which now are one level deeper than before if "origin" in crate and "../" in crate["origin"]: crate['origin'] = crate['origin'].replace("../", "../../", 1) # Fix dictionary ordering to ensure atoms (or arrays of atoms) are before tables/arrays of tables. Otherwise, rtoml # does not do it for us, and we end with an invalid TOML serialization order (top-level atoms must come before any # tables/arrays). fix_order(crate) # Fix `depends-on` to be an array. No matter that dependencies are grouped. if "depends-on" in crate: deps = crate.pop("depends-on") crate["depends-on"] = [deps] with open(os.path.join(crate_dirname, name + f"-{version}.toml"), "wt") as file: rtoml.dump(crate, file)
def fake_flit_project(tmp_path_factory): """ Returns a temporary directory containing a valid flit pyproject.toml file. """ # Create the folder and pyproject.toml file folder: Path = tmp_path_factory.mktemp("myrepo") pyproject_toml = folder.joinpath("pyproject.toml") pyproject_toml.touch() # Create some fake poetry content build_system = { "build-system": { "requires": ["flit_core >=2,<4"], "build-backend": "flit_core.buildapi", }, } with open(pyproject_toml, mode="w", encoding="utf-8") as f: rtoml.dump(build_system, f) return folder
def project_with_no_build_backend(tmp_path_factory): """ Returns a temporary directory containing a pyproject.toml. This time we do write a 'build-system' but no 'build-backend'. """ # Create the folder and pyproject.toml file folder: Path = tmp_path_factory.mktemp("myrepo") pyproject_toml = folder.joinpath("pyproject.toml") pyproject_toml.touch() # Create some fake build-system build_system = { "build-system": { "requires": ["poetry-core>=1.0.0"], }, } with open(pyproject_toml, mode="w", encoding="utf-8") as f: rtoml.dump(build_system, f) return folder
def write_options(optfile, **opts): with optfile.open("w") as f: rtoml.dump(opts, f)
from pathlib import Path import rtoml from diot import Diot in_metafile = Path({{in.metafile | quote}}) # pyright: ignore in_gmtfile = Path({{in.gmtfile | quote}}) # pyright: ignore in_config = {{in.config | repr}} # pyright: ignore out_metafile = Path({{out.metafile | quote}}) # pyright: ignore out_gmtfile = Path({{out.gmtfile | quote}}) # pyright: ignore out_configfile = Path({{out.configfile | quote}}) # pyright: ignore # make symbolic link of in.metafile to out.metafile out_metafile.symlink_to(in_metafile) # make symbolic link of in.gmtfile to out.gmtfile out_gmtfile.symlink_to(in_gmtfile) # Check the config and save as toml file if isinstance(in_config, str): if "\n" not in in_config and Path(in_config).is_file(): Path(in_config).symlink_to(out_configfile) else: # A toml string with out_configfile.open("w") as f: f.write(in_config) else: # A python dictionary with out_configfile.open("w") as f: rtoml.dump(in_config, f)
def test_dump_path(tmp_path): p = tmp_path / 'test.toml' assert rtoml.dump({'foo': 'bar'}, p) == 12 assert p.read_text() == 'foo = "bar"\n'
def test_dump_file(tmp_path): p = tmp_path / 'test.toml' with p.open('w') as f: assert rtoml.dump({'foo': 'bar'}, f) == 12 assert p.read_text() == 'foo = "bar"\n'
def persist_settings(settings: Dict[str, Any]) -> None: with open(constants.settings_path, "w", encoding="utf-8") as settings_file: toml.dump(settings, settings_file)
import json import rtoml configstr = {{in.config | repr}} outfile = {{out.outfile | quote}} infmt = {{envs.infmt | quote}} outfmt = {{envs.outfmt | quote}} data = rtoml.loads(configstr) if infmt == "toml" else json.loads(configstr) with open(outfile, "w") as fout: if outfmt == "toml": rtoml.dump(data, fout) else: json.dump(data, fout)