invenio-vocabularies 9.0.0__py2.py3-none-any.whl → 9.1.0__py2.py3-none-any.whl

invenio_vocabularies/__init__.py

@@ -11,6 +11,6 @@
 
 from .ext import InvenioVocabularies
 
-__version__ = "9.0.0"
+__version__ = "9.1.0"
 
 __all__ = ("__version__", "InvenioVocabularies")

invenio_vocabularies/contrib/names/datastreams.py

@@ -69,12 +69,11 @@ class OrcidDataSyncReader(BaseReader):
         date_format_no_millis = "%Y-%m-%d %H:%M:%S"
 
         if self.since:
-            last_sync = datetime.now()
+            last_sync = datetime.strptime(self.since, date_format)
         else:
             last_sync = datetime.now() - timedelta(
                 **current_app.config["VOCABULARIES_ORCID_SYNC_SINCE"]
             )
-
         try:
             content = io.TextIOWrapper(fileobj, encoding="utf-8")
             csv_reader = csv.DictReader(content)
@@ -95,7 +94,10 @@ class OrcidDataSyncReader(BaseReader):
 
                 if last_modified_date < last_sync:
                     current_app.logger.debug(
-                        f"Skipping ORCiD {orcid} (last modified: {last_modified_date})"
+                        f"Skipping ORCiD {orcid}: last modified {last_modified_date} is older than cutoff {last_sync}"
+                    )
+                    current_app.logger.info(
+                        "Reached cutoff date. No more recent records to process."
                     )
                     break
                 current_app.logger.debug(f"Yielding ORCiD {orcid} for sync.")
@@ -285,7 +287,12 @@ class OrcidTransformer(BaseTransformer):
                     f"Family name not found in ORCiD entry for ORCiD ID: {orcid_id}."
                 )
             )
