oldaplib 0.4.5__tar.gz → 0.4.6__tar.gz

{oldaplib-0.4.5 → oldaplib-0.4.6}/PKG-INFO

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

{oldaplib-0.4.5 → oldaplib-0.4.6}/oldaplib/src/enums/language.py

@@ -211,6 +211,11 @@ class Language(Enum):
     def toRdf(self) -> str:
         return f'"{self.name.lower()}"^^xsd:string'
 
+    @property
+    def shortlang(self) -> str:
+        """Return the language short name in lowercase (e.g., 'de' for Language.DE)"""
+        return self.name.lower()
+
 
 if __name__ == "__main__":
     print(Language.EN.toRdf)

{oldaplib-0.4.5 → oldaplib-0.4.6}/oldaplib/src/model.py

@@ -222,7 +222,10 @@ class Model:
                 del self._attributes[attr]
         else:
             if not isinstance(value, attr.datatype):
-                self._attributes[attr] = attr.datatype(value, validate=True)
+                try:
+                    self._attributes[attr] = attr.datatype(value, validate=True)
+                except Exception as err:
+                    raise Exception(f"Failed to set attribute '{attr}' with value '{value}': {err}")
             else:
                 self._attributes[attr] = value
             if hasattr(self._attributes[attr], 'set_notifier') and hasattr(self, 'notifier'):

{oldaplib-0.4.5 → oldaplib-0.4.6}/oldaplib/src/objectfactory.py

@@ -1,11 +1,12 @@
 import re
 import textwrap
+from dataclasses import dataclass
 from pprint import pprint
 
 import jwt
 
 from datetime import datetime, timedelta
-from enum import Flag, auto
+from enum import Flag, auto, Enum
 from functools import partial
 from typing import Type, Any, Self, cast, Dict
 
@@ -24,7 +25,7 @@ from oldaplib.src.helpers.langstring import LangString
 from oldaplib.src.helpers.observable_dict import ObservableDict
 from oldaplib.src.helpers.observable_set import ObservableSet
 from oldaplib.src.helpers.oldaperror import OldapErrorNotFound, OldapErrorValue, OldapErrorInconsistency, \
-    OldapErrorNoPermission, OldapError, OldapErrorUpdateFailed, OldapErrorInUse, OldapErrorAlreadyExists
+    OldapErrorNoPermission, OldapError, OldapErrorUpdateFailed, OldapErrorInUse, OldapErrorAlreadyExists, OldapErrorType
 from oldaplib.src.helpers.query_processor import QueryProcessor
 from oldaplib.src.iconnection import IConnection
 from oldaplib.src.project import Project
@@ -40,10 +41,14 @@ from oldaplib.src.xsd.xsd_string import Xsd_string
 
 ValueType = LangString | ObservableSet | Xsd | Dict[Xsd_QName, DataPermission] | ObservableDict
 
-class SortBy(Flag):
-    PROPVAL = auto()
-    CREATED = auto()
-    LASTMOD = auto()
+class SortDir(str, Enum):
+    asc = "asc"
+    desc = "desc"
+
+@dataclass(frozen=True)
+class SortBy:
+    property: Xsd_QName
+    dir: SortDir = SortDir.asc
 
 
 #@strict
@@ -167,7 +172,7 @@ class ResourceInstance:
                         raise OldapErrorValue(f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} is missing')
                     elif isinstance(self._values[prop_iri], ObservableSet) and len(self._values[prop_iri]) < 1:
                         raise OldapErrorValue(f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} is missing')
-                if hasprop.get(HasPropertyAttr.MAX_COUNT):  # testing for MAX_COUNT conformance
+                if hasprop.get(HasPropertyAttr.MAX_COUNT) and hasprop[HasPropertyAttr.MAX_COUNT] > 0:  # testing for MAX_COUNT conformance
                     if isinstance(self._values.get(prop_iri), ObservableSet) and len(self._values[prop_iri]) > 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(self._values[prop_iri])})')
                 if self._values.get(prop_iri):
