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

oldaplib/test/test_dtypes.py

@@ -13,6 +13,7 @@ from oldaplib.src.helpers.numeric import Numeric
 from oldaplib.src.helpers.oldaperror import OldapErrorValue, OldapErrorType
 from oldaplib.src.helpers.query_processor import QueryProcessor
 from oldaplib.src.helpers.serializer import serializer
+from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd import Xsd
 from oldaplib.src.xsd.xsd_anyuri import Xsd_anyURI
 from oldaplib.src.xsd.xsd_float import Xsd_float
@@ -93,7 +94,7 @@ class MyTestCase(unittest.TestCase):
         ns1 = NamespaceIRI('http://www.org/test/')
         self.assertEqual(str(ns1), 'http://www.org/test/')
         self.assertEqual(repr(ns1), 'NamespaceIRI("http://www.org/test/")')
-        self.assertEqual(ns1.toRdf, '"http://www.org/test/"^^xsd:anyURI')
+        self.assertEqual(ns1.toRdf, '<http://www.org/test/>')
         self.assertEqual(ns1 + "gaga", Xsd_anyURI("http://www.org/test/gaga"))
 
         ns2 = NamespaceIRI('http://www.org/test#')
@@ -106,7 +107,7 @@ class MyTestCase(unittest.TestCase):
 
         self.create_triple("NamespaceIRI", ns1)
         valx = self.get_triple("NamespaceIRI")
-        self.assertIsInstance(valx, Xsd_anyURI)
+        self.assertIsInstance(valx, Iri)
         if isinstance(valx, Xsd_anyURI):
             self.assertEqual(ns1, NamespaceIRI(valx))
 

oldaplib/test/test_externalontologies.py

