dsp-tools 9.1.0.post11__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/xmlupload/make_rdf_graph/make_values.py

@@ -0,0 +1,262 @@
+from typing import Union
+
+from rdflib import RDF
+from rdflib import XSD
+from rdflib import BNode
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.xmlupload.iri_resolver import IriResolver
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import LINK_PROP_TYPE_INFO
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import LIST_PROP_TYPE_INFO
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import RDF_LITERAL_PROP_TYPE_MAPPER
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import RICHTEXT_PROP_TYPE_INFO
+from dsp_tools.commands.xmlupload.models.lookup_models import IRILookups
+from dsp_tools.commands.xmlupload.models.permission import Permissions
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedBoolean
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedColor
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedDate
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedDecimal
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedGeometry
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedGeoname
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedInt
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedInterval
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedLink
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedList
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedRichtext
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedSimpleText
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedTime
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedUri
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedValue
+from dsp_tools.commands.xmlupload.models.rdf_models import RDFPropTypeInfo
+from dsp_tools.commands.xmlupload.richtext_id2iri import prepare_richtext_string_for_upload
+from dsp_tools.config.logger_config import WARNINGS_SAVEPATH
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.utils.data_formats.date_util import DayMonthYearEra
+from dsp_tools.utils.data_formats.date_util import SingleDate
+from dsp_tools.utils.data_formats.date_util import StartEnd
+from dsp_tools.utils.data_formats.iri_util import is_resource_iri
+from dsp_tools.utils.rdf_constants import KNORA_API
+
+type LiteralValueTypesAlias = Union[
+    ProcessedBoolean,
+    ProcessedColor,
+    ProcessedDecimal,
+    ProcessedGeoname,
+    ProcessedGeometry,
+    ProcessedInt,
+    ProcessedSimpleText,
+    ProcessedTime,
+    ProcessedUri,
+]
+
+
+def make_values(values: list[ProcessedValue], res_node: BNode | URIRef, lookups: IRILookups) -> Graph:
+    """
+    Serialise the values of a resource.
+
+    Args:
+        values: list of ProcessedValues of the resource
+        res_node: node of the resource
+        lookups: lookups to resolve IRIs
+
+    Returns:
+        Graph with the values
+    """
+    properties_graph = Graph()
+    for val in values:
+        single_prop_graph = _make_one_value_graph(val=val, res_node=res_node, iri_lookups=lookups)
+        properties_graph += single_prop_graph
+    return properties_graph
+
+
+def _make_one_value_graph(val: ProcessedValue, res_node: BNode | URIRef, iri_lookups: IRILookups) -> Graph:
+    match val:
+        case (
+            ProcessedBoolean()
+            | ProcessedColor()
+            | ProcessedDecimal()
+            | ProcessedGeometry()
+            | ProcessedGeoname()
+            | ProcessedInt()
+            | ProcessedTime()
+            | ProcessedUri()
+            | ProcessedSimpleText()
+        ):
+            literal_info = RDF_LITERAL_PROP_TYPE_MAPPER[type(val)]
+            properties_graph = _make_value_graph_with_literal_object(
+                val=val,
+                res_node=res_node,
+                prop_type_info=literal_info,
+            )
+        case ProcessedList():
+            properties_graph = _make_list_value_graph(val=val, res_node=res_node, prop_type_info=LIST_PROP_TYPE_INFO)
+        case ProcessedLink():
+            target_iri = _resolve_id_to_iri(val.value, iri_lookups.id_to_iri)
+            properties_graph = make_link_value_graph(
+                val=val,
+                val_node=BNode(),
+                res_node=res_node,
+                target_iri=URIRef(target_iri),
+            )
+        case ProcessedRichtext():
+            properties_graph = make_richtext_value_graph(
+                val=val,
+                val_node=BNode(),
+                res_node=res_node,
+                iri_resolver=iri_lookups.id_to_iri,
+            )
+        case ProcessedDate():
+            properties_graph = _make_date_value_graph(
+                val=val,
+                res_node=res_node,
+            )
+        case ProcessedInterval():
+            properties_graph = _make_interval_value_graph(
+                val=val,
+                res_node=res_node,
+            )
+        case _:
+            raise InputError(f"Unknown value type: {type(val).__name__}")
+    return properties_graph
+
+
+def _make_base_value_graph(
+    val: ProcessedValue,
+    val_node: BNode | URIRef,
+    prop_type_info: RDFPropTypeInfo,
+    res_node: BNode | URIRef,
+) -> Graph:
+    g = _add_optional_triples(val_node, val.permissions, val.comment)
+    g.add((res_node, URIRef(val.prop_iri), val_node))
+    g.add((val_node, RDF.type, prop_type_info.knora_type))
+    return g
+
+
+def _add_optional_triples(val_bn: BNode | URIRef, permissions: Permissions | None, comment: str | None) -> Graph:
+    g = Graph()
+    if permissions:
+        g.add((val_bn, KNORA_API.hasPermissions, Literal(str(permissions), datatype=XSD.string)))
+    if comment:
+        g.add((val_bn, KNORA_API.valueHasComment, Literal(comment, datatype=XSD.string)))
+    return g
+
+
+def _make_value_graph_with_literal_object(
+    val: LiteralValueTypesAlias,
+    prop_type_info: RDFPropTypeInfo,
+    res_node: BNode | URIRef,
+) -> Graph:
+    val_bn = BNode()
+    g = _make_base_value_graph(val=val, val_node=val_bn, prop_type_info=prop_type_info, res_node=res_node)
+    g.add((val_bn, prop_type_info.knora_prop, Literal(val.value, datatype=prop_type_info.xsd_type)))
+    return g
+
+
+def _make_list_value_graph(
+    val: ProcessedList,
+    res_node: BNode | URIRef,
+    prop_type_info: RDFPropTypeInfo,
+) -> Graph:
+    val_bn = BNode()
+    g = _make_base_value_graph(val=val, val_node=val_bn, prop_type_info=prop_type_info, res_node=res_node)
+    g.add((val_bn, prop_type_info.knora_prop, URIRef(val.value)))
+    return g
+
+
+def make_link_value_graph(
+    val: ProcessedLink,
+    val_node: BNode | URIRef,
+    res_node: BNode | URIRef,
+    target_iri: URIRef,
+) -> Graph:
+    """Make a LinkValue Graph"""
+    g = _make_base_value_graph(val=val, val_node=val_node, prop_type_info=LINK_PROP_TYPE_INFO, res_node=res_node)
+    g.add((val_node, LINK_PROP_TYPE_INFO.knora_prop, target_iri))
+    return g
+
+
+def _resolve_id_to_iri(value: str, iri_resolver: IriResolver) -> URIRef:
+    if is_resource_iri(value):
+        return URIRef(value)
+    elif resolved_iri := iri_resolver.get(value):
+        return URIRef(resolved_iri)
+    msg = (
+        f"Could not find the ID {value} in the id2iri mapping. "
+        f"This is probably because the resource '{value}' could not be created. "
+        f"See {WARNINGS_SAVEPATH} for more information."
+    )
+    raise BaseError(msg)
+
+
+def _make_date_value_graph(
+    val: ProcessedDate,
+    res_node: BNode | URIRef,
+) -> Graph:
+    val_bn = BNode()
+    date = val.value
+    g = _add_optional_triples(val_bn, val.permissions, val.comment)
+    g.add((res_node, URIRef(val.prop_iri), val_bn))
+    g.add((val_bn, RDF.type, KNORA_API.DateValue))
+    if cal := date.calendar:
+        g.add((val_bn, KNORA_API.dateValueHasCalendar, Literal(cal.value, datatype=XSD.string)))
+    g += _make_single_date_graph(val_bn, date.start, StartEnd.START)
+    if date.end:
+        g += _make_single_date_graph(val_bn, date.end, StartEnd.END)
+    return g
+
+
+def _make_single_date_graph(val_bn: BNode, date: SingleDate, start_end: StartEnd) -> Graph:
+    def get_prop(precision: DayMonthYearEra) -> URIRef:
+        return KNORA_API[f"dateValueHas{start_end.value}{precision.value}"]
+
+    g = Graph()
+    if yr := date.year:
+        g.add((val_bn, get_prop(DayMonthYearEra.YEAR), Literal(yr, datatype=XSD.integer)))
+    if mnt := date.month:
+        g.add((val_bn, get_prop(DayMonthYearEra.MONTH), Literal(mnt, datatype=XSD.integer)))
+    if day := date.day:
+        g.add((val_bn, get_prop(DayMonthYearEra.DAY), Literal(day, datatype=XSD.integer)))
+    if era := date.era:
+        g.add((val_bn, get_prop(DayMonthYearEra.ERA), Literal(era.value, datatype=XSD.string)))
+    return g
+
+
+def _make_interval_value_graph(
+    val: ProcessedInterval,
+    res_node: BNode | URIRef,
+) -> Graph:
+    val_bn = BNode()
+    g = _add_optional_triples(val_bn, val.permissions, val.comment)
+    g.add((res_node, URIRef(val.prop_iri), val_bn))
+    g.add((val_bn, RDF.type, KNORA_API.IntervalValue))
+    g.add((val_bn, KNORA_API.intervalValueHasStart, Literal(val.value.start, datatype=XSD.decimal)))
+    g.add((val_bn, KNORA_API.intervalValueHasEnd, Literal(val.value.end, datatype=XSD.decimal)))
+    return g
+
+
+def make_richtext_value_graph(
+    val: ProcessedRichtext,
+    val_node: BNode | URIRef,
+    res_node: BNode | URIRef,
+    iri_resolver: IriResolver,
+) -> Graph:
+    """
+    Creates an rdflib graph for a richtext value.
+
+    Args:
+        val: Richtext value
+        val_node: IRI or blank node of the value
+        res_node: IRI or blank node of the resource
+        iri_resolver: id to IRI resolver
+
+    Returns:
+        Graph
+    """
+    g = _make_base_value_graph(val=val, val_node=val_node, prop_type_info=RICHTEXT_PROP_TYPE_INFO, res_node=res_node)
+    val_str = prepare_richtext_string_for_upload(val.value.xmlstr, iri_resolver)
+    g.add((val_node, RICHTEXT_PROP_TYPE_INFO.knora_prop, Literal(val_str, datatype=XSD.string)))
+    g.add((val_node, KNORA_API.textValueHasMapping, URIRef("http://rdfh.ch/standoff/mappings/StandardMapping")))
+    return g

