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

oarepo_runtime/services/facets/multilingual_facet.py

@@ -1,33 +0,0 @@
-from flask_babel import get_locale
-from invenio_records_resources.services.records.facets import TermsFacet
-
-class MultilingualFacet(TermsFacet):
-
-    def __init__(self, lang_facets, **kwargs):
-
-        self.lang_facets = lang_facets
-
-        super().__init__(**kwargs)
-
-    def get_aggregation(self):
-        return self.lang_facets[get_locale().language].get_aggregation()
-
-    def get_value(self, bucket):
-        """Get key value for a bucket."""
-        return self.lang_facets[get_locale().language].get_value(bucket)
-
-    def get_label_mapping(self, buckets):
-        """Overwrite this method to provide custom labelling."""
-        return self.lang_facets[get_locale().language].get_label_mapping(buckets)
-
-    def get_values(self, data, filter_values):
-        """Get an unlabelled version of the bucket."""
-        return self.lang_facets[get_locale().language].get_values(data, filter_values)
-
-    def get_labelled_values(self, data, filter_values):
-        """Get a labelled version of a bucket."""
-        return self.lang_facets[get_locale().language].get_labelled_values(data, filter_values)
-
-    def add_filter(self, filter_values):
-        """Create a terms filter instead of bool containing term filters."""
-        return self.lang_facets[get_locale().language].add_filter(filter_values)

oarepo_runtime/services/facets/nested_facet.py

@@ -1,32 +0,0 @@
-from invenio_search.engine import dsl
-
-
-class NestedLabeledFacet(dsl.Facet):
-    agg_type = "nested"
-
-    def __init__(self, path, nested_facet, label=""):
-        self._path = path
-        self._inner = nested_facet
-        self._label = label
-        super(NestedLabeledFacet, self).__init__(
-            path=path,
-            aggs={
-                "inner": nested_facet.get_aggregation(),
-            },
-        )
-
-    def get_values(self, data, filter_values):
-        return self._inner.get_values(data.inner, filter_values)
-
-    def add_filter(self, filter_values):
-        inner_q = self._inner.add_filter(filter_values)
-        if inner_q:
-            return dsl.Nested(path=self._path, query=inner_q)
-
-    def get_labelled_values(self, data, filter_values):
-        """Get a labelled version of a bucket."""
-        try:
-            out = data["buckets"]
-        except KeyError:
-            out = []
-        return {"buckets": out, "label": str(self._label)}

oarepo_runtime/services/facets/params.py

