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

oldaplib/test/test_hasproperty.py

@@ -11,7 +11,6 @@ from oldaplib.src.helpers.langstring import LangString
 from oldaplib.src.project import Project
 from oldaplib.src.propertyclass import PropertyClass
 from oldaplib.src.resourceclass import ResourceClass
-from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd_boolean import Xsd_boolean
 from oldaplib.src.xsd.xsd_decimal import Xsd_decimal
 from oldaplib.src.xsd.xsd_integer import Xsd_integer
@@ -38,6 +37,7 @@ class TestHasProperty(unittest.TestCase):
 
         cls._context = Context(name="DEFAULT")
         cls._context['test'] = NamespaceIRI("http://oldap.org/test#")
+        cls._context['crm'] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         cls._context.use('test', 'dcterms')
 
         cls._connection = Connection(userId="rosenth",
@@ -64,17 +64,17 @@ class TestHasProperty(unittest.TestCase):
     def test_creation(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:hasprop_test_A'),
+                           property_class_iri=Xsd_QName('test:hasprop_test_A'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["HasPropTest A"]))
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Iri('test:group'), order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, group=Iri('test:group'), order=2),
+            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Xsd_QName('test:group'), order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, group=Xsd_QName('test:group'), order=2),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:HasPropertyTest_A"),
-                           superclass={'oldap:Thing', 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:HasPropertyTest_A"),
+                           superclass={'oldap:Thing', 'crm:E22_Man-Made_Object'},
                            label=LangString(["HAsProptestA@en", "PropeTesteA@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -83,31 +83,31 @@ class TestHasProperty(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_A"))
-        self.assertEqual(r1[Iri('test:hasprop_test_A')].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasprop_test_A')].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasprop_test_A')].order, Xsd_decimal(1))
-        self.assertEqual(r1[Iri('test:hasprop_test_A')].group, Iri('test:group'))
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_A"))
+        self.assertEqual(r1[Xsd_QName('test:hasprop_test_A')].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasprop_test_A')].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasprop_test_A')].order, Xsd_decimal(1))
+        self.assertEqual(r1[Xsd_QName('test:hasprop_test_A')].group, Xsd_QName('test:group'))
 
