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

oarepo_runtime/records/mapping.py

@@ -0,0 +1,84 @@
+#
+# 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.
+#
+"""Module to update the mapping of system fields in a record class."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from invenio_search import current_search_client
+from invenio_search.engine import dsl
+from invenio_search.utils import build_alias_name
+
+from oarepo_runtime.records.systemfields.mapping import MappingSystemFieldMixin
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from invenio_records.api import RecordBase
+
+
+def prefixed_index(index: dsl.Index) -> dsl.Index:
+    """Return a prefixed index for the given index."""
+    return dsl.Index(
+        build_alias_name(
+            index._name,  # type: ignore[attr-defined]  # noqa: SLF001
+        ),
+        using=current_search_client,  # pyright: ignore[reportArgumentType]
+    )
+
+
+def update_record_system_fields_mapping(record_class: type[RecordBase]) -> None:
+    """Update mapping for system fields in the record class.
+
+    :param record_class: The record class which index mapping should be updated.
+    :raise search.RequestError: If there is an error while updating the mapping.
+    """
+    index = getattr(record_class, "index", None)
+    if not index:
+        return
+
+    for fld in get_mapping_fields(record_class):
+        # get mapping
+        mapping = fld.mapping
+        settings = fld.mapping_settings
+        dynamic_templates = fld.dynamic_templates
+
+        # upload mapping
+        update_record_index(prefixed_index(index), settings, mapping, dynamic_templates)
+
+
+def update_record_index(
+    record_index: dsl.Index,
+    settings: dict,
+    mapping: dict,
+    dynamic_templates: list | None = None,
+) -> None:
+    """Update the index mapping for the given record index."""
+    if settings:
+        record_index.close()
+        record_index.put_settings(body=settings)
+        record_index.open()
+
+    body: dict[str, Any] = {}
+    if mapping:
+        body["properties"] = mapping
+    if dynamic_templates:
+        body["dynamic_templates"] = dynamic_templates
+    if body:
+        record_index.put_mapping(body=body)
+
+
+def get_mapping_fields(
+    record_class: type[RecordBase],
+) -> Iterable[MappingSystemFieldMixin]:
+    """Get all mapping fields from the record class."""
+    return (attr for _, attr in inspect.getmembers(record_class, lambda x: isinstance(x, MappingSystemFieldMixin)))

oarepo_runtime/records/pid_providers.py

@@ -1,17 +1,53 @@
+#
+# 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.
+#
+"""PID providers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Self, cast
+
 from invenio_pidstore.models import PersistentIdentifier, PIDStatus
 
+if TYPE_CHECKING:
+    from invenio_pidstore.providers.recordid_v2 import RecordIdProviderV2
+else:
+    RecordIdProviderV2 = object
+
+
+class UniversalPIDMixin(RecordIdProviderV2):
+    """Mixin class to handle creation and management of universal PIDs for records."""
 
-class UniversalPIDMixin:
     unpid_pid_type = "unpid"
     unpid_default_status = PIDStatus.REGISTERED
 
     @classmethod
