shacl2code 0.0.11__py3-none-any.whl

shacl2code/__init__.py

@@ -0,0 +1,4 @@
+from .model import Model, ModelException  # noqa: F401
+from .urlcontext import UrlContext, ContextData  # noqa: F401
+from .main import main  # noqa: F401
+from .version import VERSION  # noqa: F401

shacl2code/__main__.py

@@ -0,0 +1,12 @@
+#! /usr/bin/env python3
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+import sys
+
+from . import main
+
+if __name__ == "__main__":
+    sys.exit(main())

shacl2code/context.py

@@ -0,0 +1,167 @@
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+
+class Context(object):
+    from contextlib import contextmanager
+
+    def __init__(self, contexts=[]):
+        self.contexts = [c for c in contexts if c]
+        self.__vocabs = []
+        self.__expanded = {}
+        self.__compacted = {}
+
+    @contextmanager
+    def vocab_push(self, vocab):
+        if not vocab:
+            yield self
+            return
+
+        self.__vocabs.append(vocab)
+        try:
+            yield self
+        finally:
+            self.__vocabs.pop()
+
+    def __get_vocab_contexts(self):
+        contexts = []
+
+        for v in self.__vocabs:
+            for ctx in self.contexts:
+                # Check for vocabulary contexts
+                for name, value in ctx.items():
+                    if (
+                        isinstance(value, dict)
+                        and value["@type"] == "@vocab"
+                        and v == self.__expand(value["@id"], self.contexts)
+                    ):
+                        contexts.insert(0, value["@context"])
+
+        return contexts
+
+    def compact(self, _id):
+        return self.__compact_contexts(_id)
+
+    def compact_vocab(self, _id, vocab=None):
+        with self.vocab_push(vocab):
+            if not self.__vocabs:
+                v = ""
+            else:
+                v = self.__vocabs[-1]
+
+            return self.__compact_contexts(_id, v, self.__get_vocab_contexts())
+
+    def __compact_contexts(self, _id, v="", apply_vocabs=False):
+        if v not in self.__compacted or _id not in self.__compacted[v]:
+            if apply_vocabs:
+                contexts = self.__get_vocab_contexts() + self.contexts
+            else:
+                contexts = self.contexts
+
+            self.__compacted.setdefault(v, {})[_id] = self.__compact(
+                _id,
+                contexts,
+                apply_vocabs,
+            )
+        return self.__compacted[v][_id]
+
+    def __compact(self, _id, contexts, apply_vocabs):
+        def remove_prefix(_id, value):
+            possible = set()
+            if _id.startswith(value):
+                tmp_id = _id[len(value) :]
+                possible.add(tmp_id)
+                possible |= collect_possible(tmp_id)
+            return possible
+
+        def collect_possible(_id):
+            possible = set()
+            for ctx in contexts:
+                for name, value in ctx.items():
+                    if name == "@vocab":
+                        if apply_vocabs:
+                            possible |= remove_prefix(_id, value)
+                    elif name == "@base":
+                        possible |= remove_prefix(_id, value)
+                    else:
+                        if isinstance(value, dict):
+                            value = value["@id"]
+
+                        if _id == value:
+                            possible.add(name)
+                            possible |= collect_possible(name)
+                        elif _id.startswith(value):
+                            tmp_id = name + ":" + _id[len(value) :].lstrip("/")
+                            possible.add(tmp_id)
+                            possible |= collect_possible(tmp_id)
+
+            return possible
+
+        possible = collect_possible(_id)
+        if not possible:
+            return _id
+
+        # To select from the possible identifiers, choose the one that has the
+        # least context (fewest ":"), then the shortest, and finally
+        # alphabetically
+        possible = list(possible)
+        possible.sort(key=lambda p: (p.count(":"), len(p), p))
+
+        return possible[0]
+
+    def is_relative(self, _id):
+        import re
+
+        return not re.match(r"[^:]+:", _id)
+
+    def __expand_contexts(self, _id, v="", apply_vocabs=False):
+        if v not in self.__expanded or _id not in self.__expanded[v]:
+            if apply_vocabs:
+                contexts = self.__get_vocab_contexts() + self.contexts
+
+                # Apply contexts
+                for ctx in contexts:
+                    for name, value in ctx.items():
+                        if name == "@vocab":
+                            _id = value + _id
+            else:
+                contexts = self.contexts
+
+            for ctx in contexts:
+                for name, value in ctx.items():
+                    if name == "@base" and self.is_relative(_id):
+                        _id = value + _id
+
+            self.__expanded.setdefault(v, {})[_id] = self.__expand(_id, contexts)
+
+        return self.__expanded[v][_id]
+
+    def expand(self, _id):
+        return self.__expand_contexts(_id)
+
+    def expand_vocab(self, _id, vocab=""):
+        with self.vocab_push(vocab):
+            if not self.__vocabs:
+                v = ""
+            else:
+                v = self.__vocabs[-1]
+
+            return self.__expand_contexts(_id, v, True)
+
+    def __expand(self, _id, contexts):
+        for ctx in contexts:
+            if ":" not in _id:
+                if _id in ctx:
+                    if isinstance(ctx[_id], dict):
+                        return self.__expand(ctx[_id]["@id"], contexts)
+                    return self.__expand(ctx[_id], contexts)
+                continue
+
+            prefix, suffix = _id.split(":", 1)
+            if prefix not in ctx:
+                continue
+
+            return self.__expand(prefix, contexts) + suffix
+
+        return _id