dsp_tools/commands/xmlupload/models/bitstream_info.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dsp_tools.commands.xmlupload.models.permission import Permissions
+
+
+@dataclass(frozen=True)
+class BitstreamInfo:
+    """
+    Represents a bitstream object,
+    consisting of its file name on the local file system,
+    the internal file name assigned by the ingest service
+    and optionally its permissions.
+    """
+
+    internal_file_name: str
+    permissions: Permissions | None = None

dsp_tools/commands/xmlupload/models/formatted_text_value.py

@@ -2,34 +2,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-import regex
-
-from dsp_tools.commands.xmlupload.iri_resolver import IriResolver
-from dsp_tools.models.exceptions import BaseError
-
 
 @dataclass
 class FormattedTextValue:
     """Represents a formatted text value with standard standoff markup"""
 
     xmlstr: str
-
-    def as_xml(self) -> str:
-        """Returns the formatted text value as XML (with XML declaration and wrapped in a <text> element)"""
-        return f'<?xml version="1.0" encoding="UTF-8"?>\n<text>{self.xmlstr}</text>'
-
-    def find_internal_ids(self) -> set[str]:
-        """Returns a set of all internal ids found in the text value"""
-        return set(regex.findall(pattern='href="IRI:(.*?):IRI"', string=self.xmlstr))
-
-    def with_iris(self, iri_resolver: IriResolver) -> FormattedTextValue:
-        """
-        Returns a copy of this object, where all internal ids are replaced with iris according to the provided mapping.
-        """
-        s = self.xmlstr
-        for internal_id in self.find_internal_ids():
-            if iri := iri_resolver.get(internal_id):
-                s = s.replace(f'href="IRI:{internal_id}:IRI"', f'href="{iri}"')
-            else:
-                raise BaseError(f"Internal ID {internal_id} could not be resolved to an IRI")
-        return FormattedTextValue(s)

