oarepo-runtime 2.0.0.dev10__tar.gz → 2.0.0.dev12__tar.gz

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/PKG-INFO

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

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/oarepo_runtime/__init__.py

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

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/oarepo_runtime/api.py

@@ -27,7 +27,11 @@ if TYPE_CHECKING:
     from flask_resources.responses import ResponseHandler
     from flask_resources.serializers import BaseSerializer
     from invenio_drafts_resources.records.api import Draft
-    from invenio_records_resources.records.api import RecordBase
+    from invenio_records_resources.records.api import Record
+    from invenio_records_resources.records.systemfields.pid import (
+        ModelPIDField,
+        ModelPIDFieldContext,
+    )
     from invenio_records_resources.resources.records.config import RecordResourceConfig
     from invenio_records_resources.resources.records.resource import RecordResource
     from invenio_records_resources.services import (
@@ -72,7 +76,7 @@ class Export:
 class Model[
     S: RecordService = RecordService,
     C: RecordServiceConfig = RecordServiceConfig,
-    R: RecordBase = RecordBase,
+    R: Record = Record,
     D: Draft = Draft,
     # not sure why this is flagged by pyright as an error
     RR: RecordResource = RecordResource,  # pyright: ignore[reportGeneralTypeIssues]
@@ -242,6 +246,39 @@ class Model[
         """Get the API blueprint name for the model."""
         return cast("str", self.resource_config.blueprint_name)
 
+    @property
+    def record_pid_type(self) -> str | None:
+        """Get the PID type for the model."""
+        return self._pid_type_from_record(self.record_cls)
+
+    @property
+    def record_json_schema(self) -> str:
+        """Get the json schema of the record."""
+        return self.record_cls.schema.value  # type: ignore[attr-defined, no-any-return]
+
+    @property
+    def draft_pid_type(self) -> str | None:
+        """Get the PID type for the model."""
+        return self._pid_type_from_record(self.draft_cls)
+
+    def _pid_type_from_record(self, record_cls: type[Record] | None) -> str | None:
+        """Get the PID type from a record class, returning None if not found."""
+        if record_cls is None:
+            return None
+        pid_context: ModelPIDFieldContext | None = getattr(record_cls, "pid", None)
+        if pid_context is None:
+            # registered record has no pid field
+            return None  # pragma: no cover
+        pid_field: ModelPIDField | None = getattr(pid_context, "field", None)
+        if pid_field is None:
+            # there is no pid field in the context
+            return None  # pragma: no cover
+        pid_provider = getattr(pid_field, "_provider", None)
+        if not pid_provider:
+            # there is no pid provider in the field
+            return None  # pragma: no cover
+        return getattr(pid_provider, "pid_type", None)
+
     def api_url(self, view_name: str, **kwargs: Any) -> str:
         """Get the API URL for the model."""
         return cast("str", invenio_url_for(f"{self.api_blueprint_name}.{view_name}", **kwargs))

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/oarepo_runtime/cli/__init__.py

@@ -24,4 +24,4 @@ def oarepo() -> None:
 
 # register additional commands to the oarepo group
 for ep in entry_points(group="oarepo.cli"):
-    oarepo.add_command(ep.load())
+    oarepo.add_command(ep.load())  # pragma: nocover

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/oarepo_runtime/cli/search.py

@@ -10,13 +10,13 @@
 
 from __future__ import annotations
 
+from importlib import metadata as importlib_metadata
+
 import click
 from flask.cli import with_appcontext
 from invenio_search.cli import index, search_version_check
 from invenio_search.cli import init as original_init
 
-from oarepo_runtime.services.records.mapping import update_all_records_mappings
-
 
 @index.command()
 @click.option("--force", is_flag=True, default=False)
@@ -31,4 +31,5 @@ def init(ctx: click.Context, force: bool) -> None:
     defined inside the models.
     """
     ctx.invoke(original_init, force=force)
-    update_all_records_mappings()
+    for ep in importlib_metadata.entry_points(group="oarepo.cli.search.init"):
+        ep.load()()

oarepo_runtime-2.0.0.dev12/oarepo_runtime/ext.py

@@ -0,0 +1,198 @@
+#
+# 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.
+#
+
+"""Extension preset for runtime module."""
+
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, cast
+
+from flask import current_app
+from invenio_pidstore.errors import PIDDoesNotExistError
+from invenio_pidstore.models import PersistentIdentifier
+from invenio_records_resources.proxies import current_service_registry
+from invenio_records_resources.records.api import Record, RecordBase
+
+from . import config
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable
+    from uuid import UUID
+
+    from flask import Flask
+    from invenio_drafts_resources.records.api import Draft
+    from invenio_records_resources.services.base.service import Service
+    from invenio_records_resources.services.records import RecordService
+
+    from .api import Model
+
+
+class OARepoRuntime:
+    """OARepo base of invenio oarepo client."""
+
+    def __init__(self, app: Flask | None = None):
+        """Extension initialization."""
+        if app:
+            self.init_app(app)
+
+    def init_app(self, app: Flask) -> None:
+        """Flask application initialization."""
+        self.app = app
+        self.init_config(app)
+        app.extensions["oarepo-runtime"] = self
+
+    def init_config(self, app: Flask) -> None:
+        """Initialize the configuration for the extension."""
+        app.config.setdefault("OAREPO_MODELS", {})
+        for k, v in config.OAREPO_MODELS.items():
+            if k not in app.config["OAREPO_MODELS"]:
+                app.config["OAREPO_MODELS"][k] = v
+
+    @property
+    def models(self) -> dict[str, Model]:
+        """Return the models registered in the extension."""
+        return cast("dict[str, Model]", current_app.config["OAREPO_MODELS"])
+
+    @property
+    def rdm_models(self) -> Iterable[Model]:
+        """Return the RDM models registered in the extension."""
+        return [v for v in self.models.values() if v.records_alias_enabled]
+
+    @cached_property
+    def models_by_record_class(self) -> dict[type[Record], Model]:
+        """Return a mapping of record classes to their models."""
+        ret = {model.record_cls: model for model in self.models.values() if model.record_cls is not None}
+        ret.update({model.draft_cls: model for model in self.models.values() if model.draft_cls is not None})
+        return ret
+
+    @cached_property
+    def record_class_by_pid_type(self) -> dict[str, type[Record]]:
+        """Return a mapping of PID types to their record classes."""
+        ret: dict[str, type[Record]] = {}
+        for model in self.models.values():
+            pid_type = model.record_pid_type
+            if pid_type is not None:
+                ret[pid_type] = model.record_cls
+        return ret
+
+    @cached_property
+    def draft_class_by_pid_type(self) -> dict[str, type[Draft]]:
+        """Return a mapping of PID types to their draft classes."""
+        ret: dict[str, type[Draft]] = {}
+        for model in self.models.values():
+            pid_type = model.draft_pid_type
+            if pid_type is not None and model.draft_cls is not None:
+                ret[pid_type] = model.draft_cls
+        return ret
+
+    @cached_property
+    def model_by_pid_type(self) -> dict[str, Model]:
+        """Return a mapping of PID types to their models."""
+        ret: dict[str, Model] = {}
+        for model in self.models.values():
+            pid_type = model.record_pid_type
+            if pid_type is not None:
+                ret[pid_type] = model
+            pid_type = model.draft_pid_type
+            if pid_type is not None:
+                ret[pid_type] = model
+        return ret
+
+    @cached_property
+    def models_by_schema(self) -> dict[str, Model]:
+        """Return a mapping of schemas to their models."""
+        ret: dict[str, Model] = {}
+        for model in self.models.values():
+            if model.record_cls is not None:
+                ret[model.record_cls.schema.value] = model  # type: ignore  # noqa
+        return ret
+
+    @cached_property
+    def rdm_models_by_schema(self) -> dict[str, Model]:
+        """Return a mapping of RDM schemas to their models."""
+        return {schema: model for schema, model in self.models_by_schema.items() if model.records_alias_enabled}
+
+    def find_pid_type_from_pid(self, pid_value: str) -> str:
+        """Given a PID value, get its associated PID type.
+
+        This method requires that there are no duplicities in the PID values
+        across models.
+        """
+        return cast("str", self._filter_model_pid(pid_value=pid_value).pid_type)
+
+    def find_pid_from_uuid(self, uuid: UUID) -> PersistentIdentifier:
+        """Given an object UUID, get its associated PID."""
+        return self._filter_model_pid(object_uuid=uuid)
+
+    def _filter_model_pid(self, **filter_kwargs: Any) -> PersistentIdentifier:
+        """Filter PIDs based on the provided criteria and return only one that matches.
+
+        Select persistent identifiers from the DB and return the one that is associated
+        with any service registered within oarepo_runtime. If no such PID exists,
+        an error is raised.
+
+        If the filter matches multiple services, an error is raised.
+        """
+        pids = PersistentIdentifier.query.filter_by(**filter_kwargs).all()
+
+        filtered_pids = [pid for pid in pids if pid.pid_type in self.record_class_by_pid_type]
+        if not filtered_pids:
+            raise PIDDoesNotExistError(
+                None,
+                filter_kwargs,
+                "The pid value/record uuid is not associated with any record.",
+            )
+
+        if len(filtered_pids) > 1:
+            raise PIDDoesNotExistError(
+                None,
+                filter_kwargs,
+                f"Multiple records found for pid value/record uuid: {filtered_pids}",
+            )
+        return filtered_pids[0]
+
+    @property
+    def services(self) -> dict[str, Service]:
+        """Return the services registered in the extension."""
+        _services = current_service_registry._services  # type: ignore[attr-defined]  # noqa: SLF001
+        return cast("dict[str, Service]", _services)
+
+    def get_record_service_for_record(self, record: Any) -> RecordService:
+        """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_record_service_for_record_class(type(record))
+
+    def get_record_service_for_record_class(self, record_cls: type[RecordBase]) -> RecordService:
+        """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
+        raise KeyError(f"No service found for record class '{record_cls.__name__}'.")
+
+    @cached_property
+    def published_indices(self) -> set[str]:
+        """Return the set of published indices."""
+        indices = set()
+        for model in self.models.values():
+            indices.add(model.record_cls.index.search_alias)  # type: ignore[attr-defined]
+        return indices
+
+    @cached_property
+    def draft_indices(self) -> set[str]:
+        """Return the set of draft indices."""
+        indices = set()
+        for model in self.models.values():
+            if model.draft_cls is not None:
+                indices.add(model.draft_cls.index.search_alias)  # type: ignore[attr-defined]
+        return indices

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/oarepo_runtime/records/pid_providers.py

@@ -23,7 +23,8 @@ else:
 class UniversalPIDMixin(RecordIdProviderV2):
     """Mixin class to handle creation and management of universal PIDs for records."""
 
-    unpid_pid_type = "unpid"
+    unpid_pid_type = "recid"
+    """Setting this to recid so that RDM can use it."""
     unpid_default_status = PIDStatus.REGISTERED
 
     @classmethod

{oarepo_runtime-2.0.0.dev10 → oarepo_runtime-2.0.0.dev12}/pyproject.toml

@@ -34,6 +34,9 @@ oarepo_runtime = "oarepo_runtime.ext:OARepoRuntime"
 [project.entry-points."flask.commands"]
 oarepo = "oarepo_runtime.cli:oarepo"
 
+[project.entry-points."oarepo.cli.search.init"]
+runtime_update_mappings = "oarepo_runtime.services.records.mapping:update_all_records_mappings"
+
 [tool.hatch.version]
 path = "oarepo_runtime/__init__.py"
 

oarepo_runtime-2.0.0.dev10/oarepo_runtime/ext.py

@@ -1,84 +0,0 @@
-#
-# 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.
-#
-
-"""Extension preset for runtime module."""
-
-from __future__ import annotations
-
-from functools import cached_property
-from typing import TYPE_CHECKING, Any, cast
-
-from flask import current_app
-from invenio_records_resources.proxies import current_service_registry
-from invenio_records_resources.records.api import RecordBase
-
-from . import config
-
-if TYPE_CHECKING:  # pragma: no cover
-    from flask import Flask
-    from invenio_records_resources.services.base.service import Service
-    from invenio_records_resources.services.records import RecordService
-
-    from .api import Model
-
-
-class OARepoRuntime:
-    """OARepo base of invenio oarepo client."""
-
-    def __init__(self, app: Flask | None = None):
-        """Extension initialization."""
-        if app:
-            self.init_app(app)
-
-    def init_app(self, app: Flask) -> None:
-        """Flask application initialization."""
-        self.app = app
-        self.init_config(app)
-        app.extensions["oarepo-runtime"] = self
-
-    def init_config(self, app: Flask) -> None:
-        """Initialize the configuration for the extension."""
-        app.config.setdefault("OAREPO_MODELS", {})
-        for k, v in config.OAREPO_MODELS.items():
-            if k not in app.config["OAREPO_MODELS"]:
-                app.config["OAREPO_MODELS"][k] = v
-
-    @property
-    def models(self) -> dict[str, Model]:
-        """Return the models registered in the extension."""
-        return cast("dict[str, Model]", current_app.config["OAREPO_MODELS"])
-
-    @cached_property
-    def models_by_record_class(self) -> dict[type[RecordBase], Model]:
-        """Return a mapping of record classes to their models."""
-        ret = {model.record_cls: model for model in self.models.values() if model.record_cls is not None}
-        ret.update({model.draft_cls: model for model in self.models.values() if model.draft_cls is not None})
-        return ret
-
-    @property
-    def services(self) -> dict[str, Service]:
-        """Return the services registered in the extension."""
-        _services = current_service_registry._services  # type: ignore[attr-defined]  # noqa: SLF001
-        return cast("dict[str, Service]", _services)
-
-    def get_record_service_for_record(self, record: Any) -> RecordService:
-        """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_record_service_for_record_class(type(record))
-
-    def get_record_service_for_record_class(self, record_cls: type[RecordBase]) -> RecordService:
-        """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
-        raise KeyError(f"No service found for record class '{record_cls.__name__}'.")