





'''simple docstring'''






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 AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


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

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


__A	:	Optional[int]     =     get_tests_dir('fixtures')
class 						__UpperCamelCase	(						unittest.TestCase							):





							def 		a__   (  self		:Any			):
									# A mock response for an HTTP head request to emulate server down
									snake_case_		:							Dict			       =						mock.Mock()
									snake_case_		:							Optional[int]			       =						5_0_0
									snake_case_		:							Any			       =						{}
									snake_case_		:							Optional[Any]			       =						HTTPError
									snake_case_		:							List[Any]			       =						{}

									# Download this model to make sure it's in the cache.
									snake_case_		:							Optional[int]			       =						ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""			)
									# 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:
											snake_case_		:							List[str]			       =						ViTImageProcessor.from_pretrained("""hf-internal-testing/tiny-random-vit"""			)
											# This check we did call the fake head request
											mock_head.assert_called()





							def 		a__   (  self		:Dict			):
									# This test is for deprecated behavior and can be removed in v5
									snake_case_		:							Any			       =						ViTImageProcessor.from_pretrained(
									    """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""			)





							def 		a__   (  self		:List[Any]			):
									with self.assertRaises(_UpperCamelCase			):
											# config is in subfolder, the following should not work without specifying the subfolder
											snake_case_		:							Dict			       =						AutoImageProcessor.from_pretrained("""hf-internal-testing/stable-diffusion-all-variants"""			)

									snake_case_		:							Dict			       =						AutoImageProcessor.from_pretrained(
									    """hf-internal-testing/stable-diffusion-all-variants"""  ,subfolder="""feature_extractor"""			)

									self.assertIsNotNone(_UpperCamelCase			)





@is_staging_test
class 						__UpperCamelCase	(						unittest.TestCase							):





							@classmethod
							def 		a__   (  cls		:Optional[Any]			):
									snake_case_		:							Optional[int]			       =						TOKEN
									HfFolder.save_token(_UpperCamelCase			)





							@classmethod
							def 		a__   (  cls		:List[Any]			):
									try:
											delete_repo(token=cls._token  ,repo_id="""test-image-processor"""			)
									except HTTPError:
											pass

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

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





							def 		a__   (  self		:Optional[Any]			):
									snake_case_		:							List[Any]			       =						ViTImageProcessor.from_pretrained(_UpperCamelCase			)
									image_processor.push_to_hub("""test-image-processor"""  ,use_auth_token=self._token			)

									snake_case_		:							List[Any]			       =						ViTImageProcessor.from_pretrained(F'''{USER}/test-image-processor'''			)
									for k, v in image_processor.__dict__.items():
											self.assertEqual(_UpperCamelCase  ,getattr(_UpperCamelCase  ,_UpperCamelCase			)			)

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

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

									snake_case_		:							Optional[Any]			       =						ViTImageProcessor.from_pretrained(F'''{USER}/test-image-processor'''			)
									for k, v in image_processor.__dict__.items():
											self.assertEqual(_UpperCamelCase  ,getattr(_UpperCamelCase  ,_UpperCamelCase			)			)





							def 		a__   (  self		:Tuple			):
									snake_case_		:							List[str]			       =						ViTImageProcessor.from_pretrained(_UpperCamelCase			)
									image_processor.push_to_hub("""valid_org/test-image-processor"""  ,use_auth_token=self._token			)

									snake_case_		:							str			       =						ViTImageProcessor.from_pretrained("""valid_org/test-image-processor"""			)
									for k, v in image_processor.__dict__.items():
											self.assertEqual(_UpperCamelCase  ,getattr(_UpperCamelCase  ,_UpperCamelCase			)			)

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

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

									snake_case_		:							str			       =						ViTImageProcessor.from_pretrained("""valid_org/test-image-processor-org"""			)
									for k, v in image_processor.__dict__.items():
											self.assertEqual(_UpperCamelCase  ,getattr(_UpperCamelCase  ,_UpperCamelCase			)			)





							def 		a__   (  self		:Optional[int]			):
									CustomImageProcessor.register_for_auto_class()
									snake_case_		:							List[Any]			       =						CustomImageProcessor.from_pretrained(_UpperCamelCase			)

									image_processor.push_to_hub("""test-dynamic-image-processor"""  ,use_auth_token=self._token			)

									# This has added the proper auto_map field to the config
									self.assertDictEqual(
									    image_processor.auto_map  ,{"""AutoImageProcessor""": """custom_image_processing.CustomImageProcessor"""}  ,)

									snake_case_		:							List[Any]			       =						AutoImageProcessor.from_pretrained(
									    F'''{USER}/test-dynamic-image-processor'''  ,trust_remote_code=_UpperCamelCase			)
									# Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
									self.assertEqual(new_image_processor.__class__.__name__  ,"""CustomImageProcessor"""			)



'''simple docstring'''






import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
							import torch
@require_torch
@require_optimum
@slow
class 						__UpperCamelCase	(						unittest.TestCase							):





							def 		a__   (  self		:List[str]			):
									snake_case_		:							Union[str, Any]			       =						"""hf-internal-testing/tiny-random-t5"""
									snake_case_		:							str			       =						AutoTokenizer.from_pretrained(_UpperCamelCase			)
									snake_case_		:							str			       =						AutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase			)

									snake_case_		:							List[str]			       =						tokenizer("""This is me"""  ,return_tensors="""pt"""			)

									snake_case_		:							List[str]			       =						model.to_bettertransformer()

									self.assertTrue(any("""BetterTransformer""" in mod.__class__.__name__ for _, mod in model.named_modules()			)			)

									snake_case_		:							List[str]			       =						model.generate(**_UpperCamelCase			)

									snake_case_		:							Dict			       =						model.reverse_bettertransformer()

									self.assertFalse(any("""BetterTransformer""" in mod.__class__.__name__ for _, mod in model.named_modules()			)			)

									with tempfile.TemporaryDirectory() as tmpdirname:
											model.save_pretrained(_UpperCamelCase			)

											snake_case_		:							List[Any]			       =						AutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase			)

											self.assertFalse(
											    any("""BetterTransformer""" in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()			)			)

											snake_case_		:							Optional[Any]			       =						model_reloaded.generate(**_UpperCamelCase			)
											self.assertTrue(torch.allclose(_UpperCamelCase  ,_UpperCamelCase			)			)





							def 		a__   (  self		:Union[str, Any]			):
									snake_case_		:							Optional[Any]			       =						"""hf-internal-testing/tiny-random-t5"""
									snake_case_		:							str			       =						AutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase			)

									snake_case_		:							List[Any]			       =						model.to_bettertransformer()

									with tempfile.TemporaryDirectory() as tmpdirname:
											with self.assertRaises(_UpperCamelCase			):
													model.save_pretrained(_UpperCamelCase			)

											snake_case_		:							Any			       =						model.reverse_bettertransformer()
											model.save_pretrained(_UpperCamelCase			)