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

oldaplib/src/datamodel.py

@@ -71,10 +71,10 @@ class DataModel(Model):
     _project: Project
     __context: Context
     __version: SemanticVersion
-    __propclasses: dict[Iri, PropertyClass | None]
-    __resclasses: dict[Iri, ResourceClass | None]
-    __resclasses_changeset: dict[Iri, ResourceClassChange]
-    __propclasses_changeset: dict[Iri, PropertyClassChange]
+    __propclasses: dict[Xsd_QName, PropertyClass | None]
+    __resclasses: dict[Xsd_QName, ResourceClass | None]
+    __resclasses_changeset: dict[Xsd_QName, ResourceClassChange]
+    __propclasses_changeset: dict[Xsd_QName, PropertyClassChange]
 
     def __init__(self, *,
                  con: IConnection,
@@ -219,7 +219,7 @@ class DataModel(Model):
         instance.__propclasses_changeset = deepcopy(self.__propclasses_changeset, memo)
         return instance
 
-    def __getitem__(self, key: Iri) -> PropertyClass | ResourceClass:
+    def __getitem__(self, key: Xsd_QName) -> PropertyClass | ResourceClass:
         if key in self.__resclasses:
             return self.__resclasses[key]
         if key in self.__propclasses:
@@ -227,7 +227,7 @@ class DataModel(Model):
         else:
             raise KeyError(key)
 
-    def __setitem__(self, key: Iri, value: PropertyClass | ResourceClass) -> None:
+    def __setitem__(self, key: Xsd_QName, value: PropertyClass | ResourceClass) -> None:
         if isinstance(value, PropertyClass):
             if self.__propclasses.get(key) is None:
                 self.__propclasses_changeset[key] = PropertyClassChange(None, Action.CREATE)
@@ -243,9 +243,9 @@ class DataModel(Model):
         else:
             raise OldapErrorValue(f'"{key}" must be either PropertyClass or ResourceClass (is "{type(value).__name__}")')
 
-    def __delitem__(self, key: Iri | str) -> None:
-        if not isinstance(key, Iri):
-            key = Iri(key, validate=True)
+    def __delitem__(self, key: Xsd_QName | str) -> None:
+        if not isinstance(key, Xsd_QName):
+            key = Xsd_QName(key, validate=True)
         if key in self.__propclasses:
             self.__propclasses_changeset[key] = PropertyClassChange(self.__propclasses[key], Action.DELETE)
             del self.__propclasses[key]
@@ -255,7 +255,7 @@ class DataModel(Model):
         else:
             raise OldapErrorValue(f'"{key}" must be either PropertyClass or ResourceClass')
 
-    def get(self, key: Iri | str) -> PropertyClass | ResourceClass | None:
+    def get(self, key: Xsd_QName | str) -> PropertyClass | ResourceClass | None:
         """
         Retrieves an instance of `PropertyClass` or `ResourceClass` associated with the
         specified `key`. The `key` can be either an `Iri` instance or a string. If the
@@ -270,8 +270,8 @@ class DataModel(Model):
         :raises OldapErrorValue: If the `key` is not a valid Iri object.
         :raises OldapErrorNotFound: If no instance is found for the given `key`.
         """
-        if not isinstance(key, Iri):
-            key = Iri(key, validate=True)
+        if not isinstance(key, Xsd_QName):
+            key = Xsd_QName(key, validate=True)
         if key in self.__propclasses:
             return self.__propclasses[key]
         elif key in self.__resclasses:
@@ -279,7 +279,7 @@ class DataModel(Model):
         else:
             return None
 
-    def get_propclasses(self) -> list[Iri]:
+    def get_propclasses(self) -> list[Xsd_QName]:
         """
         Get a list of the IRIs of the standalone property classes.
 
@@ -291,7 +291,7 @@ class DataModel(Model):
         """
         return [x for x in self.__propclasses]
 
-    def get_resclasses(self) -> list[Iri]:
+    def get_resclasses(self) -> list[Xsd_QName]:
         """
         Get a list of the IRIs of the resource classes.
 
@@ -304,7 +304,7 @@ class DataModel(Model):
         return [x for x in self.__resclasses]
 
     @property
-    def changeset(self) -> dict[Iri, PropertyClassChange | ResourceClassChange]:
+    def changeset(self) -> dict[Xsd_QName, PropertyClassChange | ResourceClassChange]:
         return self.__resclasses_changeset | self.__propclasses_changeset
 
     def changeset_clear(self) -> None:
@@ -318,7 +318,7 @@ class DataModel(Model):
         self.__resclasses_changeset = {}
         self.clear_changeset()
 
-    def notifier(self, what: Iri) -> None:
+    def notifier(self, what: Xsd_QName) -> None:
         if what in self.__propclasses:
             self.__propclasses_changeset[what] = PropertyClassChange(None, Action.MODIFY)
         elif what in self.__resclasses:
@@ -329,7 +329,7 @@ class DataModel(Model):
     @classmethod
     def read(cls,
              con: IConnection,
-             project: Project | Iri | Xsd_NCName | str,
+             project: Project | Xsd_QName | Xsd_NCName | str,
              ignore_cache: bool = False):
         """
         Reads the data model from the given project by querying the triple store.
@@ -421,7 +421,7 @@ class DataModel(Model):
             projectid = r['graph'].prefix
             propnameshacl = str(r['prop'])
             propclassiri = propnameshacl.removesuffix("Shape")
-            propclass = PropertyClass.read(con, projectid, Iri(propclassiri, validate=False), ignore_cache=ignore_cache)
+            propclass = PropertyClass.read(con, projectid, Xsd_QName(propclassiri, validate=False), ignore_cache=ignore_cache)
             propclass.force_external()
             propclasses.append(propclass)
         sa_props = {x.property_class_iri: x for x in propclasses}
@@ -451,7 +451,7 @@ class DataModel(Model):
             try:
                 if resclassiri == 'test:Book':
                     pass
-                resclass = ResourceClass.read(con, project, Iri(resclassiri, validate=False), sa_props=sa_props, ignore_cache=ignore_cache)
+                resclass = ResourceClass.read(con, project, Xsd_QName(resclassiri, validate=False), sa_props=sa_props, ignore_cache=ignore_cache)
             except OldapError as er:
                 print(f'Error reading resource class {resclassiri}: {er}')
 

oldaplib/src/enums/haspropertyattr.py

@@ -6,6 +6,7 @@ from oldaplib.src.xsd.xsd_decimal import Xsd_decimal
 from oldaplib.src.xsd.xsd_integer import Xsd_integer
 from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
 from oldaplib.src.xsd.xsd_nonnegativeinteger import Xsd_nonNegativeInteger
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
 
 @unique
@@ -14,4 +15,4 @@ class HasPropertyAttr(AttributeClass):
     MIN_COUNT = ('sh:minCount', False, False, Xsd_nonNegativeInteger)
     MAX_COUNT = ('sh:maxCount', False, False, Xsd_nonNegativeInteger)
     ORDER = ('sh:order', False, False, Xsd_decimal)
-    GROUP = ('sh:group', False, False, Iri)
+    GROUP = ('sh:group', False, False, Xsd_QName)

oldaplib/src/hasproperty.py

@@ -1,14 +1,11 @@
 from copy import deepcopy
-from dataclasses import dataclass
 from enum import Enum
 from functools import partial
-from pprint import pprint
 from typing import Callable, Self, Any
 
 from oldaplib.src.enums.action import Action
 from oldaplib.src.enums.attributeclass import AttributeClass
 from oldaplib.src.enums.haspropertyattr import HasPropertyAttr
-from oldaplib.src.enums.propertyclassattr import PropClassAttr
 from oldaplib.src.helpers.Notify import Notify
 from oldaplib.src.helpers.irincname import IriOrNCName
 from oldaplib.src.helpers.oldaperror import OldapErrorNotFound
@@ -20,10 +17,10 @@ from oldaplib.src.project import Project
 from oldaplib.src.propertyclass import PropertyClass, HasPropertyData
 from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd_datetime import Xsd_dateTime
-from oldaplib.src.xsd.xsd_decimal import Xsd_decimal
-from oldaplib.src.xsd.xsd_integer import Xsd_integer
 from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
 from oldaplib.src.xsd.xsd_nonnegativeinteger import Xsd_nonNegativeInteger
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
+
 
 @serializer
 class PropType(Enum):
@@ -53,16 +50,16 @@ class HasProperty(Model, Notify):
     """
 
 
-    _prop: PropertyClass | Iri | None
+    _prop: PropertyClass | Xsd_QName | None
     _project: Project | None
     _type: PropType | None
 
     def __init__(self, *,
                  con: IConnection,
                  project: Project | Iri | Xsd_NCName | str,
-                 prop: PropertyClass | Iri | None = None,
-                 notifier: Callable[[Iri], None] | None = None,
-                 notify_data: Iri | None = None,
+                 prop: PropertyClass | Xsd_QName | None = None,
+                 notifier: Callable[[Xsd_QName], None] | None = None,
+                 notify_data: Xsd_QName | None = None,
                  creator: Iri | None = None,  # DO NO USE! Only for jsonify!!
                  created: Xsd_dateTime | None = None,  # DO NO USE! Only for jsonify!!
                  contributor: Iri | None = None,  # DO NO USE! Only for jsonify!!
@@ -103,8 +100,8 @@ class HasProperty(Model, Notify):
             if not isinstance(project, (Iri, Xsd_NCName)):
                 project = IriOrNCName(project, validate=validate)
             self._project = Project.read(self._con, project)
-        if isinstance(prop, Iri):
-            fixed_prop = Iri(str(prop).removesuffix("Shape"))
+        if isinstance(prop, Xsd_QName):
+            fixed_prop = Xsd_QName(str(prop).removesuffix("Shape"))
             try:
                 self._prop = PropertyClass.read(self._con, self._project, fixed_prop)
                 self._type = PropType.STANDALONE
@@ -129,8 +126,8 @@ class HasProperty(Model, Notify):
         self._changeset = {}
 
     def update_notifier(self,
-                        notifier: Callable[[AttributeClass | Iri], None] | None = None,
-                        notify_data: HasPropertyAttr | Iri | None = None):
+                        notifier: Callable[[AttributeClass | Xsd_QName], None] | None = None,
+                        notify_data: HasPropertyAttr | Xsd_QName | None = None):
         self.set_notifier(notifier, notify_data)
         if isinstance(self._prop, PropertyClass):
             self._prop.set_notifier(self.notifier, self._prop.property_class_iri)
@@ -177,11 +174,11 @@ class HasProperty(Model, Notify):
         return self._type
 
     @property
-    def prop(self) -> PropertyClass | Iri | None:
+    def prop(self) -> PropertyClass | Xsd_QName | None:
         return self._prop
 
     @prop.setter
-    def prop(self, prop: PropertyClass | Iri) -> None:
+    def prop(self, prop: PropertyClass | Xsd_QName) -> None:
         self._prop = prop
 
     @property
@@ -191,12 +188,12 @@ class HasProperty(Model, Notify):
                                order=self._attributes.get(HasPropertyAttr.ORDER, None),
                                group=self._attributes.get(HasPropertyAttr.GROUP, None))
 
-    def notifier(self, attr: HasPropertyAttr | Iri) -> None:
+    def notifier(self, attr: HasPropertyAttr | Iri | Xsd_QName) -> None:
         #if attr == HasPropertyAttr.PROP:
         #    return
         if isinstance(attr, HasPropertyAttr):
             self._changeset[attr] = AttributeChange(self._attributes[attr], Action.MODIFY)
-        elif isinstance(attr, Iri):
+        elif isinstance(attr, Xsd_QName):
             self._changeset[attr] = AttributeChange(None, Action.MODIFY)
         self.notify()
 
@@ -230,13 +227,13 @@ class HasProperty(Model, Notify):
 
     def update_shacl(self,
                      graph: Xsd_NCName,
-                     resclass_iri: Iri,
-                     propclass_iri: Iri,
+                     resclass_iri: Xsd_QName,
+                     propclass_iri: Xsd_QName,
                      indent: int = 0, indent_inc: int = 4) -> str:
         blank = ''
         sparql_list = []
         for attr, change in self._changeset.items():
-            if isinstance(attr, Iri):  # if it's an IRI, the attached PropertyClass has changed. We don't process this here
+            if isinstance(attr, Xsd_QName):  # if it's an IRI, the attached PropertyClass has changed. We don't process this here
                 continue
             sparql = f'WITH {graph}:shacl\n'
             if change.action != Action.CREATE:
@@ -251,7 +248,7 @@ class HasProperty(Model, Notify):
 
             sparql += f'{blank:{indent * indent_inc}}WHERE {{\n'
             sparql += f'{blank:{(indent + 1) * indent_inc}}{resclass_iri}Shape sh:property ?prop .\n'
-            if isinstance(self._prop, Iri) or self._prop.internal is None:
+            if isinstance(self._prop, Xsd_QName) or self._prop.internal is None:
                 sparql += f'{blank:{(indent + 1) * indent_inc}}?prop sh:node {propclass_iri}Shape.\n'
             else:
                 sparql += f'{blank:{(indent + 1) * indent_inc}}?prop sh:path {propclass_iri} .\n'
@@ -264,8 +261,8 @@ class HasProperty(Model, Notify):
 
     def update_owl(self,
                      graph: Xsd_NCName,
-                     resclass_iri: Iri,
-                     propclass_iri: Iri,
+                     resclass_iri: Xsd_QName,
+                     propclass_iri: Xsd_QName,
                      indent: int = 0, indent_inc: int = 4) -> str:
         blank = ''
         if HasPropertyAttr.MIN_COUNT in self._changeset or HasPropertyAttr.MAX_COUNT in self._changeset:
@@ -302,3 +299,5 @@ class HasProperty(Model, Notify):
             sparql += f'{blank:{indent * indent_inc}}}}'
 
             return sparql
+        else:
+            return ''

oldaplib/src/helpers/Notify.py

@@ -5,6 +5,7 @@ from pystrict import strict
 
 from oldaplib.src.enums.attributeclass import AttributeClass
 from oldaplib.src.xsd.iri import Iri
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
 
 #@strict
@@ -15,12 +16,12 @@ class Notify:
     as of type LangString or PropertyRestriction to notify PropertyClass that something has changed,
     e.g. the change of value
     """
-    _notifier: Callable[[Enum | Iri], None]
-    _notify_data: Enum | Iri | None
+    _notifier: Callable[[Enum | Iri | Xsd_QName], None]
+    _notify_data: Enum | Iri | Xsd_QName | None
 
     def __init__(self,
-                 notifier: Callable[[Enum | Iri], None] | None = None,
-                 data: Enum | Iri | None = None):
+                 notifier: Callable[[Enum | Iri | Xsd_QName], None] | None = None,
+                 data: Enum | Iri | Xsd_QName | None = None):
         """
         Constructor of the notifier. Usually, the notifier is only used a base class and not used directly.
         :param notifier: The callable that is to be called by the subclass when an item is beeing chaged
@@ -30,8 +31,8 @@ class Notify:
         self._notify_data = data
 
     def set_notifier(self,
-                     notifier: Callable[[Enum | AttributeClass | Iri], None],
-                     data: Enum | Iri | None = None) -> None:
+                     notifier: Callable[[Enum | AttributeClass | Iri | Xsd_QName], None],
+                     data: Enum | Xsd_QName | Iri | None = None) -> None:
         """
         Sets the notifier callback function and the data it should return...
         :param notifier: A callable that is to be called by the subclass when an item changes

