altar-legnet 0.2.0__tar.gz

altar_legnet-0.2.0/.gitignore

@@ -0,0 +1,33 @@
+*.pyc
+*~
+**/__pycache__/*
+*.swp
+.vscode/
+.idea/
+.DS_Store
+.env*
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage
+htmlcov/
+coverage.xml
+pytest.xml
+.hypothesis/
+.python-version
+.venv
+.venv-*/
+*.egg-info/
+build/
+dist/
+site/
+*.sqlite3
+*.log
+
+# Generated variant indexes and datasets. The small canonical gene table is tracked.
+altar/altar/variants/data/ccres.dnatree
+altar/altar/variants/data/region_annotations.parquet
+altar/altar/variants/data/variants.pkl.gz
+altar/altar/variants/data/region_provenance.json
+altar/altar/variants/data/raw/
+

altar_legnet-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Riya Sinha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

altar_legnet-0.2.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.5
+Name: altar-legnet
+Version: 0.2.0
+Summary: LegNet model binding for large-scale Altar MPRA variant scoring
+Project-URL: Documentation, https://kundajelab.github.io/altar/
+Author: Riya Sinha
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: altar<0.3,>=0.2.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Altar LegNet binding
+
+`altar-legnet` is the lightweight control-plane binding for large-scale human LegNet MPRA activity
+variant scoring. It produces backend-neutral container plans and does not import PyTorch.
+
+The binding scores hg38 SNVs in independently retryable Altar variant batches. Each variant contributes a
+200 bp genomic context with the SNV at index 100; the runtime adds the published 5′ and 3′ 15 bp LentiMPRA
+adapters before the 230 bp model inference. The stable scalar effect is signed `alt_activity - ref_activity`.
+
+Checkpoint bytes and the matching training configuration are independent, content-addressed resources.
+This supports the upstream K562, HepG2, and WTC11 models as well as compatible checkpoints without tying
+Altar to Zenodo, Hugging Face, Chorus, or another provider. The isolated executor is in `runtimes/legnet`.
+`LegNetConfiguration` uses the digest-pinned runtime tested with the binding by default; callers can override
+it with another immutable image reference.

altar_legnet-0.2.0/README.md

@@ -0,0 +1,14 @@
+# Altar LegNet binding
+
+`altar-legnet` is the lightweight control-plane binding for large-scale human LegNet MPRA activity
+variant scoring. It produces backend-neutral container plans and does not import PyTorch.
+
+The binding scores hg38 SNVs in independently retryable Altar variant batches. Each variant contributes a
+200 bp genomic context with the SNV at index 100; the runtime adds the published 5′ and 3′ 15 bp LentiMPRA
+adapters before the 230 bp model inference. The stable scalar effect is signed `alt_activity - ref_activity`.
+
+Checkpoint bytes and the matching training configuration are independent, content-addressed resources.
+This supports the upstream K562, HepG2, and WTC11 models as well as compatible checkpoints without tying
+Altar to Zenodo, Hugging Face, Chorus, or another provider. The isolated executor is in `runtimes/legnet`.
+`LegNetConfiguration` uses the digest-pinned runtime tested with the binding by default; callers can override
+it with another immutable image reference.

altar_legnet-0.2.0/altar_legnet/__init__.py

@@ -0,0 +1,25 @@
+# Copyright 2026 Riya Sinha
+"""LegNet model binding for Altar."""
+
+from altar_legnet.plugin import (
+    CONTEXT_LENGTH,
+    DEFAULT_IMAGE,
+    KIND_SCORING,
+    MODEL_INPUT_LENGTH,
+    LegNetConfiguration,
+    LegNetPlugin,
+    LegNetRunInputs,
+    LegNetShardKind,
+)
+
+
+__all__ = [
+    "CONTEXT_LENGTH",
+    "DEFAULT_IMAGE",
+    "KIND_SCORING",
+    "MODEL_INPUT_LENGTH",
+    "LegNetConfiguration",
+    "LegNetPlugin",
+    "LegNetRunInputs",
+    "LegNetShardKind",
+]

altar_legnet-0.2.0/altar_legnet/plugin.py

