altar-sei 0.3.0__tar.gz

altar_sei-0.3.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_sei-0.3.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_sei-0.3.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: altar-sei
+Version: 0.3.0
+Summary: Sei model binding for large-scale Altar 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.4,>=0.3.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Altar Sei binding
+
+`altar-sei` is the lightweight control-plane binding for high-throughput Sei variant scoring. It registers
+`SEI` in Altar's canonical model-plugin group and does not install PyTorch, SciPy, the model architecture, or
+the official resources.
+
+Each model instance identifies the official checkpoint, projection vectors, histone-profile indices,
+sequence-class metadata, and an immutable runtime image by SHA-256 digest. The image defaults to
+`altar_sei.DEFAULT_IMAGE`, a published image validated against FunctionLab's official Sei framework
+(`runtimes/sei/validation/cpu-official-81f595f.json`). The binding emits one independently retryable task for each staged batch, and the
+runtime loads Sei once and microbatches every reference/alternate sequence pair. `prepare_scoring_batches`
+cache-filters Sei batches when it is given the `DetailStore` that holds `sequence_class_effects`.
+
+The primary row reports the class with the largest absolute effect while retaining its sign. The
+`sequence_class_effects` detail table preserves all 40 published class effects. Effects reproduce the official
+workflow: strand-averaged 21,907-profile predictions are nucleosome-occupancy adjusted as a reference/alternate
+pair, projected onto the published class vectors, and subtracted as alternate minus reference.
+
+The per-profile predictions behind those effects are an opt-in artifact. A run whose output selection is
+`SeiPlugin.profile_effects_output` also writes `chromatin_profile_effects`: one `.npz` per batch
+(`application/x-npz`) with `variant_ids`, the float32 `effects` matrix of strand-averaged alternate-minus-reference
+predictions for all 21,907 profiles (before nucleosome adjustment, NaN for an unscorable variant), the
+`profile_index` of each column, and `profile_names`, the published name of each column's profile, so a consumer
+maps columns to profiles without the runtime or its resources. The names come from the official archive's
+`target.names`, which `SeiConfiguration.target_names` identifies by digest; scores never read it, so only a run
+that selects the artifact requires it and stages it. It is not part of the score lineage. Altar never decodes the archive; the scoring engine digests
+the file and records it in an `ArtifactStore` with the variants it covers, and batch preparation treats a variant
+without it as a cache miss. The default selection's command line is unchanged; selecting the artifact is a
+different output selection and therefore a different score lineage. In an `altar run` spec, name the artifact in
+the model's `output` and declare an `[artifact_store]`.
+
+The initial runtime accepts SNVs on hg19 or hg38. The manifest declares SNV-only variant eligibility, so
+Altar's batch preparation filters out and reports other variant classes before they reach the runtime. The
+runtime records incomplete windows, reference mismatches, unsupported allele symbols, and unsupported IUPAC
+window bases as null-score rows that keep the variant's identity, logs the reason, and continues to score valid
+batch neighbors; the primary table holds scores only. Such a row has `n_classes_scored` 0 and no class rows. The
+binding declares `n_classes_scored` as the row count of `sequence_class_effects`, so batch preparation counts
+the variant as complete on later runs. It also writes a null-score row for an indel in a batch
+staged without that filter, but Altar's scoring engine rejects that row and fails the
+batch rather than store a score for a variant the manifest excludes. A repeated canonical variant fails the
+batch, as in every other runtime. `N` bases in otherwise valid windows
+use Selene's uniform encoding and are flagged in `contains_unk`. That is narrower than Selene's general indel
+machinery and is explicit: unsupported alleles do not receive an unversioned alignment policy. The operational
+`max_abs_class_effect >= 1` prioritization default is not a universal biological cutoff; consumers should
+calibrate prioritization for their cohort and question.
+
+The executor lives under `runtimes/sei`. The official Sei implementation and resources are restricted to
+academic and research use; those terms apply independently of this MIT-licensed binding.

altar_sei-0.3.0/README.md

