oldaplib 0.3.15__tar.gz → 0.3.17__tar.gz

{oldaplib-0.3.15 → oldaplib-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oldaplib
-Version: 0.3.15
+Version: 0.3.17
 Summary: Open Media Access Server Library (Linked Open Data middleware/RESTApi)
 License: GNU Affero General Public License version 3
 Author: Lukas Rosenthaler

{oldaplib-0.3.15 → oldaplib-0.3.17}/oldaplib/src/helpers/observable_set.py

@@ -290,10 +290,10 @@ class ObservableSet(Notify):
                       field: Iri,
                       ignoreitems: Set[Any] | None = None,
                       indent: int = 0, indent_inc: int = 4) -> list[str]:
-        items_to_add = self._setdata - self._old_value.to_set()
+        items_to_add = self._setdata - self._old_value.to_set() if self._old_value else self._setdata
         if ignoreitems:
             items_to_add = items_to_add - ignoreitems
-        items_to_delete = self._old_value.to_set() - self._setdata
+        items_to_delete = self._old_value.to_set() - self._setdata if self._old_value else set()
         if ignoreitems:
             items_to_delete = items_to_delete - ignoreitems
         blank = ''

{oldaplib-0.3.15 → oldaplib-0.3.17}/oldaplib/src/propertyclass.py

@@ -166,7 +166,7 @@ class PropertyClass(Model, Notify):
     _projectShortName: Xsd_NCName
     _projectIri: Iri
     _property_class_iri: Xsd_QName | None
-    _statementProperty: Xsd_boolean
+    __statementProperty: Xsd_boolean
     _externalOntology: Xsd_boolean
     _internal: Xsd_QName | None
     _force_external: bool
@@ -197,7 +197,6 @@ class PropertyClass(Model, Notify):
                  property_class_iri: Xsd_QName | str | None = None,
                  notifier: Callable[[PropClassAttr], None] | None = None,
                  notify_data: PropClassAttr | None = None,
-                 _statementProperty: bool | Xsd_boolean= False,
                  _externalOntology: bool | Xsd_boolean = False,
                  _internal: Xsd_QName | None = None,  # DO NOT USE!! Only for serialization!
                  _force_external: bool | None = None,  # DO NOT USE!! Only for serialization!
@@ -256,7 +255,7 @@ class PropertyClass(Model, Notify):
                        validate=validate)
         Notify.__init__(self, notifier, notify_data)
 
-        self._statementProperty = _statementProperty if isinstance(_statementProperty, Xsd_boolean) else Xsd_boolean(_statementProperty, validate=True)
+        #self.__statementProperty = _statementProperty if isinstance(_statementProperty, Xsd_boolean) else Xsd_boolean(_statementProperty, validate=True)
         self._externalOntology = _externalOntology if isinstance(_externalOntology, Xsd_boolean) else Xsd_boolean(_externalOntology, validate=True)
         if self._externalOntology:
             self._force_external = True
@@ -315,11 +314,20 @@ class PropertyClass(Model, Notify):
         if self._attributes.get(PropClassAttr.DATATYPE) is not None and self._attributes.get(PropClassAttr.CLASS) is not None:
             raise OldapErrorInconsistency(f'It\'s not possible to use both DATATYPE="{self._attributes[PropClassAttr.DATATYPE]}" and CLASS={self._attributes[PropClassAttr.CLASS]} restrictions.')
 
-        # setting property type for OWL which distinguished between Data- and Object-properties
         if not self._attributes.get(PropClassAttr.TYPE):
             self._attributes[PropClassAttr.TYPE] = ObservableSet(notifier=self.notifier, notify_data=PropClassAttr.TYPE)
