tgraphx 0.4.2__tar.gz → 0.4.3__tar.gz

{tgraphx-0.4.2 → tgraphx-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tgraphx
-Version: 0.4.2
+Version: 0.4.3
 Summary: Tensor-aware graph neural networks preserving spatial node feature layouts
 Author-email: Arash Sajjadi <arash.sajjadi@usask.ca>
 Maintainer-email: Arash Sajjadi <arash.sajjadi@usask.ca>

{tgraphx-0.4.2 → tgraphx-0.4.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "tgraphx"
 # Keep this in sync with tgraphx/__init__.py::__version__
-version = "0.4.2"
+version = "0.4.3"
 description = "Tensor-aware graph neural networks preserving spatial node feature layouts"
 readme = "README.md"
 requires-python = ">=3.10"

tgraphx-0.4.3/tests/test_mining_graph_learning.py

@@ -0,0 +1,301 @@
+"""Tests for graph learning, self-supervised, and augmentation utilities."""
+import pytest
+import torch
+from tgraphx.mining import (
+    contrastive_loss, supervised_contrastive_loss, triplet_loss,
+    bpr_loss, reconstruction_loss,
+    drop_edges, drop_nodes, mask_node_features, add_random_edges,
+    subgraph_sampling, DGIObjective, GraphCLObjective,
+    create_negative_pairs, create_positive_pairs_from_batch,
+    degree_encoding, random_walk_structural_encoding,
+    shortest_path_anchor_encoding, centrality_encoding,
+    StructuralEncodingModule, attach_structural_encodings,
+    GraphSequenceEncoder, GraphSequenceClassifier, GraphRNNEdgeGenerator,
+    bfs_sequence_encode, random_walk_sequence_encode, pad_sequences,
+)
+
+
+def _chain_ei(N=4):
+    src = list(range(N-1)) + list(range(1, N))
+    dst = list(range(1, N)) + list(range(N-1))
+    return torch.tensor([src, dst], dtype=torch.long), N
+
+
+class TestContrastiveLosses:
+    def test_contrastive_loss_forward(self):
+        z1 = torch.randn(4, 8, requires_grad=True)
+        z2 = torch.randn(4, 8, requires_grad=True)
+        loss = contrastive_loss(z1, z2)
+        assert loss.dim() == 0
+        assert torch.isfinite(loss)
+
+    def test_contrastive_loss_backward(self):
+        z1 = torch.randn(4, 8, requires_grad=True)
+        z2 = torch.randn(4, 8, requires_grad=True)
+        loss = contrastive_loss(z1, z2)
+        loss.backward()
+        assert z1.grad is not None and torch.isfinite(z1.grad).all()
+
+    def test_contrastive_loss_batch_too_small(self):
+        z1 = torch.randn(1, 8)
+        z2 = torch.randn(1, 8)
+        with pytest.raises(ValueError, match="batch size"):
+            contrastive_loss(z1, z2)
+
+    def test_supervised_contrastive_loss(self):
+        emb = torch.randn(6, 8, requires_grad=True)
+        labels = torch.tensor([0, 0, 1, 1, 2, 2])
+        loss = supervised_contrastive_loss(emb, labels)
+        assert torch.isfinite(loss)
+        loss.backward()
+        assert emb.grad is not None
+
+    def test_triplet_loss(self):
+        a = torch.randn(4, 8, requires_grad=True)
+        p = torch.randn(4, 8, requires_grad=True)
+        n = torch.randn(4, 8, requires_grad=True)
+        loss = triplet_loss(a, p, n)
+        assert loss >= 0
+        loss.backward()
+        assert a.grad is not None
+
+    def test_bpr_loss(self):
+        pos = torch.randn(4, requires_grad=True)
+        neg = torch.randn(4, requires_grad=True)
+        loss = bpr_loss(pos, neg)
+        assert torch.isfinite(loss)
+        loss.backward()
+
+    def test_reconstruction_loss(self):
+        x = torch.randn(4, 8)
+        recon = torch.randn(4, 8, requires_grad=True)
+        loss = reconstruction_loss(x, recon)
+        assert torch.isfinite(loss)
+        loss.backward()
+
+
+class TestAugmentations:
+    def test_drop_edges_deterministic(self):
+        ei, N = _chain_ei()
+        new1, _ = drop_edges(ei, p=0.3, seed=42)
+        new2, _ = drop_edges(ei, p=0.3, seed=42)
+        assert torch.equal(new1, new2)
+
+    def test_drop_edges_all(self):
+        ei, N = _chain_ei()
+        new_ei, _ = drop_edges(ei, p=1.0)
+        assert new_ei.size(1) == 0
+
+    def test_drop_edges_none(self):
+        ei, N = _chain_ei()
+        new_ei, _ = drop_edges(ei, p=0.0)
+        assert torch.equal(new_ei, ei)
+
+    def test_drop_nodes_shape(self):
+        ei, N = _chain_ei()
+        x = torch.randn(N, 4)
+        new_ei, new_N, new_x, kept = drop_nodes(ei, N, p=0.3, seed=0, node_features=x)
+        assert new_x.size(0) == new_N
+        assert new_ei.size(0) == 2
+
+    def test_drop_nodes_deterministic(self):
+        ei, N = _chain_ei()
+        _, _, _, k1 = drop_nodes(ei, N, p=0.3, seed=7)
+        _, _, _, k2 = drop_nodes(ei, N, p=0.3, seed=7)
+        assert torch.equal(k1, k2)
+
+    def test_mask_node_features(self):
+        x = torch.ones(5, 8)
+        masked, mask = mask_node_features(x, p=0.5, seed=0)
+        assert masked.shape == x.shape
+        assert mask.dtype == torch.bool
+        # Masked elements should be 0.
+        assert (masked[mask] == 0.0).all()
+        # Non-masked elements should be 1.
+        assert (masked[~mask] == 1.0).all()
+
+    def test_mask_features_deterministic(self):
+        x = torch.ones(5, 8)
+        _, m1 = mask_node_features(x, p=0.3, seed=1)
+        _, m2 = mask_node_features(x, p=0.3, seed=1)
+        assert torch.equal(m1, m2)
+
+    def test_add_random_edges(self):
+        ei, N = _chain_ei()
+        new_ei = add_random_edges(ei, N, num_add=3, seed=0)
+        assert new_ei.size(1) == ei.size(1) + 3
+
+    def test_subgraph_sampling(self):
+        ei, N = _chain_ei(8)
+        x = torch.randn(8, 4)
+        new_ei, new_N, new_x, sampled = subgraph_sampling(ei, 8, 4, seed=0, node_features=x)
+        assert new_N == 4
+        assert new_x.size(0) == 4
+        assert sampled.size(0) == 4
+
+
+class TestSelfSupervisedObjectives:
+    def test_dgi_objective_forward(self):
+        dgi = DGIObjective(embed_dim=8, summary_dim=8)
+        pos_emb = torch.randn(5, 8, requires_grad=True)
+        neg_emb = torch.randn(5, 8, requires_grad=True)
+        loss = dgi(pos_emb, neg_emb)
+        assert torch.isfinite(loss)
+        loss.backward()
+        assert pos_emb.grad is not None
+
+    def test_graphcl_objective(self):
+        gcl = GraphCLObjective(project_dim=8)
+        z1 = torch.randn(4, 8, requires_grad=True)
+        z2 = torch.randn(4, 8, requires_grad=True)
+        loss = gcl(z1, z2)
+        assert torch.isfinite(loss)
+        loss.backward()
+
+
+class TestStructuralEncodings:
+    def test_degree_encoding_shape(self):
+        ei, N = _chain_ei()
+        enc = degree_encoding(ei, N)
+        assert enc.shape == (N, 2)
+        assert enc.dtype == torch.float32
+
+    def test_degree_encoding_star_hub(self):
+        from tgraphx.mining import star_graph
+        ei, N = star_graph(5)
+        enc = degree_encoding(ei, N, normalize=False)
+        # Hub (node 0) should have highest degree.
+        assert float(enc[0, 0]) == 4.0
+
+    def test_centrality_encoding_shape(self):
+        ei, N = _chain_ei(6)
+        enc = centrality_encoding(ei, N, include=["degree", "pagerank"])
+        assert enc.shape == (N, 2)
+
+    def test_attach_concat(self):
+        ei, N = _chain_ei()
+        enc = degree_encoding(ei, N)
+        x = torch.randn(N, 6)
+        aug = attach_structural_encodings(x, enc)
+        assert aug.shape == (N, 8)  # 6 + 2
+
+    def test_attach_spatial_raises(self):
+        ei, N = _chain_ei()
+        enc = degree_encoding(ei, N)
+        x = torch.randn(N, 3, 4, 4)  # spatial
+        with pytest.raises(ValueError, match="mode='side'"):
+            attach_structural_encodings(x, enc, mode="concat")
+
+    def test_attach_side_mode(self):
+        ei, N = _chain_ei()
+        enc = degree_encoding(ei, N)
+        x = torch.randn(N, 3, 4, 4)
+        result = attach_structural_encodings(x, enc, mode="side")
+        assert result is enc
+
+    def test_structural_encoding_module(self):
+        mod = StructuralEncodingModule(in_dim=2, out_dim=8)
+        enc = torch.randn(5, 2)
+        out = mod(enc)
+        assert out.shape == (5, 8)
+        out.sum().backward()
+        assert all(p.grad is not None for p in mod.parameters())
+
+
+class TestSequenceModels:
+    def test_bfs_sequence_encode(self):
+        ei, N = _chain_ei()
+        x = torch.randn(N, 4)
+        seq = bfs_sequence_encode(ei, N, node_features=x, start=0)
+        assert seq.shape[1] == 4
+        assert seq.shape[0] == N
+
+    def test_random_walk_sequence_encode(self):
+        ei, N = _chain_ei()
+        x = torch.randn(N, 4)
+        seq = random_walk_sequence_encode(ei, N, walk_length=5, node_features=x, seed=0)
+        assert seq.shape == (6, 4)  # walk_length + 1
+
+    def test_pad_sequences(self):
+        seqs = [torch.randn(3, 4), torch.randn(5, 4), torch.randn(2, 4)]
+        padded, lengths = pad_sequences(seqs)
+        assert padded.shape == (3, 5, 4)
+        assert lengths.tolist() == [3, 5, 2]
+
+    def test_graph_sequence_encoder_forward(self):
+        enc = GraphSequenceEncoder(input_dim=4, hidden_dim=16, num_layers=2)
+        x = torch.randn(3, 7, 4)
+        out = enc(x)
+        assert out.shape == (3, 16)
+
+    def test_graph_sequence_encoder_backward(self):
+        enc = GraphSequenceEncoder(input_dim=4, hidden_dim=16, num_layers=2)
+        x = torch.randn(3, 7, 4)
+        out = enc(x)
+        out.sum().backward()
+        for p in enc.parameters():
+            assert p.grad is not None
+
+    def test_graph_sequence_classifier_overfit(self):
+        clf = GraphSequenceClassifier(input_dim=4, hidden_dim=32, num_classes=2)
+        opt = torch.optim.Adam(clf.parameters(), lr=1e-2)
+        # Class 0: mostly-zero sequences; class 1: mostly-one sequences.
+        x0 = torch.randn(3, 5, 4) * 0.01
+        x1 = torch.randn(3, 5, 4) + 5.0
+        X = torch.cat([x0, x1])
+        y = torch.tensor([0,0,0,1,1,1])
+        losses = []
+        for _ in range(30):
+            opt.zero_grad()
+            logits = clf(X)
+            loss = torch.nn.functional.cross_entropy(logits, y)
+            loss.backward()
+            opt.step()
+            losses.append(loss.detach().item())
+        assert losses[-1] < losses[0], f"Loss did not decrease: {losses[0]:.4f}→{losses[-1]:.4f}"
+
+    def test_graph_rnn_generator_shape(self):
+        gen = GraphRNNEdgeGenerator(max_nodes=8)
+        adj = gen.generate(5, seed=0)
+        assert adj.shape == (5, 5)
+        # Symmetric.
+        assert torch.equal(adj, adj.t())
+
+    def test_graph_rnn_generator_deterministic(self):
+        gen = GraphRNNEdgeGenerator(max_nodes=8)
+        adj1 = gen.generate(5, seed=42)
+        adj2 = gen.generate(5, seed=42)
+        assert torch.equal(adj1, adj2)
+
+    def test_graph_rnn_generator_backward(self):
+        gen = GraphRNNEdgeGenerator(max_nodes=6)
+        # Teacher-forcing training step.
+        opt = torch.optim.Adam(gen.parameters(), lr=1e-2)
+        # Target: random binary adjacency rows.
+        N = 4
+        B = 2
+        target = torch.zeros(B, N, 6)
+        for i in range(1, N):
+            target[:, i, :i] = (torch.rand(B, i) > 0.5).float()
+        logits, _ = gen(target)
+        # BCEWithLogits loss on upper triangle.
+        loss = torch.nn.functional.binary_cross_entropy_with_logits(logits, target)
+        loss.backward()
+        assert all(p.grad is not None for p in gen.parameters())
+
+
+class TestNegativePairUtils:
+    def test_create_negative_pairs_no_false_neg(self):
+        ei = torch.tensor([[0,1],[1,2]], dtype=torch.long)
+        neg = create_negative_pairs(ei, num_nodes=4, num_neg=4, seed=0)
+        pos_set = {(int(ei[0,i]), int(ei[1,i])) for i in range(ei.size(1))}
+        neg_set = {(int(neg[0,i]), int(neg[1,i])) for i in range(neg.size(1))}
+        assert not (pos_set & neg_set)
+
+    def test_create_positive_pairs(self):
+        labels = torch.tensor([0, 0, 1, 1, 0])
+        pa, pb = create_positive_pairs_from_batch(labels)
+        assert pa.size(0) > 0
+        for a, b in zip(pa.tolist(), pb.tolist()):
+            assert labels[a] == labels[b]
+            assert a != b

tgraphx-0.4.3/tests/test_mining_paths_algorithms.py

@@ -0,0 +1,251 @@
+"""Tests for tgraphx.mining.paths — graph path algorithms."""
+import math
+import pytest
+import torch
+from tgraphx.mining import (
+    bfs_order, dfs_order, multi_source_bfs, reachable_nodes,
+    dijkstra_shortest_path, batched_shortest_path_length,
+    all_pairs_shortest_path_length, reconstruct_path,
+    minimum_spanning_tree, maximum_spanning_tree,
+    cut_size, normalized_cut, conductance, volume, boundary_edges,
+    write_path_summary,
+)
+
+
+def _chain(N=4):
+    src = list(range(N-1)) + list(range(1, N))
+    dst = list(range(1, N)) + list(range(N-1))
+    return torch.tensor([src, dst], dtype=torch.long), N
+
+
+def _star(N=5):
+    src = [0]*(N-1) + list(range(1, N))
+    dst = list(range(1, N)) + [0]*(N-1)
+    return torch.tensor([src, dst], dtype=torch.long), N
+
+
+class TestBFSOrder:
+    def test_chain_bfs(self):
+        ei, N = _chain()
+        order = bfs_order(ei, 0, N)
+        assert order[0].item() == 0
+        assert sorted(order.tolist()) == list(range(N))
+
+    def test_disconnected_partial(self):
+        ei = torch.tensor([[0, 2], [1, 3]], dtype=torch.long)
+        order = bfs_order(ei, 0, 4)
+        # Start at 0; only reaches 0 and 1.
+        assert set(order.tolist()) == {0, 1}
+
+    def test_invalid_start(self):
+        ei, N = _chain()
+        with pytest.raises(ValueError, match="start"):
+            bfs_order(ei, N + 5, N)
+
+    def test_single_node(self):
+        ei = torch.zeros((2, 0), dtype=torch.long)
+        order = bfs_order(ei, 0, 1)
+        assert order.tolist() == [0]
+
+    def test_star_hub_first(self):
+        ei, N = _star()
+        order = bfs_order(ei, 0, N)
+        assert order[0].item() == 0
+        assert order.size(0) == N
+
+
+class TestDFSOrder:
+    def test_chain_dfs(self):
+        ei, N = _chain()
+        order = dfs_order(ei, 0, N)
+        assert order[0].item() == 0
+        assert sorted(order.tolist()) == list(range(N))
+
+    def test_disconnected(self):
+        ei = torch.tensor([[0], [1]], dtype=torch.long)
+        order = dfs_order(ei, 0, 4)
+        # Directed; 0->1 but 2,3 unreachable.
+        assert set(order.tolist()) == {0, 1}
+
+
+class TestMultiSourceBFS:
+    def test_two_sources(self):
+        ei, N = _chain()
+        sources = torch.tensor([0, 3], dtype=torch.long)
+        dist = multi_source_bfs(ei, sources, N)
+        # node 0: dist 0, node 1: dist 1 from 0, node 3: dist 0, node 2: dist 1 from 3
+        assert dist[0].item() == 0
+        assert dist[3].item() == 0
+        assert dist[1].item() == 1
+        assert dist[2].item() == 1
+
+    def test_unreachable_minus_one(self):
+        ei = torch.tensor([[0], [1]], dtype=torch.long)
+        sources = torch.tensor([0], dtype=torch.long)
+        dist = multi_source_bfs(ei, sources, 4, directed=True)
+        assert dist[2].item() == -1
+        assert dist[3].item() == -1
+
+
+class TestDijkstra:
+    def test_chain_unit_weights(self):
+        ei, N = _chain()
+        dist, pred = dijkstra_shortest_path(ei, 0, N)
+        assert dist.tolist() == [0.0, 1.0, 2.0, 3.0]
+
+    def test_weighted_graph(self):
+        # Triangle: 0-1 weight 1, 1-2 weight 1, 0-2 weight 10.
+        ei = torch.tensor([[0, 1, 0, 1, 2, 2], [1, 0, 2, 2, 0, 1]], dtype=torch.long)
+        w = torch.tensor([1.0, 1.0, 10.0, 1.0, 10.0, 1.0])
+        dist, pred = dijkstra_shortest_path(ei, 0, 3, edge_weight=w)
+        assert abs(float(dist[0]) - 0.0) < 1e-6
+        assert abs(float(dist[1]) - 1.0) < 1e-6
+        assert abs(float(dist[2]) - 2.0) < 1e-6  # via 0→1→2
+
+    def test_unreachable_inf(self):
+        ei = torch.tensor([[0], [1]], dtype=torch.long)
+        dist, _ = dijkstra_shortest_path(ei, 0, 4, directed=True)
+        assert dist[0].item() == 0.0
+        assert dist[1].item() == 1.0
+        assert math.isinf(float(dist[2]))
+        assert math.isinf(float(dist[3]))
+
+    def test_source_zero_dist(self):
+        ei, N = _chain()
+        dist, _ = dijkstra_shortest_path(ei, 2, N)
+        assert dist[2].item() == 0.0
+
+    def test_negative_weight_raises(self):
+        ei = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)
+        w = torch.tensor([1.0, -1.0])
+        with pytest.raises(ValueError, match="non-negative"):
+            dijkstra_shortest_path(ei, 0, 2, edge_weight=w)
+
+    def test_reconstruct_path(self):
+        ei, N = _chain()
+        dist, pred = dijkstra_shortest_path(ei, 0, N)
+        path = reconstruct_path(0, 3, pred)
+        assert path == [0, 1, 2, 3]
+
+    def test_reconstruct_path_unreachable(self):
+        ei = torch.zeros((2, 0), dtype=torch.long)
+        _, pred = dijkstra_shortest_path(ei, 0, 4)
+        path = reconstruct_path(0, 3, pred)
+        assert path == []
+
+    def test_reconstruct_path_self(self):
+        ei, N = _chain()
+        _, pred = dijkstra_shortest_path(ei, 0, N)
+        path = reconstruct_path(0, 0, pred)
+        assert path == [0]
+
+
+class TestAllPairsSP:
+    def test_chain_symmetric(self):
+        ei, N = _chain()
+        D = all_pairs_shortest_path_length(ei, N)
+        assert D.shape == (N, N)
+        assert torch.allclose(D, D.t())  # undirected → symmetric
+
+    def test_chain_diagonal_zero(self):
+        ei, N = _chain()
+        D = all_pairs_shortest_path_length(ei, N)
+        assert (D.diagonal() == 0).all()
+
+    def test_size_guard(self):
+        ei = torch.zeros((2, 0), dtype=torch.long)
+        with pytest.raises(ValueError, match="max_nodes"):
+            all_pairs_shortest_path_length(ei, 1001, max_nodes=1000)
+
+
+class TestSpanningTree:
+    def test_triangle_mst_two_edges(self):
+        # Triangle K3: 3 edges, MST should pick 2 cheapest.
+        ei = torch.tensor([[0,1,2,1,2,0],[1,2,0,0,1,2]], dtype=torch.long)
+        w = torch.tensor([1.0, 2.0, 3.0, 1.0, 2.0, 3.0])
+        mst_ei, mst_w, total = minimum_spanning_tree(ei, 3, edge_weight=w)
+        # MST should have 2 undirected edges (= 4 directed edge_index entries).
+        assert mst_ei.size(1) == 4
+        assert abs(total - 3.0) < 1e-6  # edges of weight 1+2
+
+    def test_mst_unit_weights(self):
+        ei, N = _chain()
+        mst_ei, _, total = minimum_spanning_tree(ei, N)
+        # Chain is already a spanning tree; MST = all edges.
+        assert abs(total - float(N - 1)) < 1e-6
+
+    def test_maxst_total_ge_mst_total(self):
+        ei = torch.tensor([[0,1,2,1,2,0],[1,2,0,0,1,2]], dtype=torch.long)
+        w = torch.tensor([1.0, 2.0, 3.0, 1.0, 2.0, 3.0])
+        _, _, min_total = minimum_spanning_tree(ei, 3, w)
+        _, _, max_total = maximum_spanning_tree(ei, 3, w)
+        assert max_total >= min_total
+
+    def test_empty_graph(self):
+        ei = torch.zeros((2, 0), dtype=torch.long)
+        mst_ei, _, _ = minimum_spanning_tree(ei, 3)
+        assert mst_ei.size(1) == 0
+
+    def test_disconnected_forest(self):
+        # Two disjoint edges: 0-1 and 2-3.
+        ei = torch.tensor([[0,1,2,3],[1,0,3,2]], dtype=torch.long)
+        mst_ei, _, _ = minimum_spanning_tree(ei, 4)
+        assert mst_ei.size(1) == 4  # 2 undirected edges (forest)
+
+
+class TestCutsAndMetrics:
+    def test_cut_size_chain(self):
+        ei, N = _chain()
+        subset = torch.tensor([0, 1])
+        # Both directed crossings (1→2 and 2→1) for the undirected 1-2 edge.
+        assert cut_size(ei, N, subset) == 2
+
+    def test_cut_size_empty_subset(self):
+        ei, N = _chain()
+        assert cut_size(ei, N, torch.zeros(0, dtype=torch.long)) == 0
+
+    def test_cut_size_full_subset(self):
+        ei, N = _chain()
+        assert cut_size(ei, N, torch.arange(N)) == 0
+
+    def test_volume_star(self):
+        ei, N = _star()
+        # Hub has degree N-1.
+        vol_hub = volume(ei, N, torch.tensor([0]))
+        assert vol_hub == N - 1
+
+    def test_conductance_two_cliques(self):
+        # Two cliques {0,1,2} and {3,4,5} connected by one edge 2-3.
+        src = [0,1,2,3,4,1,2,4,5,2]
+        dst = [1,2,3,4,5,0,1,3,4,3]
+        ei = torch.tensor([src+dst, dst+src], dtype=torch.long)
+        ei = torch.unique(ei, dim=1)
+        N = 6
+        subset = torch.tensor([0, 1, 2])
+        c = conductance(ei, N, subset)
+        assert c >= 0.0 and c <= 1.0
+
+    def test_normalized_cut_two_cliques(self):
+        src = [0,1,2,3,4,1,2,4,5]
+        dst = [1,2,0,4,5,0,1,3,4]
+        ei = torch.tensor([src+dst, dst+src], dtype=torch.long)
+        ei = torch.unique(ei, dim=1)
+        labels = torch.tensor([0,0,0,1,1,1])
+        nc = normalized_cut(ei, 6, labels)
+        assert nc >= 0.0
+
+    def test_boundary_edges_shape(self):
+        ei, N = _chain()
+        subset = torch.tensor([0, 1])
+        be = boundary_edges(ei, N, subset)
+        assert be.shape[0] == 2
+        assert be.shape[1] > 0
+
+    def test_write_path_summary(self, tmp_path):
+        p = write_path_summary(
+            str(tmp_path / "algo.json"),
+            source=0, num_reachable=4, mean_distance=1.5,
+        )
+        import json; d = json.loads(open(p).read())
+        assert d["source"] == 0
+        assert d["mean_distance"] == 1.5

{tgraphx-0.4.2 → tgraphx-0.4.3}/tgraphx/__init__.py

@@ -10,7 +10,7 @@ Common one-liner imports::
 """
 
 # Keep this in sync with [project].version in pyproject.toml.
-__version__ = "0.4.2"
+__version__ = "0.4.3"
 
 # ── Core data structures ──────────────────────────────────────────────────────
 from .core.graph import Graph, GraphBatch

{tgraphx-0.4.2 → tgraphx-0.4.3}/tgraphx/mining/__init__.py

@@ -221,6 +221,65 @@ from .api import (
     run_link_prediction_baseline,
 )
 
+# ── Graph paths and algorithms (Beta) ────────────────────────────────────────
+from .paths import (
+    bfs_order,
+    dfs_order,
+    multi_source_bfs,
+    reachable_nodes,
+    dijkstra_shortest_path,
+    batched_shortest_path_length,
+    all_pairs_shortest_path_length,
+    reconstruct_path,
+    minimum_spanning_tree,
+    maximum_spanning_tree,
+    cut_size,
+    normalized_cut,
+    conductance,
+    volume,
+    boundary_edges,
+    write_path_summary,
+)
+
+# ── Graph learning utilities (Experimental) ───────────────────────────────────
+from .graph_learning import (
+    contrastive_loss,
+    supervised_contrastive_loss,
+    triplet_loss,
+    bpr_loss,
+    reconstruction_loss,
+    drop_edges,
+    drop_nodes,
+    mask_node_features,
+    add_random_edges,
+    subgraph_sampling,
+    DGIObjective,
+    GraphCLObjective,
+    create_negative_pairs,
+    create_positive_pairs_from_batch,
+)
+
+# ── Structural encodings (Beta) ───────────────────────────────────────────────
+from .structural_encodings import (
+    degree_encoding,
+    random_walk_structural_encoding,
+    shortest_path_anchor_encoding,
+    centrality_encoding,
+    community_encoding,
+    StructuralEncodingModule,
+    attach_structural_encodings,
+)
+
+# ── Graph sequence models (Experimental) ─────────────────────────────────────
+from .sequence_models import (
+    GraphSequenceEncoder,
+    GraphSequenceClassifier,
+    GraphRNNEdgeGenerator,
+    bfs_sequence_encode,
+    random_walk_sequence_encode,
+    pad_sequences,
+)
+
 # ── Neural mining (Experimental) ─────────────────────────────────────────────
 from .neural import (
     PrototypeMembershipScorer,