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

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"}

oarepo_runtime/services/schema/oneofschema.py

@@ -1,192 +0,0 @@
-import typing
-
-from marshmallow import Schema, ValidationError
-
-
-class OneOfSchema(Schema):
-    """
-    This is a special kind of schema that actually multiplexes other schemas
-    based on object type. When serializing values, it uses get_obj_type() method
-    to get object type name. Then it uses `type_schemas` name-to-Schema mapping
-    to get schema for that particular object type, serializes object using that
-    schema and adds an extra "type" field with name of object type.
-    Deserialization is reverse.
-
-    Example:
-
-        class Foo(object):
-            def __init__(self, foo):
-                self.foo = foo
-
-        class Bar(object):
-            def __init__(self, bar):
-                self.bar = bar
-
-        class FooSchema(marshmallow.Schema):
-            foo = marshmallow.fields.String(required=True)
-
-            @marshmallow.post_load
-            def make_foo(self, data, **kwargs):
-                return Foo(**data)
-
-        class BarSchema(marshmallow.Schema):
-            bar = marshmallow.fields.Integer(required=True)
-
-            @marshmallow.post_load
-            def make_bar(self, data, **kwargs):
-                return Bar(**data)
-
-        class MyUberSchema(marshmallow.OneOfSchema):
-            type_schemas = {
-                'foo': FooSchema,
-                'bar': BarSchema,
-            }
-
-            def get_obj_type(self, obj):
-                if isinstance(obj, Foo):
-                    return 'foo'
-                elif isinstance(obj, Bar):
-                    return 'bar'
-                else:
-                    raise Exception('Unknown object type: %s' % repr(obj))
-
-        MyUberSchema().dump([Foo(foo='hello'), Bar(bar=123)], many=True)
-        # => [{'type': 'foo', 'foo': 'hello'}, {'type': 'bar', 'bar': 123}]
-
-    You can control type field name added to serialized object representation by
-    setting `type_field` class property.
-    """
-
-    type_field = "type"
-    type_field_remove = True
-    type_schemas: typing.Mapping[str, typing.Union[typing.Type[Schema], Schema]] = {}
-
-    def get_obj_type(self, obj):
-        """Returns name of the schema during dump() calls, given the object
-        being dumped."""
-        return obj.__class__.__name__
-
-    def get_data_type(self, data):
-        """Returns name of the schema during load() calls, given the data being
-        loaded. Defaults to looking up `type_field` in the data."""
-        data_type = data.get(self.type_field)
-        if self.type_field in data and self.type_field_remove:
-            data.pop(self.type_field)
-        return data_type
-
-    def dump(self, obj, *, many=None, **kwargs):
-        errors = {}
-        result_data = []
-        result_errors = {}
-        many = self.many if many is None else bool(many)
-        if not many:
-            result = result_data = self._dump(obj, **kwargs)
-        else:
-            for idx, o in enumerate(obj):
-                try:
-                    result = self._dump(o, **kwargs)
-                    result_data.append(result)
-                except ValidationError as error:
-                    result_errors[idx] = error.normalized_messages()
-                    result_data.append(error.valid_data)
-
-        result = result_data
-        errors = result_errors
-
-        if not errors:
-            return result
-        else:
-            exc = ValidationError(errors, data=obj, valid_data=result)
-            raise exc
-
-    def _dump(self, obj, *, update_fields=True, **kwargs):
-        obj_type = self.get_obj_type(obj)
-        if obj_type is None:
-            return (
-                None,
-                {"_schema": "Unknown object class: %s" % obj.__class__.__name__},
-            )
-
-        type_schema = self.type_schemas.get(obj_type)
-        if not type_schema:
-            return None, {"_schema": "Unsupported object type: %s" % obj_type}
-
-        schema = type_schema if isinstance(type_schema, Schema) else type_schema()
-
-        schema.context.update(getattr(self, "context", {}))
-
-        result = schema.dump(obj, many=False, **kwargs)
-        if result is not None:
-            result[self.type_field] = obj_type
-        return result
-
-    def load(self, data, *, many=None, partial=None, unknown=None, **kwargs):
-        errors = {}
-        result_data = []
-        result_errors = {}
-        many = self.many if many is None else bool(many)
-        if partial is None:
-            partial = self.partial
-        if not many:
-            try:
-                result_data = self._load(
-                    data, partial=partial, unknown=unknown, **kwargs
-                )
-            except ValidationError as error:
-                result_errors = error.normalized_messages()
-                result_data = error.valid_data
-        else:
-            for idx, item in enumerate(data):
-                try:
-                    result = self._load(item, partial=partial, **kwargs)
-                    result_data.append(result)
-                except ValidationError as error:
-                    result_errors[idx] = error.normalized_messages()
-                    result_data.append(error.valid_data)
-
-        result = result_data
-        errors = result_errors
-
-        if not errors:
-            return result
-        else:
-            exc = ValidationError(errors, data=data, valid_data=result)
-            raise exc
-
-    def _load(self, data, *, partial=None, unknown=None, **kwargs):
-        if not isinstance(data, dict):
-            raise ValidationError({"_schema": "Invalid data type: %s" % data})
-
-        data = dict(data)
-        unknown = unknown or self.unknown
-        data_type = self.get_data_type(data)
-
-        if data_type is None:
-            raise ValidationError(
-                {self.type_field: ["Missing data for required field."]}
-            )
-
-        try:
-            type_schema = self.type_schemas.get(data_type)
-        except TypeError as error:
-            # data_type could be unhashable
-            raise ValidationError(
-                {self.type_field: ["Invalid value: %s" % data_type]}
-            ) from error
-        if not type_schema:
-            raise ValidationError(
-                {self.type_field: ["Unsupported value: %s" % data_type]}
-            )
-
-        schema = type_schema if isinstance(type_schema, Schema) else type_schema()
-
-        schema.context.update(getattr(self, "context", {}))
-
-        return schema.load(data, many=False, partial=partial, unknown=unknown, **kwargs)
-
-    def validate(self, data, *, many=None, partial=None):
-        try:
-            self.load(data, many=many, partial=partial)
-        except ValidationError as ve:
-            return ve.messages
-        return {}

