def get_adj_verb_phrase(dep_graph): """ :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() adj_node = pattern.create_node(UPOS="ADJ") get_node = pattern.create_node(LEMMA="get", UPOS="VERB") pattern.add_dependency(adj_node, get_node, r'aux') verb_phrases = [] for match in dep_graph.match(pattern): dep_adj_node = match[adj_node] dep_get_node = match[get_node] if isinstance(dep_adj_node, DependencyGraphSuperNode) and dep_adj_node.is_conj: continue pred = [dep_get_node, dep_adj_node] head = dep_adj_node verb_phrases.append((pred, head)) for verbs, root in verb_phrases: verb_node = merge_dep_nodes(verbs, UPOS="VERB", LOC=root.LOC) dep_graph.replace_nodes(verbs, verb_node)
def adj_modifier(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ adj previous to noun is coped with by noun phrase this process the case that adj is behind the noun #################### a pretty little boy ######################## :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() noun_node = pattern.create_node() # UPOS="NOUN|PRON|PROPN") adj_node = pattern.create_node() # UPOS="ADJ|NOUN") pattern.add_dependency(noun_node, adj_node, r'amod') for match in dep_graph.match(pattern): dep_noun_node = match[noun_node] dep_adj_node = match[adj_node] oia_noun_node = oia_graph.add_words(dep_noun_node.position) oia_adj_node = oia_graph.add_words(dep_adj_node.position) logger.debug("adj_modifier: ") logger.debug(dep_noun_node.position) logger.debug(oia_noun_node) logger.debug(dep_adj_node.position) logger.debug(oia_adj_node) oia_graph.add_mod(oia_adj_node, oia_noun_node)
def reverse_passive_verb(dep_graph: DependencyGraph): """ I'd forgotten how blown away I was by some of the songs the first time I saw it in NY. :param dep_graph: :return: """ pattern = DependencyGraph() subj_node = pattern.create_node() verb_node = pattern.create_node(UPOS="VERB", FEATS={"Tense": "Past"}) be_node = pattern.create_node(LEMMA=r"\bbe\b") pattern.add_dependency(verb_node, subj_node, r"\w*subj") pattern.add_dependency(verb_node, be_node, "cop") for match in list(dep_graph.match(pattern)): dep_subj_node = match[subj_node] dep_verb_node = match[verb_node] dep_be_node = match[be_node] if not (dep_verb_node.LOC < dep_subj_node.LOC < dep_be_node.LOC): continue new_verb_phrase = [dep_be_node, dep_verb_node] dep_new_verb = merge_dep_nodes(new_verb_phrase, UPOS="VERB", LOC=dep_be_node.LOC) dep_graph.replace_nodes(new_verb_phrase, dep_new_verb)
def obl_modifier(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ the adv before the verb should be processed by verb_phrase this converter should process the adv after the verb :param sentence: :return: """ pattern = DependencyGraph() # TODO: it seems that in UD labeling, adv is used instead of adj for noun modified_node = DependencyGraphNode() modifier_node = DependencyGraphNode() pattern.add_nodes([modified_node, modifier_node]) pattern.add_dependency(modified_node, modifier_node, r'\bobl') for match in dep_graph.match(pattern): dep_modified_node = match[modified_node] dep_modifier_node = match[modifier_node] if oia_graph.has_relation(dep_modified_node, dep_modifier_node, direct_link=False): continue oia_modified_node = oia_graph.add_words(dep_modified_node.position) oia_modifier_node = oia_graph.add_words(dep_modifier_node.position) oia_graph.add_mod(oia_modifier_node, oia_modified_node)
def ccomp_mark_sconj(dep_graph: DependencyGraph): """ See them as they are :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() pred1_node = pattern.create_node(UPOS="VERB") pred2_node = pattern.create_node() sconj_node = pattern.create_node(UPOS="SCONJ") pattern.add_dependency(pred1_node, pred2_node, r'ccomp') pattern.add_dependency(pred2_node, sconj_node, 'mark') for match in list(dep_graph.match(pattern)): dep_pred1_node = match[pred1_node] dep_pred2_node = match[pred2_node] dep_sconj_node = match[sconj_node] if dep_sconj_node.LEMMA == "as": dep_graph.remove_dependency(dep_pred2_node, dep_sconj_node) new_verb = [dep_pred1_node, "{1}", dep_sconj_node, "{2}"] new_verb_node = merge_dep_nodes(new_verb, UPOS=dep_pred1_node.UPOS, LOC=dep_pred1_node.LOC) # print("Noun detected", noun_node.ID) dep_graph.replace_nodes(new_verb, new_verb_node)
def appositive_phrase(dep_graph, oia_graph, context: UD2OIAContext): """ ##### Apposition: Trump, president of US, came ##### :param sentence: :return: """ pattern = DependencyGraph() subj_node = DependencyGraphNode() appos_node = DependencyGraphNode() pattern.add_nodes([subj_node, appos_node]) pattern.add_dependency(subj_node, appos_node, r'\w*appos\w*') for match in dep_graph.match(pattern): dep_subj_node = match[subj_node] dep_appos_node = match[appos_node] oia_appos_node = oia_graph.add_words(dep_appos_node.position) oia_subj_node = oia_graph.add_words(dep_subj_node.position) if oia_appos_node and oia_subj_node: pred_node = oia_graph.add_aux(label="APPOS") oia_graph.add_argument(pred_node, oia_subj_node, 1) oia_graph.add_argument(pred_node, oia_appos_node, 2)
def adv_adj_modifier(dep_graph, oia_graph, context: UD2OIAContext): """ the adv before the verb should be processed by verb_phrase this converter should process the adv after the verb :param sentence: :return: """ pattern = DependencyGraph() # TODO: it seems that in UD labeling, adv is used instead of adj for noun adj_node = DependencyGraphNode(UPOS="ADJ") adv_node = DependencyGraphNode(UPOS="ADV|X|NOUN") pattern.add_nodes([adj_node, adv_node]) pattern.add_dependency(adj_node, adv_node, r'advmod') for match in dep_graph.match(pattern): dep_adj_node = match[adj_node] dep_adv_node = match[adv_node] if oia_graph.has_relation(dep_adj_node, dep_adv_node): continue oia_adj_node = oia_graph.add_words(dep_adj_node.position) oia_adv_node = oia_graph.add_words(dep_adv_node.position) oia_graph.add_mod(oia_adv_node, oia_adj_node)
def part(dep_graph: DependencyGraph): """ :param dep_graph: :return: """ pattern = DependencyGraph() parent_node = pattern.create_node(UPOS="AUX|VERB") part_node = pattern.create_node(UPOS="PART") pattern.add_dependency(parent_node, part_node, r'advmod') for match in list(dep_graph.match(pattern)): dep_parent_node = match[parent_node] dep_part_node = match[part_node] new_node_list = [dep_parent_node, dep_part_node] new_node_list.sort(key=lambda n: n.LOC) new_node = merge_dep_nodes(new_node_list, UPOS=dep_parent_node.UPOS, LOC=dep_parent_node.LOC, FEATS=dep_parent_node.FEATS ) dep_graph.replace_nodes(new_node_list, new_node)
def whose_noun(dep_graph: DependencyGraph): """ :param dep_graph: :return: """ pattern = DependencyGraph() noun_node = pattern.create_node(UPOS="NOUN|PROPN|PRON|X|NUM|SYM") owner_node = pattern.create_node() whose_node = pattern.create_node(LEMMA="whose") pattern.add_dependency(noun_node, owner_node, "nmod:poss") pattern.add_dependency(owner_node, whose_node, "ref") whose_noun_phrase = [] for match in dep_graph.match(pattern): dep_owner_node = match[owner_node] dep_noun_node = match[noun_node] dep_whose_node = match[whose_node] whose_noun_phrase.append( (dep_owner_node, dep_whose_node, dep_noun_node)) for owner, whose, noun in whose_noun_phrase: noun_node = merge_dep_nodes([whose, noun], UPOS=noun.UPOS, LOC=noun.LOC) # print("Noun detected", noun_node.ID) dep_graph.remove_dependency(owner_node, whose) dep_graph.remove_dependency(noun, owner_node, "nmod:poss") dep_graph.replace_nodes([whose, noun], noun_node)
def negation(dep_graph, oia_graph, context: UD2OIAContext): """ #################### Negation ######################## :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() not_node = DependencyGraphNode(LEMMA="not") parent_node = DependencyGraphNode() pattern.add_nodes([not_node, parent_node]) pattern.add_dependency(parent_node, not_node, r'\w*') for match in dep_graph.match(pattern): dep_not_node = match[not_node] dep_parent_node = match[parent_node] oia_pred_node = oia_graph.add_aux(label="SCOPE") oia_not_node = oia_graph.add_words(dep_not_node.position) oia_parent_node = oia_graph.add_words(dep_parent_node.position) oia_graph.add_argument(oia_pred_node, oia_not_node, 1) oia_graph.add_argument(oia_pred_node, oia_parent_node, 1)
def there_be_verb_phrase(dep_graph): """ :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() there_node = pattern.create_node(FORM=r'there|There') be_node = pattern.create_node() pattern.add_dependency(be_node, there_node, r'\w*expl\w*') verb_phrases = [] for match in dep_graph.match(pattern): dep_there_node = match[there_node] dep_be_node = match[be_node] if not "be" in dep_be_node.LEMMA.split(" "): continue pred = [dep_there_node, dep_be_node] head = dep_be_node verb_phrases.append((pred, head)) for verbs, root in verb_phrases: verb_node = merge_dep_nodes(verbs, UPOS="VERB", LOC=root.LOC) dep_graph.replace_nodes(verbs, verb_node)
def separated_asas(dep_graph: DependencyGraph): """ ##### Equality comparison ##### ##### A is as X a C as B ##### ##### 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: """ pattern = DependencyGraph() adj_node = DependencyGraphNode(UPOS="ADJ") noun_node = DependencyGraphNode(UPOS="NOUN") as1_node = DependencyGraphNode(FORM="as") as2_node = DependencyGraphNode(FORM="as") obj_node = DependencyGraphNode() pattern.add_nodes([noun_node, adj_node, as1_node, as2_node, obj_node]) pattern.add_dependency(noun_node, adj_node, r'amod') pattern.add_dependency(adj_node, as1_node, r'\w*advmod\w*') pattern.add_dependency(as1_node, obj_node, r'\w*advcl:as\w*') pattern.add_dependency(obj_node, as2_node, r'mark') as_as_pred = [] for match in dep_graph.match(pattern): dep_noun_node = match[noun_node] dep_adj_node = match[adj_node] dep_as1_node = match[as1_node] dep_as2_node = match[as2_node] dep_obj_node = match[obj_node] if dep_as1_node.LOC < dep_adj_node.LOC < dep_noun_node.LOC < dep_as2_node.LOC < dep_obj_node.LOC: pred = [ node for node in dep_graph.nodes() if dep_as1_node.LOC <= node.LOC <= dep_adj_node.LOC ] pred.append(dep_as2_node) pred.sort(key=lambda x: x.LOC) head = dep_adj_node asas_node = merge_dep_nodes(pred, UPOS="ADJ", LOC=dep_as2_node.LOC) as_as_pred.append( (pred, head, asas_node, dep_noun_node, dep_obj_node)) for pred, head, asas_node, dep_noun_node, dep_obj_node in as_as_pred: dep_graph.replace_nodes(pred, asas_node) dep_graph.remove_dependency(asas_node, dep_obj_node) dep_graph.remove_dependency(dep_noun_node, asas_node) dep_graph.add_dependency(dep_noun_node, dep_obj_node, "acl:" + asas_node.FORM)
def acl_mod_verb(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ this is called after adnominal_clause_mark, which means there is no mark :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() noun_node = pattern.create_node(UPOS="NOUN|PRON|PROPN|ADJ|ADV|NUM") # ADJ is for the cases that "many/some" are abbrv of many X/some X, representing NOUN # ADV is for the case of "here" for "i am here thinking xxx" verb_node = pattern.create_node(UPOS="VERB|AUX") # aux is for can, have which ommits the true verb pattern.add_nodes([noun_node, verb_node]) pattern.add_dependency(noun_node, verb_node, r'acl') for match in dep_graph.match(pattern): dep_noun_node = match[noun_node] dep_verb_node = match[verb_node] if context.is_processed(dep_noun_node, dep_verb_node): continue if oia_graph.has_relation(dep_noun_node, dep_verb_node, direct_link=False): continue oia_verb_node = oia_graph.add_words(dep_verb_node.position) oia_noun_node = oia_graph.add_words(dep_noun_node.position) dep = dep_graph.get_dependency(dep_noun_node, dep_verb_node) labels = [x for x in dep.rels if x.startswith("acl:")] pred = None if labels: assert len(labels) == 1 label = labels[0] pred = label.split(":")[1] if pred == "relcl": pred = None # if pred: # # there is no mark, but we add it because it may be because of not being shared in conjunction # # oia_pred_node = oia_graph.add_aux(pred) # oia_graph.add_argument(oia_pred_node, oia_noun_node, 1, mod=True) # oia_graph.add_argument(oia_pred_node, oia_verb_node, 2) # else: oia_graph.add_mod(oia_verb_node, oia_noun_node)
def process_head_conj(dep_graph: DependencyGraph): """ :param dep_graph: :return: """ first_word = dep_graph.get_node_by_loc(0) if first_word and first_word.LEMMA in {"and", "but"}: cc_parents = [n for n, l in dep_graph.parents(first_word) if l == "cc"] for p in cc_parents: dep_graph.remove_dependency(p, first_word) dep_graph.add_dependency(first_word, p, "arg_conj:1")
def adverbial_clause(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ Adverbial Clause ##### run in order to catch it. advcl with mark (in order to) ##### ##### he worked hard, replacing his feud. advcl without mark ##### :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() verb_node = pattern.create_node() modifier_node = pattern.create_node() pattern.add_dependency(verb_node, modifier_node, "advcl") for match in list(dep_graph.match(pattern)): dep_verb_node = match[verb_node] dep_modifier_node = match[modifier_node] if context.is_processed(dep_verb_node, dep_modifier_node): continue oia_verb_node = oia_graph.add_words(dep_verb_node.position) oia_modifier_node = oia_graph.add_words(dep_modifier_node.position) logger.debug("adverbial clause: verb={0}, modifier={1}".format( dep_verb_node.position, dep_modifier_node.position)) if oia_graph.has_relation(oia_verb_node, oia_modifier_node): continue mark = list( dep_graph.children(dep_modifier_node, filter=lambda n, rel: "mark" in rel)) if mark: mark, rel = mark[0] pred_node = oia_graph.add_words(mark.position) if pred_node is None: continue if mark.LEMMA in CONJUNCTION_WORDS[language]: continue oia_graph.add_argument(pred_node, oia_verb_node, 1, mod=True) oia_graph.add_argument(pred_node, oia_modifier_node, 2) else: oia_graph.add_mod(oia_modifier_node, oia_verb_node)
def complete_missing_case_mark(dep_graph: DependencyGraph, root, root_parents, parallel_components, relation_to_conj, case_marks): """ :param dep_graph: :param parallel_components: :return: """ parallel_components.sort(key=lambda x: x.LOC) for parent in root_parents: # ic(str(root)) # ic(str(parent)) # ic(relation_to_conj) prefix, shared_prefix, required_mark = relation_to_conj[parent.ID] if not required_mark: continue for index, (node, mark) in enumerate(zip(parallel_components, required_mark)): if mark is None: continue is_exist = any( mark == child.LEMMA or mark in child.LEMMA.split(" ") for child, l in dep_graph.children(node)) if is_exist: continue found_mark = find_mark(case_marks, parallel_components[:index], mark) if found_mark: mark_node, rel = found_mark dup_case_mark = dep_graph.create_node(FORM=mark_node.FORM, LEMMA=mark_node.LEMMA, UPOS=mark_node.UPOS, LOC=mark_node.LOC) dup_case_mark.aux = True dep_graph.add_dependency(node, dup_case_mark, rel) else: logger.warning("cannot find the mark, just add the relation")
def multi_words_mark(dep_graph: DependencyGraph): """ arise on to the "on to" should be combined :param dep_graph: :param oia_graph: :return: """ # print('multi_words_mark') mark_phrases = [] for node in dep_graph.nodes(): marks = [] for n, l in dep_graph.children(node, filter=lambda n, l: "mark" in l): marks.extend(dep_graph.offsprings(n)) if not marks: continue # print('multi_words_mark marks:', marks) if len(marks) > 1: if any([x.UPOS in {"NOUN", "NUM", "VERB", "ADJ", "ADV", "PRON"} for x in marks]): continue marks.sort(key=lambda n: n.LOC) mark_phrases.append((node, marks)) for node, marks in mark_phrases: # print('multi_words_mark marks:', marks) if not all([dep_graph.get_node(x.ID) for x in marks]): continue mark_min_loc = marks[0].LOC mark_max_loc = marks[-1].LOC marks = [n for n in dep_graph.nodes() if mark_min_loc <= n.LOC <= mark_max_loc] marks.sort(key=lambda n: n.LOC) if any([x.UPOS in NOUN_UPOS for x in marks]): continue # print('marks:') # for nnnn in marks: # print(nnnn) new_mark_node = merge_dep_nodes(marks, UPOS=marks[0].UPOS, LOC=marks[0].LOC ) for mark in marks: dep_graph.remove_dependency(node, mark) dep_graph.replace_nodes(marks, new_mark_node) dep_graph.add_dependency(node, new_mark_node, "mark")
def it_verb_clause(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ ##### Expletive ##### ##### it is xxx to do ##### ##### ##### :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() it_node = pattern.create_node(LEMMA="it") verb_node = pattern.create_node(UPOS="VERB") subj_node = pattern.create_node(UPOS="NOUN|PRON|PROPN|VERB") pattern.add_dependency(verb_node, it_node, r'expl') pattern.add_dependency(verb_node, subj_node, r'nsubj|csubj') for match in dep_graph.match(pattern): dep_verb_node, dep_it_node, dep_subj_node = \ [match[x] for x in [verb_node, it_node, subj_node]] if context.is_processed(dep_verb_node, dep_it_node): continue oia_it_node = oia_graph.add_words(dep_it_node.position) oia_subj_node = oia_graph.add_words(dep_subj_node.position) # oia_that_node = oia_graph.add_word_with_head(dep_that_node) oia_verb_node = oia_graph.add_words(dep_verb_node.position) if dep_it_node.LOC < dep_subj_node.LOC: # it VERB subj that ... oia_graph.add_argument(oia_verb_node, oia_it_node, 1) oia_graph.add_argument(oia_verb_node, oia_subj_node, 1) oia_graph.add_ref(oia_it_node, oia_subj_node) else: # subj VERB it that ... oia_graph.add_argument(oia_verb_node, oia_it_node, 2) oia_graph.add_argument(oia_verb_node, oia_subj_node, 2) oia_graph.add_ref(oia_it_node, oia_subj_node) # dep_graph.remove_dependency(dep_verb_node, dep_subj_node) context.processed(dep_verb_node, dep_it_node) context.processed(dep_verb_node, dep_subj_node)
def nmod_with_case(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ #################### nmod:x ######################## ##### the office of the chair ##### ##### Istanbul in Turkey ##### :param sentence: :return: """ pattern = DependencyGraph() parent_node = DependencyGraphNode() child_node = DependencyGraphNode() case_node = DependencyGraphNode() pattern.add_nodes([parent_node, child_node, case_node]) pattern.add_dependency(parent_node, child_node, r'\w*nmod\w*') pattern.add_dependency(child_node, case_node, r'\w*case\w*') for match in dep_graph.match(pattern): dep_parent_node = match[parent_node] dep_child_node = match[child_node] dep_case_node = match[case_node] rel = dep_graph.get_dependency(dep_parent_node, dep_child_node) # vs, lemma = versus # according, lemma = accord, # but rel always select the shorter one if oia_graph.has_relation(dep_parent_node, dep_child_node): continue if rel != "nmod:" + dep_case_node.LEMMA and rel != 'nmod:' + dep_case_node.FORM: pred_node = oia_graph.add_words(dep_case_node.position) else: pred_node = oia_graph.add_words(dep_case_node.position) arg1_node = oia_graph.add_words(dep_parent_node.position) arg2_node = oia_graph.add_words(dep_child_node.position) oia_graph.add_argument(pred_node, arg1_node, 1, mod=True) oia_graph.add_argument(pred_node, arg2_node, 2)
def oblique_without_prep(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ :param dep_graph: :param oia_graph: :return: """ # cut X by a knife pattern = DependencyGraph() verb_node = DependencyGraphNode(UPOS="VERB|NOUN|ADJ|PROPN|PRON") oblique_node = DependencyGraphNode() pattern.add_node(verb_node) pattern.add_node(oblique_node) pattern.add_dependency(verb_node, oblique_node, r'obl:tmod|obl:npmod|obl') for match in dep_graph.match(pattern): dep_verb_node = match[verb_node] dep_oblique_node = match[oblique_node] if oia_graph.has_relation(dep_verb_node, dep_oblique_node, direct_link=False): continue oblique_edge = dep_graph.get_dependency(dep_verb_node, dep_oblique_node) oblique_types = oblique_edge.values() if "tmod" in oblique_types: oia_pred_node = oia_graph.add_aux("TIME_IN") arg1_node = oia_graph.add_words(dep_verb_node.position) arg2_node = oia_graph.add_words(dep_oblique_node.position) oia_graph.add_argument(oia_pred_node, arg1_node, 1, mod=True) oia_graph.add_argument(oia_pred_node, arg2_node, 2) else: # "npmod" in oblique_types and others oia_verb_node = oia_graph.add_words(dep_verb_node.position) obl_node = oia_graph.add_words(dep_oblique_node.position) oia_graph.add_mod(obl_node, oia_verb_node)
def multi_words_cc(dep_graph: DependencyGraph): """ arise on to the "on to" should be combined :param dep_graph: :param oia_graph: :return: """ mark_phrases = [] for node in dep_graph.nodes(): marks = [] for n, l in dep_graph.children(node, filter=lambda n, l: "cc" == l): marks.extend(dep_graph.offsprings(n)) if not marks: continue if len(marks) > 1: if any([x.UPOS in {"NOUN", "NUM", "VERB"} for x in marks]): continue marks.sort(key=lambda n: n.LOC) mark_phrases.append((node, marks)) for node, marks in mark_phrases: mark_min_loc = marks[0].LOC mark_max_loc = marks[-1].LOC marks = [n for n in dep_graph.nodes() if mark_min_loc <= n.LOC <= mark_max_loc] if any([x.UPOS in {"NOUN", "NUM", "VERB"} for x in marks]): continue if not all([dep_graph.get_node(x.ID) for x in marks]): continue new_mark_node = merge_dep_nodes(marks, UPOS=marks[0].UPOS, LOC=marks[0].LOC ) dep_graph.replace_nodes(marks, new_mark_node) for mark in marks: dep_graph.remove_dependency(node, mark) if dep_graph.get_node(node.ID): dep_graph.add_dependency(node, new_mark_node, "cc")
def xcomp_verb(dep_graph: DependencyGraph): """ :param dep_graph: :return: """ pattern = DependencyGraph() pred_node = pattern.create_node() xcomp_verb_node = pattern.create_node(UPOS="VERB|AUX") xcomp_mark_node = pattern.create_node(UPOS="PART") pattern.add_dependency(pred_node, xcomp_verb_node, "xcomp") pattern.add_dependency(xcomp_verb_node, xcomp_mark_node, "mark") for match in list(dep_graph.match(pattern)): dep_pred_node = match[pred_node] dep_xcomp_verb_node = match[xcomp_verb_node] dep_xcomp_mark_node = match[xcomp_mark_node] if dep_xcomp_mark_node.LEMMA != "to": # print('--------------------------LEMMA: ',dep_xcomp_mark_node.LEMMA) # raise Exception("Unexpected Situation: xcomp mark != to let's throw out to see what happens") continue if dep_xcomp_mark_node.LOC > dep_xcomp_verb_node.LOC: raise Exception( "Unexpected Situation: xcomp mark after the xcomp verb") pred_nodes = list( dep_graph.parents(dep_xcomp_verb_node, filter=lambda n, l: "xcomp" in l)) if len(pred_nodes) > 1: raise Exception( "Unexpected Situation: Multiple xcomp parents found") new_verb_phrase = [dep_xcomp_mark_node, dep_xcomp_verb_node] dep_new_verb = merge_dep_nodes(new_verb_phrase, UPOS="VERB", LOC=dep_xcomp_verb_node.LOC) dep_graph.replace_nodes(new_verb_phrase, dep_new_verb)
def amod_obl(dep_graph: DependencyGraph): """ ##### include: more than, successful by :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() noun_node = DependencyGraphNode(UPOS=r"NOUN|PRON") adj_node = DependencyGraphNode(UPOS="ADJ") adp_node = DependencyGraphNode(UPOS="ADP") obl_node = DependencyGraphNode() pattern.add_nodes([noun_node, adj_node, adp_node, obl_node]) pattern.add_dependency(noun_node, adj_node, r'amod') pattern.add_dependency(adj_node, obl_node, r'obl:\w+') pattern.add_dependency(obl_node, adp_node, r'case') more_than_pred = [] for match in dep_graph.match(pattern): dep_noun_node = match[noun_node] dep_adj_node = match[adj_node] dep_obl_node = match[obl_node] dep_adp_node = match[adp_node] obl_nodes = list( dep_graph.children(dep_adj_node, filter=lambda n, l: "obl" in l)) if len(obl_nodes) > 1: # similar in form to the one continue if dep_adp_node.FORM not in dep_graph.get_dependency( dep_adj_node, dep_obl_node).values(): continue if dep_noun_node.LOC < dep_adj_node.LOC < dep_adp_node.LOC < dep_obl_node.LOC: more_than_pred.append( (dep_noun_node, dep_adj_node, dep_obl_node, dep_adp_node)) for dep_noun_node, dep_adj_node, dep_obl_node, dep_adp_node in more_than_pred: nodes = [dep_adj_node, dep_adp_node] more_than_pred = merge_dep_nodes(nodes, UPOS="ADP", LOC=dep_adp_node.LOC) dep_graph.remove_dependency(dep_noun_node, dep_adj_node) dep_graph.remove_dependency(dep_adj_node, dep_obl_node) dep_graph.replace_nodes([dep_adj_node, dep_adp_node], more_than_pred) dep_graph.add_dependency(dep_noun_node, dep_obl_node, "nmod:" + more_than_pred.FORM)
def such_that(dep_graph: DependencyGraph): """ ##### such a high price that :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() noun_node = DependencyGraphNode(UPOS="NOUN") such_node = DependencyGraphNode(FORM="such") clause_pred_node = DependencyGraphNode(UPOS="VERB") that_node = DependencyGraphNode(FORM="that") pattern.add_nodes([noun_node, such_node, clause_pred_node, that_node]) pattern.add_dependency(noun_node, such_node, r'det:predet') pattern.add_dependency(such_node, clause_pred_node, r'advcl:that') pattern.add_dependency(clause_pred_node, that_node, r'mark') such_that_pred = [] for match in dep_graph.match(pattern): dep_noun_node = match[noun_node] dep_such_node = match[such_node] dep_clause_pred_node = match[clause_pred_node] dep_that_node = match[that_node] if dep_such_node.LOC < dep_noun_node.LOC < dep_that_node.LOC < dep_clause_pred_node.LOC: such_that_pred.append((dep_noun_node, dep_such_node, dep_clause_pred_node, dep_that_node)) for dep_noun_node, dep_such_node, dep_clause_pred_node, dep_that_node in such_that_pred: nodes = [dep_such_node, dep_that_node] such_that_pred = merge_dep_nodes(nodes, UPOS="SCONJ", LOC=dep_that_node.LOC) dep_graph.add_node(such_that_pred) dep_graph.add_dependency(dep_noun_node, dep_clause_pred_node, "advcl:" + such_that_pred.FORM) dep_graph.add_dependency(dep_clause_pred_node, such_that_pred, "mark") dep_graph.remove_node(dep_such_node) dep_graph.remove_node(dep_that_node)
def adv_question(dep_graph: DependencyGraph, oia_graph: OIAGraph, context: UD2OIAContext): """ :param dep_graph: :param oia_graph: :return: """ pattern = DependencyGraph() question_node = pattern.create_node( UPOS="ADV|ADJ", LEMMA=r"(\bhow\b|\bwhat\b|\bwhere\b|\bwhen\b|why\b)\w*") verb_node = pattern.create_node(UPOS="VERB|AUX") # subj_node = pattern.create_node() pattern.add_dependency(verb_node, question_node, "advmod|amod") # pattern.add_dependency(verb_node, subj_node, r"\w*subj") for match in list(dep_graph.match(pattern)): dep_question_node, dep_verb_node = \ [match[x] for x in (question_node, verb_node)] # if not dep_question_node.LOC < dep_subj_node.LOC: # # not a question # continue oia_question_node = oia_graph.add_words(dep_question_node.position) oia_verb_node = oia_graph.add_words(dep_verb_node.position) oia_graph.remove_relation(oia_verb_node, oia_question_node) for parent, rel in list(oia_graph.parents(oia_verb_node)): if rel.mod: continue oia_graph.remove_relation(parent, oia_verb_node) oia_graph.add_relation(parent, oia_question_node, rel) oia_graph.add_function(oia_question_node, oia_verb_node)
def det_of_noun(dep_graph: DependencyGraph): """ any/some/all of noun :param dep_graph: :return: """ pattern = DependencyGraph() det_node = pattern.create_node(UPOS="DET") of_node = pattern.create_node(LEMMA="of") noun2_node = pattern.create_node(UPOS="NOUN|PROPN|PRON|X|NUM|SYM") pattern.add_dependency(det_node, noun2_node, "nmod:of") pattern.add_dependency(noun2_node, of_node, "case") for match in list(dep_graph.match(pattern)): dep_det_node = match[det_node] dep_noun2_node = match[noun2_node] dep_of_node = match[of_node] if not all([dep_det_node, dep_noun2_node, dep_of_node]): # processed by others continue if isinstance(dep_noun2_node, DependencyGraphSuperNode) and dep_noun2_node.is_conj: continue dep_noun2_parents = [ parent for parent, rel in dep_graph.parents(dep_noun2_node) ] if len(dep_noun2_parents) == 1: assert dep_noun2_parents[0] == dep_det_node new_noun_nodes = [dep_det_node, dep_of_node, dep_noun2_node] new_noun = merge_dep_nodes(new_noun_nodes, UPOS=dep_det_node.UPOS, FEATS=dep_det_node.FEATS, LOC=dep_det_node.LOC) dep_graph.replace_nodes(new_noun_nodes, new_noun)
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 be_not_phrase(dep_graph: DependencyGraph): """TODO: add doc string """ pattern = DependencyGraph() be_node = pattern.create_node() # contain the be verb obj_node = pattern.create_node() # not_node = pattern.create_node(UPOS="PART") not_node = pattern.create_node() pattern.add_node(be_node) pattern.add_node(obj_node) pattern.add_node(not_node) pattern.add_dependency(be_node, obj_node, r'\w*obj\w*') pattern.add_dependency(obj_node, not_node, r'\w*advmod\w*') be_not = [] for match in dep_graph.match(pattern): # print("be_not_phrase match !!!!!!!!!!!!!!") dep_be_node = match[be_node] dep_obj_node = match[obj_node] dep_not_node = match[not_node] if not "be" in dep_be_node.LEMMA.split(" "): continue if not "not" in dep_not_node.LEMMA.split(" "): continue if (dep_not_node.LOC > dep_obj_node.LOC) or (dep_be_node.LOC > dep_not_node.LOC): continue be_not.append((dep_be_node, dep_obj_node, dep_not_node)) for dep_be_node, dep_obj_node, dep_not_node in be_not: dep_graph.remove_dependency(dep_obj_node, dep_not_node, 'advmod') verb_node = merge_dep_nodes((dep_be_node, dep_not_node), UPOS=dep_be_node.UPOS, LOC=dep_be_node.LOC) dep_graph.replace_nodes([dep_be_node, dep_not_node], verb_node)
def adnominal_clause_mark(dep_graph, oia_graph, context: UD2OIAContext): """ #### Adnominal clause with marker ##### #### the way to go / the proof that doing this is helpful ##### :param sentence: :return: """ pattern = DependencyGraph() a = pattern.create_node() b = pattern.create_node() mark = pattern.create_node() pattern.add_dependency(a, b, r'.*acl:.*') pattern.add_dependency(b, mark, "mark") for match in dep_graph.match(pattern): dep_a, dep_b, dep_mark = [match[x] for x in [a, b, mark]] if oia_graph.has_relation(dep_a, dep_b, direct_link=False): continue dep = dep_graph.get_dependency(dep_a, dep_b) for rel in dep: if "acl:" in rel: # print('-----------------rel: ',rel) prefix, value = rel.split(":") if (value.replace("_", " ") in {dep_mark.FORM, dep_mark.LEMMA} or value in dep_mark.FORM.split(" ") or value in dep_mark.LEMMA.split(" ")): a_node, b_node, mark_node = [ oia_graph.add_words(x.position) for x in [dep_a, dep_b, dep_mark] ] # TODO: decide whether function or argument oia_graph.add_argument(mark_node, a_node, 1, mod=True) oia_graph.add_argument(mark_node, b_node, 2) context.processed(dep_a, dep_b) context.processed(dep_b, dep_mark)
def aclwhose(dep_graph, oia_graph, context: UD2OIAContext): """ #### the person whose/who's cat is cute #### @return a list of four-tuple (noun, whose/who's, possessee, aclmodifier) :param sentence: :return: """ pattern = DependencyGraph() a = DependencyGraphNode() # person b = DependencyGraphNode(FEATS={"PronType": "Int"}) # whose c = DependencyGraphNode() # cat d = DependencyGraphNode() # cute pattern.add_nodes([a, b, c, d]) pattern.add_dependency(a, d, r'.*acl:relcl.*') pattern.add_dependency(d, c, r'.*nsubj|obj|iobj.*') pattern.add_dependency(c, b, r'.*nmod:poss.*') # pattern.add_dependency(b, a, r'.*ref.*') for match in dep_graph.match(pattern): dep_a, dep_b, dep_c, dep_d = [match[x] for x in [a, b, c, d]] a_node, b_node, c_node, d_node = [ oia_graph.add_words(x.position) for x in [dep_a, dep_b, dep_c, dep_d] ] oia_graph.add_function(d_node, a_node) oia_graph.add_function(b_node, c_node) oia_graph.add_ref(b_node, a_node)