-        self.assertIsNone(r1[Iri("test:comment")].minCount)
-        self.assertEqual(r1[Iri("test:comment")].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:comment")].order, Xsd_decimal(2))
-        self.assertEqual(r1[Iri("test:comment")].group, Iri('test:group'))
+        self.assertIsNone(r1[Xsd_QName("test:comment")].minCount)
+        self.assertEqual(r1[Xsd_QName("test:comment")].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:comment")].order, Xsd_decimal(2))
+        self.assertEqual(r1[Xsd_QName("test:comment")].group, Xsd_QName('test:group'))
 
     def test_modification_replace(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:hasprop_test_B'),
+                           property_class_iri=Xsd_QName('test:hasprop_test_B'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["HasPropTest B"]))
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Iri('test:group'), order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, group=Iri('test:group'), order=2),
+            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Xsd_QName('test:group'), order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, group=Xsd_QName('test:group'), order=2),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:HasPropertyTest_B"),
-                           superclass={'oldap:Thing', 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:HasPropertyTest_B"),
+                           superclass={'oldap:Thing', 'crm:E22_Man-Made_Object'},
                            label=LangString(["HasProptestB@en", "PropeTesteB@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -116,41 +116,41 @@ class TestHasProperty(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_B"))
-        r1[Iri('test:hasprop_test_B')].maxCount = Xsd_integer(2)
-        r1[Iri('test:hasprop_test_B')].order = Xsd_decimal(2)
-        r1[Iri('test:hasprop_test_B')].group = Iri('test:groupB')
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_B"))
+        r1[Xsd_QName('test:hasprop_test_B')].maxCount = Xsd_integer(2)
+        r1[Xsd_QName('test:hasprop_test_B')].order = Xsd_decimal(2)
+        r1[Xsd_QName('test:hasprop_test_B')].group = Xsd_QName('test:groupB')
 
-        r1[Iri('test:comment')].maxCount = Xsd_integer(2)
-        r1[Iri('test:comment')].order = Xsd_decimal(1)
-        r1[Iri('test:comment')].group = Iri('test:groupB')
+        r1[Xsd_QName('test:comment')].maxCount = Xsd_integer(2)
+        r1[Xsd_QName('test:comment')].order = Xsd_decimal(1)
+        r1[Xsd_QName('test:comment')].group = Xsd_QName('test:groupB')
 
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_B"))
-        self.assertEqual(Xsd_integer(2), r1[Iri('test:hasprop_test_B')].maxCount)
-        self.assertEqual(Xsd_decimal(2), r1[Iri('test:hasprop_test_B')].order)
-        self.assertEqual(Iri('test:groupB'), r1[Iri('test:hasprop_test_B')].group)
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_B"))
+        self.assertEqual(Xsd_integer(2), r1[Xsd_QName('test:hasprop_test_B')].maxCount)
+        self.assertEqual(Xsd_decimal(2), r1[Xsd_QName('test:hasprop_test_B')].order)
+        self.assertEqual(Xsd_QName('test:groupB'), r1[Xsd_QName('test:hasprop_test_B')].group)
 
-        self.assertEqual(Xsd_integer(2), r1[Iri('test:comment')].maxCount)
-        self.assertEqual(Xsd_decimal(1), r1[Iri('test:comment')].order)
-        self.assertEqual(Iri('test:groupB'), r1[Iri('test:comment')].group)
+        self.assertEqual(Xsd_integer(2), r1[Xsd_QName('test:comment')].maxCount)
+        self.assertEqual(Xsd_decimal(1), r1[Xsd_QName('test:comment')].order)
+        self.assertEqual(Xsd_QName('test:groupB'), r1[Xsd_QName('test:comment')].group)
 
     def test_modification_add(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:hasprop_test_C'),
+                           property_class_iri=Xsd_QName('test:hasprop_test_C'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["HasPropTest C"]))
         hasproperties: list[HasProperty] = [
             HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, group=Iri('test:group')),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, group=Xsd_QName('test:group')),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:HasPropertyTest_C"),
