invenio-vocabularies 6.7.0__py2.py3-none-any.whl → 6.9.0__py2.py3-none-any.whl

invenio_vocabularies/__init__.py

@@ -10,6 +10,6 @@
 
 from .ext import InvenioVocabularies
 
-__version__ = "6.7.0"
+__version__ = "6.9.0"
 
 __all__ = ("__version__", "InvenioVocabularies")

invenio_vocabularies/cli.py

@@ -29,6 +29,8 @@ def _process_vocab(config, num_samples=None):
         readers_config=config["readers"],
         transformers_config=config.get("transformers"),
         writers_config=config["writers"],
+        batch_size=config.get("batch_size", 1000),
+        write_many=config.get("write_many", False),
     )
 
     success, errored, filtered = 0, 0, 0

invenio_vocabularies/config.py

@@ -196,6 +196,9 @@ VOCABULARIES_SUBJECTS_GEMET_FILE_URL = (
 )
 """Subject GEMET file download link."""
 
+VOCABULARIES_SUBJECTS_BODC_PUV_FILE_URL = "http://vocab.nerc.ac.uk/collection/P01/current/?_profile=nvs&_mediatype=application/rdf+xml"
+"""Subject BODC-PUV file download link."""
+
 VOCABULARIES_AFFILIATIONS_EDMO_COUNTRY_MAPPING = {
     "Cape Verde": "Cabo Verde",
 }
@@ -213,3 +216,16 @@ VOCABULARIES_ORCID_SYNC_SINCE = {
     "days": 1,
 }
 """ORCID time shift to sync. Parameters accepted are the ones passed to 'datetime.timedelta'."""
+
+VOCABULARIES_ORCID_ORG_IDS_MAPPING_PATH = None
+"""Path to the CSV file for mapping ORCiD organization IDs to affiliation IDs.
+
+The path can be specified as either an absolute path or a relative path within the
+Flask app instance folder (i.e. ``current_app.instance_path``).
+
+The CSV file should have the following columns:
+
+- `org_scheme`: The ORCiD organization ID.
+- `org_id`: The ORCiD organization ID.
+- `aff_id`: The affiliation ID to map to.
+"""

invenio_vocabularies/contrib/affiliations/schema.py

@@ -59,3 +59,13 @@ class AffiliationRelationSchema(ContribVocabularyRelationSchema):
     ftf_name = "name"
     parent_field_name = "affiliations"
     name = SanitizedUnicode()
+    identifiers = IdentifierSet(
+        fields.Nested(
+            partial(
+                IdentifierSchema,
+                allowed_schemes=affiliation_schemes,
+                identifier_required=False,
+            )
+        ),
+        dump_only=True,
+    )

invenio_vocabularies/contrib/names/datastreams.py

@@ -13,12 +13,14 @@ import io
 import tarfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import timedelta
+from itertools import islice
+from pathlib import Path
 
 import arrow
 import regex as re
 from flask import current_app
 from invenio_access.permissions import system_identity
-from invenio_records.dictutils import dict_lookup
+from werkzeug.utils import cached_property
 
 from invenio_vocabularies.contrib.names.s3client import S3OrcidClient
 
@@ -47,10 +49,11 @@ class OrcidDataSyncReader(BaseReader):
         suffix = orcid_to_sync[-3:]
         key = f"{suffix}/{orcid_to_sync}.xml"
         try:
+            # Potential improvement: use the a XML jax parser to avoid loading the whole file in memory
+            # and choose the sections we need to read (probably the summary)
             return self.s3_client.read_file(f"s3://{bucket}/{key}")
-        except Exception as e:
-            # TODO: log
-            return None
+        except Exception:
+            current_app.logger.exception("Failed to fetch ORCiD record.")
 
     def _process_lambda_file(self, fileobj):
         """Process the ORCiD lambda file and returns a list of ORCiDs to sync.
@@ -67,42 +70,54 @@ class OrcidDataSyncReader(BaseReader):
         if self.since:
             time_shift = self.since
         last_sync = arrow.now() - timedelta(**time_shift)
-
-        file_content = fileobj.read().decode("utf-8")
-
-        csv_reader = csv.DictReader(file_content.splitlines())
-
-        for row in csv_reader:  # Skip the header line
-            orcid = row["orcid"]
-
-            # Lambda file is ordered by last modified date
-            last_modified_str = row["last_modified"]
-            try:
-                last_modified_date = arrow.get(last_modified_str, date_format)
-            except arrow.parser.ParserError:
-                last_modified_date = arrow.get(last_modified_str, date_format_no_millis)
-
-            if last_modified_date < last_sync:
-                break
-            yield orcid
+        try:
+            content = io.TextIOWrapper(fileobj, encoding="utf-8")
+            csv_reader = csv.DictReader(content)
+
+            for row in csv_reader:  # Skip the header line
+                orcid = row["orcid"]
+
+                # Lambda file is ordered by last modified date
+                last_modified_str = row["last_modified"]
+                try:
+                    last_modified_date = arrow.get(last_modified_str, date_format)
+                except arrow.parser.ParserError:
+                    last_modified_date = arrow.get(
+                        last_modified_str, date_format_no_millis
+                    )
+
+                if last_modified_date < last_sync:
+                    break
+                yield orcid
+        finally:
+            fileobj.close()
 
     def _iter(self, orcids):
         """Iterates over the ORCiD records yielding each one."""
         with ThreadPoolExecutor(
             max_workers=current_app.config["VOCABULARIES_ORCID_SYNC_MAX_WORKERS"]
         ) as executor:
-            futures = [
-                executor.submit(
+            # futures is a dictionary where the key is the ORCID value and the item is the Future object
+            futures = {
+                orcid: executor.submit(
                     self._fetch_orcid_data,
                     orcid,
                     current_app.config["VOCABULARIES_ORCID_SUMMARIES_BUCKET"],
                 )
                 for orcid in orcids
-            ]
-            for future in as_completed(futures):
-                result = future.result()
-                if result is not None:
-                    yield result
+            }
+
+            for orcid in list(futures.keys()):
+                try:
+                    result = futures[orcid].result()
+                    if result:
+                        yield result
+                finally:
+                    # Explicitly release memory, as we don't need the future anymore.
+                    # This is mostly required because as long as we keep a reference to the future
+                    # (in the above futures dict), the garbage collector won't collect it
+                    # and it will keep the memory allocated.
+                    del futures[orcid]
 
     def read(self, item=None, *args, **kwargs):
         """Streams the ORCiD lambda file, process it to get the ORCiDS to sync and yields it's data."""
@@ -111,7 +126,6 @@ class OrcidDataSyncReader(BaseReader):
             "s3://orcid-lambda-file/last_modified.csv.tar"
         )
 
-        orcids_to_sync = []
         # Opens tar file and process it
         with tarfile.open(fileobj=io.BytesIO(tar_content)) as tar:
             # Iterate over each member (file or directory) in the tar file
@@ -119,10 +133,24 @@ class OrcidDataSyncReader(BaseReader):
                 # Extract the file
                 extracted_file = tar.extractfile(member)
                 if extracted_file:
