Esempio n. 1
0
    def _process(t):
        """Encode tree *t* and return the string."""
        # tree transformations
        if normalize_options['make_variables']:
            t.reset_variables(normalize_options['make_variables'])
        if normalize_options['canonicalize_roles']:
            t = transform.canonicalize_roles(t, model)
        if normalize_options['rearrange'] == 'canonical':
            layout.rearrange(t, key=model.canonical_order)
        elif normalize_options['rearrange'] == 'random':
            layout.rearrange(t, key=model.random_order)

        g = layout.interpret(t, model)

        # graph transformations
        if normalize_options['reify_edges']:
            g = transform.reify_edges(g, model)
        if normalize_options['dereify_edges']:
            g = transform.dereify_edges(g, model)
        if normalize_options['reify_attributes']:
            g = transform.reify_attributes(g)
        if normalize_options['indicate_branches']:
            g = transform.indicate_branches(g, model)

        if triples:
            return codec.format_triples(g.triples,
                                        indent=bool(
                                            format_options.get('indent',
                                                               True)))
        else:
            return codec.encode(g, **format_options)
Esempio n. 2
0
def test_dereify_edges_default_codec():
    decode = def_codec.decode
    norm = lambda g: dereify_edges(g, def_model)
    encode = lambda g: def_codec.encode(g, indent=None)

    g = norm(
        decode('(a / alpha :ARG1-of (_ / have-mod-91'
               '                       :ARG2 (b / beta)))'))
    assert encode(g) == (
        '(a / alpha :ARG1-of (_ / have-mod-91 :ARG2 (b / beta)))')

    g = norm(
        decode('(a / alpha :ARG2-of (_ / have-mod-91'
               '                       :ARG1 (b / beta)))'))
    assert encode(g) == (
        '(a / alpha :ARG2-of (_ / have-mod-91 :ARG1 (b / beta)))')
Esempio n. 3
0
def _process_in(t, model, normalize_options):
    """Encode tree *t* and return the string."""
    # tree transformations
    if normalize_options['canonicalize_roles']:
        t = transform.canonicalize_roles(t, model)

    g = layout.interpret(t, model)

    # graph transformations
    if normalize_options['reify_edges']:
        g = transform.reify_edges(g, model)
    if normalize_options['dereify_edges']:
        g = transform.dereify_edges(g, model)
    if normalize_options['reify_attributes']:
        g = transform.reify_attributes(g)
    if normalize_options['indicate_branches']:
        g = transform.indicate_branches(g, model)

    return g
Esempio n. 4
0
def test_dereify_edges_amr_codec():
    decode = amr_codec.decode
    norm = lambda g: dereify_edges(g, amr_model)
    encode = lambda g: amr_codec.encode(g, indent=None)

    g = norm(
        decode('(a / alpha :ARG1-of~1 (_ / have-mod-91~2'
               '                         :ARG2~3 7~4))'))
    assert encode(g) == '(a / alpha :mod~2 7~4)'

    g = norm(
        decode('(a / alpha :ARG1-of~1 (_ / have-mod-91~2'
               '                       :ARG2~3 (b / beta~4)))'))
    assert encode(g) == '(a / alpha :mod~2 (b / beta~4))'

    g = norm(
        decode('(a / alpha :ARG2-of (_ / have-mod-91'
               '                       :ARG1 (b / beta)))'))
    assert encode(g) == '(a / alpha :mod-of (b / beta))'

    # dereification is blocked because node has additional relations
    g = norm(
        decode('(a / alpha :ARG1-of (_ / have-mod-91'
               '                       :ARG2 (b / beta)'
               '                       :polarity -))'))
    assert encode(g) == (
        '(a / alpha :ARG1-of (_ / have-mod-91 :ARG2 (b / beta) :polarity -))')

    g = norm(
        decode('''
        (a / alpha
            :ARG1-of (b / beta
                        :ARG0 p)
            :ARG1-of (g / gamma
                        :ARG0-of (_ / own-01
       	                            :ARG1 (p / pi))))'''))
    assert encode(g) == ('(a / alpha :ARG1-of (b / beta :ARG0 p)'
                         ' :ARG1-of (g / gamma :poss (p / pi)))')