-        if not self._is_valid_name(given_names + family_name):
+        full_name = " ".join(
+            p.strip()
+            for p in (given_names, family_name)
+            if isinstance(p, str) and p.strip()
+        )
+        if not self._is_valid_name(full_name):
             errors.append(
                 TransformerError(
                     f"Invalid characters in name for ORCiD ID: {orcid_id}."

invenio_vocabularies/contrib/names/schema.py

@@ -80,18 +80,20 @@ class NameSchema(BaseVocabularySchema, ModePIDFieldVocabularyMixin):
 
     @validates_schema
     def validate_affiliations(self, data, **kwargs):
-        """Validate names."""
+        """Validate and return distinct affiliations."""
         affiliations = data.get("affiliations", [])
         seen_names = set()
         for affiliation in affiliations:
             name = affiliation.get("name")
             if not affiliation.get("id") and name:
                 if name in seen_names:
-                    messages = [_("Duplicated affiliations.")]
-                    raise ValidationError({"affiliations": messages})
+                    affiliations.remove(affiliation)
                 else:
                     seen_names.add(name)
 
+        if affiliations:
+            data["affiliations"] = affiliations
+
     @post_load
     def update_name(self, data, **kwargs):
         """Update names for person.

invenio_vocabularies/datastreams/datastreams.py

@@ -9,6 +9,11 @@
 """Base data stream."""
 
 from flask import current_app
+from invenio_access.permissions import system_identity, system_user_id
+from invenio_access.utils import get_identity
+from invenio_accounts.proxies import current_datastore
+from invenio_jobs.logging.jobs import EMPTY_JOB_CTX, job_context
+from invenio_jobs.proxies import current_runs_service
 
 from .errors import ReaderError, TransformerError, WriterError
 
@@ -78,6 +83,14 @@ class DataStream:
     def process_batch(self, batch):
         """Process a batch of entries."""
         current_app.logger.info(f"Processing batch of size: {len(batch)}")
+        if job_context.get() is not EMPTY_JOB_CTX:
+            run_id = job_context.get()["run_id"]
+            current_runs_service.add_total_entries(
+                system_identity,
+                run_id=run_id,
+                job_id=job_context.get()["job_id"],
+                total_entries=len(batch),
+            )
         transformed_entries = []
         transformed_entries_with_errors = []
         for stream_entry in batch:
@@ -168,12 +181,36 @@ class DataStream:
 
         return stream_entry
 
+    def _prepare_async_context(self):
+        """Prepare the async context for writers."""
+        job_ctx = job_context.get()
+        run_id = job_ctx.get("run_id")
+        identity_id = job_ctx.get("identity_id")
+        job_id = job_ctx.get("job_id")
+        # System user needs to be handled separately because it doesn't exist in the database
+        if identity_id == system_user_id:
+            identity = system_identity
+        else:
+            user = current_datastore.get_user(identity_id)
+            if user is None:
+                raise ValueError(f"User with ID:{identity_id} not found.")
+            identity = get_identity(user)
+
+        subtask_run = current_runs_service.create_subtask_run(
+            identity, parent_run_id=run_id, job_id=job_id
+        )
+        return str(subtask_run.id)
+
     def write(self, stream_entry, *args, **kwargs):
-        """Apply the transformations to an stream_entry."""
+        """Write a single stream entry."""
         current_app.logger.debug(f"Writing entry: {stream_entry.entry}")
         for writer in self._writers:
             try:
-                writer.write(stream_entry)
+                if writer.is_async and job_context.get() is not EMPTY_JOB_CTX:
+                    subtask_run_id = self._prepare_async_context()
+                    writer.write(stream_entry, subtask_run_id=subtask_run_id)
+                else:
+                    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)}")
@@ -181,10 +218,21 @@ class DataStream:
         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."""
+        """Write a batch of stream entries."""
         current_app.logger.debug(f"Batch writing entries: {len(stream_entries)}")
         for writer in self._writers:
-            yield from writer.write_many(stream_entries)
+            try:
+                if writer.is_async and job_context.get() is not EMPTY_JOB_CTX:
+                    subtask_run_id = self._prepare_async_context()
+                    yield from writer.write_many(
+                        stream_entries, subtask_run_id=subtask_run_id
+                    )
+                else:
+                    yield from writer.write_many(stream_entries)
+            except WriterError as err:
+                current_app.logger.error(f"Writer error: {str(err)}")
+                for entry in stream_entries:
+                    entry.errors.append(f"{writer.__class__.__name__}: {str(err)}")
 
     def total(self, *args, **kwargs):
         """The total of entries obtained from the origin."""

invenio_vocabularies/datastreams/tasks.py

@@ -9,29 +9,107 @@
 """Data Streams Celery tasks."""
 
 from celery import shared_task
+from flask import current_app
+from invenio_access.permissions import system_identity
+from invenio_jobs.logging.jobs import EMPTY_JOB_CTX, job_context
+from invenio_jobs.proxies import current_runs_service
 
 from ..datastreams import StreamEntry
 from ..datastreams.factories import WriterFactory
 
 
 @shared_task(ignore_result=True)
-def write_entry(writer_config, entry):
+def write_entry(writer_config, entry, subtask_run_id=None):
     """Write an entry.
 
     :param writer: writer configuration as accepted by the WriterFactory.
     :param entry: dictionary, StreamEntry is not serializable.
     """
+    job_ctx = job_context.get()
+    job_id = job_ctx.get("job_id", None) if job_ctx is not EMPTY_JOB_CTX else None
+    if subtask_run_id and job_id:
+        subtask_run = current_runs_service.get(
+            system_identity, job_id=job_id, run_id=subtask_run_id
+        )
+        current_runs_service.start_processing_subtask(
+            system_identity, subtask_run.id, job_id=job_id
+        )
+
     writer = WriterFactory.create(config=writer_config)
-    writer.write(StreamEntry(entry))
+    try:
+        processed_stream_entry = writer.write(StreamEntry(entry))
+        errored_entries_count = 1 if processed_stream_entry.errors else 0
+        inserted_count = 1 if processed_stream_entry.op_type == "create" else 0
+        updated_count = 1 if processed_stream_entry.op_type == "update" else 0
+        if subtask_run_id and job_id:
+            current_runs_service.finalize_subtask(
+                system_identity,
+                subtask_run_id,
+                job_id,
+                success=True if not processed_stream_entry.errors else False,
+                errored_entries_count=errored_entries_count,
+                inserted_entries_count=inserted_count,
+                updated_entries_count=updated_count,
+            )
+    except Exception as exc:
+        current_app.logger.error(f"Error writing entry {entry}: {exc}")
+        if subtask_run_id and job_id:
+            current_runs_service.finalize_subtask(
+                system_identity,
+                subtask_run_id,
+                job_id,
+                success=False,
+                errored_entries_count=1,
+            )
 
 
 @shared_task(ignore_result=True)
-def write_many_entry(writer_config, entries):
+def write_many_entry(writer_config, entries, subtask_run_id=None):
     """Write many entries.
 
     :param writer: writer configuration as accepted by the WriterFactory.
     :param entry: lisf ot dictionaries, StreamEntry is not serializable.
     """
+    job_ctx = job_context.get()
+    job_id = job_ctx.get("job_id", None) if job_ctx is not EMPTY_JOB_CTX else None
+    if subtask_run_id and job_id:
+        subtask_run = current_runs_service.get(
+            system_identity, job_id=job_id, run_id=subtask_run_id
+        )
+        current_runs_service.start_processing_subtask(
+            system_identity, subtask_run.id, job_id=job_id
+        )
     writer = WriterFactory.create(config=writer_config)
     stream_entries = [StreamEntry(entry) for entry in entries]
-    writer.write_many(stream_entries)
+    try:
+        processed_stream_entries = writer.write_many(stream_entries)
+        errored_entries_count = sum(
+            1 for entry in processed_stream_entries if entry.errors
+        )
+        inserted_count = sum(
+            1 for entry in processed_stream_entries if entry.op_type == "create"
+        )
+        updated_count = sum(
+            1 for entry in processed_stream_entries if entry.op_type == "update"
+        )
+        if subtask_run_id and job_id:
+            current_runs_service.finalize_subtask(
+                system_identity,
+                subtask_run_id,
+                job_id,
+                success=True,
+                errored_entries_count=errored_entries_count,
+                inserted_entries_count=inserted_count,
+                updated_entries_count=updated_count,
+            )
+    except Exception as exc:
+        current_app.logger.error(
+            f"Error writing entries {entries}: {exc}. The errorred entries count might be incorrect as an entire batch might have failed"
+        )
+        if subtask_run_id and job_id:
+            current_runs_service.finalize_subtask(
+                system_identity,
+                subtask_run_id,
+                job_id,
+                success=False,
+            )

invenio_vocabularies/datastreams/writers.py

@@ -28,6 +28,8 @@ from .tasks import write_entry, write_many_entry
 class BaseWriter(ABC):
     """Base writer."""
 
+    is_async = False
+
     def __init__(self, *args, **kwargs):
         """Base initialization logic."""
         # Add any base initialization here if needed
@@ -91,7 +93,9 @@ class ServiceWriter(BaseWriter):
         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))
