invenio-vocabularies 9.1.2__py2.py3-none-any.whl

invenio_vocabularies/records/mappings/os-v1/vocabularies/vocabulary-v1.0.0.json

@@ -0,0 +1,109 @@
+{
+  "mappings": {
+    "dynamic_templates": [
+      {
+        "i18n_title": {
+          "path_match": "title.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "search_as_you_type"
+          }
+        }
+      }, {
+        "i18n_description": {
+          "path_match": "description.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "text"
+          }
+        }
+      }
+    ],
+    "dynamic": "strict",
+    "properties": {
+      "$schema": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "created": {
+        "type": "date"
+      },
+      "updated": {
+        "type": "date"
+      },
+      "indexed_at": {
+        "type": "date"
+      },
+      "uuid": {
+        "type": "keyword"
+      },
+      "version_id": {
+        "type": "integer"
+      },
+      "id": {
+        "type": "keyword",
+        "fields": {
+          "text": {
+            "type": "search_as_you_type"
+          }
+        }
+      },
+      "type": {
+        "type": "object",
+        "properties": {
+          "pid_type": {
+            "type": "keyword"
+          },
+          "id": {
+            "type": "keyword"
+          }
+        }
+      },
+      "pid": {
+        "type": "object",
+        "properties": {
+          "pk": {
+            "type": "integer"
+          },
+          "pid_type": {
+            "type": "keyword"
+          },
+          "obj_type": {
+            "type": "keyword"
+          },
+          "status": {
+            "type": "keyword"
+          }
+        }
+      },
+      "title_sort": {
+        "type": "keyword"
+      },
+      "title": {
+        "type": "object",
+        "dynamic": "true",
+        "properties": {
+          "en": {
+            "type": "search_as_you_type",
+            "copy_to": "title_sort"
+          }
+        }
+      },
+      "description": {
+        "type": "object",
+        "dynamic": "true"
+      },
+      "icon": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "tags": {
+        "type": "keyword"
+      },
+      "props": {
+        "type": "object",
+        "dynamic": "true"
+      }
+    }
+  }
+}

invenio_vocabularies/records/mappings/os-v2/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2022 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""OpenSearch v2 mappings."""

invenio_vocabularies/records/mappings/os-v2/vocabularies/vocabulary-v1.0.0.json

@@ -0,0 +1,109 @@
+{
+  "mappings": {
+    "dynamic_templates": [
+      {
+        "i18n_title": {
+          "path_match": "title.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "search_as_you_type"
+          }
+        }
+      }, {
+        "i18n_description": {
+          "path_match": "description.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "text"
+          }
+        }
+      }
+    ],
+    "dynamic": "strict",
+    "properties": {
+      "$schema": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "created": {
+        "type": "date"
+      },
+      "updated": {
+        "type": "date"
+      },
+      "indexed_at": {
+        "type": "date"
+      },
+      "uuid": {
+        "type": "keyword"
+      },
+      "version_id": {
+        "type": "integer"
+      },
+      "id": {
+        "type": "keyword",
+        "fields": {
+          "text": {
+            "type": "search_as_you_type"
+          }
+        }
+      },
+      "type": {
+        "type": "object",
+        "properties": {
+          "pid_type": {
+            "type": "keyword"
+          },
+          "id": {
+            "type": "keyword"
+          }
+        }
+      },
+      "pid": {
+        "type": "object",
+        "properties": {
+          "pk": {
+            "type": "integer"
+          },
+          "pid_type": {
+            "type": "keyword"
+          },
+          "obj_type": {
+            "type": "keyword"
+          },
+          "status": {
+            "type": "keyword"
+          }
+        }
+      },
+      "title_sort": {
+        "type": "keyword"
+      },
+      "title": {
+        "type": "object",
+        "dynamic": "true",
+        "properties": {
+          "en": {
+            "type": "search_as_you_type",
+            "copy_to": "title_sort"
+          }
+        }
+      },
+      "description": {
+        "type": "object",
+        "dynamic": "true"
+      },
+      "icon": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "tags": {
+        "type": "keyword"
+      },
+      "props": {
+        "type": "object",
+        "dynamic": "true"
+      }
+    }
+  }
+}

invenio_vocabularies/records/mappings/v7/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020-2021 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Elasticsearch version 7 mappings."""

