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

dsp_tools/commands/xmlupload/richtext_id2iri.py

@@ -0,0 +1,37 @@
+import regex
+
+from dsp_tools.commands.xmlupload.iri_resolver import IriResolver
+from dsp_tools.error.exceptions import Id2IriReplacementError
+
+
+def prepare_richtext_string_for_upload(richtext_str: str, iri_resolver: IriResolver) -> str:
+    richtext_str, ids_not_found = replace_ids_if_found(richtext_str, iri_resolver)
+    if ids_not_found:
+        raise Id2IriReplacementError(
+            f"Some internal IDs of the following richtext could not be resolved to an IRI: {richtext_str}"
+        )
+    return _richtext_as_xml(richtext_str)
+
+
+def replace_ids_if_found(richtext_str: str, iri_resolver: IriResolver) -> tuple[str, set[str]]:
+    ids_used = find_internal_ids(richtext_str)
+    not_found = set()
+    if ids_used:
+        for id_ in ids_used:
+            if iri_found := iri_resolver.get(id_):
+                richtext_str = _replace_one_id(richtext_str, id_, iri_found)
+            else:
+                not_found.add(id_)
+    return richtext_str, not_found
+
+
+def _replace_one_id(txt: str, id_: str, iri: str) -> str:
+    return txt.replace(f'href="IRI:{id_}:IRI"', f'href="{iri}"')
+
+
+def find_internal_ids(txt: str) -> set[str]:
+    return set(regex.findall(pattern='href="IRI:(.*?):IRI"', string=txt))
+
+
+def _richtext_as_xml(richtext_str: str) -> str:
+    return f'<?xml version="1.0" encoding="UTF-8"?>\n<text>{richtext_str}</text>'

dsp_tools/commands/xmlupload/stash/{construct_and_analyze_graph.py → analyse_circular_reference_graph.py}

@@ -1,124 +1,34 @@
 from __future__ import annotations
 
 from typing import Any
-from typing import cast
 
-import regex
 import rustworkx as rx
-from lxml import etree
 
 from dsp_tools.commands.xmlupload.stash.graph_models import Cost
 from dsp_tools.commands.xmlupload.stash.graph_models import Edge
-from dsp_tools.commands.xmlupload.stash.graph_models import ResptrLink
-from dsp_tools.commands.xmlupload.stash.graph_models import XMLLink
-from dsp_tools.utils.iri_util import is_resource_iri
+from dsp_tools.commands.xmlupload.stash.graph_models import InfoForGraph
+from dsp_tools.commands.xmlupload.stash.graph_models import LinkValueLink
+from dsp_tools.commands.xmlupload.stash.graph_models import StandOffLink
 
 
-def create_info_from_xml_for_graph(
-    root: etree._Element,
-) -> tuple[list[ResptrLink], list[XMLLink], list[str]]:
+def generate_upload_order(info_for_graph: InfoForGraph) -> tuple[dict[str, list[str]], list[str]]:
     """
-    Create link objects (ResptrLink/XMLLink) from the XML file,
-    and add a reference UUID to each XML element that contains a link (<resptr> or <text>).
-    With this UUID, the link objects can be identified in the XML data file.
+    Generates the upload order from the Info for the graph
 
     Args:
-        root: root of the parsed XML file
+        info_for_graph: Info for the graph
 
     Returns:
-        - All resptr links contained in the XML file, represented as ResptrLink objects.
-        - All XML links contained in the XML file, represented as XMLLink objects.
-        - A list with all resource IDs used in the XML file.
+        - A dictionary which maps the resources that have stashes to the UUIDs of the stashed links.
+        - A list of resource IDs which gives the order in which the resources should be uploaded to DSP-API.
     """
