invenio-vocabularies 7.3.0__py2.py3-none-any.whl → 7.5.0__py2.py3-none-any.whl

invenio_vocabularies/assets/semantic-ui/translations/invenio_vocabularies/package.json

@@ -2,7 +2,6 @@
   "name": "invenio-vocabularies-ui",
   "config": {
     "languages": [
-      "af",
       "ar",
       "bg",
       "ca",
@@ -13,10 +12,8 @@
       "en",
       "es",
       "et",
-      "et_EE",
       "fa",
       "fr",
-      "gl",
       "hr",
       "hu",
       "it",
@@ -28,7 +25,6 @@
       "pt",
       "ro",
       "ru",
-      "rw",
       "sk",
       "sv",
       "tr",

invenio_vocabularies/assets/semantic-ui/translations/invenio_vocabularies/scripts/compileCatalog.js

@@ -1,4 +1,4 @@
-// This file is part of React-Invenio-Deposit
+// This file is part of Invenio-Vocabularies
 //
 // Invenio-administration is free software; you can redistribute it and/or modify it
 // under the terms of the MIT License; see LICENSE file for more details.

invenio_vocabularies/assets/semantic-ui/translations/invenio_vocabularies/scripts/initCatalog.js

@@ -1,4 +1,4 @@
-// This file is part of React-Invenio-Deposit
+// This file is part of Invenio-Vocabularies
 //
 // Invenio-administration is free software; you can redistribute it and/or modify it
 // under the terms of the MIT License; see LICENSE file for more details.

invenio_vocabularies/assets/semantic-ui/translations/invenio_vocabularies/translations.pot

@@ -0,0 +1,88 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: i18next-conv\n"
+"mime-version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\n"
+"POT-Creation-Date: 2025-05-13T09:10:50.615Z\n"
+"PO-Revision-Date: 2025-05-13T09:10:50.616Z\n"
+"Language: en\n"
+
+msgid "Search for a funder by name"
+msgstr "Search for a funder by name"
+
+msgid "Funder"
+msgstr "Funder"
+
+msgid "Search for funder..."
+msgstr "Search for funder..."
+
+msgid "Additional information"
+msgstr "Additional information"
+
+msgid "optional"
+msgstr "optional"
+
+msgid "Number"
+msgstr "Number"
+
+msgid "Award/Grant number"
+msgstr "Award/Grant number"
+
+msgid "Title"
+msgstr "Title"
+
+msgid "Award/Grant Title"
+msgstr "Award/Grant Title"
+
+msgid "URL"
+msgstr "URL"
+
+msgid "Award/Grant URL"
+msgstr "Award/Grant URL"
+
+msgid "Add"
+msgstr "Add"
+
+msgid "Add custom"
+msgstr "Add custom"
+
+msgid "Edit"
+msgstr "Edit"
+
+msgid "Remove"
+msgstr "Remove"
+
+msgid "Open external link"
+msgstr "Open external link"
+
+msgid "Funder is required."
+msgstr "Funder is required."
+
+msgid "URL must be valid."
+msgstr "URL must be valid."
+
+msgid "URL must be set alongside title or number."
+msgstr "URL must be set alongside title or number."
+
+msgid "Add standard award/grant"
+msgstr "Add standard award/grant"
+
+msgid "Add custom funding"
+msgstr "Add custom funding"
+
+msgid "Search for awards/grants"
+msgstr "Search for awards/grants"
+
+msgid "Cancel"
+msgstr "Cancel"
+
+msgid "Change"
+msgstr "Change"
+
+msgid "Did not find your award/grant? "
+msgstr "Did not find your award/grant? "
+
+msgid "Add a custom award/grant."
+msgstr "Add a custom award/grant."

invenio_vocabularies/config.py

@@ -12,7 +12,7 @@
 
 import re
 
-import idutils
+from idutils import is_doi, is_gnd, is_isni, is_orcid, is_ror, is_url
 from invenio_i18n import lazy_gettext as _
 
 from .datastreams.readers import (
@@ -42,9 +42,9 @@ VOCABULARIES_SERVICE_CONFIG = VocabulariesServiceConfig
 
 VOCABULARIES_IDENTIFIER_SCHEMES = {
     "grid": {"label": _("GRID"), "validator": lambda x: True},
-    "gnd": {"label": _("GND"), "validator": idutils.is_gnd},
-    "isni": {"label": _("ISNI"), "validator": idutils.is_isni},
-    "ror": {"label": _("ROR"), "validator": idutils.is_ror},
+    "gnd": {"label": _("GND"), "validator": is_gnd},
+    "isni": {"label": _("ISNI"), "validator": is_isni},
+    "ror": {"label": _("ROR"), "validator": is_ror},
 }
 """"Generic identifier schemes, usable by other vocabularies."""
 
@@ -72,7 +72,7 @@ VOCABULARIES_AFFILIATION_SCHEMES = {
 
 VOCABULARIES_FUNDER_SCHEMES = {
     **VOCABULARIES_IDENTIFIER_SCHEMES,
-    "doi": {"label": _("DOI"), "validator": idutils.is_doi},
+    "doi": {"label": _("DOI"), "validator": is_doi},
 }
 """Funders allowed identifier schemes."""
 
@@ -80,8 +80,8 @@ VOCABULARIES_FUNDER_DOI_PREFIX = "10.13039"
 """DOI prefix for the identifier formed with the FundRef id."""
 
 VOCABULARIES_AWARD_SCHEMES = {
-    "url": {"label": _("URL"), "validator": idutils.is_url},
-    "doi": {"label": _("DOI"), "validator": idutils.is_doi},
+    "url": {"label": _("URL"), "validator": is_url},
+    "doi": {"label": _("DOI"), "validator": is_doi},
 }
 """Awards allowed identifier schemes."""
 
@@ -121,15 +121,15 @@ VOCABULARIES_AWARDS_EC_ROR_ID = "00k4n6c32"
 """ROR ID for EC funder."""
 
 VOCABULARIES_NAMES_SCHEMES = {
-    "orcid": {"label": _("ORCID"), "validator": idutils.is_orcid, "datacite": "ORCID"},
-    "isni": {"label": _("ISNI"), "validator": idutils.is_isni, "datacite": "ISNI"},
-    "gnd": {"label": _("GND"), "validator": idutils.is_gnd, "datacite": "GND"},
+    "orcid": {"label": _("ORCID"), "validator": is_orcid, "datacite": "ORCID"},
+    "isni": {"label": _("ISNI"), "validator": is_isni, "datacite": "ISNI"},
+    "gnd": {"label": _("GND"), "validator": is_gnd, "datacite": "GND"},
 }
 """Names allowed identifier schemes."""
 
 VOCABULARIES_SUBJECTS_SCHEMES = {
-    "gnd": {"label": _("GND"), "validator": idutils.is_gnd, "datacite": "GND"},
-    "url": {"label": _("URL"), "validator": idutils.is_url},
+    "gnd": {"label": _("GND"), "validator": is_gnd, "datacite": "GND"},
+    "url": {"label": _("URL"), "validator": is_url},
 }
 """Subjects allowed identifier schemes."""
 
@@ -204,9 +204,9 @@ VOCABULARIES_AFFILIATIONS_EDMO_COUNTRY_MAPPING = {
 }
 """Affiliations EDMO Country name remapping dictionary."""
 
-VOCABULARIES_ORCID_ACCESS_KEY = "TODO"
+VOCABULARIES_ORCID_ACCESS_KEY = "CHANGEME"
 """ORCID access key to access the s3 bucket."""
-VOCABULARIES_ORCID_SECRET_KEY = "TODO"
+VOCABULARIES_ORCID_SECRET_KEY = "CHANGEME"
 """ORCID secret key to access the s3 bucket."""
 VOCABULARIES_ORCID_SUMMARIES_BUCKET = "v3.0-summaries"
 """ORCID summaries bucket name."""

invenio_vocabularies/contrib/common/ror/datastreams.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2024 CERN.
+# Copyright (C) 2024-2025 CERN.
 # Copyright (C) 2024 California Institute of Technology.
 #
 # Invenio-Vocabularies is free software; you can redistribute it and/or
@@ -13,6 +13,7 @@ import io
 
 import arrow
 import requests
+from flask import current_app
 from idutils import normalize_ror
 
 from invenio_vocabularies.datastreams.errors import ReaderError, TransformerError
@@ -93,6 +94,9 @@ class RORHTTPReader(BaseReader):
         if self._since:
             last_dump_date = self._get_last_dump_date(linksets)
             if last_dump_date < arrow.get(self._since):
+                current_app.logger.info(
+                    f"Skipping ROR data dump (last dump: {last_dump_date}, since: {self._since})"
+                )
                 return
 
         for linkset in linksets:
@@ -104,6 +108,8 @@ class RORHTTPReader(BaseReader):
             if len(zip_files) > 1:
                 raise ReaderError(f"Expected 1 ZIP item but got {len(zip_files)}")
 
+        current_app.logger.info(f"Reading ROR data dump (URL: {file_url})")
+
         # Download the ZIP file and fully load the response bytes content in memory.
         # The bytes content are then wrapped by a BytesIO to be
         # file-like object (as required by `zipfile.ZipFile`).

invenio_vocabularies/contrib/names/datastreams.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2021-2024 CERN.
+# Copyright (C) 2021-2025 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
@@ -12,6 +12,7 @@ import csv
 import io
 import tarfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextvars import copy_context
 from datetime import timedelta
 from itertools import islice
 from pathlib import Path
@@ -43,17 +44,18 @@ class OrcidDataSyncReader(BaseReader):
         self.s3_client = S3OrcidClient()
         self.since = since
 
-    def _fetch_orcid_data(self, orcid_to_sync, bucket):
+    def _fetch_orcid_data(self, app, orcid_to_sync, bucket):
         """Fetches a single ORCiD record from S3."""
         # The ORCiD file key is located in a folder which name corresponds to the last three digits of the ORCiD
         suffix = orcid_to_sync[-3:]
         key = f"{suffix}/{orcid_to_sync}.xml"
+        app.logger.debug(f"Fetching ORCiD record: {key} from bucket: {bucket}")
         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:
-            current_app.logger.exception("Failed to fetch ORCiD record.")
+            app.logger.exception(f"Failed to fetch ORCiD record: {key}")
 
     def _process_lambda_file(self, fileobj):
         """Process the ORCiD lambda file and returns a list of ORCiDs to sync.
@@ -87,7 +89,11 @@ class OrcidDataSyncReader(BaseReader):
                     )
 
                 if last_modified_date < last_sync:
+                    current_app.logger.debug(
+                        f"Skipping ORCiD {orcid} (last modified: {last_modified_date})"
+                    )
                     break
+                current_app.logger.debug(f"Yielding ORCiD {orcid} for sync.")
                 yield orcid
         finally:
             fileobj.close()
@@ -97,10 +103,15 @@ class OrcidDataSyncReader(BaseReader):
         with ThreadPoolExecutor(
             max_workers=current_app.config["VOCABULARIES_ORCID_SYNC_MAX_WORKERS"]
         ) as executor:
+            app = current_app._get_current_object()
             # futures is a dictionary where the key is the ORCID value and the item is the Future object
+            # Flask does not propagate app/request context to new threads, so `copy_context().run`
+            # ensures the current instantianted contextvars (such as job_context) is preserved in each thread.
             futures = {
                 orcid: executor.submit(
+                    copy_context().run,  # Required to pass the context to the thread
                     self._fetch_orcid_data,
+                    app,  # Pass the Flask app to the thread
                     orcid,
                     current_app.config["VOCABULARIES_ORCID_SUMMARIES_BUCKET"],
                 )
@@ -111,7 +122,14 @@ class OrcidDataSyncReader(BaseReader):
                 try:
                     result = futures[orcid].result()
                     if result:
+                        current_app.logger.debug(
+                            f"Successfully fetched ORCiD record: {orcid}"
+                        )
                         yield result
+                except Exception:
+                    current_app.logger.exception(
+                        f"Error processing ORCiD record: {orcid}"
+                    )
                 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
@@ -125,7 +143,7 @@ class OrcidDataSyncReader(BaseReader):
         tar_content = self.s3_client.read_file(
             "s3://orcid-lambda-file/last_modified.csv.tar"
         )
-
+        current_app.logger.info("Fetching ORCiD lambda file")
         # 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
@@ -133,7 +151,7 @@ class OrcidDataSyncReader(BaseReader):
                 # Extract the file
                 extracted_file = tar.extractfile(member)
                 if extracted_file:
-                    current_app.logger.info(f"[ORCID Reader] Processing lambda file...")
+                    current_app.logger.info(f"Processing lambda file: {member.name}")
                     # Process the file and get the ORCiDs to sync
                     orcids_to_sync = set(self._process_lambda_file(extracted_file))
 
@@ -150,6 +168,7 @@ class OrcidDataSyncReader(BaseReader):
         """Yield successive chunks of a given size."""
         it = iter(iterable)
         while chunk := list(islice(it, batch_size)):
+            current_app.logger.debug(f"Processing batch of size {len(chunk)}.")
             yield chunk
 
 
@@ -239,18 +258,25 @@ class OrcidTransformer(BaseTransformer):
 
     def apply(self, stream_entry, **kwargs):
         """Applies the transformation to the stream entry."""
+        current_app.logger.debug("Applying transformation to stream entry.")
         record = stream_entry.entry
         person = record["person"]
         orcid_id = record["orcid-identifier"]["path"]
 
         name = person.get("name")
         if name is None:
-            raise TransformerError("Name not found in ORCiD entry.")
+            raise TransformerError(
+                f"Name not found in ORCiD entry for ORCiD ID: {orcid_id}."
+            )
         if name.get("family-name") is None:
-            raise TransformerError("Family name not found in ORCiD entry.")
+            raise TransformerError(
+                f"Family name not found in ORCiD entry for ORCiD ID: {orcid_id}."
+            )
 
         if not self._is_valid_name(name["given-names"] + name["family-name"]):
-            raise TransformerError("Invalid characters in name.")
+            raise TransformerError(
+                f"Invalid characters in name for ORCiD ID: {orcid_id}."
+            )
 
         entry = {
             "id": orcid_id,
@@ -261,6 +287,7 @@ class OrcidTransformer(BaseTransformer):
         }
 
         stream_entry.entry = entry
+        current_app.logger.debug(f"Transformed entry: {entry}")
         return stream_entry
 
     def _is_valid_name(self, name):
@@ -271,6 +298,7 @@ class OrcidTransformer(BaseTransformer):
 
     def _extract_affiliations(self, record):
         """Extract affiliations from the ORCiD record."""
+        current_app.logger.debug("Extracting affiliations from ORCiD record.")
         result = []
         try:
             employments = (
@@ -312,7 +340,7 @@ class OrcidTransformer(BaseTransformer):
 
                 result.append(aff)
         except Exception:
-            pass
+            current_app.logger.error("Error extracting affiliations.")
         return result
 
     def _extract_affiliation_id(self, org):
@@ -410,6 +438,7 @@ ORCID_PRESET_DATASTREAM_CONFIG = {
             "args": {
                 "writer": {
                     "type": "names-service",
+                    "args": {"update": True},
                 }
             },
         }

invenio_vocabularies/contrib/names/s3client.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # This file is part of Invenio.
-# Copyright (C) 2024 CERN.
+# Copyright (C) 2024-2025 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
@@ -38,7 +38,13 @@ class S3OrcidClient(S3Client):
 
     def __init__(self):
         """Constructor."""
+        access_key = current_app.config["VOCABULARIES_ORCID_ACCESS_KEY"]
+        secret_key = current_app.config["VOCABULARIES_ORCID_SECRET_KEY"]
+        if access_key == "CHANGEME" or secret_key == "CHANGEME":
+            raise Exception(
+                "VOCABULARIES_ORCID_ACCESS_KEY and VOCABULARIES_ORCID_SECRET_KEY are not configured."
+            )
         super().__init__(
-            access_key=current_app.config["VOCABULARIES_ORCID_ACCESS_KEY"],
-            secret_key=current_app.config["VOCABULARIES_ORCID_SECRET_KEY"],
+            access_key=access_key,
+            secret_key=secret_key,
         )

invenio_vocabularies/datastreams/datastreams.py

@@ -72,13 +72,18 @@ class DataStream:
 
     def filter(self, stream_entry, *args, **kwargs):
         """Checks if an stream_entry should be filtered out (skipped)."""
+        current_app.logger.debug(f"Filtering entry: {stream_entry.entry}")
         return False
 
     def process_batch(self, batch):
         """Process a batch of entries."""
+        current_app.logger.info(f"Processing batch of size: {len(batch)}")
         transformed_entries = []
         for stream_entry in batch:
             if stream_entry.errors:
+                current_app.logger.warning(
+                    f"Skipping entry with errors: {stream_entry.errors}"
+                )
                 yield stream_entry  # reading errors
             else:
                 transformed_entry = self.transform(stream_entry)
@@ -103,19 +108,23 @@ class DataStream:
         the reader, apply the transformations and yield the result of
         writing it.
         """
+        current_app.logger.info("Starting data stream processing")
         batch = []
         for stream_entry in self.read():
             batch.append(stream_entry)
             if len(batch) >= self.batch_size:
+                current_app.logger.debug(f"Processing batch of size: {len(batch)}")
                 yield from self.process_batch(batch)
                 batch = []
 
         # Process any remaining entries in the last batch
         if batch:
+            current_app.logger.debug(f"Processing final batch of size: {len(batch)}")
             yield from self.process_batch(batch)
 
     def read(self):
         """Recursively read the entries."""
+        current_app.logger.debug("Reading entries from readers")
 
         def pipe_gen(gen_funcs, piped_item=None):
             _gen_funcs = list(gen_funcs)  # copy to avoid modifying ref list
@@ -130,6 +139,7 @@ class DataStream:
                     else:
                         yield StreamEntry(item)
                 except ReaderError as err:
+                    current_app.logger.error(f"Reader error: {str(err)}")
                     yield StreamEntry(
                         entry=item,
                         errors=[f"{current_gen_func.__qualname__}: {str(err)}"],
@@ -140,6 +150,7 @@ class DataStream:
 
     def transform(self, stream_entry, *args, **kwargs):
         """Apply the transformations to an stream_entry."""
+        current_app.logger.debug(f"Transforming entry: {stream_entry.entry}")
         for transformer in self._transformers:
             try:
                 stream_entry = transformer.apply(stream_entry)
@@ -153,16 +164,19 @@ class DataStream:
 
     def write(self, stream_entry, *args, **kwargs):
         """Apply the transformations to an stream_entry."""
+        current_app.logger.debug(f"Writing entry: {stream_entry.entry}")
         for writer in self._writers:
             try:
                 writer.write(stream_entry)
             except WriterError as err:
+                current_app.logger.error(f"Writer error: {str(err)}")
                 stream_entry.errors.append(f"{writer.__class__.__name__}: {str(err)}")
 
         return stream_entry
 
     def batch_write(self, stream_entries, *args, **kwargs):
         """Apply the transformations to an stream_entry. Errors are handler in the service layer."""
+        current_app.logger.debug(f"Batch writing entries: {len(stream_entries)}")
         for writer in self._writers:
             yield from writer.write_many(stream_entries)
 

invenio_vocabularies/datastreams/readers.py

@@ -407,15 +407,18 @@ class RDFReader(BaseReader):
 class SPARQLReader(BaseReader):
     """Generic reader class to fetch and process RDF data from a SPARQL endpoint."""
 
-    def __init__(self, origin, query, mode="r", *args, **kwargs):
+    def __init__(self, origin, query, mode="r", client_params=None, *args, **kwargs):
         """Initialize the reader with the data source.
 
         :param origin: The SPARQL endpoint from which to fetch the RDF data.
         :param query: The SPARQL query to execute.
         :param mode: Mode of operation (default is 'r' for reading).
+        :param client_params: Additional client parameters to pass to the SPARQL client.
         """
         self._origin = origin
         self._query = query
+        self._client_params = client_params or {}
+
         super().__init__(origin=origin, mode=mode, *args, **kwargs)
 
     def _iter(self, fp, *args, **kwargs):
@@ -430,7 +433,14 @@ class SPARQLReader(BaseReader):
                 "SPARQLReader does not support being chained after another reader"
             )
 
-        sparql_client = sparql.SPARQLWrapper(self._origin)
+        # Avoid overwriting SPARQLWrapper's default value for the user agent string
+        if self._client_params.get("user_agent"):
+            sparql_client = sparql.SPARQLWrapper(
+                self._origin, agent=self._client_params.get("user_agent")
+            )
+        else:
+            sparql_client = sparql.SPARQLWrapper(self._origin)
+
         sparql_client.setQuery(self._query)
         sparql_client.setReturnFormat(sparql.JSON)
 

invenio_vocabularies/datastreams/writers.py

@@ -87,17 +87,21 @@ class ServiceWriter(BaseWriter):
 
     def _do_update(self, entry):
         vocab_id = self._entry_id(entry)
+        current_app.logger.debug(f"Resolving entry with ID: {vocab_id}")
         current = self._resolve(vocab_id)
         updated = dict(current.to_dict(), **entry)
+        current_app.logger.debug(f"Updating entry with ID: {vocab_id}")
         return StreamEntry(self._service.update(self._identity, vocab_id, updated))
 
     def write(self, stream_entry, *args, **kwargs):
         """Writes the input entry using a given service."""
         entry = stream_entry.entry
+        current_app.logger.debug(f"Writing entry: {entry}")
 
         try:
             if self._insert:
                 try:
+                    current_app.logger.debug("Inserting entry.")
                     return StreamEntry(self._service.create(self._identity, entry))
                 except PIDAlreadyExists:
                     if not self._update:
@@ -105,6 +109,7 @@ class ServiceWriter(BaseWriter):
                     return self._do_update(entry)
             elif self._update:
                 try:
+                    current_app.logger.debug("Attempting to update entry.")
                     return self._do_update(entry)
                 except (NoResultFound, PIDDoesNotExistError):
                     raise WriterError([f"Vocabulary entry does not exist: {entry}"])
@@ -139,6 +144,7 @@ class ServiceWriter(BaseWriter):
             processed_stream_entry.log_errors()
             stream_entries_processed.append(processed_stream_entry)
 
+        current_app.logger.debug(f"Finished writing {len(stream_entries)} entries")
         return stream_entries_processed
 
 

invenio_vocabularies/jobs.py

@@ -10,7 +10,7 @@
 
 import datetime
 
-from invenio_i18n import gettext as _
+from invenio_i18n import lazy_gettext as _
 from invenio_jobs.jobs import JobType
 
 from invenio_vocabularies.services.tasks import process_datastream
@@ -27,8 +27,8 @@ class ProcessDataStreamJob(JobType):
 class ProcessRORAffiliationsJob(ProcessDataStreamJob):
     """Process ROR affiliations datastream registered task."""
 
-    description = "Process ROR affiliations"
-    title = "Load ROR affiliations"
+    description = _("Process ROR affiliations")
+    title = _("Load ROR affiliations")
     id = "process_ror_affiliations"
 
     @classmethod
@@ -65,8 +65,8 @@ class ProcessRORAffiliationsJob(ProcessDataStreamJob):
 class ProcessRORFundersJob(ProcessDataStreamJob):
     """Process ROR funders datastream registered task."""
 
-    description = "Process ROR funders"
-    title = "Load ROR funders"
+    description = _("Process ROR funders")
+    title = _("Load ROR funders")
     id = "process_ror_funders"
 
     @classmethod
@@ -103,8 +103,8 @@ class ProcessRORFundersJob(ProcessDataStreamJob):
 class ImportAwardsOpenAIREJob(ProcessDataStreamJob):
     """Import awards from OpenAIRE registered task."""
 
-    description = "Import awards from OpenAIRE"
-    title = "Import Awards OpenAIRE"
+    description = _("Import awards from OpenAIRE")
+    title = _("Import Awards OpenAIRE")
     id = "import_awards_openaire"
 
     @classmethod
@@ -138,8 +138,8 @@ class ImportAwardsOpenAIREJob(ProcessDataStreamJob):
 class UpdateAwardsCordisJob(ProcessDataStreamJob):
     """Update awards from CORDIS registered task."""
 
-    description = "Update awards from CORDIS"
-    title = "Update Awards CORDIS"
+    description = _("Update awards from CORDIS")
+    title = _("Update Awards CORDIS")
     id = "update_awards_cordis"
 
     @classmethod
@@ -166,8 +166,8 @@ class UpdateAwardsCordisJob(ProcessDataStreamJob):
 class ImportORCIDJob(ProcessDataStreamJob):
     """Import ORCID data registered task."""
 
-    description = "Import ORCID data"
-    title = "Import ORCID data"
+    description = _("Import ORCID data")
+    title = _("Import ORCID data")
     id = "import_orcid"
 
     @classmethod

invenio_vocabularies/records/models.py

@@ -9,6 +9,7 @@
 """Vocabulary models."""
 
 from invenio_db import db
+from invenio_i18n import gettext as _
 from invenio_records.models import RecordMetadataBase
 
 
@@ -79,7 +80,9 @@ class VocabularyScheme(db.Model):
         """Create a new vocabulary subtype."""
         banned = [",", ":"]
         for b in banned:
-            assert b not in data["id"], f"No '{b}' allowed in VocabularyScheme.id"
+            assert b not in data["id"], _(
+                "No '%(banned_char)s' allowed in VocabularyScheme.id", banned_char=b
+            )
 
         with db.session.begin_nested():
             obj = cls(**data)