oldaplib 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

oldaplib/src/project.py

@@ -110,7 +110,7 @@ class Project(Model):
     #_attributes: dict[ProjectAttr, ProjectAttrTypes]
     #__changeset: dict[ProjectAttr, ProjectAttrChange]
 
-    __slots__ = ('projectIri', 'projectShortName', 'label', 'comment', 'namespaceIri', 'projectStart', 'projectEnd', 'usesExternalOntology')
+    __slots__ = ('projectIri', 'projectShortName', 'label', 'comment', 'namespaceIri', 'projectStart', 'projectEnd')
 
     def __init__(self, *,
                  con: IConnection,
@@ -176,8 +176,6 @@ class Project(Model):
                 partial(Project._get_value, attr=attr),
                 partial(Project._set_value, attr=attr),
                 partial(Project._del_value, attr=attr)))
-        if self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
-            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].set_on_change(self.eo_notify)
         self._changeset = {}
 
     def update_notifier(self):
@@ -185,10 +183,6 @@ class Project(Model):
             if getattr(value, 'set_notifier', None) is not None:
                 value.set_notifier(self.notifier, attr)
 
-    def eo_notify(self, d: ObservableDict):
-        if not self._changeset.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
-            self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
-
     def _as_dict(self):
         return {x.fragment: y for x, y in self._attributes.items()} | super()._as_dict()
 
@@ -239,29 +233,6 @@ class Project(Model):
         """
         self._changeset[attr] = AttributeChange(self._attributes[attr], Action.MODIFY)
 
-    def add_external_ontology(self, ontos: dict[Xsd_NCName, NamespaceIRI]):
-        """
-        Adds external ontologies to the project.
-        :param dict[Xsd_NCName, NamespaceIRI]: Dictionary of external ontologies to add
-        :return: None
-        """
-        if not ontos:
-            return
-        if not self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
-            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = ObservableDict()
-        for prefix, iri in ontos.items():
-            if not self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY]:
-                self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
-            self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY][prefix] = iri
-
-    def del_external_ontology(self, ontos: list[Xsd_NCName]):
-        if not ontos:
-            return
-        if not self._attributes.get(ProjectAttr.USES_EXTERNAL_ONTOLOGY):
-            raise OldapErrorInconsistency(f'Project {self} has no external ontologies.')
-        for prefix in ontos:
-            if not self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY]:
-                self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY] = AttributeChange(self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].copy(), Action.MODIFY)
 
 
     @classmethod
@@ -355,7 +326,6 @@ class Project(Model):
         comment = LangString()
         projectStart = None
         projectEnd = None
-        usesExternalOntology: dict[Xsd_QName, NamespaceIRI] | None = None
         for r in res:
             if projectIri is None:
                 projectIri = r['proj']
@@ -380,15 +350,11 @@ class Project(Model):
                     projectStart = r['val']
                 case 'oldap:projectEnd':
                     projectEnd = r['val']
-                case 'oldap:usesExternalOntology':
-                    if not usesExternalOntology:
-                        usesExternalOntology = {}
-                    usesExternalOntology[r['prefix']] = NamespaceIRI(r['iri'])
         if label:
-            label.changeset_clear()
+            label.clear_changeset()
             label.set_notifier(cls.notifier, Xsd_QName(ProjectAttr.LABEL.value))
         if comment:
-            comment.changeset_clear()
+            comment.clear_changeset()
             comment.set_notifier(cls.notifier, Xsd_QName(ProjectAttr.COMMENT.value))
         context[projectShortName] = namespaceIri
         instance = cls(con=con,
@@ -402,8 +368,7 @@ class Project(Model):
                        namespaceIri=namespaceIri,
                        comment=comment,
                        projectStart=projectStart,
-                       projectEnd=projectEnd,
-                       usesExternalOntology=usesExternalOntology)
+                       projectEnd=projectEnd)
         cache = CacheSingletonRedis()
         cache.set(instance.projectIri, instance, instance.projectShortName)
         return instance
@@ -499,6 +464,17 @@ class Project(Model):
 
         context = Context(name=self._con.context_name)
 
+        sparql0 = context.sparql_context
+        sparql0 += f"""
+        ASK {{
+            GRAPH oldap:admin {{
+    	        ?p a oldap:Project ;
+    		        oldap:projectShortName ?sname .
+    	        FILTER(?sname = {self.projectShortName.toRdf})
+	        }}
+        }}
+        """
+
         sparql1 = context.sparql_context
         sparql1 += f"""
         SELECT ?project