@@ -0,0 +1,202 @@
+# Copyright 2026 Riya Sinha
+"""Backend-neutral LegNet binding for MPRA activity variant effects."""
+
+from __future__ import annotations
+import enum
+from typing import TYPE_CHECKING, Annotated, Any, cast
+
+from altar.execution import ResourceRequest
+from altar.models import (
+    ApiVersionRange,
+    ContainerImageDigest,
+    ContainerScoringPlan,
+    ModelConfiguration,
+    ModelPlugin,
+    OutputSelection,
+    PluginCapability,
+    PluginKind,
+    PluginManifest,
+    PrioritizationPolicy,
+    ReferenceGenomeRunInputs,
+    ResourceReference,
+    ResultField,
+    ResultSchema,
+    RuntimeIdentityPolicy,
+    RuntimeKind,
+    RuntimeRequirement,
+    ScoringRequest,
+    VariantClass,
+    VariantEligibility,
+    require_resource_digests,
+    resource_transfer,
+    single_container_plan,
+)
+from altar.predicates import Abs, Col, Ge, Lit, Predicate
+from pydantic import Field, model_validator
+
+from altar_legnet.resources import manifest_resources
+
+
+if TYPE_CHECKING:
+    import os
+
+
+CONTEXT_LENGTH = 200
+MODEL_INPUT_LENGTH = 230
+LEFT_MPRA_FLANK = "AGGACCGGATCAACT"
+RIGHT_MPRA_FLANK = "CATTGCGTGAACCGA"
+DEFAULT_IMAGE = "riyavsinha/altar-legnet@sha256:43a4000583f5ebda33554a21a6b627f071a43a65da76c77c625eb1c4f3d50d0d"
+
+
+class LegNetShardKind(enum.StrEnum):
+    """Stable execution kind emitted by :class:`LegNetPlugin`."""
+
+    SCORING = "legnet_scoring"
+
+
+KIND_SCORING = LegNetShardKind.SCORING
+_SCORE_RESOURCES = ResourceRequest(memory_gb=4)
+_ACTIVITY_DELTA_THRESHOLD = 0.5
+
+
+class LegNetConfiguration(ModelConfiguration):
+    """Immutable human LegNet checkpoint and MPRA scoring settings."""
+
+    weights: ResourceReference
+    training_config: ResourceReference
+    cell_type: Annotated[str, Field(min_length=1)]
+    assay: Annotated[str, Field(min_length=1)] = "LentiMPRA"
+    average_reverse: bool = True
+    image: ContainerImageDigest = DEFAULT_IMAGE
+
+    @model_validator(mode="after")
+    def validate_resources(self) -> LegNetConfiguration:
+        require_resource_digests(self, owner="LegNet")
+        return self
+
+    @classmethod
+    def from_resource_manifest(
+        cls, path: str | os.PathLike[str], *, base_uri: str | None = None, **settings: Any
+    ) -> LegNetConfiguration:
+        """Build a configuration from the ``legnet.resources.json`` that ``legnet-resources`` wrote.
+
+        ``settings`` are the remaining configuration fields: ``assay``, ``average_reverse`` and ``image``, and
+        ``cell_type`` to override the one the manifest records for the checkpoint. See
+        :func:`altar_legnet.resources.manifest_resources` for how ``base_uri`` locates the files.
+        """
+        resources = manifest_resources(path, base_uri=base_uri)
+        settings.setdefault("cell_type", resources.cell_type)
+        return cls(weights=resources.weights, training_config=resources.training_config, **settings)
+
+
+class LegNetRunInputs(ReferenceGenomeRunInputs):
+    """Per-run inputs for the published human MPRA checkpoints."""
+
+    supported_genome_builds = frozenset({"hg38"})
+
+
+class LegNetPlugin(ModelPlugin):
+    """Human LegNet sequence-to-MPRA activity semantics and scalable batch plan."""
+
+    model_type = "LEGNET"
+    manifest = PluginManifest(
+        plugin_id="org.kundajelab.altar.model.legnet",
+        kind=PluginKind.MODEL,
+        capabilities=frozenset({PluginCapability.SCORE, PluginCapability.MATERIALIZE_RESULTS}),
+        architecture="LegNet",
+        plugin_version="0.0.1",
+        altar_api=ApiVersionRange("0.1.0", "0.2.0"),
+        configuration_schema_version="0.0.1",
+        result_schema=ResultSchema(
+            version="0.0.1",
+            fields=(
+                ResultField("ref_activity", "float", "Reference Activity", "Predicted reference MPRA activity"),
+                ResultField("alt_activity", "float", "Alternate Activity", "Predicted alternate MPRA activity"),
+                ResultField(
+                    "activity_delta",
+                    "float",
+                    "Activity Delta",
+                    "Signed alternate-minus-reference predicted MPRA activity",
+                ),
+            ),
+        ),
+        # The LegNet runtime substitutes one reference base; batch preparation filters out indels and MNVs.
+        variant_eligibility=VariantEligibility(frozenset({VariantClass.SNV})),
+        prioritization=PrioritizationPolicy(name="legnet-activity-delta-v1", version="0.0.1"),
+        runtimes=(
+            RuntimeRequirement(
+                name="model_runtime",
+                kind=RuntimeKind.CONTAINER_IMAGE,
+                policy=RuntimeIdentityPolicy.DIGEST_REQUIRED,
+            ),
+        ),
+    )
+    configuration_schema_id = "org.kundajelab.altar.model.legnet.configuration"
+    configuration_model = LegNetConfiguration
+    run_input_model = LegNetRunInputs
+    default_output = OutputSelection(outputs=("scores",), reducer="alt_minus_ref_activity_v1")
+
+    def build_scoring_plan(self, request: ScoringRequest) -> ContainerScoringPlan:
+        configuration = self.parse_configuration_as(request.configuration, LegNetConfiguration)
+        run_inputs = self.parse_run_inputs_as(request.run_inputs, LegNetRunInputs)
+        layout, resolver = request.layout, request.resolver
+        weights_logical = layout.model_resource_file(request.model_id, "legnet.weights.ckpt")
+        config_logical = layout.model_resource_file(request.model_id, "legnet.config.json")
+        genome_logical = layout.genome_fasta(request.genome_label)
+        variants_logical = layout.model_variants_file(request.job_id, request.model_id, request.scoring_batch)
+        output_logical = layout.scoring_result_file(request.job_id, request.model_id, request.scoring_batch)
+        command = [
+            "legnet-score",
+            "score",
+            "--weights",
+            resolver.resolve(weights_logical),
+            "--weights-digest",
+            cast("str", configuration.weights.digest),
+            "--model-config",
+            resolver.resolve(config_logical),
+            "--model-config-digest",
+            cast("str", configuration.training_config.digest),
+            "--cell-type",
+            configuration.cell_type,
+            "--assay",
+            configuration.assay,
+            "--genome",
+            resolver.resolve(genome_logical),
+            "--genome-digest",
+            cast("str", run_inputs.genome.digest),
+            "--variants",
+            resolver.resolve(variants_logical),
+            "--output",
+            resolver.resolve(output_logical),
+        ]
+        if configuration.average_reverse:
+            command.append("--average-reverse")
+        return single_container_plan(
+            self,
+            request,
+            kind=KIND_SCORING,
+            image=configuration.image,
+            command=command,
+            resources=_SCORE_RESOURCES,
+            inputs=[
+                resource_transfer(configuration.weights, weights_logical, locality_key=request.model_id),
+                resource_transfer(configuration.training_config, config_logical, locality_key=request.model_id),
+                resource_transfer(run_inputs.genome, genome_logical),
+            ],
+        )
+
+    def prioritize_predicate(self) -> Predicate:
+        return Ge(Abs(Col("activity_delta")), Lit(_ACTIVITY_DELTA_THRESHOLD))
+
+
+__all__ = [
+    "CONTEXT_LENGTH",
+    "KIND_SCORING",
+    "LEFT_MPRA_FLANK",
+    "MODEL_INPUT_LENGTH",
+    "RIGHT_MPRA_FLANK",
+    "LegNetConfiguration",
+    "LegNetPlugin",
+    "LegNetRunInputs",
+    "LegNetShardKind",
+]