@@ -0,0 +1,175 @@
+import unittest
+from pathlib import Path
+from time import sleep
+from tkinter.font import names
+
+from oldaplib.src.connection import Connection
+from oldaplib.src.datamodel import DataModel
+from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
+from oldaplib.src.enums.language import Language
+from oldaplib.src.externalontology import ExternalOntology
+from oldaplib.src.helpers.context import Context
+from oldaplib.src.helpers.langstring import LangString
+from oldaplib.src.helpers.oldaperror import OldapErrorNotFound, OldapError, OldapErrorImmutable
+from oldaplib.src.project import Project
+from oldaplib.src.xsd.iri import Iri
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
+
+
+def find_project_root(current_path):
+    # Climb up the directory hierarchy and check for a marker file
+    path = Path(current_path).absolute()
+    while not (path / 'pyproject.toml').exists():
+        if path.parent == path:
+            # Root of the filesystem, file not found
+            raise RuntimeError('Project root not found')
+        path = path.parent
+    return path
+
+
+class TestexternalOntologies(unittest.TestCase):
+
+    _connection: Connection
+    _unpriv: Connection
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        project_root = find_project_root(__file__)
+        cls._context = Context(name="DEFAULT")
+
+        cls._connection = Connection(userId="rosenth",
+                                     credentials="RioGrande",
+                                     context_name="DEFAULT")
+        cls._unpriv = Connection(userId="fornaro",
+                                 credentials="RioGrande",
+                                 context_name="DEFAULT")
+
+
+        cls._connection.clear_graph(Xsd_QName('oldap:admin'))
+        file = project_root / 'oldaplib' / 'ontologies' / 'admin.trig'
+        cls._connection.upload_turtle(file)
+        file = project_root / 'oldaplib' / 'ontologies' / 'admin-testing.trig'
+        cls._connection.upload_turtle(file)
+        sleep(1)  # upload may take a while...
+
+        project = Project(con=cls._connection,
+                          projectIri=Iri("http://extonto.test.org/test"),
+                          projectShortName="testext",
+                          namespaceIri=NamespaceIRI("http://extonto.test.org/test/ns/"))
+        project.create()
+
+        dm = DataModel(con=cls._connection, project=project)
+        dm.create()
+
+
+    @classmethod
+    def tearDownClass(cls):
+        cls._connection.clear_graph(Xsd_QName('testext:shacl'))
+        cls._connection.clear_graph(Xsd_QName('testext:onto'))
+        #cls._connection.upload_turtle("oldaplib/ontologies/admin.trig")
+        #sleep(1)  # upload may take a while...
+        pass
+
+    def test_create(self):
+        p = Project.read(con=self._connection, projectIri_SName="testext", ignore_cache=True)
+        dm = DataModel.read(con=self._connection, project="testext", ignore_cache=True)
+
+        eo1 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaA",
+                               label=LangString("GAGA A ontology@en", "Gaga A Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaA/"))
+        eo1.create()
+        del eo1
+
+        eo1 = ExternalOntology.read(con=self._connection, projectShortName="testext", prefix="gagaA", ignore_cache=True)
+        self.assertEqual(eo1.prefix, "gagaA")
+        self.assertEqual(eo1.label, LangString("GAGA A ontology@en", "Gaga A Ontologie@de"))
+        self.assertEqual(eo1.namespaceIri, NamespaceIRI("http://gaga.org/ns/gagaA/"))
+
+        ExternalOntology.delete_all(con=self._connection, projectShortName="testext")
+        pass
+
+
+    def test_update(self):
+        p = Project.read(con=self._connection, projectIri_SName="testext", ignore_cache=True)
+        dm = DataModel.read(con=self._connection, project="testext", ignore_cache=True)
+
+        eo1 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaB",
+                               label=LangString("GAGA B ontology@en", "Gaga B Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaB/"))
+        eo1.create()
+
+        del eo1
+        eo1 = ExternalOntology.read(con=self._connection, projectShortName="testext", prefix="gagaB", ignore_cache=True)
+        eo1.prefix = "gugus"
+        eo1.comment = LangString("Gugus comment@en", "Gugus Kommentar@de")
+        del eo1.label[Language.DE]
+        eo1.label[Language.FR] = "GAGA B ontologie"
+        eo1.update()
+
+        del eo1
+        eo1 = ExternalOntology.read(con=self._connection, projectShortName="testext", prefix="gagaB", ignore_cache=True)
+        self.assertEqual(eo1.prefix, "gugus")
+        self.assertEqual(eo1.label, LangString("GAGA B ontology@en", "GAGA B ontologie@fr"))
+        self.assertEqual(eo1.comment, LangString("Gugus comment@en", "Gugus Kommentar@de"))
+        self.assertEqual(eo1.namespaceIri, NamespaceIRI("http://gaga.org/ns/gagaB/"))
+
+        with self.assertRaises(OldapErrorImmutable):
+            eo1.namespaceIri = NamespaceIRI("http://gaga.org/ns/gaga2/new/")
+
+        ExternalOntology.delete_all(con=self._connection, projectShortName="testext")
+
+    def test_search(self):
+        p = Project.read(con=self._connection, projectIri_SName="testext", ignore_cache=True)
+        dm = DataModel.read(con=self._connection, project="testext", ignore_cache=True)
+
+        eo1 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaC",
+                               label=LangString("GAGA C ontology@en", "Gaga C Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaC/"))
+        eo1.create()
+
+        eo2 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaD",
+                               label=LangString("GAGA D ontology@en", "Gaga D Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaD/"))
+        eo2.create()
+
+        res = ExternalOntology.search(con=self._connection, projectShortName="testext")
+        qnames = [x.extonto_qname for x in res]
+        self.assertEqual(set(qnames), {Xsd_QName('testext:gagaC'), Xsd_QName('testext:gagaD')})
+
+        ExternalOntology.delete_all(con=self._connection, projectShortName="testext")
+
+    def test_delete(self):
+        p = Project.read(con=self._connection, projectIri_SName="testext", ignore_cache=True)
+        dm = DataModel.read(con=self._connection, project="testext", ignore_cache=True)
+
+        eo1 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaE",
+                               label=LangString("GAGA E ontology@en", "Gaga E Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaE/"))
+        eo1.create()
+
+        eo2 = ExternalOntology(con=self._connection,
+                               projectShortName="testext",
+                               prefix="gagaF",
+                               label=LangString("GAGA F ontology@en", "Gaga F Ontologie@de"),
+                               namespaceIri=NamespaceIRI("http://gaga.org/ns/gagaF/"))
+        eo2.create()
+        res = ExternalOntology.search(con=self._connection, projectShortName="testext", prefix="gagaF")
+        self.assertEqual(len(res), 1)
+        res[0].delete()
+
+        ExternalOntology.delete_all(con=self._connection, projectShortName="testext")
+
+
+
+