invenio_vocabularies/records/mappings/v7/vocabularies/vocabulary-v1.0.0.json

@@ -0,0 +1,109 @@
+{
+  "mappings": {
+    "dynamic_templates": [
+      {
+        "i18n_title": {
+          "path_match": "title.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "search_as_you_type"
+          }
+        }
+      }, {
+        "i18n_description": {
+          "path_match": "description.*",
+          "match_mapping_type": "string",
+          "mapping": {
+            "type": "text"
+          }
+        }
+      }
+    ],
+    "dynamic": "strict",
+    "properties": {
+      "$schema": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "created": {
+        "type": "date"
+      },
+      "updated": {
+        "type": "date"
+      },
+      "indexed_at": {
+        "type": "date"
+      },
+      "uuid": {
+        "type": "keyword"
+      },
+      "version_id": {
+        "type": "integer"
+      },
+      "id": {
+        "type": "keyword",
+        "fields": {
+          "text": {
+            "type": "search_as_you_type"
+          }
+        }
+      },
+      "type": {
+        "type": "object",
+        "properties": {
+          "pid_type": {
+            "type": "keyword"
+          },
+          "id": {
+            "type": "keyword"
+          }
+        }
+      },
+      "pid": {
+        "type": "object",
+        "properties": {
+          "pk": {
+            "type": "integer"
+          },
+          "pid_type": {
+            "type": "keyword"
+          },
+          "obj_type": {
+            "type": "keyword"
+          },
+          "status": {
+            "type": "keyword"
+          }
+        }
+      },
+      "title_sort": {
+        "type": "keyword"
+      },
+      "title": {
+        "type": "object",
+        "dynamic": "true",
+        "properties": {
+          "en": {
+            "type": "search_as_you_type",
+            "copy_to": "title_sort"
+          }
+        }
+      },
+      "description": {
+        "type": "object",
+        "dynamic": "true"
+      },
+      "icon": {
+        "type": "keyword",
+        "index": "false"
+      },
+      "tags": {
+        "type": "keyword"
+      },
+      "props": {
+        "type": "object",
+        "dynamic": "true"
+      }
+    }
+  }
+}

