oarepo-runtime 1.10.2__py3-none-any.whl → 2.0.0.dev3__py3-none-any.whl

oarepo_runtime/services/records/__init__.py

@@ -1,3 +1,16 @@
+#
+# 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.
+#
+
+"""Service records module."""
+
+from __future__ import annotations
+
 from .links import pagination_links_html
 
-__all__ = ("pagination_links_html",)
+__all__ = ("pagination_links_html",)

oarepo_runtime/services/records/links.py

@@ -1,21 +1,31 @@
+#
+# 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.
+#
+
+"""Utility for rendering URI template links."""
+
+from __future__ import annotations
+
 from invenio_records_resources.services.base.links import Link
 
-def pagination_links_html(tpl: str)->dict[str, Link]:
-    """Create pagination links (prev/selv/next) from the same template."""
+
+def pagination_links_html(tpl: str) -> dict[str, Link]:
+    """Create pagination links (prev/self/next) from the same template."""
     return {
         "prev_html": Link(
             tpl,
-            when=lambda pagination, ctx: pagination.has_prev,
-            vars=lambda pagination, vars: vars["args"].update(
-                {"page": pagination.prev_page.page}
-            ),
+            when=lambda pagination, _context: pagination.has_prev,
+            vars=lambda pagination, variables: variables["args"].update({"page": pagination.prev_page.page}),
         ),
         "self_html": Link(tpl),
         "next_html": Link(
             tpl,
-            when=lambda pagination, ctx: pagination.has_next,
-            vars=lambda pagination, vars: vars["args"].update(
-                {"page": pagination.next_page.page}
-            ),
+            when=lambda pagination, _context: pagination.has_next,
+            vars=lambda pagination, variables: variables["args"].update({"page": pagination.next_page.page}),
         ),
-    }
+    }

oarepo_runtime/services/records/mapping.py

