dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/xmllib/models/internal/file_values.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from collections.abc import Collection
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+from dsp_tools.error.xmllib_warnings import MessageInfo
+from dsp_tools.error.xmllib_warnings_util import emit_xmllib_input_type_mismatch_warning
+from dsp_tools.error.xmllib_warnings_util import emit_xmllib_input_warning
+from dsp_tools.utils.data_formats.uri_util import is_iiif_uri
+from dsp_tools.xmllib.internal.checkers import check_and_warn_if_a_string_contains_a_potentially_empty_value
+from dsp_tools.xmllib.internal.checkers import check_and_warn_potentially_empty_string
+from dsp_tools.xmllib.internal.checkers import is_nonempty_value_internal
+from dsp_tools.xmllib.internal.input_converters import check_and_fix_collection_input
+from dsp_tools.xmllib.internal.input_converters import check_and_fix_is_non_empty_string
+from dsp_tools.xmllib.models.licenses.recommended import License
+from dsp_tools.xmllib.models.permissions import Permissions
+
+
+@dataclass
+class AuthorshipLookup:
+    lookup: dict[tuple[str, ...], str]
+
+    def get_id(self, authors: tuple[str, ...] | None) -> str | None:
+        if authors is None:
+            return None
+        if not (found := self.lookup.get(authors)):
+            emit_xmllib_input_warning(MessageInfo(f"The input authors {authors} are not defined in the look-up."))
+            return " / ".join([str(x) for x in authors])
+        return found
+
+
+@dataclass
+class Metadata:
+    license: License | None
+    copyright_holder: str | None
+    authorship: tuple[str, ...] | None
+    permissions: Permissions
+
+    @classmethod
+    def new(
+        cls,
+        license: License | None,
+        copyright_holder: str | None,
+        authorship: Collection[str] | None,
+        permissions: Permissions | str,
+        resource_id: str,
+    ) -> Metadata:
+        lic_ = license
+        if license is not None and not isinstance(license, License):
+            emit_xmllib_input_type_mismatch_warning(
+                expected_type="xmllib.License",
+                value=license,
+                res_id=resource_id,
+                value_field="license (bistream/iiif-uri)",
+            )
+            lic_ = None
+        if isinstance(permissions, Permissions):
+            pass
+        elif is_nonempty_value_internal(permissions):
+            permissions = Permissions.PROJECT_SPECIFIC_PERMISSIONS
+        else:
+            emit_xmllib_input_type_mismatch_warning(
+                expected_type="xmllib.Permissions",
+                value=permissions,
+                res_id=resource_id,
+                value_field="permissions (bistream/iiif-uri)",
+            )
+            permissions = Permissions.PROJECT_SPECIFIC_PERMISSIONS
+        if copyright_holder is not None:
+            copyright_holder = check_and_fix_is_non_empty_string(
+                value=copyright_holder,
+                res_id=resource_id,
+                value_field="copyright_holder (bistream/iiif-uri)",
+            )
+        if authorship is not None:
+            if not is_nonempty_value_internal(authorship):
+                emit_xmllib_input_type_mismatch_warning(
+                    expected_type="list of authorship strings",
+                    value=authorship,
+                    res_id=resource_id,
+                    value_field="authorship (bistream/iiif-uri)",
+                )
+                authors = None
+            else:
+                fixed_authors = set(
+                    check_and_fix_collection_input(authorship, "authorship (bistream/iiif-uri)", resource_id)
+                )
+                fixed_authors_list = [
+                    check_and_fix_is_non_empty_string(
+                        value=x,
+                        res_id=resource_id,
+                        value_field="authorship (bistream/iiif-uri)",
+                    )
+                    for x in fixed_authors
+                ]
+                authors = tuple(sorted(fixed_authors_list))
+                if len(authors) == 0:
+                    authors = None
+        else:
+            authors = None
+        return cls(
+            license=lic_,
+            copyright_holder=copyright_holder,
+            authorship=authors,
+            permissions=permissions,
+        )
+
+
+class AbstractFileValue(Protocol):
+    value: str
+    metadata: Metadata
+    comment: str | None
+
+
+@dataclass
+class FileValue(AbstractFileValue):
+    value: str
+    metadata: Metadata
+    comment: str | None
+
+    @classmethod
+    def new(cls, value: str | Path, metadata: Metadata, comment: str | None, resource_id: str) -> FileValue:
+        if isinstance(value, Path):
+            if str(value) == ".":
+                value = ""
+            else:
+                value = str(value)
+        check_and_warn_potentially_empty_string(
+            value=value,
+            res_id=resource_id,
+            expected="file name",
+            field="bitstream",
+        )
+        if is_nonempty_value_internal(comment):
+            fixed_comment = str(comment)
+            check_and_warn_if_a_string_contains_a_potentially_empty_value(
+                value=comment,
+                res_id=resource_id,
+                field="comment on bitstream",
+            )
+        else:
+            fixed_comment = None
+        return cls(value=str(value), metadata=metadata, comment=fixed_comment)
+
+
+@dataclass
+class IIIFUri(AbstractFileValue):
+    value: str
+    metadata: Metadata
+    comment: str | None
+
+    @classmethod
+    def new(cls, value: str, metadata: Metadata, comment: str | None, resource_id: str) -> IIIFUri:
+        v = str(value)
+        if not is_iiif_uri(v):
+            emit_xmllib_input_type_mismatch_warning(
+                expected_type="IIIF uri",
+                value=value,
+                res_id=resource_id,
+            )
+        if is_nonempty_value_internal(comment):
+            fixed_comment = str(comment)
+            check_and_warn_if_a_string_contains_a_potentially_empty_value(
+                value=comment,
+                res_id=resource_id,
+                field="comment on iiif-uri",
+            )
+        else:
+            fixed_comment = None
+        return cls(value=v, metadata=metadata, comment=fixed_comment)

