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

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402


lowercase  :					Dict													=       {
    'return_dict': False,
    'output_hidden_states': True,
    'output_attentions': True,
    'torchscript': True,
    'torch_dtype': 'float16',
    'use_bfloat16': True,
    'tf_legacy_loss': True,
    'pruned_heads': {'a': 1},
    'tie_word_embeddings': False,
    'is_decoder': True,
    'cross_attention_hidden_size': 128,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 50,
    'min_length': 3,
    'do_sample': True,
    'early_stopping': True,
    'num_beams': 3,
    'num_beam_groups': 3,
    'diversity_penalty': 0.5,
    'temperature': 2.0,
    'top_k': 10,
    'top_p': 0.7,
    'typical_p': 0.2,
    'repetition_penalty': 0.8,
    'length_penalty': 0.8,
    'no_repeat_ngram_size': 5,
    'encoder_no_repeat_ngram_size': 5,
    'bad_words_ids': [1, 2, 3],
    'num_return_sequences': 3,
    'chunk_size_feed_forward': 5,
    'output_scores': True,
    'return_dict_in_generate': True,
    'forced_bos_token_id': 2,
    'forced_eos_token_id': 3,
    'remove_invalid_values': True,
    'architectures': ['BertModel'],
    'finetuning_task': 'translation',
    'id2label': {0: 'label'},
    'label2id': {'label': '0'},
    'tokenizer_class': 'BertTokenizerFast',
    'prefix': 'prefix',
    'bos_token_id': 6,
    'pad_token_id': 7,
    'eos_token_id': 8,
    'sep_token_id': 9,
    'decoder_start_token_id': 10,
    'exponential_decay_length_penalty': (5, 1.0_1),
    'suppress_tokens': [0, 1],
    'begin_suppress_tokens': 2,
    'task_specific_params': {'translation': 'some_params'},
    'problem_type': 'regression',
}




@is_staging_test
class  lowerCamelCase__							(				unittest.TestCase):




	'''simple docstring'''




	@classmethod
	def    _lowerCamelCase				(					cls		:Dict						)		-> Optional[Any]:
								__UpperCamelCase	:   Dict			   =					TOKEN
								HfFolder.save_token(a						)







	@classmethod
	def    _lowerCamelCase				(					cls		:Tuple						)		-> List[Any]:
								try:
															delete_repo(token=cls._token     ,   repo_id="test-config"						)
								except HTTPError:
															pass

								try:
															delete_repo(token=cls._token     ,   repo_id="valid_org/test-config-org"						)
								except HTTPError:
															pass

								try:
															delete_repo(token=cls._token     ,   repo_id="test-dynamic-config"						)
								except HTTPError:
															pass







	def    _lowerCamelCase				(					self		:Optional[int]						)		-> int:
								__UpperCamelCase	:   Dict			   =					BertConfig(
								    vocab_size=9_9     ,   hidden_size=3_2     ,   num_hidden_layers=5     ,   num_attention_heads=4     ,   intermediate_size=3_7						)
								config.push_to_hub("test-config"     ,   use_auth_token=self._token						)

								__UpperCamelCase	:   Union[str, Any]			   =					BertConfig.from_pretrained(f'{USER}/test-config'						)
								for k, v in config.to_dict().items():
															if k != "transformers_version":
																						self.assertEqual(a     ,   getattr(a     ,   a						)						)

        # Reset repo
								delete_repo(token=self._token     ,   repo_id="test-config"						)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(a     ,   repo_id="test-config"     ,   push_to_hub=a     ,   use_auth_token=self._token						)

								__UpperCamelCase	:   Any			   =					BertConfig.from_pretrained(f'{USER}/test-config'						)
								for k, v in config.to_dict().items():
															if k != "transformers_version":
																						self.assertEqual(a     ,   getattr(a     ,   a						)						)







	def    _lowerCamelCase				(					self		:Union[str, Any]						)		-> List[str]:
								__UpperCamelCase	:   Dict			   =					BertConfig(
								    vocab_size=9_9     ,   hidden_size=3_2     ,   num_hidden_layers=5     ,   num_attention_heads=4     ,   intermediate_size=3_7						)
								config.push_to_hub("valid_org/test-config-org"     ,   use_auth_token=self._token						)

								__UpperCamelCase	:   Union[str, Any]			   =					BertConfig.from_pretrained("valid_org/test-config-org"						)
								for k, v in config.to_dict().items():
															if k != "transformers_version":
																						self.assertEqual(a     ,   getattr(a     ,   a						)						)

        # Reset repo
								delete_repo(token=self._token     ,   repo_id="valid_org/test-config-org"						)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(
															    a     ,   repo_id="valid_org/test-config-org"     ,   push_to_hub=a     ,   use_auth_token=self._token						)

								__UpperCamelCase	:   int			   =					BertConfig.from_pretrained("valid_org/test-config-org"						)
								for k, v in config.to_dict().items():
															if k != "transformers_version":
																						self.assertEqual(a     ,   getattr(a     ,   a						)						)







	def    _lowerCamelCase				(					self		:Optional[Any]						)		-> Any:
								CustomConfig.register_for_auto_class()
								__UpperCamelCase	:   Any			   =					CustomConfig(attribute=4_2						)

								config.push_to_hub("test-dynamic-config"     ,   use_auth_token=self._token						)

								# This has added the proper auto_map field to the config
								self.assertDictEqual(config.auto_map     ,   {"AutoConfig": "custom_configuration.CustomConfig"}						)

								__UpperCamelCase	:   List[str]			   =					AutoConfig.from_pretrained(f'{USER}/test-dynamic-config'     ,   trust_remote_code=a						)
								# Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
								self.assertEqual(new_config.__class__.__name__     ,   "CustomConfig"						)
								self.assertEqual(new_config.attribute     ,   4_2						)




