Diff Coverage

def _suggestion(name: str, candidates: Iterable[str]) -> str:
    """Build a ``did you mean`` hint for an unknown configuration name."""
    matches = difflib.get_close_matches(name, candidates, n=1)
    return f"; did you mean {matches[0]!r}?" if matches else ""


def _replace_target_path(
    config: Target[Any],

        raise ConfigResolutionError(
            f"CLI.{full_path}: changing _target_ through an override is not supported"
        )

    signature = inspect.signature(config.callable)
    parameter = signature.parameters.get(name)
    has_var_kwargs = any(
        item.kind is inspect.Parameter.VAR_KEYWORD
        for item in signature.parameters.values()

        except AttributeError as exc:
            raise ConfigResolutionError(
                f"CLI.{full_path}: target argument is not configured"
            ) from exc
        return config.replace(**{name: _replace_path(child, parts[1:], value, path=full_path)})

    normalized = value
    if parameter is not None:
        annotation = _target_hints(config.callable, path=path).get(
            name,
            parameter.annotation,
        )
        if annotation not in (Any, object, inspect.Signature.empty):

        full_path = f"{path}.{name}" if path else name
        if name not in config:
            raise ConfigResolutionError(f"CLI.{path}: unknown mapping key {name!r}")
        if len(parts) == 1:
            return {**config, name: value}
        return {**config, name: _replace_path(config[name], parts[1:], value, path=full_path)}

    location = f"CLI.{path}" if path else "CLI"
    if not is_dataclass(config):
        raise ConfigResolutionError(

    name = parts[0]
    if name not in config_fields:
        target = getattr(config, "target", None)
        if isinstance(target, Target):
            return replace(config, target=_replace_target_path(target, parts, value, path=path))
        raise ConfigResolutionError(
            f"{location}: unknown field {name!r} on {type(config).__name__}"
            f"{_suggestion(name, config_fields)}"
        )

    if child is None:
        raise ConfigResolutionError(
            f"CLI.{full_path}: component was not selected by the YAML"
        )
    return replace(config, **{name: _replace_path(child, parts[1:], value, path=full_path)})


def _apply_typed_overrides(
    config: TrainerConfig,

    """Normalize a list, tuple, or mapping annotation."""

    if origin is list or annotation is list:
        return _normalize_list(value, args[0] if args else Any, path=path)
    if origin is tuple or annotation is tuple:
        return _normalize_tuple(value, args, path=path)
    if not isinstance(value, Mapping):
        raise _fail(path, f"expected mapping, got {type(value).__name__}")
    return dict(value)


def _coerce_class(value: object, annotation: object, *, path: str) -> object:
    """Normalize a value against a concrete class annotation."""

def _coerce_class(value: object, annotation: object, *, path: str) -> object:
    """Normalize a value against a concrete class annotation."""

    if not isinstance(annotation, type):
        raise _fail(path, f"unsupported type annotation {_type_name(annotation)}")
    if isinstance(value, annotation):
        return value
    raise _fail(
        path,
        f"expected {_type_name(annotation)}, got {type(value).__name__}",
    )

    if isinstance(annotation, type) and dataclasses.is_dataclass(annotation):
        # Nested dataclass items resolve from mappings in the same way as
        # top-level dataclass components.
        return _resolve_dataclass(value, annotation, path=path)
    return _coerce_class(value, annotation, path=path)


def _resolve_union(node: object, annotation: object, *, path: str) -> object:
    """Resolve one value against an Optional or general union."""

    @property
    def callable(self) -> Callable[..., _T]:
        """Return the wrapped callable, read-only, for callers outside this class."""
        return self._target_

    def build(self, **runtime_kwargs: Any) -> _T:
        """Invoke the target with configured and applicable runtime arguments."""
        signature = inspect.signature(self._target_)