






'''simple docstring'''





import os
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers.models.realm.configuration_realm import RealmConfig
from transformers.models.realm.retrieval_realm import _REALM_BLOCK_RECORDS_FILENAME, RealmRetriever
from transformers.models.realm.tokenization_realm import VOCAB_FILES_NAMES, RealmTokenizer


class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  def    _UpperCAmelCase     (     self )			-> Dict:
     UpperCamelCase_									=     tempfile.mkdtemp()
     UpperCamelCase_									=     5

     # Realm tok
     UpperCamelCase_									=     [
         '[UNK]',
         '[CLS]',
         '[SEP]',
         '[PAD]',
         '[MASK]',
         'test',
         'question',
         'this',
         'is',
         'the',
         'first',
         'second',
         'third',
         'fourth',
         'fifth',
         'record',
         'want',
         '##want',
         '##ed',
         'wa',
         'un',
         'runn',
         '##ing',
         ',',
         'low',
         'lowest',
     ]
     UpperCamelCase_									=     os.path.join(self.tmpdirname		,		'realm_tokenizer' )
     os.makedirs(_UpperCAmelCase		,		exist_ok=_UpperCAmelCase )
     UpperCamelCase_									=     os.path.join(_UpperCAmelCase		,		VOCAB_FILES_NAMES['vocab_file'] )
     with open(self.vocab_file		,		'w'		,		encoding='utf-8' ) as vocab_writer:
        vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) )

     UpperCamelCase_									=     os.path.join(self.tmpdirname		,		'realm_block_records' )
     os.makedirs(_UpperCAmelCase		,		exist_ok=_UpperCAmelCase )




  def    _UpperCAmelCase     (     self )			-> RealmTokenizer:
     return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname		,		'realm_tokenizer' ) )




  def    _UpperCAmelCase     (     self )			-> Tuple:
     shutil.rmtree(self.tmpdirname )




  def    _UpperCAmelCase     (     self )			-> Any:
     UpperCamelCase_									=     RealmConfig(num_block_records=self.num_block_records )
     return config




  def    _UpperCAmelCase     (     self )			-> Dict:
     UpperCamelCase_									=     Dataset.from_dict(
         {
             'id': ['0', '1'],
             'question': ['foo', 'bar'],
             'answers': [['Foo', 'Bar'], ['Bar']],
         } )
     return dataset




  def    _UpperCAmelCase     (     self )			-> Dict:
     UpperCamelCase_									=     np.array(
         [
             B'This is the first record',
             B'This is the second record',
             B'This is the third record',
             B'This is the fourth record',
             B'This is the fifth record',
             B'This is a longer longer longer record',
         ]		,		dtype=_UpperCAmelCase		,		)
     return block_records




  def    _UpperCAmelCase     (     self )			-> Union[str, Any]:
     UpperCamelCase_									=     RealmRetriever(
         block_records=self.get_dummy_block_records()		,		tokenizer=self.get_tokenizer()		,		)
     return retriever




  def    _UpperCAmelCase     (     self )			-> str:
     UpperCamelCase_									=     self.get_config()
     UpperCamelCase_									=     self.get_dummy_retriever()
     UpperCamelCase_									=     retriever.tokenizer

     UpperCamelCase_									=     np.array([0, 3]		,		dtype='long' )
     UpperCamelCase_									=     tokenizer(['Test question'] ).input_ids
     UpperCamelCase_									=     tokenizer(
         ['the fourth']		,		add_special_tokens=_UpperCAmelCase		,		return_token_type_ids=_UpperCAmelCase		,		return_attention_mask=_UpperCAmelCase		,		).input_ids
     UpperCamelCase_									=     config.reader_seq_len

     UpperCamelCase_		,      UpperCamelCase_		,      UpperCamelCase_		,      UpperCamelCase_									=     retriever(
         _UpperCAmelCase		,		_UpperCAmelCase		,		answer_ids=_UpperCAmelCase		,		max_length=_UpperCAmelCase		,		return_tensors='np' )

     self.assertEqual(len(_UpperCAmelCase )		,		2 )
     self.assertEqual(len(_UpperCAmelCase )		,		2 )
     self.assertEqual(len(_UpperCAmelCase )		,		2 )
     self.assertEqual(concat_inputs.input_ids.shape		,		(2, 10) )
     self.assertEqual(concat_inputs.attention_mask.shape		,		(2, 10) )
     self.assertEqual(concat_inputs.token_type_ids.shape		,		(2, 10) )
     self.assertEqual(concat_inputs.special_tokens_mask.shape		,		(2, 10) )
     self.assertEqual(
         tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[0] )		,		['[CLS]', 'test', 'question', '[SEP]', 'this', 'is', 'the', 'first', 'record', '[SEP]']		,		)
     self.assertEqual(
         tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[1] )		,		['[CLS]', 'test', 'question', '[SEP]', 'this', 'is', 'the', 'fourth', 'record', '[SEP]']		,		)




  def    _UpperCAmelCase     (     self )			-> Optional[int]:
     UpperCamelCase_									=     self.get_config()
     UpperCamelCase_									=     self.get_dummy_retriever()
     UpperCamelCase_									=     retriever.tokenizer

     UpperCamelCase_									=     np.array([0, 3, 5]		,		dtype='long' )
     UpperCamelCase_									=     tokenizer(['Test question'] ).input_ids
     UpperCamelCase_									=     tokenizer(
         ['the fourth', 'longer longer']		,		add_special_tokens=_UpperCAmelCase		,		return_token_type_ids=_UpperCAmelCase		,		return_attention_mask=_UpperCAmelCase		,		).input_ids
     UpperCamelCase_									=     config.reader_seq_len

     UpperCamelCase_		,      UpperCamelCase_		,      UpperCamelCase_		,      UpperCamelCase_									=     retriever(
         _UpperCAmelCase		,		_UpperCAmelCase		,		answer_ids=_UpperCAmelCase		,		max_length=_UpperCAmelCase		,		return_tensors='np' )

     self.assertEqual([False, True, True]		,		_UpperCAmelCase )
     self.assertEqual([[-1, -1, -1], [6, -1, -1], [6, 7, 8]]		,		_UpperCAmelCase )
     self.assertEqual([[-1, -1, -1], [7, -1, -1], [7, 8, 9]]		,		_UpperCAmelCase )




  def    _UpperCAmelCase     (     self )			-> List[Any]:
     UpperCamelCase_									=     self.get_dummy_retriever()
     retriever.save_pretrained(os.path.join(self.tmpdirname		,		'realm_block_records' ) )

     # Test local path
     UpperCamelCase_									=     retriever.from_pretrained(os.path.join(self.tmpdirname		,		'realm_block_records' ) )
     self.assertEqual(retriever.block_records[0]		,		B'This is the first record' )

     # Test mocked remote path
     with patch('transformers.models.realm.retrieval_realm.hf_hub_download' ) as mock_hf_hub_download:
        UpperCamelCase_									=     os.path.join(
            os.path.join(self.tmpdirname		,		'realm_block_records' )		,		_REALM_BLOCK_RECORDS_FILENAME )
        UpperCamelCase_									=     RealmRetriever.from_pretrained('google/realm-cc-news-pretrained-openqa' )

     self.assertEqual(retriever.block_records[0]		,		B'This is the first record' )













