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

oarepo_runtime/services/schema/ui.py

@@ -1,251 +0,0 @@
-import datetime
-import re
-
-import marshmallow as ma
-from babel.dates import format_date
-from babel_edtf import format_edtf
-from flask import current_app
-from idutils import to_url
-from invenio_rdm_records.records.systemfields.access.field.record import (
-    AccessStatusEnum,
-)
-from invenio_rdm_records.resources.serializers.ui.fields import (
-    UIObjectAccessStatus as InvenioUIObjectAccessStatus,
-)
-from invenio_rdm_records.services.schemas.parent import RDMParentSchema
-from invenio_rdm_records.services.schemas.pids import PIDSchema
-from invenio_rdm_records.services.schemas.record import validate_scheme
-from invenio_rdm_records.services.schemas.versions import VersionsSchema
-from marshmallow.fields import Dict, Nested, Raw
-from marshmallow_utils.fields import (
-    BabelGettextDictField,
-    FormatDate,
-    FormatDatetime,
-    FormatEDTF,
-    FormatTime,
-    SanitizedUnicode,
-)
-from marshmallow_utils.fields.babel import BabelFormatField
-
-from oarepo_runtime.i18n import gettext
-from oarepo_runtime.i18n import lazy_gettext as _
-
-from .marshmallow import RDMBaseRecordSchema
-
-
-def current_default_locale():
-    """Get the Flask app's default locale."""
-    if current_app:
-        return current_app.config.get("BABEL_DEFAULT_LOCALE", "en")
-    # Use english by default if not specified
-    return "en"
-
-
-class LocalizedMixin:
-    def __init__(self, *args, locale=None, **kwargs):
-        super().__init__(*args, locale=locale, **kwargs)
-
-    @property
-    def locale(self):
-        if self._locale:
-            return self._locale
-        if self.parent:
-            if "locale" in self.context:
-                return self.context["locale"]
-        return current_default_locale()
-
-    def format_value(self, value):
-        """Format the value, gracefully handling exceptions."""
-        try:
-            return super().format_value(value)
-        except Exception as e:
-            # Handle the exception gracefully
-            current_app.logger.error(f"Error formatting value '{value}': {e}")
-            return f"«Error formatting value '{value}'»"
-
-
-# localized date field
-class LocalizedDate(LocalizedMixin, FormatDate):
-    pass
-
-
-class FormatTimeString(FormatTime):
-    def parse(self, value, as_time=False, as_date=False, as_datetime=False):
-        if value and isinstance(value, str) and as_time == True:
-            match = re.match(
-                r"^(\d|0\d|1\d|2[0-3]):(\d|[0-5]\d|60)(:(\d|[0-5]\d|60))?$", value
-            )
-            if match:
-                value = datetime.time(
-                    hour=int(match.group(1)),
-                    minute=int(match.group(2)),
-                    second=int(match.group(4)) if match.group(4) else 0,
-                )
-
-        return super().parse(value, as_time, as_date, as_datetime)
-
-
-class MultilayerFormatEDTF(BabelFormatField):
-    def format_value(self, value):
-        try:
-            return format_date(
-                self.parse(value, as_date=True), format=self._format, locale=self.locale
-            )
-        except:
-            return format_edtf(value, format=self._format, locale=self.locale)
-
-    def parse(self, value, **kwargs):
-        # standard parsing is too lenient, for example returns "2000-01-01" for input "2000"
-        if re.match("^[0-9]+-[0-9]+-[0-9]+", value):
-            return super().parse(value, **kwargs)
-        raise ValueError("Not a valid date")
-
-class TimezoneMixin: #i'm not sure about where this should be used
-    @property
-    def tzinfo(self):
-        from oarepo_runtime.proxies import current_timezone
-        try:
-            return current_timezone.get()
-        except LookupError:
-            return
-
-class LocalizedDateTime(TimezoneMixin, LocalizedMixin, FormatDatetime):
-    pass
-
-class LocalizedTime(LocalizedMixin, FormatTimeString):
-    pass
-
-
-class LocalizedEDTF(LocalizedMixin, MultilayerFormatEDTF):
-    pass
-
-
-class LocalizedEDTFTime(LocalizedMixin, MultilayerFormatEDTF):
-    pass
-
-
-class LocalizedEDTFInterval(LocalizedMixin, FormatEDTF):
-    pass
-
-
-class LocalizedEDTFTimeInterval(LocalizedMixin, FormatEDTF):
-    pass
-
-
-class PrefixedGettextField(BabelGettextDictField):
-    def __init__(self, *, value_prefix, locale, default_locale, **kwargs):
-        super().__init__(locale, default_locale, **kwargs)
-        self.value_prefix = value_prefix
-
-    def _serialize(self, value, attr, obj, **kwargs):
-        if value:
-            value = f"{self.value_prefix}{value}"
-        return gettext(value)
-
-
-class LocalizedEnum(LocalizedMixin, PrefixedGettextField):
-    pass
-
-    def __init__(self, **kwargs):
-        super().__init__(default_locale=current_default_locale, **kwargs)
-
-
-if False:  # NOSONAR
-    # just for the makemessages to pick up the translations
-    translations = [_("True"), _("False")]
-
-
-class InvenioUISchema(ma.Schema):
-    _schema = ma.fields.Str(attribute="$schema", data_key="$schema")
-    id = ma.fields.Str()
-    created = LocalizedDateTime(dump_only=True)
-    updated = LocalizedDateTime(dump_only=True)
-    links = ma.fields.Raw(dump_only=True)
-    revision_id = ma.fields.Integer(dump_only=True)
-    expanded = ma.fields.Raw(dump_only=True)
-
-
-# seems not possible to avoid, as they have this hardcoded in their object,
-# and translation keys are i.e. open, which gets translated to otevret
-class UIObjectAccessStatus(InvenioUIObjectAccessStatus):
-    @property
-    def title(self):
-        """Access status title."""
-        return {
-            AccessStatusEnum.OPEN: _("access.status.open"),
-            AccessStatusEnum.EMBARGOED: _("access.status.embargoed"),
-            AccessStatusEnum.RESTRICTED: _("access.status.restricted"),
-            AccessStatusEnum.METADATA_ONLY: _("access.status.metadata-only"),
-        }.get(self.access_status)
-
-
-class AccessStatusField(ma.fields.Field):
-    """Record access status."""
-
-    def _serialize(self, value, attr, obj, **kwargs):
-        """Serialise access status."""
-        record_access_dict = obj.get("access")
-        _files = obj.get("files", {})
-        has_files = _files is not None and _files.get("enabled", False)
-        if record_access_dict:
-            record_access_status_ui = UIObjectAccessStatus(
-                record_access_dict, has_files
-            )
-            return {
-                "id": record_access_status_ui.id,
-                "title_l10n": record_access_status_ui.title,
-                "description_l10n": record_access_status_ui.description,
-                "icon": record_access_status_ui.icon,
-                "embargo_date_l10n": record_access_status_ui.embargo_date,
-                "message_class": record_access_status_ui.message_class,
-            }
-
-
-# to be able to have access to entire pids object
-class PIDsField(Dict):
-    """Custom Dict field for PIDs that adds URLs after serialization."""
-
-    def _serialize(self, value, attr, obj, **kwargs):
-        """Serialize the PIDs and add URLs to them."""
-        serialized = super()._serialize(value, attr, obj, **kwargs)
-
-        if serialized:
-            for scheme, pid in serialized.items():
-                if scheme and pid and isinstance(pid, dict) and pid.get("identifier"):
-                    url = to_url(pid["identifier"], scheme.lower(), url_scheme="https")
-                    if url:
-                        pid["url"] = url
-
-        return serialized
-
-
-class InvenioRDMParentUISchema(RDMParentSchema):
-    """Parent schema."""
-
-    pids = PIDsField(
-        keys=SanitizedUnicode(validate=validate_scheme),
-        values=Nested(PIDSchema),
-    )
-
-
-class InvenioRDMUISchema(InvenioUISchema, RDMBaseRecordSchema):
-    """RDM UI schema."""
-
-    is_draft = ma.fields.Boolean(dump_only=True)
-    access_status = AccessStatusField(attribute="access", dump_only=True)
-    versions = ma.fields.Nested(VersionsSchema, dump_only=True)
-    pids = PIDsField(
-        keys=SanitizedUnicode(validate=validate_scheme),
-        values=Nested(PIDSchema),
-    )
-    parent = ma.fields.Nested(InvenioRDMParentUISchema)
-    access = ma.fields.Raw(attribute="access", data_key="access", dump_only=True)
-    files = ma.fields.Raw(attribute="files", data_key="files", dump_only=True)
-
-    def hide_tombstone(self, data):
-        """Hide tombstone info if the record isn't deleted and metadata if it is."""
-        return data
-
-    def default_nested(self, data):
-        """Serialize fields as empty dict for partial drafts."""
-        return data