@@ -375,12 +380,12 @@ class ResourceInstance:
                 raise OldapErrorValue(
                     f'{self.name}: Property {prop_iri} with MIN_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has not enough values (n={n}).')
 
-        if hasprop.get(HasPropertyAttr.MAX_COUNT):  # testing for MAX_COUNT conformance
+        if hasprop.get(HasPropertyAttr.MAX_COUNT) and hasprop[HasPropertyAttr.MAX_COUNT] > 0:  # testing for MAX_COUNT conformance
             n = len(self._values[prop_iri])
             if n > hasprop[HasPropertyAttr.MAX_COUNT]:
                 self._values[prop_iri].undo()
                 raise OldapErrorValue(
-                    f'{self.name}: Property {prop_iri} with MAX_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has to many values (n={n}).')
+                    f'{self.name}: Property {prop_iri} with MAX_COUNT={hasprop[HasPropertyAttr.MAX_COUNT]} has to many values (n={n}).')
 
         self._changeset[prop_iri] = AttributeChange(None, Action.MODIFY)
 
@@ -454,7 +459,7 @@ class ResourceInstance:
             elif isinstance(value, (list, tuple, set, ObservableSet)) and len(value) < hasprop[HasPropertyAttr.MIN_COUNT]:
                 raise OldapErrorValue(
                     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 hasprop.get(HasPropertyAttr.MAX_COUNT) and hasprop[HasPropertyAttr.MAX_COUNT] > 0:  # 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 {attr} with MAX_COUNT={hasprop[HasPropertyAttr.MIN_COUNT]} has to many values (n={len(value)})')
@@ -1095,74 +1100,75 @@ class ResourceInstance:
         for r in res:
             roles[r['role']] = DataPermission.from_qname(r['dataperm'])
         data[Xsd_QName('oldap:attachedToRole')] = roles
-
+        #data[Xsd_QName('virtual:resourceIri')] = iri
         return data
 
     @staticmethod
     def search_fulltext(con: IConnection,
                         projectShortName: Xsd_NCName | str,
-                        s: str,
+                        searchstr: str,
                         resClass: Xsd_QName | str | None = None,
                         countOnly: bool = False,
-                        sortBy: SortBy | None = None,
+                        sortBy: list[SortBy] = [],
                         limit: int = 100,
                         offset: int = 0,
                         indent: int = 0, indent_inc: int = 4) -> int | dict[Iri, dict[str, Xsd]]:
         """
-        Search for entities in a project using a full-text search query, with optional filters and sorting
-        based on resource class and properties.
-
-        :param con: The connection instance to interact with the SPARQL endpoint or database.
-        :type con: IConnection
-        :param projectShortName: The project short name (identifier). Can be provided as an Xsd_NCName or a
-            string. If a string, it is automatically validated and converted to an Xsd_NCName.
-        :type projectShortName: Xsd_NCName | str
-        :param s: The full-text search query to identify entities matching the specified string values.
-        :type s: str
-        :param resClass: An optional entity class (Xsd_QName) used to filter results. If provided as a string,
-            it is validated and converted to Xsd_QName.
-        :type resClass: Xsd_QName | str | None
-        :param countOnly: If True, only the count of matching entities will be returned. Defaults to False.
-        :type countOnly: bool
-        :param sortBy: Optional sorting criterion for the results, such as creation date, last modification date,
-            or property values. Defaults to None.
-        :type sortBy: SortBy | None
-        :param limit: The maximum number of records to return when count_only is False. Defaults to 100.
-        :type limit: int
-        :param offset: The number of records to skip for paginated queries. Defaults to 0.
-        :type offset: int
-        :param indent: Initial indentation level for the generated SPARQL query. Defaults to 0.
-        :type indent: int
-        :param indent_inc: Incremental indentation used during SPARQL query generation. Defaults to 4.
-        :type indent_inc: int
-        :return: If count_only is True, an integer representing the count of matching entities. If count_only is
-            False, a dictionary with entity IRIs as keys and their respective property-to-value mappings
-            as values.
-        :rtype: int | dict[Iri, dict[str, Xsd]]
-
-        The SPARQL generated is as follows
-
-        ```sparql
-        SELECT DISTINCT ?s ?t ?p ?o ?creationDate
-        WHERE {
-            GRAPH test:data {
-                ?s oldap:creationDate ?creationDate .
-                ?s ?p ?o .
-                ?s rdf:type ?t .
-                ?s rdf:type test:Book .
-                ?s oldap:grantsPermission ?permset .
-            }
-            FILTER(isLiteral(?o) && (datatype(?o) = xsd:string || datatype(?o) = rdf:langString || lang(?o) != ""))
-            FILTER(CONTAINS(LCASE(STR(?o)), "gaga"))  # case-insensitive substring match
-            GRAPH oldap:admin {
-                <https://orcid.org/0000-0003-1681-4036> oldap:hasPermissions ?permset .
-                ?permset oldap:givesPermission ?DataPermission .
-                ?DataPermission oldap:permissionValue ?permval .
-            }
-            FILTER(?permval >= "2"^^xsd:integer)
-        }
-        ORDER BY ASC(?creationDate)LIMIT 100 OFFSET 0
-        ```
+            Searches and retrieves data from the database using a full-text search query. This method allows
+            users to optionally filter and sort the results based on specific criteria. It supports returning
+            either the count of matching results or the results themselves in a structured format.
+
+            :param con: The connection object used to interact with the database.
+                This must implement the IConnection interface.
+            :type con: IConnection
+
+            :param projectShortName: The short name of the project for which the data
+                needs to be queried.
+            :type projectShortName: Xsd_NCName | str
+
+            :param searchstr: The search string used for full-text search, with case-insensitive
+                substring matching.
+            :type searchstr: str
+
+            :param resClass: An optional parameter specifying the resource class of the
+                objects to be retrieved. If provided, the query will filter results for the
+                specified class.
+            :type resClass: Xsd_QName | str | None
+
+            :param countOnly: A boolean flag to indicate whether to return only the count
+                of matching results. If set to True, only the count is returned;
+                otherwise, matching records are retrieved.
+            :type countOnly: bool
+
+            :param sortBy: A list of sorting criteria. Each criterion specifies the property
+                and direction (ascending or descending) to sort the results. If not provided,
+                no sorting is applied. SortBy has the following attributes:
+                - property (Xsd_QName): The property to sort by. The property must be one of
+                  Xsd_QName('oldap:creationDate'), Xsd_QName('oldap:lastModificationDate') or
+                  Xsd_QName('oldap:propval') to sort according the property where the match has been found..
+                - direction (str): The sorting direction, either 'asc' for ascending or 'desc' for descending.
+            :type sortBy: list[SortBy]
+
+            :param limit: The maximum number of results to retrieve. Defaults to 100 if not specified.
+            :type limit: int
+
+            :param offset: The number of records to skip before starting to retrieve results.
+                This is useful for paginated responses.
+            :type offset: int
+
+            :param indent: The base indentation level used for formatting the generated SPARQL
+                query string.
+            :type indent: int
+
+            :param indent_inc: The incremental value to add to the base indent for nested query
+                components.
+            :type indent_inc: int
+
+            :return: If `countOnly` is True, an integer representing the count of matching results
+                is returned. Otherwise, a dictionary is returned where the keys are IRIs of the
+                matching resources, and the values are dictionaries containing their respective
+                properties and values.
+            :rtype: int | dict[Iri, dict[str, Xsd]]
         """
         if not isinstance(projectShortName, Xsd_NCName):
             graph = Xsd_NCName(projectShortName, validate=True)
@@ -1180,10 +1186,12 @@ class ResourceInstance:
         else:
             sparql += f'{blank:{indent * indent_inc}}SELECT DISTINCT ?s ?t ?p ?o'
             if sortBy:
-                if sortBy == SortBy.CREATED:
-                    sparql += ' ?creationDate'
-                if sortBy == SortBy.LASTMOD:
-                    sparql += '?lastModificationDate'
+                for sortby in sortBy:
+                    if sortby.property == Xsd_QName('oldap:creationDate'):
+                        sparql += ' ?creationDate'
+                    elif sortby.property == Xsd_QName('oldap:lastModificationDate'):
+                        sparql += '?lastModificationDate'
+
         sparql += f'\n{blank:{indent * indent_inc}}WHERE {{'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}GRAPH oldap:admin {{'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}{con.userIri.toRdf} oldap:hasRole ?role .'
@@ -1191,11 +1199,12 @@ class ResourceInstance:
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}FILTER(?permval >= {DataPermission.DATA_VIEW.numeric.toRdf})'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}}}'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}GRAPH {graph}:data {{'
-        if sortBy:
-            if sortBy == SortBy.CREATED:
-                sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:creationDate ?creationDate .'
-            if sortBy == SortBy.LASTMOD:
-                sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:lastModificationDate ?lastModificationDate .'
+        if not countOnly and sortBy:
+            for sortby in sortBy:
+                if sortby.property == Xsd_QName('oldap:creationDate'):
+                    sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:creationDate ?creationDate .'
+                elif sortby.property == Xsd_QName('oldap:lastModificationDate'):
+                    sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:lastModificationDate ?lastModificationDate .'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s ?p ?o .'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s rdf:type ?t .'
         if resClass:
@@ -1203,17 +1212,27 @@ class ResourceInstance:
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:attachedToRole ?role .'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}<< ?s oldap:attachedToRole ?role >> oldap:hasDataPermission ?DataPermission .'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}FILTER(isLiteral(?o) && (datatype(?o) = xsd:string || datatype(?o) = rdf:langString || lang(?o) != ""))'
-        sparql += f'\n{blank:{(indent + 2) * indent_inc}}FILTER(CONTAINS(LCASE(STR(?o)), "{s}"))  # case-insensitive substring match'
+        sparql += f'\n{blank:{(indent + 2) * indent_inc}}FILTER(CONTAINS(LCASE(STR(?o)), "{searchstr}"))  # case-insensitive substring match'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}}}'
         sparql += f'\n{blank:{indent * indent_inc}}}}'
 
