



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     lowerCAmelCase_		(  unittest.TestCase							):
       def  snake_case_	(      self	)					->		int:
          # A mock response for an HTTP head request to emulate server down
          UpperCamelCase   :  Dict						     =     mock.Mock()
          UpperCamelCase   :  Optional[Any]						     =     500
          UpperCamelCase   :  Union[str, Any]						     =     {}
          UpperCamelCase   :  Union[str, Any]						     =     HTTPError
          UpperCamelCase   :  Any						     =     {}

          # Download this model to make sure it's in the cache.
          UpperCamelCase   :  Tuple						     =     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=SCREAMING_SNAKE_CASE_	) as mock_head:
             UpperCamelCase   :  Union[str, Any]						     =     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	)					->		Optional[int]:
          # This test is for deprecated behavior and can be removed in v5
          UpperCamelCase   :  Optional[int]						     =     ViTImageProcessor.from_pretrained(
              'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'	)






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

          UpperCamelCase   :  Union[str, Any]						     =     AutoImageProcessor.from_pretrained(
              'hf-internal-testing/stable-diffusion-all-variants',      subfolder='feature_extractor'	)

          self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)






@is_staging_test
class     lowerCAmelCase_		(  unittest.TestCase							):
       @classmethod
       def  snake_case_	(      cls	)					->		Dict:
          UpperCamelCase   :  List[Any]						     =     TOKEN
          HfFolder.save_token(SCREAMING_SNAKE_CASE_	)
       @classmethod
       def  snake_case_	(      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  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  Union[str, Any]						     =     ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_	)
          image_processor.push_to_hub('test-image-processor',      use_auth_token=self._token	)

          UpperCamelCase   :  Any						     =     ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor"""	)
          for k, v in image_processor.__dict__.items():
             self.assertEqual(SCREAMING_SNAKE_CASE_,      getattr(SCREAMING_SNAKE_CASE_,      SCREAMING_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(
                 SCREAMING_SNAKE_CASE_,      repo_id='test-image-processor',      push_to_hub=SCREAMING_SNAKE_CASE_,      use_auth_token=self._token	)

          UpperCamelCase   :  List[str]						     =     ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor"""	)
          for k, v in image_processor.__dict__.items():
             self.assertEqual(SCREAMING_SNAKE_CASE_,      getattr(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)	)
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  List[Any]						     =     ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_	)
          image_processor.push_to_hub('valid_org/test-image-processor',      use_auth_token=self._token	)

          UpperCamelCase   :  List[str]						     =     ViTImageProcessor.from_pretrained('valid_org/test-image-processor'	)
          for k, v in image_processor.__dict__.items():
             self.assertEqual(SCREAMING_SNAKE_CASE_,      getattr(SCREAMING_SNAKE_CASE_,      SCREAMING_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(
                 SCREAMING_SNAKE_CASE_,      repo_id='valid_org/test-image-processor-org',      push_to_hub=SCREAMING_SNAKE_CASE_,      use_auth_token=self._token	)

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






       def  snake_case_	(      self	)					->		Optional[int]:
          CustomImageProcessor.register_for_auto_class()
          UpperCamelCase   :  str						     =     CustomImageProcessor.from_pretrained(SCREAMING_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'},      )

          UpperCamelCase   :  Union[str, Any]						     =     AutoImageProcessor.from_pretrained(
              F"""{USER}/test-dynamic-image-processor""",      trust_remote_code=SCREAMING_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'	)








# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__UpperCAmelCase	       =	abspath(join(dirname(dirname(dirname(__file__))), '''src'''))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)
def 		UpperCamelCase     (       snake_case__	:   Dict     )     ->					List[str]:
   from transformers.testing_utils import pytest_addoption_shared

   pytest_addoption_shared(snake_case__     )


def 		UpperCamelCase     (       snake_case__	:   List[Any]     )     ->					Dict:
   from transformers.testing_utils import pytest_terminal_summary_main

   UpperCamelCase   :  Optional[int]						     =     terminalreporter.config.getoption('--make-reports'     )
   if make_reports:
      pytest_terminal_summary_main(snake_case__	,					id=snake_case__     )