oldaplib/src/helpers/irincname.py

@@ -1,33 +1,79 @@
 from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
 
 class IriOrNCName:
 
-    def __init__(self, value: Iri | Xsd_NCName | str, validate: bool = False):
+    def __init__(self, value: Iri | Xsd_QName | Xsd_NCName | str, validate: bool = False):
         self.__iri: Iri | None = None
         self.__ncname: Xsd_NCName | None = None
+        self.__qname: Xsd_QName | None = None
         if isinstance(value, Iri):
             self.__iri = value
             self.__ncname = None
+            self.__qname = None
         elif isinstance(value, Xsd_NCName):
             self.__ncname = Xsd_NCName(value)
             self.__iri = None
+            self.__qname = None
+        elif isinstance(value, Xsd_QName):
+            self.__qname = Xsd_QName(value)
+            self.__iri = None
+            self.__ncname = None
         else:
             if ':' in str(value):  # must be IRI or QName
-                self.__iri = Iri(value, validate=validate)
-                self.__ncname = None
+                try:
+                    self.__qname = Xsd_QName(value, validate=validate)
+                    self.__iri = None
+                    self.__ncname = None
+                except:
+                    self.__iri = Iri(value, validate=validate)
+                    self.__ncname = None
+                    self.__qname = None
             else:
                 self.__ncname = Xsd_NCName(value, validate=validate)
                 self.__iri = None