@@ -1,192 +0,0 @@
-import copy
-import logging
-import operator
-from functools import partial, reduce
-from typing import List
-
-from flask import current_app
-from flask_principal import Identity
-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
-from invenio_access.permissions import authenticated_user
-from invenio_records_resources.services.records.params.base import ParamInterpreter
-from invenio_search.engine import dsl
-from invenio_rdm_records.records.systemfields.deletion_status import (
-    RecordDeletionStatusEnum,
-)
-
-log = logging.getLogger(__name__)
-
-
-class FilteredFacetsParam(FacetsParam):
-    def filter(self, search):
-        """Apply a post filter on the search."""
-        if not self._filters:
-            return search
-
-        filters = list(self._filters.values())
-
-        facet_filter = filters[0]
-        for f in filters[1:]:
-            facet_filter &= f
-
-        return search.filter(facet_filter)
-
-
-class GroupedFacetsParam(FacetsParam):
-    def __init__(self, config):
-        super().__init__(config)
-        self._facets = {**config.facets}
-
-    @property
-    def facets(self):
-        return self._facets
-
-    def identity_facet_groups(self, identity: Identity) -> List[str]:
-        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)
-
-        if hasattr(identity, "provides"):
-            return [need.value for need in identity.provides if need.method == "role"]
-
-        return []
-
-    @property
-    def facet_groups(self):
-        if hasattr(self.config, "facet_groups"):
-            return self.config.facet_groups
-        return None
-
-    def identity_facets(self, identity: Identity):
-        global_search_model = False
-        for model in current_app.config.get("GLOBAL_SEARCH_MODELS", []):
-            service_config = obj_or_import_string(model["service_config"])
-            if service_config == self.config:
-                global_search_model = True
-
-        if not self.facet_groups:
-            if global_search_model:
-                log.warning(
-                    "No facet groups defined on the service config %s", type(self.config)
-                )
-            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
-
-        user_facets = self._filter_user_facets(identity)
-        return user_facets
-
-    def aggregate(self, search, user_facets):
-        for name, facet in user_facets.items():
-            agg = facet.get_aggregation()
-            search.aggs.bucket(name, agg)
-
-        return search
-
-    def filter(self, 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, search, params):
-        """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
-        search = search.response_class(FacetsResponse.create_response_cls(self_copy))
-
-        search = self.aggregate(search, user_facets)
-        search = self.filter(search)
-
-        params.update(self.selected_values)
-
-        return search
-
-    def _filter_user_facets(self, identity: 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.get(group, {}))
-        return user_facets
-
-
-class OARepoAllVersionsParam(ParamInterpreter):
-    """Evaluates the 'allversions' parameter."""
-    def __init__(self, field_names, config):
-        """Construct."""
-        self.field_names = field_names
-        super().__init__(config)
-
-    @classmethod
-    def factory(cls, field_names: list[str]):
-        """Create a new filter parameter."""
-        return partial(cls, field_names)
-
-    def apply(self, identity, search, params):
-        """Evaluate the allversions parameter on the search."""
-        if not params.get("allversions"):
-            queries = [dsl.query.Q("term", **{field_name: True}) for field_name in self.field_names]
-            query = reduce(operator.or_, queries)
-            search = search.filter(query)
-        return search
-
-class OARepoPublishedRecordsParam(ParamInterpreter):
-    """Evaluates the include_deleted parameter."""
-
-    def apply(self, identity, search, params):
-        """Evaluate the include_deleted parameter on the search."""
-
-        value = params.pop("include_deleted", None)
-        # Filter prevents from displaying deleted records on mainsite search
-        # deleted records should appear only in admins panel
-        if value is None:
-            query = dsl.query.Q(
-                "bool",
-                should=[
-                    dsl.query.Q(
-                        "bool",
-                        must=[
-                            dsl.query.Q(
-                                "term",
-                                deletion_status=RecordDeletionStatusEnum.PUBLISHED.value,
-                            )
-                        ],
-                    ),
-                    # Drafts does not have deletion_status so this clause is needed to
-                    # prevent the above clause from filtering out the drafts
-                    dsl.query.Q(
-                        "bool", must_not=[dsl.query.Q("exists", field="deletion_status")]
-                    ),
-                ],
-            )
-            search = search.filter(query)
-        return search

oarepo_runtime/services/facets/year_histogram.py

@@ -1,200 +0,0 @@
-import re
-from typing import Dict, List
-
-from invenio_records_resources.services.records.facets.facets import LabelledFacetMixin
-from invenio_search.engine import dsl
-
-
-class YearAutoHistogramFacet(LabelledFacetMixin, dsl.Facet):
-    """Histogram facet.
-
-        .. code-block:: python
-
-            facets = {
-                'year': IntegerHistogramFacet(
-                    field='year',
-                    label=_('Year'),
-                    size=1000000
-                )
-            }
-
-            Usage in the oarepo model together with SyntheticSystemField::
-    record:
-      record:
-        imports:
-          - import: oarepo_runtime.records.systemfields.SyntheticSystemField
-          - import: oarepo_runtime.records.systemfields.PathSelector
-        fields:
-          year: |
-            SyntheticSystemField(
-                selector=PathSelector("metadata.date"),
-                key="year",
-                filter=lambda x: len(x) >= 4,
-                map=lambda x: x[:4]
-            )
-      properties:
-        year:
-          facets:
-            facet-class: oarepo_runtime.services.facets.year_histogram.YearAutoHistogramFacet
-          type: edtf
-    """
-
-    agg_type = "auto_date_histogram"
-
-    def __init__(self, **kwargs):
-        self._min_doc_count = kwargs.pop("min_doc_count", 0)
-        buckets = kwargs.pop("buckets", 20)
-        # TODO: the minimum interval should be year, but opensearch does not support it yet
-        super().__init__(
-            **kwargs, buckets=buckets, format="yyyy", minimum_interval="month"
-        )
-
-    def get_value_filter(self, filter_value):
-        if "/" in filter_value:
-            start, end = filter_value.split("/")
-            return dsl.query.Range(
-                _expand__to_dot=False,
-                **{
-                    self._params["field"]: {
-                        "gte": f"{start}-01-01",
-                        "lte": f"{end}-12-31",
-                    }
-                },
-            )
-        return dsl.query.Term(
-            _expand__to_dot=False,
-            **{
-                self._params["field"]: {
-                    "gte": f"{filter_value}-01-01",
-                    "lte": f"{filter_value}-12-31",
-                }
-            },
-        )
-
-    def add_filter(self, filter_values):
-        ret = super().add_filter(filter_values)
-        return ret
-
-    def get_labelled_values(self, data, filter_values):
-        """Get a labelled version of a bucket."""
-
-        # fix for opensearch bug
-        data = self.fix_yearly_interval(data)
-
-        interval = data["interval"]
-
-        interval_in_years = int(re.sub(r"\D", "", interval))
-
-        buckets = data["buckets"]
-
-        for bucket in buckets:
-            bucket["interval"] = interval_in_years
-
-        if self._min_doc_count > 0:
-            buckets = self._merge_small_buckets(buckets)
-
-        out_buckets = []
-        for i, bucket in enumerate(buckets):
-            value = int(bucket["key_as_string"].split("-")[0])
-
-            out_buckets.append(
-                {
-                    **bucket,
-                    "interval": f"{bucket['interval']}y",
-                    "start": str(value),
-                }
-            )
-            if i > 0:
-                out_buckets[i - 1]["end"] = str(value - 1)
-
-        if out_buckets:
-            out_buckets[-1]["end"] = str(
-                int(out_buckets[-1]["start"]) + interval_in_years - 1
-            )
-
-        return {
-            "buckets": out_buckets,
-            "label": str(self._label),
-            "interval": interval,
-        }
-
-    def merge_buckets(self, buckets):
-        merged = {}
-
-        for bucket in buckets:
-            key = bucket["key_as_string"]
-            if key not in merged:
-                merged[key] = {
-                    "key_as_string": key,
-                    "key": bucket["key"],
-                    "doc_count": 0,
-                }
-
-            merged[key]["doc_count"] += bucket["doc_count"]
-
-        result = list(merged.values())
-        return result
-
-    def fix_yearly_interval(self, data) -> Dict:
-        """
-        Currently opensearch has a bug that does not allow to set minimum_interval to year.
-        This function will fix the interval to be yearly if the minimum_interval is has lower value.
-        """
-        data = data.to_dict()
-
-        interval = data["interval"]
-
-        if interval.endswith("y"):
-            # no need to fix the interval, as it is in years
-            return data
-
-        # make sure it is in years
-        data["interval"] = "1y"
-
-        buckets = data["buckets"]
-        data["buckets"] = out_buckets = []
-
-        by_year = {}
-
-        # there might be several buckets returned with the same year - merge them
-        for bucket in buckets:
-            key = bucket["key_as_string"]
-            if key not in by_year:
-                by_year[key] = {
-                    "key_as_string": key,
-                    "key": bucket["key"],
-                    "doc_count": 0,
-                }
-                out_buckets.append(by_year[key])
-
-            by_year[key]["doc_count"] += bucket["doc_count"]
-
-        return data
-
-    def _merge_small_buckets(self, buckets: List[Dict]):
-        """
-        Merges small buckets into the previous bucket. If the small bucket is the first one,
-        merge it with subsequent buckets until the first non-small bucket is found.
-        """
-        ret = []
-        initial_small_buckets = 0
-        initial_small_interval = 0
-        for bucket in buckets:
-            if bucket["doc_count"] < self._min_doc_count:
-                if ret:
-                    ret[-1]["doc_count"] += bucket["doc_count"]
-                    ret[-1]["interval"] += bucket["interval"]
-                else:
-                    initial_small_buckets += bucket["doc_count"]
-                    initial_small_interval += bucket["interval"]
-            else:
-                ret.append(bucket)
-
-        if ret and initial_small_buckets:
-            doc_count = ret[0]["doc_count"] + initial_small_buckets
-            interval = ret[0]["interval"] + initial_small_interval
-            ret[0] = buckets[0]
-            ret[0]["doc_count"] = doc_count
-            ret[0]["interval"] = interval
-
-        return ret

oarepo_runtime/services/files/__init__.py

@@ -1,8 +0,0 @@
-try:
-    from invenio_records_resources.services.records.components import (
-        FilesOptionsComponent as FilesComponent,
-    )
-except ImportError:
-    from invenio_records_resources.services.records.components import FilesComponent
-
-__all__ = ("FilesComponent",)

oarepo_runtime/services/files/components.py

@@ -1,62 +0,0 @@
-import mimetypes
-import os
-
-from invenio_records_resources.services.files.components import FileServiceComponent
-from marshmallow.exceptions import ValidationError
-
-
-class AllowedFileTypesComponent(FileServiceComponent):
-    def guess_content_type(self, filename: str | None) -> str | None:
-        if filename:
-            return mimetypes.guess_type(filename)[0] or "application/octet-stream"
-        return None
-
-    @property
-    def allowed_mimetypes(self):
-        """Returns files attribute (field) key."""
-        return getattr(self.service.config, "allowed_mimetypes", [])
-
-    def guess_extension(self, file, mimetype):
-        """File extension."""
-        # The ``ext`` property is used to in search to aggregate file types, and we want e.g. both ``.jpeg`` and
-        # ``.jpg`` to be aggregated under ``.jpg``
-        ext_guessed = mimetypes.guess_extension(mimetype)
-
-        # Check if a valid extension is guessed and it's not the default mimetype
-        if ext_guessed is not None and mimetype != "application/octet-stream":
-            return ext_guessed[1:]
-
-        # Support non-standard file extensions that cannot be guessed
-        _, ext = os.path.splitext(file)
-        if ext and len(ext) <= 5:
-            return ext[1:].lower()
-
-        if ext_guessed:
-            return ext_guessed[1:]
-
-    @property
-    def allowed_extensions(self):
-        """Returns files attribute (field) key."""
-        return getattr(self.service.config, "allowed_extensions", [])
-
-    def init_files(self, identity, id_, data, uow=None):
-        """Initialize the file upload for the record."""
-        list_files = list(data.files.entries)
-
-        for file in list_files:
-            allowed_type = self.guess_content_type(file)
-            allowed_ext = self.guess_extension(file, allowed_type)
-            if (
-                len(self.allowed_mimetypes) > 0
-                and allowed_type not in self.allowed_mimetypes
-            ):
-                raise ValidationError(
-                    f"Mimetype not supported, supported mimetypes: {self.allowed_mimetypes}"
-                )
-            elif (
-                len(self.allowed_extensions) > 0
-                and allowed_ext not in self.allowed_extensions
-            ):
-                raise ValidationError(
-                    f"Extension not supported, supported extensions: {self.allowed_extensions}"
-                )

oarepo_runtime/services/files/service.py

@@ -1,16 +0,0 @@
-from invenio_records_resources.services.uow import unit_of_work
-
-from oarepo_runtime.datastreams.utils import get_record_service_for_file_service
-
-
-class FeaturedFileServiceMixin:
-    @unit_of_work()
-    def commit_file(self, identity, id_, file_key, uow=None):
-        super().commit_file(identity, id_, file_key, uow=uow)
-
-        record = self._get_record(id_, identity, "read", file_key=file_key)
-        record_service = get_record_service_for_file_service(self, record=record)
-        indexer = record_service.indexer
-        if indexer:
-            indexer.index(record)
-            indexer.refresh()

oarepo_runtime/services/generators.py

@@ -1,10 +0,0 @@
-import warnings
-
-from .permissions import RecordOwners
-
-warnings.warn(
-    "oarepo_runtime.services.generators is deprecated, import RecordOwners from "
-    "oarepo_runtime.services.permissions",
-    DeprecationWarning,
-)
-__all__ = ("RecordOwners",)

oarepo_runtime/services/permissions/__init__.py

@@ -1,3 +0,0 @@
-from .generators import IfDraftType, RecordOwners, UserWithRole
-
-__all__ = ("RecordOwners", "UserWithRole", "IfDraftType")

oarepo_runtime/services/permissions/generators.py

@@ -1,103 +0,0 @@
-from typing import Literal
-
-from flask import current_app
-from flask_principal import RoleNeed, UserNeed
-from invenio_records_permissions.generators import (
-    ConditionalGenerator,
-    Disable,
-    Generator,
-)
-from invenio_search.engine import dsl
-
-
-class RecordOwners(Generator):
-    """Allows record owners."""
-
-    def needs(self, record=None, **kwargs):
-        """Enabling Needs."""
-        if record is None:
-            # 'record' is required, so if not passed we default to empty array,
-            # i.e. superuser-access.
-            return []
-        if current_app.config.get("INVENIO_RDM_ENABLED", False):
-            owners = getattr(record.parent.access, "owned_by", None)
-            if owners is not None:
-                owners_list = owners if isinstance(owners, list) else [owners]
-                return [UserNeed(owner.owner_id) for owner in owners_list]
-        else:
-            owners = getattr(record.parent, "owners", None)
-            if owners is not None:
-                return [UserNeed(owner.id) for owner in owners]
-        return []
-
-    def query_filter(self, identity=None, **kwargs):
-        """Filters for current identity as owner."""
-        users = [n.value for n in identity.provides if n.method == "id"]
-        if users:
-            if current_app.config.get("INVENIO_RDM_ENABLED", False):
-                return dsl.Q("terms", **{"parent.access.owned_by.user": users})
-            else:
-                return dsl.Q("terms", **{"parent.owners.user": users})
-        return dsl.Q("match_none")
-
-
-class UserWithRole(Generator):
-    def __init__(self, *roles):
-        self.roles = roles
-
-    def needs(self, **kwargs):
-        return [RoleNeed(role) for role in self.roles]
-
-    def query_filter(self, identity=None, **kwargs):
-        if not identity:
-            return dsl.Q("match_none")
-        for provide in identity.provides:
-            if provide.method == "role" and provide.value in self.roles:
-                return dsl.Q("match_all")
-        return dsl.Q("match_none")
-
-
-class IfDraftType(ConditionalGenerator):
-    def __init__(
-        self,
-        draft_types: (
-            list[Literal["initial"] | Literal["metadata"] | Literal["new_version"]]
-            | Literal["initial"]
-            | Literal["metadata"]
-            | Literal["new_version"]
-        ),
-        then_=None,
-        else_=None,
-    ):
-        if not isinstance(draft_types, (list, tuple)):
-            draft_types = [draft_types]
-        self._draft_types = draft_types
-        if not then_:
-            then_ = [Disable()]
-        if not else_:
-            else_ = [Disable()]
-        if not isinstance(then_, (list, tuple)):
-            then_ = [then_]
-        if not isinstance(else_, (list, tuple)):
-            else_ = [else_]
-        super().__init__(then_, else_)
-
-    def _condition(self, record=None, **kwargs):
-        if not record:
-            return False
-
-        index = record.versions.index
-        is_latest = record.versions.is_latest
-        is_draft = record.is_draft
-
-        if not is_draft:
-            return False
-
-        if index == 1 and not is_latest:
-            draft_type = "initial"
-        elif index > 1 and not is_latest:
-            draft_type = "new_version"
-        else:
-            draft_type = "metadata"
-
-        return draft_type in self._draft_types

oarepo_runtime/services/relations/components.py

@@ -1,15 +0,0 @@
-from invenio_records_resources.services.records.components import ServiceComponent
-
-from oarepo_runtime.uow import CachingUnitOfWork
-
-
-class CachingRelationsComponent(ServiceComponent):
-    def create(self, identity, *, record, **kwargs):
-        """Create handler."""
-        # skutecny jmeno relations atributu
-        if isinstance(self.uow, CachingUnitOfWork) and hasattr(record, "relations"):
-            record.relations.set_cache(self.uow.cache)
-
-    def update(self, identity, *, record, **kwargs):
-        """Update handler."""
-        self.create(identity, record=record, **kwargs)