def __init__(self, verbose: bool, model_root: Path, docs_root: Path,
fragments_root: Path):
self.verbose = verbose
self.model_root = model_root
self.docs_root = docs_root
self.fragments_root = fragments_root
self.g = Graph()
self.g.base = "https://maturity-model.ekgf.org/"
if not self.model_root.is_dir():
raise value_error("{} is not a valid directory",
self.model_root.name)
if not self.docs_root.is_dir():
raise value_error("{} is not a valid directory",
self.model_root.name)
def pillars(self, model_node: Node):
found = 0
for pillar in self.g.subjects(MATURIY_MODEL.pillarInModel, model_node):
found += 1
yield pillar
if found == 0:
raise value_error(f"Model has no pillars: <{model_node}>")
def name_for(self, subject_uri, hint: str) -> str:
name = self.__name_with_lang_for(
subject_uri, self.lang, hint) # first ask language specific label
if name is not None:
return name
name = self.__name_with_lang_for(
subject_uri, None, hint) # then get language independent label
if name is not None:
return name
raise value_error(f"{hint} has no label: {subject_uri}")
def create_sort_keys(self):
""" Generate sortKeys for anything with an ekgmm:capabilityNumber """
for subject, capability_number in self.g.subject_objects(
MATURIY_MODEL.capabilityNumber):
capability_number_parts = str(capability_number).split('.')
if len(capability_number_parts) != 3:
raise value_error(
f"{subject} has an invalid number: {capability_number}")
sort_key = f'{capability_number_parts[0]}.{capability_number_parts[1]:0>3}.{capability_number_parts[2]:0>3}'
self.g.add((subject, MATURIY_MODEL.sortKey, Literal(sort_key)))
def load(self) -> MaturityModelGraph:
self.load_ontologies()
self.load_model_files()
self.rdfs_infer()
log_item("# triples", len(self.g))
# dump_as_ttl_to_stdout(self.g)
graph = MaturityModelGraph(self.g, self.verbose, 'en')
if len(list(graph.models())) == 0:
raise value_error("No models loaded")
graph.rewrite_fragment_references(self.fragments_root)
graph.create_sort_keys()
return graph
def rewrite_fragment_references(self, fragments_root: Path):
"""
For each reference to some text-fragment rewrite the path to that markdown file
relative to the given input directory
"""
predicate = MATURIY_MODEL.backgroundAndIntro
for (subject, objekt) in self.g.subject_objects(predicate):
log_item("Subject", subject)
log_item("Fragments Root", fragments_root)
fragment_path = fragments_root / objekt
log_item("Fragment Path", fragment_path)
if not fragment_path.exists():
raise value_error(f"Fragment {fragment_path} does not exist")
self.g.remove((subject, predicate, objekt))
self.g.add((subject, predicate, Literal(str(fragment_path))))
def local_type_name_for_type(self, type_node: Node, hint: str) -> str:
for local_type_name in self.g.objects(type_node,
MATURIY_MODEL.iriLocalTypeName):
# log_item(f"{hint} Local Type Name", local_type_name)
return str(local_type_name)
raise value_error(f"{hint} has no iriLocalTypeName: {type_node}")
def local_name_for(self, subject_node: Node, hint: str) -> str:
for local_name in self.g.objects(subject_node,
MATURIY_MODEL.iriLocalName):
log_item(f"{hint} Local Name", local_name)
return str(local_name)
raise value_error(f"{hint} has no iriLocalName: {subject_node}")
def capability_number_for(self, capability_node, hint: str):
for number in self.g.objects(capability_node,
MATURIY_MODEL.capabilityNumber):
log_item(f"{hint} Number", number)
return str(number)
raise value_error(f"{hint} has no capabilityNumber: {capability_node}")
def model_with_name(self, model_name: str):
for model in self.models():
name = self.name_for(model, "Model")
if name == model_name:
return model
raise value_error(f"Model with name {model_name} does not exist")
def existing_file(cls, mkdocs: bool, path: Path):
file = File(mkdocs, path)
if not file.exists():
raise value_error(f"File {path} does not exist")
return file