oldaplib 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

oldaplib/src/helpers/observable_set.py

@@ -18,6 +18,9 @@ from oldaplib.src.helpers.oldaperror import OldapErrorKey, OldapErrorNotImplemen
 from oldaplib.src.helpers.serializer import serializer
 from oldaplib.src.helpers.attributechange import AttributeChange
 from oldaplib.src.xsd.iri import Iri
+from oldaplib.src.xsd.xsd_datetime import Xsd_dateTime
+from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
 
 #@strict
@@ -28,8 +31,8 @@ class ObservableSet(Notify):
     is items are added or removed. For this purpose, a callback function can be added to the set which is
     called whenever the set changes.
     """
-    __setdata: Set[Any]
-    __old_value: Self | None
+    _setdata: Set[Any]
+    _old_value: Self | None
 
     def __init__(self,
                  setitems: Self | Iterable | None = None,
@@ -44,56 +47,56 @@ class ObservableSet(Notify):
         :param on_change: Callback function to be called when an item is added/removed
         :param on_change_data: data supplied to the callback function
         """
-        self.__old_value = old_value
+        self._old_value = old_value
         super().__init__(notifier=notifier, data=notify_data)
         if isinstance(setitems, ObservableSet):
-            self.__setdata = setitems.__setdata
+            self._setdata = setitems._setdata
         else:
-            self.__setdata = set(setitems if setitems else [])
+            self._setdata = set(setitems if setitems else [])
 
     def __deepcopy__(self, memo: dict[Any, Any]) -> Self:
         new_copy = self.__class__.__new__(self.__class__)
         memo[id(self)] = new_copy
         #new_copy.__data = deepcopy(self.__data, memo)
-        new_copy.__setdata = set(self.__setdata)
+        new_copy._setdata = set(self._setdata)
         #new_copy._notifier = deepcopy(self._notifier, memo)
         new_copy._notifier = self._notifier
         new_copy._notify_data = deepcopy(self._notify_data, memo)
         return new_copy
 
     def __iter__(self):
-        return iter(self.__setdata)
+        return iter(self._setdata)
 
     def __len__(self) -> int:
-        return len(self.__setdata)
+        return len(self._setdata)
 
     def __contains__(self, item: Any) -> bool:
-        return item in self.__setdata
+        return item in self._setdata
 
     def __repr__(self) -> str:
-        l = [repr(x) for x in self.__setdata]
+        l = [repr(x) for x in self._setdata]
         return ", ".join(l)
 
     def __str__(self) -> str:
-        return str(self.__setdata)
+        return str(self._setdata)
 
     def __eq__(self, other: Iterable) -> bool:
         if isinstance(other, ObservableSet):
-            return self.__setdata == other.__setdata
+            return self._setdata == other._setdata
         elif isinstance(other, set):
-            return self.__setdata == other
+            return self._setdata == other
         elif isinstance(other, Iterable):
-            return self.__setdata == set(other)
+            return self._setdata == set(other)
         else:
             raise OldapErrorNotImplemented(f'Set.__eq__() not implemented for {type(other).__name__}')
 
     def __or__(self, other: Iterable) -> Self:
         if isinstance(other, ObservableSet):
-            return ObservableSet(self.__setdata.__or__(other.__setdata), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__or__(other._setdata), self._notifier, self._notify_data)
         elif isinstance(other, set):
-            return ObservableSet(self.__setdata.__or__(other), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__or__(other), self._notifier, self._notify_data)
         elif isinstance(other, Iterable):
-            return ObservableSet(self.__setdata.__or__(set(other)), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__or__(set(other)), self._notifier, self._notify_data)
         else:
             raise OldapErrorNotImplemented(f'Set.__or__() not implemented for {type(other).__name__}')
 
@@ -103,40 +106,40 @@ class ObservableSet(Notify):
     def __ior__(self, other: Iterable) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
-            self.__setdata.__ior__(other.__setdata)
+            self._setdata.__ior__(other._setdata)
         elif isinstance(other, set):
-            self.__setdata.__ior__(other)
+            self._setdata.__ior__(other)
         elif isinstance(other, Iterable):
