def resolve_events(event):
"""
Helper method to combine events, accounting for
missing sources, and targets, passives, multiple-
target passives, and codeless verbs.
Parameters
----------
event: tuple
(source, target, code) of lower event
Returns
-------
returns: [tuple]
list of resolved event tuples
"""
returns = []
first, second, third = [up, "", ""]
if not (up or c):
return [event]
if not isinstance(event, tuple):
second = event
third = c
if passive:
for item in first:
e2 = ([second], item, passive)
self.sentence.metadata[id(e2)] = [event, meta, 7]
returns.append(e2)
elif event[1] == "passive":
first = event[0]
third = utilities.combine_code(c, event[2])
if up:
returns = []
for source in up:
e = (first, source, third)
self.sentence.metadata[id(e)] = [event, up, 1]
returns.append(e)
return returns
second = "passive"
elif not event[0] in ["", [], [""], ["~"], ["~~"]]:
second = event
third = c
else:
second = event[1]
third = utilities.combine_code(c, event[2])
e = (first, second, third)
self.sentence.metadata[id(e)] = [event, c, meta, 2]
return returns + [e]
def match_transform(self, e):
"""
Check to see if the event e follows one of the verb transformation patterns
specified at the bottom of the Verb Dictionary file.
If the transformation is present, adjust the event accordingly.
If no transformation is present, check if the event is of the form:
a ( b . Q ) P , where Q is not a top-level verb.
and then convert this to ( a b P+Q )
Otherwise, return the event as-is.
Parameters
-----------
e: tuple
Event to be transformed
Returns
-------
t: list of tuples
List of modified events, since multiple events can come from one single event
"""
def recurse(pdict, event, a2v={}, v2a={}):
path = pdict
if isinstance(pdict, list):
line = pdict[1]
path = pdict[0]
verb = utilities.convert_code(path[2])[0] if not path[2] == "Q" else v2a["Q"]
if isinstance(v2a[path[1]], tuple):
results = []
for item in v2a[path[1]]:
results.append((list(v2a[path[0]]), item, verb))
return results, line
return [(list(v2a[path[0]]), v2a[path[1]], verb)], line
if isinstance(event, tuple):
actor = None if not event[0] else tuple(event[0])
masks = filter(
lambda a: a in pdict,
[event[2], event[2] - event[2] % 0x10, event[2] - event[2] % 0x100, event[2] - event[2] % 0x1000],
)
if masks:
path = pdict[masks[0]]
elif -1 in pdict:
v2a["Q"] = event[2]
path = pdict[-1]
else:
return False
else:
actor = event
if actor in a2v:
actor = a2v[actor]
if not actor:
actor = "_"
if actor in path:
return recurse(path[actor], event[1], a2v, v2a)
elif not actor == "_":
for var in sorted(path.keys())[::-1]:
if var in v2a:
continue
if not var == ".":
v2a[var] = actor
a2v[actor] = var
return recurse(path[var], event[1], a2v, v2a)
return False
try:
t = recurse(PETRglobals.VerbDict["transformations"], e)
if t:
return t
else:
if e[0] and e[2] and isinstance(e[1], tuple) and e[1][0] and not e[1][2] / (16 ** 3):
if isinstance(e[1][0], list):
results = []
for item in e[1][0]:
event = (e[0], item, utilities.combine_code(e[1][2], e[2]))
results.append(event)
return results
event = (e[0], e[1][0], utilities.combine_code(e[2], e[1][2]))
return [event]
except Exception as ex:
pass # print(ex)
return [e]
