oldaplib 0.3.7__tar.gz → 0.3.9__tar.gz

{oldaplib-0.3.7 → oldaplib-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oldaplib
-Version: 0.3.7
+Version: 0.3.9
 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.7 → oldaplib-0.3.9}/oldaplib/src/helpers/observable_set.py

@@ -80,7 +80,7 @@ class ObservableSet(Notify):
     def __str__(self) -> str:
         return str(self._setdata)
 
-    def __eq__(self, other: Iterable) -> bool:
+    def __eq__(self, other: Iterable[Any]) -> bool:
         if isinstance(other, ObservableSet):
             return self._setdata == other._setdata
         elif isinstance(other, set):
@@ -90,7 +90,7 @@ class ObservableSet(Notify):
         else:
             raise OldapErrorNotImplemented(f'Set.__eq__() not implemented for {type(other).__name__}')
 
-    def __or__(self, other: Iterable) -> Self:
+    def __or__(self, other: Iterable[Any]) -> Self:
         if isinstance(other, ObservableSet):
             return ObservableSet(self._setdata.__or__(other._setdata), self._notifier, self._notify_data)
         elif isinstance(other, set):
@@ -100,25 +100,24 @@ class ObservableSet(Notify):
         else:
             raise OldapErrorNotImplemented(f'Set.__or__() not implemented for {type(other).__name__}')
 
-    def __ror__(self, other: Self) -> Self:
-        pass
+    def __ror__(self, other: Iterable[Any]) -> Self:
+        return ObservableSet(set(other).__or__(self._setdata), self._notifier, self._notify_data)
+
+    def __rsub__(self, other: Iterable[Any]) -> Self:
+        return ObservableSet(set(other).__sub__(self._setdata), self._notifier, self._notify_data)
 
-    def __ior__(self, other: Iterable) -> Self:
+    def __ior__(self, other: Iterable[Any]) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
             self._setdata.__ior__(other._setdata)
-        elif isinstance(other, set):
-            self._setdata.__ior__(other)
-        elif isinstance(other, Iterable):
-            return ObservableSet(self._setdata.__ior__(set(other)), self._notifier, self._notify_data)
         else:
-            raise OldapErrorNotImplemented(f'Set.i__or__() not implemented for {type(other).__name__}')
+            self._setdata.__ior__(set(other))
         if not self._old_value:
             self._old_value = tmp_copy
         self.notify()
         return self
 
-    def __and__(self, other: Iterable) -> Self:
+    def __and__(self, other: Iterable[Any]) -> Self:
         if isinstance(other, ObservableSet):
             return ObservableSet(self._setdata.__and__(other._setdata), self._notifier, self._notify_data)
         elif isinstance(other, set):
@@ -128,7 +127,7 @@ class ObservableSet(Notify):
         else:
             raise OldapErrorNotImplemented(f'Set.__and__() not implemented for {type(other).__name__}')
 
-    def __iand__(self, other: Iterable) -> Self:
+    def __iand__(self, other: Iterable[Any]) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
             self._setdata.__iand__(other._setdata)
@@ -146,7 +145,7 @@ class ObservableSet(Notify):
     def __rsub__(self, other: Self) -> Self:
         pass
 
-    def __sub__(self, other: Iterable) -> Self:
+    def __sub__(self, other: Iterable[Any]) -> Self:
         if isinstance(other, ObservableSet):
             return ObservableSet(self._setdata.__sub__(other._setdata), self.notify, self._notify_data)
         elif isinstance(other, set):
@@ -156,7 +155,7 @@ class ObservableSet(Notify):
         else:
             raise OldapErrorNotImplemented(f'Set.__sub__() not implemented for {type(other).__name__}')
 
-    def __isub__(self, other: Iterable) -> Self:
+    def __isub__(self, other: Iterable[Any]) -> Self:
         tmp_copy = deepcopy(self)
         if isinstance(other, ObservableSet):
             self._setdata.__isub__(other._setdata)
@@ -171,34 +170,45 @@ class ObservableSet(Notify):
         self.notify()
         return self
 
-    def update(self, items: Iterable):
+    @classmethod
+    def coerce(cls, value: Iterable[Any], *, notifier=None, notify_data=None) -> "ObservableSet":
+        return value if isinstance(value, cls) else cls(value, notifier=notifier, notify_data=notify_data)
+
+    def update(self, items: Iterable[Any]):
         tmp_copy = deepcopy(self)
         self._setdata.update(items)
         if not self._old_value:
             self._old_value = tmp_copy
         self.notify()
 
-    def intersection_update(self, items: Iterable):
+    def intersection_update(self, items: Iterable[Any]):
         tmp_copy = deepcopy(self)
         self._setdata.intersection_update(items)
         if not self._old_value:
             self._old_value = tmp_copy
         self.notify()
 
-    def difference_update(self, items: Iterable):
+    def difference_update(self, items: Iterable[Any]):
         tmp_copy = deepcopy(self)
         self._setdata.difference_update(items)
         if not self._old_value:
             self._old_value = tmp_copy
         self.notify()
 
-    def symmetric_difference_update(self, items: Iterable):
+    def symmetric_difference_update(self, items: Iterable[Any]):
         tmp_copy = deepcopy(self)
         self._setdata.symmetric_difference_update(items)
         if not self._old_value:
             self._old_value = tmp_copy
         self.notify()
 
+    def replace(self, items: Iterable[Any]) -> None:
+        tmp_copy = deepcopy(self)
+        self._setdata = set(items)
+        if not self._old_value:
+            self._old_value = tmp_copy
+        self.notify()
+
     def add(self, item: Any) -> None:
         tmp_copy = deepcopy(self)
         self._setdata.add(item)

{oldaplib-0.3.7 → oldaplib-0.3.9}/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.7 → oldaplib-0.3.9}/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,21 +532,19 @@ class ResourceInstance:
         context = Context(name=con.context_name)
         sparql = context.sparql_context
         sparql += f'''
-SELECT ?predicate ?value
-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
@@ -887,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 .
@@ -901,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.9/oldaplib/src/version.py

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

{oldaplib-0.3.7 → oldaplib-0.3.9}/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.7 → oldaplib-0.3.9}/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.7 → oldaplib-0.3.9}/oldaplib/test/test_objectfactory.py

@@ -357,7 +357,7 @@ class TestObjectFactory(unittest.TestCase):
                  pubDate="2001-01-01",
                  grantsPermission=Iri('oldap:GenericView'))
         b.create()
-        data = factory.read_data(con=self._connection, iri=b.iri, projectShortName='test')
+        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'])
@@ -379,6 +379,23 @@ 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')
@@ -433,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",
@@ -459,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.7 → oldaplib-0.3.9}/pyproject.toml

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

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