Relocate

def plan_relocations(data_root: str | Path | None = None) -> RelocationReport:
    """Report what a relocation would do, touching nothing.

    Parameters
    ----------
    data_root : str | Path | None
        Override for the data root; defaults to the resolved FWL_DATA tree.

    Returns
    -------
    RelocationReport
        One entry per dataset that declares a legacy location, whether or not
        that location exists on this machine.
    """
    root = resolve_data_root(data_root)
    locations, layout_error = _legacy_locations()
    entries: list[Relocation] = []
    seen: set[str] = set()
    discovery = _discover_all()
    for provider_datasets in discovery.found.values():
        for ds in provider_datasets:
            legacy = locations.get(ds.key)
            if legacy is None or ds.key in seen:
                continue
            seen.add(ds.key)
            legacy_dir = root / legacy
            try:
                registry = ds.registry()
                target_dir = root / _version_dir(ds)
            except Exception as exc:  # noqa: BLE001 -- reported, never raised
                entries.append(
                    Relocation(ds.key, UNRESOLVABLE, legacy_dir=legacy_dir, detail=str(exc))
                )
                continue
            legacy_present = True  # a directory that cannot be read is still there
            try:
                legacy_present = _is_directory(legacy_dir)
                state, detail, files = _assess(
                    ds, registry, legacy_dir, target_dir, root, legacy_present
                )
            except OSError as exc:
                state, detail, files = (
                    UNRESOLVABLE,
                    f'cannot read {legacy_dir} or {target_dir}: {exc}',
                    (),
                )
            except ValueError as exc:
                state, detail, files = UNRESOLVABLE, f'{ds.key} registry cannot be used: {exc}', ()
            entries.append(
                Relocation(
                    ds.key,
                    state,
                    legacy_dir=legacy_dir,
                    target_dir=target_dir,
                    files=files,
                    detail=detail,
                    legacy_present=legacy_present,
                )
            )
    return RelocationReport(tuple(entries), discovery.errors, layout_error)

def relocate_all(data_root: str | Path | None = None, dry_run: bool = False) -> RelocationReport:
    """Move every legacy tree that checks out into the current layout.

    Every present file in the legacy location that matches its recorded
    digest moves; an absent file is reported for the fetcher to fill in at
    the new location. A present file that does not match its digest, or a
    legacy tree holding none of its registry's files, is reported and left
    untouched, as is a dataset already at its current location, which is the
    ordinary state once a fetch has happened there.

    Parameters
    ----------
    data_root : str | Path | None
        Override for the data root; defaults to the resolved FWL_DATA tree.
    dry_run : bool
        Report what would move without moving it.

    Returns
    -------
    RelocationReport
        The plan, with each moved dataset's entry rewritten to say so.
    """
    plan = plan_relocations(data_root)
    if dry_run:
        return plan
    root = resolve_data_root(data_root)
    done = []
    for entry in plan.entries:
        if entry.state != READY:
            done.append(entry)
            continue
        moved = _move_one(entry, root)
        done.append(moved)
        if moved.state in (FAILED, SPLIT):
            # Reported and left for a person to look at; a fault in one
            # dataset says nothing about the ones after it, so they still run.
            log.error('%s could not be relocated', moved.key)
    return RelocationReport(tuple(done), dict(plan.manifest_errors), plan.layout_error)