diff --git a/bootstrap/primitive.py b/bootstrap/primitive.py index 5500b6c..177c085 100644 --- a/bootstrap/primitive.py +++ b/bootstrap/primitive.py @@ -1,5 +1,6 @@ from state.base import State, UUID from services.bottom.V0 import Bottom +from services.primitives.integer_type import Integer def bootstrap_type(type_name: str, python_type: str, scd_root: UUID, model_root: UUID, state: State): @@ -10,7 +11,9 @@ def bootstrap_type(type_name: str, python_type: str, scd_root: UUID, model_root: scd_node, = bottom.read_outgoing_elements(scd_root, "Class") # retrieve type bottom.create_edge(class_node, scd_node, "Morphism") # create morphism link # set min_cardinality - min_c_node = bottom.create_node(1) + 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) bottom.create_edge(model_root, min_c_link, f"{type_name}.lower_cardinality_link") @@ -19,7 +22,9 @@ def bootstrap_type(type_name: str, python_type: str, scd_root: UUID, model_root: bottom.create_edge(min_c_node, scd_node, "Morphism") bottom.create_edge(min_c_link, scd_link, "Morphism") # set max_cardinality - max_c_node = bottom.create_node(1) + 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) bottom.create_edge(model_root, max_c_link, f"{type_name}.upper_cardinality_link") @@ -28,7 +33,7 @@ def bootstrap_type(type_name: str, python_type: str, scd_root: UUID, model_root: bottom.create_edge(max_c_node, scd_node, "Morphism") bottom.create_edge(max_c_link, scd_link, "Morphism") # set constraint - constraint_node = bottom.create_node(f"isinstance(read_value(x),{python_type})") + constraint_node = bottom.create_node(f"isinstance(read_value(element),{python_type})") bottom.create_edge(model_root, constraint_node, f"{type_name}.constraint") constraint_link = bottom.create_edge(class_node, constraint_node) bottom.create_edge(model_root, constraint_link, f"{type_name}.constraint_link") diff --git a/bootstrap/scd.py b/bootstrap/scd.py index 19e6c59..34fe1d3 100644 --- a/bootstrap/scd.py +++ b/bootstrap/scd.py @@ -110,9 +110,10 @@ def bootstrap_scd(state: State) -> UUID: assoc_t_l_c_edge = add_edge_element("Association_target_lower_cardinality", assoc_edge, integer_node) assoc_t_u_c_edge = add_edge_element("Association_target_upper_cardinality", assoc_edge, integer_node) # # bootstrap primitive types + # # order is important, integer must be first + bootstrap_integer_type(mcl_root, integer_type_root, state) bootstrap_boolean_type(mcl_root, boolean_type_root, state) bootstrap_float_type(mcl_root, float_type_root, state) - bootstrap_integer_type(mcl_root, integer_type_root, state) bootstrap_string_type(mcl_root, string_type_root, state) bootstrap_type_type(mcl_root, type_type_root, state) # # ATTRIBUTE ATTRIBUTES, assign 'name' and 'optional' attributes to all AttributeLinks @@ -156,6 +157,11 @@ def bootstrap_scd(state: State) -> UUID: m_name, m_opt = add_attribute_attributes("Association_target_upper_cardinality", assoc_t_u_c_edge) String(m_name, state).create("target_upper_cardinality") Boolean(m_opt, state).create(True) + # # Make Element abstract + abs_model = bottom.create_node() + abs_node = add_node_element(f"Element.abstract", str(abs_model)) + abs_edge = add_edge_element(f"Element.abstract_link", element_node, abs_node) + Boolean(abs_model, state).create(True) # create phi(SCD,SCD) to type MCL with itself @@ -245,6 +251,9 @@ def bootstrap_scd(state: State) -> UUID: add_mcl_morphism("Association_source_upper_cardinality.optional", "Boolean") add_mcl_morphism("Association_target_lower_cardinality.optional", "Boolean") add_mcl_morphism("Association_target_upper_cardinality.optional", "Boolean") + add_mcl_morphism("Element.abstract", "Boolean") + # Class_abstract + add_mcl_morphism("Element.abstract_link", "Class_abstract") return mcl_root diff --git a/framework/__init__.py b/framework/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/framework/conformance.py b/framework/conformance.py new file mode 100644 index 0000000..042aedb --- /dev/null +++ b/framework/conformance.py @@ -0,0 +1,358 @@ +from services.bottom.V0 import Bottom +from uuid import UUID +from state.base import State +from typing import Dict, Tuple, Set, Any, List +from pprint import pprint + + +class Conformance: + def __init__(self, state: State, scd_model: UUID, model: UUID, type_model: UUID): + self.state = state + self.bottom = Bottom(state) + self.scd_model = scd_model + self.model = model + self.type_model = type_model + 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.sub_types: Dict[str, Set[str]] = { + k: set() for k in self.bottom.read_keys(self.type_model) + } + self.primitive_values: Dict[UUID, Any] = {} + self.abstract_types: List[str] = [] + self.multiplicities: Dict[str, Tuple] = {} + self.source_multiplicities: Dict[str, Tuple] = {} + self.target_multiplicities: Dict[str, Tuple] = {} + + def check_nominal(self): + steps = [ + self.check_typing, + self.check_link_typing, + self.check_multiplicities, + self.check_constraints + ] + for step in steps: + conforms = step() + if not conforms: + return False + return True + + def read_attribute(self, m_element: UUID, attr_name: str): + + def has_label(_edge: UUID, _label): + elems = self.bottom.read_outgoing_elements(_edge) + for elem in elems: + value = self.primitive_values.get(elem, self.bottom.read_value(elem)) + if value is not None and value == _label: + return True + return False + + def get_outgoing_edge_by_label(_element: UUID, _label): + edges = self.bottom.read_outgoing_edges(_element) + for e in edges: + if has_label(e, _label): + return e + + outgoing = self.bottom.read_outgoing_edges(m_element) + for edge in outgoing: + try: + edge_name = self.model_names[edge] + edge_type_name = self.type_mapping[edge_name] + edge_type, = self.bottom.read_outgoing_elements(self.type_model, edge_type_name) + edge_type_src = self.bottom.read_edge_source(edge_type) + if get_outgoing_edge_by_label(edge_type_src, attr_name) == edge_type: + result = self.bottom.read_edge_target(edge) + return self.primitive_values.get(result, self.bottom.read_value(result)) + + except KeyError: + pass # non-model edge, e.g. morphism link + + def precompute_sub_types(self): + inh_element, = self.bottom.read_outgoing_elements(self.scd_model, "Inheritance") + inh_links = [] + for tm_element, tm_name in self.type_model_names.items(): + morphisms = self.bottom.read_outgoing_elements(tm_element, "Morphism") + if inh_element in morphisms: + inh_links.append(tm_element) + + for link in inh_links: + tm_source = self.bottom.read_edge_source(link) + tm_target = self.bottom.read_edge_target(link) + parent_name = self.type_model_names[tm_target] + child_name = self.type_model_names[tm_source] + self.sub_types[parent_name].add(child_name) + + stop = False + while not stop: + stop = True + for child_name, child_children in self.sub_types.items(): + for parent_name, parent_children in self.sub_types.items(): + if child_name in parent_children: + original_size = len(parent_children) + parent_children.update(child_children) + if len(parent_children) != original_size: + stop = False + + def deref_primitive_values(self): + 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): + 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") + if abstract: + self.abstract_types.append(tm_name) + if lc or uc: + mult = ( + lc if lc is not None else float("-inf"), + uc if uc is not 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 is not None else float("-inf"), + suc if suc is not 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 is not None else float("-inf"), + tuc if tuc is not None else float("inf") + ) + self.target_multiplicities[tm_name] = mult + # optional for attribute links + opt = self.read_attribute(tm_element, "optional") + if opt is not None: + mult = (0 if opt else 1, 1) + self.source_multiplicities[tm_name] = mult + self.target_multiplicities[tm_name] = mult + + def get_type(self, element: UUID): + 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 + + def check_typing(self): + """ + for each element of model check whether a morphism + link exists to some element of type_model + """ + 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)) + if not Conformance(self.state, self.scd_model, sub_m, sub_tm).check_nominal(): + return False + except ValueError: + # no or too many morphism links found + print(f"Incorrectly typed element: {m_name}") + return False + return True + + def check_link_typing(self): + self.precompute_sub_types() + 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 is None or m_target is 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 source_type_actual != source_type_expected: + if source_type_actual not in self.sub_types[source_type_expected]: + print(f"Invalid source type {source_type_actual} for element {m_name}") + return False + # 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 target_type_actual != target_type_expected: + if target_type_actual not in self.sub_types[target_type_expected]: + print(f"Invalid target type {target_type_actual} for element {m_name}") + return False + return True + + def check_multiplicities(self): + self.deref_primitive_values() + self.precompute_multiplicities() + for tm_name in self.type_model_names.values(): + # abstract classes + if tm_name in self.abstract_types: + type_count = list(self.type_mapping.values()).count(tm_name) + if type_count > 0: + print(f"Invalid instantiation of abstract class: {tm_name}") + return False + # class multiplicities + if tm_name in self.multiplicities: + lc, uc = self.multiplicities[tm_name] + type_count = list(self.type_mapping.values()).count(tm_name) + for sub_type in self.sub_types[tm_name]: + type_count += list(self.type_mapping.values()).count(sub_type) + if type_count < lc or type_count > uc: + print(f"Cardinality of type exceeds valid multiplicity range: {tm_name} ({type_count})") + return False + # association source multiplicities + if tm_name in self.source_multiplicities: + tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name) + tm_source_element = self.bottom.read_edge_source(tm_element) + tm_source_name = self.type_model_names[tm_source_element] + lc, uc = self.source_multiplicities[tm_name] + for i, t in self.type_mapping.items(): + if t == tm_source_name or t in self.sub_types[tm_source_name]: + count = 0 + i_element, = self.bottom.read_outgoing_elements(self.model, i) + outgoing = self.bottom.read_outgoing_edges(i_element) + for o in outgoing: + try: + if self.type_mapping[self.model_names[o]] == tm_name: + count += 1 + except KeyError: + pass # for elements not part of model, e.g. morphism links + if count < lc or count > uc: + print(f"Source cardinality of type {tm_name} exceeds valid multiplicity range in {i}.") + return False + + # association target multiplicities + if tm_name in self.target_multiplicities: + tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name) + tm_target_element = self.bottom.read_edge_source(tm_element) + tm_target_name = self.type_model_names[tm_target_element] + lc, uc = self.target_multiplicities[tm_name] + for i, t in self.type_mapping.items(): + if t == tm_target_name or t in self.sub_types[tm_target_name]: + count = 0 + i_element, = self.bottom.read_outgoing_elements(self.model, i) + outgoing = self.bottom.read_outgoing_edges(i_element) + for o in outgoing: + try: + if self.type_mapping[self.model_names[o]] == tm_name: + count += 1 + except KeyError: + pass # for elements not part of model, e.g. morphism links + if count < lc or count > uc: + print(f"Target cardinality of type {tm_name} exceeds valid multiplicity range in {i}.") + return False + return True + + def check_constraints(self): + # local constraints + for m_name, tm_name in self.type_mapping.items(): + if tm_name != "GlobalConstraint": + tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name) + code = self.read_attribute(tm_element, "constraint") + print(code) + # global constraints + for m_name, tm_name in self.type_mapping.items(): + if tm_name == "GlobalConstraint": + tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name) + code = self.read_attribute(tm_element, "constraint") + print(code) + return True + + +def __create_pn(state: State): + from services.scd import SCD + # Retrieve refs to primitive type models + # # integer + int_type_id = state.read_dict(state.read_root(), "Integer") + int_type = UUID(state.read_value(int_type_id)) + # # string + str_type_id = state.read_dict(state.read_root(), "String") + str_type = UUID(state.read_value(str_type_id)) + # Create LTM_PN + model_uuid = state.create_node() + service = SCD(scd, model_uuid, state) + # Create classes + service.create_class("P") + service.create_class("T") + # Create associations + service.create_association("P2T", "P", "T") + service.create_association("T2P", "T", "P") + # Create model refs + service.create_model_ref("Integer", int_type) + service.create_model_ref("String", int_type) + # Create class attributes + service.create_attribute_link("P", "Integer", "t", False) + service.create_attribute_link("P", "String", "n", False) + service.create_attribute_link("T", "String", "n", False) + # Create association attributes + service.create_attribute_link("P2T", "Integer", "w", False) + service.create_attribute_link("T2P", "Integer", "w", False) + # Create test constraint + service.add_constraint("P", "print(element)\nreturn True") + return model_uuid + + +if __name__ == '__main__': + from state.devstate import DevState as State + s = State() + from bootstrap.scd import bootstrap_scd + scd = bootstrap_scd(s) + pn = __create_pn(s) + # cf = Conformance(s, scd, scd, scd) + # cf.check_nominal() + cf = Conformance(s, scd, pn, scd) + cf.check_nominal() + diff --git a/services/primitives/boolean_type.py b/services/primitives/boolean_type.py index 9ab1852..9f157f2 100644 --- a/services/primitives/boolean_type.py +++ b/services/primitives/boolean_type.py @@ -14,6 +14,7 @@ class Boolean: if "boolean" in self.bottom.read_keys(self.model): instance, = self.bottom.read_outgoing_elements(self.model, "boolean") self.bottom.delete_element(instance) - _instance = self.bottom.create_edge(self.model, self.bottom.create_node(value), "boolean") + _instance = self.bottom.create_node(value) + self.bottom.create_edge(self.model, _instance, "boolean") _type, = self.bottom.read_outgoing_elements(self.type_model, "Boolean") self.bottom.create_edge(_instance, _type, "Morphism") diff --git a/services/primitives/float_type.py b/services/primitives/float_type.py index 3d92a20..ff18bbc 100644 --- a/services/primitives/float_type.py +++ b/services/primitives/float_type.py @@ -14,6 +14,7 @@ class Float: if "float" in self.bottom.read_keys(self.model): instance, = self.bottom.read_outgoing_elements(self.model, "float") self.bottom.delete_element(instance) - _instance = self.bottom.create_edge(self.model, self.bottom.create_node(value), "float") + _instance = self.bottom.create_node(value) + self.bottom.create_edge(self.model, _instance, "float") _type, = self.bottom.read_outgoing_elements(self.type_model, "Float") self.bottom.create_edge(_instance, _type, "Morphism") diff --git a/services/primitives/integer_type.py b/services/primitives/integer_type.py index 87ebd7d..44864bb 100644 --- a/services/primitives/integer_type.py +++ b/services/primitives/integer_type.py @@ -14,6 +14,7 @@ class Integer: if "string" in self.bottom.read_keys(self.model): instance, = self.bottom.read_outgoing_elements(self.model, "integer") self.bottom.delete_element(instance) - _instance = self.bottom.create_edge(self.model, self.bottom.create_node(value), "integer") + _instance = self.bottom.create_node(value) + self.bottom.create_edge(self.model, _instance, "integer") _type, = self.bottom.read_outgoing_elements(self.type_model, "Integer") self.bottom.create_edge(_instance, _type, "Morphism") diff --git a/services/primitives/string_type.py b/services/primitives/string_type.py index e1a5a87..926c1cd 100644 --- a/services/primitives/string_type.py +++ b/services/primitives/string_type.py @@ -14,6 +14,7 @@ class String: if "string" in self.bottom.read_keys(self.model): instance, = self.bottom.read_outgoing_elements(self.model, "string") self.bottom.delete_element(instance) - _instance = self.bottom.create_edge(self.model, self.bottom.create_node(value), "string") + _instance = self.bottom.create_node(value) + self.bottom.create_edge(self.model, _instance, "string") _type, = self.bottom.read_outgoing_elements(self.type_model, "String") self.bottom.create_edge(_instance, _type, "Morphism") diff --git a/services/primitives/type_type.py b/services/primitives/type_type.py index e7031c2..98ec38b 100644 --- a/services/primitives/type_type.py +++ b/services/primitives/type_type.py @@ -14,6 +14,7 @@ class Integer: if "string" in self.bottom.read_keys(self.model): instance, = self.bottom.read_outgoing_elements(self.model, "type") self.bottom.delete_element(instance) - _instance = self.bottom.create_edge(self.model, self.bottom.create_node(value), "type") + _instance = self.bottom.create_node(value) + self.bottom.create_edge(self.model, _instance, "type") _type, = self.bottom.read_outgoing_elements(self.type_model, "Type") self.bottom.create_edge(_instance, _type, "Morphism")