invenio_vocabularies/records/models.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020-2024 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Vocabulary models."""
+
+from invenio_db import db
+from invenio_i18n import gettext as _
+from invenio_records.models import RecordMetadataBase
+
+
+class VocabularyType(db.Model):
+    """Vocabulary type model."""
+
+    __tablename__ = "vocabularies_types"
+
+    id = db.Column(db.String(255), primary_key=True)
+    pid_type = db.Column(db.String(255), unique=True)
+
+    @classmethod
+    def create(cls, **data):
+        """Create a new vocabulary type."""
+        with db.session.begin_nested():
+            obj = cls(**data)
+            db.session.add(obj)
+        return obj
+
+    @classmethod
+    def dump_obj(cls, field, record, obj):
+        """Serializer the object into a record."""
+        record[field.attr_name] = {
+            "id": obj.id,
+            "pid_type": obj.pid_type,
+        }
+
+    @classmethod
+    def load_obj(cls, field, record):
+        """Deserializer the object from a record."""
+        data = record.get(field.attr_name)
+        if data:
+            obj = cls(
+                id=data.get("id"),
+                pid_type=data.get("pid_type"),
+            )
+            return obj
+        return None
+
+
+class VocabularyMetadata(db.Model, RecordMetadataBase):
+    """Model for vocabulary metadata."""
+
+    __tablename__ = "vocabularies_metadata"
+
+
+class VocabularyScheme(db.Model):
+    """Vocabulary scheme model.
+
+    This table stores the metadata for schemes (subtypes) of VocabularyType
+    or separate specific vocabularies.
+
+    It is only used to store metadata for subject schemes for now.
+    But we might store affiliations's schemes or other schemes later.
+    """
+
+    __tablename__ = "vocabularies_schemes"
+
+    id = db.Column(db.String(255), primary_key=True)
+    # This is e.g. `subjects`, 'affiliations', ...
+    parent_id = db.Column(db.String(255), primary_key=True)
+    name = db.Column(db.String(255))
+    uri = db.Column(db.String(255))
+    # Any extra metadata is added as columns.
+
+    @classmethod
+    def create(cls, **data):
+        """Create a new vocabulary subtype."""
+        banned = [",", ":"]
+        for b in banned:
+            assert b not in data["id"], _(
+                "No '%(banned_char)s' allowed in VocabularyScheme.id", banned_char=b
+            )
+
+        with db.session.begin_nested():
+            obj = cls(**data)
+            db.session.add(obj)
+        return obj

invenio_vocabularies/records/pidprovider.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2021-2024 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Persistent identifier provider for vocabularies."""
+
+from invenio_pidstore.models import PIDStatus
+from invenio_pidstore.providers.base import BaseProvider
+
+
+class VocabularyIdProvider(BaseProvider):
+    """Vocabulary identifier provider.
+
+    This PID provider requires a Vocabulary record to be passed, and relies
+    on the vocabulary record having an 'id' key and a type defined.
+    """
+
+    @classmethod
+    def create(cls, object_type=None, object_uuid=None, record=None, **kwargs):
+        """Create a new vocabulary identifier.
+
+        Relies on the a vocabulary record being
+
+        Note: if the object_type and object_uuid values are passed, then the
+        PID status will be automatically setted to
+        :attr:`invenio_pidstore.models.PIDStatus.REGISTERED`.
+
+        For more information about parameters,
+        see :meth:`invenio_pidstore.providers.base.BaseProvider.create`.
+
+        :param object_type: The object type. (Default: None.)
+        :param object_uuid: The object identifier. (Default: None).
+        :param record: A vocabulary record.
+        :param kwargs: Addtional options
+        :returns: A :class:`VocabularyIdProvider` instance.
+        """
+        assert record is not None, "Missing or invalid 'record'."
+        assert "id" in record and isinstance(
+            record["id"], str
+        ), "Missing 'id' key in record."
+
+        # Retrieve pid type from type.
+        pid_type = record.type.pid_type
+        # Retrieve pid value form record.
+        pid_value = record["id"]
+
+        # You must assign immediately.
+        assert object_uuid
+        assert object_type
+
+        return super().create(
+            pid_type=pid_type,
+            pid_value=pid_value,
+            object_type=object_type,
+            object_uuid=object_uuid,
+            status=PIDStatus.REGISTERED,
+        )
+
+
+class CustomVocabularyPIDProvider(BaseProvider):
+    """Affiliations PID provider."""
+
+    pid_type = None
+    """Type of persistent identifier."""
+
+    @classmethod
+    def create(cls, object_type=None, object_uuid=None, record=None, **kwargs):
+        """Create a new affiliation identifier.
+
+        Relies on the record having already a pid_value.
+
+        For more information about parameters,
+        see :meth:`invenio_pidstore.providers.base.BaseProvider.create`.
+
+        :param object_type: The object type. (Default: None.)
+        :param object_uuid: The object identifier. (Default: None).
+        :param record: An affiliation vocabulary record.
+        :param kwargs: Addtional options
+        :returns: A :class:`AffiliationProvider` instance.
+        """
+        assert record is not None, "Missing or invalid 'record'."
+        assert "id" in record and isinstance(
+            record["id"], str
+        ), "Missing 'id' key in record."
+
+        # Retrieve pid value form record.
+        pid_value = record["id"]
+
+        # You must assign immediately.
+        assert object_uuid
+        assert object_type
+
+        return super().create(
+            pid_type=cls.pid_type,
+            pid_value=pid_value,
+            object_type=object_type,
+            object_uuid=object_uuid,
+            status=PIDStatus.REGISTERED,
+        )
+
+
+class PIDProviderFactory:
+    """Vocabulary PID provider factory."""
+
+    @staticmethod
+    def create(pid_type, base_cls=CustomVocabularyPIDProvider):
+        """Returns a CustomVocabularyPIDProvider with the given PID type."""
+        provider_class_attributes = {
+            "pid_type": pid_type,
+        }
+
+        return type(
+            "CustomVocabularyPIDProvider", (base_cls,), provider_class_attributes
+        )

