dsp-tools 0.9.13__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

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class FormattedTextValue:
+    """Represents a formatted text value with standard standoff markup"""
+
+    xmlstr: str

dsp_tools/commands/xmlupload/models/ingest.py

@@ -0,0 +1,143 @@
+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
+
+import requests
+from loguru import logger
+from requests import Session
+from requests.adapters import HTTPAdapter
+from requests.adapters import Retry
+
+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)
+class IngestResponse:
+    """Wrapper around `internal_filename`"""
+
+    internal_filename: str
+
+
+class AssetClient(Protocol):
+    """Protocol for asset handling clients."""
+
+    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:
+            file_info: Information required for ingesting an asset
+        """
+
+
+@dataclass
+class DspIngestClientLive(AssetClient):
+    """Client for uploading assets to the DSP-Ingest."""
+
+    dsp_ingest_url: str
+    authentication_client: AuthenticationClient
+    shortcode: str
+    imgdir: str
+    session: Session = field(init=False)
+
+    def __post_init__(self) -> None:
+        retries = 6
+        self.session = Session()
+        retry = Retry(
+            total=retries,
+            read=retries,
+            connect=retries,
+            backoff_factor=0.3,
+            allowed_methods=None,  # means all methods
+            status_forcelist=[HTTPStatus.INTERNAL_SERVER_ERROR.value],
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+    def _ingest(self, filepath: Path) -> IngestResponse:
+        """Uploads a file to the ingest server and returns the IngestResponse.
+
+        This function sends a POST request to the ingest server with the file to upload.
+        It will retry the request 6 times in case of a connection, timeout or internal server error.
+
+        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.
+
+        Raises:
+            BadCredentialsError: If the credentials are invalid.
+            PermanentConnectionError: If the connection fails.
+
+        Returns:
+            IngestResponse: The internal filename of the uploaded file.
+        """
+        filename = urllib.parse.quote(filepath.name)
+        url = f"{self.dsp_ingest_url}/projects/{self.shortcode}/assets/ingest/{filename}"
+        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:
+                log_request(params)
+                res = self.session.post(
+                    url=params.url,
+                    headers=params.headers,
+                    data=binary_io,
+                    timeout=params.timeout,
+                )
+                log_response(res)
+            except requests.exceptions.RequestException as e:
+                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(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 '{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, 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

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+list_separator = "\n    - "
+medium_separator = "\n----------------------------\n"
+
+HTTP_OK = 200
+
+
+@dataclass(frozen=True)
+class AllIIIFUriProblems:
+    """Information about all problems with IIIF URIs."""
+
+    problems: list[IIIFUriProblem]
+
+    def get_msg(self) -> str:
+        """Get a message describing all problems with the IIIF URIs."""
+        msg = "There were problems with the following IIIF URI(s):"
+        all_msg = [problem.get_msg() for problem in self.problems]
+        return msg + medium_separator + medium_separator.join(all_msg)
+
+
+@dataclass(frozen=True)
+class IIIFUriProblem:
+    """Information about a problem with an IIIF URI."""
+
+    uri: str
+    regex_has_passed: bool
+    status_code: int | None = None
+    raised_exception_name: str | None = None
+
+    def get_msg(self) -> str:
+        """Get a message describing the problem with the IIIF URI."""
+        msg = [f"URI: {self.uri}"]
+        if self.regex_has_passed:
+            msg.append("Passed the internal regex check.")
+        else:
+            msg.append("Did not pass the internal regex check.")
+        if self.status_code == HTTP_OK:
+            msg.extend(self._good_status_code_bad_regex_msg())
+        elif self.status_code is not None:
+            msg.extend(self._bad_status_code_msg())
+        else:
+            msg.append(self._exception_msg())
+        return list_separator.join(msg)
+
+    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}"]
+
+    def _good_status_code_bad_regex_msg(self) -> list[str]:
+        return [
+            "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

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from enum import Enum
+from enum import unique
+from typing import Optional
+
+
+@unique
+class PermissionValue(Enum):
+    RV = 1
+    V = 2
+    M = 4
+    D = 8
+    CR = 16
+
+    def __str__(self) -> str:
+        tmp = {
+            1: "RV",
+            2: "V",
+            4: "M",
+            8: "D",
+            16: "CR",
+        }
+        return tmp[self.value]
+
+
+class Permissions:
+    _permissions: dict[PermissionValue, list[str]]
+
+    def __init__(self, permissions: Optional[dict[PermissionValue, list[str]]] = None):
+        self._permissions = permissions or {}
+
+    def __str__(self) -> str:
+        tmpstr = ""
+        for permission, groups in self._permissions.items():
+            if tmpstr:
+                tmpstr += "|"
+            tmpstr += f"{permission!s} " + ",".join(groups)
+        return tmpstr
+
+    def add(self, key: PermissionValue, val: str) -> None:
+        if self._permissions.get(key) is None:
+            self._permissions[key] = [val]
+        else:
+            self._permissions[key].append(val)

dsp_tools/commands/xmlupload/models/permissions_parsed.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+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.error.exceptions import XmlUploadError
+from dsp_tools.legacy_models.projectContext import ProjectContext
+
+
+class XmlPermission:
+    """Represents the permission set containing several XmlAllow elements in the XML used for data import"""
+
+    permission_id: str
+    _allows: list[XmlAllow]
+
+    def __init__(self, node: etree._Element, project_context: ProjectContext) -> None:
+        """
+        Constructor which parses a XML DOM permissions element representing an named permission set
+
+        Args:
+            node: The DOM node to be processed (representing an a permission set)
+            project_context: Context for DOM node traversal
+        """
+        self._allows = []
+        self.permission_id = node.attrib["id"]
+        self._allows.extend(XmlAllow(allow_node, project_context) for allow_node in node)
+
+    def get_permission_instance(self) -> Permissions:
+        """Returns a list of allow elements of this permission instance"""
+        permissions = Permissions()
+        for allow in self._allows:
+            permissions.add(allow.permission, allow.group)
+        return permissions
+
+    def __str__(self) -> str:
+        allow_str: list[str] = [f"{allow.permission} {allow.group}" for allow in self._allows]
+        return "|".join(allow_str)
+
+
+class XmlAllow:
+    """Represents the allow element of the XML used for data import"""
+
+    _group: str
+    _permission: PermissionValue
+
+    def __init__(self, node: etree._Element, project_context: ProjectContext) -> None:
+        """
+        Constructor which parses the XML DOM allow element
+
+        Args:
+            node: The DOM node to be processed (represents a single right in a permission set)
+            project_context: Context for DOM node traversal
+
+        Raises:
+            XmlUploadError: If an upload fails
+        """
+        tmp = node.attrib["group"].split(":")
+
+        sysgroups = ["UnknownUser", "KnownUser", "ProjectMember", "Creator", "ProjectAdmin", "SystemAdmin"]
+        if len(tmp) > 1:
+            if tmp[0]:
+                if tmp[0] == "knora-admin" and tmp[1] in sysgroups:
+                    self._group = node.attrib["group"]
+                else:
+                    _group = project_context.group_map.get(node.attrib["group"])
+                    if _group is None:
+                        raise XmlUploadError(f'Group "{node.attrib["group"]}" is not known: Cannot find project!')
+                    self._group = _group
+            elif project_context.project_name is None:
+                raise XmlUploadError("Project shortname has not been set in ProjectContext")
+            else:
+                prefixed_custom_groupname = f"{project_context.project_name}:{tmp[1]}"
+                if _group := project_context.group_map.get(prefixed_custom_groupname):
+                    self._group = _group
+        elif tmp[0] in sysgroups:
+            self._group = "knora-admin:" + node.attrib["group"]
+        else:
+            raise XmlUploadError(f'Group "{node.attrib["group"]}" is not known: ')
+
+        if not node.text:
+            raise XmlUploadError("No permission set specified")
+        self._permission = PermissionValue[node.text]
+
+    @property
+    def group(self) -> str:
+        """The group specified in the allow element"""
+        return self._group
+
+    @property
+    def permission(self) -> PermissionValue:
+        """The reference to a set of permissions"""
+        return self._permission

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