-                           superclass={'oldap:Thing', 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:HasPropertyTest_C"),
+                           superclass={'oldap:Thing', 'crm:E22_Man-Made_Object'},
                            label=LangString(["HasProptestC@en", "PropeTesteC@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -159,34 +159,34 @@ class TestHasProperty(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_C"))
-        r1[Iri('test:hasprop_test_C')].maxCount = Xsd_integer(10)
-        #r1[Iri('test:hasprop_test_C')].group = Iri('test:group')
-        #r1[Iri("test:comment")].minCount = Xsd_integer(1)
-        #r1[Iri("test:comment")].order = Xsd_decimal(1)
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_C"))
+        r1[Xsd_QName('test:hasprop_test_C')].maxCount = Xsd_integer(10)
+        #r1[Xsd_QName('test:hasprop_test_C')].group = Xsd_QName('test:group')
+        #r1[Xsd_QName("test:comment")].minCount = Xsd_integer(1)
+        #r1[Xsd_QName("test:comment")].order = Xsd_decimal(1)
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_C"))
-        self.assertEqual(Xsd_integer(10), r1[Iri('test:hasprop_test_C')].maxCount)
-        #self.assertEqual(Iri('test:group'), r1[Iri('test:hasprop_test_C')].group)
-        #self.assertEqual(Xsd_integer(1), r1[Iri("test:comment")].minCount)
-        #self.assertEqual(Xsd_decimal(1), r1[Iri("test:comment")].order)
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_C"))
+        self.assertEqual(Xsd_integer(10), r1[Xsd_QName('test:hasprop_test_C')].maxCount)
+        #self.assertEqual(Xsd_QName('test:group'), r1[Xsd_QName('test:hasprop_test_C')].group)
+        #self.assertEqual(Xsd_integer(1), r1[Xsd_QName("test:comment")].minCount)
+        #self.assertEqual(Xsd_decimal(1), r1[Xsd_QName("test:comment")].order)
 
     def test_modification_delete(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:hasprop_test_D'),
+                           property_class_iri=Xsd_QName('test:hasprop_test_D'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["HasPropTest D"]))
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Iri('test:group'), order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, group=Iri('test:group'), order=2),
+            HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, group=Xsd_QName('test:group'), order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, group=Xsd_QName('test:group'), order=2),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:HasPropertyTest_D"),
-                           superclass={'oldap:Thing', 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:HasPropertyTest_D"),
+                           superclass={'oldap:Thing', 'crm:E22_Man-Made_Object'},
                            label=LangString(["HasProptestC@en", "PropeTesteC@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -195,22 +195,22 @@ class TestHasProperty(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_D"))
-        del r1[Iri('test:hasprop_test_D')].maxCount
-        del r1[Iri('test:hasprop_test_D')].order
-        del r1[Iri('test:comment')].maxCount
-        del r1[Iri('test:comment')].group
-        del r1[Iri('test:comment')].order
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_D"))
+        del r1[Xsd_QName('test:hasprop_test_D')].maxCount
+        del r1[Xsd_QName('test:hasprop_test_D')].order
+        del r1[Xsd_QName('test:comment')].maxCount
+        del r1[Xsd_QName('test:comment')].group
+        del r1[Xsd_QName('test:comment')].order
         r1.update()
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:HasPropertyTest_D"))
-        self.assertIsNone(r1[Iri('test:hasprop_test_D')].maxCount)
-        self.assertIsNone(r1[Iri('test:hasprop_test_D')].order)
-        self.assertIsNone(r1[Iri('test:comment')].maxCount)
-        self.assertIsNone(r1[Iri('test:comment')].group)
-        self.assertIsNone(r1[Iri('test:comment')].order)
+                                owl_class_iri=Xsd_QName("test:HasPropertyTest_D"))
+        self.assertIsNone(r1[Xsd_QName('test:hasprop_test_D')].maxCount)
+        self.assertIsNone(r1[Xsd_QName('test:hasprop_test_D')].order)
+        self.assertIsNone(r1[Xsd_QName('test:comment')].maxCount)
+        self.assertIsNone(r1[Xsd_QName('test:comment')].group)
+        self.assertIsNone(r1[Xsd_QName('test:comment')].order)
 
 
 

oldaplib/test/test_objectfactory.py

@@ -106,7 +106,7 @@ class TestObjectFactory(unittest.TestCase):
         sleep(1)  # upload may take a while...
 
         user = User.read(cls._connection, "rosenth")
-        user.hasPermissions.add(Iri('oldap:GenericUpdate'))
+        user.hasPermissions.add(Iri('oldap:GenericUpdate'))  # TODO: SHOULD WORK WITH Xsd_QName
         user.update()
 
         ps = PermissionSet(con=cls._connection,

oldaplib/test/test_observable_dict.py

@@ -5,6 +5,9 @@ from enum import Enum
 from oldaplib.src.helpers.observable_dict import ObservableDict
 from oldaplib.src.helpers.serializer import serializer
 from oldaplib.src.xsd.iri import Iri
+from oldaplib.src.xsd.xsd_integer import Xsd_integer
+from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
+
 
 class TestObservableDict(unittest.TestCase):
 
@@ -24,6 +27,13 @@ class TestObservableDict(unittest.TestCase):
     def test_json(self):
         obs = ObservableDict({Iri('http://gaga.com/a'): 1, Iri('http://gaga.com/b'): 2, Iri('http://gaga.com/c'): 3, Iri('http://gaga.com/d'): 4})
         jsonstr = json.dumps(obs, default=serializer.encoder_default)
-        print(jsonstr)
         obs2 = json.loads(jsonstr, object_hook=serializer.decoder_hook)
+        pass
         self.assertEqual(obs2, {Iri('http://gaga.com/a'): 1, Iri('http://gaga.com/b'): 2, Iri('http://gaga.com/c'): 3, Iri('http://gaga.com/d'): 4})
+
+    def test_json2(self):
+        obs = ObservableDict()
+        jsonstr = json.dumps(obs, default=serializer.encoder_default)
+        print(jsonstr)
+        obs2 = json.loads(jsonstr, object_hook=serializer.decoder_hook)
+        print(obs2)

oldaplib/test/test_oldaplist.py

@@ -330,18 +330,18 @@ class TestOldapList(unittest.TestCase):
 
         selection = PropertyClass(con=self._connection,
                                   project=self._project,
-                                  property_class_iri=Iri(f'{dm_name}:selection'),
+                                  property_class_iri=Xsd_QName(f'{dm_name}:selection'),
                                   toClass=node_classIri,
                                   name=LangString(["Selection@en", "Selektion@de"]))
 
         resobj = ResourceClass(con=self._connection,
                                project=self._project,
-                               owlclass_iri=Iri(f'{dm_name}:Resobj'),
+                               owlclass_iri=Xsd_QName(f'{dm_name}:Resobj'),
                                label=LangString(["Resobj@en", "Resobj@de"]),
                                hasproperties=[
                                    HasProperty(con=self._connection, project=self._project, prop=selection, maxCount=Xsd_integer(1),
                                                minCount=Xsd_integer(1), order=1)])
-        dm[Iri(f'{dm_name}:resobj')] = resobj
+        dm[Xsd_QName(f'{dm_name}:resobj')] = resobj
         dm.update()
         dm = DataModel.read(self._connection, self._project, ignore_cache=True)
 
@@ -373,22 +373,22 @@ class TestOldapList(unittest.TestCase):
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
                                 prefLabel=Xsd_string("Animals", "en"))