-        if sortBy:
-            if sortBy == SortBy.CREATED:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?creationDate)'
-            if sortBy == SortBy.LASTMOD:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?lastModificationDate)'
-            if sortBy == SortBy.PROPVAL:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(LCASE(STR(?o)))'
+        if not countOnly and sortBy:
+            for sortby in sortBy:
+                if sortby.property == Xsd_QName('oldap:creationDate'):
+                    if sortby.dir == SortDir.asc:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?creationDate)'
+                    else:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY DESC(?creationDate)'
+                elif sortby.property == Xsd_QName('oldap:lastModificationDate'):
+                    if sortby.dir == SortDir.asc:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?lastModificationDate)'
+                    else:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY DESC(?lastModificationDate)'
+                elif sortby.property == Xsd_QName('oldap:propval'):
+                    if sortby.dir == SortDir.asc:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?o)'
+                    else:
+                        sparql += f'\n{blank:{indent * indent_inc}}ORDER BY DESC(?o)'
 
         if not countOnly:
             sparql += f'\n{blank:{indent * indent_inc}}LIMIT {limit} OFFSET {offset}'
@@ -1235,10 +1254,11 @@ class ResourceInstance:
                     Xsd_QName('owl:Class'): r['t']
                 }
                 if sortBy:
-                    if sortBy == SortBy.CREATED:
-                        tmp['oldap:creationDate'] = r['creationDate'],
-                    if sortBy == SortBy.LASTMOD:
-                        tmp['oldap:lastModificationDate'] = r['lastModificationDate']
+                    for sortby in sortBy:
+                        if sortby.property == Xsd_QName('oldap:creationDate'):
+                            tmp['oldap:creationDate'] = r['creationDate'],
+                        elif sortby.property == Xsd_QName('oldap:lastModificationDate'):
+                            tmp['oldap:lastModificationDate'] = r['lastModificationDate']
                 result[r['s']] = tmp
             return result
 