@@ -0,0 +1,42 @@
+#
+# 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.
+#
+"""Update mappings for all record classes in the service registry."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from invenio_records_resources.services.records import (
+    RecordService,
+    RecordServiceConfig,
+)
+
+from oarepo_runtime import current_runtime
+from oarepo_runtime.records.mapping import update_record_system_fields_mapping
+
+if TYPE_CHECKING:
+    from invenio_records_resources.services.base import Service
+
+
+def update_all_records_mappings() -> None:
+    """Update all mappings for the registered record classes."""
+    service: Service
+    for service in current_runtime.services.values():
+        if not isinstance(service, RecordService):
+            continue
+
+        config: RecordServiceConfig = service.config
+
+        record_class = getattr(config, "record_cls", None)
+        if record_class:
+            update_record_system_fields_mapping(record_class)
+
+        draft_class = getattr(config, "draft_cls", None)
+        if draft_class:
+            update_record_system_fields_mapping(draft_class)

oarepo_runtime/services/results.py

@@ -1,5 +1,21 @@
+#
+# 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.
+#
+
+"""Service results."""
+
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING, Any
 
+from invenio_access.permissions import Identity
+from invenio_records.api import RecordBase
 from invenio_records_resources.errors import _iter_errors_dict
 from invenio_records_resources.services.records.results import (
     RecordItem as BaseRecordItem,
@@ -8,26 +24,50 @@ from invenio_records_resources.services.records.results import (
     RecordList as BaseRecordList,
 )
 
+if TYPE_CHECKING:
+    from invenio_access.permissions import Identity
+    from invenio_records.api import RecordBase
+
 log = logging.getLogger(__name__)
 
 
-class ResultsComponent:
-    def update_data(self, identity, record, projection, expand):
-        raise NotImplementedError
+class ResultComponent:
+    """Base class for result components that can modify the serialized record data."""
+
+    def __init__(
+        self,
+        record_item: BaseRecordItem | None = None,
+        record_list: BaseRecordList | None = None,
+    ):
+        """Initialize the result component."""
+        self._record_item = record_item
+        self._record_list = record_list
+
+    def update_data(self, identity: Identity, record: RecordBase, projection: dict, expand: bool) -> None:
+        """Update the projection data with additional information.
+
+        :param identity: The identity of the user making the request.
+        :param record: The record being processed.
+        :param projection: The current projection of the record.
+        :param expand: Whether to expand the record data.
+        """
+        raise NotImplementedError  # pragma: no cover
 
 
 class RecordItem(BaseRecordItem):
     """Single record result."""
 
-    components = []
+    components: tuple[type[ResultComponent], ...] = ()
+    """A list of components that can modify the serialized record data."""
 
     @property
-    def data(self):
+    def data(self) -> Any:
+        """Property to get the record."""
         if self._data:
             return self._data
         _data = super().data
         for c in self.components:
-            c.update_data(
+            c(record_item=self).update_data(
                 identity=self._identity,
                 record=self._record,
                 projection=_data,
@@ -36,57 +76,55 @@ class RecordItem(BaseRecordItem):
         return _data
 
     @property
-    def errors(self):
-        return postprocess_errors(self._errors)
+    def errors(self) -> list[dict]:
+        """Get the processed errors."""
+        return self.postprocess_errors(self._errors or [])
 
-    def to_dict(self):
+    def to_dict(self) -> Any:
         """Get a dictionary for the record."""
         res = self.data
         if self._errors:
             res["errors"] = self.errors
         return res
 
-
-def postprocess_error_messages(field_path: str, messages: any):
-    """Postprocess error messages, looking for those that were not correctly processed by marshmallow/invenio."""
-    if not isinstance(messages, list):
-        yield {"field": field_path, "messages": messages}
-    else:
-        str_messages = [msg for msg in messages if isinstance(msg, str)]
-        non_str_messages = [msg for msg in messages if not isinstance(msg, str)]
-
-        if str_messages:
-            yield {"field": field_path, "messages": str_messages}
-        else:
-            for non_str_msg in non_str_messages:
-                yield from _iter_errors_dict(non_str_msg, field_path)
-
-
-def postprocess_errors(errors: list[dict]):
-    """Postprocess errors."""
-    converted_errors = []
-    for error in errors:
-        if error.get("messages"):
-            converted_errors.extend(
-                postprocess_error_messages(error["field"], error["messages"])
-            )
+    def postprocess_error_messages(self, field_path: str, messages: Any) -> Any:
+        """Postprocess error messages, looking for those that were not correctly processed by marshmallow/invenio."""
+        if not isinstance(messages, list):
+            yield {"field": field_path, "messages": messages}
         else:
-            converted_errors.append(error)
-    return converted_errors
+            str_messages = [msg for msg in messages if isinstance(msg, str)]
+            non_str_messages = [msg for msg in messages if not isinstance(msg, str)]
+
+            if str_messages:
+                yield {"field": field_path, "messages": str_messages}
+            else:
+                for non_str_msg in non_str_messages:
+                    yield from _iter_errors_dict(non_str_msg, field_path)
+
+    def postprocess_errors(self, errors: list[dict]) -> list[dict]:
+        """Postprocess errors."""
+        converted_errors = []
+        for error in errors:
+            if error.get("messages"):
+                converted_errors.extend(self.postprocess_error_messages(error["field"], error["messages"]))
+            else:
+                converted_errors.append(error)
+        return converted_errors
 
 
 class RecordList(BaseRecordList):
-    components = []
+    """List of records result."""
+
+    components: tuple[type[ResultComponent], ...] = ()
 
     @property
-    def aggregations(self):
+    def aggregations(self) -> Any:
         """Get the search result aggregations."""
         try:
             result = super().aggregations
             if result is None:
-                return result
-
-            for key in result.keys():
+                return result  # pragma: no cover
+            for key in result:
                 if "buckets" in result[key]:
                     for bucket in result[key]["buckets"]:
                         val = bucket["key"]
@@ -96,12 +134,12 @@ class RecordList(BaseRecordList):
                             bucket["key"] = str(val)
                         if not isinstance(label, str):
                             bucket["label"] = str(label)
-            return result
-        except AttributeError:
-            return None
+        except AttributeError:  # pragma: no cover
+            return None  # pragma: no cover
+        return result
 
     @property
-    def hits(self):
+    def hits(self) -> Any:
         """Iterator over the hits."""
         for hit in self._results:
             # Load dump
@@ -109,87 +147,38 @@ class RecordList(BaseRecordList):
 
             try:
                 # Project the record
-                if hit_dict.get("record_status") == "draft":
+                # TODO: check if this logic is correct
+                versions = hit_dict.get("versions", {})
+                if versions.get("is_latest_draft") and not versions.get("is_latest"):
                     record = self._service.draft_cls.loads(hit_dict)
                 else:
                     record = self._service.record_cls.loads(hit_dict)
 
                 projection = self._schema.dump(
                     record,
-                    context=dict(
-                        identity=self._identity,
-                        record=record,
-                    ),
+                    context={
+                        "identity": self._identity,
+                        "record": record,
+                    },
                 )
                 if hasattr(self._service.config, "links_search_item"):
-                    links_tpl = self._service.config.search_item_links_template(
-                        self._service.config.links_search_item
-                    )
+                    links_tpl = self._service.config.search_item_links_template(self._service.config.links_search_item)
+                else:
+                    links_tpl = self._links_item_tpl
+
+                if links_tpl:
                     projection["links"] = links_tpl.expand(self._identity, record)
-                elif self._links_item_tpl:
-                    projection["links"] = self._links_item_tpl.expand(
-                        self._identity, record
-                    )
-                # todo optimization viz FieldsResolver
+
+                # TODO: optimization viz FieldsResolver
                 for c in self.components:
-                    c.update_data(
+                    c(record_list=self).update_data(
                         identity=self._identity,
                         record=record,
                         projection=projection,
                         expand=self._expand,
                     )
                 yield projection
-            except Exception:
+            except Exception:  # pragma: no cover
                 # ignore record with error, put it to log so that it gets to glitchtip
                 # but don't break the whole search
                 log.exception("Error while dumping record %s", hit_dict)
-
-
-class ArrayRecordItem(RecordItem):
-    """Single record result."""
-
-    @property
-    def id(self):
-        """Get the record id."""
-        return self._record["id"]
-
-
-class ArrayRecordList(RecordList):
-    # move to runtime
-
-    @property
-    def total(self):
-        """Get total number of hits."""
-        return len(self._results)
-
-    @property
-    def aggregations(self):
-        """Get the search result aggregations."""
-        return None
-
-    @property
-    def hits(self):
-        """Iterator over the hits."""
-        for hit in self._results:
-            # Project the record
-            projection = self._schema.dump(
-                hit,
-                context=dict(
-                    identity=self._identity,
-                    record=hit,
-                ),
-            )
-            if self._links_item_tpl:
-                projection["links"] = self._links_item_tpl.expand(self._identity, hit)
-            if self._nested_links_item:
-                for link in self._nested_links_item:
-                    link.expand(self._identity, hit, projection)
-
-            for c in self.components:
-                c.update_data(
-                    identity=self._identity,
-                    record=hit,
-                    projection=projection,
-                    expand=self._expand,
-                )
-            yield projection

oarepo_runtime/services/schema/__init__.py

@@ -1,44 +1,12 @@
-from .polymorphic import PolymorphicSchema
-
-
-def consistent_resolution(*classes):
-    """
-    A helper function to solve resolution order of classes.
-    If the classes are in a correct mro order, it will return
-    them in the same order. Otherwise it will try to reorder
-    them and remove those that are already contained in mro
-    of others.
-    """
-
-    # remove classes that are already in mro of others
-    filtered_classes = []
-    for cls in classes:
-        for other_cls in classes:
-            if cls != other_cls and issubclass(other_cls, cls):
-                break
-        else:
-            if cls not in filtered_classes:
-                filtered_classes.append(cls)
-
-    name = [cls.__name__ for cls in filtered_classes]
-    name = "".join(name) + "ConsistentResolution"
-    try:
-        return type(name, tuple(filtered_classes), {})
-    except TypeError:
-        pass
-
-    filtered_classes.sort(key=lambda cls: -len(cls.mro()))
-    try:
-        return type(name, tuple(filtered_classes), {})
-    except TypeError:
-        pass
-
-    bases = ", ".join(cls.__name__ for cls in filtered_classes)
-    orig_bases = ", ".join(cls.__name__ for cls in classes)
-    raise TypeError(
-        f"Cannot create a consistent method resolution order (MRO) "
-        f"for bases {orig_bases}, tried {bases}"
-    )
-
-
-__all__ = ("PolymorphicSchema", "consistent_resolution")
+#
+# 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.
+#
+
+"""Marshmallow schema module."""
+
+from __future__ import annotations

oarepo_runtime/services/schema/i18n.py

@@ -1,28 +1,48 @@
+#
+# 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.
+#
+
+"""Marshmallow schema for multilingual strings."""
+
+from __future__ import annotations
+
 from functools import lru_cache
+from typing import Any
 
 import langcodes
+import langcodes.tag_parser
 from invenio_base.utils import obj_or_import_string
 from invenio_i18n import gettext as _
 from marshmallow import Schema, ValidationError, fields, pre_load, validates
 
-"""
-Marshmallow schema for multilingual strings. Consider moving this file to a library, not generating
-it for each project.
-"""
-
 
 @lru_cache
 def get_i18n_schema(
-    lang_name, value_name, value_field="marshmallow_utils.fields.SanitizedHTML"
-):
+    lang_name: str,
+    value_name: str,
+    value_field: str = "marshmallow_utils.fields.SanitizedHTML",
+) -> type[Schema]:
+    """Dynamically creates and returns I18n Schema class.
+
+    Add custom serialization logic based on the provided `lang_name` and `value_name`.
+    """
+
     class I18nMixin:
         @validates(lang_name)
-        def validate_lang(self, value):
-            if value != "_" and not langcodes.Language.get(value).is_valid():
-                raise ValidationError("Invalid language code")
+        def validate_lang(self, value: str) -> None:
+            try:
+                if value != "_" and not langcodes.Language.get(value).is_valid():
+                    raise ValidationError("Invalid language code")
+            except langcodes.tag_parser.LanguageTagError as e:
+                raise ValidationError("Invalid language code") from e
 
         @pre_load
-        def pre_load_func(self, data, **kwargs):
+        def pre_load_func(self, data: dict[str, Any], **_kwargs: Any) -> dict[str, Any]:
             errors = {}
             if not data.get(lang_name) or not data.get(value_name):
                 errors[lang_name] = [_("Both language and text must be provided.")]
@@ -33,7 +53,11 @@ def get_i18n_schema(
             return data
 
     value_field_class = obj_or_import_string(value_field)
-
+    if value_field_class is None:
+        raise ValueError(
+            f"Invalid value field class provided: '{value_field}'. "
+            "Expected a valid import string for a Marshmallow field class."
+        )
     return type(
         f"I18nSchema_{lang_name}_{value_name}",
         (
@@ -48,14 +72,15 @@ def get_i18n_schema(
 
 
 def MultilingualField(  # noqa NOSONAR
-    *args,
-    lang_name="lang",
-    value_name="value",
-    value_field="marshmallow_utils.fields.SanitizedHTML",
-    **kwargs,
+    *args: Any,
+    lang_name: str = "lang",
+    value_name: str = "value",
+    value_field: str = "marshmallow_utils.fields.SanitizedHTML",
+    **kwargs: Any,
 ):
     # TODO: args are not used but oarepo-model-builder-multilingual generates them
     # should be fixed there and subsequently removed here
+    _ = args
     return fields.List(
         fields.Nested(get_i18n_schema(lang_name, value_name, value_field)),
         **kwargs,
@@ -63,11 +88,11 @@ def MultilingualField(  # noqa NOSONAR
 
 
 def I18nStrField(  # noqa NOSONAR
-    *args,
-    lang_name="lang",
-    value_name="value",
-    value_field="marshmallow_utils.fields.SanitizedHTML",
-    **kwargs,
+    *args: Any,
+    lang_name: str = "lang",
+    value_name: str = "value",
+    value_field: str = "marshmallow_utils.fields.SanitizedHTML",
+    **kwargs: Any,
 ):
     return fields.Nested(
         get_i18n_schema(lang_name, value_name, value_field),