-        self.assertEqual(iris, [Iri('test:animals')])
+        self.assertEqual(iris, [Xsd_QName('test:animals')])
 
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
                                 prefLabel=Xsd_string("Animals"))
-        self.assertEqual(iris, [Iri('test:animals')])
+        self.assertEqual(iris, [Xsd_QName('test:animals')])
 
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
                                 prefLabel=Xsd_string("Pflanzen", "de"))
-        self.assertEqual(iris, [Iri('test:plants')])
+        self.assertEqual(iris, [Xsd_QName('test:plants')])
 
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
                                 prefLabel=Xsd_string("Tier"))
-        self.assertEqual(iris, [Iri('test:animals')])
+        self.assertEqual(iris, [Xsd_QName('test:animals')])
 
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
@@ -404,8 +404,8 @@ class TestOldapList(unittest.TestCase):
         iris = OldapList.search(con=self._connection,
                                 project=self._project,
                                 definition=Xsd_string("hierarchical"))
-        self.assertTrue(Iri('test:animals') in iris)
-        self.assertTrue(Iri('test:plants') in iris)
+        self.assertTrue(Xsd_QName('test:animals') in iris)
+        self.assertTrue(Xsd_QName('test:plants') in iris)
 
 
 

oldaplib/test/test_oldaplistnode.py

@@ -1553,7 +1553,7 @@ class TestOldapListNode(unittest.TestCase):
 
         selection = PropertyClass(con=self._connection,
                                   project=self._dmproject,
-                                  property_class_iri=Iri(f'{dm_name}:selection'),
+                                  property_class_iri=Xsd_QName(f'{dm_name}:selection'),
                                   toClass=node_classIri,
                                   name=LangString(["Selection@en", "Selektion@de"]))
 
@@ -1562,12 +1562,12 @@ class TestOldapListNode(unittest.TestCase):
         #
         resobj = ResourceClass(con=self._connection,
                                project=self._dmproject,
-                               owlclass_iri=Iri(f'{dm_name}:Resobj'),
+                               owlclass_iri=Xsd_QName(f'{dm_name}:Resobj'),
                                label=LangString(["Resobj@en", "Resobj@de"]),
                                hasproperties=[
                                    HasProperty(con=self._connection, project=self._dmproject, prop=selection, maxCount=Xsd_integer(1),
                                                minCount=Xsd_integer(1), order=1)])
-        dm[Iri(f'{dm_name}:resobj')] = resobj
+        dm[Xsd_QName(f'{dm_name}:resobj')] = resobj
         dm.update()
         dm = DataModel.read(self._connection, self._dmproject, ignore_cache=True)
 