oldaplib/test/test_project.py

@@ -16,7 +16,8 @@ from oldaplib.src.xsd.xsd_qname import Xsd_QName
 from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
 from oldaplib.src.xsd.xsd_date import Xsd_date
 from oldaplib.src.helpers.langstring import LangString
-from oldaplib.src.helpers.oldaperror import OldapErrorNotFound, OldapErrorInconsistency, OldapErrorNoPermission
+from oldaplib.src.helpers.oldaperror import OldapErrorNotFound, OldapErrorInconsistency, OldapErrorNoPermission, \
+    OldapErrorAlreadyExists
 from oldaplib.src.project import Project, ProjectSearchResult
 from oldaplib.src.helpers.serializer import serializer
 
@@ -90,6 +91,9 @@ class Testproject(unittest.TestCase):
         self.assertEqual(project.projectEnd, project2.projectEnd)
 
 
+    def test_project_read_with_uses_ontologies(self):
+        project = Project.read(con=self._connection, projectIri_SName="hyha", ignore_cache=True)
+
     # @unittest.skip('Work in progress')
     def test_project_read(self):
         project = Project.read(con=self._connection, projectIri_SName=Iri("oldap:SystemProject"), ignore_cache=True)
@@ -260,83 +264,33 @@ class Testproject(unittest.TestCase):
         project = Project.read(con=self._connection, projectIri_SName="unittest6", ignore_cache=True)
         project.delete()
 
-    def test_project_create_with_external_ontologies_A(self):
-        project = Project(con=self._connection,
-                          projectShortName="WithExternalOntologiesA",
-                          label=LangString("External Ontologies"),
-                          namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
-                          comment=LangString(["For testingXX@en", "Für TestsXX@de"]),
-                          projectStart=Xsd_date(2024, 3, 3),
-                          projectEnd=Xsd_date(2027, 3, 2),
-                          usesExternalOntology={
-                              Xsd_NCName("prefix1"): NamespaceIRI("http://prefix1.org/"),
-                              Xsd_NCName("prefix2"): NamespaceIRI("http://prefix2.org/")
-                          })
-        project.create()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesA", ignore_cache=True)
-        self.assertEqual(project.usesExternalOntology, {
-                              Xsd_NCName("prefix1"): NamespaceIRI("http://prefix1.org/"),
-                              Xsd_NCName("prefix2"): NamespaceIRI("http://prefix2.org/")
-                          })
+    def test_duplicate_project_create(self):
+        project1 = Project(con=self._connection,
+                           projectShortName="unittestXX",
+                           namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
+                           label=LangString(["unittestXX@en", "unittestXX@de"]))
+        project1.create()
+        project2 = Project(con=self._connection,
+                           projectShortName="unittestXX",
+                           namespaceIri=NamespaceIRI("http://unitest.org/project/unittestYY#"),
+                           label=LangString(["unittestXX@en", "unittestXX@de"]))
+        with self.assertRaises(OldapErrorAlreadyExists) as ex:
+            project2.create()
 
