oarepo-runtime 2.0.0.dev3__tar.gz → 2.0.0.dev5__tar.gz

{oarepo_runtime-2.0.0.dev3 → oarepo_runtime-2.0.0.dev5}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: oarepo-runtime
-Version: 2.0.0.dev3
+Version: 2.0.0.dev5
 Summary: A set of runtime extensions of Invenio repository
+Project-URL: Homepage, https://github.com/oarepo/oarepo-runtime
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: <3.14,>=3.13

{oarepo_runtime-2.0.0.dev3 → oarepo_runtime-2.0.0.dev5}/oarepo_runtime/__init__.py

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

oarepo_runtime-2.0.0.dev5/oarepo_runtime/api.py

@@ -0,0 +1,229 @@
+#
+# 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.
+#
+
+"""Runtime API classes that are returned from the current_runtime instance."""
+
+from __future__ import annotations
+
+import dataclasses
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, cast
+
+from flask import current_app
+from invenio_base import invenio_url_for
+from invenio_base.utils import obj_or_import_string
+from invenio_records_resources.proxies import current_service_registry
+
+if TYPE_CHECKING:
+    from flask_babel.speaklater import LazyString
+    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.resources.records.config import RecordResourceConfig
+    from invenio_records_resources.resources.records.resource import RecordResource
+    from invenio_records_resources.services import RecordService, RecordServiceConfig
+
+
+@dataclasses.dataclass
+class Export:
+    """Configuration of an export format.
+
+    Exports are shown on the record landing page and user can download them.
+    """
+
+    code: str
+    """Code of the export format, used to identify the export format in the URL."""
+
+    name: LazyString
+    """Name of the export format, human readable."""
+
+    mimetype: str
+    """MIME type of the export format."""
+
+    serializer: BaseSerializer
+    """Serializer used to serialize the record into the export format."""
+
+    display: bool = True
+    """Whether the export format is displayed in the UI."""
+
+    oai_metadata_prefix: str | None = None
+    """OAI metadata prefix, if applicable. If not set, the export can not be used in OAI-PMH responses."""
+
+    oai_schema: str | None = None
+    """OAI schema, if applicable. If not set, the export can not be used in OAI-PMH responses."""
+
+    oai_namespace: str | None = None
+    """OAI namespace, if applicable. If not set, the export can not be used in OAI-PMH responses."""
+
+
+class Model[
+    S: RecordService = RecordService,
+    C: RecordServiceConfig = RecordServiceConfig,
+    R: RecordBase = RecordBase,
+    D: Draft = Draft,
+    # not sure why this is flagged by pyright as an error
+    RR: RecordResource = RecordResource,  # pyright: ignore[reportGeneralTypeIssues]
+    RC: RecordResourceConfig = RecordResourceConfig,
+]:
+    """Model configuration.
+
+    Every model in oarepo repository must have this configuration which must be
+    registered in the `oarepo.runtime` extension via the OAREPO_MODELS config
+    variable.
+    """
+
+    code: str
+    """Code of the model, used to identify the model"""
+
+    name: str | LazyString
+    """Name of the model, human readable."""
+
+    version: str
+    """Version of the model, should be a valid semantic version."""
+
+    description: str | LazyString | None = None
+    """Description of the model, human readable."""
+
+    records_alias_enabled: bool = False
+    """Whether the records alias is enabled for this model. Such models will be searchable
+    via the `/api/records` endpoint."""
+
+    def __init__(  # noqa: PLR0913 more attributes as we are creating a config
+        self,
+        *,
+        code: str,
+        name: str | LazyString,
+        version: str,
+        service: str | S,
+        resource_config: RC | str,
+        # params with default values
+        service_config: C | None = None,
+        description: str | LazyString | None = None,
+        record: type[R] | None = None,
+        draft: type[D] | None = None,
+        resource: str | RR = "invenio_records_resources.resources.records.resource.RecordResource",
+        exports: list[Export] | None = None,
+        records_alias_enabled: bool = True,
+    ):
+        """Initialize the model configuration.
+
+        :param name: Name of the model, human readable.
+        :param version: Version of the model, should be a valid semantic version.
+        :param description: Description of the model, human readable.
+        :param service: Name of the service inside the `current_service_registry` or
+            a configured service instance.
+        :param service_config: Service configuration, if not provided,
+            if will be taken from the service.
+        :param record: Record class, if not provided, it will be taken from the service
+            configuration.
+        :param draft: Draft class, if not provided, it will be taken from the service
+            configuration.
+        :param resource: Resource class or string import path to the resource class.
+            If not provided, it will be taken from the service configuration.
+        :param resource_config: Resource configuration, if not provided, it will be
+            taken from the resource class.
+        :param exports: List of export formats that can be used to export the record.
+            If not provided, no exports are available.
+        :param records_alias_enabled: Whether the records alias is enabled for this model.
+            Such models will be searchable via the `/api/records` endpoint.
+        """
+        self.code = code
+        self.name = name
+        self.version = version
+        self.description = description
+        self.records_alias_enabled = records_alias_enabled
+
+        # lazy getters ...
+        self._record = record
+        self._draft = draft
+        self._service = service
+        self._service_config = service_config
+        self._resource = resource
+        self._resource_config = resource_config
+        self._exports = exports or []
+
+    @property
+    def service(self) -> S:
+        """Get the service."""
+        if isinstance(self._service, str):
+            return cast(
+                "S",
+                current_service_registry.get(self._service),  # type: ignore[attr-defined]
+            )
+        return self._service
+
+    @property
+    def service_config(self) -> C:
+        """Get the service configuration."""
+        if self._service_config is not None:
+            return self._service_config
+        return cast("C", self.service.config)
+
+    @property
+    def record_cls(self) -> type[R]:
+        """Get the record class."""
+        if self._record is None:
+            return cast("type[R]", self.service.config.record_cls)
+        return self._record
+
+    @property
+    def draft_cls(self) -> type[D] | None:
+        """Get the draft class."""
+        if self._draft is None:
+            if hasattr(self.service.config, "draft_cls"):
+                return cast("type[D]", self.service.config.draft_cls)
+            return None
+        return self._draft
+
+    @property
+    def api_blueprint_name(self) -> str:
+        """Get the API blueprint name for the model."""
+        return cast("str", self.resource_config.blueprint_name)
+
+    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))
+
+    @cached_property
+    def resource_config(self) -> RC:
+        """Get the resource configuration."""
+        if isinstance(self._resource_config, str):
+            resource_config_class: type[RC] = cast("type[RC]", obj_or_import_string(self._resource_config))
+            # need to import it here to avoid circular import issues
+            from .config import build_config
+
+            return build_config(resource_config_class, current_app)
+        return self._resource_config
+
+    @cached_property
+    def resource(self) -> RR:
+        """Get the resource."""
+        if isinstance(self._resource, str):
+            resource_class = obj_or_import_string(self._resource)
+            if resource_class is None:
+                raise ValueError(f"Resource class {self._resource} can not be None.")
+            return cast(
+                "RR",
+                resource_class(
+                    service=self.service,
+                    config=self.resource_config,
+                ),
+            )
+        return self._resource
+
+    @property
+    def exports(self) -> list[Export]:
+        """Get all exportable response handlers."""
+        return self._exports
+
+    @property
+    def response_handlers(self) -> dict[str, ResponseHandler]:
+        """Get all response handlers from the resource configuration."""
+        return cast("dict[str, ResponseHandler]", self.resource_config.response_handlers)

