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

oarepo_runtime/records/relations/base.py

@@ -1,296 +0,0 @@
-from functools import cached_property
-from typing import List
-
-from invenio_records.dictutils import dict_lookup, dict_set
-from invenio_records.systemfields.base import SystemField
-from invenio_records.systemfields.relations import (
-    InvalidCheckValue,
-    InvalidRelationValue,
-)
-
-from oarepo_runtime.services.relations.errors import MultipleInvalidRelationErrors
-from oarepo_runtime.services.relations.mapping import RelationsMapping
-
-from .lookup import LookupResult, lookup_key
-
-
-class RelationResult:
-    def __init__(self, field, record, cache) -> None:
-        self.field = field
-        self.record = record
-        self.cache = cache
-
-    def validate(self, raise_first_exception=True):
-        found: List[LookupResult] = lookup_key(self.record, self.field.key)
-        exceptions = []
-        for relation in found:
-            try:
-                resolved_object = self._resolve_lookup_result(relation)
-
-                if self.field.value_check:
-                    transformed_data = {}
-                    self._get_dereferenced_value(
-                        transformed_data, resolved_object, relation
-                    )
-                    self._value_check(relation.value, transformed_data)
-            except Exception as e:
-                if raise_first_exception:
-                    raise
-                exceptions.append((relation, e))
-        if exceptions:
-            raise MultipleInvalidRelationErrors(exceptions)
-
-    def _resolve_lookup_result(self, relation):
-        if not isinstance(relation.value, dict):
-            raise InvalidRelationValue(
-                f"Value at path {relation.path} must be dict, found {relation.value}"
-            )
-        relation_id = self._lookup_id(relation)
-        resolved_object = self.resolve(relation_id)
-        if resolved_object is None:
-            raise InvalidRelationValue(f"Could not resolve relation id {relation_id}.")
-        return resolved_object
-
-    def clean(self):
-        """Clean the dereferenced attributes inside the record."""
-        found: List[LookupResult] = lookup_key(self.record, self.field.key)
-        for relation in found:
-            self._clean_one(relation)
-
-    def dereference(self):
-        """Dereference the relation field object inside the record."""
-        found: List[LookupResult] = lookup_key(self.record, self.field.key)
-        for relation in found:
-            self._dereference_one(relation)
-
-    def _clean_one(self, relation: LookupResult):
-        """
-        Cleans the relation. The default implementation does nothing - the relation has been
-        validated,
-        """
-
-    def _needs_update_relation_value(self, _relation: LookupResult):
-        """
-        Returns True if the relation needs resolving and updating value
-
-        :param relation: relation being processed
-        """
-        return True
-
-    def _add_version_info(self, data, relation: LookupResult, resolved_object):
-        """
-        Adds versioning info on relation data
-
-        :param data: relation data
-        :param relation: relation being processed
-        :param resolved_object: the object to which this relation points to
-        """
-
-    def _dereference_one(self, relation: LookupResult):
-        """Dereference a single object into a dict."""
-        if not self._needs_update_relation_value(relation):
-            return
-
-        data = relation.value
-        obj = self._resolve_lookup_result(relation)
-        self._get_dereferenced_value(data, obj, relation)
-
-        return data
-
-    def _get_dereferenced_value(self, data, obj, relation):
-        # Inject selected key/values from related record into
-        # the current record.
-
-        # From record dictionary
-        if self.field.keys is None:
-            data.update({k: v for k, v in obj.items()})
-        else:
-            new_obj = {}
-            for k in self.field.keys:
-                try:
-                    key = self._get_dereference_key(k, relation)
-                    target = self._get_dereference_target(k, relation)
-                    val = dict_lookup(obj, key)
-                    if val:
-                        dict_set(new_obj, target, val)
-                except KeyError:
-                    pass
-            data.update(new_obj)
-
-        # From record attributes (i.e. system fields)
-        for a in self.field.attrs:
-            data[a] = getattr(obj, a)
-
-        self._add_version_info(data, relation, obj)
-
-    def _get_dereference_key(self, key, _relation: LookupResult):
-        if isinstance(key, dict):
-            return key["key"]
-        return key
-
-    def _get_dereference_target(self, key, _relation: LookupResult):
-        if isinstance(key, dict):
-            return key["target"]
-        return key
-
-    def _value_check(self, value_to_check, object):
-        """Checks if the value is present in the object."""
-        # TODO: this is way too complicated, should refactor it (and look at the code coverage as well)
-        for key, value in value_to_check.items():
-            if key not in object:
-                raise InvalidCheckValue(f"Invalid key {key}.")
-            if isinstance(value, dict):
-                self._value_check(value, object[key])
-            else:
-                if not isinstance(value, list):
-                    raise InvalidCheckValue(
-                        f"Invalid value_check value: {value}; it must be " "a list"
-                    )
-                elif isinstance(object[key], list):
-                    value_exist = set(object[key]).intersection(set(value))
-                    if not value_exist:
-                        raise InvalidCheckValue(
-                            f"Failed cross checking value_check value "
-                            f"{value} with record value {object[key]}."
-                        )
-                else:
-                    if object[key] not in value:
-                        raise InvalidCheckValue(
-                            f"Failed cross checking value_check value "
-                            f"{value} with record value {object[key]}."
-                        )
-
-    def _lookup_id(self, relation: LookupResult):
-        relation_id = relation.value.get("id", None)
-        if not relation_id:
-            raise InvalidRelationValue(
-                f"Value at path {relation.path} must contain non-empty 'id' field, found {relation.value}"
-            )
-        return relation_id
-
-    def _store_id(self, relation: LookupResult, relation_id):
-        relation.value["id"] = relation_id
-
-    def resolve(self, id_):
-        raise NotImplementedError("Please implement this method in your subclass")
-
-
-class UnstrictRelationResult(RelationResult):
-
-    def _resolve_lookup_result(self, relation):
-        if not isinstance(relation.value, dict):
-            raise InvalidRelationValue(
-                f"Value at path {relation.path} must be dict, found {relation.value}"
-            )
-        if "id" not in relation.value:
-            return relation.value
-        relation_id = self._lookup_id(relation)
-        resolved_object = self.resolve(relation_id, relation.value)
-        if resolved_object is None:
-            raise InvalidRelationValue(f"Could not resolve relation id {relation_id}.")
-        return resolved_object
-
-    def _dereference_one(self, relation: LookupResult):
-        """Dereference a single object into a dict."""
-        if not self._needs_update_relation_value(relation):
-            return
-
-        data = relation.value
-        obj = self._resolve_lookup_result(relation)
-        if type(obj) is not dict:
-            self._get_dereferenced_value(data, obj, relation)
-
-        return data
-
-
-class Relation:
-    result_cls = RelationResult
-
-    def __init__(
-        self,
-        key=None,
-        attrs=None,
-        keys=None,
-        _clear_empty=True,
-        value_check=None,
-    ):
-        """Initialize the relation."""
-        self.key = key
-        self.attrs = attrs or []
-        self.keys = keys or []
-        self._clear_empty = _clear_empty
-        self.value_check = value_check
-
-    def get_value(self, record, cache):
-        """Return the resolved relation from a record."""
-        return self.result_cls(self, record, cache)
-
-
-class RelationsField(SystemField):
-    # taken from RelationsField
-    def __init__(self, **fields):
-        """Initialize the field."""
-        super().__init__()
-        assert all(isinstance(f, Relation) for f in fields.values())
-        self._original_fields = fields
-
-    def __getattr__(self, name):
-        """Get a field definition."""
-        if name in self._fields:
-            return self._fields[name]
-        raise AttributeError
-
-    def __iter__(self):
-        """Iterate over the configured fields."""
-        return iter(getattr(self, f) for f in self._fields)
-
-    def __contains__(self, name):
-        """Return if a field exists in the configured fields."""
-        return name in self._fields
-
-    #
-    # Properties
-    #
-    @cached_property
-    def _fields(self):
-        """Get the fields."""
-        return self._original_fields
-
-    #
-    # Helpers
-    #
-    def obj(self, instance):
-        """Get the relations object."""
-        # Check cache
-        obj = self._get_cache(instance)
-        if obj:
-            return obj
-        obj = RelationsMapping(record=instance, fields=self._fields)
-        self._set_cache(instance, obj)
-        return obj
-
-    #
-    # Data descriptor
-    #
-    def __get__(self, record, owner=None):
-        """Accessing the attribute."""
-        # Class access
-        if record is None:
-            return self
-        return self.obj(record)
-
-    def __set__(self, instance, values):
-        """Setting the attribute."""
-        obj = self.obj(instance)
-        for k, v in values.items():
-            setattr(obj, k, v)
-
-    #
-    # Record extension
-    #
-    def pre_commit(self, record):
-        """Initialise the model field."""
-        obj = self.obj(record)
-        obj.validate()
-        obj.clean()
-        obj.dereference()