-            return ObservableSet(self.__setdata.__ior__(set(other)), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__ior__(set(other)), self._notifier, self._notify_data)
         else:
             raise OldapErrorNotImplemented(f'Set.i__or__() not implemented for {type(other).__name__}')
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
         return self
 
     def __and__(self, other: Iterable) -> Self:
         if isinstance(other, ObservableSet):
-            return ObservableSet(self.__setdata.__and__(other.__setdata), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__and__(other._setdata), self._notifier, self._notify_data)
         elif isinstance(other, set):
-            return ObservableSet(self.__setdata.__and__(other), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__and__(other), self._notifier, self._notify_data)
         elif isinstance(other, Iterable):
-            return ObservableSet(self.__setdata.__and__(set(other)), self._notifier, self._notify_data)
+            return ObservableSet(self._setdata.__and__(set(other)), self._notifier, self._notify_data)
         else:
             raise OldapErrorNotImplemented(f'Set.__and__() not implemented for {type(other).__name__}')
 
     def __iand__(self, other: Iterable) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
-            self.__setdata.__iand__(other.__setdata)
+            self._setdata.__iand__(other._setdata)
         elif isinstance(other, set):
-            self.__setdata.__iand__(other)
+            self._setdata.__iand__(other)
         elif isinstance(other, Iterable):
-            self.__setdata.__iand__(set(other))
+            self._setdata.__iand__(set(other))
         else:
             raise OldapErrorNotImplemented(f'Set.__iand__() not implemented for {type(other).__name__}')
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
         return self
 
@@ -145,136 +148,144 @@ class ObservableSet(Notify):
 
     def __sub__(self, other: Iterable) -> Self:
         if isinstance(other, ObservableSet):
-            return ObservableSet(self.__setdata.__sub__(other.__setdata), self.notify, self._notify_data)
+            return ObservableSet(self._setdata.__sub__(other._setdata), self.notify, self._notify_data)
         elif isinstance(other, set):
-            return ObservableSet(self.__setdata.__sub__(other), self.notify, self._notify_data)
+            return ObservableSet(self._setdata.__sub__(other), self.notify, self._notify_data)
         elif isinstance(other, Iterable):
-            return ObservableSet(self.__setdata.__sub__(set(other)), self.notify, self._notify_data)
+            return ObservableSet(self._setdata.__sub__(set(other)), self.notify, self._notify_data)
         else:
             raise OldapErrorNotImplemented(f'Set.__sub__() not implemented for {type(other).__name__}')
 
     def __isub__(self, other: Iterable) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
-            self.__setdata.__isub__(other.__setdata)
+            self._setdata.__isub__(other._setdata)
         elif isinstance(other, set):
-            self.__setdata.__isub__(other)
+            self._setdata.__isub__(other)
         elif isinstance(other, Iterable):
-            self.__setdata.__isub__(set(other))
+            self._setdata.__isub__(set(other))
         else:
             raise OldapErrorNotImplemented(f'Set.__isub__() not implemented for {type(other).__name__}')
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
         return self
 
     def update(self, items: Iterable):
         tmp_copy = deepcopy(self)
-        self.__setdata.update(items)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.update(items)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def intersection_update(self, items: Iterable):
         tmp_copy = deepcopy(self)
-        self.__setdata.intersection_update(items)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.intersection_update(items)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def difference_update(self, items: Iterable):
         tmp_copy = deepcopy(self)
-        self.__setdata.difference_update(items)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.difference_update(items)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def symmetric_difference_update(self, items: Iterable):
         tmp_copy = deepcopy(self)
-        self.__setdata.symmetric_difference_update(items)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.symmetric_difference_update(items)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def add(self, item: Any) -> None:
         tmp_copy = deepcopy(self)
-        self.__setdata.add(item)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.add(item)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def remove(self, item: Any) -> None:
         tmp_copy = deepcopy(self)
-        self.__setdata.remove(item)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.remove(item)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def discard(self, item: Any):
         tmp_copy = deepcopy(self)
-        self.__setdata.discard(item)
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.discard(item)
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     def pop(self):
         tmp_copy = deepcopy(self)
-        item = self.__setdata.pop()
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        item = self._setdata.pop()
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
         return item
 
     def clear(self) -> None:
         tmp_copy = deepcopy(self)