@@ -508,6 +484,23 @@ class Project(Model):
             FILTER(?project = {self.projectIri.toRdf})
         }}
         """
+        sparql1a = context.sparql_context
+        sparql1a += f"""
+        ASK {{
+            GRAPH oldap:admin {{
+                ?project oldap:namespaceIri {self.namespaceIri.toRdf} .
+            }}
+        }}
+        """
+
+        sparql1b = context.sparql_context
+        sparql1b += f"""
+        ASK {{
+            GRAPH oldap:admin {{
+                {self.projectIri.toRdf} ?p ?o .
+            }}
+        }}
+        """
 
         blank = ''
         sparql2 = context.sparql_context
@@ -521,21 +514,25 @@ class Project(Model):
         for attr, value in self._attributes.items():
             if not value:
                 continue
-            if attr == ProjectAttr.USES_EXTERNAL_ONTOLOGY:
-                for prefix, iri in value.items():
-                    sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}oldap:usesExternalOntology [ oldap:prefix {prefix.toRdf} ; oldap:fullIri {iri.toRdf} ]'
-                pass
-            else:
-                sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}{attr.value.toRdf} {value.toRdf}'
+            sparql2 += f' ;\n{blank:{(indent + 3) * indent_inc}}{attr.value.toRdf} {value.toRdf}'
         sparql2 += f' .\n{blank:{(indent + 1) * indent_inc}}}}\n'
         sparql2 += f'{blank:{indent * indent_inc}}}}\n'
 
         self._con.transaction_start()
-        jsonobj = self.safe_query(sparql1)
-        res = QueryProcessor(context, jsonobj)
-        if len(res) > 0:
+        result = self.safe_query(sparql0)
+        if result['boolean']:
             self._con.transaction_abort()
-            raise OldapErrorAlreadyExists(f'A Project with a projectIri "{self.projectIri}" already exists')
+            raise OldapErrorAlreadyExists(f'A Project with a shortname "{self.projectShortName}" already exists.')
+
+        result = self.safe_query(sparql1a)
+        if result['boolean']:
+            self._con.transaction_abort()
+            raise OldapErrorAlreadyExists(f'A Project with a namespace IRI "{self.namespaceIri}" already exists.')
+
+        result = self.safe_query(sparql1b)
+        if result['boolean']:
+            self._con.transaction_abort()
+            raise OldapErrorAlreadyExists(f'A Project with a project IRI "{self.projectIri}" already exists.')
 
         self.safe_update(sparql2)
         self.safe_commit()
@@ -607,70 +604,7 @@ class Project(Model):
                                                             field=Xsd_QName(field.value))
                     sparql_list.append(sparql)
                 continue
-            if field == ProjectAttr.USES_EXTERNAL_ONTOLOGY:
-                if change.action == Action.MODIFY:
-                    diff = dict_diff(self._changeset[ProjectAttr.USES_EXTERNAL_ONTOLOGY].old_value, self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY])
-                    #
-                    # first we remove the "removed" and "changed"
-                    #
-                    to_delete = set(diff['removed']) | set(diff['changed'])
-                    for key in to_delete:
-                        sparql = f"""
-                        DELETE {{
-                            GRAPH oldap:admin {{
-                                {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
-                                ?o ?p ?v .
-                            }}
-                        }}
-                        WHERE {{
-                            GRAPH oldap:admin {{
-                                ?o oldap:prefix {key.toRdf} .
-                                ?o oldap:fullIri ?anyiri .
-                            }}
-                        }}
-                        """
-                        sparql_list.append(sparql)
-                    to_add = set(diff['added']) | set(diff['changed'])
-                    sparql = f"""
-                    INSERT DATA {{
-                        GRAPH oldap:admin {{
-                    """
-                    for key in to_add:
-                        sparql += f"   {self.projectIri.toRdf} oldap:usesExternalOntology  [ oldap:prefix {key.toRdf} ; oldap:fullIri {self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY][key].toRdf} ] .\n"
-                    sparql += f"""
-                        }}
-                    }}
-                    """
-                    sparql_list.append(sparql)
-                if change.action == Action.DELETE:
-                    sparql = f"""
-                    DELETE {{
-                        GRAPH oldap:admin {{
-                            {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
-                            ?o ?p ?v .
-                        }}
-                    }}
-                    WHERE {{
-                        GRAPH oldap:admin {{
-                            {self.projectIri.toRdf} oldap:usesExternalOntology ?o .
-                            ?o ?p ?v .
-                        }}
-                    }}
-                    """
-                    sparql_list.append(sparql)
-                if change.action == Action.CREATE:
-                    sparql = f"""
-                    INSERT DATA {{
-                        GRAPH oldap:admin {{
-                    """
-                    for prefix, iri in self._attributes[ProjectAttr.USES_EXTERNAL_ONTOLOGY].items():
-                        sparql += f"   {self.projectIri.toRdf} oldap:usesExternalOntology  [ oldap:prefix {prefix.toRdf} ; oldap:fullIri {iri.toRdf} ] .\n"
-                    sparql += f"""
-                        }}
-                    }}
-                    """
-                    sparql_list.append(sparql)
-                continue
+
             sparql = f'{blank:{indent * indent_inc}}# Project field "{field.value}" with action "{change.action.value}"\n'
             if change.action != Action.CREATE:
                 sparql += f'{blank:{indent * indent_inc}}DELETE {{\n'

oldaplib/src/propertyclass.py

@@ -22,6 +22,7 @@ from pprint import pprint
 from typing import Callable, Self, Any
 
 from oldaplib.src.helpers.irincname import IriOrNCName
+from oldaplib.src.helpers.observable_set import ObservableSet
 from oldaplib.src.helpers.serializer import serializer
 from oldaplib.src.oldaplogging import get_logger
 from oldaplib.src.cachesingleton import CacheSingletonRedis
@@ -312,15 +313,16 @@ class PropertyClass(Model, Notify):
             raise OldapErrorInconsistency(f'It\'s not possible to use both DATATYPE="{self._attributes[PropClassAttr.DATATYPE]}" and CLASS={self._attributes[PropClassAttr.CLASS]} restrictions.')
 
         # setting property type for OWL which distinguished between Data- and Object-properties
+        if not self._attributes.get(PropClassAttr.TYPE):
+            self._attributes[PropClassAttr.TYPE] = ObservableSet(notifier=self.notifier, notify_data=PropClassAttr.TYPE)
         if self._statementProperty:
-            self._attributes[PropClassAttr.TYPE] = OwlPropertyType.StatementProperty
-        else:
-            if self._attributes.get(PropClassAttr.CLASS) is not None:
-                self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlObjectProperty
-                if self._attributes.get(PropClassAttr.DATATYPE) is not None:
-                    raise OldapError(f'Datatype "{self._attributes.get(PropClassAttr.DATATYPE)}" not possible for OwlObjectProperty')
-            elif self._attributes.get(PropClassAttr.DATATYPE) is not None:
-                self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlDataProperty
+            self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.StatementProperty)
+        if self._attributes.get(PropClassAttr.CLASS) is not None:
+            self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlObjectProperty)
+            if self._attributes.get(PropClassAttr.DATATYPE) is not None:
+                raise OldapError(f'Datatype "{self._attributes.get(PropClassAttr.DATATYPE)}" not possible for OwlObjectProperty')
+        elif self._attributes.get(PropClassAttr.DATATYPE) is not None:
+            self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlDataProperty)
 
         #
         # set the class properties
@@ -344,6 +346,7 @@ class PropertyClass(Model, Notify):
             self._force_external = True
         self.__version = SemanticVersion()
         self.__from_triplestore = _from_triplestore
+        self.clear_changeset()
 
     def __len__(self) -> int:
         return len(self._attributes)
@@ -755,12 +758,16 @@ class PropertyClass(Model, Notify):
         maxCount: Xsd_integer | None = None
         order: Xsd_decimal | None = None
         group: Xsd_QName | None = None
+        nodeKind: Xsd_QName | None = None
         propkeys = {Xsd_QName(x.value) for x in PropClassAttr}
         for key, val in attributes.items():
             if key == 'rdf:type':
                 if val != 'sh:PropertyShape':
                     raise OldapError(f'Inconsistency, expected "sh:PropertyType", got "{val}".')
                 continue
+            elif key == 'sh:nodeKind':
+                nodeKind = val
+                continue
             elif key == 'sh:path':
                 if isinstance(val, Xsd_QName):
                     self._property_class_iri = val
@@ -816,6 +823,8 @@ class PropertyClass(Model, Notify):
                 group = val
             elif key in propkeys:
                 attr = PropClassAttr.from_value(key)
+                if not attr.in_shacl:
+                    continue
                 if attr.datatype == Numeric:
                     if not isinstance(val, (Xsd_integer, Xsd_float)):
                         raise OldapErrorInconsistency(f'SHACL inconsistency: "{attr.value}" expects a "Xsd:integer" or "Xsd:float", but got "{type(val).__name__}".')
@@ -831,12 +840,15 @@ class PropertyClass(Model, Notify):
                                    group=group)
 
         if self._attributes.get(PropClassAttr.CLASS) is not None:
-            self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlObjectProperty
+            self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlObjectProperty)
             dt = self._attributes.get(PropClassAttr.DATATYPE)
             if dt and (dt != XsdDatatypes.anyURI and dt != XsdDatatypes.QName):
                 raise OldapError(f'Datatype "{dt}" not valid for OwlObjectProperty')
         else:
-            self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlDataProperty
+            if nodeKind in {Xsd_QName('sh:IRI'), Xsd_QName('sh:BlankNode'), Xsd_QName('sh:BlankNodeOrIRI')}:
+                self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlObjectProperty)
+            else:
+                self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlDataProperty)
         #
         # update all notifiers of properties
         #
@@ -848,6 +860,7 @@ class PropertyClass(Model, Notify):
     def read_owl(self) -> None:
         if self._externalOntology:
             return
+        propkeys = {Xsd_QName(x.value) for x in PropClassAttr}
         context = Context(name=self._con.context_name)
         query1 = context.sparql_context
         query1 += f"""
@@ -868,12 +881,12 @@ class PropertyClass(Model, Notify):
             obj = r['o']
             match attr:
                 case 'rdf:type':
-                    if obj == 'owl:DatatypeProperty':
-                        self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlDataProperty
-                    elif obj == 'owl:ObjectProperty':
-                        self._attributes[PropClassAttr.TYPE] = OwlPropertyType.OwlObjectProperty
-                    elif obj == 'rdf:Property':
-                        self._attributes[PropClassAttr.TYPE] = OwlPropertyType.StatementProperty
+                    try:
+                        # If obj is already a member, keep it; otherwise look it up by value
+                        prop_type = obj if isinstance(obj, OwlPropertyType) else OwlPropertyType(obj)
+                    except ValueError as e:
+                        raise OldapErrorNotFound(f'Unknown owl:Property type "{obj}"') from e
+                    self._attributes[PropClassAttr.TYPE].add(prop_type)
                 case 'owl:subPropertyOf':
                     self._attributes[PropClassAttr.SUBPROPERTY_OF] = obj
                 case 'rdfs:range':
@@ -897,22 +910,27 @@ class PropertyClass(Model, Notify):
                     dt = obj
                     if self._modified != dt:
                         raise OldapError(f'Inconsistency between SHACL and OWL: created "{self._modified}" vs "{dt}" for property "{self._property_class_iri}".')
+                case _:
+                    if attr in propkeys:
+                        pcattr = PropClassAttr.from_value(attr)
+                        if pcattr.in_owl:
+                            self._attributes[pcattr] = pcattr.datatype(obj)
         #
         # Consistency checks
         #
         if self._statementProperty:
-            if self._attributes.get(PropClassAttr.TYPE) != OwlPropertyType.StatementProperty:
+            if OwlPropertyType.StatementProperty not in self._attributes.get(PropClassAttr.TYPE):
                 raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" is a statementProperty, but not an StatementProperty.')
         else:
-            if self._attributes.get(PropClassAttr.TYPE) == OwlPropertyType.StatementProperty:
+            if OwlPropertyType.StatementProperty in self._attributes.get(PropClassAttr.TYPE):
                 raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" is not a statementProperty, but an StatementProperty.')
-        if self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlDataProperty:
+        if OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
             if not datatype:
                 raise OldapError(f'OwlDataProperty "{self._property_class_iri}" has no rdfs:range datatype defined!')
             if datatype != self._attributes.get(PropClassAttr.DATATYPE).value:
                 raise OldapError(
                     f'Property "{self._property_class_iri}" has inconsistent datatype definitions: OWL: "{datatype}" vs. SHACL: "{self._attributes[PropClassAttr.DATATYPE].value}"')
-        if self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlObjectProperty:
+        if OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
             if not to_node_iri:
                 raise OldapError(f'OwlObjectProperty "{self._property_class_iri}" has no rdfs:range resource class defined!')
             if to_node_iri != self._attributes.get(PropClassAttr.CLASS):
@@ -960,9 +978,10 @@ class PropertyClass(Model, Notify):
         attributes = PropertyClass.__query_shacl(con, property._graph, property_class_iri)
         property.parse_shacl(attributes=attributes)
         property.read_owl()
-        cache.set(property.property_class_iri, property)
+        property.clear_changeset()
 
         property.update_notifier()
+        cache.set(property.property_class_iri, property)
 
         return property
 
@@ -1029,7 +1048,7 @@ class PropertyClass(Model, Notify):
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:statementProperty {self._statementProperty.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:externalOntology {self._externalOntology.toRdf}'
         for prop, value in self._attributes.items():
-            if prop == PropClassAttr.TYPE:
+            if not prop.in_shacl:
                 continue
             if not value and not isinstance(value, bool):
             #if value is None:
@@ -1062,24 +1081,47 @@ class PropertyClass(Model, Notify):
 
     def create_owl_part1(self, timestamp: Xsd_dateTime, indent: int = 0, indent_inc: int = 4) -> str:
         blank = ''
-        sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} rdf:type {self._attributes[PropClassAttr.TYPE].value}'
-        if self._attributes.get(PropClassAttr.SUBPROPERTY_OF):
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:subPropertyOf {self._attributes[PropClassAttr.SUBPROPERTY_OF].toRdf}'
+        sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} {PropClassAttr.TYPE.toRdf} {self._attributes[PropClassAttr.TYPE].toRdf}'
         if self._internal:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:domain {self._internal.toRdf}'
-        if self._attributes.get(PropClassAttr.TYPE) == OwlPropertyType.OwlDataProperty:
+        if self._attributes.get(PropClassAttr.TYPE) and  OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.DATATYPE].value}'
-        elif self._attributes.get(PropClassAttr.TYPE) == OwlPropertyType.OwlObjectProperty:
+        elif self._attributes.get(PropClassAttr.TYPE) and OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.CLASS].toRdf}'
+        for attr, val in self._attributes.items():
+            #attr = PropClassAttr.from_value(key)
+            if not attr.in_owl or attr == PropClassAttr.TYPE or val is None:
+                continue
+            if attr == PropClassAttr.NAME:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {val.toRdf}'
+            elif attr == PropClassAttr.DESCRIPTION:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {val.toRdf}'
+            else:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}{attr.toRdf} {val.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:created {timestamp.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:contributor {self._con.userIri.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:modified {timestamp.toRdf}'
-        if self.name:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {self.name.toRdf}'
-        if self.description:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {self.description.toRdf}'
         sparql += ' .\n'
+
+        # sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} rdf:type {self._attributes[PropClassAttr.TYPE].toRdf}'
+        # if self._attributes.get(PropClassAttr.SUBPROPERTY_OF):
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:subPropertyOf {self._attributes[PropClassAttr.SUBPROPERTY_OF].toRdf}'
+        # if self._internal:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:domain {self._internal.toRdf}'
+        # if self._attributes.get(PropClassAttr.TYPE) and  OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.DATATYPE].value}'
+        # elif self._attributes.get(PropClassAttr.TYPE) and OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.CLASS].toRdf}'
+        # sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
+        # sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:created {timestamp.toRdf}'
+        # sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:contributor {self._con.userIri.toRdf}'
+        # sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:modified {timestamp.toRdf}'
+        # if self.name:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {self.name.toRdf}'
+        # if self.description:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {self.description.toRdf}'
+        # sparql += ' .\n'
         return sparql
 
     def create_owl_part2(self, *,
@@ -1104,9 +1146,9 @@ class PropertyClass(Model, Notify):
         # of the property within the given resource. However, rdfs:range is "global" for all use of this property!
         #
         if self._attributes.get(PropClassAttr.DATATYPE) or self._attributes.get(PropClassAttr.CLASS):
-            if self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlDataProperty:
+            if OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
                 sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onDataRange {self._attributes[PropClassAttr.DATATYPE].value}'
-            elif self._attributes[PropClassAttr.TYPE] == OwlPropertyType.OwlObjectProperty:
+            elif OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
                 sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}owl:onClass {self._attributes[PropClassAttr.CLASS]}'
         sparql += f' ;\n{blank:{indent * indent_inc}}]'
         return sparql
@@ -1195,6 +1237,7 @@ class PropertyClass(Model, Notify):
         try:
             self._con.transaction_update(sparql)
         except OldapError as err:
+            print(sparql)
             self._con.transaction_abort()
             raise
         if not self._externalOntology:  # it's a project specific property -> OWL has been written -> check consistency!
@@ -1269,6 +1312,16 @@ class PropertyClass(Model, Notify):
                                                                   attr=prop,
                                                                   modified=self._modified,
                                                                   indent=indent, indent_inc=indent_inc)
+                elif prop.datatype == ObservableSet:
+                    if prop == PropClassAttr.TYPE:
+                        continue
+                #     sparql += self._attributes[prop].update_shacl(graph=self._graph,
+                #                                                   owlclass_iri=owlclass_iri,
+                #                                                   prop_iri=self._property_class_iri,
+                #                                                   attr=prop,
+                #                                                   modified=self._modified,
+                #                                                   indent=indent, indent_inc=indent_inc)
+                #     print(gaga)
                 else:
                     raise OldapError(f'SHACL property {prop.value} should not have update action "MODIFY" ({prop.datatype}).')
                 sparql_list.append(sparql)
@@ -1329,12 +1382,14 @@ class PropertyClass(Model, Notify):
                    owlclass_iri: Xsd_QName | None = None,
                    timestamp: Xsd_dateTime,
                    indent: int = 0, indent_inc: int = 4) -> str:
+        tmp = {x for x in PropClassAttr if x.in_owl and x != PropClassAttr.TYPE}
         owl_propclass_attributes = {PropClassAttr.SUBPROPERTY_OF,  # should be in OWL ontology
                                     PropClassAttr.DATATYPE,  # used for rdfs:range in OWL ontology
-                                    PropClassAttr.CLASS}  # used for rdfs:range in OWL ontology
+                                    PropClassAttr.CLASS} | tmp # used for rdfs:range in OWL ontology
+        tmp = {x: x.value.toRdf for x in PropClassAttr if x.in_owl and x != PropClassAttr.TYPE}
         owl_prop = {PropClassAttr.SUBPROPERTY_OF: PropClassAttr.SUBPROPERTY_OF.value,
                     PropClassAttr.DATATYPE: "rdfs:range",
-                    PropClassAttr.CLASS: "rdfs:range"}
+                    PropClassAttr.CLASS: "rdfs:range"} | tmp
         blank = ''
         sparql_list = []
         for prop, change in self._changeset.items():