oarepo_runtime/records/relations/internal.py

@@ -1,46 +0,0 @@
-from invenio_records.systemfields.relations import InvalidRelationValue
-
-from .base import Relation, RelationResult
-from .lookup import LookupResult, lookup_key
-
-
-class InternalResult(RelationResult):
-    def resolve(self, id_):
-        related_part = self.field.related_part
-
-        if not related_part:
-            return self.record
-
-        potential_values = list(lookup_key(self.record, related_part))
-
-        if not id_:
-            if len(potential_values) > 1:
-                raise InvalidRelationValue(
-                    "Relation returned more than one part at "
-                    f"{related_part} but has no id to check those parts against"
-                )
-            return potential_values[0].value
-
-        for rel in potential_values:
-            if not isinstance(rel.value, dict):
-                raise KeyError(
-                    f"Related part {related_part} does not point to an array of objects at path "
-                    f"{rel.path}- array member is {type(rel.value)}: {rel.value}"
-                )
-
-            if id_ == rel.value.get("id", None):
-                return rel.value
-
-        raise KeyError(f"No data for relation at path {related_part} with id {id_}")
-
-    def _lookup_id(self, relation: LookupResult):
-        relation_id = relation.value.get("id", None)
-        return relation_id
-
-
-class InternalRelation(Relation):
-    result_cls = InternalResult
-
-    def __init__(self, key=None, related_part=None, **kwargs):
-        super().__init__(key=key, **kwargs)
-        self.related_part = related_part

