shacl2code 0.0.11__tar.gz → 0.0.13__tar.gz

{shacl2code-0.0.11 → 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.11 → shacl2code-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: shacl2code
-Version: 0.0.11
+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.11 → 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.11 → 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.11 → shacl2code-0.0.13}/src/shacl2code/lang/templates/jsonschema.j2

@@ -59,7 +59,7 @@
         {#- 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 #}
-        {%- if not class.is_abstract %}
+        {%- if not class.is_abstract or class.is_extensible %}
         "{{ varname(*class.clsname) }}": {
             "allOf": [
                 {
@@ -69,13 +69,21 @@
                     {%- 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":  [
+                                { "$ref": "#/$defs/IRI" },
+                                { "not": { "const": "{{ context.compact_vocab(class._id) }}" } }
+                            ]
+                        {%- else %}
                             "oneOf": [
                                 {%- if class.is_extensible %}
                                 { "$ref": "#/$defs/IRI" },
                                 {%- endif %}
                                 { "const": "{{ context.compact_vocab(class._id) }}" }
                             ]
+                        {%- endif %}
                         }
                     }{%- if class.node_kind == SH.IRI %},
                     "required": ["{{ class.id_property or "@id" }}"]
@@ -86,9 +94,14 @@
         },
         {%- endif %}
         "{{ varname(*class.clsname) }}_derived": {
-            {%- set ns = namespace(external_ref=False, local_ref=False, any_ref=False, json_refs=[]) %}
+            {%- set ns = namespace(json_refs=[], named_individuals=[]) %}
             {%- 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_iri(n._id) != n._id %}
+                        {%- set ns.named_individuals = ns.named_individuals + [context.compact_iri(n._id)] %}
+                    {%- endif %}
+                {%- endfor %}
             {%- endfor %}
             "anyOf": [
                 {%- if ns.json_refs %}
@@ -104,6 +117,9 @@
                     ]
                 },
                 {%- endif %}
+                {%- for n in ns.named_individuals %}
+                { "const": "{{ n }}" },
+                {%- endfor %}
                 { "$ref": "#/$defs/BlankNodeOrIRI" }
             ]
         },
@@ -251,7 +267,7 @@
         "SHACLClass": {
             "type": "object",
             "properties": {
-                "{{ context.compact("@type") }}": {
+                "{{ context.compact_iri("@type") }}": {
                     "oneOf": [
                         { "$ref": "#/$defs/IRI" },
                         {
@@ -264,7 +280,7 @@
                     ]
                 }
             },
-            "required": ["{{ context.compact("@type") }}"]
+            "required": ["{{ context.compact_iri("@type") }}"]
         },
         "AnyClass": {
             "anyOf": [

{shacl2code-0.0.11 → 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,7 +285,7 @@ class ObjectProp(Property):
             raise ValueError("Object cannot be None")
 
         if isinstance(value, str):
-            encoder.write_iri(value)
+            encoder.write_iri(value, self.compact(value))
             return
 
         return value.encode(encoder, state)
@@ -274,6 +295,8 @@ class ObjectProp(Property):
         if iri is None:
             return self.cls.decode(decoder, objectset=objectset)
 
+        iri = self.expand(iri) or iri
+
         if objectset is None:
             return iri
 
@@ -442,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):
@@ -506,6 +520,8 @@ def register(type_iri, *, compact_type=None, abstract=False):
         SHACLObject.CLASSES[key] = c
 
     def decorator(c):
+        global NAMED_INDIVIDUALS
+
         assert issubclass(
             c, SHACLObject
         ), f"{c.__name__} is not derived from SHACLObject"
@@ -518,6 +534,8 @@ def register(type_iri, *, compact_type=None, abstract=False):
         if compact_type:
             add_class(compact_type, c)
 
+        NAMED_INDIVIDUALS |= set(c.NAMED_INDIVIDUALS.values())
+
         # Registration is deferred until the first instance of class is created
         # so that it has access to any other defined class
         c._NEEDS_REG = True
@@ -527,6 +545,7 @@ def register(type_iri, *, compact_type=None, abstract=False):
 
 
 register_lock = threading.Lock()
+NAMED_INDIVIDUALS = set()
 
 
 @functools.total_ordering
@@ -537,7 +556,7 @@ class SHACLObject(object):
     IS_ABSTRACT = True
 
     def __init__(self, **kwargs):
-        if self.__class__.IS_ABSTRACT:
+        if self._is_abstract():
             raise NotImplementedError(
                 f"{self.__class__.__name__} is abstract and cannot be implemented"
             )
@@ -559,6 +578,9 @@ class SHACLObject(object):
         for k, v in kwargs.items():
             setattr(self, k, v)
 
+    def _is_abstract(self):
+        return self.__class__.IS_ABSTRACT
+
     @classmethod
     def _register_props(cls):
         cls._add_property("_id", StringProp(), iri="@id")
@@ -875,11 +897,20 @@ class SHACLExtensibleObject(object):
     CLOSED = False
 
     def __init__(self, typ=None, **kwargs):
-        super().__init__(**kwargs)
         if typ:
             self.__dict__["_obj_TYPE"] = (typ, None)
         else:
             self.__dict__["_obj_TYPE"] = (self._OBJ_TYPE, self._OBJ_COMPACT_TYPE)
+        super().__init__(**kwargs)
+
+    def _is_abstract(self):
+        # Unknown classes are assumed to not be abstract so that they can be
+        # deserialized
+        typ = self.__dict__["_obj_TYPE"][0]
+        if typ in self.__class__.CLASSES:
+            return self.__class__.CLASSES[typ].IS_ABSTRACT
+
+        return False
 
     @classmethod
     def _make_object(cls, typ):
@@ -1079,6 +1110,8 @@ class SHACLObjectSet(object):
         return self._link()
 
     def _link(self):
+        global NAMED_INDIVIDUALS
+
         self.missing_ids = set()
         visited = set()
 
@@ -1101,6 +1134,9 @@ class SHACLObjectSet(object):
                 obj_by_id[_id] = obj
         self.obj_by_id = obj_by_id
 
+        # Named individuals aren't considered missing
+        self.missing_ids -= NAMED_INDIVIDUALS
+
         return self.missing_ids
 
     def find_by_id(self, _id, default=None):
@@ -1493,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
 
@@ -1692,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
@@ -1816,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
@@ -1946,7 +1982,7 @@ CONTEXT_URLS = [
 #{{ (" " + 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{{", "}}
@@ -1997,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.11 → 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"