def hgvs_parser(description, convert_to_model, grammar_file, start_rule,
save_png):
"""
Parse the HGVS description.
:param description: HGVS description.
:param grammar_file: Path towards grammar file.
:param start_rule: Root rule for the grammar.
:param save_png: Save parse tree as png.
:param convert_to_model:
"""
if grammar_file:
parser = HgvsParser(grammar_path=grammar_file, start_rule=start_rule)
else:
parser = HgvsParser()
try:
parse_tree = parser.parse(description)
except ParseError as e:
print(e)
else:
if parse_tree is not None:
if convert_to_model:
model = parse_tree_to_model(parse_tree)
print(json.dumps(model['model'], indent=2))
if save_png:
pydot__tree_to_png(parse_tree, save_png)
else:
print('Successfully parsed HGVS description:\n %s' %
description)
if save_png:
pydot__tree_to_png(parse_tree, save_png)
print('Parse tree image saved to:\n %s ' % save_png)
def test():
tree = EvalExpressions().transform(
l.parse(
"output = tf.nn.conv2d(input_op, kernel,(1,dh,dw,1),padding='SAME')"
))
pydot__tree_to_png(tree, "conv2d.png")
def visualize(self, png_path=None, show=False):
from lark.tree import pydot__tree_to_png
png_path = png_path or "/tmp/cell.png"
pydot__tree_to_png(self.tree, png_path)
if show:
import subprocess
subprocess.call(['open', png_path])
def visualize_lark(string: str, parser: Lark, path2filename: Union[str, Path]):
if type(path2filename) is str:
path2filename = Path(path2filename).expanduser()
else:
path2filename = path2filename.expanduser()
ast = parser.parse(string)
tree.pydot__tree_to_png(ast, path2filename)
def parse(query, full_tree=False, create_png=False):
ast = parser.parse(query)
if create_png:
filename = create_filename(query)
tree.pydot__tree_to_png(ast, filename)
if full_tree:
return ast
return RomanParser().transform(ast)
def get_tree(self, input, destination=None):
"""Generates readable representation of the input
optionally can save graph into a PNG file"""
tree = self._get_tree(input)
out = tree.pretty(indent_str=' ')
if destination:
pydot__tree_to_png(tree, destination)
return out
def make_png(
grounding
): # make a visual png of the AST for a given grounding. requires pydot package.
try:
parser = Lark(open('mod/ltl.lark').read(),
start='ltl',
ambiguity='explicit')
except FileNotFoundError:
parser = Lark(open('./ltl.lark').read(),
start='ltl',
ambiguity='explicit')
tree.pydot__tree_to_png(parser.parse(grounding), './parse.png')
def parse_idl_string(idl_string, png_file=None):
tree = get_ast_from_idl_string(idl_string)
content = extract_content_from_ast(tree)
if png_file:
os.makedirs(os.path.dirname(png_file), exist_ok=True)
try:
pydot__tree_to_png(tree, png_file)
except ImportError:
pass
return content
def parse_idl_string(idl_string, png_file=None):
tree = get_ast_from_idl_string(idl_string)
content = extract_content_from_ast(tree)
if png_file:
os.makedirs(os.path.dirname(png_file), exist_ok=True)
try:
pydot__tree_to_png(tree, png_file)
except ImportError:
pass
return content
def main(s, out_fn):
graphviz_setup()
project_root = os.path.normpath(os.path.join(os.path.dirname(__file__), "../../"))
fld = os.path.normpath(project_root + "./mappyfile")
gf = os.path.join(fld, "mapfile.lalr.g")
grammar_text = open(gf).read()
g = Lark(grammar_text, parser="lalr", lexer="contextual")
t = g.parse(s)
print(t)
pydot__tree_to_png(t, os.path.join(project_root, "docs/images", out_fn))
print(t.pretty())
def main(s, out_fn):
graphviz_setup()
project_root = os.path.normpath(
os.path.join(os.path.dirname(__file__), "../../"))
fld = os.path.normpath(project_root + "./mappyfile")
gf = os.path.join(fld, "mapfile.lalr.g")
grammar_text = open(gf).read()
g = Lark(grammar_text, parser="lalr", lexer="contextual")
t = g.parse(s)
print(t)
pydot__tree_to_png(t, os.path.join(project_root, "docs/images", out_fn))
print(t.pretty())
def parse_idl_string(idl_string, png_file=None):
global parser
tree = parser.parse(idl_string)
if png_file:
try:
from lark.tree import pydot__tree_to_png
except ImportError:
pass
else:
os.makedirs(os.path.dirname(png_file), exist_ok=True)
pydot__tree_to_png(tree, png_file)
return extract_content_from_ast(tree)
def f_compile(text, file_name=None, debug=0) -> CodeType:
if file_name is None:
try:
file_name = text.name
except AttributeError:
file_name = "<unknown>"
try:
text = text.read()
except AttributeError:
pass
tree = f.parse(text)
if debug > 0:
from lark.tree import pydot__tree_to_png
pydot__tree_to_png(tree, 'debug.png')
tree = FLarkTransformer(FASTTransformer()).transform(tree)
co = compile(tree, file_name, 'exec', dont_inherit=False)
return co
def add_mismatch_offsets(
netlist_in: Union[Path, str],
netlist_out: Optional[Union[Path, str]] = None,
debug: bool = False,
) -> None:
if isinstance(netlist_in, str):
netlist_in = Path(netlist_in)
if netlist_in.suffix in ['.cdl', '.sp', '.spf']:
parser = Lark(grammar_cdl, parser='lalr')
scs = False
elif netlist_in.suffix in ['.scs', '.net']:
parser = Lark(grammar_scs, parser='lalr')
scs = True
else:
raise ValueError(
f'Unknown netlist suffix={netlist_in.suffix}. Use ".cdl" or ".scs".'
)
lines = read_spectre_cdl_unwrap(netlist_in)
lines[-1] += '\n'
tree = parser.parse('\n'.join(lines))
if debug:
pydot__tree_to_png(tree, "test0.png")
obj_list = CktTransformer().transform(tree).children
obj_list[-1].last = True
if netlist_out is None:
netlist_out: Path = netlist_in.with_name(netlist_in.stem + 'out')
if isinstance(netlist_out, str):
netlist_out: Path = Path(netlist_out)
full_netlist = ''
used_names = []
offset_map = {}
for obj in obj_list:
full_netlist += obj.netlist(used_names, offset_map, scs)
for key, val in offset_map.items():
print(f'{val}: 0.0')
with open_file(netlist_out, 'w') as f:
f.write(full_netlist)
def run_earley_parser(sentence, word_sentence, counter, variant, label,
directory):
if '#unknown' in sentence:
# Unknown token cannot be resolved into valid tree
return None
try:
sentence_wo_floskule = [x for x in sentence if x != "#floskule"]
parse_tree = PARSER.parse(" ".join(sentence_wo_floskule))
# print(sentence)
# print(parse_tree.pretty())
# Map empty tokens to the sentence
# @note Currently, only single lemma enters sentence, so situation is quite simple
expanded_sentence = []
word_counter = 0
for t in get_tokens_from_tree(parse_tree):
word = ''
if t.startswith('#'):
word = word_sentence[word_counter]
word_counter += 1
expanded_sentence.append((word, t))
print(expanded_sentence)
larktree.pydot__tree_to_png(
parse_tree,
directory + '/sentence-{:03d}-{:02d}.png'.format(counter, variant),
label=label + "\n" + " ".join(sentence))
with open(
directory +
"/sentence-{:03d}-{:02d}.pretty".format(counter, variant),
"w") as f:
f.write(parse_tree.pretty())
except Exception as e:
LOGGER.info(e)
LOGGER.info("Unable to create a tree for <%s>", (" ".join(sentence)))
return False
return True
def image_tree(self, which="after"):
if which == "after":
pydot__tree_to_png(self.after_tree, "../tree-after.png")
else:
if which == "before":
pydot__tree_to_png(self.after_tree, "../tree-before.png")
else:
pydot__tree_to_png(self.after_tree, "../tree-after.png")
line = line.rstrip()
if (len(line) > 0):
count = 1
items = line.split()
word = items[0]
if (len(items) > 1):
if (items[0].isdigit()):
count = items[0]
word = items[len(items) - 1]
else:
count = items[len(items) - 1]
tot += int(count)
print("'" + line + "'")
try:
out_tree = lrk.parse(word)
sys.stdout.write("SUCCESS:True " + word + " ")
print(repr(out_tree).replace("Tree", ""))
fname = word + "_" + gname + ".png"
print(fname)
tree.pydot__tree_to_png(out_tree, fname)
success += int(count)
except:
print("Exception " + line)
#lrk.parse(word)
perc_succ = 100.0 * float(success) / float(tot)
print("TOT_WORDS: " + str(tot) + " TOT_SUCCESS: " + str(success) +
" TOT_FAIL: " + str(tot - success))
print('SUCCESS%: ' + frmt(perc_succ) + " FAIL%: " + frmt(100.0 - perc_succ))
LE: "<="
GT: ">"
GE: ">="
EQ: "=="
NE: "!="
ASSIGN: "="
CHAR: "a".."z" | "A".."Z"
%import common.SIGNED_INT
%import common.CNAME -> VAR
%import common.ESCAPED_STRING -> STR
%import common.WS
%import common.CPP_COMMENT
%ignore WS
%ignore CPP_COMMENT
'''
# TODO: update grammar to use lalr parser
parser = Lark(language_grammar)
parse = parser.parse
if __name__ == '__main__':
import sys
from lark import tree
program = sys.argv[1]
program = open(program, 'rt', encoding='utf-8').read()
program = parse(program)
tree.pydot__tree_to_png(program, 'program.png')
def _parse_tree_to_png(tree, file):
from lark.tree import pydot__tree_to_png
pydot__tree_to_png(tree, file)
def saveTreeImg(self,tree):
pydot__tree_to_png(tree, "syntaxTree.png")
ID : /[_A-Za-z]([A-Za-z0-9_]*)/
EQUALS : /=/
TYPE : /int|float|double|boolean/
%import common.NUMBER
%import common.WS
%ignore WS
"""
file = open('test.txt', 'r')
# Creacion del objeto que representa la gramatica
parser = Lark(grammar, start='inst')
i = 1
nameTREE = ''
# Leer el archivo linea por linea
for line in file:
try:
result = parser.parse(line.rstrip())
except Exception:
print("Error sintactico en linea " + str(i))
else:
print(result.pretty())
nameTREE = 'arbol_' + str(i) + '.png'
i += 1
pydot__tree_to_png(result, nameTREE)
file.close()
"""
Utility to check out the dice tree and generate images of graphs because pretty.
Test syntaxes:
1d20
1+1
4d6kh3
(1)
(1,)
(((1d6)))
4*(3d8kh2+9[fire]+(9d2e2+3[cold])/2)
(1d4, 2+2, 3d6kl1)kh1
((10d6kh5)kl2)kh1
"""
from lark import Lark
from lark.tree import pydot__tree_to_png
with open("d20/grammar.lark") as f:
grammar = f.read()
parser = Lark(grammar, start='expr', parser='lalr')
while True:
result = parser.parse(input())
print(result.pretty())
print(result)
pydot__tree_to_png(result, 'tree.png')
%import common.NUMBER
'''
grammar2 = '''
start: NUMBER "+" NUMBER | NUMBER "-" NUMBER | WORD
WORD: " "*
%import common.NUMBER
'''
'''
SPACE: " "*
STRING: [STRING]| WORD
'''
grammar_print = '''
start: "print" SPACE STRING
STRING: QUOTES /[A-Z a-z 0-9 //w]*/ QUOTES
QUOTES: "\'"
%import common.WORD
SPACE: " "+
'''
parser = l(grammar_print)
inp = input("INP: ")
tree = parser.parse(inp)
print(tree)
from lark.tree import pydot__tree_to_png # Just a neat utility function
pydot__tree_to_png(tree, "examples/fruitflies.png")
def save_diagram(tree, filename, show=False):
pydot__tree_to_png(tree, filename)
if show:
return Image(filename)
def make_png(data):
tree.pydot__tree_to_png(data, "out.png")
def make_png(self, sentence, filename):
tree.pydot__tree_to_png(sentence, filename)
def make_png(filename):
tree.pydot__tree_to_png(parser.parse(sentence), filename)
def make_png(parsed_tree, filename):
pydot__tree_to_png(parsed_tree, filename)
def plot_tree(self, filename: str = 'tree'):
pydot__tree_to_png(self.tree, filename + ".png")
import os
from lark import Lark
from lark.tree import pydot__tree_to_png
GVIZ_PATH = r"C:\Program Files (x86)\Graphviz2.38\bin"
def graphviz_setup():
os.environ['PATH'] = GVIZ_PATH + ';' + os.environ['PATH']
graphviz_setup()
fld = os.path.normpath(
os.path.join(os.path.dirname(__file__), "../.././mappyfile"))
gf = os.path.join(fld, "mapfile.g")
grammar_text = open(gf).read()
g = Lark(grammar_text, parser='earley', lexer='standard')
t = g.parse("MAP NAME 'Test' END")
print(t)
pydot__tree_to_png(t, r"C:\temp\tree.png")
print(t.pretty())
def make_ast_image(self, filename) -> None:
'''Cria uma imagem da AST gerada'''
if (self._tree == None) :
raise Exception("Parser tree is not exist.")
tree.pydot__tree_to_png(self._tree, filename+".png")
pngs_folder = os.path.join(str(current_dir), 'ast_pngs/')
def create_filename(query):
f = query.replace(":", "_colon_")
f = f.replace("=", "_equal_")
f = f.replace(">", "_gt_")
f = f.replace("/", "_slash_")
f = f.replace("|", "_pipe_")
f = f.replace("?", "_questionmark_")
f = f.replace("#", "_sharp_")
f = f.replace("+", "_plus_")
f = f.replace("(", "_parenthesisl_")
f = f.replace(")", "_parenthesisr_")
f = f.replace("[", "_bracketl_")
f = f.replace("]", "_bracketr_")
return pngs_folder + f + ".png"
def parse(query, full_tree=False, create_png=False):
ast = parser.parse(query)
if create_png:
filename = create_filename(query)
tree.pydot__tree_to_png(ast, filename)
if full_tree:
return ast
return RomanParser().transform(ast)
if __name__ == '__main__':
ast = parse(sys.argv[1], full_tree=True)
print(RomanParser().transform(ast))
tree.pydot__tree_to_png(ast, 'ast_pngs/harmalysis_roman.png')
