def _node_isomorphic_build_nodedict(x, varprops):
# nodes are eps and vars:
# preds: {ep_sig: (nid, {arg_or_lbl: tgt})}
# ep_sig = 'pred|{CARG}'
# vars: {var_sig: (var, {ref_name: tgt})}
# var_sig = 'varsort|{VARPROPS}'
nd = defaultdict(list)
for ep in x.eps():
ep_sig = '{}|{}'.format(ep[1].string, ep[3].get(CONSTARG_ROLE))
ep_out = {'LBL': ep[2]}
for rargname, val in ep[3].items():
if rargname == CONSTARG_ROLE: continue
ep_out[rargname] = val
nd[ep_sig].append((ep[0], ep_out))
for var, vd in x._vars.items():
if varprops:
vps = '|'.join('%s=%s' % (p, v) for p, v in vd['props'])
else:
vps = ''
refs = '|'.join(
'%s:%s' % (x._eps[tgt][1].string, ref)
for ref, tgts in vd['refs'].items()
for tgt in tgts if tgt in x._eps
)
var_sig = '{}|{}|{}'.format(var_sort(var), vps, refs)
var_tgts = {}
if var in x._hcons:
hc = x._hcons[var]
var_tgts[hc[1]] = hc[2]
nd[var_sig].append((var, var_tgts))
return nd
def main(args):
total_sums = _make_counters()
total_record_count = 0
for profile in args.PROFILE:
ts = itsdb.TestSuite(profile)
sums = _make_counters()
record_count = 0
for record in ts['result']:
record_count += 1
total_record_count += 1
mrs = simplemrs.loads_one(record['mrs'])
for var in mrs.variables():
vartype = var_sort(var)
for prop, val in mrs.properties(var).items():
sums[vartype][prop.upper()][val.lower()] += 1
print('{} ({} MRSs):'.format(profile, record_count))
report(sums)
for vartype, props in sums.items():
for prop, vals in props.items():
for val, count in vals.items():
total_sums[vartype][prop][val] += count
print('TOTAL ({} MRSs):'.format(total_record_count))
report(total_sums)
def _node_isomorphic_build_nodedict(x, varprops):
# nodes are eps and vars:
# preds: {ep_sig: (nid, {arg_or_lbl: tgt})}
# ep_sig = 'pred|{CARG}'
# vars: {var_sig: (var, {ref_name: tgt})}
# var_sig = 'varsort|{VARPROPS}'
nd = defaultdict(list)
for ep in x.eps():
ep_sig = '{}|{}'.format(ep[1].string, ep[3].get(CONSTARG_ROLE))
ep_out = {'LBL': ep[2]}
for rargname, val in ep[3].items():
if rargname == CONSTARG_ROLE: continue
ep_out[rargname] = val
nd[ep_sig].append((ep[0], ep_out))
for var, vd in x._vars.items():
if varprops:
vps = '|'.join('%s=%s' % (p, v) for p, v in vd['props'])
else:
vps = ''
refs = '|'.join('%s:%s' % (x._eps[tgt][1].string, ref)
for ref, tgts in vd['refs'].items() for tgt in tgts
if tgt in x._eps)
var_sig = '{}|{}|{}'.format(var_sort(var), vps, refs)
var_tgts = {}
if var in x._hcons:
hc = x._hcons[var]
var_tgts[hc[1]] = hc[2]
nd[var_sig].append((var, var_tgts))
return nd
def func(xmrs, deps):
edges = []
for src in deps:
for _, tgt in deps[src]:
edges.append((src, tgt))
components = _connected_components(xmrs.nodeids(), edges)
ccmap = {}
for i, component in enumerate(components):
for n in component:
ccmap[n] = i
addl = {}
if not only_connecting or len(components) > 1:
lsh = xmrs.labelset_heads
lblheads = {v: lsh(v) for v, vd in xmrs._vars.items()
if 'LBL' in vd['refs']}
for heads in lblheads.values():
if len(heads) > 1:
first = heads[0]
joined = set([ccmap[first]])
for other in heads[1:]:
occ = ccmap[other]
srt = var_sort(xmrs.args(other).get(role, 'u0'))
needs_edge = not only_connecting or occ not in joined
edge_available = srt == 'u'
if needs_edge and edge_available:
addl.setdefault(other, []).append((role, first))
joined.add(occ)
return addl
def make_graph(x, args):
if args.parameters:
params = json.load(open(args.parameters))
else:
params = {}
# first create a graph to get normalized triples
g = codec.triples_to_graph(xmrs.Dmrs.to_triples(x, properties=True))
# then filter if necessary
if params:
varsort = dict(
(ep.nodeid, var_sort(ep.intrinsic_variable)) for ep in x.eps())
preds = dict((nid, x.pred(nid).short_form()) for nid in x.nodeids())
drop = set(params.get('drop_nodes', []))
allow = params.get('allow_relations', {})
global_allow = set(allow.get('global', []))
x_allow = set(allow.get('x', []))
e_allow = set(allow.get('e', []))
pred_allow = allow.get('predicate', {})
ts = [
t for t in g.triples() if (preds.get(t.source) not in drop and (
t.relation in global_allow or
(varsort.get(t.source) == 'x' and t.relation in x_allow) or
(varsort.get(t.source) == 'e' and t.relation in e_allow) or
(t.relation in pred_allow.get(preds.get(t.source), []))))
]
top = g.top if g.top in [t.source for t in ts] else None
g = codec.triples_to_graph(ts, top=top)
if params.get('substitute_attribute_value', {}):
g = _substitute_attrval(g, params['substitute_attribute_value'],
params['default_attribute_value'])
# Transform graph to DMRS
dmrs = xmrs.Dmrs.from_triples(g.triples())
return dmrs
def serialize_argument(rargname, value, varprops):
"""Serialize an MRS argument into the SimpleMRS format."""
_argument = "{rargname}: {value}{props}"
props = ""
if value in varprops:
props = " [ {} ]".format(" ".join([var_sort(value)] + list(map("{0[0]}: {0[1]}".format, varprops[value]))))
del varprops[value] # only print props once
return _argument.format(rargname=rargname, value=str(value), props=props)
def _serialize_argument(rargname, value, varprops):
"""Serialize an MRS argument into the SimpleMRS format."""
_argument = '{rargname}: {value}{props}'
props = ''
if value in varprops:
props = ' [ {} ]'.format(' '.join([var_sort(value)] + list(
map('{0[0]}: {0[1]}'.format, [(k.upper(), v)
for k, v in varprops[value]]))))
del varprops[value] # only print props once
return _argument.format(rargname=rargname, value=str(value), props=props)
def __init__(self, x, varprops=True):
self.sig = sig = defaultdict(list)
self.sigidx = sigidx = {}
self.adj = adj = defaultdict(lambda: defaultdict(list))
self.deg = deg = {}
# generate signatures (node labels)
for ep in x.eps():
# ep_sig = 'pred|{CARG}'
nid, args = ep[0], ep[3]
if CONSTARG_ROLE in args:
s = '{}({})'.format(ep[1].string, args[CONSTARG_ROLE])
else:
s = ep[1].string
sig[s].append(nid)
sigidx[nid] = s
for var, vd in x._vars.items():
# var_sig = 'varsort|{VARPROPS_AND_REFERENCES}'
aspects = ['%s=%s' % (p, v)
for p, v in vd['props']] if varprops else []
aspects.extend([
'%s:%s' % (sigidx[tgt], ref)
for ref, tgts in vd['refs'].items() for tgt in tgts
if tgt in x._eps
])
s = '{}|{}'.format(var_sort(var), '|'.join(sorted(aspects)))
sig[s].append(var)
sigidx[var] = s
# generate adjacency dicts (slightly optimized)
for ep in x.eps():
nid, lbl, args, s = ep[0], ep[2], ep[3], sigidx[nid]
adj[nid][sigidx[lbl]].append((lbl, 'LBL', 1))
adj[lbl][s].append((nid, 'LBL', 1))
for role, val in args.items():
if role == CONSTARG_ROLE: continue
adj[nid][sigidx[val]].append((val, role, 1))
adj[val][s].append((nid, role, 1 if role == IVARG_ROLE else 0))
for hc in x._hcons.values():
hi, reln, lo = hc
adj[hi][sigidx[lo]].append((lo, reln, 1))
adj[lo][sigidx[hi]].append((hi, reln, 0))
# generate a degree mapping for each node
for id_, ad in adj.items(): # ad = adj dict mapping sig to adjacents
# al = adjacent list; d is direction (forward=1, backward=0)
deg[id_] = sum(d for al in ad.values() for _, _, d in al)
def serialize_argument(rargname, value, varprops):
"""Serialize an MRS argument into the SimpleMRS format."""
_argument = '{rargname}: {value}{props}'
props = ''
if value in varprops:
props = ' [ {} ]'.format(
' '.join(
[var_sort(value)] +
list(map('{0[0]}: {0[1]}'.format,
[(k.upper(), v) for k, v in varprops[value]]))
)
)
del varprops[value] # only print props once
return _argument.format(
rargname=rargname,
value=str(value),
props=props
)
def __init__(self, x, varprops=True):
self.sig = sig = defaultdict(list)
self.sigidx = sigidx = {}
self.adj = adj = defaultdict(lambda: defaultdict(list))
self.deg = deg = {}
# generate signatures (node labels)
for ep in x.eps():
# ep_sig = 'pred|{CARG}'
nid, args = ep[0], ep[3]
if CONSTARG_ROLE in args:
s = '{}({})'.format(ep[1].string, args[CONSTARG_ROLE])
else:
s = ep[1].string
sig[s].append(nid)
sigidx[nid] = s
for var, vd in x._vars.items():
# var_sig = 'varsort|{VARPROPS_AND_REFERENCES}'
aspects = ['%s=%s' % (p,v) for p,v in vd['props']] if varprops else []
aspects.extend(['%s:%s' % (sigidx[tgt], ref)
for ref, tgts in vd['refs'].items()
for tgt in tgts if tgt in x._eps])
s = '{}|{}'.format(var_sort(var), '|'.join(sorted(aspects)))
sig[s].append(var)
sigidx[var] = s
# generate adjacency dicts (slightly optimized)
for ep in x.eps():
nid, lbl, args, s = ep[0], ep[2], ep[3], sigidx[nid]
adj[nid][sigidx[lbl]].append((lbl, 'LBL', 1))
adj[lbl][s].append((nid, 'LBL', 1))
for role, val in args.items():
if role == CONSTARG_ROLE: continue
adj[nid][sigidx[val]].append((val, role, 1))
adj[val][s].append((nid, role, 1 if role == IVARG_ROLE else 0))
for hc in x._hcons.values():
hi, reln, lo = hc
adj[hi][sigidx[lo]].append((lo, reln, 1))
adj[lo][sigidx[hi]].append((hi, reln, 0))
# generate a degree mapping for each node
for id_, ad in adj.items(): # ad = adj dict mapping sig to adjacents
# al = adjacent list; d is direction (forward=1, backward=0)
deg[id_] = sum(d for al in ad.values() for _, _, d in al)
def _make_digraph(x, check_varprops):
dg = nx.DiGraph()
for ep in x.eps():
nid, pred, args = ep[0], ep[1], ep[3]
if CONSTARG_ROLE in args:
s = '{}({})'.format(pred.string, args[CONSTARG_ROLE])
else:
s = pred.string
dg.add_node(nid, sig=s)
dg.add_edges_from((nid, var_id(val)) for role, val in args.items()
if role != CONSTARG_ROLE)
for var, vd in x._vars.items():
aspects = []
if check_varprops:
aspects.extend('%s=%s' % (p,v) for p,v in vd['props'])
aspects.extend('%s:%s' % (dg.node[tgt]['sig'], ref)
for ref, tgts in vd['refs'].items()
for tgt in tgts if tgt in x._eps)
s = '{}|{}'.format(var_sort(var), '|'.join(sorted(aspects)))
dg.add_node(var_id(var), sig=s)
dg.add_edges_from((var_id(hi), var_id(lo), {'sig':reln})
for hi, reln, lo in x.hcons())
return dg
def _make_digraph(x, check_varprops):
dg = nx.DiGraph()
for ep in x.eps():
nid, pred, args = ep[0], ep[1], ep[3]
if CONSTARG_ROLE in args:
s = '{}({})'.format(pred.string, args[CONSTARG_ROLE])
else:
s = pred.string
dg.add_node(nid, sig=s)
dg.add_edges_from((nid, var_id(val)) for role, val in args.items()
if role != CONSTARG_ROLE)
for var, vd in x._vars.items():
aspects = []
if check_varprops:
aspects.extend('%s=%s' % (p,v) for p,v in vd['props'])
aspects.extend('%s:%s' % (dg.node[tgt]['sig'], ref)
for ref, tgts in vd['refs'].items()
for tgt in tgts if tgt in x._eps)
s = '{}|{}'.format(var_sort(var), '|'.join(sorted(aspects)))
dg.add_node(var_id(var), sig=s)
dg.add_edges_from((var_id(hi), var_id(lo), {'sig':reln})
for hi, reln, lo in x.hcons())
return dg
def test_var_sort():
assert var_sort('x1') == 'x'
assert var_sort('event10') == 'event'
with pytest.raises(ValueError): var_sort('x')