shacl2code/lang/__init__.py

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from .lang import LANGUAGES  # noqa: F401
+
+# All renderers must be imported here to be registered
+from .jinja import JinjaRender  # noqa: F401
+from .python import PythonRender  # noqa: F401
+from .jsonschema import JsonSchemaRender  # noqa: F401

shacl2code/lang/common.py

@@ -0,0 +1,144 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+import sys
+import os
+from pathlib import Path
+from contextlib import contextmanager
+from jinja2 import Environment, FileSystemLoader, TemplateRuntimeError
+from rdflib.namespace import SH
+from ..model import SHACL2CODE
+
+THIS_DIR = Path(__file__).parent
+
+
+class OutputFile(object):
+    def __init__(self, path):
+        self.path = path
+
+    @contextmanager
+    def open(self):
+        if self.path == "-":
+            yield sys.stdout
+        else:
+            with open(self.path, "w") as f:
+                yield f
+
+
+class BasicJinjaRender(object):
+    """
+    Common Jinja Template Renderer
+
+    Renderers that only use a single Jinja file can derive from this class. For
+    example:
+
+        @language("my-lang")
+        class MyRendered(BasicJinjaRenderer):
+            HELP = "Generates my-lang bindings"
+
+            def __init__(self, args):
+                super().__init__(args, PATH / TO / TEMPLATE)
+    """
+
+    def __init__(self, args, template):
+        self.__output = args.output
+        self.__template = template
+
+    @classmethod
+    def get_arguments(cls, parser):
+        parser.add_argument(
+            "--output",
+            "-o",
+            type=OutputFile,
+            help="Output file or '-' for stdout",
+            required=True,
+        )
+
+    def get_additional_render_args(self):
+        return {}
+
+    def get_extra_env(self):
+        return {}
+
+    def render(self, template, output, *, extra_env={}, render_args={}):
+        def abort_helper(msg):
+            raise TemplateRuntimeError(msg)
+
+        env = Environment(loader=FileSystemLoader([template.parent, THIS_DIR.parent]))
+        for k, v in extra_env.items():
+            env.globals[k] = v
+        env.globals["abort"] = abort_helper
+        env.globals["SHACL2CODE"] = SHACL2CODE
+        env.globals["SH"] = SH
+        template = env.get_template(template.name)
+
+        render = template.render(
+            disclaimer=f"This file was automatically generated by {os.path.basename(sys.argv[0])}. DO NOT MANUALLY MODIFY IT",
+            **render_args,
+        )
+
+        output.write(render)
+        if not render[-1] == "\n":
+            output.write("\n")
+
+    def output(self, model):
+        """
+        Render the provided model
+        """
+
+        class ObjectList(object):
+            def __init__(self, objs):
+                self.__objs = objs
+
+            def __iter__(self):
+                return iter(self.__objs)
+
+            def get(self, _id):
+                for o in self.__objs:
+                    if o._id == _id:
+                        return o
+                raise KeyError(f"Object with ID {_id} not found")
+
+        def get_all_derived(cls):
+            nonlocal classes
+
+            def _recurse(cls):
+                result = set(cls.derived_ids)
+                for r in cls.derived_ids:
+                    result |= _recurse(classes.get(r))
+                return result
+
+            d = list(_recurse(cls))
+            d.sort()
+            return d
+
+        classes = ObjectList(model.classes)
+        concrete_classes = ObjectList(
+            list(c for c in model.classes if not c.is_abstract)
+        )
+        abstract_classes = ObjectList(list(c for c in model.classes if c.is_abstract))
+        enums = ObjectList(model.enums)
+
+        render_args = {
+            "classes": classes,
+            "concrete_classes": concrete_classes,
+            "abstract_classes": abstract_classes,
+            "enums": enums,
+            "context": model.context,
+            **self.get_additional_render_args(),
+        }
+
+        env = {
+            "get_all_derived": get_all_derived,
+            **self.get_extra_env(),
+        }
+
+        with self.__output.open() as f:
+            self.render(
+                self.__template,
+                f,
+                extra_env=env,
+                render_args=render_args,
+            )

