class_docstr: Bracket of rungs for the algorithm Hyperband.
  
  Parameters
  ----------
  evolutiones: `evolutiones` algorithm
      The evolutiones algorithm object which this bracket will be part of.
  budgets: list of tuple
      Each tuple gives the (n_trials, resource_budget) for the respective rung.
  repetition_id: int
      The id of hyperband execution this bracket belongs to
docstr: Get the mutated population and hurdles
docstr_tok: ["Get","the","mutated","population","and","hurdles"]
code: def _mutate_population(
      self,
      red_team: Sequence[int],
      blue_team: Sequence[int],
      rung: dict,
      population_range: int,
      fidelity: int | float,
  ) -> tuple[list[Trial], np.ndarray]:
      """Get the mutated population and hurdles"""
      winner_list = []
      loser_list = []
  
      if set(red_team) != set(blue_team):
          hurdles = np.zeros(1)
          for i, red_value in enumerate(red_team):
              winner, loser = (
                  (red_team, blue_team)
                  if self.owner.performance[red_value]
                  < self.owner.performance[blue_team[i]]
                  else (blue_team, red_team)
              )
  
              winner_list.append(winner[i])
              loser_list.append(loser[i])
              hurdles += self.owner.performance[winner[i]]
              self._mutate(winner[i], loser[i])
  
          hurdles /= len(red_team)
          self.owner.hurdles.append(hurdles)
  
          logger.debug(
              "Evolution hurdles are: %s", str(self.owner.hurdles)
          )
  
      trials = []
      trial_ids = set()
      nums_all_equal = [0] * population_range
      for i in range(population_range):
          point: Sequence[int | float] = [0] * len(self.space)
          while True:
              point = list(point)
              point[
                  list(self.space.keys()).index(
                      self.owner.fidelity_index
                  )
              ] = fidelity
  
              for j in self.search_space_without_fidelity:
                  point[j] = self.owner.population[j][i]
  
              trial = format_trials.tuple_to_trial(point, self.space)
              trial_id = self.owner.get_id(trial)
  
              if trial_id in trial_ids:
                  nums_all_equal[i] += 1
                  logger.debug("find equal one, continue to mutate.")
                  self._mutate(i, i)
              elif self.owner.has_suggested(trial):
                  nums_all_equal[i] += 1
                  logger.debug(
                      "find one already suggested, continue to mutate."
                  )
                  self._mutate(i, i)
              else:
                  break
              if nums_all_equal[i] > self.owner.max_retries:
                  logger.warning(
                      "Can not Evolve any more. You can make an early stop."
                  )
                  break
  
          if nums_all_equal[i] < self.owner.max_retries:
              trials.append(trial)
              trial_ids.add(trial_id)
          else:
              logger.debug("Dropping trial %s", trial)
  
      return trials, np.array(nums_all_equal)
  
imports: from __future__ import annotations
  import copy
  import importlib
  import logging
  from typing import Callable, ClassVar, Sequence, TypeVar
  import numpy
  from orion.algo.hyperband import BudgetTuple, Hyperband, HyperbandBracket
  from orion.algo.space import Space
  from orion.core.utils import format_trials
  from orion.core.utils.flatten import flatten
  from orion.core.worker.trial import Trial
label_desc: Use image node_id 6 for calling the BracketEVES obj's underlying member method code with example usage: obj._mutate_population(red_team, blue_team, rung, population_range, fidelity) and returns: trials,  np