+                    current_app.logger.info(f"[ORCID Reader] Processing lambda file...")
                     # Process the file and get the ORCiDs to sync
-                    orcids_to_sync.extend(self._process_lambda_file(extracted_file))
+                    orcids_to_sync = set(self._process_lambda_file(extracted_file))
+
+                    # Close the file explicitly after processing
+                    extracted_file.close()
+
+                    # Process ORCIDs in smaller batches
+                    for orcid_batch in self._chunked_iter(
+                        orcids_to_sync, batch_size=100
+                    ):
+                        yield from self._iter(orcid_batch)
 
-        yield from self._iter(orcids_to_sync)
+    def _chunked_iter(self, iterable, batch_size):
+        """Yield successive chunks of a given size."""
+        it = iter(iterable)
+        while chunk := list(islice(it, batch_size)):
+            yield chunk
 
 
 class OrcidHTTPReader(SimpleHTTPReader):
@@ -139,24 +167,75 @@ class OrcidHTTPReader(SimpleHTTPReader):
 
 
 DEFAULT_NAMES_EXCLUDE_REGEX = r"[\p{P}\p{S}\p{Nd}\p{No}\p{Emoji}--,.()\-']"
-"""Regex to filter out names with punctuations, symbols, decimal numbers and emojis."""
+"""Regex to filter out names with punctuation, symbols, numbers and emojis."""
+
+
+class OrcidOrgToAffiliationMapper:
+    """Default ORCiD Org ID to affiliation ID mapper."""
+
+    def __init__(self, org_ids_mapping=None, org_ids_mapping_file=None):
+        """Constructor."""
+        self._org_ids_mapping = org_ids_mapping
+        self._org_ids_mapping_file = org_ids_mapping_file
+
+    @cached_property
+    def org_ids_mapping(self):
+        """Mapping of ORCiD org IDs to affiliation IDs."""
+        org_ids_mapping_file = self._org_ids_mapping_file or current_app.config.get(
+            "VOCABULARIES_ORCID_ORG_IDS_MAPPING_PATH"
+        )
+        if org_ids_mapping_file:
+            org_ids_mapping_file = Path(org_ids_mapping_file)
+            # If the path is relative, prepend the instance path
+            if not org_ids_mapping_file.is_absolute():
+                org_ids_mapping_file = (
+                    Path(current_app.instance_path) / org_ids_mapping_file
+                )
+            with open(org_ids_mapping_file) as fin:
+                result = {}
+                reader = csv.reader(fin)
+
+                # Check if the first row is a header
+                org_scheme, org_id, aff_id = next(reader)
+                if org_scheme.lower() != "org_scheme":
+                    result[(org_scheme, org_id)] = aff_id
+
+                for org_scheme, org_id, aff_id in reader:
+                    result[(org_scheme, org_id)] = aff_id
+
+                return result
+
+        return self._org_ids_mapping or {}
+
+    def __call__(self, org_scheme, org_id):
+        """Map an ORCiD org ID to an affiliation ID."""
+        # By default we know that ROR IDs are linkable
+        if org_scheme == "ROR":
+            return org_id.split("/")[-1]
+        # Otherwise see if we have a mapping from other schemes to an affiliation ID
+        return self.org_ids_mapping.get((org_scheme, org_id))
 
 
 class OrcidTransformer(BaseTransformer):
     """Transforms an ORCiD record into a names record."""
 
     def __init__(
-        self, *args, names_exclude_regex=DEFAULT_NAMES_EXCLUDE_REGEX, **kwargs
+        self,
+        *args,
+        names_exclude_regex=DEFAULT_NAMES_EXCLUDE_REGEX,
+        org_id_to_affiliation_id_func=None,
+        **kwargs,
     ) -> None:
         """Constructor."""
         self._names_exclude_regex = names_exclude_regex
+        self._org_id_to_affiliation_id_func = (
+            org_id_to_affiliation_id_func or OrcidOrgToAffiliationMapper()
+        )
         super().__init__()
 
-    def _is_valid_name(self, name):
-        """Check whether the name passes the regex."""
-        if not self._names_exclude_regex:
-            return True
-        return not bool(re.search(self._names_exclude_regex, name, re.UNICODE | re.V1))
+    def org_id_to_affiliation_id(self, org_scheme, org_id):
+        """Convert and ORCiD org ID to a linkable affiliation ID."""
+        return self._org_id_to_affiliation_id_func(org_scheme, org_id)
 
     def apply(self, stream_entry, **kwargs):
         """Applies the transformation to the stream entry."""
@@ -166,42 +245,88 @@ class OrcidTransformer(BaseTransformer):
 
         name = person.get("name")
         if name is None:
-            raise TransformerError(f"Name not found in ORCiD entry.")
+            raise TransformerError("Name not found in ORCiD entry.")
         if name.get("family-name") is None:
-            raise TransformerError(f"Family name not found in ORCiD entry.")
+            raise TransformerError("Family name not found in ORCiD entry.")
 
         if not self._is_valid_name(name["given-names"] + name["family-name"]):
-            raise TransformerError(f"Invalid characters in name.")
+            raise TransformerError("Invalid characters in name.")
 
         entry = {
             "id": orcid_id,
             "given_name": name.get("given-names"),
             "family_name": name.get("family-name"),
             "identifiers": [{"scheme": "orcid", "identifier": orcid_id}],
-            "affiliations": [],
+            "affiliations": self._extract_affiliations(record),
         }
 
+        stream_entry.entry = entry
+        return stream_entry
+
+    def _is_valid_name(self, name):
+        """Check whether the name passes the regex."""
+        if not self._names_exclude_regex:
+            return True
+        return not bool(re.search(self._names_exclude_regex, name, re.UNICODE | re.V1))
+
+    def _extract_affiliations(self, record):
+        """Extract affiliations from the ORCiD record."""
+        result = []
         try:
-            employments = dict_lookup(
-                record, "activities-summary.employments.affiliation-group"
+            employments = (
+                record.get("activities-summary", {})
+                .get("employments", {})
+                .get("affiliation-group", [])
             )
+
+            # If there are single values, the XML to dict, doesn't wrap them in a list
             if isinstance(employments, dict):
                 employments = [employments]
-            history = set()
+
+            # Remove the "employment-summary" nesting
+            employments = [
+                employment.get("employment-summary", {}) for employment in employments
+            ]
+
             for employment in employments:
-                terminated = employment["employment-summary"].get("end-date")
-                affiliation = dict_lookup(
-                    employment,
-                    "employment-summary.organization.name",
-                )
-                if affiliation not in history and not terminated:
-                    history.add(affiliation)
-                    entry["affiliations"].append({"name": affiliation})
+                terminated = employment.get("end-date")
+                if terminated:
+                    continue
+
+                org = employment["organization"]
+                aff_id = self._extract_affiliation_id(org)
+
+                # Skip adding if the ID already exists in result
+                if aff_id and any(aff.get("id") == aff_id for aff in result):
+                    continue
+
+                # Skip adding if the name exists in result with no ID
+                if any(
+                    aff.get("name") == org["name"] and "id" not in aff for aff in result
+                ):
+                    continue
+
+                aff = {"name": org["name"]}
+                if aff_id:
+                    aff["id"] = aff_id
+
+                result.append(aff)
         except Exception:
             pass
-
-        stream_entry.entry = entry
-        return stream_entry
+        return result
+
+    def _extract_affiliation_id(self, org):
+        """Extract the affiliation ID from an ORCiD organization."""
+        dis_org = org.get("disambiguated-organization")
+        if not dis_org:
+            return
+
+        aff_id = None
+        org_id = dis_org.get("disambiguated-organization-identifier")
+        org_scheme = dis_org.get("disambiguation-source")
+        if org_id and org_scheme:
+            aff_id = self.org_id_to_affiliation_id(org_scheme, org_id)
+        return aff_id
 
 
 class NamesServiceWriter(ServiceWriter):

invenio_vocabularies/contrib/subjects/bodc/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2024 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""BODC Subjects module."""

invenio_vocabularies/contrib/subjects/bodc/datastreams.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2024 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""BODC subjects datastreams, readers, transformers, and writers."""
+
+from invenio_vocabularies.datastreams.errors import TransformerError
+from invenio_vocabularies.datastreams.readers import RDFReader
+from invenio_vocabularies.datastreams.transformers import RDFTransformer
+
+from ..config import bodc_puv_file_url
+
+# Available with the "rdf" extra
+try:
+    import rdflib
+except ImportError:
+    rdflib = None
+
+
+class BODCPUVSubjectsTransformer(RDFTransformer):
+    """
+    Transformer class to convert BODC-PUV RDF data to a dictionary format.
+
+    Input:
+        - Relevant fields:
+            - `skos:notation`: Primary identifier for the concept.
+            - `skos:prefLabel`: Preferred labels with language codes.
+            - `skos:altLabel`: Alternative labels (optional).
+            - `skos:definition`: Definitions of the concept.
+            - `owl:deprecated`: Boolean flag indicating if the concept is deprecated.
+
+    Output:
+        - A dictionary with the following structure:
+            {
+                "id": "SDN:P01::SAGEMSFM",  # BODC-specific parameter ID (skos:notation).
+                "scheme": "BODC-PUV",  # The scheme name indicating this is a BODC Parameter Usage Vocabulary concept.
+                "subject": "AMSSedAge",  # The alternative label (skos:altLabel), if available, or None.
+                "title": {
+                    "en": "14C age of Foraminiferida"  # English preferred label (skos:prefLabel).
+                },
+                "props": {
+                    "definitions": "Accelerated mass spectrometry on picked tests",  # Definition of subject (skos:definition).
+                },
+                "identifiers": [
+                    {
+                        "scheme": "url",  # Type of identifier (URL).
+                        "identifier": "http://vocab.nerc.ac.uk/collection/P01/current/SAGEMSFM"  # URI of the concept.
+                    }
+                ]
+            }
+    """
+
+    def _get_subject_data(self, rdf_graph, subject):
+        """Fetch all triples for a subject and organize them into a dictionary."""
+        data = {}
+        for predicate, obj in rdf_graph.predicate_objects(subject=subject):
+            predicate_name = str(predicate)
+            if predicate_name not in data:
+                data[predicate_name] = []
+            data[predicate_name].append(obj)
+        return data
+
+    def _transform_entry(self, subject, rdf_graph):
+        """Transform an entry to the required dictionary format."""
+        labels = self._get_labels(subject, rdf_graph)
+        subject_data = self._get_subject_data(rdf_graph, subject)
+        deprecated = subject_data.get(str(rdflib.namespace.OWL.deprecated), [False])
+        if deprecated and str(deprecated[0]).lower() == "true":
+            return None  # Skip deprecated subjects
+
+        notation = subject_data.get(str(self.skos_core.notation), [])
+        if notation:
+            id = str(notation[0])
+        else:
+            raise TransformerError(f"No id found for: {subject}")
+
+        alt_labels = [obj for obj in subject_data.get(str(self.skos_core.altLabel), [])]
+        subject_text = str(alt_labels[0]) if alt_labels else ""
+        definition = str(subject_data.get(str(self.skos_core.definition), [None])[0])
+
+        return {
+            "id": id,
+            "scheme": "BODC-PUV",
+            "subject": subject_text,
+            "title": labels,
+            "props": {"definition": definition} if definition else {},
+            "identifiers": self._get_identifiers(subject),
+        }
+
+
+# Configuration for datastream
+
+VOCABULARIES_DATASTREAM_TRANSFORMERS = {"bodc-transformer": BODCPUVSubjectsTransformer}
+
+DATASTREAM_CONFIG = {
+    "readers": [
+        {
+            "type": "http",
+            "args": {
+                "origin": bodc_puv_file_url,
+            },
+        },
+        {"type": "rdf"},
+    ],
+    "transformers": [{"type": "bodc-transformer"}],
+    "writers": [{"args": {"writer": {"type": "subjects-service"}}, "type": "async"}],
+}

invenio_vocabularies/contrib/subjects/config.py

@@ -15,10 +15,12 @@ from invenio_i18n import get_locale
 from invenio_i18n import lazy_gettext as _
 from invenio_records_resources.services import SearchOptions
 from invenio_records_resources.services.records.components import DataComponent
+from invenio_records_resources.services.records.queryparser import (
+    CompositeSuggestQueryParser,
+)
 from werkzeug.local import LocalProxy
 
 from ...services.components import PIDComponent
-from ...services.querystr import FilteredSuggestQueryParser
 
 subject_schemes = LocalProxy(
     lambda: current_app.config["VOCABULARIES_SUBJECTS_SCHEMES"]
@@ -34,13 +36,16 @@ euroscivoc_file_url = LocalProxy(
     lambda: current_app.config["VOCABULARIES_SUBJECTS_EUROSCIVOC_FILE_URL"]
 )
 
+bodc_puv_file_url = LocalProxy(
+    lambda: current_app.config["VOCABULARIES_SUBJECTS_BODC_PUV_FILE_URL"]
+)
+
 
 class SubjectsSearchOptions(SearchOptions):
     """Search options."""
 
-    suggest_parser_cls = FilteredSuggestQueryParser.factory(
-        filter_field="scheme",
-        fields=[  # suggest fields
+    suggest_parser_cls = CompositeSuggestQueryParser.factory(
+        fields=[
             "subject^100",
             localized_title,
             "synonyms^20",

invenio_vocabularies/contrib/subjects/datastreams.py

@@ -12,6 +12,7 @@ from invenio_access.permissions import system_identity
 from invenio_i18n import lazy_gettext as _
 
 from ...datastreams.writers import ServiceWriter
+from .bodc import datastreams as bodc_datastreams
 from .euroscivoc import datastreams as euroscivoc_datastreams
 from .gemet import datastreams as gemet_datastreams
 from .mesh import datastreams as mesh_datastreams
@@ -32,8 +33,6 @@ class SubjectsServiceWriter(ServiceWriter):
 
 VOCABULARIES_DATASTREAM_READERS = {
     **mesh_datastreams.VOCABULARIES_DATASTREAM_READERS,
-    **euroscivoc_datastreams.VOCABULARIES_DATASTREAM_READERS,
-    **gemet_datastreams.VOCABULARIES_DATASTREAM_READERS,
 }
 """Subjects Data Streams readers."""
 
@@ -41,14 +40,13 @@ VOCABULARIES_DATASTREAM_TRANSFORMERS = {
     **mesh_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
     **euroscivoc_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
     **gemet_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
+    **bodc_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
 }
 """Subjects Data Streams transformers."""
 
 VOCABULARIES_DATASTREAM_WRITERS = {
     "subjects-service": SubjectsServiceWriter,
     **mesh_datastreams.VOCABULARIES_DATASTREAM_WRITERS,
-    **euroscivoc_datastreams.VOCABULARIES_DATASTREAM_WRITERS,
-    **gemet_datastreams.VOCABULARIES_DATASTREAM_WRITERS,
 }
 """Subjects Data Streams writers."""
 

invenio_vocabularies/contrib/subjects/euroscivoc/datastreams.py

@@ -14,7 +14,36 @@ from ..config import euroscivoc_file_url
 
 
 class EuroSciVocSubjectsTransformer(RDFTransformer):
-    """Transformer class to convert EuroSciVoc RDF data to a dictionary format."""
+    """
+     Transformer class to convert EuroSciVoc RDF data to a dictionary format.
+
+     Input:
+         - Relevant fields:
+             - `skos:notation`: Primary identifier for the concept.
+             - `skos:prefLabel`: Preferred labels with language codes.
+             - `skos:altLabel`: Alternative labels.
+             - `skos:broader`: Broader concepts that this concept belongs to.
+
+    Output:
+         {
+             "id": "euroscivoc:1717",  # EuroSciVoc-specific concept ID (skos:notation).
+             "scheme": "EuroSciVoc",  # The scheme name indicating this is a EuroSciVoc concept.
+             "subject": "Satellite radio",  # The primary subject label (first preferred label in English, skos:prefLabel).
+             "title": {
+                 "it": "Radio satellitare",  # Italian preferred label (skos:prefLabel).
+                 "en": "Satellite radio",  # English preferred label (skos:prefLabel).
+             },
+             "props": {
+                 "parents": "euroscivoc:1225",  # The broader concept (skos:broader), identified by its EuroSciVoc Concept ID.
+             },
+             "identifiers": [
+                 {
+                     "scheme": "url",  # Type of identifier (URL).
+                     "identifier": "http://data.europa.eu/8mn/euroscivoc/87ff3577-527a-4a40-9c76-2f9d3075e2ba",  # URI of the concept (rdf:about).
+                 }
+             ],
+         }
+    """
 
     def _get_notation(self, subject, rdf_graph):
         """Extract the numeric notation for a subject."""
@@ -38,7 +67,6 @@ class EuroSciVocSubjectsTransformer(RDFTransformer):
             for n in reversed(self._find_parents(subject, rdf_graph))
             if n
         )
-        identifiers = [{"scheme": "url", "identifier": str(subject)}]
 
         return {
             "id": id,
@@ -46,13 +74,11 @@ class EuroSciVocSubjectsTransformer(RDFTransformer):
             "subject": labels.get("en", "").capitalize(),
             "title": labels,
             "props": {"parents": parents} if parents else {},
-            "identifiers": identifiers,
+            "identifiers": self._get_identifiers(subject),
         }
 
 
-# Configuration for datastream transformers, and writers
-VOCABULARIES_DATASTREAM_READERS = {}
-VOCABULARIES_DATASTREAM_WRITERS = {}
+# Configuration for datastream
 
 VOCABULARIES_DATASTREAM_TRANSFORMERS = {
     "euroscivoc-transformer": EuroSciVocSubjectsTransformer
@@ -71,9 +97,5 @@ DATASTREAM_CONFIG = {
         },
     ],
     "transformers": [{"type": "euroscivoc-transformer"}],
-    "writers": [
-        {
-            "type": "subjects-service",
-        }
-    ],
+    "writers": [{"args": {"writer": {"type": "subjects-service"}}, "type": "async"}],
 }

invenio_vocabularies/contrib/subjects/gemet/datastreams.py

@@ -20,7 +20,40 @@ except ImportError:
 
 
 class GEMETSubjectsTransformer(RDFTransformer):
-    """Transformer class to convert GEMET RDF data to a dictionary format."""
+    """
+    Transformer class to convert GEMET RDF data to a dictionary format.
+
+    Input:
+        - Relevant fields:
+            - `skos:prefLabel`: Preferred labels with language codes.
+            - `skos:broader`: References to broader concepts (parent concepts).
+            - `skos:memberOf`: References to groups or themes the concept belongs to.
+
+    Output:
+        - A dictionary with the following structure:
+            {
+                "id": "gemet:concept/10008",  # GEMET-specific concept ID (skos:Concept).
+                "scheme": "GEMET",  # The scheme name indicating this is a GEMET concept.
+                "subject": "Consumer product",  # The subject label (first preferred label in English, skos:prefLabel).
+                "title": {
+                    "en": "Consumer product",  # English label for the concept (skos:prefLabel).
+                    "ar": "منتج استهلاكي"  # Arabic label for the concept (skos:prefLabel).
+                },
+                "props": {
+                    "parents": "gemet:concept/6660",  # The parent concept (skos:broader), identified by its GEMET Concept ID.
+                    "groups": ["http://www.eionet.europa.eu/gemet/group/10112"],  # Group the concept belongs to (skos:memberOf)(skos:prefLabel).
+                    "themes": [
+                        "http://www.eionet.europa.eu/gemet/theme/27",  # Theme the concept belongs to (skos:memberOf)(rdfs:label).
+                    ]
+                },
+                "identifiers": [
+                    {
+                        "scheme": "url",  # Type of identifier (URL).
+                        "identifier": "http://www.eionet.europa.eu/gemet/concept/10008"  # URI of the concept (rdf:about).
+                    }
+                ]
+            }
+    """
 
     def _get_parent_notation(self, broader, rdf_graph):
         """Extract parent notation from GEMET URI."""
@@ -83,13 +116,11 @@ class GEMETSubjectsTransformer(RDFTransformer):
             "subject": labels.get("en", "").capitalize(),
             "title": labels,
             "props": props,
-            "identifiers": identifiers,
+            "identifiers": self._get_identifiers(subject),
         }
 
 
-# Configuration for datastream transformers, and writers
-VOCABULARIES_DATASTREAM_READERS = {}
-VOCABULARIES_DATASTREAM_WRITERS = {}
+# Configuration for datastream
 
 VOCABULARIES_DATASTREAM_TRANSFORMERS = {"gemet-transformer": GEMETSubjectsTransformer}
 

invenio_vocabularies/datastreams/datastreams.py

@@ -48,7 +48,16 @@ class StreamEntry:
 class DataStream:
     """Data stream."""
 
-    def __init__(self, readers, writers, transformers=None, *args, **kwargs):
+    def __init__(
+        self,
+        readers,
+        writers,
+        transformers=None,
+        batch_size=100,
+        write_many=False,
+        *args,
+        **kwargs,
+    ):
         """Constructor.
 
         :param readers: an ordered list of readers.
@@ -58,12 +67,14 @@ class DataStream:
         self._readers = readers
         self._transformers = transformers
         self._writers = writers
+        self.batch_size = batch_size
+        self.write_many = write_many
 
     def filter(self, stream_entry, *args, **kwargs):
         """Checks if an stream_entry should be filtered out (skipped)."""
         return False
 
-    def process_batch(self, batch, write_many=False):
+    def process_batch(self, batch):
         """Process a batch of entries."""
         transformed_entries = []
         for stream_entry in batch:
@@ -79,12 +90,12 @@ class DataStream:
                 else:
                     transformed_entries.append(transformed_entry)
         if transformed_entries:
-            if write_many:
+            if self.write_many:
                 yield from self.batch_write(transformed_entries)
             else:
                 yield from (self.write(entry) for entry in transformed_entries)
 
-    def process(self, batch_size=100, write_many=False, *args, **kwargs):
+    def process(self, *args, **kwargs):
         """Iterates over the entries.
 
         Uses the reader to get the raw entries and transforms them.
@@ -95,13 +106,13 @@ class DataStream:
         batch = []
         for stream_entry in self.read():
             batch.append(stream_entry)
-            if len(batch) >= batch_size:
-                yield from self.process_batch(batch, write_many=write_many)
+            if len(batch) >= self.batch_size:
+                yield from self.process_batch(batch)
                 batch = []
 
         # Process any remaining entries in the last batch
         if batch:
-            yield from self.process_batch(batch, write_many=write_many)
+            yield from self.process_batch(batch)
 
     def read(self):
         """Recursively read the entries."""

invenio_vocabularies/datastreams/factories.py

@@ -81,4 +81,6 @@ class DataStreamFactory:
             for t_conf in transformers_config:
                 transformers.append(TransformerFactory.create(t_conf))
 
-        return DataStream(readers=readers, writers=writers, transformers=transformers)
+        return DataStream(
+            readers=readers, writers=writers, transformers=transformers, **kwargs
+        )

invenio_vocabularies/datastreams/transformers.py

@@ -9,6 +9,7 @@
 """Transformers module."""
 
 from abc import ABC, abstractmethod
+from urllib.parse import urlparse
 
 from lxml import etree
 
@@ -76,6 +77,17 @@ class RDFTransformer(BaseTransformer):
         """Get the SKOS core namespace."""
         return rdflib.Namespace("http://www.w3.org/2004/02/skos/core#")
 
+    def _validate_subject_url(self, subject):
+        """Check if the subject is a valid URL."""
+        parsed = urlparse(str(subject))
+        return bool(parsed.netloc and parsed.scheme)
+
+    def _get_identifiers(self, subject):
+        """Generate identifiers field for a valid subject URL."""
+        if self._validate_subject_url(subject):
+            return [{"scheme": "url", "identifier": str(subject)}]
+        return []
+
     def _get_labels(self, subject, rdf_graph):
         """Extract labels (prefLabel or altLabel) for a subject."""
         labels = {

invenio_vocabularies/datastreams/writers.py

@@ -12,6 +12,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 
 import yaml
+from flask import current_app
 from invenio_access.permissions import system_identity
 from invenio_pidstore.errors import PIDAlreadyExists, PIDDoesNotExistError
 from invenio_records.systemfields.relations.errors import InvalidRelationValue
@@ -120,11 +121,14 @@ class ServiceWriter(BaseWriter):
 
     def write_many(self, stream_entries, *args, **kwargs):
         """Writes the input entries using a given service."""
+        current_app.logger.info(f"Writing {len(stream_entries)} entries")
         entries = [entry.entry for entry in stream_entries]
         entries_with_id = [(self._entry_id(entry), entry) for entry in entries]
-        results = self._service.create_or_update_many(self._identity, entries_with_id)
+        result_list = self._service.create_or_update_many(
+            self._identity, entries_with_id
+        )
         stream_entries_processed = []
-        for entry, result in zip(entries, results):
+        for entry, result in zip(entries, result_list.results):
             processed_stream_entry = StreamEntry(
                 entry=entry,
                 record=result.record,

invenio_vocabularies/factories.py

@@ -28,7 +28,12 @@ from .contrib.awards.datastreams import (
 )
 from .contrib.funders.datastreams import DATASTREAM_CONFIG as funders_ds_config
 from .contrib.names.datastreams import DATASTREAM_CONFIG as names_ds_config
+from .contrib.subjects.bodc.datastreams import DATASTREAM_CONFIG as bodc_ds_config
 from .contrib.subjects.datastreams import DATASTREAM_CONFIG as subjects_ds_config
+from .contrib.subjects.euroscivoc.datastreams import (
+    DATASTREAM_CONFIG as euroscivoc_ds_config,
+)
+from .contrib.subjects.gemet.datastreams import DATASTREAM_CONFIG as gemet_ds_config
 
 
 class VocabularyConfig:
@@ -137,6 +142,39 @@ class AffiliationsEDMOVocabularyConfig(VocabularyConfig):
         raise NotImplementedError("Service not implemented for EDMO Affiliations")
 
 
+class SubjectsEuroSciVocVocabularyConfig(VocabularyConfig):
+    """EuroSciVoc Subjects Vocabulary Config."""
+
+    config = euroscivoc_ds_config
+    vocabulary_name = "subjects:euroscivoc"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for EuroSciVoc Subjects")
+
+
+class SubjectsGEMETVocabularyConfig(VocabularyConfig):
+    """GEMET Subjects Vocabulary Config."""
+
+    config = gemet_ds_config
+    vocabulary_name = "subjects:gemet"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for GEMET Subjects")
+
+
+class SubjectsBODCVocabularyConfig(VocabularyConfig):
+    """BODC Subjects Vocabulary Config."""
+
+    config = bodc_ds_config
+    vocabulary_name = "subjects:bodc-puv"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for BODC Subjects")
+
+
 def get_vocabulary_config(vocabulary):
     """Factory function to get the appropriate Vocabulary Config."""
     vocab_config = {
@@ -148,5 +186,8 @@ def get_vocabulary_config(vocabulary):
         "affiliations:openaire": AffiliationsOpenAIREVocabularyConfig,
         "affiliations:edmo": AffiliationsEDMOVocabularyConfig,
         "subjects": SubjectsVocabularyConfig,
+        "subjects:gemet": SubjectsGEMETVocabularyConfig,
+        "subjects:bodc": SubjectsBODCVocabularyConfig,
+        "subjects:euroscivoc": SubjectsEuroSciVocVocabularyConfig,
     }
     return vocab_config.get(vocabulary, VocabularyConfig)()

invenio_vocabularies/fixtures.py

@@ -28,6 +28,8 @@ class VocabularyFixture:
             readers_config=config["readers"],
             transformers_config=config.get("transformers"),
             writers_config=config["writers"],
+            batch_size=config.get("batch_size", 1000),
+            write_many=config.get("write_many", False),
         )
 
         errors = []

invenio_vocabularies/services/querystr.py

@@ -8,6 +8,7 @@
 
 """Querystring parsing."""
 
+import warnings
 from functools import partial
 
 from invenio_records_resources.services.records.params import SuggestQueryParser
@@ -20,6 +21,10 @@ class FilteredSuggestQueryParser(SuggestQueryParser):
     @classmethod
     def factory(cls, filter_field=None, **extra_params):
         """Create a prepared instance of the query parser."""
+        warnings.warn(
+            "FilteredSuggestQueryParser is deprecated, use SuggestQueryParser or CompositeSuggestQueryParser instead",
+            DeprecationWarning,
+        )
         return partial(cls, filter_field=filter_field, extra_params=extra_params)
 
     def __init__(self, identity=None, filter_field=None, extra_params=None):

invenio_vocabularies/services/tasks.py

@@ -20,6 +20,8 @@ def process_datastream(config):
         readers_config=config["readers"],
         transformers_config=config.get("transformers"),
         writers_config=config["writers"],
+        batch_size=config.get("batch_size", 1000),
+        write_many=config.get("write_many", False),
     )
 
     for result in ds.process():

{invenio_vocabularies-6.7.0.dist-info → invenio_vocabularies-6.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: invenio-vocabularies
-Version: 6.7.0
+Version: 6.9.0
 Summary: Invenio module for managing vocabularies.
 Home-page: https://github.com/inveniosoftware/invenio-vocabularies
 Author: CERN
@@ -88,6 +88,17 @@ https://invenio-vocabularies.readthedocs.io/
 Changes
 =======
 
+Version v6.9.0 (released 2024-12-09)
+
+- schema: added identifiers in affiliations relation
+
+Version v6.8.0 (released 2024-12-09)
+
+- names: extract affiliation identifiers from employments
+- names: optimize memory usage on ORCID sync
+- subjects: improve search with CompositeSuggestQueryParser
+- subjects: added datastream for bodc
+
 Version v6.7.0 (released 2024-11-27)
 
 - contrib: improve search accuracy for names, funders, affiliations

{invenio_vocabularies-6.7.0.dist-info → invenio_vocabularies-6.9.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-invenio_vocabularies/__init__.py,sha256=IvdaI7jMnH_uHjMrYwtACXOE2Nw-H-a8HQbkLpurCl0,377
-invenio_vocabularies/cli.py,sha256=S3lBsLxsSYa83sCDaGZr5mP7TwPvmmwxzzbB13h8VBI,5856
-invenio_vocabularies/config.py,sha256=NcfDDZ0s1y2V78DcN69itua9wWt3_1-y87wonBl0vts,6340
+invenio_vocabularies/__init__.py,sha256=sQ6j-Dnfro84dUjb1SBr8X7MucAMXh1112UnZK_-tZE,377
+invenio_vocabularies/cli.py,sha256=CpXTTIn2GTpUqNfLEMlRAp3JWst8ZjHVxoGYdhuuv_4,5959
+invenio_vocabularies/config.py,sha256=h9Iied753mmZwZZHe5COMqUYvV-zSQtx763EIkUVb1Q,6973
 invenio_vocabularies/ext.py,sha256=GujJ4UARd4Fxf4z7zznRk9JAgHamZuYCOdrKU5czg00,5987
-invenio_vocabularies/factories.py,sha256=7VHpoF3jQch5O7efytRwFPojz_MpeiXeu-cfw7ajHs4,4949
-invenio_vocabularies/fixtures.py,sha256=nNWwH04HFASjfj1oy5kMdcQGKmVjzUuA5wSw-ER1QAg,1585
+invenio_vocabularies/factories.py,sha256=lRHPGPos6GdXf0yAhB1d7iMjVfpOeFDZRL9PPZvuWlY,6408
+invenio_vocabularies/fixtures.py,sha256=iEPkWf_ZjdP2D9r2sLdIlPoR8Rq2m5cnoFwywUGHneg,1696
 invenio_vocabularies/jobs.py,sha256=0aTukWooBPCvEgvnjJcQAZuMeS2H_m-RGULNIfJ5Gmc,6800
 invenio_vocabularies/proxies.py,sha256=k7cTUgWfnCoYIuNqAj_VFi1zBN33KNNclRSVnBkObEM,711
 invenio_vocabularies/views.py,sha256=PNJ5nvc3O7ASwNe56xmqy5YaU9n3UYF3W2JwvtE_kYs,1561
@@ -51,7 +51,7 @@ invenio_vocabularies/contrib/affiliations/datastreams.py,sha256=sMvkt9XOBTV7Q0we
 invenio_vocabularies/contrib/affiliations/facets.py,sha256=w316MGvtdyTpRCPOpCEmMxxLraRkbFFb1VvLkFlEc9o,1229
 invenio_vocabularies/contrib/affiliations/models.py,sha256=JUcj-1ydc2Cw2Rsc24JwXE3TFBJ_6fivhUYhGq4rT8A,329
 invenio_vocabularies/contrib/affiliations/resources.py,sha256=DBEbRxQmp-o-PeZlgFG588Q4sGcruuwIL8L9O-SzCes,435
-invenio_vocabularies/contrib/affiliations/schema.py,sha256=O4s6aHcO1w4_aAfGuYLx_eLS6nctd6ktyIuHB6dMKqw,1842
+invenio_vocabularies/contrib/affiliations/schema.py,sha256=geORDYdBIWnv81Txl07qdHhB3U_fo9ObVp7UrSlCLRI,2104
 invenio_vocabularies/contrib/affiliations/services.py,sha256=KJbv46c2LuQOW3xz7KVLtfZjWR8vhMRPHninlUEhrss,395
 invenio_vocabularies/contrib/affiliations/jsonschemas/__init__.py,sha256=ILyZ5kejTr0p50macMBPALQCTJSe4KEE3_cgf2p3zV4,252
 invenio_vocabularies/contrib/affiliations/jsonschemas/affiliations/affiliation-v1.0.0.json,sha256=be-glRNIBtIO87Tcyw8d68OdG4J8-ojjiCj8UJBnckg,1649
@@ -113,7 +113,7 @@ invenio_vocabularies/contrib/funders/mappings/v7/funders/funder-v1.0.0.json,sha2
 invenio_vocabularies/contrib/names/__init__.py,sha256=DBfsM7JMETZGaV5QmXEwE7zhCaAXvc2SZN6uXnW_V-c,451
 invenio_vocabularies/contrib/names/api.py,sha256=sEPn_jFX3gyoxgbdEUSIvOoPCUI8pocI6qCZO6mzCgQ,300
 invenio_vocabularies/contrib/names/config.py,sha256=9sb5novWuQYXg_5Egexn52mjgGd1D_D9UKyQ1fmIuh4,1977
-invenio_vocabularies/contrib/names/datastreams.py,sha256=EKatHb0gkvcC9LCYBLIcN5pAgklBY4G43lZR_XE52wY,9505
+invenio_vocabularies/contrib/names/datastreams.py,sha256=mmhtdrda6b4c83dRjxVF5JTqtkt92GSEMHTU6TzQtHw,14570
 invenio_vocabularies/contrib/names/models.py,sha256=SYdtDDG-y5Wq_d06YhiVO5n8gfxPW_mx-tECsIcv5H8,308
 invenio_vocabularies/contrib/names/names.py,sha256=_kBJBcPuANgUHlZ8RoVkpfJwzR5qaOQCBIyZusjKoCE,2509
 invenio_vocabularies/contrib/names/permissions.py,sha256=5xrpYsA3oQUJ5lJpF7wjRAFiW-pM6_yP1k9zllbRwnQ,844
@@ -134,18 +134,20 @@ invenio_vocabularies/contrib/names/mappings/v7/__init__.py,sha256=qLGB8C0kPI3xub
 invenio_vocabularies/contrib/names/mappings/v7/names/name-v1.0.0.json,sha256=5Ybcq3fUMYx3u1MNKmHh-CWBtATS9MYpdEcwAM8EQ80,1943
 invenio_vocabularies/contrib/subjects/__init__.py,sha256=GtXZKA6VWG1oA1fUX2Wh92nd-1i7RnnQF6RprGhxkD4,591
 invenio_vocabularies/contrib/subjects/api.py,sha256=QH8mxoLsa8qjJT1i1Tj6rRnpbH23plo2IMOJ56rnvbU,347
-invenio_vocabularies/contrib/subjects/config.py,sha256=VsS1fAlHOceLu0E_ciAE4XrrqpI7cfl-OPScqVPimR8,2064
-invenio_vocabularies/contrib/subjects/datastreams.py,sha256=V-g4d-gh9MUhAVG-3lrbd-IO6TNWlsGZedCivT_6aFg,2015
+invenio_vocabularies/contrib/subjects/config.py,sha256=6svsCjiptqWB5x3NlG6wDH_dehdQYRTPKDCkNc9MtNA,2169
+invenio_vocabularies/contrib/subjects/datastreams.py,sha256=YRdUP0saks5LGVuFjDhhyJdsiYzkysLTBja32I4x9eU,1888
 invenio_vocabularies/contrib/subjects/facets.py,sha256=qQ7_rppFBzsmrlZu4-MvOIdUcjeOmDA9gOHAcs0lWwI,695
 invenio_vocabularies/contrib/subjects/models.py,sha256=8XgbVRxDDvhWPjMWsoCriNlOKdmV_113a14yLRtlvM4,363
 invenio_vocabularies/contrib/subjects/resources.py,sha256=0KRfUMizwgIziZybk4HnIjiSsXbrCv_XmguNPwnxoo8,506
 invenio_vocabularies/contrib/subjects/schema.py,sha256=VOW8a9Ob5M-mKrict2bApdFyTpHBwCTJZSxrm93Puv0,3516
 invenio_vocabularies/contrib/subjects/services.py,sha256=s1U6HMmpjuz7rrgR0DtT9C28TC6sZEeDTsa4Jh1TXQk,864
 invenio_vocabularies/contrib/subjects/subjects.py,sha256=NwZycExLyV8l7ikGStH4GOecVuDSxFT70KoNv6qC78I,1877
+invenio_vocabularies/contrib/subjects/bodc/__init__.py,sha256=RlJVmWpbRgDcpx61ITjco3IqHkwZwIypeo2Dt2_AWRc,241
+invenio_vocabularies/contrib/subjects/bodc/datastreams.py,sha256=RgFJTrr-eMyKrS2MuGK4QHhOkPseMwpmsKKpEqE_tgs,4220
 invenio_vocabularies/contrib/subjects/euroscivoc/__init__.py,sha256=e5L9E4l5JHqVzijAX8tn2DIa2n01vJ5wOAZdN62RnIo,247
-invenio_vocabularies/contrib/subjects/euroscivoc/datastreams.py,sha256=eyEHbH-cTbtf3kKHv4ehMUMngy48H0CIwsjU-qQKK6I,2367
+invenio_vocabularies/contrib/subjects/euroscivoc/datastreams.py,sha256=Vs4mpIn321KZ94lzTxpYnQTATle1QdKg0yegmDMptw4,3565
 invenio_vocabularies/contrib/subjects/gemet/__init__.py,sha256=OlRWH2gumZZ1Djc_N3ZGPHyt2wOcIwlDDYO6uOfaZfI,242
-invenio_vocabularies/contrib/subjects/gemet/datastreams.py,sha256=YaCt1698-jQRn4-jj-qfcluLCR9nSHAID9bbHWVOyUk,3566
+invenio_vocabularies/contrib/subjects/gemet/datastreams.py,sha256=OZaKnT6cw3cjNtB_TxEBtVwWWf1Wrm-x9h71YXMAmBk,5203
 invenio_vocabularies/contrib/subjects/jsonschemas/__init__.py,sha256=WowVUST1JoEDS3-xeHhCJvIgC9nzMkFs8XRks9zgzaM,292
 invenio_vocabularies/contrib/subjects/jsonschemas/subjects/subject-v1.0.0.json,sha256=O1IsPWrVeuEiMBKtADcRByFNmd1soABgODOnauEJBoI,1868
 invenio_vocabularies/contrib/subjects/mappings/__init__.py,sha256=Qk-yj1ENsTmijO8ImWuDYGzXi6QQ2VjP4DbjrpRfDk8,243
@@ -158,13 +160,13 @@ invenio_vocabularies/contrib/subjects/mappings/v7/subjects/subject-v1.0.0.json,s
 invenio_vocabularies/contrib/subjects/mesh/__init__.py,sha256=P44hmgVNNTN5O_EmWgaeYJ91yqkGNoeKYo0wfif_wE4,241
 invenio_vocabularies/contrib/subjects/mesh/datastreams.py,sha256=6W6bgQ7P_31kf3enkAqCBTFBqgrQ2BlV625vn0N9ibQ,1544
 invenio_vocabularies/datastreams/__init__.py,sha256=VPefh6k4Q3eYxKIW8I5zXUGucntp7VHxaOR5Vhgkfmg,412
-invenio_vocabularies/datastreams/datastreams.py,sha256=SpI6ivmf2LIDS2JSkxoM2v5kRmrPoRDtAG5fuzZO4oQ,6078
+invenio_vocabularies/datastreams/datastreams.py,sha256=mAi_xUDmDWpc3NyhU1TMOhqVRbwYu_meJ9UY6-wgBKQ,6169
 invenio_vocabularies/datastreams/errors.py,sha256=IDUZ3gNtYGrhcOgApHCms1gNNJTyJzoMPmG5JtIeYNU,678
-invenio_vocabularies/datastreams/factories.py,sha256=H8a2gAy7KNImtdCdtqpVKC5gIvE3ON6U1Wn1_zaMlQ4,2181
+invenio_vocabularies/datastreams/factories.py,sha256=kuuN4Zt7Xw58rwf0M03djqcdZOZRWgJdLK16-HmID24,2213
 invenio_vocabularies/datastreams/readers.py,sha256=DUuV-D2PLio3nVR0J-2knASq8rB-H14QBr3DoRL6UgA,14352
 invenio_vocabularies/datastreams/tasks.py,sha256=0fuH_PRt9Ncv6WHM4pkYmfheRVGDKkERZiMPvgV4bZU,1129
-invenio_vocabularies/datastreams/transformers.py,sha256=czWKO-h9CB1QoO-mL3fhQv_YHjX-bkAVyhgph-GQFa8,3667
-invenio_vocabularies/datastreams/writers.py,sha256=FMTQdGavRgq6Qk21UcifYeDVH3jUA3rmwdyICr1ywxU,6719
+invenio_vocabularies/datastreams/transformers.py,sha256=PJFbmRSj3dpJ95NzONAIns5ksztshd99JOp_FLQAlJM,4133
+invenio_vocabularies/datastreams/writers.py,sha256=VIXx9klJaCEdscaKqi2zO959cc157YUGjVYdeTfhTTI,6861
 invenio_vocabularies/datastreams/xml.py,sha256=HFa-lfxj7kFrr2IjeN1jxSLDfcvpBwO9nZLZF2-BryE,997
 invenio_vocabularies/records/__init__.py,sha256=Uj7O6fYdAtLOkLXUGSAYPADBB7aqP4yVs9b6OAjA158,243
 invenio_vocabularies/records/api.py,sha256=Lynt6Sz4BVN1orh0zgJ5ljhnUobEtcq8c22PmSeUo2U,1494
@@ -194,11 +196,11 @@ invenio_vocabularies/services/config.py,sha256=A9_r2vErcfo3Xt6fC4YVobHXdd64_YyI7
 invenio_vocabularies/services/facets.py,sha256=qvdHoGSJJr90dZHSVe0-hlO1r0LtTnFVSjrt9PNuNAg,3872
 invenio_vocabularies/services/generators.py,sha256=jcXwb9Hiyek4o-cQ1G2osVgbTBKDbd-5siJMBOWE018,1116
 invenio_vocabularies/services/permissions.py,sha256=83rNOwCuggdJji3VtWTQgytTrhfiWqASCpvI75DxEus,960
-invenio_vocabularies/services/querystr.py,sha256=X3JHVF9B0O0iLWrnW3ok_bf_8jA-Cs_oAcYYkGOm3Uw,1829
+invenio_vocabularies/services/querystr.py,sha256=OrNUR_QAcQ_T-EiL3H1Jvzz9gK2ZB5FicsG0fOipSro,2029
 invenio_vocabularies/services/results.py,sha256=6LZIpzWSbt9wpRNWgjA1uIM4RFooOYTkHcp5-PnIJdU,3767
 invenio_vocabularies/services/schema.py,sha256=mwIBFylpQlWw1M6h_axc-z4Yd7X3Z1S0PxJOlZGpfrQ,4634
 invenio_vocabularies/services/service.py,sha256=9QQDsG1WShCpBVFze-Dnq-iC2BwNX_0-qzfzrpImJo8,6469
-invenio_vocabularies/services/tasks.py,sha256=AH0XifkOypsEdh8LyjmlHnPLQK5qqUJC8cNVWGkbqks,788
+invenio_vocabularies/services/tasks.py,sha256=xKEymph1M-wFjPLeCGkqvnuYdPMMHgxhCCdC0j44Pi4,891
 invenio_vocabularies/services/custom_fields/__init__.py,sha256=QgvSsn-S1xLzbZ57pjjGTt5oI3HqzXHVjwGTtuPgzN8,421
 invenio_vocabularies/services/custom_fields/subject.py,sha256=ZM-ZkaxoouF9lL62smOtLxsjQQZwiQs0jG3qGruP6nY,2231
 invenio_vocabularies/services/custom_fields/vocabulary.py,sha256=oQwI8Aoi2Nr9k3eWKnde5H7RXc7qdlATSeI6coy8UR0,3020
@@ -300,10 +302,10 @@ invenio_vocabularies/translations/zh_CN/LC_MESSAGES/messages.mo,sha256=g1I5aNO8r
 invenio_vocabularies/translations/zh_CN/LC_MESSAGES/messages.po,sha256=vg8qC8ofpAdJ3mQz7mWM1ylKDpiNWXFs7rlMdSPkgKk,4629
 invenio_vocabularies/translations/zh_TW/LC_MESSAGES/messages.mo,sha256=cqSm8NtMAwrP9O6qbmtkDtRT1e9D93qpsJN5X9_PPVw,600
 invenio_vocabularies/translations/zh_TW/LC_MESSAGES/messages.po,sha256=9ACePz_EpB-LfcIJajZ2kp8Q04tcdrQLOtug162ZUss,4115
-invenio_vocabularies-6.7.0.dist-info/AUTHORS.rst,sha256=8d0p_WWE1r9DavvzMDi2D4YIGBHiMYcN3LYxqQOj8sY,291
-invenio_vocabularies-6.7.0.dist-info/LICENSE,sha256=UvI8pR8jGWqe0sTkb_hRG6eIrozzWwWzyCGEpuXX4KE,1062
-invenio_vocabularies-6.7.0.dist-info/METADATA,sha256=Eb8yxpxyr_aqn1dkluiEffaS4t5uFS8LCcErmHmo6D0,11971
-invenio_vocabularies-6.7.0.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110
-invenio_vocabularies-6.7.0.dist-info/entry_points.txt,sha256=ud9nfdMlhO_mu3okwmy5vQD48r3-rCU_pSR-lUtLeYE,3180
-invenio_vocabularies-6.7.0.dist-info/top_level.txt,sha256=x1gRNbaODF_bCD0SBLM3nVOFPGi06cmGX5X94WKrFKk,21
-invenio_vocabularies-6.7.0.dist-info/RECORD,,
+invenio_vocabularies-6.9.0.dist-info/AUTHORS.rst,sha256=8d0p_WWE1r9DavvzMDi2D4YIGBHiMYcN3LYxqQOj8sY,291
+invenio_vocabularies-6.9.0.dist-info/LICENSE,sha256=UvI8pR8jGWqe0sTkb_hRG6eIrozzWwWzyCGEpuXX4KE,1062
+invenio_vocabularies-6.9.0.dist-info/METADATA,sha256=DDZji_utemzfuJq2CxCfHfyIwQApzq4hDckuaKpIsRo,12303
+invenio_vocabularies-6.9.0.dist-info/WHEEL,sha256=-G_t0oGuE7UD0DrSpVZnq1hHMBV9DD2XkS5v7XpmTnk,110
+invenio_vocabularies-6.9.0.dist-info/entry_points.txt,sha256=ud9nfdMlhO_mu3okwmy5vQD48r3-rCU_pSR-lUtLeYE,3180
+invenio_vocabularies-6.9.0.dist-info/top_level.txt,sha256=x1gRNbaODF_bCD0SBLM3nVOFPGi06cmGX5X94WKrFKk,21
+invenio_vocabularies-6.9.0.dist-info/RECORD,,