ci: add package and runtime smoke checks

.github/workflows/ci.yml

@@ -0,0 +1,75 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.8.x"
+          enable-cache: true
+      - run: uv sync --dev
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.8.x"
+          enable-cache: true
+      - run: uv sync --dev
+      - run: uv run pytest
+
+  package:
+    name: package
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.8.x"
+          enable-cache: true
+      - run: uv sync --dev
+      - run: uv build
+      - run: uv run python -m twine check dist/*
+      - name: Wheel install smoke test
+        shell: bash
+        run: |
+          set -euo pipefail
+          smoke_dir="$(mktemp -d)"
+          trap 'rm -rf "$smoke_dir"' EXIT
+          uv venv "$smoke_dir/venv"
+          uv pip install --python "$smoke_dir/venv/bin/python" dist/*.whl
+          (
+            cd "$smoke_dir"
+            "$smoke_dir/venv/bin/python" -c 'import gnn4colliders; print(gnn4colliders.__version__)'
+            "$smoke_dir/venv/bin/gnn4colliders" --help
+            "$smoke_dir/venv/bin/gnn4colliders" train --help
+            "$smoke_dir/venv/bin/gnn4colliders" export --help
+          )
+
+  onnx:
+    name: onnx
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.8.x"
+          enable-cache: true
+      - run: uv sync --dev --extra root-gnn --extra onnx
+      - run: uv run pytest tests/unit/export -v

tests/parity/test_legacy_tracking.py

@@ -0,0 +1,77 @@
+"""Characterization of the legacy dataset item contract."""
+
+import torch
+
+
+def _dataset_item(legacy_dataset_module_without_dgl, labels, tracking, globals_):
+    dataset = object.__new__(legacy_dataset_module_without_dgl.RootDataset)
+    dataset.graphs = [object() for _ in labels]
+    dataset.labels = torch.as_tensor(labels)
+    dataset.tracking = torch.as_tensor(tracking, dtype=torch.float32)
+    dataset.global_features = torch.as_tensor(globals_, dtype=torch.float32)
+    return dataset
+
+
+def test_dataset_item_contract_preserves_label_tracking_and_global_shapes(
+    legacy_dataset_module_without_dgl,
+):
+    dataset = object.__new__(legacy_dataset_module_without_dgl.RootDataset)
+    graph = object()
+    dataset.graphs = [graph]
+    dataset.labels = torch.tensor([7])
+    dataset.tracking = torch.tensor([[3.0, 2.5]], dtype=torch.float32)
+    dataset.global_features = torch.empty((1, 0), dtype=torch.float32)
+    item = dataset[0]
+    assert item[0] is graph
+    assert item[1].shape == torch.Size([])
+    assert item[1].dtype == torch.int64
+    assert item[2].shape == (2,)
+    assert item[2].dtype == torch.float32
+    assert item[2].tolist() == [3.0, 2.5]
+    assert item[3].shape == (0,)
+    assert item[3].dtype == torch.float32
+
+
+def test_dataset_item_contract_preserves_binary_and_multiclass_labels(
+    legacy_dataset_module_without_dgl,
+):
+    dataset = _dataset_item(
+        legacy_dataset_module_without_dgl,
+        labels=[0, 1, 11],
+        tracking=[[0.0, 1.0], [3.0, -2.5], [7.0, 0.0]],
+        globals_=[[], [], []],
+    )
+    items = [dataset[index] for index in range(3)]
+    assert [item[1].item() for item in items] == [0, 1, 11]
+    assert all(item[1].shape == torch.Size([]) for item in items)
+    assert all(item[1].dtype == torch.int64 for item in items)
+    assert items[1][2].tolist() == [3.0, -2.5]
+    assert all(item[3].shape == (0,) for item in items)
+
+
+def test_dataset_item_contract_preserves_nonempty_global_features(
+    legacy_dataset_module_without_dgl,
+):
+    dataset = _dataset_item(
+        legacy_dataset_module_without_dgl,
+        labels=[1],
+        tracking=[[4.0, 2.0]],
+        globals_=[[12.5, -3.0]],
+    )
+    item = dataset[0]
+    assert item[3].shape == (2,)
+    assert item[3].dtype == torch.float32
+    assert item[3].tolist() == [12.5, -3.0]
+
+
+def test_fold_selection_uses_tracking_column_zero_and_keeps_weights(
+    legacy_utils_module,
+):
+    sample = type(
+        "Sample",
+        (),
+        {"tracking": torch.tensor([[0.0, 1.0], [1.0, -2.5], [2.0, 0.0], [3.0, 4.0]])},
+    )()
+    selection = legacy_utils_module.fold_selection({"n_folds": 2, "test": [1]}, "test")
+    assert selection(sample).tolist() == [False, True, False, True]
+    assert sample.tracking[:, 1].tolist() == [1.0, -2.5, 0.0, 4.0]

tests/unit/test_package_import.py

@@ -5,3 +5,35 @@ def test_package_imports() -> None:
     import gnn4colliders
 
     assert gnn4colliders.__file__ is not None
+    assert gnn4colliders.__version__ == "0.1.0"
+
+
+def test_public_import_contract() -> None:
+    from gnn4colliders.inference import Predictor
+    from gnn4colliders.models.root_gnn import EdgeNetwork, FineTunedEdgeNetwork
+    from gnn4colliders.tasks import (
+        BinaryClassificationTask,
+        MulticlassClassificationTask,
+    )
+    from gnn4colliders.training import CheckpointManager, Trainer
+
+    assert all(
+        item is not None
+        for item in (
+            EdgeNetwork,
+            FineTunedEdgeNetwork,
+            BinaryClassificationTask,
+            MulticlassClassificationTask,
+            Trainer,
+            CheckpointManager,
+            Predictor,
+        )
+    )
+
+
+def test_hydra_config_is_discoverable_from_package() -> None:
+    from gnn4colliders.cli import _config
+
+    config = _config([])
+    assert config.model.name == "edge_network"
+    assert config.task.type == "multiclass_classification"