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)