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

oarepo_runtime/__init__.py

@@ -0,0 +1,24 @@
+#
+# 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.
+#
+
+"""OARepo Runtime package.
+
+This package provides support for custom fields identification and iteration and `invenio oarepo cf init`
+initialization tool for customfields.
+"""
+
+from __future__ import annotations
+
+from .api import Model
+from .ext import OARepoRuntime
+from .proxies import current_runtime
+
+__version__ = "2.0.0dev4"
+
+__all__ = ("Model", "OARepoRuntime", "__version__", "current_runtime")

oarepo_runtime/api.py

@@ -0,0 +1,210 @@
+#
+# 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, cast
+
+from flask import current_app
+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.
+    """
+
+    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.
+    """
+
+    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,
+        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.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
+
+    @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/cli/__init__.py

@@ -1,22 +1,11 @@
-from .assets import assets
-from .base import as_command, oarepo
-from .cf import cf
-from .check import check
-from .configuration import configuration_command
-from .fixtures import fixtures
-from .index import index
-from .permissions import permissions
-from .validate import validate
+#
+# 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.
+#
+"""OAREPO Runtime CLI module."""
 
-__all__ = (
-    "oarepo",
-    "index",
-    "as_command",
-    "assets",
-    "check",
-    "validate",
-    "fixtures",
-    "configuration_command",
-    "permissions",
-    "cf",
-)
+from __future__ import annotations

oarepo_runtime/cli/search.py

@@ -0,0 +1,34 @@
+#
+# 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.
+#
+"""OARepo extensions to the index command."""
+
+from __future__ import annotations
+
+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)
+@with_appcontext
+@search_version_check
+@click.pass_context
+def init(ctx: click.Context, force: bool) -> None:
+    """Initialize registered aliases and mappings.
+
+    This command initializes the search indices by creating templates, component templates,
+    index templates, and the actual indices. It will also create all dynamic mappings
+    defined inside the models.
+    """
+    ctx.invoke(original_init, force=force)
+    update_all_records_mappings()

oarepo_runtime/config.py

@@ -1,19 +1,104 @@
-from typing import Any, cast
+#
+# 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.
+#
 
-from flask import Flask
+"""Config module."""
 
+from __future__ import annotations
 
-def build_config[T: type](config_class: T, app: Flask, *args: Any, **kwargs: Any) -> T:
-    """
-    Builds the configuration for the service
+from typing import TYPE_CHECKING, Any
+
+from invenio_vocabularies import __version__ as vocabularies_version
+
+from .api import Model
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from flask import Flask
 
-    This function is used to build the configuration for the service
+
+def build_config[T](config_class: type[T], app: Flask, *args: Any, **kwargs: Any) -> T:
+    """Build the configuration for the service.
+
+    This function is used to build the configuration for the service.
     """
-    if hasattr(config_class, "build") and callable(config_class.build):
+    build_config: Callable[[Flask], T] | None = getattr(config_class, "build", None)
+    if build_config is not None and callable(build_config):
         if args or kwargs:
-            raise ValueError(
-                "Can not pass extra arguments when invenio ConfigMixin is used"
-            )
-        return cast(T, config_class.build(app))
-    else:
-        return config_class(*args, **kwargs)
+            raise ValueError("Can not pass extra arguments when invenio ConfigMixin is used")
+        return build_config(app)
+    return config_class(*args, **kwargs)
+
+
+#
+# Configuration for the extension.
+#
+
+OAREPO_MODELS: dict[str, Model] = {
+    # default invenio vocabularies
+    "vocabularies": Model(
+        name="vocabularies",
+        version=vocabularies_version,
+        service="vocabularies",
+        description="Base (non-specialized) invenio vocabularies",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.resources.config.VocabulariesResourceConfig",
+        resource="invenio_vocabularies.resources.resource.VocabulariesResource",
+    ),
+    # affiliations
+    "affiliations": Model(
+        name="affiliations",
+        version=vocabularies_version,
+        service="affiliations",
+        description="Affiliations vocabulary",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.affiliations.resources.AffiliationsResourceConfig",
+        resource="invenio_vocabularies.contrib.affiliations.resources.AffiliationsResource",
+    ),
+    # funders
+    "funders": Model(
+        name="funders",
+        version=vocabularies_version,
+        service="funders",
+        description="Funders vocabulary",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.funders.resources.FundersResourceConfig",
+        resource="invenio_vocabularies.contrib.funders.resources.FundersResource",
+    ),
+    # awards
+    "awards": Model(
+        name="awards",
+        version=vocabularies_version,
+        service="awards",
+        description="Awards vocabulary",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.awards.resources.AwardsResourceConfig",
+        resource="invenio_vocabularies.contrib.awards.resources.AwardsResource",
+    ),
+    # names
+    "names": Model(
+        name="names",
+        version=vocabularies_version,
+        service="names",
+        description="Names vocabulary",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.names.resources.NamesResourceConfig",
+        resource="invenio_vocabularies.contrib.names.resources.NamesResource",
+    ),
+    # subjects
+    "subjects": Model(
+        name="subjects",
+        version=vocabularies_version,
+        service="subjects",
+        description="Subjects vocabulary",
+        records_alias_enabled=False,
+        resource_config="invenio_vocabularies.contrib.subjects.resources.SubjectsResourceConfig",
+        resource="invenio_vocabularies.contrib.subjects.resources.SubjectsResource",
+    ),
+}

oarepo_runtime/ext.py

@@ -1,102 +1,84 @@
-from functools import cached_property
+#
+# 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."""
 
