oldaplib 0.3.4__tar.gz → 0.3.6__tar.gz

{oldaplib-0.3.4 → oldaplib-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: oldaplib
-Version: 0.3.4
+Version: 0.3.6
 Summary: Open Media Access Server Library (Linked Open Data middleware/RESTApi)
 License: GNU Affero General Public License version 3
 Author: Lukas Rosenthaler
@@ -9,6 +9,7 @@ Requires-Python: >=3.12,<4.0
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: bcrypt (==5.0.0)
 Requires-Dist: bump2version (>=1.0.1,<2.0.0)
 Requires-Dist: cloudpickle (>=3.1.1,<4.0.0)

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/enums/attributeclass.py

@@ -1,8 +1,13 @@
-from enum import Enum
-from typing import Type, Self
+from enum import Enum, Flag, auto
+from typing import Type, Self, Any
 
 from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
+class Target(Flag):
+    SHACL = auto()
+    OWL = auto()
+    BOTH = SHACL | OWL    # convenience alias
+
 
 class AttributeClass(Enum):
     """
@@ -10,7 +15,12 @@ class AttributeClass(Enum):
     Project, PropertyClass, ResourceClass, User etc.,
     """
 
-    def __new__(cls, value: Xsd_QName | str, mandatory: bool, immutable: bool, datatype: Type):
+    def __new__(cls,
+                value: Xsd_QName | str,
+                mandatory: bool,
+                immutable: bool,
+                datatype: Type,
+                target: Target = Target.BOTH):
         """
         :param value: The value of the attribute-enum item. Must have the form of a QName!
         :param mandatory: True, if this attribute is mandatory, False otherwise.
@@ -23,6 +33,7 @@ class AttributeClass(Enum):
         member._mandatory = mandatory
         member._immutable = immutable
         member._datatype = datatype
+        member._target = target
         return member
 
     def __str__(self) -> str:
@@ -48,6 +59,23 @@ class AttributeClass(Enum):
     def immutable(self) -> bool:
         return self._immutable
 
+    @property
+    def target(self) -> Target:
+        """Where this attribute should be emitted/used (SHACL, OWL, BOTH)."""
+        return self._target
+
+    @property
+    def in_shacl(self) -> bool:
+        return bool(self._target & Target.SHACL)
+
+    @property
+    def in_owl(self) -> bool:
+        return bool(self._target & Target.OWL)
+
+    @property
+    def to_rdf(self) -> str:
+        return self._value.toRdf
+
     @classmethod
     def from_value(cls, value: Xsd_QName | str) -> Self:
         """
@@ -73,6 +101,3 @@ class AttributeClass(Enum):
                 return member
         raise ValueError(f"No member with name {name} found")
 
-    @property
-    def to_rdf(self) -> str:
-        return self._value.toRdf

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/enums/externalontologyattr.py

@@ -15,7 +15,7 @@ class ExternalOntologyAttr(AttributeClass):
     (QName, mandatory, immutable, datatype)
     """
     # order: (QName, mandatory, immutable, datatype)
-    PREFIX = ('oldap:prefix', True, False, Xsd_NCName)
+    PREFIX = ('oldap:prefix', True, True, Xsd_NCName)
     NAMESPACE_IRI = ('oldap:namespaceIri', True, True, NamespaceIRI)
     LABEL = ('rdfs:label', False, False, LangString)
     COMMENT = ('rdfs:comment', False, False, LangString)

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/enums/owlpropertytype.py

@@ -19,8 +19,8 @@ class OwlPropertyType(Enum):
     IrreflexiveProperty = 'owl:IrreflexiveProperty'
     FunctionalProperty = 'owl:FunctionalProperty'
     InverseFunctionalProperty = 'owl:InverseFunctionalProperty'
-    # InverseOfProperty = 'owl:InverseOfProperty'
-    # EquivalentProperty = 'owl:EquivalentProperty'
+    # InverseOfProperty = 'owl:inverseOf'
+    # EquivalentProperty = 'owl:equivalentProperty'
     # _owl_inverseOf: Xsd_QName  # :hasParent owl:inverseOf :hasChild .
     # _owl_equivalent: Xsd_QName  # :hasSpouse owl:equivalentProperty :marriedTo .
 

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/enums/propertyclassattr.py

@@ -3,7 +3,7 @@ from typing import Self
 
 from oldaplib.src.dtypes.languagein import LanguageIn
 from oldaplib.src.dtypes.xsdset import XsdSet
-from oldaplib.src.enums.attributeclass import AttributeClass
+from oldaplib.src.enums.attributeclass import AttributeClass, Target
 from oldaplib.src.enums.xsd_datatypes import XsdDatatypes
 from oldaplib.src.helpers.langstring import LangString
 from oldaplib.src.helpers.numeric import Numeric
@@ -12,6 +12,7 @@ from oldaplib.src.helpers.observable_set import ObservableSet
 from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd_boolean import Xsd_boolean
 from oldaplib.src.xsd.xsd_integer import Xsd_integer
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
 from oldaplib.src.xsd.xsd_string import Xsd_string
 
 
@@ -35,26 +36,28 @@ class PropClassAttr(AttributeClass):
     - `PropertyClassAttribute.DESCRIPTION`: Description of the property. The literal is a string that may
       have attached a language id.
     """
-    # order: (QName, mandatory, immutable, datatype)
+    # order: (QName, mandatory, immutable, datatype, target)
     SUBPROPERTY_OF = ('rdfs:subPropertyOf', False, False, Iri)
-    TYPE = ('rdf:type', False, False, ObservableSet)
-    CLASS = ('sh:class', False, False, Iri)
-    NODEKIND = ('sh:nodeKind', False, False, Iri)
-    DATATYPE = ('sh:datatype', False, False, XsdDatatypes)
-    NAME = ('sh:name', False, False, LangString)  # needs notifier
-    DESCRIPTION = ('sh:description', False, False, LangString)  # needs notifier
-    LANGUAGE_IN = ('sh:languageIn', False, False, LanguageIn)  # needs notifier
-    UNIQUE_LANG = ('sh:uniqueLang', False, False, Xsd_boolean)
-    IN = ('sh:in', False, False, XsdSet)  # needs notifier
-    MIN_LENGTH = ('sh:minLength', False, False, Xsd_integer)
-    MAX_LENGTH = ('sh:maxLength', False, False, Xsd_integer)
-    PATTERN = ('sh:pattern', False, False, Xsd_string)
-    MIN_EXCLUSIVE = ('sh:minExclusive', False, False, Numeric)
-    MIN_INCLUSIVE = ('sh:minInclusive', False, False, Numeric)
-    MAX_EXCLUSIVE = ('sh:maxExclusive', False, False, Numeric)
-    MAX_INCLUSIVE = ('sh:maxInclusive', False, False, Numeric)
-    LESS_THAN = ('sh:lessThan', False, False, Iri)
-    LESS_THAN_OR_EQUALS = ('sh:lessThanOrEquals', False, False, Iri)
+    TYPE = ('rdf:type', False, False, ObservableSet, Target.OWL)
+    CLASS = ('sh:class', False, False, Iri, Target.SHACL)
+    NODEKIND = ('sh:nodeKind', False, False, Iri, Target.SHACL)
+    DATATYPE = ('sh:datatype', False, False, XsdDatatypes, Target.SHACL)
+    NAME = ('sh:name', False, False, LangString, Target.SHACL)  # needs notifier
+    DESCRIPTION = ('sh:description', False, False, LangString, Target.SHACL)  # needs notifier
+    LANGUAGE_IN = ('sh:languageIn', False, False, LanguageIn, Target.SHACL)  # needs notifier
+    UNIQUE_LANG = ('sh:uniqueLang', False, False, Xsd_boolean, Target.SHACL)
+    IN = ('sh:in', False, False, XsdSet, Target.SHACL)  # needs notifier
+    MIN_LENGTH = ('sh:minLength', False, False, Xsd_integer, Target.SHACL)
+    MAX_LENGTH = ('sh:maxLength', False, False, Xsd_integer, Target.SHACL)
+    PATTERN = ('sh:pattern', False, False, Xsd_string, Target.SHACL)
+    MIN_EXCLUSIVE = ('sh:minExclusive', False, False, Numeric, Target.SHACL)
+    MIN_INCLUSIVE = ('sh:minInclusive', False, False, Numeric, Target.SHACL)
+    MAX_EXCLUSIVE = ('sh:maxExclusive', False, False, Numeric, Target.SHACL)
+    MAX_INCLUSIVE = ('sh:maxInclusive', False, False, Numeric, Target.SHACL)
+    LESS_THAN = ('sh:lessThan', False, False, Iri, Target.SHACL)
+    LESS_THAN_OR_EQUALS = ('sh:lessThanOrEquals', False, False, Iri, Target.SHACL)
+    INVERSE_OF = ('owl:inverseOf', False, False, Xsd_QName, Target.OWL)
+    EQUIVALEND_PROPERTY = ('owl:equivalentProperty', False, False, Xsd_QName, Target.OWL)
 
 
     @classmethod

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/objectfactory.py

@@ -144,7 +144,9 @@ class ResourceInstance:
                             self.validate_value(self._values[prop_iri], hasprop.prop)
 
         def process_superclasses(superclass: dict[Xsd_QName, ResourceClass]):
-           for sc_iri, sc in superclass.items():
+            for sc_iri, sc in superclass.items():
+                if not sc:
+                    continue
                 if sc.superclass:
                     process_superclasses(sc.superclass)
                 if sc.owl_class_iri == Xsd_QName("oldap:Thing", validate=False):

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/propertyclass.py

@@ -823,6 +823,8 @@ class PropertyClass(Model, Notify):
                 group = val
             elif key in propkeys:
                 attr = PropClassAttr.from_value(key)
+                if not attr.in_shacl:
+                    continue
                 if attr.datatype == Numeric:
                     if not isinstance(val, (Xsd_integer, Xsd_float)):
                         raise OldapErrorInconsistency(f'SHACL inconsistency: "{attr.value}" expects a "Xsd:integer" or "Xsd:float", but got "{type(val).__name__}".')
@@ -858,6 +860,7 @@ class PropertyClass(Model, Notify):
     def read_owl(self) -> None:
         if self._externalOntology:
             return
+        propkeys = {Xsd_QName(x.value) for x in PropClassAttr}
         context = Context(name=self._con.context_name)
         query1 = context.sparql_context
         query1 += f"""
@@ -878,24 +881,12 @@ class PropertyClass(Model, Notify):
             obj = r['o']
             match attr:
                 case 'rdf:type':
-                    if obj == 'owl:DatatypeProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlDataProperty)
-                    elif obj == 'owl:ObjectProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.OwlObjectProperty)
-                    elif obj == 'rdf:Property':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.StatementProperty)
-                    elif obj == 'owl:TransitiveProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.TransitiveProperty)
-                    elif obj == 'owl:SymmetricProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.SymmetricProperty)
-                    elif obj == 'owl:ReflexiveProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.ReflexiveProperty)
-                    elif obj == 'owl:IrreflexiveProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.IrreflexiveProperty)
-                    elif obj == 'owl:InverseFunctionalProperty':
-                        self._attributes[PropClassAttr.TYPE].add(OwlPropertyType.InverseFunctionalProperty)
-                    else:
-                        raise OldapErrorNotFound(f'Unknown owl:Property type "{obj}"')
+                    try:
+                        # If obj is already a member, keep it; otherwise look it up by value
+                        prop_type = obj if isinstance(obj, OwlPropertyType) else OwlPropertyType(obj)
+                    except ValueError as e:
+                        raise OldapErrorNotFound(f'Unknown owl:Property type "{obj}"') from e
+                    self._attributes[PropClassAttr.TYPE].add(prop_type)
                 case 'owl:subPropertyOf':
                     self._attributes[PropClassAttr.SUBPROPERTY_OF] = obj
                 case 'rdfs:range':
@@ -919,6 +910,11 @@ class PropertyClass(Model, Notify):
                     dt = obj
                     if self._modified != dt:
                         raise OldapError(f'Inconsistency between SHACL and OWL: created "{self._modified}" vs "{dt}" for property "{self._property_class_iri}".')
+                case _:
+                    if attr in propkeys:
+                        pcattr = PropClassAttr.from_value(attr)
+                        if pcattr.in_owl:
+                            self._attributes[pcattr] = pcattr.datatype(obj)
         #
         # Consistency checks
         #
@@ -1052,7 +1048,7 @@ class PropertyClass(Model, Notify):
         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 prop == PropClassAttr.TYPE:
+            if not prop.in_shacl:
                 continue
             if not value and not isinstance(value, bool):
             #if value is None:
@@ -1085,24 +1081,47 @@ class PropertyClass(Model, Notify):
 
     def create_owl_part1(self, timestamp: Xsd_dateTime, indent: int = 0, indent_inc: int = 4) -> str:
         blank = ''
-        sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} rdf:type {self._attributes[PropClassAttr.TYPE].toRdf}'
-        if self._attributes.get(PropClassAttr.SUBPROPERTY_OF):
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:subPropertyOf {self._attributes[PropClassAttr.SUBPROPERTY_OF].toRdf}'
+        sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} {PropClassAttr.TYPE.toRdf} {self._attributes[PropClassAttr.TYPE].toRdf}'
         if self._internal:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:domain {self._internal.toRdf}'
         if self._attributes.get(PropClassAttr.TYPE) and  OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.DATATYPE].value}'
         elif self._attributes.get(PropClassAttr.TYPE) and OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
             sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.CLASS].toRdf}'
+        for attr, val in self._attributes.items():
+            #attr = PropClassAttr.from_value(key)
+            if not attr.in_owl or attr == PropClassAttr.TYPE or val is None:
+                continue
+            if attr == PropClassAttr.NAME:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {val.toRdf}'
+            elif attr == PropClassAttr.DESCRIPTION:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {val.toRdf}'
+            else:
+                sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}{attr.toRdf} {val.toRdf}'
         sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
         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}'
-        if self.name:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {self.name.toRdf}'
-        if self.description:
-            sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {self.description.toRdf}'
         sparql += ' .\n'
+
+        # sparql = f'{blank:{indent * indent_inc}}{self._property_class_iri.toRdf} rdf:type {self._attributes[PropClassAttr.TYPE].toRdf}'
+        # if self._attributes.get(PropClassAttr.SUBPROPERTY_OF):
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:subPropertyOf {self._attributes[PropClassAttr.SUBPROPERTY_OF].toRdf}'
+        # if self._internal:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:domain {self._internal.toRdf}'
+        # if self._attributes.get(PropClassAttr.TYPE) and  OwlPropertyType.OwlDataProperty in self._attributes[PropClassAttr.TYPE]:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.DATATYPE].value}'
+        # elif self._attributes.get(PropClassAttr.TYPE) and OwlPropertyType.OwlObjectProperty in self._attributes[PropClassAttr.TYPE]:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:range {self._attributes[PropClassAttr.CLASS].toRdf}'
+        # sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}dcterms:creator {self._con.userIri.toRdf}'
+        # 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}'
+        # if self.name:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:label {self.name.toRdf}'
+        # if self.description:
+        #     sparql += f' ;\n{blank:{(indent + 1) * indent_inc}}rdfs:comment {self.description.toRdf}'
+        # sparql += ' .\n'
         return sparql
 
     def create_owl_part2(self, *,
@@ -1218,6 +1237,7 @@ class PropertyClass(Model, Notify):
         try:
             self._con.transaction_update(sparql)
         except OldapError as err:
+            print(sparql)
             self._con.transaction_abort()
             raise
         if not self._externalOntology:  # it's a project specific property -> OWL has been written -> check consistency!
@@ -1362,12 +1382,14 @@ class PropertyClass(Model, Notify):
                    owlclass_iri: Xsd_QName | None = None,
                    timestamp: Xsd_dateTime,
                    indent: int = 0, indent_inc: int = 4) -> str:
+        tmp = {x for x in PropClassAttr if x.in_owl and x != PropClassAttr.TYPE}
         owl_propclass_attributes = {PropClassAttr.SUBPROPERTY_OF,  # should be in OWL ontology
                                     PropClassAttr.DATATYPE,  # used for rdfs:range in OWL ontology
-                                    PropClassAttr.CLASS}  # used for rdfs:range in OWL ontology
+                                    PropClassAttr.CLASS} | tmp # used for rdfs:range in OWL ontology
+        tmp = {x: x.value.toRdf for x in PropClassAttr if x.in_owl and x != PropClassAttr.TYPE}
         owl_prop = {PropClassAttr.SUBPROPERTY_OF: PropClassAttr.SUBPROPERTY_OF.value,
                     PropClassAttr.DATATYPE: "rdfs:range",
-                    PropClassAttr.CLASS: "rdfs:range"}
+                    PropClassAttr.CLASS: "rdfs:range"} | tmp
         blank = ''
         sparql_list = []
         for prop, change in self._changeset.items():

oldaplib-0.3.6/oldaplib/src/version.py

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

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/src/xsd/xsd_qname.py

@@ -55,7 +55,7 @@ class Xsd_QName(Xsd):
                     raise OldapErrorValue(f'Invalid string "{value}" for QName. Error: {err}')
                 self._value = f'{prefix}:{fragment}'
             else:
-                raise OldapErrorValue(f'Invalid value for QName "{value}"')
+                raise OldapErrorValue(f'Invalid value for QName "{value}" (type: {type(value).__name__})')
         else:
             prefix = Xsd_NCName(value, validate=validate)
             if fragment:

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/test/test_datamodel.py

@@ -622,10 +622,10 @@ class TestDataModel(unittest.TestCase):
     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"))
+                              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)

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/test/test_objectfactory.py

@@ -6,6 +6,8 @@ from pathlib import Path
 from pprint import pprint
 from time import sleep
 
+from oldaplib.src.cachesingleton import CacheSingletonRedis
+from oldaplib.src.datamodel import DataModel
 from oldaplib.src.objectfactory import ResourceInstanceFactory
 from oldaplib.src.connection import Connection
 from oldaplib.src.enums.action import Action
@@ -129,6 +131,8 @@ class TestObjectFactory(unittest.TestCase):
                     isActive=True)
         user.create()
         cls._tuser = User.read(cls._connection, "factorytestuser")
+        cache = CacheSingletonRedis()
+        cache.clear()
 
 
     @classmethod
@@ -337,6 +341,14 @@ class TestObjectFactory(unittest.TestCase):
                  grantsPermission=Iri('oldap:GenericView'))
         b.create()
 
+    def test_constructor_D(self):
+        dm = DataModel.read(con=self._connection, project='test')
+        factory = ResourceInstanceFactory(con=self._connection, project='test')
+        Cat = factory.createObjectInstance('Cat')
+
+        mycat = Cat(name="Fluffy", subName="Fluffy the Cat")
+        mycat.create()
+
     def test_read_A(self):
         factory = ResourceInstanceFactory(con=self._connection, project='test')
         Book = factory.createObjectInstance('Book')

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/test/test_propertyclass.py

@@ -110,6 +110,22 @@ class TestPropertyClass(unittest.TestCase):
         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_constructor_owlprop(self):
+        p = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isParent'),
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Parent"]),
+                          description={"Parent of the human"})
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild'),
+                          toClass=Iri('test:Human'),
+                          inverseOf=Xsd_QName('test:isParent'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        self.assertEqual(i.inverseOf, Xsd_QName('test:isParent'))
+
     def test_propertyclass_inset_datatypes(self):
         p = PropertyClass(con=self._connection,
                           project=self._project,
@@ -416,6 +432,30 @@ class TestPropertyClass(unittest.TestCase):
                                 ignore_cache=True)
         self.assertEqual(p4.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
 
+    def test_propertyclass_create_G(self):
+        p = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isParentG'),
+                          toClass=Iri('test:Human'),
+                          name=LangString(["Parent"]),
+                          description={"Parent of the human"})
+        p.create()
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChildG'),
+                          toClass=Iri('test:Human'),
+                          inverseOf=Xsd_QName('test:isParentG'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        self.assertEqual(i.inverseOf, Xsd_QName('test:isParentG'))
+        i.create()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChildG'),
+                                ignore_cache=True)
+        self.assertEqual(i2.get(PropClassAttr.INVERSE_OF), Xsd_QName('test:isParentG'))
+
+
     def test_propertyclass_create_nopermission(self):
         p1 = PropertyClass(
             con=self._unpriv,
@@ -850,6 +890,24 @@ class TestPropertyClass(unittest.TestCase):
                                 ignore_cache=True)
         self.assertEqual(p8.get(PropClassAttr.TYPE), {OwlPropertyType.SymmetricProperty, OwlPropertyType.OwlDataProperty})
 
+    def test_propertyclass_update9(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChild9'),
+                          toClass=Iri('test:Human'),
+                          inverseOf=Xsd_QName('test:isParent9'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        self.assertEqual(i.inverseOf, Xsd_QName('test:isParent9'))
+        i.create()
+        i.inverseOf = Xsd_QName('test:anotherParent')
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChild9'),
+                                ignore_cache=True)
+        self.assertEqual(i2.get(PropClassAttr.INVERSE_OF), Xsd_QName('test:anotherParent'))
+
     # @unittest.skip('Work in progress')
     def test_propertyclass_delete_attrs(self):
         p1 = PropertyClass(
@@ -894,6 +952,23 @@ class TestPropertyClass(unittest.TestCase):
         res = QueryProcessor(self._context, jsonres)
         self.assertEqual(len(res), 0)
 
+    def test_propertyclass_delete_owlattr(self):
+        i = PropertyClass(con=self._connection,
+                          project=self._project,
+                          property_class_iri=Xsd_QName('test:isChildDel'),
+                          toClass=Iri('test:Human'),
+                          inverseOf=Xsd_QName('test:isParentDel'),
+                          name=LangString(["Child"]),
+                          description={"Child of the human"})
+        i.create()
+        i.inverseOf = None
+        i.update()
+        i2 = PropertyClass.read(con=self._connection,
+                                project=self._project,
+                                property_class_iri=Xsd_QName('test:isChildDel'),
+                                ignore_cache=True)
+        self.assertIsNone(i2.get(PropClassAttr.INVERSE_OF))
+
     # @unittest.skip('Work in progress')
     def test_propertyclass_delete(self):
         p1 = PropertyClass(

{oldaplib-0.3.4 → oldaplib-0.3.6}/oldaplib/testdata/objectfactory_test.trig

@@ -30,6 +30,46 @@ test:shacl {
 
     test:shapes schema:version "0.1.0"^^xsd:string .
 
+    test:MammalShape a sh:NodeShape ;
+        sh:targetClass test:Mammal ;
+        dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        sh:node oldap:ThingShape ;
+        sh:property [
+            sh:path rdf:type ;
+        ],
+        [
+            sh:path test:name ;
+            sh:datatype xsd:string ;
+            dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+            dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+            dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+            dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+       ] .
+
+    test:CatShape a sh:NodeShape ;
+        sh:targetClass test:Cat ;
+        dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        sh:node oldap:ThingShape, test:MammalShape ;
+        sh:property [
+            sh:path rdf:type ;
+        ],
+        [
+            sh:path test:subName ;
+            sh:datatype xsd:string ;
+            dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+            dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+            dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+            dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        ] .
+
+
+
     test:PersonShape a sh:NodeShape ;
         sh:targetClass test:Person ;
         dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
@@ -776,6 +816,46 @@ test:onto {
     test:ontology owl:type owl:Ontology ;
     owl:versionInfo "0.1.0"^^xsd:string .
 
+    test:Mammal rdf:type owl:Class ;
+        dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        rdfs:subClassOf oldap:Thing ,
+            [
+                rdf:type owl:Restriction ;
+                owl:onProperty test:name ;
+                owl:onDataRange xsd:string ;
+            ] .
+
+    test:Cat rdf:type owl:Class ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:created "2023-11-04T12:00:00+00:00"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2023-11-04T12:00:00+00:00"^^xsd:dateTime ;
+        rdfs:subClassOf oldap:Thing, test:Mammal,
+            [
+                rdf:type owl:Restriction ;
+                owl:onProperty test:subName ;
+                owl:onDataRange xsd:string ;
+            ] .
+
+    test:name rdf:type owl:DatatypeProperty ;
+        rdfs:domain test:Mammal ;
+        rdfs:range xsd:string ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime .
+
+    test:subName rdf:type owl:DatatypeProperty ;
+        rdfs:domain test:Cat ;
+        rdfs:range xsd:string ;
+        dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:created "2024-05-16T18:38:25.551434"^^xsd:dateTime ;
+        dcterms:contributor <https://orcid.org/0000-0003-1681-4036> ;
+        dcterms:modified "2024-05-16T18:38:25.551434"^^xsd:dateTime .
+
     test:Person rdf:type owl:Class ;
         dcterms:creator <https://orcid.org/0000-0003-1681-4036> ;
         dcterms:created "2023-11-04T12:00:00+00:00"^^xsd:dateTime ;

{oldaplib-0.3.4 → oldaplib-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "oldaplib"
-version = "0.3.4"
+version = "0.3.6"
 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.4/oldaplib/src/version.py

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