oarepo-runtime 1.10.3__py3-none-any.whl → 2.0.0.dev4__py3-none-any.whl

oarepo_runtime/services/config/link_conditions.py

@@ -1,126 +1,120 @@
-import warnings
+#
+# 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.
+#
+
+"""Link conditions module."""
+
+from __future__ import annotations
+
 from abc import abstractmethod
 from logging import getLogger
+from typing import Any
 
 from invenio_pidstore.errors import PIDDoesNotExistError, PIDUnregistered
-from invenio_records.api import RecordBase
-from invenio_records_resources.records.api import FileRecord, Record
+from invenio_records_resources.records.api import FileRecord, RecordBase
 
-from ...datastreams.utils import (
-    get_file_service_for_record_class,
-    get_record_service_for_record,
-)
-from ...records.drafts import get_draft
+from oarepo_runtime.proxies import current_runtime
+from oarepo_runtime.records.drafts import get_draft
 
 log = getLogger(__name__)
 
 
 class Condition:
+    """Base class for defining conditions with callable logic."""
+
     @abstractmethod
-    def __call__(self, obj, ctx: dict):
-        raise NotImplementedError
+    def __call__(self, obj: RecordBase, ctx: dict):
+        """Abstract method to be implemented in subclasses to define a condition."""
+        raise NotImplementedError  # pragma: no cover
 
-    def __and__(self, other):
+    def __and__(self, other: Any):
+        """Combine two conditions using a logical AND."""
         return type(
-            "CompositeCondition",
+            "And",
             (Condition,),
             {"__call__": lambda _, obj, ctx: self(obj, ctx) and other(obj, ctx)},
         )()
 
-    def __or__(self, other):
+    def __or__(self, other: Any):
+        """Combine two conditions using a logical OR."""
         return type(
-            "CompositeCondition",
+            "Or",
             (Condition,),
             {"__call__": lambda _, obj, ctx: self(obj, ctx) or other(obj, ctx)},
         )()
 
 
-class is_published_record(Condition):
-    """Shortcut for links to determine if record is a published record."""
-
-    def __call__(self, obj: Record, ctx: dict):
-        return not getattr(obj, "is_draft", False)
-
-
-class is_draft_record(Condition):
-    """Shortcut for links to determine if record is a draft record."""
-
-    def __call__(self, obj: Record, ctx: dict):
-        return getattr(obj, "is_draft", False)
-
-
-class has_draft(Condition):
-    """Shortcut for links to determine if record is either a draft or a published one with a draft associated."""
-
-    def __call__(self, obj: Record, ctx: dict):
-        if getattr(obj, "is_draft", False):
-            return True
-        if getattr(obj, "has_draft", False):
-            return True
-        return False
-
+class has_permission(Condition):  # noqa: N801
+    """A condition to check if a user has the specified permission for a given record."""
 
-class has_permission(Condition):
-    def __init__(self, action_name):
+    def __init__(self, action_name: str):
+        """Initialize the condition with the specified action name."""
         self.action_name = action_name
 
     def __call__(self, obj: RecordBase, ctx: dict):
+        """Evaluate the condition by checking the permission for a given record."""
         if isinstance(obj, FileRecord):
             obj = obj.record
-        service = get_record_service_for_record(obj)
+        service = current_runtime.get_record_service_for_record(obj)
         try:
-            return service.check_permission(
-                action_name=self.action_name, record=obj, **ctx
-            )
-        except Exception as e:
-            log.exception(f"Unexpected exception {e}.")
+            return service.check_permission(action_name=self.action_name, record=obj, **ctx)
+        except Exception:  # pragma: no cover
+            log.exception("Unexpected exception.")
+
 
+class has_draft_permission(Condition):  # noqa: N801
+    """A condition to check if a user has the specified permission for a draft record."""
 
-class has_draft_permission(Condition):
-    def __init__(self, action_name):
+    def __init__(self, action_name: str):
+        """Initialize the condition with the specified action name."""
         self.action_name = action_name
 
     def __call__(self, obj: RecordBase, ctx: dict):
+        """Valuates the condition by checking the permission for a draft record."""
+        _ = ctx
         draft_record = get_draft(obj)
         if not draft_record:
             return False
-        service = get_record_service_for_record(obj)
+        service = current_runtime.get_record_service_for_record(obj)
         try:
-            return service.check_permission(
-                action_name=self.action_name, record=draft_record, **ctx
-            )
-        except Exception as e:
-            log.exception(f"Unexpected exception {e}.")
+            return service.check_permission(action_name=self.action_name, record=draft_record, **ctx)
+        except Exception:  # pragma: no cover
+            log.exception("Unexpected exception.")
             return False
 
 