@@ -1669,18 +1669,18 @@ class TestOldapListNode(unittest.TestCase):
         #
         selection = PropertyClass(con=self._connection,
                                   project=self._project,
-                                  property_class_iri=Iri(f'{dm_name}:selection2'),
+                                  property_class_iri=Xsd_QName(f'{dm_name}:selection2'),
                                   toClass=node_classIri,
                                   name=LangString(["Selection2@en", "Selektion2@de"]))
 
         resobj = ResourceClass(con=self._connection,
                                project=self._project,
-                               owlclass_iri=Iri(f'{dm_name}:Resobj2'),
+                               owlclass_iri=Xsd_QName(f'{dm_name}:Resobj2'),
                                label=LangString(["Resobj2@en", "Resobj2@de"]),
                                hasproperties=[
                                    HasProperty(con=self._connection, project=self._project, prop=selection, maxCount=Xsd_integer(1),
                                                minCount=Xsd_integer(1), order=1)])
-        dm[Iri(f'{dm_name}:Resobj2')] = resobj
+        dm[Xsd_QName(f'{dm_name}:Resobj2')] = resobj
         dm.update()
         dm = DataModel.read(self._connection, self._project, ignore_cache=True)
 
@@ -2750,61 +2750,61 @@ class TestOldapListNode(unittest.TestCase):
         self.assertEqual(Xsd_integer(8), olBAB.rightIndex)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, id="Node_BA", exactMatch=True)
-        self.assertEqual([Iri("L-TestListY:Node_BA")], irilist)
+        self.assertEqual([Xsd_QName("L-TestListY:Node_BA")], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, id="Node_XX", exactMatch=True)
         self.assertEqual([], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, id="BA")