dsp_tools/xmllib/models/internal/geometry.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Protocol
+
+from dsp_tools.error.xmllib_warnings import MessageInfo
+from dsp_tools.error.xmllib_warnings_util import raise_xmllib_input_error
+from dsp_tools.xmllib.value_checkers import is_color
+from dsp_tools.xmllib.value_checkers import is_decimal
+
+
+@dataclass
+class GeometryShape(Protocol):
+    color: str
+
+    def to_json_string(self) -> str: ...
+
+
+@dataclass
+class Rectangle(GeometryShape):
+    point1: GeometryPoint
+    point2: GeometryPoint
+    line_width: float
+    color: str
+    active: bool
+    resource_id: str
+
+    def __post_init__(self) -> None:
+        _check_warn_shape_info(self.color, self.line_width, self.resource_id)
+
+    def to_json_string(self) -> str:
+        json_dict = {
+            "status": "active" if self.active else "deleted",
+            "type": "rectangle",
+            "lineWidth": self.line_width,
+            "points": [self.point1.to_dict(), self.point2.to_dict()],
+        }
+        return json.dumps(json_dict)
+
+
+@dataclass
+class Polygon(GeometryShape):
+    points: list[GeometryPoint]
+    line_width: float
+    color: str
+    active: bool
+    resource_id: str
+
+    def __post_init__(self) -> None:
+        _check_warn_shape_info(self.color, self.line_width, self.resource_id)
+        if len(self.points) < 3:
+            msg = (
+                "The region shape is a polygon. Polygons should have at least 3 points. "
+                "If you would like to display a rectangle we recommend to use the designated rectangle shape."
+            )
+            raise_xmllib_input_error(MessageInfo(msg, self.resource_id))
+
+    def to_json_string(self) -> str:
+        json_dict = {
+            "status": "active" if self.active else "deleted",
+            "type": "polygon",
+            "lineWidth": self.line_width,
+            "points": [x.to_dict() for x in self.points],
+        }
+        return json.dumps(json_dict)
+
+
+@dataclass
+class Circle(GeometryShape):
+    center: GeometryPoint
+    radius: Vector
+    line_width: float
+    color: str
+    active: bool
+    resource_id: str
+
+    def __post_init__(self) -> None:
+        _check_warn_shape_info(self.color, self.line_width, self.resource_id)
+
+    def to_json_string(self) -> str:
+        json_dict = {
+            "status": "active" if self.active else "deleted",
+            "type": "circle",
+            "lineWidth": self.line_width,
+            "points": [self.center.to_dict()],
+            "radius": self.radius.to_dict(),
+        }
+        return json.dumps(json_dict)
+
+
+@dataclass
+class GeometryPoint:
+    x: float
+    y: float
+    resource_id: str
+
+    def __post_init__(self) -> None:
+        if not all([is_decimal(self.x), is_decimal(self.y)]):
+            msg = f"The entered geometry points are not floats. x: '{self.x}', y: '{self.y}'"
+            raise_xmllib_input_error(MessageInfo(msg, self.resource_id))
+
+        else:
+            info = []
+            if not 0 <= float(self.x) <= 1:
+                info.append(f"x: '{self.x}'")
+            if not 0 <= float(self.y) <= 1:
+                info.append(f"y: '{self.y}'")
+            if info:
+                msg = (
+                    f"The geometry points must be larger/equal 0 and smaller/equal 1. "
+                    f"The following points are not valid: {', '.join(info)}"
+                )
+                raise_xmllib_input_error(MessageInfo(msg, self.resource_id))
+        self.x = float(self.x)
+        self.y = float(self.y)
+
+    def to_dict(self) -> dict[str, float]:
+        return {"x": self.x, "y": self.y}
+
+
+@dataclass
+class Vector:
+    x: float
+    y: float
+    resource_id: str
+
+    def __post_init__(self) -> None:
+        if not all([is_decimal(self.x), is_decimal(self.y)]):
+            msg = f"The radius vector are not floats. x: '{self.x}', y: '{self.y}'"
+            raise_xmllib_input_error(MessageInfo(msg, self.resource_id))
+        else:
+            info = []
+            if not 0 <= float(self.x) <= 1:
+                info.append(f"x: '{self.x}'")
+            if not 0 <= float(self.y) <= 1:
+                info.append(f"y: '{self.y}'")
+            if info:
+                msg = (
+                    f"The radius vector must be larger/equal 0 and smaller/equal 1. "
+                    f"The following values are not valid: {', '.join(info)}"
+                )
+                raise_xmllib_input_error(MessageInfo(msg, self.resource_id))
+        self.x = float(self.x)
+        self.y = float(self.y)
+
+    def to_dict(self) -> dict[str, float]:
+        return {"x": self.x, "y": self.y}
+
+
+def _check_warn_shape_info(color: str, line_width: float, res_id: str) -> None:
+    problems = []
+    line_msg = f"The line width must be a number between 1-5. The provided value is not valid: {line_width}"
+    if not is_decimal(line_width):
+        problems.append(line_msg)
+    elif not 0 < int(line_width) <= 5:
+        problems.append(line_msg)
+    if not is_color(color):
+        problems.append(f"The color must be a valid hexadecimal color. The provided value is not valid: {color}")
+    if problems:
+        msg = f"Some of the shape values are not valid: \n- {'\n- '.join(problems)}"
+        raise_xmllib_input_error(MessageInfo(msg, res_id))