shacl2code/lang/jinja.py

@@ -0,0 +1,29 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from pathlib import Path
+
+from .common import BasicJinjaRender
+from .lang import language
+
+
+@language("jinja")
+class JinjaRender(BasicJinjaRender):
+    HELP = "Render Jinja Output (for testing)"
+
+    def __init__(self, args):
+        super().__init__(args, args.template)
+
+    @classmethod
+    def get_arguments(cls, parser):
+        super().get_arguments(parser)
+
+        parser.add_argument(
+            "--template",
+            "-t",
+            type=Path,
+            help="Jinja Template file",
+            required=True,
+        )

shacl2code/lang/jsonschema.py

@@ -0,0 +1,51 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from .common import BasicJinjaRender
+from .lang import language, TEMPLATE_DIR
+
+import re
+import keyword
+
+
+def varname(*name):
+    name = str("_".join(name)).replace("@", "_")
+    name = re.sub(r"[^a-zA-Z0-9_]", "", name)
+    while keyword.iskeyword(name):
+        name = name + "_"
+    return name
+
+
+@language("jsonschema")
+class JsonSchemaRender(BasicJinjaRender):
+    HELP = "JSON Schema"
+
+    def __init__(self, args):
+        super().__init__(args, TEMPLATE_DIR / "jsonschema.j2")
+        self.__render_args = {
+            "schema_title": args.title,
+            "schema_id": args.id,
+            "allow_elided_lists": args.allow_elided_lists,
+        }
+
+    @classmethod
+    def get_arguments(cls, parser):
+        super().get_arguments(parser)
+
+        parser.add_argument("--title", help="Schema title")
+        parser.add_argument("--id", help="Schema ID")
+        parser.add_argument(
+            "--allow-elided-lists",
+            action="store_true",
+            help="Allow lists to be elided if they only contain a single element",
+        )
+
+    def get_extra_env(self):
+        return {
+            "varname": varname,
+        }
+
+    def get_additional_render_args(self):
+        return self.__render_args

shacl2code/lang/lang.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from pathlib import Path
+
+LANGUAGES = {}
+
+TEMPLATE_DIR = Path(__file__).parent / "templates"
+
+
+def language(name):
+    def inner(cls):
+        global LANGUAGES
+        LANGUAGES[name] = cls
+        return cls
+
+    return inner

shacl2code/lang/python.py

@@ -0,0 +1,54 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from .common import BasicJinjaRender
+from .lang import language, TEMPLATE_DIR
+
+import re
+import keyword
+
+
+def varname(*name):
+    name = "_".join(name)
+    # Any invalid characters at the beginning of the name are removed (except
+    # "@")
+    name = re.sub(r"^[^a-zA-Z0-9_@]*", "", name)
+    # Any other invalid characters are replaced with "_" (including "@")
+    name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+    # Consolidate runs of "_" to a single one
+    name = re.sub(r"__+", "_", name)
+    # Add a _ to anything that is a python keyword
+    while keyword.iskeyword(name):
+        name = name + "_"
+    return name
+
+
+@language("python")
+class PythonRender(BasicJinjaRender):
+    HELP = "Python Language Bindings"
+
+    def __init__(self, args):
+        super().__init__(args, TEMPLATE_DIR / "python.j2")
+        self.__render_args = {
+            "elide_lists": args.elide_lists,
+        }
+
+    @classmethod
+    def get_arguments(cls, parser):
+        super().get_arguments(parser)
+
+        parser.add_argument(
+            "--elide-lists",
+            action="store_true",
+            help="Elide lists when writing documents if they only contain a single item",
+        )
+
+    def get_extra_env(self):
+        return {
+            "varname": varname,
+        }
+
+    def get_additional_render_args(self):
+        return self.__render_args