


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


UpperCAmelCase      		=			get_tests_dir('''fixtures''')
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:int       							=				mock.Mock()
              lowercase		:List[str]       							=				5_0_0
              lowercase		:str       							=				{}
              lowercase		:List[str]       							=				HTTPError
              lowercase		:Optional[int]       							=				{}

              # Download this model to make sure it's in the cache.
              lowercase		: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=snake_case__				) as mock_head:
                     lowercase		: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  __snake_case						(   self  :    int				):

              '''simple docstring'''






              lowercase		:Optional[int]       							=				ViTImageProcessor.from_pretrained(
                  '''https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'''				)







       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              with self.assertRaises(snake_case__				):
                     # config is in subfolder, the following should not work without specifying the subfolder
                     lowercase		:Optional[Any]       							=				AutoImageProcessor.from_pretrained('''hf-internal-testing/stable-diffusion-all-variants'''				)

              lowercase		:Any       							=				AutoImageProcessor.from_pretrained(
                  '''hf-internal-testing/stable-diffusion-all-variants'''  ,     subfolder='''feature_extractor'''				)

              self.assertIsNotNone(snake_case__				)







@is_staging_test
class 					__magic_name__		(			unittest.TestCase     ):






       @classmethod
       def  __snake_case						(   cls  :    int				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				TOKEN
              HfFolder.save_token(snake_case__				)






       @classmethod
       def  __snake_case						(   cls  :    int				):

              '''simple docstring'''






              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  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              lowercase		:Any       							=				ViTImageProcessor.from_pretrained(snake_case__				)
              image_processor.push_to_hub('''test-image-processor'''  ,     use_auth_token=self._token				)

              lowercase		:Optional[Any]       							=				ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""				)
              for k, v in image_processor.__dict__.items():
                     self.assertEqual(snake_case__  ,     getattr(snake_case__  ,     snake_case__				)				)

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

              lowercase		:Tuple       							=				ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""				)
              for k, v in image_processor.__dict__.items():
                     self.assertEqual(snake_case__  ,     getattr(snake_case__  ,     snake_case__				)				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:List[str]       							=				ViTImageProcessor.from_pretrained(snake_case__				)
              image_processor.push_to_hub('''valid_org/test-image-processor'''  ,     use_auth_token=self._token				)

              lowercase		:Tuple       							=				ViTImageProcessor.from_pretrained('''valid_org/test-image-processor'''				)
              for k, v in image_processor.__dict__.items():
                     self.assertEqual(snake_case__  ,     getattr(snake_case__  ,     snake_case__				)				)

              # 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(
                         snake_case__  ,     repo_id='''valid_org/test-image-processor-org'''  ,     push_to_hub=snake_case__  ,     use_auth_token=self._token				)

              lowercase		:Tuple       							=				ViTImageProcessor.from_pretrained('''valid_org/test-image-processor-org'''				)
              for k, v in image_processor.__dict__.items():
                     self.assertEqual(snake_case__  ,     getattr(snake_case__  ,     snake_case__				)				)







       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              CustomImageProcessor.register_for_auto_class()
              lowercase		:int       							=				CustomImageProcessor.from_pretrained(snake_case__				)

              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'''}  ,     )

              lowercase		:List[str]       							=				AutoImageProcessor.from_pretrained(
                  f"""{USER}/test-dynamic-image-processor"""  ,     trust_remote_code=snake_case__				)
              # 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"""



UpperCAmelCase      		=			{str(digit): digit**5 for digit in range(10)}






def       lowerCamelCase					(a_						:int)     ->							int:
       return sum(DIGITS_FIFTH_POWER[digit] for digit in str(a_))






def       lowerCamelCase					()     ->							int:
       return sum(
           number
           for number in range(1000				,				100_0000)
           if number == digits_fifth_powers_sum(a_))


if __name__ == "__main__":
 print(solution())