+        return StreamEntry(
+            self._service.update(self._identity, vocab_id, updated), op_type="update"
+        )
 
     def write(self, stream_entry, *args, **kwargs):
         """Writes the input entry using a given service."""
@@ -102,7 +106,9 @@ class ServiceWriter(BaseWriter):
             if self._insert:
                 try:
                     current_app.logger.debug("Inserting entry.")
-                    return StreamEntry(self._service.create(self._identity, entry))
+                    return StreamEntry(
+                        self._service.create(self._identity, entry), op_type="create"
+                    )
                 except PIDAlreadyExists:
                     if not self._update:
                         raise WriterError([f"Vocabulary entry already exists: {entry}"])
@@ -182,6 +188,8 @@ class YamlWriter(BaseWriter):
 class AsyncWriter(BaseWriter):
     """Writes the entries asynchronously (celery task)."""
 
+    is_async = True
+
     def __init__(self, writer, *args, **kwargs):
         """Constructor.
 
@@ -190,16 +198,25 @@ class AsyncWriter(BaseWriter):
         super().__init__(*args, **kwargs)
         self._writer = writer
 
-    def write(self, stream_entry, *args, **kwargs):
-        """Launches a celery task to write an entry."""
-        write_entry.delay(self._writer, stream_entry.entry)
+    def write(self, stream_entry, subtask_run_id=None, *args, **kwargs):
+        """Launches a celery task to write an entry with a delay."""
+        # Add some delay to avoid processing the tasks too fast
+        write_entry.apply_async(
+            args=(self._writer, stream_entry.entry, subtask_run_id), countdown=1
+        )
 
         return stream_entry
 
-    def write_many(self, stream_entries, *args, **kwargs):
-        """Launches a celery task to write an entry."""
-        write_many_entry.delay(
-            self._writer, [stream_entry.entry for stream_entry in stream_entries]
+    def write_many(self, stream_entries, subtask_run_id=None, *args, **kwargs):
+        """Launches a celery task to write entries with a delay."""
+        # Add some delay to avoid processing the tasks too fast
+        write_many_entry.apply_async(
+            args=(
+                self._writer,
+                [stream_entry.entry for stream_entry in stream_entries],
+                subtask_run_id,
+            ),
+            countdown=1,
         )
 
         return stream_entries

invenio_vocabularies/jobs.py

@@ -8,6 +8,9 @@
 
 """Jobs module."""
 
+from datetime import datetime, timedelta
+
+from flask import current_app
 from invenio_i18n import lazy_gettext as _
 from invenio_jobs.jobs import JobType
 
@@ -177,3 +180,28 @@ class ImportORCIDJob(ProcessDataStreamJob):
             # It is the responsibility of the reader to handle it or ignore it
             reader["args"] = {**reader.get("args", {}), "since": str(since)}
         return task_args
+
+    @classmethod
+    def _build_task_arguments(cls, job_obj, since=None, custom_args=None, **kwargs):
+        """Build dict of arguments injected on task execution.
+
+        :param job_obj (Job): the Job object.
+        :param since (datetime): last time the job was executed.
+        :param custom_args (dict): when provided, takes precedence over any other
+            provided argument.
+        :return: a dict of arguments to be injected on task execution.
+        """
+        if custom_args:
+            return custom_args
+
+        if since is None:
+            """We set since to a time in the past defined by the VOCABULARIES_ORCID_SYNC_SINCE."""
+
+            since = datetime.now() - timedelta(
+                **current_app.config["VOCABULARIES_ORCID_SYNC_SINCE"]
+            )
+        """
+        Otherwise, since is already specified as a datetime with a timezone (see PredefinedArgsSchema) or we have never
+        run the job before so there is no logical value.
+        """
+        return {**cls.build_task_arguments(job_obj, since=since, **kwargs)}

invenio_vocabularies/services/tasks.py

@@ -30,7 +30,9 @@ def process_datastream(config):
             for err in result.errors:
                 current_app.logger.error(err)
             entries_with_errors += 1
+
     if entries_with_errors:
         raise TaskExecutionPartialError(
-            message=f"Task execution succeeded with {entries_with_errors} entries with errors."
+            message=f"Task execution succeeded with {entries_with_errors} entries with errors.",
+            errored_entries_count=entries_with_errors,
         )

{invenio_vocabularies-9.0.0.dist-info → invenio_vocabularies-9.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invenio-vocabularies
-Version: 9.0.0
+Version: 9.1.0
 Summary: Invenio module for managing vocabularies.
 Home-page: https://github.com/inveniosoftware/invenio-vocabularies
 Author: CERN
@@ -15,7 +15,7 @@ License-File: AUTHORS.rst
 Requires-Dist: invenio-i18n<4.0.0,>=3.0.0
 Requires-Dist: invenio-records-resources<9.0.0,>=8.0.0
 Requires-Dist: invenio-administration<5.0.0,>=4.0.0
-Requires-Dist: invenio-jobs<6.0.0,>=5.0.0
+Requires-Dist: invenio-jobs<7.0.0,>=6.0.0
 Requires-Dist: lxml>=4.5.0
 Requires-Dist: pycountry>=24.0.0
 Requires-Dist: PyYAML>=5.4.1
@@ -89,6 +89,10 @@ Invenio module for managing vocabularies, based on Invenio-Records and Invenio-R
 Changes
 =======
 
+Version v9.1.0 (released 2025-09-05)
+
+- installation: bump major version of invenio-jobs
+
 Version v9.0.0 (released 2025-09-05)
 
 - setup: bump major version of invenio-jobs

{invenio_vocabularies-9.0.0.dist-info → invenio_vocabularies-9.1.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-invenio_vocabularies/__init__.py,sha256=SaZR_FgM2gQeKd8dbBxVnBmb-8zKMNzg9uT4T6_cV6g,434
+invenio_vocabularies/__init__.py,sha256=XwPV7VV-dIH6JCpnyDYCJ4sZcPPW9K2z4q1Wf0873Uk,434
 invenio_vocabularies/cli.py,sha256=CpXTTIn2GTpUqNfLEMlRAp3JWst8ZjHVxoGYdhuuv_4,5959
 invenio_vocabularies/config.py,sha256=v6fTdeQXfUl0LavI2Xslql7mv3DVuIuGTqe2z3H3S7o,6942
 invenio_vocabularies/ext.py,sha256=GujJ4UARd4Fxf4z7zznRk9JAgHamZuYCOdrKU5czg00,5987
 invenio_vocabularies/factories.py,sha256=DM4jRUYu-so1jHRzhbNoNTnWKpYTZeRJhSP273giYws,6400
 invenio_vocabularies/fixtures.py,sha256=iEPkWf_ZjdP2D9r2sLdIlPoR8Rq2m5cnoFwywUGHneg,1696
-invenio_vocabularies/jobs.py,sha256=fSRedZhu_jH5gBD7Z8f_sNdGxAn9dFmbouXkIbqE4LI,6083
+invenio_vocabularies/jobs.py,sha256=71_peishXz0E1a1PhjeLQ6vjVmLFZ0TSIzvUtmG3-7I,7220
 invenio_vocabularies/proxies.py,sha256=k7cTUgWfnCoYIuNqAj_VFi1zBN33KNNclRSVnBkObEM,711
 invenio_vocabularies/views.py,sha256=PNJ5nvc3O7ASwNe56xmqy5YaU9n3UYF3W2JwvtE_kYs,1561
 invenio_vocabularies/webpack.py,sha256=FkM8TxXClmaJcD8YsQq5Mai56nYVJh_1IYTMEHb3c1M,1891
@@ -175,13 +175,13 @@ invenio_vocabularies/contrib/names/__init__.py,sha256=QwPEMnNyjt9LVeBBdFbVQfIxOn
 invenio_vocabularies/contrib/names/api.py,sha256=sEPn_jFX3gyoxgbdEUSIvOoPCUI8pocI6qCZO6mzCgQ,300
 invenio_vocabularies/contrib/names/components.py,sha256=PyYD1lOhmsuNoyDwM_huxkeo7kWd44vkEbJk9gqbDrM,769
 invenio_vocabularies/contrib/names/config.py,sha256=62jh4MP-CygnBpnRBVaCoGySHDEwhBSG1MnlUBumthw,2046
-invenio_vocabularies/contrib/names/datastreams.py,sha256=FqljkIl_MdYQ-oAnSMFf2Smfz-XjX8eVIdngeQApey0,16933
+invenio_vocabularies/contrib/names/datastreams.py,sha256=IjqBPW1Nq3IlCKuSrXFkItOqWOQm3D9x16_KzvQE5Vk,17282
 invenio_vocabularies/contrib/names/models.py,sha256=SYdtDDG-y5Wq_d06YhiVO5n8gfxPW_mx-tECsIcv5H8,308
 invenio_vocabularies/contrib/names/names.py,sha256=jej3gkBgOJpKwp5RmWk1AP678WkMb0VqCpzbTHLTyEc,2675
 invenio_vocabularies/contrib/names/permissions.py,sha256=5xrpYsA3oQUJ5lJpF7wjRAFiW-pM6_yP1k9zllbRwnQ,844
 invenio_vocabularies/contrib/names/resources.py,sha256=Z8XqLKfFKE69zdTTvcTDmpEZ6wqiqjIH5tp0LzXTSwQ,1588
 invenio_vocabularies/contrib/names/s3client.py,sha256=9n_Moet-XCQe0NEt1lYzRk_vorcNoCnmylZPKTbaqLA,1342
-invenio_vocabularies/contrib/names/schema.py,sha256=o5RDy3C9GaqCG6om6q-52t5DAJDwApwbnTUvuZUDQPg,3773
+invenio_vocabularies/contrib/names/schema.py,sha256=RX9uteii6ww0MkfarncV1giZKhxx5BczXfPhMVgid1I,3794
 invenio_vocabularies/contrib/names/services.py,sha256=ntcGUTM0ZsKnRTxIKvZhKrRuup6Tjv965PATCaJR6Cc,2127
 invenio_vocabularies/contrib/names/jsonschemas/__init__.py,sha256=pdDZdyoxqWbAQ6ngiclhYoDUsGKgRDRPXlIDy0U5Jzg,241
 invenio_vocabularies/contrib/names/jsonschemas/names/name-v1.0.0.json,sha256=WlIroNhE9o6oh1Cd13ymBPXuXDOs0NYfjLGtAH417YI,1574
@@ -222,13 +222,13 @@ invenio_vocabularies/contrib/subjects/mesh/datastreams.py,sha256=6W6bgQ7P_31kf3e
 invenio_vocabularies/contrib/subjects/nvs/__init__.py,sha256=H7joYEPU0lzGN_p72i9FElSRoaQTYHM7PvOn-ZPHyzM,245
 invenio_vocabularies/contrib/subjects/nvs/datastreams.py,sha256=PQsHKat9kAeZYAT_gEkVHLcZJLCwlc6TTwfMxewgVek,4273
 invenio_vocabularies/datastreams/__init__.py,sha256=VPefh6k4Q3eYxKIW8I5zXUGucntp7VHxaOR5Vhgkfmg,412
-invenio_vocabularies/datastreams/datastreams.py,sha256=QgMNUyB_oGXIiOXIj58YQPl9QBEbPE99svMOEPdGneI,7454
+invenio_vocabularies/datastreams/datastreams.py,sha256=oFYCyLceC8dEUbR0Drb7yQRrfH7abhSchyPgBZ6WMZI,9637
 invenio_vocabularies/datastreams/errors.py,sha256=IDUZ3gNtYGrhcOgApHCms1gNNJTyJzoMPmG5JtIeYNU,678
 invenio_vocabularies/datastreams/factories.py,sha256=kuuN4Zt7Xw58rwf0M03djqcdZOZRWgJdLK16-HmID24,2213
 invenio_vocabularies/datastreams/readers.py,sha256=rDYnYASYgPvp9OH0mtlGHsOEJGzDNcnSbyD8arXkmKE,14803
-invenio_vocabularies/datastreams/tasks.py,sha256=0fuH_PRt9Ncv6WHM4pkYmfheRVGDKkERZiMPvgV4bZU,1129
+invenio_vocabularies/datastreams/tasks.py,sha256=l-DcbW68jY0ww8u7pBDQsIvSDQRH7R-dAUOY0H7npX4,4466
 invenio_vocabularies/datastreams/transformers.py,sha256=PJFbmRSj3dpJ95NzONAIns5ksztshd99JOp_FLQAlJM,4133
-invenio_vocabularies/datastreams/writers.py,sha256=58BczBDaEJQpJM8R4SAXwlDy4UegbxX5thD3IhmnNq0,7291
+invenio_vocabularies/datastreams/writers.py,sha256=NgIdow2Q_Hr2j_49fcs2fmGccPvLqQzDJ9JaQeph8aw,7815
 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
@@ -262,7 +262,7 @@ invenio_vocabularies/services/querystr.py,sha256=OrNUR_QAcQ_T-EiL3H1Jvzz9gK2ZB5F
 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=2LrtXa6gFXhHSWn4R3Kl7Nj2f2mFmxzjgAF3K3Q3LGM,6749
-invenio_vocabularies/services/tasks.py,sha256=uS6tjbzpZC5g95QjxfVe21r_MTclNKVjlyC98NoIA-A,1188
+invenio_vocabularies/services/tasks.py,sha256=_kg7k0ESK-YWn8De-xTr6mkJnrjdTcydRcWUOHdKfAU,1245
 invenio_vocabularies/services/custom_fields/__init__.py,sha256=Wi7v8VUUTi16TCpMNKZ1zK3zWO2UjWBEnRMJjNm2foI,426
 invenio_vocabularies/services/custom_fields/subject.py,sha256=XTHnOddoSZsDHqGQq-hns46-WaLn88fqz57K--YLHg4,2243
 invenio_vocabularies/services/custom_fields/vocabulary.py,sha256=oQwI8Aoi2Nr9k3eWKnde5H7RXc7qdlATSeI6coy8UR0,3020
@@ -328,10 +328,10 @@ invenio_vocabularies/translations/zh_CN/LC_MESSAGES/messages.mo,sha256=AEoPrwqBX
 invenio_vocabularies/translations/zh_CN/LC_MESSAGES/messages.po,sha256=sP0-MvZo4F4wIG4JVLebCAOxh1tFIkfM2bLaKL-B148,8024
 invenio_vocabularies/translations/zh_TW/LC_MESSAGES/messages.mo,sha256=p2PFN_PL1m7miZ6qyoHFmBi6UUF3qhuz1sfCqTxm5fY,599
 invenio_vocabularies/translations/zh_TW/LC_MESSAGES/messages.po,sha256=vO8YRTkTqKE6gepSW_N3uNKYp3Me1rqnYaONFQGJOoY,7519
-invenio_vocabularies-9.0.0.dist-info/licenses/AUTHORS.rst,sha256=8d0p_WWE1r9DavvzMDi2D4YIGBHiMYcN3LYxqQOj8sY,291
-invenio_vocabularies-9.0.0.dist-info/licenses/LICENSE,sha256=UvI8pR8jGWqe0sTkb_hRG6eIrozzWwWzyCGEpuXX4KE,1062
-invenio_vocabularies-9.0.0.dist-info/METADATA,sha256=GehY1RJ6qpXMG-uJe-auQUbfCFsb1SakoN5Cj00rATM,15180
-invenio_vocabularies-9.0.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-invenio_vocabularies-9.0.0.dist-info/entry_points.txt,sha256=lget4Ekno9VRTq36oowWReIJA99165gOp0BOiiET60Y,3179
-invenio_vocabularies-9.0.0.dist-info/top_level.txt,sha256=x1gRNbaODF_bCD0SBLM3nVOFPGi06cmGX5X94WKrFKk,21
-invenio_vocabularies-9.0.0.dist-info/RECORD,,
+invenio_vocabularies-9.1.0.dist-info/licenses/AUTHORS.rst,sha256=8d0p_WWE1r9DavvzMDi2D4YIGBHiMYcN3LYxqQOj8sY,291
+invenio_vocabularies-9.1.0.dist-info/licenses/LICENSE,sha256=UvI8pR8jGWqe0sTkb_hRG6eIrozzWwWzyCGEpuXX4KE,1062
+invenio_vocabularies-9.1.0.dist-info/METADATA,sha256=6bBS7XM2SClCorCpGrJ1CWEgFZxd0HbCtLYIuZCW1Yw,15270
+invenio_vocabularies-9.1.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+invenio_vocabularies-9.1.0.dist-info/entry_points.txt,sha256=lget4Ekno9VRTq36oowWReIJA99165gOp0BOiiET60Y,3179
+invenio_vocabularies-9.1.0.dist-info/top_level.txt,sha256=x1gRNbaODF_bCD0SBLM3nVOFPGi06cmGX5X94WKrFKk,21
+invenio_vocabularies-9.1.0.dist-info/RECORD,,