Beispiel #1
0
def make_edges_with_intermediate_nodes(from_nodes, to_nodes, intermediate, graph):
    edges = []
    # import pdb

    # if len(to_nodes) == 1 and len(from_nodes) > 1:
    # pdb.set_trace()
    has_intermediate = False
    for f, t in product(from_nodes, to_nodes):
        int_tok = intermediate.get((f.s, t.s), None)
        repeat = int_tok in [i.s for i in from_nodes]
        has_intermediate = (int_tok is not None and int_tok != 'NULL' and f.s != t.s) or has_intermediate
        has_intermediate = has_intermediate and (not repeat)

    if has_intermediate:
        for f, t in product(from_nodes, to_nodes):
            int_tok = intermediate.get((f.s, t.s), None)
            if int_tok is None or int_tok == 'NULL' or f.s == t.s:
                int_tok = f.s  # why force this?
            else:
                pass
            sys.stderr.write('int:' + int_tok + ' in:' + f.s + '-' + t.s + '\n')
            int_node = f.makecopy()
            int_node.id = len(graph.nodes)
            int_node.s = int_tok
            int_node.to_en = True
            int_node.to_de = True
            int_node.en_id = int_node.en_id if int_node.en_id is not None else t.en_id
            int_node.de_id = int_node.de_id if int_node.de_id is not None else t.de_id
            graph.nodes.append(int_node)
            edges += get_edges(f, int_node)
            edges += get_edges(int_node, t)
    else:
        for f, t in product(from_nodes, to_nodes):
            edges += get_edges(f, t)
    return edges
Beispiel #2
0
def make_edges(from_nodes, to_nodes):
    edges = []
    for fn in from_nodes:
        for tn in to_nodes:
            edges += get_edges(fn, tn)
            # print fn.s, tn.s
    return edges
Beispiel #3
0
def make_edges(from_nodes, to_nodes):
    edges = []
    for fn in from_nodes:
        for tn in to_nodes:
            edges += get_edges(fn, tn)
            # print fn.s, tn.s
    return edges
Beispiel #4
0
def make_edges_with_intermediate_nodes(from_nodes, to_nodes, intermediate,
                                       graph):
    edges = []
    # import pdb

    # if len(to_nodes) == 1 and len(from_nodes) > 1:
    # pdb.set_trace()
    has_intermediate = False
    for f, t in product(from_nodes, to_nodes):
        int_tok = intermediate.get((f.s, t.s), None)
        repeat = int_tok in [i.s for i in from_nodes]
        has_intermediate = (int_tok is not None and int_tok != 'NULL'
                            and f.s != t.s) or has_intermediate
        has_intermediate = has_intermediate and (not repeat)

    if has_intermediate:
        for f, t in product(from_nodes, to_nodes):
            int_tok = intermediate.get((f.s, t.s), None)
            if int_tok is None or int_tok == 'NULL' or f.s == t.s:
                int_tok = f.s  # why force this?
            else:
                pass
            sys.stderr.write('int:' + int_tok + ' in:' + f.s + '-' + t.s +
                             '\n')
            int_node = f.makecopy()
            int_node.id = len(graph.nodes)
            int_node.s = int_tok
            int_node.to_en = True
            int_node.to_de = True
            int_node.en_id = int_node.en_id if int_node.en_id is not None else t.en_id
            int_node.de_id = int_node.de_id if int_node.de_id is not None else t.de_id
            graph.nodes.append(int_node)
            edges += get_edges(f, int_node)
            edges += get_edges(int_node, t)
    else:
        for f, t in product(from_nodes, to_nodes):
            edges += get_edges(f, t)
    return edges
                                                      lang=rn.lang, visible=False)
                                        new_add_nodes = [add_nodes[0][0], copy_n]

                                    assert rn.visible
                                    rn.visible = False
                                    rn.to_de = True
                                    rn_idx = get_idx_of_node(rn, nodes_in_visible_order)
                                    nodes_in_visible_order.pop(rn_idx)
                                    for w_idx, a in enumerate(new_add_nodes):
                                        a.visible = True
                                        a.to_en = True
                                        a.en_id = rn.en_id + w_idx
                                        a.graph = changed_graph
                                        a.id = len(changed_graph.nodes)
                                        changed_graph.nodes.append(a)
                                        changed_graph.edges += get_edges(rn, a)
                                        nodes_in_visible_order.insert(rn_idx + w_idx, a)
                                        new_nodes.append(a)

                                    pass
                                elif len(remove_nodes) == 1 and len(add_nodes) == 0:
                                    # todo: handle deletion
                                    adjacent_node = get_adjacent_node(remove_nodes[0], nodes_in_visible_order)
                                    if adjacent_node is None:
                                        raise NotImplementedError()
                                    remove_nodes.append(adjacent_node)
                                    # now combine remove node and adjacent node
                                    min_rn_idx = min(
                                        [get_idx_of_node(rn, nodes_in_visible_order) for rn in remove_nodes])
                                    for rn in remove_nodes:
                                        assert rn.visible
Beispiel #6
0
                                        ]

                                    assert rn.visible
                                    rn.visible = False
                                    rn.to_de = True
                                    rn_idx = get_idx_of_node(
                                        rn, nodes_in_visible_order)
                                    nodes_in_visible_order.pop(rn_idx)
                                    for w_idx, a in enumerate(new_add_nodes):
                                        a.visible = True
                                        a.to_en = True
                                        a.en_id = rn.en_id + w_idx
                                        a.graph = changed_graph
                                        a.id = len(changed_graph.nodes)
                                        changed_graph.nodes.append(a)
                                        changed_graph.edges += get_edges(rn, a)
                                        nodes_in_visible_order.insert(
                                            rn_idx + w_idx, a)
                                        new_nodes.append(a)

                                    pass
                                elif len(remove_nodes) == 1 and len(
                                        add_nodes) == 0:
                                    # todo: handle deletion
                                    adjacent_node = get_adjacent_node(
                                        remove_nodes[0],
                                        nodes_in_visible_order)
                                    if adjacent_node is None:
                                        raise NotImplementedError()
                                    remove_nodes.append(adjacent_node)
                                    # now combine remove node and adjacent node