Properly handle a graph of one word (previously caused a crash because there were no Edges from which to extract the roots)

Author: AngledLuffa

itest/src/edu/stanford/nlp/pipeline/CoNLLUReaderITest.java

@@ -451,4 +451,37 @@ public void testReadingNoEnhanced() throws ClassNotFoundException, IOException {
     assertFalse(sentence.containsKey(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class));
   }
 
+  public static final String oneWordPath = String.format("edu/stanford/nlp/pipeline/en-example-oneword.conllu");
+
+  @Test
+  /**
+   * This test checks that the graphs are successfully constructed
+   * when they are only one word big.
+   * (Previously, such a case would throw an error.)
+   */
+  public void testReadingOneWord() throws ClassNotFoundException, IOException {
+    Annotation readInDocument = new CoNLLUReader(new Properties()).readCoNLLUFile(oneWordPath).get(0);
+
+    // this document only has one sentence
+    List<CoreMap> sentences = readInDocument.get(CoreAnnotations.SentencesAnnotation.class);
+    assertEquals(1, sentences.size());
+
+    CoreMap sentence = sentences.get(0);
+
+    // cursory check of the tokens
+    List<CoreLabel> tokens = sentence.get(CoreAnnotations.TokensAnnotation.class);
+    assertEquals(1, tokens.size());
+    assertEquals("...", tokens.get(0).value());
+
+    assertTrue(sentence.containsKey(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class));
+    SemanticGraph graph = sentence.get(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class);
+    assertEquals(0, graph.edgeListSorted().size());
+    assertEquals(1, graph.getRoots().size());
+
+    assertTrue(sentence.containsKey(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class));
+    graph = sentence.get(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class);
+    assertEquals(0, graph.edgeListSorted().size());
+    assertEquals(1, graph.getRoots().size());
+  }
+
 }

src/edu/stanford/nlp/pipeline/CoNLLUReader.java

@@ -554,26 +554,29 @@ public CoreMap convertCoNLLUSentenceToCoreMap(CoNLLUDocument doc, CoNLLUSentence
     boolean hasEnhanced = false;
     // build SemanticGraphEdges for a basic graph
     List<SemanticGraphEdge> graphEdges = new ArrayList<>();
+    List<IndexedWord> graphRoots = new ArrayList<>();
     for (int i = 0; i < lines.size(); i++) {
       List<String> fields = Arrays.asList(lines.get(i).split("\t"));
       // track whether any of these lines signify there is an enhanced graph
       hasEnhanced = hasEnhanced || !fields.get(CoNLLU_EnhancedField).equals("_");
-      // skip the ROOT node
-      if (fields.get(CoNLLU_GovField).equals("0"))
-        continue;
       IndexedWord dependent = graphNodes.get(fields.get(CoNLLU_IndexField));
-      IndexedWord gov = graphNodes.get(fields.get(CoNLLU_GovField));
-      GrammaticalRelation reln = GrammaticalRelation.valueOf(fields.get(CoNLLU_RelnField));
-      graphEdges.add(new SemanticGraphEdge(gov, dependent, reln, 1.0, false));
+      if (fields.get(CoNLLU_GovField).equals("0")) {
+        // no edges for the ROOT node
+        graphRoots.add(dependent);
+      } else {
+        IndexedWord gov = graphNodes.get(fields.get(CoNLLU_GovField));
+        GrammaticalRelation reln = GrammaticalRelation.valueOf(fields.get(CoNLLU_RelnField));
+        graphEdges.add(new SemanticGraphEdge(gov, dependent, reln, 1.0, false));
+      }
     }
     // build SemanticGraph
-    SemanticGraph depParse = SemanticGraphFactory.makeFromEdges(graphEdges);
+    SemanticGraph depParse = SemanticGraphFactory.makeFromEdges(graphEdges, graphRoots);
     // add dependency graph
     sentenceCoreMap.set(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class, depParse);
 
     if (hasEnhanced) {
       List<SemanticGraphEdge> enhancedEdges = new ArrayList<>();
-      List<IndexedWord> roots = new ArrayList<>();
+      List<IndexedWord> enhancedRoots = new ArrayList<>();
 
       List<String> allLines = new ArrayList<>();
       allLines.addAll(lines);
@@ -585,16 +588,15 @@ public CoreMap convertCoNLLUSentenceToCoreMap(CoNLLUDocument doc, CoNLLUSentence
         for (String arc : arcs) {
           String[] arcPieces = arc.split(":", 2);
           if (arcPieces[0].equals("0")) {
-            roots.add(dependent);
+            enhancedRoots.add(dependent);
           } else {
             IndexedWord gov = graphNodes.get(arcPieces[0]);
             GrammaticalRelation reln = GrammaticalRelation.valueOf(arcPieces[1]);
             enhancedEdges.add(new SemanticGraphEdge(gov, dependent, reln, 1.0, false));
           }
         }
       }
-      SemanticGraph enhancedParse = SemanticGraphFactory.makeFromEdges(enhancedEdges);
-      enhancedParse.setRoots(roots);
+      SemanticGraph enhancedParse = SemanticGraphFactory.makeFromEdges(enhancedEdges, enhancedRoots);
       sentenceCoreMap.set(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class, enhancedParse);
     }
 

src/edu/stanford/nlp/semgraph/SemanticGraphFactory.java

@@ -365,6 +365,29 @@ public static SemanticGraph makeFromEdges(Iterable<SemanticGraphEdge> edges) {
     return sg;
   }
 
+  /**
+   * Given a list of edges, attempts to create and return a rooted SemanticGraph.
+   *
+   * TODO: throw Exceptions, or flag warnings on conditions for concern (no root, etc)
+   */
+  public static SemanticGraph makeFromEdges(Iterable<SemanticGraphEdge> edges, Collection<IndexedWord> roots) {
+    // Identify the root(s) of this graph
+    SemanticGraph sg = new SemanticGraph();
+    Collection<IndexedWord> vertices = getVerticesFromEdgeSet(edges);
+    for (IndexedWord vertex : vertices) {
+      sg.addVertex(vertex);
+    }
+    for (IndexedWord vertex : roots) {
+      sg.addVertex(vertex);
+    }
+    for (SemanticGraphEdge edge : edges) {
+      sg.addEdge(edge.getSource(),edge.getTarget(), edge.getRelation(), edge.getWeight(), edge.isExtra());
+    }
+
+    sg.setRoots(roots);
+    return sg;
+  }
+
   /**
    * Given an iterable set of edges, returns the set of  vertices covered by these edges.
    *