oarepo_runtime/services/schema/validation.py

@@ -1,70 +0,0 @@
-import functools
-import re
-from datetime import datetime
-from idutils import normalize_pid
-from isbnlib import canonical, mask
-
-from marshmallow.exceptions import ValidationError
-from marshmallow_utils.fields.edtfdatestring import EDTFValidator
-
-from invenio_i18n import gettext as _
-
-
-def validate_identifier(value):
-    try:
-        original_identifier = (value["identifier"] or '').strip()
-        normalized_identifier = normalize_pid(
-            value["identifier"], value["scheme"].lower()
-        )
-        if original_identifier and not normalized_identifier:
-            # the normalize_pid library has problems with isbn - does not raise an exception
-            # but returns an empty string
-            raise ValueError()
-        
-        # normalized_pid is changing from 10 length ISBN to 13 length ISBN
-        if value["scheme"].lower() == "isbn":    
-            canonical_isbn = canonical(value["identifier"])
-            if original_identifier and not canonical_isbn:  # just check in case it returns empty string
-                raise ValueError() 
-            value["identifier"] = mask(canonical_isbn)
-            return value
-
-        value["identifier"] = normalized_identifier
-    except:
-        raise ValidationError({
-            "identifier": _("Invalid value %(identifier)s of identifier type %(type)s") % {"identifier": value['identifier'], "type": value['scheme']}
-        })
-    return value
-
-
-def validate_date(date_format):
-    def validate(value):
-        try:
-            datetime.strptime(value, date_format)
-        except Exception as e:
-            raise ValidationError(
-                f"Invalid date/time format, expecting {date_format}, got {value}"
-            ) from e
-
-    return validate
-
-
-def validate_datetime(value):
-    try:
-        datetime.fromisoformat(value)
-    except Exception as e:
-        raise ValidationError(
-            f"Invalid datetime format, expecting iso format, got {value}"
-        ) from e
-
-
-class CachedMultilayerEDTFValidator(EDTFValidator):
-    @functools.lru_cache(maxsize=1024)
-    def __call__(self, value):
-        if re.match(r"^\d{4}$", value):
-            return value
-        try:
-            datetime.strptime(value, "%Y-%m-%d")
-            return value
-        except:
-            return super().__call__(value)

