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

oarepo_runtime/records/systemfields/synthetic.py

@@ -1,130 +0,0 @@
-import logging
-
-from invenio_records.systemfields import SystemField
-
-from . import Selector
-from .mapping import MappingSystemFieldMixin
-
-log = logging.getLogger(__name__)
-
-
-class SyntheticSystemField(MappingSystemFieldMixin, SystemField):
-    """
-        A class that provides a synthetic system field, that is a system field that
-        generates its content from what is already present inside the record.
-
-        The field is not stored in the record, but is generated on the fly when
-        the record is being indexed.
-
-        Usage:
-        1. Check if any of the provided selectors (oarepo_runtime.records.systemfields.selectors)
-           are usable for your use case. If not, create a subclass of Selector class.
-        2. Put this class onto the record. If you use oarepo-model-builder, add it to the model
-           like:
-           ```yaml
-    record:
-      record:
-        imports:
-          - oarepo_runtime.records.systemfields.SyntheticSystemField
-          - oarepo_vocabularies.records.selectors.LevelSelector
-        fields:
-          faculty = SyntheticSystemField(selector=LevelSelector("metadata.thesis.degreeGrantors", level=1))
-          department = SyntheticSystemField(selector=LevelSelector("metadata.thesis.degreeGrantors", level=2))
-          defenseYear = |
-            SyntheticSystemField(selector=PathSelector("metadata.thesis.dateDefended"),
-                transformer=lambda x: x[:4]
-            )
-           ```
-
-        4. Add the extra fields to the mapping and facets. If using oarepo-model-builder, add it to the
-           model like the following piece of code and compile the model:
-           ```yaml
-    record:
-      properties:
-        faculty:
-          type: vocabulary
-          vocabulary-type: institutions
-          facets:
-            facet-groups:
-            - default
-          label.cs: Fakulta
-          label.en: Faculty
-
-
-        department:
-          type: vocabulary
-          vocabulary-type: institutions
-          facets:
-            facet-groups:
-            - default
-          label.cs: Ústav
-          label.en: Department
-
-        defenseYear:
-          type: integer
-          facets:
-            facet-groups:
-            - default
-          label.cs: Rok obhajoby
-          label.en: Defense year
-           ```
-    """
-
-    def __init__(
-        self, selector: Selector = None, filter=None, map=None, key=None, **kwargs
-    ):
-        self.selector = selector
-        self.map = map
-        self.filter = filter
-        super().__init__(key=key, **kwargs)
-
-    def search_dump(self, data, record):
-        dt = self._value(data)
-        if dt:
-            key = self.key.split(".")
-            d = data
-            for k in key[:-1]:
-                d = d.setdefault(k, {})
-            d[key[-1]] = dt
-
-    def search_load(self, data, record_cls):
-        def remove_key(d, key):
-            if len(key) == 1:
-                d.pop(key[0], None)
-            else:
-                if not isinstance(d, dict) or key[0] not in d:
-                    return
-                remove_key(d[key[0]], key[1:])
-                if not d[key[0]]:
-                    d.pop(key[0])
-
-        remove_key(data, self.key.split("."))
-
-    def __get__(self, record, owner=None):
-        if record is None:
-            return self
-        return self._value(record)
-
-    def _value(self, data):
-        if self.selector:
-            try:
-                value = list(self.selector.select(data) or [])
-                value = [x for x in value if x is not None]
-                if self.filter:
-                    value = [x for x in value if self.filter(x)]
-                if self.map:
-                    ret = []
-                    for x in value:
-                        mapped = self.map(x)
-                        if isinstance(mapped, list):
-                            ret.extend(mapped)
-                        elif mapped is not None:
-                            ret.append(mapped)
-                    value = ret
-                return value
-            except:
-                log.exception(f"Error in selector {self.selector} for {self.key}")
-                return []
-        raise ValueError(
-            "Please either provide a selector or subclass this class and implement a _value method"
-        )

oarepo_runtime/resources/__init__.py

@@ -1,4 +0,0 @@
-from .file_resource import S3RedirectFileResource
-from .localized_ui_json_serializer import LocalizedUIJSONSerializer
-
-__all__ = ("LocalizedUIJSONSerializer", "S3RedirectFileResource")

oarepo_runtime/resources/config.py

@@ -1,12 +0,0 @@
-from invenio_rdm_records.resources.config import (
-    RDMRecordResourceConfig,
-)
-
-class BaseRecordResourceConfig(RDMRecordResourceConfig):
-    """Record resource configuration."""
-
-    blueprint_name = None
-    url_prefix = None
-
-    routes = RDMRecordResourceConfig.routes
-    routes["all-prefix"] = "/all"

oarepo_runtime/resources/file_resource.py

@@ -1,15 +0,0 @@
-from invenio_records_resources.resources import FileResource
-
-
-class S3RedirectFileResource(FileResource):
-    """
-    A workaround for the fact that the file resource with S3 backend does not
-    return HTTP 302 for pre-signed URLs.
-    """
-
-    def read_content(self):
-        ret = super().read_content()
-        if ret[0].status_code == 302:
-            return ret[0], 302
-        else:
-            return ret

oarepo_runtime/resources/json_serializer.py