invenio_vocabularies/records/systemfields/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020-2021 CERN.
+#
+# Invenio-Vocabularies is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""System fields module."""
+
+from .pid import BaseVocabularyPIDFieldContext, VocabularyPIDFieldContext
+
+__all__ = (
+    "BaseVocabularyPIDFieldContext",
+    "VocabularyPIDFieldContext",
+)

invenio_vocabularies/records/systemfields/pid.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2020-2021 CERN.
+# Copyright (C) 2020 Northwestern University.
+#
+# Invenio-Records-Resources is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""System field context for the Vocabulary PID field.
+
+The context overrides the PID resolver to be aware of the vocabulary type, and
+hence the PID type.
+
+The context is used when you initialise a PIField, for instance:
+
+.. code-block:: python
+
+    class Vocabulary(Record):
+        pid = PIDField(
+            'id',
+            provider=VocabularyIdProvider,
+            context_cls=VocabularyPIDFieldContext
+        )
+
+You can then resolve vocabulary records using the type:
+
+.. code-block:: python
+
+    Vocabulary.pid.resolve(('<type>', '<pid_value>'))
+
+
+Also, it's possible to make initialise the field with a type context:
+
+.. code-block:: python
+
+    Vocabulary.pid.with_type_ctx('<type>').resolve('<pid_value>')
+
+"""
+
+from copy import copy
+
+from invenio_db import db
+from invenio_pidstore.errors import PIDDoesNotExistError
+from invenio_records_resources.records.systemfields.pid import PIDFieldContext
+
+from invenio_vocabularies.records.models import VocabularyType
+
+
+class BaseVocabularyPIDFieldContext(PIDFieldContext):
+    """PIDField context for vocabularies.
+
+    This class implements the class-level methods available on a PIDField
+    for vocabulary records.
+    """
+
+    def create(self, record):
+        """Proxy to the field's create method."""
+        return self.field.create(record)
+
+    def delete(self, record):
+        """Proxy to the field's delete method."""
+        return self.field.delete(record)
+
+
+class VocabularyPIDFieldContext(BaseVocabularyPIDFieldContext):
+    """PIDField context for vocabularies.
+
+    This class implements the class-level methods available on a PIDField
+    for vocabulary records.
+    """
+
+    def resolve(self, pid_value):
+        """Resolve identifier.
+
+        :params pid_value: Either a tuple ``(type_id, pid_value)`` or just a
+            ``pid_value`` if the type context has been initialized using
+            ``with_type_ctx()``.
+        """
+        pid_type = self.pid_type
+        if pid_type is None:
+            type_id, pid_value = pid_value
+            pid_type = self.get_pid_type(type_id)
+
+        # Create resolver
+        resolver = self.field._resolver_cls(
+            pid_type=pid_type,
+            object_type=self.field._object_type,
+            getter=self.record_cls.get_record,
+        )
+
+        # Resolve
+        pid, record = resolver.resolve(pid_value)
+
+        # Store pid in cache on record.
+        self.field._set_cache(record, pid)
+
+        return record
+
+    def get_pid_type(self, type_id):
+        """Get the PID type for a vocabulary type."""
+        # Get type based on name.
+        vocab_type = VocabularyType.query.filter_by(id=type_id).one_or_none()
+        if vocab_type is None:
+            raise PIDDoesNotExistError(None, None)
+        return vocab_type.pid_type
+
+    @property
+    def pid_type(self):
+        """Get the current defined type."""
+        # This ensures that when we use Vocabulary.pid.with_type_ctx('...')
+        # we cache the pid type to avoid querying the database every time.
+        type_id = getattr(self, "_type_id", None)
+        if type_id:
+            pid_type = getattr(self, "_pid_type", None)
+            if pid_type is None:
+                pid_type = self.get_pid_type(type_id)
+                self._pid_type = pid_type
+            return pid_type
+
+    def with_type_ctx(self, type_id):
+        """Returns a new context initialized with the type context."""
+        ctx = copy(self)
+        ctx._type_id = type_id
+        return ctx