dsp_tools/xmllib/models/internal/migration_metadata.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+
+from typing_extensions import deprecated
+
+from dsp_tools.error.xmllib_warnings import MessageInfo
+from dsp_tools.error.xmllib_warnings_util import emit_xmllib_input_warning
+from dsp_tools.xmllib.value_checkers import is_dsp_ark
+from dsp_tools.xmllib.value_checkers import is_dsp_iri
+from dsp_tools.xmllib.value_checkers import is_timestamp
+
+LIST_SEPARATOR = "\n    - "
+
+
+@dataclass
+class MigrationMetadata:
+    """
+    Metadata originating from a SALSAH migration.
+    This will be deprecated in the future when all projects are migrated.
+    """
+
+    creation_date: str | None
+    iri: str | None
+    ark: str | None
+    res_id: str
+
+    @deprecated("This is for salsah migration only and will be deleted in future releases.")
+    def __post_init__(self) -> None:
+        msg_list = []
+        if self.creation_date and not is_timestamp(self.creation_date):
+            msg_list.append(f"The value for creation date is not a valid timestamp: {self.creation_date}")
+            self.creation_date = str(self.creation_date)
+        if self.iri and not is_dsp_iri(self.iri):
+            msg_list.append(f"The provided IRI is not valid: {self.iri}")
+            self.creation_date = str(self.creation_date)
+        if self.ark and not is_dsp_ark(self.ark):
+            msg_list.append(f"The provided ARK is not valid: {self.ark}")
+            self.ark = str(self.ark)
+        if msg_list:
+            msg = f"The migration metadata has the following problem(s):{LIST_SEPARATOR}{LIST_SEPARATOR.join(msg_list)}"
+            emit_xmllib_input_warning(MessageInfo(msg, self.res_id))
+
+    def as_attrib(self) -> dict[str, str]:
+        attrib_dict = {}
+        if self.creation_date:
+            attrib_dict["creation_date"] = self.creation_date
+        if self.iri:
+            attrib_dict["iri"] = self.iri
+        if self.ark:
+            attrib_dict["ark"] = self.ark
+        if not attrib_dict:
+            msg = (
+                "The migration metadata of the resource does not contain any values. Please check if an error occurred."
+            )
+            emit_xmllib_input_warning(MessageInfo(msg, self.res_id))
+        return attrib_dict

