teaching/muMLE
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Conformance checker relies much more on ODAPI rather than duplicating its logic + Fix error in bootstrap of primitive types

Browse source
This commit is contained in:
Joeri Exelmans 2024-11-05 16:54:00 +01:00
parent c92d5be284
commit a26ceef10f
5 changed files with 187 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

6
api/cd.py
View file

@ -49,7 +49,7 @@ class CDAPI:
self.transitive_sub_types = { type_name: set(get_transitive_sub_types(type_name)) for type_name in self.direct_sub_types }
self.transitive_super_types = { type_name: set(get_transitive_super_types(type_name)) for type_name in self.direct_super_types }
def get_type(self, type_name: str):
def get(self, type_name: str):
return self.bottom.read_outgoing_elements(self.m, type_name)[0]
def is_direct_subtype(self, super_type_name: str, sub_type_name: str):
@ -68,7 +68,9 @@ class CDAPI:
# # The edge connecting an object to the value of a slot must be named `{object_name}_{attr_name}`
def get_attr_link_name(self, class_name, attr_name):
return self.type_model_names[self.find_attribute_type(class_name, attr_name)]
attr_type_link = self.find_attribute_type(class_name, attr_name)
if attr_type_link != None:
return self.type_model_names[attr_type_link]
# Attributes are inherited, so when we instantiate an attribute of a class, the AttributeLink may contain the name of the superclass
def find_attribute_type(self, class_name: str, attr_name: str):

68
api/od.py
View file

