forked from kristjan/cjvt-valency
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
133 lines
3.7 KiB
133 lines
3.7 KiB
import logging
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
def frames_from_db_entry(dbent):
|
|
def _full_tid(tid):
|
|
return ".".join([dbent["sid"], str(tid)])
|
|
|
|
token_dict = {str(x["tid"]): x for x in dbent["tokens"]}
|
|
|
|
frames = []
|
|
if "srl_links" not in dbent:
|
|
return []
|
|
srldict = {}
|
|
for srl in dbent["srl_links"]:
|
|
key = str(srl["from"])
|
|
if key not in srldict:
|
|
srldict[key] = [srl]
|
|
else:
|
|
srldict[key] += [srl]
|
|
for hwtid, srlarr in srldict.items():
|
|
frames += [Frame(
|
|
hw_lemma=token_dict[hwtid]["lemma"],
|
|
tids=[_full_tid(hwtid)],
|
|
slots=[
|
|
Slot(
|
|
functor=srl["afun"],
|
|
tids=[_full_tid(srl["to"])]
|
|
) for srl in srlarr
|
|
],
|
|
# sentences=[(dbent["sid"], dbent["tokens"])],
|
|
sentences=[
|
|
[(_full_tid(t["tid"]), t) for t in dbent["tokens"]],
|
|
]
|
|
)]
|
|
return frames
|
|
|
|
class Frame():
|
|
def __init__(self, tids, deep_links=None, slots=None, hw_lemma=None, sentences=None):
|
|
self.hw = hw_lemma
|
|
self.tids = tids # list of tokens with the same hw_lemma
|
|
# Each tid = "S123.t123";
|
|
# you can get sentence with vallex.get_sentence(S123)
|
|
self.slots = []
|
|
if slots is None:
|
|
self.slots = self.init_slots(deep_links)
|
|
else:
|
|
self.slots = slots
|
|
self.sense_info = {}
|
|
self.sentences = sentences
|
|
self.aggr_sent = None # Dictionary { hw: self.sentences idx }
|
|
|
|
def get_functors(self):
|
|
return [slot.functor for slot in self.slots]
|
|
|
|
|
|
def to_json(self):
|
|
ret = {
|
|
"hw": self.hw,
|
|
"tids": self.tids,
|
|
"slots": [slot.to_json() for slot in self.slots],
|
|
"sentences": self.sentences,
|
|
"aggr_sent": self.aggr_sent,
|
|
"sense_info": self.sense_info
|
|
}
|
|
return ret
|
|
|
|
def init_slots(self, deep):
|
|
slots = []
|
|
for link in deep:
|
|
slots.append(Slot(
|
|
functor=link["afun"],
|
|
tids=[link["to"]]
|
|
))
|
|
return slots
|
|
|
|
def sort_slots(self):
|
|
# ACT, PAT, alphabetically
|
|
srt1 = [
|
|
x for x in self.slots
|
|
if (x.functor == "ACT" or
|
|
x.functor == "PAT")
|
|
]
|
|
srt1 = sorted(srt1, key=lambda x: x.functor)
|
|
srt2 = [
|
|
x for x in self.slots
|
|
if (x.functor != "ACT" and
|
|
x.functor != "PAT")
|
|
]
|
|
srt2 = sorted(srt2, key=lambda x: x.functor)
|
|
self.slots = (srt1 + srt2)
|
|
|
|
def to_string(self):
|
|
ret = "Frame:\n"
|
|
ret += "sense_info: {}\n".format(str(self.sense_info))
|
|
ret += "tids: ["
|
|
for t in self.tids:
|
|
ret += (str(t) + ", ")
|
|
ret += "]\n"
|
|
if self.slots is not None:
|
|
ret += "slots:\n"
|
|
for sl in self.slots:
|
|
ret += (sl.to_string() + "\n")
|
|
return ret
|
|
|
|
|
|
class Slot():
|
|
# Each slot is identified by its functor (ACT, PAT, ...)
|
|
# It consists of different tokens.
|
|
def __init__(self, functor, tids=None, count=None):
|
|
self.functor = functor
|
|
self.tids = tids or [] # combining multiple sentences vertically
|
|
self.count = count or 1
|
|
|
|
def to_string(self):
|
|
ret = "---- Slot:\n"
|
|
ret += "functor: {}\n".format(self.functor)
|
|
ret += "tids: ["
|
|
for t in self.tids:
|
|
ret += (str(t) + ", ")
|
|
ret += "]\n"
|
|
ret += "]\n"
|
|
ret += "----\n"
|
|
return ret
|
|
|
|
def to_json(self):
|
|
ret = {
|
|
"functor": self.functor,
|
|
"tids": self.tids,
|
|
"count": self.count
|
|
}
|
|
return ret
|