oarepo_runtime/records/relations/lookup.py

@@ -1,28 +0,0 @@
-import dataclasses
-from typing import Any, Tuple
-
-
-@dataclasses.dataclass
-class LookupResult:
-    path: Tuple[str]
-    value: Any
-
-
-def lookup_key(record, key):
-    """more generic version of dict_lookup, for arrays does not look up by index but returns all members of array"""
-
-    def _internal_lookup_key(key, data, path: Tuple):
-        if isinstance(data, (tuple, list)):
-            for idx, d in enumerate(data):
-                yield from _internal_lookup_key(key, d, path + (idx,))
-            return
-        if not key:
-            yield LookupResult(path, data)
-            return
-        if not isinstance(data, dict):
-            return
-        if key[0] in data:
-            yield from _internal_lookup_key(key[1:], data[key[0]], path + (key[0],))
-
-    key = key.split(".")
-    return list(_internal_lookup_key(key, record, tuple()))

oarepo_runtime/records/relations/pid_relation.py

@@ -1,102 +0,0 @@
-from invenio_db import db
-
-from oarepo_runtime.services.relations.errors import InvalidRelationError
-from sqlalchemy.exc import NoResultFound
-
-from .base import Relation, RelationResult, UnstrictRelationResult
-from .lookup import LookupResult
-
-class PIDRelationResult(RelationResult):
-    def resolve(self, id_, data = None):
-        """Resolve the value using the record class."""
-        # TODO: handle permissions here !!!!!!
-        try:
-            pid_field_context = self.field.pid_field
-            try:
-                pid_type = getattr(pid_field_context, "pid_type", None)
-            except:
-                pass
-
-            if pid_type is None:
-                pid_field = pid_field_context.field
-                if pid_field._provider:
-                    if hasattr(pid_field._provider, "pid_type"):
-                        pid_type = pid_field._provider.pid_type
-                    else:
-                        pid_type = self.field.pid_field.record_cls.__name__
-                else:
-                    if hasattr(pid_field, "_pid_type"):
-                        pid_type = pid_field._pid_type
-                    else:
-                        pid_type = self.field.pid_field.record_cls.__name__
-        except Exception as e:
-            raise InvalidRelationError(
-                f"PID type for field {self.field.key} has not been found or there was an exception accessing it.",
-                related_id=id_,
-                location=self.field.key,
-            ) from e
-
-        cache_key = (pid_type, id_)
-        if cache_key in self.cache:
-            obj = self.cache[cache_key]
-            return obj
-
-        try:
-            obj = pid_field_context.resolve(id_)
-            if hasattr(obj, "relations") and obj.relations and hasattr(obj.relations, "dereference"):
-                obj.relations.dereference()
-            # We detach the related record model from the database session when
-            # we add it in the cache. Otherwise, accessing the cached record
-            # model, will execute a new select query after a db.session.commit.
-            db.session.expunge(obj.model)
-            self.cache[cache_key] = obj
-            return obj
-        except Exception as e:
-            raise InvalidRelationError(
-                f"Repository object {cache_key} has not been found or there was an exception accessing it. "
-                f"Referenced from {self.field.key}.",
-                related_id=id_,
-                location=self.field.key,
-            ) from e
-
-    def _needs_update_relation_value(self, relation: LookupResult):
-        # Don't dereference if already referenced.
-        return "@v" not in relation.value
-
-    def _add_version_info(self, data, relation: LookupResult, resolved_object):
-        data["@v"] = f"{resolved_object.id}::{resolved_object.revision_id}"
-
-class UnstrictPIDRelationResult(PIDRelationResult, UnstrictRelationResult):
-
-    def resolve(self, id_, data):
-        try:
-            return super().resolve(id_, data)
-        except InvalidRelationError as e:
-            if isinstance(e.__cause__, NoResultFound):
-                return data
-            raise
-
-class PIDRelation(Relation):
-    result_cls = PIDRelationResult
-
-    def __init__(self, key=None, pid_field=None, **kwargs):
-        super().__init__(key=key, **kwargs)
-        self.pid_field = pid_field
-
-class UnstrictPIDRelation(Relation):
-    result_cls = UnstrictPIDRelationResult
-
-    def __init__(self, key=None, pid_field=None, **kwargs):
-        super().__init__(key=key, **kwargs)
-        self.pid_field = pid_field
-
-class MetadataRelationResult(PIDRelationResult):
-    def _dereference_one(self, relation: LookupResult):
-        ret = super()._dereference_one(relation)
-        if "metadata" in ret:
-            ret.update(ret.pop("metadata"))
-        return ret
-
-
-class MetadataPIDRelation(PIDRelation):
-    result_cls = MetadataRelationResult