@@ -1247,43 +1267,19 @@ class ResourceInstance:
                       projectShortName: Xsd_NCName | str,
                       resClass: Xsd_QName | str,
                       includeProperties: list[Xsd_QName] | None = None,
-                      count_only: bool = False,
-                      sortBy: SortBy | None = None,
+                      countOnly: bool = False,
+                      sortBy: list[SortBy] = [],
                       limit: int = 100,
                       offset: int = 0,
                       indent: int = 0, indent_inc: int = 4) -> dict[Iri, dict[str, Xsd]]:
-        # TODO: PROBLEM: does not work for properties which use MAX_COUNT > 1 !!!!!!!
         """
         Retrieves all resources matching the specified parameters from a data store using a SPARQL query.
         Depending on the `count_only` flag, it can return either a count of matching resources or detailed
         information about each resource.
-
-        :param con: The connection object used to execute the SPARQL query.
-        :type con: IConnection
-        :param projectShortName: The short name of the project being queried.
-        :type projectShortName: Xsd_NCName | str
-        :param resClass: The resource class to filter the results by.
-        :type resClass: Xsd_QName | str
-        :param includeProperties: A list of resource properties to include in the query and results.
-        :type includeProperties: list[Xsd_QName] | None
-        :param count_only: If True, returns only the count of matching resources. Defaults to False.
-        :type count_only: bool
-        :param sortBy: The sorting criterion for the results. Defaults to None.
-        :type sortBy: SortBy | None
-        :param limit: The maximum number of results to retrieve. Defaults to 100.
-        :type limit: int
-        :param offset: The starting point for result retrieval in pagination. Defaults to 0.
-        :type offset: int
-        :param indent: The initial level of indentation for the SPARQL query strings. Defaults to 0.
-        :type indent: int
-        :param indent_inc: The incremental level of indentation for the SPARQL query strings. Defaults to 4.
-        :type indent_inc: int
-        :return: A dictionary where keys are resource IRIs and values are dictionaries containing resource
-            properties and their corresponding values. If `count_only` is True, returns the total count of
-            matching resources as an integer.
-        :rtype: dict[Iri, dict[str, Xsd]]
-        :raises OldapError: If there is an error during query execution in the connection object.
         """