-import pytz
-from flask import current_app, session
-from invenio_accounts.models import User
-from invenio_base.utils import obj_or_import_string
+from __future__ import annotations
 
-from .cli import oarepo as oarepo_cmd
-from .datastreams.ext import OARepoDataStreamsExt
-from .proxies import current_timezone
+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
 
-def set_timezone():
-    if "timezone" in session:
-        current_timezone.set(pytz.timezone(session["timezone"]))
-    else:
-        default_user_timezone = current_app.config.get("BABEL_DEFAULT_TIMEZONE")
-        if default_user_timezone:
-            current_timezone.set(pytz.timezone(default_user_timezone))
-        else:
-            current_timezone.set(None)
+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
 
-def on_identity_changed(sender, identity):
-    if "timezone" not in session and "_user_id" in session:
-        user = User.query.filter_by(id=session["_user_id"]).first()
-        if user and "timezone" in user.preferences:
-            session["timezone"] = user.preferences["timezone"]
-    set_timezone()
+    from .api import Model
 
 
-class OARepoRuntime(object):
-    """OARepo extension of Invenio-Vocabularies."""
+class OARepoRuntime:
+    """OARepo base of invenio oarepo client."""
 
-    def __init__(self, app=None):
+    def __init__(self, app: Flask | None = None):
         """Extension initialization."""
         if app:
             self.init_app(app)
 
-    def init_app(self, app):
+    def init_app(self, app: Flask) -> None:
         """Flask application initialization."""
-        self.init_config(app)
         self.app = app
+        self.init_config(app)
         app.extensions["oarepo-runtime"] = self
-        app.extensions["oarepo-datastreams"] = OARepoDataStreamsExt(app)
-        app.cli.add_command(oarepo_cmd)
-
-        from flask_principal import identity_changed
 
-        identity_changed.connect(on_identity_changed, self.app)
-        app.before_request(set_timezone)
+    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
 
-    @cached_property
-    def owner_entity_resolvers(self):
-        return [
-            obj_or_import_string(x) for x in self.app.config["OWNER_ENTITY_RESOLVERS"]
-        ]
+    @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 rdm_excluded_components(self):
-        return [
-            obj_or_import_string(x)
-            for x in self.app.config.get("RDM_EXCLUDED_COMPONENTS", [])
-        ]
-
-    def init_config(self, app):
-        """Initialize configuration."""
-        from . import ext_config
-
-        if "OAREPO_PERMISSIONS_PRESETS" not in app.config:
-            app.config["OAREPO_PERMISSIONS_PRESETS"] = {}
-
-        for k in ext_config.OAREPO_PERMISSIONS_PRESETS:
-            if k not in app.config["OAREPO_PERMISSIONS_PRESETS"]:
-                app.config["OAREPO_PERMISSIONS_PRESETS"][k] = (
-                    ext_config.OAREPO_PERMISSIONS_PRESETS[k]
-                )
-
-        for k in dir(ext_config):
-            if k == "DEFAULT_DATASTREAMS_EXCLUDES":
-                app.config.setdefault(k, []).extend(getattr(ext_config, k))
-
-            elif k.startswith("DATASTREAMS_"):
-                val = getattr(ext_config, k)
-                if isinstance(val, dict):
-                    self.add_non_existing(app.config.setdefault(k, {}), val)
-                else:
-                    app.config.setdefault(k, val)
-
-            elif k == "HAS_DRAFT_CUSTOM_FIELD":
-                app.config.setdefault(k, getattr(ext_config, k))
-
-            elif k == "OAREPO_FACET_GROUP_NAME":
-                app.config.setdefault(k, getattr(ext_config, k))
-
-            elif k == "OWNER_ENTITY_RESOLVERS":
-                app.config.setdefault(k, []).extend(getattr(ext_config, k))
-
-    def add_non_existing(self, target, source):
-        for val_k, val_value in source.items():
-            if val_k not in target:
-                target[val_k] = val_value
+    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__}'.")

oarepo_runtime/proxies.py

@@ -1,8 +1,24 @@
+#
+# 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.
+#
+
+"""Proxies."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from flask import current_app
 from werkzeug.local import LocalProxy
-from contextvars import ContextVar
 
-current_timezone = ContextVar('timezone') #idk how or exactly why to use the LocalProxy here
-current_datastreams = LocalProxy(lambda: current_app.extensions["oarepo-datastreams"])
-current_oarepo = LocalProxy(lambda: current_app.extensions["oarepo-runtime"])
-"""Helper proxy to get the current datastreams."""
+if TYPE_CHECKING:
+    from oarepo_runtime.ext import OARepoRuntime
+
+    current_runtime: OARepoRuntime
+
+current_runtime = LocalProxy(lambda: current_app.extensions["oarepo-runtime"])  # type: ignore[assignment]