oarepo_runtime/records/systemfields/featured_file.py

@@ -1,45 +0,0 @@
-from invenio_access.permissions import system_identity
-from invenio_records.systemfields import SystemField
-from invenio_records_resources.proxies import current_service_registry
-
-from oarepo_runtime.datastreams.utils import get_file_service_for_record_service
-from oarepo_runtime.records.systemfields.mapping import MappingSystemFieldMixin
-
-
-class FeaturedFileFieldResult:
-    def __init__(self, record=None):
-        super().__init__()
-        self.record = record
-
-
-class FeaturedFileField(MappingSystemFieldMixin, SystemField):
-    def __init__(self, source_field):
-        super(FeaturedFileField, self).__init__(source_field)
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        result = FeaturedFileFieldResult(record=instance)
-        return result
-
-    def search_dump(self, data, record):
-        for service in current_service_registry._services:
-            if getattr(
-                current_service_registry._services[service], "record_cls"
-            ) == type(record):
-                file_service = get_file_service_for_record_service(
-                    record_service=current_service_registry._services[service],
-                    record=record,
-                )
-
-                files = file_service.list_files(system_identity, record["id"])
-                file_list = list(files.entries)
-
-                for file in file_list:
-                    if (
-                        file["metadata"]
-                        and "featured" in file["metadata"]
-                        and file["metadata"]["featured"]
-                    ):
-                        record["metadata"].update({"featured": file})
-                        record.commit()

oarepo_runtime/records/systemfields/has_draftcheck.py

@@ -1,47 +0,0 @@
-from inspect import isfunction
-
-from invenio_records.dictutils import dict_set
-from invenio_records.systemfields import SystemField
-from sqlalchemy.orm.exc import NoResultFound
-
-from oarepo_runtime.services.custom_fields import CustomFieldsMixin
-
-
-# taken from https://github.com/inveniosoftware/invenio-rdm-records/blob/master/invenio_rdm_records/records/systemfields/has_draftcheck.py
-class HasDraftCheckField(CustomFieldsMixin, SystemField):
-    """PID status field which checks against an expected status."""
-
-    def __init__(self, draft_cls=None, key=None, **kwargs):
-        """Initialize the PIDField.
-
-        It stores the `record.has_draft` value in the secondary storage
-        system's record or defaults to `False` if the `draft_cls` is not passed
-        e.g Draft records.
-
-        :param key: Attribute name of the HasDraftCheckField.
-        :param draft_cls: The draft class to use for querying.
-        """
-        super().__init__(key=key, **kwargs)
-        self.draft_cls = draft_cls
-
-    #
-    # Data descriptor methods (i.e. attribute access)
-    #
-    def __get__(self, record, owner=None):
-        if record is None:
-            return self  # returns the field itself.
-
-        # If not draft_cls is passed return False
-        if self.draft_cls is None:
-            return False
-
-        try:
-            if isfunction(self.draft_cls):
-                self.draft_cls = self.draft_cls()
-            self.draft_cls.get_record(record.id)
-            return True
-        except NoResultFound:
-            return False
-
-    def pre_dump(self, record, data, **kwargs):
-        dict_set(data, self.key, record.has_draft)