





import json
import logging
import os
import sys
from pathlib import Path

import finetune_rag

from transformers.file_utils import is_apex_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    require_ray,
    require_torch_gpu,
    require_torch_multi_gpu,
)


logging.basicConfig(level=logging.DEBUG)
_snake_case  :    Optional[int]						    =  logging.getLogger()

_snake_case  :    Union[str, Any]						    =  logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)



class 				_UpperCAmelCase    (    __a    ):

  """simple docstring"""


  def 				lowercase		(				self :		Tuple					,  lowerCAmelCase_ :		Optional[Any]     )							->						Dict:
     os.makedirs(lowerCAmelCase__					,  exist_ok=lowerCAmelCase__     )
     __lowerCAmelCase								=	{'source': 'What is love ?', 'target': 'life'}
     __lowerCAmelCase								=	{'train': 1_2, 'val': 2, 'test': 2}
     for split in ["train", "test", "val"]:
        for field in ["source", "target"]:
           __lowerCAmelCase								=	'\n'.join([contents[field]] * n_lines[split]     )
           with open(os.path.join(lowerCAmelCase__					,  f"""{split}.{field}"""     )					,  'w'     ) as f:
              f.write(lowerCAmelCase__     )






  def 				lowercase		(				self :		Optional[Any]					,  lowerCAmelCase_ :		int					,  lowerCAmelCase_ :		List[str] = "pytorch"     )							->						int:
     __lowerCAmelCase								=	self.get_auto_remove_tmp_dir()
     __lowerCAmelCase								=	os.path.join(lowerCAmelCase__					,  'output'     )
     __lowerCAmelCase								=	os.path.join(lowerCAmelCase__					,  'data'     )
     self._create_dummy_data(data_dir=lowerCAmelCase__     )

     __lowerCAmelCase								=	f"""\n                --data_dir {data_dir} \\n                --output_dir {output_dir} \\n                --model_name_or_path facebook/rag-sequence-base \\n                --model_type rag_sequence \\n                --do_train \\n                --do_predict \\n                --n_val -1 \\n                --val_check_interval 1.0 \\n                --train_batch_size 2 \\n                --eval_batch_size 1 \\n                --max_source_length 25 \\n                --max_target_length 25 \\n                --val_max_target_length 25 \\n                --test_max_target_length 25 \\n                --label_smoothing 0.1 \\n                --dropout 0.1 \\n                --attention_dropout 0.1 \\n                --weight_decay 0.001 \\n                --adam_epsilon 1e-08 \\n                --max_grad_norm 0.1 \\n                --lr_scheduler polynomial \\n                --learning_rate 3e-04 \\n                --num_train_epochs 1 \\n                --warmup_steps 4 \\n                --gradient_accumulation_steps 1 \\n                --distributed-port 8787 \\n                --use_dummy_dataset 1 \\n                --distributed_retriever {distributed_retriever} \\n            """.split()

     if gpus > 0:
        testargs.append(f"""--gpus={gpus}"""     )
        if is_apex_available():
           testargs.append('--fp16'     )
     else:
        testargs.append('--gpus=0'     )
        testargs.append('--distributed_backend=ddp_cpu'     )
        testargs.append('--num_processes=2'     )

     __lowerCAmelCase								=	[sys.executable, str(Path(finetune_rag.__file__     ).resolve()     )] + testargs
     execute_subprocess_async(lowerCAmelCase__					,  env=self.get_env()     )

     __lowerCAmelCase								=	os.path.join(lowerCAmelCase__					,  'metrics.json'     )
     with open(lowerCAmelCase__     ) as f:
        __lowerCAmelCase								=	json.load(lowerCAmelCase__     )
     return result






  @require_torch_gpu
  def 				lowercase		(				self :		Optional[int]     )							->						Any:
     __lowerCAmelCase								=	self._run_finetune(gpus=1     )
     self.assertGreaterEqual(result['test'][0]['test_avg_em']					,  0.2     )






  @require_torch_multi_gpu
  def 				lowercase		(				self :		Dict     )							->						List[Any]:
     __lowerCAmelCase								=	self._run_finetune(gpus=2     )
     self.assertGreaterEqual(result['test'][0]['test_avg_em']					,  0.2     )






  @require_torch_gpu
  @require_ray
  def 				lowercase		(				self :		Optional[Any]     )							->						Tuple:
     __lowerCAmelCase								=	self._run_finetune(gpus=1					,  distributed_retriever='ray'     )
     self.assertGreaterEqual(result['test'][0]['test_avg_em']					,  0.2     )






  @require_torch_multi_gpu
  @require_ray
  def 				lowercase		(				self :		Any     )							->						List[str]:
     __lowerCAmelCase								=	self._run_finetune(gpus=1					,  distributed_retriever='ray'     )
     self.assertGreaterEqual(result['test'][0]['test_avg_em']					,  0.2     )



"""simple docstring"""





def 						_lowerCAmelCase				(				UpperCamelCase_				):

		if isinstance(UpperCamelCase_  ,				UpperCamelCase_				):
				raise TypeError("""'float' object cannot be interpreted as an integer"""				)
		if isinstance(UpperCamelCase_  ,				UpperCamelCase_				):
				raise TypeError("""'str' object cannot be interpreted as an integer"""				)

		if num == 0:
				return "0b0"

		__SCREAMING_SNAKE_CASE            = False

		if num < 0:
				__SCREAMING_SNAKE_CASE            = True
				__SCREAMING_SNAKE_CASE            = -num

		__SCREAMING_SNAKE_CASE            = []
		while num > 0:
				binary.insert(0  ,				num % 2				)
				num >>= 1

		if negative:
				return "-0b" + "".join(str(UpperCamelCase_				) for e in binary				)

		return "0b" + "".join(str(UpperCamelCase_				) for e in binary				)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




