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