-        if self._statementProperty:
-            self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.StatementProperty)
+
+        #
+        # process the statement property stuff
+        #
+        if OwlPropertyType.StatementProperty in self._attributes[PropClassAttr.TYPE]:
+            self.__statementProperty = Xsd_boolean(True)
+        else:
+            self.__statementProperty = Xsd_boolean(False)
+
+        #
+        # setting property type for OWL which distinguished between Data- and Object-properties
+        #
         if self._attributes.get(PropClassAttr.CLASS) is not None:
             if OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
                 raise OldapErrorInconsistency(f'Property {self._property_class_iri} cannot be both a link property and a data property.')
@@ -374,7 +382,7 @@ class PropertyClass(Model, Notify):
             **({'_internal': self._internal} if self._internal else {}),
             **({'_force_external': self._force_external} if self._force_external else {}),
             **({'_externalOntology': self._externalOntology} if self._externalOntology else {}),
-            **({'_statementProperty': self._statementProperty} if self._statementProperty else {}),
+            **({'__statementProperty': self.__statementProperty} if self.__statementProperty else {}),
             '_from_triplestore': self.__from_triplestore,
         }
 
@@ -469,6 +477,15 @@ class PropertyClass(Model, Notify):
                 self._changeset[PropClassAttr.DATATYPE] = AttributeChange(None, Action.CREATE)
             self._attributes[PropClassAttr.DATATYPE] = value
 
+    def _del_value(self, attr: PropClassAttr) -> None:
+        if attr == PropClassAttr.TYPE:
+            remaining = self._attributes.get(attr) & {OwlPropertyType.OwlObjectProperty, OwlPropertyType.OwlDataProperty}
+            to_delete = self._attributes.get(attr) - remaining
+            for x in to_delete:
+                self._attributes[attr].discard(x)
+                return
+        super()._del_value(attr)
+
     def _change_setter(self: Self, attr: PropClassAttr, value: PropTypes) -> None:
         """
         INTERNAL USE ONLY! Overrides the method _change_setter from the Model class.
@@ -481,6 +498,12 @@ class PropertyClass(Model, Notify):
         """
         if not isinstance(attr, PropClassAttr):
             raise OldapError(f'Unsupported prop {attr}')
+        if attr == PropClassAttr.TYPE and value is None:
+            remaining = self._attributes.get(attr) & {OwlPropertyType.OwlObjectProperty, OwlPropertyType.OwlDataProperty}
+            to_delete = self._attributes.get(attr) - remaining
+            for x in to_delete:
+                self._attributes[attr].discard(x)
+                return
         if self._attributes.get(attr) == value:
             return
         super()._change_setter(attr, value)
@@ -510,7 +533,7 @@ class PropertyClass(Model, Notify):
                         notifier=self._notifier,
                         data=deepcopy(self._notify_data, memo))
         # Copy internals of Model:
-        instance._statementProperty = deepcopy(self._statementProperty, memo)
+        instance.__statementProperty = deepcopy(self.__statementProperty, memo)
         instance._externalOntology = deepcopy(self._externalOntology, memo)
         instance._attributes = deepcopy(self._attributes, memo)
         instance._changset = deepcopy(self._changeset, memo)
@@ -572,14 +595,14 @@ class PropertyClass(Model, Notify):
         """
         return self._internal
 
-    @property
-    def statementProperty(self) -> Xsd_boolean:
-        """
-        Return the statementProperty
-        :return: statementProperty
-        :rtype: bool
-        """
-        return self._statementProperty
+    # @property
+    # def statementProperty(self) -> Xsd_boolean:
+    #     """
+    #     Return the statementProperty
+    #     :return: statementProperty
+    #     :rtype: bool
+    #     """
+    #     return self.__statementProperty
 
     @property
     def externalOntology(self) -> Xsd_boolean:
@@ -807,7 +830,7 @@ class PropertyClass(Model, Notify):
                     raise OldapError(f'Inconsistency in SHACL "dcterms:modified (type={type(val)})"')
             elif key == 'oldap:statementProperty':
                 if isinstance(val, Xsd_boolean):