@@ -1367,6 +1422,13 @@ class PropertyClass(Model, Notify):
                                              last_modified=self._modified,
                                              indent=indent, indent_inc=indent_inc)
                 sparql_list.append(sparql)
+            if prop == PropClassAttr.TYPE:
+
+                sparql = self._attributes[prop].update_sparql(graph=Xsd_QName(str(self._graph), 'onto'),
+                                                              subject=self._property_class_iri,
+                                                              ignoreitems={OwlPropertyType.OwlDataProperty,OwlPropertyType.OwlObjectProperty},
+                                                              field=prop)
+                sparql_list.extend(sparql)
             if prop == PropClassAttr.NAME:
                 if change.action == Action.CREATE:
                     sparql = self.name.create(graph=Xsd_QName(self._graph, 'onto'),
@@ -1574,7 +1636,7 @@ class PropertyClass(Model, Notify):
         self._contributor = self._con.userIri
         for prop, change in self._changeset.items():
             if change.action == Action.MODIFY:
-                self._attributes[prop].changeset_clear()
+                self._attributes[prop].clear_changeset()
         self._changeset = {}
         cache = CacheSingletonRedis()
         cache.set(self._property_class_iri, self)

oldaplib/src/resourceclass.py

@@ -639,7 +639,9 @@ class ResourceClass(Model, Notify):
             s += f'{blank:{indent*2}}{qname} = {hasprop.prop} (minCount={hasprop.minCount}, maxCount={hasprop.maxCount}\n'
         return s
 
-    def changeset_clear(self) -> None:
+    def clear_changeset(self) -> None:
+        for prop in self._properties.values():
+            prop.clear_changeset()
         super().clear_changeset()
 
     def notifier(self, what: ResClassAttribute | Xsd_QName):
@@ -797,7 +799,7 @@ class ResourceClass(Model, Notify):
                     self._attributes[attr].set_notifier(self.notifier, attr)
 
         self.__from_triplestore = True
-        self.changeset_clear()
+        self.clear_changeset()
 
     @staticmethod
     def __query_resource_props(con: IConnection,
@@ -1082,7 +1084,7 @@ class ResourceClass(Model, Notify):
         if not resclass.externalOntology:
             resclass.__read_owl()
 
-        resclass.changeset_clear()
+        resclass.clear_changeset()
 
         resclass.update_notifier()
 
@@ -1296,7 +1298,7 @@ class ResourceClass(Model, Notify):
                 raise OldapErrorUpdateFailed(f'Creating resource "{self._owlclass_iri}" failed.')
         else:
             self._con.transaction_commit()
-        self.changeset_clear()
+        self.clear_changeset()
         cache = CacheSingletonRedis()
         cache.set(self._owlclass_iri, self)
 
@@ -1859,7 +1861,7 @@ class ResourceClass(Model, Notify):
                 raise OldapErrorUpdateFailed(f'Update of {self._owlclass_iri} failed. {modtime_shacl} {modtime_owl} {timestamp}')
         else:
             self._con.transaction_commit()
-        self.changeset_clear()
+        self.clear_changeset()
         self._modified = timestamp
         self._contributor = self._con.userIri
         self._test_in_use = False

oldaplib/src/version.py

@@ -1 +1 @@
-__version__ = "0.3.3"
+__version__ = "0.3.5"

oldaplib/src/xsd/iri.py

@@ -169,6 +169,9 @@ class Iri(Xsd):
         """
         return hash(self.__value)
 
+    def startswith(self, value, start=None, end=None):
+        return self.__value.startswith(value, start, end)
+
     @property
     def toRdf(self) -> str:
         """

oldaplib/src/xsd/xsd_anyuri.py

@@ -65,20 +65,20 @@ class Xsd_anyURI(Xsd):
             if isinstance(value, str):
                 value = value.replace("<", "").replace(">", "")
             if value.startswith("urn:"):
-                if not re.match(r'^urn:[a-z0-9][a-z0-9-]{0,31}:[^\s]+', value):
+                if not re.match(r'^urn:[a-z0-9][a-z0-9-]{0,31}:[^\s]+', str(value)):
                     raise OldapErrorValue(f'Invalid URN format for "{value}".')
             elif value.startswith("http"):
-                if not re.match(self._uri_pattern, value):
+                if not re.match(self._uri_pattern, str(value)):
                     raise OldapErrorValue(f'Invalid string "{value}" for xsd:anyURI.')
                 if validate:
-                    if not XsdValidator.validate(XsdDatatypes.anyURI, value):
+                    if not XsdValidator.validate(XsdDatatypes.anyURI, str(value)):
                         raise OldapErrorValue(f'Invalid string "{value}" for anyURI')
                     else:
-                        if not url(value):
+                        if not url(str(value)):
                             raise OldapErrorValue(f'Invalid string "{value}" for xsd:anyURI.')
             else:
                 raise OldapErrorValue(f'Invalid string "{value}" for anyURI')
-            self._value = value
+            self._value = str(value)
         self._append_allowed = self._value[-1] == '/' or self._value[-1] == '#'
 
     def __repr__(self) -> str:

oldaplib/src/xsd/xsd_qname.py

@@ -55,11 +55,14 @@ class Xsd_QName(Xsd):
                     raise OldapErrorValue(f'Invalid string "{value}" for QName. Error: {err}')
                 self._value = f'{prefix}:{fragment}'
             else:
-                raise OldapErrorValue(f'Invalid value for QName "{value}"')
+                raise OldapErrorValue(f'Invalid value for QName "{value}" (type: {type(value).__name__})')
         else:
             prefix = Xsd_NCName(value, validate=validate)
-            fragment = Xsd_NCName(fragment, validate=validate)
-            self._value = f'{prefix}:{fragment}'
+            if fragment:
+                fragment = Xsd_NCName(fragment, validate=validate)
+                self._value = f'{prefix}:{fragment}'
+            else:
+                self._value = f'{prefix}:'
 
     def __len__(self) -> int:
         """