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 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 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(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_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 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 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_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_resolved_proxy_simple_relation(lib):
rset = ResourceSet()
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'b1.xmi')
root2 = rset.get_resource(xmi_file).contents[0]
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'a3.xmi')
root = rset.get_resource(xmi_file).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_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 test_delete_resolved_proxy_loaded_models_from_pointed(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]
root.a[0].tob[0].force_resolve()
b = root2.b[0]
b.delete()
assert len(root.a[0].tob) == 0 # the element is not in the collection
assert len(root2.b) == 0
assert b.eContainer() is None
def test_delete_resolved_proxy_loaded_models_from_pointed_simple_rel(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]
root.a[0].simpleb.force_resolve()
b = root2.b[0]
b.delete()
assert root.a[0].simpleb is None # the element is still in the col.
assert len(root2.b) == 0
assert b.eContainer() is None
def test_delete_resolved_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.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_energy_system(self, name):
# create a resourceSet that hold the contents of the esdl.ecore model and the instances we use/create
rset = ResourceSet()
# Assign files with the .esdl extension to the XMLResource instead of default XMI
rset.resource_factory['esdl'] = lambda uri: XMLResource(uri)
# Read the lastest esdl.ecore from github
esdl_model_resource = rset.get_resource(
HttpURI(
'https://raw.githubusercontent.com/EnergyTransition/ESDL/master/esdl/model/esdl.ecore'
))
esdl_model = esdl_model_resource.contents[0]
# print('Namespace: {}'.format(esdl_model.nsURI))
rset.metamodel_registry[esdl_model.nsURI] = esdl_model
# Create a dynamic model from the loaded esdl.ecore model, which we can use to build Energy Systems
esdl = DynamicEPackage(esdl_model)
# fix python buildin 'from' that is also used in ProfileElement as attribute
# use 'start' instead of 'from' when using a ProfileElement
alias('start', esdl.ProfileElement.findEStructuralFeature('from'))
# have a nice __repr__ for some ESDL classes when printing ESDL objects (includes all Assets and EnergyAssets)
esdl.Item.python_class.__repr__ = lambda x: '{}: ({})'.format(
x.name, EnergySystemHandler.attr_to_dict(x))
esdl.Carrier.python_class.__repr__ = lambda x: '{}: ({})'.format(
x.name, EnergySystemHandler.attr_to_dict(x))
esdl.Geometry.python_class.__repr__ = lambda x: '{}: ({})'.format(
x.name, EnergySystemHandler.attr_to_dict(x))
esdl.QuantityAndUnitType.python_class.__repr__ = lambda x: '{}: ({})'.format(
x.id, EnergySystemHandler.attr_to_dict(x))
esdl.QuantityAndUnitReference.python_class.__repr__ = lambda x: '{}: ({})'.format(
'QuantityAndUnitReference', EnergySystemHandler.attr_to_dict(x))
esdl.KPI.python_class.__repr__ = lambda x: '{}: ({})'.format(
x.name, EnergySystemHandler.attr_to_dict(x))
esdl.ProfileElement.python_class.__repr__ = lambda x: 'ProfileElement ({})'.format(
EnergySystemHandler.attr_to_dict(x))
# load the ESDL file
resource = rset.get_resource(URI(name))
es = resource.contents[0]
# At this point, the model instance is loaded!
# get notifications of changes in the EnergySystem model
#observer = PrintNotification(es)
#observer2 = PrintNotification(es.instance[0].area)
# also return the esdlm and rset reference, so we can create esdl classes and store them as strings
return es, resource, esdl, rset
def get_energysystem_from_esdl(fname):
"""
Helper function for esdl_parser. It takes the name of an ESDL file
and returns the EnergySystem object (root of the ESDL tree).
"""
rset = ResourceSet()
resource = rset.get_resource(
HttpURI(
'https://raw.githubusercontent.com/EnergyTransition/ESDL/master/esdl/model/esdl.ecore'
))
esdl_model = resource.contents[0]
rset.metamodel_registry[esdl_model.nsURI] = esdl_model
resource = rset.get_resource(URI(fname))
return resource.contents[0]
def load():
#return model_root
rset = ResourceSet()
resource = rset.get_resource(URI('metamodel.ecore'))
mm_root = resource.contents[0]
rset.metamodel_registry[mm_root.nsURI] = mm_root
resource = rset.get_resource(URI('model.xmi'))
model_root = resource.contents[0]
MyMetamodel = DynamicEPackage(mm_root)
#main_model_creator() #debug
def get_energysystem_from_esdl(fname):
rset = ResourceSet()
# Read the lastest esdl.ecore from github
resource = rset.get_resource(
HttpURI(
'https://raw.githubusercontent.com/EnergyTransition/ESDL/master/esdl/model/esdl.ecore'
))
esdl_model = resource.contents[0]
rset.metamodel_registry[esdl_model.nsURI] = esdl_model
# Create a dynamic model from the loaded esdl.ecore model, which we can use to build Energy Systems
esdl = DynamicEPackage(esdl_model)
resource = rset.get_resource(URI(fname))
return resource.contents[0]
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 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 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 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(lib):
rset = ResourceSet()
xmi_file = path.join('tests', 'xmi', 'xmi-tests', 'a1.xmi')
root = rset.get_resource(xmi_file).contents[0]
b = root.a[0].tob[0]
b.delete()
assert len(root.a[0].tob) == 0
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 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 __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 create_external_ref():
rset = ResourceSet()
rset.resource_factory['esdl'] = XMLResource
rset.resource_factory['*'] = XMLResource
car_rs = rset.get_resource(
HttpURI(
'https://edr.hesi.energy/store/esdl/80e3ac6a-94b1-4a85-a0d1-a68de4251243?format=xml'
))
units_rs = rset.get_resource(
HttpURI(
'http://localhost:9080/store/resource/public/QuantityAndUnits.esdl'
))
es_rs = rset.get_resource(
'C:\\Users\\werkmane\\OneDrive - TNO\\Documents\\ESDL\\EnergySystems\\Untitled EnergySystem.esdl'
)
units = units_rs.contents[0]
ext_carriers = car_rs.contents[0]
#es = esdl.EnergySystem(name='example', id=str(uuid4()))
#es_rs = rset.create_resource(uri=StringURI('example.esdl'))
#es_rs.append(es)
es = es_rs.contents[0]
esi = esdl.EnergySystemInformation()
es.energySystemInformation = esi
carriers = esdl.Carriers()
esi.carriers = carriers
"""
Containment relations are copied, not referenced.
"""
#esi.carriers = ext_carriers
#carriers.carrier.append(first)
first: esdl.Carrier = ext_carriers.carrier[0]
print(first.eURIFragment())
print(first.eResource.uri.plain)
ec = esdl.EnergyCarrier(id=str(uuid4()), name="test")
powerUnit = units_rs.uuid_dict['powerUnit']
ec.energyContentUnit = esdl.QuantityAndUnitReference(reference=powerUnit)
carriers.carrier.append(ec)
print(ec.energyContentUnit)
uri = StringURI('to_string_' + 'left' + '.esdl')
uri = URI('ES with external ref.esdl')
es_rs.save(uri)
def load_metamodel():
"""
Load and return a statechart metamodel and its resource set.
:return: a tuple (metamodel, resource set)
"""
filepath = os.path.join(os.path.dirname(__file__), 'amola.ecore')
rset = ResourceSet()
resource = rset.get_resource(URI(filepath))
metamodel = resource.contents[0]
rset.metamodel_registry[metamodel.nsURI] = metamodel
return DynamicEPackage(metamodel), rset
class EcoreDocumentation:
"""This class loads the dynamic meta-model and returns the documentation for attributes as these are
not present in the static meta-model"""
def __init__(self, esdlEcoreFile=None):
self.esdl = None
self.rset = None
self.esdl_model = None
self.resource = None
if esdlEcoreFile is None:
self.esdlEcoreFile = 'https://raw.githubusercontent.com/EnergyTransition/ESDL/master/esdl/model/esdl.ecore'
else:
self.esdlEcoreFile = esdlEcoreFile
self._init_metamodel()
def _init_metamodel(self):
self.rset = ResourceSet()
# Assign files with the .esdl extension to the XMLResource instead of default XMI
self.rset.resource_factory['esdl'] = lambda uri: XMLResource(uri)
# Read esdl.ecore as meta model
logger.info(
'Initalizing ESDL metamodel for documentation from {}'.format(
self.esdlEcoreFile))
mm_uri = URI(self.esdlEcoreFile)
if self.esdlEcoreFile[:4] == 'http':
mm_uri = HttpURI(self.esdlEcoreFile)
esdl_model_resource = self.rset.get_resource(mm_uri)
esdl_model = esdl_model_resource.contents[0]
self.esdl_model = esdl_model
# logger.debug('Namespace: {}'.format(esdl_model.nsURI))
self.rset.metamodel_registry[esdl_model.nsURI] = esdl_model
# Create a dynamic model from the loaded esdl.ecore model, which we can use to build Energy Systems
self.esdl = DynamicEPackage(esdl_model)
def get_doc(self, className, attributeName):
""" Returns the documentation of an attribute from the dynamic meta model,
because the static meta model does not contain attribute documentation"""
ecoreClass = self.esdl_model.getEClassifier(className)
if ecoreClass is None: return None
attr = ecoreClass.findEStructuralFeature(attributeName)
if attr is None: return None
# logger.debug('Retrieving doc for {}: {}'.format(attributeName, attr.__doc__))
return (attr.__doc__)
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]