






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)
lowercase    				=   logging.getLogger()

lowercase    				=   logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




class 					UpperCamelCase_ (     a_							):



	'''simple docstring'''




	def 				_UpperCamelCase     (			self			,     a   )			->       Optional[int]:
								os.makedirs(lowercase_			,     exist_ok=lowercase_   )
								snake_case_           =				{'''source''': '''What is love ?''', '''target''': '''life'''}
								snake_case_           =				{'''train''': 12, '''val''': 2, '''test''': 2}
								for split in ["train", "test", "val"]:
															for field in ["source", "target"]:
																						snake_case_           =				'''\n'''.join([contents[field]] * n_lines[split]   )
																						with open(os.path.join(lowercase_			,     F'''{split}.{field}'''   )			,     'w'   ) as f:
																													f.write(lowercase_   )




	def 				_UpperCamelCase     (			self			,     a			,     a = "pytorch"   )			->       Union[str, Any]:
								snake_case_           =				self.get_auto_remove_tmp_dir()
								snake_case_           =				os.path.join(lowercase_			,     'output'   )
								snake_case_           =				os.path.join(lowercase_			,     'data'   )
								self._create_dummy_data(data_dir=lowercase_   )

								snake_case_           =				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'   )

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

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




	@require_torch_gpu
	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self._run_finetune(gpus=1   )
								self.assertGreaterEqual(result['test'][0]['test_avg_em']			,     0.2   )




	@require_torch_multi_gpu
	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self._run_finetune(gpus=2   )
								self.assertGreaterEqual(result['test'][0]['test_avg_em']			,     0.2   )




	@require_torch_gpu
	@require_ray
	def 				_UpperCamelCase     (			self   )			->       Dict:
								snake_case_           =				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 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self._run_finetune(gpus=1			,     distributed_retriever='ray'   )
								self.assertGreaterEqual(result['test'][0]['test_avg_em']			,     0.2   )








"""simple docstring"""





def     __SCREAMING_SNAKE_CASE    ( A_		,	A_					):
	if number < 0 or shift_amount < 0:
		raise ValueError('''both inputs must be positive integers'''					)

	lowerCAmelCase__      :		int    							=      str(bin(A_					)					)
	binary_number += "0" * shift_amount
	return binary_number

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_					):
	if number < 0 or shift_amount < 0:
		raise ValueError('''both inputs must be positive integers'''					)

	lowerCAmelCase__      :		Any    							=      str(bin(A_					)					)[2:]
	if shift_amount >= len(A_					):
		return "0b0"
	lowerCAmelCase__      :		Tuple    							=      binary_number[: len(A_					) - shift_amount]
	return "0b" + shifted_binary_number

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_					):
	if number >= 0:  # Get binary representation of positive number
		lowerCAmelCase__      :		Union[str, Any]    							=      '''0''' + str(bin(A_					)					).strip('''-'''					)[2:]
	else:  # Get binary (2's complement) representation of negative number
		lowerCAmelCase__      :		Optional[Any]    							=      len(bin(A_					)[3:]					)  # Find 2's complement of number
		lowerCAmelCase__      :		Optional[int]    							=      bin(abs(A_					) - (1 << binary_number_length)					)[3:]
		lowerCAmelCase__      :		int    							=      (
		    '''1''' + '''0''' * (binary_number_length - len(A_					)) + binary_number
		)

	if shift_amount >= len(A_					):
		return "0b" + binary_number[0] * len(A_					)
	return (
	    "0b"
	    + binary_number[0] * shift_amount
	    + binary_number[: len(A_					) - shift_amount]
	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