-                    self._statementProperty = val
+                    self.__statementProperty = val
                 else:
                     raise OldapError(f'Inconsistency in SHACL "oldap:statementProperty (type={type(val)})"')
             elif key == 'oldap:externalOntology':
@@ -925,12 +948,12 @@ class PropertyClass(Model, Notify):
         #
         # Consistency checks
         #
-        if self._statementProperty:
+        if self.__statementProperty:
             if OwlPropertyType.StatementProperty not in self._attributes.get(PropClassAttr.TYPE):
-                raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" is a statementProperty, but not an StatementProperty.')
+                raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" has SHACL oldap:statementProperty, but missing rdf:type rdf:Property.')
         else:
             if OwlPropertyType.StatementProperty in self._attributes.get(PropClassAttr.TYPE):
-                raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" is not a statementProperty, but an StatementProperty.')
+                raise OldapErrorInconsistency(f'Property "{self._property_class_iri}" has no SHACL oldap:statementProperty, but a rdf:type rdf:Property.')
         if OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
             if not datatype:
                 raise OldapError(f'OwlDataProperty "{self._property_class_iri}" has no rdfs:range datatype defined!')
@@ -1052,7 +1075,7 @@ class PropertyClass(Model, Notify):
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:created {timestamp.toRdf}'
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:contributor {self._con.userIri.toRdf}'
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:modified {timestamp.toRdf}'
-        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:statementProperty {self._statementProperty.toRdf}'
+        sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:statementProperty {self.__statementProperty.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}oldap:externalOntology {self._externalOntology.toRdf}'
         for prop, value in self._attributes.items():
             if not prop.in_shacl:
@@ -1324,14 +1347,32 @@ class PropertyClass(Model, Notify):
                                                                   indent=indent, indent_inc=indent_inc)
                 elif prop.datatype == ObservableSet:
                     if prop == PropClassAttr.TYPE:
-                        continue
-                #     sparql += self._attributes[prop].update_shacl(graph=self._graph,
-                #                                                   owlclass_iri=owlclass_iri,
-                #                                                   prop_iri=self._property_class_iri,
-                #                                                   attr=prop,
-                #                                                   modified=self._modified,
-                #                                                   indent=indent, indent_inc=indent_inc)
-                #     print(gaga)
+                        if self._attributes[prop].old_value:
+                            added = set(self._attributes[PropClassAttr.TYPE]) - set(self._attributes[prop].old_value)
+                        else:
+                            added = set(self._attributes[PropClassAttr.TYPE])
+                        if OwlPropertyType.StatementProperty in added:
+                            self.__statementProperty = Xsd_boolean(True)
+                            ele = RdfModifyItem(Xsd_QName('oldap:statementProperty'), Xsd_boolean(False), Xsd_boolean(True))
+                            sparql += RdfModifyProp.shacl(action=change.action,
+                                                          graph=self._graph,
+                                                          owlclass_iri=owlclass_iri,
+                                                          pclass_iri=self._property_class_iri,
+                                                          ele=ele,
+                                                          last_modified=self._modified)
+                        if self._attributes[prop].old_value:
+                            removed = set(self._attributes[prop].old_value) - set(self._attributes[PropClassAttr.TYPE])
+                        else:
+                            removed = set()
+                        if OwlPropertyType.StatementProperty in removed:
+                            self.__statementProperty = Xsd_boolean(False)
+                            ele = RdfModifyItem(Xsd_QName('oldap:statementProperty'), Xsd_boolean(True), Xsd_boolean(False))
+                            sparql += RdfModifyProp.shacl(action=change.action,
+                                                          graph=self._graph,
+                                                          owlclass_iri=owlclass_iri,
+                                                          pclass_iri=self._property_class_iri,
+                                                          ele=ele,
+                                                          last_modified=self._modified)
                 else:
                     raise OldapError(f'SHACL property {prop.value} should not have update action "MODIFY" ({prop.datatype}).')
                 sparql_list.append(sparql)
