


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching
def 							UpperCamelCase_(					)->		Optional[Any]:
			import os as original_os
			from os import path as original_path
			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join

			UpperCamelCase__       =							"__test_patch_submodule_mock__"
			with patch_submodule(_test_patching					,  "os.path.join"					,  _A	):
						# Every way to access os.path.join must be patched, and the rest must stay untouched

						# check os.path.join
						assert isinstance(_test_patching.os					,  _PatchedModuleObj	)
						assert isinstance(_test_patching.os.path					,  _PatchedModuleObj	)
						assert _test_patching.os.path.join is mock

						# check path.join
						assert isinstance(_test_patching.path					,  _PatchedModuleObj	)
						assert _test_patching.path.join is mock

						# check join
						assert _test_patching.join is mock

						# check that the other attributes are untouched
						assert _test_patching.os.rename is original_rename
						assert _test_patching.path.dirname is original_dirname
						assert _test_patching.os.path.dirname is original_dirname

						# Even renamed modules or objects must be patched

						# check renamed_os.path.join
						assert isinstance(_test_patching.renamed_os					,  _PatchedModuleObj	)
						assert isinstance(_test_patching.renamed_os.path					,  _PatchedModuleObj	)
						assert _test_patching.renamed_os.path.join is mock

						# check renamed_path.join
						assert isinstance(_test_patching.renamed_path					,  _PatchedModuleObj	)
						assert _test_patching.renamed_path.join is mock

						# check renamed_join
						assert _test_patching.renamed_join is mock

						# check that the other attributes are untouched
						assert _test_patching.renamed_os.rename is original_rename
						assert _test_patching.renamed_path.dirname is original_dirname
						assert _test_patching.renamed_os.path.dirname is original_dirname

			# check that everthing is back to normal when the patch is over

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join
def 							UpperCamelCase_(					)->		List[str]:
			assert _test_patching.open is open

			UpperCamelCase__       =							"__test_patch_submodule_builtin_mock__"
			# _test_patching has "open" in its globals
			assert _test_patching.open is open
			with patch_submodule(_test_patching					,  "open"					,  _A	):
						assert _test_patching.open is mock

			# check that everthing is back to normal when the patch is over

			assert _test_patching.open is open
def 							UpperCamelCase_(					)->		Optional[Any]:
			# pandas.read_csv is not present in _test_patching
			UpperCamelCase__       =							"__test_patch_submodule_missing_mock__"
			with patch_submodule(_test_patching					,  "pandas.read_csv"					,  _A	):
						pass
def 							UpperCamelCase_(					)->		Tuple:
			# builtin should always be mocked even if they're not in the globals
			# in case they're loaded at one point
			UpperCamelCase__       =							"__test_patch_submodule_missing_builtin_mock__"
			# _test_patching doesn't have "len" in its globals
			assert getattr(_test_patching					,  "len"					,  _A	) is None
			with patch_submodule(_test_patching					,  "len"					,  _A	):
						assert _test_patching.len is mock
			assert _test_patching.len is len
def 							UpperCamelCase_(					)->		int:
			UpperCamelCase__       =							"__test_patch_submodule_start_and_stop_mock__"
			UpperCamelCase__       =							patch_submodule(_test_patching					,  "open"					,  _A	)
			assert _test_patching.open is open
			patch.start()
			assert _test_patching.open is mock
			patch.stop()
			assert _test_patching.open is open
def 							UpperCamelCase_(					)->		int:
			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			UpperCamelCase__       =							"__test_patch_submodule_successive_join__"
			UpperCamelCase__       =							"__test_patch_submodule_successive_dirname__"
			UpperCamelCase__       =							"__test_patch_submodule_successive_rename__"
			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename

			with patch_submodule(_test_patching					,  "os.path.join"					,  _A	):
						with patch_submodule(_test_patching					,  "os.rename"					,  _A	):
									with patch_submodule(_test_patching					,  "os.path.dirname"					,  _A	):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

    # try another order
			with patch_submodule(_test_patching					,  "os.rename"					,  _A	):
						with patch_submodule(_test_patching					,  "os.path.join"					,  _A	):
									with patch_submodule(_test_patching					,  "os.path.dirname"					,  _A	):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename







def 							UpperCamelCase_(					)->		List[str]:
			UpperCamelCase__       =							"__test_patch_submodule_doesnt_exist_mock__"
			with patch_submodule(_test_patching					,  "__module_that_doesn_exist__.__attribute_that_doesn_exist__"					,  _A	):
						pass
			with patch_submodule(_test_patching					,  "os.__attribute_that_doesn_exist__"					,  _A	):
						pass






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

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







class 							lowerCamelCase__						(				UpperCAmelCase   ):






			"""simple docstring"""






			def 					snake_case__					(				self   ,    snake_case  ):

						'''simple docstring'''


						os.makedirs(snake_case   ,    exist_ok=snake_case  )
						UpperCamelCase__       =							{"source": "What is love ?", "target": "life"}
						UpperCamelCase__       =							{"train": 12, "val": 2, "test": 2}
						for split in ["train", "test", "val"]:
									for field in ["source", "target"]:
												UpperCamelCase__       =							"\n".join([contents[field]] * n_lines[split]  )
												with open(os.path.join(snake_case   ,    F'''{split}.{field}'''  )   ,    "w"  ) as f:
															f.write(snake_case  )




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case = "pytorch"  ):

						'''simple docstring'''


						UpperCamelCase__       =							self.get_auto_remove_tmp_dir()
						UpperCamelCase__       =							os.path.join(snake_case   ,    "output"  )
						UpperCamelCase__       =							os.path.join(snake_case   ,    "data"  )
						self._create_dummy_data(data_dir=snake_case  )

						UpperCamelCase__       =							F'''
                --data_dir {data_dir} \
                --output_dir {output_dir} \
                --model_name_or_path facebook/rag-sequence-base \
                --model_type rag_sequence \
                --do_train \
                --do_predict \
                --n_val -1 \
                --val_check_interval 1.0 \
                --train_batch_size 2 \
                --eval_batch_size 1 \
                --max_source_length 25 \
                --max_target_length 25 \
                --val_max_target_length 25 \
                --test_max_target_length 25 \
                --label_smoothing 0.1 \
                --dropout 0.1 \
                --attention_dropout 0.1 \
                --weight_decay 0.001 \
                --adam_epsilon 1e-08 \
                --max_grad_norm 0.1 \
                --lr_scheduler polynomial \
                --learning_rate 3e-04 \
                --num_train_epochs 1 \
                --warmup_steps 4 \
                --gradient_accumulation_steps 1 \
                --distributed-port 8787 \
                --use_dummy_dataset 1 \
                --distributed_retriever {distributed_retriever} \
            '''.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"  )

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

						UpperCamelCase__       =							os.path.join(snake_case   ,    "metrics.json"  )
						with open(snake_case  ) as f:
									UpperCamelCase__       =							json.load(snake_case  )
						return result




			@require_torch_gpu
			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self._run_finetune(gpus=1  )
						self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,    0.2  )




			@require_torch_multi_gpu
			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self._run_finetune(gpus=2  )
						self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,    0.2  )




			@require_torch_gpu
			@require_ray
			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							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 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self._run_finetune(gpus=1   ,    distributed_retriever="ray"  )
						self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,    0.2  )


