Ejemplo n.º 1
0
    def process_pp_when_be_is_root(relations, index, context, engine, info,
                                   subjs):

        """TODO: Docstring for process_pp_when_be_is_root."""

        prep_indices = Relation.get_children_with_dep('prep', relations,
                                                      index)
        if not prep_indices:
            return []

        if subjs['return_list'][0].lower() == 'it':
            prep_index = prep_indices[0]
            pobj_children = Relation.get_children_with_dep('pobj', relations, prep_index)
            if pobj_children:
                pobj_index = pobj_children[0]
            else:
                return []

            pobj_return_value = engine.analyze(relations, pobj_index, context +
                                               [index, prep_index])

            return_list = []
            for noun in pobj_return_value['return_list']:
                return_list.append(relations[prep_index].word + ' ' + noun)

            engine.mark_processed(relations, prep_index)

            return return_list
        else:
            for prep_index in prep_indices:
                engine.analyze(relations, prep_index, context + [index])
            return []
Ejemplo n.º 2
0
    def process_conjs(relations, index, context, engine, info, subjs, auxs,
                      prop_ids):
        conj_indices = Relation.get_children_with_dep('conj', relations, index)

        if conj_indices != []:
            cc_indices = Relation.get_children_with_dep('cc', relations, index)

            if cc_indices:
                conjunction = engine.analyze(relations, cc_indices[0],
                                             context + [index])
            else:
                conjunction = None

            preconj_indices = Relation.get_children_with_dep(
                'preconj', relations, index)
            if preconj_indices != []:
                preconj = engine.analyze(relations, preconj_indices[0],
                                         context + [index])
                conjunction = preconj + '_' + conjunction

            for i in conj_indices:
                ret = engine.analyze(relations,
                                     i,
                                     context + [index],
                                     info={
                                         'class': 'VP',
                                         'subj': subjs,
                                         'aux': auxs
                                     })
                prop_ids.extend(ret['prop_ids'])

            if conjunction:
                conj_prop = tuple([conjunction] + prop_ids)
                engine.emit(conj_prop, 'C')
Ejemplo n.º 3
0
    def process_conjs(relations, index, context, engine):

        """TODO: Docstring for process_conjs."""

        # Composite NP with conjunction

        conj_indices = Relation.get_children_with_dep('conj', relations, index)

        if conj_indices != []:
            # Consume the cc.
            cc_indices = Relation.get_children_with_dep('cc', relations, index)
            for i in cc_indices:
                engine.analyze(relations, i, context + [index])

            # Get the conjs.
            conjs = [engine.analyze(relations, i, context + [index],
                                    info={'class': 'NP'})
                     for i in conj_indices]
            # TODO: check if this makes sense.
            conjs = [c[0] for c in conjs]
        else:
            conjs = []

        conjs = [relations[index].word] + conjs

        return conjs
Ejemplo n.º 4
0
    def process_conjs(relations, index, context, engine, info={}):
        """Process composite NP with conjunction (e.g., John and Mary)."""

        conj_indices = Relation.get_children_with_dep('conj', relations, index)

        if conj_indices != []:
            # Consume the cc.
            cc_indices = Relation.get_children_with_dep('cc', relations, index)
            for i in cc_indices:
                engine.analyze(relations, i, context + [index])

            # Get the conjs.
            conjs = [
                engine.analyze(relations,
                               i,
                               context + [index],
                               info={'class': 'NP'}) for i in conj_indices
            ]
            # TODO: check if this makes sense.
            conjs = [c[0] for c in conjs]
        else:
            conjs = []

        conjs = [relations[index].word] + conjs

        return conjs
Ejemplo n.º 5
0
    def transform(self, relations):
        for index, relation in enumerate(relations):
            if relation.rel in ('null', 'root', 'xcomp', 'rcmod')\
                    and relation.tag in ('VBZ', 'VBD', 'VBP', 'VB')\
                    and relation.word in self.verb_forms:
                xcomp_indices = Relation.get_children_with_dep(
                    'xcomp', relations, index)
                if xcomp_indices == []:
                    continue
                else:
                    xcomp_index = xcomp_indices[0]

                if relations[xcomp_index].tag == 'VB':
                    aux_indices = Relation.get_children_with_dep(
                        'aux', relations, xcomp_index)
                    to_index = [
                        index for index in aux_indices
                        if relations[index].tag == 'TO'
                    ][0]

                    # Append 'to' and the xcomp head to main verb.
                    relations[index].word += ' to ' + \
                        relations[xcomp_index].word

                    # Remove 'aux' and 'xcomp' relations.
                    delete_indices(relations, [to_index, xcomp_index])

                    # Change head of relations pointing to xcomp to point to
                    #   the main verb.
                    for i, rel in enumerate(relations):
                        if rel.head == xcomp_index - 2:
                            rel.head = index
                            relations[index].deps.append(i)

                    relations[index].deps.sort()
