import json
import os
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from requests.exceptions import HTTPError

from transformers.utils import (
    CONFIG_NAME,
    FLAX_WEIGHTS_NAME,
    TF2_WEIGHTS_NAME,
    TRANSFORMERS_CACHE,
    WEIGHTS_NAME,
    cached_file,
    get_file_from_repo,
    has_file,
)


__lowerCamelCase					:	Any       =  '''hf-internal-testing/tiny-random-bert'''
__lowerCamelCase					:	Dict       =  os.path.join(TRANSFORMERS_CACHE, '''models--hf-internal-testing--tiny-random-bert''')
__lowerCamelCase					:	Optional[int]       =  '''9b8c223d42b2188cb49d29af482996f9d0f3e5a6'''






class 		a__						(					unittest.TestCase					):

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    cached_file(_A,_A    )
							# Should have downloaded the file in here
							self.assertTrue(os.path.isdir(_A    )    )
							# Cache should contain at least those three subfolders:
							for subfolder in ["blobs", "refs", "snapshots"]:
									self.assertTrue(os.path.isdir(os.path.join(_A,_A    )    )    )
							with open(os.path.join(_A,"refs","main"    )    ) as f:
									SCREAMING_SNAKE_CASE_  :		Dict				      =    f.read()
							self.assertEqual(_A,os.path.join(_A,"snapshots",_A,_A    )    )
							self.assertTrue(os.path.isfile(_A    )    )

							# File is cached at the same place the second time.
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    cached_file(_A,_A    )
							self.assertEqual(_A,_A    )

							# Using a specific revision to test the full commit hash.
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    cached_file(_A,_A,revision="9b8c223"    )
							self.assertEqual(_A,os.path.join(_A,"snapshots",_A,_A    )    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							with self.assertRaisesRegex(_A,"is not a valid model identifier"    ):
									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    cached_file("tiny-random-bert",_A    )

							with self.assertRaisesRegex(_A,"is not a valid git identifier"    ):
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    cached_file(_A,_A,revision="aaaa"    )

							with self.assertRaisesRegex(_A,"does not appear to have a file named"    ):
									SCREAMING_SNAKE_CASE_  :		Any				      =    cached_file(_A,"conf"    )

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							with self.assertRaisesRegex(_A,"does not appear to have a file named"    ):
									SCREAMING_SNAKE_CASE_  :		Any				      =    cached_file(_A,"conf"    )

							with open(os.path.join(_A,"refs","main"    )    ) as f:
									SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    f.read()
							self.assertTrue(os.path.isfile(os.path.join(_A,".no_exist",_A,"conf"    )    )    )

							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    cached_file(_A,"conf",_raise_exceptions_for_missing_entries=_A    )
							self.assertIsNone(_A    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    cached_file(_A,"conf",local_files_only=_A,_raise_exceptions_for_missing_entries=_A    )
							self.assertIsNone(_A    )

							SCREAMING_SNAKE_CASE_  :		int				      =    mock.Mock()
							SCREAMING_SNAKE_CASE_  :		int				      =    500
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    {}
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    HTTPError
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    {}

							# Under the mock environment we get a 500 error when trying to reach the tokenizer.
							with mock.patch("requests.Session.request",return_value=_A    ) as mock_head:
									SCREAMING_SNAKE_CASE_  :		Any				      =    cached_file(_A,"conf",_raise_exceptions_for_connection_errors=_A    )
									self.assertIsNone(_A    )
									# This check we did call the fake head request
									mock_head.assert_called()

					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							self.assertTrue(has_file("hf-internal-testing/tiny-bert-pt-only",_A    )    )
							self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only",_A    )    )
							self.assertFalse(has_file("hf-internal-testing/tiny-bert-pt-only",_A    )    )

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							self.assertIsNone(get_file_from_repo("bert-base-cased","ahah.txt"    )    )

							# The function raises if the repository does not exist.
							with self.assertRaisesRegex(_A,"is not a valid model identifier"    ):
									get_file_from_repo("bert-base-case",_A    )

							# The function raises if the revision does not exist.
							with self.assertRaisesRegex(_A,"is not a valid git identifier"    ):
									get_file_from_repo("bert-base-cased",_A,revision="ahaha"    )

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    get_file_from_repo("bert-base-cased",_A    )
							# The name is the cached name which is not very easy to test, so instead we load the content.
							SCREAMING_SNAKE_CASE_  :		Dict				      =    json.loads(open(_A,"r"    ).read()    )
							self.assertEqual(config["hidden_size"],768    )






					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmp_dir:
									SCREAMING_SNAKE_CASE_  :		Dict				      =    Path(_A    ) / "a.txt"
									filename.touch()
									self.assertEqual(get_file_from_repo(_A,"a.txt"    ),str(_A    )    )

									self.assertIsNone(get_file_from_repo(_A,"b.txt"    )    )

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    )    )    )    )
