invenio-vocabularies 9.1.2__py2.py3-none-any.whl

invenio_vocabularies/contrib/names/resources.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# Copyright (C) 2021 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 vocabulary resources."""
+
+from flask import g
+from flask_resources import resource_requestctx, response_handler, route
+from invenio_records_resources.resources.records.resource import request_view_args
+from marshmallow import fields
+
+from .names import record_type
+
+
+class NamesResourceConfig(record_type.resource_config_cls):
+    """Name resource."""
+
+    routes = record_type.resource_config_cls.routes
+    routes["item-names-resolve"] = "/<pid_type>/<pid_value>"
+    request_view_args = {
+        "pid_value": fields.Str(),
+        "pid_type": fields.Str(),
+    }
+
+
+class NamesResource(record_type.resource_cls):
+    """Name resource."""
+
+    def create_url_rules(self):
+        """Create the URL rules for the record resource."""
+        routes = self.config.routes
+        url_rules = super(NamesResource, self).create_url_rules()
+        url_rules += [
+            route("GET", routes["item-names-resolve"], self.name_resolve_by_id),
+        ]
+
+        return url_rules
+
+    @request_view_args
+    @response_handler()
+    def name_resolve_by_id(self):
+        """Resolve an identifier."""
+        item = self.service.resolve(
+            id_=resource_requestctx.view_args["pid_value"],
+            id_type=resource_requestctx.view_args["pid_type"],
+            identity=g.identity,
+        )
+
+        return item.to_dict(), 200

invenio_vocabularies/contrib/names/s3client.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of Invenio.
+# 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
+# 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."""
+        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=access_key,
+            secret_key=secret_key,
+        )

invenio_vocabularies/contrib/names/schema.py

@@ -0,0 +1,121 @@
+# -*- 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 schema."""
+
+from functools import partial
+
+from invenio_i18n import lazy_gettext as _
+from marshmallow import (
+    EXCLUDE,
+    ValidationError,
+    fields,
+    post_dump,
+    post_load,
+    validates_schema,
+)
+from marshmallow_utils.fields import IdentifierSet, SanitizedUnicode
+from marshmallow_utils.schemas import IdentifierSchema
+
+from ...services.schema import BaseVocabularySchema, ModePIDFieldVocabularyMixin
+from ..affiliations.schema import (
+    AffiliationRelationSchema as BaseAffiliationRelationSchema,
+)
+from .config import names_schemes
+
+
+class AffiliationRelationSchema(BaseAffiliationRelationSchema):
+    """Affiliation relation schema."""
+
+    acronym = SanitizedUnicode(dump_only=True)
+
+    class Meta:
+        """Meta class."""
+
+        unknown = EXCLUDE
+
+
+class NameSchema(BaseVocabularySchema, ModePIDFieldVocabularyMixin):
+    """Service schema for names.
+
+    Note that this vocabulary is very different from the base vocabulary
+    so it does not inherit from it.
+    """
+
+    internal_id = fields.Str(allow_none=True)
+    name = SanitizedUnicode()
+    given_name = SanitizedUnicode()
+    family_name = SanitizedUnicode()
+    identifiers = IdentifierSet(
+        fields.Nested(
+            partial(
+                IdentifierSchema,
+                # It is intended to allow org schemes to be sent as personal
+                # and viceversa. This is a trade off learnt from running
+                # Zenodo in production.
+                allowed_schemes=names_schemes,
+            )
+        )
+    )
+    affiliations = fields.List(fields.Nested(AffiliationRelationSchema))
+    props = fields.Dict(keys=fields.Str(), values=fields.Raw())
+
+    @validates_schema
+    def validate_names(self, data, **kwargs):
+        """Validate names."""
+        can_compose = data.get("family_name") and data.get("given_name")
+        name = data.get("name")
+        if not can_compose and not name:
+            messages = [
+                _(
+                    "A name or the family name together with the given name must be present."
+                )
+            ]
+            raise ValidationError({"family_name": messages})
+
+    @validates_schema
+    def validate_affiliations(self, data, **kwargs):
+        """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:
+                    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.
+
+        Fill name from given_name and family_name if person.
+        """
+        family_name = data.get("family_name")
+        given_name = data.get("given_name")
+        if family_name and given_name:
+            data["name"] = f"{family_name}, {given_name}"
+
+        return data
+
+    @post_dump
+    def dump_name(self, data, **kwargs):
+        """Dumps the name if not present in the serialized data."""
+        name = data.get("name")
+        if not name:
+            family_name = data.get("family_name")
+            given_name = data.get("given_name")
+            if family_name and given_name:
+                data["name"] = f"{family_name}, {given_name}"
+            elif family_name:
+                data["name"] = family_name
+        return data

