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

replace everywhere: 'is [not] None' -> '(==|!=) None'

Browse source
This commit is contained in:
Joeri Exelmans 2024-09-04 09:50:30 +02:00
parent 3ae35a87d0
commit ec1a9dbfca
28 changed files with 690 additions and 668 deletions
Download patch file Download diff file Expand all files Collapse all files

51
framework/conformance.py
View file

@ -4,6 +4,8 @@ from state.base import State
from typing import Dict, Tuple, Set, Any, List
from pprint import pprint
import functools
class Conformance:
def __init__(self, state: State, model: UUID, type_model: UUID):
@ -21,8 +23,8 @@ class Conformance:
}
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.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)
@ -192,8 +194,8 @@ class Conformance:
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")
lc if lc != None else float("-inf"),
uc if uc != None else float("inf")
)
self.multiplicities[tm_name] = mult
# multiplicities for associations
@ -201,21 +203,21 @@ class Conformance:
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")
slc if slc != None else float("-inf"),
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 is not None else float("-inf"),
tuc if tuc is not None else float("inf")
tlc if tlc != None else float("-inf"),
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 is not None:
if opt != None:
self.source_multiplicities[tm_name] = (0 if opt else 1, 1)
self.target_multiplicities[tm_name] = (0, 1)
@ -245,7 +247,9 @@ class Conformance:
sub_tm = UUID(self.bottom.read_value(tm_element))
if not Conformance(self.state, sub_m, sub_tm).check_nominal():
raise RuntimeError(f"Incorrectly model reference: {m_name}")
except ValueError:
except ValueError as e:
import traceback
traceback.format_exc(e)
# no or too many morphism links found
raise RuntimeError(f"Incorrectly typed element: {m_name}")
return True
@ -259,7 +263,7 @@ class Conformance:
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:
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)
@ -367,7 +371,7 @@ class Conformance:
if tm_name != "GlobalConstraint":
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
code = self.read_attribute(tm_element, "constraint")
if code is not None:
if code != None:
morphisms = self.bottom.read_incoming_elements(tm_element, "Morphism")
morphisms = [m for m in morphisms if m in self.model_names]
for m_element in morphisms:
@ -379,7 +383,7 @@ class Conformance:
if tm_name == "GlobalConstraint":
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
code = self.read_attribute(tm_element, "constraint")
if code is not None:
if code != None:
if not self.evaluate_constraint(code, model=self.model):
raise RuntimeError(f"Global constraint {tm_name} not satisfied.")
return True
@ -460,14 +464,17 @@ class Conformance:
ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
# matching
for m_element, m_name in self.model_names.items():
is_edge = self.bottom.read_edge_source(m_element) is not None
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():
tm_element, = self.bottom.read_outgoing_elements(self.type_model, type_name)
type_is_edge = self.bottom.read_edge_source(tm_element) is not None
type_is_edge = self.bottom.read_edge_source(tm_element) != None
if is_edge == type_is_edge:
print(' type_name:', type_name, 'type_is_edge:', type_is_edge, "structure:", structure)
mismatch = False
matched = 0
for name, optional, attr_type in structure:
print(' name:', name, "optional:", optional, "attr_type:", attr_type)
try:
attr, = self.bottom.read_outgoing_elements(self.model, f"{m_name}.{name}")
attr_tm, = self.bottom.read_outgoing_elements(self.type_model, attr_type)
@ -485,26 +492,34 @@ class Conformance:
else:
# eval constraints
code = self.read_attribute(attr_tm, "constraint")
if code is not None:
if code != None:
attr_conforms = self.evaluate_constraint(code, element=attr)
if attr_conforms:
matched += 1
except ValueError:
print(" attr_conforms -> matched:", matched)
except ValueError as e:
# attr not found or failed parsing UUID
if optional:
print(" skipping:", e)
continue
else:
# did not match mandatory attribute
print(" breaking:", e)
mismatch = True
break
print(' matched:', matched, 'len(structure):', len(structure))
# if matched == len(structure):
if not mismatch:
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():
is_edge = self.bottom.read_edge_source(m_element) is not None
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]]
remove = set()

6
framework/interactive_prompt.py
View file

