diff --git a/saref_patterns/__init__.py b/saref_patterns/__init__.py
index d3abcab35d0007c1c7b50d85c8a01e52d63349b2..45a78ac60b3f73f5e2bd4a063f186b77bfc37db3 100644
--- a/saref_patterns/__init__.py
+++ b/saref_patterns/__init__.py
@@ -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
diff --git a/saref_patterns/check.py b/saref_patterns/check.py
deleted file mode 100644
index f40d5eeecd80cd9391451a742128a3b7faf700fe..0000000000000000000000000000000000000000
--- a/saref_patterns/check.py
+++ /dev/null
@@ -1,3 +0,0 @@
-
-from saref_project import SAREFProject, SAREFCore, SAREF
-
diff --git a/saref_patterns/saref_project.py b/saref_patterns/saref_project.py
index 160d49925956a1a88eee30e1cbd9a7d64b934013..f2c5d0bb08f118bd4199027412e4d6027c03a55e 100644
--- a/saref_patterns/saref_project.py
+++ b/saref_patterns/saref_project.py
@@ -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)
+ with open(patterns_config_yml, 'r') as patterns_config_file:
+ patterns_config = yaml.safe_load(patterns_config_file)
+
+ 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 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)
- sys.stderr.write(f"# Specialization for pattern {pattern} of project {project.name}\n")
+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)
- try:
- with open(patterns_config_yml, 'r') as patterns_config_file, open(projectRepository / "ontology" / (project.ontologyFileName + ".ttl"), 'r') as ontology_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")
- 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")
- sys.exit()
-
- 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)
-
- # 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)
-
\ No newline at end of file
+ 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)