public virtual void TestEnv()
{
SemanticGraph h = SemanticGraph.ValueOf("[married/VBN nsubjpass>Hughes/NNP auxpass>was/VBD nmod:to>Gracia/NNP]");
h.GetFirstRoot().Set(typeof(PatternsAnnotations.PatternLabel1), "YES");
//SemanticGraph t = SemanticGraph
// .valueOf("[loved/VBD\nnsubj:Hughes/NNP\ndobj:[wife/NN poss:his/PRP$ appos:Gracia/NNP]\nconj_and:[obsessed/JJ\ncop:was/VBD\nadvmod:absolutely/RB\nprep_with:[Elicia/NN poss:his/PRP$ amod:little/JJ nn:daughter/NN]]]");
string macro = "macro WORD = married";
Env env = new Env();
env.Bind("pattern1", typeof(PatternsAnnotations.PatternLabel1));
string pattern = "({pattern1:YES}=parent >>nsubjpass {}=node)";
IList <SemgrexPattern> pats = SemgrexBatchParser.CompileStream(new ByteArrayInputStream(Sharpen.Runtime.GetBytesForString((macro + "\n" + pattern), StandardCharsets.Utf8)), env);
SemgrexPattern pat3 = pats[0];
bool ignoreCase = true;
SemgrexMatcher mat3 = pat3.Matcher(h, ignoreCase);
if (mat3.Find())
{
string parent = mat3.GetNode("parent").Word();
string node = mat3.GetNode("node").Word();
System.Console.Out.WriteLine("Result: parent is " + parent + " and node is " + node);
NUnit.Framework.Assert.AreEqual(parent, "married");
NUnit.Framework.Assert.AreEqual(node, "Hughes");
}
else
{
throw new Exception("failed!");
}
}
public virtual void TestNamedRelation()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{idx:0}=gov >>=foo {idx:3}=dep");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("ate", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:3}=dep <<=foo {idx:0}=gov");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("ate", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("dobj", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:3}=dep <=foo {idx:2}=gov");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:2}=gov >=foo {idx:3}=dep");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public override string ToString(bool hasPrecedence)
{
StringBuilder sb = new StringBuilder();
if (isConj)
{
foreach (SemgrexPattern node in children)
{
sb.Append(node.ToString());
}
}
else
{
sb.Append('[');
for (IEnumerator <SemgrexPattern> iter = children.GetEnumerator(); iter.MoveNext();)
{
SemgrexPattern node = iter.Current;
sb.Append(node.ToString());
if (iter.MoveNext())
{
sb.Append(" |");
}
}
sb.Append(']');
}
return(sb.ToString());
}
public static void RunTest(SemgrexPattern pattern, SemanticGraph graph, params string[] expectedMatches)
{
// results are not in the order I would expect. Using a counter
// allows them to be in any order
IntCounter <string> counts = new IntCounter <string>();
for (int i = 0; i < expectedMatches.Length; ++i)
{
counts.IncrementCount(expectedMatches[i]);
}
IntCounter <string> originalCounts = new IntCounter <string>(counts);
SemgrexMatcher matcher = pattern.Matcher(graph);
for (int i_1 = 0; i_1 < expectedMatches.Length; ++i_1)
{
if (!matcher.Find())
{
throw new AssertionFailedError("Expected " + expectedMatches.Length + " matches for pattern " + pattern + " on " + graph + ", only got " + i_1);
}
string match = matcher.GetMatch().ToString();
if (!counts.ContainsKey(match))
{
throw new AssertionFailedError("Unexpected match " + match + " for pattern " + pattern + " on " + graph);
}
counts.DecrementCount(match);
if (counts.GetCount(match) < 0)
{
throw new AssertionFailedError("Found too many matches for " + match + " for pattern " + pattern + " on " + graph);
}
}
if (matcher.FindNextMatchingNode())
{
throw new AssertionFailedError("Found more than " + expectedMatches.Length + " matches for pattern " + pattern + " on " + graph + "... extra match is " + matcher.GetMatch());
}
}
public static void OutputResults(SemgrexPattern pattern, SemanticGraph graph, params string[] ignored)
{
System.Console.Out.WriteLine("Matching pattern " + pattern + " to\n" + graph + " :" + (pattern.Matcher(graph).Matches() ? "matches" : "doesn't match"));
System.Console.Out.WriteLine();
pattern.PrettyPrint();
System.Console.Out.WriteLine();
SemgrexMatcher matcher = pattern.Matcher(graph);
while (matcher.Find())
{
System.Console.Out.WriteLine(" " + matcher.GetMatch());
ICollection <string> nodeNames = matcher.GetNodeNames();
if (nodeNames != null && nodeNames.Count > 0)
{
foreach (string name in nodeNames)
{
System.Console.Out.WriteLine(" " + name + ": " + matcher.GetNode(name));
}
}
ICollection <string> relNames = matcher.GetRelationNames();
if (relNames != null)
{
foreach (string name in relNames)
{
System.Console.Out.WriteLine(" " + name + ": " + matcher.GetRelnString(name));
}
}
}
}
public static void ComparePatternToString(string pattern)
{
SemgrexPattern semgrex = SemgrexPattern.Compile(pattern);
string tostring = semgrex.ToString();
tostring = tostring.ReplaceAll(" +", " ");
NUnit.Framework.Assert.AreEqual(pattern.Trim(), tostring.Trim());
}
public virtual void TestSerialization()
{
SemgrexPattern pat3 = SemgrexPattern.Compile("({word:LIKE}=parent >>nn {word:/do/}=node)");
File tempfile = File.CreateTempFile("temp", "file");
tempfile.DeleteOnExit();
IOUtils.WriteObjectToFile(pat3, tempfile);
SemgrexPattern pat4 = IOUtils.ReadObjectFromFile(tempfile);
NUnit.Framework.Assert.AreEqual(pat3, pat4);
}
public virtual void TestEqualsRelation()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >> ({}=a == {}=b)");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
// This split pattern should also work
pattern = SemgrexPattern.Compile("{} >> {}=a >> {}=b : {}=a == {}=b");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public virtual void AddRelnToNodeCoord(SemgrexPattern child)
{
if (isNodeCoord)
{
foreach (SemgrexPattern c in children)
{
IList <SemgrexPattern> newChildren = new List <SemgrexPattern>();
Sharpen.Collections.AddAll(newChildren, c.GetChildren());
newChildren.Add(child);
c.SetChild(new Edu.Stanford.Nlp.Semgraph.Semgrex.CoordinationPattern(false, newChildren, true));
}
}
}
internal override void SetChild(SemgrexPattern child)
{
if (isNodeCoord)
{
foreach (object c in children)
{
if (c is NodePattern)
{
((NodePattern)c).SetChild(child);
}
}
}
}
public virtual void TestMatchAll()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
ICollection <IndexedWord> words = graph.VertexSet();
SemgrexPattern pattern = SemgrexPattern.Compile("{}");
SemgrexMatcher matcher = pattern.Matcher(graph);
string[] expectedMatches = new string[] { "ate", "Bill", "muffins", "blueberry" };
for (int i = 0; i < expectedMatches.Length; ++i)
{
NUnit.Framework.Assert.IsTrue(matcher.FindNextMatchingNode());
}
NUnit.Framework.Assert.IsFalse(matcher.FindNextMatchingNode());
}
public CoordinationMatcher(CoordinationPattern c, SemanticGraph sg, Alignment alignment, SemanticGraph sg_align, bool hypToText, IndexedWord n, IDictionary <string, IndexedWord> namesToNodes, IDictionary <string, string> namesToRelations, VariableStrings
variableStrings, bool ignoreCase)
: base(sg, alignment, sg_align, hypToText, n, namesToNodes, namesToRelations, variableStrings)
{
// do all con/dis-juncts have to be considered to determine a match?
// i.e. true if conj and not negated or disj and negated
myNode = c;
children = new SemgrexMatcher[myNode.children.Count];
for (int i = 0; i < children.Length; i++)
{
SemgrexPattern node = myNode.children[i];
children[i] = node.Matcher(sg, alignment, sg_align, hypToText, n, namesToNodes, namesToRelations, variableStrings, ignoreCase);
}
currChild = 0;
considerAll = myNode.isConj ^ myNode.IsNegated();
}
public virtual void TestExactDepthRelations()
{
SemanticGraph graph = MakeComplicatedGraph();
RunTest("{} 2,3<< {word:A}", graph, "E", "F", "G", "I");
RunTest("{} 2,2<< {word:A}", graph, "E");
RunTest("{} 1,2<< {word:A}", graph, "B", "C", "D", "E");
RunTest("{} 0,2<< {word:A}", graph, "B", "C", "D", "E");
RunTest("{} 0,10<< {word:A}", graph, "B", "C", "D", "E", "F", "G", "H", "I", "J");
RunTest("{} 0,10>> {word:J}", graph, "A", "B", "C", "D", "E", "F", "G", "H", "I");
RunTest("{} 2,3>> {word:J}", graph, "B", "C", "D", "E", "F", "G", "H");
RunTest("{} 2,2>> {word:J}", graph, "E", "H");
// use this method to avoid the toString() test, since we expect it
// to use 2,2>> instead of 2>>
RunTest(SemgrexPattern.Compile("{} 2>> {word:J}"), graph, "E", "H");
RunTest("{} 1,2>> {word:J}", graph, "E", "H", "I");
}
public virtual void TestPrettyPrint()
{
// SemgrexPattern pat = SemgrexPattern.compile("{} >sub {} & ?>ss {w:w}");
// SemgrexPattern pat =
// SemgrexPattern.compile("({} </nsubj|agent/ {pos:/VB.*/}=hypVerb) @ ({#} </nsubj|agent/ {pos:/VB.*/}=txtVerb)");
// SemgrexPattern pat =
// SemgrexPattern.compile("({sentIndex:4} <=hypReln {sentIndex:2}=hypGov) @ ({} <=hypReln ({} >conj_and ({} @ {}=hypGov)))");
SemgrexPattern pat = SemgrexPattern.Compile("({}=partnerOne [[<prep_to ({word:/married/} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>/nn|appos/ {lemma:/wife|husband/} >poss ({}=txtPartner @ {}=partnerTwo)] | [<poss (({}=txtPartner @ {}=partnerTwo) >/appos|nn/ {lemma:/wife|husband/})]])"
);
// SemgrexPattern pat =
// SemgrexPattern.compile("({pos:/VB.*/}=hVerb @ {pos:/VB.*/}=tVerb) >/nsubj|nsubjpass|dobj|iobj|prep.*/=hReln ({}=hWord @ ({}=tWord [ [ >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb] | [ >appos ({} >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb) ] | [ <appos ({} >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb)] | ![> {}=tVerb]]))");
// SemgrexPattern pat =
// SemgrexPattern.compile("({}=partnerOne [[<prep_to ({word:married} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>nn {lemma:/wife|husband/} >poss {}=txtPartner] | [<poss ({}=txtPartner >nn {lemma:/wife|husband/})]])");
// @ ({} </nsubj|agent/ {pos:/VB.*/}=txtVerb)
pat.PrettyPrint();
}
public virtual void TestNamedNode()
{
SemanticGraph graph = MakeComplicatedGraph();
RunTest("{} >dobj ({} >expl {})", graph, "A");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo)");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod {}");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} >mark {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} > {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} > {}=foo)");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({}=foo > {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public virtual void TestInitialConditions()
{
SemanticGraph graph = MakeComplicatedGraph();
SemgrexPattern pattern = SemgrexPattern.Compile("{}=a >> {}=b : {}=a >> {}=c");
IDictionary <string, IndexedWord> variables = new Dictionary <string, IndexedWord>();
variables["b"] = graph.GetNodeByIndex(5);
variables["c"] = graph.GetNodeByIndex(2);
SemgrexMatcher matcher = pattern.Matcher(graph, variables);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(3, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("A", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.AreEqual("B", matcher.GetNode("c").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
/// <exception cref="System.IO.IOException"/>
private static IList <SemgrexPattern> Parse(BufferedReader reader, IDictionary <string, string> macros, Env env)
{
IList <SemgrexPattern> patterns = new List <SemgrexPattern>();
for (string line; (line = reader.ReadLine()) != null;)
{
line = line.Trim();
if (line.IsEmpty() || line.StartsWith("#"))
{
continue;
}
if (line.StartsWith("macro "))
{
continue;
}
line = ReplaceMacros(line, macros);
SemgrexPattern pattern = SemgrexPattern.Compile(line, env);
patterns.Add(pattern);
}
return(patterns);
}
public virtual void TestMacro()
{
SemanticGraph h = SemanticGraph.ValueOf("[married/VBN nsubjpass>Hughes/NNP auxpass>was/VBD nmod:to>Gracia/NNP]");
string macro = "macro WORD = married";
string pattern = "({word:${WORD}}=parent >>nsubjpass {}=node)";
IList <SemgrexPattern> pats = SemgrexBatchParser.CompileStream(new ByteArrayInputStream(Sharpen.Runtime.GetBytesForString((macro + "\n" + pattern), StandardCharsets.Utf8)));
SemgrexPattern pat3 = pats[0];
bool ignoreCase = true;
SemgrexMatcher mat3 = pat3.Matcher(h, ignoreCase);
if (mat3.Find())
{
string parent = mat3.GetNode("parent").Word();
string node = mat3.GetNode("node").Word();
System.Console.Out.WriteLine("Result: parent is " + parent + " and node is " + node);
NUnit.Framework.Assert.AreEqual(parent, "married");
NUnit.Framework.Assert.AreEqual(node, "Hughes");
}
else
{
throw new Exception("failed!");
}
}
public virtual void TestSiblingPatterns()
{
SemanticGraph sg = SemanticGraph.ValueOf("[loved/VBD-2\nnsubj>Hughes/NNP-1\ndobj>[wife/NN-4 nmod:poss>his/PRP$-3 appos>Gracia/NNP-5]\nconj:and>[obsessed/JJ-9\ncop>was/VBD-7\nadvmod>absolutely/RB-8\nnmod:with>[Elicia/NN-14 nmod:poss>his/PRP$-11 amod>little/JJ-12 compound>daughter/NN-13]]]"
);
/* Test "." */
SemgrexPattern pat1 = SemgrexPattern.Compile("{tag:NNP}=w1 . {tag:VBD}=w2");
SemgrexMatcher matcher = pat1.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("Hughes", w1);
NUnit.Framework.Assert.AreEqual("loved", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$+" */
SemgrexPattern pat2 = SemgrexPattern.Compile("{word:was}=w1 $+ {}=w2");
matcher = pat2.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("was", w1);
NUnit.Framework.Assert.AreEqual("absolutely", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$-" */
SemgrexPattern pat3 = SemgrexPattern.Compile("{word:absolutely}=w1 $- {}=w2");
matcher = pat3.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("absolutely", w1);
NUnit.Framework.Assert.AreEqual("was", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$++" */
SemgrexPattern pat4 = SemgrexPattern.Compile("{word:his}=w1 $++ {tag:NN}=w2");
matcher = pat4.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("his", w1);
NUnit.Framework.Assert.AreEqual("daughter", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$--" */
SemgrexPattern pat6 = SemgrexPattern.Compile("{word:daughter}=w1 $-- {tag:/PRP./}=w2");
matcher = pat6.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("daughter", w1);
NUnit.Framework.Assert.AreEqual("his", w2);
}
else
{
throw new Exception("failed!");
}
/* Test for not matching. */
SemgrexPattern pat5 = SemgrexPattern.Compile("{word:his}=w1 $-- {}=w2");
matcher = pat5.Matcher(sg);
if (matcher.Find())
{
throw new Exception("failed!");
}
/* Test for negation. */
SemgrexPattern pat7 = SemgrexPattern.Compile("{word:his}=w1 !$-- {}");
matcher = pat7.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
NUnit.Framework.Assert.AreEqual("his", w1);
}
else
{
throw new Exception("failed!");
}
SemgrexPattern pat8 = SemgrexPattern.Compile("{word:his}=w1 !$++ {}");
matcher = pat8.Matcher(sg);
if (matcher.Find())
{
throw new Exception("failed!");
}
}
public virtual void TestFind()
{
SemanticGraph h = SemanticGraph.ValueOf("[married/VBN nsubjpass>Hughes/NNP auxpass>was/VBD prep_to>Gracia/NNP]");
SemanticGraph t = SemanticGraph.ValueOf("[loved/VBD\nnsubj>Hughes/NNP\ndobj>[wife/NN poss>his/PRP$ appos>Gracia/NNP]\nconj_and>[obsessed/JJ\ncop>was/VBD\nadvmod>absolutely/RB\nprep_with>[Elicia/NN poss>his/PRP$ amod>little/JJ compound>daughter/NN]]]"
);
string s = "(ROOT\n(S\n(NP (DT The) (NN chimney) (NNS sweeps))\n(VP (VBP do) (RB not)\n(VP (VB like)\n(S\n(VP (VBG working)\n(PP (IN on)\n(NP (DT an) (JJ empty) (NN stomach)))))))\n(. .)))";
Tree tree = Tree.ValueOf(s);
SemanticGraph sg = SemanticGraphFactory.MakeFromTree(tree, SemanticGraphFactory.Mode.Collapsed, GrammaticalStructure.Extras.Maximal, null);
SemgrexPattern pat = SemgrexPattern.Compile("{}=gov ![>det {}] & > {word:/^(?!not).*$/}=dep");
sg.PrettyPrint();
// SemgrexPattern pat =
// SemgrexPattern.compile("{} [[<prep_to ({word:married} >nsubjpass {})] | [<nsubjpass ({word:married} >prep_to {})]]");
pat.PrettyPrint();
SemgrexMatcher mat = pat.Matcher(sg);
while (mat.Find())
{
// String match = mat.getMatch().word();
string gov = mat.GetNode("gov").Word();
// String reln = mat.getRelnString("reln");
string dep = mat.GetNode("dep").Word();
// System.out.println(match);
System.Console.Out.WriteLine(dep + ' ' + gov);
}
SemgrexPattern pat2 = SemgrexPattern.Compile("{} [[>/nn|appos/ ({lemma:/wife|husband|partner/} >/poss/ {}=txtPartner)] | [<poss ({}=txtPartner >/nn|appos/ {lemma:/wife|husband|partner/})]" + "| [<nsubj ({$} >> ({word:/wife|husband|partner/} >poss {word:/his|her/} >/nn|appos/ {}))]]"
);
SemgrexMatcher mat2 = pat2.Matcher(t);
while (mat2.Find())
{
string match = mat2.GetMatch().Word();
// String gov = mat.getNode("gov").word();
// String reln = mat.getRelnString("reln");
// String dep = mat.getNode("dep").word();
System.Console.Out.WriteLine(match);
}
// System.out.println(dep + " " + gov);
Dictionary <IndexedWord, IndexedWord> map = new Dictionary <IndexedWord, IndexedWord>();
map[h.GetNodeByWordPattern("Hughes")] = t.GetNodeByWordPattern("Hughes");
map[h.GetNodeByWordPattern("Gracia")] = t.GetNodeByWordPattern("Gracia");
Alignment alignment = new Alignment(map, 0, string.Empty);
SemgrexPattern fullPat = SemgrexPattern.Compile("({}=partnerOne [[<prep_to ({word:married} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>/nn|appos/ ({lemma:/wife|husband|partner/} >/poss/ {}=txtPartner)] | [<poss ({}=txtPartner >/nn|appos/ {lemma:/wife|husband|partner/})]"
+ "| [<nsubj ({$} >> ({word:/wife|husband|partner/} >poss {word:/his|her/} >/nn|appos/ {}=txtPartner))]])");
fullPat.PrettyPrint();
SemgrexMatcher fullMat = fullPat.Matcher(h, alignment, t);
if (fullMat.Find())
{
System.Console.Out.WriteLine("woo: " + fullMat.GetMatch().Word());
System.Console.Out.WriteLine(fullMat.GetNode("txtPartner"));
System.Console.Out.WriteLine(fullMat.GetNode("partnerOne"));
System.Console.Out.WriteLine(fullMat.GetNode("partnerTwo"));
}
else
{
System.Console.Out.WriteLine("boo");
}
SemgrexPattern pat3 = SemgrexPattern.Compile("({word:LIKE}=parent >>/aux.*/ {word:/do/}=node)");
System.Console.Out.WriteLine("pattern is ");
pat3.PrettyPrint();
System.Console.Out.WriteLine("tree is ");
sg.PrettyPrint();
//checking if ignoring case or not
SemgrexMatcher mat3 = pat3.Matcher(sg, true);
if (mat3.Find())
{
string parent = mat3.GetNode("parent").Word();
string node = mat3.GetNode("node").Word();
System.Console.Out.WriteLine("Result: parent is " + parent + " and node is " + node);
NUnit.Framework.Assert.AreEqual(parent, "like");
NUnit.Framework.Assert.AreEqual(node, "do");
}
else
{
NUnit.Framework.Assert.Fail();
}
}
public static void RunTest(string pattern, SemanticGraph graph, params string[] expectedMatches)
{
ComparePatternToString(pattern);
RunTest(SemgrexPattern.Compile(pattern), graph, expectedMatches);
}
internal override void SetChild(SemgrexPattern n)
{
child = n;
}
public static void OutputResults(string pattern, SemanticGraph graph, params string[] ignored)
{
OutputResults(SemgrexPattern.Compile(pattern), graph);
}
public NodePattern(GraphRelation r, bool negDesc, IDictionary <string, string> attrs, bool root, bool empty, string name, IList <Pair <int, string> > variableGroups)
{
// specifies the groups in a regex that are captured as
// matcher-global string variables
// TODO: there is no capacity for named variable groups in the parser right now
this.reln = r;
this.negDesc = negDesc;
attributes = Generics.NewHashMap();
descString = "{";
foreach (KeyValuePair <string, string> entry in attrs)
{
if (!descString.Equals("{"))
{
descString += ";";
}
string key = entry.Key;
string value = entry.Value;
// Add the attributes for this key
if (value.Equals("__"))
{
attributes[key] = Pair.MakePair(true, true);
}
else
{
if (value.Matches("/.*/"))
{
bool isRegexp = false;
for (int i = 1; i < value.Length - 1; ++i)
{
char chr = value[i];
if (!((chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z') || (chr >= '0' && chr <= '9')))
{
isRegexp = true;
break;
}
}
string patternContent = Sharpen.Runtime.Substring(value, 1, value.Length - 1);
if (isRegexp)
{
attributes[key] = Pair.MakePair(Pattern.Compile(patternContent), Pattern.Compile(patternContent, Pattern.CaseInsensitive | Pattern.UnicodeCase));
}
else
{
attributes[key] = Pair.MakePair(patternContent, patternContent);
}
}
else
{
// raw description
attributes[key] = Pair.MakePair(value, value);
}
}
// if (value.equals("__")) {
// attributes.put(key, Pair.makePair(Pattern.compile(".*"), Pattern.compile(".*", Pattern.CASE_INSENSITIVE)));
// } else if (value.matches("/.*/")) {
// attributes.put(key, Pair.makePair(
// Pattern.compile(value.substring(1, value.length() - 1)),
// Pattern.compile(value.substring(1, value.length() - 1), Pattern.CASE_INSENSITIVE))
// );
// } else { // raw description
// attributes.put(key, Pair.makePair(
// Pattern.compile("^(" + value + ")$"),
// Pattern.compile("^(" + value + ")$", Pattern.CASE_INSENSITIVE))
// );
// }
descString += (key + ':' + value);
}
if (root)
{
descString += "$";
}
else
{
if (empty)
{
descString += "#";
}
}
descString += '}';
this.name = name;
this.child = null;
this.isRoot = root;
this.isEmpty = empty;
this.variableGroups = variableGroups;
}
/// <exception cref="Edu.Stanford.Nlp.Semgraph.Semgrex.ParseException"/>
public SemgrexPattern SubNode(GraphRelation r)
{
SemgrexPattern result = null;
SemgrexPattern child = null;
switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
{
case 13:
{
Jj_consume_token(13);
result = SubNode(r);
Jj_consume_token(14);
switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
{
case SemgrexParserConstantsConstants.Relation:
case SemgrexParserConstantsConstants.Alignreln:
case SemgrexParserConstantsConstants.Identifier:
case 17:
case 18:
case 19:
{
child = RelationDisj();
break;
}
default:
{
jj_la1[2] = jj_gen;
break;
}
}
if (child != null)
{
IList <SemgrexPattern> newChildren = new List <SemgrexPattern>();
Sharpen.Collections.AddAll(newChildren, result.GetChildren());
newChildren.Add(child);
result.SetChild(new CoordinationPattern(false, newChildren, true));
}
if (true)
{
return(result);
}
break;
}
case 17:
case 19:
case 23:
{
result = ModNode(r);
switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
{
case SemgrexParserConstantsConstants.Relation:
case SemgrexParserConstantsConstants.Alignreln:
case SemgrexParserConstantsConstants.Identifier:
case 17:
case 18:
case 19:
{
child = RelationDisj();
break;
}
default:
{
jj_la1[3] = jj_gen;
break;
}
}
if (child != null)
{
result.SetChild(child);
}
if (true)
{
return(result);
}
break;
}
default:
{
jj_la1[4] = jj_gen;
Jj_consume_token(-1);
throw new ParseException();
}
}
throw new Exception("Missing return statement in function");
}
public virtual void TestNotEquals()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >> {}=a >> {}=b : {}=a !== {}=b");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
// same as the first test, essentially, but with a more compact expression
pattern = SemgrexPattern.Compile("{} >> {}=a >> ({}=b !== {}=a)");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}