-    def test_project_create_with_external_ontologies_B(self):
-        project = Project(con=self._connection,
-                          projectShortName="WithExternalOntologiesB",
-                          label=LangString("External Ontologies"),
-                          namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
-                          comment=LangString(["For testingXX@en", "Für TestsXX@de"]),
-                          projectStart=Xsd_date(2024, 3, 3),
-                          projectEnd=Xsd_date(2027, 3, 2),
-                          usesExternalOntology={
-                              Xsd_NCName("prefix1"): NamespaceIRI("http://prefix1.org/"),
-                              Xsd_NCName("prefix2"): NamespaceIRI("http://prefix2.org/")
-                          })
-        project.create()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesB", ignore_cache=True)
-        del project.usesExternalOntology
-        project.update()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesB", ignore_cache=True)
-        self.assertIsNone(project.usesExternalOntology)
-
-    def test_project_create_with_external_ontologies_C(self):
-        project = Project(con=self._connection,
-                          projectShortName="WithExternalOntologiesC",
-                          label=LangString("External Ontologies"),
-                          namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
-                          comment=LangString(["For testingXX@en", "Für TestsXX@de"]),
-                          projectStart=Xsd_date(2024, 3, 3),
-                          projectEnd=Xsd_date(2027, 3, 2))
-        project.create()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesC", ignore_cache=True)
-        project.usesExternalOntology = {Xsd_NCName('prefix') : NamespaceIRI('http://prefix.org/')}
-        project.update()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesC", ignore_cache=True)
-        self.assertEqual(project.usesExternalOntology, {Xsd_NCName('prefix') : NamespaceIRI('http://prefix.org/')})
-
-    def test_project_create_with_external_ontologies_D(self):
-        project = Project(con=self._connection,
-                          projectShortName="WithExternalOntologiesD",
-                          label=LangString("External Ontologies"),
-                          namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
-                          comment=LangString(["For testingXX@en", "Für TestsXX@de"]),
-                          projectStart=Xsd_date(2024, 3, 3),
-                          projectEnd=Xsd_date(2027, 3, 2),
-                          usesExternalOntology={
-                              Xsd_NCName("prefix1"): NamespaceIRI("http://prefix1.org/"),
-                              Xsd_NCName("prefix2"): NamespaceIRI("http://prefix2.org/")
-                          })
-        project.create()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesD", ignore_cache=True)
-        del project.usesExternalOntology['prefix1']
-        project.usesExternalOntology[Xsd_NCName('prefix2')] = NamespaceIRI("http://prefix2.org/CHANGED/")
-        project.usesExternalOntology[Xsd_NCName('prefix3')] = NamespaceIRI("http://prefix3.org/")
-        project.update()
-        project = Project.read(con=self._connection, projectIri_SName="WithExternalOntologiesD", ignore_cache=True)
-        self.assertEqual(project.usesExternalOntology, {
-                              Xsd_NCName("prefix2"): NamespaceIRI("http://prefix2.org/CHANGED/"),
-                              Xsd_NCName("prefix3"): NamespaceIRI("http://prefix3.org/")
-                          })
+        project3 = Project(con=self._connection,
+                           projectShortName="unittestYY",
+                           namespaceIri=NamespaceIRI("http://unitest.org/project/unittestXX#"),
+                           label=LangString(["unittestXX@en", "unittestXX@de"]))
+        with self.assertRaises(OldapErrorAlreadyExists) as ex:
+            project3.create()
 