@ -35,11 +35,11 @@ def main():
man = Manager(state)
while True:
if man.current_model is not None and man.current_context is None:
if man.current_model != None and man.current_context == None:
# we have selected a model, so we display typing questions
answer = prompt(questions.MODEL_SELECTED)
ctx = man
elif man.current_model is not None and man.current_context is not None:
elif man.current_model != None and man.current_context != None:
# we have selected both a model and a context, so we display available services
qs = generate_context_question(type(man.current_context), man.get_services())
answer = prompt(qs)
@ -79,7 +79,7 @@ def main():
args = {k: types[k](v) if len(v) > 0 else None for k, v in args.items()}
try:
output = method(**args)
if output is not None:
if output != None:
try:
if isinstance(output, str):
raise TypeError

24
framework/manager.py
View file

@ -1,5 +1,6 @@
from state.base import State
from bootstrap.scd import bootstrap_scd
from bootstrap.pn import bootstrap_pn
from services import implemented as services
from framework.conformance import Conformance
from uuid import UUID
@ -11,6 +12,7 @@ class Manager:
self.current_context = None
self.state = state
bootstrap_scd(state)
# bootstrap_pn(state, "PN")
scd_node = self.state.read_dict(self.state.read_root(), "SCD")
for key_node in self.state.read_dict_keys(self.state.read_root()):
model_node = self.state.read_dict_node(self.state.read_root(), key_node)
@ -39,7 +41,7 @@ class Manager:
"""
root = self.state.read_root()
type_model_node = self.state.read_dict(root, type_model_name)
if type_model_node is None:
if type_model_node == None:
raise RuntimeError(f"No type model with name {type_model_name} found.")
else:
# check if model is a linguistic type model
@ -71,7 +73,7 @@ class Manager:
"""
root = self.state.read_root()
model_node = self.state.read_dict(root, name)
if model_node is None:
if model_node == None:
raise RuntimeError(f"No model with name {name} found.")
model_root = UUID(self.state.read_value(model_node))
self.current_model = (name, model_root)
@ -94,7 +96,7 @@ class Manager:
Names of the model's types
"""
root = self.state.read_root()
if self.current_model is None:
if self.current_model == None:
raise RuntimeError(f"No model currently selected.")
name, model = self.current_model
model_id = self.state.read_dict(root, name)
@ -142,9 +144,9 @@ class Manager:
Returns:
Functions exposed by the current context's implementation
"""
if self.current_model is None:
if self.current_model == None:
raise RuntimeError(f"No model currently selected.")
if self.current_context is None:
if self.current_context == None:
raise RuntimeError(f"No context currently selected.")
yield from [
getattr(self.current_context, func)
@ -171,14 +173,16 @@ class Manager:
"""
root = self.state.read_root()
type_model_node = self.state.read_dict(root, type_model_name)
if type_model_node is None:
if type_model_node == None:
raise RuntimeError(f"No type model with name {type_model_name} found.")
model_node = self.state.read_dict(root, model_name)
if model_node is None:
if model_node == None:
raise RuntimeError(f"No model with name {model_node} found.")
types = self.state.read_outgoing(model_node)
types = [self.state.read_edge(e)[1] for e in types]
if type_model_node not in types:
# if type_model_node not in types:
if True:
print("checking structural conformance")
conf = Conformance(self.state,
UUID(self.state.read_value(model_node)),
UUID(self.state.read_value(type_model_node))).check_structural(log=True)
@ -186,6 +190,7 @@ class Manager:
self.state.create_edge(model_node, type_model_node)
return conf
else:
print("checking nominal conformance")
return Conformance(self.state,
UUID(self.state.read_value(model_node)),
UUID(self.state.read_value(type_model_node))).check_nominal(log=True)
@ -206,6 +211,9 @@ class Manager:
with open("state.p", "rb") as file:
self.state = pickle.load(file)
def to_graphviz(self):
self.state.dump("state.dot")
if __name__ == '__main__':
from state.devstate import DevState

1
framework/prompt_questions.py
View file

@ -28,6 +28,7 @@ MODEL_MGMT = [
Separator(),
'load state',
'dump state',
'to graphviz',
Separator(),
'exit'
],