oarepo_runtime/services/schema/polymorphic.py

@@ -1,21 +0,0 @@
-from functools import cached_property
-
-import marshmallow as ma
-
-# from marshmallow_oneofschema import OneOfSchema
-from oarepo_runtime.services.schema.oneofschema import OneOfSchema
-
-
-class PolymorphicSchema(OneOfSchema):
-    type_field_remove = False
-
-    def get_obj_type(self, obj):
-        return obj[self.type_field]
-
-    @cached_property
-    def type_schemas(self):
-        ret = {}
-        for key, fld in self.fields.items():
-            if isinstance(fld, ma.fields.Nested):
-                ret[fld.attribute or key] = type(fld.schema)
-        return ret

oarepo_runtime/services/schema/rdm.py

@@ -1,75 +0,0 @@
-from functools import partial
-
-import marshmallow as ma
-from invenio_i18n.selectors import get_locale
-from invenio_rdm_records.services.schemas.metadata import record_identifiers_schemes
-from invenio_rdm_records.services.schemas.tombstone import DeletionStatusSchema
-from invenio_rdm_records.services.schemas.versions import VersionsSchema
-from invenio_vocabularies.contrib.awards.schema import AwardRelationSchema
-from invenio_vocabularies.contrib.funders.schema import FunderRelationSchema
-from marshmallow import fields as ma_fields
-from marshmallow import pre_load
-from marshmallow_utils.fields import (
-    IdentifierSet,
-)
-from marshmallow_utils.fields.nestedattr import NestedAttribute
-from marshmallow_utils.schemas.identifier import IdentifierSchema
-
-from .i18n import MultilingualField
-
-
-class RDMRecordMixin(ma.Schema):
-    versions = NestedAttribute(VersionsSchema, dump_only=True)
-    deletion_status = ma_fields.Nested(DeletionStatusSchema, dump_only=True)
-
-
-class MultilingualAwardSchema(AwardRelationSchema):
-    class Meta:
-        unknown = ma.RAISE
-
-    @pre_load()
-    def convert_to_multilingual(self, data, many, **kwargs):
-        if "title" in data and type(data["title"]) is str:
-            lang = get_locale()
-            data["title"] = {lang: data["title"]}
-        return data
-
-
-class FundingSchema(ma.Schema):
-    """Funding schema."""
-
-    funder = ma_fields.Nested(FunderRelationSchema, required=True)
-    award = ma_fields.Nested(MultilingualAwardSchema)
-
-
-class RecordIdentifierField(IdentifierSet):
-    def __init__(self, *args, **kwargs):
-        super().__init__(
-            ma.fields.Nested(
-                partial(IdentifierSchema, allowed_schemes=record_identifiers_schemes)
-            ),
-            *args,
-            **kwargs
-        )
-
-
-class RelatedRecordIdentifierField(IdentifierSet):
-    def __init__(self, *args, **kwargs):
-        super().__init__(
-            ma.fields.Nested(
-                partial(IdentifierSchema, allowed_schemes=record_identifiers_schemes)
-            ),
-            *args,
-            **kwargs
-        )
-
-
-class RDMSubjectSchema(ma.Schema):
-    """Subject ui schema."""
-
-    class Meta:
-        unknown = ma.RAISE
-
-    _id = ma.fields.String(data_key="id")
-
-    subject = MultilingualField()

oarepo_runtime/services/schema/rdm_ui.py