altar_legnet-0.2.0/altar_legnet/py.typed

@@ -0,0 +1 @@
+

altar_legnet-0.2.0/altar_legnet/resources.py

@@ -0,0 +1,84 @@
+# Copyright 2026 Riya Sinha
+"""The manifest ``legnet-resources`` writes beside a prepared LegNet checkpoint, read back into references.
+
+The LegNet runtime's ``legnet-resources`` command (``altar_legnet_runtime.resources``) validates a checkpoint by
+loading it with PyTorch, copies it and its training configuration under stable names, and writes
+``legnet.resources.json`` beside them with each file's SHA-256 digest and the checkpoint's cell type. The
+preparer stays in the runtime because loading the checkpoint needs torch; this module knows only the manifest
+it writes, so ``LegNetConfiguration.from_resource_manifest`` turns it into content-addressed
+``ResourceReference`` values without anyone copying digests by hand.
+
+Provider locations never enter the manifest. A reference's ``uri`` names the file beside the manifest, or
+``base_uri`` joined with the recorded filename when the prepared directory was copied elsewhere; the storage
+adapter that stages a reference decides where the bytes come from and verifies them against the digest.
+"""
+
+from __future__ import annotations
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from altar.models import ResourceReference
+
+
+if TYPE_CHECKING:
+    import os
+
+
+ARCHITECTURE = "human LegNet"
+MANIFEST_SCHEMA_VERSION = "0.0.1"
+MANIFEST_FILENAME = "legnet.resources.json"
+# The manifest's resource keys; the runtime records the training configuration as ``model_config``.
+_WEIGHTS_RESOURCE = "weights"
+_CONFIG_RESOURCE = "model_config"
+
+
+@dataclass(frozen=True)
+class ManifestResources:
+    """Location-neutral references and the checkpoint's cell type, read from one ``legnet.resources.json``."""
+
+    weights: ResourceReference
+    training_config: ResourceReference
+    cell_type: str
+
+
+def manifest_resources(path: str | os.PathLike[str], *, base_uri: str | None = None) -> ManifestResources:
+    """Read the manifest the runtime's preparer writes into the weights and training-configuration references.
+
+    Each reference's ``uri`` names the file beside the manifest, or ``base_uri`` joined with the recorded
+    filename when the prepared directory was copied elsewhere, such as an object-storage prefix. The digests
+    are the manifest's; the storage adapter that stages a reference verifies the bytes against them. Raises
+    ``ValueError`` for a manifest of another architecture or schema, or one that lacks a resource or the
+    checkpoint's cell type.
+    """
+    manifest_path = Path(path)
+    manifest: dict[str, Any] = json.loads(manifest_path.read_text())
+    if manifest.get("architecture") != ARCHITECTURE or manifest.get("schema_version") != MANIFEST_SCHEMA_VERSION:
+        msg = f"{str(manifest_path)!r} is not a {ARCHITECTURE} resource manifest with schema {MANIFEST_SCHEMA_VERSION}"
+        raise ValueError(msg)
+    records = manifest.get("resources", {})
+    missing = [name for name in (_CONFIG_RESOURCE, _WEIGHTS_RESOURCE) if name not in records]
+    if missing:
+        msg = f"{str(manifest_path)!r} is missing resources {missing}"
+        raise ValueError(msg)
+    cell_type = manifest.get("cell_type")
+    if not isinstance(cell_type, str) or not cell_type:
+        msg = f"{str(manifest_path)!r} does not record the checkpoint's cell_type"
+        raise ValueError(msg)
+
+    def reference(name: str) -> ResourceReference:
+        record = records[name]
+        return ResourceReference(
+            uri=_resource_uri(manifest_path.parent, record["filename"], base_uri), digest=record["digest"]
+        )
+
+    return ManifestResources(
+        weights=reference(_WEIGHTS_RESOURCE), training_config=reference(_CONFIG_RESOURCE), cell_type=cell_type
+    )
+
+
+def _resource_uri(directory: Path, filename: str, base_uri: str | None) -> str:
+    if base_uri is None:
+        return str(directory / filename)
+    return f"{base_uri.rstrip('/')}/{filename}"

