def test_cannot_convert_EBNF_to_strategy_directly(): with pytest.raises(InvalidArgument): # Not a Lark object from_lark(EBNF_GRAMMAR).example() with pytest.raises(TypeError): # Not even the right number of arguments from_lark(EBNF_GRAMMAR, start="value").example()
def test_cannot_convert_EBNF_to_strategy_directly(): with pytest.raises(InvalidArgument): # Not a Lark object from_lark(EBNF_GRAMMAR).example() with pytest.raises(TypeError): # Not even the right number of arguments from_lark(EBNF_GRAMMAR, start="value").example()
def test_can_not_use_undefined_terminals_yet(): grammar = r""" list : "[" ELEMENT ("," ELEMENT)* "]" %declare ELEMENT """ with pytest.raises(InvalidArgument): from_lark(Lark(grammar, start="list")).example()
def test_can_not_use_undefined_terminals_yet(): grammar = r""" list : "[" ELEMENT ("," ELEMENT)* "]" %declare ELEMENT """ with pytest.raises(InvalidArgument): from_lark(Lark(grammar, start="list")).example()
def test_undefined_terminals_require_explicit_strategies(): elem_grammar = r""" list : "[" [ELEMENT ("," ELEMENT)*] "]" %declare ELEMENT """ with pytest.raises(InvalidArgument): from_lark(Lark(elem_grammar, start="list")).example() strategy = {"ELEMENT": just("200")} from_lark(Lark(elem_grammar, start="list"), explicit=strategy).example()
def test_generation_without_whitespace(): list_grammar = r""" list : "[" [NUMBER ("," NUMBER)*] "]" NUMBER: /[0-9]+/ """ @given(from_lark(Lark(list_grammar, start="list"))) def test(g): assert " " not in g test()
def test_can_generate_ignored_tokens(): list_grammar = r""" list : "[" [STRING ("," STRING)*] "]" STRING : /"[a-z]*"/ WS : /[ \t\r\n]+/ %ignore WS """ strategy = from_lark(Lark(list_grammar, start="list")) # A JSON list of strings in canonical form which does not round-trip, # must contain ignorable whitespace in the initial string. find_any(strategy, lambda s: "\t" in s)
def test_generation_without_whitespace(): list_grammar = r""" list : "[" [NUMBER ("," NUMBER)*] "]" NUMBER: /[0-9]+/ """ @given(from_lark(Lark(list_grammar, start="list"))) def test(g): assert " " not in g test()
def test_can_generate_ignored_tokens(): list_grammar = r""" list : "[" [STRING ("," STRING)*] "]" STRING : /"[a-z]*"/ WS : /[ \t\r\n]+/ %ignore WS """ strategy = from_lark(Lark(list_grammar, start="list")) # A JSON list of strings in canoncial form which does not round-trip, # must contain ignorable whitespace in the initial string. find_any(strategy, lambda s: "\t" in s)
def test_cannot_convert_EBNF_to_strategy_directly(): with pytest.raises(InvalidArgument): # Not a Lark object from_lark(EBNF_GRAMMAR).example() with pytest.raises(TypeError): # Not even the right number of arguments from_lark(EBNF_GRAMMAR, start="value").example() with pytest.raises(InvalidArgument): # Wrong type for explicit_strategies from_lark(Lark(LIST_GRAMMAR, start="list"), explicit=[]).example()
def test_can_specify_start_rule(data, start, type_): string = data.draw( from_lark(Lark(EBNF_GRAMMAR, start="value"), start=start)) value = json.loads(string) assert isinstance(value, type_)
def test_non_string_explicit_strategies_are_invalid(): with pytest.raises(InvalidArgument): from_lark(Lark(LIST_GRAMMAR, start="list"), explicit={ "NUMBER": just(0) }).example()
def test_cannot_use_explicit_strategies_for_unknown_terminals(): with pytest.raises(InvalidArgument): from_lark(Lark(LIST_GRAMMAR, start="list"), explicit={ "unused_name": just("") }).example()
import hypothesis grammar_source = r""" prog: stmt+ stmt: typ id "=" num ";" typ: "int" | "float" id: /[a-z]+/ num: /[0-9]+/ %ignore /[ ]+/ """ grammar = Lark(grammar_source, start='prog') @hypothesis.given(from_lark(grammar, start='prog')) def test_lark_token_concatenation(prog): print('===========') print(prog) print('----') p = grammar.parse(prog) print(p) print('===========') if __name__ == "__main__": test_lark_token_concatenation()
dict : "{" [STRING ":" value ("," STRING ":" value)*] "}" STRING : /"[a-z]*"/ NUMBER : /-?[1-9][0-9]*(\.[0-9]+)?([eE][+-]?[0-9]+)?/ WS : /[ \t\r\n]+/ %ignore WS """ LIST_GRAMMAR = r""" list : "[" [NUMBER ("," NUMBER)*] "]" NUMBER: /[0-9]+/ """ @given(from_lark(Lark(EBNF_GRAMMAR, start="value"))) def test_generates_valid_json(string): json.loads(string) @pytest.mark.parametrize( "start, type_", [ ("dict", dict), ("list", list), ("STRING", str), ("NUMBER", (int, float)), ("TRUE", bool), ("FALSE", bool), ("NULL", type(None)), ],
def test_can_specify_start_rule(data, start, type_): string = data.draw(from_lark(Lark(EBNF_GRAMMAR, start="value"), start=start)) value = json.loads(string) assert isinstance(value, type_)
#gramática generativa # !pip install lark-parser --user # !pip install hypothesis --user from lark import Lark from hypothesis.extra import lark grammar = Lark (""" start : PLANETA S "em" S SIGNO S "indica" S evento "." evento : "que você terá" S PROBLEMA S ALVO | "uma boa fase" S ALVO PLANETA : "Mercúrio" | "Vênus" SIGNO : "Capricórnio" | "Peixes" PROBLEMA : "problemas" | "decepções" ALVO : "no amor" | "no trabalho" | "na vida financeira" | "na universidade" S : " " """) frase = "Mercúrio em Peixes indica que você terá problemas na universidade." tree=grammar.parse(frase) print(tree.pretty) gen = lark.from_lark(grammar) for i in range(10): print(gen.example())
| "let me down,\nyou have found her, now go and get her" rememberto : "remember to" WS rememberwhat NL rememberwhat: "let her into your heart" | "let her under your skin" then : "then you" WS thenwhat WS "to make it better" NL thenwhat : "can start" | "begin" better : starstbetter "waaaaa" NL starstbetter: "better" WS | "better" WS starstbetter nanana : beginnanana "na-na-na-na" NL NL startnanana : "na" WS | "na" WS startnanana WS : " " NL : "\n" """) generator = from_lark(grammar) ex = generator.example() print() print("=" * 50) print(ex)
#!/usr/bin/env python # -*- coding: utf-8 -*- from lark import Lark from hypothesis.extra.lark import from_lark import argparse import sys if __name__ == '__main__': parser = argparse.ArgumentParser(description='Generate grammar samples.') parser.add_argument('--grammar', dest='grammar', help='file with grammar syntax') parser.add_argument('--start', dest='start', help='start terminal') args = parser.parse_args() if (not args.grammar): sys.exit(1) if args.grammar == "mime.lark": sys.setrecursionlimit(10000) with open(args.grammar, 'r') as grammar: sample = from_lark(Lark(open(args.grammar, 'r'), start="start")).example() print('{}'.format(sample))
| "|" | "&" %ignore / +/ %declare NUM ID """ grammar = Lark(grammar_text) explicit = { "NUM": st.integers().map(str), "ID": st.text(alphabet="abcdefghijUVWXYZ", min_size=6), } @given(from_lark(grammar, explicit=explicit)) def test_c(prog): """ Test various randomly generated slabs of C-ish code. """ print(prog) try: ast = parse_text(prog) except CompilerError as ex: print("Compilation error", ex) else: print(ast) print_ast(ast) if __name__ == "__main__": test_c()
| NUMBER | "true" -> true | "false" -> false | "null" -> null list : "[" [value ("," value)*] "]" dict : "{" [STRING ":" value ("," STRING ":" value)*] "}" STRING : /"[a-z]*"/ NUMBER : /-?[1-9][0-9]*(\.[0-9]+)?([eE][+-]?[0-9]+)?/ WS : /[ \t\r\n]+/ %ignore WS """ @given(from_lark(Lark(EBNF_GRAMMAR, start="value"))) def test_generates_valid_json(string): json.loads(string) @pytest.mark.parametrize( "start, type_", [ ("dict", dict), ("list", list), ("STRING", text_type), ("NUMBER", integer_types + (float, )), ("TRUE", bool), ("FALSE", bool), ("NULL", type(None)), ],
def test_generation_without_whitespace(): find_any(from_lark(Lark(LIST_GRAMMAR, start="list")), lambda g: " " not in g)
'rfc_1738': _build_path('rfc_1738.lark'), 'rfc_2397': _build_path('rfc_2397.lark'), 'rfc_2396': _build_path('rfc_2396.lark'), 'rfc_6531': _build_path('rfc_6531.lark'), 'rfc_5321': _build_path('rfc_5321.lark'), 'rfc_5545': _build_path('rfc_5545.lark'), 'robotstxt': _build_path('robotstxt.lark'), 'subunit_v1': _build_path('subunit_v1.lark'), 'tap13': _build_path('tap13.lark'), 'toml': _build_path('toml.lark'), 'yaml': _build_path('yaml.lark') } if __name__ == '__main__': hypothesis.seed(time.time()) parser = argparse.ArgumentParser(description='Generate grammar samples.') parser.add_argument('--grammar', dest='grammar', help='file with grammar syntax') parser.add_argument('--start', dest=DEFAULT_START, help='start terminal') args = parser.parse_args() if (not args.grammar): sys.exit(1) if args.grammar == 'mime.lark': sys.setrecursionlimit(10000) with open(args.grammar, 'r') as grammar: sample = from_lark(Lark(grammar, start=args.start)).example() print('{}'.format(sample))
| NUMBER | "true" -> true | "false" -> false | "null" -> null list : "[" [value ("," value)*] "]" dict : "{" [STRING ":" value ("," STRING ":" value)*] "}" STRING : /"[a-z]*"/ NUMBER : /-?[1-9][0-9]*(\.[0-9]+)?([eE][+-]?[0-9]+)?/ WS : /[ \t\r\n]+/ %ignore WS """ @given(from_lark(Lark(EBNF_GRAMMAR, start="value"))) def test_generates_valid_json(string): json.loads(string) @pytest.mark.parametrize( "start, type_", [ ("dict", dict), ("list", list), ("STRING", text_type), ("NUMBER", integer_types + (float,)), ("TRUE", bool), ("FALSE", bool), ("NULL", type(None)), ],
from hypothesis import given, strategies from hypothesis.extra.lark import from_lark import lark from beboppy import __version__ from beboppy import encode, decode, generate, parse parser = parse.get_parser() bop_strategy = from_lark(parser, start="start") msg_strategy = from_lark(parser, start="message") struct_strategy = from_lark(parser, start="struct") enum_strategy = from_lark(parser, start="enum") def test_version(): assert __version__ == '0.1.0' def assert_roundtrips(val, e_func, d_func): encoded = e_func(val) decoded = d_func(encoded) assert decoded == val, f"Given {val}, encoded: {encoded}, decoded: {decoded}" @given(strategies.booleans()) def test_roundtrip_bool(val: bool): assert_roundtrips(val, encode.encode_bool, decode.decode_bool) def assert_parses(text: str) -> lark.Tree:
def test_grammars(name, path): if os.path.basename(path) in skipped: pytest.skip() with open(path, 'r') as fh: from_lark(Lark(fh)).example()