-class has_file_permission(has_permission):
-    def __call__(self, obj: RecordBase, ctx: dict):
-        if isinstance(obj, FileRecord):
-            obj = obj.record
-        service = get_file_service_for_record_class(type(obj))
-        try:
-            return service.check_permission(
-                action_name=self.action_name, record=obj, **ctx
-            )
-        except Exception as e:
-            log.exception(f"Unexpected exception {e}.")
+class has_draft(Condition):  # noqa: N801
+    """Shortcut for links to determine if record is either a draft or a published one with a draft associated."""
 
+    def __call__(self, obj: RecordBase, ctx: dict):
+        """Check if the given record has draft."""
+        _ = ctx
+        return bool(getattr(obj, "is_draft", False)) or bool(getattr(obj, "has_draft", False))
 
-class has_permission_file_service(has_file_permission):
-    def __init__(self, action_name):
-        warnings.warn(
-            "has_permission_file_service is deprecated, use has_file_permission instead",
-            DeprecationWarning,
-        )
-        super().__init__(action_name)
 
+class has_published_record(Condition):  # noqa: N801
+    """Shortcut for links to determine if the given record has a published PID."""
 
-class has_published_record(Condition):
-    def __call__(self, obj: Record, ctx: dict):
-        service = get_record_service_for_record(obj)
+    def __call__(self, obj: RecordBase, ctx: dict):
+        """Check if the given record has a published PID."""
+        _ = ctx
+        service = current_runtime.get_record_service_for_record(obj)
         try:
             service.record_cls.pid.resolve(obj["id"])
         except (PIDUnregistered, PIDDoesNotExistError):
             return False
         return True
+
+
+class is_published_record(Condition):  # noqa: N801
+    """Shortcut for links to determine if record is a published record."""
+
+    def __call__(self, obj: RecordBase, ctx: dict):
+        """Check if the given record is draft."""
+        _ = ctx
+        return not getattr(obj, "is_draft", False)

oarepo_runtime/services/config/permissions.py

@@ -0,0 +1,62 @@
+# mypy: disable-error-code="assignment"
+#
+# 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.
+#
+
+"""Everyone permissions."""
+
+from __future__ import annotations
+
+from invenio_records_permissions import RecordPermissionPolicy
+from invenio_records_permissions.generators import AnyUser, Generator, SystemProcess
+
+type GeneratorList = tuple[Generator, ...]
+
+
+class EveryonePermissionPolicy(RecordPermissionPolicy):
+    """Record policy for read-only repository."""
+
+    can_search: GeneratorList = (SystemProcess(), AnyUser())
+    can_read: GeneratorList = (SystemProcess(), AnyUser())
+    can_create: GeneratorList = (SystemProcess(), AnyUser())
+    can_update: GeneratorList = (SystemProcess(), AnyUser())
+    can_delete: GeneratorList = (SystemProcess(), AnyUser())
+    can_manage: GeneratorList = (SystemProcess(), AnyUser())
+
+    can_create_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_set_content_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_get_content_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_commit_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_read_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_update_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_delete_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_list_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_manage_files: GeneratorList = (SystemProcess(), AnyUser())
+
+    can_edit: GeneratorList = (SystemProcess(), AnyUser())
+    can_new_version: GeneratorList = (SystemProcess(), AnyUser())
+    can_search_drafts: GeneratorList = (SystemProcess(), AnyUser())
+    can_read_draft: GeneratorList = (SystemProcess(), AnyUser())
+    can_search_versions: GeneratorList = (SystemProcess(), AnyUser())
+    can_update_draft: GeneratorList = (SystemProcess(), AnyUser())
+    can_delete_draft: GeneratorList = (SystemProcess(), AnyUser())
+    can_publish: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_create_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_set_content_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_get_content_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_commit_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_read_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_update_files: GeneratorList = (SystemProcess(), AnyUser())
+    can_draft_delete_files: GeneratorList = (SystemProcess(), AnyUser())
+
+    can_add_community: GeneratorList = (SystemProcess(), AnyUser())
+    can_remove_community: GeneratorList = (SystemProcess(), AnyUser())
+
+    can_read_deleted: GeneratorList = (SystemProcess(), AnyUser())
+    can_manage_record_access: GeneratorList = (SystemProcess(), AnyUser())
+    can_lift_embargo: GeneratorList = (SystemProcess(), AnyUser())

oarepo_runtime/services/facets/__init__.py

