def test_command_resource(mm):
rset = ResourceSet()
resource = rset.create_resource(URI('http://logical'))
a = mm.A()
resource.append(a)
cmd = Set(a, 'name', 'test_value')
assert cmd.resource is resource
def load_esdl_from_string(esdl_string):
uri = StringURI('from_string.esdl', esdl_string)
rset = ResourceSet()
resource = rset.create_resource(uri)
resource.load()
esdl_instance = resource.contents[0]
return esdl_instance
def __init__(self, energy_system=None):
if energy_system is not None:
self.energy_system = energy_system
self.resource = None
self.rset = ResourceSet()
self.esid_uri_dict = {}
self._set_resource_factories()
# fix python builtin 'from' that is also used in ProfileElement as attribute
# use 'start' instead of 'from' when using a ProfileElement
# and make sure that it is serialized back as 'from' instead of 'from_'
esdl.ProfileElement.from_.name = 'from'
setattr(esdl.ProfileElement, 'from', esdl.ProfileElement.from_)
alias('start', esdl.ProfileElement.from_)
# also for FromToIntItem
esdl.FromToIntItem.from_.name = 'from'
setattr(esdl.FromToIntItem, 'from', esdl.FromToIntItem.from_)
alias('start', esdl.FromToIntItem.from_)
# also for FromToDoubleItem
esdl.FromToDoubleItem.from_.name = 'from'
setattr(esdl.FromToDoubleItem, 'from', esdl.FromToDoubleItem.from_)
alias('start', esdl.FromToDoubleItem.from_)
# add support for cloning of EObjects and coppy.copy()
setattr(EObject, '__copy__', support_functions.clone)
setattr(EObject, 'clone', support_functions.clone)
# add support for deepcopying EObjects and copy.deepcopy()
setattr(EObject, '__deepcopy__', support_functions.deepcopy)
setattr(EObject, 'deepcopy', support_functions.deepcopy)
# have a nice __repr__ for some ESDL classes when printing ESDL objects (includes all Assets and EnergyAssets)
esdl.EnergySystem.__repr__ = \
lambda x: '{}: ({})'.format(x.name, EnergySystemHandler.attr_to_dict(x))
def generated_library(pygen_output_dir):
rset = ResourceSet()
resource = rset.get_resource(URI('input/library.ecore'))
library_model = resource.contents[0]
generator = EcoreGenerator()
generator.generate(library_model, pygen_output_dir)
return importlib.import_module('library')
def test_globaluridecoder():
assert Global_URI_decoder.can_resolve('http://simple.ecore'
'#//test') is False
rset = ResourceSet()
resource = rset.create_resource('http://simple.ecore')
global_registry['http://simple.ecore'] = resource
assert Global_URI_decoder.can_resolve('http://simple.ecore#//test') is True
def model_setup():
rset = ResourceSet()
resource = rset.get_resource(URI('metamodel.ecore'))
mm_root = resource.contents[0]
mm_root.nsURI = 'ghmde'
mm_root.nsPrefix = 'model'
mm_root.name = 'ghmde'
rset.metamodel_registry[mm_root.nsURI] = mm_root
print(mm_root.nsURI)
MyMetamodel = DynamicEPackage(
mm_root) # We create a DynamicEPackage for the loaded root
file_instance = MyMetamodel.File()
print(file_instance)
A = mm_root.getEClassifier('Model')
# nuovo
instance = A()
dictionary = {}
dictionary['model'] = instance
dictionary['meta-model'] = MyMetamodel
return dictionary
def generated_metamodel(pygen_output_dir):
rset = ResourceSet()
resource = rset.get_resource(URI('input/A.ecore'))
library_model = resource.contents[0]
generator = EcoreGenerator(with_dependencies=True)
generator.generate(library_model, pygen_output_dir)
return importlib.import_module('a')
def test_delete_unresolved_proxy_simple_relation(lib):
rset = ResourceSet()
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'a3.xmi')
root = rset.get_resource(xmi_file).contents[0]
b = root.a[0].simpleb
b.delete()
assert len(root.a[0].tob) == 0
def main(args):
"""The main function"""
output_filename = ""
if len(args) > 0:
if args[0] == '-h' or args[0] == '-help':
print("Usage: pypy/python3 main <henshin_file>")
print("")
print("Extract SLCO/REFINER semantics from henchin file.")
sys.exit(0)
input_file = args[0]
if not input_file.endswith(EXT):
input_file = input_file + EXT
output_file = input_file[:-len(EXT)] + ".rs"
print("Input: %s" % input_file)
print("Output: %s" % output_file)
new_input_file = preprocess_input_file(input_file)
rset = ResourceSet()
rset.metamodel_registry[Ecore.nsURI] = Ecore
rset.metamodel_registry[henshin.nsURI] = henshin
rset.metamodel_registry[SLCO.nsURI] = SLCO
input_model = rset.get_resource(new_input_file)
root_module = input_model.contents[0]
rs = henshin_to_rulesystem(root_module)
f = open(output_file, 'w')
f.write(rs.to_string())
f.close()
def test_resource_mmregistry_isolation():
global_registry['cdef'] = None
rset1 = ResourceSet()
rset2 = ResourceSet()
rset1.metamodel_registry['abcd'] = None
assert 'abcd' not in rset2.metamodel_registry
assert 'cdef' in rset2.metamodel_registry
assert 'cdef' in rset1.metamodel_registry
def test_delete_unresolved_proxy_2_models_loaded_simple_relation(lib):
rset = ResourceSet()
root = rset.get_resource('tests/xmi/xmi-tests/a3.xmi').contents[0]
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
b = root.a[0].simpleb
b.delete()
assert root.a[0].simpleb is None
assert len(root2.b) == 1 # the element is still here
def test_delete_unresolved_proxy_2_models_loaded(lib):
rset = ResourceSet()
root = rset.get_resource('tests/xmi/xmi-tests/a1.xmi').contents[0]
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
b = root.a[0].tob[0]
b.delete()
assert len(root.a[0].tob) == 0
assert len(root2.b) == 1 # the element is still here
def test_resource_double_load(simplemm):
rset = ResourceSet()
rset.metamodel_registry[simplemm.nsURI] = simplemm
root = rset.get_resource(path.join('tests', 'xmi', 'xmi-tests',
'a1.xmi')).contents[0]
root2 = rset.get_resource(path.join('tests', 'xmi', 'xmi-tests',
'a1.xmi')).contents[0]
assert root is root2
def loadModelDDM(self, input_file):
rset = ResourceSet()
# register the metamodel (available in the generated files)
rset.metamodel_registry[ddm.nsURI] = ddm
rset.resource_factory['ddm'] = lambda uri: XMIResource(uri)
resource = rset.get_resource(URI(input_file))
model = resource.contents[0]
return model
def test_resource_load_proxy_missinghref(simplemm):
rset = ResourceSet()
rset.metamodel_registry[simplemm.nsURI] = simplemm
root = rset.get_resource(path.join('tests', 'xmi', 'xmi-tests',
'a1-1.xmi')).contents[0]
assert isinstance(root.a[0].tob[0], EProxy)
with pytest.raises(TypeError):
root.a[0].tob[0].eClass
def test_resourceset_createresource_xmi():
rset = ResourceSet()
resource = rset.create_resource(URI('simple.xmi'))
rpath = path.abspath('simple.xmi')
assert rpath in rset.resources
assert rset.resources[rpath] is resource
assert rset in resource._decoders
assert isinstance(resource, rset.resource_factory['xmi']('').__class__)
def __init__(self):
rset = ResourceSet()
model_url = URI(
os.path.join(
os.path.dirname(__file__),
'../ecore/GeppettoCommonLibrary.xmi')) # The model URI
resource = rset.get_resource(model_url) # We load the model
self.geppetto_common_library = resource.contents[0] # We get the root
def test_delete_unresolved_proxy_loaded_models_from_pointed(lib):
rset = ResourceSet()
root = rset.get_resource('tests/xmi/xmi-tests/a1.xmi').contents[0]
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
b = root2.b[0]
b.delete()
assert len(root.a[0].tob) == 1 # the element is still in the collection
assert len(root2.b) == 0
assert b.eContainer() is None
def test_delete_resolved_proxy_simple_relation(lib):
rset = ResourceSet()
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
root = rset.get_resource('tests/xmi/xmi-tests/a3.xmi').contents[0]
b = root.a[0].simpleb
b.force_resolve()
b.delete()
assert len(root.a[0].tob) == 0
assert len(root2.b) == 0
def test_delete_unresolved_proxy_loaded_models_from_pointed_simple_rel(lib):
rset = ResourceSet()
root = rset.get_resource('tests/xmi/xmi-tests/a3.xmi').contents[0]
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
b = root2.b[0]
b.delete()
assert root.a[0].simpleb is not None # the element is still in the col.
assert len(root2.b) == 0
assert b.eContainer() is None
def main(debug=False):
# Go to working directory
if str(os.path.dirname(__file__)) != '':
os.chdir(str(os.path.dirname(__file__)))
# Count arguments
if len(sys.argv) < 2 or len(sys.argv) > 3:
print(
'Please give at least an GRS file name (input model) and optionaly an XMI file name (output model)'
)
sys.exit(0)
# Obtain GRS model filename
# ~ grs_filename = os.path.relpath(sys.argv[1], str(os.getcwd()))
grs_filename = os.path.relpath(sys.argv[1], str(os.getcwd()))
# Obtain XMI model filename
if len(sys.argv) == 3:
xmi_filename = sys.argv[2]
else:
xmi_filename = '../models/generos.xmi'
# Load Grammar
dsl_metamodel = metamodel_from_file('generos.tx', debug=False)
# Convert importURI string (if needed)
def conv(i):
return i.replace(".", "/") + ".grs"
# Scope Providers
dsl_metamodel.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI(importAs=True)})
# Recursive function that loads the commands of the imported models to the main model
def resolve_imports(current_model):
# Load imported models
imports = get_children_of_type("Import", current_model)
for i in imports:
for m in i._tx_loaded_models:
# Recursively attach commands of more deep imports
m = resolve_imports(m)
# Attach commands of the submodels (imports) to the main model
current_model.commands.extend(m.commands)
return current_model
# Load Model
model = dsl_metamodel.model_from_file(grs_filename)
resolve_imports(model)
# Fire up the generation
system = RosSystem()
system.interpret(model)
#create rset
global_registry[Ecore.nsURI] = Ecore
rset = ResourceSet()
rset.metamodel_registry[metageneros.nsURI] = metageneros
model_res = rset.create_resource(URI(xmi_filename))
# Save
model_res.append(system.rosystem)
model_res.save()
def setup_resourceset():
import pyuml2.types as types
types_URI = 'platform:/plugin/org.eclipse.uml2.types/model/Types.ecore'
ecore_UML_URI = 'platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore'
rset = ResourceSet()
rset.metamodel_registry[types_URI] = types
rset.metamodel_registry[ecore_UML_URI] = ecore
return rset
def test_delete_resolved_proxy_2_models_loaded(lib):
rset = ResourceSet()
root = rset.get_resource('tests/xmi/xmi-tests/a1.xmi').contents[0]
root2 = rset.get_resource('tests/xmi/xmi-tests/b1.xmi').contents[0]
b = root.a[0].tob[0]
b.force_resolve()
b.delete()
assert len(root.a[0].tob) == 0
assert len(root2.b) == 0 # the element had been removed
assert b.eContainer() is None
def load_external_string(self, esdl_string, name='from_string'):
"""Loads an energy system from a string but does NOT add it to the resourceSet (e.g. as a separate resource)
It returns an Energy System, but it is not part of a resource in the ResourceSet """
uri = StringURI(name + '.esdl', esdl_string)
external_rset = ResourceSet()
external_resource = external_rset.create_resource(uri)
external_resource.load()
external_energy_system = external_resource.contents[0]
self.validate(es=external_energy_system)
return external_energy_system
def serialize(self, geppetto_model):
#we now create a resource to save the geppetto model and serialize it to a JSON string
rset = ResourceSet()
uri = StringURI('netpyne_model.json')
rset.resource_factory['*'] = lambda uri: GeppettoResource(uri, indent=2)
resource = rset.create_resource(uri)
resource.append(geppetto_model)
#TODO: We need to apply a visitor and set all the serialised objects to synched
resource.save(options={JsonOptions.SERIALIZE_DEFAULT_VALUES: True})
return uri.getvalue()
def test_delete_unresolved_proxy_2_models_loaded_simple_relation(lib):
rset = ResourceSet()
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'a3.xmi')
root = rset.get_resource(xmi_file).contents[0]
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'b1.xmi')
root2 = rset.get_resource(xmi_file).contents[0]
b = root.a[0].simpleb
b.delete()
assert root.a[0].simpleb is None
assert len(root2.b) == 1 # the element is still here
def test_delete_unresolved_proxy_2_models_loaded(lib):
rset = ResourceSet()
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'a1.xmi')
root = rset.get_resource(xmi_file).contents[0]
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'b1.xmi')
root2 = rset.get_resource(xmi_file).contents[0]
b = root.a[0].tob[0]
b.delete()
assert len(root.a[0].tob) == 0
assert len(root2.b) == 1 # the element is still here
def saveModel(model):
# create a resourceSet that hold the contents of the gdm.ecore model and the instances we use/create
rset = ResourceSet()
# register the metamodel (available in the generated files)
rset.metamodel_registry[gdm.nsURI] = gdm
rset.resource_factory['gdm'] = lambda uri: XMIResource(uri)
resource = rset.create_resource(URI('Static_model_test.xmi'))
resource.append(model)
resource.save()
return
def test_resource_load_proxy_href(simplemm):
rset = ResourceSet()
rset.metamodel_registry[simplemm.nsURI] = simplemm
root = rset.get_resource(path.join('tests', 'xmi', 'xmi-tests',
'a1.xmi')).contents[0]
rset.get_resource(path.join('tests', 'xmi', 'xmi-tests', 'b1.xmi'))
assert isinstance(root.a[0].tob[0], EProxy)
B = simplemm.getEClassifier('B')
root.a[0].tob[0].eClass # We force the proxy resolution
assert isinstance(root.a[0].tob[0], B.python_class)
assert EcoreUtils.isinstance(root.a[0].tob[0], B)
def test_resource_load_proxy_href_force_resolve_idempotent(simplemm):
rset = ResourceSet()
rset.metamodel_registry[simplemm.nsURI] = simplemm
root = rset.get_resource(path.join('tests', 'xmi', 'xmi-tests',
'a2.xmi')).contents[0]
rset.get_resource(path.join('tests', 'xmi', 'xmi-tests', 'inner',
'b2.xmi'))
x = root.a[0].tob[0]
x.force_resolve()
wrapped = x._wrapped
x.force_resolve()
assert wrapped is x._wrapped
def loadMetaModel(file):
global_registry[Ecore.nsURI] = Ecore # We load the Ecore metamodel first
rset = ResourceSet()
metamodel = rset.get_resource(URI(file))
return metamodel.contents[0]
def loadModel(metamodel, file):
rset = ResourceSet()
rset.metamodel_registry[metamodel.nsURI] = metamodel
return rset.get_resource(file).contents[0]
def saveModel(metamodel, model, output):
rset = ResourceSet()
rset.metamodel_registry[metamodel.nsURI] = metamodel
model_resource = rset.create_resource(URI(output))
model_resource.append(model)
return model_resource.save()