+                self.__qname = None
+
+    @property
+    def is_iri(self) -> bool:
+        return self.__iri is not None
+
+    @property
+    def is_ncname(self) -> bool:
+        return self.__ncname is not None
+
+    @property
+    def is_qname(self) -> bool:
+        return self.__qname is not None
+
+    @property
+    def as_iri(self) -> Iri | None:
+        if self.__iri:
+            return self.__iri
+        elif self.__qname:
+            return Iri(self.__qname)
+        else:
+            return None
+
+    @property
+    def as_qname(self) -> Xsd_QName | None:
+            return self.__qname if self.__qname else None
+
+    @property
+    def as_ncname(self) -> Xsd_NCName | None:
+        return self.__ncname if self.__ncname else None
 
     def value(self) -> tuple[Xsd_NCName| None, Iri | None]:
-        return self.__ncname, self.__iri
+        return self.as_ncname, self.as_iri
 
     def __str__(self):
         if self.__iri is not None:
             return str(self.__iri)
         elif self.__ncname is not None:
             return str(self.__ncname)
+        elif self.__qname is not None:
+            return str(self.__qname)
         else:
             return "???"

oldaplib/src/helpers/observable_dict.py

@@ -50,7 +50,7 @@ class ObservableDict(UserDict):
             for item in obsdict:
                 self[item['key']] = item['val']
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value) -> None:
         if key in self.data:
             self._changeset[key] = AttributeChange(self.data[key], Action.MODIFY)
         else:
