oarepo-runtime 2.0.0.dev37__py3-none-any.whl → 2.0.0.dev39__py3-none-any.whl

oarepo_runtime/__init__.py

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

oarepo_runtime/api.py

@@ -153,6 +153,7 @@ class Model[
         model_metadata: ModelMetadata | None = None,
         features: Mapping[str, Any] | None = None,
         imports: list[Import] | None = None,
+        ui_blueprint_name: str | None = None,
     ):
         """Initialize the model configuration.
 
@@ -179,6 +180,7 @@ class Model[
         :param features: Features of the model. Filled by the feature presets themselves during registration.
         :param imports: List of import formats that can be used to import the record.
             If not provided, no imports are available.
+        :param ui_blueprint_name: Name of the UI blueprint
         """
         self._code = code
         self._name = name
@@ -203,6 +205,7 @@ class Model[
         self._imports = imports or []
         self._model_metadata = model_metadata
         self._features = features
+        self._ui_blueprint_name = ui_blueprint_name
 
     @property
     def code(self) -> str:
@@ -302,6 +305,11 @@ class Model[
         """Get the API blueprint name for the model."""
         return cast("str", self.resource_config.blueprint_name)
 
+    @property
+    def ui_blueprint_name(self) -> str | None:
+        """Get the API blueprint name for the model."""
+        return self._ui_blueprint_name
+
     @property
     def record_pid_type(self) -> str | None:
         """Get the PID type for the model."""
@@ -342,6 +350,12 @@ class Model[
         """Get the API URL for the model."""
         return cast("str", invenio_url_for(f"{self.api_blueprint_name}.{view_name}", **kwargs))
 
+    def ui_url(self, view_name: str, **kwargs: Any) -> str | None:
+        """Get the UI URL for the model."""
+        if self.ui_blueprint_name is None:
+            return None
+        return cast("str", invenio_url_for(f"{self.ui_blueprint_name}.{view_name}", **kwargs))
+
     @cached_property
     def resource_config(self) -> RC:
         """Get the resource configuration."""
@@ -374,6 +388,13 @@ class Model[
         """Get all exportable response handlers."""
         return self._exports
 
+    def get_export_by_mimetype(self, mimetype: str) -> Export | None:
+        """Get an export by mimetype."""
+        for export in self._exports:
+            if export.mimetype == mimetype:
+                return export
+        return None
+
     @property
     def response_handlers(self) -> dict[str, ResponseHandler]:
         """Get all response handlers from the resource configuration."""

oarepo_runtime/ext.py

@@ -177,6 +177,12 @@ class OARepoRuntime:
             raise ValueError("Need to pass a record instance, got None")
         return self.get_record_service_for_record_class(type(record))
 
+    def get_model_for_record(self, record: Any) -> Model:
+        """Retrieve the associated service for a given record."""
+        if record is None:
+            raise ValueError("Need to pass a record instance, got None")
+        return self.get_model_for_record_class(type(record))
+
     def get_file_service_for_record(self, record: Any) -> FileService | None:
         """Return the file service for the given record (draft or published)."""
         model = self.models_by_record_class.get(type(record))
@@ -188,13 +194,16 @@ class OARepoRuntime:
         return model.file_service
 
     def get_record_service_for_record_class(self, record_cls: type[RecordBase]) -> RecordService:
+        """Retrieve the service associated with a given record class."""
+        return self.get_model_for_record_class(record_cls).service
+
+    def get_model_for_record_class(self, record_cls: type[RecordBase]) -> Model:
         """Retrieve the service associated with a given record class."""
         for t in record_cls.mro():
             if t is RecordBase:
                 break
             if t in self.models_by_record_class:
-                model = self.models_by_record_class[t]
-                return model.service
+                return self.models_by_record_class[t]
         raise KeyError(f"No service found for record class '{record_cls.__name__}'.")
 
     @cached_property

oarepo_runtime/info/views.py

@@ -1,13 +1,12 @@
 #
 # Copyright (c) 2025 CESNET z.s.p.o.
 #
-# This file is a part of oarepo-runtime (see http://github.com/oarepo/oarepo-runtime).
+# This file is a part of oarepo-runtime (see https://github.com/oarepo/oarepo-runtime).
 #
 # oarepo-runtime is free software; you can redistribute it and/or modify it
 # under the terms of the MIT License; see LICENSE file for more details.
 #
-# TODO: better docstring
-"""Info Resource."""
+"""Resource for serving machine-readable information about the repository."""
 
 from __future__ import annotations
 

oarepo_runtime/records/systemfields/relations.py

@@ -0,0 +1,307 @@
+#
+# Copyright (c) 2025 CESNET z.s.p.o.
+#
+# This file is a part of oarepo-runtime (see https://github.com/oarepo/oarepo-runtime).
+#
+# oarepo-runtime is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+#
+"""A relation field that allows arbitrarily nested lists of relations."""
+
+from __future__ import annotations
+
+from itertools import zip_longest
+from typing import TYPE_CHECKING, Any, override
+
+from invenio_records.dictutils import dict_lookup, dict_set
+from invenio_records.systemfields.relations import (
+    InvalidRelationValue,
+    ListRelation,
+    RelationListResult,
+)
+from invenio_records_resources.records.systemfields.relations import (
+    PIDRelation,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+
+    from invenio_records.api import Record
+
+
+class ArbitraryNestedListResult(RelationListResult):
+    """Relation access result."""
+
+    @override
+    def __call__(self, force: bool = True):
+        """Resolve the relation."""
+        try:
+            # not as efficient as it could be as we create the list of lists first
+            # before returning the iterator, but simpler to implement
+            return iter(
+                _for_each_deep(
+                    self._lookup_data(),
+                    lambda v: self.resolve(v[self._value_key_suffix]),
+                    levels=len(self.field.path_elements),
+                )
+            )
+        except KeyError:
+            return None
+
+    def _lookup_data(self) -> Any:
+        """Lookup the data from the record."""
+
+        # recursively lookup the data following the path elements. The end of the path
+        # must always be an array of objects.
+        def _lookup(r: Any, paths: list[str]) -> Any:
+            if not paths:
+                if self.field.relation_field:
+                    try:
+                        return dict_lookup(r, self.field.relation_field)
+                    except KeyError:  # pragma: no cover
+                        return None
+                return r
+            try:
+                level_values = dict_lookup(r, paths[0])
+                if not isinstance(level_values, list):
+                    raise InvalidRelationValue(  # pragma: no cover
+                        f'Invalid structure, expecting list at "{paths[0]}", got {level_values}. '
+                        f'Complete paths: "{self.field.path_elements}"'
+                    )
+                ret = [_lookup(v, paths[1:]) for v in level_values]
+                return [v for v in ret if v is not None]
+            except KeyError:
+                return []
+
+        return _lookup(self.record, self.field.path_elements)
+
+    @override
+    def validate(self) -> None:
+        """Validate the field."""
+        try:
+            values = self._lookup_data()
+            # not as efficient as it could be as we create the list of lists first
+            # before returning, but simpler to implement
+            _for_each_deep(
+                values,
+                lambda v: self._validate_single_value(v),
+                levels=len(self.field.path_elements),
+            )
+        except KeyError:  # pragma: no cover
+            return
+
+    def _validate_single_value(self, v: Any) -> None:
+        """Validate a single value."""
+        if isinstance(v, list):
+            raise InvalidRelationValue(f"Invalid value {v}, should not be list.")
+        relation_id = self._lookup_id(v)
+        if not self.exists(relation_id):
+            raise InvalidRelationValue(f"Invalid value {relation_id}.")
+        if self.value_check:  # pragma: no cover # not testing, copied from invenio
+            obj = self.resolve(v[self.field._value_key_suffix])  # noqa: SLF001 # private attr
+            self._value_check(self.value_check, obj)
+
+    @override
+    def _apply_items(  # type: ignore[override]
+        self,
+        func: Callable,
+        keys: list[str] | None = None,
+        attrs: list[str] | None = None,
+    ) -> list[Any] | None:
+        """Iterate over the list of objects."""
+        # The attributes we want to get from the related record.
+        attrs = attrs or self.attrs
+        keys = keys or self.keys
+        try:
+            # Get the list of objects we have to dereference/clean.
+            values = self._lookup_data()
+            return _for_each_deep(
+                values,
+                lambda v: func(v, keys, attrs),
+                levels=len(self.field.path_elements),
+            )
+        except KeyError:  # pragma: no cover
+            return None
+
+
+class ArbitraryNestedListRelation(ListRelation):
+    """Arbitrary nested relation list type.
+
+    self.path_elements contain the segments of the path that are within lists.
+    For example:
+    - For paths like "a.b.c", path = [], relation_field="a.b.c"
+    - For paths like "a.b.0.c", path = ["a.b"], relation_field="c"
+    - For paths like "a.0.b.1.c", path = ["a", "b"], relation_field="c"
+    - For paths like "a.1", path = ["a"], relation_field=None
+
+    ids and values are stored as lists that can contain other lists arbitrarily nested.
+    The total depth of nesting is given by the length of self.path_elements + 1 if self.relation_field is not None
+    or length of self.path_elements if self.relation_field is None.
+    """
+
+    result_cls = ArbitraryNestedListResult
+
+    def __init__(
+        self,
+        *args: Any,
+        array_paths: list[str] | None = None,
+        relation_field: str | None = None,
+        **kwargs: Any,
+    ):
+        """Initialize the relation."""
+        if not array_paths:
+            raise ValueError("array_paths are required for ArbitraryNestedListRelation.")
+        self.path_elements = array_paths
+        super().__init__(*args, relation_field=relation_field, **kwargs)
+
+    @override
+    def exists_many(self, ids: Any) -> bool:  # type: ignore[override]
+        """Return True if all ids exists."""
+
+        # ids is a list that might recursively contain lists that contain ids
+        def flatten(nested_list: Any) -> Generator[Any]:
+            for item in nested_list:
+                if isinstance(item, (list, tuple)):
+                    yield from flatten(item)
+                else:
+                    yield item
+
+        return all(self.exists(i) for i in flatten(ids))
+
+    @override
+    def parse_value(self, value: list[Any] | tuple[Any]) -> list[Any]:  # type: ignore[override]
+        """Parse a record (or ID) to the ID to be stored."""
+        return _for_each_deep(value, lambda v: self._parse_single_value(v), levels=len(self.path_elements))
+
+    def _parse_single_value(self, value: Any) -> Any:
+        """Parse a single value using the parent class method.
+
+        Note: we are skipping the list's parse_value here and calling
+        the next one after ListRelation in mro chain. That might be, for example,
+        PIDRelation.parse_value
+        """
+        if self.relation_field:
+            try:
+                return super(ListRelation, self).parse_value(dict_lookup(value, self.relation_field))
+            except KeyError:  # pragma: no cover
+                return None
+        else:
+            return super(ListRelation, self).parse_value(value)
+
+    @override
+    def set_value(
+        self,
+        record: Record,
+        value: list[Any] | tuple[Any],
+    ) -> None:  # type: ignore[override]
+        """Set the relation value."""
+        store_values = self.parse_value(value)
+
+        if not self.exists_many(store_values):
+            raise InvalidRelationValue(f'One of the values "{store_values}" is invalid.')
+
+        total_depth = len(self.path_elements)
+
+        for path_indices, path_value in _deep_enumerate(store_values, total_depth):
+            r: Any = record
+            self._set_value_at_path(r, path_indices, {self._value_key_suffix: path_value})
+
+    def _set_value_at_path(self, r: Any, path_indices: list[int], path_value: Any) -> None:
+        """Set the value at the given path indices."""
+        pe = [
+            *self.path_elements,
+        ]
+        if self.relation_field:
+            pe.append(self.relation_field)
+
+        # pe might be 1 longer than path_indices, that's why we use zip_longest
+        zipped = list(zip_longest(pe, path_indices, fillvalue=None))
+        for idx, (subpath, index) in enumerate(zipped[:-1]):
+            if not subpath:
+                raise InvalidRelationValue(  # pragma: no cover
+                    f"Invalid structure, missing key at index {idx} in [{self.path_elements}, {path_indices}]."
+                )
+            if index is None:
+                raise InvalidRelationValue(  # pragma: no cover
+                    f"Invalid structure, missing index at {subpath} in [{self.path_elements}, {path_indices}]."
+                )
+            r = self._set_default_value_at_path(r, subpath, index, path_indices)
+
+        last_path, last_index = zipped[-1]
+        if last_path is None:  # pragma: no cover
+            raise InvalidRelationValue("Implementation error.")
+        if last_index is None:
+            # we have a relation_field at the end, so set it directly
+            dict_set(r, last_path, path_value)
+        else:
+            # no relation_field at the end, so we set the whole object at the index
+            try:
+                val = dict_lookup(r, last_path)
+            except KeyError:
+                val = []
+                dict_set(r, last_path, val)
+            if last_index < len(val):
+                val[last_index] = path_value
+            elif last_index == len(val):
+                val.append(path_value)
+            else:
+                raise InvalidRelationValue(  # pragma: no cover # just sanity check
+                    f"Invalid structure, missing index {last_index} "
+                    f"at {last_path} in [{self.path_elements}, {path_indices}]."
+                )
+
+    def _set_default_value_at_path(self, r: Any, subpath: str, index: int, path_indices: list[int]) -> Any:
+        """Set default value of [] at the given path if missing."""
+        # look up the subpath and create it if missing
+        try:
+            val = dict_lookup(r, subpath)
+        except KeyError:
+            dict_set(r, subpath, [])
+            val = dict_lookup(r, subpath)
+        if not isinstance(val, list):
+            raise InvalidRelationValue(  # pragma: no cover
+                f"Invalid structure, expecting list at {subpath} in [{self.path_elements}, {path_indices}]."
+            )
+
+        # now we have the array - if the index is within array, return the value at the index
+        if index < len(val):
+            return val[index]
+
+        # if the index is exactly at the end of the array, we can append a new default value,
+        # which is always an empty dict
+        if index == len(val):
+            # append new default value which is always empty dict
+            r = {}
+            val.append(r)
+            return r
+
+        # we can not skip indices, so if that would happen, raise error
+        raise InvalidRelationValue(  # pragma: no cover
+            f"Invalid structure, missing index {index} at {subpath} in [{self.path_elements}, {path_indices}]."
+        )
+
+
+def _deep_enumerate(nested_list: Any, max_depth: int, depth: int = 0) -> Generator[tuple[list[int], Any]]:
+    """Enumerate all non-list items in a nested list structure."""
+    for index, item in enumerate(nested_list):
+        current_path = [index]
+        if depth < max_depth - 1 and isinstance(item, (list, tuple)):
+            for sub_path, sub_item in _deep_enumerate(item, max_depth, depth + 1):
+                yield current_path + sub_path, sub_item
+        else:
+            yield current_path, item
+
+
+def _for_each_deep(nested_list: Any, func: Any, levels: int) -> list[Any]:
+    """Apply a function to each non-list item in a nested list structure."""
+    result = []
+    for item in nested_list:
+        if isinstance(item, (list, tuple)) and levels > 1:
+            result.append(_for_each_deep(item, func, levels=levels - 1))
+        else:
+            result.append(func(item))
+    return result
+
+
+class PIDArbitraryNestedListRelation(ArbitraryNestedListRelation, PIDRelation):  # type: ignore[override, misc]
+    """PID list relation type."""

oarepo_runtime/resources/signposting/__init__.py

@@ -0,0 +1,365 @@
+#
+# Copyright (c) 2025 CESNET z.s.p.o.
+#
+# This file is a part of oarepo-runtime (see http://github.com/oarepo/oarepo-runtime).
+#
+# oarepo-runtime is free software; you can redistribute it and/or modify it
+# under the terms of the MIT License; see LICENSE file for more details.
+#
+"""Signposting functionality.
+
+Functions to create a list of signpost links record's landing page, export formats and file contents.
+Separate functions to create a complete linkset for the record item in application/linkset or application/linkset+json format.
+Function to format the linkset into a HTTP Link header.
+
+Information about relation types can be found at: https://signposting.org/FAIR/#reltypes
+Excerpt with explanations about relation types:
+author 	        = The target of the link is a URI for an author of the resource that is the origin of the link.
+cite-as 	    = The target of the link is a persistent URI for the resource that is the origin of the link. When accessing the persistent URI, it redirects to that origin resource.
+describedby 	= The target of the link provides metadata that describes the resource that is the origin of the link. It is the inverse of the describes relation type.
+describes 	    = The origin of the link is a resource that provides metadata that describes the resource that is the target of the link. It is the inverse of the describedby relation type.
+type 	        = The target of the link is the URI for a class of resources to which the resource that is the origin of the link belongs.
+license 	    = The target of the link is the URI of a license that applies to the resource that is the origin of the link.
+item 	        = The origin of the link is a collection of resources and the target of the link is a resource that belongs to that collection. It is the inverse of the collection relation type.
+collection 	    = The origin of the link is a resource that belongs to a collection and the target of the link is the collection to which it belongs. It is the inverse of the item relation type.
+
+item <-> collection
+describedby <-> describes
+"""  # noqa: E501
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+from urllib.parse import urljoin
+
+if TYPE_CHECKING:
+    from invenio_records_resources.services.records.results import RecordItem
+from signposting import AbsoluteURI, LinkRel, Signpost
+
+from oarepo_runtime.proxies import current_runtime
+from oarepo_runtime.typing import record_from_result
+
+
+def signpost_link_to_str(signpost_link: Signpost) -> str:
+    """Convert a signpost link to string."""
+    link_str = str(signpost_link)
+    if link_str[:6] == "Link: ":
+        return f"{link_str[6:]}"
+    raise ValueError(f"Invalid signpost link: {link_str}")  # pragma: no cover
+
+
+def signpost_link_to_dict(link: Signpost) -> dict[str, Any]:
+    """Convert signpost link to a dictionary."""
+    link_dict: dict[str, Any] = {"href": link.target}
+    if link.type:
+        link_dict["type"] = link.type
+    return link_dict
+
+
+def signpost_link_to_additional_link(
+    link: Signpost, landing_page_url: str, as_dict: bool = True
+) -> Signpost | dict[str, Any] | None:
+    """Transform signpost link to additional link with inversed relation type..
+
+    Args:
+        link: A signpost link to transform
+        landing_page_url: landing page url which will be passed to href
+        as_dict: if true, return dict, else return Signpost
+
+    Returns: Additional link as dict or Signpost or None if relation type does no thave additional link.
+
+    """
+    match link.rel:
+        case LinkRel.item:
+            if as_dict:
+                return {
+                    "anchor": link.target,
+                    str(LinkRel.collection): [{"href": landing_page_url, "type": "text/html"}],
+                }
+            return Signpost(
+                rel=LinkRel.collection, target=landing_page_url, media_type="text/html", context=link.target
+            )
+        case LinkRel.describedby:
+            if as_dict:
+                return {
+                    "anchor": link.target,
+                    str(LinkRel.describes): [{"href": landing_page_url, "type": "text/html"}],
+                }
+            return Signpost(rel=LinkRel.describes, target=landing_page_url, media_type="text/html", context=link.target)
+        case LinkRel.cite_as:
+            return None
+        # anchor is generated only for item & describedby, not for license
+        case _:
+            return None
+
+
+def anchor_signpost_link(signpost_link: Signpost, anchor_url: str) -> Signpost:
+    """Add anchor to a signpost link."""
+    signpost_link.context = AbsoluteURI(anchor_url)
+    return signpost_link
+
+
+@overload
+def get_additional_links(
+    list_of_signpost_links: list[Signpost], landing_page_url: str, as_dict: Literal[True] = True
+) -> list[dict[str, Any]]: ...
+
+
+@overload
+def get_additional_links(
+    list_of_signpost_links: list[Signpost], landing_page_url: str, as_dict: Literal[False]
+) -> list[Signpost]: ...
+
+
+def get_additional_links(
+    list_of_signpost_links: list[Signpost], landing_page_url: str, as_dict: bool = True
+) -> list[Signpost] | list[dict[str, Any]]:
+    """Create a list of additional links from a list of signpost links.
+
+    Args:
+        list_of_signpost_links: list of signpost link objects to be formatted
+        landing_page_url: landing page url
+        as_dict: if true, return a list of signpost link dicts, else return a list of Signpost link objects
+    Returns: list of signpost link dicts or list of Signpost link objects
+
+    """
+    results = [
+        result
+        for signpost_link in list_of_signpost_links
+        if (
+            result := signpost_link_to_additional_link(
+                link=signpost_link, landing_page_url=landing_page_url, as_dict=as_dict
+            )
+        )
+        is not None
+    ]
+    if as_dict:
+        return cast("list[dict[str, Any]]", results)
+    return cast("list[Signpost]", results)
+
+
+def list_of_signpost_links_to_http_header(links_list: list[Signpost]) -> str:
+    """Create an HTTP Link header from a list of signpost links.
+
+    Args:
+        links_list: list of signpost link objects to be formatted
+
+    Returns: signpost header with formatted links.
+
+    """
+    links = [str(link)[6:] for link in links_list if str(link)[:6] == "Link: "]
+    return f"Link: {', '.join(links)}"
+
+
+def create_linkset(datacite_dict: dict, record_item: RecordItem) -> str:
+    """Create a linkset for the record item in the application/linkset format.
+
+    Args:
+        datacite_dict:  dictionary with datacite data
+        record_item: record item, for which signpost links should be generated
+
+    Returns: linkset in string format
+
+    """
+    landing_page_url = record_item.links.get("self_html")
+    # just sanity check, we don't expect this to happen, not covered in tests
+    if not landing_page_url:  # pragma: no cover
+        return ""
+    landing_page_links = landing_page_signpost_links_list(datacite_dict, record_item, short=False)
+    additional_links: list[Signpost] = get_additional_links(landing_page_links, landing_page_url, as_dict=False)
+    anchored_links = [
+        anchor_signpost_link(signpost_link, landing_page_url) for signpost_link in landing_page_links
+    ] + additional_links
+    links = [str(link)[6:] for link in anchored_links if str(link)[:6] == "Link: "]
+    return ", ".join(links)
+
+
+def create_linkset_json(datacite_dict: dict, record_item: RecordItem) -> dict[str, list[dict[str, Any]]]:
+    """Create a linkset for the record item in the application/linkset+json format.
+
+    Args:
+        datacite_dict:  dictionary with datacite data
+        record_item: record item, for which signpost links should be generated
+
+    Returns: linkset in JSON format
+
+    """
+    landing_page_url = record_item.links.get("self_html")
+    # just sanity check, we don't expect this to happen, not covered in tests
+    if not landing_page_url:  # pragma: no cover
+        return {}
+    landing_page_links = landing_page_signpost_links_list(datacite_dict, record_item, short=False)
+    dict_of_links_by_relation = defaultdict(list)
+    for link in landing_page_links:
+        dict_of_links_by_relation[str(link.rel)].append(link)
+    links_json = defaultdict(list)
+    links_json["anchor"] = landing_page_url
+
+    additional_links: list[dict[str, Any]] = get_additional_links(landing_page_links, landing_page_url)
+    for link_relation_from_dict, list_of_links_for_relation in dict_of_links_by_relation.items():
+        for link in list_of_links_for_relation:
+            links_json[link_relation_from_dict].append(signpost_link_to_dict(link))
+
+    return {"linkset": [dict(links_json), *[x for x in additional_links if x]]}
+
+
+def file_content_signpost_links_list(record_item: RecordItem) -> list[Signpost]:
+    """Create a list of signpost links for the file content of the record item.
+
+    Args:
+        record_item: record item with the file to generate a signpost link for
+
+    Returns: list with the signpost link for the file content
+
+    """
+    record = record_from_result(record_item)
+    model = current_runtime.get_model_for_record(record)
+    landing_page_url = model.ui_url(view_name="record_detail", pid_value=record.pid.pid_value)
+    if not landing_page_url:  # pragma: no cover
+        return []
+    return [
+        Signpost(
+            rel=LinkRel.linkset,
+            target=landing_page_url,
+            media_type="application/linkset",
+        ),
+        Signpost(
+            rel=LinkRel.linkset,
+            target=landing_page_url,
+            media_type="application/linkset+json",
+        ),
+        Signpost(
+            rel=LinkRel.collection,
+            target=landing_page_url,
+            media_type="text/html",
+        ),
+    ]
+
+
+def export_format_signpost_links_list(record_item: RecordItem) -> list[Signpost]:
+    """Create a list of signpost links for the export format of the record item.
+
+    Args:
+    record_item: record item with the export format to generate a signpost link for
+    code: code of the export format
+
+    Returns: list with the signpost link for the export format
+
+    """
+    return [
+        Signpost(
+            rel=LinkRel.linkset,
+            target=record_item.links["self_html"],
+            media_type="application/linkset",
+        ),
+        Signpost(
+            rel=LinkRel.linkset,
+            target=record_item.links["self_html"],
+            media_type="application/linkset+json",
+        ),
+        Signpost(rel=LinkRel.describes, target=record_item.links["self_html"], media_type="text/html"),
+    ]
+
+
+def landing_page_signpost_links_list(datacite_dict: dict, record_item: RecordItem, short: bool) -> list[Signpost]:
+    """Create a list of signpost links for the landing page of the record item.
+
+    Args:
+        datacite_dict: dictionary with datacite data
+        record_item: record item, for which signpost links should be generated
+        short: If true, lists only the first three links for relations with greater count
+
+    Returns: list of signpost links for the landing page
+
+    """
+    signposting_links: list[Signpost] = []
+    record = record_from_result(record_item)
+    record_data = record_item.data  # self.html
+    record_files = record_data.get("files", {}).get("entries", {})
+    model = current_runtime.get_model_for_record(record)
+
+    # author - prvni tri
+    data = datacite_dict["data"]
+    attributes = data["attributes"]
+    creators = attributes.get("creators", [])
+    if short:
+        creators = creators[:3]
+    for attribute in creators:
+        signposting_links.extend(
+            Signpost(rel=LinkRel.author, target=name_identifier["nameIdentifier"])
+            for name_identifier in attribute["nameIdentifiers"]
+        )
+
+    # cite-as = DOI
+    signposting_links.append(Signpost(rel=LinkRel.cite_as, target=urljoin("https://doi.org/", attributes.get("doi"))))
+
+    # describedby
+    for model_export in model.exports:
+        model_export_url = model.ui_url(
+            view_name="export", pid_value=record.pid.pid_value, export_format=model_export.code
+        )
+        # just sanity check, we don't expect this to happen, not covered in tests
+        if not model_export_url:  # pragma: no cover
+            continue
+        signposting_links.append(
+            Signpost(rel=LinkRel.describedby, target=model_export_url, media_type=model_export.mimetype)
+        )
+
+    # item
+    record_file_values = record_files.values()
+    if short:
+        record_file_values = list(record_file_values)[:3]
+    record_files_url = record_item.links.get("files")
+    if record_files_url:
+        signposting_links.extend(
+            Signpost(
+                rel=LinkRel.item,
+                media_type=record_file.get("mimetype"),
+                target=f"{record_files_url}/{record_file.get('key')}",
+            )
+            for record_file in record_file_values
+        )
+
+    # license
+    for attribute in attributes.get("rightsList"):
+        # check for schemeUri, rightsIdentifier and 'rightsIdentifierScheme' == SPDX, fallback rightsUri, else nothing
+        license_url = attribute.get("rightsUri")
+        if (
+            attribute.get("schemeUri")
+            and attribute.get("rightsIdentifier")
+            and attribute.get("rightsIdentifierScheme") == "SPDX"
+        ):
+            license_url = urljoin(attribute.get("schemeUri"), attribute.get("rightsIdentifier"))
+        signposting_links.append(Signpost(rel=LinkRel.license, target=license_url))
+
+    # type
+    schema_org = attributes.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))
+    signposting_links.append(Signpost(rel=LinkRel.type, target="https://schema.org/AboutPage"))
+
+    return signposting_links
+
+
+def record_to_linkset(record_item: RecordItem) -> str:
+    """Create a linkset from the record item. Get datacite to build linkset from model exports."""
+    record = record_from_result(record_item)
+    model = current_runtime.get_model_for_record(record)
+    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)
+    return create_linkset(datacite_dict, record_item)
+
+
+def record_to_json_linkset(record_item: RecordItem) -> dict[str, list[dict[str, Any]]]:
+    """Create a JSON linkset from the record item. Get datacite to build linkset from model exports."""
+    record = record_from_result(record_item)
+    model = current_runtime.get_model_for_record(record)
+    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)
+    return create_linkset_json(datacite_dict, record_item)

{oarepo_runtime-2.0.0.dev37.dist-info → oarepo_runtime-2.0.0.dev39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oarepo-runtime
-Version: 2.0.0.dev37
+Version: 2.0.0.dev39
 Summary: A set of runtime extensions of Invenio repository
 Project-URL: Homepage, https://github.com/oarepo/oarepo-runtime
 License-Expression: MIT
@@ -9,6 +9,7 @@ Requires-Python: <3.14,>=3.13
 Requires-Dist: langcodes>=3.5.0
 Requires-Dist: oarepo-invenio-typing-stubs>=0.1.0
 Requires-Dist: oarepo[rdm,tests]<15,>=14
+Requires-Dist: signposting>=0.9.9
 Provides-Extra: dev
 Requires-Dist: pytest>=7.1.2; extra == 'dev'
 Provides-Extra: oarepo14

{oarepo_runtime-2.0.0.dev37.dist-info → oarepo_runtime-2.0.0.dev39.dist-info}/RECORD

@@ -1,14 +1,14 @@
-oarepo_runtime/__init__.py,sha256=JR0f1Ihyrg0u3il_AHkGxW24pISnxnXHCilb58xIoWM,686
-oarepo_runtime/api.py,sha256=6AHyFnf0Cg1nfhGaQFMPjynVvrp1UURo8vX5vb5LvC4,14169
+oarepo_runtime/__init__.py,sha256=Hq07N9-oKqUJGYTjwG4TvOXZT2Usdd3GJ-ySd7Y3Wrw,686
+oarepo_runtime/api.py,sha256=hEYmBbqxk0DRfLGikSx4NMMmyDYxUKRAVP1z678iIOw,15000
 oarepo_runtime/config.py,sha256=RUEPFn_5bKp9Wb0OY-Fb3VK30m35vF5IsLjYaQHhP3g,3838
-oarepo_runtime/ext.py,sha256=hA_OmJJHum6W28iPkjxvFrKHzFwi_Ki_0Fy2Mgzl7UQ,8851
+oarepo_runtime/ext.py,sha256=OdhT4gGKK2LpNcJ30cHndCxWZgeHdAk1Ev8bISeX8Qk,9321
 oarepo_runtime/proxies.py,sha256=x8Y1iTP8QIzSI67s90VR0_5fvXuT1xlJXtAHsaoXFwg,903
 oarepo_runtime/py.typed,sha256=RznSCjXReEUI9zkmD25E8XniG_MvPpLBF6MyNZA8MmE,42
 oarepo_runtime/typing.py,sha256=VtINHm4BZ5OJ4KdRAwnFXPZiAEgPRIYTtPC9fIzK1bU,1876
 oarepo_runtime/cli/__init__.py,sha256=H7GOeOBf0udgKWOdlAQswIMvRrD8BwcEjOVxIqP0Suw,731
 oarepo_runtime/cli/search.py,sha256=4fHkrjltUUPVUzJiuWaiWxTk62rIYxal3_3jRsZVMmI,1175
 oarepo_runtime/info/__init__.py,sha256=qRG3mSyoiw7sKm9StiuBJs6l15HrdAQ4sphsAQsJtQc,336
-oarepo_runtime/info/views.py,sha256=JwESs-KVq163OBeqWVwfy0RU4WXR_MBolVR7W-dGtm0,16954
+oarepo_runtime/info/views.py,sha256=ObeRjbuH5_eKMOkVfT3O5EhPLIQ0HuCLD3fXSEv2z7U,16987
 oarepo_runtime/records/__init__.py,sha256=AbWzmVCY7MhrpdEeI0e3lKzeugPMUSo8T08-NBVeig4,339
 oarepo_runtime/records/drafts.py,sha256=b45ROjd9lwy6ratrpAruimcKvQmJradk5JgILoBAHmY,1965
 oarepo_runtime/records/mapping.py,sha256=fn6M208axxBqHtRV6qKQukwUw1z0hq_KF4qfuB2rr98,2630
@@ -18,9 +18,11 @@ oarepo_runtime/records/systemfields/base.py,sha256=EWSdVsWePkdwksRQ9yaMMk9Mrhicw
 oarepo_runtime/records/systemfields/custom_fields.py,sha256=PEoaCEnvanysFQAaqTtD9-VwaBmnFkoP2pmpCl9ZFfI,2237
 oarepo_runtime/records/systemfields/mapping.py,sha256=GcNp_-Ho3G8nk4-SXgoWWk_IPdGsM0LZ-DBl5fnYJvE,1699
 oarepo_runtime/records/systemfields/publication_status.py,sha256=5D8L_-Wsf-Or-Er7EhuOnwzXfGY28TRPTg1XmMEKxM8,1995
+oarepo_runtime/records/systemfields/relations.py,sha256=EyFTpdglkRCeCtNg3lXTh3H2_F3zTTjttjMQmuwt1M0,12240
 oarepo_runtime/records/systemfields/selectors.py,sha256=ijVDwAXaXTV5NtcXsrALkhddgCogLNe2eEscFr23qyg,1656
 oarepo_runtime/resources/__init__.py,sha256=voynQULXoOEviADkbOpekMphZPTAz4IOTg5BF9xPwTM,453
 oarepo_runtime/resources/config.py,sha256=Lbx1QPWAJ8z1truhYntbnhGGWp2OCcwqKm6BuvPJNT0,1330
+oarepo_runtime/resources/signposting/__init__.py,sha256=USztM57sVm1LWxACxt6o8cy3VZS0Kz-MYrjG8Jm-Ock,14959
 oarepo_runtime/services/__init__.py,sha256=OGtBgEeaDTyk2RPDNXuKbU9_7egFBZr42SM0gN5FrF4,341
 oarepo_runtime/services/generators.py,sha256=8Z2QGzob4c2vaaNqhcMZsRybmwtOt30Plgf3EFmcJXw,4622
 oarepo_runtime/services/results.py,sha256=EwMW1ed7u6uozgOLZpFa07-NKC89hJlHaVSD8-D5ibU,7211
@@ -42,8 +44,8 @@ oarepo_runtime/services/schema/__init__.py,sha256=jgAPI_uKC6Ug4KQWnwQVg3-aNaw-eH
 oarepo_runtime/services/schema/i18n.py,sha256=9D1zOQaPKAnYzejB0vO-m2BJYnam0N0Lrq4jID7twfE,3174
 oarepo_runtime/services/schema/i18n_ui.py,sha256=DbusphhGDeaobTt4nuwNgKZ6Houlu4Sv3SuMGkdjRRY,3582
 oarepo_runtime/services/schema/ui.py,sha256=Y_jBO-fowkpOgceWz8aqJSJAUiAnKLGSIuNpjNLnp8Q,4612
-oarepo_runtime-2.0.0.dev37.dist-info/METADATA,sha256=6Cl9JNhk5K76z8S6JfwJcPywCOVmedvqjbme6kv7PIc,4626
-oarepo_runtime-2.0.0.dev37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-oarepo_runtime-2.0.0.dev37.dist-info/entry_points.txt,sha256=rOfs8R1oXFN_dLH9zAZ6ydkvr83mDajegc6NBIRsCMQ,318
-oarepo_runtime-2.0.0.dev37.dist-info/licenses/LICENSE,sha256=h2uWz0OaB3EN-J1ImdGJZzc7yvfQjvHVYdUhQ-H7ypY,1064
-oarepo_runtime-2.0.0.dev37.dist-info/RECORD,,
+oarepo_runtime-2.0.0.dev39.dist-info/METADATA,sha256=yqEwOh9uNtI0K20bSvj-GDXDZJjhZj8comcClUjJaPA,4660
+oarepo_runtime-2.0.0.dev39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+oarepo_runtime-2.0.0.dev39.dist-info/entry_points.txt,sha256=rOfs8R1oXFN_dLH9zAZ6ydkvr83mDajegc6NBIRsCMQ,318
+oarepo_runtime-2.0.0.dev39.dist-info/licenses/LICENSE,sha256=h2uWz0OaB3EN-J1ImdGJZzc7yvfQjvHVYdUhQ-H7ypY,1064
+oarepo_runtime-2.0.0.dev39.dist-info/RECORD,,