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.
    """
    from fwl_io.manifest import _discover

    root = resolve_data_root(data_root)
    locations, layout_error = _legacy_locations()
    entries: list[Relocation] = []
    seen: set[str] = set()
    providers, manifest_errors = _discover()
    for provider_datasets in providers.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
            unmovable = _unmovable(ds, registry) if legacy_dir.is_dir() else None
            if unmovable is not None:
                entries.append(
                    Relocation(
                        ds.key,
                        UNRESOLVABLE,
                        legacy_dir=legacy_dir,
                        target_dir=target_dir,
                        detail=unmovable,
                    )
                )
                continue
            outside = _escaping(legacy_dir, target_dir, tuple(registry), root)
            if outside is not None:
                # A symlink is how this happens in a real tree: every joined
                # path looks clean and only resolving one shows it leaves.
                entries.append(
                    Relocation(
                        ds.key,
                        UNRESOLVABLE,
                        legacy_dir=legacy_dir,
                        target_dir=target_dir,
                        detail=f'{outside} resolves outside the data root {root}',
                    )
                )
                continue
            state, detail = _classify(legacy_dir, target_dir, registry)
            entries.append(
                Relocation(
                    ds.key,
                    state,
                    legacy_dir=legacy_dir,
                    target_dir=target_dir,
                    files=tuple(sorted(registry)),
                    detail=detail,
                    legacy_present=legacy_dir.is_dir(),
                )
            )
    return RelocationReport(tuple(entries), dict(manifest_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.

    A dataset is moved only when every file its registry declares is present
    in the legacy location and matches its recorded digest. Anything else is
    reported and left untouched, including 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, halted = [], False
    for entry in plan.entries:
        if entry.state != READY or halted:
            done.append(entry)
            continue
        moved = _move_one(entry, root)
        done.append(moved)
        if moved.state in (FAILED, SPLIT):
            # Stop rather than move more data past a tree that is already in a
            # state somebody has to look at.
            log.error('stopping after %s could not be relocated', moved.key)
            halted = True
    return RelocationReport(tuple(done), dict(plan.manifest_errors), plan.layout_error)