@@ -1,27 +0,0 @@
-from flask import url_for
-from flask_resources import JSONSerializer as FlaskJSONSerializer
-from invenio_records_resources.services import Service
-
-
-class JSONSerializer(FlaskJSONSerializer):
-
-    def info(self, service:Service) -> dict:
-        ret = {'description': "Invenio RDM JSON Serialization",
-                'name': "JSON Serialization"
-               }
-
-        schema_value = service.config.record_cls.schema.value
-        if schema_value:
-            ret['schema'] = schema_value
-            if schema_value.startswith("local://"):
-                schema_value = schema_value.replace("local://", "")
-                ret['schema_url'] = url_for(
-                    "oarepo_runtime_info.schema",
-                    schema= schema_value,
-                    _external=True,
-                )
-            elif schema_value.startwith("http://") or schema_value.startwith("https://"):
-                ret['schema_url'] = schema_value
-
-
-        return ret

oarepo_runtime/resources/localized_ui_json_serializer.py

@@ -1,54 +0,0 @@
-import marshmallow
-from flask_resources import MarshmallowSerializer
-
-from oarepo_runtime.i18n import get_locale
-
-
-class LocalizedUIJSONSerializer(MarshmallowSerializer):
-    def __init__(
-        self,
-        format_serializer_cls,
-        object_schema_cls,
-        list_schema_cls=None,
-        schema_context=None,
-        **serializer_options,
-    ):
-        # the constructor instantiates the object_schema_cls, which is too early
-        # if the schema uses current_app (for example, for translations or custom fields)
-        # so we pass an empty schema and replace it later
-        super().__init__(
-            format_serializer_cls=format_serializer_cls,
-            object_schema_cls=marshmallow.Schema,
-            list_schema_cls=marshmallow.Schema,
-            schema_context=schema_context or {},
-            **serializer_options,
-        )
-        # replace the object schema class
-        self.object_schema_cls = object_schema_cls
-        self.list_schema_cls = list_schema_cls
-
-    def dump_obj(self, obj, *args, **kwargs):
-        """Dump the object using object schema class."""
-        ctx = {**self.schema_context, "locale": get_locale()}
-        if "extra_context" in kwargs:
-            ctx |= kwargs["extra_context"]
-
-        return self.object_schema_cls(context=ctx).dump(obj)
-
-    def dump_list(self, obj_list, *args, **kwargs):
-        """Dump the list of objects."""
-        ctx = {
-            "object_schema_cls": self.object_schema_cls,
-        }
-        ctx.update(self.schema_context)
-        ctx["locale"] = get_locale()
-
-        if "extra_context" in kwargs:
-            ctx |= kwargs["extra_context"]
-
-        if self.list_schema_cls is None:
-            return self.object_schema_cls(context=self.schema_context).dump(
-                obj_list, many=True
-            )
-
-        return self.list_schema_cls(context=ctx).dump(obj_list)

oarepo_runtime/resources/resource.py

@@ -1,53 +0,0 @@
-from flask import g
-from flask_resources import (
-    resource_requestctx,
-    response_handler,
-    route,
-)
-from invenio_rdm_records.resources import RDMRecordResource
-from invenio_records_resources.resources.records.resource import (
-    request_extra_args,
-    request_search_args,
-    request_view_args,
-)
-from invenio_records_resources.resources.records.utils import search_preference
-
-class BaseRecordResource(RDMRecordResource):
-
-    def create_url_rules(self):
-        """Create the URL rules for the record resource."""
-
-        def p(route):
-            """Prefix a route with the URL prefix."""
-            return f"{self.config.url_prefix}{route}"
-
-        def s(route):
-            """Suffix a route with the URL prefix."""
-            return f"{route}{self.config.url_prefix}"
-
-        routes = self.config.routes
-        url_rules = super(RDMRecordResource, self).create_url_rules()
-        url_rules += [
-            route("GET", s(routes["all-prefix"]), self.search_all_records),
-        ]
-
-        return url_rules
-
-    @request_extra_args
-    @request_search_args
-    @request_view_args
-    @response_handler(many=True)
-    def search_all_records(self):
-        """Perform a search over all records. Permission generators for search_all_records
-        and read_all_records must be in place and must be used to filter the results so that
-        no information is leaked.
-
-        GET /all/records
-        """
-        hits = self.service.search_all_records(
-            identity=g.identity,
-            params=resource_requestctx.args,
-            search_preference=search_preference(),
-            expand=resource_requestctx.args.get("expand", False),
-        )
-        return hits.to_dict(), 200

oarepo_runtime/resources/responses.py

@@ -1,20 +0,0 @@
-from flask_resources.responses import ResponseHandler
-
-class ExportableResponseHandler(ResponseHandler):
-
-    def __init__(self, serializer, export_code, name, headers=None):
-        """Constructor."""
-        self.export_code = export_code
-        self.name = name
-        super().__init__(serializer, headers)
-
-
-class OAIExportableResponseHandler(ExportableResponseHandler):
-
-    def __init__(self, serializer, export_code, name, oai_metadata_prefix, oai_schema, oai_namespace,
-                 headers=None):
-        """Constructor."""
-        self.oai_metadata_prefix = oai_metadata_prefix
-        self.oai_schema = oai_schema
-        self.oai_namespace = oai_namespace
-        super().__init__(serializer, export_code, name, headers)