def test_mention_get_context(self):
self.assertEqual(
["laid", "plans"], Mention.from_document(Span(21, 27), self.date_mention_document).get_context(2)
)
self.assertEqual(None, Mention.from_document(Span(21, 27), self.date_mention_document).get_context(0))
self.assertEqual(["through"], Mention.from_document(Span(31, 32), self.date_mention_document).get_context(-1))
self.assertEqual(None, Mention.from_document(Span(21, 27), self.date_mention_document).get_context(1000))
def test_not_embedding(self):
self.assertEqual(
True,
features.not_embedding(
Mention(None, Span(3, 3), {
"tokens": ["it"],
"type": "PRO",
"fine_type": "PERS"
}),
Mention(
None, Span(0, 4), {
"tokens": ["the", "company", "which", "it", "bought"],
"type": "NOM"
})))
self.assertEqual(
False,
features.not_embedding(
Mention(None, Span(3, 3), {
"tokens": ["its"],
"type": "PRO",
"fine_type": "POSS_ADJ"
}),
Mention(
None, Span(0, 4), {
"tokens":
["the", "company", "which", "loves", "its", "success"],
"type":
"NOM"
})))
def test_mention_type(self):
self.assertEqual(
"NAM",
Mention.from_document(
Span(37, 37),
self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(
Span(11, 12),
self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(
Span(31, 32),
self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(
Span(8, 8),
self.date_mention_document).attributes["type"])
self.assertEqual(
"NOM",
Mention.from_document(
Span(33, 34),
self.real_document).attributes["type"])
def test_mention_tokens(self):
expected = ["the", "massacre"]
self.assertEqual(expected, Mention.from_document(Span(33, 34), self.real_document).attributes["tokens"])
expected = "the massacre"
self.assertEqual(
expected, Mention.from_document(Span(33, 34), self.real_document).attributes["tokens_as_lowercase_string"]
)
def test_mention_set_id(self):
self.assertEqual(0, Mention.from_document(Span(33, 34), self.real_document).attributes["annotated_set_id"])
self.assertEqual(
4, Mention.from_document(Span(6, 10), self.complicated_mention_document).attributes["annotated_set_id"]
)
self.assertEqual(
1, Mention.from_document(Span(3, 3), self.complicated_mention_document).attributes["annotated_set_id"]
)
def test_mention_get_sentence_id(self):
self.assertEqual(
0,
Mention.from_document(Span(
13, 20), self.real_document).attributes["sentence_id"])
self.assertEqual(
1,
Mention.from_document(Span(
33, 34), self.real_document).attributes["sentence_id"])
def test_mention_get_fine_type(self):
self.assertEqual("DEF", Mention.from_document(Span(33, 34), self.real_document).attributes["fine_type"])
self.assertEqual("DEF", Mention.from_document(Span(21, 27), self.date_mention_document).attributes["fine_type"])
self.assertEqual(
"INDEF", Mention.from_document(Span(22, 22), self.date_mention_document).attributes["fine_type"]
)
self.assertEqual(
"POSS_ADJ", Mention.from_document(Span(45, 45), self.date_mention_document).attributes["fine_type"]
)
def test_mention_get_sentence_id(self):
self.assertEqual(
0,
Mention.from_document(
Span(13, 20),
self.real_document).attributes["sentence_id"])
self.assertEqual(
1,
Mention.from_document(
Span(33, 34),
self.real_document).attributes["sentence_id"])
def test_mention_get_head(self):
expected = ["massacre"]
self.assertEqual(expected, Mention.from_document(Span(33, 34), self.real_document).attributes["head"])
expected = ["Wedding"]
self.assertEqual(expected, Mention.from_document(Span(3, 3), self.for_head_document).attributes["head"])
expected = "wedding"
self.assertEqual(
expected, Mention.from_document(Span(3, 3), self.for_head_document).attributes["head_as_lowercase_string"]
)
def test_mention_get_ancestry(self):
expected = "-L-VBN-L-NONE"
self.assertEqual(
expected,
Mention.from_document(Span(11, 11),
self.real_document).attributes["ancestry"])
expected = "-R-NNS-R-VBN"
self.assertEqual(
expected,
Mention.from_document(Span(0, 0),
self.real_document).attributes["ancestry"])
def test_mention_tokens(self):
expected = ["the", "massacre"]
self.assertEqual(
expected,
Mention.from_document(Span(33, 34),
self.real_document).attributes["tokens"])
expected = "the massacre"
self.assertEqual(
expected,
Mention.from_document(
Span(33, 34),
self.real_document).attributes["tokens_as_lowercase_string"])
def test_mention_set_id(self):
self.assertEqual(
0,
Mention.from_document(Span(
33, 34), self.real_document).attributes["annotated_set_id"])
self.assertEqual(
4,
Mention.from_document(Span(6, 10),
self.complicated_mention_document).
attributes["annotated_set_id"])
self.assertEqual(
1,
Mention.from_document(Span(3, 3), self.complicated_mention_document
).attributes["annotated_set_id"])
def test_non_pronominal_string_match(self):
self.assertEqual(
True,
features.non_pronominal_string_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"pos": ["DT", "JJ", "NN", "POS", "NN"],
"type": "NOM"
}),
Mention(
None, Span(5, 7), {
"tokens": ["newly-elect", "leader", "wife"],
"pos": ["JJ", "NN", "NN"],
"type": "NOM"
})))
self.assertEqual(
False,
features.non_pronominal_string_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"pos": ["DT", "JJ", "NN", "POS", "NN"],
"type": "NOM"
}),
Mention(None, Span(5, 5), {
"tokens": ["leader"],
"pos": ["NN"],
"type": "NOM"
})))
self.assertEqual(
True,
features.non_pronominal_string_match(
Mention(None, Span(0, 0), {
"tokens": ["President"],
"pos": ["NNP"],
"type": "NAM"
}),
Mention(
None, Span(1, 2), {
"tokens": ["the", "president"],
"pos": ["DT", "NN"],
"type": "NOM"
})))
self.assertEqual(
False,
features.non_pronominal_string_match(
Mention(None, Span(0, 0), {
"tokens": ["it"],
"pos": ["PRP"],
"type": "PRO"
}),
Mention(None, Span(1, 1), {
"tokens": ["IT"],
"pos": ["NNP"],
"type": "NAM"
})))
def test_mention_get_context(self):
self.assertEqual(
["laid", "plans"],
Mention.from_document(Span(21, 27),
self.date_mention_document).get_context(2))
self.assertEqual(
None,
Mention.from_document(Span(21, 27),
self.date_mention_document).get_context(0))
self.assertEqual(
["through"],
Mention.from_document(Span(31, 32),
self.date_mention_document).get_context(-1))
self.assertEqual(
None,
Mention.from_document(Span(
21, 27), self.date_mention_document).get_context(1000))
def test_mention_get_fine_type(self):
self.assertEqual(
"DEF",
Mention.from_document(Span(33, 34),
self.real_document).attributes["fine_type"])
self.assertEqual(
"DEF",
Mention.from_document(Span(
21, 27), self.date_mention_document).attributes["fine_type"])
self.assertEqual(
"INDEF",
Mention.from_document(Span(
22, 22), self.date_mention_document).attributes["fine_type"])
self.assertEqual(
"POSS_ADJ",
Mention.from_document(Span(
45, 45), self.date_mention_document).attributes["fine_type"])
def test_mention_get_head(self):
expected = ["massacre"]
self.assertEqual(
expected,
Mention.from_document(Span(33, 34),
self.real_document).attributes["head"])
expected = ["Wedding"]
self.assertEqual(
expected,
Mention.from_document(Span(3, 3),
self.for_head_document).attributes["head"])
expected = "wedding"
self.assertEqual(
expected,
Mention.from_document(
Span(3, 3),
self.for_head_document).attributes["head_as_lowercase_string"])
def test_mention_type(self):
self.assertEqual(
"NAM",
Mention.from_document(Span(
37, 37), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
11, 12), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
31, 32), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
8, 8), self.date_mention_document).attributes["type"])
self.assertEqual(
"NOM",
Mention.from_document(Span(33, 34),
self.real_document).attributes["type"])
def test_get_modifiers(self):
self.assertEqual(
set(["long-awaited", "new", "century"]),
features.get_modifier(
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
})))
def test_alias(self):
self.assertEqual(
False,
features.alias(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
False,
features.alias(
Mention(
None, Span(0, 2), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
}),
Mention(
None, Span(3, 5), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
})))
self.assertEqual(
True,
features.alias(
Mention(
None, Span(0, 2), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
}),
Mention(
None, Span(3, 3), {
"head": ["IBM"],
"type": "NAM",
"ner": ["ORG"],
"head_index": 0
})))
def test_pronoun_same_canonical_form(self):
self.assertEqual(
True,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
True,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["him"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
False,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["US"],
"type": "NAM"
}), Mention(None, Span(1, 1), {
"tokens": ["us"],
"type": "PRO"
})))
def test_get_string_representation(self):
expected = """#begin document (/test2); part 000
test2 0 0 This NN (NP* - - - - - (0|(1)
test2 0 1 is NN * - - - - - 0)
test2 0 2 just NN * - - - - - -
test2 0 3 a NN * - - - - - -
test2 0 4 test NN * - - - - - (1
test2 0 5 . NN *) - - - - - (2|1)
test2 0 0 It NN (NP* - - - - - 2)
test2 0 1 shows NN * - - - - - (3)
test2 0 2 that NN * - - - - - (3)
test2 0 3 the NN * - - - - - -
test2 0 4 scorer NN * - - - - - -
test2 0 5 works NN * - - - - - -
test2 0 6 . NN *) - - - - - -
#end document
"""
self.complicated_mention_document.system_mentions = [
Mention(self.complicated_mention_document, Span(0, 0),
{"set_id": 1}),
Mention(self.complicated_mention_document, Span(0, 1),
{"set_id": 0}),
Mention(self.complicated_mention_document, Span(4, 5),
{"set_id": 1}),
Mention(self.complicated_mention_document, Span(5, 6),
{"set_id": 2}),
Mention(self.complicated_mention_document, Span(7, 7),
{"set_id": 3}),
Mention(self.complicated_mention_document, Span(8, 8),
{"set_id": 3}),
]
self.assertEqual(
expected,
self.complicated_mention_document.get_string_representation())
def test_not_speaker(self):
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "foo"
}),
))
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["us"],
"type": "PRO",
"citation_form": "we",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["we"],
"type": "PRO",
"citation_form": "we",
"speaker": "foo"
}),
))
self.assertEqual(
False,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["you"],
"type": "PRO",
"citation_form": "you",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "foo"
}),
))
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["you"],
"type": "PRO",
"citation_form": "you",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "snafu"
}),
))
def test_not_pronoun_distance(self):
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he",
"sentence_id": 10
}),
Mention(
None, Span(100, 100), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he",
"sentence_id": 0
})))
self.assertEqual(
True,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["it"],
"type": "PRO",
"citation_form": "it",
"sentence_id": 10
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["them"],
"type": "PRO",
"citation_form": "they",
"sentence_id": 10
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["them"],
"type": "PRO",
"citation_form": "they",
"sentence_id": 1
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
def test_mention_get_ancestry(self):
expected = "-L-VBN-L-NONE"
self.assertEqual(expected, Mention.from_document(Span(11, 11), self.real_document).attributes["ancestry"])
expected = "-R-NNS-R-VBN"
self.assertEqual(expected, Mention.from_document(Span(0, 0), self.real_document).attributes["ancestry"])
def test_mention_get_governor(self):
expected = "massacred"
self.assertEqual(expected, Mention.from_document(Span(0, 1), self.real_document).attributes["governor"])
def test_mention_get_head_span(self):
self.assertEqual(
Span(9, 10),
Mention.from_document(Span(
8, 10), self.for_head_document).attributes["head_span"])
def test_not_compatible(self):
self.assertEqual(
True,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["she"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "FEMALE",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["slawabu"],
"pos": ["NN"],
"type": "NOM",
"number": "UNKNOWN",
"gender": "UNKNOWN",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["Jesus"],
"pos": ["NNP"],
"type": "NAM",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["Jesus"],
"pos": ["NNP"],
"type": "NAM",
"number": "SINGULAR",
"gender": "UNKNOWN",
"semantic_class": "NORP"
})))
def test_mention_get_head_span(self):
self.assertEqual(
Span(9, 10), Mention.from_document(Span(8, 10), self.for_head_document).attributes["head_span"]
)
def test_not_modifier(self):
self.assertEqual(
True,
features.not_modifier(
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"type":
"NOM",
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
}),
Mention(
None, Span(0, 1), {
"tokens": ["the", "beginning"],
"type": "NOM",
"head_span": Span(1, 1),
"pos": ["DT", "NN"]
})))
self.assertEqual(
False,
features.not_modifier(
Mention(
None, Span(18, 19), {
"tokens": ["the", "beginning"],
"type": "NOM",
"head_span": Span(19, 19),
"pos": ["DT", "NN"]
}),
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"type":
"NOM",
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
}),
))
self.assertEqual(
False,
features.not_modifier(
Mention(
None, Span(18, 19), {
"tokens": ["cool", "people"],
"type": "NOM",
"head_span": Span(19, 19),
"pos": ["JJ", "NNS"]
}),
Mention(
None, Span(10, 11), {
"tokens": ["Cool", "people"],
"type": "NOM",
"head_span": Span(11, 11),
"pos": ["JJ", "NNS"]
}),
))
def test_mention_get_governor(self):
expected = "massacred"
self.assertEqual(
expected,
Mention.from_document(Span(0, 1),
self.real_document).attributes["governor"])
def test_head_match(self):
self.assertEqual(
True,
features.head_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(5, 6), {
"tokens": ["the", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(5, 5), {
"tokens": ["leader"],
"head": ["leader"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
True,
features.head_match(
Mention(
None, Span(0, 0), {
"tokens": ["President"],
"head": ["President"],
"type": "NAM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 2), {
"tokens": ["the", "president"],
"head": ["president"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 0), {
"tokens": ["it"],
"head": ["it"],
"type": "PRO",
"semantic_class": "OBJECT"
}),
Mention(
None, Span(1, 1), {
"tokens": ["it"],
"head": ["it"],
"type": "PRO",
"semantic_class": "OBJECT"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 1), {
"tokens": ["10", "percent"],
"head": ["percent"],
"type": "NOM",
"semantic_class": "NUMERIC"
}),
Mention(
None, Span(2, 3), {
"tokens": ["Some", "percent"],
"head": ["percent"],
"type": "NOM",
"semantic_class": "NUMERIC"
})))
def test_is_coreferent_with(self):
self.assertEqual(
True,
Mention(None, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": 1})))
self.assertEqual(
False,
Mention(None, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": 0})))
self.assertEqual(
False,
Mention(None, Span(0, 0), {
"annotated_set_id": None
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": None})))
self.assertEqual(
True,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(self.complicated_mention_document, Span(3, 4),
{"annotated_set_id": 1})))
self.assertEqual(
False,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": None
}).is_coreferent_with(
Mention(self.complicated_mention_document, Span(3, 4),
{"annotated_set_id": None})))
self.assertEqual(
False,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(self.real_document, Span(13, 20),
{"annotated_set_id": 1})))