class  lowerCamelCase__							(				unittest.TestCase):




	'''simple docstring'''




	def    _lowerCamelCase				(					self		:str						)		-> Union[str, Any]:
								__UpperCamelCase	:   Optional[int]			   =					GPTaConfig()

								# attempt to modify each of int/float/bool/str config records and verify they were updated
								__UpperCamelCase	:   List[str]			   =					c.n_embd + 1  # int
								__UpperCamelCase	:   Optional[int]			   =					c.resid_pdrop + 1.0  # float
								__UpperCamelCase	:   int			   =					not c.scale_attn_weights  # bool
								__UpperCamelCase	:   Union[str, Any]			   =					c.summary_type + "foo"  # str
								c.update_from_string(
								    f'n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'						)
								self.assertEqual(a     ,   c.n_embd     ,   "mismatch for key: n_embd"						)
								self.assertEqual(a     ,   c.resid_pdrop     ,   "mismatch for key: resid_pdrop"						)
								self.assertEqual(a     ,   c.scale_attn_weights     ,   "mismatch for key: scale_attn_weights"						)
								self.assertEqual(a     ,   c.summary_type     ,   "mismatch for key: summary_type"						)







	def    _lowerCamelCase				(					self		:List[str]						)		-> Any:
								__UpperCamelCase	:   Optional[Any]			   =					PretrainedConfig()
								__UpperCamelCase	:   Optional[Any]			   =					[key for key in base_config.__dict__ if key not in config_common_kwargs]
								# If this part of the test fails, you have arguments to addin config_common_kwargs above.
								self.assertListEqual(
								    a     ,   ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]						)
								__UpperCamelCase	:   List[Any]			   =					[key for key, value in config_common_kwargs.items() if value == getattr(a     ,   a						)]
								if len(a						) > 0:
															raise ValueError(
															    "The following keys are set with the default values in"
															    " `test_configuration_common.config_common_kwargs` pick another value for them:"
															    f' {", ".join(a						)}.'						)







	def    _lowerCamelCase				(					self		:Union[str, Any]						)		-> str:
								with self.assertRaises(a						):
															# config is in subfolder, the following should not work without specifying the subfolder
															__UpperCamelCase	:   Dict			   =					BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"						)

								__UpperCamelCase	:   int			   =					BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"     ,   subfolder="bert"						)

								self.assertIsNotNone(a						)







	def    _lowerCamelCase				(					self		:Tuple						)		-> Dict:
								# A mock response for an HTTP head request to emulate server down
								__UpperCamelCase	:   Dict			   =					mock.Mock()
								__UpperCamelCase	:   Optional[Any]			   =					5_0_0
								__UpperCamelCase	:   Dict			   =					{}
								__UpperCamelCase	:   List[str]			   =					HTTPError
								__UpperCamelCase	:   Tuple			   =					{}

								# Download this model to make sure it's in the cache.
								__UpperCamelCase	:   List[Any]			   =					BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"						)

								# Under the mock environment we get a 500 error when trying to reach the model.
								with mock.patch("requests.Session.request"     ,   return_value=a						) as mock_head:
															__UpperCamelCase	:   int			   =					BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"						)
															# This check we did call the fake head request
															mock_head.assert_called()







	def    _lowerCamelCase				(					self		:str						)		-> Any:
								# This test is for deprecated behavior and can be removed in v5
								__UpperCamelCase	:   str			   =					BertConfig.from_pretrained(
								    "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"						)







	def    _lowerCamelCase				(					self		:Union[str, Any]						)		-> Any:
								__UpperCamelCase	:   Any			   =					AutoConfig.from_pretrained("bert-base-cased"						)
								__UpperCamelCase	:   int			   =					["config.4.0.0.json"]

								with tempfile.TemporaryDirectory() as tmp_dir:
															configuration.save_pretrained(a						)
															__UpperCamelCase	:   Optional[int]			   =					2
															json.dump(configuration.to_dict()     ,   open(os.path.join(a     ,   "config.4.0.0.json"						)     ,   "w"						)						)

															# This should pick the new configuration file as the version of Transformers is > 4.0.0
															__UpperCamelCase	:   List[str]			   =					AutoConfig.from_pretrained(a						)
															self.assertEqual(new_configuration.hidden_size     ,   2						)

															# Will need to be adjusted if we reach v42 and this test is still here.
															# Should pick the old configuration file as the version of Transformers is < 4.42.0
															__UpperCamelCase	:   List[Any]			   =					["config.42.0.0.json"]
															__UpperCamelCase	:   Any			   =					7_6_8
															configuration.save_pretrained(a						)
															shutil.move(os.path.join(a     ,   "config.4.0.0.json"						)     ,   os.path.join(a     ,   "config.42.0.0.json"						)						)
															__UpperCamelCase	:   List[Any]			   =					AutoConfig.from_pretrained(a						)
															self.assertEqual(new_configuration.hidden_size     ,   7_6_8						)







	def    _lowerCamelCase				(					self		:Optional[Any]						)		-> Tuple:
								# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
								__UpperCamelCase	:   List[str]			   =					"hf-internal-testing/test-two-configs"

								import transformers as new_transformers

								__UpperCamelCase	:   int			   =					"v4.0.0"
								__UpperCamelCase   ,						__UpperCamelCase	:   Any			   =					new_transformers.models.auto.AutoConfig.from_pretrained(
								    a     ,   return_unused_kwargs=a						)
								self.assertEqual(new_configuration.hidden_size     ,   2						)
								# This checks `_configuration_file` ia not kept in the kwargs by mistake.
								self.assertDictEqual(a     ,   {}						)

								# Testing an older version by monkey-patching the version in the module it's used.
								import transformers as old_transformers

								__UpperCamelCase	:   Optional[Any]			   =					"v3.0.0"
								__UpperCamelCase	:   Optional[Any]			   =					old_transformers.models.auto.AutoConfig.from_pretrained(a						)
								self.assertEqual(old_configuration.hidden_size     ,   7_6_8						)

