invenio-vocabularies 3.4.2__py2.py3-none-any.whl → 4.1.1__py2.py3-none-any.whl

invenio_vocabularies/contrib/names/jsonschemas/names/name-v1.0.0.json

@@ -8,6 +8,9 @@
     "$schema": {
       "$ref": "local://definitions-v1.0.0.json#/$schema"
     },
+    "tags": {
+      "$ref": "local://vocabularies/definitions-v1.0.0.json#/tags"
+    },
     "scheme": {
       "description": "Identifier of the name scheme.",
       "$ref": "local://definitions-v1.0.0.json#/identifier"

invenio_vocabularies/contrib/names/mappings/os-v1/names/name-v1.0.0.json

@@ -24,6 +24,9 @@
       "id": {
         "type": "keyword"
       },
+      "tags": {
+        "type": "keyword"
+      },
       "name_sort": {
         "type": "keyword"
       },

invenio_vocabularies/contrib/names/mappings/os-v2/names/name-v1.0.0.json

@@ -24,6 +24,9 @@
       "id": {
         "type": "keyword"
       },
+      "tags": {
+        "type": "keyword"
+      },
       "name_sort": {
         "type": "keyword"
       },

invenio_vocabularies/contrib/names/mappings/v7/names/name-v1.0.0.json

@@ -24,6 +24,9 @@
       "id": {
         "type": "keyword"
       },
+      "tags": {
+        "type": "keyword"
+      },
       "name_sort": {
         "type": "keyword"
       },

invenio_vocabularies/contrib/subjects/jsonschemas/subjects/subject-v1.0.0.json

@@ -8,6 +8,9 @@
     "$schema": {
       "$ref": "local://definitions-v1.0.0.json#/$schema"
     },
+    "tags": {
+      "$ref": "local://vocabularies/definitions-v1.0.0.json#/tags"
+    },
     "id": {
       "description": "URI or classification code as identifier - globally unique among all subject schemes.",
       "$ref": "local://definitions-v1.0.0.json#/identifier"

invenio_vocabularies/contrib/subjects/mappings/os-v1/subjects/subject-v1.0.0.json

@@ -55,6 +55,9 @@
             "type": "keyword"
           }
         }
+      },
+      "tags": {
+        "type": "keyword"
       }
     }
   }

invenio_vocabularies/contrib/subjects/mappings/os-v2/subjects/subject-v1.0.0.json

@@ -55,6 +55,9 @@
             "type": "keyword"
           }
         }
+      },
+      "tags": {
+        "type": "keyword"
       }
     }
   }

invenio_vocabularies/contrib/subjects/mappings/v7/subjects/subject-v1.0.0.json

@@ -55,6 +55,9 @@
             "type": "keyword"
           }
         }
+      },
+      "tags": {
+        "type": "keyword"
       }
     }
   }

invenio_vocabularies/datastreams/factories.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
@@ -36,7 +36,6 @@ class Factory:
         try:
             type_ = config["type"]
             args = config.get("args", {})
-
             return cls.options()[type_](**args)
         except KeyError:
             raise FactoryError(name=cls.FACTORY_NAME, key=type_)

invenio_vocabularies/datastreams/readers.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # Copyright (C) 2021-2024 CERN.
+# 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
@@ -15,16 +16,21 @@ import re
 import tarfile
 import zipfile
 from abc import ABC, abstractmethod
-from collections import defaultdict
 from json.decoder import JSONDecodeError
 
 import requests
 import yaml
+from lxml import etree
 from lxml.html import parse as html_parse
 
 from .errors import ReaderError
 from .xml import etree_to_dict
 
+try:
+    import oaipmh_scythe
+except ImportError:
+    oaipmh_scythe = None
+
 
 class BaseReader(ABC):
     """Base reader."""
@@ -80,7 +86,12 @@ class TarReader(BaseReader):
     def read(self, item=None, *args, **kwargs):
         """Opens a tar archive or uses the given file pointer."""
         if item:
-            yield from self._iter(fp=item, *args, **kwargs)
+            if isinstance(item, tarfile.TarFile):
+                yield from self._iter(fp=item, *args, **kwargs)
+            else:
+                # If the item is not already a TarFile (e.g. if it is a BytesIO), try to create a TarFile from the item.
+                with tarfile.open(mode=self._mode, fileobj=item) as archive:
+                    yield from self._iter(fp=archive, *args, **kwargs)
         else:
             with tarfile.open(self._origin, self._mode) as archive:
                 yield from self._iter(fp=archive, *args, **kwargs)
@@ -136,7 +147,12 @@ class ZipReader(BaseReader):
         """Opens a Zip archive or uses the given file pointer."""
         # https://docs.python.org/3/library/zipfile.html
         if item:
-            yield from self._iter(fp=item, *args, **kwargs)
+            if isinstance(item, zipfile.ZipFile):
+                yield from self._iter(fp=item, *args, **kwargs)
+            else:
+                # If the item is not already a ZipFile (e.g. if it is a BytesIO), try to create a ZipFile from the item.
+                with zipfile.ZipFile(item, **self._options) as archive:
+                    yield from self._iter(fp=archive, *args, **kwargs)
         else:
             with zipfile.ZipFile(self._origin, **self._options) as archive:
                 yield from self._iter(fp=archive, *args, **kwargs)
@@ -217,3 +233,80 @@ class XMLReader(BaseReader):
             raise ReaderError(f"Record not found in XML entry.")
 
         yield record
+
+
+class OAIPMHReader(BaseReader):
+    """OAIPMH reader."""
+
+    def __init__(
+        self,
+        *args,
+        base_url=None,
+        metadata_prefix=None,
+        set=None,
+        from_date=None,
+        until_date=None,
+        verb=None,
+        **kwargs,
+    ):
+        """Constructor."""
+        self._base_url = base_url
+        self._metadata_prefix = metadata_prefix if not None else "oai_dc"
+        self._set = set
+        self._until = until_date
+        self._from = from_date
+        self._verb = verb if not None else "ListRecords"
+        super().__init__(*args, **kwargs)
+
+    def _iter(self, scythe, *args, **kwargs):
+        """Read and parse an OAIPMH stream to dict."""
+
+        class OAIRecord(oaipmh_scythe.models.Record):
+            """An XML unpacking implementation for more complicated formats."""
+
+            def get_metadata(self):
+                """Extract and return the record's metadata as a dictionary."""
+                return xml_to_dict(
+                    self.xml.find(f".//{self._oai_namespace}metadata").getchildren()[0],
+                )
+
+        scythe.class_mapping["ListRecords"] = OAIRecord
+        try:
+            records = scythe.list_records(
+                from_=self._from,
+                until=self._until,
+                metadata_prefix=self._metadata_prefix,
+                set_=self._set,
+                ignore_deleted=True,
+            )
+            for record in records:
+                yield {"record": record}
+        except oaipmh_scythe.NoRecordsMatch:
+            raise ReaderError(f"No records found in OAI-PMH request.")
+
+    def read(self, item=None, *args, **kwargs):
+        """Reads from item or opens the file descriptor from origin."""
+        if item:
+            raise NotImplementedError(
+                "OAIPMHReader does not support being chained after another reader"
+            )
+        else:
+            with oaipmh_scythe.Scythe(self._base_url) as scythe:
+                yield from self._iter(scythe=scythe, *args, **kwargs)
+
+
+def xml_to_dict(tree: etree._Element):
+    """Convert an XML tree to a dictionary.
+
+    This function takes an XML element tree and converts it into a dictionary.
+
+    Args:
+        tree: The root element of the XML tree to be converted.
+
+    Returns:
+        A dictionary with the key "record".
+    """
+    dict_obj = dict()
+    dict_obj["record"] = etree.tostring(tree)
+
+    return dict_obj

invenio_vocabularies/datastreams/writers.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
@@ -103,6 +103,6 @@ class YamlWriter(BaseWriter):
         with open(self._filepath, "a") as file:
             # made into array for safer append
             # will always read array (good for reader)
-            yaml.safe_dump([stream_entry.entry], file)
+            yaml.safe_dump([stream_entry.entry], file, allow_unicode=True)
 
         return stream_entry

invenio_vocabularies/ext.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2020-2022 CERN.
+# Copyright (C) 2020-2024 CERN.
 # Copyright (C) 2023 Graz University of Technology.
 #
 # Invenio-Vocabularies is free software; you can redistribute it and/or
@@ -40,8 +40,14 @@ from .contrib.subjects import (
     SubjectsService,
     SubjectsServiceConfig,
 )
-from .resources.resource import VocabulariesResource
-from .services.service import VocabulariesService
+from .resources import (
+    VocabulariesAdminResource,
+    VocabulariesResource,
+    VocabulariesResourceConfig,
+    VocabularyTypeResourceConfig,
+)
+from .services.config import VocabularyTypesServiceConfig
+from .services.service import VocabulariesService, VocabularyTypeService
 
 
 class InvenioVocabularies(object):
@@ -76,6 +82,7 @@ class InvenioVocabularies(object):
             funders = FundersServiceConfig
             names = NamesServiceConfig
             subjects = SubjectsServiceConfig
+            vocabulary_types = VocabularyTypesServiceConfig
 
         return ServiceConfigs
 
@@ -93,9 +100,12 @@ class InvenioVocabularies(object):
         self.funders_service = FundersService(config=service_configs.funders)
         self.names_service = NamesService(config=service_configs.names)
         self.subjects_service = SubjectsService(config=service_configs.subjects)
-        self.service = VocabulariesService(
+        self.vocabularies_service = VocabulariesService(
             config=app.config["VOCABULARIES_SERVICE_CONFIG"],
         )
+        self.vocabulary_types_service = VocabularyTypeService(
+            config=service_configs.vocabulary_types
+        )
 
     def init_resource(self, app):
         """Initialize vocabulary resources."""
@@ -121,9 +131,13 @@ class InvenioVocabularies(object):
             config=SubjectsResourceConfig,
         )
         self.resource = VocabulariesResource(
-            service=self.service,
+            service=self.vocabularies_service,
             config=app.config["VOCABULARIES_RESOURCE_CONFIG"],
         )
+        self.vocabulary_admin_resource = VocabulariesAdminResource(
+            service=self.vocabulary_types_service,
+            config=VocabularyTypeResourceConfig,
+        )
 
 
 def finalize_app(app):
@@ -153,7 +167,8 @@ def init(app):
     sregistry.register(ext.funders_service, service_id="funders")
     sregistry.register(ext.names_service, service_id="names")
     sregistry.register(ext.subjects_service, service_id="subjects")
-    sregistry.register(ext.service, service_id="vocabularies")
+    sregistry.register(ext.vocabularies_service, service_id="vocabularies")
+    sregistry.register(ext.vocabulary_types_service, service_id="vocabulary-types")
     # Register indexers
     iregistry = app.extensions["invenio-indexer"].registry
     iregistry.register(ext.affiliations_service.indexer, indexer_id="affiliations")
@@ -161,4 +176,4 @@ def init(app):
     iregistry.register(ext.funders_service.indexer, indexer_id="funders")
     iregistry.register(ext.names_service.indexer, indexer_id="names")
     iregistry.register(ext.subjects_service.indexer, indexer_id="subjects")
-    iregistry.register(ext.service.indexer, indexer_id="vocabularies")
+    iregistry.register(ext.vocabularies_service.indexer, indexer_id="vocabularies")

invenio_vocabularies/factories.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2024 CERN.
+# Copyright (C) 2024 KTH Royal Institute of Technology.
+#
+# 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.
+"""Generate Vocabulary Config."""
+from copy import deepcopy
+
+import yaml
+from invenio_records_resources.proxies import current_service_registry
+
+from .contrib.affiliations.datastreams import (
+    DATASTREAM_CONFIG as affiliations_ds_config,
+)
+from .contrib.awards.datastreams import DATASTREAM_CONFIG as awards_ds_config
+from .contrib.funders.datastreams import DATASTREAM_CONFIG as funders_ds_config
+from .contrib.names.datastreams import DATASTREAM_CONFIG as names_ds_config
+
+
+class VocabularyConfig:
+    """Vocabulary Config Factory."""
+
+    config = None
+    vocabulary_name = None
+
+    def get_config(self, filepath=None, origin=None):
+        """Get the configuration for the vocabulary."""
+        config = deepcopy(self.config)
+        if filepath:
+            with open(filepath, encoding="utf-8") as f:
+                config = yaml.safe_load(f).get(self.vocabulary_name)
+        if origin:
+            config["readers"][0].setdefault("args", {})
+            config["readers"][0]["args"]["origin"] = origin
+        return config
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        return current_service_registry.get(self.vocabulary_name)
+
+
+class NamesVocabularyConfig(VocabularyConfig):
+    """Names Vocabulary Config."""
+
+    config = names_ds_config
+    vocabulary_name = "names"
+
+
+class FundersVocabularyConfig(VocabularyConfig):
+    """Funders Vocabulary Config."""
+
+    config = funders_ds_config
+    vocabulary_name = "funders"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for Funders")
+
+
+class AwardsVocabularyConfig(VocabularyConfig):
+    """Awards Vocabulary Config."""
+
+    config = awards_ds_config
+    vocabulary_name = "awards"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for Awards")
+
+
+class AffiliationsVocabularyConfig(VocabularyConfig):
+    """Affiliations Vocabulary Config."""
+
+    config = affiliations_ds_config
+    vocabulary_name = "affiliations"
+
+    def get_service(self):
+        """Get the service for the vocabulary."""
+        raise NotImplementedError("Service not implemented for Affiliations")
+
+
+def get_vocabulary_config(vocabulary):
+    """Factory function to get the appropriate Vocabulary Config."""
+    vocab_config = {
+        "names": NamesVocabularyConfig,
+        "funders": FundersVocabularyConfig,
+        "awards": AwardsVocabularyConfig,
+        "affiliations": AffiliationsVocabularyConfig,
+    }
+    return vocab_config.get(vocabulary, VocabularyConfig)()

invenio_vocabularies/proxies.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2021 CERN.
+# Copyright (C) 2021-2024 CERN.
 # Copyright (C) 2021 Northwestern University.
 #
 # Invenio-Vocabularies is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@ def _ext_proxy(attr):
     )
 
 
-current_service = _ext_proxy("service")
+current_service = _ext_proxy("vocabularies_service")
 """Proxy to the instantiated vocabulary service."""
 
 

invenio_vocabularies/records/jsonschemas/vocabularies/definitions-v1.0.0.json

@@ -10,5 +10,12 @@
   },
   "icon": {
     "type": "string"
+  },
+  "tags": {
+    "type": "array",
+    "description": "Tags for a vocabulary item.",
+    "items": {
+      "type": "string"
+    }
   }
 }

invenio_vocabularies/records/jsonschemas/vocabularies/vocabulary-v1.0.0.json

@@ -34,10 +34,7 @@
       }
     },
     "tags": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
+      "$ref": "local://vocabularies/definitions-v1.0.0.json#/tags"
     },
     "title": {
       "$ref": "local://vocabularies/definitions-v1.0.0.json#/title"

invenio_vocabularies/resources/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2020-2021 CERN.
+# Copyright (C) 2020-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
@@ -9,7 +9,14 @@
 """Resources module."""
 from invenio_vocabularies.resources.schema import L10NString, VocabularyL10Schema
 
+from .config import VocabulariesResourceConfig, VocabularyTypeResourceConfig
+from .resource import VocabulariesAdminResource, VocabulariesResource
+
 __all__ = (
     "VocabularyL10Schema",
     "L10NString",
+    "VocabulariesResourceConfig",
+    "VocabularyTypeResourceConfig",
+    "VocabulariesAdminResource",
+    "VocabulariesResource",
 )

invenio_vocabularies/resources/config.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2024 CERN.
+# Copyright (C) 2024 University of Münster.
+#
+# Invenio-Vocabularies is free software; you can redistringibute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+
+"""Resources config."""
+
+import marshmallow as ma
+from flask_resources import (
+    BaseListSchema,
+    HTTPJSONException,
+    JSONSerializer,
+    MarshmallowSerializer,
+    ResourceConfig,
+    ResponseHandler,
+    create_error_handler,
+)
+from invenio_records_resources.resources import (
+    RecordResource,
+    RecordResourceConfig,
+    SearchRequestArgsSchema,
+)
+from invenio_records_resources.resources.errors import ErrorHandlersMixin
+from invenio_records_resources.resources.records.args import SearchRequestArgsSchema
+from invenio_records_resources.resources.records.headers import etag_headers
+from invenio_records_resources.services.base.config import ConfiguratorMixin
+
+from .serializer import VocabularyL10NItemSchema
+
+
+class VocabularySearchRequestArgsSchema(SearchRequestArgsSchema):
+    """Vocabularies search request parameters."""
+
+    tags = ma.fields.Str()
+    active = ma.fields.Boolean()
+    status = ma.fields.Boolean()
+
+
+class VocabulariesResourceConfig(RecordResourceConfig):
+    """Vocabulary resource configuration."""
+
+    blueprint_name = "vocabularies"
+    url_prefix = "/vocabularies"
+    routes = {
+        "list": "/<type>",
+        "item": "/<type>/<pid_value>",
+        "tasks": "/tasks",
+    }
+
+    request_view_args = {
+        "pid_value": ma.fields.Str(),
+        "type": ma.fields.Str(required=True),
+    }
+
+    request_search_args = VocabularySearchRequestArgsSchema
+
+    response_handlers = {
+        "application/json": ResponseHandler(JSONSerializer(), headers=etag_headers),
+        "application/vnd.inveniordm.v1+json": ResponseHandler(
+            MarshmallowSerializer(
+                format_serializer_cls=JSONSerializer,
+                object_schema_cls=VocabularyL10NItemSchema,
+                list_schema_cls=BaseListSchema,
+            ),
+            headers=etag_headers,
+        ),
+    }
+
+
+class VocabularyTypeResourceConfig(ResourceConfig, ConfiguratorMixin):
+    """Vocabulary list resource config."""
+
+    # /vocabulary/vocabulary_id
+    # Blueprint configuration
+    blueprint_name = "vocabulary_types"
+    url_prefix = "/vocabularies"
+
+    routes = {"list": "/"}
+
+    # Request parsing
+    request_read_args = {}
+    request_view_args = {
+        "pid_value": ma.fields.String,
+        "type": ma.fields.String,
+    }
+    request_search_args = VocabularySearchRequestArgsSchema
+
+    error_handlers = {
+        **ErrorHandlersMixin.error_handlers,
+        # TODO: Add custom error handlers here
+    }
+    response_handlers = {
+        "application/json": ResponseHandler(JSONSerializer(), headers=etag_headers),
+        "application/vnd.inveniordm.v1+json": ResponseHandler(
+            MarshmallowSerializer(
+                format_serializer_cls=JSONSerializer,
+                object_schema_cls=VocabularyL10NItemSchema,
+                list_schema_cls=BaseListSchema,
+            ),
+            headers=etag_headers,
+        ),
+    }