@@ -1623,6 +1664,7 @@ class PropertyClass(Model, Notify):
         try:
             self._con.transaction_update(sparql)
         except OldapError as e:
+            print(sparql)
             self._con.transaction_abort()
             raise
 

oldaplib-0.3.17/oldaplib/src/version.py

@@ -0,0 +1 @@
+__version__ = "0.3.17"

{oldaplib-0.3.15 → oldaplib-0.3.17}/oldaplib/test/test_propertyclass.py

@@ -100,12 +100,12 @@ class TestPropertyClass(unittest.TestCase):
         p = PropertyClass(con=self._connection,
                           project=self._project,
                           property_class_iri=Xsd_QName('test:testpropstar'),
-                          _statementProperty=True,
+                          type={OwlPropertyType.StatementProperty},
                           datatype=XsdDatatypes.string,
                           name=LangString(["Test property@en", "Testprädikat@de"]),
                           description={"A property for testing...@en", "Property für Tests@de"})
         self.assertEqual(p.property_class_iri, Xsd_QName('test:testpropstar'))
-        self.assertTrue(p.statementProperty)
+        self.assertTrue(OwlPropertyType.StatementProperty in p.type)
         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"))
@@ -457,7 +457,7 @@ class TestPropertyClass(unittest.TestCase):
             con=self._connection,
             project=self._project,
             property_class_iri=Xsd_QName('test:testWriteStar'),
-            _statementProperty=True,
+            type={OwlPropertyType.StatementProperty},
             datatype=XsdDatatypes.string,
         )
         p.create()
@@ -465,7 +465,7 @@ class TestPropertyClass(unittest.TestCase):
                                 project=self._project,
                                 property_class_iri=Xsd_QName('test:testWriteStar'),
                                 ignore_cache=True)
-        self.assertTrue(p.statementProperty)
+        self.assertTrue(OwlPropertyType.StatementProperty in p.type)
         self.assertEqual(p.get(PropClassAttr.DATATYPE), XsdDatatypes.string)
 
     def test_propertyclass_create_F(self):
@@ -654,7 +654,7 @@ class TestPropertyClass(unittest.TestCase):
 
 
     # @unittest.skip('Work in progress')