-        self.__setdata.clear()
-        if not self.__old_value:
-            self.__old_value = tmp_copy
+        self._setdata.clear()
+        if not self._old_value:
+            self._old_value = tmp_copy
         self.notify()
 
     @property
     def old_value(self) -> Self | None:
-        return self.__old_value
+        return self._old_value
 
     def clear_old_value(self) -> None:
         """
         Clear the changeset. This method is only for internal use or debugging...
         :return: None
         """
-        self.__old_value = None
+        self._old_value = None
 
     def copy(self) -> Self:
-        return ObservableSet(self.__setdata.copy(), notifier=self._notifier, notify_data=self._notify_data)
+        return ObservableSet(self._setdata.copy(), notifier=self._notifier, notify_data=self._notify_data)
 
     @property
     def toRdf(self) -> str:
-        l = [x.toRdf if getattr(x, "toRdf", None) else x for x in self.__setdata]
+        l = [x.toRdf if getattr(x, "toRdf", None) else x for x in self._setdata]
         return ", ".join(l)
 
     def _as_dict(self):
-        return {'setitems': list(self.__setdata)}
+        return {'setitems': list(self._setdata)}
 
     def asSet(self) -> set:
-        return self.__setdata.copy()
+        return self._setdata.copy()
 
     def to_set(self) -> set:
-        return self.__setdata
+        return self._setdata
 
     def undo(self) -> None:
-        if self.__old_value:
-            self.__setdata = self.__old_value.to_set()
-        self.__old_value = None
+        if self._old_value:
+            self._setdata = self._old_value.to_set()
+        self._old_value = None
 
-    def clear_changeset(self):
-        self.__old_value = None
+    def clear_changeset(self) -> None:
+        for item in self._setdata:
+            if hasattr(item, 'clear_changeset'):
+                item.clear_changeset()
+        self._old_value = None
 
     def update_sparql(self, *,
-                      graph: Iri,
+                      graph: Iri | Xsd_QName,
                       subject: Iri,
                       field: Iri,
+                      ignoreitems: Set[Any] | None = None,
                       indent: int = 0, indent_inc: int = 4) -> list[str]:
-        items_to_add = self.__setdata - self.__old_value.__setdata
-        items_to_delete = self.__old_value.__setdata - self.__setdata
+        items_to_add = self._setdata - self._old_value.to_set()
+        if ignoreitems:
+            items_to_add = items_to_add - ignoreitems
+        items_to_delete = self._old_value.to_set() - self._setdata
+        if ignoreitems:
+            items_to_delete = items_to_delete - ignoreitems
         blank = ''
         sparql_list = []
 
@@ -297,3 +308,47 @@ class ObservableSet(Notify):
             sparql_list.append(sparql)
 
         return sparql_list
+
+    def update_shacl(self, *,
+                     graph: Xsd_NCName,
+                     owlclass_iri: Iri | None = None,
+                     prop_iri: Iri,
+                     attr: AttributeClass,
+                     modified: Xsd_dateTime,
+                     indent: int = 0, indent_inc: int = 4) -> list[str]:
+        items_to_add = self._setdata - self._old_value
+        items_to_delete = self._old_value - self._setdata
+
+        blank = ''
+        sparql_list = []
+        sparql = f'# ObservableSet: Update SHACL\n'
+        sparql += f'{blank:{indent * indent_inc}}WITH {graph}:shacl\n'
+
+        if items_to_add:
+            sparql = f'{blank:{indent * indent_inc}}INSERT {{\n'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}GRAPH {graph} {{\n'
+            for item in items_to_add:
+                sparql += f'{blank:{(indent + 2) * indent_inc}}?prop {attr.value.toRdf} {item.toRdf} .'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}}}\n'
+            sparql += f'{blank:{indent * indent_inc}}}}\n'
+
+        if items_to_delete:
+            sparql = f'{blank:{indent * indent_inc}}DELETE {{\n'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}GRAPH {graph} {{\n'
+            for item in items_to_delete:
+                sparql += f'{blank:{(indent + 2) * indent_inc}}?prop {attr.value.toRdf} {item.toRdf} .'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}}}\n'
+            sparql += f'{blank:{indent * indent_inc}}}}\n'
+            sparql_list.append(sparql)
+
+            sparql += f'{blank:{indent * indent_inc}}WHERE {{\n'
+            if owlclass_iri:
+                sparql += f'{blank:{(indent + 1) * indent_inc}}{owlclass_iri}Shape sh:property ?prop .\n'
+                sparql += f'{blank:{(indent + 1) * indent_inc}}?prop sh:path {prop_iri.toRdf} .\n'
+            else:
+                sparql += f'{blank:{(indent + 1) * indent_inc}}BIND({prop_iri}Shape as ?prop) .\n'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}?prop dcterms:modified ?modified .\n'
+            sparql += f'{blank:{(indent + 1) * indent_inc}}FILTER(?modified = {modified.toRdf})\n'
+            sparql += f'{blank:{indent * indent_inc}}}}'
+            sparql_list.append(sparql)
+        return sparql

