oldaplib 0.3.6__tar.gz → 0.3.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oldaplib
-Version: 0.3.6
+Version: 0.3.8
 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.6 → oldaplib-0.3.8}/oldaplib/src/model.py

@@ -8,6 +8,7 @@ from typing import Set, Dict, Any, Self
 from oldaplib.src.connection import Connection
 from oldaplib.src.enums.action import Action
 from oldaplib.src.enums.attributeclass import AttributeClass
+from oldaplib.src.enums.language import Language
 from oldaplib.src.helpers.attributechange import AttributeChange
 from oldaplib.src.helpers.context import Context
 from oldaplib.src.helpers.numeric import Numeric

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

@@ -99,7 +99,7 @@ class ResourceInstance:
         if iri and isinstance(iri, str):
             iri = Iri(Xsd_QName(self.project.projectShortName, iri))
         self._iri = Iri(iri, validate=True) if iri else Iri()
-        self._values = {}
+        self._values: dict[Xsd_QName, ValueType] = {}
         self._graph = self.project.projectShortName
         self._superclass_objs = {}
         self._changeset = {}
@@ -170,11 +170,33 @@ class ResourceInstance:
 
         for propname in self.properties.keys():
             setattr(ResourceInstance, propname.fragment, property(
-                partial(ResourceInstance.__get_value, prefix=propname.prefix, fragment=propname.fragment),
-                partial(ResourceInstance.__set_value, prefix=propname.prefix, fragment=propname.fragment),
-                partial(ResourceInstance.__del_value, prefix=propname.prefix, fragment=propname.fragment)))
+                partial(ResourceInstance.__get_value, attr=propname),
+                partial(ResourceInstance.__set_value, attr=propname),
+                partial(ResourceInstance.__del_value, attr=propname)))
         self.clear_changeset()
 