@@ -59,12 +59,14 @@ class ObservableDict(UserDict):
             self.__on_change(self.copy())
         super().__setitem__(key, value)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key) -> None:
         self._changeset[key] = AttributeChange(self.data[key], Action.DELETE)
         if self.__on_change:
             self.__on_change(self.copy())
         super().__delitem__(key)
 
+    def __bool__(self) -> bool:
+        return len(self) > 0
 
     def copy(self) -> Self:
         return ObservableDict(self.data.copy())

oldaplib/src/helpers/query_processor.py

@@ -73,7 +73,8 @@ class QueryProcessor:
                     if tmp is None:
                         row[name] = Iri(valobj["value"], validate=False)
                     else:
-                        row[name] = Iri(tmp, validate=False)
+                        #row[name] = Iri(tmp, validate=False)
+                        row[name] = tmp
                 elif valobj["type"] == "bnode":
                     row[name] = BNode(f'_:{valobj["value"]}', validate=False)
                 elif valobj["type"] == "literal":

oldaplib/src/helpers/tools.py

@@ -38,7 +38,7 @@ class RdfModifyRes:
     def __rdf_modify_property(cls, *,
                               shacl: bool,
                               action: Action,
-                              owlclass_iri: Iri,
+                              owlclass_iri: Xsd_QName,
                               graph: Xsd_QName,
                               ele: RdfModifyItem,
                               last_modified: Xsd_dateTime,
@@ -78,7 +78,7 @@ class RdfModifyRes:
     def shacl(cls, *,
               action: Action,
               graph: Xsd_NCName,
-              owlclass_iri: Iri,
+              owlclass_iri: Xsd_QName,
               ele: RdfModifyItem,
               last_modified: Xsd_dateTime,
               indent: int = 0, indent_inc: int = 4):
@@ -91,7 +91,7 @@ class RdfModifyRes:
     def onto(cls, *,
              action: Action,
              graph: Xsd_NCName,
-             owlclass_iri: Iri,
+             owlclass_iri: Xsd_QName,
              ele: RdfModifyItem,
              last_modified: Xsd_dateTime,
              indent: int = 0, indent_inc: int = 4):
@@ -107,8 +107,8 @@ class RdfModifyProp:
     def __rdf_modify_property(cls, *,
                               shacl: bool,
                               action: Action,
-                              owlclass_iri: Iri | None = None,
-                              pclass_iri: Iri,
+                              owlclass_iri: Xsd_QName | None = None,
+                              pclass_iri: Xsd_QName,
                               graph: Xsd_QName,
                               ele: RdfModifyItem,
                               last_modified: Xsd_dateTime,
@@ -150,8 +150,8 @@ class RdfModifyProp:
     def shacl(cls, *,
               action: Action,
               graph: Xsd_NCName,
-              owlclass_iri: Iri | None = None,
-              pclass_iri: Iri,
+              owlclass_iri: Xsd_QName | None = None,
+              pclass_iri: Xsd_QName,
               ele: RdfModifyItem,
               last_modified: Xsd_dateTime,
               indent: int = 0, indent_inc: int = 4) -> str:
@@ -164,8 +164,8 @@ class RdfModifyProp:
     def onto(cls, *,
              action: Action,
              graph: Xsd_NCName,
-             owlclass_iri: Iri | None = None,
-             pclass_iri: Iri,
+             owlclass_iri: Xsd_QName | None = None,
+             pclass_iri: Xsd_QName,
              ele: RdfModifyItem,
              last_modified: Xsd_dateTime,
              indent: int = 0, indent_inc: int = 4) -> str:
@@ -177,8 +177,8 @@ class RdfModifyProp:
     @classmethod
     def replace_rdfset(cls, *,
                        action: Action,
-                       owlclass_iri: Iri | None = None,
-                       pclass_iri: Iri,
+                       owlclass_iri: Xsd_QName | None = None,
+                       pclass_iri: Xsd_QName,
                        graph: Xsd_QName,
                        ele: RdfModifyItem,
                        last_modified: Xsd_dateTime,

oldaplib/src/model.py

@@ -46,7 +46,7 @@ class Model:
     _contributor: Iri | None
     _modified: Xsd_dateTime | None
     _attributes: dict[Enum, Any]
-    _changeset: dict[AttributeClass | Iri, AttributeChange]
+    _changeset: dict[AttributeClass | Xsd_QName, AttributeChange]
     _validate: bool
 
     def __init__(self, *,

oldaplib/src/objectfactory.py

@@ -72,7 +72,7 @@ class ResourceInstance:
     :type changeset: dict[Iri, AttributeChange]
     """
     _iri: Iri
-    _values: dict[Iri, LangString | ObservableSet]
+    _values: dict[Xsd_QName, LangString | ObservableSet]
     _graph: Xsd_NCName
     _changeset: dict[Iri, AttributeChange]
 
@@ -104,7 +104,7 @@ class ResourceInstance:
         self._superclass_objs = {}
         self._changeset = {}
 
-        def set_values(propclass: dict[Iri, HasProperty]):
+        def set_values(propclass: dict[Xsd_QName, HasProperty]):
             for prop_iri, hasprop in propclass.items():
                 if kwargs.get(str(prop_iri)) or kwargs.get(prop_iri.fragment):
                     value = kwargs[str(prop_iri)] if kwargs.get(str(prop_iri)) else kwargs[prop_iri.fragment]
@@ -143,20 +143,20 @@ class ResourceInstance:
                         else:
                             self.validate_value(self._values[prop_iri], hasprop.prop)
 
-        def process_superclasses(superclass: dict[Iri, ResourceClass]):
+        def process_superclasses(superclass: dict[Xsd_QName, ResourceClass]):
            for sc_iri, sc in superclass.items():
                 if sc.superclass:
                     process_superclasses(sc.superclass)
-                if sc.owl_class_iri == Iri("oldap:Thing", validate=False):
+                if sc.owl_class_iri == Xsd_QName("oldap:Thing", validate=False):
                     timestamp = Xsd_dateTimeStamp()
-                    if not self._values.get(Iri('oldap:createdBy', validate=False)):
-                        self._values[Iri('oldap:createdBy', validate=False)] = ObservableSet({self._con.userIri})
-                    if not self._values.get(Iri('oldap:creationDate', validate=False)):
-                        self._values[Iri('oldap:creationDate', validate=False)] = ObservableSet({timestamp})
-                    if not self._values.get(Iri('oldap:lastModifiedBy', validate=False)):
-                        self._values[Iri('oldap:lastModifiedBy', validate=False)] = ObservableSet({self._con.userIri})
-                    if not self._values.get(Iri('oldap:lastModificationDate', validate=False)):
-                        self._values[Iri('oldap:lastModificationDate', validate=False)] = ObservableSet({timestamp})
+                    if not self._values.get(Xsd_QName('oldap:createdBy', validate=False)):
+                        self._values[Xsd_QName('oldap:createdBy', validate=False)] = ObservableSet({self._con.userIri})
+                    if not self._values.get(Xsd_QName('oldap:creationDate', validate=False)):
+                        self._values[Xsd_QName('oldap:creationDate', validate=False)] = ObservableSet({timestamp})
+                    if not self._values.get(Xsd_QName('oldap:lastModifiedBy', validate=False)):
+                        self._values[Xsd_QName('oldap:lastModifiedBy', validate=False)] = ObservableSet({self._con.userIri})
+                    if not self._values.get(Xsd_QName('oldap:lastModificationDate', validate=False)):
+                        self._values[Xsd_QName('oldap:lastModificationDate', validate=False)] = ObservableSet({timestamp})
                 set_values(sc.properties)
                 for iri, prop in sc.properties.items():
                     self.properties[iri] = prop
@@ -289,7 +289,7 @@ class ResourceInstance:
                     raise OldapErrorInconsistency(
                         f'Property {property} with LESS_THAN={property[PropClassAttr.LESS_THAN_OR_EQUALS]} has invalid value: "{max_value}" NOT LESS_THAN "{min_other_value}".')
 
-    def notifier(self, prop_iri: Iri):
+    def notifier(self, prop_iri: Xsd_QName):
         hasprop = self.properties[prop_iri]
         self.validate_value(self._values[prop_iri], hasprop)
 
@@ -329,14 +329,14 @@ class ResourceInstance:
                 return False, f'Actor does not have {permission} in project "{self.project.projectShortName}".'
 
     def __get_value(self: Self, prefix: str, fragment: str) -> Xsd | ValueType | None:
-        attr = Iri(Xsd_QName(prefix, fragment, validate=False), validate=False)
+        attr = Xsd_QName(prefix, fragment, validate=False)
         tmp = self._values.get(attr, None)
         if tmp is not None and str(attr) in {'oldap:createdBy', 'oldap:creationDate', 'oldap:lastModifiedBy', 'oldap:lastModificationDate'}:
             return next(iter(tmp))
         return tmp
 
     def __set_value(self: Self, value: ValueType | Xsd | None, prefix: str, fragment: str) -> None:
-        prop_iri = Iri(Xsd_QName(prefix, fragment, validate=False), validate=False)
+        prop_iri = Xsd_QName(prefix, fragment, validate=False)
         hasprop = self.properties.get(prop_iri)
 
         #
@@ -388,7 +388,7 @@ class ResourceInstance:
                 self._values[prop_iri] = convert2datatype(value, hasprop.prop.datatype)
 
     def __del_value(self: Self, prefix: str, fragment: str) -> None:
-        prop_iri = Iri(Xsd_QName(prefix, fragment, validate=False), validate=False)
+        prop_iri = Xsd_QName(prefix, fragment, validate=False)
         hasprop = self.properties.get(prop_iri)
 
         if hasprop.get(HasPropertyAttr.MIN_COUNT):  # testing for MIN_COUNT conformance
@@ -396,7 +396,7 @@ class ResourceInstance:
                 raise OldapErrorValue(f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} cannot be deleted.')
 
         self._changeset[prop_iri] = AttributeChange(self._values.get(prop_iri), Action.DELETE)
-        attr = Iri(Xsd_QName(prefix, fragment, validate=False), validate=False)
+        attr = Xsd_QName(prefix, fragment, validate=False)
         del self._values[attr]
 
     @property
@@ -404,7 +404,7 @@ class ResourceInstance:
         return self._iri
 
     @property
-    def changeset(self) -> dict[Iri, AttributeChange]:
+    def changeset(self) -> dict[Xsd_QName, AttributeChange]:
         return self._changeset
 
     def clear_changeset(self) -> None:
@@ -451,10 +451,10 @@ class ResourceInstance:
 
         timestamp = Xsd_dateTimeStamp()
         if self.name == "Thing":
-            self._values[Iri('oldap:createdBy', validate=False)] = ObservableSet({self._con.userIri})
-            self._values[Iri('oldap:creationDate', validate=False)] = ObservableSet({timestamp})
-            self._values[Iri('oldap:lastModifiedBy', validate=False)] = ObservableSet({self._con.userIri})
-            self._values[Iri('oldap:lastModificationDate', validate=False)] = ObservableSet({timestamp})
+            self._values[Xsd_QName('oldap:createdBy', validate=False)] = ObservableSet({self._con.userIri})
+            self._values[Xsd_QName('oldap:creationDate', validate=False)] = ObservableSet({timestamp})
+            self._values[Xsd_QName('oldap:lastModifiedBy', validate=False)] = ObservableSet({self._con.userIri})
+            self._values[Xsd_QName('oldap:lastModificationDate', validate=False)] = ObservableSet({timestamp})
 
         indent: int = 0
         indent_inc: int = 4

oldaplib/src/oldaplist.py

@@ -383,7 +383,7 @@ class OldapList(Model):
         last_nodeiri = None
         for r in res:
             nodeiri = r['node']
-            if last_nodeiri != nodeiri:
+            if last_nodeiri is None or last_nodeiri != nodeiri:
                 prefix, id = str(nodeiri).split(':')
                 ln = OldapListNode(con=self._con,
                                    **self.info,