def main(args):
"""The main function"""
global dve_mm, slco_mm, use_composite_statement
if len(args) == 0:
print("Missing argument: DVE model")
sys.exit(1)
else:
if args[0] == '-h' or args[0] == '-help':
print("Usage: pypy/python3 dve2slco <file_in>")
print("")
print("Transform an DVE model to an SLCO 2.0 model.")
print(
"-composite use composite statement for dve transitions")
sys.exit(0)
else:
for i in range(0, len(args)):
if args[i] == '-composite':
use_composite_statement = True
else:
modelname = args[i]
break
# create meta-model
dve_mm = metamodel_from_file(
join(this_folder, '../../textx_grammars/dve.tx'))
slco_mm = metamodel_from_file(
join(this_folder, '../../textx_grammars/slco2.tx'))
batch = []
if modelname.endswith('.dve'):
batch = [modelname]
else:
batch = glob.glob(join(this_folder, modelname, "*.dve"))
gen_dir = "generated_slco"
dir = dirname(batch[0])
gen_folder = join(dir, gen_dir)
if exists(gen_folder):
rmtree(gen_folder)
mkdir(gen_folder)
# read model
for file in batch:
model = dve_mm.model_from_file(file)
mname = basename(file)
print("processing model %s" % mname)
mname = mname[:-4]
mname = mname.replace('.', '_')
# translate
out_model = translate(model, mname)
# write to file
if len(batch) == 1:
print(out_model)
outFile = open(join(gen_folder, basename(file)[:-3] + "slco"), 'w')
outFile.write(out_model)
outFile.close()
def check(language, model_file, debug):
"""
Checks (meta)model syntax validity.
"""
try:
if language == 'textx':
click.echo('Checking model using language "textx".')
metamodel_from_file(model_file, debug=debug)
click.echo('Meta-model OK.')
else:
mm = get_language(language)
click.echo('Checking model using language "{}".'.format(language))
mm.model_from_file(model_file, debug=debug)
click.echo('Model OK.')
except TextXError as e:
click.echo(e)
def execute_on_request(path, grammar_file_name, example_str):
meta_path = os.path.join(path, grammar_file_name)
metamodel = metamodel_from_file(meta_path)
model = metamodel.model_from_str(example_str)
return model
def process_rules(files, verbose=False):
""" Parse our rule files with the provided parser """
models = []
# Load Meta-Model
resource_package = __name__
resource_path = '/'.join(['secrules.tx'])
template = pkg_resources.resource_filename(resource_package, resource_path)
modsec_mm = metamodel_from_file(template, memoization=True)
# Register test processor
modsec_mm.register_obj_processors({'SecRule': secrule_id_processor})
# Make sure we don't have an empty list of files
if files == []:
return models
for rule_file in files:
if verbose:
print('Processing file %s:' % rule_file)
try:
model = modsec_mm.model_from_file(rule_file)
except TextXSyntaxError as e:
model = {
"Error":
"Syntax error in line %d col %d: %s" %
(e.line, e.col, e.message)
}
models.append(model)
return models
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():
# add a pathling route
# $ lings-path-add "/foo -> bar"
parser = argparse.ArgumentParser()
parser.add_argument("route", help="db host ip")
parser.add_argument("--db-host", default="127.0.0.1", help="db host ip")
parser.add_argument("--db-port", type=int, default=6379, help="db port")
args = parser.parse_args()
db_settings = {"host": args.db_host, "port": args.db_port}
redis_conn = redis.StrictRedis(**db_settings, decode_responses=True)
routes_key = "machinic:routes:{}:{}".format(args.db_host, args.db_port)
# pathling model
pathling_model_file = pathlib.Path(
pathlib.PurePath(pathlib.Path(__file__).parents[0], "pathling.tx"))
pathling_metamodel = metamodel_from_file(pathling_model_file)
route = args.route
try:
# validate path
pathling_metamodel.model_from_str(route)
route_hash = hashlib.sha224(route.encode()).hexdigest()
redis_conn.hmset(routes_key, {route_hash: route})
except Exception as ex:
print(ex)
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 parse(inputs, debug=False):
this_folder = dirname(__file__)
# Get meta-model from language description
grammar = join(this_folder, 'grammar.tx')
classes = [
Fortran, Module, InternalSubprogram, Declaration, DeclarationAttribute,
DeclarationEntityObject, DeclarationEntityFunction, ArraySpec,
ArrayExplicitShapeSpec
]
meta = metamodel_from_file(grammar,
debug=debug,
classes=classes,
ignore_case=True)
# Instantiate model
if os.path.isfile(inputs):
ast = meta.model_from_file(inputs)
else:
ast = meta.model_from_str(inputs)
# print(namespace)
# for k,v in namespace.items():
# v.inspect()
# this is usefull for testing
# if len(namespace) == 1:
# return list(namespace.values())[0]
return ast
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 __init__(self):
this_folder = dirname(__file__)
grammar = metamodel_from_file(join(this_folder, 'grammar.tx'),
debug=False)
self.grammar_model = grammar.model_from_file(
join(this_folder, '.txconfig'))
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 callgraph_memoization():
mm = metamodel_from_file('rhapsody.tx', memoization=True)
# Small file
this_folder = dirname(__file__)
model = mm.model_from_file(
join(this_folder, 'test_inputs', 'LightSwitch.rpy'))
def check(parameters):
try:
harmonization_config = utils.load_configuration(HARMONIZATION_CONF_FILE)
SieveExpertBot._harmonization = harmonization_config['event']
grammarfile = os.path.join(os.path.dirname(__file__), 'sieve.tx')
if not os.path.exists(grammarfile):
raise FileExistsError(f'Sieve grammar file not found: {grammarfile!r}.')
metamodel = None
try:
metamodel = metamodel_from_file(grammarfile)
except TextXError as e:
raise ValueError(f'Could not process sieve grammar file. Error in ({e.line}, {e.col}).')
if not os.path.exists(parameters['file']):
raise ValueError(f'File does not exist: {parameters["file"]!r}')
try:
metamodel.model_from_file(parameters['file'])
except TextXError as e:
raise ValueError(f'Could not process sieve file {parameters["file"]!r}. Error in ({e.line}, {e.col}).')
except Exception:
return [['error', f'Validation of Sieve file failed with the following traceback: {traceback.format_exc()!r}']]
def parse(filename=None, stmts=None, debug=False):
this_folder = dirname(__file__)
# Get meta-model from language description
grammar = join(this_folder, '../grammar/openmp.tx')
from textx.metamodel import metamodel_from_file
meta = metamodel_from_file(grammar, debug=debug, classes=omp_classes)
# Instantiate model
if filename:
model = meta.model_from_file(filename)
elif stmts:
model = meta.model_from_str(stmts)
else:
raise ValueError('Expecting a filename or a string')
stmts = []
for stmt in model.statements:
if isinstance(stmt, OpenmpStmt):
e = stmt.stmt.expr
stmts.append(e)
if len(stmts) == 1:
return stmts[0]
else:
return stmts
def get_entity_mm( metaModel, debug=False,):
"""
Builds and returns a meta-model for Entity language.
"""
this_folder = dirname(__file__)
# Built-in simple types
# Each model will have this simple types during reference resolving but
# these will not be a part of `types` list of EntityModel.
type_builtins = {
'int': SimpleType(None, 'int'),
'string': SimpleType(None, 'string'),
'text': SimpleType(None, 'text'),
'file': SimpleType(None, 'file'),
'bool': SimpleType(None, 'bool'),
'date': SimpleType(None, 'date'),
'dateTime': SimpleType(None, 'dateTime'),
'currency': SimpleType(None, 'currency')
}
entity_mm = metamodel_from_file(join(this_folder, metaModel),
classes=[SimpleType],
builtins=type_builtins,
debug=debug)
return entity_mm
def get_rconf_meta():
grammar_file = os.path.join(os.path.dirname(__file__), 'rconf.tx')
mm = metamodel_from_file(grammar_file)
mm.register_obj_processors({'Rule': validate_rule})
return mm
def callgraph_memoization():
mm = metamodel_from_file('rhapsody.tx', memoization=True)
# Small file
this_folder = dirname(__file__)
model = mm.model_from_file(join(this_folder,
'test_inputs', 'LightSwitch.rpy'))
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 parse(inputs, debug=False, verbose=False):
this_folder = dirname(__file__)
classes = [NamedAbstraction, Abstraction, Application, ValuedItem]
# Get meta-model from language description
grammar = join(this_folder, 'grammar.tx')
from textx.metamodel import metamodel_from_file
meta = metamodel_from_file(grammar, debug=debug, classes=classes)
# Instantiate model
if os.path.isfile(inputs):
ast = meta.model_from_file(inputs)
else:
ast = meta.model_from_str(inputs)
# ...
expr = to_sympy(ast)
if verbose:
print('>>> stage 0 = ', expr)
# ...
# ...
if verbose:
print('')
# ...
return expr
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 _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 __init__(
self,
db_host,
db_port,
broker_host,
broker_port,
env_vars=None,
allow_shell_calls=False,
):
self.routing_ling = "pathling"
self.routes_key = "machinic:routes:{}:{}".format(db_host, db_port)
self.env_vars = env_vars
self.allow_shell_calls = allow_shell_calls
self.pathling_model_file = pathlib.Path(
pathlib.PurePath(pathlib.Path(__file__).parents[0], "pathling.tx")
)
self.pathling_metamodel = metamodel_from_file(self.pathling_model_file)
db_settings = {"host": db_host, "port": db_port}
self.binary_r = redis.StrictRedis(**db_settings)
self.redis_conn = redis.StrictRedis(**db_settings, decode_responses=True)
self.broker_client = mosquitto.Client()
self.broker_client.on_message = self.on_message
sub_topics = "#"
self.broker_client.connect(broker_host, broker_port, 60)
self.broker_client.subscribe(sub_topics, 0)
self.broker_client.loop_start()
def __init__(self, backend=None):
self.variables = None
self.backend = backend
self.model = metamodel_from_file(GRAMMAR_FILE)
self.model.register_obj_processors({
'PrintStatement': self.handle_print
})
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 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 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(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 test_textx_imported_metaclass_repr_same_level_import():
current_dir = os.path.dirname(__file__)
mm = metamodel_from_file(os.path.join(current_dir, 'import',
'repr',
'first_repr.tx'))
model = mm.model_from_str('second 42')
assert '<textx:third_repr.Third instance at' \
in repr(model.seconds[0].thirds[0])
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 __init__(self, kron_file, grammar=KRON_GRAMMAR, blocking=True): self._meta_model = metamodel_from_file(grammar) self._add_processors(self._meta_model) self._model = self._meta_model.model_from_file(kron_file) self._number_of_tasks = len(self._model.jobs) self.workers = WorkersList() self._process(self._model) self.workers.start()
def main():
print('Compiling ada')
ada_mm = metamodel_from_file(os.path.join(this_dir, 'ada83.tx'))
parser = argparse.ArgumentParser()
parser.add_argument('source')
args = parser.parse_args()
ast = ada_mm.load(args.source)
def __init__(self, kron_file, grammar=KRON_GRAMMAR, blocking=True):
self._meta_model = metamodel_from_file(grammar)
self._add_processors(self._meta_model)
self._model = self._meta_model.model_from_file(kron_file)
self._number_of_tasks = len(self._model.jobs)
self.workers = WorkersList()
self._process(self._model)
self.workers.start()
def get_entity_mm(debug=False):
type_builtins = {
'integer': SimpleType(None, 'integer'),
'string': SimpleType(None, 'string')
}
entity_mm = metamodel_from_file(join(this_folder, 'entity.tx'),
classes=[SimpleType],
builtins=type_builtins,
debug=debug)
return entity_mm
def do_coloring_for_vscode(self):
if self.configuration.coloring_path == '':
return
this_folder = dirname(__file__)
textX = metamodel_from_file(join(dirname(__file__), '..', 'textX.tx'))
grammar_model = textX.model_from_file(self.configuration.grammar_path)
grammar = metamodel_from_file(join(this_folder, 'coloring.tx'), debug=False)
program_model = grammar.model_from_file(self.configuration.coloring_path)
self.name = self.configuration.language_name
self.interpret_grammar(grammar_model)
self.interpret_program(program_model)
self.prepare_data()
self.generate_code()
def get_model_meta():
"""
Gets model meta-model.
"""
global _model_meta
_model_meta = metamodel_from_file(os.path.join(os.path.dirname(__file__),
"model.tx"),
classes=_classes)
_model_meta.register_obj_processors(obj_processors)
return _model_meta
def meta():
"""
Language for generators configuration.
"""
global genconf_mm
curr_dir = os.path.dirname(__file__)
if genconf_mm is None:
genconf_mm = metamodel_from_file(os.path.join(curr_dir, 'genconf.tx'))
return genconf_mm
def nomemoization():
mm = metamodel_from_file('rhapsody.tx')
# Small file
this_folder = dirname(__file__)
model = mm.model_from_file(join(this_folder,
'test_inputs', 'LightSwitch.rpy'))
# Large file
model2 = mm.model_from_file(join(this_folder,
'test_inputs', 'LightSwitchDouble.rpy'))
def test_textx_imported_metaclass_repr():
"""
Test imported metaclass __repr__ uses fqn.
"""
current_dir = os.path.dirname(__file__)
mm = metamodel_from_file(os.path.join(current_dir, 'import',
'first_diamond.tx'))
MyDiamondRule = mm['diamond.last.MyDiamondRule']
assert '<textx:diamond.last.MyDiamondRule class at' in repr(MyDiamondRule)
def __init__(self):
self.logger = logging.getLogger()
grammarfile = os.path.join(os.path.dirname(__file__), 'sieve.tx')
if not os.path.exists(grammarfile):
self.logger.error('Sieve grammar file not found: %r.', grammarfile)
return
try:
self.metamodel = metamodel_from_file(grammarfile)
except TextXError as e:
self.logger.error('Could not process sieve grammar file. Error in (%d, %d).', e.line, e.col)
self.logger.error(str(e))
def get_entity_mm():
"""
Builds and returns a meta-model for Entity language.
"""
type_builtins = {
'integer': SimpleType(None, 'integer'),
'string': SimpleType(None, 'string')
}
entity_mm = metamodel_from_file(join(this_folder, 'entity.tx'),
classes=[SimpleType],
builtins=type_builtins)
return entity_mm
def generate_tests(self):
meta = metamodel_from_file('Tests.tx')
files = self.search_for_yufa_files()
tests = []
for file in files:
model = meta.model_from_file(file)
language = model.language
for test in model.tests:
tests.append((file, language, test.base, test.conjugation,
test.form, test.expected) + tuple(test.extra))
return tests
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):
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 __init__(self, language):
self.context = ''
self.base = ''
self.state = ''
self.group = ''
self.language = language
self.status = {'default': ''}
self.exceptions = {}
ortho_meta = metamodel_from_file('Orthography.tx')
orthography = ortho_meta.model_from_file(os.path.join(self.language, 'orthography.tx'))
self.orthography = {}
for token in orthography.tokens:
self.orthography[''.join(token.token)] = ''.join(token.value)
def get_entity_mm():
"""
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
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 get_entity_mm(debug=False):
"""
Builds and returns a meta-model for Entity language.
"""
# Built-in simple types
# Each model will have this simple types during reference resolving but
# these will not be a part of `types` list of EntityModel.
type_builtins = {
'integer': SimpleType(None, 'integer'),
'string': SimpleType(None, 'string')
}
entity_mm = metamodel_from_file(join(this_folder, 'entity.tx'),
classes=[SimpleType],
builtins=type_builtins,
debug=debug)
return entity_mm
def set_context(self, inflection_type):
meta = metamodel_from_file('Rules.tx')
model = meta.model_from_file(os.path.join(self.language, inflection_type + '.tx'))
self.model = model
self.state = model.name
self.inflection_type = inflection_type
for exception in self.model.exceptions:
forms = {}
for e in exception.exceptions:
for t in e.type:
forms[t] = e.override
self.exceptions[exception.base_word] = forms
for step in model.steps:
if step == 'none':
continue
self._run(step)
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 init_metamodel():
if metamodel_from_file is None:
raise ValueError('Could not import textx. Please install it')
try:
grammarfile = os.path.join(os.path.dirname(__file__), 'sieve.tx')
metamodel = metamodel_from_file(grammarfile)
# apply custom validation rules
metamodel.register_obj_processors({
'StringMatch': SieveExpertBot.validate_string_match,
'NumericMatch': SieveExpertBot.validate_numeric_match,
'SingleIpRange': SieveExpertBot.validate_ip_range
})
return metamodel
except TextXError as e:
raise ValueError('Could not process sieve grammar file. Error in (%d, %d): %s' % (e.line, e.col, str(e)))
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 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'))
def load_model(self, file_path):
# Create model
meta_model = metamodel_from_file(self.grammar_path,
classes=[
View,
Object,
Page,
Property,
Query,
StringCondition,
IntegerCondition,
SelectorObject,
SelectorFKObject,
SelectorView,
ViewOnPage,
DataShow,
Sidebar,
Layout,
Menubar,
Menu,
Form,
RefLink,
Footer,
Use,
Row,
ViewInView,
RowSeparator,
AdditionParameters,
Paragraph,
Jumbo,
JumboParameters,
AdditionParameters,
StaticLink
],
builtins=self.builtins,
debug=False)
meta_model.register_obj_processors(self.obj_processors)
return meta_model.model_from_file(file_path)
import os
from textx.metamodel import metamodel_from_file
from textx.export import metamodel_export
if __name__ == '__main__':
pyflies_mm = metamodel_from_file(
os.path.join(os.path.dirname(__file__), 'pyflies.tx'), debug=True)
else:
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)
def interpret(self):
"""
Main interpreter loop.
"""
self.print_menu()
while True:
try:
event = input()
if event == 'q':
return
event = int(event)
event = self.model.events[event-1]
except:
print('Invalid input')
self.event(event)
self.print_menu()
if __name__ == '__main__':
this_folder = dirname(__file__)
if len(sys.argv) != 2:
print("Usage: python {} <model>".format(sys.argv[0]))
else:
meta_model = metamodel_from_file(join(this_folder, 'state_machine.tx'))
model = meta_model.model_from_file(sys.argv[1])
state_machine = StateMachine(model)
state_machine.interpret()
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')
def __init__(self,):
metamodel_dir = sys.path[0]
metamodel_path = os.path.join(metamodel_dir, "layout.tx")
metamodel = metamodel_from_file(metamodel_path)
self.metamodel = metamodel
