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

oldaplib/test/test_datamodel.py

@@ -9,6 +9,7 @@ from oldaplib.src.cachesingleton import CacheSingletonRedis
 from oldaplib.src.connection import Connection
 from oldaplib.src.datamodel import DataModel, PropertyClassChange, ResourceClassChange
 from oldaplib.src.dtypes.languagein import LanguageIn
+from oldaplib.src.externalontology import ExternalOntology
 from oldaplib.src.helpers.context import Context
 from oldaplib.src.enums.action import Action
 from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
@@ -371,7 +372,8 @@ class TestDataModel(unittest.TestCase):
         model = DataModel.read(self._connection, self._sysproject, ignore_cache=True)
         self.assertEqual(set(model.get_propclasses()), {
             Xsd_QName("oldap:hasAdminPermission"),
-            Xsd_QName("oldap:statementProperty")
+            Xsd_QName("oldap:statementProperty"),
+            Xsd_QName("oldap:namespaceIri")
         })
         self.assertEqual(set(model.get_resclasses()), {
             Xsd_QName("oldap:Project"),
@@ -389,6 +391,19 @@ class TestDataModel(unittest.TestCase):
     def test_datamodel_read_shared(self):
         model = DataModel.read(self._connection, self._sharedproject, ignore_cache=True)
 
+    def test_datamodel_read_system(self):
+        model = DataModel.read(self._connection, self._sysproject, ignore_cache=True)
+
+    def test_datamodel_read_test(self):
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        ontos = model.get_extontos()
+        crm = model[Xsd_QName('test:crm')]
+        self.assertEqual(crm.prefix, 'crm')
+        self.assertEqual(crm.namespaceIri, 'http://www.cidoc-crm.org/cidoc-crm/')
+        context = model.context
+        self.assertEqual(context['crm'], 'http://www.cidoc-crm.org/cidoc-crm/')
+
+
     def test_datamodel_cache(self):
         start = time()
         model = DataModel.read(self._connection, self._sysproject, ignore_cache=True)
@@ -488,6 +503,7 @@ class TestDataModel(unittest.TestCase):
         #
         dm[Xsd_QName(f'{dm_name}:Book')][Xsd_QName(f'{dm_name}:authors')].prop.name[Language.FR] = "Ecrivain(s)"
 
+
         #
         # Add a new property as internal property
         #
@@ -584,6 +600,39 @@ class TestDataModel(unittest.TestCase):
         tmp = set([key for key, val in dm[Xsd_QName(f'{dm_name}:Book')].superclass.items()])
         assert tmp == {'oldap:Thing', 'dcterms:Event'}
 
+    def test_datamodel_extonto_motify(self):
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        model[Xsd_QName('test:crm')].label['it'] = 'CIDOC-CRM (it)'
+        model.update()
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+
+        crm = model[Xsd_QName('test:crm')]
+        self.assertEqual(crm.prefix, 'crm')
+        self.assertEqual(crm.namespaceIri, 'http://www.cidoc-crm.org/cidoc-crm/')
+        self.assertEqual(crm.label, LangString("CIDOC-CRM@en", "CIDOC-CRM@de", "CIDOC-CRM@fr", "CIDOC-CRM (it)@it"))
+
+    def test_datamodel_extonto_delete(self):
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        self.assertIsInstance(model.get(Xsd_QName('test:edm')), ExternalOntology)
+        del model[Xsd_QName('test:edm')]
+        model.update()
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        self.assertIsNone(model.get(Xsd_QName('test:edm')))
+
+    def test_datamodel_extonto_add(self):
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        eo = ExternalOntology(con=self._connection,
+                             projectShortName=self._project.projectShortName,
+                             prefix='testonto',
+                             namespaceIri='http://www.example.org/ns/testonto#',
+                             label=LangString("Test ontology@en", "Test ontology@de"))
+        model[Xsd_QName('test:testonto')] = eo
+        model.update()
+        model = DataModel.read(self._connection, self._project, ignore_cache=True)
+        self.assertIsInstance(model.get(Xsd_QName('test:testonto')), ExternalOntology)
+
+        context = model.context
+        self.assertEqual(context['testonto'], 'http://www.example.org/ns/testonto#')
 
     def test_incremental_generation(self):
         dm = DataModel(con=self._connection,

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(