shacl2code 0.0.5__tar.gz → 0.0.7__tar.gz

{shacl2code-0.0.5 → shacl2code-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: shacl2code
-Version: 0.0.5
+Version: 0.0.7
 Summary: Convert SHACL model file to code bindings
 Project-URL: Homepage, https://github.com/JPEWdev/shacl2code
 Project-URL: Repository, https://github.com/JPEWdev/shacl2code.git
@@ -18,10 +18,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Dist: jinja2>=3.1.2
-Requires-Dist: pyld>=2.0.3
+Requires-Dist: rdflib>=7.0.0
 Provides-Extra: dev
 Requires-Dist: flake8>=7.0.0; extra == 'dev'
 Requires-Dist: jsonschema>=4.21.1; extra == 'dev'
+Requires-Dist: pyshacl>=0.25.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1; extra == 'dev'
 Requires-Dist: pytest-server-fixtures>=1.7; extra == 'dev'
 Requires-Dist: pytest>=7.4; extra == 'dev'

{shacl2code-0.0.5 → shacl2code-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ description = "Convert SHACL model file to code bindings"
 dynamic = ["version"]
 dependencies = [
     "jinja2 >= 3.1.2",
-    "pyld >= 2.0.3",
+    "rdflib >= 7.0.0",
 ]
 required-python = ">= 3.8"
 authors = [
@@ -26,11 +26,12 @@ classifiers = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest >= 7.4",
-    "pytest-server-fixtures >= 1.7",
-    "pytest-cov >= 4.1",
     "flake8 >= 7.0.0",
     "jsonschema >= 4.21.1",
+    "pyshacl >= 0.25.0",
+    "pytest >= 7.4",
+    "pytest-cov >= 4.1",
+    "pytest-server-fixtures >= 1.7",
 ]
 
 [project.urls]

{shacl2code-0.0.5 → shacl2code-0.0.7}/src/shacl2code/context.py

@@ -40,30 +40,50 @@ class Context(object):
 
         return contexts
 
-    def compact(self, _id, vocab=None):
+    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]
 
-            if v not in self.__compacted or _id not in self.__compacted[v]:
-                self.__compacted.setdefault(v, {})[_id] = self.__compact(
-                    _id,
-                    self.__get_vocab_contexts() + self.contexts,
-                )
-            return self.__compacted[v][_id]
+            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 __compact(self, _id, contexts):
         def collect_possible(_id):
             possible = set()
             for ctx in contexts:
                 for name, value in ctx.items():
                     if name == "@vocab":
-                        if _id.startswith(value):
-                            tmp_id = _id[len(value) :]
-                            possible.add(tmp_id)
-                            possible |= collect_possible(tmp_id)
+                        if apply_vocabs:
+                            possible |= remove_prefix(_id, value)
+                    elif name == "@base":
+                        possible |= remove_prefix(_id, value)
                     else:
                         if isinstance(value, dict):
                             value = value["@id"]
@@ -90,14 +110,14 @@ class Context(object):
 
         return possible[0]
 
-    def expand(self, _id, vocab=""):
-        with self.vocab_push(vocab):
-            if not self.__vocabs:
-                v = ""
-            else:
-                v = self.__vocabs[-1]
+    def is_relative(self, _id):
+        import re
+
+        return not re.match(r"[^:]+:", _id)
 
-            if v not in self.__expanded or _id not in self.__expanded[v]:
+    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
@@ -105,10 +125,29 @@ class Context(object):
                     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)
 
-                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.__expanded[v][_id]
+            return self.__expand_contexts(_id, v, True)
 
     def __expand(self, _id, contexts):
         for ctx in contexts:

{shacl2code-0.0.5 → shacl2code-0.0.7}/src/shacl2code/lang/common.py

@@ -8,6 +8,8 @@ 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
 
@@ -57,10 +59,26 @@ class BasicJinjaRender(object):
     def get_additional_render_args(self):
         return {}
 
+    def get_extra_env(self):
+        return {}
+
     def output(self, model):
         def abort_helper(msg):
             raise TemplateRuntimeError(msg)
 
+        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
+
         class ObjectList(object):
             def __init__(self, objs):
                 self.__objs = objs
@@ -77,13 +95,21 @@ class BasicJinjaRender(object):
         env = Environment(
             loader=FileSystemLoader([self.__template.parent, THIS_DIR.parent])
         )
+        for k, v in self.get_extra_env().items():
+            env.globals[k] = v
         env.globals["abort"] = abort_helper
+        env.globals["get_all_derived"] = get_all_derived
+        env.globals["SHACL2CODE"] = SHACL2CODE
+        env.globals["SH"] = SH
         template = env.get_template(self.__template.name)
 
+        classes = ObjectList(model.classes)
+        enums = ObjectList(model.enums)
+
         render = template.render(
             disclaimer=f"This file was automatically generated by {os.path.basename(sys.argv[0])}. DO NOT MANUALLY MODIFY IT",
-            enums=ObjectList(model.enums),
-            classes=ObjectList(model.classes),
+            enums=enums,
+            classes=classes,
             context=model.context,
             **self.get_additional_render_args(),
         )