-        self.assertTrue(Iri("L-TestListY:Node_BA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAB") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAB") in irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="BA@en")
-        self.assertTrue(Iri("L-TestListY:Node_BA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAB") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAB") in irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="BA@zu")
         self.assertEqual([], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="Neud_BA@fr", exactMatch=True)
-        self.assertEqual([Iri("L-TestListY:Node_BA")], irilist)
+        self.assertEqual([Xsd_QName("L-TestListY:Node_BA")], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="BA@en")
-        self.assertTrue(Iri("L-TestListY:Node_BA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAB") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAB") in irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="XX")
         self.assertEqual([], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, prefLabel="Neud_BA", exactMatch=True)
-        self.assertEqual([Iri("L-TestListY:Node_BA")], irilist)
+        self.assertEqual([Xsd_QName("L-TestListY:Node_BA")], irilist)
 
         ##
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="BA@en")
-        self.assertTrue(Iri("L-TestListY:Node_BA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAB") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAB") in irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="BA@zu")
         self.assertEqual([], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="Eine Liste zum Testen BA@de", exactMatch=True)
-        self.assertEqual([Iri("L-TestListY:Node_BA")], irilist)
+        self.assertEqual([Xsd_QName("L-TestListY:Node_BA")], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="BA@en")
-        self.assertTrue(Iri("L-TestListY:Node_BA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAA") in irilist)
-        self.assertTrue(Iri("L-TestListY:Node_BAB") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAA") in irilist)
+        self.assertTrue(Xsd_QName("L-TestListY:Node_BAB") in irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="XX")
         self.assertEqual([], irilist)
 
         irilist = OldapListNode.search(con=self._connection, **oldaplist.info, definition="Eine Liste zum Testen BA", exactMatch=True)
-        self.assertEqual([Iri("L-TestListY:Node_BA")], irilist)
+        self.assertEqual([Xsd_QName("L-TestListY:Node_BA")], irilist)
 
     def test_invalid_move_A(self):
         oldaplist = OldapList(con=self._connection,
@@ -2996,7 +2996,7 @@ class TestOldapListNode(unittest.TestCase):
 
         title = PropertyClass(con=self._connection,
                               project=project,
-                              property_class_iri=Iri(f'{dm_name}:title'),
+                              property_class_iri=Xsd_QName(f'{dm_name}:title'),
                               datatype=XsdDatatypes.langString,
                               name=LangString(["Title@en", "Titel@de"]),
                               description=LangString(["Title of book@en", "Titel des Buches@de"]),
@@ -3005,14 +3005,14 @@ class TestOldapListNode(unittest.TestCase):
 
         category = PropertyClass(con=self._connection,
                                  project=project,
-                                 property_class_iri=Iri(f'{dm_name}:category'),
+                                 property_class_iri=Xsd_QName(f'{dm_name}:category'),
                                  toClass=oldaplist.node_classIri,
                                  name=LangString(["Category@en", "Kategorie@de"]),
                                  description=LangString(["Category@en", "Kategorie@de"]))
 
         categoryitem = ResourceClass(con=self._connection,
                                      project=project,
-                                     owlclass_iri=Iri(f'{dm_name}:CategoryItem'),
+                                     owlclass_iri=Xsd_QName(f'{dm_name}:CategoryItem'),
                                      label=LangString(["CategoryItem@en", "CategoryItem@de"]),
                                      comment=LangString("Something with categories@en"),
                                      closed=Xsd_boolean(True),
@@ -3025,7 +3025,7 @@ class TestOldapListNode(unittest.TestCase):
         #dm.create()
 
         dm = DataModel.read(con=self._connection, project=project)
-        dm[Iri(f'{dm_name}:CategoryItem')] = categoryitem
+        dm[Xsd_QName(f'{dm_name}:CategoryItem')] = categoryitem
         dm.update()
 
         factory = ResourceInstanceFactory(con=self._connection, project=project)

oldaplib/test/test_permissionset.py

@@ -202,7 +202,7 @@ class TestPermissionSet(unittest.TestCase):
         self.assertFalse(ps.definedByProject is ps2.definedByProject)
 
     def test_read_permission_with_iri(self):
-        ps = PermissionSet.read(con=self._connection, iri=Iri('hyha:HyperHamletMember'), ignore_cache=True)
+        ps = PermissionSet.read(con=self._connection, qname=Xsd_QName('hyha:HyperHamletMember'), ignore_cache=True)
         self.assertEqual(ps.givesPermission, DataPermission.DATA_UPDATE)  # add assertion here
         self.assertEqual(ps.label, LangString("HyHaUpdate@en", "HyHaUpdate@de", "HyHaUpdate@fr", "HyHaUpdate@it"))
         self.assertEqual(ps.definedByProject, Iri('oldap:HyperHamlet'))
@@ -309,26 +309,26 @@ class TestPermissionSet(unittest.TestCase):
     def test_search_permission_sets(self):
         iris = PermissionSet.search(self._connection, label="GenericView")
         self.assertEqual(len(iris), 1)
-        self.assertTrue(Iri('oldap:GenericView') in iris)
+        self.assertTrue(Xsd_QName('oldap:GenericView') in iris)
 
         iris = PermissionSet.search(self._connection, label=Xsd_string("GenericView@de"))
         self.assertEqual(len(iris), 1)
-        self.assertTrue(Iri('oldap:GenericView') in iris)
+        self.assertTrue(Xsd_QName('oldap:GenericView') in iris)
 
         iris = PermissionSet.search(self._connection, definedByProject=Iri("oldap:HyperHamlet"))
         self.assertEqual(len(iris), 1)
-        self.assertEqual(Iri('hyha:HyperHamletMember'), iris[0])
+        self.assertEqual(Xsd_QName('hyha:HyperHamletMember'), iris[0])
 
         iris = PermissionSet.search(self._connection, givesPermission=DataPermission.DATA_RESTRICTED)
         #self.assertEqual(len(iris), 1)
-        self.assertEqual([Iri('oldap:GenericRestricted')], iris)
+        self.assertEqual([Xsd_QName('oldap:GenericRestricted')], iris)
 
         iris = PermissionSet.search(self._connection)
-        self.assertEqual({Iri("oldap:GenericRestricted"),
-                          Iri("oldap:GenericView"),
-                          Iri("hyha:HyperHamletMember"),
-                          Iri("oldap:GenericExtend"),
-                          Iri("oldap:GenericUpdate")}, set(iris))
+        self.assertEqual({Xsd_QName("oldap:GenericRestricted"),
+                          Xsd_QName("oldap:GenericView"),
+                          Xsd_QName("hyha:HyperHamletMember"),
+                          Xsd_QName("oldap:GenericExtend"),
+                          Xsd_QName("oldap:GenericUpdate")}, set(iris))
 
     def test_update_permission_set(self):
         ps = PermissionSet(con=self._connection,
@@ -409,7 +409,7 @@ class TestPermissionSet(unittest.TestCase):
 
         irgendwas = PropertyClass(con=self._connection,
                                   project=self._project,
-                                  property_class_iri=Iri(f'{dm_name}:irgendwas'),
+                                  property_class_iri=Xsd_QName(f'{dm_name}:irgendwas'),
                                   datatype=XsdDatatypes.string,
                                   name=LangString(["AnyString@en", "Irgendwas@de"]))
 
@@ -418,18 +418,18 @@ class TestPermissionSet(unittest.TestCase):
         #
         resobj = ResourceClass(con=self._connection,
                                project=self._project,
-                               owlclass_iri=Iri(f'{dm_name}:DummyClass'),
+                               owlclass_iri=Xsd_QName(f'{dm_name}:DummyClass'),
                                label=LangString(["Dummy@en", "Dummy@de"]),
                                hasproperties=[
                                    HasProperty(con=self._connection, project=self._project, prop=irgendwas, maxCount=Xsd_integer(1),
                                                minCount=Xsd_integer(1), order=1)])
-        dm[Iri(f'{dm_name}:resobj')] = resobj
+        dm[Xsd_QName(f'{dm_name}:resobj')] = resobj
         dm.update()
         dm = DataModel.read(self._connection, self._project, ignore_cache=True)
 
         factory = ResourceInstanceFactory(con=self._connection, project=self._project)
         DummyClass = factory.createObjectInstance('DummyClass')
-        r = DummyClass(irgendwas="Dies ist irgend ein String", grantsPermission=Iri('oldap:GenericUpdate'))
+        r = DummyClass(irgendwas="Dies ist irgend ein String", grantsPermission=Xsd_QName('oldap:GenericUpdate'))
         r.create()
 
         ps = PermissionSet.read(con=self._connection, permissionSetId="GenericUpdate", definedByProject=Iri('oldap:SystemProject'), ignore_cache=True)

oldaplib/test/test_project.py

@@ -124,7 +124,7 @@ class Testproject(unittest.TestCase):
     # @unittest.skip('Work in progress')
     def test_project_search(self):
         projects = Project.search(con=self._connection, label="HyperHamlet")
-        self.assertEqual({ProjectSearchResult(Iri("oldap:HyperHamlet"), Xsd_NCName("hyha"))}, set(projects))
+        self.assertEqual({ProjectSearchResult(Xsd_QName("oldap:HyperHamlet"), Xsd_NCName("hyha"))}, set(projects))
 
     # @unittest.skip('Work in progress')
     def test_project_search_fail(self):
@@ -133,9 +133,9 @@ class Testproject(unittest.TestCase):
 
     def test_project_search_all(self):
         projects = Project.search(con=self._connection)
-        self.assertTrue(set(projects) >= {ProjectSearchResult(Iri("oldap:SystemProject"), Xsd_NCName("oldap")),
-                          ProjectSearchResult(Iri("oldap:SharedProject"), Xsd_NCName("shared")),
-                          ProjectSearchResult(Iri("oldap:HyperHamlet"), Xsd_NCName("hyha")),
+        self.assertTrue(set(projects) >= {ProjectSearchResult(Xsd_QName("oldap:SystemProject"), Xsd_NCName("oldap")),
+                          ProjectSearchResult(Xsd_QName("oldap:SharedProject"), Xsd_NCName("shared")),
+                          ProjectSearchResult(Xsd_QName("oldap:HyperHamlet"), Xsd_NCName("hyha")),
                           ProjectSearchResult(Iri("http://www.salsah.org/version/2.0/SwissBritNet"), Xsd_NCName("britnet"))})
 
     def test_project_create_simplest(self):