fairgraph 0.11.0__tar.gz → 0.12.2__tar.gz

{fairgraph-0.11.0 → fairgraph-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fairgraph
-Version: 0.11.0
+Version: 0.12.2
 Summary: Python API for the EBRAINS Knowledge Graph
 Author-email: "Andrew P. Davison" <andrew.davison@cnrs.fr>
 License: Apache Software License
@@ -11,16 +11,30 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE.txt
+Requires-Dist: ebrains-kg-core
+Requires-Dist: python-dateutil
+Requires-Dist: tabulate
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: twine; extra == "dev"
 
 # fairgraph: a Python API for the EBRAINS Knowledge Graph.
 
 Authors: Andrew P. Davison, Onur Ates, Nico Feld, Yann Zerlaut, Glynis Mattheisen, Peyman Najafi
 
-Copyright CNRS 2019-2023
+Copyright CNRS 2019-2024
 
 **fairgraph** is a Python library for working with metadata
 in the EBRAINS Knowledge Graph, with a particular focus on data reuse,
@@ -84,10 +98,10 @@ following the openMINDS structure. For example:
 
 ```
 >>> from fairgraph.openminds.core import DatasetVersion
->>> from fairgraph.openminds.controlledterms import Technique
+>>> from fairgraph.openminds.controlled_terms import Technique
 ```
 
-The following openMINDS modules are currently available: `core`, `controlledterms`, `sands`, `computation`, `ephys`, `publications`.
+The following openMINDS modules are currently available: `core`, `controlled_terms`, `sands`, `computation`, `chemicals`, `specimen_prep`, `ephys`, `publications`, `stimulation`.
 Using these classes, it is possible to list all metadata matching a particular criterion, e.g.
 
 ```
@@ -174,4 +188,5 @@ please open a ticket in the [issue tracker](https://github.com/HumanBrainProject
 
 <div><img src="https://www.braincouncil.eu/wp-content/uploads/2018/11/wsi-imageoptim-EU-Logo.jpg" alt="EU Logo" height="23%" width="15%" align="right" style="margin-left: 10px"></div>
 
-This open source software code was developed in part or in whole in the Human Brain Project, funded from the European Union's Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and SGA3).
+This open source software code was developed in part or in whole in the Human Brain Project, funded from the European Union's Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and SGA3) and in the EBRAINS research infrastructure,
+funded from the European Union's Horizon Europe funding programme under grant agreement No. 101147319 (EBRAINS-2.0).

{fairgraph-0.11.0 → fairgraph-0.12.2}/README.md

@@ -2,7 +2,7 @@
 
 Authors: Andrew P. Davison, Onur Ates, Nico Feld, Yann Zerlaut, Glynis Mattheisen, Peyman Najafi
 
-Copyright CNRS 2019-2023
+Copyright CNRS 2019-2024
 
 **fairgraph** is a Python library for working with metadata
 in the EBRAINS Knowledge Graph, with a particular focus on data reuse,
@@ -66,10 +66,10 @@ following the openMINDS structure. For example:
 
 ```
 >>> from fairgraph.openminds.core import DatasetVersion
->>> from fairgraph.openminds.controlledterms import Technique
+>>> from fairgraph.openminds.controlled_terms import Technique
 ```
 
-The following openMINDS modules are currently available: `core`, `controlledterms`, `sands`, `computation`, `ephys`, `publications`.
+The following openMINDS modules are currently available: `core`, `controlled_terms`, `sands`, `computation`, `chemicals`, `specimen_prep`, `ephys`, `publications`, `stimulation`.
 Using these classes, it is possible to list all metadata matching a particular criterion, e.g.
 
 ```
@@ -156,4 +156,5 @@ please open a ticket in the [issue tracker](https://github.com/HumanBrainProject
 
 <div><img src="https://www.braincouncil.eu/wp-content/uploads/2018/11/wsi-imageoptim-EU-Logo.jpg" alt="EU Logo" height="23%" width="15%" align="right" style="margin-left: 10px"></div>
 
-This open source software code was developed in part or in whole in the Human Brain Project, funded from the European Union's Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and SGA3).
+This open source software code was developed in part or in whole in the Human Brain Project, funded from the European Union's Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270, No. 785907 and No. 945539 (Human Brain Project SGA1, SGA2 and SGA3) and in the EBRAINS research infrastructure,
+funded from the European Union's Horizon Europe funding programme under grant agreement No. 101147319 (EBRAINS-2.0).

{fairgraph-0.11.0 → fairgraph-0.12.2}/fairgraph/__init__.py

@@ -4,7 +4,7 @@ Python client for the EBRAINS Knowledge Graph
 Authors: Andrew Davison et al., CNRS (see authors.rst)
 
 
-Copyright 2018-2023 CNRS
+Copyright 2018-2024 CNRS
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@ from .kgproxy import KGProxy
 from .kgquery import KGQuery
 from .base import IRI
 
-__version__ = "0.11.0"
+__version__ = "0.12.2"
 
 # from . import (
 #    base, client, errors, utility, openminds)

{fairgraph-0.11.0 → fairgraph-0.12.2}/fairgraph/base.py

@@ -3,7 +3,7 @@ This module contains base classes that define interfaces
 and contain code common to sub-classes, to avoid code duplication.
 """
 
-# Copyright 2018-2023 CNRS
+# Copyright 2018-2024 CNRS
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,7 +19,6 @@ and contain code common to sub-classes, to avoid code duplication.
 
 
 from __future__ import annotations
-
 from typing import TYPE_CHECKING, Optional, Dict, List, Union, Any
 from typing_extensions import TypeAlias
 from copy import copy
@@ -29,16 +28,17 @@ from warnings import warn
 
 from .registry import Registry
 from .queries import QueryProperty
-from .errors import ResolutionFailure, AuthorizationError
+from .errors import ResolutionFailure, AuthorizationError, CannotBuildExistenceQuery
 from .utility import (
     as_list,  # temporary for backwards compatibility (a lot of code imports it from here)
     expand_uri,
     normalize_data,
+    invert_dict
 )
 
 if TYPE_CHECKING:
     from .client import KGClient
-    from .fields import Field
+    from .properties import Property
     from .utility import ActivityLog
 
 logger = logging.getLogger("fairgraph")
@@ -74,40 +74,49 @@ class Resolvable:  # all
 
 
 class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and EmbeddedMetadata
-    fields: List[Field]
+    properties: List[Property]
+    reverse_properties: List[Property]
     context: Dict[str, str]
-    type_: List[str]
+    type_: str
     scope: Optional[str]
     space: Union[str, None]
     default_space: Union[str, None]
     remote_data: Optional[JSONdict]
+    aliases: Dict[str, str] = {}
 
     def __init__(self, data: Optional[Dict] = None, **properties):
         properties_copy = copy(properties)
-        for field in self.fields:
+        for prop in self.__class__.all_properties:
             try:
-                value = properties[field.name]
+                val = properties[prop.name]
             except KeyError:
-                if field.required:
-                    msg = "Field '{}' is required.".format(field.name)
-                    ErrorHandling.handle_violation(field.error_handling, msg)
-                value = None
+                if prop.required:
+                    msg = "Property '{}' is required.".format(prop.name)
+                    ErrorHandling.handle_violation(prop.error_handling, msg)
+                val = None
             else:
-                properties_copy.pop(field.name)
-            if value is None:
-                value = field.default
-                if callable(value):
-                    value = value()
-            elif isinstance(value, (list, tuple)) and len(value) == 0:  # empty list
-                value = None
-            field.check_value(value)
-            setattr(self, field.name, value)
+                properties_copy.pop(prop.name)
+            if val is None:
+                val = prop.default
+                if callable(val):
+                    val = val()
+            elif isinstance(val, (list, tuple)) and len(val) == 0:  # empty list
+                val = None
+            setattr(self, prop.name, val)
+        for name_, alias_ in self.aliases.items():
+            # the trailing underscores are because 'name' and 'alias' can be keys in 'properties'
+            if name_ in properties_copy:
+                val = properties_copy.pop(name_)
+                if val is not None:
+                    if properties.get(alias_, None):
+                        raise ValueError(f"'{name_}' is an alias for '{alias_}', you cannot specify both")
+                    setattr(self, alias_, val)
         if len(properties_copy) > 0:
             if len(properties_copy) == 1:
-                raise NameError(f'{self.__class__.__name__} does not have a field named "{list(properties_copy)[0]}".')
+                raise NameError(f'{self.__class__.__name__} does not have a property named "{list(properties_copy)[0]}".')
             else:
                 raise NameError(
-                    f"""{self.__class__.__name__} does not have fields named "{'", "'.join(properties_copy)}"."""
+                    f"""{self.__class__.__name__} does not have properties named "{'", "'.join(properties_copy)}"."""
                 )
 
         # we store the original remote data in `_raw_remote_data`
@@ -115,14 +124,35 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
         self._raw_remote_data = data  # for debugging
         self.remote_data = {}
         if data:
-            self.remote_data = self.to_jsonld(include_empty_fields=True, follow_links=False)
+            self.remote_data = self.to_jsonld(include_empty_properties=True, follow_links=False)
+
+    def __getattribute__(self, name):
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            if name in self.aliases:
+                return object.__getattribute__(self, self.aliases[name])
+            else:
+                raise
+
+    def __setattr__(self, name, value):
+        try:
+            prop = self._property_lookup[name]
+        except KeyError:
+            if name in self.aliases:
+                setattr(self, self.aliases[name], value)
+            else:
+                super().__setattr__(name, value)
+        else:
+            prop.check_value(value)
+            super().__setattr__(name, value)
 
     def to_jsonld(
         self,
         normalized: bool = True,
         follow_links: bool = False,
-        include_empty_fields: bool = False,
-        include_reverse_fields: bool = False,
+        include_empty_properties: bool = False,
+        include_reverse_properties: bool = False,
     ):
         """
         Return a JSON-LD representation of this metadata object
@@ -131,20 +161,20 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
             normalized (bool): Whether to expand all URIs. Defaults to True.
             follow_links (bool, optional): Whether to represent linked objects just by their "@id"
                 or to include their full metadata. Defaults to False.
-            include_empty_fields (bool, optional): Whether to include empty fields (with value "null").
+            include_empty_properties (bool, optional): Whether to include empty properties (with value "null").
                 Defaults to False.
 
         """
-        if self.fields:
-            data: JSONdict = {"@type": self.type_}
+        if self.properties:
+            data: JSONdict = {"@type": [self.type_]}
             if hasattr(self, "id") and self.id:
                 data["@id"] = self.id
-            for field in self.fields:
-                if field.intrinsic or include_reverse_fields:
-                    expanded_path = field.expanded_path
-                    value = getattr(self, field.name)
-                    if include_empty_fields or field.required or value is not None:
-                        serialized = field.serialize(value, follow_links=follow_links)
+            for prop in self.__class__.all_properties:
+                if prop.intrinsic or include_reverse_properties:
+                    expanded_path = prop.expanded_path
+                    value = getattr(self, prop.name)
+                    if include_empty_properties or prop.required or value is not None:
+                        serialized = prop.serialize(value, follow_links=follow_links)
                         if expanded_path in data:
                             if isinstance(data[expanded_path], list):
                                 data[expanded_path].append(serialized)
@@ -181,41 +211,40 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
         activity_log: Optional[ActivityLog] = None,
         replace: bool = False,
         ignore_auth_errors: bool = False,
+        ignore_duplicates: bool = False
     ):
         pass
 
     @classmethod
     def set_error_handling(
-        cls, value: Union[ErrorHandling, None], field_names: Optional[Union[str, List[str]]] = None
+        cls, value: Union[ErrorHandling, None], property_names: Optional[Union[str, List[str]]] = None
     ):
         """
         Control validation for this class.
 
         Args:
             value (str): action to follow when there is a validation failure.
-                (e.g. if a required field is not provided).
+                (e.g. if a required property is not provided).
                 Possible values: "error", "warning", "log", None
-            field_names (str or list of str, optional): If not provided, the error handling
-                mode will be applied to all fields. If a field name or list of names is given,
-                the mode will be applied only to those fields.
+            property_names (str or list of str, optional): If not provided, the error handling
+                mode will be applied to all properties. If a property name or list of names is given,
+                the mode will be applied only to those properties.
         """
         if value is None:
             value = ErrorHandling.none
         else:
             value = ErrorHandling(value)
-        if field_names:
-            for field_name in as_list(field_names):
-                found = False
-                for field in cls.fields:
-                    if field.name == field_name:
-                        field.error_handling = value
-                        found = True
-                        break
-                if not found:
-                    raise ValueError("No such field: {}".format(field_name))
+        if property_names:
+            for property_name in as_list(property_names):
+                try:
+                    prop = cls._property_lookup[property_name]
+                except KeyError:
+                    raise ValueError("No such property: {}".format(property_name))
+                else:
+                    prop.error_handling = value
         else:
-            for field in cls.fields:
-                field.error_handling = value
+            for prop in cls.all_properties:
+                prop.error_handling = value
 
     @classmethod
     def normalize_filter(cls, filter_dict: Dict[str, Any]) -> Dict[str, Any]:
@@ -232,15 +261,22 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
              'custodians': 'https://kg.ebrains.eu/api/instances/045f846f-f010-4db8-97b9-b95b20970bf2'}
         """
         normalized = {}
-        for field in cls.fields:
-            if field.name in filter_dict:
-                value = filter_dict[field.name]
+        filter_dict_copy = filter_dict.copy()
+
+        # handle aliases
+        for name_, alias_ in cls.aliases.items():
+            if name_ in filter_dict_copy:
+                filter_dict_copy[alias_] = filter_dict_copy.pop(name_)
+
+        for prop in cls.all_properties:
+            if prop.name in filter_dict_copy:
+                value = filter_dict_copy[prop.name]
                 if isinstance(value, dict):
-                    normalized[field.name] = {}
-                    for child_cls in field.types:
-                        normalized[field.name].update(child_cls.normalize_filter(value))
+                    normalized[prop.name] = {}
+                    for child_cls in prop.types:
+                        normalized[prop.name].update(child_cls.normalize_filter(value))
                 else:
-                    normalized[field.name] = field.get_filter_value(value)
+                    normalized[prop.name] = prop.get_filter_value(value)
         return normalized
 
     @classmethod
@@ -253,11 +289,17 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
             follow_links (dict): The links in the graph to follow when constructing the query. Defaults to None.
         """
         properties = [QueryProperty("@type")]
-        for field in cls.fields:
-            if field.is_link and follow_links and field.name in follow_links:
-                properties.extend(field.get_query_properties(follow_links[field.name]))
+        reverse_aliases = invert_dict(cls.aliases)
+        for prop in cls.all_properties:
+            if prop.is_link and follow_links:
+                if prop.name in follow_links:
+                    properties.extend(prop.get_query_properties(follow_links[prop.name]))
+                elif reverse_aliases.get(prop.name, None) in follow_links:
+                    properties.extend(prop.get_query_properties(follow_links[reverse_aliases[prop.name]]))
+                else:
+                    properties.extend(prop.get_query_properties())
             else:
-                properties.extend(field.get_query_properties())
+                properties.extend(prop.get_query_properties())
         return properties
 
     @classmethod
@@ -273,9 +315,9 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
         if filters is None:
             filters = {}
         properties = []
-        for field in cls.fields:
-            if field.name in filters:
-                properties.append(field.get_query_filter_property(filters[field.name]))
+        for prop in cls.all_properties:
+            if prop.name in filters:
+                properties.append(prop.get_query_filter_property(filters[prop.name]))
         return properties
 
     @classmethod
@@ -293,22 +335,41 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
                     D[normalised_key].extend(value)
                 else:
                     D[normalised_key] = value
-            elif key.startswith("Q"):  # for 'Q' fields in data from queries
+            elif key.startswith("Q"):  # for 'Q' properties in data from queries
                 D[key] = value
             elif key[0] != "@":
                 normalised_key = expand_uri(key, cls.context)
                 D[normalised_key] = value
-        for otype in expand_uri(as_list(cls.type_), cls.context):
-            if otype not in D["@type"]:
-                raise TypeError("type mismatch {} - {}".format(otype, D["@type"]))
+        if cls.type_ not in D["@type"]:
+            raise TypeError("type mismatch {} - {}".format(cls.type_, D["@type"]))
+
+        def _get_type_from_data(data_item):
+            type_ = data_item.get("@type", None)
+            if type_:
+                return type_[0]
+            else:
+                return None
+
         deserialized_data = {}
-        for field in cls.fields:
-            expanded_path = expand_uri(field.path, cls.context)
+        for prop in cls.all_properties:
+            expanded_path = expand_uri(prop.path, cls.context)
             data_item = D.get(expanded_path)
+            if data_item is not None and prop.reverse:
+                # for reverse properties, more than one property can have the same path
+                # so we extract only those sub-items whose types match
+                try:
+                    data_item = [
+                        part for part in as_list(data_item)
+                        if _get_type_from_data(part) in [t.type_ for t in prop.types]
+                    ]
+                except AttributeError:
+                    # problem when a forward and reverse path both given the same expanded path
+                    # e.g. for Configuration
+                    data_item = None
             # sometimes queries put single items in a list, this removes the enclosing list
-            if (not field.multiple) and isinstance(data_item, (list, tuple)) and len(data_item) == 1:
+            if (not prop.multiple) and isinstance(data_item, (list, tuple)) and len(data_item) == 1:
                 data_item = data_item[0]
-            deserialized_data[field.name] = field.deserialize(data_item, client, belongs_to=data.get("@id", None))
+            deserialized_data[prop.name] = prop.deserialize(data_item, client, belongs_to=data.get("@id", None))
         return deserialized_data
 
     def resolve(
@@ -319,7 +380,7 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
         follow_links: Optional[Dict[str, Any]] = None,
     ):
         """
-        Resolve fields that are represented by KGProxy objects.
+        Resolve properties that are represented by KGProxy objects.
 
         Args:
             client: KGClient object that handles the communication with the KG.
@@ -332,39 +393,83 @@ class ContainsMetadata(Resolvable, metaclass=Registry):  # KGObject and Embedded
         """
         use_scope = scope or self.scope or "released"
         if follow_links:
-            for field in self.fields:
-                if field.is_link and field.name in follow_links:
-                    if issubclass(field.types[0], ContainsMetadata):
-                        values = getattr(self, field.name)
-                        resolved_values: List[Any] = []
-                        for value in as_list(values):
-                            if isinstance(value, Resolvable):
-                                if isinstance(value, ContainsMetadata) and isinstance(value, RepresentsSingleObject):
-                                    # i.e. isinstance(value, KGObject) - already resolved
-                                    resolved_values.append(value)
-                                else:
-                                    try:
-                                        resolved_value = value.resolve(
-                                            client,
-                                            scope=use_scope,
-                                            use_cache=use_cache,
-                                            follow_links=follow_links[field.name],
-                                        )
-                                    except ResolutionFailure as err:
-                                        warn(str(err))
+            reverse_aliases = invert_dict(self.__class__.aliases)
+            for prop in self.__class__.all_properties:
+                if prop.is_link:
+                    follow_name = None
+                    if prop.name in follow_links:
+                        follow_name = prop.name
+                    elif reverse_aliases.get(prop.name, None) in follow_links:
+                        follow_name = reverse_aliases[prop.name]
+
+                    if follow_name:
+                        if issubclass(prop.types[0], ContainsMetadata):
+                            values = getattr(self, prop.name)
+                            resolved_values: List[Any] = []
+                            for value in as_list(values):
+                                if isinstance(value, Resolvable):
+                                    if isinstance(value, ContainsMetadata) and isinstance(value, RepresentsSingleObject):
+                                        # i.e. isinstance(value, KGObject) - already resolved
                                         resolved_values.append(value)
                                     else:
-                                        resolved_values.append(resolved_value)
-                        if isinstance(values, RepresentsSingleObject):
-                            assert len(resolved_values) == 1
-                            setattr(self, field.name, resolved_values[0])
-                        elif values is None:
-                            assert len(resolved_values) == 0
-                            setattr(self, field.name, None)
-                        else:
-                            setattr(self, field.name, resolved_values)
+                                        try:
+                                            resolved_value = value.resolve(
+                                                client,
+                                                scope=use_scope,
+                                                use_cache=use_cache,
+                                                follow_links=follow_links[follow_name],
+                                            )
+                                        except ResolutionFailure as err:
+                                            warn(str(err))
+                                            resolved_values.append(value)
+                                        else:
+                                            resolved_values.append(resolved_value)
+                            if isinstance(values, RepresentsSingleObject):
+                                assert len(resolved_values) == 1
+                                setattr(self, prop.name, resolved_values[0])
+                            elif values is None:
+                                assert len(resolved_values) == 0
+                                setattr(self, prop.name, None)
+                            else:
+                                setattr(self, prop.name, resolved_values)
         return self
 
+    def _build_existence_query(self) -> Union[None, Dict[str, Any]]:
+        """
+        Generate a KG query definition (as a JSON-LD document) that can be used to
+        check whether a locally-defined object (with no ID) already exists in the KG.
+        """
+        if self.existence_query_properties is None:
+            return None
+
+        query_properties = []
+        for property_name in self.existence_query_properties:
+            for property in self.__class__.all_properties:
+                if property.name == property_name:
+                    query_properties.append(property)
+                    break
+        if len(query_properties) < 1:
+            raise CannotBuildExistenceQuery("Empty existence query for class {}".format(self.__class__.__name__))
+        query = {}
+        for property in query_properties:
+            query_property_name = property.name
+            value = getattr(self, property.name)
+            if isinstance(value, ContainsMetadata):
+                if hasattr(value, "id") and value.id:
+                    query[query_property_name] = value.id
+                else:
+                    sub_query = value._build_existence_query()
+                    query.update({f"{query_property_name}__{key}": val for key, val in sub_query.items()})
+            elif isinstance(value, (list, tuple)):
+                raise CannotBuildExistenceQuery("not implemented yet")
+            elif value is None:
+                raise CannotBuildExistenceQuery(f"Required value for '{query_property_name}' is missing")
+            else:
+                query_val = property.serialize(value, follow_links=False)
+                if query_val is None:
+                    raise CannotBuildExistenceQuery(f"Required value for '{query_property_name}' is missing")
+                query[query_property_name] = query_val
+        return query
 
 class RepresentsSingleObject(Resolvable):  # KGObject, KGProxy
     id: Optional[str]
@@ -414,7 +519,7 @@ class IRI:
         else:
             iri = value
         if not iri.startswith("http"):
-            raise ValueError("Invalid IRI")
+            raise ValueError(f"Invalid IRI: '{iri}'")
         self.value: str = iri
 
     def __eq__(self, other):

{fairgraph-0.11.0 → fairgraph-0.12.2}/fairgraph/caching.py

@@ -3,7 +3,7 @@ This module contains global caches for Knowledge Graph data and queries,
 to avoid making unnecessary API calls.
 """
 
-# Copyright 2018-2023 CNRS
+# Copyright 2018-2024 CNRS
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -31,7 +31,10 @@ def generate_cache_key(qd: Dict[str, str]) -> Tuple:
         if isinstance(value, (list, tuple)):
             sub_key = []
             for sub_value in value:
-                sub_key.append(generate_cache_key(sub_value))
+                if isinstance(sub_value, dict):
+                    sub_key.append(generate_cache_key(sub_value))
+                else:
+                    sub_key.append(str(value))
             cache_key.append(tuple(sub_key))
         elif isinstance(value, dict):
             cache_key.append((key, str(value)))