shacl2code-0.0.7/src/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(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-0.0.7/src/shacl2code/lang/python.py

@@ -0,0 +1,53 @@
+#
+# 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):
+    # 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

{shacl2code-0.0.5 → shacl2code-0.0.7}/src/shacl2code/lang/templates/jsonschema.j2

@@ -57,34 +57,56 @@
         {#- Classes are divided into 2 parts. The properties are separated into a separate object #}
         {#- so that a object can references the properties of its parent without needing the const #}
         {#- @type tag #}
-        "{{ class.clsname }}": {
+        "{{ varname(class.clsname) }}": {
             "allOf": [
                 {
-                    "type": "object",
                     "properties": {
-                        "{{ context.compact("@id") }}": { "$ref": "#/$defs/idRef" },
-                        "{{ context.compact("@type") }}": { "const": "{{ context.compact(class._id) }}" }
-                    },
-                    "required": ["{{ context.compact("@type") }}"]
+                        "{{ class.id_property or "@id" }}": { "$ref": "#/$defs/{{ class.node_kind.split("#")[-1] }}" },
+                        "{{ context.compact("@type") }}": { "const": "{{ context.compact_vocab(class._id) }}" }
+                    }{%- if class.node_kind == SH.IRI %},
+                    "required": ["{{ class.id_property or "@id" }}"]
+                    {%- endif %}
                 },
-                { "$ref": "#/$defs/{{ class.clsname }}_props" }
+                { "$ref": "#/$defs/{{ varname(class.clsname) }}_props" }
             ]
         },
-        "{{ class.clsname }}_props": {
+        "{{ varname(class.clsname) }}_derived": {
+            {%- set ns = namespace(external_ref=False, local_ref=False, any_ref=False, json_refs=[]) %}
+            {%- for d in get_all_derived(class) + [class._id] %}
+                {%- set ns.json_refs = ns.json_refs + ["#/$defs/" + varname(classes.get(d).clsname)] %}
+            {%- endfor %}
+            {%- set ns.json_refs = ns.json_refs + ["#/$defs/BlankNodeOrIRI"] %}
+
+            {%- if ns.json_refs | length == 1 %}
+            "$ref": "{{ ns.json_refs[0] }}",
+            {%- elif ns.json_refs %}
+            "oneOf": [
+                {%- for r in ns.json_refs %}
+                { "$ref": "{{ r }}" }{% if not loop.last %},{% endif %}
+                {%- endfor %}
+            ],
+            {%- endif %}
+            "unevaluatedProperties": false
+        },
+        "{{ varname(class.clsname) }}_props": {
             "allOf": [
+                {%- if class.parent_ids %}
                 {%- for parent in class.parent_ids %}
-                { "$ref": "#/$defs/{{ classes.get(parent).clsname }}_props" },
+                { "$ref": "#/$defs/{{ varname(classes.get(parent).clsname) }}_props" },
                 {%- endfor %}
+                {%- else %}
+                { "$ref": "#/$defs/SHACLClass" },
+                {%- endif %}
                 {%- set required = [] %}
                 {
-                    "type": "object",
                     "properties": {
                         {%- for prop in class.properties %}
                         {%- if not prop.min_count is none and prop.min_count > 0 %}
                             {{- required.append(prop.path) or "" }}
                         {%- endif %}
                         {%- set is_list = prop.max_count is none or prop.max_count != 1 %}
-                        "{{ context.compact(prop.path) }}": {
+                        "{{ context.compact_vocab(prop.path) }}": {
+                        {%- set prop_ref = "#/$defs/prop_" + varname(class.clsname) + "_" + varname(prop.varname) %}
                         {%- if is_list %}
                             "oneOf": [
                                 {
@@ -96,22 +118,23 @@
                                     "minItems": {{ prop.min_count }},
                                     {%- endif %}
                                     "items": {
-                                        "$ref": "#/$defs/{{ prop.path | replace("/", "_") }}"
+                                        "$ref": "{{ prop_ref }}"
                                     }
-                                },
+                                }{% if allow_elided_lists %},
                                 {
-                        {%- endif %}
-                                    "$ref": "#/$defs/{{ prop.path | replace("/", "_") }}"
-                        {%- if is_list %}
+                                    "$ref": "{{ prop_ref }}"
                                 }
+                                {%- endif %}
                             ]
+                        {%- else %}
+                            "$ref": "{{ prop_ref }}"
                         {%- endif %}
                         }{% if not loop.last %},{% endif %}
                         {%- endfor %}
                     }{% if required %},
                     "required": [
                         {%- for r in required %}
-                        "{{ context.compact(r) }}"{% if not loop.last %},{% endif %}
+                        "{{ context.compact_vocab(r) }}"{% if not loop.last %},{% endif %}
                         {%- endfor %}
                     ]
                     {%- endif %}
@@ -119,43 +142,68 @@
             ]
         },
         {%- for prop in class.properties %}
-        "{{ prop.path | replace("/", "_") }}": {
+        "prop_{{ varname(class.clsname) }}_{{ varname(prop.varname) }}": {
             {%- if prop.class_id %}
-                "oneOf": [
-                    { "$ref": "#/$defs/idRef" },
-                    {
-                        "$ref": "#/$defs/{{ classes.get(prop.class_id).clsname }}",
-                        "unevaluatedProperties": false
-                    }
-                ]
+                "$ref": "#/$defs/{{ varname(classes.get(prop.class_id).clsname) }}_derived"
             {%- elif prop.enum_id %}
                 "enum": [
                 {%- for e in enums.get(prop.enum_id).values %}
-                    "{{ context.compact(e._id, prop.path) }}"{% if not loop.last %},{% endif %}
+                    "{{ context.compact_vocab(e._id, prop.path) }}"{% if not loop.last %},{% endif %}
                 {%- endfor %}
                 ]
             {%- else %}
                 {%- if prop.datatype == "http://www.w3.org/2001/XMLSchema#string" %}
+                    {%- if prop.pattern %}
+                    "pattern": "{{ prop.pattern | replace("\\", "\\\\") }}",
+                    {%- endif %}
                     "type": "string"
+                {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#dateTime" %}
+                    "type": "string",
+                    "allOf": [
+                        {
+                            "pattern": "^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](Z|[+-][0-9]{2}:[0-9]{2})?$"
+                        }{%- if prop.pattern %},
+                        {
+                            "pattern": "{{ prop.pattern | replace("\\", "\\\\") }}"
+                        }
+                        {%- endif %}
+                    ]
+                {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#dateTimeStamp" %}
+                    "type": "string",
+                    "allOf": [
+                        {
+                            "pattern": "^[0-9]{4}-[0-1][0-9]-[0-3][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](Z|[+-][0-9]{2}:[0-9]{2})$"
+                        }{%- if prop.pattern %},
+                        {
+                            "pattern": "{{ prop.pattern | replace("\\", "\\\\") }}"
+                        }
+                        {%- endif %}
+                    ]
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#anyURI" %}
+                    {%- if prop.pattern %}
+                    "pattern": "{{ prop.pattern | replace("\\", "\\\\") }}",
+                    {%- endif %}
                     "$ref": "#/$defs/anyURI"
-                {%- elif prop.datatype == "https://spdx.org/rdf/v3/Core/DateTime" %}
-                    "$ref": "#/$defs/DateTime"
-                {%- elif prop.datatype == "https://spdx.org/rdf/v3/Core/MediaType" %}
-                    "$ref": "#/$defs/MediaType"
-                {%- elif prop.datatype == "https://spdx.org/rdf/v3/Core/SemVer" %}
-                    "$ref": "#/$defs/SemVer"
-                {%- elif prop.datatype == "https://spdx.org/rdf/v3/Core/Extension" %}
-                    "$ref": "#/$defs/Extension"
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#positiveInteger" %}
                     "type": "integer",
-                    "minimum": 0
+                    "minimum": 1
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#nonNegativeInteger" %}
+                    "type": "integer",
+                    "minimum": 0
+                {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#integer" %}
                     "type": "integer"
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#boolean" %}
                     "type": "boolean"
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#decimal" %}
-                    "type": "number"
+                    "oneOf": [
+                        {
+                            "type": "number"
+                        },
+                        {
+                            "type": "string",
+                            "pattern": "^-?[0-9]+(\\.[0-9]*)?$"
+                        }
+                    ]
                 {%- else %}
                     {{- abort("Unknown data type " + prop.datatype) }}
                 {%- endif %}
@@ -163,8 +211,19 @@
         },
         {%- endfor %}
     {%- endfor %}
-        "idRef": {
-            "type": "string"
+        "IRI": {
+            "type": "string",
+            "pattern": "^(?!_:).*"
+        },
+        "BlankNode": {
+            "type": "string",
+            "pattern": "^_:.*"
+        },
+        "BlankNodeOrIRI": {
+            "oneOf": [
+                { "$ref": "#/$defs/IRI" },
+                { "$ref": "#/$defs/BlankNode" }
+            ]
         },
         "anyURI": {
             "type": "string"
@@ -181,10 +240,23 @@
         "Extension": {
             "type": "string"
         },
+        "SHACLClass": {
+            "type": "object",
+            "properties": {
+                "{{ context.compact("@type") }}": {
+                    "enum": [
+                    {%- for class in classes %}
+                        "{{ context.compact_vocab(class._id) }}"{% if not loop.last %},{% endif %}
+                    {%- endfor %}
+                    ]
+                }
+            },
+            "required": ["{{ context.compact("@type") }}"]
+        },
         "AnyClass": {
             "oneOf": [
                 {%- for class in classes %}
-                { "$ref": "#/$defs/{{ class.clsname }}" }{% if not loop.last %},{% endif %}
+                { "$ref": "#/$defs/{{ varname(class.clsname) }}" }{% if not loop.last %},{% endif %}
                 {%- endfor %}
             ]
         }