-    def create(cls, object_type=None, object_uuid=None, options=None, **kwargs):
-        pid = super().create(
-            object_type=object_type, object_uuid=object_uuid, options=options, **kwargs
+    def create(  # type: ignore[override]
+        cls,
+        object_type: str | None = None,
+        object_uuid: str | None = None,
+        options: dict | None = None,
+        **kwargs: Any,
+    ) -> Self:
+        """Create PID for a given object and store it."""
+        pid = cast(
+            "Self",
+            super().create(
+                object_type=object_type,
+                object_uuid=object_uuid,
+                options=options,
+                **kwargs,
+            ),
         )
-        assert pid.pid.pid_value is not None
-        control_pid = PersistentIdentifier.create(
+        if pid.pid.pid_value is None:
+            raise ValueError("PID value cannot be None.")  # pragma: no cover
+
+        PersistentIdentifier.create(
             cls.unpid_pid_type,
             pid.pid.pid_value,
             pid_provider=None,
@@ -19,4 +55,4 @@ class UniversalPIDMixin:
             object_uuid=object_uuid,
             status=cls.unpid_default_status,
         )
-        return pid
+        return pid

oarepo_runtime/records/systemfields/__init__.py

@@ -1,34 +1,16 @@
-from .icu import (
-    FulltextIndexField,
-    ICUField,
-    ICUSearchField,
-    ICUSortField,
-    ICUSuggestField,
-    TermIndexField,
-)
-from .mapping import MappingSystemFieldMixin, SystemFieldDumperExt
-from .selectors import (
-    FilteredSelector,
-    FirstItemSelector,
-    MultiSelector,
-    PathSelector,
-    Selector,
-)
-from .synthetic import SyntheticSystemField
+#
+# 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.
+#
+"""Records system fields."""
 
-__all__ = (
-    "ICUField",
-    "ICUSuggestField",
-    "ICUSortField",
-    "ICUSearchField",
-    "FulltextIndexField",
-    "MappingSystemFieldMixin",
-    "SystemFieldDumperExt",
-    "SyntheticSystemField",
-    "PathSelector",
-    "Selector",
-    "FirstItemSelector",
-    "FilteredSelector",
-    "MultiSelector",
-    "TermIndexField",
-)
+from __future__ import annotations
+
+from .mapping import MappingSystemFieldMixin
+from .publication_status import PublicationStatusSystemField
+
+__all__ = ("MappingSystemFieldMixin", "PublicationStatusSystemField")

oarepo_runtime/records/systemfields/mapping.py

@@ -1,39 +1,56 @@
-import inspect
+#
+# 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.
+#
+"""System fields mapping."""
 
-from invenio_records.dumpers import SearchDumperExt
+from __future__ import annotations
 
+from typing import TYPE_CHECKING, override
+
+if TYPE_CHECKING:
+    from invenio_records.api import RecordBase
+    from invenio_records.dumpers import Dumper
+    from invenio_records.systemfields import SystemField
+else:
+    SystemField = object
+
+
+class MappingSystemFieldMixin(SystemField):
+    """Mixin class that provides default mapping, mapping settings, and dynamic templates for system fields."""
 
-class MappingSystemFieldMixin:
     @property
-    def mapping(self):
+    def mapping(self) -> dict:
+        """Return the default mapping for the system field."""
         return {}
 
     @property
-    def mapping_settings(self):
+    def mapping_settings(self) -> dict:
+        """Return the default mapping settings for the system field."""
         return {}
 
     @property
-    def dynamic_templates(self):
+    def dynamic_templates(self) -> list:
+        """Return the default dynamic templates for the system field."""
         return []
 
-    def search_dump(self, data, record):
-        """Dump custom field."""
-
-    def search_load(self, data, record_cls):
-        """Load custom field."""
+    # The following methods are added just for typing purposes.
+    @override
+    def pre_dump(self, record: RecordBase, data: dict, dumper: Dumper | None = None) -> None:  # type: ignore[misc]
+        """Dump record to the data - pre-dump phase."""
 
+    @override
+    def post_dump(self, record: RecordBase, data: dict, dumper: Dumper | None = None) -> None:  # type: ignore[misc]
+        """Dump record to the data - post-dump phase."""
 
-class SystemFieldDumperExt(SearchDumperExt):
-    def dump(self, record, data):
-        """Dump custom fields."""
-        for cf in inspect.getmembers(
-            type(record), lambda x: isinstance(x, MappingSystemFieldMixin)
-        ):
-            cf[1].search_dump(data, record=record)
+    @override
+    def pre_load(self, data: dict, loader: Dumper | None = None) -> None:  # type: ignore[misc]
+        """Load record from the data - pre-load phase."""
 
-    def load(self, data, record_cls):
-        """Load custom fields."""
-        for cf in inspect.getmembers(
-            record_cls, lambda x: isinstance(x, MappingSystemFieldMixin)
-        ):
-            cf[1].search_load(data, record_cls=record_cls)
+    @override
+    def post_load(self, record: RecordBase, data: dict, loader: Dumper | None = None) -> None:  # type: ignore[misc]
+        """Load record from the data - post-load phase."""

oarepo_runtime/records/systemfields/publication_status.py

@@ -0,0 +1,59 @@
+#
+# 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.
+#
+"""Record status module."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, override
+
+from invenio_records.systemfields import SystemField
+
+from .mapping import MappingSystemFieldMixin
+
+if TYPE_CHECKING:
+    from invenio_records.api import RecordBase
+    from invenio_records.dumpers import Dumper
+
+
+class PublicationStatusSystemField(MappingSystemFieldMixin, SystemField):
+    """A system field to track the status of a record (either 'draft' or 'published').
+
+    The default key for this field is 'publication_status', but it can be customized.
+    """
+
+    def __init__(self, key: str | None = "publication_status"):
+        """Initialize the system field with an optional key."""
+        super().__init__(key)
+
+    @property
+    def mapping(self) -> dict:
+        """Return the mapping for the field in the search index."""
+        return {
+            self.key: {
+                "type": "keyword",
+            },
+        }
+
+    @override
+    def post_load(self, record: RecordBase, data: dict, loader: Dumper | None = None) -> None:
+        data.pop(self.key, None)
+
+    @override
+    def post_dump(self, record: RecordBase, data: dict, dumper: Dumper | None = None) -> None:
+        if self.key is None:
+            return
+        if not self.attr_name:
+            raise ValueError("attr_name must be set for PublicationStatusSystemField")
+        data[self.key] = getattr(record, self.attr_name)
+
+    def __get__(self, record: RecordBase | None, owner: Any = None) -> Any:
+        """Access the attribute."""
+        if record is None:
+            return self
+        return "draft" if getattr(record, "is_draft", False) else "published"

oarepo_runtime/services/__init__.py

@@ -0,0 +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).
+#
+# 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.
+#
+
+"""Services module."""
+
+from __future__ import annotations

oarepo_runtime/services/config/__init__.py

@@ -1,35 +1,29 @@
-from .draft_link import DraftLink
+#
+# 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 config module."""
+
+from __future__ import annotations
+
 from .link_conditions import (
     has_draft,
     has_draft_permission,
-    has_file_permission,
     has_permission,
-    has_permission_file_service,
     has_published_record,
-    is_draft_record,
     is_published_record,
 )
-from .permissions_presets import (
-    AuthenticatedPermissionPolicy,
-    EveryonePermissionPolicy,
-    OaiHarvesterPermissionPolicy,
-    ReadOnlyPermissionPolicy,
-)
-from .service import PermissionsPresetsConfigMixin
+from .permissions import EveryonePermissionPolicy
 
 __all__ = (
-    "PermissionsPresetsConfigMixin",
-    "OaiHarvesterPermissionPolicy",
-    "ReadOnlyPermissionPolicy",
     "EveryonePermissionPolicy",
-    "AuthenticatedPermissionPolicy",
-    "is_published_record",
-    "is_draft_record",
     "has_draft",
+    "has_draft_permission",
     "has_permission",
-    "has_permission_file_service",
-    "has_file_permission",
     "has_published_record",
-    "has_draft_permission",
-    "DraftLink",
+    "is_published_record",
 )

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())