saref_project.py can be called to check each of the pattern specializations (3e20f3c4) · Commits · SAREF / saref-patterns

saref_patterns/init.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -4,4 +4,4 @@ BASE = saref_project.BASE
		SAREFProject = saref_project.SAREFProject
		SAREFCore = saref_project.SAREFCore
		SAREF = saref_project.SAREF
		check_patterns = saref_project.run
		check_patterns = saref_project.check_pattern

saref_patterns/check.py

deleted100644 → 0

+0 −3

Original line number	Diff line number	Diff line

		from saref_project import SAREFProject, SAREFCore, SAREF

saref_patterns/saref_project.py

+93 −45

Original line number	Diff line number	Diff line
		@@ -4,13 +4,13 @@ import re
		from pathlib import Path
		import yaml
		from jsonschema import validate
		import importlib
		from rdflib import Namespace
		from rdflib import Graph
		from rdflib.namespace import NamespaceManager
		from rdflib.compare import to_isomorphic, graph_diff



		BASE = "https://saref.etsi.org/"

		class SAREFProject:
		@@ -39,58 +39,106 @@ class SAREFProject:
		SAREFCore = SAREFProject("saref-core")
		SAREF = SAREFCore.namespace

		def run(specialize, schema=None):
		class SAREFPattern:
		def __init__(self, specialize, schema):
		self.specialize = specialize
		self.schema = schema

		def run_one(project, pattern, executions):
		g = Graph()
		g += pattern.ontology
		for execution in executions:
		# check the format
		if pattern.schema:
		validate(execution, pattern.schema)
		# execute the pattern specialization function
		g += pattern.specialize(project.namespace, execution)

		# check if some triples are not in the ontology
		g = to_isomorphic(g)
		in_both, in_first, in_second = graph_diff(project.ontology, g)
		if in_second:
		sys.stderr.write("Error: the following triples should be in the ontology:\n")
		in_second.namespace_manager = project.namespace_manager
		in_second.print(out=sys.stderr)

		def get_project(patterns_config_yml:Path):
		projectRepository = patterns_config_yml.parents[1]
		project = SAREFProject(projectRepository)

		project.namespace_manager = NamespaceManager(Graph())
		project.namespace_manager.bind(SAREFCore.prefix, SAREF)
		project.namespace_manager.bind(project.prefix, project.namespace)

		with open(projectRepository / "ontology" / (project.ontologyFileName + ".ttl"), 'r') as ontology_file:
		project.ontology = Graph()
		project.ontology.parse(ontology_file)
		project.ontology = to_isomorphic(project.ontology)

		project.namespace_manager = NamespaceManager(Graph())
		project.namespace_manager.bind(SAREFCore.prefix, SAREF)
		project.namespace_manager.bind(project.prefix, project.namespace)
		return project

		def check_pattern(specialize, schema=None):
		if len(sys.argv) != 2:
		print()
		sys.stderr.write("Expecting one argument: the location of a pattern specialization specification document. See ETSI TS 103 673")
		sys.exit(1)
		scriptname = Path(sys.argv[0]).resolve()
		pattern = os.path.basename(os.path.dirname(scriptname))
		reference_pattern = os.path.basename(os.path.dirname(scriptname))
		project_with_reference_patterns = os.path.basename(scriptname.parents[2])
		pattern = SAREFPattern(specialize, schema)
		pattern.ontology = Graph()
		try:
		with open((scriptname/".."/"pattern.ttl").resolve(), "r") as pattern_ontology_file:
		pattern.ontology.parse(pattern_ontology_file)
		except Exception as e:
		print(e)
		pass

		patterns_config_yml = Path(sys.argv[1]).resolve()
		projectRepository = patterns_config_yml.parents[1]
		project = SAREFProject(projectRepository)
		project = get_project(patterns_config_yml)

		namespace_manager = NamespaceManager(Graph())
		namespace_manager.bind(SAREFCore.prefix, SAREF)
		namespace_manager.bind(project.prefix, project.namespace)

		sys.stderr.write(f"# Specialization for pattern {pattern} of project {project.name}\n")

		try:
		with open(patterns_config_yml, 'r') as patterns_config_file, open(projectRepository / "ontology" / (project.ontologyFileName + ".ttl"), 'r') as ontology_file:
		with open(patterns_config_yml, 'r') as patterns_config_file:
		patterns_config = yaml.safe_load(patterns_config_file)
		if project.ontologyFileName not in patterns_config:
		sys.stderr.write(f"Warning: Patterns specialization specification document does not contain a section for {project.ontologyFileName}\n")

		if project_with_reference_patterns not in patterns_config:
		sys.stderr.write(f"Warning: Patterns specialization specification document does not contain a section for {project_with_reference_patterns}\n")
		sys.exit()
		if pattern not in patterns_config[project.ontologyFileName]:
		sys.stderr.write(f"Warning: Patterns specialization specification document does not contain a section for {project.ontologyFileName}.{pattern}\n")
		if reference_pattern not in patterns_config[project_with_reference_patterns]:
		sys.stderr.write(f"Warning: Patterns specialization specification document does not contain a section for {project_with_reference_patterns}.{reference_pattern}\n")
		sys.exit()
		executions = patterns_config[project_with_reference_patterns][reference_pattern]
		run_one(project, pattern, executions)

		ontology = Graph()
		ontology.parse(ontology_file)
		ontology_iso = to_isomorphic(ontology)

		# specialize patterns
		for execution in patterns_config[project.ontologyFileName][pattern]:
		# check the format
		if schema:
		validate(execution, schema)
		if __name__ == "__main__":
		if len(sys.argv) != 2:
		print()
		sys.stderr.write("Expecting one argument: the location of a pattern specialization specification document. See ETSI TS 103 673")
		sys.exit(1)

		# run the specialization script
		specialization = specialize(project.namespace, execution)
		patterns_config_yml = Path(sys.argv[1]).resolve()
		project = get_project(patterns_config_yml)

		# check if some triples are not in the ontology
		specialize_iso = to_isomorphic(specialization)
		in_both, in_first, in_second = graph_diff(ontology_iso, specialize_iso)
		# print("Success: the following triples are in the ontology:")
		# in_both.namespace_manager = namespace_manager
		# in_both.print()
		if in_second:
		sys.stderr.write("Error: the following triples should be in the ontology:\n")
		in_second.namespace_manager = namespace_manager
		in_second.print(out=sys.stderr)
		except Exception as exc:
		sys.stderr.write(f"{type(exc).__name__} {exc}")
		sys.exit(1)
		with open(patterns_config_yml, 'r') as patterns_config_file:
		patterns_config = yaml.safe_load(patterns_config_file)
		for project_with_reference_patterns in patterns_config:
		for reference_pattern in patterns_config[project_with_reference_patterns]:
		print(f"executing pattern {reference_pattern} in project {project_with_reference_patterns}")

		pattern_name = f"{project_with_reference_patterns}.{reference_pattern}"
		pattern_path = Path("..")/project_with_reference_patterns/"patterns"/reference_pattern
		spec = importlib.util.spec_from_file_location(pattern_name, pattern_path/"specialization.py")
		pattern = importlib.util.module_from_spec(spec)
		# sys.modules[module_name] = module
		spec.loader.exec_module(pattern)
		# initialize pattern.ontology
		pattern.ontology = Graph()
		try:
		with open(pattern_path/"pattern.ttl", "r") as pattern_ontology_file:
		pattern.ontology.parse(pattern_ontology_file)
		except:
		pass
		executions = patterns_config[project_with_reference_patterns][reference_pattern]
		run_one(project, pattern, executions)