-    resptr_links = []
-    xml_links = []
-    all_resource_ids = []
-    for resource in root.iter(tag="resource"):
-        resptr, xml = _create_info_from_xml_for_graph_from_one_resource(resource)
-        all_resource_ids.append(resource.attrib["id"])
-        resptr_links.extend(resptr)
-        xml_links.extend(xml)
-    return resptr_links, xml_links, all_resource_ids
-
-
-def _create_info_from_xml_for_graph_from_one_resource(
-    resource: etree._Element,
-) -> tuple[list[ResptrLink], list[XMLLink]]:
-    resptr_links: list[ResptrLink] = []
-    xml_links: list[XMLLink] = []
-    for prop in resource.getchildren():
-        match prop.tag:
-            case "resptr-prop":
-                resptr_links.extend(_create_resptr_link_objects(resource.attrib["id"], prop))
-            case "text-prop":
-                xml_links.extend(_create_text_link_objects(resource.attrib["id"], prop))
-            case "hasComment" | "hasDescription":
-                if xml_link := _create_text_link_object_from_special_tags(resource.attrib["id"], prop):
-                    xml_links.append(xml_link)
-            case "isSegmentOf" | "relatesTo":
-                if segment_link := _create_segmentOf_link_objects(resource.attrib["id"], prop):
-                    resptr_links.append(segment_link)
-    return resptr_links, xml_links
-
-
-def _create_segmentOf_link_objects(subject_id: str, resptr: etree._Element) -> ResptrLink | None:
-    resptr.text = cast(str, resptr.text)
-    if is_resource_iri(resptr.text):
-        return None
-    link_object = ResptrLink(subject_id, resptr.text)
-    # this UUID is so that the links that were stashed can be identified in the XML data file
-    resptr.attrib["linkUUID"] = link_object.link_uuid
-    return link_object
-
-
-def _create_resptr_link_objects(subject_id: str, resptr_prop: etree._Element) -> list[ResptrLink]:
-    resptr_links = []
-    for resptr in resptr_prop.getchildren():
-        resptr.text = cast(str, resptr.text)
-        if not is_resource_iri(resptr.text):
-            link_object = ResptrLink(subject_id, resptr.text)
-            # this UUID is so that the links that were stashed can be identified in the XML data file
-            resptr.attrib["linkUUID"] = link_object.link_uuid
-            resptr_links.append(link_object)
-    return resptr_links
-
-
-def _create_text_link_objects(subject_id: str, text_prop: etree._Element) -> list[XMLLink]:
-    # if the same ID is in several separate <text> values of one <text-prop>, they are considered separate links
-    xml_props = []
-    for text in text_prop.getchildren():
-        if links := _extract_ids_from_one_text_value(text):
-            xml_link = XMLLink(subject_id, links)
-            xml_props.append(xml_link)
-            # this UUID is so that the links that were stashed can be identified in the XML data file
-            text.attrib["linkUUID"] = xml_link.link_uuid
-    return xml_props
-
-
-def _create_text_link_object_from_special_tags(subject_id: str, special_tag: etree._Element) -> XMLLink | None:
-    # This is for <hasDescription> and <hasComment> properties of <video-segment>s or <audio-segment>s
-    if not (links := _extract_ids_from_one_text_value(special_tag)):
-        return None
-    xml_link = XMLLink(subject_id, links)
-    # this UUID is so that the links that were stashed can be identified in the XML data file
-    special_tag.attrib["linkUUID"] = xml_link.link_uuid
-    return xml_link
-
-
-def _extract_ids_from_one_text_value(text: etree._Element) -> set[str]:
-    # the same id in one <text> only means one link to the resource
-    all_links = set()
-    for ele in text.iterdescendants():
-        if href := ele.attrib.get("href"):
-            if internal_id := regex.search(r"IRI:(.*):IRI", href):
-                all_links.add(internal_id.group(1))
-    return all_links
-
-
-def make_graph(
-    resptr_links: list[ResptrLink],
-    xml_links: list[XMLLink],
-    all_resource_ids: list[str],
+    graph, node_to_id, edges = _make_graph(info_for_graph)
+    stash_lookup, upload_order, _ = _generate_upload_order_from_graph(graph, node_to_id, edges)
+    return stash_lookup, upload_order
+
+
+def _make_graph(
+    info_for_graph: InfoForGraph,
 ) -> tuple[rx.PyDiGraph[Any, Any], dict[int, str], list[Edge]]:
     """
     This function takes information about the resources of an XML file and links between them.
@@ -126,10 +36,7 @@ def make_graph(
     Resources are represented as nodes and links as edges.
 
     Args:
-        resptr_links: objects representing a direct link between a starting resource and a target resource
-        xml_links: objects representing one or more links from a single text value of a single starting resource
-                   to a set of target resources
-        all_resource_ids: IDs of all resources in the graph
+        info_for_graph: Information required to construct the graph
 
     Returns:
         - The rustworkx graph.
@@ -137,17 +44,57 @@ def make_graph(
         - A list with all the edges in the graph.
     """
     graph: rx.PyDiGraph[Any, Any] = rx.PyDiGraph()
-    nodes = [(id_, None, None) for id_ in all_resource_ids]
+    nodes = [(id_, None, None) for id_ in info_for_graph.all_resource_ids]
     node_indices = list(graph.add_nodes_from(nodes))
-    id_to_node = dict(zip(all_resource_ids, node_indices))
-    node_to_id = dict(zip(node_indices, all_resource_ids))
-    edges = [Edge(id_to_node[x.source_id], id_to_node[x.target_id], x) for x in resptr_links]
-    for xml in xml_links:
+    id_to_node = dict(zip(info_for_graph.all_resource_ids, node_indices))
+    node_to_id = dict(zip(node_indices, info_for_graph.all_resource_ids))
+    edges = [Edge(id_to_node[x.source_id], id_to_node[x.target_id], x) for x in info_for_graph.link_values]
+    for xml in info_for_graph.standoff_links:
         edges.extend([Edge(id_to_node[xml.source_id], id_to_node[x], xml) for x in xml.target_ids])
     graph.add_edges_from([e.as_tuple() for e in edges])
     return graph, node_to_id, edges
 
 
+def _generate_upload_order_from_graph(
+    graph: rx.PyDiGraph[Any, Any],
+    node_to_id: dict[int, str],
+    edges: list[Edge],
+) -> tuple[dict[str, list[str]], list[str], int]:
+    """
+    Generate the order in which the resources should be uploaded to the DSP-API based on the dependencies.
+
+    Args:
+        graph: graph
+        node_to_id: mapping between indices of the graph nodes and original resource IDs from the XML file
+        edges: edges in the graph (contains info about source node, target node, and link info)
+
+    Returns:
+        - A dictionary which maps the resources that have stashes to the UUIDs of the stashed links.
+        - A list of resource IDs which gives the order in which the resources should be uploaded to DSP-API.
+        - The number of links in the stash.
+    """
+    upload_order: list[str] = []
+    stash_lookup: dict[str, list[str]] = {}
+    node_indices = set(node_to_id.keys())
+    leaf_nodes, remaining_node_indices = _remove_leaf_nodes(graph, node_to_id, node_indices)
+    upload_order.extend(leaf_nodes)
+    stash_counter = 0
+    while remaining_node_indices:
+        cycle = list(rx.digraph_find_cycle(graph))
+        links_to_remove = _find_cheapest_outgoing_links(graph, cycle, edges)
+        stash_counter += len(links_to_remove)
+        _remove_edges_to_stash(
+            graph=graph,
+            edges_to_remove=links_to_remove,
+            all_edges=edges,
+            remaining_nodes=remaining_node_indices,
+        )
+        stash_lookup = _add_stash_to_lookup_dict(stash_lookup, [x.link_object for x in links_to_remove])
+        leaf_nodes, remaining_node_indices = _remove_leaf_nodes(graph, node_to_id, remaining_node_indices)
+        upload_order.extend(leaf_nodes)
+    return stash_lookup, upload_order, stash_counter
+
+
 def _remove_leaf_nodes(
     graph: rx.PyDiGraph[Any, Any],
     node_to_id: dict[int, str],
@@ -227,7 +174,7 @@ def _remove_edges_to_stash(
     phantom_edges_to_remove = []
     source, target = edges_to_remove[0].source, edges_to_remove[0].target
     for link_to_stash in [x.link_object for x in edges_to_remove]:
-        if isinstance(link_to_stash, XMLLink):
+        if isinstance(link_to_stash, StandOffLink):
             phantom_edges_to_remove.extend(
                 _find_phantom_xml_edges(source, target, all_edges, link_to_stash, remaining_nodes)
             )
@@ -240,7 +187,7 @@ def _find_phantom_xml_edges(
     source_node_index: int,
     target_node_index: int,
     all_edges: list[Edge],
-    xml_link_to_stash: XMLLink,
+    xml_link_to_stash: StandOffLink,
     remaining_nodes: set[int],
 ) -> list[tuple[int, int]]:
     """
@@ -277,7 +224,7 @@ def _find_phantom_xml_edges(
 
 def _add_stash_to_lookup_dict(
     stash_dict: dict[str, list[str]],
-    links_to_stash: list[XMLLink | ResptrLink],
+    links_to_stash: list[StandOffLink | LinkValueLink],
 ) -> dict[str, list[str]]:
     stash_list = [stash_link.link_uuid for stash_link in links_to_stash]
     # all stashed links have the same subject id, so we can just take the first one
@@ -287,43 +234,3 @@ def _add_stash_to_lookup_dict(
     else:
         stash_dict[subj_id] = stash_list
     return stash_dict
-
-
-def generate_upload_order(
-    graph: rx.PyDiGraph[Any, Any],
-    node_to_id: dict[int, str],
-    edges: list[Edge],
-) -> tuple[dict[str, list[str]], list[str], int]:
-    """
-    Generate the order in which the resources should be uploaded to the DSP-API based on the dependencies.
-
-    Args:
-        graph: graph
-        node_to_id: mapping between indices of the graph nodes and original resource IDs from the XML file
-        edges: edges in the graph (contains info about source node, target node, and link info)
-
-    Returns:
-        - A dictionary which maps the resources that have stashes to the UUIDs of the stashed links.
-        - A list of resource IDs which gives the order in which the resources should be uploaded to DSP-API.
-        - The number of links in the stash.
-    """
-    upload_order: list[str] = []
-    stash_lookup: dict[str, list[str]] = {}
-    node_indices = set(node_to_id.keys())
-    leaf_nodes, remaining_node_indices = _remove_leaf_nodes(graph, node_to_id, node_indices)
-    upload_order.extend(leaf_nodes)
-    stash_counter = 0
-    while remaining_node_indices:
-        cycle = list(rx.digraph_find_cycle(graph))
-        links_to_remove = _find_cheapest_outgoing_links(graph, cycle, edges)
-        stash_counter += len(links_to_remove)
-        _remove_edges_to_stash(
-            graph=graph,
-            edges_to_remove=links_to_remove,
-            all_edges=edges,
-            remaining_nodes=remaining_node_indices,
-        )
-        stash_lookup = _add_stash_to_lookup_dict(stash_lookup, [x.link_object for x in links_to_remove])
-        leaf_nodes, remaining_node_indices = _remove_leaf_nodes(graph, node_to_id, remaining_node_indices)
-        upload_order.extend(leaf_nodes)
-    return stash_lookup, upload_order, stash_counter

dsp_tools/commands/xmlupload/stash/create_info_for_graph.py

@@ -0,0 +1,53 @@
+from dsp_tools.commands.xmlupload.models.processed.res import ProcessedResource
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedLink
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedRichtext
+from dsp_tools.commands.xmlupload.stash.graph_models import InfoForGraph
+from dsp_tools.commands.xmlupload.stash.graph_models import LinkValueLink
+from dsp_tools.commands.xmlupload.stash.graph_models import StandOffLink
+from dsp_tools.utils.data_formats.iri_util import is_resource_iri
+
+
+def create_info_for_graph_from_processed_resources(resources: list[ProcessedResource]) -> InfoForGraph:
+    """Extracts information to create the graph to analyse the circular references."""
+    all_links = []
+    all_stand_off = []
+    all_resource_ids = []
+    for res in resources:
+        links, stand_off = _process_one_resource(res)
+        all_links.extend(links)
+        all_stand_off.extend(stand_off)
+        all_resource_ids.append(res.res_id)
+    return InfoForGraph(
+        all_resource_ids=all_resource_ids,
+        link_values=all_links,
+        standoff_links=all_stand_off,
+    )
+
+
+def _process_one_resource(resource: ProcessedResource) -> tuple[list[LinkValueLink], list[StandOffLink]]:
+    link_values = []
+    stand_off = []
+    for val in resource.values:
+        if isinstance(val, ProcessedLink):
+            if is_resource_iri(val.value):
+                continue
+            link_values.append(
+                LinkValueLink(
+                    source_id=resource.res_id,
+                    target_id=val.value,
+                    link_uuid=val.value_uuid,
+                )
+            )
+        elif isinstance(val, ProcessedRichtext):
+            if val.resource_references:
+                only_ids = {x for x in val.resource_references if not is_resource_iri(x)}
+                if not only_ids:
+                    continue
+                stand_off.append(
+                    StandOffLink(
+                        source_id=resource.res_id,
+                        target_ids=only_ids,
+                        link_uuid=val.value_uuid,
+                    )
+                )
+    return link_values, stand_off

dsp_tools/commands/xmlupload/stash/graph_models.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
-import uuid
 from dataclasses import dataclass
-from dataclasses import field
+
+
+@dataclass
+class InfoForGraph:
+    all_resource_ids: list[str]
+    link_values: list[LinkValueLink]
+    standoff_links: list[StandOffLink]
 
 
 @dataclass(frozen=True)
-class ResptrLink:
+class LinkValueLink:
     """
     This class represents a direct link (resptr) between a starting resource and a target resource.
 
@@ -18,7 +23,7 @@ class ResptrLink:
 
     source_id: str
     target_id: str
-    link_uuid: str = field(default_factory=lambda: str(uuid.uuid4()))
+    link_uuid: str
 
     @property
     def cost_links(self) -> float:
@@ -27,7 +32,7 @@ class ResptrLink:
 
 
 @dataclass(frozen=True)
-class XMLLink:
+class StandOffLink:
     """
     This class represents one or more links from a single starting resource to a set of target resources,
     where all target resources are linked to from a single text value of the starting resource.
@@ -40,7 +45,7 @@ class XMLLink:
 
     source_id: str
     target_ids: set[str]
-    link_uuid: str = field(default_factory=lambda: str(uuid.uuid4()))
+    link_uuid: str
 
     @property
     def cost_links(self) -> float:
@@ -61,9 +66,9 @@ class Edge:
 
     source: int
     target: int
-    link_object: ResptrLink | XMLLink
+    link_object: LinkValueLink | StandOffLink
 
-    def as_tuple(self) -> tuple[int, int, ResptrLink | XMLLink]:
+    def as_tuple(self) -> tuple[int, int, LinkValueLink | StandOffLink]:
         """Returns a representation of this edge as a tuple of the source index, target index and link object"""
         return self.source, self.target, self.link_object
 

dsp_tools/commands/xmlupload/stash/stash_circular_references.py

@@ -1,17 +1,9 @@
-from __future__ import annotations
+from copy import deepcopy
 
-from typing import cast
-from uuid import uuid4
-
-from lxml import etree
-
-from dsp_tools.commands.xmlupload.models.deserialise.deserialise_value import XMLProperty
-from dsp_tools.commands.xmlupload.models.deserialise.xmlresource import XMLResource
 from dsp_tools.commands.xmlupload.models.formatted_text_value import FormattedTextValue
-from dsp_tools.commands.xmlupload.models.permission import Permissions
-from dsp_tools.commands.xmlupload.stash.construct_and_analyze_graph import create_info_from_xml_for_graph
-from dsp_tools.commands.xmlupload.stash.construct_and_analyze_graph import generate_upload_order
-from dsp_tools.commands.xmlupload.stash.construct_and_analyze_graph import make_graph
+from dsp_tools.commands.xmlupload.models.processed.res import ProcessedResource
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedLink
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedRichtext
 from dsp_tools.commands.xmlupload.stash.stash_models import LinkValueStash
 from dsp_tools.commands.xmlupload.stash.stash_models import LinkValueStashItem
 from dsp_tools.commands.xmlupload.stash.stash_models import StandoffStash
@@ -19,117 +11,58 @@ from dsp_tools.commands.xmlupload.stash.stash_models import StandoffStashItem
 from dsp_tools.commands.xmlupload.stash.stash_models import Stash
 
 
-def _stash_standoff(
-    res_id: str,
-    restype: str,
-    link_prop: XMLProperty,
-    stash_lookup: dict[str, list[str]],
-) -> list[StandoffStashItem]:
-    stashed_items = []
-    for value in link_prop.values:
-        if value.link_uuid not in stash_lookup[res_id]:
-            continue
-        # value.value is a KnoraStandoffXml text with problematic links.
-        # stash it, then replace the problematic text with a UUID
-        standoff_xml = cast(FormattedTextValue, value.value)
-        uuid = str(uuid4())
-        standoff_stash_item = StandoffStashItem(
-            res_id=res_id,
-            res_type=restype,
-            uuid=uuid,
-            prop_name=link_prop.name,
-            value=standoff_xml,
-        )
-        value.value = FormattedTextValue(uuid)
-        stashed_items.append(standoff_stash_item)
-    return stashed_items
-
-
-def _stash_resptr(
-    res_id: str,
-    restype: str,
-    link_prop: XMLProperty,
-    stash_lookup: dict[str, list[str]],
-    permission_lookup: dict[str, Permissions],
-) -> list[LinkValueStashItem]:
-    stashed_items = []
-    for value in link_prop.values.copy():
-        if value.link_uuid not in stash_lookup[res_id]:
-            continue
-        permission = str(permission_lookup[value.permissions]) if value.permissions else None
-        # value.value is the ID of the target resource. stash it, then delete it
-        link_stash_item = LinkValueStashItem(
-            res_id=res_id,
-            res_type=restype,
-            prop_name=link_prop.name,
-            target_id=str(value.value),
-            permission=permission,
-        )
-        link_prop.values.remove(value)
-        stashed_items.append(link_stash_item)
-    return stashed_items
-
-
-def stash_circular_references(
-    resources: list[XMLResource],
-    stash_lookup: dict[str, list[str]],
-    permission_lookup: dict[str, Permissions],
-) -> Stash | None:
-    """
-    Stashes problematic resource-references from a list of resources.
-    The resources are modified in-place.
-
-    Args:
-        resources: all resources of the XML file
-        stash_lookup: A dictionary which maps the resources that have stashes to the UUIDs of the stashed links
-        permission_lookup: A dictionary which maps the permissions of the stashed links to their string representation
-
-    Returns:
-        stash: an object that contains the stashed references
-
-    Raises:
-        ValueError: If a link property of one of the resources is not "text" or "resptr"
-    """
-    stashed_standoff_values: list[StandoffStashItem] = []
+def stash_circular_references(resources: list[ProcessedResource], stash_lookup: dict[str, list[str]]) -> Stash | None:
+    """Stash the values that would create circular references and remove them from the Resources."""
     stashed_link_values: list[LinkValueStashItem] = []
+    stashed_standoff_values: list[StandoffStashItem] = []
+
+    if not stash_lookup:
+        return None
 
     for res in resources:
         if res.res_id not in stash_lookup:
             continue
-        for link_prop in res.get_props_with_links():
-            if link_prop.valtype == "text":
-                standoff_stash_item = _stash_standoff(res.res_id, res.restype, link_prop, stash_lookup)
-                stashed_standoff_values.extend(standoff_stash_item)
-            elif link_prop.valtype == "resptr":
-                link_stash_item = _stash_resptr(res.res_id, res.restype, link_prop, stash_lookup, permission_lookup)
-                stashed_link_values.extend(link_stash_item)
-            else:
-                raise ValueError(f"Unknown value type: '{link_prop.valtype}' (should be 'text' or 'resptr')")
-
-            if len(link_prop.values) == 0:
-                # if all values of a link property have been stashed, the property needs to be removed
-                res.properties.remove(link_prop)
+        links, standoff = _process_one_resource(res, stash_lookup)
+        stashed_link_values.extend(links)
+        stashed_standoff_values.extend(standoff)
 
     standoff_stash = StandoffStash.make(stashed_standoff_values)
     link_value_stash = LinkValueStash.make(stashed_link_values)
-    return Stash.make(standoff_stash, link_value_stash)
-
+    return Stash.make(standoff_stash=standoff_stash, link_value_stash=link_value_stash)
 
-def identify_circular_references(root: etree._Element) -> tuple[dict[str, list[str]], list[str]]:
-    """
-    Identifies problematic resource-references inside an XML tree.
-    A reference is problematic if it creates a circle (circular references).
-    The XML tree is modified in-place:
-    A reference UUID is added to each XML element that contains a link (`<resptr>` or `<text>`).
 
-    Args:
-        root: the root element of the parsed XML document
+def _process_one_resource(
+    resource: ProcessedResource,
+    stash_lookup: dict[str, list[str]],
+) -> tuple[list[LinkValueStashItem], list[StandoffStashItem]]:
+    stashed_link_values: list[LinkValueStashItem] = []
+    stashed_standoff_values: list[StandoffStashItem] = []
 
-    Returns:
-        stash_lookup: A dictionary which maps the resources that have stashes to the UUIDs of the stashed links
-        upload_order: A list of resource IDs in the order in which they should be uploaded
-    """
-    resptr_links, xml_links, all_resource_ids = create_info_from_xml_for_graph(root)
-    graph, node_to_id, edges = make_graph(resptr_links, xml_links, all_resource_ids)
-    stash_lookup, upload_order, _ = generate_upload_order(graph, node_to_id, edges)
-    return stash_lookup, upload_order
+    for val in resource.values.copy():
+        if isinstance(val, ProcessedLink):
+            if val.value_uuid not in stash_lookup[resource.res_id]:
+                continue
+            stashed_link_values.append(LinkValueStashItem(resource.res_id, resource.type_iri, val))
+            resource.values.remove(val)
+        elif isinstance(val, ProcessedRichtext):
+            if val.value_uuid not in stash_lookup[resource.res_id]:
+                continue
+            # val.value is a KnoraStandoffXml text with problematic links.
+            # stash it, then replace the problematic text with a UUID
+            stashed_standoff_values.append(_stash_standoff(val, resource.res_id, resource.type_iri))
+
+    return stashed_link_values, stashed_standoff_values
+
+
+def _stash_standoff(value: ProcessedRichtext, res_id: str, res_type: str) -> StandoffStashItem:
+    original_value = deepcopy(value)
+    # Replace the content with the UUID
+    value.value = FormattedTextValue(value.value_uuid)
+    # It is not necessary to add the permissions to the StandoffStashItem.
+    # Because when no new permissions are given during an update request,
+    # the permissions of the previous value are taken.
+    return StandoffStashItem(
+        res_id=res_id,
+        res_type=res_type,
+        value=original_value,
+    )

dsp_tools/commands/xmlupload/stash/stash_models.py

@@ -3,18 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from itertools import groupby
 
-from dsp_tools.commands.xmlupload.models.formatted_text_value import FormattedTextValue
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedLink
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedRichtext
 
 
 @dataclass(frozen=True)
 class StandoffStashItem:
-    """Holds information about a single stashed XML text value."""
-
     res_id: str
     res_type: str
-    uuid: str
-    prop_name: str
-    value: FormattedTextValue
+    value: ProcessedRichtext
 
 
 @dataclass(frozen=True)
@@ -51,9 +48,7 @@ class LinkValueStashItem:
 
     res_id: str
     res_type: str
-    prop_name: str
-    target_id: str
-    permission: str | None = None
+    value: ProcessedLink
 
 
 @dataclass(frozen=True)