@@ -0,0 +1,48 @@
+# Altar Sei binding
+
+`altar-sei` is the lightweight control-plane binding for high-throughput Sei variant scoring. It registers
+`SEI` in Altar's canonical model-plugin group and does not install PyTorch, SciPy, the model architecture, or
+the official resources.
+
+Each model instance identifies the official checkpoint, projection vectors, histone-profile indices,
+sequence-class metadata, and an immutable runtime image by SHA-256 digest. The image defaults to
+`altar_sei.DEFAULT_IMAGE`, a published image validated against FunctionLab's official Sei framework
+(`runtimes/sei/validation/cpu-official-81f595f.json`). The binding emits one independently retryable task for each staged batch, and the
+runtime loads Sei once and microbatches every reference/alternate sequence pair. `prepare_scoring_batches`
+cache-filters Sei batches when it is given the `DetailStore` that holds `sequence_class_effects`.
+
+The primary row reports the class with the largest absolute effect while retaining its sign. The
+`sequence_class_effects` detail table preserves all 40 published class effects. Effects reproduce the official
+workflow: strand-averaged 21,907-profile predictions are nucleosome-occupancy adjusted as a reference/alternate
+pair, projected onto the published class vectors, and subtracted as alternate minus reference.
+
+The per-profile predictions behind those effects are an opt-in artifact. A run whose output selection is
+`SeiPlugin.profile_effects_output` also writes `chromatin_profile_effects`: one `.npz` per batch
+(`application/x-npz`) with `variant_ids`, the float32 `effects` matrix of strand-averaged alternate-minus-reference
+predictions for all 21,907 profiles (before nucleosome adjustment, NaN for an unscorable variant), the
+`profile_index` of each column, and `profile_names`, the published name of each column's profile, so a consumer
+maps columns to profiles without the runtime or its resources. The names come from the official archive's
+`target.names`, which `SeiConfiguration.target_names` identifies by digest; scores never read it, so only a run
+that selects the artifact requires it and stages it. It is not part of the score lineage. Altar never decodes the archive; the scoring engine digests
+the file and records it in an `ArtifactStore` with the variants it covers, and batch preparation treats a variant
+without it as a cache miss. The default selection's command line is unchanged; selecting the artifact is a
+different output selection and therefore a different score lineage. In an `altar run` spec, name the artifact in
+the model's `output` and declare an `[artifact_store]`.
+
+The initial runtime accepts SNVs on hg19 or hg38. The manifest declares SNV-only variant eligibility, so
+Altar's batch preparation filters out and reports other variant classes before they reach the runtime. The
+runtime records incomplete windows, reference mismatches, unsupported allele symbols, and unsupported IUPAC
+window bases as null-score rows that keep the variant's identity, logs the reason, and continues to score valid
+batch neighbors; the primary table holds scores only. Such a row has `n_classes_scored` 0 and no class rows. The
+binding declares `n_classes_scored` as the row count of `sequence_class_effects`, so batch preparation counts
+the variant as complete on later runs. It also writes a null-score row for an indel in a batch
+staged without that filter, but Altar's scoring engine rejects that row and fails the
+batch rather than store a score for a variant the manifest excludes. A repeated canonical variant fails the
+batch, as in every other runtime. `N` bases in otherwise valid windows
+use Selene's uniform encoding and are flagged in `contains_unk`. That is narrower than Selene's general indel
+machinery and is explicit: unsupported alleles do not receive an unversioned alignment policy. The operational
+`max_abs_class_effect >= 1` prioritization default is not a universal biological cutoff; consumers should
+calibrate prioritization for their cohort and question.
+
+The executor lives under `runtimes/sei`. The official Sei implementation and resources are restricted to
+academic and research use; those terms apply independently of this MIT-licensed binding.

altar_sei-0.3.0/altar_sei/__init__.py

@@ -0,0 +1,29 @@
+# Copyright 2026 Riya Sinha
+"""Sei model binding for Altar."""
+
+from altar_sei.plugin import (
+    CHROMATIN_PROFILE_COUNT,
+    DEFAULT_IMAGE,
+    KIND_SCORING,
+    PROFILE_EFFECTS,
+    SEQUENCE_CLASS_COUNT,
+    SEQUENCE_LENGTH,
+    SeiConfiguration,
+    SeiPlugin,
+    SeiRunInputs,
+    SeiShardKind,
+)
+
+
+__all__ = [
+    "CHROMATIN_PROFILE_COUNT",
+    "DEFAULT_IMAGE",
+    "KIND_SCORING",
+    "PROFILE_EFFECTS",
+    "SEQUENCE_CLASS_COUNT",
+    "SEQUENCE_LENGTH",
+    "SeiConfiguration",
+    "SeiPlugin",
+    "SeiRunInputs",
+    "SeiShardKind",
+]

altar_sei-0.3.0/altar_sei/plugin.py