+        project4 = Project(con=self._connection,
+                           projectIri=project1.projectIri,
+                           projectShortName="unittestZZ",
+                           namespaceIri=NamespaceIRI("http://unitest.org/project/unittestZZ#"),
+                           label=LangString(["unittestZZ@en", "unittestZZ@de"]))
+        with self.assertRaises(OldapErrorAlreadyExists) as ex:
+            project4.create()
 
     def test_project_create_without_label_comment(self):
         project = Project(con=self._connection,
@@ -352,6 +306,7 @@ class Testproject(unittest.TestCase):
         project = Project.read(con=self._connection, projectIri_SName="emptyfieldsXX", ignore_cache=True)
         project.delete()
 
+
     def test_project_create_empty_fields(self):
         project = Project(con=self._connection,
                           projectShortName="emptyfields1",

oldaplib/test/test_propertyclass.py

@@ -16,6 +16,7 @@ from oldaplib.src.enums.propertyclassattr import PropClassAttr
 from oldaplib.src.enums.xsd_datatypes import XsdDatatypes
 from oldaplib.src.helpers.context import Context
 from oldaplib.src.helpers.langstring import LangString, LangStringChange
+from oldaplib.src.helpers.observable_set import ObservableSet
 from oldaplib.src.helpers.oldaperror import OldapErrorAlreadyExists, OldapErrorValue, OldapErrorNoPermission, \
     OldapErrorInconsistency
 from oldaplib.src.helpers.query_processor import QueryProcessor
@@ -70,6 +71,8 @@ class TestPropertyClass(unittest.TestCase):
         cls._connection.upload_turtle(file)
         sleep(1)  # upload may take a while...
         cls._project = Project.read(cls._connection, "test")
+        cls._sysproject = Project.read(cls._connection, "oldap")
+
 
     @classmethod
     def tearDownClass(cls):
@@ -90,6 +93,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p.get(PropClassAttr.DATATYPE), XsdDatatypes.string)
         self.assertEqual(p.get(PropClassAttr.NAME), LangString(["Test property@en", "Testprädikat@de"]))
         self.assertEqual(p.get(PropClassAttr.DESCRIPTION), LangString("A property for testing...@en", "Property für Tests@de"))
+        self.assertEqual(p.get(PropClassAttr.TYPE), {OwlPropertyType.OwlDataProperty})
 
     def test_star_propertyclass_constructor(self):
         p = PropertyClass(con=self._connection,
@@ -104,6 +108,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p.get(PropClassAttr.DATATYPE), XsdDatatypes.string)
         self.assertEqual(p.get(PropClassAttr.NAME), LangString(["Test property@en", "Testprädikat@de"]))
         self.assertEqual(p.get(PropClassAttr.DESCRIPTION), LangString("A property for testing...@en", "Property für Tests@de"))
+        self.assertEqual(p[PropClassAttr.TYPE], {OwlPropertyType.StatementProperty, OwlPropertyType.OwlDataProperty})
 
     def test_propertyclass_inset_datatypes(self):
         p = PropertyClass(con=self._connection,
@@ -166,6 +171,7 @@ class TestPropertyClass(unittest.TestCase):
                            project=self._project,
                            toClass=Xsd_QName('test:Person'))
         self.assertEqual(p2.get(PropClassAttr.CLASS), Xsd_QName('test:Person'))
+        self.assertEqual(p2.get(PropClassAttr.TYPE), {OwlPropertyType.OwlObjectProperty})
 
     def test_propertyclass_toclass_constructor_invalid_A(self):
         with self.assertRaises(OldapErrorValue):
@@ -212,6 +218,24 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p4a.get(PropClassAttr.LANGUAGE_IN), LanguageIn(Language.EN, Language.FR))
         self.assertEqual(p4a.get(PropClassAttr.DATATYPE), XsdDatatypes.langString)
 
+    def test_propertyclass_owltype_constructor(self):
+        p4 = PropertyClass(con=self._connection,
+                           project=self._project,
+                           property_class_iri=Xsd_QName('test:testprop4c'),
+                           type={OwlPropertyType.SymmetricProperty},
+                           datatype=XsdDatatypes.string)
+        p4.create()
+        self.assertEqual(p4.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
+        p4 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testprop4c'),
+                                ignore_cache=True)
+        self.assertEqual(p4.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
+
+        p4.type.add(OwlPropertyType.TransitiveProperty)
+        p4.update()
+        self.assertEqual(p4.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.TransitiveProperty, OwlPropertyType.OwlDataProperty})
+
     def test_propertyclass_inconsistent_constructor(self):
         with self.assertRaises(OldapErrorValue):
             p5 = PropertyClass(con=self._connection,
@@ -238,6 +262,12 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p6.get(PropClassAttr.DATATYPE), XsdDatatypes.langString)
 
 
+    def test_propertyclass_read_projectshape(self):
+        p = PropertyClass.read(con=self._connection,
+                               project=self._sysproject,
+                               property_class_iri=Xsd_QName('oldap:namespaceIri'),
+                               ignore_cache=True)
+
     # @unittest.skip('Work in progress')
     def test_propertyclass_read_shacl(self):
         p1 = PropertyClass.read(con=self._connection,
@@ -255,8 +285,8 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p1.description, LangString("This is a test property@de"))
         self.assertIsNone(p1.get(PropClassAttr.SUBPROPERTY_OF))
         self.assertIsNone(p1.subPropertyOf)