@ -16,6 +16,9 @@ def build_name_mapping(state, m):
mapping[element] = name
return mapping
class NoSuchSlotException(Exception):
pass
# Object Diagram API
# Intended to replace the 'services.od.OD' class eventually
class ODAPI:
@ -25,7 +28,7 @@ class ODAPI:
self.m = m
self.mm = mm
self.od = od.OD(mm, m, state)
self.cd = cd.CDAPI(state, mm)
self.cdapi = cd.CDAPI(state, mm)
self.create_boolean_value = self.od.create_boolean_value
self.create_integer_value = self.od.create_integer_value
@ -36,15 +39,16 @@ class ODAPI:
# Called after every change - makes querying faster but modifying slower
def __recompute_mappings(self):
self.obj_to_name = {**build_name_mapping(self.state, self.m), **build_name_mapping(self.state, self.mm)}
# self.obj_to_type = {}
self.m_obj_to_name = build_name_mapping(self.state, self.m)
self.mm_obj_to_name = build_name_mapping(self.state, self.mm)
self.type_to_objs = { type_name : set() for type_name in self.bottom.read_keys(self.mm)}
for m_name in self.bottom.read_keys(self.m):
m_element, = self.bottom.read_outgoing_elements(self.m, m_name)
tm_element = self.get_type(m_element)
tm_name = self.obj_to_name[tm_element]
# self.obj_to_type[m_name] = tm_name
self.type_to_objs[tm_name].add(m_name)
if tm_element in self.mm_obj_to_name:
tm_name = self.mm_obj_to_name[tm_element]
# self.obj_to_type[m_name] = tm_name
self.type_to_objs[tm_name].add(m_name)
def get_value(self, obj: UUID):
return od.read_primitive_value(self.bottom, obj, self.mm)[0]
@ -58,21 +62,44 @@ class ODAPI:
def get_slot(self, obj: UUID, attr_name: str):
slot = self.od.get_slot(obj, attr_name)
if slot == None:
raise Exception(f"Object '{self.obj_to_name[obj]}' has no slot '{attr_name}'")
raise NoSuchSlotException(f"Object '{self.m_obj_to_name[obj]}' has no slot '{attr_name}'")
return slot
def get_slot_link(self, obj: UUID, attr_name: str):
return self.od.get_slot_link(obj, attr_name)
def get_outgoing(self, obj: UUID, assoc_name: str):
return od.find_outgoing_typed_by(self.bottom, src=obj, type_node=self.bottom.read_outgoing_elements(self.mm, assoc_name)[0])
# Parameter 'include_subtypes': whether to include subtypes of the given association
def get_outgoing(self, obj: UUID, assoc_name: str, include_subtypes=True):
outgoing = self.bottom.read_outgoing_edges(obj)
result = []
for o in outgoing:
try:
type_of_outgoing_link = self.get_type_name(o)
except:
continue # OK, not all edges are typed
if (include_subtypes and self.cdapi.is_subtype(super_type_name=assoc_name, sub_type_name=type_of_outgoing_link)
or not include_subtypes and type_of_outgoing_link == assoc_name):
result.append(o)
return result
def get_incoming(self, obj: UUID, assoc_name: str):
return od.find_incoming_typed_by(self.bottom, tgt=obj, type_node=self.bottom.read_outgoing_elements(self.mm, assoc_name)[0])
# Parameter 'include_subtypes': whether to include subtypes of the given association
def get_incoming(self, obj: UUID, assoc_name: str, include_subtypes=True):
incoming = self.bottom.read_incoming_edges(obj)
result = []
for i in incoming:
try:
type_of_incoming_link = self.get_type_name(i)
except:
continue # OK, not all edges are typed
if (include_subtypes and self.cdapi.is_subtype(super_type_name=assoc_name, sub_type_name=type_of_incoming_link)
or not include_subtypes and type_of_incoming_link == assoc_name):
result.append(i)
return result
def get_all_instances(self, type_name: str, include_subtypes=True):
if include_subtypes:
all_types = self.cd.transitive_sub_types[type_name]
all_types = self.cdapi.transitive_sub_types[type_name]
else:
all_types = set([type_name])
obj_names = [obj_name for type_name in all_types for obj_name in self.type_to_objs[type_name]]
@ -89,7 +116,6 @@ class ODAPI:
[name for name in self.bottom.read_keys(self.m) if self.bottom.read_outgoing_elements(self.m, name)[0] == obj] +
[name for name in self.bottom.read_keys(self.mm) if self.bottom.read_outgoing_elements(self.mm, name)[0] == obj]
)[0]
return self.obj_to_name[obj]
def get(self, name: str):
return self.bottom.read_outgoing_elements(self.m, name)[0]
@ -98,8 +124,8 @@ class ODAPI:
return self.get_name(self.get_type(obj))
def is_instance(obj: UUID, type_name: str, include_subtypes=True):
typ = self.cd.get_type(type_name)
types = set(typ) if not include_subtypes else self.cd.transitive_sub_types[type_name]
typ = self.cdapi.get_type(type_name)
types = set(typ) if not include_subtypes else self.cdapi.transitive_sub_types[type_name]
for type_of_obj in self.bottom.read_outgoing_elements(obj, "Morphism"):
if type_of_obj in types:
return True
@ -109,12 +135,20 @@ class ODAPI:
self.bottom.delete_element(obj)
self.__recompute_mappings()
# Does the class of the object have the given attribute?
def has_slot(self, obj: UUID, attr_name: str):
class_name = self.get_name(self.get_type(obj))
return self.od.get_attr_link_name(class_name, attr_name) != None
def get_slot_value(self, obj: UUID, attr_name: str):
return self.get_value(self.get_slot(obj, attr_name))
slot = self.get_slot(obj, attr_name)
return self.get_value(slot)
def get_slot_value_default(self, obj: UUID, attr_name: str, default: any):
try:
return self.get_slot_value(obj, attr_name)
except NoSuchSlotException:
return default
# create or update slot value
def set_slot_value(self, obj: UUID, attr_name: str, new_value: any, is_code=False):
@ -130,7 +164,7 @@ class ODAPI:
self.bottom.delete_element(old_target) # this also deletes the slot-link
new_target = self.create_primitive_value(target_name, new_value, is_code)
slot_type = self.cd.find_attribute_type(self.get_type_name(obj), attr_name)
slot_type = self.cdapi.find_attribute_type(self.get_type_name(obj), attr_name)
new_link = self.od._create_link(link_name, slot_type, obj, new_target)
self.__recompute_mappings()

36
bootstrap/primitive.py
View file

