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

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/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)

oarepo_runtime/services/relations/errors.py

@@ -1,18 +0,0 @@
-class InvalidRelationError(KeyError):
-    def __init__(self, message, related_id, location):
-        self.related_id = related_id
-        self.location = location
-        super().__init__(message)
-
-
-class MultipleInvalidRelationErrors(Exception):
-    """
-    Records multiple validation errors of a relation field.
-    self.errors is a list of pairs (path, Error)
-    """
-
-    def __init__(self, errors):
-        super().__init__(
-            "; ".join([f"{e[0]}: {type(e[1]).__name__}({e[1]})" for e in errors])
-        )
-        self.errors = errors

oarepo_runtime/services/relations/mapping.py

@@ -1,38 +0,0 @@
-class RelationsMapping:
-    """Helper class for managing relation fields."""
-
-    def __init__(self, record, fields):
-        """Initialize the relations mapping."""
-        # Needed because we overwrite __setattr__
-        cache = {}
-        self._fields = fields
-        for name, fld in fields.items():
-            field_value = fld.get_value(record, cache)
-            setattr(self, name, field_value)
-
-    def __iter__(self):
-        """Iterate over the relations fields."""
-        return iter(self._fields)
-
-    def validate(self, fields=None):
-        """Validates all relations in the record."""
-        for name in fields or self:
-            getattr(self, name).validate()
-
-    def dereference(self, fields=None):
-        """Dereferences relation fields."""
-        for name in fields or self:
-            getattr(self, name).dereference()
-
-    def clean(self, fields=None):
-        """Clean dereferenced relation fields."""
-        for name in fields or self:
-            getattr(self, name).clean()
-
-    def set_cache(self, cache):
-        from oarepo_runtime.records.relations import PIDRelation
-
-        for key, fld in self._fields.items():
-            if isinstance(fld, PIDRelation):
-                fld.cache = cache
-                getattr(self, key).cache = cache

oarepo_runtime/services/schema/cf.py

@@ -1,13 +0,0 @@
-from invenio_records_resources.services.custom_fields.schema import (
-    CustomFieldsSchemaUI as InvenioCustomFieldsSchemaUI,
-)
-
-
-class CustomFieldsSchemaUI(InvenioCustomFieldsSchemaUI):
-    def _serialize(self, obj, **kwargs):
-        self._schema.context.update(self.context)
-        return super()._serialize(obj, **kwargs)
-
-    def _deserialize(self, data, **kwargs):
-        self._schema.context.update(self.context)
-        return super()._deserialize(data, **kwargs)

oarepo_runtime/services/schema/i18n_validation.py

@@ -1,7 +0,0 @@
-import langcodes
-from marshmallow.exceptions import ValidationError
-
-
-def lang_code_validator(value):
-    if value != "_" and not langcodes.Language.get(value).is_valid():
-        raise ValidationError(f"Invalid language code {value}")

oarepo_runtime/services/schema/marshmallow.py

@@ -1,44 +0,0 @@
-import typing
-
-from invenio_rdm_records.services.schemas.record import RDMRecordSchema
-from invenio_records_resources.services.records.schema import (
-    BaseRecordSchema as InvenioBaseRecordSchema,
-)
-
-import marshmallow as ma
-
-
-class BaseRecordSchema(InvenioBaseRecordSchema):
-    """Base record schema - in addition to invenio exposes $schema as well."""
-
-    _schema = ma.fields.Str(attribute="$schema", data_key="$schema")
-
-
-class RDMBaseRecordSchema(RDMRecordSchema):
-    """Base record schema - in addition to invenio exposes $schema as well."""
-
-    _schema = ma.fields.Str(attribute="$schema", data_key="$schema")
-
-
-class DictOnlySchema(ma.Schema):
-    def get_attribute(self, obj: typing.Any, attr: str, default: typing.Any):
-        if not isinstance(attr, int) and "." in attr:
-            return _get_value_for_keys_dict_only(obj, attr.split("."), default)
-        else:
-            return _get_value_for_key_dict_only(obj, attr, default)
-
-
-def _get_value_for_keys_dict_only(obj, keys, default):
-    if len(keys) == 1:
-        return _get_value_for_key_dict_only(obj, keys[0], default)
-    else:
-        return _get_value_for_keys_dict_only(
-            _get_value_for_key_dict_only(obj, keys[0], default), keys[1:], default
-        )
-
-
-def _get_value_for_key_dict_only(obj, key, default):
-    try:
-        return obj[key]
-    except (KeyError, IndexError, TypeError, AttributeError):
-        return default

oarepo_runtime/services/schema/marshmallow_to_json_schema.py

@@ -1,72 +0,0 @@
-from marshmallow import Schema, fields
-from oarepo_runtime.services.schema.ui import (
-    LocalizedEDTFTime,
-    LocalizedDateTime,
-    LocalizedEDTF,
-    LocalizedEDTFInterval,
-    LocalizedEDTFTimeInterval,
-    LocalizedTime
-)
-
-field_type_converters = {
-    fields.String : lambda field: {"type" : "string"},
-    fields.Integer: lambda field: {"type": "integer"},
-    fields.Float: lambda field: {"type": "number"},
-    fields.Boolean: lambda field: {"type": "boolean"},
-    fields.List: lambda field: {
-        "type": "array",
-        "items": convert_field_to_json_schema(field.inner)
-    },
-    fields.Nested: lambda field: {
-        "type": "object",
-        "properties": marshmallow_to_json_schema(field.schema)["properties"]
-    },
-    fields.Raw: lambda field: {
-        "type": "object",
-        'additionalProperties' : True
-    },
-    LocalizedEDTFTime: lambda field: {
-        "type": "string",
-        "format": "date-time",
-    },
-    LocalizedDateTime: lambda field: {
-        "type": "string",
-        "format": "date-time",
-    },
-    LocalizedTime: lambda field: {
-        "type": "string",
-        "format": "time",
-    },
-    LocalizedEDTF: lambda field: {
-        "type": "string",
-        "format": "date",
-    },
-    LocalizedEDTFInterval: lambda field: {
-        "type": "string",
-        "format": "date-time",
-    },
-    LocalizedEDTFTimeInterval: lambda field: {
-        "type": "string",
-        "format": "date-time",
-    }
-}
-
-def marshmallow_to_json_schema(schema:Schema) -> dict:
-    json_schema = {
-        'type': 'object',
-        'properties': {}
-    }
-
-    for field_name, field in schema.fields.items():
-        json_schema["properties"][field_name] = convert_field_to_json_schema(field)
-
-    return json_schema
-
-
-def convert_field_to_json_schema(field:fields) -> dict:
-    for field_type in type(field).mro():
-        if field_type in field_type_converters:
-            return field_type_converters[field_type](field)
-
-    # no converter found, just string
-    return {"type":"string"}