invenio-vocabularies 4.2.0__tar.gz → 4.3.0__tar.gz

invenio-vocabularies-4.3.0/.github/workflows/tests.yml

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2020-2024 CERN.
+# Copyright (C) 2022 Graz University of Technology.
+#
+# Invenio is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+      - "maint-**"
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron: "0 3 * * 6"
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: "Reason"
+        required: false
+        default: "Manual trigger"
+
+jobs:
+  Python:
+    uses: inveniosoftware/workflows/.github/workflows/tests-python.yml@master
+    with:
+      extras: "tests,oaipmh"
+
+  JS:
+    uses: inveniosoftware/workflows/.github/workflows/tests-js.yml@master
+    with:
+      js-working-directory: ./invenio_vocabularies/assets/semantic-ui/js/invenio_vocabularies
+      translations-working-directory: ./invenio_vocabularies/assets/semantic-ui/translations/invenio_vocabularies

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/CHANGES.rst

@@ -8,6 +8,12 @@
 Changes
 =======
 
+Version v4.3.0 (released 2024-08-05)
+
+- names: make names_exclude_regex configurable
+- names: validate entry full names
+- names: add orcid public data sync
+
 Version v4.2.0 (released 2024-07-24)
 
 - ror: check last update; use ld+json for metadata (#367)

{invenio-vocabularies-4.2.0/invenio_vocabularies.egg-info → invenio-vocabularies-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: invenio-vocabularies
-Version: 4.2.0
+Version: 4.3.0
 Summary: "Invenio module for managing vocabularies."
 Home-page: https://github.com/inveniosoftware/invenio-vocabularies
 Author: CERN
@@ -50,6 +50,12 @@ Description: ..
         Changes
         =======
         
+        Version v4.3.0 (released 2024-08-05)
+        
+        - names: make names_exclude_regex configurable
+        - names: validate entry full names
+        - names: add orcid public data sync
+        
         Version v4.2.0 (released 2024-07-24)
         
         - ror: check last update; use ld+json for metadata (#367)
@@ -250,6 +256,7 @@ Keywords: invenio vocabulary management
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
 Requires-Python: >=3.7
+Provides-Extra: s3fs
 Provides-Extra: oaipmh
 Provides-Extra: tests
 Provides-Extra: elasticsearch7

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/__init__.py

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

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/cli.py

@@ -142,18 +142,27 @@ def convert(vocabulary, filepath=None, origin=None, target=None, num_samples=Non
     type=click.STRING,
     help="Identifier of the vocabulary item to delete.",
 )
-@click.option("--all", is_flag=True, default=False, help="Not supported yet.")
+@click.option("--all", is_flag=True, default=False)
 @with_appcontext
 def delete(vocabulary, identifier, all):
     """Delete all items or a specific one of the vocabulary."""
-    if not id and not all:
+    if not identifier and not all:
         click.secho("An identifier or the --all flag must be present.", fg="red")
         exit(1)
+
     vc = get_vocabulary_config(vocabulary)
     service = vc.get_service()
     if identifier:
         try:
-            if service.delete(identifier, system_identity):
+            if service.delete(system_identity, identifier):
                 click.secho(f"{identifier} deleted from {vocabulary}.", fg="green")
         except (PIDDeletedError, PIDDoesNotExistError):
             click.secho(f"PID {identifier} not found.")
+    elif all:
+        items = service.scan(system_identity)
+        for item in items.hits:
+            try:
+                if service.delete(system_identity, item["id"]):
+                    click.secho(f"{item['id']} deleted from {vocabulary}.", fg="green")
+            except (PIDDeletedError, PIDDoesNotExistError):
+                click.secho(f"PID {item['id']} not found.")

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/config.py

@@ -155,3 +155,16 @@ VOCABULARIES_TYPES_SEARCH = {
     "sort": ["name", "count"],
 }
 """Vocabulary type search configuration."""
+
+VOCABULARIES_ORCID_ACCESS_KEY = "TODO"
+"""ORCID access key to access the s3 bucket."""
+VOCABULARIES_ORCID_SECRET_KEY = "TODO"
+"""ORCID secret key to access the s3 bucket."""
+VOCABULARIES_ORCID_SUMMARIES_BUCKET = "v3.0-summaries"
+"""ORCID summaries bucket name."""
+VOCABULARIES_ORCID_SYNC_MAX_WORKERS = 32
+"""ORCID max number of simultaneous workers/connections."""
+VOCABULARIES_ORCID_SYNC_SINCE = {
+    "days": 1,
+}
+"""ORCID time shift to sync. Parameters accepted are the ones passed to 'datetime.timedelta'."""

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/contrib/affiliations/datastreams.py

@@ -42,7 +42,7 @@ class AffiliationsRORTransformer(RORTransformer):
             *args,
             vocab_schemes=vocab_schemes,
             funder_fundref_doi_prefix=funder_fundref_doi_prefix,
-            **kwargs
+            **kwargs,
         )
 
 

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/contrib/funders/datastreams.py

@@ -46,7 +46,7 @@ class FundersRORTransformer(RORTransformer):
             *args,
             vocab_schemes=vocab_schemes,
             funder_fundref_doi_prefix=funder_fundref_doi_prefix,
-            **kwargs
+            **kwargs,
         )
 
 

invenio-vocabularies-4.3.0/invenio_vocabularies/contrib/names/datastreams.py

@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021-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.
+
+"""Names datastreams, transformers, writers and readers."""
+
+import csv
+import io
+import tarfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import timedelta
+
+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 invenio_vocabularies.contrib.names.s3client import S3OrcidClient
+
+from ...datastreams.errors import TransformerError
+from ...datastreams.readers import BaseReader, SimpleHTTPReader
+from ...datastreams.transformers import BaseTransformer
+from ...datastreams.writers import ServiceWriter
+
+
+class OrcidDataSyncReader(BaseReader):
+    """ORCiD Data Sync Reader."""
+
+    def __init__(self, origin=None, mode="r", since=None, *args, **kwargs):
+        """Constructor.
+
+        :param origin: Data source (e.g. filepath).
+                       Can be none in case of piped readers.
+        """
+        super().__init__(origin=origin, mode=mode, *args, **kwargs)
+        self.s3_client = S3OrcidClient()
+        self.since = since
+
+    def _fetch_orcid_data(self, 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"
+        try:
+            return self.s3_client.read_file(f"s3://{bucket}/{key}")
+        except Exception as e:
+            # TODO: log
+            return None
+
+    def _process_lambda_file(self, fileobj):
+        """Process the ORCiD lambda file and returns a list of ORCiDs to sync.
+
+        The decoded fileobj looks like the following:
+        orcid, path, date_created, last_modified
+        0000-0001-5109-3700, http://orcid.org/0000-0001-5109-3700, 2014-08-02 15:00:00.000,2021-08-02 15:00:00.000
+
+        Yield ORCiDs to sync until the last sync date is reached.
+        """
+        date_format = "YYYY-MM-DD HH:mm:ss.SSSSSS"
+        date_format_no_millis = "YYYY-MM-DD HH:mm:ss"
+        time_shift = current_app.config["VOCABULARIES_ORCID_SYNC_SINCE"]
+        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
+
+    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(
+                    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
+
+    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."""
+        # Read the file from S3
+        tar_content = self.s3_client.read_file(
+            "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
+            for member in tar.getmembers():
+                # Extract the file
+                extracted_file = tar.extractfile(member)
+                if extracted_file:
+                    # Process the file and get the ORCiDs to sync
+                    orcids_to_sync.extend(self._process_lambda_file(extracted_file))
+
+        yield from self._iter(orcids_to_sync)
+
+
+class OrcidHTTPReader(SimpleHTTPReader):
+    """ORCiD HTTP Reader."""
+
+    def __init__(self, *args, test_mode=True, **kwargs):
+        """Constructor."""
+        if test_mode:
+            origin = "https://sandbox.orcid.org/{id}"
+        else:
+            origin = "https://orcid.org/{id}"
+
+        super().__init__(origin, *args, **kwargs)
+
+
+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."""
+
+
+class OrcidTransformer(BaseTransformer):
+    """Transforms an ORCiD record into a names record."""
+
+    def __init__(
+        self, *args, names_exclude_regex=DEFAULT_NAMES_EXCLUDE_REGEX, **kwargs
+    ) -> None:
+        """Constructor."""
+        self._names_exclude_regex = names_exclude_regex
+        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 apply(self, stream_entry, **kwargs):
+        """Applies the transformation to the 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(f"Name not found in ORCiD entry.")
+        if name.get("family-name") is None:
+            raise TransformerError(f"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.")
+
+        entry = {
+            "id": orcid_id,
+            "given_name": name.get("given-names"),
+            "family_name": name.get("family-name"),
+            "identifiers": [{"scheme": "orcid", "identifier": orcid_id}],
+            "affiliations": [],
+        }
+
+        try:
+            employments = dict_lookup(
+                record, "activities-summary.employments.affiliation-group"
+            )
+            if isinstance(employments, dict):
+                employments = [employments]
+            history = set()
+            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})
+        except Exception:
+            pass
+
+        stream_entry.entry = entry
+        return stream_entry
+
+
+class NamesServiceWriter(ServiceWriter):
+    """Names service writer."""
+
+    def __init__(self, *args, **kwargs):
+        """Constructor."""
+        service_or_name = kwargs.pop("service_or_name", "names")
+        super().__init__(service_or_name=service_or_name, *args, **kwargs)
+
+    def _entry_id(self, entry):
+        """Get the id from an entry."""
+        return entry["id"]
+
+
+VOCABULARIES_DATASTREAM_READERS = {
+    "orcid-http": OrcidHTTPReader,
+    "orcid-data-sync": OrcidDataSyncReader,
+}
+
+
+VOCABULARIES_DATASTREAM_TRANSFORMERS = {
+    "orcid": OrcidTransformer,
+}
+"""ORCiD Data Streams transformers."""
+
+
+VOCABULARIES_DATASTREAM_WRITERS = {
+    "names-service": NamesServiceWriter,
+}
+"""ORCiD Data Streams transformers."""
+
+
+DATASTREAM_CONFIG = {
+    "readers": [
+        {
+            "type": "tar",
+            "args": {
+                "regex": "\\.xml$",
+            },
+        },
+        {"type": "xml"},
+    ],
+    "transformers": [{"type": "orcid"}],
+    "writers": [
+        {
+            "type": "names-service",
+            "args": {
+                "identity": system_identity,
+            },
+        }
+    ],
+}
+"""ORCiD Data Stream configuration.
+
+An origin is required for the reader.
+"""
+
+# TODO: Used on the jobs and should be set as a "PRESET" (naming to be defined)
+ORCID_PRESET_DATASTREAM_CONFIG = {
+    "readers": [
+        {
+            "type": "orcid-data-sync",
+        },
+        {"type": "xml"},
+    ],
+    "transformers": [{"type": "orcid"}],
+    "writers": [
+        {
+            "type": "async",
+            "args": {
+                "writer": {
+                    "type": "names-service",
+                }
+            },
+        }
+    ],
+    "batch_size": 1000,
+    "write_many": True,
+}
+"""ORCiD Data Stream configuration.
+
+An origin is required for the reader.
+"""

invenio-vocabularies-4.3.0/invenio_vocabularies/contrib/names/s3client.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# 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.
+
+"""S3 client."""
+
+from flask import current_app
+
+try:
+    import s3fs
+except ImportError:
+    s3fs = None
+
+
+class S3Client:
+    """S3 client."""
+
+    def __init__(self, access_key, secret_key):
+        """Constructor."""
+        if s3fs is None:
+            raise Exception("s3fs is not installed.")
+
+        self.fs = s3fs.S3FileSystem(key=access_key, secret=secret_key)
+
+    def read_file(self, s3_path):
+        """Reads a file from S3."""
+        with self.fs.open(s3_path, "rb") as f:
+            return f.read()
+
+
+class S3OrcidClient(S3Client):
+    """S3 ORCiD client."""
+
+    def __init__(self):
+        """Constructor."""
+        super().__init__(
+            access_key=current_app.config["VOCABULARIES_ORCID_ACCESS_KEY"],
+            secret_key=current_app.config["VOCABULARIES_ORCID_SECRET_KEY"],
+        )

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/datastreams/datastreams.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2021-2022 CERN.
+# Copyright (C) 2021-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
@@ -8,17 +8,41 @@
 
 """Base data stream."""
 
+from flask import current_app
+
 from .errors import ReaderError, TransformerError, WriterError
 
 
 class StreamEntry:
     """Object to encapsulate streams processing."""
 
-    def __init__(self, entry, errors=None):
-        """Constructor."""
+    def __init__(self, entry, record=None, errors=None, op_type=None, exc=None):
+        """Constructor for the StreamEntry class.
+
+        :param entry (object): The entry object, usually a record dict.
+        :param record (object): The record object, usually a record class.
+        :param errors (list, optional): List of errors. Defaults to None.
+        :param op_type (str, optional): The operation type. Defaults to None.
+        :param exc (str, optional): The raised unhandled exception. Defaults to None.
+        """
         self.entry = entry
+        self.record = record
         self.filtered = False
         self.errors = errors or []
+        self.op_type = op_type
+        self.exc = exc
+
+    def log_errors(self, logger=None):
+        """Log the errors using the provided logger or the default logger.
+
+        :param logger (logging.Logger, optional): Logger instance to use. Defaults to None.
+        """
+        if logger is None:
+            logger = current_app.logger
+        for error in self.errors:
+            logger.error(f"Error in entry {self.entry}: {error}")
+        if self.exc:
+            logger.error(f"Exception in entry {self.entry}: {self.exc}")
 
 
 class DataStream:
@@ -39,15 +63,10 @@ class DataStream:
         """Checks if an stream_entry should be filtered out (skipped)."""
         return False
 
-    def process(self, *args, **kwargs):
-        """Iterates over the entries.
-
-        Uses the reader to get the raw entries and transforms them.
-        It will iterate over the `StreamEntry` objects returned by
-        the reader, apply the transformations and yield the result of
-        writing it.
-        """
-        for stream_entry in self.read():
+    def process_batch(self, batch, write_many=False):
+        """Process a batch of entries."""
+        transformed_entries = []
+        for stream_entry in batch:
             if stream_entry.errors:
                 yield stream_entry  # reading errors
             else:
@@ -58,7 +77,31 @@ class DataStream:
                     transformed_entry.filtered = True
                     yield transformed_entry
                 else:
-                    yield self.write(transformed_entry)
+                    transformed_entries.append(transformed_entry)
+        if transformed_entries:
+            if 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):
+        """Iterates over the entries.
+
+        Uses the reader to get the raw entries and transforms them.
+        It will iterate over the `StreamEntry` objects returned by
+        the reader, apply the transformations and yield the result of
+        writing it.
+        """
+        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)
+                batch = []
+
+        # Process any remaining entries in the last batch
+        if batch:
+            yield from self.process_batch(batch, write_many=write_many)
 
     def read(self):
         """Recursively read the entries."""
@@ -107,6 +150,11 @@ 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."""
+        for writer in self._writers:
+            yield from writer.write_many(stream_entries)
+
     def total(self, *args, **kwargs):
         """The total of entries obtained from the origin."""
         raise NotImplementedError()

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/datastreams/readers.py

@@ -21,6 +21,7 @@ from json.decoder import JSONDecodeError
 import requests
 import yaml
 from lxml import etree
+from lxml.html import fromstring
 from lxml.html import parse as html_parse
 
 from .errors import ReaderError
@@ -226,8 +227,13 @@ class XMLReader(BaseReader):
     def _iter(self, fp, *args, **kwargs):
         """Read and parse an XML file to dict."""
         # NOTE: We parse HTML, to skip XML validation and strip XML namespaces
-        xml_tree = html_parse(fp).getroot()
-        record = etree_to_dict(xml_tree)["html"]["body"].get("record")
+        record = None
+        try:
+            xml_tree = fromstring(fp)
+            record = etree_to_dict(xml_tree).get("record")
+        except Exception as e:
+            xml_tree = html_parse(fp).getroot()
+            record = etree_to_dict(xml_tree)["html"]["body"].get("record")
 
         if not record:
             raise ReaderError(f"Record not found in XML entry.")

{invenio-vocabularies-4.2.0 → invenio-vocabularies-4.3.0}/invenio_vocabularies/datastreams/tasks.py

@@ -15,11 +15,23 @@ from ..datastreams.factories import WriterFactory
 
 
 @shared_task(ignore_result=True)
-def write_entry(writer, entry):
+def write_entry(writer_config, entry):
     """Write an entry.
 
     :param writer: writer configuration as accepted by the WriterFactory.
     :param entry: dictionary, StreamEntry is not serializable.
     """
-    writer = WriterFactory.create(config=writer)
+    writer = WriterFactory.create(config=writer_config)
     writer.write(StreamEntry(entry))
+
+
+@shared_task(ignore_result=True)
+def write_many_entry(writer_config, entries):
+    """Write many entries.
+
+    :param writer: writer configuration as accepted by the WriterFactory.
+    :param entry: lisf ot dictionaries, StreamEntry is not serializable.
+    """
+    writer = WriterFactory.create(config=writer_config)
+    stream_entries = [StreamEntry(entry) for entry in entries]
+    writer.write_many(stream_entries)