code: 
  
  '''simple docstring'''
  
  
  
  
  
  class    SCREAMING_SNAKE_CASE__      :
  
  
  
  
  
      def __init__(   self):
           # numbermap keys are the number and its values are lists of indexes sorted
           # in ascending order
           lowercase__					:     Optional[int]   = {}
           # indexmap keys are an index and it's values are the number at that index
           lowercase__					:     List[str]   = {}
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a):
           if isinstance(__snake_case		,     (range, str)):
                lowercase__					:     List[str]   = list(__snake_case)
           elif not isinstance(__snake_case		,     __snake_case):
                raise TypeError(
                    'binary_search_delete() only accepts either a list, range or str')
  
           lowercase__					:     List[str]   = 0
           lowercase__					:     Union[str, Any]   = len(__snake_case) - 1
  
           while low <= high:
                lowercase__					:     List[str]   = (low + high) // 2
                if array[mid] == item:
                     array.pop(__snake_case)
                     return array
                elif array[mid] < item:
                     lowercase__					:     Any   = mid + 1
                else:
                     lowercase__					:     str   = mid - 1
           raise ValueError(
               'Either the item is not in the array or the array was unsorted')
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a):
           if isinstance(__snake_case		,     (range, str)):
                lowercase__					:     Dict   = list(__snake_case)
           elif not isinstance(__snake_case		,     __snake_case):
                raise TypeError(
                    'binary_search_insert() only accepts either a list, range or str')
  
           lowercase__					:     Dict   = 0
           lowercase__					:     Dict   = len(__snake_case) - 1
  
           while low <= high:
                lowercase__					:     Tuple   = (low + high) // 2
                if array[mid] == index:
                     # If the item already exists in the array,
                     # insert it after the existing item
                     array.insert(mid + 1		,     __snake_case)
                     return array
                elif array[mid] < index:
                     lowercase__					:     List[Any]   = mid + 1
                else:
                     lowercase__					:     int   = mid - 1
  
          # If the item doesn't exist in the array, insert it at the appropriate position
           array.insert(__snake_case		,     __snake_case)
           return array
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a):
           # Remove previous index
           if index in self.indexmap:
                lowercase__					:     Optional[Any]   = self.indexmap[index]
                if len(self.numbermap[n]) == 1:
                     del self.numbermap[n]
                else:
                     lowercase__					:     Optional[int]   = self.binary_search_delete(self.numbermap[n]		,     __snake_case)
  
          # Set new index
           lowercase__					:     List[str]   = number
  
           # Number not seen before or empty so insert number value
           if number not in self.numbermap:
                lowercase__					:     Tuple   = [index]
  
           # Here we need to perform a binary search insertion in order to insert
           # The item in the correct place
           else:
                lowercase__					:     Dict   = self.binary_search_insert(
                    self.numbermap[number]		,     __snake_case)
  
  
  
  
  
      def    snake_case_       (   self		,     a):
           return self.numbermap.get(__snake_case		,     [-1])[0]
  
  
  if __name__ == "__main__":
         import doctest
  
         doctest.testmod()
  
  
style_context: 
  
  # as due to their complexity multi-gpu tests could impact other tests, and to aid debug we have those in a separate module.
  
  import os
  import sys
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, get_gpu_count, require_torch_gpu, slow
  
  from .utils import load_json
  
  
  class    SCREAMING_SNAKE_CASE__      (__snake_case  ):
  
  
  
  
  
      @classmethod
      def    snake_case_       (   cls):
           return cls
  
  
  
  
  
      @slow
      @require_torch_gpu
      def    snake_case_       (   self):
           lowercase__					:     List[Any]   = self.get_auto_remove_tmp_dir()
           lowercase__					:     List[str]   = f"""
              --model_name Helsinki-NLP/opus-mt-en-ro
              --save_dir {output_dir}
              --data_dir {self.test_file_dir_str}/test_data/wmt_en_ro
              --num_beams 2
              --task translation
          """.split()
  
           # we want this test to run even if there is only one GPU, but if there are more we use them all
           lowercase__					:     int   = get_gpu_count()
           lowercase__					:     Tuple   = f"""
              -m torch.distributed.launch
              --nproc_per_node={n_gpu}
              {self.test_file_dir}/run_distributed_eval.py
          """.split()
           lowercase__					:     Optional[Any]   = [sys.executable] + distributed_args + args
           execute_subprocess_async(a		,     env=self.get_env())
  
           lowercase__					:     str   = os.path.join(a		,     'test_bleu.json')
           lowercase__					:     List[str]   = load_json(a)
           # print(metrics)
           self.assertGreaterEqual(metrics['bleu']		,     25)
  
  