from __future__ import annotations

import math

lowercase  :					Any													=       '2020.9.26'
lowercase  :					Union[str, Any]													=       'xcodz-dot, cclaus, dhruvmanila'




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			float						,  _lowerCamelCase :			float						,  _lowerCamelCase :			float						,  _lowerCamelCase :			float						,  _lowerCamelCase :			float)					->    tuple[float, float]:






							'''simple docstring'''





							if not all(isinstance(_lowerCamelCase						,  (float, int)) for val in locals().values()):
														__UpperCamelCase	:   str			   =					F'Input values must either be float or int: {list(locals().values())}'
														raise TypeError(_lowerCamelCase)
							__UpperCamelCase	:   List[str]			   =					((x * distance) / (z + distance)) * scale
							__UpperCamelCase	:   List[Any]			   =					((y * distance) / (z + distance)) * scale
							return projected_x, projected_y




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			float						,  _lowerCamelCase :			float						,  _lowerCamelCase :			float						,  _lowerCamelCase :			str						,  _lowerCamelCase :			float)					->    tuple[float, float, float]:






							'''simple docstring'''





							if not isinstance(_lowerCamelCase						,  _lowerCamelCase):
														raise TypeError("Axis must be a str")
							__UpperCamelCase	:   str			   =					locals()
							del input_variables["axis"]
							if not all(isinstance(_lowerCamelCase						,  (float, int)) for val in input_variables.values()):
														__UpperCamelCase	:   Dict			   =					(
														    "Input values except axis must either be float or int: "
														    F'{list(input_variables.values())}'
														)
														raise TypeError(_lowerCamelCase)
							__UpperCamelCase	:   Optional[Any]			   =					(angle % 360) / 450 * 180 / math.pi
							if axis == "z":
														__UpperCamelCase	:   Tuple			   =					x * math.cos(_lowerCamelCase) - y * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   Union[str, Any]			   =					y * math.cos(_lowerCamelCase) + x * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   Any			   =					z
							elif axis == "x":
														__UpperCamelCase	:   Dict			   =					y * math.cos(_lowerCamelCase) - z * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   Any			   =					z * math.cos(_lowerCamelCase) + y * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   List[str]			   =					x
							elif axis == "y":
														__UpperCamelCase	:   Any			   =					x * math.cos(_lowerCamelCase) - z * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   Any			   =					z * math.cos(_lowerCamelCase) + x * math.sin(_lowerCamelCase)
														__UpperCamelCase	:   Dict			   =					y
							else:
														raise ValueError("not a valid axis, choose one of 'x', 'y', 'z'")

							return new_x, new_y, new_z


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		print(f"{convert_to_ad(1.0, 2.0, 3.0, 1_0.0, 1_0.0) = }")
		print(f"{rotate(1.0, 2.0, 3.0, 'y', 9_0.0) = }")