def and_or(dep_graph: DependencyGraph):
"""
:param dep_graph:
:param oia_graph:
:return:
"""
pattern = DependencyGraph()
parent_node = pattern.create_node()
some_node = pattern.create_node()
and_node = pattern.create_node(LEMMA=r"\band\b")
or_node = pattern.create_node(LEMMA=r"\bor\b")
pattern.add_dependency(parent_node, some_node, r'\bconj:\w*')
pattern.add_dependency(some_node, and_node, r'\bcc\b')
pattern.add_dependency(some_node, or_node, r'\bcc\b')
pattern.add_dependency(and_node, or_node, r'\bconj')
for match in list(dep_graph.match(pattern)):
dep_parent_node = match[parent_node]
dep_some_node = match[some_node]
dep_and_node = match[and_node]
dep_or_node = match[or_node]
rel = dep_graph.get_dependency(dep_parent_node, dep_some_node)
if not rel.startswith("conj:and") and not rel.startswith("conj:or"):
continue
and_or_nodes = [n for n in dep_graph.nodes() if dep_and_node.LOC < n.LOC < dep_or_node.LOC]
if any([node.UPOS in {"VERB", "NOUN", "ADJ", "ADP", "ADV"} for node in and_or_nodes]):
continue
and_or_nodes.append(dep_and_node)
and_or_nodes.append(dep_or_node)
and_or_nodes.sort(key=lambda n: n.LOC)
if not all([dep_graph.get_node(x.ID) for x in and_or_nodes]):
continue
new_and_or_node = merge_dep_nodes(and_or_nodes,
UPOS=dep_and_node.UPOS,
LOC=dep_and_node.LOC,
FEATS=dep_and_node.FEATS
)
dep_graph.replace_nodes(and_or_nodes, new_and_or_node)
dep_graph.set_dependency(dep_parent_node, dep_some_node, "conj:" + new_and_or_node.FORM)
def amod_xcomp_to_acl(dep_graph: DependencyGraph):
"""
something extracted by
:param dep_graph:
:param oia_graph:
:return:
"""
pattern = DependencyGraph()
noun_node = pattern.create_node(UPOS="NOUN")
adj_node = pattern.create_node(UPOS="ADJ")
verb_node = pattern.create_node(UPOS="VERB")
pattern.add_dependency(noun_node, adj_node, r'amod')
pattern.add_dependency(adj_node, verb_node, r"xcomp")
for match in list(dep_graph.match(pattern)):
dep_noun_node = match[noun_node]
dep_verb_node = match[verb_node]
dep_adj_node = match[adj_node]
try:
[
dep_graph.get_node(x.ID)
for x in [dep_noun_node, dep_verb_node, dep_adj_node]
]
except Exception as e:
# has been processed by previous match
continue
xcomp_nodes = [
n for n, l in dep_graph.children(
dep_adj_node, filter=lambda n, l: l.startswith("xcomp"))
]
mark_nodes_list = []
for dep_xcomp_node in xcomp_nodes:
mark_nodes = [
n for n, l in dep_graph.children(
dep_xcomp_node,
filter=lambda n, l: l.startswith("mark") and dep_adj_node.
LOC < n.LOC < dep_xcomp_node.LOC)
]
if mark_nodes:
mark_nodes_list.append(mark_nodes)
if len(mark_nodes_list) > 1:
raise Exception("Unexpected Situation Happened")
new_verb_nodes = [dep_adj_node]
if mark_nodes_list:
mark_nodes = mark_nodes_list[0]
new_verb_nodes.extend(mark_nodes)
new_verb_nodes.sort(key=lambda x: x.LOC)
new_verb_nodes = ["(be)"] + new_verb_nodes
new_node = merge_dep_nodes(new_verb_nodes,
UPOS="VERB",
LOC=new_verb_nodes[-1].LOC,
FEATS={"VerbForm": "Ger"})
dep_graph.replace_nodes(new_verb_nodes, new_node)
dep_graph.set_dependency(dep_noun_node, new_node, "acl")
for dep_xcomp_node in xcomp_nodes:
dep_graph.remove_dependency(dep_xcomp_node, new_node)
dep_graph.set_dependency(new_node, dep_verb_node, "obj")
def continuous_asas(dep_graph: DependencyGraph):
"""
##### as far as I known #####
##### the first 'as' is always the advmod of a following element, X, which is within the range of as... as #####
##### the second 'as' is always the dependent of B #####
##### B sometimes depends on the first 'as', sometimes dependts on X #####
##### Sometimes X has a head that is also within the range of as...as #####
:param dep_graph:
:param oia_graph:
:return:
"""
verb_node = DependencyGraphNode(UPOS="VERB|NOUN|PRON|PROPN")
adv_node = DependencyGraphNode(UPOS="ADV|ADJ")
as1_node = DependencyGraphNode(LEMMA="as")
as2_node = DependencyGraphNode(LEMMA="as")
verb2_node = DependencyGraphNode(UPOS="VERB|ADJ|NOUN|PROPN|PRON")
# ADJ is for as soon as possible
pattern1 = DependencyGraph()
pattern1.add_nodes([verb_node, adv_node, as1_node, as2_node, verb2_node])
pattern1.add_dependency(verb_node, adv_node, r'advmod|amod')
pattern1.add_dependency(adv_node, as1_node, r'\w*advmod\w*')
pattern1.add_dependency(as1_node, verb2_node, r'advcl:as|obl:as|advmod')
pattern1.add_dependency(verb2_node, as2_node, r'mark|case')
pattern2 = DependencyGraph()
pattern2.add_nodes([verb_node, adv_node, as1_node, as2_node, verb2_node])
pattern2.add_dependency(verb_node, adv_node, r'advmod|amod')
pattern2.add_dependency(adv_node, as1_node, r'\w*advmod\w*')
pattern2.add_dependency(adv_node, verb2_node, r'advcl:as|obl:as|advmod')
pattern2.add_dependency(verb2_node, as2_node, r'mark|case')
as_as_pred = []
for match in list(dep_graph.match(pattern1)) + list(
dep_graph.match(pattern2)):
dep_verb_node = match[verb_node]
dep_adv_node = match[adv_node]
dep_as1_node = match[as1_node]
dep_as2_node = match[as2_node]
dep_verb2_node = match[verb2_node]
if not (dep_as1_node.LOC < dep_adv_node.LOC < dep_as2_node.LOC <
dep_verb2_node.LOC):
continue
as_as_pred.append((dep_as1_node, dep_as2_node, dep_adv_node,
dep_verb_node, dep_verb2_node))
pred = [
node for node in dep_graph.nodes()
if dep_as1_node.LOC <= node.LOC <= dep_adv_node.LOC
]
pred.append(dep_as2_node)
pred.sort(key=lambda x: x.LOC)
head = dep_adv_node
dep_asas_node = merge_dep_nodes(pred, UPOS="ADP", LOC=head.LOC)
dep_graph.replace_nodes(pred, dep_asas_node)
dep_graph.remove_dependency(dep_verb2_node, dep_asas_node)
dep_graph.remove_dependency(dep_asas_node, dep_verb2_node)
dep_graph.remove_dependency(dep_verb_node, dep_asas_node)
if dep_verb_node.UPOS == "VERB":
dep_graph.set_dependency(dep_verb_node, dep_verb2_node,
"advcl:" + dep_asas_node.FORM)
dep_graph.set_dependency(dep_verb2_node, dep_asas_node, "mark")
else:
dep_graph.set_dependency(dep_verb_node, dep_verb2_node,
"obl:" + dep_asas_node.FORM)
dep_graph.set_dependency(dep_verb2_node, dep_asas_node, "case")
def gradation(dep_graph: DependencyGraph):
"""
TODO: do not match with the tech report, and the verb is not considered
##### Comparative #####
##### Periphrastic gradation #####
##### He runs faster than her #####
##### Martin is more intelligent than Donald #####
##### He is a nicer person than Tom
##### She is more than a regular cook
:param dep_graph:
:param oia_graph:
:return:
"""
pattern = DependencyGraph()
verb_node = pattern.create_node(UPOS="VERB|NOUN|PRON|PROPN|SYM")
advj_node = pattern.create_node(UPOS="ADJ|ADV", FEATS={"Degree": "Cmp"})
than_node = pattern.create_node(FORM="than")
obj_node = pattern.create_node()
pattern.add_dependency(verb_node, advj_node, r'advmod|amod')
pattern.add_dependency(advj_node, obj_node,
r'\w*(nmod:than|obl:than|advcl:than)\w*')
pattern.add_dependency(obj_node, than_node, r'\w*case|mark\w*')
for match in list(dep_graph.match(pattern)):
dep_verb_node = match[verb_node]
dep_advj_node = match[advj_node]
dep_than_node = match[than_node]
dep_obj_node = match[obj_node]
def __valid_mod(n, l):
return (l == "amod" or l == "advmod") and in_interval(
n, None, dep_advj_node)
aux_node = list(dep_graph.children(dep_advj_node, filter=__valid_mod))
if aux_node:
aux_node = aux_node[0][0]
offsprings = dep_graph.offsprings(aux_node)
more_than_nodes = offsprings + [dep_than_node]
else:
more_than_nodes = (dep_advj_node, dep_than_node)
dep_more_than_node = merge_dep_nodes(more_than_nodes,
UPOS="ADP",
LOC=dep_than_node.LOC)
dep_graph.replace_nodes(more_than_nodes, dep_more_than_node)
dep_graph.remove_dependency(dep_obj_node, dep_more_than_node)
dep_graph.remove_dependency(dep_more_than_node, dep_obj_node)
dep_graph.remove_dependency(dep_verb_node, dep_more_than_node)
if dep_verb_node.UPOS == "VERB":
dep_graph.set_dependency(dep_verb_node, dep_obj_node,
"advcl:" + dep_more_than_node.FORM)
dep_graph.set_dependency(dep_obj_node, dep_more_than_node, "mark")
else:
dep_graph.set_dependency(dep_verb_node, dep_obj_node,
"obl:" + dep_more_than_node.FORM)
dep_graph.set_dependency(dep_obj_node, dep_more_than_node, "case")
