def _get_checkpoints_and_launch_runs(self, state: State):
        """Get the latest checkpoint from the training run.

        Args:
            state: The current state of the training run

        Returns:
            Returns checkpoints that have not been evaled
        """
        checkpointer = None
        for callback in state.callbacks:
            if isinstance(callback, CheckpointSaver):
                if checkpointer is None:
                    checkpointer = callback
                else:
                    log.warning(
                        'Multiple checkpoint savers found. Using the first one',
                    )

        if not checkpointer:
            warnings.warn('No checkpoint saver callback found. Skipping eval')
            return

        if not checkpointer.all_saved_checkpoints_to_timestamp:
            log.debug(
                'No saved checkpoints found on the checkpointer. Skipping eval',
            )
            return

        log.debug(
            f'Found {len(checkpointer.all_saved_checkpoints_to_timestamp)} ' +
            f'checkpoints: {checkpointer.all_saved_checkpoints_to_timestamp}',
        )

        remote_checkpoints = list_remote_objects(self.checkpoint_save_folder)

        if not remote_checkpoints:
            log.debug('No saved checkpoints found yet on remote. Skipping eval')
            return

        if state.fsdp_sharded_state_dict_enabled:
            checkpoints_to_eval = self._get_ready_sharded_checkpoints(
                checkpointer.all_saved_checkpoints_to_timestamp,
                remote_checkpoints,
            )
        else:
            checkpoints_to_eval = self._get_ready_single_checkpoints(
                checkpointer.all_saved_checkpoints_to_timestamp,
                remote_checkpoints,
            )

        for checkpoint_interval_path, checkpoint_timestamp in checkpoints_to_eval.items(
        ):
            checkpoint_ts = checkpoint_timestamp.get(self.interval.unit)
            if checkpoint_ts.value % self.interval.value != 0:
                log.debug(
                    f'Checkpoint {checkpoint_interval_path} ({checkpoint_ts}) is '
                    + f'not at an eval interval ({self.interval}), skipping',
                )
                continue
            if checkpoint_ts in self.checkpoints_evaled:
                continue  # Skip checkpoints that have already been evaled

            full_checkpoint_path = f'{self.checkpoint_save_folder}/{checkpoint_interval_path}'
            eval_run = self.launch_run(full_checkpoint_path, checkpoint_ts)
            self.checkpoints_evaled[checkpoint_ts] = (
                full_checkpoint_path,
                eval_run.name,
            )
Get the latest checkpoint from the training run.

        Args:
            state: The current state of the training run

        Returns:
            Returns checkpoints that have not been evaled
        
llmfoundry/callbacks/async_eval_callback.py