+    def __setitem__(self, key: Xsd_QName, value: ValueType | Xsd | None):
+        if self._values.get(key):
+            self.__set_value(value, key)
+        else:
+            raise OldapErrorValue(f'{self.name}: Property {key} does not exist.')
+
+    def __getitem__(self, key: Xsd_QName) -> ValueType | Xsd | None:
+        if self._values.get(key):
+            return self.__get_value(key)
+        else:
+            raise OldapErrorValue(f'{self.name}: Property {key} does not exist.')
+
+    def __delitem__(self, key: Xsd_QName):
+        if self._values.get(key):
+            self.__del_value(key)
+
+    def get(self, key: Xsd_QName) -> ValueType | Xsd | None:
+        if self._values.get(key):
+            return self._values[key]
+        else:
+            return None
+
     def validate_value(self, values: ValueType, property: PropertyClass):
         """
         Validates a set of values against a given property and its constraints. This function ensures
@@ -330,16 +352,19 @@ class ResourceInstance:
             else:
                 return False, f'Actor does not have {permission} in project "{self.project.projectShortName}".'
 
-    def __get_value(self: Self, prefix: str, fragment: str) -> Xsd | ValueType | None:
-        attr = Xsd_QName(prefix, fragment, validate=False)
+    def __get_value(self: Self, attr: Xsd_QName | str) -> Xsd | ValueType | None:
+        #attr = Xsd_QName(prefix, fragment, validate=False)
+        if not isinstance(attr, Xsd_QName):
+            attr = Xsd_QName(attr)
         tmp = self._values.get(attr, None)
         if tmp is not None and str(attr) in {'oldap:createdBy', 'oldap:creationDate', 'oldap:lastModifiedBy', 'oldap:lastModificationDate'}:
             return next(iter(tmp))
         return tmp
 
-    def __set_value(self: Self, value: ValueType | Xsd | None, prefix: str, fragment: str) -> None:
-        prop_iri = Xsd_QName(prefix, fragment, validate=False)
-        hasprop = self.properties.get(prop_iri)
+    def __set_value(self: Self, value: ValueType | Xsd | None, attr: Xsd_QName | str) -> None:
+        if not isinstance(attr, Xsd_QName):
+            attr = Xsd_QName(attr)
+        hasprop = self.properties.get(attr)
 
         #
         # Validate
@@ -347,58 +372,58 @@ class ResourceInstance:
         if hasprop.get(HasPropertyAttr.MIN_COUNT):  # testing for MIN_COUNT conformance
             if hasprop[HasPropertyAttr.MIN_COUNT] > 0 and not value:
                 raise OldapErrorValue(
-                    f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} is missing')
+                    f'{self.name}: Property {attr} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} is missing')
             elif isinstance(value, (list, tuple, set, ObservableSet)) and len(value) < hasprop[HasPropertyAttr.MIN_COUNT]:
                 raise OldapErrorValue(
-                    f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has not enough values')
+                    f'{self.name}: Property {attr} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has not enough values')
         if hasprop.get(HasPropertyAttr.MAX_COUNT):  # testing for MAX_COUNT conformance
             if isinstance(value, (list, tuple, set, ObservableSet)) and len(value) > hasprop[HasPropertyAttr.MAX_COUNT]:
                 raise OldapErrorValue(
-                    f'{self.name}: Property {prop_iri} with MAX_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has to many values (n={len(value)})')
+                    f'{self.name}: Property {attr} with MAX_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has to many values (n={len(value)})')
         if value:
             if isinstance(value, LangString):
                 self.validate_value(value, hasprop.prop)
             else:
                 if isinstance(value, (list, tuple, set, ObservableSet)):
-                    for val in self._values[prop_iri]:
+                    for val in self._values[attr]:
                         self.validate_value(val, hasprop.prop)
                 else:
                     self.validate_value(value, hasprop.prop)
 
         if not value:
-            self._changeset[prop_iri] = AttributeChange(self._values.get(prop_iri), Action.DELETE)
-            del self._values[prop_iri]
+            self._changeset[attr] = AttributeChange(self._values.get(attr), Action.DELETE)
+            del self._values[attr]
         elif isinstance(value, (list, tuple, set, LangString)):  # we may have multiple values...
-            if self._values.get(prop_iri):
-                self._changeset[prop_iri] = AttributeChange(self._values.get(prop_iri), Action.REPLACE)
+            if self._values.get(attr):
+                self._changeset[attr] = AttributeChange(self._values.get(attr), Action.REPLACE)
             else:
-                self._changeset[prop_iri] = AttributeChange(None, Action.CREATE)
+                self._changeset[attr] = AttributeChange(None, Action.CREATE)
             if hasprop.prop.datatype == XsdDatatypes.langString:
-                self._values[prop_iri] = LangString(value, notifier=self.notifier, notify_data=prop_iri)
+                self._values[attr] = LangString(value, notifier=self.notifier, notify_data=attr)
             else:
-                self._values[prop_iri] = ObservableSet({
+                self._values[attr] = ObservableSet({
                     convert2datatype(x, hasprop.prop.datatype) for x in value
-                }, notifier=self.notifier, notify_data=prop_iri)
+                }, notifier=self.notifier, notify_data=attr)
         else:
-            if self._values.get(prop_iri):
-                self._changeset[prop_iri] = AttributeChange(self._values.get(prop_iri), Action.REPLACE)
+            if self._values.get(attr):
+                self._changeset[attr] = AttributeChange(self._values.get(attr), Action.REPLACE)
             else:
-                self._changeset[prop_iri] = AttributeChange(None, Action.CREATE)
+                self._changeset[attr] = AttributeChange(None, Action.CREATE)
             try:
-                self._values[prop_iri] = ObservableSet({convert2datatype(value, hasprop.prop.datatype)})
+                self._values[attr] = ObservableSet({convert2datatype(value, hasprop.prop.datatype)})
             except TypeError:
-                self._values[prop_iri] = convert2datatype(value, hasprop.prop.datatype)
+                self._values[attr] = convert2datatype(value, hasprop.prop.datatype)
 
-    def __del_value(self: Self, prefix: str, fragment: str) -> None:
-        prop_iri = Xsd_QName(prefix, fragment, validate=False)
-        hasprop = self.properties.get(prop_iri)
+    def __del_value(self: Self, attr: Xsd_QName | str) -> None:
+        if not isinstance(attr, Xsd_QName):
+            attr = Xsd_QName(attr)
+        hasprop = self.properties.get(attr)
 
         if hasprop.get(HasPropertyAttr.MIN_COUNT):  # testing for MIN_COUNT conformance
             if hasprop[HasPropertyAttr.MIN_COUNT] > 0:
-                raise OldapErrorValue(f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} cannot be deleted.')
+                raise OldapErrorValue(f'{self.name}: Property {attr} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} cannot be deleted.')
 
-        self._changeset[prop_iri] = AttributeChange(self._values.get(prop_iri), Action.DELETE)
-        attr = Xsd_QName(prefix, fragment, validate=False)
+        self._changeset[attr] = AttributeChange(self._values.get(attr), Action.DELETE)
         del self._values[attr]
 
     @property
@@ -507,26 +532,19 @@ class ResourceInstance:
         context = Context(name=con.context_name)
         sparql = context.sparql_context
         sparql += f'''
-SELECT ?predicate ?value
-FROM oldap:onto
-FROM shared:onto
-FROM {graph}:onto
-FROM NAMED oldap:admin
-FROM NAMED {graph}:data
-WHERE {{
-	BIND({iri.toRdf} as ?iri)
-    GRAPH {graph}:data {{
-        ?iri ?predicate ?value .
-        ?iri oldap:grantsPermission ?permset .
-    }}
-    BIND({con.userIri.toRdf} as ?user)
-    GRAPH oldap:admin {{
-    	?user oldap:hasPermissions ?permset .
-    	?permset oldap:givesPermission ?DataPermission .
-    	?DataPermission oldap:permissionValue ?permval .
-    }}
-    FILTER(?permval >= {DataPermission.DATA_VIEW.numeric.toRdf})
-}}'''
+        SELECT ?predicate ?value
+        WHERE {{
+            GRAPH {graph}:data {{
+                {iri.toRdf} ?predicate ?value .
+                {iri.toRdf} oldap:grantsPermission ?permset .
+            }}
+            GRAPH oldap:admin {{
+                {con.userIri.toRdf} oldap:hasPermissions ?permset .
+                ?permset oldap:givesPermission ?DataPermission .
+                ?DataPermission oldap:permissionValue ?permval .
+            }}
+            FILTER(?permval >= {DataPermission.DATA_VIEW.numeric.toRdf})
+        }}'''
         jsonres = con.query(sparql)
         res = QueryProcessor(context, jsonres)
         objtype = None
@@ -791,6 +809,47 @@ class ResourceInstanceFactory:
             'properties': resclass.properties,
             'superclass': resclass.superclass})
 
+    @staticmethod
+    def read_data(con: IConnection, projectShortName: Xsd_NCName | str, iri: Iri | str) -> dict[Xsd_QName, Any]:
+        if not isinstance(iri, Iri):
+            iri = Iri(iri, validate=True)
+        if not isinstance(projectShortName, Xsd_NCName):
+            graph = Xsd_NCName(projectShortName)
+        else:
+            graph = projectShortName
+
+        context = Context(name=con.context_name)
+        sparql = context.sparql_context
+        sparql += f'''
+        SELECT ?predicate ?value
+        WHERE {{
+            GRAPH {graph}:data {{
+                {iri.toRdf} ?predicate ?value .
+                {iri.toRdf} oldap:grantsPermission ?permset .
+            }}
+            GRAPH oldap:admin {{
+            	{con.userIri.toRdf} oldap:hasPermissions ?permset .
+            	?permset oldap:givesPermission ?DataPermission .
+            	?DataPermission oldap:permissionValue ?permval .
+            }}
+            FILTER(?permval >= {DataPermission.DATA_VIEW.numeric.toRdf})
+        }}
+        '''
+        jsonres = con.query(sparql)
+        res = QueryProcessor(context, jsonres)
+        data = {}
+        for r in res:
+            if r['predicate'].is_qname:
+                if not data.get(r['predicate'].as_qname):
+                    data[r['predicate'].as_qname] = []
+                data[str(r['predicate'].as_qname)].append(str(r['value']))
+            else:
+                raise OldapErrorInconsistency(f"Expected QName as predicate, got {r['predicate']}")
+        if not data.get('rdf:type'):
+            raise OldapErrorNotFound(f'Resource with iri <{iri}> not found.')
+        return data
+
+
     def read(self, iri: Iri | str) -> ResourceInstance:
         if not isinstance(iri, Iri):
             iri = Iri(iri, validate=True)
@@ -799,11 +858,6 @@ class ResourceInstanceFactory:
         sparql = context.sparql_context
         sparql += f'''
         SELECT ?predicate ?value
-        FROM oldap:onto
-        FROM shared:onto
-        FROM {graph}:onto
-        FROM NAMED oldap:admin
-        FROM NAMED {graph}:data
         WHERE {{
         	BIND({iri.toRdf} as ?iri)
             GRAPH {graph}:data {{
@@ -856,11 +910,6 @@ class ResourceInstanceFactory:
         else:
             sparql += "SELECT DISTINCT ?s ?t ?p ?o"
         sparql += f'''
-        FROM oldap:onto
-        FROM shared:onto
-        FROM {graph}:onto
-        FROM NAMED oldap:admin
-        FROM NAMED {graph}:data
         WHERE {{
             GRAPH {graph}:data {{
                 ?s ?p ?o .
@@ -870,9 +919,8 @@ class ResourceInstanceFactory:
             FILTER(isLiteral(?o) && 
                 (datatype(?o) = xsd:string || datatype(?o) = rdf:langString || lang(?o) != ""))
             FILTER(CONTAINS(LCASE(STR(?o)), "{s}"))  # case-insensitive substring match
-            BIND({self._con.userIri.toRdf} as ?user)
             GRAPH oldap:admin {{
-    	        ?user oldap:hasPermissions ?permset .
+    	        {self._con.userIri.toRdf} oldap:hasPermissions ?permset .
     	        ?permset oldap:givesPermission ?DataPermission .
     	        ?DataPermission oldap:permissionValue ?permval .
             }}

oldaplib-0.3.8/oldaplib/src/version.py

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

{oldaplib-0.3.6 → oldaplib-0.3.8}/oldaplib/src/xsd/xsd_datetimestamp.py

@@ -54,7 +54,7 @@ class Xsd_dateTimeStamp(Xsd):
         Constructor string representation of the Xsd_dateTimeStamp instance as ISO datetimestamp
         :return: Constructor string
         """
