def test_succeed(parser: ParserElement, text: str, target: str = None, skip_target: bool = False, show_raw: bool = False, verbose: bool = False) -> None: log.critical("Testing to succeed: " + text) if target is None: target = text try: p = parser.parseString(text, parseAll=True) log.debug("Success: {} -> {}", text, text_from_parsed(p)) if show_raw: log.debug("... raw: {}", p) if verbose: log.debug("... dump:\n{}", p.dump()) except ParseException as exception: log.debug("ParseException on: {}\n... parser: {}", text, parser) print(statement_and_failure_marker(text, exception)) raise if not skip_target: intended = standardize_for_testing(target) raw = text_from_parsed(p) actual = standardize_for_testing(raw) if intended != actual: raise ValueError(f"Failure on: {text}\n" f"-> Raw output:\n" f"{raw!r}\n" f"-> Standardized output:\n" f"{actual!r}\n" f"... should have been:\n" f"{intended!r}\n" f"... parser: {parser}\n" f"... as list: {p.asList()!r}]")
def string_to_ast(rule: ParserElement, input_: str) -> Dict: """ Convert the input string "input_" into an AST, according to "rule" :param rule: :param input_: :return: a dictionary conforming the AST (the format changes from rule to rule) """ def clean_str(us): # "En dash" character is replaced by minus (-) # "Left/Right double quote" character is replaced by double quote (") # "Left/Right single quote" character is replaced by single quote (') # "€" character is replaced by "eur" # "$" character is replaced by "usd" return us.replace(u'\u2013', '-'). \ replace(u'\u201d', '"').replace(u'\u201c', '"'). \ replace(u'\u2018', "'").replace(u'\u2019', "'"). \ replace('€', 'eur'). \ replace('$', 'usd') res = rule.parseString(clean_str(input_), parseAll=True) res = res.asList()[0] while isinstance(res, list): res = res[0] return res
def test_fail(parser: ParserElement, text: str, verbose: bool = True) -> None: if verbose: log.critical("Testing to fail: {}", text) try: p = parser.parseString(text, parseAll=True) raise ValueError(f"Succeeded erroneously (no ParseException): {text}\n" f"-> structured format: {p}\n" f"-> Raw text output: {text_from_parsed(p)}\n" f"... parser: {parser}]") except ParseException: log.debug("Correctly failed: {}", text)
def test(parser: ParserElement, text: str) -> None: print(f"STATEMENT:\n{text}") # scanned = parser.scanString(text) # for tokens, start, end in scanned: # print(start, end, tokens) try: tokens = parser.parseString(text, parseAll=True) print(tokens.asXML()) # print(tokens.dump()) # print(text_from_parsed(tokens)) print(f"tokens = {tokens}") d = tokens.asDict() for k, v in d.items(): print(f"tokens.{k} = {v}") for c in tokens.columns: print(f"column: {c}") except ParseException as err: print(statement_and_failure_marker(text, err)) raise print()