@@ -1,156 +0,0 @@
-import marshmallow as ma
-from idutils import to_url
-from oarepo_vocabularies.services.ui_schema import VocabularyI18nStrUIField
-
-from oarepo_runtime.services.schema.marshmallow import DictOnlySchema
-
-from .i18n_ui import MultilingualUIField
-
-
-class RDMIdentifierWithSchemaUISchema(ma.Schema):
-    scheme = ma.fields.String(
-        required=True,
-    )
-    identifier = ma.fields.String(required=True)
-
-    @ma.post_dump
-    def add_url(self, value, **kwargs):
-        try:
-            # ignore errors here
-            if "identifier" in value and "scheme" in value:
-                url = to_url(
-                    value["identifier"], value["scheme"].lower(), url_scheme="https"
-                )
-                if url:
-                    value["url"] = url
-        except Exception:
-            pass
-        return value
-
-
-class RDMAwardIdentifierUISchema(ma.Schema):
-    identifier = ma.fields.String()
-
-
-class RDMAwardSubjectUISchema(ma.Schema):
-    _id = ma.fields.String(data_key="id")
-
-    subject = ma.fields.String()
-
-
-class RDMAwardOrganizationUISchema(ma.Schema):
-    schema = ma.fields.String()
-
-    _id = ma.fields.String(data_key="id")
-
-    organization = ma.fields.String()
-
-
-class RDMFunderVocabularyUISchema(DictOnlySchema):
-    class Meta:
-        unknown = ma.INCLUDE
-
-    _id = ma.fields.String(data_key="id", attribute="id")
-
-    _version = ma.fields.String(data_key="@v", attribute="@v")
-
-    name = ma.fields.String()
-
-    identifiers = ma.fields.List(ma.fields.Nested(RDMIdentifierWithSchemaUISchema()))
-
-
-class RDMRoleVocabularyUISchema(DictOnlySchema):
-    class Meta:
-        unknown = ma.INCLUDE
-
-    _id = ma.fields.String(data_key="id", attribute="id")
-
-    _version = ma.fields.String(data_key="@v", attribute="@v")
-
-    title = VocabularyI18nStrUIField()
-
-
-class RDMAwardVocabularyUISchema(DictOnlySchema):
-    class Meta:
-        unknown = ma.INCLUDE
-
-    _id = ma.fields.String(data_key="id", attribute="id")
-
-    _version = ma.fields.String(data_key="@v", attribute="@v")
-
-    title = VocabularyI18nStrUIField()
-
-    number = ma.fields.String()
-
-    identifier = ma.fields.List(ma.fields.Nested(RDMAwardIdentifierUISchema()))
-
-    acronym = ma.fields.String()
-
-    program = ma.fields.String()
-
-    subjects = ma.fields.List(ma.fields.Nested(RDMAwardSubjectUISchema()))
-
-    organizations = ma.fields.List(ma.fields.Nested(RDMAwardOrganizationUISchema()))
-
-
-class RDMFundersUISchema(ma.Schema):
-    """Funding ui schema."""
-
-    class Meta:
-        unknown = ma.RAISE
-
-    funder = ma.fields.Nested(lambda: RDMFunderVocabularyUISchema())
-
-    award = ma.fields.Nested(lambda: RDMAwardVocabularyUISchema())
-
-
-class RDMPersonOrOrganizationUISchema(ma.Schema):
-    class Meta:
-        unknown = ma.INCLUDE
-
-    name = ma.fields.String()
-
-    type = ma.fields.String()
-
-    given_name = ma.fields.String()
-
-    family_name = ma.fields.String()
-
-    identifiers = ma.fields.List(ma.fields.Nested(RDMIdentifierWithSchemaUISchema()))
-
-
-class RDMAffiliationVocabularyUISchema(DictOnlySchema):
-    class Meta:
-        unknown = ma.INCLUDE
-
-    _id = ma.fields.String(data_key="id", attribute="id")
-
-    _version = ma.fields.String(data_key="@v", attribute="@v")
-
-    name = ma.fields.String()
-
-
-class RDMCreatorsUISchema(ma.Schema):
-    """Funding ui schema."""
-
-    class Meta:
-        unknown = ma.RAISE
-
-    role = ma.fields.Nested(lambda: RDMRoleVocabularyUISchema())
-
-    affiliations = ma.fields.List(
-        ma.fields.Nested(lambda: RDMAffiliationVocabularyUISchema())
-    )
-
-    person_or_org = ma.fields.Nested(RDMPersonOrOrganizationUISchema())
-
-
-class RDMSubjectUISchema(ma.Schema):
-    """Subject ui schema."""
-
-    class Meta:
-        unknown = ma.RAISE
-
-    _id = ma.fields.String(data_key="id")
-
-    subject = MultilingualUIField()