@@ -0,0 +1,324 @@
+# Copyright 2026 Riya Sinha
+"""Backend-neutral Sei binding for sequence-class variant effects."""
+
+from __future__ import annotations
+import enum
+from typing import cast
+
+from altar.execution import GpuPool, ResourceRequest, Transfer
+from altar.models import (
+    ApiVersionRange,
+    ArtifactSchema,
+    ContainerImageDigest,
+    ContainerScoringPlan,
+    DetailSchema,
+    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 Col, Ge, Lit, Predicate
+from pydantic import JsonValue
+from pydantic import model_validator
+
+
+SEQUENCE_LENGTH = 4_096
+CHROMATIN_PROFILE_COUNT = 21_907
+SEQUENCE_CLASS_COUNT = 40
+# Built from commit 81f595f; validated in runtimes/sei/validation/cpu-official-81f595f.json.
+DEFAULT_IMAGE = "riyavsinha/altar-sei@sha256:e6522cdfb01c3ea3ce3f2048a7d8cad0b40e61194a4952db0a41e9f25a2139c1"
+
+
+class SeiShardKind(enum.StrEnum):
+    """Stable execution kind emitted by :class:`SeiPlugin`."""
+
+    SCORING = "sei_scoring"
+
+
+KIND_SCORING = SeiShardKind.SCORING
+# 0.0.2 added profile_names, so a consumer maps matrix columns to profiles without the runtime or its resources.
+PROFILE_EFFECTS = ArtifactSchema(
+    name="chromatin_profile_effects",
+    version="0.0.2",
+    description=(
+        "One NumPy .npz archive per scoring batch: variant_ids (str, n), effects (float32, n x 21,907; the "
+        "strand-averaged alternate-minus-reference prediction of every chromatin profile, before nucleosome "
+        "adjustment, NaN for a variant the runtime could not score), profile_index (int32, 21,907; the "
+        "model's output column of each effect), and profile_names (str, 21,907; the published name of each "
+        "column's chromatin profile: line profile_index + 1 of the official target.names)."
+    ),
+    media_type="application/x-npz",
+)
+_PROFILE_EFFECTS_EXTENSION = ".npz"
+_SCORE_RESOURCES = ResourceRequest(gpu=GpuPool.NORMAL_GPU, count=1, memory_gb=16)
+_CLASS_EFFECT_THRESHOLD = 1.0
+
+
+class SeiConfiguration(ModelConfiguration):
+    """Immutable official Sei resources and runtime image.
+
+    Strand averaging, the 4,096 bp input, all 21,907 chromatin profiles, all 40 sequence classes, and
+    nucleosome-occupancy adjustment are fixed parts of the published scoring semantics rather than user options.
+    ``image`` defaults to :data:`DEFAULT_IMAGE`, the published runtime validated against the official Sei
+    framework.
+
+    ``target_names`` is the official archive's ``target.names``, the published name of each of the 21,907
+    chromatin profiles in model-output order. A run that selects the ``chromatin_profile_effects`` artifact
+    requires it, to name the archive's columns. No score reads it, so it is never part of the scientific
+    projection: setting it keeps the score lineage. The saved configuration includes it only while it is set.
+    """
+
+    weights: ResourceReference
+    projection_vectors: ResourceReference
+    histone_indices: ResourceReference
+    sequence_class_names: ResourceReference
+    target_names: ResourceReference | None = None
+    image: ContainerImageDigest = DEFAULT_IMAGE
+
+    @model_validator(mode="after")
+    def validate_resources(self) -> SeiConfiguration:
+        require_resource_digests(self, owner="Sei")
+        return self
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        """Return the saved configuration, without ``target_names`` while it is unset."""
+        return _without_unset_target_names(self, super().to_dict())
+
+    def scientific_dict(self) -> dict[str, JsonValue]:
+        """Return the scientific projection, which never includes ``target_names``."""
+        value = super().scientific_dict()
+        value.pop("target_names", None)
+        return value
+
+
+def _without_unset_target_names(configuration: SeiConfiguration, value: dict[str, JsonValue]) -> dict[str, JsonValue]:
+    if configuration.target_names is None:
+        value.pop("target_names", None)
+    return value
+
+
+class SeiRunInputs(ReferenceGenomeRunInputs):
+    """Per-run reference inputs supported by the official Sei workflow."""
+
+    supported_genome_builds = frozenset({"hg19", "hg38"})
+
+
+class SeiPlugin(ModelPlugin):
+    """Predicts how a variant changes 40 sequence classes of regulatory activity."""
+
+    model_type = "SEI"
+    manifest = PluginManifest(
+        plugin_id="org.kundajelab.altar.model.sei",
+        kind=PluginKind.MODEL,
+        capabilities=frozenset({PluginCapability.SCORE, PluginCapability.MATERIALIZE_RESULTS}),
+        architecture="Sei",
+        # The plugin version is part of every score lineage, and the profile names change neither the scores
+        # nor a configuration that does not name target_names, so adding them bumps only the artifact's version.
+        plugin_version="0.0.2",
+        altar_api=ApiVersionRange("0.1.0", "0.2.0"),
+        # target_names is optional and defaulted, so every saved 0.0.1 configuration still loads unchanged.
+        configuration_schema_version="0.0.1",
+        # 0.0.2 dropped the validation status and message columns: the primary table holds scores only, and
+        # an unscorable variant is a null-score row whose reason the runtime logs. 0.0.3 gives that row
+        # n_classes_scored 0, the row count of sequence_class_effects, so it counts as complete in the cache.
+        result_schema=ResultSchema(
+            version="0.0.3",
+            fields=(
+                ResultField("top_class_index", "int", "Top Class Index", "Index with largest absolute class effect"),
+                ResultField("top_class_label", "str", "Top Class", "Published label with largest absolute effect"),
+                ResultField(
+                    "top_class_effect",
+                    "float",
+                    "Top Class Effect",
+                    "Signed nucleosome-adjusted alternate-minus-reference projection score",
+                ),
+                ResultField(
+                    "max_abs_class_effect",
+                    "float",
+                    "Maximum Absolute Class Effect",
+                    "Absolute value of the largest-magnitude sequence-class effect",
+                ),
+                ResultField(
+                    "n_classes_scored",
+                    "int",
+                    "Classes Scored",
+                    "Sequence-class effect rows emitted for the variant: 40, or 0 for a variant the runtime could "
+                    "not score",
+                ),
+                ResultField(
+                    "contains_unk",
+                    "bool",
+                    "Contains Unknown Base",
+                    "Whether the scored reference window contained at least one N encoded uniformly across bases",
+                ),
+            ),
+        ),
+        detail_schemas=(
+            DetailSchema(
+                name="sequence_class_effects",
+                version="0.0.1",
+                description="All 40 official nucleosome-adjusted Sei sequence-class variant effects.",
+                fields=(
+                    ResultField("class_index", "int", "Class Index", "Zero-based published class index", False),
+                    ResultField("class_label", "str", "Class Label", "Published short class label", False),
+                    ResultField("class_name", "str", "Class Name", "Published class description", False),
+                    ResultField(
+                        "class_effect",
+                        "float",
+                        "Class Effect",
+                        "Signed nucleosome-adjusted alternate-minus-reference projection score",
+                        False,
+                    ),
+                ),
+                key_fields=("class_index",),
+                row_count_field="n_classes_scored",
+            ),
+        ),
+        # The Sei runtime substitutes one reference base; batch preparation filters out indels and MNVs.
+        variant_eligibility=VariantEligibility(frozenset({VariantClass.SNV})),
+        # Opt-in: the full profile matrix is ~88 kB per variant, so only a run that selects it pays for it.
+        artifact_schemas=(PROFILE_EFFECTS,),
+        prioritization=PrioritizationPolicy(name="sei-max-absolute-class-effect-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.sei.configuration"
+    configuration_model = SeiConfiguration
+    run_input_model = SeiRunInputs
+    default_output = OutputSelection(
+        outputs=("scores", "sequence_class_effects"),
+        reducer="official_nucleosome_adjusted_sequence_class_effect_v1",
+    )
+    profile_effects_output = OutputSelection(
+        outputs=(*default_output.outputs, PROFILE_EFFECTS.name),
+        reducer=default_output.reducer,
+    )
+    """The output selection that also writes the per-batch ``chromatin_profile_effects`` artifact.
+
+    It requires :attr:`SeiConfiguration.target_names`, which the runtime copies into the archive as
+    ``profile_names``."""
+
+    def validate_output_selection(self, output: OutputSelection) -> OutputSelection:
+        """Accept the default selection, or the default plus the opt-in profile-effect artifact."""
+        if output in (self.default_output, self.profile_effects_output):
+            return output
+        msg = (
+            f"{self.model_type} supports output selections {self.default_output.to_dict()} and "
+            f"{self.profile_effects_output.to_dict()}, got {output.to_dict()}"
+        )
+        raise ValueError(msg)
+
+    def scoring_runtime_identities(self, configuration: ModelConfiguration) -> dict[str, str]:
+        """Record the configured Sei image as the scoring plan's one runtime."""
+        return {"model_runtime": self.parse_configuration_as(configuration, SeiConfiguration).image}
+
+    def build_scoring_plan(self, request: ScoringRequest) -> ContainerScoringPlan:
+        configuration = self.parse_configuration_as(request.configuration, SeiConfiguration)
+        run_inputs = self.parse_run_inputs_as(request.run_inputs, SeiRunInputs)
+        output = self.validate_output_selection(request.output)
+        layout, resolver = request.layout, request.resolver
+        resources = (
+            (configuration.weights, "sei.pth", "--weights", "--weights-digest"),
+            (configuration.projection_vectors, "projvec_targets.npy", "--projection-vectors", "--projection-digest"),
+            (configuration.histone_indices, "histone_inds.npy", "--histone-indices", "--histone-indices-digest"),
+            (configuration.sequence_class_names, "seqclass.names", "--class-names", "--class-names-digest"),
+        )
+        command = ["sei-score", "score"]
+        inputs: list[Transfer] = []
+        for resource, filename, path_argument, digest_argument in resources:
+            logical = layout.model_resource_file(request.model_id, filename)
+            command += [path_argument, resolver.resolve(logical), digest_argument, cast("str", resource.digest)]
+            inputs.append(resource_transfer(resource, logical, locality_key=request.model_id))
+        genome_logical = layout.genome_fasta(request.genome_label)
+        variants_logical = layout.model_variants_file(request.job_id, request.model_id, request.scoring_batch)
+        primary_logical = layout.scoring_result_file(request.job_id, request.model_id, request.scoring_batch)
+        details_logical = layout.detail_result_file(
+            request.job_id, request.model_id, "sequence_class_effects", request.scoring_batch
+        )
+        command += [
+            "--genome",
+            resolver.resolve(genome_logical),
+            "--genome-digest",
+            cast("str", run_inputs.genome.digest),
+            "--variants",
+            resolver.resolve(variants_logical),
+            "--primary-output",
+            resolver.resolve(primary_logical),
+            "--detail-output",
+            resolver.resolve(details_logical),
+        ]
+        if PROFILE_EFFECTS.name in output.outputs:
+            target_names = configuration.target_names
+            if target_names is None:
+                msg = (
+                    f"selecting the {PROFILE_EFFECTS.name} artifact requires SeiConfiguration.target_names, the "
+                    "official target.names that names the archive's 21,907 profile columns"
+                )
+                raise ValueError(msg)
+            target_names_logical = layout.model_resource_file(request.model_id, "target.names")
+            inputs.append(resource_transfer(target_names, target_names_logical, locality_key=request.model_id))
+            profile_effects_logical = layout.artifact_result_file(
+                request.job_id,
+                request.model_id,
+                PROFILE_EFFECTS.name,
+                request.scoring_batch,
+                extension=_PROFILE_EFFECTS_EXTENSION,
+            )
+            command += [
+                "--target-names",
+                resolver.resolve(target_names_logical),
+                "--target-names-digest",
+                cast("str", target_names.digest),
+                "--profile-effects-output",
+                resolver.resolve(profile_effects_logical),
+            ]
+        inputs.append(resource_transfer(run_inputs.genome, genome_logical))
+        return single_container_plan(
+            self,
+            request,
+            kind=KIND_SCORING,
+            image=configuration.image,
+            command=command,
+            resources=_SCORE_RESOURCES,
+            inputs=inputs,
+            artifact_extensions={PROFILE_EFFECTS.name: _PROFILE_EFFECTS_EXTENSION},
+        )
+
+    def prioritize_predicate(self) -> Predicate:
+        # Operational default only; Sei does not publish a universal biological cutoff.
+        return Ge(Col("max_abs_class_effect"), Lit(_CLASS_EFFECT_THRESHOLD))
+
+
+__all__ = [
+    "CHROMATIN_PROFILE_COUNT",
+    "DEFAULT_IMAGE",
+    "KIND_SCORING",
+    "PROFILE_EFFECTS",
+    "SEQUENCE_CLASS_COUNT",
+    "SEQUENCE_LENGTH",
+    "SeiConfiguration",
+    "SeiPlugin",
+    "SeiRunInputs",
+    "SeiShardKind",
+]

altar_sei-0.3.0/altar_sei/py.typed

@@ -0,0 +1 @@
+

altar_sei-0.3.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "altar-sei"
+version = "0.3.0"
+description = "Sei model binding for large-scale Altar 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.3.0,<0.4"]
+
+[project.urls]
+Documentation = "https://kundajelab.github.io/altar/"
+
+[project.entry-points."altar.model_plugins"]
+SEI = "altar_sei:SeiPlugin"
+
+[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_sei"]
+
+[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