Ejemplo n.º 6
0
    def process_conjs(relations, index, context, engine, info, subjs, auxs,
                      prop_ids):

        """Process cc/conj."""

        conj_indices = Relation.get_children_with_dep('conj', relations,
                                                      index)

        if conj_indices != []:
            cc_indices = Relation.get_children_with_dep('cc', relations, index)

            if cc_indices:
                conjunction = engine.analyze(relations, cc_indices[0],
                                             context + [index])
            else:
                conjunction = None

            preconj_indices = Relation.get_children_with_dep('preconj',
                                                             relations, index)
            if preconj_indices != []:
                preconj = engine.analyze(relations, preconj_indices[0],
                                         context + [index])
                conjunction = preconj + '_' + conjunction

            for i in conj_indices:
                ret = engine.analyze(relations, i, context + [index],
                                     info={'class': 'VP',
                                           'subj': subjs,
                                           'aux': auxs})
                prop_ids.extend(ret['prop_ids'])

            if conjunction:
                conj_prop = tuple([conjunction] + prop_ids)
                engine.emit(conj_prop, 'C')
Ejemplo n.º 7
0
    def transform(self, relations):
        for i in range(len(relations)):
            cc_indices = Relation.get_children_with_dep('cc', relations, i)
            conj_indices = Relation.get_children_with_dep('conj', relations, i)

            if cc_indices and not conj_indices:
                relations[cc_indices[0]].rel = 'preconj'
Ejemplo n.º 8
0
    def process_pp_when_be_is_root(relations, index, context, engine, info,
                                   subjs):
        # TODO: Maybe unnecessary.

        """Process prepositional phrases when be is root."""

        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        if prep_indices == []:
            return []

        if subjs['return_list'][0].lower() == 'it':
            prep_index = prep_indices[0]
            pobj_index = Relation.get_children_with_dep('adpobj', relations,
                                                        prep_index)[0]

            pobj_return_value = engine.analyze(relations, pobj_index, context +
                                               [index, prep_index])

            return_list = []
            for noun in pobj_return_value['return_list']:
                return_list.append(relations[prep_index].word + ' ' + noun)

            engine.mark_processed(relations, prep_index)

            return return_list
        else:
            for prep_index in prep_indices:
                engine.analyze(relations, prep_index, context + [index])
            return []
Ejemplo n.º 9
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> str | list(str)

        An nn can be a single word or multiple words connected by cc/conj.

        Examples:

            * Oil prices
                nn(prices, Oil)
                -> return "Oil"
            * East and West Germany
                nn(Germany, East)
                cc(East, and)
                conj(East, West)
                -> return ["East", "West"]
        """
        conj_indices = Relation.get_children_with_dep('conj', relations, index)

        if conj_indices != []:
            # Consume the conjunction.
            cc_indices = Relation.get_children_with_dep('cc', relations, index)
            for i in cc_indices:
                engine.analyze(relations, cc_indices[0], context + [index])

            conjs = [
                engine.analyze(relations,
                               i,
                               context + [index],
                               info={'class': 'NP'}) for i in conj_indices
            ]
            conjs = [c[0] for c in conjs]  # TODO: check if this makes sense.

            return [relations[index].word] + conjs
        else:
            return relations[index].word
Ejemplo n.º 10
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> str | list(str)

        An nn can be a single word or multiple words connected by cc/conj.

        Examples:

            * Oil prices
                nn(prices, Oil)
                -> return "Oil"
            * East and West Germany
                nn(Germany, East)
                cc(East, and)
                conj(East, West)
                -> return ["East", "West"]
        """
        conj_indices = Relation.get_children_with_dep('conj', relations,
                                                      index)

        if conj_indices != []:
            # Consume the conjunction.
            cc_indices = Relation.get_children_with_dep('cc', relations, index)
            for i in cc_indices:
                engine.analyze(relations, cc_indices[0], context + [index])

            conjs = [engine.analyze(relations, i, context + [index],
                                    info={'class': 'NP'})
                     for i in conj_indices]
            conjs = [c[0] for c in conjs]  # TODO: check if this makes sense.

            return [relations[index].word] + conjs
        else:
            return relations[index].word
