shacl2code 0.0.12__tar.gz → 0.0.13__tar.gz

{shacl2code-0.0.12 → shacl2code-0.0.13}/.github/workflows/test.yaml

@@ -22,10 +22,15 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install build
+          npm install -g jsonld-cli
       - name: Build package
         run: |
           python -m build

{shacl2code-0.0.12 → shacl2code-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: shacl2code
-Version: 0.0.12
+Version: 0.0.13
 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
@@ -25,7 +25,6 @@ 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'
 Description-Content-Type: text/markdown
 

{shacl2code-0.0.12 → shacl2code-0.0.13}/pyproject.toml

@@ -31,7 +31,6 @@ dev = [
     "pyshacl >= 0.25.0",
     "pytest >= 7.4",
     "pytest-cov >= 4.1",
-    "pytest-server-fixtures >= 1.7",
 ]
 
 [project.urls]

shacl2code-0.0.13/src/shacl2code/context.py

@@ -0,0 +1,277 @@
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+import re
+from contextlib import contextmanager
+
+
+def foreach_context(contexts):
+    for ctx in contexts:
+        for name, value in ctx.items():
+            yield name, value
+
+
+class Context(object):
+    def __init__(self, contexts=[]):
+        self.contexts = [c for c in contexts if c]
+        self.__vocabs = []
+        self.__expanded_iris = {}
+        self.__expanded_ids = {}
+        self.__expanded_vocabs = {}
+        self.__compacted_iris = {}
+        self.__compacted_ids = {}
+        self.__compacted_vocabs = {}
+
+    @contextmanager
+    def vocab_push(self, vocab):
+        if not vocab:
+            yield self
+            return
+
+        self.__vocabs.append(vocab)
+        try:
+            yield self
+        finally:
+            self.__vocabs.pop()
+
+    def __vocab_key(self):
+        if not self.__vocabs:
+            return ""
+
+        return self.__vocabs[-1]
+
+    def __get_vocab_contexts(self):
+        contexts = []
+
+        for v in self.__vocabs:
+            for name, value in foreach_context(self.contexts):
+                if (
+                    isinstance(value, dict)
+                    and value["@type"] == "@vocab"
+                    and v == self.expand_iri(value["@id"])
+                ):
+                    if "@context" in value:
+                        contexts.insert(0, value["@context"])
+
+        contexts.extend(self.contexts)
+
+        return contexts
+
+    def __choose_possible(
+        self,
+        term,
+        default,
+        contexts,
+        *,
+        vocab=False,
+        base=False,
+        exact=False,
+        prefix=False,
+    ):
+        def remove_prefix(_id, value):
+            expanded_id = self.expand_iri(_id)
+            expanded_value = self.expand_iri(value)
+
+            possible = set()
+            if expanded_id.startswith(expanded_value):
+                tmp_id = _id[len(expanded_value) :]
+                possible.add(tmp_id)
+            return possible
+
+        def helper(term):
+            possible = set()
+            for name, value in foreach_context(contexts):
+                if name == "@vocab":
+                    if vocab:
+                        possible |= remove_prefix(term, value)
+                    continue
+
+                if name == "@base":
+                    if base:
+                        possible |= remove_prefix(term, value)
+                    continue
+
+                if isinstance(value, dict):
+                    value = value["@id"]
+
+                if term == self.expand_iri(value):
+                    if exact and name not in possible:
+                        possible.add(name)
+                        possible |= helper(name)
+                    continue
+
+                if not prefix:
+                    continue
+
+                if term.startswith(value) and value.endswith("/"):
+                    tmp_id = name + ":" + term[len(value) :].lstrip("/")
+                    if tmp_id not in possible:
+                        possible.add(tmp_id)
+                        possible |= helper(tmp_id)
+                    continue
+
+                if term.startswith(value + ":") and self.expand_iri(value).endswith(
+                    "/"
+                ):
+                    tmp_id = name + term[len(value) :]
+                    if tmp_id not in possible:
+                        possible.add(tmp_id)
+                        possible |= helper(tmp_id)
+                    continue
+
+            return possible
+
+        possible = helper(term)
+
+        if not possible:
+            return default
+
+        # 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 compact_iri(self, iri):
+        if iri not in self.__compacted_iris:
+            self.__compacted_iris[iri] = self.__choose_possible(
+                iri,
+                iri,
+                self.contexts,
+                exact=True,
+                prefix=True,
+            )
+
+        return self.__compacted_iris[iri]
+
+    def compact_id(self, _id):
+        if ":" not in _id:
+            return _id
+
+        if _id not in self.__compacted_ids:
+            self.__compacted_ids[_id] = self.__choose_possible(
+                _id,
+                _id,
+                self.contexts,
+                base=True,
+                prefix=True,
+            )
+
+        return self.__compacted_ids[_id]
+
+    def compact_vocab(self, term, vocab=None):
+        with self.vocab_push(vocab):
+            v = self.__vocab_key()
+            if v in self.__compacted_vocabs and term in self.__compacted_vocabs[v]:
+                return self.__compacted_vocabs[v][term]
+
+            compact = self.__choose_possible(
+                term,
+                None,
+                self.__get_vocab_contexts(),
+                vocab=True,
+                exact=True,
+            )
+            if compact is not None:
+                self.__compacted_vocabs.setdefault(v, {})[term] = self.compact_id(
+                    compact
+                )
+                return compact
+
+        # If unable to compact with a vocabulary, compact as an ID
+        return self.compact_id(term)
+
+    def expand_iri(self, iri):
+        if iri not in self.__expanded_iris:
+            self.__expanded_iris[iri] = self.__expand(
+                iri,
+                self.contexts,
+                exact=True,
+                prefix=True,
+            )
+
+        return self.__expanded_iris[iri]
+
+    def expand_id(self, _id):
+        if _id not in self.__expanded_ids:
+            self.__expanded_ids[_id] = self.__expand(
+                _id,
+                self.contexts,
+                base=True,
+                prefix=True,
+            )
+
+        return self.__expanded_ids[_id]
+
+    def expand_vocab(self, term, vocab=None):
+        with self.vocab_push(vocab):
+            v = self.__vocab_key()
+            if v not in self.__expanded_vocabs or term not in self.__expanded_vocabs[v]:
+                value = self.__expand(
+                    term,
+                    self.__get_vocab_contexts(),
+                    vocab=True,
+                    exact=True,
+                )
+                self.__expanded_vocabs.setdefault(v, {})[term] = self.expand_id(value)
+
+        return self.__expanded_vocabs[v][term]
+
+    def __expand(
+        self,
+        term,
+        contexts,
+        *,
+        base=False,
+        exact=False,
+        prefix=False,
+        vocab=False,
+    ):
+        def helper(term):
+            vocabs = []
+            bases = []
+            prefixes = []
+            exacts = []
+            is_short = not re.match(r"[^:]+:", term)
+
+            for name, value in foreach_context(contexts):
+                if name == "@vocab":
+                    if vocab and is_short:
+                        vocabs.append(helper(value))
+                    continue
+
+                if name == "@base":
+                    if base and is_short:
+                        bases.append(value)
+                    continue
+
+                if isinstance(value, dict):
+                    value = value["@id"]
+
+                if term == name:
+                    if exact:
+                        exacts.append(helper(value))
+                    continue
+
+                if prefix:
+                    prefixes.append(name)
+
+            for e in exacts:
+                return e
+
+            if ":" in term:
+                p, suffix = term.split(":", 1)
+                for name in prefixes:
+                    if p == name:
+                        p = self.expand_iri(p)
+                        if p.endswith("/"):
+                            return p + suffix
+
+            for value in vocabs + bases:
+                return value + term
+
+            return term
+
+        return helper(term)

{shacl2code-0.0.12 → shacl2code-0.0.13}/src/shacl2code/lang/common.py

@@ -114,6 +114,14 @@ class BasicJinjaRender(object):
             d.sort()
             return d
 
+        def get_all_named_individuals(cls):
+            ni = set(i._id for i in cls.named_individuals)
+
+            for d in get_all_derived(cls):
+                ni |= set(i._id for i in classes.get(d).named_individuals)
+
+            return ni
+
         classes = ObjectList(model.classes)
         concrete_classes = ObjectList(
             list(c for c in model.classes if not c.is_abstract)
@@ -132,6 +140,7 @@ class BasicJinjaRender(object):
 
         env = {
             "get_all_derived": get_all_derived,
+            "get_all_named_individuals": get_all_named_individuals,
             **self.get_extra_env(),
         }
 

{shacl2code-0.0.12 → shacl2code-0.0.13}/src/shacl2code/lang/templates/jsonschema.j2

@@ -69,7 +69,7 @@
                     {%- endif %}
                     "properties": {
                         "{{ class.id_property or "@id" }}": { "$ref": "#/$defs/{{ class.node_kind.split("#")[-1] }}" },
-                        "{{ context.compact("@type") }}": {
+                        "{{ context.compact_iri("@type") }}": {
                         {#- Abstract Extensible classes are weird; any type _except_ the specific class type is allowed #}
                         {%- if class.is_abstract and class.is_extensible %}
                             "allOf":  [
@@ -98,8 +98,8 @@
             {%- for d in get_all_derived(class) + [class._id] %}
                 {%- set ns.json_refs = ns.json_refs + ["#/$defs/" + varname(*classes.get(d).clsname)] %}
                 {%- for n in classes.get(d).named_individuals %}
-                    {%- if context.compact(n._id) != n._id %}
-                        {%- set ns.named_individuals = ns.named_individuals + [context.compact(n._id)] %}
+                    {%- if context.compact_iri(n._id) != n._id %}
+                        {%- set ns.named_individuals = ns.named_individuals + [context.compact_iri(n._id)] %}
                     {%- endif %}
                 {%- endfor %}
             {%- endfor %}
@@ -267,7 +267,7 @@
         "SHACLClass": {
             "type": "object",
             "properties": {
-                "{{ context.compact("@type") }}": {
+                "{{ context.compact_iri("@type") }}": {
                     "oneOf": [
                         { "$ref": "#/$defs/IRI" },
                         {
@@ -280,7 +280,7 @@
                     ]
                 }
             },
-            "required": ["{{ context.compact("@type") }}"]
+            "required": ["{{ context.compact_iri("@type") }}"]
         },
         "AnyClass": {
             "anyOf": [

{shacl2code-0.0.12 → shacl2code-0.0.13}/src/shacl2code/lang/templates/python.j2

@@ -220,13 +220,34 @@ class FloatProp(Property):
         return decoder.read_float()
 
 
-class ObjectProp(Property):
+class IRIProp(Property):
+    def __init__(self, context=[], *, pattern=None):
+        super().__init__(pattern=pattern)
+        self.context = context
+
+    def compact(self, value):
+        for iri, compact in self.context:
+            if value == iri:
+                return compact
+        return None
+
+    def expand(self, value):
+        for iri, compact in self.context:
+            if value == compact:
+                return iri
+        return None
+
+    def iri_values(self):
+        return (iri for iri, _ in self.context)
+
+
+class ObjectProp(IRIProp):
     """
     A scalar SHACL object property of a SHACL object
     """
 
-    def __init__(self, cls, required):
-        super().__init__()
+    def __init__(self, cls, required, context=[]):
+        super().__init__(context)
         self.cls = cls
         self.required = required
 
@@ -264,8 +285,7 @@ class ObjectProp(Property):
             raise ValueError("Object cannot be None")
 
         if isinstance(value, str):
-            value = _NI_ENCODE_CONTEXT.get(value, value)
-            encoder.write_iri(value)
+            encoder.write_iri(value, self.compact(value))
             return
 
         return value.encode(encoder, state)
@@ -275,7 +295,7 @@ class ObjectProp(Property):
         if iri is None:
             return self.cls.decode(decoder, objectset=objectset)
 
-        iri = _NI_DECODE_CONTEXT.get(iri, iri)
+        iri = self.expand(iri) or iri
 
         if objectset is None:
             return iri
@@ -445,36 +465,27 @@ class ListProp(Property):
         return ListProxy(self.prop, data=data)
 
 
-class EnumProp(Property):
+class EnumProp(IRIProp):
     VALID_TYPES = str
 
     def __init__(self, values, *, pattern=None):
-        super().__init__(pattern=pattern)
-        self.values = values
+        super().__init__(values, pattern=pattern)
 
     def validate(self, value):
         super().validate(value)
 
-        valid_values = (iri for iri, _ in self.values)
+        valid_values = self.iri_values()
         if value not in valid_values:
             raise ValueError(
                 f"'{value}' is not a valid value. Choose one of {' '.join(valid_values)}"
             )
 
     def encode(self, encoder, value, state):
-        for iri, compact in self.values:
-            if iri == value:
-                encoder.write_enum(value, self, compact)
-                return
-
-        encoder.write_enum(value, self)
+        encoder.write_enum(value, self, self.compact(value))
 
     def decode(self, decoder, *, objectset=None):
         v = decoder.read_enum(self)
-        for iri, compact in self.values:
-            if v == compact:
-                return iri
-        return v
+        return self.expand(v) or v
 
 
 class NodeKind(Enum):
@@ -1518,14 +1529,14 @@ class JSONLDDecoder(Decoder):
 
     def object_keys(self):
         for key in self.data.keys():
-            if key in ("@type", "{{ context.compact('@type') }}"):
+            if key in ("@type", "{{ context.compact_iri('@type') }}"):
                 continue
             if self.root and key == "@context":
                 continue
             yield key
 
     def read_object(self):
-        typ = self.__get_value("@type", "{{ context.compact('@type') }}")
+        typ = self.__get_value("@type", "{{ context.compact_iri('@type') }}")
         if typ is not None:
             return typ, self
 
@@ -1717,7 +1728,7 @@ class JSONLDEncoder(Encoder):
     @contextmanager
     def write_object(self, o, _id, needs_id):
         self.data = {
-            "{{ context.compact('@type') }}": o.COMPACT_TYPE or o.TYPE,
+            "{{ context.compact_iri('@type') }}": o.COMPACT_TYPE or o.TYPE,
         }
         if needs_id:
             self.data[o.ID_ALIAS or "@id"] = _id
@@ -1841,7 +1852,7 @@ class JSONLDInlineEncoder(Encoder):
         self._write_comma()
 
         self.write("{")
-        self.write_string("{{ context.compact('@type') }}")
+        self.write_string("{{ context.compact_iri('@type') }}")
         self.write(":")
         self.write_string(o.COMPACT_TYPE or o.TYPE)
         self.comma = True
@@ -1963,26 +1974,6 @@ CONTEXT_URLS = [
 {%- endfor %}
 ]
 
-_NI_ENCODE_CONTEXT = {
-{%- for class in classes %}
-{%- for member in class.named_individuals %}
-    {%- if context.compact(member._id) != member._id %}
-    "{{ member._id }}": "{{ context.compact(member._id) }}",
-    {%- endif %}
-{%- endfor %}
-{%- endfor %}
-}
-
-_NI_DECODE_CONTEXT = {
-{%- for class in classes %}
-{%- for member in class.named_individuals %}
-    {%- if context.compact(member._id) != member._id %}
-    "{{ context.compact(member._id) }}": "{{ member._id }}",
-    {%- endif %}
-{%- endfor %}
-{%- endfor %}
-}
-
 
 # CLASSES
 {%- for class in classes %}
@@ -1991,7 +1982,7 @@ _NI_DECODE_CONTEXT = {
 #{{ (" " + l).rstrip() }}
 {%- endfor %}
 {%- endif %}
-@register("{{ class._id }}"{%- if context.compact(class._id) != class._id %}, compact_type="{{ context.compact(class._id) }}"{%- endif %}, abstract={{ class.is_abstract }})
+@register("{{ class._id }}"{%- if context.compact_iri(class._id) != class._id %}, compact_type="{{ context.compact_iri(class._id) }}"{%- endif %}, abstract={{ class.is_abstract }})
 class {{ varname(*class.clsname) }}(
 {%- if class.is_extensible -%}
     SHACLExtensibleObject{{", "}}
@@ -2042,7 +2033,19 @@ class {{ varname(*class.clsname) }}(
                 {%- endfor %}
                 ])
             {%- elif prop.class_id -%}
-                ObjectProp({{ varname(*classes.get(prop.class_id).clsname) }}, {% if prop.min_count and not is_list %}True{% else %}False{% endif %})
+                {%- set ctx = [] %}
+                {%- for value in get_all_named_individuals(classes.get(prop.class_id)) %}
+                    {%- if context.compact_vocab(value, prop.path) != value %}
+                        {{- ctx.append((value, context.compact_vocab(value, prop.path))) or "" }}
+                    {%- endif %}
+                {%- endfor -%}
+                ObjectProp({{ varname(*classes.get(prop.class_id).clsname) }}, {% if prop.min_count and not is_list %}True{% else %}False{% endif %}{% if ctx %}, context=[
+                {%- for value, compact in ctx %}
+                    ("{{ value }}", "{{ compact }}"),
+                {%- endfor %}
+                ],
+                {%- endif -%}
+                )
             {%- else -%}
                 {% if not prop.datatype in DATATYPE_CLASSES -%}
                     {{ abort("Unknown data type " + prop.datatype) -}}

{shacl2code-0.0.12 → shacl2code-0.0.13}/src/shacl2code/model.py

@@ -280,7 +280,7 @@ class Model(object):
         """
         _id = str(_id)
         if _id not in self.compact_ids:
-            self.compact_ids[_id] = self.context.compact(_id)
+            self.compact_ids[_id] = self.context.compact_iri(_id)
 
         if self.compact_ids[_id] == _id and fallback is not None:
             return fallback

shacl2code-0.0.13/src/shacl2code/version.py

@@ -0,0 +1 @@
+VERSION = "0.0.13"

{shacl2code-0.0.12 → shacl2code-0.0.13}/tests/conftest.py

@@ -9,8 +9,8 @@ import pytest
 import shutil
 import subprocess
 import time
+from .http import HTTPTestServer
 
-from pytest_server_fixtures.http import SimpleHTTPTestServer
 from pathlib import Path
 
 THIS_FILE = Path(__file__)
@@ -21,19 +21,18 @@ MODEL_DIR = THIS_DIR / "data" / "model"
 
 @pytest.fixture
 def http_server():
-    with SimpleHTTPTestServer() as s:
+    with HTTPTestServer() as s:
         s.start()
         yield s
 
 
 @pytest.fixture(scope="session")
 def model_server():
-    with SimpleHTTPTestServer() as s:
-        root = Path(s.document_root)
+    with HTTPTestServer() as s:
         for p in MODEL_DIR.iterdir():
             if not p.is_file():
                 continue
-            shutil.copyfile(p, root / p.name)
+            shutil.copyfile(p, s.document_root / p.name)
         s.start()
         yield s.uri
 

{shacl2code-0.0.12 → shacl2code-0.0.13}/tests/data/context.j2

@@ -2,8 +2,8 @@
 Context: {{ url }}
 {% endfor -%}
 {% for enum in enums %}
-{{ enum._id }}: {{ context.compact(enum._id) }}
+{{ enum._id }}: {{ context.compact_iri(enum._id) }}
 {% endfor %}
 {% for class in classes %}
-{{ class._id }}: {{ context.compact(class._id) }}
+{{ class._id }}: {{ context.compact_iri(class._id) }}
 {% endfor %}