@ -4,36 +4,35 @@ from services.primitives.integer_type import Integer
from services.primitives.actioncode_type import ActionCode
def bootstrap_type(type_name: str, scd_root: UUID, model_root: UUID, integer_type: UUID, state: State):
def bootstrap_type(type_name: str, scd_root: UUID, model_root: UUID, state: State):
bottom = Bottom(state)
# create class
class_node = bottom.create_node() # create class node
bottom.create_edge(model_root, class_node, type_name) # attach to model
scd_node, = bottom.read_outgoing_elements(scd_root, "Class") # retrieve type
bottom.create_edge(class_node, scd_node, "Morphism") # create morphism link
type_class_node = bottom.create_node() # create class node
bottom.create_edge(model_root, type_class_node, type_name) # attach to model
class_class_node, = bottom.read_outgoing_elements(scd_root, "Class") # retrieve type
bottom.create_edge(type_class_node, class_class_node, "Morphism") # create morphism link
scd_int_node, = bottom.read_outgoing_elements(scd_root, "Integer")
# set min_cardinality
min_c_model = bottom.create_node()
Integer(min_c_model, state).create(1)
min_c_node = bottom.create_node(str(min_c_model))
bottom.create_edge(model_root, min_c_node, f"{type_name}.lower_cardinality")
min_c_link = bottom.create_edge(class_node, min_c_node)
min_c_link = bottom.create_edge(type_class_node, min_c_node)
bottom.create_edge(model_root, min_c_link, f"{type_name}_lower_cardinality")
scd_node = integer_type
scd_link, = bottom.read_outgoing_elements(scd_root, "Class_lower_cardinality")
bottom.create_edge(min_c_node, scd_node, "Morphism")
bottom.create_edge(min_c_node, scd_int_node, "Morphism")
bottom.create_edge(min_c_link, scd_link, "Morphism")
# set max_cardinality
max_c_model = bottom.create_node()
Integer(max_c_model, state).create(1)
max_c_node = bottom.create_node(str(max_c_model))
bottom.create_edge(model_root, max_c_node, f"{type_name}.upper_cardinality")
max_c_link = bottom.create_edge(class_node, max_c_node)
max_c_link = bottom.create_edge(type_class_node, max_c_node)
bottom.create_edge(model_root, max_c_link, f"{type_name}_upper_cardinality")
scd_node = integer_type
scd_link, = bottom.read_outgoing_elements(scd_root, "Class_upper_cardinality")
bottom.create_edge(max_c_node, scd_node, "Morphism")
bottom.create_edge(max_c_node, scd_int_node, "Morphism")
bottom.create_edge(max_c_link, scd_link, "Morphism")
return class_node
return type_class_node
def bootstrap_constraint(class_node, type_name: str, python_type: str, scd_root: UUID, model_root: UUID, actioncode_type: UUID, state: State):
bottom = Bottom(state)
@ -50,12 +49,12 @@ def bootstrap_constraint(class_node, type_name: str, python_type: str, scd_root:
def bootstrap_primitive_types(scd_root, state, integer_type, boolean_type, float_type, string_type, type_type, actioncode_type):
# Order is important: Integer must come first
class_integer = bootstrap_type("Integer", scd_root, integer_type, integer_type, state)
class_type = bootstrap_type("Type", scd_root, type_type, integer_type, state)
class_boolean = bootstrap_type("Boolean", scd_root, boolean_type, integer_type, state)
class_float = bootstrap_type("Float", scd_root, float_type, integer_type, state)
class_string = bootstrap_type("String", scd_root, string_type, integer_type, state)
class_actioncode = bootstrap_type("ActionCode", scd_root, actioncode_type, integer_type, state)
class_integer = bootstrap_type("Integer", scd_root, integer_type, state)
class_type = bootstrap_type("Type", scd_root, type_type, state)
class_boolean = bootstrap_type("Boolean", scd_root, boolean_type, state)
class_float = bootstrap_type("Float", scd_root, float_type, state)
class_string = bootstrap_type("String", scd_root, string_type, state)
class_actioncode = bootstrap_type("ActionCode", scd_root, actioncode_type, state)
# Can only create constraints after ActionCode type has been created:
bootstrap_constraint(class_integer, "Integer", "int", scd_root, integer_type, actioncode_type, state)
@ -64,4 +63,3 @@ def bootstrap_primitive_types(scd_root, state, integer_type, boolean_type, float
bootstrap_constraint(class_float, "Float", "float", scd_root, float_type, actioncode_type, state)
bootstrap_constraint(class_string, "String", "str", scd_root, string_type, actioncode_type, state)
bootstrap_constraint(class_actioncode, "ActionCode", "str", scd_root, actioncode_type, actioncode_type, state)

343
framework/conformance.py
View file

@ -32,36 +32,33 @@ def render_conformance_check_result(error_list):
class Conformance:
# Parameter 'constraint_check_subtypes': whether to check local type-level constraints also on subtypes.
def __init__(self, state: State, model: UUID, type_model: UUID, constraint_check_subtypes=True):
self.state = state
self.bottom = Bottom(state)
type_model_id = state.read_dict(state.read_root(), "SCD")
self.scd_model = UUID(state.read_value(type_model_id))
self.model = model
self.type_model = type_model
self.constraint_check_subtypes = constraint_check_subtypes # for a class-level constraint, also check the constraint on the subtypes of that class? In other words, are constraints inherited.
self.type_mapping: Dict[str, str] = {}
self.model_names = {
# map model elements to their names to prevent iterating too much
self.bottom.read_outgoing_elements(self.model, e)[0]: e
for e in self.bottom.read_keys(self.model)
}
self.type_model_names = {
# map type model elements to their names to prevent iterating too much
self.bottom.read_outgoing_elements(self.type_model, e)[0]
: e for e in self.bottom.read_keys(self.type_model)
}
self.primitive_values: Dict[UUID, Any] = {}
self.constraint_check_subtypes = constraint_check_subtypes
# MCL
type_model_id = state.read_dict(state.read_root(), "SCD")
self.scd_model = UUID(state.read_value(type_model_id))
# Helpers
self.cdapi = CDAPI(state, type_model)
self.odapi = ODAPI(state, model, type_model)
self.type_odapi = ODAPI(state, type_model, self.scd_model)
# Pre-computed:
self.abstract_types: List[str] = []
self.multiplicities: Dict[str, Tuple] = {}
self.source_multiplicities: Dict[str, Tuple] = {}
self.target_multiplicities: Dict[str, Tuple] = {}
# ?
self.structures = {}
self.matches = {}
self.candidates = {}
self.cdapi = CDAPI(state, type_model)
self.odapi = ODAPI(state, model, type_model)
def check_nominal(self, *, log=False):
"""
@ -103,120 +100,38 @@ class Conformance:
# print(e)
# return False
def read_attribute(self, element: UUID, attr_name: str):
"""
Read an attribute value attached to an element
Args:
element: UUID of the element
attr_name: name of the attribute to read
Returns:
The value of hte attribute, if no attribute with given name is found, returns None
"""
if element in self.type_model_names:
# type model element
element_name = self.type_model_names[element]
model = self.type_model
else:
# model element
element_name = self.model_names[element]
model = self.model
try:
attr_elem, = self.bottom.read_outgoing_elements(model, f"{element_name}.{attr_name}")
return self.primitive_values.get(attr_elem, self.bottom.read_value(UUID(self.bottom.read_value(attr_elem))))
except ValueError:
return None
def deref_primitive_values(self):
"""
Prefetch the values stored in referenced primitive type models
"""
ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
string_element, = self.bottom.read_outgoing_elements(self.scd_model, "String")
boolean_element, = self.bottom.read_outgoing_elements(self.scd_model, "Boolean")
integer_element, = self.bottom.read_outgoing_elements(self.scd_model, "Integer")
t_deref = []
t_refs = []
for tm_element, tm_name in self.type_model_names.items():
morphisms = self.bottom.read_outgoing_elements(tm_element, "Morphism")
if ref_element in morphisms:
t_refs.append(self.type_model_names[tm_element])
elif string_element in morphisms:
t_deref.append(tm_element)
elif boolean_element in morphisms:
t_deref.append(tm_element)
elif integer_element in morphisms:
t_deref.append(tm_element)
for elem in t_deref:
primitive_model = UUID(self.bottom.read_value(elem))
primitive_value_node, = self.bottom.read_outgoing_elements(primitive_model)
primitive_value = self.bottom.read_value(primitive_value_node)
self.primitive_values[elem] = primitive_value
for m_name, tm_name in self.type_mapping.items():
if tm_name in t_refs:
# dereference
m_element, = self.bottom.read_outgoing_elements(self.model, m_name)
primitive_model = UUID(self.bottom.read_value(m_element))
try:
primitive_value_node, = self.bottom.read_outgoing_elements(primitive_model)
primitive_value = self.bottom.read_value(primitive_value_node)
self.primitive_values[m_element] = primitive_value
except ValueError:
pass # multiple elements in model indicate that we're not dealing with a primitive
def precompute_multiplicities(self):
"""
Creates an internal representation of type multiplicities that is
more easily queryable that the state graph
"""
for tm_element, tm_name in self.type_model_names.items():
# class abstract flags and multiplicities
abstract = self.read_attribute(tm_element, "abstract")
lc = self.read_attribute(tm_element, "lower_cardinality")
uc = self.read_attribute(tm_element, "upper_cardinality")
for clss_name, clss in self.type_odapi.get_all_instances("Class"):
abstract = self.type_odapi.get_slot_value_default(clss, "abstract", default=False)
if abstract:
self.abstract_types.append(tm_name)
if lc or uc:
mult = (
lc if lc != None else float("-inf"),
uc if uc != None else float("inf")
)
self.multiplicities[tm_name] = mult
# multiplicities for associations
slc = self.read_attribute(tm_element, "source_lower_cardinality")
suc = self.read_attribute(tm_element, "source_upper_cardinality")
if slc or suc:
mult = (
# slc if slc != None else float("-inf"),
slc if slc != None else 0,
suc if suc != None else float("inf")
)
self.source_multiplicities[tm_name] = mult
tlc = self.read_attribute(tm_element, "target_lower_cardinality")
tuc = self.read_attribute(tm_element, "target_upper_cardinality")
if tlc or tuc:
mult = (
# tlc if tlc != None else float("-inf"),
tlc if tlc != None else 0,
tuc if tuc != None else float("inf")
)
self.target_multiplicities[tm_name] = mult
# optional for attribute links
opt = self.read_attribute(tm_element, "optional")
if opt != None:
self.source_multiplicities[tm_name] = (0, float('inf'))
self.target_multiplicities[tm_name] = (0 if opt else 1, 1)
self.abstract_types.append(clss_name)
def get_type(self, element: UUID):
"""
Retrieve the type of an element (wrt. current type model)
"""
morphisms = self.bottom.read_outgoing_elements(element, "Morphism")
tm_element, = [m for m in morphisms if m in self.type_model_names.keys()]
return tm_element
lc = self.type_odapi.get_slot_value_default(clss, "lower_cardinality", default=0)
uc = self.type_odapi.get_slot_value_default(clss, "upper_cardinality", default=float('inf'))
if lc or uc:
self.multiplicities[clss_name] = (lc, uc)
for assoc_name, assoc in self.type_odapi.get_all_instances("Association"):
# multiplicities for associations
slc = self.type_odapi.get_slot_value_default(assoc, "source_lower_cardinality", default=0)
suc = self.type_odapi.get_slot_value_default(assoc, "source_upper_cardinality", default=float('inf'))
if slc or suc:
self.source_multiplicities[assoc_name] = (slc, suc)
tlc = self.type_odapi.get_slot_value_default(assoc, "target_lower_cardinality", default=0)
tuc = self.type_odapi.get_slot_value_default(assoc, "target_upper_cardinality", default=float('inf'))
if tlc or tuc:
self.target_multiplicities[assoc_name] = (tlc, tuc)
for attr_name, attr in self.type_odapi.get_all_instances("AttributeLink"):
# optional for attribute links
opt = self.type_odapi.get_slot_value(attr, "optional")
if opt != None:
self.source_multiplicities[attr_name] = (0, float('inf'))
self.target_multiplicities[attr_name] = (0 if opt else 1, 1)
def check_typing(self):
"""
@ -224,24 +139,15 @@ class Conformance:
link exists to some element of type_model
"""
errors = []
ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
model_names = self.bottom.read_keys(self.model)
for m_name in model_names:
m_element, = self.bottom.read_outgoing_elements(self.model, m_name)
try:
tm_element = self.get_type(m_element)
tm_name = self.type_model_names[tm_element]
self.type_mapping[m_name] = tm_name
if ref_element in self.bottom.read_outgoing_elements(tm_element, "Morphism"):
sub_m = UUID(self.bottom.read_value(m_element))
sub_tm = UUID(self.bottom.read_value(tm_element))
nested_errors = Conformance(self.state, sub_m, sub_tm).check_nominal()
errors += [f"In ModelRef ({m_name}):" + err for err in nested_errors]
except ValueError as e:
import traceback
traceback.format_exc(e)
# no or too many morphism links found
errors.append(f"Incorrectly typed element: '{m_name}'")
# Recursively do a conformance check for each ModelRef
for ref_name, ref in self.type_odapi.get_all_instances("ModelRef"):
sub_mm = UUID(self.bottom.read_value(ref))
for ref_inst_name, ref_inst in self.odapi.get_all_instances(ref_name):
sub_m = UUID(self.bottom.read_value(ref_inst))
nested_errors = Conformance(self.state, sub_m, sub_mm).check_nominal()
errors += [f"In ModelRef ({m_name}):" + err for err in nested_errors]
return errors
def check_link_typing(self):
@ -249,97 +155,76 @@ class Conformance:
for each link, check whether its source and target are of a valid type
"""
errors = []
for m_name, tm_name in self.type_mapping.items():
m_element, = self.bottom.read_outgoing_elements(self.model, m_name)
m_source = self.bottom.read_edge_source(m_element)
m_target = self.bottom.read_edge_target(m_element)
if m_source == None or m_target == None:
# element is not a link
continue
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
tm_source = self.bottom.read_edge_source(tm_element)
tm_target = self.bottom.read_edge_target(tm_element)
# check if source is typed correctly
source_name = self.model_names[m_source]
source_type_actual = self.type_mapping[source_name]
source_type_expected = self.type_model_names[tm_source]
if not self.cdapi.is_subtype(super_type_name=source_type_expected, sub_type_name=source_type_actual):
errors.append(f"Invalid source type '{source_type_actual}' for element '{m_name}'")
# check if target is typed correctly
target_name = self.model_names[m_target]
target_type_actual = self.type_mapping[target_name]
target_type_expected = self.type_model_names[tm_target]
if not self.cdapi.is_subtype(super_type_name=source_type_expected, sub_type_name=source_type_actual):
errors.append(f"Invalid target type '{target_type_actual}' for element '{m_name}'")
for tm_name, tm_element in self.type_odapi.get_all_instances("Association") + self.type_odapi.get_all_instances("AttributeLink"):
for m_name, m_element in self.odapi.get_all_instances(tm_name):
m_source = self.bottom.read_edge_source(m_element)
m_target = self.bottom.read_edge_target(m_element)
if m_source == None or m_target == None:
# element is not a link
continue
# tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
tm_source = self.bottom.read_edge_source(tm_element)
tm_target = self.bottom.read_edge_target(tm_element)
# check if source is typed correctly
# source_name = self.odapi.m_obj_to_name[m_source]
source_type_actual = self.odapi.get_type_name(m_source)
source_type_expected = self.odapi.mm_obj_to_name[tm_source]
if not self.cdapi.is_subtype(super_type_name=source_type_expected, sub_type_name=source_type_actual):
errors.append(f"Invalid source type '{source_type_actual}' for link '{m_name}:{tm_name}'")
# check if target is typed correctly
# target_name = self.odapi.m_obj_to_name[m_target]
target_type_actual = self.odapi.get_type_name(m_target)
target_type_expected = self.odapi.mm_obj_to_name[tm_target]
if not self.cdapi.is_subtype(super_type_name=source_type_expected, sub_type_name=source_type_actual):
errors.append(f"Invalid target type '{target_type_actual}' for link '{m_name}:{tm_name}'")
return errors
def check_multiplicities(self):
"""
Check whether multiplicities for all types are respected
"""
self.deref_primitive_values()
self.precompute_multiplicities()
errors = []
for type_name in self.type_model_names.values():
for class_name, clss in self.type_odapi.get_all_instances("Class"):
# for type_name in self.odapi.mm_obj_to_name.values():
# abstract classes
if type_name in self.abstract_types:
count = list(self.type_mapping.values()).count(type_name)
if class_name in self.abstract_types:
count = len(self.odapi.get_all_instances(class_name, include_subtypes=False))
if count > 0:
errors.append(f"Invalid instantiation of abstract class: '{type_name}'")
errors.append(f"Invalid instantiation of abstract class: '{class_name}'")
# class multiplicities
if type_name in self.multiplicities:
lc, uc = self.multiplicities[type_name]
count = 0
for sub_type in self.cdapi.transitive_sub_types[type_name]:
count += list(self.type_mapping.values()).count(sub_type)
if class_name in self.multiplicities:
lc, uc = self.multiplicities[class_name]
count = len(self.odapi.get_all_instances(class_name, include_subtypes=True))
if count < lc or count > uc:
errors.append(f"Cardinality of type exceeds valid multiplicity range: '{type_name}' ({count})")
errors.append(f"Cardinality of type exceeds valid multiplicity range: '{class_name}' ({count})")
for assoc_name, assoc in self.type_odapi.get_all_instances("Association") + self.type_odapi.get_all_instances("AttributeLink"):
# association/attribute source multiplicities
if type_name in self.source_multiplicities:
if assoc_name in self.source_multiplicities:
# type is an association
type_obj, = self.bottom.read_outgoing_elements(self.type_model, type_name)
tgt_type_obj = self.bottom.read_edge_target(type_obj)
tgt_type_name = self.type_model_names[tgt_type_obj]
lc, uc = self.source_multiplicities[type_name]
for obj_name, obj_type_name in self.type_mapping.items():
if self.cdapi.is_subtype(super_type_name=tgt_type_name, sub_type_name=obj_type_name):
# obj's type has this incoming association -> now we will count the number of links typed by it
count = 0
obj, = self.bottom.read_outgoing_elements(self.model, obj_name)
incoming = self.bottom.read_incoming_edges(obj)
for i in incoming:
try:
type_of_incoming_link = self.type_mapping[self.model_names[i]]
if self.cdapi.is_subtype(super_type_name=type_name, sub_type_name=type_of_incoming_link):
count += 1
except KeyError:
pass # for elements not part of model, e.g. morphism links
if count < lc or count > uc:
errors.append(f"Source cardinality of type '{type_name}' ({count}) out of bounds ({lc}..{uc}) in '{obj_name}'.")
assoc, = self.bottom.read_outgoing_elements(self.type_model, assoc_name)
tgt_type_obj = self.bottom.read_edge_target(assoc)
tgt_type_name = self.odapi.mm_obj_to_name[tgt_type_obj]
lc, uc = self.source_multiplicities[assoc_name]
for obj_name, obj in self.odapi.get_all_instances(tgt_type_name, include_subtypes=True):
# obj's type has this incoming association -> now we will count the number of links typed by it
count = len(self.odapi.get_incoming(obj, assoc_name, include_subtypes=True))
if count < lc or count > uc:
errors.append(f"Source cardinality of type '{assoc_name}' ({count}) out of bounds ({lc}..{uc}) in '{obj_name}'.")
# association/attribute target multiplicities
if type_name in self.target_multiplicities:
if assoc_name in self.target_multiplicities:
# type is an association
type_obj, = self.bottom.read_outgoing_elements(self.type_model, type_name)
type_obj, = self.bottom.read_outgoing_elements(self.type_model, assoc_name)
src_type_obj = self.bottom.read_edge_source(type_obj)
src_type_name = self.type_model_names[src_type_obj]
lc, uc = self.target_multiplicities[type_name]
for obj_name, obj_type_name in self.type_mapping.items():
if self.cdapi.is_subtype(super_type_name=src_type_name, sub_type_name=obj_type_name):
# obj's type has this outgoing association -> now we will count the number of links typed by it
count = 0
obj, = self.bottom.read_outgoing_elements(self.model, obj_name)
outgoing = self.bottom.read_outgoing_edges(obj)
for o in outgoing:
try:
type_of_outgoing_link = self.type_mapping[self.model_names[o]]
if self.cdapi.is_subtype(super_type_name=type_name, sub_type_name=type_of_outgoing_link):
count += 1
except KeyError:
pass # for elements not part of model, e.g. morphism links
if count < lc or count > uc:
errors.append(f"Target cardinality of type '{type_name}' ({count}) out of bounds ({lc}..{uc}) in '{obj_name}'.")
src_type_name = self.odapi.mm_obj_to_name[src_type_obj]
lc, uc = self.target_multiplicities[assoc_name]
for obj_name, obj in self.odapi.get_all_instances(src_type_name, include_subtypes=True):
# obj's type has this outgoing association -> now we will count the number of links typed by it
count = len(self.odapi.get_outgoing(obj, assoc_name, include_subtypes=True))
if count < lc or count > uc:
errors.append(f"Target cardinality of type '{assoc_name}' ({count}) out of bounds ({lc}..{uc}) in '{obj_name}'.")
return errors
def evaluate_constraint(self, code, **kwargs):
@ -447,7 +332,7 @@ class Conformance:
# collect types
class_element, = self.bottom.read_outgoing_elements(self.scd_model, "Class")
association_element, = self.bottom.read_outgoing_elements(self.scd_model, "Association")
for tm_element, tm_name in self.type_model_names.items():
for tm_element, tm_name in self.odapi.mm_obj_to_name.items():
# retrieve elements that tm_element is a morphism of
morphisms = self.bottom.read_outgoing_elements(tm_element, "Morphism")
morphism, = [m for m in morphisms if m in scd_elements]
@ -457,7 +342,7 @@ class Conformance:
# collect type structures
# retrieve AttributeLink to check whether element is a morphism of AttributeLink
attr_link_element, = self.bottom.read_outgoing_elements(self.scd_model, "AttributeLink")
for tm_element, tm_name in self.type_model_names.items():
for tm_element, tm_name in self.odapi.mm_obj_to_name.items():
# retrieve elements that tm_element is a morphism of
morphisms = self.bottom.read_outgoing_elements(tm_element, "Morphism")
morphism, = [m for m in morphisms if m in scd_elements]
@ -465,8 +350,8 @@ class Conformance:
if attr_link_element == morphism:
# retrieve attributes of attribute link, i.e. 'name' and 'optional'
attrs = self.bottom.read_outgoing_elements(tm_element)
name_model_node, = filter(lambda x: self.type_model_names.get(x, "").endswith(".name"), attrs)
opt_model_node, = filter(lambda x: self.type_model_names.get(x, "").endswith(".optional"), attrs)
name_model_node, = filter(lambda x: self.odapi.m_obj_to_name.get(x, "").endswith(".name"), attrs)
opt_model_node, = filter(lambda x: self.odapi.m_obj_to_name.get(x, "").endswith(".optional"), attrs)
# get attr name value
name_model = UUID(self.bottom.read_value(name_model_node))
name_node, = self.bottom.read_outgoing_elements(name_model)
@ -477,9 +362,9 @@ class Conformance:
opt = self.bottom.read_value(opt_node)
# get attr type name
source_type_node = self.bottom.read_edge_source(tm_element)
source_type_name = self.type_model_names[source_type_node]
source_type_name = self.odapi.mm_obj_to_name[source_type_node]
target_type_node = self.bottom.read_edge_target(tm_element)
target_type_name = self.type_model_names[target_type_node]
target_type_name = self.odapi.mm_obj_to_name[target_type_node]
# add attribute to the structure of its source type
# attribute is stored as a (name, optional, type) triple
self.structures.setdefault(source_type_name, set()).add((name, opt, target_type_name))
@ -493,7 +378,7 @@ class Conformance:
# filter out abstract types, as they cannot be instantiated
# retrieve Class_abstract to check whether element is a morphism of Class_abstract
class_abs_element, = self.bottom.read_outgoing_elements(self.scd_model, "Class_abstract")
for tm_element, tm_name in self.type_model_names.items():
for tm_element, tm_name in self.odapi.mm_obj_to_name.items():
# retrieve elements that tm_element is a morphism of
morphisms = self.bottom.read_outgoing_elements(tm_element, "Morphism")
morphism, = [m for m in morphisms if m in scd_elements]
@ -506,7 +391,7 @@ class Conformance:
is_abstract = self.bottom.read_value(abst_node)
# retrieve type name
source_node = self.bottom.read_edge_source(tm_element)
type_name = self.type_model_names[source_node]
type_name = self.odapi.mm_obj_to_name[source_node]
if is_abstract:
self.structures.pop(type_name)
@ -516,7 +401,7 @@ class Conformance:
"""
ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
# matching
for m_element, m_name in self.model_names.items():
for m_element, m_name in self.odapi.m_obj_to_name.items():
is_edge = self.bottom.read_edge_source(m_element) != None
print('element:', m_element, 'name:', m_name, 'is_edge', is_edge)
for type_name, structure in self.structures.items():
@ -567,23 +452,23 @@ class Conformance:
print(' add to candidates:', m_name, type_name)
self.candidates.setdefault(m_name, set()).add(type_name)
# filter out candidates for links based on source and target types
for m_element, m_name in self.model_names.items():
for m_element, m_name in self.odapi.m_obj_to_name.items():
is_edge = self.bottom.read_edge_source(m_element) != None
if is_edge and m_name in self.candidates:
m_source = self.bottom.read_edge_source(m_element)
m_target = self.bottom.read_edge_target(m_element)
print(self.candidates)
source_candidates = self.candidates[self.model_names[m_source]]
target_candidates = self.candidates[self.model_names[m_target]]
source_candidates = self.candidates[self.odapi.m_obj_to_name[m_source]]
target_candidates = self.candidates[self.odapi.m_obj_to_name[m_target]]
remove = set()
for candidate_name in self.candidates[m_name]:
candidate_element, = self.bottom.read_outgoing_elements(self.type_model, candidate_name)
candidate_source = self.type_model_names[self.bottom.read_edge_source(candidate_element)]
candidate_source = self.odapi.mm_obj_to_name[self.bottom.read_edge_source(candidate_element)]
if candidate_source not in source_candidates:
if len(source_candidates.intersection(set(self.odapi.transitive_sub_types[candidate_source]))) == 0:
# if len(source_candidates.intersection(set(self.sub_types[candidate_source]))) == 0:
remove.add(candidate_name)
candidate_target = self.type_model_names[self.bottom.read_edge_target(candidate_element)]
candidate_target = self.odapi.mm_obj_to_name[self.bottom.read_edge_target(candidate_element)]
if candidate_target not in target_candidates:
if len(target_candidates.intersection(set(self.odapi.transitive_sub_types[candidate_target]))) == 0:
# if len(target_candidates.intersection(set(self.sub_types[candidate_target]))) == 0:

2
services/od.py
View file

@ -372,7 +372,7 @@ def read_primitive_value(bottom, modelref: UUID, mm: UUID):
if not is_typed_by(bottom, typ, get_scd_mm_modelref_node(bottom)):
raise Exception("Assertion failed: argument must be typed by ModelRef", typ)
referred_model = UUID(bottom.read_value(modelref))
typ_name = get_object_name(bottom, mm, typ)
typ_name = get_object_name(bottom, model=mm, object_node=typ)
if typ_name == "Integer":
return Integer(referred_model, bottom.state).read(), typ_name
elif typ_name == "String":