shacl2code 0.0.22__tar.gz → 0.0.24__tar.gz

{shacl2code-0.0.22 → shacl2code-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shacl2code
-Version: 0.0.22
+Version: 0.0.24
 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

{shacl2code-0.0.22 → shacl2code-0.0.24}/src/shacl2code/lang/templates/jsonschema.j2

@@ -34,24 +34,28 @@
     "required": ["@context"],
     {%- endif %}
 
-    "oneOf": [
-        {
-            "type": "object",
-            "properties": {
-                "@graph": {
-                    "description": "Top level container for JSON-LD objects",
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "$ref": "#/$defs/AnyClass",
-                        "unevaluatedProperties": false
-                    }
+    "if": {
+        "type": "object",
+        "required": ["@graph"]
+    },
+    "then": {
+        "type": "object",
+        "properties": {
+            "@graph": {
+                "description": "Top level container for JSON-LD objects",
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "$ref": "#/$defs/AnyClass",
+                    "unevaluatedProperties": false
                 }
-            },
-            "required": ["@graph"]
+            }
         },
-        { "$ref": "#/$defs/AnyClass" }
-    ],
+        "required": ["@graph"]
+    },
+    "else": {
+        "$ref": "#/$defs/AnyClass"
+    },
     "unevaluatedProperties": false,
 
     "$defs": {
@@ -61,39 +65,51 @@
         {#- @type tag #}
         {%- if not class.is_abstract or class.is_extensible %}
         "{{ varname(*class.clsname) }}": {
-            "allOf": [
-                {
-                    "type": "object",
-                    {%- if class.deprecated %}
-                    "deprecated": true,
-                    {%- endif %}
-                    {%- if class.is_extensible %}
-                    "unevaluatedProperties": true,
-                    {%- endif %}
-                    "properties": {
-                        "{{ class.id_property or "@id" }}": { "$ref": "#/$defs/{{ class.node_kind.split("#")[-1] }}" },
-                        "{{ 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" }}"]
+            "if": {
+                "type": "object",
+                "properties": {
+                    "{{ 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) }}" } }
+                        ]
+                    {%- elif class.is_extensible %}
+                        "anyOf": [
+                            { "$ref": "#/$defs/IRI" },
+                            { "const": "{{ context.compact_vocab(class._id) }}" }
+                        ]
+                    {%- else %}
+                        "const": "{{ context.compact_vocab(class._id) }}"
                     {%- endif %}
+                    }
                 },
-                { "$ref": "#/$defs/{{ varname(*class.clsname) }}_props" }
-            ]
+                "required": ["{{ context.compact_iri("@type") }}"]
+            },
+            "then": {
+                "allOf": [
+                    {
+                        "type": "object",
+                        {%- if class.deprecated %}
+                        "deprecated": true,
+                        {%- endif %}
+                        {%- if class.is_extensible %}
+                        "unevaluatedProperties": true,
+                        {%- endif %}
+                        "properties": {
+                            "{{ class.id_property or "@id" }}": { "$ref": "#/$defs/{{ class.node_kind.split("#")[-1] }}" },
+                            "{{ context.compact_iri("@type") }}": { "type": "string" }
+                        }{%- if class.node_kind == SH.IRI %},
+                        "required": ["{{ class.id_property or "@id" }}"]
+                        {%- endif %}
+                    },
+                    { "$ref": "#/$defs/{{ varname(*class.clsname) }}_props" }
+                ]
+            },
+            "else": {
+                "const": "Not a {{ varname(*class.clsname) }}"
+            }
         },
         {%- endif %}
         "{{ varname(*class.clsname) }}_derived": {
@@ -151,7 +167,7 @@
                         "{{ context.compact_vocab(prop.path) }}": {
                         {%- set prop_ref = "#/$defs/prop_" + varname(*class.clsname) + "_" + varname(prop.varname) %}
                         {%- if is_list %}
-                            "oneOf": [
+                            "anyOf": [
                                 {
                                     "type": "array",
                                     {%- if prop.max_count is not none %}
@@ -241,7 +257,7 @@
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#boolean" %}
                     "type": "boolean"
                 {%- elif prop.datatype == "http://www.w3.org/2001/XMLSchema#decimal" %}
-                    "oneOf": [
+                    "anyOf": [
                         {
                             "type": "number"
                         },
@@ -266,7 +282,7 @@
             "pattern": "^_:.+"
         },
         "BlankNodeOrIRI": {
-            "oneOf": [
+            "anyOf": [
                 { "$ref": "#/$defs/IRI" },
                 { "$ref": "#/$defs/BlankNode" }
             ]
@@ -278,7 +294,7 @@
             "type": "object",
             "properties": {
                 "{{ context.compact_iri("@type") }}": {
-                    "oneOf": [
+                    "anyOf": [
                         { "$ref": "#/$defs/IRI" },
                         {
                             "enum": [

{shacl2code-0.0.22 → shacl2code-0.0.24}/src/shacl2code/lang/templates/python.j2

@@ -33,8 +33,10 @@ from typing import (
     Set,
     Tuple,
     Type,
+    TypeVar,
     Union,
     cast,
+    overload,
 )
 
 
@@ -540,10 +542,9 @@ class EnumProp(IRIProp):
     def validate(self, value) -> None:
         super().validate(value)
 
-        valid_values = self.iri_values()
-        if value not in valid_values:
+        if value not in self.iri_values():
             raise ValueError(
-                f"'{value}' is not a valid value. Choose one of {' '.join(valid_values)}"
+                f"'{value}' is not a valid value. Choose one of {' '.join(self.iri_values())}"
             )
 
     def encode(self, encoder, value, state) -> None:
@@ -616,6 +617,7 @@ def register(
 
 register_lock = threading.Lock()
 NAMED_INDIVIDUALS: Set[str] = set()
+T_SHACLObject = TypeVar("T_SHACLObject", bound="SHACLObject")
 
 
 @functools.total_ordering
@@ -861,7 +863,7 @@ class SHACLObject(object):
         ) as obj_s:
             self._encode_properties(obj_s, state)
 
-    def _encode_properties(self, encoder, state):
+    def _encode_properties(self, encoder, state) -> None:
         for iri, prop, min_count, max_count, pyname, compact in self.__iter_props():
             value = self.__dict__["_obj_data"][iri]
             if prop.elide(value):
@@ -921,7 +923,9 @@ class SHACLObject(object):
 
         return obj
 
-    def _decode_properties(self, decoder, objectset: Optional[SHACLObjectSet] = None):
+    def _decode_properties(
+        self, decoder, objectset: Optional[SHACLObjectSet] = None
+    ) -> None:
         for key in decoder.object_keys():
             if not self._decode_prop(decoder, key, objectset=objectset):
                 raise KeyError(f"Unknown property '{key}'")
@@ -1019,7 +1023,9 @@ class SHACLExtensibleObject(SHACLObject):
         obj = cls(typ)
         return obj
 
-    def _decode_properties(self, decoder, objectset: Optional[SHACLObjectSet] = None):
+    def _decode_properties(
+        self, decoder, objectset: Optional[SHACLObjectSet] = None
+    ) -> None:
         def decode_value(d):
             if not d.is_list():
                 return d.read_value()
@@ -1042,7 +1048,7 @@ class SHACLExtensibleObject(SHACLObject):
             with decoder.read_property(key) as prop_d:
                 self.__dict__["_obj_data"][key] = decode_value(prop_d)
 
-    def _encode_properties(self, encoder, state):
+    def _encode_properties(self, encoder, state) -> None:
         super()._encode_properties(encoder, state)
         if self.CLOSED:
             return
@@ -1274,8 +1280,17 @@ class SHACLObjectSet(object):
             for child in o.iter_objects(recursive=True, visited=visited):
                 yield child
 
+    @overload
+    def foreach_type(
+        self, typ: str, *, match_subclass: bool = True
+    ) -> Iterator[SHACLObject]: ...
+    @overload
+    def foreach_type(
+        self, typ: Type[T_SHACLObject], *, match_subclass: bool = True
+    ) -> Iterator[T_SHACLObject]: ...
+
     def foreach_type(
-        self, typ: Union[str, SHACLObject], *, match_subclass: bool = True
+        self, typ: Union[str, Type[T_SHACLObject]], *, match_subclass: bool = True
     ) -> Iterable[SHACLObject]:
         """
         Iterate over each object of a specified type (or subclass there of)
@@ -1287,15 +1302,16 @@ class SHACLObjectSet(object):
         if not isinstance(typ, str):
             if not isinstance(typ, type) or not issubclass(typ, SHACLObject):
                 raise TypeError(f"Type must be derived from SHACLObject, got {typ}")
-            typ = cast(SHACLObject, typ)
-            typ = typ._OBJ_TYPE
+            # This intermediate step is necessary for pyrefly...
+            typ_class: Type[SHACLObject] = typ
+            typ = typ_class._OBJ_TYPE
 
         if typ not in self.obj_by_type:
             return
 
         for exact, o in self.obj_by_type[typ]:
             if match_subclass or exact:
-                yield o
+                yield cast(T_SHACLObject, o)
 
     def merge(self, *objectsets) -> "SHACLObjectSet":
         """

{shacl2code-0.0.22 → shacl2code-0.0.24}/src/shacl2code/model.py

@@ -5,7 +5,7 @@
 # SPDX-License-Identifier: MIT
 
 import typing
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from rdflib import URIRef
 from rdflib.namespace import RDF, RDFS, OWL, SH, XSD, DefinedNamespace, Namespace
@@ -68,7 +68,7 @@ class Property:
     comment: str = ""
     max_count: int = None
     min_count: int = None
-    enum_values: list = None
+    enum_values: list = field(default_factory=list)
     class_id: str = ""
     datatype: str = ""
     pattern: str = ""
@@ -206,24 +206,40 @@ class Model(object):
                             c.is_abstract = True
                     continue
 
-                p = Property(
-                    varname=self.model.value(
-                        obj_prop,
-                        SH.name,
-                        default=self.get_compact_id(
-                            prop,
-                            fallback=remove_common_prefix(prop, cls_iri).lstrip("/"),
-                        ),
+                varname = self.model.value(
+                    obj_prop,
+                    SH.name,
+                    default=self.get_compact_id(
+                        prop,
+                        fallback=remove_common_prefix(prop, cls_iri).lstrip("/"),
                     ),
-                    path=str(prop),
-                    comment=str(self.model.value(prop, RDFS.comment, default="")),
-                    max_count=int_val(self.model.value(obj_prop, SH.maxCount)),
-                    min_count=int_val(self.model.value(obj_prop, SH.minCount)),
-                    deprecated=(prop, RDF.type, OWL.DeprecatedProperty) in self.model,
                 )
 
+                for p in c.properties:
+                    if p.path == str(prop):
+                        break
+                else:
+                    p = Property(
+                        varname=varname,
+                        path=str(prop),
+                        comment=str(self.model.value(prop, RDFS.comment, default="")),
+                        deprecated=(prop, RDF.type, OWL.DeprecatedProperty)
+                        in self.model,
+                    )
+                    c.properties.append(p)
+
+                if varname < p.varname:
+                    p.varname = varname
+
+                if (v := int_val(self.model.value(obj_prop, SH.maxCount))) is not None:
+                    p.max_count = v
+
+                if (v := int_val(self.model.value(obj_prop, SH.minCount))) is not None:
+                    p.min_count = v
+
                 if in_list := self.model.value(obj_prop, SH["in"]):
-                    p.enum_values = sorted(tuple(self.model.items(in_list)))
+                    enum_values = set(p.enum_values) | set(self.model.items(in_list))
+                    p.enum_values = sorted(list(enum_values))
 
                 if range_id := self.model.value(obj_prop, SH["class"]):
                     if not set_prop_range(p, range_id):
@@ -252,8 +268,6 @@ class Model(object):
                         )
                     p.pattern = str(pattern)
 
-                c.properties.append(p)
-
             c.properties.sort(key=lambda p: p.path)
 
             self.classes.append(c)

shacl2code-0.0.24/src/shacl2code/version.py

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