altar_legnet-0.2.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "altar-legnet"
+version = "0.2.0"
+description = "LegNet model binding for large-scale Altar MPRA variant scoring"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{ name = "Riya Sinha" }]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Typing :: Typed",
+]
+dependencies = ["altar>=0.2.0,<0.3"]
+
+[project.urls]
+Documentation = "https://kundajelab.github.io/altar/"
+
+[project.entry-points."altar.model_plugins"]
+LEGNET = "altar_legnet:LegNetPlugin"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["altar_legnet"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+ignore_missing_imports = true

altar_legnet-0.2.0/tests/test_plugin.py

@@ -0,0 +1,275 @@
+# Copyright 2026 Riya Sinha
+"""Contract tests for the backend-neutral LegNet binding."""
+
+# Assertions use fixed golden values intentionally.
+# ruff: noqa: PLR2004
+
+from __future__ import annotations
+import json
+import math
+import os
+from pathlib import Path
+
+import pytest
+from altar.execution import LocalStorage, PathResolver
+from altar.models import (
+    ContainerImageDigest,
+    ContainerScoringPlan,
+    ResourceReference,
+    ScoringLayout,
+    ScoringRequest,
+    VariantClass,
+    VariantKey,
+    get_model_plugin_registry,
+    scoring_plan_from_json,
+    scoring_plan_to_json,
+)
+from altar.testing import ContainerScorerContract, ModelResultContract
+from altar_legnet import (
+    CONTEXT_LENGTH,
+    DEFAULT_IMAGE,
+    KIND_SCORING,
+    MODEL_INPUT_LENGTH,
+    LegNetConfiguration,
+    LegNetPlugin,
+    LegNetRunInputs,
+)
+from pydantic import TypeAdapter, ValidationError
+
+
+PLUGIN = LegNetPlugin()
+IMAGE = f"ghcr.io/kundajelab/altar-legnet@sha256:{'1' * 64}"
+WEIGHTS_DIGEST = f"sha256:{'2' * 64}"
+CONFIG_DIGEST = f"sha256:{'3' * 64}"
+GENOME_DIGEST = f"sha256:{'4' * 64}"
+
+
+def _configuration(**overrides: object) -> LegNetConfiguration:
+    values: dict[str, object] = {
+        "weights": ResourceReference(uri="s3://models/WTC11.ckpt", digest=WEIGHTS_DIGEST),
+        "training_config": ResourceReference(uri="s3://models/WTC11.json", digest=CONFIG_DIGEST),
+        "cell_type": "WTC11",
+        "average_reverse": True,
+        "image": IMAGE,
+    }
+    values.update(overrides)
+    return LegNetConfiguration.model_validate(values)
+
+
+def _request(*, scoring_batch: int | None = 3) -> ScoringRequest:
+    return ScoringRequest(
+        job_id="J",
+        model_id="M",
+        configuration=_configuration(),
+        run_inputs=LegNetRunInputs(
+            genome_build="hg38",
+            genome=ResourceReference(uri="s3://genomes/hg38.fa", digest=GENOME_DIGEST),
+        ),
+        output=PLUGIN.default_output,
+        resolver=PathResolver("/mnt/volume"),
+        layout=ScoringLayout(),
+        scoring_batch=scoring_batch,
+        scoring_batch_count=16,
+    )
+
+
+class TestLegNetResultsConformance(ModelResultContract):
+    @pytest.fixture
+    def plugin(self) -> LegNetPlugin:
+        return LegNetPlugin()
+
+
+class TestLegNetContainerConformance(ContainerScorerContract):
+    @pytest.fixture
+    def plugin(self) -> LegNetPlugin:
+        return LegNetPlugin()
+
+    @pytest.fixture
+    def scoring_request(self) -> ScoringRequest:
+        return _request()
+
+
+def test_registration_manifest_and_plan_shape() -> None:
+    assert get_model_plugin_registry().get("LEGNET") is LegNetPlugin
+    assert {
+        PLUGIN.manifest.plugin_version,
+        PLUGIN.manifest.configuration_schema_version,
+        PLUGIN.manifest.result_schema.version,
+        PLUGIN.manifest.prioritization.version,
+    } == {"0.0.1"}
+    assert CONTEXT_LENGTH == 200
+    assert MODEL_INPUT_LENGTH == 230
+    plan = PLUGIN.build_scoring_plan(_request())
+    assert isinstance(plan, ContainerScoringPlan)
+    assert len(plan.shards) == plan.ready_when == 1
+    assert plan.shards[0].kind == KIND_SCORING
+    assert plan.shards[0].resources.gpu is None
+    assert plan.shards[0].resources.memory_gb == 4
+    assert scoring_plan_from_json(scoring_plan_to_json(plan)) == plan
+
+
+def test_binding_supplies_digest_pinned_default_image() -> None:
+    configuration = _configuration()
+    configuration = LegNetConfiguration.model_validate(
+        {key: value for key, value in configuration.to_dict().items() if key != "image"}
+    )
+    assert configuration.image == DEFAULT_IMAGE
+    assert TypeAdapter(ContainerImageDigest).validate_python(DEFAULT_IMAGE) == DEFAULT_IMAGE
+
+
+def test_plan_stages_content_addressed_resources_and_primary_result() -> None:
+    plan = PLUGIN.build_scoring_plan(_request())
+    task = plan.shards[0]
+    transfers = {item.logical_path: item for item in task.inputs}
+    assert transfers["models/M/legnet.weights.ckpt"].digest == WEIGHTS_DIGEST
+    assert transfers["models/M/legnet.config.json"].digest == CONFIG_DIGEST
+    assert transfers["genomes/hg38/genome.fasta"].digest == GENOME_DIGEST
+    assert task.command[task.command.index("--genome-digest") + 1] == GENOME_DIGEST
+    assert "--average-reverse" in task.command
+    assert task.command[0:2] == ["legnet-score", "score"]
+    assert [result.name for result in plan.result_files] == ["primary"]
+    assert [item.logical_path for item in task.outputs] == ["jobs/J/results/M/batch_000003/mean.variant_scores.tsv"]
+
+
+def test_forward_only_mode_changes_scientific_identity_and_command() -> None:
+    averaged = PLUGIN.build_scoring_plan(_request())
+    request = _request()
+    request = ScoringRequest(
+        job_id=request.job_id,
+        model_id=request.model_id,
+        configuration=_configuration(average_reverse=False),
+        run_inputs=request.run_inputs,
+        output=request.output,
+        resolver=request.resolver,
+        layout=request.layout,
+    )
+    forward = PLUGIN.build_scoring_plan(request)
+    assert "--average-reverse" not in forward.shards[0].command
+    assert (
+        averaged.plugin_identity.scientific_configuration_hash != forward.plugin_identity.scientific_configuration_hash
+    )
+
+
+def test_batch_paths_change_without_changing_scientific_identity() -> None:
+    first = PLUGIN.build_scoring_plan(_request(scoring_batch=0))
+    second = PLUGIN.build_scoring_plan(_request(scoring_batch=1))
+    assert first.plugin_identity == second.plugin_identity
+    assert first.shards[0].outputs != second.shards[0].outputs
+
+
+def test_resource_relocation_does_not_change_scientific_identity() -> None:
+    first_request = _request()
+    relocated = _configuration(
+        weights=ResourceReference(uri="https://mirror.example/WTC11.ckpt", digest=WEIGHTS_DIGEST),
+        training_config=ResourceReference(uri="file:///models/WTC11.json", digest=CONFIG_DIGEST),
+    )
+    second_request = ScoringRequest(
+        job_id="other-job",
+        model_id="other-model",
+        configuration=relocated,
+        run_inputs=first_request.run_inputs,
+        output=first_request.output,
+        resolver=first_request.resolver,
+        layout=first_request.layout,
+    )
+    first = PLUGIN.build_scoring_plan(first_request)
+    second = PLUGIN.build_scoring_plan(second_request)
+    assert first.plugin_identity.scientific_configuration_hash == second.plugin_identity.scientific_configuration_hash
+    assert first.plugin_identity.configuration_hash != second.plugin_identity.configuration_hash
+
+
+@pytest.mark.parametrize("field", ["weights", "training_config"])
+def test_resources_require_digests(field: str) -> None:
+    with pytest.raises(ValidationError, match="require sha256 digests"):
+        _configuration(**{field: ResourceReference(uri=f"s3://models/{field}")})
+
+
+def test_only_hg38_is_accepted() -> None:
+    with pytest.raises(ValidationError, match="requires genome_build='hg38'"):
+        LegNetRunInputs(
+            genome_build="hg19",
+            genome=ResourceReference(uri="s3://genomes/hg19.fa", digest=GENOME_DIGEST),
+        )
+
+
+def test_prioritization_and_materialization_preserve_signed_delta() -> None:
+    assert PLUGIN.prioritize({"activity_delta": -0.75}, {})
+    assert not PLUGIN.prioritize({"activity_delta": 0.2}, {})
+    score = PLUGIN.to_model_score(
+        model_id="m1",
+        model_name="LegNet WTC11",
+        score={"ref_activity": 2.0, "alt_activity": 1.25, "activity_delta": -0.75, "prioritized": True},
+    )
+    assert score["activity_delta"] == -0.75
+    assert score["ref_activity"] == 2.0
+    missing = PLUGIN.to_model_score(
+        model_id="m1", model_name="LegNet", score={"activity_delta": math.nan, "prioritized": None}
+    )
+    assert missing["activity_delta"] is None
+    assert missing["prioritized"] is False
+
+
+async def test_codec_consumes_activity_rows(tmp_path: Path) -> None:
+    primary = tmp_path / "primary.tsv"
+    primary.write_text("variant_id\tref_activity\talt_activity\tactivity_delta\nchr1:7:A:T\t2.0\t1.25\t-0.75\n")
+    batches = [batch async for batch in PLUGIN.scoring_result_codec().decode(LocalStorage(), [str(primary)])]
+    assert batches[0].rows[0]["variant_id"] == "chr1:7:A:T"
+    assert batches[0].rows[0]["activity_delta"] == -0.75
+
+
+def test_manifest_declares_the_runtime_snv_only_input() -> None:
+    eligibility = PLUGIN.manifest.variant_eligibility
+    assert eligibility.variant_classes == {VariantClass.SNV}
+    assert eligibility.admits(VariantKey.parse("chr1:100:A:G"))
+    for variant_id in ("chr1:100:A:AT", "chr1:100:AT:A", "chr1:100:AC:GT"):
+        assert not eligibility.admits(VariantKey.parse(variant_id)), f"the LegNet runtime rejects {variant_id}"
+
+
+# The paired runtime's tests parse every argv in this file with the runtime's own CLI parser.
+RUNTIME_COMMANDS = Path(__file__).parents[3] / "runtimes" / "legnet" / "tests" / "data" / "binding_commands.json"
+
+
+def _golden_request() -> ScoringRequest:
+    """Pin the command coverage independently of the other tests' helpers.
+
+    Covers --cell-type, --assay, and the optional --average-reverse.
+    """
+    configuration = LegNetConfiguration(
+        weights=ResourceReference(uri="s3://models/HepG2.ckpt", digest=WEIGHTS_DIGEST),
+        training_config=ResourceReference(uri="s3://models/HepG2.json", digest=CONFIG_DIGEST),
+        cell_type="HepG2",
+        assay="LentiMPRA",
+        average_reverse=True,
+        image=IMAGE,
+    )
+    run_inputs = LegNetRunInputs(
+        genome_build="hg38", genome=ResourceReference(uri="s3://genomes/hg38.fa", digest=GENOME_DIGEST)
+    )
+    return ScoringRequest(
+        job_id="J",
+        model_id="M",
+        configuration=configuration,
+        run_inputs=run_inputs,
+        output=PLUGIN.default_output,
+        resolver=PathResolver("/mnt/volume"),
+        layout=ScoringLayout(),
+        scoring_batch=4,
+        scoring_batch_count=5,
+    )
+
+
+def test_runtime_command_golden_matches_plan() -> None:
+    plan = PLUGIN.build_scoring_plan(_golden_request())
+    tasks = [*plan.shards, *([plan.summarize] if plan.summarize is not None else [])]
+    golden = {
+        "generated_by": "bindings/legnet/tests/test_plugin.py (ALTAR_UPDATE_GOLDENS=1 rewrites this file)",
+        "commands": [{"kind": task.kind, "argv": list(task.command)} for task in tasks],
+    }
+    text = json.dumps(golden, indent=2) + "\n"
+    if os.environ.get("ALTAR_UPDATE_GOLDENS") == "1":
+        if os.environ.get("CI"):
+            pytest.fail("ALTAR_UPDATE_GOLDENS must not rewrite goldens in CI")
+        RUNTIME_COMMANDS.write_text(text)
+    assert json.loads(RUNTIME_COMMANDS.read_text()) == json.loads(text), (
+        "the runtime command changed; rerun with ALTAR_UPDATE_GOLDENS=1, then run the runtime's tests"
+    )

altar_legnet-0.2.0/tests/test_resources.py

@@ -0,0 +1,95 @@
+# Copyright 2026 Riya Sinha
+"""The LegNet resource manifest: written by the runtime's preparer, read back by the binding's configuration."""
+
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+from altar.models import sha256_file
+from altar_legnet import LegNetConfiguration, LegNetPlugin
+from altar_legnet.resources import ARCHITECTURE, MANIFEST_FILENAME, MANIFEST_SCHEMA_VERSION, manifest_resources
+
+
+IMAGE = f"ghcr.io/kundajelab/altar-legnet@sha256:{'1' * 64}"
+# The one manifest golden: a directory as `legnet-resources package` leaves it, which the runtime's
+# tests/test_resource_manifest.py regenerates from its own preparer (ALTAR_UPDATE_GOLDENS=1).
+PREPARED = Path(__file__).parents[3] / "runtimes" / "legnet" / "tests" / "data" / "prepared_resources"
+# The names `altar_legnet_runtime.resources` gives the prepared checkpoint and training configuration.
+WEIGHTS_FILENAME = "legnet.weights.ckpt"
+CONFIG_FILENAME = "legnet.config.json"
+
+
+def test_manifest_resources_are_content_addressed_and_located_beside_the_manifest() -> None:
+    manifest_path = PREPARED / MANIFEST_FILENAME
+
+    resources = manifest_resources(manifest_path)
+
+    assert resources.weights.uri == str(manifest_path.parent / WEIGHTS_FILENAME)
+    assert resources.training_config.uri == str(manifest_path.parent / CONFIG_FILENAME)
+    assert resources.weights.digest == sha256_file(resources.weights.uri)
+    assert resources.training_config.digest == sha256_file(resources.training_config.uri)
+    assert resources.cell_type == "WTC11"
+    relocated = manifest_resources(manifest_path, base_uri="gs://bucket/legnet-wtc11/")
+    assert relocated.weights.uri == f"gs://bucket/legnet-wtc11/{WEIGHTS_FILENAME}"
+    assert relocated.training_config.uri == f"gs://bucket/legnet-wtc11/{CONFIG_FILENAME}"
+    assert relocated.weights.digest == resources.weights.digest
+
+
+_RECORD = {"filename": "f", "digest": f"sha256:{'2' * 64}", "size_bytes": 1, "source": "s"}
+
+
+@pytest.mark.parametrize(
+    ("manifest", "match"),
+    [
+        (
+            {"architecture": "Enformer", "schema_version": MANIFEST_SCHEMA_VERSION, "resources": {}},
+            "is not a human LegNet resource manifest with schema 0.0.1",
+        ),
+        (
+            {"architecture": ARCHITECTURE, "schema_version": "0.0.2", "resources": {}},
+            "is not a human LegNet resource manifest with schema 0.0.1",
+        ),
+        (
+            {
+                "architecture": ARCHITECTURE,
+                "schema_version": MANIFEST_SCHEMA_VERSION,
+                "cell_type": "WTC11",
+                "resources": {"weights": _RECORD},
+            },
+            r"is missing resources \['model_config'\]",
+        ),
+        (
+            {
+                "architecture": ARCHITECTURE,
+                "schema_version": MANIFEST_SCHEMA_VERSION,
+                "resources": {"weights": _RECORD, "model_config": _RECORD},
+            },
+            "does not record the checkpoint's cell_type",
+        ),
+    ],
+)
+def test_manifest_resources_rejects_other_or_incomplete_manifests(
+    tmp_path: Path, manifest: dict[str, Any], match: str
+) -> None:
+    path = tmp_path / MANIFEST_FILENAME
+    path.write_text(json.dumps(manifest))
+    with pytest.raises(ValueError, match=match):
+        manifest_resources(path)
+
+
+def test_configuration_from_resource_manifest() -> None:
+    manifest_path = PREPARED / MANIFEST_FILENAME
+
+    configuration = LegNetConfiguration.from_resource_manifest(manifest_path, image=IMAGE, average_reverse=False)
+
+    resources = manifest_resources(manifest_path)
+    assert configuration.weights == resources.weights
+    assert configuration.training_config == resources.training_config
+    assert (configuration.cell_type, configuration.assay) == ("WTC11", "LentiMPRA")
+    assert (configuration.average_reverse, configuration.image) == (False, IMAGE)
+    # The manifest's cell type is a default; a setting overrides it like any other field.
+    assert LegNetConfiguration.from_resource_manifest(manifest_path, cell_type="HepG2").cell_type == "HepG2"
+    # The run driver hands the built configuration to the plugin, which accepts it as its own.
+    assert LegNetPlugin().parse_configuration(configuration) is configuration