add resolve_parts_of_same dataset variant

This adds a new dataset variant `resolve_parts_of_same` where all spans connected via `parts_of_same` relations are merged by using the smallest start index as new start and the biggest end index as new end index, i.e. the max coverage will be used span. Note that this may create nested spans!

sciarg.py

@@ -1,8 +1,13 @@
+import logging
+from typing import Sequence, Set, Tuple, Union
+
+import networkx as nx
 from pie_modules.document.processing import (
     RegexPartitioner,
     RelationArgumentSorter,
     TextSpanTrimmer,
 )
+from pytorch_ie.annotations import BinaryRelation, LabeledMultiSpan, LabeledSpan
 from pytorch_ie.core import Document
 from pytorch_ie.documents import (
     TextDocumentWithLabeledSpansAndBinaryRelations,
@@ -11,12 +16,130 @@ from pytorch_ie.documents import (
 
 from pie_datasets.builders import BratBuilder, BratConfig
 from pie_datasets.builders.brat import BratDocumentWithMergedSpans
+from pie_datasets.core.dataset import DocumentConvertersType
 from pie_datasets.document.processing import Caster, Pipeline
 
 URL = "http://data.dws.informatik.uni-mannheim.de/sci-arg/compiled_corpus.zip"
 SPLIT_PATHS = {"train": "compiled_corpus"}
 
 
+logger = logging.getLogger(__name__)
+
+
+def _merge_spans_via_relation(
+    spans: Sequence[LabeledSpan],
+    relations: Sequence[BinaryRelation],
+    link_relation_label: str,
+    create_multi_spans: bool = True,
+) -> Tuple[Union[Set[LabeledSpan], Set[LabeledMultiSpan]], Set[BinaryRelation]]:
+    # convert list of relations to a graph to easily calculate connected components to merge
+    g = nx.Graph()
+    link_relations = []
+    other_relations = []
+    for rel in relations:
+        if rel.label == link_relation_label:
+            link_relations.append(rel)
+            # never merge spans that have not the same label
+            if (
+                not (isinstance(rel.head, LabeledSpan) or isinstance(rel.tail, LabeledSpan))
+                or rel.head.label == rel.tail.label
+            ):
+                g.add_edge(rel.head, rel.tail)
+            else:
+                logger.debug(
+                    f"spans to merge do not have the same label, do not merge them: {rel.head}, {rel.tail}"
+                )
+        else:
+            other_relations.append(rel)
+
+    span_mapping = {}
+    connected_components: Set[LabeledSpan]
+    for connected_components in nx.connected_components(g):
+        # all spans in a connected component have the same label
+        label = list(span.label for span in connected_components)[0]
+        connected_components_sorted = sorted(connected_components, key=lambda span: span.start)
+        if create_multi_spans:
+            new_span = LabeledMultiSpan(
+                slices=tuple((span.start, span.end) for span in connected_components_sorted),
+                label=label,
+            )
+        else:
+            new_span = LabeledSpan(
+                start=min(span.start for span in connected_components_sorted),
+                end=max(span.end for span in connected_components_sorted),
+                label=label,
+            )
+        for span in connected_components_sorted:
+            span_mapping[span] = new_span
+    for span in spans:
+        if span not in span_mapping:
+            if create_multi_spans:
+                span_mapping[span] = LabeledMultiSpan(
+                    slices=((span.start, span.end),), label=span.label, score=span.score
+                )
+            else:
+                span_mapping[span] = LabeledSpan(
+                    start=span.start, end=span.end, label=span.label, score=span.score
+                )
+
+    new_spans = set(span_mapping.values())
+    new_relations = {
+        BinaryRelation(
+            head=span_mapping[rel.head],
+            tail=span_mapping[rel.tail],
+            label=rel.label,
+            score=rel.score,
+        )
+        for rel in other_relations
+    }
+
+    return new_spans, new_relations
+
+
+class SpansWithRelationsMerger:
+    """Merge spans that are connected via a specific relation type.
+
+    Args:
+        relation_layer: The name of the layer that contains the relations.
+        link_relation_label: The label of the relations that connect the spans.
+        create_multi_spans: If True, the merged spans are LabeledMultiSpans, otherwise LabeledSpans.
+    """
+
+    def __init__(
+        self,
+        relation_layer: str,
+        link_relation_label: str,
+        result_document_type: type[Document],
+        result_field_mapping: dict[str, str],
+        create_multi_spans: bool = True,
+    ):
+        self.relation_layer = relation_layer
+        self.link_relation_label = link_relation_label
+        self.create_multi_spans = create_multi_spans
+        self.result_document_type = result_document_type
+        self.result_field_mapping = result_field_mapping
+
+    def __call__(self, document: Document) -> Document:
+        relations: Sequence[BinaryRelation] = document[self.relation_layer]
+        spans: Sequence[LabeledSpan] = document[self.relation_layer].target_layer
+
+        new_spans, new_relations = _merge_spans_via_relation(
+            spans=spans,
+            relations=relations,
+            link_relation_label=self.link_relation_label,
+            create_multi_spans=self.create_multi_spans,
+        )
+
+        result = document.copy(with_annotations=False).as_type(new_type=self.result_document_type)
+        span_layer_name = document[self.relation_layer].target_name
+        result_span_layer_name = self.result_field_mapping[span_layer_name]
+        result_relation_layer_name = self.result_field_mapping[self.relation_layer]
+        result[result_span_layer_name].extend(new_spans)
+        result[result_relation_layer_name].extend(new_relations)
+
+        return result
+
+
 def get_common_pipeline_steps(target_document_type: type[Document]) -> dict:
     return dict(
         cast=Caster(
@@ -31,6 +154,36 @@ def get_common_pipeline_steps(target_document_type: type[Document]) -> dict:
     )
 
 
+def get_common_pipeline_steps_with_merge_multi_spans(
+    target_document_type: type[Document],
+) -> dict:
+    return dict(
+        merge_spans=SpansWithRelationsMerger(
+            relation_layer="relations",
+            link_relation_label="parts_of_same",
+            create_multi_spans=False,
+            result_document_type=target_document_type,
+            result_field_mapping={"spans": "labeled_spans", "relations": "binary_relations"},
+        ),
+        trim_adus=TextSpanTrimmer(layer="labeled_spans"),
+        sort_symmetric_relation_arguments=RelationArgumentSorter(
+            relation_layer="binary_relations",
+            label_whitelist=["parts_of_same", "semantically_same"],
+        ),
+    )
+
+
+class SciArgConfig(BratConfig):
+    def __init__(
+        self,
+        name: str,
+        resolve_parts_of_same: bool = False,
+        **kwargs,
+    ):
+        super().__init__(name=name, merge_fragmented_spans=True, **kwargs)
+        self.resolve_parts_of_same = resolve_parts_of_same
+
+
 class SciArg(BratBuilder):
     BASE_DATASET_PATH = "DFKI-SLT/brat"
     BASE_DATASET_REVISION = "844de61e8a00dc6a93fc29dc185f6e617131fbf1"
@@ -39,33 +192,55 @@ class SciArg(BratBuilder):
     # The span fragments in SciArg come just from the new line splits, so we can merge them.
     # Actual span fragments are annotated via "parts_of_same" relations.
     BUILDER_CONFIGS = [
-        BratConfig(name=BratBuilder.DEFAULT_CONFIG_NAME, merge_fragmented_spans=True),
+        SciArgConfig(name=BratBuilder.DEFAULT_CONFIG_NAME),
+        SciArgConfig(name="resolve_parts_of_same", resolve_parts_of_same=True),
     ]
     DOCUMENT_TYPES = {
         BratBuilder.DEFAULT_CONFIG_NAME: BratDocumentWithMergedSpans,
+        "resolve_parts_of_same": BratDocumentWithMergedSpans,
     }
 
     # we need to add None to the list of dataset variants to support the default dataset variant
     BASE_BUILDER_KWARGS_DICT = {
         dataset_variant: {"url": URL, "split_paths": SPLIT_PATHS}
-        for dataset_variant in ["default", "merge_fragmented_spans", None]
+        for dataset_variant in ["default", "resolve_parts_of_same", None]
     }
 
-    DOCUMENT_CONVERTERS = {
-        TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
-            **get_common_pipeline_steps(TextDocumentWithLabeledSpansAndBinaryRelations)
-        ),
-        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
-            **get_common_pipeline_steps(
-                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
-            ),
-            add_partitions=RegexPartitioner(
-                partition_layer_name="labeled_partitions",
-                pattern="<([^>/]+)>.*</\\1>",
-                label_group_id=1,
-                label_whitelist=["Title", "Abstract", "H1"],
-                skip_initial_partition=True,
-                strip_whitespace=True,
-            ),
-        ),
-    }
+    @property
+    def document_converters(self) -> DocumentConvertersType:
+        regex_partitioner = RegexPartitioner(
+            partition_layer_name="labeled_partitions",
+            pattern="<([^>/]+)>.*</\\1>",
+            label_group_id=1,
+            label_whitelist=["Title", "Abstract", "H1"],
+            skip_initial_partition=True,
+            strip_whitespace=True,
+        )
+        if not self.config.resolve_parts_of_same:
+            return {
+                TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
+                    **get_common_pipeline_steps(TextDocumentWithLabeledSpansAndBinaryRelations)
+                ),
+                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
+                    **get_common_pipeline_steps(
+                        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
+                    ),
+                    add_partitions=regex_partitioner,
+                ),
+            }
+        else:
+            return {
+                TextDocumentWithLabeledSpansAndBinaryRelations: Pipeline(
+                    **get_common_pipeline_steps_with_merge_multi_spans(
+                        TextDocumentWithLabeledSpansAndBinaryRelations
+                    )
+                ),
+                TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions: Pipeline(
+                    **get_common_pipeline_steps_with_merge_multi_spans(
+                        TextDocumentWithLabeledSpansBinaryRelationsAndLabeledPartitions
+                    ),
+                    add_partitions=regex_partitioner,
+                ),
+                # TODO: add TextDocumentWithLabeledMultiSpansAndBinaryRelations
+                # TODO: add TextDocumentWithLabeledMultiSpansBinaryRelationsAndLabeledPartitions
+            }