@@ -1,33 +1,12 @@
-from .base import LabelledValuesTermsFacet
-from .date import (
-    AutoDateHistogramFacet,
-    DateFacet,
-    DateIntervalFacet,
-    DateTimeFacet,
-    EDTFIntervalFacet,
-    TimeFacet,
-)
-from .enum import EnumTermsFacet
-from .facet_groups_names import facet_groups_names
-from .max_facet import MaxFacet
-from .nested_facet import NestedLabeledFacet
-from .params import FilteredFacetsParam, GroupedFacetsParam
-from .year_histogram import YearAutoHistogramFacet
-from .multilingual_facet import MultilingualFacet
-__all__ = [
-    "LabelledValuesTermsFacet",
-    "DateFacet",
-    "TimeFacet",
-    "DateTimeFacet",
-    "AutoDateHistogramFacet",
-    "EDTFIntervalFacet",
-    "DateIntervalFacet",
-    "EnumTermsFacet",
-    "facet_groups_names",
-    "MaxFacet",
-    "NestedLabeledFacet",
-    "GroupedFacetsParam",
-    "FilteredFacetsParam",
-    "YearAutoHistogramFacet",
-    "MultilingualFacet"
-]
+#
+# 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.
+#
+
+"""Facet parameter classes."""
+
+from __future__ import annotations

oarepo_runtime/services/facets/params.py

@@ -1,55 +1,52 @@
+#
+# 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.
+#
+
+"""Facet params."""
+
+from __future__ import annotations
+
 import copy
 import logging
-import operator
-from functools import partial, reduce
-from typing import List
+from typing import TYPE_CHECKING
 
 from flask import current_app
-from flask_principal import Identity
 from invenio_access.permissions import system_user_id
 from invenio_app.helpers import obj_or_import_string
 from invenio_records_resources.services.records.facets import FacetsResponse
 from invenio_records_resources.services.records.params import FacetsParam
-from invenio_access.permissions import authenticated_user
-from invenio_records_resources.services.records.params.base import ParamInterpreter
-from invenio_search.engine import dsl
-from invenio_rdm_records.records.systemfields.deletion_status import (
-    RecordDeletionStatusEnum,
-)
-
-log = logging.getLogger(__name__)
-
 
-class FilteredFacetsParam(FacetsParam):
-    def filter(self, search):
-        """Apply a post filter on the search."""
-        if not self._filters:
-            return search
+if TYPE_CHECKING:
+    from flask_principal import Identity
+    from invenio_records_resources.services.records.config import SearchOptions
+    from invenio_search.engine import dsl
 
-        filters = list(self._filters.values())
-
-        facet_filter = filters[0]
-        for f in filters[1:]:
-            facet_filter &= f
-
-        return search.filter(facet_filter)
+log = logging.getLogger(__name__)
 
 
 class GroupedFacetsParam(FacetsParam):
-    def __init__(self, config):
+    """Facet parameter class that supports grouping of facets."""
+
+    def __init__(self, config: SearchOptions):
+        """Initialize the facets parameter with the given config."""
         super().__init__(config)
         self._facets = {**config.facets}
 
     @property
-    def facets(self):
+    def facets(self) -> dict[str, dsl.Facet]:
+        """Return the facets dictionary."""
         return self._facets
 
-    def identity_facet_groups(self, identity: Identity) -> List[str]:
+    def identity_facet_groups(self, identity: Identity) -> list[str]:
+        """Return the facet groups for the given identity."""
         if "OAREPO_FACET_GROUP_NAME" in current_app.config:
-            find_facet_groups_func = obj_or_import_string(
-                current_app.config["OAREPO_FACET_GROUP_NAME"]
-            )
-            return find_facet_groups_func(identity, self.config, None)
+            find_facet_groups_func = obj_or_import_string(current_app.config["OAREPO_FACET_GROUP_NAME"])
+            return find_facet_groups_func(identity, self.config, None)  # type: ignore[no-any-return]
 
         if hasattr(identity, "provides"):
             return [need.value for need in identity.provides if need.method == "role"]
@@ -57,43 +54,33 @@ class GroupedFacetsParam(FacetsParam):
         return []
 
     @property
-    def facet_groups(self):
+    def facet_groups(self) -> dict[str, dict[str, dsl.Facet]] | None:
+        """Return the facet groups defined in the service config."""
         if hasattr(self.config, "facet_groups"):
-            return self.config.facet_groups
+            return self.config.facet_groups  # type: ignore[no-any-return]
         return None
 
-    def identity_facets(self, identity: Identity):
-        global_search_model = False
-        for model in current_app.config.get("GLOBAL_SEARCH_MODELS", []):
-            service_config = obj_or_import_string(model["service_config"])
-            if service_config == self.config:
-                global_search_model = True
-
+    def identity_facets(self, identity: Identity) -> dict[str, dsl.Facet]:
+        """Return the facets for the given identity."""
         if not self.facet_groups:
-            if global_search_model:
-                log.warning(
-                    "No facet groups defined on the service config %s", type(self.config)
-                )
             return self.facets
 
         has_system_user_id = identity.id == system_user_id
-        has_system_process_need = any(
-            need.method == "system_process" for need in identity.provides
-        )
+        has_system_process_need = any(need.method == "system_process" for need in identity.provides)
         if has_system_user_id or has_system_process_need:
             return self.facets
 
-        user_facets = self._filter_user_facets(identity)
-        return user_facets
+        return self._filter_user_facets(identity)
 
-    def aggregate(self, search, user_facets):
+    def aggregate_with_user_facets(self, search: dsl.Search, user_facets: dict[str, dsl.Facet]) -> dsl.Search:
+        """Add aggregations representing the user facets."""
         for name, facet in user_facets.items():
             agg = facet.get_aggregation()
             search.aggs.bucket(name, agg)
 
         return search
 
-    def filter(self, search):
+    def filter(self, search: dsl.Search) -> dsl.Search:
         """Apply a post filter on the search."""
         if not self._filters:
             return search
@@ -106,7 +93,7 @@ class GroupedFacetsParam(FacetsParam):
 
         return search.filter(_filter).post_filter(_filter)
 
-    def apply(self, identity, search, params):
+    def apply(self, identity: Identity, search: dsl.Search, params: dict) -> dsl.Search:
         """Evaluate the facets on the search."""
         facets_values = params.pop("facets", {})
         for name, values in facets_values.items():
@@ -115,17 +102,18 @@ class GroupedFacetsParam(FacetsParam):
 
         user_facets = self.identity_facets(identity)
         self_copy = copy.copy(self)
-        self_copy._facets = user_facets
+        self_copy._facets = user_facets  # noqa: SLF001 - TODO: this looks like a hack
         search = search.response_class(FacetsResponse.create_response_cls(self_copy))
 
-        search = self.aggregate(search, user_facets)
+        search = self.aggregate_with_user_facets(search, user_facets)
         search = self.filter(search)
 
         params.update(self.selected_values)
 
         return search
 
-    def _filter_user_facets(self, identity: Identity):
+    def _filter_user_facets(self, identity: Identity) -> dict[str, dsl.Facet]:
+        """Filter user facets based on the identity."""
         user_facets = {}
         if not self.facet_groups:
             user_facets.update(self.facets)
@@ -135,58 +123,5 @@ class GroupedFacetsParam(FacetsParam):
 
         groups = self.identity_facet_groups(identity)
         for group in groups:
-            user_facets.update(self.facet_groups.get(group, {}))
+            user_facets.update((self.facet_groups or {}).get(group, {}))
         return user_facets
-
-
-class OARepoAllVersionsParam(ParamInterpreter):
-    """Evaluates the 'allversions' parameter."""
-    def __init__(self, field_names, config):
-        """Construct."""
-        self.field_names = field_names
-        super().__init__(config)
-
-    @classmethod
-    def factory(cls, field_names: list[str]):
-        """Create a new filter parameter."""
-        return partial(cls, field_names)
-
-    def apply(self, identity, search, params):
-        """Evaluate the allversions parameter on the search."""
-        if not params.get("allversions"):
-            queries = [dsl.query.Q("term", **{field_name: True}) for field_name in self.field_names]
-            query = reduce(operator.or_, queries)
-            search = search.filter(query)
-        return search
-
-class OARepoPublishedRecordsParam(ParamInterpreter):
-    """Evaluates the include_deleted parameter."""
-
-    def apply(self, identity, search, params):
-        """Evaluate the include_deleted parameter on the search."""
-
-        value = params.pop("include_deleted", None)
-        # Filter prevents from displaying deleted records on mainsite search
-        # deleted records should appear only in admins panel
-        if value is None:
-            query = dsl.query.Q(
-                "bool",
-                should=[
-                    dsl.query.Q(
-                        "bool",
-                        must=[
-                            dsl.query.Q(
-                                "term",
-                                deletion_status=RecordDeletionStatusEnum.PUBLISHED.value,
-                            )
-                        ],
-                    ),
-                    # Drafts does not have deletion_status so this clause is needed to
-                    # prevent the above clause from filtering out the drafts
-                    dsl.query.Q(
-                        "bool", must_not=[dsl.query.Q("exists", field="deletion_status")]
-                    ),
-                ],
-            )
-            search = search.filter(query)
-        return search

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)