def main(debug=False): bool_mm = metamodel_from_str(grammar, classes=[Bool, Or, And, Not, Operand], ignore_case=True, debug=debug) this_folder = dirname(__file__) if debug: metamodel_export(bool_mm, join(this_folder, 'bool_metamodel.dot')) input_expr = ''' a = true; b = not a and true; a and false or not b ''' model = bool_mm.model_from_str(input_expr) if debug: model_export(model, join(this_folder, 'bool_model.dot')) # Getting value property from the Bool instance will start evaluation. result = model.value assert model.value is True print("Result is", result)
def execute(path, grammar_file_name, example_file_name, export_dot, export_png): '''U svrhe brzeg testiranja, metoda koja prima putanju do foldera, naziv fajla gde je gramatika i naziv fajla gde je primer programa u nasem jeziku i indikator da li da se eksportuju .dot i .png fajlovi''' meta_path = os.path.join(path, grammar_file_name) meta_name = os.path.splitext(meta_path)[0] metamodel = metamodel_from_file(meta_path) if export_dot: metamodel_export(metamodel, meta_name + '.dot') if export_png: graph = pydotplus.graph_from_dot_file(meta_name + '.dot') graph.write_png(meta_name + '.png') model_path = os.path.join(path, example_file_name) model_name = os.path.splitext(model_path)[0] model = metamodel.model_from_file(model_path) if export_dot: model_export(model, model_name + '.dot') if export_png: graph = pydotplus.graph_from_dot_file(model_name + '.dot') graph.write_png(model_name + '.png') return model
def main(debug=False): calc_mm = metamodel_from_str( grammar, classes=[Calc, Expression, Term, Factor, Operand], debug=debug) this_folder = dirname(__file__) if debug: metamodel_export(calc_mm, join(this_folder, 'calc_metamodel.dot')) input_expr = ''' a = 10; b = 2 * a + 17; -(4-1)*a+(2+4.67)+b*5.89/(.2+7) ''' model = calc_mm.model_from_str(input_expr) if debug: model_export(model, join(this_folder, 'calc_model.dot')) # Getting value property from the Calc instance will start evaluation. result = model.value assert (model.value - 6.93805555) < 0.0001 print("Result is", result)
def load_model(file_name): """Generates program model from '/examples' and returns it.""" # current_dir = os.path.dirname(__file__) # __file__ is unbound in interactive mode current_dir = os.path.dirname(os.path.realpath(__file__)) visualization_dir = os.path.join(current_dir, pymajorme_config.VISUALIZATION_DIR) if not os.path.exists(visualization_dir): os.makedirs(visualization_dir) # jorm_mm = entity_mm.get_entity_mm() jorm_mm = metamodel_from_file(os.path.join(current_dir, 'languages', 'pymajorme_language.tx'), classes=[javatype.JavaType], # Register Entity class builtins=javatype.get_java_builtins(), debug=False) metamodel_export(jorm_mm, os.path.join(visualization_dir, 'jorm_metamodel.dot')) model = jorm_mm.model_from_file(os.path.join(current_dir, file_name)) model_export(model, os.path.join(visualization_dir, 'jorm_model.dot')) return model
def execute(path, grammar_file_name, example_file_name, export_dot, export_png): """U svrhe brzeg testiranja, metoda koja prima putanju do foldera, naziv fajla gde je gramatika i naziv fajla gde je primer programa u nasem jeziku i indikator da li da se eksportuju .dot i .png fajlovi""" meta_path = os.path.join(SRC_DIR, 'model', grammar_file_name) meta_name = os.path.splitext(meta_path)[0] metamodel = metamodel_from_file(meta_path) if export_dot: metamodel_export(metamodel, meta_name + '.dot') if export_png: graph = pydot.graph_from_dot_file(meta_name + '.dot') graph.write_png(meta_name + '.png') model_path = os.path.join(path, example_file_name) model_name = os.path.splitext(model_path)[0] model = metamodel.model_from_file(model_path) if export_dot: model_export(model, model_name + '.dot') if export_png: graph = pydot.graph_from_dot_file(model_name + '.dot') graph.write_png(model_name + '.png') return model
def visualize(ctx, meta_model_file, model_file, ignore_case, output_format): """ Generate .dot file(s) from meta-model and optionally model. """ debug = ctx.obj['debug'] meta_model, model = check_model(meta_model_file, model_file, debug, ignore_case) if output_format == 'plantuml': pu_file = "{}.pu".format(meta_model_file) click.echo("Generating '{}' file for meta-model.".format(pu_file)) click.echo("To convert to png run 'plantuml {}'".format(pu_file)) click.echo("To convert to svg run 'plantuml -tsvg {}'".format(pu_file)) metamodel_export(meta_model, pu_file, PlantUmlRenderer()) else: dot_file = "{}.dot".format(meta_model_file) click.echo("Generating '{}' file for meta-model.".format(dot_file)) click.echo("To convert to png run 'dot -Tpng -O {}'".format(dot_file)) metamodel_export(meta_model, dot_file) if model_file: if output_format == 'plantuml': raise Exception("plantuml is not supported for model files, yet.") dot_file = "{}.dot".format(model_file) click.echo("Generating '{}' file for model.".format(model_file)) click.echo( "To convert to png run 'dot -Tpng -O {}'".format(model_file)) model_export(model, dot_file)
def main(debug=False): calc_mm = metamodel_from_str(grammar, classes=[Calc, Expression, Term, Factor, Operand], debug=debug) this_folder = dirname(__file__) if debug: metamodel_export(calc_mm, join(this_folder, 'calc_metamodel.dot')) input_expr = ''' a = 10; b = 2 * a + 17; -(4-1)*a+(2+4.67)+b*5.89/(.2+7) ''' model = calc_mm.model_from_str(input_expr) if debug: model_export(model, join(this_folder, 'calc_model.dot')) # Getting value property from the Calc instance will start evaluation. result = model.value assert (model.value - 6.93805555) < 0.0001 print("Result is", result)
def _visualize(self, fileName): fileType = self.get_file_type(fileName) if fileType == METAMODEL: # Get meta-model from language description try: self.meta_model = metamodel_from_file(fileName) if not self.graph_widget.isHidden(): # Export model to dot path = os.path.join(PRJ_PATH, "meta.dot") metamodel_export(self.meta_model, path) svg_path = os.path.join(PRJ_PATH, "img", METAMODEL_SVG) self.create_load_svg( path, svg_path, file_manager.get_module_name(fileName), 0) except TextXError as error: self.handle_exception(fileName, 0, error.line) elif fileType == MODEL: if not self.graph_widget.isHidden(): try: self.model = self.meta_model.model_from_file(fileName) path = os.path.join(PRJ_PATH, "model.dot") model_export(self.model, path) svg_path = os.path.join(PRJ_PATH, "img", MODEL_SVG) self.create_load_svg( path, svg_path, file_manager.get_module_name(fileName), 1) except TextXError as error: self.handle_exception(fileName, 1, error.line)
def test_multiple_imports(): """ Test that rules grammars imported from multiple places results in the same meta-class objects. """ current_dir = os.path.dirname(__file__) mm = metamodel_from_file(os.path.join(current_dir, 'multiple', 'first.tx')) print(mm['First']._tx_attrs) print(mm['First']._tx_attrs['first'].cls._tx_attrs['second'].cls.__name__) print(mm['Third']) print(type(mm['First']._tx_attrs['first'])) assert mm['First']._tx_attrs['first'].cls._tx_attrs['second'].cls \ is mm['relative.third.Third'] metamodel_export(mm, 'multipleimport_test_mm.dot') model = """ first 1 2 third "one" "two" """ model = mm.model_from_str(model) model_export(model, 'multipleimport_test_model.dot')
def execute_for_web(path, grammar_file_name, query, export_dot, export_png): meta_path = os.path.join(path, grammar_file_name) meta_name = os.path.splitext(meta_path)[0] metamodel = metamodel_from_file(meta_path) if export_dot: metamodel_export(metamodel, meta_name + '.dot') if export_png: graph = pydot.graph_from_dot_file(meta_name + '.dot') #graph[0].write_png(meta_name + '.png') model = metamodel.model_from_str(query) model_name = "" if BASE_DIR.__contains__('/'): model_name = path + '/query' # linux else: model_name = path + '\query' # windows if export_dot: model_export(model, model_name + '.dot') if export_png: graph = pydot.graph_from_dot_file(model_name + '.dot') #graph[0].write_png(model_name + '.png') return model
def parse(self, path, grammar_file_name, model_file_name, export_dot): meta_path = os.path.join(path, grammar_file_name) meta_name = os.path.splitext(meta_path)[0] type_builtins = { 'int': SimpleType(None, 'Int'), 'string': SimpleType(None, 'String'), 'long': SimpleType(None, 'Long'), 'double': SimpleType(None, 'Double'), 'byte': SimpleType(None, 'Byte'), 'float': SimpleType(None, 'Float'), 'boolean': SimpleType(None, 'Boolean') } metamodel = metamodel_from_file(meta_path, classes=[SimpleType], builtins=type_builtins) obj_processors = { 'Product': Parser.product_obj_processor, 'Category': Parser.category_obj_processor, 'Property': Parser.property_obj_processor } metamodel.register_obj_processors(obj_processors) metamodel.register_model_processor(Parser.check_some_semantics) if export_dot: metamodel_export(metamodel, meta_name + '.dot') model_path = os.path.join(path, model_file_name) model_name = os.path.splitext(model_path)[0] model = metamodel.model_from_file(model_path) if export_dot: model_export(model, model_name + '.dot') return model
def textx(): """ textx console command. """ class MyParser(argparse.ArgumentParser): """ Custom argument parser for printing help message in case of an error. See http://stackoverflow.com/questions/4042452/display-help-message-with-python-argparse-when-script-is-called-without-any-argu """ def error(self, message): sys.stderr.write('error: %s\n' % message) self.print_help() sys.exit(2) parser = MyParser(description='textX checker and visualizer') parser.add_argument('cmd', help='Command - "check" or "visualize"') parser.add_argument('metamodel', help='Meta-model file name') parser.add_argument('model', help='Model file name', nargs='?') parser.add_argument('-i', help='case-insensitive parsing', action='store_true') parser.add_argument('-d', help='run in debug mode', action='store_true') args = parser.parse_args() if args.cmd not in ['visualize', 'check']: print("Unknown command {}. Command must be one of" " 'visualize', 'check'.".format(args.cmd)) sys.exit(1) try: metamodel = metamodel_from_file(args.metamodel, ignore_case=args.i, debug=args.d) print("Meta-model OK.") except TextXError as e: print("Error in meta-model file.") print(e) sys.exit(1) if args.model: try: model = metamodel.model_from_file(args.model, debug=args.d) print("Model OK.") except TextXError as e: print("Error in model file.") print(e) sys.exit(1) if args.cmd == "visualize": print("Generating '%s.dot' file for meta-model." % args.metamodel) print("To convert to png run 'dot -Tpng -O %s.dot'" % args.metamodel) metamodel_export(metamodel, "%s.dot" % args.metamodel) if args.model: print("Generating '%s.dot' file for model." % args.model) print("To convert to png run 'dot -Tpng -O %s.dot'" % args.model) model_export(model, "%s.dot" % args.model)
def get_outline_model(self): this_folder = dirname(__file__) language = metamodel_from_file(join(dirname(__file__), 'outline.tx')) metamodel_export(language, join(dirname(__file__), 'outline.dot')) grammar_model = language.model_from_file( join(this_folder, 'outline.ol')) model_export(grammar_model, join(this_folder, 'outline.dot')) return grammar_model
def main(debug = False): metamodel_export(data_dsl_mm, join(this_folder, 'family-tree_meta.dot')) family_tree_model = data_dsl_mm.model_from_file(join(this_folder, "miljkovic.family")) model_export(family_tree_model, join(this_folder, 'family-tree.dot')) family_tree_to_txt = generator_for_language_target('family_tree_dsl', 'txt') family_tree_to_txt(data_dsl_mm, family_tree_model,this_folder,True) family_tree_to_html = generator_for_language_target('family_tree_dsl', 'html') family_tree_to_html(data_dsl_mm, family_tree_model,this_folder,True)
def main(debug=False): entity_mm = get_entity_mm(debug) dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entity_meta.dot')) Car_model = entity_mm.model_from_file(join(this_folder, 'Car.ent')) model_export(Car_model, join(dot_folder, 'Car.dot'))
def textx(): """ textx console command """ class MyParser(argparse.ArgumentParser): """ Custom arugment parser for printing help message in case of error. See http://stackoverflow.com/questions/4042452/display-help-message-with-python-argparse-when-script-is-called-without-any-argu """ def error(self, message): sys.stderr.write('error: %s\n' % message) self.print_help() sys.exit(2) parser = MyParser(description='textX checker and visualizer') parser.add_argument('cmd', help='Command - "check" or "visualize"') parser.add_argument('metamodel', help='Meta-model file name') parser.add_argument('model', help='Model file name', nargs='?') parser.add_argument('-i', help='case-insensitive parsing', action='store_true') parser.add_argument('-d', help='run in debug mode', action='store_true') args = parser.parse_args() if args.cmd not in ['visualize', 'check']: print("Unknown command {}. Command must be one of" " 'visualize', 'check'.".format(args.cmd)) sys.exit(1) try: metamodel = metamodel_from_file(args.metamodel, ignore_case=args.i, debug=args.d) print("Meta-model OK.") except TextXError as e: print("Error in meta-model file.") print(e) sys.exit(1) if args.model: try: model = metamodel.model_from_file(args.model, debug=args.d) print("Model OK.") except TextXError as e: print("Error in model file.") print(e) sys.exit(1) if args.cmd == "visualize": print("Generating '%s.dot' file for meta-model." % args.metamodel) print("To convert to png run 'dot -Tpng -O %s.dot'" % args.metamodel) metamodel_export(metamodel, "%s.dot" % args.metamodel) if args.model: print("Generating '%s.dot' file for model." % args.model) print("To convert to png run 'dot -Tpng -O %s.dot'" % args.model) model_export(model, "%s.dot" % args.model)
def main(path=None, debug=False, reportfilename=None): if path is None: path = join(dirname(__file__), "..", "..") if reportfilename is None: reportfilename = join(dirname(__file__), "REPORT.md") print("render_all_grammars.py - example program") matches = [] for root, dirnames, filenames in os.walk(path): for filename in fnmatch.filter(filenames, '*.tx'): matches.append((root, filename)) with open(reportfilename, "wt") as md: md.write("# All grammars (*.tx)\n") for m in matches: inname = join(m[0], m[1]) outfname_base = "{}_{}".format( m[0].replace(path, '').lstrip(sep).replace(sep, '_'), m[1].rstrip('.tx')) destpath = join(dirname(reportfilename), "dot") if not exists(destpath): os.mkdir(destpath) dest_dot = join(destpath, outfname_base + ".dot") dest_dot_png = join(destpath, outfname_base + ".dot.png") destpath = join(dirname(reportfilename), "pu") if not exists(destpath): os.mkdir(destpath) dest_pu = join(destpath, outfname_base + ".pu") dest_pu_png = join(destpath, outfname_base + ".png") print(dest_dot) mm = metamodel_from_file(inname, debug=debug) metamodel_export(mm, dest_dot) metamodel_export(mm, dest_pu, renderer=PlantUmlRenderer()) md.write("## {}\n".format(m[1])) md.write(" * source: {}/{}\n".format(m[0], m[1])) md.write(" * basename: {}\n".format(outfname_base)) md.write('\n') with open(inname, "rt") as gr: for l in gr: md.write("\t\t" + l) md.write('\n') rel_dest_dot_png = os.path.relpath(dest_dot_png, dirname(reportfilename)) rel_dest_pu_png = os.path.relpath(dest_pu_png, dirname(reportfilename)) md.write('<img width="49%" src="{}" alt="{}">\n'.format( rel_dest_pu_png, rel_dest_pu_png)) md.write('<img width="49%" src="{}" alt="{}">\n'.format( rel_dest_dot_png, rel_dest_dot_png)) md.write('\n\n') print("-------------------------") print("how to process and display the output:") print(" dot -O -Tpng dot/*.dot") print(" plantuml pu/*.pu") print("open the generated {}".format(reportfilename))
def main(path=None, debug=False, reportfilename=None): if path is None: path = join(dirname(__file__), "..", "..") if reportfilename is None: reportfilename = join(dirname(__file__), "REPORT.md") print("render_all_grammars.py - example program") matches = [] for root, dirnames, filenames in os.walk(path): for filename in fnmatch.filter(filenames, '*.tx'): matches.append((root, filename)) with open(reportfilename, "wt") as md: md.write("# All grammars (*.tx)\n") for m in matches: inname = join(m[0], m[1]) outfname_base = "{}_{}".format( m[0].replace(path, '').lstrip(sep).replace(sep, '_'), m[1].rstrip('.tx')) destpath = join(dirname(reportfilename), "dot") if not exists(destpath): os.mkdir(destpath) dest_dot = join(destpath, outfname_base + ".dot") dest_dot_png = join(destpath, outfname_base + ".dot.png") destpath = join(dirname(reportfilename), "pu") if not exists(destpath): os.mkdir(destpath) dest_pu = join(destpath, outfname_base+".pu") dest_pu_png = join(destpath, outfname_base+".png") print(dest_dot) mm = metamodel_from_file(inname, debug=debug) metamodel_export(mm, dest_dot) metamodel_export(mm, dest_pu, renderer=PlantUmlRenderer()) md.write("## {}\n".format(m[1])) md.write(" * source: {}/{}\n".format(m[0], m[1])) md.write(" * basename: {}\n".format(outfname_base)) md.write('\n') with open(inname, "rt") as gr: for l in gr: md.write("\t\t"+l) md.write('\n') rel_dest_dot_png = os.path.relpath( dest_dot_png, dirname(reportfilename)) rel_dest_pu_png = os.path.relpath( dest_pu_png, dirname(reportfilename)) md.write('<img width="49%" src="{}" alt="{}">\n'.format( rel_dest_pu_png, rel_dest_pu_png)) md.write('<img width="49%" src="{}" alt="{}">\n'.format( rel_dest_dot_png, rel_dest_dot_png)) md.write('\n\n') print("-------------------------") print("how to process and display the output:") print(" dot -O -Tpng dot/*.dot") print(" plantuml pu/*.pu") print("open the generated {}".format(reportfilename))
def main(debug=False): this_folder = dirname(__file__) pyflies_mm = metamodel_from_file(join(this_folder,'pyflies.tx'), debug=debug) metamodel_export(pyflies_mm, join(this_folder, 'pyflies_meta.dot')) experiment = pyflies_mm.model_from_file(join(this_folder, 'experiment.pf')) model_export(experiment, join(this_folder, 'experiment.dot'))
def get_outline_model(self): this_folder = dirname(__file__) language = metamodel_from_file( join(dirname(__file__), 'resources', 'outline.tx')) metamodel_export(language, join(dirname(__file__), 'outline.dot')) grammar_model = language.model_from_file( self.configuration.outline_path) model_export(grammar_model, join(this_folder, 'outline.dot')) return grammar_model
def getmodel(debug=False): this_folder = dirname(__file__) bt_mm = metamodel_from_file(join(this_folder, 'BinaryTree.tx'), debug=False) metamodel_export(bt_mm, join(this_folder, 'bt_meta.dot')) bt_model = bt_mm.model_from_file(join(this_folder, 'temp.bt')) model_export(bt_model, join(this_folder, 'temp.dot')) binarytree = BinaryTree() binarytree.interpret(bt_model) return binarytree
def createDotFiles(form_mm,form_model,dotFolder): # Export to .dot file for visualization metamodel_export(form_mm, join(dotFolder, 'form_meta.dot')) # Export to .dot file for visualization model_export(form_model, join(dotFolder, 'form.dot')) (graph,) = pydot.graph_from_dot_file(join(dotFolder,'form_meta.dot')) graph.write_png(join(dotFolder,'form_meta.png')) (graph,) = pydot.graph_from_dot_file(join(dotFolder,'form.dot')) graph.write_png(join(dotFolder,'form.png'))
def main(): mm = get_metamodel() dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(mm, join(dot_folder, 'term.dot')) model = mm.model_from_file('model/model.term') model_export(model, join(dot_folder, 'model.dot'))
def dotexport_metamodel_cmd(textx_ls, args): """ Exports metamodel to workspace (dot file) """ ws_path = to_fs_path(textx_ls.root_uri) metamodel_path = textx_ls.configuration.grammar_path mm = metamodel_from_file(metamodel_path) mm_file_name = splitext(basename(metamodel_path))[0] or uuid.uuid4().hex path = join(ws_path, mm_file_name + '_metamodel.dot') metamodel_export(mm, path) textx_ls.workspace.show_message("Metamodel is exported at {}".format(path))
def test_issue_14(): """ Test object processors in context of match rules with base types. """ grammar = """ Program: 'begin' commands*=Command 'end' ; Command: InitialCommand | InteractCommand ; InitialCommand: 'initial' x=INT ',' y=INT ; InteractCommand: 'sleep' | NUMBER | BOOL | STRING ; """ # note: you can also use "STRICTFLOAT | INT" instead of "NUMBER" mm = metamodel_from_str(grammar) metamodel_export(mm, 'test_issue_14_metamodel.dot') # Error happens only when there are obj. processors registered mm.register_obj_processors({'InitialCommand': lambda x: x}) model_str = """ begin initial 2, 3 sleep 34 4.3 true "a string" end """ model = mm.model_from_str(model_str) model_export(model, 'test_issue_14_model.dot') assert model.commands[0].x == 2 assert model.commands[0].y == 3 assert model.commands[1] == 'sleep' assert model.commands[2] == 34 assert model.commands[3] == 4.3 assert model.commands[4] is True assert model.commands[5] == "a string"
def main(debug=False): entity_mm = get_entity_mm(debug) # Exportar a archivo .dot para visualización dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entity_meta.dot')) # Construir modelo de persona a partir del archivo person.ent person_model = entity_mm.model_from_file(join(this_folder, 'biblioteca.ent')) # Exportar a archivo .dot para visualización model_export(person_model, join(dot_folder, 'biblioteca.dot'))
def main(debug=False): entity_mm = get_entity_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entity_meta.dot')) # Build Person model from person.ent file person_model = entity_mm.model_from_file(join(this_folder, 'person.ent')) # Export to .dot file for visualization model_export(person_model, join(dot_folder, 'person.dot'))
def metamodel_generate_dot(metamodel, model, output_path, overwrite, debug): "Generating dot visualizations from textX grammars" input_file = model.file_name base_dir = output_path if output_path else os.path.dirname(input_file) base_name, _ = os.path.splitext(os.path.basename(input_file)) output_file = os.path.abspath( os.path.join(base_dir, "{}.{}".format(base_name, 'dot'))) if overwrite or not os.path.exists(output_file): click.echo('-> {}'.format(output_file)) metamodel_export(model, output_file) click.echo(' To convert to png run "dot -Tpng -O {}"' .format(os.path.basename(output_file))) else: click.echo('-- Skipping: {}'.format(output_file))
def main(debug=False): entity_mm = get_entity_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entity_meta.dot')) # Build Person model from person.ent file person_model = entity_mm.model_from_file(join(this_folder, 'Banda.ent')) # Export to .dot file for visualization model_export(person_model, join(dot_folder, 'Banda.dot'))
def main(debug=False): this_folder = dirname(__file__) robot_mm = metamodel_from_file(join(this_folder, 'robot.tx'), debug=False) metamodel_export(robot_mm, join(this_folder, 'robot_meta.dot')) # Register object processor for MoveCommand robot_mm.register_obj_processors({'MoveCommand': move_command_processor}) robot_model = robot_mm.model_from_file(join(this_folder, 'program.rbt')) model_export(robot_model, join(this_folder, 'program.dot')) robot = Robot() robot.interpret(robot_model)
def main(debug=False): entity_mm = get_entity_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entity_meta.dot')) # Build database model from tablatest.ent file database_model = entity_mm.model_from_file(join(this_folder, 'tablatest.ent')) # Export to .dot file for visualization model_export(database_model, join(dot_folder, 'tablatest.dot'))
def metamodel_generate_plantuml(metamodel, model, output_path, overwrite, debug): "Generating PlantUML visualizations from textX grammars" input_file = model.file_name base_dir = output_path if output_path else os.path.dirname(input_file) base_name, _ = os.path.splitext(os.path.basename(input_file)) output_file = os.path.abspath( os.path.join(base_dir, "{}.{}".format(base_name, 'pu'))) if overwrite or not os.path.exists(output_file): click.echo('-> {}'.format(output_file)) metamodel_export(model, output_file, PlantUmlRenderer()) click.echo("To convert to png run 'plantuml {}'".format(output_file)) else: click.echo('-- Skipping: {}'.format(output_file))
def main(debug=False): entity_mm = get_entity_mm(debug) #Exporta el archivo .dot para visualizarlo. dot_folder = join(this_folder, 'diagramas') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entidades.dot')) #Se construye un modelo person del archivo almacen.ent. person_model = entity_mm.model_from_file(join(this_folder, 'almacen.ent')) #Exporta el archivo .dot para visualizarlo. model_export(person_model, join(dot_folder, 'almacen.dot'))
def main(debug=False): entity_mm = get_smart_home_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'smart_home_meta.dot')) # Build Person model from smart_home.ev file smart_home_model = entity_mm.model_from_file( join(this_folder, 'smart_home.shome')) # Export to .dot file for visualization model_export(smart_home_model, join(dot_folder, 'smart_home.dot'))
def main(debug=False): this_folder = dirname(__file__) # Get meta-model from language description hello_meta = metamodel_from_file(join(this_folder, 'hello.tx'), debug=debug) # Optionally export meta-model to dot metamodel_export(hello_meta, join(this_folder, 'hello_meta.dot')) # Instantiate model example_hello_model = hello_meta.model_from_file( join(this_folder, 'example.hello')) # Optionally export model to dot model_export(example_hello_model, join(this_folder, 'example.dot'))
def main(debug=False): entity_mm = get_entity_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'diagram') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(entity_mm, join(dot_folder, 'entidades.dot')) # Build Person model from person.ent file restaurante = entity_mm.model_from_file( join(this_folder, 'restaurante.ent')) # Export to .dot file for visualization model_export(restaurante, join(dot_folder, 'entidades.dot'))
def main(debug=False): categoria_mm = get_categoria_mm(debug) # Export to .dot file for visualization dot_folder = join(this_folder, 'dotexport') if not os.path.exists(dot_folder): os.mkdir(dot_folder) metamodel_export(categoria_mm, join(dot_folder, 'categoria_meta.dot')) # Build Person model from person.ent file modelo_categoria = categoria_mm.model_from_file( join(this_folder, 'tienda.ent')) # Export to .dot file for visualization model_export(modelo_categoria, join(dot_folder, 'tienda.dot'))
def main(): # get input arguments parser = argparse.ArgumentParser(prog='d_generator') parser.add_argument('-m', nargs='?', help='Path to application dgdl model file') parser.add_argument('-s', nargs='?', help='Path to desired generation source directory') args = parser.parse_args() arguments = {'model_path': args.m, 'srcgen': args.s} # create metamodel and model entity_mm = get_entity_mm() application_model = entity_mm.model_from_file(arguments['model_path']) semantic_analysis(application_model) # find or create source directory srcgen_folder = arguments['srcgen'] if not exists(srcgen_folder): mkdir(srcgen_folder) # create application object appDTO = applicationToDto(application_model) plugin_params = (appDTO, srcgen_folder, abspath(arguments['model_path'])) # run database generator db_generator = get_generator(appDTO.configObject.database, 'database_generator', plugin_params) db_generator.generate_code() # run backend generator backend_generator = get_generator(appDTO.configObject.server, 'backend_generator', plugin_params) backend_generator.generate_code() # run frontend generator frontend_generator = get_generator(appDTO.configObject.frontend, 'frontend_generator', plugin_params) frontend_generator.generate_code() # export model and metamodel description files metamodel_export(entity_mm, 'metamodel.dot') model_export(application_model, 'model.dot')
def main(debug=False): this_folder = dirname(__file__) # Create metamodel from textX description scrum_mm = get_scrum_mm(debug) # Export to dot # Create png image with: dot -Tpng -O workflow_meta.dot metamodel_export(scrum_mm, join(this_folder, 'Models/scrum_meta.dot')) # Load example model example = scrum_mm.model_from_file(join(this_folder, 'example.sr')) # Export to dot # Create png image with: dot -Tpng -O example.dot model_export(example, join(this_folder, 'Models/example.dot'))
def get_semantic_model_from_file(applang_file, metamodel_file, export_to_dot=False): metamodel = metamodel_from_file(metamodel_file) if export_to_dot: print_log('Exporting metamodel to dot') metamodel_export(metamodel, 'applang_metamodel.dot') print_log('Exporting metamodel to dot completed') model = metamodel.model_from_file(applang_file) print_log('Checking model semantics') model = check_semantics(model, metamodel) print_log('Checking model semantics completed') if export_to_dot: print_log('Exporting model to dot') model_export(model, 'applang_model.dot') print_log('Exporting model to dot completed') return model
def main(debug=False): this_folder = dirname(__file__) # Create metamodel from textX description workflow_mm = metamodel_from_file( join(this_folder, 'workflow.tx'), debug=debug) # Export to dot # Create png image with: dot -Tpng -O workflow_meta.dot metamodel_export(workflow_mm, join(this_folder, 'workflow_meta.dot')) # Load example model example = workflow_mm.model_from_file(join(this_folder, 'example.wf')) # Export to dot # Create png image with: dot -Tpng -O example.dot model_export(example, join(this_folder, 'example.dot'))
def mean_model(file_name): """Generates program model from '/examples' and returns it.""" # current_dir = os.path.dirname(__file__) # __file__ is unbound in interactive mode current_dir = os.getcwd() visualization_dir = os.path.join(current_dir, mean_gen_config.VISUALIZATION_DIR) if not os.path.exists(visualization_dir): os.makedirs(visualization_dir) mean_mm = metamodel_from_file(os.path.join(current_dir, 'lang', 'mean.tx')) metamodel_export(mean_mm, os.path.join(visualization_dir, 'mean_meta.dot')) app = mean_mm.model_from_file(os.path.join(current_dir, 'examples', file_name)) model_export(app, os.path.join(visualization_dir, 'clue-example.dot')) return app
def test_import(): """ Test grammar import. """ current_dir = os.path.dirname(__file__) mm = metamodel_from_file(os.path.join(current_dir, 'relativeimport', 'first.tx')) metamodel_export(mm, 'import_test_mm.dot') model = """ first second "1" "2" third true false true 12 false endfirst """ model = mm.model_from_str(model) model_export(model, 'import_test_model.dot')
def test_issue_14(): """ Test object processors in context of match rules with base types. """ grammar = """ Program: 'begin' commands*=Command 'end' ; Command: InitialCommand | InteractCommand ; InitialCommand: 'initial' x=INT ',' y=INT ; InteractCommand: 'sleep' | INT | FLOAT | BOOL | STRING ; """ mm = metamodel_from_str(grammar) metamodel_export(mm, 'test_issue_14_metamodel.dot') # Error happens only when there are obj. processors registered mm.register_obj_processors({'InitialCommand': lambda x: x}) model_str = """ begin initial 2, 3 sleep 34 4.3 true "a string" end """ model = mm.model_from_str(model_str) model_export(model, 'test_issue_14_model.dot')
def main(debug=False): this_folder = dirname(__file__) json_mm = metamodel_from_file(join(this_folder, 'json.tx'), debug=debug) metamodel_export(json_mm, join(this_folder, 'json.tx.dot')) model1 = json_mm.model_from_file(join(this_folder, 'example1.json')) model_export(model1, join(this_folder, 'example1.json.dot')) model2 = json_mm.model_from_file(join(this_folder, 'example2.json')) model_export(model2, join(this_folder, 'example2.json.dot')) model3 = json_mm.model_from_file(join(this_folder, 'example3.json')) model_export(model3, join(this_folder, 'example3.json.dot')) model4 = json_mm.model_from_file(join(this_folder, 'example4.json')) model_export(model4, join(this_folder, 'example4.json.dot')) model5 = json_mm.model_from_file(join(this_folder, 'example5.json')) model_export(model5, join(this_folder, 'example5.json.dot'))
Builds and returns a meta-model for Entity language. """ # Built-in primitive types # Each model will have this entities during reference resolving but # these entities will not be a part of `entities` list of EntityModel. entity_builtins = { 'integer': Entity(None, 'integer', []), 'string': Entity(None, 'string', []) } entity_mm = metamodel_from_file('entity.tx', classes=[Entity], # Register Entity class builtins=entity_builtins, debug=False) return entity_mm if __name__ == "__main__": entity_mm = get_entity_mm() # Export to .dot file for visualization metamodel_export(entity_mm, 'dotexport/entity_meta.dot') # Build Person model from person.ent file person_model = entity_mm.model_from_file('person.ent') # Export to .dot file for visualization model_export(person_model, 'dotexport/entity.dot')
from textx.metamodel import metamodel_from_file from textx.export import metamodel_export, model_export # Create metamodel from textX description workflow_mm = metamodel_from_file('workflow.tx') # Export to dot # Create png image with: dot -Tpng -O workflow_meta.dot metamodel_export(workflow_mm, 'workflow_meta.dot') # Load example model example = workflow_mm.model_from_file('example.wf') # Export to dot # Create png image with: dot -Tpng -O example.dot model_export(example, 'example.dot')
def main(debug=False): calc_mm = metamodel_from_str(grammar, auto_init_attributes=False, debug=debug) this_folder = dirname(__file__) if debug: metamodel_export(calc_mm, join(this_folder, 'calc_metamodel.dot')) input_expr = ''' a = 10; b = 2 * a + 17; -(4-1)*a+(2+4.67)+b*5.89/(.2+7) ''' model = calc_mm.model_from_str(input_expr) if debug: model_export(model, join(this_folder, 'calc_model.dot')) # test whether x is an instance of a certain rule # note that it is different than comparing to x.__class__.__name__ # because the latter only tests for the most derived type and # wont be helpful for abstract rules def _is(x, rule): return textx_isinstance(x, calc_mm[rule]) def assertIs(x, rule): assert _is(x, rule), 'Unexpected object "{}" to rule "{}"'\ .format(x, type(x), rule) def evaluate(x): if isinstance(x, float): return x elif _is(x, 'Expression'): ret = evaluate(x.operands[0]) for operator, operand in zip(x.operators, x.operands[1:]): if operator == '+': ret += evaluate(operand) else: ret -= evaluate(operand) return ret elif _is(x, 'Term'): ret = evaluate(x.operands[0]) for operator, operand in zip(x.operators, x.operands[1:]): if operator == '*': ret *= evaluate(operand) else: ret /= evaluate(operand) return ret elif _is(x, 'Factor'): value = evaluate(x.op) return -value if x.sign == '-' else value elif _is(x, 'Operand'): if _is(x, 'PrimitiveOperand'): if x.op_num is not None: return x.op_num elif x.op_id: if x.op_id in namespace: return namespace[x.op_id] else: raise Exception('Unknown variable "{}" at position {}' .format(x.op_id, x._tx_position)) else: assertIs(x, 'CompoundOperand') return evaluate(x.expression) elif _is(x, 'Calc'): for a in x.assignments: namespace[a.variable] = evaluate(a.expression) return evaluate(x.expression) else: assert False, 'Unexpected object "{}" of type "{}"'\ .format(x, type(x)) result = evaluate(model) assert (result - 6.93805555) < 0.0001 print("Result is", result)
from textx.metamodel import metamodel_from_file from textx.export import metamodel_export from textx.export import model_export hello_meta = metamodel_from_file('hello.tx') metamodel_export(hello_meta, 'hello_meta.dot') example_hello_model = hello_meta.model_from_file('example.hello') model_export(example_hello_model, 'example.dot')
from textx.metamodel import metamodel_from_file from textx.export import metamodel_export from textx.export import model_export coshh_meta = metamodel_from_file('coshh.tx') metamodel_export(coshh_meta, 'coshh.dot') example_coshh_model = coshh_meta.model_from_file('test.coshh') model_export(example_coshh_model, 'coshh_example.dot')
"import model.Kafic;", "import model.Oblik;", "import model.elements.Elipsa;", "import model.elements.Pravougaonik;", "import model.elements.Trougao;", "import model.elements.Linija;", "import model.elements.ZaobljeniPravougaonik;", "import view.MainFrame;", ] return importList if __name__ == "__main__": metamodel = metamodel_from_file("language_definition.tx") metamodel_export(metamodel, "meta.dot") graph = pydot.graph_from_dot_file("meta.dot") graph.write_png("meta.png") model = metamodel.model_from_file("example.cafe") model_export(model, "model.dot") graph = pydot.graph_from_dot_file("model.dot") graph.write_png("model.png") interpreter = Interpreter(model) interpreter.interpret() konkretanKafic = interpreter.kafic generator.generate( "painter_template.java", "CafePainter.java", {"canvas": model, "imports": javaPackageAndImports(), "kafic": konkretanKafic},
self.away_team.tehnicals += 1 eventTeam = self.away_team.name coach = self.away_team.coach.getFullName() if who == "Team": self.events.append(Event(action, self.home_team.getPoints(), self.away_team.getPoints(), eventTeam, "")) else : self.events.append(Event(action, self.home_team.getPoints(), self.away_team.getPoints(), eventTeam, coach)) def getGameObject(self): return Game(game_info=self.game_info, home_team=self.home_team, away_team=self.away_team, events=self.events) if __name__ == '__main__': basket_metamodel = metamodel_from_file('textX/grammar.tx', debug=False) metamodel_export(basket_metamodel, 'output/basketStats_meta.dot') graph = pydot.graph_from_dot_file('output/basketStats_meta.dot') graph.write_png('output/basketStats_meta.png') basket_model = basket_metamodel.model_from_file('textX/game.tx') model_export(basket_model, 'output/basketStats_model.dot') graph = pydot.graph_from_dot_file('output/basketStats_model.dot') graph.write_png('output/basketStats_model.png') basket = Basket() basket.interpret(basket_model) env = Environment(trim_blocks=True, lstrip_blocks=True, loader=PackageLoader("basket", "templates")) template = env.get_template("statsTemplate.html") t = template.render(game=basket.getGameObject())
import os from textx.metamodel import metamodel_from_file from textx.export import metamodel_export from pyflies.lang.model_processor import pyflies_model_processor pyflies_mm = metamodel_from_file( os.path.join(os.path.dirname(__file__), 'pyflies.tx')) pyflies_mm.register_model_processor(pyflies_model_processor) if __name__ == '__main__': metamodel_export(pyflies_mm, 'pyflies_meta.dot')
from textx.metamodel import metamodel_from_file from textx.export import metamodel_export, model_export pyflies_mm = metamodel_from_file("../../pyflies/lang/pyflies.tx") metamodel_export(pyflies_mm, "pyflies_meta.dot") experiment = pyflies_mm.model_from_file("ref_experiment.pf") model_export(experiment, "ref_experiment.dot")
dir = c.direction print("Going {} for {} step(s).".format(dir, c.steps)) move = { "up": (0, 1), "down": (0, -1), "left": (-1, 0), "right": (1, 0) }[dir] # Calculate new robot position self.x += c.steps * move[0] self.y += c.steps * move[1] print(self) if __name__ == "__main__": robot_mm = metamodel_from_file('robot.tx', debug=False) metamodel_export(robot_mm, 'robot_meta.dot') # Register object processor for MoveCommand robot_mm.register_obj_processors({'MoveCommand': move_command_processor}) robot_model = robot_mm.model_from_file('program.rbt') model_export(robot_model, 'program.dot') robot = Robot() robot.interpret(robot_model)