dsp_tools/commands/xmlupload/models/ingest.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import urllib
 from dataclasses import dataclass
 from dataclasses import field
+from http import HTTPStatus
 from pathlib import Path
 from typing import Protocol
 
@@ -10,16 +13,15 @@ from requests import Session
 from requests.adapters import HTTPAdapter
 from requests.adapters import Retry
 
-from dsp_tools.commands.xmlupload.models.deserialise.deserialise_value import XMLBitstream
-from dsp_tools.commands.xmlupload.models.deserialise.xmlresource import BitstreamInfo
-from dsp_tools.commands.xmlupload.models.permission import Permissions
-from dsp_tools.models.exceptions import BadCredentialsError
-from dsp_tools.models.exceptions import PermanentConnectionError
-from dsp_tools.utils.logger_config import WARNINGS_SAVEPATH
-
-STATUS_OK = 200
-STATUS_UNAUTHORIZED = 401
-STATUS_INTERNAL_SERVER_ERROR = 500
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.commands.xmlupload.models.bitstream_info import BitstreamInfo
+from dsp_tools.commands.xmlupload.models.processed.file_values import ProcessedFileValue
+from dsp_tools.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import InvalidIngestFileNameError
+from dsp_tools.error.exceptions import PermanentConnectionError
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
 
 
 @dataclass(frozen=True)
