def save_yaml( dictionary: Dict, path: str, encoding: str = "utf-8", pretty: bool = False, sortkeys: bool = False, ) -> None: """Save dictionary to YAML file preserving order if it is an OrderedDict Args: dictionary (Dict): Python dictionary to save path (str): Path to YAML file encoding (str): Encoding of file. Defaults to utf-8. pretty (bool): Whether to pretty print. Defaults to False. sortkeys (bool): Whether to sort dictionary keys. Defaults to False. Returns: None """ with open(path, "w", encoding=encoding) as f: representer = representers[sortkeys][pretty] yaml = YAML(typ="rt") yaml.Representer = representer add_representer(OrderedDict, representer.represent_dict, representer=representer) if pretty: yaml.indent(offset=2) else: yaml.default_flow_style = None yaml.representer.add_representer(type(None), representer.represent_none) yaml.dump(dictionary, f)
def get_yaml_loader(typ): if typ == "rt": loader = YAML(typ=typ) loader.preserve_quotes = True loader.default_flow_style = False loader.indent(sequence=4, offset=2) loader.width = 1000 loader.Representer = MyRepresenter loader.Loader = ruamel.yaml.RoundTripLoader elif typ == "safe": loader = YAML(typ=typ) return loader
def get_yaml_instance( version: VersionType = (1, 2), indent: Any = {'mapping': 2, 'sequence': 4, 'offset': 2}, **kwargs: Any ) -> YAML: yaml = YAML(**kwargs) yaml.version = version # type: ignore yaml.Representer = CustomRepresenter yaml.indent(**indent) return yaml
def get_yaml_instance(version=(1, 2), indent={ 'mapping': 2, 'sequence': 4, 'offset': 2 }, **kwargs): yaml = YAML(**kwargs) yaml.Representer = CustomRepresenter yaml.version = version yaml.indent(**indent) return yaml
def yaml_dump(cls, stream=sys.stdout): class MyRepresenter(SafeRepresenter): def ignore_aliases(self, data): return True yaml = YAML(typ="safe") yaml.default_flow_style = False yaml.Representer = MyRepresenter types = EntityTypeBase.get_entity_types() for _, t in types.items(): yaml.register_class(t) yaml.indent(mapping=2, sequence=4, offset=2) yaml.dump(cls, stream=stream)
def save(self): """Saves the scenes data to file. """ # This is necessary to prevent the representer from making its own # yaml aliases. While aliases are helpful, the computer generated # ones would just confuse people. class Representer(RoundTripRepresenter): def ignore_aliases(self, data): return True if self.path is not None: with open(self.path, "w") as f: yaml = YAML() yaml.Representer = Representer yaml.preserve_quotes = True yaml.indent(mapping=2, sequence=4, offset=2) yaml.dump(self.data, f) else: LOG.error("Scenes File not Defined in Config. Scenes not saved.")
class Representer(RoundTripRepresenter): pass Representer.add_representer(OrderedDict, Representer.represent_dict) def wrap_yaml_string(s, width=100): ss = (l.rstrip() for l in s.splitlines()) ss = (l for l in ss if l) #ss = textwrap.wrap('\n'.join(ss), width=width, drop_whitespace=False, tabsize=2) return PreservedScalarString('\n'.join(ss)) yaml = YAML(typ='rt') yaml.Representer = Representer yaml.compact() yaml.default_flow_style = False def yaml_dumps(document): stream = StringIO() yaml.dump(document, stream) return stream.getvalue() def write_yaml(dir_, fn, data): if not os.path.exists(dir_): os.makedirs(dir_) with open(os.path.join(dir_, fn), 'w') as f: yaml.dump(data, f)
def main(docname): with open(docname, "r") as fi: lines = fi.readlines() context = {} rest_lines = [] for line in lines: # print(line) if "{%" in line: set_expr = re.search("{%(.*)%}", line) set_expr = set_expr.group(1) set_expr = set_expr.replace("set", "", 1).strip() exec(set_expr, globals(), context) else: rest_lines.append(line) yaml = YAML(typ="rt") yaml.preserve_quotes = True yaml.default_flow_style = False yaml.indent(sequence=4, offset=2) yaml.width = 1000 yaml.Representer = MyRepresenter yaml.Loader = ruamel.yaml.RoundTripLoader result_yaml = CommentedMap() result_yaml["context"] = context def has_selector(s): return s.strip().endswith("]") quoted_lines = [] for line in rest_lines: if has_selector(line): selector_start = line.rfind("[") selector_end = line.rfind("]") selector_content = line[selector_start + 1 : selector_end] if line.strip().startswith("-"): line = ( line[: line.find("-") + 1] + f" sel({selector_content}): " + line[ line.find("-") + 1 : min(line.rfind("#"), line.rfind("[")) ].strip() + "\n" ) quoted_lines.append(line) rest_lines = quoted_lines def check_if_quoted(s): s = s.strip() return s.startswith('"') or s.startswith("'") quoted_lines = [] for line in rest_lines: if "{{" in line: # make sure that jinja stuff is quoted if line.find(":") != -1: idx = line.find(":") elif line.strip().startswith("-"): idx = line.find("-") rest = line[idx + 1 :] if not check_if_quoted(rest): if "'" in rest: rest = rest.replace("'", '"') line = line[: idx + 1] + f" '{rest.strip()}'\n" quoted_lines.append(line) rest_lines = quoted_lines skips, wo_skip_lines = [], [] for line in rest_lines: if line.strip().startswith("skip"): parts = line.split(":") rhs = parts[1].strip() if rhs.startswith("true"): selector_start = line.rfind("[") selector_end = line.rfind("]") selector_content = line[selector_start + 1 : selector_end] skips.append(selector_content) else: print("ATTENTION skip: false not handled!") else: wo_skip_lines.append(line) rest_lines = wo_skip_lines result_yaml.update( ruamel.yaml.load("".join(rest_lines), ruamel.yaml.RoundTripLoader) ) if len(skips) != 0: result_yaml["build"]["skip"] = skips if result_yaml.get("outputs"): for o in result_yaml["outputs"]: name = o["name"] package = {"name": name} del o["name"] if o.get("version"): package["version"] = o["version"] del o["version"] build = {} if o.get("script"): build["script"] = o["script"] del o["script"] o["package"] = package o["build"] = build for d in result_yaml["outputs"]: print(order_output_dict(d)) result_yaml["outputs"] = [order_output_dict(d) for d in result_yaml["outputs"]] from io import StringIO output = StringIO() yaml.dump(result_yaml, output) # Hacky way to insert an empty line after the context-key-object context_output = StringIO() yaml.dump(context, context_output) context_output = context_output.getvalue() context_output_len = len(context_output.split("\n")) final_result = output.getvalue() final_result_lines = final_result.split("\n") final_result_lines.insert(context_output_len, "") print("\n".join(final_result_lines))
from ruamel.yaml import YAML, representer logger = logging.getLogger("submitter." + __name__) class NonAliasingRTRepresenter(representer.RoundTripRepresenter): """ Turn off auto-aliases in ruamel.yaml """ def ignore_aliases(self, data): return True yaml = YAML() yaml.default_flow_style = False yaml.preserve_quotes = True yaml.Representer = NonAliasingRTRepresenter def load_json(path): """ Load the dictionary from a json file """ with open(path, "r") as file: data = json.load(file) return data def dump_json(data, path): """ Dump the dictionary to a json file """ with open(path, "w") as file: