oarepo-runtime 2.0.0.dev43__tar.gz → 2.0.0.dev45__tar.gz

{oarepo_runtime-2.0.0.dev43 → oarepo_runtime-2.0.0.dev45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oarepo-runtime
-Version: 2.0.0.dev43
+Version: 2.0.0.dev45
 Summary: A set of runtime extensions of Invenio repository
 Project-URL: Homepage, https://github.com/oarepo/oarepo-runtime
 License-Expression: MIT

{oarepo_runtime-2.0.0.dev43 → oarepo_runtime-2.0.0.dev45}/oarepo_runtime/__init__.py

@@ -19,6 +19,6 @@ from .api import Model
 from .ext import OARepoRuntime
 from .proxies import current_runtime
 
-__version__ = "2.0.0dev43"
+__version__ = "2.0.0dev45"
 
 __all__ = ("Model", "OARepoRuntime", "__version__", "current_runtime")

{oarepo_runtime-2.0.0.dev43 → oarepo_runtime-2.0.0.dev45}/oarepo_runtime/api.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import dataclasses
 from functools import cached_property
+from mimetypes import guess_extension
 from typing import TYPE_CHECKING, Any, cast
 
 from flask import current_app
@@ -93,6 +94,23 @@ class Export:
     description: LazyString | None = None
     """Description of the export format, human readable."""
 
+    extension: str | None = None
+    """Extension of the export format, used in the filename when downloading the export."""
+
+    def __post_init__(self):
+        """Post init with extension guessing."""
+        if self.extension is None:
+            extension = guess_extension(self.mimetype)
+            if not extension:
+                first, second = self.mimetype.rsplit("/", maxsplit=1)
+                second = second.rsplit("+", maxsplit=1)[-1]
+                mimetype = f"{first}/{second}"
+                if mimetype != self.mimetype:
+                    extension = guess_extension(mimetype)
+            self.extension = extension
+        if not self.extension:
+            self.extension = ".bin"
+
 
 @dataclasses.dataclass
 class Import:
@@ -399,6 +417,13 @@ class Model[
                 return export
         return None
 
+    def get_export_by_code(self, code: str) -> Export | None:
+        """Get an export by code."""
+        for export in self._exports:
+            if export.code == code:
+                return export
+        return None
+
     @property
     def response_handlers(self) -> dict[str, ResponseHandler]:
         """Get all response handlers from the resource configuration."""

{oarepo_runtime-2.0.0.dev43 → oarepo_runtime-2.0.0.dev45}/oarepo_runtime/ext.py

@@ -11,8 +11,10 @@
 
 from __future__ import annotations
 
+import json
+from enum import Enum
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
 
 from flask import current_app
 from invenio_db import db
@@ -20,6 +22,7 @@ from invenio_pidstore.errors import PIDDoesNotExistError
 from invenio_pidstore.models import PersistentIdentifier
 from invenio_records.api import Record as RecordBase
 from invenio_records_resources.proxies import current_service_registry
+from lxml.etree import fromstring
 
 from . import config
 
@@ -34,10 +37,19 @@ if TYPE_CHECKING:  # pragma: no cover
     from invenio_records_resources.services.base.service import Service
     from invenio_records_resources.services.files.service import FileService
     from invenio_records_resources.services.records import RecordService
+    from lxml.etree import Element
 
     from .api import Model
 
 
+class ExportRepresentation(Enum):
+    """Representation of the export, which can be response, dictionary or XML."""
+
+    RESPONSE = ("response",)  # Response
+    DICTIONARY = ("dictionary",)  # python dictionary
+    XML = ("xml",)  # XML Element
+
+
 class OARepoRuntime:
     """OARepo base of invenio oarepo client."""
 
@@ -226,3 +238,106 @@ class OARepoRuntime:
                 if draft_index is not None:
                     indices.add(draft_index.search_alias)
         return indices
+
+    @overload
+    def get_export_from_serialized_record(
+        self,
+        record_dict: dict,
+        representation: Literal[ExportRepresentation.RESPONSE],
+        export_code: str | None = None,
+        export_mimetype: str | None = None,
+    ) -> tuple[Any, int, dict[str, str]] | None: ...
+
+    @overload
+    def get_export_from_serialized_record(
+        self,
+        record_dict: dict,
+        representation: Literal[ExportRepresentation.DICTIONARY],
+        export_code: str | None = None,
+        export_mimetype: str | None = None,
+    ) -> dict: ...
+
+    @overload
+    def get_export_from_serialized_record(
+        self,
+        record_dict: dict,
+        representation: Literal[ExportRepresentation.XML],
+        export_code: str | None = None,
+        export_mimetype: str | None = None,
+    ) -> Element: ...
+
+    def get_export_from_serialized_record(
+        self,
+        record_dict: dict,
+        representation: Literal[
+            ExportRepresentation.RESPONSE, ExportRepresentation.DICTIONARY, ExportRepresentation.XML
+        ],
+        export_code: str | None = None,
+        export_mimetype: str | None = None,
+    ):
+        """Retrieve and prepare the export of a record item based on the specified parameters.
+
+        This function processes the input `record_item` and converts it to the appropriate
+        export format based on the `representation` and either `export_code` or `export_mimetype`.
+        It ensures strict constraints on input validity and raises errors when conditions
+        are violated.
+
+        Args:
+            record_dict: The record item serialized as a dictionary
+            representation: The desired output representation of the export. It must be one
+                of the defined values of `ExportRepresentation`.
+            export_code: The code representing the type of export to retrieve. Only one of
+                `export_code` or `export_mimetype` should be provided.
+            export_mimetype: The MIME type representing the type of export to retrieve. Only
+                one of `export_code` or `export_mimetype` should be provided.
+
+        Raises:
+            ValueError: Raised if both `export_code` and `export_mimetype` are None.
+            ValueError: Raised if both `export_code` and `export_mimetype` are provided
+                simultaneously.
+            ValueError: Raised if no export is found for the given `export_code` or
+                `export_mimetype`.
+
+        Returns:
+            Union[Tuple[str, int, dict], dict, etree._Element]: Depending on the `representation`
+            specified:
+                - If `ExportRepresentation.RESPONSE`, returns a tuple with the serialized export,
+                  HTTP status code (200), and the HTTP headers containing content type and
+                  disposition.
+                - If `ExportRepresentation.DICTIONARY`, returns a dictionary representation of
+                  the exported record item.
+                - If `ExportRepresentation.XML`, returns an XML element structure of the exported
+                  record.
+
+        """
+        model = self.models_by_schema[record_dict["$schema"]]
+        if export_mimetype:
+            if export_code is not None:
+                raise ValueError("Only one of the parameters export_code/export_mimetype must be set, both are set")
+            model_export = model.get_export_by_mimetype(mimetype=export_mimetype)
+        elif export_code:
+            model_export = model.get_export_by_code(code=export_code)
+        else:
+            raise ValueError("One of the parameters export_code/export_mimetype must be set, both are None")
+
+        if model_export is None:
+            raise ValueError("No export found for the given mimetype or code")
+
+        exported_record = model_export.serializer.serialize_object(record_dict)
+
+        match representation:
+            case ExportRepresentation.RESPONSE:
+                filename = f"{record_dict['id']}{model_export.extension}"
+                headers = {
+                    "Content-Type": model_export.mimetype,
+                    "Content-Disposition": f"attachment; filename={filename}",
+                }
+                return (exported_record, 200, headers)
+
+            case ExportRepresentation.DICTIONARY:
+                if isinstance(exported_record, str):
+                    exported_record = json.loads(exported_record)
+                return exported_record
+
+            case ExportRepresentation.XML:
+                return fromstring(exported_record)

{oarepo_runtime-2.0.0.dev43 → oarepo_runtime-2.0.0.dev45}/oarepo_runtime/resources/signposting/__init__.py

@@ -35,6 +35,7 @@ from urllib.parse import urljoin
 
 from signposting import AbsoluteURI, LinkRel, Signpost
 
+from oarepo_runtime.ext import ExportRepresentation
 from oarepo_runtime.proxies import current_runtime
 
 
@@ -277,9 +278,7 @@ def landing_page_signpost_links_list(datacite_dict: dict, record_dict: dict, sho
     model = current_runtime.models_by_schema[record_dict["$schema"]]
 
     # author - prvni tri
-    data = datacite_dict["data"]
-    attributes = data["attributes"]
-    creators = attributes.get("creators", [])
+    creators = datacite_dict.get("creators", [])
     if short:
         creators = creators[:3]
     for attribute in creators:
@@ -289,7 +288,9 @@ def landing_page_signpost_links_list(datacite_dict: dict, record_dict: dict, sho
         )
 
     # cite-as = DOI
-    signposting_links.append(Signpost(rel=LinkRel.cite_as, target=urljoin("https://doi.org/", attributes.get("doi"))))
+    signposting_links.append(
+        Signpost(rel=LinkRel.cite_as, target=urljoin("https://doi.org/", datacite_dict.get("doi")))
+    )
 
     # describedby
     for model_export in model.exports:
@@ -319,7 +320,7 @@ def landing_page_signpost_links_list(datacite_dict: dict, record_dict: dict, sho
         )
 
     # license
-    for attribute in attributes.get("rightsList"):
+    for attribute in datacite_dict.get("rightsList", []):
         # check for schemeUri, rightsIdentifier and 'rightsIdentifierScheme' == SPDX, fallback rightsUri, else nothing
         license_url = attribute.get("rightsUri")
         if (
@@ -331,7 +332,7 @@ def landing_page_signpost_links_list(datacite_dict: dict, record_dict: dict, sho
         signposting_links.append(Signpost(rel=LinkRel.license, target=license_url))
 
     # type
-    schema_org = attributes.get("types", {}).get("schemaOrg")
+    schema_org = datacite_dict.get("types", {}).get("schemaOrg")
     if schema_org:
         resource_type_url = "https://schema.org/" + schema_org
         signposting_links.append(Signpost(rel=LinkRel.type, target=resource_type_url))
@@ -342,19 +343,19 @@ def landing_page_signpost_links_list(datacite_dict: dict, record_dict: dict, sho
 
 def record_dict_to_linkset(record_dict: dict) -> str:
     """Create a linkset from the dictionary of a record item. Get datacite to build linkset from model exports."""
-    model = current_runtime.models_by_schema[record_dict["$schema"]]
-    datacite_export = model.get_export_by_mimetype("application/vnd.datacite.datacite+json")
-    if not datacite_export:
-        return ""
-    datacite_dict = datacite_export.serializer.serialize_object(record_dict)
+    datacite_dict = current_runtime.get_export_from_serialized_record(
+        record_dict=record_dict,
+        representation=ExportRepresentation.DICTIONARY,
+        export_mimetype="application/vnd.datacite.datacite+json",
+    )
     return create_linkset(datacite_dict, record_dict)
 
 
 def record_dict_to_json_linkset(record_dict: dict) -> dict[str, list[dict[str, Any]]]:
     """Create a JSON linkset from the dictionary of a record item. Get datacite to build linkset from model exports."""
-    model = current_runtime.models_by_schema[record_dict["$schema"]]
-    datacite_export = model.get_export_by_mimetype("application/vnd.datacite.datacite+json")
-    if not datacite_export:
-        return {}
-    datacite_dict = datacite_export.serializer.serialize_object(record_dict)
+    datacite_dict = current_runtime.get_export_from_serialized_record(
+        record_dict=record_dict,
+        representation=ExportRepresentation.DICTIONARY,
+        export_mimetype="application/vnd.datacite.datacite+json",
+    )
     return create_linkset_json(datacite_dict, record_dict)