Choosing the Right Repository for Grant-Funded Projects #

from __future__ import annotations

from dataclasses import dataclass
from enum import Enum


class Repository(str, Enum):
    CONTROLLED_ACCESS = "controlled_access_gateway"
    DOMAIN = "domain_repository"
    DATAVERSE = "institutional_dataverse"
    FIGSHARE = "figshare"
    ZENODO = "zenodo"


# Generalist per-record ceiling in gigabytes (Zenodo/Figshare class).
GENERALIST_SIZE_CEILING_GB: float = 50.0

# Funders that designate a named archive for a given data type.
# key = (funder_ror, data_type) -> designated archive label.
FUNDER_DESIGNATED_ARCHIVES: dict[tuple[str, str], str] = {
    ("https://ror.org/01cwqze88", "sequence"): "NCBI GEO / SRA",   # NIH
    ("https://ror.org/01cwqze88", "structure"): "wwPDB",           # NIH
    ("https://ror.org/021nxhr62", "earth_observation"): "PANGAEA", # NSF (example)
}

# Disciplines with a community-certified repository.
DISCIPLINE_ARCHIVES: dict[str, str] = {
    "ecology": "Dryad",
    "earth_science": "PANGAEA",
    "proteomics": "ProteomeXchange",
    "genomics": "NCBI GEO / SRA",
}


@dataclass(frozen=True)
class DatasetProfile:
    """Everything the routing decision needs, known before deposit."""
    dataset_id: str
    funder_ror: str
    data_type: str          # e.g. "sequence", "structure", "tabular"
    discipline: str         # e.g. "genomics", "ecology"
    largest_file_gb: float
    is_restricted: bool     # human-subjects, PII, export-controlled
    has_curation_budget: bool


@dataclass(frozen=True)
class RepositoryChoice:
    repository: Repository
    target_archive: str     # concrete archive name for the operator
    reason: str             # audit string, logged with the correlation ID


def select_repository(profile: DatasetProfile) -> RepositoryChoice:
    """Route a grant-funded dataset to exactly one repository, deterministically."""
    if profile.largest_file_gb < 0:
        raise ValueError(f"largest_file_gb must be non-negative: {profile.largest_file_gb}")

    # Rule 1 — sensitivity is an absolute filter: never an open archive.
    if profile.is_restricted:
        return RepositoryChoice(
            Repository.CONTROLLED_ACCESS,
            "dbGaP / institutional restricted gateway",
            "restricted data: routed to a controlled-access gateway",
        )

    # Rule 2 — an explicit funder mandate outranks discipline and convenience.
    designated = FUNDER_DESIGNATED_ARCHIVES.get((profile.funder_ror, profile.data_type))
    if designated is not None:
        return RepositoryChoice(
            Repository.DOMAIN, designated,
            f"funder mandate: {profile.data_type} data must go to {designated}",
        )

    # Rule 3 — a certified disciplinary repository is the community norm.
    discipline_archive = DISCIPLINE_ARCHIVES.get(profile.discipline)
    if discipline_archive is not None:
        return RepositoryChoice(
            Repository.DOMAIN, discipline_archive,
            f"discipline standard: {profile.discipline} deposits to {discipline_archive}",
        )

    # Rule 4 — capacity forces the institutional large-file platform.
    if profile.largest_file_gb > GENERALIST_SIZE_CEILING_GB:
        return RepositoryChoice(
            Repository.DATAVERSE, "Institutional Dataverse",
            f"file {profile.largest_file_gb} GB exceeds the {GENERALIST_SIZE_CEILING_GB} GB "
            "generalist ceiling",
        )

    # Rule 5 — budgeted projects get managed curation.
    if profile.has_curation_budget:
        return RepositoryChoice(
            Repository.FIGSHARE, "Figshare",
            "curation budget available: managed onboarding via Figshare",
        )

    # Rule 6 — explicit default; free, DOI-minting, no capacity conflict.
    return RepositoryChoice(
        Repository.ZENODO, "Zenodo",
        "no constraint binds: default to free DOI-minting Zenodo",
    )

from repository_selector import (  # module holding the code above
    DatasetProfile, Repository, select_repository,
)


def _profile(**overrides) -> DatasetProfile:
    base = dict(
        dataset_id="DS-20260701", funder_ror="https://ror.org/00000000x",
        data_type="tabular", discipline="chemistry",
        largest_file_gb=2.0, is_restricted=False, has_curation_budget=False,
    )
    return DatasetProfile(**{**base, **overrides})


def test_precedence_and_default() -> None:
    # Rule 1 wins even when a funder mandate would otherwise apply.
    restricted = _profile(is_restricted=True, funder_ror="https://ror.org/01cwqze88",
                          data_type="sequence")
    assert select_repository(restricted).repository is Repository.CONTROLLED_ACCESS

    # Rule 2: NIH sequence data is routed to its designated archive.
    nih = _profile(funder_ror="https://ror.org/01cwqze88", data_type="sequence")
    assert select_repository(nih).target_archive == "NCBI GEO / SRA"

    # Rule 3: discipline standard, no funder mandate.
    eco = _profile(discipline="ecology")
    assert select_repository(eco).target_archive == "Dryad"

    # Rule 4: oversized file forces institutional Dataverse.
    big = _profile(largest_file_gb=120.0)
    assert select_repository(big).repository is Repository.DATAVERSE

    # Rule 5 vs Rule 6: budget flips managed curation on.
    assert select_repository(_profile(has_curation_budget=True)).repository is Repository.FIGSHARE
    assert select_repository(_profile()).repository is Repository.ZENODO


def test_incoherent_profile_raises() -> None:
    import pytest
    with pytest.raises(ValueError, match="non-negative"):
        select_repository(_profile(largest_file_gb=-1.0))