def METHOD_NAME(strategy_class: Strategy) -> Strategy:
    """Return overloaded Strategy Wrapper."""
    if TF is None:
        log(WARN, MISSING_EXTRA_TF)
        return strategy_class
    class TBWrapper(strategy_class):  # type: ignore
        """Strategy wrapper that hooks into some methods for TensorBoard logging."""
        def aggregate_evaluate(
            self,
            server_round: int,
            results: List[Tuple[ClientProxy, EvaluateRes]],
            failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
        ) -> Tuple[Optional[float], Dict[str, Scalar]]:
            """Hooks into aggregate_evaluate for TensorBoard logging purpose."""
            # Execute decorated function and extract results for logging
            # They will be returned at the end of this function but also
            # used for logging
            loss_aggregated, config = super().aggregate_evaluate(
                server_round,
                results,
                failures,
            )
            # Server logs
            writer = TF.summary.create_file_writer(
                os.path.join(logdir_run, "server")
            )
            # Write aggregated loss
            with writer.as_default(
                step=server_round
            ):  # pylint: disable=not-context-manager
                TF.summary.scalar(
                    "server/loss_aggregated", loss_aggregated, step=server_round
                )
                writer.flush()
            if len(results) == 0:
                return loss_aggregated, config
            # Client logs
            for client, evaluate_res in results:
                loss, num_examples, metrics = (
                    evaluate_res.loss,
                    evaluate_res.num_examples,
                    evaluate_res.metrics,
                )
                writer = TF.summary.create_file_writer(
                    os.path.join(logdir_run, "clients", client.cid)
                )
                with writer.as_default(  # pylint: disable=not-context-manager
                    step=server_round
                ):
                    TF.summary.scalar("clients/loss", loss)
                    TF.summary.scalar("clients/num_examples", num_examples)
                    if metrics is not None:
                        for key, value in metrics.items():
                            if type(value) in [int, float]:
                                TF.summary.scalar(f"clients/{key}", value)
                    writer.flush()
            return loss_aggregated, config
    return cast(Strategy, TBWrapper)