def test_constructor_types(data_filename, code_filename, verbose=False): _make_objects() native1 = None native2 = None yaml = ruyaml.YAML(typ='safe', pure=True) yaml.loader = MyLoader try: with open(data_filename, 'rb') as fp0: native1 = list(ruyaml.load_all(fp0)) if len(native1) == 1: native1 = native1[0] with open(code_filename, 'rb') as fp0: native2 = _load_code(fp0.read()) try: if native1 == native2: return except TypeError: pass # print('native1', native1) if verbose: print('SERIALIZED NATIVE1:') print(_serialize_value(native1)) print('SERIALIZED NATIVE2:') print(_serialize_value(native2)) assert _serialize_value(native1) == _serialize_value(native2), ( native1, native2, ) finally: if verbose: print('NATIVE1:') pprint.pprint(native1) print('NATIVE2:') pprint.pprint(native2)
def __init__(self, path_to_graph_yml: Optional[Path], read: bool = True): self._yaml = ruyaml.YAML() self._path_to_graph_yml = path_to_graph_yml self._yaml.indent(mapping=2, sequence=4, offset=2) # read text manually instead of loading the Path directly to normalize line # breaks. Ruyaml opens files in binary mode (bypassing universal newline # support), then proceeds to behave incorrectly in the presence of \r\n, adding # extra line breaks in the output. if read: with self._path_to_graph_yml.open() as f: text = f.read() self._cfg = self._yaml.load(text) or {} # ruyaml doesn't provide a way to preserve indentation, # so pick a value that matches the least-indented list item we see. matches = ( len(m.group(1)) for m in re.finditer(r"^( *)-", text, re.MULTILINE) ) # ruyaml's indent number includes the length of "- " for some reason indent = min(matches, default=2) + 2 else: self._cfg = {} indent = 4 self._yaml.indent( mapping=int(indent / 2), sequence=indent, offset=max(0, indent - 2) )
def test_recursive(recursive_filename, verbose=False): yaml = ruyaml.YAML(typ='safe', pure=True) context = globals().copy() with open(recursive_filename, 'rb') as fp0: exec(fp0.read(), context) value1 = context['value'] output1 = None value2 = None output2 = None try: buf = ruyaml.compat.StringIO() output1 = yaml.dump(value1, buf) yaml.load(output1) value2 = buf.getvalue() buf = ruyaml.compat.StringIO() yaml.dump(value2, buf) output2 = buf.getvalue() assert output1 == output2, (output1, output2) finally: if verbose: print('VALUE1:', value1) print('VALUE2:', value2) print('OUTPUT1:') print(output1) print('OUTPUT2:') print(output2)
def round_trip_dump_all( data, stream=None, # *, indent=None, block_seq_indent=None, default_flow_style=unset, top_level_colon_align=None, prefix_colon=None, explicit_start=None, explicit_end=None, version=None, allow_unicode=None, ): yaml = ruyaml.YAML() yaml.indent(mapping=indent, sequence=indent, offset=block_seq_indent) if default_flow_style is not unset: yaml.default_flow_style = default_flow_style yaml.top_level_colon_align = top_level_colon_align yaml.prefix_colon = prefix_colon yaml.explicit_start = explicit_start yaml.explicit_end = explicit_end yaml.version = version yaml.allow_unicode = allow_unicode if stream is not None: yaml.dump(data, stream=stream) return buf = io.StringIO() yaml.dump_all(data, stream=buf) return buf.getvalue()
def test_dice_constructor_with_loader(): import ruyaml # NOQA yaml = ruyaml.YAML(typ='unsafe', pure=True) ruyaml.add_constructor('!dice', dice_constructor, Loader=ruyaml.Loader) data = yaml.load('initial hit points: !dice 8d4') assert str(data) == "{'initial hit points': Dice(8,4)}"
def test_issue_130a(self): # issue 130 reported by Devid Fee import ruyaml ys = dedent("""\ components: server: &server_component type: spark.server:ServerComponent host: 0.0.0.0 port: 8000 shell: &shell_component type: spark.shell:ShellComponent services: server: &server_service <<: *server_component port: 4000 shell: &shell_service <<: *shell_component components: server: {<<: *server_service} """) yaml = ruyaml.YAML(typ='safe', pure=True) data = yaml.load(ys) assert data['services']['shell']['components']['server'][ 'port'] == 4000
def round_trip_load_all(inp, preserve_quotes=None, version=None): import ruyaml # NOQA dinp = dedent(inp) yaml = ruyaml.YAML() yaml.preserve_quotes = preserve_quotes yaml.version = version return yaml.load_all(dinp)
def yload(stream, multi=False): """ Load one or more YAML objects from a file. """ y = yaml.YAML(typ="safe") if multi: return y.load_all(stream) else: return y.load(stream)
def test_issue_232(self): import ruyaml yaml = ruyaml.YAML(typ='safe', pure=True) with pytest.raises(ruyaml.parser.ParserError): yaml.load(']') with pytest.raises(ruyaml.parser.ParserError): yaml.load('{]')
def test_issue_222(self): from io import StringIO import ruyaml yaml = ruyaml.YAML(typ='safe') buf = StringIO() yaml.dump(['012923'], buf) assert buf.getvalue() == "['012923']\n"
def _compare_scanners(py_data, c_data, verbose): yaml = ruyaml.YAML(typ='unsafe', pure=True) py_tokens = list(yaml.scan(py_data, Loader=ruyaml.PyLoader)) c_tokens = [] try: yaml = ruyaml.YAML(typ='unsafe', pure=False) for token in yaml.scan(c_data, Loader=ruyaml.CLoader): c_tokens.append(token) assert len(py_tokens) == len(c_tokens), (len(py_tokens), len(c_tokens)) for py_token, c_token in zip(py_tokens, c_tokens): assert py_token.__class__ == c_token.__class__, (py_token, c_token) if hasattr(py_token, 'value'): assert py_token.value == c_token.value, (py_token, c_token) if isinstance(py_token, ruyaml.StreamEndToken): continue py_start = ( py_token.start_mark.index, py_token.start_mark.line, py_token.start_mark.column, ) py_end = ( py_token.end_mark.index, py_token.end_mark.line, py_token.end_mark.column, ) c_start = ( c_token.start_mark.index, c_token.start_mark.line, c_token.start_mark.column, ) c_end = ( c_token.end_mark.index, c_token.end_mark.line, c_token.end_mark.column, ) assert py_start == c_start, (py_start, c_start) assert py_end == c_end, (py_end, c_end) finally: if verbose: print('PY_TOKENS:') pprint.pprint(py_tokens) print('C_TOKENS:') pprint.pprint(c_tokens)
def test_load_cyaml(): print("???????????????????????", platform.python_implementation()) import ruyaml if sys.version_info >= NO_CLIB_VER: return yaml = ruyaml.YAML(typ='safe', pure=False) assert ruyaml.__with_libyaml__ yaml.load('abc: 1')
def test_issue_284(self): import ruyaml inp = dedent("""\ plain key: in-line value : # Both empty "quoted key": - entry """) yaml = ruyaml.YAML(typ='rt') yaml.version = (1, 2) d = yaml.load(inp) assert d[None] is None yaml = ruyaml.YAML(typ='rt') yaml.version = (1, 1) with pytest.raises(ruyaml.parser.ParserError, match='expected <block end>'): d = yaml.load(inp)
def test_dice_representer(): import ruyaml # NOQA yaml = ruyaml.YAML(typ='unsafe', pure=True) yaml.default_flow_style = False ruyaml.add_representer(Dice, dice_representer) # ruyaml 0.15.8+ no longer forces quotes tagged scalars buf = ruyaml.compat.StringIO() yaml.dump(dict(gold=Dice(10, 6)), buf) assert buf.getvalue() == 'gold: !dice 10d6\n'
def test_yaml_obj(): import ruyaml # NOQA yaml = ruyaml.YAML(typ='unsafe', pure=True) ruyaml.add_representer(Obj1, YAMLObj1.to_yaml) ruyaml.add_multi_constructor(YAMLObj1.yaml_tag, YAMLObj1.from_yaml) x = yaml.load('!obj:x.2\na: 1') print(x) buf = ruyaml.compat.StringIO() yaml.dump(x, buf) assert buf.getvalue() == """!obj:x.2 "{'a': 1}"\n"""
def test_dice_implicit_resolver(): import ruyaml # NOQA yaml = ruyaml.YAML(typ='unsafe', pure=True) yaml.default_flow_style = False pattern = re.compile(r'^\d+d\d+$') ruyaml.add_implicit_resolver('!dice', pattern) buf = ruyaml.compat.StringIO() yaml.dump(dict(treasure=Dice(10, 20)), buf) assert buf.getvalue() == 'treasure: 10d20\n' assert yaml.load('damage: 5d10') == dict(damage=Dice(5, 10))
def test_scanner(data_filename, canonical_filename, verbose=False): for filename in [data_filename, canonical_filename]: tokens = [] try: yaml = ruyaml.YAML(typ='unsafe', pure=False) with open(filename, 'rb') as fp: for token in yaml.scan(fp): tokens.append(token.__class__.__name__) finally: if verbose: pprint.pprint(tokens)
def load(s, typ=float): import ruyaml yaml = ruyaml.YAML() x = '{"low": %s }' % (s) print('input: [%s]' % (s), repr(x)) # just to check it is loadable json res = json.loads(x) assert isinstance(res['low'], typ) ret_val = yaml.load(x) print(ret_val) return ret_val['low']
def test_dump_cyaml(): import ruyaml if sys.version_info >= NO_CLIB_VER: return data = {'a': 1, 'b': 2} yaml = ruyaml.YAML(typ='safe', pure=False) yaml.default_flow_style = False yaml.allow_unicode = True buf = ruyaml.compat.StringIO() yaml.dump(data, buf) assert buf.getvalue() == 'a: 1\nb: 2\n'
def test_load_cyaml_1_2(): # issue 155 import ruyaml if sys.version_info >= NO_CLIB_VER: return assert ruyaml.__with_libyaml__ inp = dedent("""\ %YAML 1.2 --- num_epochs: 70000 """) yaml = ruyaml.YAML(typ='safe') yaml.load(inp)
def test_set_out(self): # preferable would be the shorter format without the ': null' import ruyaml # NOQA x = set(['a', 'b', 'c']) # cannot use round_trip_dump, it doesn't show null in block style buf = io.StringIO() yaml = ruyaml.YAML(typ='unsafe', pure=True) yaml.default_flow_style = False yaml.dump(x, buf) assert buf.getvalue() == dedent(""" !!set a: null b: null c: null """)
def yprint(data, stream=sys.stdout, compact=False): """ Write a YAML record. :param data: The data to write. :param stream: the file to write to, defaults to stdout. :param compact: Write single lines if possible, default False. """ if isinstance(data, (int, float)): print(data, file=stream) elif isinstance(data, (str, bytes)): print(repr(data), file=stream) # elif isinstance(data, bytes): # os.write(sys.stdout.fileno(), data) else: y = yaml.YAML(typ="safe") y.default_flow_style = compact y.dump(data, stream=stream)
def test_constructor(data_filename, canonical_filename, verbose=False): _make_loader() _make_canonical_loader() native1 = None native2 = None yaml = ruyaml.YAML(typ='safe') try: with open(data_filename, 'rb') as fp0: native1 = list(yaml.load(fp0, Loader=MyLoader)) with open(canonical_filename, 'rb') as fp0: native2 = list(yaml.load(fp0, Loader=MyCanonicalLoader)) assert native1 == native2, (native1, native2) finally: if verbose: print('NATIVE1:') pprint.pprint(native1) print('NATIVE2:') pprint.pprint(native2)
def test_issue_127(): import ruyaml # NOQA class Ref(ruyaml.YAMLObject): yaml_constructor = ruyaml.RoundTripConstructor yaml_representer = ruyaml.RoundTripRepresenter yaml_tag = '!Ref' def __init__(self, logical_id): self.logical_id = logical_id @classmethod def from_yaml(cls, loader, node): return cls(loader.construct_scalar(node)) @classmethod def to_yaml(cls, dumper, data): if isinstance(data.logical_id, ruyaml.scalarstring.ScalarString): style = data.logical_id.style # ruyaml>0.15.8 else: style = None return dumper.represent_scalar(cls.yaml_tag, data.logical_id, style=style) document = dedent("""\ AList: - !Ref One - !Ref 'Two' - !Ref Two and a half BList: [!Ref Three, !Ref "Four"] CList: - Five Six - 'Seven Eight' """) yaml = ruyaml.YAML() yaml.preserve_quotes = True yaml.default_flow_style = None yaml.indent(sequence=4, offset=2) data = yaml.load(document) buf = ruyaml.compat.StringIO() yaml.dump(data, buf) assert buf.getvalue() == document.replace('\n Two and', ' Two and')
def test_tokens(data_filename, tokens_filename, verbose=False): tokens1 = [] with open(tokens_filename, 'r') as fp: tokens2 = fp.read().split() try: yaml = ruyaml.YAML(typ='unsafe', pure=True) with open(data_filename, 'rb') as fp1: for token in yaml.scan(fp1): if not isinstance( token, (ruyaml.StreamStartToken, ruyaml.StreamEndToken)): tokens1.append(_replaces[token.__class__]) finally: if verbose: print('TOKENS1:', ' '.join(tokens1)) print('TOKENS2:', ' '.join(tokens2)) assert len(tokens1) == len(tokens2), (tokens1, tokens2) for token1, token2 in zip(tokens1, tokens2): assert token1 == token2, (token1, token2)
def test_load_all_perserve_quotes(self): import ruyaml # NOQA yaml = ruyaml.YAML() yaml.preserve_quotes = True s = dedent("""\ a: 'hello' --- b: "goodbye" """) data = [] for x in yaml.load_all(s): data.append(x) buf = ruyaml.compat.StringIO() yaml.dump_all(data, buf) out = buf.getvalue() print(type(data[0]['a']), data[0]['a']) # out = ruyaml.round_trip_dump_all(data) print(out) assert out == s
def test_dump_cyaml_1_2(): # issue 155 from io import StringIO import ruyaml if sys.version_info >= NO_CLIB_VER: return assert ruyaml.__with_libyaml__ yaml = ruyaml.YAML(typ='safe') yaml.version = (1, 2) yaml.default_flow_style = False data = {'a': 1, 'b': 2} exp = dedent("""\ %YAML 1.2 --- a: 1 b: 2 """) buf = StringIO() yaml.dump(data, buf) assert buf.getvalue() == exp
def spec_data(): """Read role_spec.yaml and parse it to structure""" with open(os.path.join(os.path.dirname(__file__), "role_spec.yaml"), encoding="utf-8") as f: return ruyaml.YAML().load(f)
def test_issue_223(self): import ruyaml yaml = ruyaml.YAML(typ='safe') yaml.load('phone: 0123456789')
def load(s, version=None): import ruyaml # NOQA yaml = ruyaml.YAML() yaml.version = version return yaml.load(dedent(s))