






'''simple docstring'''




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


lowerCAmelCase__          =						{
    '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       __lowercase					(unittest.TestCase    ):

	@classmethod
	def      __UpperCamelCase							(      cls   :						Any):
			UpperCamelCase__				:					str					=					TOKEN
			HfFolder.save_token(UpperCAmelCase_)

	@classmethod
	def      __UpperCamelCase							(      cls   :						List[str]):
			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      __UpperCamelCase							(      self   :						str):
			UpperCamelCase__				:					List[str]					=					BertConfig(
			    vocab_size=99  ,					hidden_size=32  ,					num_hidden_layers=5  ,					num_attention_heads=4  ,					intermediate_size=37)
			config.push_to_hub('test-config'  ,					use_auth_token=self._token)

			UpperCamelCase__				:					List[str]					=					BertConfig.from_pretrained(F'{USER}/test-config')
			for k, v in config.to_dict().items():
					if k != "transformers_version":
							self.assertEqual(UpperCAmelCase_  ,					getattr(UpperCAmelCase_  ,					UpperCAmelCase_))

        # 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(UpperCAmelCase_  ,					repo_id='test-config'  ,					push_to_hub=UpperCAmelCase_  ,					use_auth_token=self._token)

			UpperCamelCase__				:					List[Any]					=					BertConfig.from_pretrained(F'{USER}/test-config')
			for k, v in config.to_dict().items():
					if k != "transformers_version":
							self.assertEqual(UpperCAmelCase_  ,					getattr(UpperCAmelCase_  ,					UpperCAmelCase_))

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					int					=					BertConfig(
			    vocab_size=99  ,					hidden_size=32  ,					num_hidden_layers=5  ,					num_attention_heads=4  ,					intermediate_size=37)
			config.push_to_hub('valid_org/test-config-org'  ,					use_auth_token=self._token)

			UpperCamelCase__				:					Any					=					BertConfig.from_pretrained('valid_org/test-config-org')
			for k, v in config.to_dict().items():
					if k != "transformers_version":
							self.assertEqual(UpperCAmelCase_  ,					getattr(UpperCAmelCase_  ,					UpperCAmelCase_))

        # 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(
					    UpperCAmelCase_  ,					repo_id='valid_org/test-config-org'  ,					push_to_hub=UpperCAmelCase_  ,					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(UpperCAmelCase_  ,					getattr(UpperCAmelCase_  ,					UpperCAmelCase_))





	def      __UpperCamelCase							(      self   :						Any):
			CustomConfig.register_for_auto_class()
			UpperCamelCase__				:					Dict					=					CustomConfig(attribute=42)

			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__				:					Tuple					=					AutoConfig.from_pretrained(F'{USER}/test-dynamic-config'  ,					trust_remote_code=UpperCAmelCase_)
			# 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  ,					42)







class       __lowercase					(unittest.TestCase    ):

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			UpperCamelCase__				:					List[str]					=					GPTaConfig()

			# attempt to modify each of int/float/bool/str config records and verify they were updated
			UpperCamelCase__				:					int					=					c.n_embd + 1  # int
			UpperCamelCase__				:					List[str]					=					c.resid_pdrop + 1.0  # float
			UpperCamelCase__				:					List[Any]					=					not c.scale_attn_weights  # bool
			UpperCamelCase__				:					Dict					=					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(UpperCAmelCase_  ,					c.n_embd  ,					'mismatch for key: n_embd')
			self.assertEqual(UpperCAmelCase_  ,					c.resid_pdrop  ,					'mismatch for key: resid_pdrop')
			self.assertEqual(UpperCAmelCase_  ,					c.scale_attn_weights  ,					'mismatch for key: scale_attn_weights')
			self.assertEqual(UpperCAmelCase_  ,					c.summary_type  ,					'mismatch for key: summary_type')

	def      __UpperCamelCase							(      self   :						Tuple):
			UpperCamelCase__				:					Any					=					PretrainedConfig()
			UpperCamelCase__				:					Optional[int]					=					[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(
			    UpperCAmelCase_  ,					['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version'])
			UpperCamelCase__				:					Union[str, Any]					=					[key for key, value in config_common_kwargs.items() if value == getattr(UpperCAmelCase_  ,					UpperCAmelCase_)]
			if len(UpperCAmelCase_) > 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(UpperCAmelCase_)}.')

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			with self.assertRaises(UpperCAmelCase_):
					# config is in subfolder, the following should not work without specifying the subfolder
					UpperCamelCase__				:					int					=					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(UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Tuple):
			# A mock response for an HTTP head request to emulate server down
			UpperCamelCase__				:					Any					=					mock.Mock()
			UpperCamelCase__				:					int					=					500
			UpperCamelCase__				:					str					=					{}
			UpperCamelCase__				:					Optional[Any]					=					HTTPError
			UpperCamelCase__				:					Optional[int]					=					{}

			# Download this model to make sure it's in the cache.
			UpperCamelCase__				:					Tuple					=					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=UpperCAmelCase_) as mock_head:
					UpperCamelCase__				:					List[str]					=					BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert')
					# This check we did call the fake head request
					mock_head.assert_called()

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

	def      __UpperCamelCase							(      self   :						str):
			UpperCamelCase__				:					List[Any]					=					AutoConfig.from_pretrained('bert-base-cased')
			UpperCamelCase__				:					Tuple					=					['config.4.0.0.json']

			with tempfile.TemporaryDirectory() as tmp_dir:
					configuration.save_pretrained(UpperCAmelCase_)
					UpperCamelCase__				:					List[str]					=					2
					json.dump(configuration.to_dict()  ,					open(os.path.join(UpperCAmelCase_  ,					'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(UpperCAmelCase_)
					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__				:					Dict					=					['config.42.0.0.json']
					UpperCamelCase__				:					Optional[Any]					=					768
					configuration.save_pretrained(UpperCAmelCase_)
					shutil.move(os.path.join(UpperCAmelCase_  ,					'config.4.0.0.json')  ,					os.path.join(UpperCAmelCase_  ,					'config.42.0.0.json'))
					UpperCamelCase__				:					Tuple					=					AutoConfig.from_pretrained(UpperCAmelCase_)
					self.assertEqual(new_configuration.hidden_size  ,					768)





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

			import transformers as new_transformers

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

			# 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__				:					List[Any]					=					old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase_)
			self.assertEqual(old_configuration.hidden_size  ,					768)












'''simple docstring'''




import unittest

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device


if is_torch_available():
		import torch

		from transformers import AutoModelForImageClassification

if is_vision_available():
		from transformers import AutoImageProcessor







@require_torch
@require_vision
class       __lowercase					(unittest.TestCase    ):

	@slow
	def      __UpperCamelCase							(      self   :						int):
			UpperCamelCase__				:					Union[str, Any]					=					AutoImageProcessor.from_pretrained('microsoft/dit-base-finetuned-rvlcdip')
			UpperCamelCase__				:					List[str]					=					AutoModelForImageClassification.from_pretrained('microsoft/dit-base-finetuned-rvlcdip')
			model.to(UpperCAmelCase_)

			from datasets import load_dataset

			UpperCamelCase__				:					Optional[Any]					=					load_dataset('nielsr/rvlcdip-demo')

			UpperCamelCase__				:					int					=					dataset['train'][0]['image'].convert('RGB')

			UpperCamelCase__				:					Union[str, Any]					=					image_processor(UpperCAmelCase_  ,					return_tensors='pt').to(UpperCAmelCase_)

			# forward pass
			with torch.no_grad():
					UpperCamelCase__				:					Optional[Any]					=					model(**UpperCAmelCase_)
					UpperCamelCase__				:					Tuple					=					outputs.logits

			UpperCamelCase__				:					str					=					torch.Size((1, 16))
			self.assertEqual(logits.shape  ,					UpperCAmelCase_)

			UpperCamelCase__				:					Tuple					=					torch.tensor(
			    [-0.41_58, -0.40_92, -0.43_47]  ,					device=UpperCAmelCase_  ,					dtype=torch.float  ,					)
			self.assertTrue(torch.allclose(logits[0, :3]  ,					UpperCAmelCase_  ,					atol=1e-4))