+        # --- ensure re is imported ---
+        import re
+
         if not isinstance(projectShortName, Xsd_NCName):
             graph = Xsd_NCName(projectShortName, validate=True)
         else:
@@ -1291,22 +1287,26 @@ class ResourceInstance:
         if not isinstance(resClass, Xsd_QName):
             resClass = Xsd_QName(resClass, validate=True)
 
+        if sortBy:
+            for s in sortBy:
+                if not isinstance(s, SortBy):
+                    raise OldapErrorType(f'Expected SortBy, got {type(s)}')
+                if not includeProperties or s.property not in includeProperties:
+                    if not includeProperties:
+                        includeProperties = []
+                    includeProperties.append(s.property)
+
         blank = ''
         context = Context(name=con.context_name)
         sparql = context.sparql_context
 
-        if (count_only):
+        if (countOnly):
             sparql += f'{blank:{indent * indent_inc}}SELECT (COUNT(DISTINCT ?s) as ?numResult)'
         else:
             sparql += f'{blank:{indent * indent_inc}}SELECT DISTINCT ?s'
             if includeProperties:
                 for index, item in enumerate(includeProperties):
                     sparql += f' ?o{index}'
-            if sortBy:
-                if sortBy == SortBy.CREATED:
-                    sparql += ' ?creationDate'
-                if sortBy == SortBy.LASTMOD:
-                    sparql += '?lastModificationDate'
         sparql += f'\n{blank:{indent * indent_inc}}WHERE {{'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}GRAPH oldap:admin {{'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}{con.userIri.toRdf} oldap:hasRole ?role .'
@@ -1316,30 +1316,23 @@ class ResourceInstance:
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}GRAPH {graph}:data {{'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:attachedToRole ?role .'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}<< ?s oldap:attachedToRole ?role >> oldap:hasDataPermission ?dataperm .'
-        if sortBy:
-            if sortBy == SortBy.CREATED:
-                sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:creationDate ?creationDate .'
-            if sortBy == SortBy.LASTMOD:
-                sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s oldap:lastModificationDate ?lastModificationDate .'
         if includeProperties:
             for index, prop in enumerate(includeProperties):
-                sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s {prop} ?o{index} .'
+                sparql += f'\n{blank:{(indent + 2) * indent_inc}}OPTIONAL {{ ?s {prop} ?o{index} . }}'
         sparql += f'\n{blank:{(indent + 2) * indent_inc}}?s rdf:type {resClass} .'
         sparql += f'\n{blank:{(indent + 1) * indent_inc}}}}'
         sparql += f'\n{blank:{indent * indent_inc}}}}'
 
-        if sortBy:
-            if sortBy == SortBy.CREATED:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?creationDate)'
-            if sortBy == SortBy.LASTMOD:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY ASC(?lastModificationDate)'
-            if sortBy == SortBy.PROPVAL:
-                sparql += f'\n{blank:{indent * indent_inc}}ORDER BY'
-                if includeProperties:
-                    for index, item in enumerate(includeProperties):
-                        sparql += f'\n{blank:{indent * indent_inc}} ?o{index}'
+        if not countOnly and sortBy:
+            sparql += f'\n{blank:{indent * indent_inc}}ORDER BY'
+            for s in sortBy:
+                if s.dir == SortDir.asc:
+                    sparql += f' ASC(?o{includeProperties.index(s.property)})'
+                else:
+                    sparql += f' DESC(?o{includeProperties.index(s.property)})'
+            sparql += '\n'
 
-        if not count_only:
+        if not countOnly:
             sparql += f'\n{blank:{indent * indent_inc}}LIMIT {limit} OFFSET {offset}'
         sparql += '\n'
 
@@ -1349,22 +1342,33 @@ class ResourceInstance:
             print(sparql)
             raise
         res = QueryProcessor(context, jsonres)
-        if count_only:
+        if countOnly:
             return res[0]['numResult']
         else:
             result = {}
             for r in res:
-                tmp = {}
+                if result.get(r['s'], None) is None:
+                    result[r['s']] = {}
                 if includeProperties:
-                    for index, item in enumerate(includeProperties):
-                        tmp[item] = r[f'o{index}']
+                    for index, property in enumerate(includeProperties):
+                        if result[r['s']].get(property, None) is None:
+                            result[r['s']][property] = []
+                        raw = r.get(f'o{index}')
+                        if raw is None:
+                            continue
+                        if raw not in result[r['s']][property]:
+                            result[r['s']][property].append(raw)
+            if includeProperties:
+                for k, v in result.items():
+                    for index, property in enumerate(includeProperties):
+                        is_langstring = False
+                        for val in v[property]:
+                            if isinstance(val, Xsd_string) and val.lang is not None:
+                                is_langstring = True
+                                break
+                        if is_langstring:
+                            v[property] = LangString(v[property])
 
-                if sortBy:
-                    if sortBy == SortBy.CREATED:
-                        tmp[Xsd_QName('oldap:creationDate')] = r['creationDate']
-                    if sortBy == SortBy.LASTMOD:
-                        tmp[Xsd_QName('oldap:lastModificationDate')] = r['lastModificationDate']
-                result[r['s']] = tmp
             return result
 
     @staticmethod

oldaplib-0.4.6/oldaplib/src/version.py

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