oldaplib/src/helpers/query_processor.py

@@ -3,6 +3,7 @@ from typing import List, Dict
 
 from pystrict import strict
 
+from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
 from oldaplib.src.helpers.context import Context
 from oldaplib.src.dtypes.bnode import BNode
 from oldaplib.src.xsd.iri import Iri
@@ -72,6 +73,8 @@ class QueryProcessor:
                     tmp = context.iri2qname(valobj["value"], validate=False)
                     if tmp is None:
                         row[name] = Iri(valobj["value"], validate=False)
+                    elif not tmp.fragment:
+                        row[name] = NamespaceIRI(valobj["value"], validate=False)
                     else:
                         #row[name] = Iri(tmp, validate=False)
                         row[name] = tmp

oldaplib/src/model.py

@@ -45,7 +45,7 @@ class Model:
     _created: Xsd_dateTime | None
     _contributor: Iri | None
     _modified: Xsd_dateTime | None
-    _attributes: dict[Enum, Any]
+    _attributes: dict[AttributeClass, Any]
     _changeset: dict[AttributeClass | Xsd_QName, AttributeChange]
     _validate: bool
 

oldaplib/src/oldaplist.py

@@ -501,10 +501,10 @@ class OldapList(Model):
                         definition = LangString()
                     definition.add(r['val'])
         if prefLabel:
-            prefLabel.changeset_clear()
+            prefLabel.clear_changeset()
             prefLabel.set_notifier(cls.notifier, Xsd_QName(OldapListAttr.PREF_LABEL.value))
         if definition:
-            definition.changeset_clear()
+            definition.clear_changeset()
             definition.set_notifier(cls.notifier, Xsd_QName(OldapListAttr.DEFINITION.value))
 
         instance = cls(con=con,

oldaplib/src/oldaplistnode.py

@@ -352,10 +352,10 @@ class OldapListNode(Model):
                 case 'oldap:rightIndex':
                     rightIndex = r['val']
         if prefLabel:
-            prefLabel.changeset_clear()
+            prefLabel.clear_changeset()
             prefLabel.set_notifier(cls.notifier, Xsd_QName(OldapListNodeAttr.PREF_LABEL.value))
         if definition:
-            definition.changeset_clear()
+            definition.clear_changeset()
             definition.set_notifier(cls.notifier, Xsd_QName(OldapListNodeAttr.DEFINITION.value))
         return cls(con=con,
                    projectShortName=projectShortName,

oldaplib/src/permissionset.py

@@ -179,7 +179,7 @@ class PermissionSet(Model):
                     return False, f'Actor has no ADMIN_PERMISSION_SETS permission for project {self.definedByProject}'
             return True, "OK"
 
-    def notifier(self, what: PermissionSetAttr) -> None:
+    def notifier(self, what: PermissionSetAttr, value: Any = None) -> None:
         self._changeset[what] = AttributeChange(None, Action.MODIFY)
 
     @property
@@ -379,10 +379,10 @@ class PermissionSet(Model):
                     _definedByProject = r['o']
         cls.__permset_iri = permset_iri
         if comment:
-            comment.changeset_clear()
+            comment.clear_changeset()
             comment.set_notifier(cls.notifier, Xsd_QName(PermissionSetAttr.LABEL.value))
         if label:
-            label.changeset_clear()
+            label.clear_changeset()
             label.set_notifier(cls.notifier, Xsd_QName(PermissionSetAttr.LABEL.value))
         instance = cls(con=con,
                        permissionSetId=Xsd_NCName(_permissionSetId, validate=False),