{oarepo_runtime-2.0.0.dev3 → oarepo_runtime-2.0.0.dev5}/oarepo_runtime/config.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from invenio_i18n import lazy_gettext as _
 from invenio_vocabularies import __version__ as vocabularies_version
 
 from .api import Model
@@ -43,50 +44,68 @@ def build_config[T](config_class: type[T], app: Flask, *args: Any, **kwargs: Any
 OAREPO_MODELS: dict[str, Model] = {
     # default invenio vocabularies
     "vocabularies": Model(
-        name="vocabularies",
+        code="vocabularies",
+        name=_("Base vocabularies"),
         version=vocabularies_version,
         service="vocabularies",
         description="Base (non-specialized) invenio vocabularies",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.resources.config.VocabulariesResourceConfig",
+        resource="invenio_vocabularies.resources.resource.VocabulariesResource",
     ),
     # affiliations
     "affiliations": Model(
-        name="affiliations",
+        code="affiliations",
+        name=_("Affiliations"),
         version=vocabularies_version,
         service="affiliations",
         description="Affiliations vocabulary",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.affiliations.resources.AffiliationsResourceConfig",
+        resource="invenio_vocabularies.contrib.affiliations.resources.AffiliationsResource",
     ),
     # funders
     "funders": Model(
-        name="funders",
+        code="funders",
+        name=_("Funders"),
         version=vocabularies_version,
         service="funders",
         description="Funders vocabulary",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.funders.resources.FundersResourceConfig",
+        resource="invenio_vocabularies.contrib.funders.resources.FundersResource",
     ),
     # awards
     "awards": Model(
-        name="awards",
+        code="awards",
+        name=_("Awards"),
         version=vocabularies_version,
         service="awards",
         description="Awards vocabulary",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.awards.resources.AwardsResourceConfig",
+        resource="invenio_vocabularies.contrib.awards.resources.AwardsResource",
     ),
     # names
     "names": Model(
-        name="names",
+        code="names",
+        name=_("Names"),
         version=vocabularies_version,
         service="names",
         description="Names vocabulary",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.names.resources.NamesResourceConfig",
+        resource="invenio_vocabularies.contrib.names.resources.NamesResource",
     ),
     # subjects
     "subjects": Model(
-        name="subjects",
+        code="subjects",
+        name=_("Subjects"),
         version=vocabularies_version,
         service="subjects",
         description="Subjects vocabulary",
-        global_search_enabled=False,
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.subjects.resources.SubjectsResourceConfig",
+        resource="invenio_vocabularies.contrib.subjects.resources.SubjectsResource",
     ),
 }

{oarepo_runtime-2.0.0.dev3 → oarepo_runtime-2.0.0.dev5}/oarepo_runtime/records/systemfields/publication_status.py

@@ -47,9 +47,11 @@ class PublicationStatusSystemField(MappingSystemFieldMixin, SystemField):
     @override
     def post_dump(self, record: RecordBase, data: dict, dumper: Dumper | None = None) -> None:
         if self.key is None:
-            return
+            return  # pragma: no cover
         if not self.attr_name:
-            raise ValueError("attr_name must be set for PublicationStatusSystemField")
+            raise ValueError(  # pragma: no cover
+                "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:

oarepo_runtime-2.0.0.dev5/oarepo_runtime/services/facets/__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.
+#
+
+"""Facet parameter classes."""
+
+from __future__ import annotations

oarepo_runtime-2.0.0.dev5/oarepo_runtime/services/facets/params.py

@@ -0,0 +1,127 @@
+#
+# 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
+from typing import TYPE_CHECKING
+
+from flask import current_app
+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
+
+if TYPE_CHECKING:
+    from flask_principal import Identity
+    from invenio_records_resources.services.records.config import SearchOptions
+    from invenio_search.engine import dsl
+
+log = logging.getLogger(__name__)
+
+
+class GroupedFacetsParam(FacetsParam):
+    """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) -> dict[str, dsl.Facet]:
+        """Return the facets dictionary."""
+        return self._facets
+
+    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)  # type: ignore[no-any-return]
+
+        if hasattr(identity, "provides"):
+            return [need.value for need in identity.provides if need.method == "role"]
+
+        return []
+
+    @property
+    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  # type: ignore[no-any-return]
+        return None
+
+    def identity_facets(self, identity: Identity) -> dict[str, dsl.Facet]:
+        """Return the facets for the given identity."""
+        if not self.facet_groups:
+            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)
+        if has_system_user_id or has_system_process_need:
+            return self.facets
+
+        return self._filter_user_facets(identity)
+
+    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: dsl.Search) -> dsl.Search:
+        """Apply a post filter on the search."""
+        if not self._filters:
+            return search
+
+        filters = list(self._filters.values())
+
+        _filter = filters[0]
+        for f in filters[1:]:
+            _filter &= f
+
+        return search.filter(_filter).post_filter(_filter)
+
+    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():
+            if name in self.facets:
+                self.add_filter(name, values)
+
+        user_facets = self.identity_facets(identity)
+        self_copy = copy.copy(self)
+        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_with_user_facets(search, user_facets)
+        search = self.filter(search)
+
+        params.update(self.selected_values)
+
+        return search
+
+    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)
+        else:
+            self.facets.clear()  # TODO: why is this needed?
+            user_facets.update(self.facet_groups.get("default", {}))
+
+        groups = self.identity_facet_groups(identity)
+        for group in groups:
+            user_facets.update((self.facet_groups or {}).get(group, {}))
+        return user_facets

{oarepo_runtime-2.0.0.dev3 → oarepo_runtime-2.0.0.dev5}/pyproject.toml

@@ -14,6 +14,9 @@ dependencies = [
 ]
 requires-python = ">=3.13,<3.14"
 
+[project.urls]
+Homepage = "https://github.com/oarepo/oarepo-runtime"
+
 [project.optional-dependencies]
 dev = [
     "pytest>=7.1.2",

oarepo_runtime-2.0.0.dev3/oarepo_runtime/api.py

@@ -1,111 +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.
-#
-
-"""Runtime API classes that are returned from the current_runtime instance."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, cast
-
-from invenio_records_resources.proxies import current_service_registry
-
-if TYPE_CHECKING:
-    from flask_babel.speaklater import LazyString
-    from invenio_drafts_resources.records.api import Draft
-    from invenio_records_resources.records.api import RecordBase
-    from invenio_records_resources.services import RecordService, RecordServiceConfig
-
-
-class Model[
-    S: RecordService = RecordService,
-    C: RecordServiceConfig = RecordServiceConfig,
-    R: RecordBase = RecordBase,
-    D: Draft = Draft,
-]:
-    """Model configuration.
-
-    Every model in oarepo repository must have this configuration which must be
-    registered in the `oarepo.runtime` extension via the OAREPO_MODELS config
-    variable.
-    """
-
-    name: str | LazyString
-    version: str
-    description: str | LazyString | None = None
-    global_search_enabled: bool = False
-
-    def __init__(  # noqa: PLR0913 more attributes as we are creating a config
-        self,
-        name: str | LazyString,
-        version: str,
-        service: str | S,
-        # params with default values
-        service_config: C | None = None,
-        description: str | LazyString | None = None,
-        record: type[R] | None = None,
-        draft: type[D] | None = None,
-        global_search_enabled: bool = True,
-    ):
-        """Initialize the model configuration.
-
-        :param name: Name of the model, human readable.
-        :param version: Version of the model, should be a valid semantic version.
-        :param description: Description of the model, human readable.
-        :param service: Name of the service inside the `current_service_registry` or
-            a configured service instance.
-        :param service_config: Service configuration, if not provided,
-            if will be taken from the service.
-        :param record: Record class, if not provided, it will be taken from the service
-            configuration.
-        :param draft: Draft class, if not provided, it will be taken from the service
-            configuration.
-        """
-        self.name = name
-        self.version = version
-        self.description = description
-        self.global_search_enabled = global_search_enabled
-
-        # lazy getters ...
-        self._record = record
-        self._draft = draft
-        self._service = service
-        self._service_config = service_config
-
-    @property
-    def service(self) -> S:
-        """Get the service."""
-        if isinstance(self._service, str):
-            return cast(
-                "S",
-                current_service_registry.get(self._service),  # type: ignore[attr-defined]
-            )
-        return self._service
-
-    @property
-    def service_config(self) -> C:
-        """Get the service configuration."""
-        if self._service_config is not None:
-            return self._service_config
-        return cast("C", self.service.config)
-
-    @property
-    def record_cls(self) -> type[R]:
-        """Get the record class."""
-        if self._record is None:
-            return cast("type[R]", self.service.config.record_cls)
-        return self._record
-
-    @property
-    def draft_cls(self) -> type[D] | None:
-        """Get the draft class."""
-        if self._draft is None:
-            if hasattr(self.service.config, "draft_cls"):
-                return cast("type[D]", self.service.config.draft_cls)
-            return None
-        return self._draft