-        return f'Xsd_dateTimeSTamp("{self.__value.isoformat()}")'
+        return f'Xsd_dateTimeStamp("{self.__value.isoformat()}")'
 
     def __eq__(self, other: Self | datetime | str | None) -> bool:
         """

{oldaplib-0.3.6 → oldaplib-0.3.8}/oldaplib/test/test_externalontologies.py

@@ -105,7 +105,8 @@ class TestexternalOntologies(unittest.TestCase):
 
         del eo1
         eo1 = ExternalOntology.read(con=self._connection, projectShortName="testext", prefix="gagaB", ignore_cache=True)
-        eo1.prefix = "gugus"
+        with self.assertRaises(OldapErrorImmutable):
+            eo1.prefix = "gugus"
         eo1.comment = LangString("Gugus comment@en", "Gugus Kommentar@de")
         del eo1.label[Language.DE]
         eo1.label[Language.FR] = "GAGA B ontologie"
@@ -113,7 +114,7 @@ class TestexternalOntologies(unittest.TestCase):
 
         del eo1
         eo1 = ExternalOntology.read(con=self._connection, projectShortName="testext", prefix="gagaB", ignore_cache=True)
-        self.assertEqual(eo1.prefix, "gugus")
+        self.assertEqual(eo1.prefix, "gagaB")
         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/"))

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

@@ -350,6 +350,19 @@ class TestObjectFactory(unittest.TestCase):
         mycat.create()
 
     def test_read_A(self):
+        factory = ResourceInstanceFactory(con=self._connection, project='test')
+        Book = factory.createObjectInstance('Book')
+        b = Book(title="The Life and Times of Scrooge",
+                 author="test:TuomasHolopainen",
+                 pubDate="2001-01-01",
+                 grantsPermission=Iri('oldap:GenericView'))
+        b.create()
+        data = ResourceInstanceFactory.read_data(con=self._connection, iri=b.iri, projectShortName='test')
+        self.assertEqual(data['rdf:type'], ['test:Book'])
+        self.assertEqual(data['test:title'], ['The Life and Times of Scrooge'])
+        self.assertEqual(data['test:author'], ['test:TuomasHolopainen'])
+
+    def test_read_B(self):
         factory = ResourceInstanceFactory(con=self._connection, project='test')
         Book = factory.createObjectInstance('Book')
         b = Book(title="The Life and Times of Scrooge",
@@ -366,6 +379,24 @@ class TestObjectFactory(unittest.TestCase):
         self.assertEqual(jsonobj['test:pubDate'], ['2001-01-01'])
         self.assertEqual(jsonobj['test:title'], ['The Life and Times of Scrooge'])
 
+    def test_read_C(self):
+        factory = ResourceInstanceFactory(con=self._connection, project='test')
+        Book = factory.createObjectInstance('Book')
+        b = Book(title="The Life and Times of Scrooge",
+                 author="test:TuomasHolopainen",
+                 pubDate="2001-01-01",
+                 grantsPermission=Iri('oldap:GenericView'))
+        b.create()
+        bb = Book.read(con=self._connection, iri=b.iri)
+        self.assertEqual(bb.name, "Book")
+        self.assertEqual(bb.title, {Xsd_string("The Life and Times of Scrooge")})
+        self.assertEqual(bb.author, {Iri("test:TuomasHolopainen")})
+        jsonobj = bb.toJsonObject()
+        self.assertEqual(jsonobj['test:author'], ['test:TuomasHolopainen'])
+        self.assertEqual(jsonobj['test:pubDate'], ['2001-01-01'])
+        self.assertEqual(jsonobj['test:title'], ['The Life and Times of Scrooge'])
+
+
     def test_value_setter(self):
         factory = ResourceInstanceFactory(con=self._connection, project='test')
         SetterTester = factory.createObjectInstance('SetterTester')
@@ -419,7 +450,7 @@ class TestObjectFactory(unittest.TestCase):
         self.assertEqual(obj2.decimalSetter, {Xsd_decimal(3.14159), Xsd_decimal(2.71828), Xsd_decimal(1.61803)})
         self.assertFalse(obj2.integerSetter)
 
-    def test_value_modifier(self):
+    def test_value_modifier_A(self):
         factory = ResourceInstanceFactory(con=self._connection, project='test')
         SetterTester = factory.createObjectInstance('SetterTester')
         obj1 = SetterTester(stringSetter="This is a test string",
@@ -445,6 +476,32 @@ class TestObjectFactory(unittest.TestCase):
         self.assertEqual(obj1.integerSetter, {Xsd_int(20), Xsd_int(42)})
         self.assertFalse(obj1.booleanSetter)
 
+    def test_value_modifier_B(self):
+        factory = ResourceInstanceFactory(con=self._connection, project='test')
+        SetterTester = factory.createObjectInstance('SetterTester')
+        obj1 = SetterTester(stringSetter="This is a test string",
+                            langStringSetter=LangString("C'est un teste@fr", "Dies ist eine Test-Zeichenkette@de"),
+                            decimalSetter=Xsd_decimal(3.14),
+                            integerSetter={-10, 20},
+                            booleanSetter=True,
+                            grantsPermission={Iri('oldap:GenericView'), Iri('oldap:GenericUpdate')})
+        obj1.create()
+        obj1 = SetterTester.read(con=self._connection, iri=obj1.iri)
+        obj1[Xsd_QName('test:langStringSetter')][Language.FR] = "Qu'est-ce que c'est?"
+        obj1[Xsd_QName('test:integerSetter')].add(42)
+        obj1[Xsd_QName('test:integerSetter')].discard(-10)
+        obj1[Xsd_QName('test:booleanSetter')] = False
+        with self.assertRaises(OldapErrorValue):
+            obj1[Xsd_QName('test:stringSetter')].pop()
+        with self.assertRaises(OldapErrorValue):
+            del obj1[Xsd_QName('test:stringSetter')]
+        obj1.update()
+        obj1 = SetterTester.read(con=self._connection, iri=obj1.iri)
+        self.assertEqual(obj1.stringSetter, {"This is a test string"})
+        self.assertEqual(obj1.langStringSetter, LangString("Dies ist eine Test-Zeichenkette@de", "Qu'est-ce que c'est?@fr"))
+        self.assertEqual(obj1.integerSetter, {Xsd_int(20), Xsd_int(42)})
+        self.assertFalse(obj1.booleanSetter)
+
     def test_value_maxcount_mincount(self):
         factory = ResourceInstanceFactory(con=self._connection, project='test')
         Person = factory.createObjectInstance('Person')

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

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

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