Ejemplo n.º 11
0
    def process_comps(relations, index, context, engine, info):
        """Process complements (direct objects, open clausal complements,
            adjectival complements, and subject predicates)."""

        dobj_index = Relation.get_children_with_dep('dobj', relations, index)
        xcomp_index = Relation.get_children_with_dep('xcomp', relations, index)
        acomp_index = Relation.get_children_with_dep('acomp', relations, index)
        attr_index = Relation.get_children_with_dep('attr', relations, index)

        comps_indices = sorted(dobj_index + xcomp_index + acomp_index +
                               attr_index)
        _comps = [
            engine.analyze(relations, i, context + [index], info)
            for i in comps_indices
        ]

        comps = []
        for comp in _comps:
            if isinstance(comp, dict):
                if 'return_value' in comp:  # xcomp
                    comp = comp['return_value']
                else:  # attr
                    comp = comp['return_list']

            if isinstance(comp, list):
                comps.extend(comp)
            else:
                if comp is not None:
                    comps.append(comp)

        return comps
Ejemplo n.º 12
0
    def transform(self, relations):
        for index, relation in enumerate(relations):
            if relation.rel in ('null', 'root', 'xcomp', 'rcmod')\
                    and relation.tag in ('VBZ', 'VBD', 'VBP', 'VB')\
                    and relation.word in self.verb_forms:
                xcomp_indices = Relation.get_children_with_dep('xcomp', relations, index)
                if not xcomp_indices:
                    continue
                else:
                    xcomp_index = xcomp_indices[0]

                if relations[xcomp_index].tag == 'VB':
                    aux_indices = Relation.get_children_with_dep('aux', relations, xcomp_index)

                    aux_indices_with_to = [index for index in aux_indices if relations[index].tag == 'TO']
                    if aux_indices_with_to:
                        to_index = aux_indices_with_to[0]
                    else:
                        continue

                    # Append 'to' and the xcomp head to main verb.
                    relations[index].word += ' to ' + \
                        relations[xcomp_index].word

                    # Remove 'aux' and 'xcomp' relations.
                    delete_indices(relations, [to_index, xcomp_index])

                    # Change head of relations pointing to xcomp to point to
                    #   the main verb.
                    for i, rel in enumerate(relations):
                        if rel.head == xcomp_index - 2:
                            rel.head = index
                            relations[index].deps.append(i)

                    relations[index].deps.sort()
Ejemplo n.º 13
0
    def process_pp_when_be_is_root(relations, index, context, engine, info,
                                   subjs):
        """TODO: Docstring for process_pp_when_be_is_root."""

        prep_indices = Relation.get_children_with_dep('prep', relations, index)
        if prep_indices == []:
            return []

        if subjs['return_list'][0].lower() == 'it':
            prep_index = prep_indices[0]
            pobj_index = Relation.get_children_with_dep(
                'pobj', relations, prep_index)[0]

            pobj_return_value = engine.analyze(relations, pobj_index,
                                               context + [index, prep_index])

            return_list = []
            for noun in pobj_return_value['return_list']:
                return_list.append(relations[prep_index].word + ' ' + noun)

            engine.mark_processed(relations, prep_index)

            return return_list
        else:
            for prep_index in prep_indices:
                engine.analyze(relations, prep_index, context + [index])
            return []
Ejemplo n.º 14
0
    def transform(self, relations):
        for i in range(len(relations)):
            cc_indices = Relation.get_children_with_dep('cc', relations, i)
            conj_indices = Relation.get_children_with_dep('conj', relations, i)

            if cc_indices and not conj_indices:
                relations[cc_indices[0]].rel = 'preconj'
Ejemplo n.º 15
0
    def process_comps(relations, index, context, engine, info):
        """TODO: Docstring for process_comps."""

        dobj_index = Relation.get_children_with_dep('dobj', relations, index)
        xcomp_index = Relation.get_children_with_dep('xcomp', relations, index)
        acomp_index = Relation.get_children_with_dep('acomp', relations, index)

        comps_indices = sorted(dobj_index + xcomp_index + acomp_index)
        _comps = [
            engine.analyze(relations, i, context + [index], info)
            for i in comps_indices
        ]

        comps = []
        for comp in _comps:
            if isinstance(comp, dict):
                comp = comp['return_value']

            if isinstance(comp, list):
                comps.extend(comp)
            else:
                if comp is not None:
                    comps.append(comp)

        return comps
Ejemplo n.º 16
0
    def process_pp_when_be_is_root(relations, index, context, engine, info,
                                   subjs):
        # TODO: Maybe unnecessary.
        """Process prepositional phrases when be is root."""

        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        if prep_indices == []:
            return []

        if subjs['return_list'][0].lower() == 'it':
            prep_index = prep_indices[0]
            pobj_index = Relation.get_children_with_dep(
                'adpobj', relations, prep_index)[0]

            pobj_return_value = engine.analyze(relations, pobj_index,
                                               context + [index, prep_index])

            return_list = []
            for noun in pobj_return_value['return_list']:
                return_list.append(relations[prep_index].word + ' ' + noun)

            engine.mark_processed(relations, prep_index)

            return return_list
        else:
            for prep_index in prep_indices:
                engine.analyze(relations, prep_index, context + [index])
            return []
