Check

def check_dataset(fetcher: Fetcher, key: str = '') -> DatasetCheck:
    """Report the state of one dataset's files without touching the network.

    Parameters
    ----------
    fetcher : Fetcher
        Configured for the dataset to inspect. Nothing is fetched.
    key : str, optional
        Name for the dataset in the report; defaults to its subdirectory.

    Returns
    -------
    DatasetCheck
        One entry per file the manifest declares. For an archive dataset the
        entries are the extracted members recorded in the provenance stamp,
        reported as present rather than verified, since the registry pins the
        archive's checksum and not the checksums of what came out of it.
    """
    key = key or fetcher.subdir

    if fetcher.extract is not None:
        members = fetcher.recorded_members()
        if members is None:
            # No usable stamp means no extracted tree to speak of. The dataset
            # is reported as one missing item under the archive's own name,
            # rather than as zero items, which would read as complete.
            archive_name = next(iter(fetcher.registry))
            files = (FileCheck(archive_name, fetcher.target_dir / archive_name, MISSING),)
            return DatasetCheck(key, fetcher.subdir, fetcher.target_dir, files, verifiable=False)
        checks = [
            FileCheck(name, fetcher.target_dir / name, _member_state(fetcher.target_dir / name))
            for name in sorted(members)
        ]
        return DatasetCheck(
            key, fetcher.subdir, fetcher.target_dir, tuple(checks), verifiable=False
        )

    checks = [
        FileCheck(name, fetcher.target_dir / name, _file_state(fetcher, name))
        for name in sorted(fetcher.registry)
    ]
    return DatasetCheck(key, fetcher.subdir, fetcher.target_dir, tuple(checks), verifiable=True)

def check_for(model: str, data_root: str | Path | None = None) -> CheckReport:
    """Report the state of every dataset a given model requires.

    Nothing is downloaded and no dataset directory or file is written, so this
    is safe to run against a tree another process is reading.

    Nothing here raises for the state of the data or of a manifest. A caller
    running a check wants the whole picture, including the parts that could not
    be established, so every failure is carried in the report instead.

    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.

    Returns
    -------
    CheckReport
        Keyed by dataset, alongside the manifests that could not be read and
        the datasets that could not be resolved.
    """
    from fwl_io.manifest import _discover

    model = model.lower()
    datasets: dict[str, DatasetCheck] = {}
    dataset_errors: dict[str, str] = {}
    providers, manifest_errors = _discover()
    for provider_datasets in providers.values():
        for ds in provider_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,
                    extract=ds.extract,
                )
                datasets[ds.key] = check_dataset(fetcher, key=ds.key)
            except Exception as exc:  # noqa: BLE001 -- reported, never raised
                dataset_errors[ds.key] = str(exc)
                log.warning('cannot check dataset %r: %s', ds.key, exc)
    return CheckReport(
        datasets=datasets,
        manifest_errors=dict(manifest_errors),
        dataset_errors=dataset_errors,
    )