arguebuf 2.7.0__tar.gz → 2.7.2__tar.gz

{arguebuf-2.7.0/src/arguebuf.egg-info → arguebuf-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: arguebuf
-Version: 2.7.0
+Version: 2.7.2
 Summary: Create and analyze argument graphs and serialize them via Protobuf
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/recap-utr/arguebuf-python
@@ -22,6 +22,7 @@ Requires-Dist: typer<1,>=0.9; extra == "cli"
 Requires-Dist: deepl<2,>=1; extra == "cli"
 Provides-Extra: graphviz
 Requires-Dist: pygraphviz<2,>=1; extra == "graphviz"
+Dynamic: license-file
 
 # Arguebuf Python
 

{arguebuf-2.7.0 → arguebuf-2.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arguebuf"
-version = "2.7.0"
+version = "2.7.2"
 description = "Create and analyze argument graphs and serialize them via Protobuf"
 authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"

arguebuf-2.7.2/src/arguebuf/load/_load_aif.py

@@ -0,0 +1,368 @@
+import typing as t
+
+import pendulum
+
+from arguebuf import dt
+from arguebuf.model import Graph, utils
+from arguebuf.model.edge import Edge, warn_missing_nodes
+from arguebuf.model.node import AbstractNode, AtomNode, SchemeNode
+from arguebuf.model.scheme import aif2scheme, text2scheme
+from arguebuf.schemas import aif
+
+from ._config import Config, DefaultConfig
+
+__all__ = ("load_aif",)
+
+
+def load_aif(
+    obj: aif.Graph,
+    name: str | None = None,
+    config: Config = DefaultConfig,
+    reconstruct_dialog: bool = False,
+) -> Graph:
+    """Generate Graph structure from AIF argument graph file"""
+    g = config.GraphClass(name)
+
+    # Preprocess the graph to handle dialogue nodes
+    if reconstruct_dialog:
+        obj = preprocess_dialog(obj)
+
+    for aif_node in obj["nodes"]:
+        node = (
+            atom_from_aif(aif_node, config)
+            if aif_node["type"] == "I"
+            else scheme_from_aif(aif_node, config)
+        )
+
+        if node:
+            g.add_node(node)
+
+    for aif_edge in obj["edges"]:
+        if edge := edge_from_aif(aif_edge, g.nodes, config):
+            g.add_edge(edge)
+
+    return g
+
+
+def atom_from_aif(obj: aif.Node, config: Config) -> AtomNode:
+    """Generate AtomNode object from AIF Node object."""
+    timestamp = dt.from_format(obj.get("timestamp"), aif.DATE_FORMAT) or pendulum.now()
+
+    return config.AtomNodeClass(
+        id=obj["nodeID"],
+        metadata=config.MetadataClass(timestamp, timestamp),
+        text=utils.parse(obj["text"], config.nlp),
+    )
+
+
+def scheme_from_aif(obj: aif.Node, config: Config) -> SchemeNode | None:
+    """Generate SchemeNode object from AIF Node object."""
+
+    aif_type = obj["type"]
+    aif_scheme: str = obj.get("scheme", obj["text"])
+
+    if aif_type in aif2scheme:
+        scheme = aif2scheme[t.cast(aif.SchemeType, aif_type)]
+
+        # TODO: Handle formatting like capitalization, spaces, underscores, etc.
+        # TODO: Araucaria does not use spaces between scheme names
+        # aif_scheme = re.sub("([A-Z])", r" \1", aif_scheme)
+        if scheme and (found_scheme := text2scheme[type(scheme)].get(aif_scheme)):
+            scheme = found_scheme
+
+        timestamp = (
+            dt.from_format(obj.get("timestamp"), aif.DATE_FORMAT) or pendulum.now()
+        )
+
+        return config.SchemeNodeClass(
+            id=obj["nodeID"],
+            metadata=config.MetadataClass(timestamp, timestamp),
+            scheme=scheme,
+        )
+
+    return None
+
+
+def edge_from_aif(
+    obj: aif.Edge, nodes: t.Mapping[str, AbstractNode], config: Config
+) -> Edge | None:
+    """Generate Edge object from AIF Edge format."""
+    source_id = obj.get("fromID")
+    target_id = obj.get("toID")
+
+    if source_id in nodes and target_id in nodes:
+        return config.EdgeClass(
+            id=obj["edgeID"],
+            source=nodes[source_id],
+            target=nodes[target_id],
+        )
+    else:
+        warn_missing_nodes(obj["edgeID"], source_id, target_id)
+
+    return None
+
+
+# Node types that are not directly supported in arguebuf
+UNSUPPORTED_NODE_TYPES = {"L", "TA", "YA"}
+
+
+def preprocess_dialog(graph: aif.Graph) -> aif.Graph:
+    """Preprocess AIF graph by removing dialogue nodes and reconnecting arguments.
+
+    Removes unsupported dialogue nodes (L, TA, YA) while preserving
+    argument structure by creating rephrase connections.
+    """
+    # Copy the graph
+    result: aif.Graph = {
+        "nodes": graph["nodes"].copy(),
+        "edges": graph["edges"].copy(),
+        "locutions": graph.get("locutions", []).copy(),
+    }
+
+    # Find hanging nodes before removing dialogue nodes
+    hanging_nodes = _find_hanging_nodes(result)
+
+    # Remove dialogue nodes and create bypass edges
+    result = _remove_dialogue_nodes(result)
+
+    # Reconnect hanging nodes with rephrase nodes
+    result = _add_rephrase_connections(result, hanging_nodes, graph)
+
+    return result
+
+
+def _find_hanging_nodes(graph: aif.Graph) -> set[str]:
+    """Find I-nodes with exactly one incoming edge and no outgoing edges."""
+    hanging = set()
+
+    for node in graph["nodes"]:
+        if node["type"] != "I":
+            continue
+
+        node_id = node["nodeID"]
+        incoming = sum(1 for e in graph["edges"] if e["toID"] == node_id)
+        outgoing = sum(1 for e in graph["edges"] if e["fromID"] == node_id)
+
+        if incoming == 1 and outgoing == 0:
+            hanging.add(node_id)
+
+    return hanging
+
+
+def _remove_dialogue_nodes(graph: aif.Graph) -> aif.Graph:
+    """Remove dialogue nodes (L, TA, YA) and bypass them with direct edges."""
+    # Identify dialogue nodes
+    dialogue_nodes = {
+        n["nodeID"] for n in graph["nodes"] if n["type"] in UNSUPPORTED_NODE_TYPES
+    }
+
+    # Find edges to bypass
+    new_edges = []
+    edges_to_remove = set()
+
+    for node_id in dialogue_nodes:
+        incoming = [e for e in graph["edges"] if e["toID"] == node_id]
+        outgoing = [e for e in graph["edges"] if e["fromID"] == node_id]
+
+        # Mark these edges for removal
+        for edge in incoming + outgoing:
+            edges_to_remove.add(edge["edgeID"])
+
+        # Create bypass edges
+        for in_edge in incoming:
+            for out_edge in outgoing:
+                from_id = in_edge["fromID"]
+                to_id = out_edge["toID"]
+
+                # Skip self-loops and edges to other dialogue nodes
+                if from_id == to_id:
+                    continue
+
+                from_node = next(
+                    (n for n in graph["nodes"] if n["nodeID"] == from_id), None
+                )
+                to_node = next(
+                    (n for n in graph["nodes"] if n["nodeID"] == to_id), None
+                )
+
+                if (
+                    from_node
+                    and to_node
+                    and from_node["type"] not in UNSUPPORTED_NODE_TYPES
+                    and to_node["type"] not in UNSUPPORTED_NODE_TYPES
+                ):
+                    # Check if edge already exists
+                    if not any(
+                        e["fromID"] == from_id and e["toID"] == to_id
+                        for e in graph["edges"]
+                    ):
+                        new_edges.append(
+                            {
+                                "edgeID": utils.uuid(),
+                                "fromID": from_id,
+                                "toID": to_id,
+                                "formEdgeID": None,
+                            }
+                        )
+
+    # Update graph
+    graph["nodes"] = [n for n in graph["nodes"] if n["nodeID"] not in dialogue_nodes]
+    graph["edges"] = [e for e in graph["edges"] if e["edgeID"] not in edges_to_remove]
+    graph["edges"].extend(new_edges)
+
+    return graph
+
+
+def _add_rephrase_connections(
+    graph: aif.Graph, hanging_nodes: set[str], original_graph: aif.Graph
+) -> aif.Graph:
+    """Add rephrase nodes to connect hanging nodes to their dialogue partners."""
+    if not hanging_nodes:
+        return graph
+
+    # Build maps for the original graph
+    orig_edges_from = {}
+    orig_edges_to = {}
+    for edge in original_graph["edges"]:
+        orig_edges_from.setdefault(edge["fromID"], []).append(edge["toID"])
+        orig_edges_to.setdefault(edge["toID"], []).append(edge["fromID"])
+
+    nodes_by_id = {n["nodeID"]: n for n in original_graph["nodes"]}
+
+    new_nodes = []
+    new_edges = []
+    connections_made = set()
+
+    for hanging_id in hanging_nodes:
+        # Find the I-nodes this hanging node should connect to
+        targets = _find_dialogue_targets(
+            hanging_id, orig_edges_to, orig_edges_from, nodes_by_id
+        )
+
+        for i, target_id in enumerate(targets):
+            # Skip if target doesn't exist in processed graph
+            if not any(n["nodeID"] == target_id for n in graph["nodes"]):
+                continue
+
+            # Skip if already connected
+            pair = (min(hanging_id, target_id), max(hanging_id, target_id))
+            if pair in connections_made:
+                continue
+
+            # Check if already connected in the processed graph
+            if any(
+                (e["fromID"] == hanging_id and e["toID"] == target_id)
+                or (e["fromID"] == target_id and e["toID"] == hanging_id)
+                for e in graph["edges"]
+            ):
+                continue
+
+            # Create rephrase node
+            rephrase_id = utils.uuid()
+            hanging_node = next(n for n in graph["nodes"] if n["nodeID"] == hanging_id)
+            new_nodes.append(
+                {
+                    "nodeID": rephrase_id,
+                    "text": "Default Rephrase",
+                    "type": "MA",
+                    "timestamp": hanging_node.get("timestamp", ""),
+                }
+            )
+
+            # First target is backward (response), others are forward
+            if i == 0 and len(targets) > 1:
+                # Backward: target -> rephrase -> hanging
+                new_edges.extend(
+                    [
+                        {
+                            "edgeID": utils.uuid(),
+                            "fromID": target_id,
+                            "toID": rephrase_id,
+                            "formEdgeID": None,
+                        },
+                        {
+                            "edgeID": utils.uuid(),
+                            "fromID": rephrase_id,
+                            "toID": hanging_id,
+                            "formEdgeID": None,
+                        },
+                    ]
+                )
+            else:
+                # Forward: hanging -> rephrase -> target
+                new_edges.extend(
+                    [
+                        {
+                            "edgeID": utils.uuid(),
+                            "fromID": hanging_id,
+                            "toID": rephrase_id,
+                            "formEdgeID": None,
+                        },
+                        {
+                            "edgeID": utils.uuid(),
+                            "fromID": rephrase_id,
+                            "toID": target_id,
+                            "formEdgeID": None,
+                        },
+                    ]
+                )
+
+            connections_made.add(pair)
+
+    graph["nodes"].extend(new_nodes)
+    graph["edges"].extend(new_edges)
+
+    return graph
+
+
+def _find_dialogue_targets(
+    node_id: str, edges_to: dict, edges_from: dict, nodes_by_id: dict
+) -> list[str]:
+    """Find I-nodes that a hanging node should connect to based on dialogue structure."""
+    targets = []
+
+    # Find the locution that supports this node through YA
+    locution = None
+    for ya_id in edges_to.get(node_id, []):
+        if nodes_by_id.get(ya_id, {}).get("type") == "YA":
+            for loc_id in edges_to.get(ya_id, []):
+                if nodes_by_id.get(loc_id, {}).get("type") == "L":
+                    locution = loc_id
+                    break
+            if locution:
+                break
+
+    if not locution:
+        return targets
+
+    # Find backward connections (what this responds to)
+    for ta_id in edges_to.get(locution, []):
+        if nodes_by_id.get(ta_id, {}).get("type") == "TA":
+            for source_loc in edges_to.get(ta_id, []):
+                if nodes_by_id.get(source_loc, {}).get("type") == "L":
+                    # Find I-nodes from this locution
+                    for ya_id in edges_from.get(source_loc, []):
+                        if nodes_by_id.get(ya_id, {}).get("type") == "YA":
+                            for i_id in edges_from.get(ya_id, []):
+                                if (
+                                    nodes_by_id.get(i_id, {}).get("type") == "I"
+                                    and i_id != node_id
+                                ):
+                                    targets.append(i_id)
+
+    # Find forward connections (where this transitions to)
+    for ta_id in edges_from.get(locution, []):
+        if nodes_by_id.get(ta_id, {}).get("type") == "TA":
+            for target_loc in edges_from.get(ta_id, []):
+                if nodes_by_id.get(target_loc, {}).get("type") == "L":
+                    # Find I-nodes from this locution
+                    for ya_id in edges_from.get(target_loc, []):
+                        if nodes_by_id.get(ya_id, {}).get("type") == "YA":
+                            for i_id in edges_from.get(ya_id, []):
+                                if (
+                                    nodes_by_id.get(i_id, {}).get("type") == "I"
+                                    and i_id != node_id
+                                ):
+                                    targets.append(i_id)
+
+    return targets

{arguebuf-2.7.0 → arguebuf-2.7.2}/src/arguebuf/render/_render_graphviz.py

@@ -31,7 +31,7 @@ def graphviz(
 
     if isinstance(graph, Graph):
         raise ValueError(
-            "This method expects a graph in the 'DOT' format.Please use"
+            "This method expects a graph in the 'DOT' format. Please use"
             " 'arguebuf.dump.graphviz(graph)' to convert your argument graph to the 'DOT'"
             " format."
         )

{arguebuf-2.7.0 → arguebuf-2.7.2/src/arguebuf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: arguebuf
-Version: 2.7.0
+Version: 2.7.2
 Summary: Create and analyze argument graphs and serialize them via Protobuf
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/recap-utr/arguebuf-python
@@ -22,6 +22,7 @@ Requires-Dist: typer<1,>=0.9; extra == "cli"
 Requires-Dist: deepl<2,>=1; extra == "cli"
 Provides-Extra: graphviz
 Requires-Dist: pygraphviz<2,>=1; extra == "graphviz"
+Dynamic: license-file
 
 # Arguebuf Python
 

{arguebuf-2.7.0 → arguebuf-2.7.2}/src/arguebuf.egg-info/SOURCES.txt

@@ -50,7 +50,6 @@ src/arguebuf/load/_load_protobuf.py
 src/arguebuf/load/_load_sadface.py
 src/arguebuf/load/_load_text.py
 src/arguebuf/load/_load_xaif.py
-src/arguebuf/load/_preprocess_aif.py
 src/arguebuf/model/__init__.py
 src/arguebuf/model/analyst.py
 src/arguebuf/model/edge.py
@@ -80,4 +79,5 @@ tests/test_create_graph.py
 tests/test_load_casebase.py
 tests/test_load_edge.py
 tests/test_load_node.py
+tests/test_preprocess_dialog.py
 tests/test_render_graph.py

arguebuf-2.7.2/tests/test_preprocess_dialog.py

@@ -0,0 +1,134 @@
+"""Test dialog preprocessing in AIF graphs."""
+
+import json
+from pathlib import Path
+
+from arguebuf.load._load_aif import preprocess_dialog
+from arguebuf.schemas import aif
+
+
+def test_preprocess_dialog_6064():
+    """Test preprocessing of complex dialog structure in 6064.json."""
+    # Load test data
+    data_dir = Path(__file__).parent.parent / "data"
+
+    with open(data_dir / "6064-original.json") as f:
+        original = json.load(f)
+
+    with open(data_dir / "6064-reconstructed.json") as f:
+        expected = json.load(f)
+
+    # Run preprocessing
+    result = preprocess_dialog(original)
+
+    # Check that we have the same number of nodes
+    assert len(result["nodes"]) == len(expected["nodes"])
+
+    # Separate original nodes from new rephrase nodes
+    original_node_ids = {n["nodeID"] for n in original["nodes"]}
+
+    result_original_nodes = [
+        n for n in result["nodes"] if n["nodeID"] in original_node_ids
+    ]
+    result_new_nodes = [
+        n for n in result["nodes"] if n["nodeID"] not in original_node_ids
+    ]
+
+    expected_original_nodes = [
+        n for n in expected["nodes"] if n["nodeID"] in original_node_ids
+    ]
+    expected_new_nodes = [
+        n for n in expected["nodes"] if n["nodeID"] not in original_node_ids
+    ]
+
+    # Check original nodes are preserved correctly
+    assert len(result_original_nodes) == len(expected_original_nodes)
+
+    result_original_sorted = sorted(result_original_nodes, key=lambda n: n["nodeID"])
+    expected_original_sorted = sorted(
+        expected_original_nodes, key=lambda n: n["nodeID"]
+    )
+
+    for r_node, e_node in zip(result_original_sorted, expected_original_sorted):
+        assert r_node["nodeID"] == e_node["nodeID"]
+        assert r_node["type"] == e_node["type"]
+        assert r_node["text"] == e_node["text"]
+        assert r_node["timestamp"] == e_node["timestamp"]
+
+    # Check new rephrase nodes
+    assert len(result_new_nodes) == len(expected_new_nodes)
+    for node in result_new_nodes:
+        assert node["type"] == "MA"
+        assert node["text"] == "Default Rephrase"
+
+    # Check edges count
+    assert len(result["edges"]) == len(expected["edges"])
+
+    # Check that locutions are preserved (they match the expected output)
+    assert len(result["locutions"]) == len(original["locutions"])
+
+    # Verify all dialogue nodes were removed
+    for node in result["nodes"]:
+        assert node["type"] not in {"L", "TA", "YA"}, (
+            f"Dialogue node {node['nodeID']} not removed"
+        )
+
+
+def test_preprocess_dialog_preserves_argument_structure():
+    """Test that preprocessing preserves the essential argument structure."""
+    original: aif.Graph = {
+        "nodes": [
+            {"nodeID": "n1", "text": "Claim 1", "type": "I", "timestamp": ""},
+            {"nodeID": "n2", "text": "Support", "type": "RA", "timestamp": ""},
+            {"nodeID": "n3", "text": "Claim 2", "type": "I", "timestamp": ""},
+            {"nodeID": "l1", "text": "Speaker", "type": "L", "timestamp": ""},
+            {"nodeID": "ta1", "text": "Transition", "type": "TA", "timestamp": ""},
+            {"nodeID": "ya1", "text": "Asserting", "type": "YA", "timestamp": ""},
+        ],
+        "edges": [
+            {"edgeID": "e1", "fromID": "n1", "toID": "n2", "formEdgeID": None},
+            {"edgeID": "e2", "fromID": "n2", "toID": "n3", "formEdgeID": None},
+            {"edgeID": "e3", "fromID": "l1", "toID": "ta1", "formEdgeID": None},
+            {"edgeID": "e4", "fromID": "ta1", "toID": "ya1", "formEdgeID": None},
+            {"edgeID": "e5", "fromID": "ya1", "toID": "n1", "formEdgeID": None},
+        ],
+        "locutions": [],
+    }
+
+    result = preprocess_dialog(original)
+
+    # Check that argument nodes and edges are preserved
+    assert len([n for n in result["nodes"] if n["type"] == "I"]) == 2
+    assert len([n for n in result["nodes"] if n["type"] == "RA"]) == 1
+
+    # Check that the main argument structure is intact
+    edges = result["edges"]
+    assert any(e["fromID"] == "n1" and e["toID"] == "n2" for e in edges)
+    assert any(e["fromID"] == "n2" and e["toID"] == "n3" for e in edges)
+
+    # Check that dialogue nodes are removed
+    assert not any(n["type"] in {"L", "TA", "YA"} for n in result["nodes"])
+
+
+def test_preprocess_dialog_no_dialogue_nodes():
+    """Test that preprocessing works correctly when there are no dialogue nodes."""
+    original: aif.Graph = {
+        "nodes": [
+            {"nodeID": "n1", "text": "Claim 1", "type": "I", "timestamp": ""},
+            {"nodeID": "n2", "text": "Support", "type": "RA", "timestamp": ""},
+            {"nodeID": "n3", "text": "Claim 2", "type": "I", "timestamp": ""},
+        ],
+        "edges": [
+            {"edgeID": "e1", "fromID": "n1", "toID": "n2", "formEdgeID": None},
+            {"edgeID": "e2", "fromID": "n2", "toID": "n3", "formEdgeID": None},
+        ],
+        "locutions": [],
+    }
+
+    result = preprocess_dialog(original)
+
+    # Should be unchanged
+    assert len(result["nodes"]) == len(original["nodes"])
+    assert len(result["edges"]) == len(original["edges"])
+    assert all(n in result["nodes"] for n in original["nodes"])
+    assert all(e in result["edges"] for e in original["edges"])

arguebuf-2.7.0/src/arguebuf/load/_load_aif.py

@@ -1,106 +0,0 @@
-import typing as t
-
-import pendulum
-
-from arguebuf import dt
-from arguebuf.load._preprocess_aif import process_hanging_nodes
-from arguebuf.model import Graph, utils
-from arguebuf.model.edge import Edge, warn_missing_nodes
-from arguebuf.model.node import AbstractNode, AtomNode, SchemeNode
-from arguebuf.model.scheme import aif2scheme, text2scheme
-from arguebuf.schemas import aif
-
-from ._config import Config, DefaultConfig
-
-__all__ = ("load_aif",)
-
-
-def load_aif(
-    obj: aif.Graph,
-    name: str | None = None,
-    config: Config = DefaultConfig,
-    reconstruct_dialog: bool = False,
-) -> Graph:
-    """Generate Graph structure from AIF argument graph file
-    (reference: http://www.wi2.uni-trier.de/shared/publications/2019_LenzOllingerSahitajBergmann_ICCBR.pdf)
-
-    """
-    g = config.GraphClass(name)
-
-    # Process hanging nodes
-    if reconstruct_dialog:
-        obj = process_hanging_nodes(obj)
-
-    for aif_node in obj["nodes"]:
-        node = (
-            atom_from_aif(aif_node, config)
-            if aif_node["type"] == "I"
-            else scheme_from_aif(aif_node, config)
-        )
-
-        if node:
-            g.add_node(node)
-
-    for aif_edge in obj["edges"]:
-        if edge := edge_from_aif(aif_edge, g.nodes, config):
-            g.add_edge(edge)
-
-    return g
-
-
-def atom_from_aif(obj: aif.Node, config: Config) -> AtomNode:
-    """Generate AtomNode object from AIF Node object."""
-    timestamp = dt.from_format(obj.get("timestamp"), aif.DATE_FORMAT) or pendulum.now()
-
-    return config.AtomNodeClass(
-        id=obj["nodeID"],
-        metadata=config.MetadataClass(timestamp, timestamp),
-        text=utils.parse(obj["text"], config.nlp),
-    )
-
-
-def scheme_from_aif(obj: aif.Node, config: Config) -> SchemeNode | None:
-    """Generate SchemeNode object from AIF Node object."""
-
-    aif_type = obj["type"]
-    aif_scheme: str = obj.get("scheme", obj["text"])
-
-    if aif_type in aif2scheme:
-        scheme = aif2scheme[t.cast(aif.SchemeType, aif_type)]
-
-        # TODO: Handle formatting like capitalization, spaces, underscores, etc.
-        # TODO: Araucaria does not use spaces between scheme names
-        # aif_scheme = re.sub("([A-Z])", r" \1", aif_scheme)
-        if scheme and (found_scheme := text2scheme[type(scheme)].get(aif_scheme)):
-            scheme = found_scheme
-
-        timestamp = (
-            dt.from_format(obj.get("timestamp"), aif.DATE_FORMAT) or pendulum.now()
-        )
-
-        return config.SchemeNodeClass(
-            id=obj["nodeID"],
-            metadata=config.MetadataClass(timestamp, timestamp),
-            scheme=scheme,
-        )
-
-    return None
-
-
-def edge_from_aif(
-    obj: aif.Edge, nodes: t.Mapping[str, AbstractNode], config: Config
-) -> Edge | None:
-    """Generate Edge object from AIF Edge format."""
-    source_id = obj.get("fromID")
-    target_id = obj.get("toID")
-
-    if source_id in nodes and target_id in nodes:
-        return config.EdgeClass(
-            id=obj["edgeID"],
-            source=nodes[source_id],
-            target=nodes[target_id],
-        )
-    else:
-        warn_missing_nodes(obj["edgeID"], source_id, target_id)
-
-    return None

arguebuf-2.7.0/src/arguebuf/load/_preprocess_aif.py

@@ -1,302 +0,0 @@
-from dataclasses import dataclass, field
-
-import pendulum
-
-from arguebuf.model import utils
-from arguebuf.schemas import aif
-
-
-@dataclass(slots=True)
-class NewNode:
-    node_id: str
-    text: str
-    node_type: str
-    timestamp: str
-    incoming_edges: list[aif.Edge] = field(default_factory=list)
-    outgoing_edges: list[aif.Edge] = field(default_factory=list)
-
-    def add_incoming_edge(self, edge: aif.Edge):
-        self.incoming_edges.append(edge)
-
-    def add_outgoing_edge(self, edge: aif.Edge):
-        self.outgoing_edges.append(edge)
-
-
-def get_connected_nodes_of_type(
-    node: NewNode, node_type: str, allnodes: dict[str, NewNode]
-) -> list[NewNode]:
-    """Returns a list of nodes connected to the given node (either incoming or outgoing) of a specific type."""
-    connected_node_ids = [edge["fromID"] for edge in node.incoming_edges] + [
-        edge["toID"] for edge in node.outgoing_edges
-    ]
-    return [
-        allnodes[node_id]
-        for node_id in connected_node_ids
-        if allnodes[node_id].node_type == node_type
-    ]
-
-
-def get_connected_nodes_excluding_types(
-    node: NewNode, excluded_types: list[str], allnodes: dict[str, NewNode]
-) -> list[NewNode]:
-    """Returns a list of nodes connected to the given node (either incoming or outgoing) excluding specific types."""
-    connected_node_ids = [edge["fromID"] for edge in node.incoming_edges] + [
-        edge["toID"] for edge in node.outgoing_edges
-    ]
-    return [
-        allnodes[node_id]
-        for node_id in connected_node_ids
-        if allnodes[node_id].node_type not in excluded_types
-    ]
-
-
-def are_nodes_connected(node1: NewNode, node2: NewNode) -> bool:
-    """Returns True if node1 and node2 are connected (either node1 to node2 or node2 to node1), otherwise False."""
-    return any(
-        edge["fromID"] == node1.node_id and edge["toID"] == node2.node_id
-        for edge in node1.outgoing_edges
-    ) or any(
-        edge["fromID"] == node2.node_id and edge["toID"] == node1.node_id
-        for edge in node2.outgoing_edges
-    )
-
-
-def remove_loops_in_hanging_nodes(
-    hanging_nodes: list[NewNode], obj: aif.Graph, allnodes: dict[str, NewNode]
-) -> None:
-    """
-    Removes loops in the graph that are formed specifically by connecting hanging nodes.
-    Steps:
-    1) For each hanging node, examine any outgoing edge.
-    2) Trace each outgoing edge to its destination argument node.
-    If the destination is not in the list of hanging nodes, the function returns without making changes.
-    3) If the destination is a hanging node,
-    search for and identify any outgoing edge from this node that leads back to the initial hanging node.
-    4) Upon finding such a loop, delete the path that forms the loop.
-
-     Loop Structure, 2nd Rephrase Node needs to be removed:
-    <HangingNode_1> --<Rephrase>--> <HangingNode_2> --<Rephrase>--> <HangingNode_1>
-    """
-    hanging_node_ids = {node.node_id for node in hanging_nodes}
-
-    for hanging_node in hanging_nodes:
-        for edge in hanging_node.outgoing_edges:
-            target_node_id = edge["toID"]
-
-            # Check if the target node is also a hanging node
-            if target_node_id in hanging_node_ids:
-                # Loop detected, remove the edge and the associated rephrase node
-                rephrase_node_id = edge["fromID"]
-
-                # Remove the edge and rephrase node from obj
-                obj["edges"] = [
-                    e for e in obj["edges"] if e["edgeID"] != edge["edgeID"]
-                ]
-                obj["nodes"] = [
-                    n for n in obj["nodes"] if n["nodeID"] != rephrase_node_id
-                ]
-
-                # Update the nodes dictionary
-                if rephrase_node_id in allnodes:
-                    del allnodes[rephrase_node_id]
-
-                # Update the hanging_node's outgoing edges
-                hanging_node.outgoing_edges = [
-                    e
-                    for e in hanging_node.outgoing_edges
-                    if e["edgeID"] != edge["edgeID"]
-                ]
-                break  # Break after removing the loop for this hanging node
-
-
-def process_each_hanging_node(
-    hanging_nodes: list[NewNode],
-    obj: aif.Graph,
-    allnodes: dict[str, NewNode],
-    updated_hanging_nodes: list[NewNode],
-) -> aif.Graph:
-    """
-    Finds and connects plausible connected Nodes based on specific criteria related to dialogues and transitions.
-
-    The process involves several steps:
-    1) Navigate back to a Dialog Node, e.g., "Chris Philp: <text>", through the only connected "Asserting" Node, and save the speaker's name.
-    2) Move to the one or two directly connected "Default Transition" Nodes, considering both ingoing and outgoing connections.
-    3) For each "Default Transition" Node, navigate to the directly connected Dialog Node and check if the speaker's name is similar.
-    4) If the speaker's name matches, proceed from this Dialog Node to the next connected Node (e.g., "Asserting" or another type),
-    excluding "Default Transition" Nodes.
-    5) From the new node, such as an "Asserting" Node, move to another Argument Node, for example, "Mrs. X thinks that Y is good."
-    6) Verify if this Argument Node has a connection (either incoming or outgoing) from the hanging_node. If there is no such connection, create one.
-
-    Rough graph structure example:
-
-                                             ---DefaultTransition--> <DialogNode> ---<Assert>--> <ArgumentNode>
-    <HangingNode> <--<Assert>-- <DialogNode>
-                                             <--DefaultTransition--- <DialogNode> ---<Assert>--> <ArgumentNode>
-
-    """
-
-    # 1)
-    # Iterate over hanging nodes
-    # all generated "Rephrase" Nodes should have the same datetime to filter them out for postprocessing
-    similar_datetime = pendulum.now().format(aif.DATE_FORMAT)
-    for hanging_node in hanging_nodes:
-        # Check if the hanging node has exactly one incoming edge
-        if len(hanging_node.incoming_edges) == 1:
-            # Get the ID of the connected node (Asserting node)
-            asserting_node_id = hanging_node.incoming_edges[0]["fromID"]
-            asserting_node = allnodes.get(asserting_node_id)
-
-            # Ensure the asserting node exists and follow its incoming edge
-            if asserting_node and len(asserting_node.incoming_edges) == 1:
-                # Get the ID of the next node (should be of type "L")
-                l_node_id = asserting_node.incoming_edges[0]["fromID"]
-                l_node = allnodes.get(l_node_id)
-
-                # Check if the node is of type "L" and process the speaker's name
-                if l_node and l_node.node_type == "L":
-                    speaker_name = l_node.text.split(" :", 1)[
-                        0
-                    ]  # Extracting speaker's name
-                    speakerNode = l_node  # Save the original speaker's node
-
-                    # 2) + 3)
-                    # Find connected "Default Transition" nodes of type "TA"
-                    default_transition_nodes = get_connected_nodes_of_type(
-                        l_node, "TA", allnodes
-                    )
-
-                    # For each "Default Transition" node, find connected "L" nodes and check if the speaker name is =
-                    for dt_node in default_transition_nodes:
-                        connected_dialog_nodes = get_connected_nodes_of_type(
-                            dt_node, "L", allnodes
-                        )
-
-                        # Check if the speaker name aligns in the connected "L" nodes,excluding the original speakerNode
-                        # For each Dialog-Node, find the next connected nodes excluding types "L" and "TA"
-                        for dialog_node in connected_dialog_nodes:
-                            if (
-                                dialog_node.node_id != speakerNode.node_id
-                                and dialog_node.text.startswith(speaker_name + " :")
-                            ):
-                                # 4) + 5)
-                                # Find connecting nodes
-                                connecting_nodes = get_connected_nodes_excluding_types(
-                                    dialog_node, ["L", "TA"], allnodes
-                                )
-
-                                # For each connecting node, find the next Argument-Nodes
-                                for connecting_node in connecting_nodes:
-                                    argument_nodes = (
-                                        get_connected_nodes_excluding_types(
-                                            connecting_node, ["L", "TA"], allnodes
-                                        )
-                                    )
-                                    # 6)
-                                    for (
-                                        argument_node
-                                    ) in argument_nodes:  # datetime für alle gleich
-                                        if not are_nodes_connected(
-                                            hanging_node, argument_node
-                                        ):
-                                            new_node_id = utils.uuid()
-                                            new_node: aif.Node = {
-                                                "nodeID": new_node_id,
-                                                "text": "Default Rephrase",
-                                                "type": "MA",
-                                                "timestamp": similar_datetime,
-                                            }
-                                            obj["nodes"].append(new_node)
-
-                                            # Create edges connecting hanging_node -> new_node and new_node -> ArgumentNode
-                                            new_edge_1_id = utils.uuid()
-                                            new_edge_1: aif.Edge = {
-                                                "edgeID": new_edge_1_id,
-                                                "fromID": hanging_node.node_id,
-                                                "toID": new_node_id,
-                                                "formEdgeID": None,
-                                            }
-                                            obj["edges"].append(new_edge_1)
-
-                                            new_edge_2_id = utils.uuid()
-                                            new_edge_2: aif.Edge = {
-                                                "edgeID": new_edge_2_id,
-                                                "fromID": new_node_id,
-                                                "toID": argument_node.node_id,
-                                                "formEdgeID": None,
-                                            }
-                                            obj["edges"].append(new_edge_2)
-                                            # Update the edges in the copied hanging nodes list
-                                            # Find and update the hanging_node and argument_node in updated_hanging_nodes
-                                            for node in updated_hanging_nodes:
-                                                if node.node_id == hanging_node.node_id:
-                                                    node.outgoing_edges.append(
-                                                        new_edge_1
-                                                    )
-                                                if (
-                                                    node.node_id
-                                                    == argument_node.node_id
-                                                ):
-                                                    node.incoming_edges.append(
-                                                        new_edge_2
-                                                    )
-    # check for loops:
-    remove_loops_in_hanging_nodes(updated_hanging_nodes, obj, allnodes)
-    return obj
-
-
-def create_and_process_nodes(obj: aif.Graph) -> dict[str, NewNode]:
-    """
-    creates and processes all Nodes, so they contain every ingoing/outgoing edge
-    """
-    nodes: dict[str, NewNode] = {}
-    for aif_node in obj["nodes"]:
-        node_id = aif_node["nodeID"]
-        node_text = aif_node.get("text", "")
-        node_type = aif_node.get("type", "")
-        node_timestamp = aif_node.get("timestamp", "")
-        nodes[node_id] = NewNode(node_id, node_text, node_type, node_timestamp)
-
-    # process edges and link them to nodes
-    for aif_edge in obj["edges"]:
-        edge_id = aif_edge["edgeID"]
-        from_id = aif_edge["fromID"]
-        to_id = aif_edge["toID"]
-        edge_data: aif.Edge = {
-            "edgeID": edge_id,
-            "fromID": from_id,
-            "toID": to_id,
-            "formEdgeID": None,
-        }
-
-        if from_id in nodes:
-            nodes[from_id].add_outgoing_edge(edge_data)
-        if to_id in nodes:
-            nodes[to_id].add_incoming_edge(edge_data)
-    return nodes
-
-
-def find_hanging_nodes(allnodes: dict[str, NewNode]) -> list[NewNode]:
-    """
-    Identifies nodes within a graph that have no outgoing edges and exactly one incoming edge, excluding nodes of type "L".
-    Returns:
-        A list of identified hanging nodes
-    """
-    hanging_nodes = [
-        node
-        for node in allnodes.values()
-        if len(node.incoming_edges) == 1
-        and not node.outgoing_edges
-        and node.node_type != "L"
-    ]
-    return hanging_nodes
-
-
-def process_hanging_nodes(obj: aif.Graph) -> aif.Graph:
-    """
-    Finds and connects specific Nodes which aren't connected to other ArgumentNodes yet
-    """
-    allnodes = create_and_process_nodes(obj)
-    hanging_nodes = find_hanging_nodes(allnodes)
-    updated_hanging_nodes = hanging_nodes.copy()
-    obj = process_each_hanging_node(hanging_nodes, obj, allnodes, updated_hanging_nodes)
-    return obj