An edge list looks like nothing. It is dense with structure.

pagerank

ur.pagerank(edges, damping=0.85, max_iter=30, tol=1e-6, weight=None) → NodeFrame

Returns a lazy frame of id and pagerank. Nothing runs until .collect(), so the scan, the algorithm and the sort are planned and executed as a single DataFusion query — with the graph operator as a first-class node in that plan, not a step orchestrated around it.

The colour in the table is the only colour on this page. It is a temperature scale, and it appears because there is finally something measured to show.

import ursa as ur
import pyarrow as pa

edges = ur.from_arrow(
    pa.table({"s": [0, 1, 2, 3, 4, 5, 2, 6, 7],
              "d": [1, 2, 0, 4, 5, 3, 3, 0, 0]}),
    src="s", dst="d",
)

(ur.pagerank(edges, damping=0.85)
   .sort("pagerank", descending=True)
   .head(5)
   .collect()
   .to_polars())

Tab. 1 — top 5 of 8 by pagerank over the 9 edges above, damping 0.85, iterated to convergence. Computed, not illustrated.

One plan, not two engines.

There is no Graph object. An EdgeFrame is the graph, a NodeFrame is an attribute table, and every operation returns a frame — so metrics, attributes, filters and top-k compose into one lazy pipeline instead of a script that hands results between libraries.

The topology index is built once on first use and shared by every graph operation over that frame. Property-only transformations keep it; row-changing ones drop it. That contract is the performance model, and it is written down rather than guessed at.

Core concepts ·Quickstart

nodes = ur.scan_nodes("towers.parquet", id="tower_id")
edges = ur.scan_edges("links.parquet",
                      src="tower_a", dst="tower_b")

(nodes
 .with_columns(
     pagerank  = ur.pagerank(edges, damping=0.85),
     component = ur.connected_components(edges),
     nbr_cap   = ur.neighbors(edges).agg(
                     ur.col("capacity_gbps").mean()),
 )
 .filter(ur.col("pagerank") > 0.001)
 .sort("pagerank", descending=True)
 .head(20)
 .collect())

One collect(). Three kernels over one shared topology index, joined to the node attributes, filtered and ranked inside the engine — and the node file is read for only the columns the plan proves it needs.