invenio_vocabularies/contrib/names/services.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021 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 services."""
+
+from invenio_pidstore.errors import PIDDoesNotExistError
+from invenio_search.engine import dsl
+
+from .names import record_type
+
+NamesServiceConfig = record_type.service_config_cls
+
+
+class NamesService(record_type.service_cls):
+    """Name service."""
+
+    def resolve(self, identity, id_, id_type, many=False):
+        """Get the record with a given identifier.
+
+        param id_: The identifier value.
+        param id_type: The identifier type.
+        param many: If True, return a list of records.
+        """
+        search_query = dsl.Q(
+            "bool",
+            minimum_should_match=1,
+            must=[
+                dsl.Q("term", identifiers__identifier=id_),
+                dsl.Q("term", identifiers__scheme=id_type),
+            ],
+        )
+
+        # max_records = 1, we assume there cannot be duplicates
+        # the loading process needs to make sure of that
+        if many:
+            results = self._read_many(identity, search_query)
+        else:
+            results = self._read_many(identity, search_query, max_records=1)
+
+        # cant use the results_item because it returns dicts instead of records
+        total = results.hits.total["value"]
+        if total == 0:
+            # Not a PID but treated as such
+            raise PIDDoesNotExistError(pid_type=id_type, pid_value=id_)
+        if many:
+            for result in results:
+                record = self.record_cls.loads(result.to_dict())
+                self.require_permission(identity, "read", record=record)
+            return self.result_list(self, identity, results)
+        else:
+            record = self.record_cls.loads(results[0].to_dict())
+            self.require_permission(identity, "read", record=record)
+
+            return self.result_item(
+                self,
+                identity,
+                record,
+                links_tpl=self.links_item_tpl,
+            )

invenio_vocabularies/contrib/subjects/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020-2021 CERN.
+# Copyright (C) 2021 Northwestern University.
+#
+# 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.
+
+"""Subjects module."""
+
+from .facets import SubjectsLabels
+from .resources import SubjectsResource, SubjectsResourceConfig
+from .services import SubjectsService, SubjectsServiceConfig
+
+__all__ = [
+    "SubjectsLabels",
+    "SubjectsResource",
+    "SubjectsResourceConfig",
+    "SubjectsService",
+    "SubjectsServiceConfig",
+]

invenio_vocabularies/contrib/subjects/api.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021 CERN.
+# Copyright (C) 2021 Northwestern University.
+#
+# 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.
+
+"""Subject API."""
+
+from .subjects import record_type
+
+Subject = record_type.record_cls

invenio_vocabularies/contrib/subjects/config.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021-2025 CERN.
+# Copyright (C) 2021 Northwestern University.
+# Copyright (C) 2024 University of Münster.
+#
+# 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.
+
+"""Subjects configuration."""
+
+from flask import current_app
+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
+
+subject_schemes = LocalProxy(
+    lambda: current_app.config["VOCABULARIES_SUBJECTS_SCHEMES"]
+)
+localized_title = LocalProxy(lambda: f"title.{get_locale()}^20")
+
+
+gemet_file_url = LocalProxy(
+    lambda: current_app.config["VOCABULARIES_SUBJECTS_GEMET_FILE_URL"]
+)
+
+euroscivoc_file_url = LocalProxy(
+    lambda: current_app.config["VOCABULARIES_SUBJECTS_EUROSCIVOC_FILE_URL"]
+)
+
+nvs_file_url = LocalProxy(
+    lambda: current_app.config["VOCABULARIES_SUBJECTS_NVS_FILE_URL"]
+)
+
+
+class SubjectsSearchOptions(SearchOptions):
+    """Search options."""
+
+    suggest_parser_cls = CompositeSuggestQueryParser.factory(
+        filter_field="scheme",
+        fields=[
+            "subject^100",
+            "scheme^20",
+            localized_title,
+            "synonyms^20",
+        ],
+        clauses=[
+            {"type": "cross_fields", "boost": 3},
+            {"type": "bool_prefix", "boost": 2, "fuzziness": "AUTO"},
+            {"type": "most_fields", "boost": 1, "fuzziness": "AUTO"},
+        ],
+    )
+
+    sort_default = "bestmatch"
+
+    sort_default_no_query = "subject"
+
+    sort_options = {
+        "bestmatch": dict(
+            title=_("Best match"),
+            fields=["_score"],  # ES defaults to desc on `_score` field
+        ),
+        "subject": dict(
+            title=_("Name"),
+            fields=["subject_sort"],
+        ),
+        "newest": dict(
+            title=_("Newest"),
+            fields=["-created"],
+        ),
+        "oldest": dict(
+            title=_("Oldest"),
+            fields=["created"],
+        ),
+    }
+
+
+service_components = [
+    # Order of components are important!
+    DataComponent,
+    PIDComponent,
+]

invenio_vocabularies/contrib/subjects/datastreams.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2024 University of Münster.
+#
+# 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."""
+
+from invenio_access.permissions import system_identity
+from invenio_i18n import lazy_gettext as _
+
+from ...datastreams.writers import ServiceWriter
+from .euroscivoc import datastreams as euroscivoc_datastreams
+from .gemet import datastreams as gemet_datastreams
+from .mesh import datastreams as mesh_datastreams
+from .nvs import datastreams as nvs_datastreams
+
+
+class SubjectsServiceWriter(ServiceWriter):
+    """Subjects Service Writer."""
+
+    def __init__(self, *args, **kwargs):
+        """Constructor."""
+        service_or_name = kwargs.pop("service_or_name", "subjects")
+        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 = {
+    **mesh_datastreams.VOCABULARIES_DATASTREAM_READERS,
+}
+"""Subjects Data Streams readers."""
+
+VOCABULARIES_DATASTREAM_TRANSFORMERS = {
+    **mesh_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
+    **euroscivoc_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
+    **gemet_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
+    **nvs_datastreams.VOCABULARIES_DATASTREAM_TRANSFORMERS,
+}
+"""Subjects Data Streams transformers."""
+
+VOCABULARIES_DATASTREAM_WRITERS = {
+    "subjects-service": SubjectsServiceWriter,
+    **mesh_datastreams.VOCABULARIES_DATASTREAM_WRITERS,
+}
+"""Subjects Data Streams writers."""
+
+DATASTREAM_CONFIG = {
+    "readers": [
+        {"type": "yaml"},
+    ],
+    "writers": [
+        {
+            "type": "subjects-service",
+        }
+    ],
+}
+"""Data Stream configuration."""

invenio_vocabularies/contrib/subjects/euroscivoc/__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.
+
+"""EuroSciVoc Subjects module."""

invenio_vocabularies/contrib/subjects/euroscivoc/datastreams.py

@@ -0,0 +1,101 @@
+# -*- 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.
+
+"""EuroSciVoc subjects datastreams, readers, transformers, and writers."""
+
+from invenio_vocabularies.datastreams.transformers import RDFTransformer
+
+from ..config import euroscivoc_file_url
+
+
+class EuroSciVocSubjectsTransformer(RDFTransformer):
+    """
+     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."""
+        for _, _, notation in rdf_graph.triples(
+            (subject, self.skos_core.notation, None)
+        ):
+            if str(notation).isdigit():
+                return str(notation)
+        return None
+
+    def _get_parent_notation(self, broader, rdf_graph):
+        """Extract parent notation using numeric notation."""
+        return self._get_notation(broader, rdf_graph)
+
+    def _transform_entry(self, subject, rdf_graph):
+        notation = self._get_notation(subject, rdf_graph)
+        id = f"euroscivoc:{notation}" if notation else None
+        labels = self._get_labels(subject, rdf_graph)
+        parents = ",".join(
+            f"euroscivoc:{n}"
+            for n in reversed(self._find_parents(subject, rdf_graph))
+            if n
+        )
+
+        return {
+            "id": id,
+            "scheme": "EuroSciVoc",
+            "subject": labels.get("en", "").capitalize(),
+            "title": labels,
+            "props": {"parents": parents} if parents else {},
+            "identifiers": self._get_identifiers(subject),
+        }
+
+
+# Configuration for datastream
+
+VOCABULARIES_DATASTREAM_TRANSFORMERS = {
+    "euroscivoc-transformer": EuroSciVocSubjectsTransformer
+}
+
+DATASTREAM_CONFIG = {
+    "readers": [
+        {
+            "type": "http",
+            "args": {
+                "origin": euroscivoc_file_url,
+            },
+        },
+        {
+            "type": "rdf",
+        },
+    ],
+    "transformers": [{"type": "euroscivoc-transformer"}],
+    "writers": [{"args": {"writer": {"type": "subjects-service"}}, "type": "async"}],
+}

invenio_vocabularies/contrib/subjects/facets.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021 Northwestern University.
+#
+# 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.
+
+"""Subjects services."""
+
+
+class SubjectsLabels:
+    """Fetching of subjects labels for facets."""
+
+    def __call__(self, ids):
+        """Return the mapping when evaluated.
+
+        In this case, the ids received are actually the vocabulary `scheme`
+        (top-level) and `subject` (nested). And since they are already
+        human-readable, we keep them as-is.
+        """
+        unique_ids = list(set(ids))
+        return {id_: id_ for id_ in unique_ids}

invenio_vocabularies/contrib/subjects/gemet/__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.
+
+"""GEMET Subjects module."""