def test_error_on_app_query_non_compatible_graph(arrow_property_graph):
g = arrow_property_graph
# return a arrow property graph
with pytest.raises(
InvalidArgumentError,
match="Not compatible for arrow_property dynamic_property type",
):
sssp(g, src=6)
sg = g.project_to_simple(
v_label=0, e_label=0) # edata is empty, not compatible with sssp
with pytest.raises(graphscope.framework.errors.CompilationError):
sssp(sg, 4)
def test_serialize_roundtrip(gs_session_distributed, p2p_property_dir):
graph = gs_session_distributed.load_from(
edges={
"knows": (
Loader("{}/p2p-31_property_e_0".format(p2p_property_dir),
header_row=True),
["src_label_id", "dst_label_id", "dist"],
("src_id", "person"),
("dst_id", "person"),
),
},
vertices={
"person":
Loader("{}/p2p-31_property_v_0".format(p2p_property_dir),
header_row=True),
},
generate_eid=False,
)
graph.serialize("/tmp/serialize")
new_graph = Graph.deserialize("/tmp/serialize", gs_session_distributed)
pg = new_graph.project_to_simple(0, 0, 0, 2)
ctx = graphscope.sssp(pg, src=6)
ret = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"end": 6
}).sort_values(by=["node"]).to_numpy(dtype=float))
expect = np.array([[1.0, 260.0], [2.0, 229.0], [3.0, 310.0], [4.0, 256.0],
[5.0, 303.0]])
assert np.all(ret == expect)
def test_run_app_on_property_graph(arrow_property_graph, twitter_sssp_result):
ctx1 = graphscope.sssp(arrow_property_graph, src=4, weight="weight")
r1 = (ctx1.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(r1, twitter_sssp_result)
def test_serialize_roundtrip(gs_session_distributed, p2p_property_dir):
graph = gs_session_distributed.g(generate_eid=False)
graph = graph.add_vertices(f"{p2p_property_dir}/p2p-31_property_v_0",
"person")
graph = graph.add_edges(
f"{p2p_property_dir}/p2p-31_property_e_0",
label="knows",
src_label="person",
dst_label="person",
)
graph.save_to("/tmp/serialize")
new_graph = Graph.load_from("/tmp/serialize", gs_session_distributed)
pg = new_graph.project_to_simple(0, 0, 0, 2)
ctx = graphscope.sssp(pg, src=6)
ret = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"end": 6
}).sort_values(by=["node"]).to_numpy(dtype=float))
expect = np.array([[1.0, 260.0], [2.0, 229.0], [3.0, 310.0], [4.0, 256.0],
[5.0, 303.0]])
assert np.all(ret == expect)
def test_serialize_roundtrip(gs_session_distributed, p2p_property_dir):
graph = gs_session_distributed.g(generate_eid=False)
graph = graph.add_vertices(f"{p2p_property_dir}/p2p-31_property_v_0",
"person")
graph = graph.add_edges(
f"{p2p_property_dir}/p2p-31_property_e_0",
label="knows",
src_label="person",
dst_label="person",
)
serialization_path = os.path.join("/", tempfile.gettempprefix(),
"serialize")
graph.save_to(serialization_path)
new_graph = Graph.load_from(serialization_path, gs_session_distributed)
pg = new_graph.project(vertices={"person": []}, edges={"knows": ["dist"]})
ctx = graphscope.sssp(pg, src=6)
ret = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"end": 6
}).sort_values(by=["node"]).to_numpy(dtype=float))
expect = np.array([[1.0, 260.0], [2.0, 229.0], [3.0, 310.0], [4.0, 256.0],
[5.0, 303.0]])
assert np.all(ret == expect)
def test_border_cases():
s1 = graphscope.session(cluster_type="hosts")
s2 = graphscope.session(cluster_type="hosts")
s3 = graphscope.session(cluster_type="hosts")
s1.as_default()
assert graphscope.get_default_session() == s1
g3 = load_p2p_network(s3)
pg3 = g3.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
with pytest.raises(
ValueError,
match=
"A default session is already active. You must explicitly call Session.close().",
):
s2.as_default()
s1.close()
s2.as_default()
assert graphscope.get_default_session() == s2
s2.close()
s3.as_default()
assert graphscope.get_default_session() == s3
sssp = graphscope.sssp(pg3, src=4) # ok, g3 belong to s3
s3.close()
def test_run_app_on_pandas_graph(p2p_graph_from_pandas, sssp_result):
ctx1 = sssp(p2p_graph_from_pandas, src=6, weight="dist")
r1 = (ctx1.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r1[r1 == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r1, sssp_result["directed"])
def test_graph_to_numpy(sess):
g = load_p2p_network(sess)
pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
c = graphscope.sssp(pg, 20)
ctx_out_np = c.to_numpy("r")
g2 = g.add_column(c, {"result_0": "r"})
graph_out_np = g2.to_numpy("v:host.result_0")
r = sess.run([ctx_out_np, graph_out_np])
assert np.all(r[0] == r[1])
def test_load_only_from_efile(arrow_property_graph,
arrow_property_graph_only_from_efile):
sg1 = arrow_property_graph.project(vertices={"v0": []},
edges={"e0": ["weight"]})
sg2 = arrow_property_graph_only_from_efile.project(
vertices={"v0": []}, edges={"e0": ["weight"]})
simple_ctx1 = sssp(sg1, 20)
simple_ctx2 = sssp(sg2, 20)
v_out1 = simple_ctx1.to_numpy("v.id")
v_out2 = simple_ctx2.to_numpy("v.id")
assert v_out1.shape == (40521, )
assert v_out1.shape == v_out2.shape
assert sorted(v_out1) == sorted(v_out2)
r_out1 = simple_ctx1.to_numpy("r")
r_out2 = simple_ctx2.to_numpy("r")
assert r_out1.shape == (40521, )
assert r_out1.shape == r_out2.shape
assert sorted(r_out1) == sorted(r_out2)
def test_graph_to_dataframe(sess):
g = load_p2p_network(sess)
pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
c = graphscope.sssp(pg, 20)
ctx_out_df = c.to_dataframe({"result": "r"})
g2 = g.add_column(c, {"result_0": "r"})
graph_out_df = g2.to_dataframe({"result": "v:host.result_0"})
r = sess.run([ctx_out_df, graph_out_df])
assert r[0].equals(r[1])
def test_error_selector_context(sess):
# vertex data context
g = load_p2p_network(sess)
pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
c = graphscope.sssp(pg, 20)
with pytest.raises(SyntaxError, match="Invalid selector"):
r = c.to_dataframe({"id": "v.ID"})
with pytest.raises(ValueError, match="selector of to_dataframe must be a dict"):
r = c.to_dataframe("id")
def test_add_column(sess):
g = load_p2p_network(sess)
pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
c = graphscope.sssp(pg, 20)
g1 = g.add_column(c, {
"id_col": "v.id",
"data_col": "v.data",
"result_col": "r"
})
sess.run(g1)
def test_project_to_simple_with_id(p2p_property_graph, sssp_result):
pg = p2p_property_graph.project_to_simple(0, 0, 0, 2)
ctx = sssp(pg, src=6)
r = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r[r == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r, sssp_result["directed"])
def test_add_column_after_computation(arrow_property_graph):
sg = arrow_property_graph.project_to_simple(0, 0, 0, 0)
ret = sssp(sg, 20)
g2 = arrow_property_graph.add_column(ret, {
"id_col": "v.id",
"data_col": "v.data",
"result_col": "r"
})
assert "id_col" in g2.schema.vertex_properties[0]
assert "data_col" in g2.schema.vertex_properties[0]
assert "result_col" in g2.schema.vertex_properties[0]
def test_simulate_eager(sess):
g1_node = load_p2p_network(sess)
g1 = sess.run(g1_node)
pg_node = g1.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
pg = sess.run(pg_node)
c_node = graphscope.sssp(pg, 20)
c = sess.run(c_node)
g2_node = g1.add_column(
c, {"id_col": "v.id", "data_col": "v.data", "result_col": "r"}
)
g2 = sess.run(g2_node)
def test_context(sess):
g = load_p2p_network(sess)
pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
c = graphscope.sssp(pg, 20)
r1 = c.to_numpy("r")
r2 = c.to_dataframe({"id": "v.id", "result": "r"})
r3 = c.to_vineyard_tensor("r")
r4 = c.to_vineyard_dataframe({"id": "v.id", "data": "v.data", "result": "r"})
r = sess.run([r1, r2, r3, r4])
assert r[0].shape == (62586,)
assert r[1].shape == (62586, 2)
assert r[2] is not None
assert r[3] is not None
def test_load_only_from_efile(arrow_property_graph,
arrow_property_graph_only_from_efile):
assert (arrow_property_graph.schema.edge_properties ==
arrow_property_graph_only_from_efile.schema.edge_properties)
assert (arrow_property_graph.schema.edge_relationships ==
arrow_property_graph_only_from_efile.schema.edge_relationships)
assert (arrow_property_graph.schema.vertex_label_num ==
arrow_property_graph_only_from_efile.schema.vertex_label_num)
assert (arrow_property_graph.schema.oid_type ==
arrow_property_graph_only_from_efile.schema.oid_type)
assert (arrow_property_graph.schema.vid_type ==
arrow_property_graph_only_from_efile.schema.vid_type)
assert (arrow_property_graph_only_from_efile.schema.vertex_labels ==
arrow_property_graph.schema.vertex_labels)
assert arrow_property_graph_only_from_efile.schema.vertex_properties == [
{
"id": types_pb2.LONG
},
{
"id": types_pb2.LONG
},
]
sg1 = arrow_property_graph.project_to_simple(0, 0, 0, 0)
sg2 = arrow_property_graph_only_from_efile.project_to_simple(0, 0, 0, 0)
simple_ctx1 = sssp(sg1, 20)
simple_ctx2 = sssp(sg2, 20)
v_out1 = simple_ctx1.to_numpy("v.id")
v_out2 = simple_ctx2.to_numpy("v.id")
assert v_out1.shape == (40521, )
assert v_out1.shape == v_out2.shape
assert sorted(v_out1) == sorted(v_out2)
r_out1 = simple_ctx1.to_numpy("r")
r_out2 = simple_ctx2.to_numpy("r")
assert r_out1.shape == (40521, )
assert r_out1.shape == r_out2.shape
assert sorted(r_out1) == sorted(r_out2)
def test_add_column_after_computation(arrow_property_graph):
sg = arrow_property_graph.project(vertices={"v0": ["id"]},
edges={"e0": ["weight"]})
ret = sssp(sg, 20)
g2 = arrow_property_graph.add_column(ret, {
"id_col": "v.id",
"data_col": "v.data",
"result_col": "r"
})
assert "id_col" in [p.name for p in g2.schema.get_vertex_properties("v0")]
assert "data_col" in [
p.name for p in g2.schema.get_vertex_properties("v0")
]
assert "result_col" in [
p.name for p in g2.schema.get_vertex_properties("v0")
]
def test_serialize_roundtrip(p2p_property_dir):
gs_image, gie_manager_image = get_gs_image_on_ci_env()
sess = graphscope.session(
num_workers=2,
k8s_gs_image=gs_image,
k8s_gie_graph_manager_image=gie_manager_image,
k8s_coordinator_cpu=0.5,
k8s_coordinator_mem="2500Mi",
k8s_vineyard_cpu=0.1,
k8s_vineyard_mem="512Mi",
k8s_engine_cpu=0.1,
k8s_engine_mem="1500Mi",
k8s_vineyard_shared_mem="2Gi",
k8s_volumes=get_k8s_volumes(),
)
graph = sess.load_from(
edges={
"knows": (
Loader("{}/p2p-31_property_e_0".format(p2p_property_dir),
header_row=True),
["src_label_id", "dst_label_id", "dist"],
("src_id", "person"),
("dst_id", "person"),
),
},
vertices={
"person":
Loader("{}/p2p-31_property_v_0".format(p2p_property_dir),
header_row=True),
},
generate_eid=False,
)
graph.serialize("/tmp/serialize")
graph.unload()
new_graph = Graph.deserialize("/tmp/serialize", sess)
pg = new_graph.project_to_simple(0, 0, 0, 2)
ctx = graphscope.sssp(pg, src=6)
ret = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"end": 6
}).sort_values(by=["node"]).to_numpy(dtype=float))
expect = np.array([[1.0, 260.0], [2.0, 229.0], [3.0, 310.0], [4.0, 256.0],
[5.0, 303.0]])
assert np.all(ret == expect)
def test_sssp():
prev_result = None
for num_workers in (1, 2, 3, 4):
sess, g = p2p_property_graph(num_workers, True)
sg = g.project_to_simple(0, 0, 0, 2)
ctx = sssp(sg, 6)
curr_result = (ctx.to_dataframe({
"node": "v.id",
"result": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
if prev_result is not None and not np.array_equal(
prev_result, curr_result):
raise RuntimeError(
"Result is not consistent with different workers, current number of workers: %d",
num_workers,
)
prev_result = curr_result
sess.close()
def test_serialize_roundtrip(gs_session_local):
graph = gs_session_local.g(generate_eid=False)
p2p_property_dir = os.path.expandvars("${GS_TEST_DIR}/property")
graph = graph.add_vertices(f"{p2p_property_dir}/p2p-31_property_v_0",
"person")
graph = graph.add_edges(
f"{p2p_property_dir}/p2p-31_property_e_0",
label="knows",
src_label="person",
dst_label="person",
)
logger.debug("finishing loading graphs")
serialization_path = os.path.join("/", tempfile.gettempprefix(),
"serialize")
shutil.rmtree(serialization_path, ignore_errors=True)
graph.save_to(serialization_path)
logger.debug("finishing serializing graph to %s", serialization_path)
new_graph = Graph.load_from(serialization_path, gs_session_local)
logger.info("finishing loading new graph from serialization %s",
serialization_path)
pg = new_graph.project(vertices={"person": []}, edges={"knows": ["dist"]})
ctx = graphscope.sssp(pg, src=6)
ret = (ctx.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"end": 6
}).sort_values(by=["node"]).to_numpy(dtype=float))
expect = np.array([[1.0, 260.0], [2.0, 229.0], [3.0, 310.0], [4.0, 256.0],
[5.0, 303.0]])
assert np.all(ret == expect)
def test_error_on_run_app(projected_pg_no_edge_data):
# compile error: wrong type of edge data with sssp
with pytest.raises(graphscope.CompilationError):
sssp(projected_pg_no_edge_data, src=4)
def test_run_app_on_string_oid_graph(p2p_project_directed_graph_string):
ctx = sssp(p2p_project_directed_graph_string, src="6")
r1 = ctx.to_dataframe({"node": "v.id", "r": "r"})
assert r1[r1["node"] == "6"].r.values[0] == 0.0
def test_app_on_undirected_graph(
p2p_project_undirected_graph,
sssp_result,
pagerank_result,
bfs_result,
wcc_result,
lpa_result,
triangles_result,
kshell_result,
):
# sssp
ctx1 = sssp(p2p_project_undirected_graph, src=6)
r1 = (ctx1.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r1[r1 == 1.7976931348623157e308] = float(
"inf") # replace limit<double>::max with inf
assert np.allclose(r1, sssp_result["undirected"])
assert np.allclose(
ctx1.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy(),
[[1.0, 31.0], [2.0, 39.0], [3.0, 78.0]],
)
assert np.allclose(
sorted(ctx1.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})),
[31.0, 39.0, 78.0],
)
# pagerank (only work on undirected graph)
ctx2 = pagerank(p2p_project_undirected_graph, delta=0.85, max_round=10)
r2 = (ctx2.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(r2, pagerank_result["undirected"])
ctx3 = pagerank(p2p_project_undirected_graph, 0.85, 10)
r3 = (ctx3.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(r3, pagerank_result["undirected"])
# r4 = pagerank(arrow_project_graph, 10, 0.85) # check max_round=10
# assert r4 is not None
ctx5 = pagerank(p2p_project_undirected_graph, "0.85", "10")
r5 = (ctx5.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(r5, pagerank_result["undirected"])
ctx6 = pagerank(p2p_project_undirected_graph)
r6 = (ctx6.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(r6, pagerank_result["undirected"])
assert np.allclose(
ctx6.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy(),
[
[1.0, 6.153724343761569e-05],
[2.0, 9.280361872165397e-05],
[3.0, 1.643246086005906e-05],
],
)
assert np.allclose(
sorted(ctx6.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})),
sorted([
6.153724343761569e-05, 9.280361872165397e-05, 1.643246086005906e-05
]),
)
# bfs
ctx7 = bfs(p2p_project_undirected_graph, src=6)
r7 = (ctx7.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r7 == bfs_result["undirected"])
assert np.all(
ctx7.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 1], [2, 2], [3, 2]])
assert np.all(
sorted(ctx7.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})) == [1, 2, 2])
# wcc
ctx8 = wcc(p2p_project_undirected_graph)
r8 = (ctx8.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r8 == wcc_result)
assert np.all(
ctx8.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 1], [2, 1], [3, 1]])
assert np.all(
ctx8.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
}) == [1, 1, 1])
# lpa
ctx9 = lpa(p2p_project_undirected_graph, max_round=10)
r9 = (ctx9.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r9 == lpa_result)
assert np.all(
ctx9.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 1], [2, 2], [3, 2]])
assert np.all(
sorted(ctx9.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})) == [1, 2, 2])
# kshell
ctx10 = k_shell(p2p_project_undirected_graph, k=3)
r10 = (ctx10.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r10 == kshell_result)
assert np.all(
ctx10.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 0], [2, 0], [3, 0]])
assert np.all(
ctx10.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
}) == [0, 0, 0])
# triangles
ctx_triangles = triangles(p2p_project_undirected_graph)
ret_triangles = (ctx_triangles.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_triangles, triangles_result["undirected"])
# louvain
ctx10 = louvain(p2p_project_undirected_graph,
min_progress=50,
progress_tries=2)
# simple_path
assert is_simple_path(p2p_project_undirected_graph, [1, 10])
def test_error_on_non_graph():
eg1 = nx.Graph() # networkx graph is unsupported
with pytest.raises(InvalidArgumentError,
match="Missing graph_type attribute in graph object"):
sssp(eg1, 4)
def test_run_app_on_directed_graph(
p2p_project_directed_graph,
sssp_result,
pagerank_result,
bfs_result,
clustering_result,
dc_result,
ev_result,
katz_result,
):
# sssp
ctx1 = sssp(p2p_project_directed_graph, src=6)
r1 = (ctx1.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r1[r1 == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r1, sssp_result["directed"])
ctx2 = sssp(p2p_project_directed_graph, 6)
r2 = (ctx2.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r2[r2 == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r2, sssp_result["directed"])
assert np.allclose(
ctx2.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy(),
[[1.0, 260.0], [2.0, 229.0], [3.0, 310.0]],
)
assert np.allclose(
sorted(ctx1.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})),
sorted([260.0, 229.0, 310.0]),
)
r3 = sssp(p2p_project_directed_graph, 100000000)
assert r3 is not None
# bfs
ctx4 = bfs(p2p_project_directed_graph, src=6)
r4 = (ctx4.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r4 == bfs_result["directed"])
ctx5 = bfs(p2p_project_directed_graph, 6)
r5 = (ctx5.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r5 == bfs_result["directed"])
assert np.all(
ctx5.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 5], [2, 5], [3, 6]])
assert np.all(
sorted(ctx5.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})) == [5, 5, 6])
def simple_context(arrow_property_graph):
sg = arrow_property_graph.project_to_simple(0, 0, 0, 0)
return sssp(sg, 20)
def test_run_app_on_directed_graph(
p2p_project_directed_graph,
sssp_result,
pagerank_result,
hits_result,
bfs_result,
clustering_result,
dc_result,
ev_result,
katz_result,
):
# sssp
ctx1 = sssp(p2p_project_directed_graph, src=6)
r1 = (ctx1.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r1[r1 == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r1, sssp_result["directed"])
ctx2 = sssp(p2p_project_directed_graph, 6)
r2 = (ctx2.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
r2[r2 == 1.7976931348623157e308] = float(
"inf") # replace limit::max with inf
assert np.allclose(r2, sssp_result["directed"])
assert np.allclose(
ctx2.to_dataframe({
"node": "v.id",
"r": "r"
},
vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy(),
[[1.0, 260.0], [2.0, 229.0], [3.0, 310.0]],
)
assert np.allclose(
sorted(ctx1.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})),
sorted([260.0, 229.0, 310.0]),
)
r3 = sssp(p2p_project_directed_graph, 100000000)
assert r3 is not None
# pagerank
ctx_pr = pagerank(p2p_project_directed_graph, delta=0.85, max_round=10)
ret_pr = (ctx_pr.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_pr, pagerank_result["directed"])
# hits
ctx_hits = hits(p2p_project_directed_graph, tolerance=0.001)
ret_hub = (ctx_hits.to_dataframe({
"node": "v.id",
"hub": "r.hub"
}).sort_values(by=["node"]).to_numpy(dtype=float))
ret_auth = (ctx_hits.to_dataframe({
"node": "v.id",
"auth": "r.auth"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_hub, hits_result["hub"])
assert np.allclose(ret_auth, hits_result["auth"])
# bfs
ctx4 = bfs(p2p_project_directed_graph, src=6)
r4 = (ctx4.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r4 == bfs_result["directed"])
ctx5 = bfs(p2p_project_directed_graph, 6)
r5 = (ctx5.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=int))
assert np.all(r5 == bfs_result["directed"])
assert np.all(
ctx5.to_dataframe(
{
"node": "v.id",
"r": "r"
}, vertex_range={
"begin": 1,
"end": 4
}).sort_values(by=["node"]).to_numpy() == [[1, 5], [2, 5], [3, 6]])
assert np.all(
sorted(ctx5.to_numpy("r", vertex_range={
"begin": 1,
"end": 4
})) == [5, 5, 6])
# simple_path
assert is_simple_path(p2p_project_directed_graph, [1, 10])
with pytest.raises(InvalidArgumentError,
match="Louvain not support directed graph."):
louvain(p2p_project_directed_graph)
# clustering
ctx_clustering = clustering(p2p_project_directed_graph)
ret_clustering = (ctx_clustering.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_clustering, clustering_result["directed"])
# degree_centrality
ctx_dc = degree_centrality(p2p_project_directed_graph)
ret_dc = (ctx_dc.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_dc, dc_result["directed"])
# eigenvector_centrality
ctx_ev = eigenvector_centrality(p2p_project_directed_graph)
ret_ev = (ctx_ev.to_dataframe({
"node": "v.id",
"r": "r"
}).sort_values(by=["node"]).to_numpy(dtype=float))
assert np.allclose(ret_ev, ev_result["directed"])
# katz_centrality
ctx_katz = katz_centrality(p2p_project_directed_graph)
def simple_context(arrow_property_graph):
sg = arrow_property_graph.project(vertices={"v0": ["id"]},
edges={"e0": ["weight"]})
return sssp(sg, 20)