@@ -32,20 +34,11 @@ class IngestResponse:
 class AssetClient(Protocol):
     """Protocol for asset handling clients."""
 
-    def get_bitstream_info(
-        self,
-        bitstream: XMLBitstream,
-        permissions_lookup: dict[str, Permissions],
-        res_label: str,
-        res_id: str,
-    ) -> tuple[bool, None | BitstreamInfo]:
-        """Uploads the file to the ingest server if applicable, and returns the BitstreamInfo.
+    def get_bitstream_info(self, file_info: ProcessedFileValue) -> BitstreamInfo | None:
+        """Uploads the file to the ingest server if applicable, and returns the upload results.
 
         Args:
-            bitstream: The bitstream to upload.
-            permissions_lookup: The permissions lookup.
-            res_label: The resource label (for error message in failure case).
-            res_id: The resource ID (for error message in failure case).
+            file_info: Information required for ingesting an asset
         """
 
 
@@ -54,7 +47,7 @@ class DspIngestClientLive(AssetClient):
     """Client for uploading assets to the DSP-Ingest."""
 
     dsp_ingest_url: str
-    token: str
+    authentication_client: AuthenticationClient
     shortcode: str
     imgdir: str
     session: Session = field(init=False)
@@ -68,7 +61,7 @@ class DspIngestClientLive(AssetClient):
             connect=retries,
             backoff_factor=0.3,
             allowed_methods=None,  # means all methods
-            status_forcelist=[STATUS_INTERNAL_SERVER_ERROR],
+            status_forcelist=[HTTPStatus.INTERNAL_SERVER_ERROR.value],
         )
         adapter = HTTPAdapter(max_retries=retry)
         self.session.mount("http://", adapter)
@@ -83,6 +76,10 @@ class DspIngestClientLive(AssetClient):
         After all retry attempts are exhausted it will raise exceptions if the upload failed.
         The http status code is also checked and if it is not 200, a PermanentConnectionError is raised.
 
+        The load balancer on DSP servers currently has a timeout of 10m,
+        so we need to use a slightly shorter timeout of 9m.
+        See https://linear.app/dasch/issue/INFRA-847/increase-traefik-readtimeout
+
         Args:
             filepath: Path to the file to ingest, could be either absolute or relative.
 
@@ -95,63 +92,52 @@ class DspIngestClientLive(AssetClient):
         """
         filename = urllib.parse.quote(filepath.name)
         url = f"{self.dsp_ingest_url}/projects/{self.shortcode}/assets/ingest/{filename}"
-        headers = {"Authorization": f"Bearer {self.token}", "Content-Type": "application/octet-stream"}
-        timeout = 600
-        err = f"Failed to ingest {filepath} to '{url}'."
+        headers = {
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+            "Content-Type": "application/octet-stream",
+        }
+        timeout = 9 * 60
+        params = RequestParameters(method="POST", url=url, timeout=timeout, headers=headers)
         with open(filepath, "rb") as binary_io:
             try:
-                logger.debug(f"REQUEST: POST to {url}, timeout: {timeout}, headers: {headers | {"Authorization": "*"}}")
+                log_request(params)
                 res = self.session.post(
-                    url=url,
-                    headers=headers,
+                    url=params.url,
+                    headers=params.headers,
                     data=binary_io,
-                    timeout=timeout,
+                    timeout=params.timeout,
                 )
-                logger.debug(f"RESPONSE: {res.status_code}: {res.text}")
-                if res.status_code == STATUS_OK:
-                    return IngestResponse(internal_filename=res.json()["internalFilename"])
-                elif res.status_code == STATUS_UNAUTHORIZED:
-                    raise BadCredentialsError("Bad credentials")
-                else:
-                    user_msg = f"{err} See {WARNINGS_SAVEPATH} for more information."
-                    print(user_msg)
-                    log_msg = f"{err}. Response status code {res.status_code} '{res.text}'"
-                    logger.error(log_msg)
-                    raise PermanentConnectionError(log_msg)
+                log_response(res)
             except requests.exceptions.RequestException as e:
-                raise PermanentConnectionError(f"{err}. {e}") from e
-
-    def get_bitstream_info(
-        self,
-        bitstream: XMLBitstream,
-        permissions_lookup: dict[str, Permissions],
-        res_label: str,
-        res_id: str,
-    ) -> tuple[bool, None | BitstreamInfo]:
-        """Uploads a file to the ingest server and returns the BitstreamInfo."""
+                raise PermanentConnectionError() from e
+
+            if res.ok:
+                return IngestResponse(internal_filename=res.json()["internalFilename"])
+            elif res.status_code == HTTPStatus.FORBIDDEN:
+                raise BadCredentialsError("Only SystemAdmins and ProjectAdmins can upload assets.")
+            elif res.status_code == HTTPStatus.BAD_REQUEST and res.text == "Invalid value for: path parameter filename":
+                raise InvalidIngestFileNameError()
+            else:
+                raise PermanentConnectionError()
+
+    def get_bitstream_info(self, file_info: ProcessedFileValue) -> BitstreamInfo | None:
+        """Uploads a file to the ingest server and returns the upload results."""
         try:
-            res = self._ingest(Path(self.imgdir) / Path(bitstream.value))
-            msg = f"Uploaded file '{bitstream.value}'"
-            logger.info(msg)
-            permissions = permissions_lookup.get(bitstream.permissions) if bitstream.permissions else None
-            return True, BitstreamInfo(bitstream.value, res.internal_filename, permissions)
+            res = self._ingest(Path(self.imgdir) / Path(file_info.value))
+            logger.info(f"Uploaded file '{file_info.value}'")
+            return BitstreamInfo(res.internal_filename, file_info.metadata.permissions)
+        except InvalidIngestFileNameError:
+            msg = f"Invalid filename: Unable to upload file '{file_info.value}' of resource '{file_info.res_id}'"
         except PermanentConnectionError:
-            msg = f"Unable to upload file '{bitstream.value}' of resource '{res_label}' ({res_id})"
-            logger.opt(exception=True).warning(msg)
-            return False, None
+            msg = f"Unable to upload file '{file_info.value}' of resource '{file_info.res_id}'"
+        logger.error(msg)
+        return None
 
 
 @dataclass(frozen=True)
 class BulkIngestedAssetClient(AssetClient):
     """Client for handling media info, if the assets were bulk ingested previously."""
 
-    def get_bitstream_info(
-        self,
-        bitstream: XMLBitstream,
-        permissions_lookup: dict[str, Permissions],
-        res_label: str,  # noqa: ARG002
-        res_id: str,  # noqa: ARG002
-    ) -> tuple[bool, BitstreamInfo | None]:
-        """Returns the BitstreamInfo of the already ingested file based on the `XMLBitstream.value`."""
-        permissions = permissions_lookup.get(bitstream.permissions) if bitstream.permissions else None
-        return True, BitstreamInfo(bitstream.value, bitstream.value, permissions)
+    def get_bitstream_info(self, file_info: ProcessedFileValue) -> BitstreamInfo:
+        """Returns the BitstreamInfo of the already ingested file based on the `ProcessedFileValue.value`."""
+        return BitstreamInfo(file_info.value, file_info.metadata.permissions)

dsp_tools/commands/xmlupload/models/input_problems.py

@@ -29,7 +29,6 @@ class IIIFUriProblem:
     regex_has_passed: bool
     status_code: int | None = None
     raised_exception_name: str | None = None
-    original_text: str | None = None
 
     def get_msg(self) -> str:
         """Get a message describing the problem with the IIIF URI."""
@@ -43,24 +42,17 @@ class IIIFUriProblem:
         elif self.status_code is not None:
             msg.extend(self._bad_status_code_msg())
         else:
-            msg.extend(self._exception_msg())
+            msg.append(self._exception_msg())
         return list_separator.join(msg)
 
-    def _exception_msg(self) -> list[str]:
-        return [
-            f"An error occurred during the network call: {self.raised_exception_name}",
-            f"Error message: {self.original_text}",
-        ]
+    def _exception_msg(self) -> str:
+        return f"An error occurred during the network call: {self.raised_exception_name}"
 
     def _bad_status_code_msg(self) -> list[str]:
-        return [
-            "The server did not respond as expected.",
-            f"Status code: {self.status_code}",
-            f"Response text: {self.original_text}",
-        ]
+        return ["The server did not respond as expected.", f"Status code: {self.status_code}"]
 
     def _good_status_code_bad_regex_msg(self) -> list[str]:
         return [
-            "The URI is correct and the server responded as expected.",
-            "Please contact the dsp-tools development team with this information.",
+            "Although the IIIF-server responded as expected, this URI did not pass validation.",
+            "Please contact the dsp-tools development team (at support@dasch.swiss) with this information.",
         ]

dsp_tools/commands/xmlupload/models/lookup_models.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rdflib import URIRef
+
+from dsp_tools.commands.xmlupload.iri_resolver import IriResolver
+from dsp_tools.commands.xmlupload.models.permission import Permissions
+
+
+@dataclass
+class XmlReferenceLookups:
+    permissions: dict[str, Permissions]
+    listnodes: dict[tuple[str, str], str]
+    authorships: dict[str, list[str]]
+
+
+@dataclass
+class IRILookups:
+    project_iri: URIRef
+    id_to_iri: IriResolver

dsp_tools/commands/xmlupload/models/permission.py

@@ -3,9 +3,6 @@ from __future__ import annotations
 from enum import Enum
 from enum import unique
 from typing import Optional
-from typing import Union
-
-import regex
 
 
 @unique
@@ -33,21 +30,6 @@ class Permissions:
     def __init__(self, permissions: Optional[dict[PermissionValue, list[str]]] = None):
         self._permissions = permissions or {}
 
-    def __getitem__(self, key: PermissionValue) -> Union[list[str], None]:
-        return self._permissions.get(key)
-
-    def __setitem__(self, key: PermissionValue, value: list[str]) -> None:
-        self._permissions[key] = value
-
-    def __delitem__(self, key: PermissionValue) -> None:
-        del self._permissions[key]
-
-    def __missing__(self, key: PermissionValue) -> None:
-        return None
-
-    def __contains__(self, key: PermissionValue) -> bool:
-        return key in self._permissions
-
     def __str__(self) -> str:
         tmpstr = ""
         for permission, groups in self._permissions.items():
@@ -61,24 +43,3 @@ class Permissions:
             self._permissions[key] = [val]
         else:
             self._permissions[key].append(val)
-
-    def toJsonLdObj(self) -> str:
-        tmpstr = ""
-        for permission, groups in self._permissions.items():
-            if tmpstr:
-                tmpstr += "|"
-            tmpstr += f"{permission!s} " + ",".join(groups)
-        return tmpstr
-
-    @classmethod
-    def fromString(cls, permstr: str) -> Permissions:
-        tmpstr = permstr.split("|")
-        permissions: dict[PermissionValue, list[str]] = {}
-        for s in tmpstr:
-            key, *vals = regex.split("[\\s,]+", s)
-            permissions[PermissionValue[key]] = vals
-        return cls(permissions)
-
-    @property
-    def permissions(self) -> Union[dict[PermissionValue, list[str]], None]:
-        return self._permissions

dsp_tools/commands/xmlupload/models/{deserialise/xmlpermission.py → permissions_parsed.py}

@@ -4,8 +4,8 @@ from lxml import etree
 
 from dsp_tools.commands.xmlupload.models.permission import Permissions
 from dsp_tools.commands.xmlupload.models.permission import PermissionValue
-from dsp_tools.models.exceptions import XmlUploadError
-from dsp_tools.models.projectContext import ProjectContext
+from dsp_tools.error.exceptions import XmlUploadError
+from dsp_tools.legacy_models.projectContext import ProjectContext
 
 
 class XmlPermission:

dsp_tools/commands/xmlupload/models/processed/file_values.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dsp_tools.commands.xmlupload.models.permission import Permissions
+from dsp_tools.utils.xml_parsing.models.parsed_resource import KnoraValueType
+
+
+@dataclass
+class ProcessedFileMetadata:
+    license_iri: str
+    copyright_holder: str
+    authorships: list[str]
+    permissions: Permissions | None = None
+
+
+@dataclass
+class ProcessedFileValue:
+    value: str
+    file_type: KnoraValueType
+    metadata: ProcessedFileMetadata
+    res_id: str
+    res_label: str
+
+
+@dataclass
+class ProcessedIIIFUri:
+    value: str
+    metadata: ProcessedFileMetadata