oarepo_runtime/services/search.py

@@ -1,282 +0,0 @@
-import dataclasses
-import inspect
-from typing import List
-
-from invenio_rdm_records.services.config import (
-    RDMSearchDraftsOptions as BaseRDMSearchDraftsOptions,
-)
-from invenio_rdm_records.services.config import RDMSearchOptions as BaseRDMSearchOptions
-from invenio_records_resources.proxies import current_service_registry
-from invenio_records_resources.services.records import (
-    SearchOptions as InvenioSearchOptions,
-)
-from invenio_drafts_resources.services.records.config import SearchDraftsOptions as InvenioSearchDraftsOptions
-from invenio_records_resources.services.records.params import (
-    FacetsParam,
-    PaginationParam,
-    QueryStrParam,
-    SortParam,
-)
-from invenio_records_resources.services.records.queryparser import SuggestQueryParser
-from invenio_search.engine import dsl
-from invenio_drafts_resources.services.records.search_params import AllVersionsParam
-# TODO: integrate this to invenio_records_resources.services.records and remove SearchOptions class
-from oarepo_runtime.i18n import lazy_gettext as _
-from oarepo_runtime.records.systemfields.icu import ICUSuggestField
-from oarepo_runtime.utils.functools import class_property
-
-from .facets.params import GroupedFacetsParam, OARepoAllVersionsParam, OARepoPublishedRecordsParam
-from invenio_drafts_resources.services.records.search_params import AllVersionsParam
-from invenio_rdm_records.services.search_params import PublishedRecordsParam
-from functools import partial
-try:
-    from invenio_i18n import get_locale
-except ImportError:
-    from invenio_i18n.babel import get_locale
-
-
-class FuzzySuggestQueryParser(SuggestQueryParser):
-    def __init__(self, identity=None, extra_params=None, **kwargs):
-        """Constructor."""
-        super().__init__(identity=identity, extra_params=extra_params)
-        self.fields = self.extra_params.get("fields", [])
-        self.extra_params.setdefault("type", "bool_prefix")
-
-    def parse(self, query_str):
-        """Parse the query."""
-        # default behavior
-        multi_match_with_bool_prefix = dsl.Q(
-            "multi_match", query=query_str, **self.extra_params
-        )
-        # fuzziness does not seem to work with bool_prefix multimatch query, so we turn this into
-        # should multi match query with two clauses
-        multi_match_fuzzy = dsl.Q(
-            "multi_match", query=query_str, fields=self.fields, fuzziness="AUTO"
-        )
-        return dsl.Q("bool", should=[multi_match_with_bool_prefix, multi_match_fuzzy])
-
-
-class SearchOptionsMixin:
-    @class_property
-    def params_interpreters_cls(cls):
-        """Replaces FacetsParam with GroupedFacetsParam."""
-        params_replace_map = {FacetsParam: GroupedFacetsParam, AllVersionsParam:
-            OARepoAllVersionsParam.factory(["versions.is_latest", "versions.is_latest_draft"]),
-                              PublishedRecordsParam: OARepoPublishedRecordsParam}
-
-        param_interpreters = [*super(SearchOptionsMixin, cls).params_interpreters_cls]
-        # replace FacetsParam with GroupedFacetsParam
-        for idx, interpreter in enumerate(param_interpreters):
-            if interpreter in params_replace_map:
-                param_interpreters[idx] = params_replace_map[interpreter]
-            elif isinstance(interpreter, partial):
-                fn = interpreter.func
-                if fn in params_replace_map:
-                    param_interpreters[idx] = params_replace_map[fn]
-        return param_interpreters
-
-    sort_options = {
-        "title": dict(
-            title=_("By Title"),
-            fields=["metadata.title"],  # ES defaults to desc on `_score` field
-        ),
-        "bestmatch": dict(
-            title=_("Best match"),
-            fields=["_score"],  # ES defaults to desc on `_score` field
-        ),
-        "newest": dict(
-            title=_("Newest"),
-            fields=["-created"],
-        ),
-        "oldest": dict(
-            title=_("Oldest"),
-            fields=["created"],
-        ),
-    }
-
-
-class SearchOptionsDraftMixin(SearchOptionsMixin):
-    sort_options = {
-        "bestmatch": dict(
-            title=_("Best match"),
-            fields=["_score"],  # search defaults to desc on `_score` field
-        ),
-        "updated-desc": dict(
-            title=_("Recently updated"),
-            fields=["-updated"],
-        ),
-        "updated-asc": dict(
-            title=_("Least recently updated"),
-            fields=["updated"],
-        ),
-        "newest": dict(
-            title=_("Newest"),
-            fields=["-created"],
-        ),
-        "oldest": dict(
-            title=_("Oldest"),
-            fields=["created"],
-        ),
-        "version": dict(
-            title=_("Version"),
-            fields=["-versions.index"],
-        ),
-    }
-
-
-
-class SearchOptions(SearchOptionsMixin, InvenioSearchOptions):
-    # TODO: should be changed
-    params_interpreters_cls = [
-        QueryStrParam,
-        PaginationParam,
-        SortParam,
-        GroupedFacetsParam,
-    ]
-
-class SearchDraftsOptions(SearchOptionsMixin, InvenioSearchDraftsOptions):
-    # TODO: should be changed
-    params_interpreters_cls = [
-        QueryStrParam,
-        PaginationParam,
-        SortParam,
-        GroupedFacetsParam,
-        AllVersionsParam.factory("versions.is_latest_draft")
-    ]
-
-
-class RDMSearchOptions(SearchOptionsMixin, BaseRDMSearchOptions):
-    pass
-
-
-class RDMSearchDraftsOptions(SearchOptionsDraftMixin, BaseRDMSearchDraftsOptions):
-    pass
-
-
-@dataclasses.dataclass
-class SuggestField:
-    field: str
-    boost: int
-    use_ngrams: bool = True
-    boost_exact: float = 5
-    boost_2gram: float = 1
-    boost_3gram: float = 1
-    boost_prefix: float = 1
-
-
-class ICUSuggestParser:
-    def __init__(
-        self,
-        record_cls_or_service_name,
-        extra_fields: List[SuggestField] = None,
-        default_fields: List[SuggestField] = None,
-    ):
-        self.record_cls_or_service_name = record_cls_or_service_name
-        self.extra_fields = extra_fields or []
-        self.default_fields = default_fields or []
-
-    @property
-    def record_cls(self):
-        if not isinstance(self.record_cls_or_service_name, str):
-            return self.record_cls_or_service_name
-        return current_service_registry.get(
-            self.record_cls_or_service_name
-        ).config.record_cls
-
-    def __get__(self, instance, owner):
-        search_as_you_type_fields: List[SuggestField] = []
-        locale = get_locale()
-        if locale:
-            language = locale.language
-
-            for fld_name, fld in inspect.getmembers(
-                self.record_cls, lambda x: isinstance(x, ICUSuggestField)
-            ):
-                search_as_you_type_fields.append(
-                    SuggestField(f"{fld_name}.{language}.original", 2)
-                )
-                search_as_you_type_fields.append(
-                    SuggestField(f"{fld_name}.{language}.no_accent", 1)
-                )
-
-        if not search_as_you_type_fields:
-            search_as_you_type_fields.extend(self.default_fields)
-
-        search_as_you_type_fields.extend(self.extra_fields)
-
-        fields = []
-        for fld in search_as_you_type_fields:
-            fields.append(f"{fld.field}^{fld.boost * fld.boost_exact}")
-            if fld.use_ngrams:
-                fields.append(f"{fld.field}._2gram^{fld.boost * fld.boost_2gram}")
-                fields.append(f"{fld.field}._3gram^{fld.boost * fld.boost_3gram}")
-                fields.append(
-                    f"{fld.field}._index_prefix^{fld.boost * fld.boost_prefix}"
-                )
-
-        return FuzzySuggestQueryParser.factory(fields=fields)
-
-
-@dataclasses.dataclass
-class SortField:
-    option_name: str = "title"
-    icu_sort_field: str = "sort"
-    title: str = _("By Title")
-
-
-class ICUSortOptions:
-    def __init__(self, record_cls_or_service_name, fields: List[SortField] = None):
-        self.record_cls_or_service_name = record_cls_or_service_name
-        self.fields = fields or [SortField()]
-
-    @property
-    def record_cls(self):
-        if not isinstance(self.record_cls_or_service_name, str):
-            return self.record_cls_or_service_name
-        return current_service_registry.get(
-            self.record_cls_or_service_name
-        ).config.record_cls
-
-    def __get__(self, instance, owner):
-        if not inspect.isclass(owner):
-            owner = type(owner)
-        super_options = {}
-        for mro in list(owner.mro())[1:]:
-            if hasattr(mro, "sort_options"):
-                super_options = mro.sort_options
-                break
-
-        ret = {
-            **super_options,
-            **getattr(owner, "extra_sort_options", {}),
-        }
-
-        # transform the sort options by the current language
-        locale = get_locale()
-        if not locale:
-            return ret
-
-        language = locale.language
-
-        for sort_field in self.fields:
-            icu_field = getattr(self.record_cls, sort_field.icu_sort_field)
-            ret[sort_field.option_name] = {
-                "title": sort_field.title,
-                "fields": [f"{icu_field.key}.{language}"],
-            }
-        return ret
-
-
-class I18nSearchOptions(SearchOptions):
-    extra_sort_options = {}
-    record_cls = None
-
-
-class I18nRDMSearchOptions(RDMSearchOptions):
-    extra_sort_options = {}
-    record_cls = None
-
-
-class I18nRDMDraftsSearchOptions(RDMSearchDraftsOptions):
-    extra_sort_options = {}
-    record_cls = None