-        self.assertEqual(p1.get(PropClassAttr.TYPE), OwlPropertyType.OwlDataProperty)
-        self.assertEqual(p1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(p1.get(PropClassAttr.TYPE), {OwlPropertyType.OwlDataProperty})
+        self.assertEqual(p1.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(p1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(p1.created, Xsd_dateTime("2023-11-04T12:00:00Z"))
 
@@ -268,7 +298,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p2[PropClassAttr.NAME], LangString("Test"))
         self.assertEqual(p2[PropClassAttr.DESCRIPTION], LangString("Property shape for testing purposes"))
         self.assertEqual(p2[PropClassAttr.DATATYPE], XsdDatatypes.string)
-        self.assertEqual(p2[PropClassAttr.TYPE], OwlPropertyType.OwlDataProperty)
+        self.assertEqual(p2[PropClassAttr.TYPE], {OwlPropertyType.OwlDataProperty})
 
         p3 = PropertyClass.read(con=self._connection,
                                 project=self._project,
@@ -342,14 +372,20 @@ class TestPropertyClass(unittest.TestCase):
     def test_propertyclass_create_D(self):
         pX = PropertyClass(
             con=self._connection,
-            #graph=Xsd_NCName('test'),
             project=self._project,
-            property_class_iri=Xsd_QName('test:testWrite'),
+            property_class_iri=Xsd_QName('test:testWriteABC'),
+            datatype=XsdDatatypes.int
+        )
+        pX.create()
+        pX = PropertyClass(
+            con=self._connection,
+            project=self._project,
+            property_class_iri=Xsd_QName('test:testWriteABC'),
             datatype=XsdDatatypes.int
         )
         with self.assertRaises(OldapErrorAlreadyExists) as ex:
             pX.create()
-        self.assertEqual(str(ex.exception), 'Property "test:testWrite" already exists.')
+        self.assertEqual(str(ex.exception), 'Property "test:testWriteABC" already exists.')
 
     def test_propertyclass_create_E(self):
         p = PropertyClass(
@@ -367,6 +403,19 @@ class TestPropertyClass(unittest.TestCase):
         self.assertTrue(p.statementProperty)
         self.assertEqual(p.get(PropClassAttr.DATATYPE), XsdDatatypes.string)
 
+    def test_propertyclass_create_F(self):
+        p4 = PropertyClass(con=self._connection,
+                           project=self._project,
+                           property_class_iri=Xsd_QName('test:testpropF'),
+                           type={OwlPropertyType.SymmetricProperty},
+                           datatype=XsdDatatypes.string)
+        p4.create()
+        p4 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testpropF'),
+                                ignore_cache=True)
+        self.assertEqual(p4.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
+
     def test_propertyclass_create_nopermission(self):
         p1 = PropertyClass(
             con=self._unpriv,
@@ -763,6 +812,44 @@ class TestPropertyClass(unittest.TestCase):
         for r in res:
             self.assertIn(r['comment'], [Xsd_string("description english@en"), Xsd_string("description français@fr")])
 
+    def test_propertyclass_update7(self):
+        p7 = PropertyClass(con=self._connection,
+                           project=self._project,
+                           property_class_iri=Xsd_QName('test:testprop7'),
+                           type={OwlPropertyType.SymmetricProperty},
+                           datatype=XsdDatatypes.string)
+        p7.create()
+        p7 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testprop7'),
+                                ignore_cache=True)
+        p7.type.add(OwlPropertyType.TransitiveProperty)
+        p7.update()
+        p7 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testprop7'),
+                                ignore_cache=True)
+        self.assertEqual(p7.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.TransitiveProperty, OwlPropertyType.OwlDataProperty})
+
+    def test_propertyclass_update8(self):
+        p8 = PropertyClass(con=self._connection,
+                           project=self._project,
+                           property_class_iri=Xsd_QName('test:testprop8'),
+                           type={OwlPropertyType.SymmetricProperty, OwlPropertyType.TransitiveProperty},
+                           datatype=XsdDatatypes.string)
+        p8.create()
+        p8 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testprop8'),
+                                ignore_cache=True)
+        p8.type.remove(OwlPropertyType.TransitiveProperty)
+        p8.update()
+        p8 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:testprop8'),
+                                ignore_cache=True)
+        self.assertEqual(p8.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
+
     # @unittest.skip('Work in progress')
     def test_propertyclass_delete_attrs(self):
         p1 = PropertyClass(

oldaplib/test/test_resourceclass.py

@@ -212,7 +212,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(r1[Xsd_QName("test:testprop")].order, Xsd_decimal(3))
         self.assertEqual(prop3.internal, Xsd_QName('test:TestResource'))
         self.assertEqual(prop3.property_class_iri, Xsd_QName("test:testprop"))
-        self.assertEqual(prop3.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop3.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(prop3.datatype, XsdDatatypes.langString)
         self.assertEqual(prop3.name, LangString(["Test property@en", "Testprädikat@de"]))
         self.assertEqual(prop3.subPropertyOf, Xsd_QName("test:comment"))
@@ -657,7 +657,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
         self.assertEqual(prop1.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop1.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
-        self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
         self.assertEqual(r1[Xsd_QName('test:test')].minCount, Xsd_integer(1))
@@ -671,7 +671,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop2.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
         self.assertEqual(prop2.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop2.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
-        self.assertEqual(prop2.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop2.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(prop2.datatype, XsdDatatypes.langString)
         self.assertEqual(prop2.name, LangString(["A text@en", "Ein Text@de"]))
         self.assertEqual(prop2.description, LangString("A longer text..."))
@@ -680,7 +680,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(r1[Xsd_QName('test:hasText')].order, Xsd_decimal(1))
 
         prop3 = r1[Xsd_QName('test:hasEnum')].prop
-        self.assertEqual(prop3.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop3.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(prop3.datatype, XsdDatatypes.string)
         self.assertEqual(prop3.inSet,
                          RdfSet(Xsd_string('red'), Xsd_string('green'), Xsd_string('blue'), Xsd_string('yellow')))
@@ -826,7 +826,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.name, LangString(["comment@en", "Kommentar@de"]))
         self.assertEqual(prop1.description, LangString("This is a test property@de"))
         self.assertIsNone(prop1.subPropertyOf)
-        self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(prop1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop1.created, Xsd_dateTime("2023-11-04T12:00:00Z"))
         self.assertEqual(r2[Xsd_QName("test:comment")].order, Xsd_decimal(1))
@@ -838,7 +838,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop2.name, LangString("Test"))
         self.assertEqual(prop2.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop2.datatype, XsdDatatypes.string)
-        self.assertEqual(prop2.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop2.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(r2[Xsd_QName("test:test")].order, Xsd_decimal(2))
 
         prop3 = r2[Xsd_QName("test:testone")].prop
@@ -1159,7 +1159,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
         self.assertEqual(r2[Xsd_QName('test:test')].order, Xsd_decimal(3))
-        self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlDataProperty})
 
     def test_updating_add_int_prop(self):
         r1 = ResourceClass.read(con=self._connection,
@@ -1185,7 +1185,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.internal, Xsd_QName("test:testMyResMinimalB"))
         self.assertEqual(prop1.toClass, Xsd_QName('test:Person'))
         self.assertEqual(r2[Xsd_QName('dcterms:contributor')].maxCount, Xsd_integer(1))
-        self.assertEqual(prop1.type, OwlPropertyType.OwlObjectProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlObjectProperty})
 
     # @unittest.skip('Work in progress')
     def test_updating_add(self):
@@ -1234,7 +1234,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.name, LangString("Test"))
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
-        self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlDataProperty})
         self.assertEqual(r2[Xsd_QName('test:test')].minCount, Xsd_integer(1))
         self.assertEqual(r2[Xsd_QName('test:test')].order, Xsd_decimal(3))
 
@@ -1242,7 +1242,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop2.internal, Xsd_QName("test:testMyResMinimalC"))
         self.assertEqual(prop2.toClass, Xsd_QName('test:Person'))
         self.assertEqual(r2[Xsd_QName('dcterms:creator')].maxCount, Xsd_integer(1))
-        self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
+        self.assertEqual(prop1.type, {OwlPropertyType.OwlDataProperty})
 
         prop3 = r2[Xsd_QName('test:color')].prop
         self.assertEqual(prop3.internal, Xsd_QName("test:testMyResMinimalC"))