



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 SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






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

    __lowerCamelCase			: Any					=      ["accelerate", "launch"]
    __lowerCamelCase			: List[Any]					=      Path.home() / ".cache/huggingface/accelerate"
    __lowerCamelCase			: Optional[Any]					=      "default_config.yaml"
    __lowerCamelCase			: Dict					=      config_folder / config_file
    __lowerCamelCase			: str					=      config_folder / "_default_config.yaml"

    __lowerCamelCase			: int					=      Path("tests/test_configs"    )






    @classmethod
    def 			_lowerCAmelCase					(       cls		):






        if cls.config_path.is_file():
            cls.config_path.rename(cls.changed_path		)






    @classmethod
    def 			_lowerCAmelCase					(       cls		):






        if cls.changed_path.is_file():
            cls.changed_path.rename(cls.config_path		)






    def 			_lowerCAmelCase					(       self		):
        A :       str          =   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 			_lowerCAmelCase					(       self		):






        for config in sorted(self.test_config_path.glob("""**/*.yaml"""		)		):
            with self.subTest(config_file=_A		):
                execute_subprocess_async(
                    self.base_cmd + ["""--config_file""", str(_A		), self.test_file_path],		env=os.environ.copy()		)






    def 			_lowerCAmelCase					(       self		):
        execute_subprocess_async(["""accelerate""", """test"""],		env=os.environ.copy()		)






class SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






    __lowerCamelCase			: List[Any]					=      "test-tpu"
    __lowerCamelCase			: Optional[Any]					=      "us-central1-a"
    __lowerCamelCase			: Any					=      "ls"
    __lowerCamelCase			: List[Any]					=      ["accelerate", "tpu-config"]
    __lowerCamelCase			: Optional[Any]					=      "cd /usr/share"
    __lowerCamelCase			: Union[str, Any]					=      "tests/test_samples/test_command_file.sh"
    __lowerCamelCase			: Tuple					=      "Running gcloud compute tpus tpu-vm ssh"






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






    def 			_lowerCAmelCase					(       self		):
        A :       Union[str, Any]          =   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=_A,		)
        self.assertIn(
            f'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all''',		_A,		)






    def 			_lowerCAmelCase					(       self		):
        A :       Optional[Any]          =   run_command(
            self.cmd + ["""--config_file""", """tests/test_configs/latest.yaml""", """--debug"""],		return_stdout=_A		)
        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''',		_A,		)






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






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






    def 			_lowerCAmelCase					(       self		):
        A :       Tuple          =   run_command(
            self.cmd
            + ["""--config_file""", """tests/test_configs/latest.yaml""", """--command_file""", self.command_file, """--debug"""],		return_stdout=_A,		)
        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''',		_A,		)






    def 			_lowerCAmelCase					(       self		):
        A :       Any          =   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=_A,		)
        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''',		_A,		)






    def 			_lowerCAmelCase					(       self		):
        A :       List[str]          =   run_command(
            self.cmd + ["""--config_file""", """tests/test_configs/latest.yaml""", """--install_accelerate""", """--debug"""],		return_stdout=_A,		)
        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''',		_A,		)






    def 			_lowerCAmelCase					(       self		):
        A :       Optional[int]          =   run_command(
            self.cmd
            + [
                """--config_file""",
                """tests/test_configs/latest.yaml""",
                """--install_accelerate""",
                """--accelerate_version""",
                """12.0.0""",
                """--debug""",
            ],		return_stdout=_A,		)
        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''',		_A,		)



import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
		import jax.numpy as jnp

if is_tf_available():
		import tensorflow as tf

if is_torch_available():
		import torch






class 		a__						(					unittest.TestCase					):

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    {
							    "task_specific_params": {
							        "summarization": {"length_penalty": 1.0, "max_length": 128, "min_length": 12, "num_beams": 4},
							        "summarization_cnn": {"length_penalty": 2.0, "max_length": 142, "min_length": 56, "num_beams": 4},
							        "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6},
							    }
							}
							SCREAMING_SNAKE_CASE_  :		Any				      =    {
							    "task_specific_params.summarization.length_penalty": 1.0,
							    "task_specific_params.summarization.max_length": 128,
							    "task_specific_params.summarization.min_length": 12,
							    "task_specific_params.summarization.num_beams": 4,
							    "task_specific_params.summarization_cnn.length_penalty": 2.0,
							    "task_specific_params.summarization_cnn.max_length": 142,
							    "task_specific_params.summarization_cnn.min_length": 56,
							    "task_specific_params.summarization_cnn.num_beams": 4,
							    "task_specific_params.summarization_xsum.length_penalty": 1.0,
							    "task_specific_params.summarization_xsum.max_length": 62,
							    "task_specific_params.summarization_xsum.min_length": 11,
							    "task_specific_params.summarization_xsum.num_beams": 6,
							}

							self.assertEqual(flatten_dict(_A    ),_A    )

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(transpose(_A    ),x.transpose()    )    )

							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4,5    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),x.transpose((1, 2, 0)    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),transpose(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),transpose(_A,axes=(1, 2, 0)    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),transpose(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),transpose(_A,axes=(1, 2, 0)    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),np.asarray(transpose(_A    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),np.asarray(transpose(_A,axes=(1, 2, 0)    )    )    )    )

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),np.reshape(_A,(4, 3)    )    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(3,4,5    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),np.reshape(_A,(12, 5)    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),reshape(_A,(4, 3)    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		int				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),reshape(_A,(12, 5)    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),reshape(_A,(4, 3)    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),reshape(_A,(12, 5)    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		int				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),np.asarray(reshape(_A,(4, 3)    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),np.asarray(reshape(_A,(12, 5)    )    )    )    )

					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(1,3,4    )
							self.assertTrue(np.allclose(squeeze(_A    ),np.squeeze(_A    )    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),np.squeeze(_A,axis=2    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),squeeze(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Dict				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),squeeze(_A,axis=2    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),squeeze(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),squeeze(_A,axis=2    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),np.asarray(squeeze(_A    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),np.asarray(squeeze(_A,axis=2    )    )    )    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),np.expand_dims(_A,axis=1    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),expand_dims(_A,axis=1    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),expand_dims(_A,axis=1    ).numpy()    )    )






					@require_flax
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),np.asarray(expand_dims(_A,axis=1    )    )    )    )