Ejemplo n.º 17
0
    def process_comps(relations, index, context, engine, info):

        """Process complements (direct objects, open clausal complements,
            adjectival complements, and subject predicates)."""

        dobj_index = Relation.get_children_with_dep('dobj', relations, index)
        xcomp_index = Relation.get_children_with_dep('xcomp', relations, index)
        acomp_index = Relation.get_children_with_dep('acomp', relations, index)
        attr_index = Relation.get_children_with_dep('attr', relations, index)

        comps_indices = sorted(dobj_index + xcomp_index + acomp_index +
                               attr_index)
        _comps = [engine.analyze(relations, i, context + [index], info)
                  for i in comps_indices]

        comps = []
        for comp in _comps:
            if isinstance(comp, dict):
                if 'return_value' in comp:  # xcomp
                    comp = comp['return_value']
                else:  # attr
                    comp = comp['return_list']

            if isinstance(comp, list):
                comps.extend(comp)
            else:
                if comp is not None:
                    comps.append(comp)

        return comps
Ejemplo n.º 18
0
    def process_iobj(relations, index, context, engine, info):
        """TODO: Docstring for process_iobj."""

        # prep + pobj
        prep_indices = Relation.get_children_with_dep('prep', relations, index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])

        # iobj
        iobj_index = Relation.get_children_with_dep('iobj', relations, index)
        if iobj_index != []:
            engine.analyze(relations, iobj_index[0], context + [index])
Ejemplo n.º 19
0
    def process_iobj(relations, index, context, engine, info):

        """TODO: Docstring for process_iobj."""

        # prep + pobj
        prep_indices = Relation.get_children_with_dep('prep', relations, index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])

        # iobj
        iobj_index = Relation.get_children_with_dep('iobj', relations, index)
        if iobj_index != []:
            engine.analyze(relations, iobj_index[0], context + [index])
Ejemplo n.º 20
0
    def process_iobj(relations, index, context, engine, info):
        """Process the indirect object."""

        # adpmod + adpobj
        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])

        # iobj
        iobj_index = Relation.get_children_with_dep('iobj', relations, index)
        if iobj_index != []:
            engine.analyze(relations, iobj_index[0], context + [index])
Ejemplo n.º 21
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> None

        Prepositional phrases always generate new propositions, according to
            Chand et al.'s manual.

        Examples:

            * to the city
                pobj(to, city)
                det(city, the)
                -> emit((to the city,))

            * to both East and West Germany
                pobj(to, Germany)
                preconj(Germany, both)
                nn(Germany, East)
                cc(East, and)
                conj(East, West)
                -> emit((to East Germany, )) # Proposition x
                -> emit((to West Germany, )) # Proposition y
                -> emit((both, x, y))

            * TODO: insert example with PCOMP.
        """
        # pobj
        pobj_index = Relation.get_children_with_dep('pobj', relations, index)
        if pobj_index != []:
            pobjs = engine.analyze(relations, pobj_index[0], context + [index])

            emitted_prop_ids = []
            for pobj in pobjs['return_list']:
                prop_id = engine.emit((relations[index].word + ' ' + pobj, ),
                                      'M')
                emitted_prop_ids.append(prop_id)

            if pobjs['ids_for_preconj'] != []:
                indices = [
                    j for i, j in enumerate(emitted_prop_ids)
                    if i in pobjs['ids_for_preconj']
                ]
                proposition = tuple([pobjs['preconj']] + indices)
                engine.emit(proposition, 'C')

        # pcomp
        pcomp_index = Relation.get_children_with_dep('pcomp', relations, index)
        if pcomp_index != []:
            pcomp = engine.analyze(relations, pcomp_index[0],
                                   context + [index])['return_value']
            if pcomp is not None:
                engine.emit((relations[index].word + ' ' + pcomp, ), 'M')
Ejemplo n.º 22
0
    def process_iobj(relations, index, context, engine, info):

        """Process the indirect object."""

        # adpmod + adpobj
        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])

        # iobj
        iobj_index = Relation.get_children_with_dep('iobj', relations, index)
        if iobj_index != []:
            engine.analyze(relations, iobj_index[0], context + [index])
Ejemplo n.º 23
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> None

        Prepositional phrases always generate new propositions, according to
            Chand et al.'s manual.

        Examples:

            * to the city
                pobj(to, city)
                det(city, the)
                -> emit((to the city,))

            * to both East and West Germany
                pobj(to, Germany)
                preconj(Germany, both)
                nn(Germany, East)
                cc(East, and)
                conj(East, West)
                -> emit((to East Germany, )) # Proposition x
                -> emit((to West Germany, )) # Proposition y
                -> emit((both, x, y))

            * TODO: insert example with PCOMP.
        """
        # adpobj
        pobj_index = Relation.get_children_with_dep('adpobj', relations, index)
        if pobj_index != []:
            pobjs = engine.analyze(relations, pobj_index[0], context + [index])

            emitted_prop_ids = []
            for pobj in pobjs['return_list']:
                prop_id = engine.emit((relations[index].word + ' ' + pobj,),
                                      'M')
                emitted_prop_ids.append(prop_id)

            if pobjs['ids_for_preconj'] != []:
                indices = [j for i, j in enumerate(emitted_prop_ids)
                           if i in pobjs['ids_for_preconj']]
                proposition = tuple([pobjs['preconj']] + indices)
                engine.emit(proposition, 'C')

        # adpcomp
        pcomp_index = Relation.get_children_with_dep('adpcomp', relations,
                                                     index)
        if pcomp_index != []:
            pcomp = engine.analyze(relations, pcomp_index[0],
                                   context + [index])['return_value']
            if pcomp is not None:
                engine.emit((relations[index].word + ' ' + pcomp,), 'M')