-    def test_propertyclass_update(self):
+    def test_propertyclass_update_01(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -698,7 +698,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertFalse(p2[PropClassAttr.UNIQUE_LANG])
 
     # @unittest.skip('Work in progress')
-    def test_propertyclass_update2(self):
+    def test_propertyclass_update_02(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -739,7 +739,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p2.inSet, RdfSet(Xsd_string("gaga"), Xsd_string("is was")))
         self.assertFalse(p2.uniqueLang)
 
-    def test_propertyclass_update3(self):
+    def test_propertyclass_update_03(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -784,7 +784,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertIsNone(p2.languageIn)
         self.assertIsNone(p2.uniqueLang)
 
-    def test_propertyclass_update4(self):
+    def test_propertyclass_update_04(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -817,7 +817,7 @@ class TestPropertyClass(unittest.TestCase):
         self.assertEqual(p2.description, LangString("An annotation@en"))
 
 
-    def test_propertyclass_update5(self):
+    def test_propertyclass_update_05(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -851,7 +851,7 @@ class TestPropertyClass(unittest.TestCase):
                                        Xsd_string("nom français@fr"),
                                        Xsd_string("name deutsch@de")])
 
-    def test_propertyclass_update6(self):
+    def test_propertyclass_update_06(self):
         p1 = PropertyClass(
             con=self._connection,
             project=self._project,
@@ -901,7 +901,7 @@ 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):
+    def test_propertyclass_update_07(self):
         p7 = PropertyClass(con=self._connection,
                            project=self._project,
                            property_class_iri=Xsd_QName('test:testprop7'),
@@ -920,7 +920,7 @@ class TestPropertyClass(unittest.TestCase):
                                 ignore_cache=True)
         self.assertEqual(p7.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.TransitiveProperty, OwlPropertyType.OwlDataProperty})
 
-    def test_propertyclass_update8(self):
+    def test_propertyclass_update_08(self):
         p8 = PropertyClass(con=self._connection,
                            project=self._project,
                            property_class_iri=Xsd_QName('test:testprop8'),
@@ -939,7 +939,7 @@ class TestPropertyClass(unittest.TestCase):
                                 ignore_cache=True)
         self.assertEqual(p8.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
 
-    def test_propertyclass_update9(self):
+    def test_propertyclass_update_09(self):
         i = PropertyClass(con=self._connection,
                           project=self._project,
                           property_class_iri=Xsd_QName('test:isChild9'),
@@ -957,6 +957,109 @@ class TestPropertyClass(unittest.TestCase):
                                 ignore_cache=True)
         self.assertEqual(i2.get(PropClassAttr.INVERSE_OF), Xsd_QName('test:anotherParent'))
 
+    def test_propertyclass_update_10(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild10'),
+                          toClass=Iri('test:Human'),
+                          inverseOf=Xsd_QName('test:isParent10'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.type = [OwlPropertyType.FunctionalProperty]
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild10'),
+                                ignore_cache=True)
+        self.assertTrue({OwlPropertyType.FunctionalProperty} <= set(i2.type))
+
+    def test_propertyclass_update_11(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild11'),
+                          type={OwlPropertyType.FunctionalProperty, OwlPropertyType.StatementProperty, OwlPropertyType.TransitiveProperty},
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.type.discard(OwlPropertyType.FunctionalProperty)
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild11'),
+                                ignore_cache=True)
+        self.assertTrue({OwlPropertyType.StatementProperty, OwlPropertyType.TransitiveProperty} <= set(i2.type))
+        self.assertTrue(OwlPropertyType.FunctionalProperty not in i2.type)
+
+    def test_propertyclass_update_12(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild12'),
+                          type={OwlPropertyType.FunctionalProperty, OwlPropertyType.TransitiveProperty},
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.type.add(OwlPropertyType.StatementProperty)
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild12'),
+                                ignore_cache=True)
+        self.assertTrue({OwlPropertyType.StatementProperty, OwlPropertyType.FunctionalProperty, OwlPropertyType.TransitiveProperty} <= set(i2.type))
+
+    def test_propertyclass_update_13(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild13'),
+                          type={OwlPropertyType.StatementProperty},
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.type.discard(OwlPropertyType.StatementProperty)
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild13'),
+                                ignore_cache=True)
+        self.assertTrue(OwlPropertyType.StatementProperty not in set(i2.type))
+
+    def test_propertyclass_update_14(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild14'),
+                          type={OwlPropertyType.StatementProperty},
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.type = None
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild14'),
+                                ignore_cache=True)
+        self.assertTrue(OwlPropertyType.StatementProperty not in set(i2.type))
+
+    def test_propertyclass_update_15(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild15'),
+                          type={OwlPropertyType.StatementProperty},
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        del i.type
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild15'),
+                                ignore_cache=True)
+        self.assertTrue(OwlPropertyType.StatementProperty not in set(i2.type))
+
     # @unittest.skip('Work in progress')
     def test_propertyclass_delete_attrs(self):
         p1 = PropertyClass(

{oldaplib-0.3.15 → oldaplib-0.3.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "oldaplib"
-version = "0.3.15"
+version = "0.3.17"
 description = "Open Media Access Server Library (Linked Open Data middleware/RESTApi)"
 authors = ["Lukas Rosenthaler <lukas.rosenthaler@unibas.ch>"]
 license = "GNU Affero General Public License version 3"

oldaplib-0.3.15/oldaplib/src/version.py

@@ -1 +0,0 @@
-__version__ = "0.3.15"