oarepo-runtime 1.5.89__py3-none-any.whl → 1.5.91__py3-none-any.whl

oarepo_runtime/info/views.py

@@ -1,9 +1,10 @@
+import importlib
 import json
 import logging
 import os
 import re
 from functools import cached_property
-from urllib.parse import urljoin
+from urllib.parse import urljoin, urlparse, urlunparse
 
 import importlib_metadata
 import importlib_resources
@@ -23,7 +24,11 @@ from flask_resources import (
 from flask_restful import abort
 from invenio_base.utils import obj_or_import_string
 from invenio_jsonschemas import current_jsonschemas
-from invenio_records_resources.proxies import current_service_registry
+from invenio_records_resources.proxies import (
+    current_service_registry,
+    current_transfer_registry,
+)
+from invenio_records_resources.records.api import Record
 
 logger = logging.getLogger("oarepo_runtime.info")
 
@@ -68,32 +73,42 @@ class InfoResource(Resource):
         """Repository endpoint."""
         links = {
             "self": url_for(request.endpoint, _external=True),
+            "api": replace_path_in_url(
+                url_for(request.endpoint, _external=True), "/api"
+            ),
             "models": url_for("oarepo_runtime_info.models", _external=True),
         }
         try:
             import invenio_requests  # noqa
+
             links["requests"] = api_url_for("requests.search", _external=True)
         except ImportError:
             pass
 
         ret = {
+            "schema": "local://introspection-v1.0.0",
             "name": current_app.config.get("THEME_SITENAME", ""),
             "description": current_app.config.get("REPOSITORY_DESCRIPTION", ""),
             "version": os.environ.get("DEPLOYMENT_VERSION", "local development"),
             "invenio_version": get_package_version("oarepo"),
-            "transfers": [
-                "local-file",
-                "url-fetch",
-                # TODO: where to get these? (permissions?)
-                # "direct-s3",
-            ],
+            "transfers": list(current_transfer_registry.get_transfer_types()),
             "links": links,
+            "features": [
+                *_add_feature_if_can_import("drafts", "invenio_drafts_resources"),
+                *_add_feature_if_can_import("workflows", "oarepo_workflows"),
+                *_add_feature_if_can_import("requests", "invenio_requests"),
+                *_add_feature_if_can_import("communities", "invenio_communities"),
+                *_add_feature_if_can_import("request_types", "oarepo_requests"),
+            ],
         }
+        if len(self.model_data) == 1:
+            ret["default_model"] = self.model_data[0]["name"]
+
         self.call_components("repository", data=ret)
         return ret, 200
 
-    @response_handler(many=True)
-    def models(self):
+    @cached_property
+    def model_data(self):
         data = []
         # iterate entrypoint oarepo.models
         for model in importlib_metadata.entry_points().select(group="oarepo.models"):
@@ -112,9 +127,9 @@ class InfoResource(Resource):
                 continue
 
             # check if the service class is inside OAREPO_GLOBAL_SEARCH and if not, skip it
-            global_search_models = current_app.config.get('GLOBAL_SEARCH_MODELS', [])
+            global_search_models = current_app.config.get("GLOBAL_SEARCH_MODELS", [])
             for global_model in global_search_models:
-                if global_model['model_service'] == model_data["service"]["class"]:
+                if global_model["model_service"] == model_data["service"]["class"]:
                     break
             else:
                 continue
@@ -122,19 +137,22 @@ class InfoResource(Resource):
             model_features = self._get_model_features(model_data)
 
             links = {
-                "api": self._get_model_api_endpoint(model_data),
                 "html": self._get_model_html_endpoint(model_data),
-                "schemas": self._get_model_schema_endpoints(model_data),
                 "model": self._get_model_model_endpoint(model.name),
                 # "openapi": url_for(self._get_model_openapi_endpoint(model_data), _external=True)
             }
 
-            links["published"] = links["api"]
+            links["records"] = self._get_model_api_endpoint(model_data)
             if "drafts" in model_features:
-                links["user_records"] = self._get_model_draft_endpoint(model_data)
+                links["drafts"] = self._get_model_draft_endpoint(model_data)
+            links["deposit"] = links["records"]
 
             data.append(
                 {
+                    "schema": "local://" + model_data["json-schema-settings"]["name"],
+                    "type": model_data.get(
+                        "model-name", model_data.get("module", {}).get("base", "")
+                    ).lower(),
                     "name": model_data.get(
                         "model-name", model_data.get("module", {}).get("base", "")
                     ).lower(),
@@ -144,11 +162,163 @@ class InfoResource(Resource):
                     "links": links,
                     # TODO: we also need to get previous schema versions here if we support
                     # multiple version of the same schema at the same time
-                    "accept": self._get_model_accept_types(service, resource_config_class),
+                    "content_types": self._get_model_content_types(
+                        service, resource_config_class, model_data
+                    ),
+                    "metadata": model_data.get("properties", {}).get("metadata", None)
+                    is not None,
                 }
             )
         self.call_components("model", data=data)
-        return data, 200
+        data.sort(key=lambda x: x["type"])
+        return data
+
+    @cached_property
+    def vocabulary_data(self):
+        ret = []
+        try:
+            from invenio_vocabularies.contrib.affiliations.api import Affiliation
+            from invenio_vocabularies.contrib.awards.api import Award
+            from invenio_vocabularies.contrib.funders.api import Funder
+            from invenio_vocabularies.contrib.names.api import Name
+            from invenio_vocabularies.contrib.subjects.api import Subject
+            from invenio_vocabularies.records.api import Vocabulary
+            from invenio_vocabularies.records.models import VocabularyType
+        except ImportError:
+            return ret
+
+        def _generate_rdm_vocabulary(
+            base_url: str,
+            record: type[Record],
+            vocabulary_type: str,
+            vocabulary_name: str,
+            vocabulary_description: str,
+            special: bool,
+            can_export: bool = True,
+            can_deposit: bool = False,
+        ) -> dict:
+            if not base_url.endswith("/"):
+                base_url += "/"
+            url_prefix = base_url + "api" if special else base_url + "api/vocabularies"
+            schema_path = base_url + record.schema.value.replace("local://", "schemas/")
+            links = dict(
+                records=f"{url_prefix}/{vocabulary_type}",
+            )
+            if can_deposit:
+                links["deposit"] = f"{url_prefix}/{vocabulary_type}"
+
+            return dict(
+                schema=record.schema.value,
+                type=vocabulary_type,
+                name=vocabulary_name,
+                description="Vocabulary for " + vocabulary_name,
+                version="unknown",
+                features=["rdm", "vocabulary"],
+                links=links,
+                content_types=[
+                    dict(
+                        content_type="application/json",
+                        name="Invenio RDM JSON",
+                        description="Vocabulary JSON",
+                        schema=schema_path,
+                        can_export=can_export,
+                        can_deposit=can_deposit,
+                    )
+                ],
+                metadata=False,
+            )
+
+        base_url = api_url_for("vocabularies.search", type="languages", _external=True)
+        base_url = replace_path_in_url(base_url, "/")
+        ret = [
+            _generate_rdm_vocabulary(
+                base_url, Affiliation, "affiliations", "Affiliations", "", special=True
+            ),
+            _generate_rdm_vocabulary(
+                base_url, Award, "awards", "Awards", "", special=True
+            ),
+            _generate_rdm_vocabulary(
+                base_url, Funder, "funders", "Funders", "", special=True
+            ),
+            _generate_rdm_vocabulary(
+                base_url, Subject, "subjects", "Subjects", "", special=True
+            ),
+            _generate_rdm_vocabulary(
+                base_url, Name, "names", "Names", "", special=True
+            ),
+            _generate_rdm_vocabulary(
+                base_url,
+                Affiliation,
+                "affiliations-vocab",
+                "Writable Affiliations",
+                "Write endpoint for affiliations",
+                special=False,
+                can_deposit=True,
+            ),
+            _generate_rdm_vocabulary(
+                base_url,
+                Award,
+                "awards-vocab",
+                "Writable Awards",
+                "Write endpoint for awards",
+                special=False,
+                can_deposit=True,
+            ),
+            _generate_rdm_vocabulary(
+                base_url,
+                Funder,
+                "funders-vocab",
+                "Writable Funders",
+                "Write endpoint for funders",
+                special=False,
+                can_deposit=True,
+            ),
+            _generate_rdm_vocabulary(
+                base_url,
+                Subject,
+                "subjects-vocab",
+                "Writable Subjects",
+                "Write endpoint for subjects",
+                special=False,
+                can_deposit=True,
+            ),
+            _generate_rdm_vocabulary(
+                base_url,
+                Name,
+                "names-vocab",
+                "Writable Names",
+                "Write endpoint for names",
+                special=False,
+                can_deposit=True,
+            ),
+        ]
+
+        vc_types = {vc.id for vc in VocabularyType.query.all()}
+        vocab_type_metadata = current_app.config.get(
+            "INVENIO_VOCABULARY_TYPE_METADATA", {}
+        )
+        vc_types.update(vocab_type_metadata.keys())
+
+        for vc in sorted(vc_types):
+            vc_metadata = vocab_type_metadata.get(vc, {})
+            ret.append(
+                _generate_rdm_vocabulary(
+                    base_url,
+                    Vocabulary,
+                    vc,
+                    to_current_language(vc_metadata.get("name")) or vc,
+                    to_current_language(vc_metadata.get("description")) or "",
+                    special=False,
+                    can_export=True,
+                    can_deposit=True,
+                )
+            )
+
+        return ret
+
+    @response_handler(many=True)
+    def models(self):
+        return self.model_data + self.vocabulary_data, 200
 
     @schema_view_args
     @response_handler()
@@ -161,7 +331,7 @@ class InfoResource(Resource):
     def model(self):
         model = resource_requestctx.view_args["model"]
         for _model in importlib_metadata.entry_points().select(
-                group="oarepo.models", name=model
+            group="oarepo.models", name=model
         ):
             package_name, file_name = _model.value.split(":")
             model_data = json.loads(
@@ -254,10 +424,17 @@ class InfoResource(Resource):
             logger.exception("Failed to get model html endpoint")
             return None
 
+    def _get_model_model_endpoint(self, model):
+        try:
+            return url_for("oarepo_runtime_info.model", model=model, _external=True)
+        except:  # NOSONAR noqa
+            logger.exception("Failed to get model model endpoint")
+            return None
+
     def _get_model_schema_endpoints(self, model):
         try:
             return {
-                'application/json': url_for(
+                "application/json": url_for(
                     "oarepo_runtime_info.schema",
                     schema=model["json-schema-settings"]["name"],
                     _external=True,
@@ -267,32 +444,60 @@ class InfoResource(Resource):
             logger.exception("Failed to get model schema endpoint")
             return None
 
-    def _get_model_model_endpoint(self, model):
-        try:
-            return url_for("oarepo_runtime_info.model", model=model, _external=True)
-        except:  # NOSONAR noqa
-            logger.exception("Failed to get model model endpoint")
-            return None
+    def _get_model_content_types(self, service, resource_config, model):
+        """Get the content types supported by the model. Returns a list of:
+
+        content_type="application/json",
+        name="Invenio RDM JSON",
+        description="Invenio RDM JSON as described in",
+        schema=url / "schemas" / "records" / "record-v6.0.0.json",
+        can_export=True,
+        can_deposit=True,
+        """
+
+        content_types = []
+        # implicit content type
+        content_types.append(
+            {
+                "content_type": "application/json",
+                "name": f"Internal json serialization of {model['model-name']}",
+                "description": "This content type is serving this model's native format as described on model link.",
+                "schema": url_for(
+                    "oarepo_runtime_info.schema",
+                    schema=model["json-schema-settings"]["name"],
+                    _external=True,
+                ),
+                "can_export": True,
+                "can_deposit": True,
+            }
+        )
 
-    def _get_model_accept_types(self, service, resource_config):
+        # export content types
         try:
-            record_cls = service.config.record_cls
-            schema = getattr(record_cls, "schema", None)
-            accept_types = []
             for accept_type, handler in resource_config.response_handlers.items():
-                curr_item = {'accept': accept_type}
-                if handler.serializer is not None and hasattr(handler.serializer, "info"):
-                    curr_item.update(handler.serializer.info(service))
-                accept_types.append(curr_item)
-
-            return accept_types
+                if accept_type == "application/json":
+                    continue
+                curr_item = {
+                    "content_type": accept_type,
+                    "name": getattr(handler, "name", accept_type),
+                    "description": getattr(handler, "description", ""),
+                    "can_export": True,
+                    "can_deposit": False,
+                }
+                if handler.serializer is not None:
+                    if hasattr(handler.serializer, "name"):
+                        curr_item["name"] = handler.serializer.name
+                    if hasattr(handler.serializer, "description"):
+                        curr_item["description"] = handler.serializer.description
+                    if hasattr(handler.serializer, "info"):
+                        curr_item.update(handler.serializer.info(service))
+                content_types.append(curr_item)
         except:  # NOSONAR noqa
             logger.exception("Failed to get model schemas")
-        return {}
-
+        return content_types
 
     def _get_resource_config_class(self, model_data):
-        model_class = model_data['resource-config']['class']
+        model_class = model_data["resource-config"]["class"]
         return obj_or_import_string(model_class)()
 
     def _get_service(self, model_data):
@@ -350,3 +555,32 @@ def api_url_for(endpoint, _external=True, **values):
         )
     finally:
         _cv_request.set(current_request_context)
+
+
+def replace_path_in_url(url, path):
+    # Parse the URL into its components
+    parsed_url = urlparse(url)
+
+    # Replace the path with '/api'
+    new_parsed_url = parsed_url._replace(path=path)
+
+    # Reconstruct the URL with the new path
+    new_url = urlunparse(new_parsed_url)
+
+    return new_url
+
+
+def _add_feature_if_can_import(feature, module):
+    try:
+        importlib.import_module(module)
+        return [feature]
+    except ImportError:
+        return []
+
+
+def to_current_language(data):
+    if isinstance(data, dict):
+        from flask_babel import get_locale
+
+        return data.get(get_locale().language)
+    return data

oarepo_runtime/services/components.py

@@ -1,17 +1,30 @@
+from __future__ import annotations
+
 import inspect
 from collections import defaultdict
+from dataclasses import dataclass, field
 from typing import Type
 
 from flask import current_app
 from invenio_accounts.models import User
+from invenio_base.utils import obj_or_import_string
+from invenio_drafts_resources.services.records.config import (
+    RecordServiceConfig as DraftsRecordServiceConfig,
+)
+from invenio_rdm_records.services.config import RDMRecordServiceConfig
 from invenio_records import Record
+from invenio_records_resources.services import FileServiceConfig
+from invenio_records_resources.services.records.config import (
+    RecordServiceConfig as RecordsRecordServiceConfig,
+)
 
-from oarepo_runtime.services.custom_fields import CustomFieldsMixin, CustomFields, InlinedCustomFields
+from oarepo_runtime.services.custom_fields import (
+    CustomFields,
+    CustomFieldsMixin,
+    InlinedCustomFields,
+)
 from oarepo_runtime.services.generators import RecordOwners
-from invenio_rdm_records.services.config import RDMRecordServiceConfig
-from invenio_drafts_resources.services.records.config import RecordServiceConfig as DraftsRecordServiceConfig
-from invenio_records_resources.services.records.config import RecordServiceConfig as RecordsRecordServiceConfig
-from invenio_records_resources.services import  FileServiceConfig
+
 try:
     from invenio_drafts_resources.services.records.uow import ParentRecordCommitOp
 except ImportError:
@@ -62,18 +75,23 @@ class DateIssuedComponent(ServiceComponent):
         if "dateIssued" not in record["metadata"]:
             record["metadata"]["dateIssued"] = datetime.today().strftime("%Y-%m-%d")
 
+
 class CFRegistry:
     def __init__(self):
         self.custom_field_names = defaultdict(list)
 
     def lookup(self, record_type: Type[Record]):
         if record_type not in self.custom_field_names:
-            for fld in inspect.getmembers(record_type, lambda x: isinstance(x, CustomFieldsMixin)):
+            for fld in inspect.getmembers(
+                record_type, lambda x: isinstance(x, CustomFieldsMixin)
+            ):
                 self.custom_field_names[record_type].append(fld[1])
         return self.custom_field_names[record_type]
 
+
 cf_registry = CFRegistry()
 
+
 class CustomFieldsComponent(ServiceComponent):
     def create(self, identity, data=None, record=None, **kwargs):
         """Create a new record."""
@@ -90,16 +108,16 @@ class CustomFieldsComponent(ServiceComponent):
             elif isinstance(cf, InlinedCustomFields):
                 config = current_app.config.get(cf.config_key, {})
                 for c in config:
-                    record[c.name] =data.get(c.name)
+                    record[c.name] = data.get(c.name)
 
-def process_service_configs(service_config):
 
+def process_service_configs(service_config, *additional_components):
     processed_components = []
     target_classes = {
         RDMRecordServiceConfig,
         DraftsRecordServiceConfig,
         RecordsRecordServiceConfig,
-        FileServiceConfig
+        FileServiceConfig,
     }
 
     for end_index, cls in enumerate(type(service_config).mro()):
@@ -110,19 +128,160 @@ def process_service_configs(service_config):
     # there are two service_config instances in the MRO (Method Resolution Order) output.
     start_index = 2 if hasattr(service_config, "build") else 1
 
-    service_configs = type(service_config).mro()[start_index:end_index + 1]
+    service_configs = type(service_config).mro()[start_index : end_index + 1]
     for config in service_configs:
-
         if hasattr(config, "build"):
             config = config.build(current_app)
 
-        if hasattr(config, 'components'):
+        if hasattr(config, "components"):
             component_property = config.components
             if isinstance(component_property, list):
                 processed_components.extend(component_property)
             elif isinstance(component_property, tuple):
-                processed_components.extend(list (component_property))
+                processed_components.extend(list(component_property))
             else:
                 raise ValueError(f"{config} component's definition is not supported")
 
-    return processed_components
+    processed_components.extend(additional_components)
+    processed_components = _sort_components(processed_components)
+    return processed_components
+
+
+@dataclass
+class ComponentPlacement:
+    """Component placement in the list of components.
+
+    This is a helper class used in the component ordering algorithm.
+    """
+
+    component: Type[ServiceComponent]
+    """Component to be ordered."""
+
+    depends_on: list[ComponentPlacement] = field(default_factory=list)
+    """List of components this one depends on.
+    
+    The components must be classes of ServiceComponent or '*' to denote
+    that this component depends on all other components and should be placed last.
+    """
+
+    affects: list[ComponentPlacement] = field(default_factory=list)
+    """List of components that depend on this one.
+    
+    This is a temporary list used for evaluation of '*' dependencies
+    but does not take part in the sorting algorithm."""
+
+    def __hash__(self) -> int:
+        return id(self.component)
+
+    def __eq__(self, other: ComponentPlacement) -> bool:
+        return self.component is other.component
+
+
+def _sort_components(components):
+    """Sort components based on their dependencies while trying to
+    keep the initial order as far as possible."""
+
+    placements: list[ComponentPlacement] = _prepare_component_placement(components)
+    placements = _propagate_dependencies(placements)
+
+    ret = []
+    while placements:
+        without_dependencies = [p for p in placements if not p.depends_on]
+        if not without_dependencies:
+            raise ValueError("Circular dependency detected in components.")
+        for p in without_dependencies:
+            ret.append(p.component)
+            placements.remove(p)
+            for p2 in placements:
+                if p in p2.depends_on:
+                    p2.depends_on.remove(p)
+    return ret
+
+
+def _matching_placements(placements, dep_class_or_factory):
+    for pl in placements:
+        pl_component = pl.component
+        if not inspect.isclass(pl_component):
+            pl_component = type(pl_component(service=object()))
+        if issubclass(pl_component, dep_class_or_factory):
+            yield pl
+
+
+def _prepare_component_placement(components) -> list[ComponentPlacement]:
+    """Convert components to ComponentPlacement instances and resolve dependencies."""
+    placements = []
+    for idx, c in enumerate(components):
+        placement = ComponentPlacement(component=c)
+        placements.append(placement)
+
+    # direct dependencies
+    for idx, placement in enumerate(placements):
+        placements_without_this = placements[:idx] + placements[idx + 1 :]
+        for dep in getattr(placement.component, "depends_on", []):
+            if dep == "*":
+                continue
+            dep = obj_or_import_string(dep)
+            for pl in _matching_placements(placements_without_this, dep):
+                if pl not in placement.depends_on:
+                    placement.depends_on.append(pl)
+                if placement not in pl.affects:
+                    pl.affects.append(placement)
+
+        for dep in getattr(placement.component, "affects", []):
+            if dep == "*":
+                continue
+            dep = obj_or_import_string(dep)
+            for pl in _matching_placements(placements_without_this, dep):
+                if pl not in placement.affects:
+                    placement.affects.append(pl)
+                if placement not in pl.depends_on:
+                    pl.depends_on.append(placement)
+
+    # star dependencies
+    for idx, placement in enumerate(placements):
+        placements_without_this = placements[:idx] + placements[idx + 1 :]
+        if "*" in getattr(placement.component, "depends_on", []):
+            for pl in placements_without_this:
+                # if this placement is not in placements that pl depends on
+                # (added via direct dependencies above), add it
+                if placement not in pl.depends_on:
+                    if pl not in placement.depends_on:
+                        placement.depends_on.append(pl)
+                    if placement not in pl.affects:
+                        pl.affects.append(placement)
+
+        if "*" in getattr(placement.component, "affects", []):
+            for pl in placements_without_this:
+                # if this placement is not in placements that pl affects
+                # (added via direct dependencies above), add it
+                if placement not in pl.affects:
+                    if pl not in placement.affects:
+                        placement.affects.append(pl)
+                    if placement not in pl.depends_on:
+                        pl.depends_on.append(placement)
+    return placements
+
+
+def _propagate_dependencies(
+    placements: list[ComponentPlacement],
+) -> list[ComponentPlacement]:
+    # now propagate dependencies
+    dependency_propagated = True
+    while dependency_propagated:
+        dependency_propagated = False
+        for placement in placements:
+            for dep in placement.depends_on:
+                for dep_of_dep in dep.depends_on:
+                    if dep_of_dep not in placement.depends_on:
+                        placement.depends_on.append(dep_of_dep)
+                        dep_of_dep.affects.append(placement)
+                        dependency_propagated = True
+
+            for dep in placement.affects:
+                for dep_of_dep in dep.affects:
+                    if dep_of_dep not in placement.affects:
+                        placement.affects.append(dep_of_dep)
+                        dep_of_dep.depends_on.append(placement)
+                        dependency_propagated = True
+
+    return placements

{oarepo_runtime-1.5.89.dist-info → oarepo_runtime-1.5.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: oarepo-runtime
-Version: 1.5.89
+Version: 1.5.91
 Summary: A set of runtime extensions of Invenio repository
 Description-Content-Type: text/markdown
 License-File: LICENSE

{oarepo_runtime-1.5.89.dist-info → oarepo_runtime-1.5.91.dist-info}/RECORD

@@ -43,7 +43,7 @@ oarepo_runtime/datastreams/writers/yaml.py,sha256=XchUJHQ58E2Mfgs8elImXbL38jFtI8
 oarepo_runtime/i18n/__init__.py,sha256=h0knW_HwiyIt5TBHfdGqN7_BBYfpz1Fw6zhVy0C28fM,111
 oarepo_runtime/info/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 oarepo_runtime/info/check.py,sha256=6O5Wjsdorx4eqiBiPU3z33XhCiwPTO_FGkzMDK7UH6I,3049
-oarepo_runtime/info/views.py,sha256=q9PG46aM-1ihaVxJGjfcD5HvJWanM28gMefao8FIQk4,12440
+oarepo_runtime/info/views.py,sha256=5ygLgiZilk33OhrnB0h83-MG6K8nsmJFOiJaTBQc43c,21070
 oarepo_runtime/records/__init__.py,sha256=JUf9_o09_6q4vuG43JzhSeTu7c-m_CVDSmgTQ7epYEo,1776
 oarepo_runtime/records/dumpers/__init__.py,sha256=OmzNhLdMNKibmCksnj9eTX9xPBG30dziiK3j3bAAp3k,233
 oarepo_runtime/records/dumpers/edtf_interval.py,sha256=YCShZAoqBQYaxVilEVotS-jXZsxxoXO67yu2urhkaMA,1198
@@ -73,7 +73,7 @@ oarepo_runtime/resources/file_resource.py,sha256=Ta3bFce7l0xwqkkOMOEu9mxbB8BbKj5
 oarepo_runtime/resources/json_serializer.py,sha256=82_-xQEtxKaPakv8R1oBAFbGnxskF_Ve4tcfcy4PetI,963
 oarepo_runtime/resources/localized_ui_json_serializer.py,sha256=3V9cJaG_e1PMXKVX_wKfBp1LmbeForwHyBNYdyha4uQ,1878
 oarepo_runtime/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oarepo_runtime/services/components.py,sha256=rCdK3amTM2PAihiRFnaoN_Xkm35W-PreAPjm-gAJFww,4902
+oarepo_runtime/services/components.py,sha256=h7oQNPueuPqBD6mCRCIr7ZuNvzeliXinHjOyVV3FBvw,10775
 oarepo_runtime/services/generators.py,sha256=j87HitHA_w2awsz0C5IAAJ0qjg9JMtvdO3dvh6FQyfg,250
 oarepo_runtime/services/results.py,sha256=Ap2mUJHl3V4BSduTrBWPuco0inQVq0QsuCbVhez48uY,5705
 oarepo_runtime/services/search.py,sha256=9xGTN5Yg6eTdptQ9qjO_umbacf9ooMuHYGXWYfla4-M,6227
@@ -135,9 +135,9 @@ tests/marshmallow_to_json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 tests/marshmallow_to_json/test_datacite_ui_schema.py,sha256=82iLj8nW45lZOUewpWbLX3mpSkpa9lxo-vK-Qtv_1bU,48552
 tests/marshmallow_to_json/test_simple_schema.py,sha256=izZN9p0v6kovtSZ6AdxBYmK_c6ZOti2_z_wPT_zXIr0,1500
 tests/pkg_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oarepo_runtime-1.5.89.dist-info/LICENSE,sha256=h2uWz0OaB3EN-J1ImdGJZzc7yvfQjvHVYdUhQ-H7ypY,1064
-oarepo_runtime-1.5.89.dist-info/METADATA,sha256=2WAbKmJSznmufN3BQhjw5i4Sn_ZA_RRgkdwWuAOb0DY,4720
-oarepo_runtime-1.5.89.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-oarepo_runtime-1.5.89.dist-info/entry_points.txt,sha256=k7O5LZUOGsVeSpB7ulU0txBUNp1CVQG7Q7TJIVTPbzU,491
-oarepo_runtime-1.5.89.dist-info/top_level.txt,sha256=bHhlkT1_RQC4IkfTQCqA3iN4KCB6cSFQlsXpQMSP-bE,21
-oarepo_runtime-1.5.89.dist-info/RECORD,,
+oarepo_runtime-1.5.91.dist-info/LICENSE,sha256=h2uWz0OaB3EN-J1ImdGJZzc7yvfQjvHVYdUhQ-H7ypY,1064
+oarepo_runtime-1.5.91.dist-info/METADATA,sha256=ummUvZcf6ncHllBBplL7Pp3L0ZzLuatkfQ52spuTV8s,4720
+oarepo_runtime-1.5.91.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+oarepo_runtime-1.5.91.dist-info/entry_points.txt,sha256=k7O5LZUOGsVeSpB7ulU0txBUNp1CVQG7Q7TJIVTPbzU,491
+oarepo_runtime-1.5.91.dist-info/top_level.txt,sha256=bHhlkT1_RQC4IkfTQCqA3iN4KCB6cSFQlsXpQMSP-bE,21
+oarepo_runtime-1.5.91.dist-info/RECORD,,