oarepo_runtime/services/service.py

@@ -1,61 +0,0 @@
-"""An extension to invenio RDM service that includes a search across all records
-(published, draft and deleted).
-without any filtering. Permission `can_read_all_records` and `search_all_records`
-were added and must be used to filter the results so that no information is leaked.
-"""
-
-from invenio_rdm_records.services import RDMRecordService
-from invenio_records_resources.services import LinksTemplate
-
-
-class SearchAllRecordsService(RDMRecordService):
-    def search_all_records(
-        self,
-        identity,
-        params=None,
-        search_preference=None,
-        expand=False,
-        extra_filter=None,
-        **kwargs,
-    ):
-        """Search for drafts records matching the querystring."""
-        self.require_permission(
-            identity,
-            "search_all_records",
-            params=params,
-            extra_filter=extra_filter,
-            **kwargs,
-        )
-        # Prepare and execute the search
-        params = params or {}
-
-        search_opts = (
-            getattr(self.config, "search_all", None) or self.config.search
-        )
-
-        search_result = self._search(
-            "search_all",
-            identity,
-            params,
-            search_preference,
-            record_cls=self.draft_cls,
-            search_opts=search_opts,
-            extra_filter=extra_filter,
-            permission_action="read_all_records",
-            **kwargs,
-        ).execute()
-
-        return self.result_list(
-            self,
-            identity,
-            search_result,
-            params,
-            links_tpl=LinksTemplate(
-                getattr(self.config, "links_search_drafts")
-                or self.config.links_search_drafts,
-                context={"args": params},
-            ),
-            links_item_tpl=self.links_item_tpl,
-            expandable_fields=self.expandable_fields,
-            expand=expand,
-        )

oarepo_runtime/tasks.py

@@ -1,6 +0,0 @@
-from celery import shared_task
-
-# TODO priority if something big is in queue already
-@shared_task(name='ping')
-def ping():
-    return 'pong'