import inspect
import os
import unittest
from pathlib import Path

import torch

import accelerate
from accelerate.test_utils import execute_subprocess_async
from accelerate.test_utils.testing import run_command


class 						_a       (  unittest.TestCase    ):






  """simple docstring"""





  A_						=   inspect.getfile(accelerate.test_utils    )
  A_						=   os.path.sep.join(mod_file.split(os.path.sep    )[:-1] + ["""scripts""", """test_cli.py"""]    )

  A_						=   ["""accelerate""", """launch"""]
  A_						=   Path.home() / """.cache/huggingface/accelerate"""
  A_						=   """default_config.yaml"""
  A_						=   config_folder / config_file
  A_						=   config_folder / """_default_config.yaml"""

  A_						=   Path("""tests/test_configs"""    )




  @classmethod
  def    _UpperCAmelCase     (     cls )			-> Union[str, Any]:
     if cls.config_path.is_file():
        cls.config_path.rename(cls.changed_path )




  @classmethod
  def    _UpperCAmelCase     (     cls )			-> List[str]:
     if cls.changed_path.is_file():
        cls.changed_path.rename(cls.config_path )




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     UpperCamelCase_									=     self.base_cmd
     if torch.cuda.is_available() and (torch.cuda.device_count() > 1):
        cmd += ["--multi_gpu"]
     execute_subprocess_async(cmd + [self.test_file_path]		,		env=os.environ.copy() )




  def    _UpperCAmelCase     (     self )			-> Optional[int]:
     for config in sorted(self.test_config_path.glob('**/*.yaml' ) ):
        with self.subTest(config_file=_UpperCAmelCase ):
           execute_subprocess_async(
               self.base_cmd + ['--config_file', str(_UpperCAmelCase ), self.test_file_path]		,		env=os.environ.copy() )




  def    _UpperCAmelCase     (     self )			-> Tuple:
     execute_subprocess_async(['accelerate', 'test']		,		env=os.environ.copy() )




class 						_a       (  unittest.TestCase    ):






  """simple docstring"""





  A_						=   """test-tpu"""
  A_						=   """us-central1-a"""
  A_						=   """ls"""
  A_						=   ["""accelerate""", """tpu-config"""]
  A_						=   """cd /usr/share"""
  A_						=   """tests/test_samples/test_command_file.sh"""
  A_						=   """Running gcloud compute tpus tpu-vm ssh"""




  def    _UpperCAmelCase     (     self )			-> Any:
     UpperCamelCase_									=     run_command(
         self.cmd
         + ['--command', self.command, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Any:
     UpperCamelCase_									=     run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/0_12_0.yaml',
             '--command',
             self.command,
             '--tpu_zone',
             self.tpu_zone,
             '--tpu_name',
             self.tpu_name,
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Any:
     UpperCamelCase_									=     run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--debug']		,		return_stdout=_UpperCAmelCase )
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Tuple:
     UpperCamelCase_									=     run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--command', self.command, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     UpperCamelCase_									=     run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/latest.yaml',
             '--command',
             self.command,
             '--command',
             'echo "Hello World"',
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls; echo \"Hello World\" --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Dict:
     UpperCamelCase_									=     run_command(
         self.cmd
         + ['--config_file', 'tests/test_configs/latest.yaml', '--command_file', self.command_file, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Dict:
     UpperCamelCase_									=     run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/0_12_0.yaml',
             '--command_file',
             self.command_file,
             '--tpu_zone',
             self.tpu_zone,
             '--tpu_name',
             self.tpu_name,
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> List[Any]:
     UpperCamelCase_									=     run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--install_accelerate', '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate -U; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     UpperCamelCase_									=     run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/latest.yaml',
             '--install_accelerate',
             '--accelerate_version',
             '12.0.0',
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate==12.0.0; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)