dsp_tools/xmllib/models/internal/serialise_permissions.py

@@ -0,0 +1,66 @@
+from enum import Enum
+
+from lxml import etree
+
+from dsp_tools.xmllib.internal.constants import DASCH_SCHEMA
+from dsp_tools.xmllib.internal.constants import XML_NAMESPACE_MAP
+
+
+class PermissionTypes(Enum):
+    RV = "RV"
+    V = "V"
+    D = "D"
+    CR = "CR"
+
+
+PUBLIC = {
+    "UnknownUser": PermissionTypes.V,
+    "KnownUser": PermissionTypes.V,
+    "ProjectMember": PermissionTypes.D,
+    "ProjectAdmin": PermissionTypes.CR,
+}
+
+PRIVATE = {
+    "ProjectMember": PermissionTypes.D,
+    "ProjectAdmin": PermissionTypes.CR,
+}
+
+LIMITED_VIEW = {
+    "UnknownUser": PermissionTypes.RV,
+    "KnownUser": PermissionTypes.RV,
+    "ProjectMember": PermissionTypes.D,
+    "ProjectAdmin": PermissionTypes.CR,
+}
+
+
+class XMLPermissions:
+    def serialise(self, contains_old_permissions: bool, contains_new_permissions: bool = True) -> list[etree._Element]:
+        new_perms = [
+            self._serialise_one_permission_element("public", PUBLIC),
+            self._serialise_one_permission_element("private", PRIVATE),
+            self._serialise_one_permission_element("limited_view", LIMITED_VIEW),
+        ]
+        old_perms = [
+            self._serialise_one_permission_element("open", PUBLIC),
+            self._serialise_one_permission_element("restricted", PRIVATE),
+            self._serialise_one_permission_element("restricted-view", LIMITED_VIEW),
+        ]
+        res = []
+        if contains_new_permissions:
+            res.extend(new_perms)
+        if contains_old_permissions:
+            res.extend(old_perms)
+        return res
+
+    def _serialise_one_permission_element(
+        self, permission_name: str, groups: dict[str, PermissionTypes]
+    ) -> etree._Element:
+        ele = etree.Element(f"{DASCH_SCHEMA}permissions", attrib={"id": permission_name}, nsmap=XML_NAMESPACE_MAP)
+        allows = [self._serialise_one_allow(g, name) for g, name in groups.items()]
+        ele.extend(allows)
+        return ele
+
+    def _serialise_one_allow(self, group: str, tag_text: PermissionTypes) -> etree._Element:
+        ele = etree.Element(f"{DASCH_SCHEMA}allow", attrib={"group": group}, nsmap=XML_NAMESPACE_MAP)
+        ele.text = tag_text.value
+        return ele