





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

from transformers.testing_utils import CaptureStd, is_pt_tf_cross_test, require_torch





class 	lowerCAmelCase__(       unittest.TestCase			):






       '''simple docstring'''


       @patch("sys.argv"			,  ["fakeprogrampath", "env"]							)
       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            # test transformers-cli env
            import transformers.commands.transformers_cli

            with CaptureStd() as cs:
                 transformers.commands.transformers_cli.main()
            self.assertIn("Python version"			,  cs.out							)
            self.assertIn("Platform"			,  cs.out							)
            self.assertIn("Using distributed or parallel set-up in script?"			,  cs.out							)




       @is_pt_tf_cross_test
       @patch(
           "sys.argv"			,  ["fakeprogrampath", "pt-to-tf", "--model-name", "hf-internal-testing/tiny-random-gptj", "--no-pr"]							)
       def 			UpperCamelCase_	(					self							)	->   int:
            import transformers.commands.transformers_cli

            shutil.rmtree("/tmp/hf-internal-testing/tiny-random-gptj"			,  ignore_errors=__lowerCamelCase							)  # cleans potential past runs
            transformers.commands.transformers_cli.main()

            # The original repo has no TF weights -- if they exist, they were created by the CLI
            self.assertTrue(os.path.exists("/tmp/hf-internal-testing/tiny-random-gptj/tf_model.h5"							)							)




       @require_torch
       @patch("sys.argv"			,  ["fakeprogrampath", "download", "hf-internal-testing/tiny-random-gptj", "--cache-dir", "/tmp"]							)
       def 			UpperCamelCase_	(					self							)	->   Any:
            import transformers.commands.transformers_cli

            # # remove any previously downloaded model to start clean
            shutil.rmtree("/tmp/models--hf-internal-testing--tiny-random-gptj"			,  ignore_errors=__lowerCamelCase							)

            # run the command
            transformers.commands.transformers_cli.main()

            # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--tiny-random-gptj
            self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/blobs"							)							)
            self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/refs"							)							)
            self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/snapshots"							)							)







       @require_torch
       @patch(
           "sys.argv"			,  [
               "fakeprogrampath",
               "download",
               "hf-internal-testing/test_dynamic_model_with_tokenizer",
               "--trust-remote-code",
               "--cache-dir",
               "/tmp",
           ]			,  )
       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            import transformers.commands.transformers_cli

            # # remove any previously downloaded model to start clean
            shutil.rmtree("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer"			,  ignore_errors=__lowerCamelCase							)

            # run the command
            transformers.commands.transformers_cli.main()

            # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer
            self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/blobs"							)							)
            self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/refs"							)							)
            self.assertTrue(
                os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/snapshots"							)							)






# 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 	lowerCAmelCase__(       __lowercase			):






       '''simple docstring'''


       @classmethod
       def 			UpperCamelCase_	(					cls							)	->   Tuple:
            return cls







       @slow
       @require_torch_gpu
       def 			UpperCamelCase_	(					self							)	->   Any:
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							self.get_auto_remove_tmp_dir()
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							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
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							get_gpu_count()
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							F"""
            -m torch.distributed.launch
            --nproc_per_node={n_gpu}
            {self.test_file_dir}/run_distributed_eval.py
        """.split()
            _SCREAMING_SNAKE_CASE				:		int  			=							[sys.executable] + distributed_args + args
            execute_subprocess_async(__lowerCamelCase			,  env=self.get_env()							)

            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							os.path.join(__lowerCamelCase			,  "test_bleu.json"							)
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							load_json(__lowerCamelCase							)
            # print(metrics)
            self.assertGreaterEqual(metrics["bleu"]			,  2_5							)