def test_Pred_cmp_self(self):
"""
All Pred instances should be equal.
"""
p1 = Pred()
p2 = Pred()
self.assertEqual(p1, p2)
self.assertLessEqual(p1, p2)
self.assertGreaterEqual(p1, p2)
self.assertFalse(p1 < p2)
self.assertFalse(p1 > p2)
self.assertFalse(p1 != p2)
def test_Pred_new(self):
"""
Pred() instances denote underpecified preds,
and should not take any arguments
"""
with self.assertRaises(TypeError):
Pred('name')
def test_Pred_cmp_subclasses(self):
"""
Any Pred instance should be less than instances of subclasses.
"""
p = Pred()
cat = RealPred('cat', 'n', '1')
pron = GPred('pron')
self.assertEqual(p, p)
self.assertEqual(pron, pron)
self.assertEqual(cat, cat)
self.assertNotEqual(p, pron)
self.assertNotEqual(p, cat)
self.assertNotEqual(pron, cat)
self.assertLess(p, pron)
self.assertLess(p, cat)
self.assertLess(pron, cat)
self.assertLessEqual(p, pron)
self.assertLessEqual(p, cat)
self.assertLessEqual(pron, cat)
self.assertGreater(pron, p)
self.assertGreater(cat, p)
self.assertGreater(cat, pron)
self.assertGreaterEqual(pron, p)
self.assertGreaterEqual(cat, p)
self.assertGreaterEqual(cat, pron)
def _parse_pred(string, nodeid, queries, equalities):
assert string.islower(), 'Predicates must be lower-case.'
assert ' ' not in string, 'Predicates must not contain spaces.'
if string[0] == '"' and string[-1] == '"':
string = string[1:-1]
assert '"' not in string, 'Predicates must not contain quotes.'
assert string[
0] != '\'', 'Predicates with opening single-quote have been deprecated.'
if (string[:4] == 'pred' and
(len(string) == 4 or string[4] in special_values)) or (
string[:8] == 'predsort' and
(len(string) == 8 or string[8] in special_values)):
i = 8 if string[:8] == 'predsort' else 4
value = _parse_value(
string[i:], None, queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].pred))
assert not value
return Pred(), string[:i]
rel_suffix = ''
if string[-4:] == '_rel':
string = string[:-4]
rel_suffix = '_rel'
if string[0] != '_':
name = _parse_value(
string, '?', queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].pred.name))
return GPred(name), name + rel_suffix
values = string[1:].rsplit('_', 2)
count = len(values)
assert count > 0, 'Invalid number of arguments for RealPred.'
if count == 1:
values.insert(0, '?')
values.append('unknown')
elif count == 2:
values.append(None)
lemma = _parse_value(
values[0], '?', queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].pred.lemma))
pos = _parse_value(
values[1], 'u', queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].pred.pos)) # u ???
sense = _parse_value(
values[2], 'unknown', queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].pred.sense
)) # unknown ???
if count == 1:
ref_name = '_{}{}'.format(pos, rel_suffix)
elif count == 2:
ref_name = '_{}_{}{}'.format(lemma, pos, rel_suffix)
else:
ref_name = '_{}_{}_{}{}'.format(lemma, pos, sense, rel_suffix)
return RealPred(lemma, pos, sense), ref_name
def test_Node_underspecification(self):
with self.assertRaises(TypeError):
Node(pred='_the_q').is_more_specific(4)
# complete underspecification
self.assertFalse(Node().is_more_specific(Node()))
self.assertFalse(Node().is_less_specific(Node()))
# pred underspecification
self.assertFalse(Node(pred=Pred()).is_more_specific(Node()))
self.assertTrue(Node(pred=Pred()).is_less_specific(Node()))
self.assertTrue(Node().is_more_specific(Node(pred=Pred())))
self.assertFalse(Node().is_less_specific(Node(pred=Pred())))
self.assertFalse(Node(pred=Pred()).is_more_specific(Node(pred=Pred())))
self.assertFalse(Node(pred=Pred()).is_less_specific(Node(pred=Pred())))
self.assertFalse(
Node(pred=Pred()).is_more_specific(Node(pred=GPred(name='abc'))))
self.assertTrue(
Node(pred=Pred()).is_less_specific(Node(pred=GPred(name='abc'))))
self.assertTrue(
Node(pred=GPred(name='abc')).is_more_specific(Node(pred=Pred())))
self.assertFalse(
Node(pred=GPred(name='abc')).is_less_specific(Node(pred=Pred())))
# carg underspecification
self.assertFalse(Node(carg='?').is_more_specific(Node()))
self.assertTrue(Node(carg='?').is_less_specific(Node()))
self.assertTrue(Node().is_more_specific(Node(carg='?')))
self.assertFalse(Node().is_less_specific(Node(carg='?')))
self.assertFalse(Node(carg='?').is_more_specific(Node(carg='?')))
self.assertFalse(Node(carg='?').is_less_specific(Node(carg='?')))
self.assertFalse(Node(carg='?').is_more_specific(Node(carg='abc')))
self.assertTrue(Node(carg='?').is_less_specific(Node(carg='abc')))
self.assertTrue(Node(carg='abc').is_more_specific(Node(carg='?')))
self.assertFalse(Node(carg='abc').is_less_specific(Node(carg='?')))
# sortinfo underspecification
self.assertFalse(Node(sortinfo=Sortinfo()).is_more_specific(Node()))
self.assertTrue(Node(sortinfo=Sortinfo()).is_less_specific(Node()))
self.assertTrue(Node().is_more_specific(Node(sortinfo=Sortinfo())))
self.assertFalse(Node().is_less_specific(Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(sortinfo=Sortinfo()).is_more_specific(
Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(sortinfo=Sortinfo()).is_less_specific(
Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(sortinfo=Sortinfo()).is_more_specific(
Node(sortinfo=EventSortinfo(sf='abc'))))
self.assertTrue(
Node(sortinfo=Sortinfo()).is_less_specific(
Node(sortinfo=EventSortinfo(sf='abc'))))
self.assertTrue(
Node(sortinfo=EventSortinfo(sf='abc')).is_more_specific(
Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(sortinfo=EventSortinfo(sf='abc')).is_less_specific(
Node(sortinfo=Sortinfo())))
# mixed specification
self.assertFalse(Node(pred=Pred()).is_more_specific(Node(carg='?')))
self.assertFalse(Node(pred=Pred()).is_less_specific(Node(carg='?')))
self.assertFalse(
Node(pred=Pred()).is_more_specific(Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(pred=Pred()).is_less_specific(Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(carg='?').is_more_specific(Node(sortinfo=Sortinfo())))
self.assertFalse(
Node(carg='?').is_less_specific(Node(sortinfo=Sortinfo())))
def _parse_node(string, nodeid, queries, equalities, anchors, sortinfo_classes,
sortinfo_shortforms):
m = string.find('(')
if m < 0:
m = string.find(' ')
if m < 0:
l = string.find(':')
else:
l = string.find(':', 0, m)
if l < 0:
ref_ids = None
l = 0
else:
ref_ids = string[:l]
l += 1
while string[l] == ' ':
l += 1
if string[l:l + 4] == 'node' and (len(string) - l == 4
or string[l + 4] in special_values):
value = _parse_value(string[l + 4:], None, queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]]))
assert not value
pred = Pred()
carg = '?'
sortinfo = Sortinfo()
ref_name = 'node'
elif m < 0:
pred, ref_name = _parse_pred(string[l:], nodeid, queries, equalities)
carg = None
sortinfo = None
else:
pred, ref_name = _parse_pred(string[l:m], nodeid, queries, equalities)
if string[m] == '(':
r = string.index(')', m)
if string[m + 1] == '"' and string[r - 1] == '"':
carg = string[m + 2:r - 1]
else:
carg = string[m + 1:r]
assert '"' not in carg
carg = _parse_value(
carg, '?', queries, equalities,
(lambda matching, dmrs: dmrs[matching[nodeid]].carg))
m = r + 1
else:
carg = None
if m < len(string) and string[m] == ' ':
while string[m] == ' ':
m += 1
sortinfo = _parse_sortinfo(string[m:], nodeid, queries, equalities,
sortinfo_classes, sortinfo_shortforms)
else:
sortinfo = None
if not ref_ids:
ref_ids = None
node = Node(nodeid, pred, sortinfo=sortinfo, carg=carg)
else:
if ref_ids[0] == '[' and ref_ids[-1] == ']':
ref_ids = ref_ids[1:-1].split(',')
node = AnchorNode(anchors=ref_ids,
nodeid=nodeid,
pred=pred,
sortinfo=sortinfo,
carg=carg)
elif ref_ids[0] == '(' and ref_ids[-1] == ')':
ref_ids = ref_ids[1:-1].split(',')
node = OptionalNode(anchors=ref_ids,
nodeid=nodeid,
pred=pred,
sortinfo=sortinfo,
carg=carg)
elif ref_ids[0] == '{' and ref_ids[-1] == '}':
ref_ids = ref_ids[1:-1].split(',')
node = SubgraphNode(anchors=ref_ids,
nodeid=nodeid,
pred=pred,
sortinfo=sortinfo,
carg=carg)
else:
ref_ids = ref_ids.split(',')
node = Node(nodeid=nodeid, pred=pred, sortinfo=sortinfo, carg=carg)
for ref_id in ref_ids:
assert ref_id not in anchors, 'Reference ids have to be unique.'
anchors[ref_id] = node
return node, ref_ids, ref_name
def test_Pred_repr(self):
"""
The 'official' string representation of Pred()
should evaluate to Pred()
"""
self.assertEqual(eval(repr(Pred())), Pred())
def test_Pred_str(self):
"""
The 'informal' string representation of a Pred should be
'predsort', the type name for predicates in Delph-in grammars
"""
self.assertEqual(str(Pred()), 'predsort')
def predsort():
dmrs = DictDmrs()
dmrs.add_node(
Node(pred=Pred(),
sortinfo=Sortinfo())) # underspecified predicate and sortinfo
return dmrs