Ejemplo n.º 24
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> str

        Nummerical modifiers are treated in the same way as adjectives.
            This ruleset assembles and returns the number, and it's up
            to the calling NounPhraseRuleset to emit the propositions.
            This ruleset also emits propositions for quantifier phrase
            modifiers.

        Examples:

            * About 200 people
                num(people, 200)
                quantmod(200, About)
                -> emit((200, about)) # by calling QuantmodRuleset
                -> return "200"
        """
        number_indices = Relation.get_children_with_dep(
            'number', relations, index)
        cc_indices = Relation.get_children_with_dep('cc', relations, index)
        conj_indices = Relation.get_children_with_dep('conj', relations, index)

        indices = sorted([index] + number_indices + cc_indices + conj_indices)

        words = []
        for n in indices:
            if n != index:
                word = engine.analyze(relations,
                                      n,
                                      context + [index],
                                      info={'class': 'NP'})
            else:
                word = relations[index].word

            if isinstance(word, str):
                words.append(word)
            elif isinstance(word, list):
                words += word

        this_number = ' '.join(words)

        # Process quantmods
        quantmod_indices = Relation.get_children_with_dep(
            'quantmod', relations, index)
        for q in quantmod_indices:
            engine.analyze(relations, q, context + [index],
                           {'num': this_number})

        return this_number
Ejemplo n.º 25
0
    def extract(self, relations, index, context, engine, info={}):
        """extract(relations, index, context, engine, info) -> str

        Nummerical modifiers are treated in the same way as adjectives.
            This ruleset assembles and returns the number, and it's up
            to the calling NounPhraseRuleset to emit the propositions.
            This ruleset also emits propositions for quantifier phrase
            modifiers.

        Examples:

            * About 200 people
                num(people, 200)
                quantmod(200, About)
                -> emit((200, about)) # by calling QuantmodRuleset
                -> return "200"
        """
        number_indices = Relation.get_children_with_dep('number',
                                                        relations, index)
        cc_indices = Relation.get_children_with_dep('cc',
                                                    relations, index)
        conj_indices = Relation.get_children_with_dep('conj',
                                                      relations, index)

        indices = sorted([index] + number_indices + cc_indices + conj_indices)

        words = []
        for n in indices:
            if n != index:
                word = engine.analyze(relations, n, context + [index],
                                      info={'class': 'NP'})
            else:
                word = relations[index].word

            if isinstance(word, str):
                words.append(word)
            elif isinstance(word, list):
                words += word

        this_number = ' '.join(words)

        # Process quantmods
        quantmod_indices = Relation.get_children_with_dep('quantmod',
                                                          relations, index)
        for q in quantmod_indices:
            engine.analyze(relations, q, context + [index],
                           {'num': this_number})

        return this_number
Ejemplo n.º 26
0
    def extract(self, relations, index, context, engine, info={}):
        cc_indices = Relation.get_children_with_dep('cc', relations, index)

        if cc_indices != []:
            engine.analyze(relations, cc_indices[0], context + [index])
            conj_indices = Relation.get_children_with_dep('conj', relations,
                                                          index)
            conjs = [engine.analyze(relations, i, context + [index],
                                    info={'class': 'NP'})
                     for i in conj_indices]
            conjs = [c[0] for c in conjs]  # TODO: check if this makes sense.

            return [relations[index].word] + conjs
        else:
            return [relations[index].word]
Ejemplo n.º 27
0
    def extract(self, relations, index, context, engine, info={}):
        cc_indices = Relation.get_children_with_dep('cc', relations, index)

        if cc_indices != []:
            engine.analyze(relations, cc_indices[0], context + [index])
            conj_indices = Relation.get_children_with_dep('conj', relations,
                                                          index)
            conjs = [engine.analyze(relations, i, context + [index],
                                    info={'class': 'NP'})
                     for i in conj_indices]
            conjs = [c[0] for c in conjs]  # TODO: check if this makes sense.

            return [relations[index].word] + conjs
        else:
            return [relations[index].word]
Ejemplo n.º 28
0
    def process_auxs(relations, index, context, engine, info):
        """Process auxiliaries and modals."""

        aux_index = Relation.get_children_with_dep('aux', relations, index)
        auxpass_index = Relation.get_children_with_dep('auxpass', relations,
                                                       index)
        auxs_index = sorted(aux_index + auxpass_index)
        auxs = [
            engine.analyze(relations, i, context + [index]) for i in auxs_index
        ]

        if auxs == [] and 'aux' in info:
            auxs = info['aux']

        return auxs
Ejemplo n.º 29
0
    def process_ignorables(relations, index, context, engine, info):
        """Process elements that can be ignored (complm - DEPRECATED,
            and mark)."""

        # complm
        complm_indices = Relation.get_children_with_dep(
            'complm', relations, index)
        for i in complm_indices:
            engine.analyze(relations, i, context + [index])

        # TODO: check if this makes sense.
        # mark
        mark_indices = Relation.get_children_with_dep('mark', relations, index)
        for i in mark_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 30
0
    def process_auxs(relations, index, context, engine, info):

        """Process auxiliaries and modals."""

        aux_index = Relation.get_children_with_dep('aux', relations, index)
        auxpass_index = Relation.get_children_with_dep('auxpass', relations,
                                                       index)
        auxs_index = sorted(aux_index + auxpass_index)
        auxs = [engine.analyze(relations, i, context + [index])
                for i in auxs_index]

        if auxs == [] and 'aux' in info:
            auxs = info['aux']

        return auxs
Ejemplo n.º 31
0
    def process_preps(relations, index, context, engine, info):

        """TODO: Docstring for process_preps."""

        prep_indices = Relation.get_children_with_dep("prep", relations, index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])
Ejemplo n.º 32
0
    def process_negs(relations, index, context, engine, info):

        """Process negations."""

        neg_indices = Relation.get_children_with_dep('neg', relations, index)
        for i in neg_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 33
0
    def process_ccomp(relations, index, context, engine, info):

        """Process clausal complements."""

        ccomp_index = Relation.get_children_with_dep('ccomp', relations, index)
        if ccomp_index != []:
            engine.analyze(relations, ccomp_index[0], context + [index], info)
Ejemplo n.º 34
0
    def process_ignorables(relations, index, context, engine, info):

        """Process elements that can be ignored (complm - DEPRECATED,
            and mark)."""

        # complm
        complm_indices = Relation.get_children_with_dep('complm', relations,
                                                        index)
        for i in complm_indices:
            engine.analyze(relations, i, context + [index])

        # TODO: check if this makes sense.
        # mark
        mark_indices = Relation.get_children_with_dep('mark', relations, index)
        for i in mark_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 35
0
    def process_auxs(relations, index, context, engine, info):
        """TODO: Docstring for process_auxs."""

        # TODO: add support for multiple auxiliaries.
        aux_index = Relation.get_children_with_dep('aux', relations, index)
        auxpass_index = Relation.get_children_with_dep('auxpass', relations,
                                                       index)
        auxs_index = sorted(aux_index + auxpass_index)
        auxs = [
            engine.analyze(relations, i, context + [index]) for i in auxs_index
        ]

        if auxs == [] and 'aux' in info:
            auxs = info['aux']

        return auxs
Ejemplo n.º 36
0
    def process_vmods(relations, index, context, engine, info):
        """Processes reduced non-finite verbal modifiers."""

        vmod_indices = Relation.get_children_with_dep('vmod', relations, index)

        for i in vmod_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 37
0
    def process_adpmods(relations, index, context, engine, info):
        """Process adpositional modifiers (e.g., angry with you)."""

        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])
Ejemplo n.º 38
0
    def handle_cop_with_np(self, relations, index, context, engine, info):

        """Handle copular verbs with NP complements."""

        subjs = self.process_subj(relations, index, context, engine, info)

        cop_index = Relation.get_children_with_dep('cop', relations, index)[0]
        cop = engine.analyze(relations, cop_index, context + [index])

        auxs = self.process_auxs(relations, index, context, engine, info)

        verb = ' '.join([word for word in auxs + [cop] if word is not None])

        self.process_ignorables(relations, index, context, engine, info)

        this = NounPhraseRuleset.extract(self, relations, index, context,
                                         engine, info)

        # TODO: handle cc/conj and preconj.
        complms = this['return_list']

        prop_ids = []
        for subj in subjs['return_list']:
            for compl in complms:
                # engine.emit((verb, subj, relations[index].word))
                prop_id = engine.emit((verb, subj, compl), 'P')
                prop_ids.append(prop_id)

        self.subjs = subjs
        self.auxs = auxs

        return {'return_value': None, 'prop_ids': prop_ids, 'this': this}
Ejemplo n.º 39
0
    def process_auxs(relations, index, context, engine, info):

        """TODO: Docstring for process_auxs."""

        # TODO: add support for multiple auxiliaries.
        aux_index = Relation.get_children_with_dep('aux', relations, index)
        auxpass_index = Relation.get_children_with_dep('auxpass', relations,
                                                       index)
        auxs_index = sorted(aux_index + auxpass_index)
        auxs = [engine.analyze(relations, i, context + [index])
                for i in auxs_index]

        if auxs == [] and 'aux' in info:
            auxs = info['aux']

        return auxs
Ejemplo n.º 40
0
    def process_appos(relations, index, context, engine, info):
        """Process appositional modifiers (e.g., John, my brother, is here)."""

        appos_indices = Relation.get_children_with_dep('appos', relations,
                                                       index)
        for i in appos_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 41
0
    def handle_cop_with_adjp(self, relations, index, context, engine, info):

        """Handle copular verbs with AdjP complements."""

        subjs = self.process_subj(relations, index, context, engine, info)

        cop_index = Relation.get_children_with_dep('cop', relations, index)[0]
        cop = engine.analyze(relations, cop_index, context + [index])

        auxs = self.process_auxs(relations, index, context, engine, info)

        verb = ' '.join([word for word in auxs + [cop] if word is not None])

        self.process_ignorables(relations, index, context, engine, info)

        self.process_nmods(relations, index, context, engine, info)

        this = AdjectivalPhraseRuleset.extract(self, relations, index, context,
                                               engine, info)

        prop_ids = []
        for subj in subjs['return_list']:
            for word in this:
                prop_id = engine.emit((verb, subj, word), 'P')
                prop_ids.append(prop_id)

        self.subjs = subjs
        self.auxs = auxs

        return {'return_value': None, 'prop_ids': prop_ids}
Ejemplo n.º 42
0
    def process_adpmods(relations, index, context, engine, info={}):
        """Process adpositional modifiers (e.g., result of the action)."""

        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        for i in prep_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 43
0
    def handle_cop_with_adjp(self, relations, index, context, engine, info):
        """Handle copular verbs with ADJP complements."""

        subjs = self.process_subj(relations, index, context, engine, info)

        cop_index = Relation.get_children_with_dep('cop', relations, index)[0]
        cop = engine.analyze(relations, cop_index, context + [index])

        auxs = self.process_auxs(relations, index, context, engine, info)

        verb = ' '.join([word for word in auxs + [cop] if word is not None])

        self.process_ignorables(relations, index, context, engine, info)

        self.process_npadvmod(relations, index, context, engine, info)

        this = AdjectivalPhraseRuleset.extract(self, relations, index, context,
                                               engine, info)

        prop_ids = []
        for subj in subjs['return_list']:
            for word in this:
                prop_id = engine.emit((verb, subj, word), 'P')
                prop_ids.append(prop_id)

        self.subjs = subjs
        self.auxs = auxs

        return {'return_value': None, 'prop_ids': prop_ids}
Ejemplo n.º 44
0
    def process_ccomp(relations, index, context, engine, info):

        """TODO: Docstring for process_ccomp."""

        ccomp_index = Relation.get_children_with_dep('ccomp', relations, index)
        if ccomp_index != []:
            engine.analyze(relations, ccomp_index[0], context + [index], info)
Ejemplo n.º 45
0
    def process_vmods(relations, index, context, engine, info):
        """Processes children with label 'vmod'."""

        vmod_indices = Relation.get_children_with_dep('vmod', relations, index)

        for i in vmod_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 46
0
    def handle_cop_with_np(self, relations, index, context, engine, info):
        """Handle copular verbs with NP complements."""

        subjs = self.process_subj(relations, index, context, engine, info)

        cop_index = Relation.get_children_with_dep('cop', relations, index)[0]
        cop = engine.analyze(relations, cop_index, context + [index])

        auxs = self.process_auxs(relations, index, context, engine, info)

        verb = ' '.join([word for word in auxs + [cop] if word is not None])

        self.process_ignorables(relations, index, context, engine, info)

        this = NounPhraseRuleset.extract(self, relations, index, context,
                                         engine, info)

        # TODO: handle cc/conj and preconj.
        complms = this['return_list']

        prop_ids = []
        for subj in subjs['return_list']:
            for compl in complms:
                # engine.emit((verb, subj, relations[index].word))
                prop_id = engine.emit((verb, subj, compl), 'P')
                prop_ids.append(prop_id)

        self.subjs = subjs
        self.auxs = auxs

        return {'return_value': None, 'prop_ids': prop_ids, 'this': this}
Ejemplo n.º 47
0
Archivo: run.py Proyecto: p-h-c-s/idd3
def process_graphs(graphs):
    engine = Engine(idd3.all_rulesets, idd3.all_transformations)
    stats = defaultdict(int)

    for index in range(len(graphs)):
        print('-' * int(columns))
        relations = []
        for relation in graphs[index].nodes.values():
            relations.append(Relation(**relation))

        print(colored('Sentence %d:' % (index + 1), 'white', attrs=['bold']))
        print('\t' + get_sentence(graphs[index]))

        print(colored('Propositions:', 'white', attrs=['bold']))
        try:
            engine.analyze(relations)
            for i, prop in enumerate(engine.props):
                print(str(i + 1) + ' ' + str(prop))
                stats[prop.kind] += 1
        except Exception as e:
            logger.error('{0} in engine.analyze: {1}'.format(
                e.__class__.__name__, e))

    print('-' * int(columns))
    return stats
Ejemplo n.º 48
0
    def process_whats(relations, index, context, engine, info):
        """Processes children with label 'what'."""

        what_indices = Relation.get_children_with_dep('what', relations, index)

        for i in what_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 49
0
    def process_npadvmod(relations, index, context, engine, info={}):

        """TODO: Docstring for process_npadvmod."""

        npadvmod_indices = Relation.get_children_with_dep("npadvmod", relations, index)
        if npadvmod_indices != []:
            npadvmod = engine.analyze(relations, npadvmod_indices[0], context + [index])
            engine.emit((relations[index].word, npadvmod), "M")
Ejemplo n.º 50
0
    def process_vmods(relations, index, context, engine, info):

        """Processes reduced non-finite verbal modifiers."""

        vmod_indices = Relation.get_children_with_dep('vmod', relations, index)

        for i in vmod_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 51
0
    def process_discourse_markers(relations, index, context, engine, info):
        """TODO: Docstring for process_discourse_markers."""

        discourse_indices = Relation.get_children_with_dep(
            'discourse', relations, index)

        for i in discourse_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 52
0
    def process_appos(relations, index, context, engine, info):

        """TODO: Docstring for process_appos."""

        appos_indices = Relation.get_children_with_dep('appos',
                                                       relations, index)
        for i in appos_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 53
0
    def process_ignorables(relations, index, context, engine, info):
        """TODO: Docstring for process_ignorables."""

        # complm
        complm_indices = Relation.get_children_with_dep(
            'complm', relations, index)
        for i in complm_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 54
0
    def process_preps(relations, index, context, engine, info={}):

        """TODO: Docstring for process_preps."""

        # VP modifiers
        prep_indices = Relation.get_children_with_dep('prep', relations, index)
        for i in prep_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 55
0
    def process_advmods(relations, index, context, engine, info={}):

        """TODO: Docstring for process_advmods."""

        advmod_indices = Relation.get_children_with_dep("advmod", relations, index)
        advmods = [engine.analyze(relations, i, context + [index], {"no_emit": True}) for i in advmod_indices]

        return advmods
Ejemplo n.º 56
0
    def process_negs(relations, index, context, engine, info):

        """TODO: Docstring for process_negs."""

        # neg
        neg_indices = Relation.get_children_with_dep('neg', relations, index)
        for i in neg_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 57
0
    def process_appos(relations, index, context, engine, info):

        """TODO: Docstring for process_appos."""

        appos_indices = Relation.get_children_with_dep('appos',
                                                       relations, index)
        for i in appos_indices:
            engine.analyze(relations, i, context + [index], info)
Ejemplo n.º 58
0
    def process_preps(relations, index, context, engine):

        """TODO: Docstring for process_preps."""

        # VP modifiers
        prep_indices = Relation.get_children_with_dep('prep', relations, index)
        for i in prep_indices:
            engine.analyze(relations, i, context + [index])
Ejemplo n.º 59
0
    def process_adpmods(relations, index, context, engine, info):

        """Process adpositional modifiers (e.g., angry with you)."""

        prep_indices = Relation.get_children_with_dep('adpmod', relations,
                                                      index)
        for prep_index in prep_indices:
            engine.analyze(relations, prep_index, context + [index])
Ejemplo n.º 60
0
    def process_advmods(relations, index, context, engine, info={}):

        """TODO: Docstring for process_advmods."""

        advmod_indices = Relation.get_children_with_dep("advmod", relations, index)
        for i in advmod_indices:
            advmod = engine.analyze(relations, i, context + [index], {"no_emit": True})
            engine.emit((relations[index].word, advmod), "M")