manifest

def discover_manifests() -> dict[str, list[Dataset]]:
    """Collect datasets from every installed ``fwl_io.manifests`` entry point.

    Entry points must resolve to a zero-argument callable returning the
    manifest path. A provider whose manifest fails to load is skipped with a
    logged warning, so one broken package cannot break data access for every
    other model.
    """
    found, _ = _discover()
    return found

def fetch_for(model: str, data_root: str | Path | None = None) -> dict[str, list[Path]]:
    """Fetch every dataset a given model requires; return paths per dataset.

    All matching datasets are attempted; failures are collected and raised
    together at the end so one broken dataset does not block the others
    (files fetched before the error remain in place).

    Parameters
    ----------
    model : str
        Model name matched (case-insensitively) against ``required_by``.
    data_root : str | Path | None
        Override for the data root; defaults to the resolved FWL_DATA tree.
    """
    from fwl_io.fetch import create_fetcher

    model = model.lower()
    fetched: dict[str, list[Path]] = {}
    failures: dict[str, str] = {}
    for datasets in discover_manifests().values():
        for ds in datasets:
            if model not in tuple(r.lower() for r in ds.required_by):
                continue
            try:
                fetcher = create_fetcher(
                    subdir=ds.subdir,
                    zenodo=ds.zenodo,
                    dataverse=ds.dataverse,
                    registry=ds.registry(),
                    data_root=data_root,
                )
                fetched[ds.key] = fetcher.fetch_all()
            except Exception as exc:  # noqa: BLE001 -- aggregate and re-raise below
                failures[ds.key] = str(exc)
    if failures:
        detail = '\n'.join(f'  {key}: {msg}' for key, msg in sorted(failures.items()))
        raise RuntimeError(
            f'{len(failures)} dataset(s) failed for model {model!r} '
            f'({len(fetched)} succeeded):\n{detail}'
        )
    return fetched

def load_manifest(path: str | Path) -> list[Dataset]:
    """Load and validate all datasets declared in one manifest file."""
    path = Path(path)
    with path.open('rb') as fh:
        tree = tomllib.load(fh)

    datasets: list[Dataset] = []
    for key, table in _walk_tables(tree):
        subdir = table['subdir']
        _validate_subdir(key, subdir)
        zenodo = table.get('zenodo')
        dataverse = table.get('dataverse')
        if not zenodo:
            raise ValueError(
                f'dataset {key!r}: a Zenodo version DOI is required '
                f'("dataverse" is a download mirror, not a primary source)'
            )
        if not ZENODO_DOI_PATTERN.match(zenodo):
            raise ValueError(
                f'dataset {key!r}: zenodo value {zenodo!r} is not a Zenodo DOI '
                f'of the form 10.5281/zenodo.<record-id>'
            )
        if dataverse and not _GENERIC_DOI_PATTERN.match(dataverse):
            raise ValueError(f'dataset {key!r}: dataverse value {dataverse!r} is not a DOI')
        datasets.append(
            Dataset(
                key=key,
                name=table.get('name', key),
                subdir=subdir,
                zenodo=zenodo,
                dataverse=dataverse,
                required_by=tuple(table.get('required_by', ())),
                registry_path=path.parent / f'{key}.registry.txt',
            )
        )
    return datasets

def shared_manifest_path() -> Path:
    """Entry-point target: the manifest of datasets shared across models."""
    return Path(__file__).parent / 'data' / 'shared_manifest.toml'

def zenodo_record_id(doi: str) -> str:
    """Return the numeric record id of a Zenodo version DOI.

    Parameters
    ----------
    doi : str
        A Zenodo DOI of the form ``10.5281/zenodo.<record-id>`` (an optional
        ``doi:`` prefix is accepted).

    Returns
    -------
    str
        The trailing record-id digits.

    Raises
    ------
    ValueError
        When the string is not a Zenodo DOI.
    """
    match = ZENODO_DOI_PATTERN.match(doi.strip())
    if not match:
        raise ValueError(f'{doi!r} is not a Zenodo DOI of the form 10.5281/zenodo.<id>')
    return match.group(2)