



'''simple docstring'''





import importlib
import os
import sys


# This is required to make the module import works (when the python process is running from the root of the repo)
sys.path.append(".")




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						test_file.split(os.path.sep)
     if components[0:2] != ["tests", "models"]:
          raise ValueError(
              '''`test_file` should start with `tests/models/` (with `/` being the OS specific path separator). Got '''
              F'''{test_file} instead.''')
     _a											=						components[-1]
     if not test_fn.endswith('''py'''):
          raise ValueError(F'''`test_file` should be a python file. Got {test_fn} instead.''')
     if not test_fn.startswith('''test_modeling_'''):
          raise ValueError(
              F'''`test_file` should point to a file name of the form `test_modeling_*.py`. Got {test_fn} instead.''')

     _a											=						components[:-1] + [test_fn.replace('''.py'''						,			'''''')]
     _a											=						'''.'''.join(__A)

     return test_module_path




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						get_module_path(__A)
     _a											=						importlib.import_module(__A)

     return test_module




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						[]
     _a											=						get_test_module(__A)
     for attr in dir(__A):
          if attr.endswith('''ModelTester'''):
               tester_classes.append(getattr(__A						,			__A))

    # sort with class names
     return sorted(__A						,			key=lambda __A: x.__name__)




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						[]
     _a											=						get_test_module(__A)
     for attr in dir(__A):
          _a											=						getattr(__A						,			__A)
          # (TF/Flax)ModelTesterMixin is also an attribute in specific model test module. Let's exclude them by checking
          # `all_model_classes` is not empty (which also excludes other special classes).
          _a											=						getattr(__A						,			'''all_model_classes'''						,			[])
          if len(__A) > 0:
               test_classes.append(__A)

    # sort with class names
     return sorted(__A						,			key=lambda __A: x.__name__)




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						get_test_classes(__A)
     _a											=						set()
     for test_class in test_classes:
          model_classes.update(test_class.all_model_classes)

     # sort with class names
     return sorted(__A						,			key=lambda __A: x.__name__)




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						test_class()
     if hasattr(__A						,			'''setUp'''):
          test.setUp()

     _a											=						None
     if hasattr(__A						,			'''model_tester'''):
          # `(TF/Flax)ModelTesterMixin` has this attribute default to `None`. Let's skip this case.
          if test.model_tester is not None:
               _a											=						test.model_tester.__class__

     return model_tester




def lowerCAmelCase						(__A						,			__A):



     """simple docstring"""



     _a											=						get_test_classes(__A)

     _a											=						[]
     for test_class in test_classes:
          if model_class in test_class.all_model_classes:
               target_test_classes.append(__A)

    # sort with class names
     return sorted(__A						,			key=lambda __A: x.__name__)




def lowerCAmelCase						(__A						,			__A):



     """simple docstring"""



     _a											=						get_test_classes_for_model(__A						,			__A)

     _a											=						[]
     for test_class in test_classes:
          _a											=						get_model_tester_from_test_class(__A)
          if tester_class is not None:
               tester_classes.append(__A)

    # sort with class names
     return sorted(__A						,			key=lambda __A: x.__name__)




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						get_test_classes(__A)
     _a											=						{test_class: get_model_tester_from_test_class(__A) for test_class in test_classes}
     return test_tester_mapping




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						get_model_classes(__A)
     _a											=						{
         model_class: get_test_classes_for_model(__A						,			__A) for model_class in model_classes
     }
     return model_test_mapping




def lowerCAmelCase						(__A):



     """simple docstring"""



     _a											=						get_model_classes(__A)
     _a											=						{
         model_class: get_tester_classes_for_model(__A						,			__A) for model_class in model_classes
     }
     return model_to_tester_mapping




def lowerCAmelCase						(__A):



     """simple docstring"""



     if isinstance(__A						,			__A):
          return o
     elif isinstance(__A						,			__A):
          return o.__name__
     elif isinstance(__A						,			(list, tuple)):
          return [to_json(__A) for x in o]
     elif isinstance(__A						,			__A):
          return {to_json(__A): to_json(__A) for k, v in o.items()}
     else:
          return o








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


lowercase_	 =						get_tests_dir("fixtures")






class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						mock.Mock()
      _a											=						500
      _a											=						{}
      _a											=						HTTPError
      _a											=						{}

      # Download this model to make sure it's in the cache.
      _a											=						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=A ) as mock_head:
           _a											=						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 )					->  str:


      """simple docstring"""



      _a											=						ViTImageProcessor.from_pretrained(
          '''https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json''' )



 def       a__						(self )					->  Dict:


      """simple docstring"""



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

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

      self.assertIsNotNone(A )






@is_staging_test
class __A    (						unittest.TestCase		):



 '''simple docstring'''







 @classmethod
 def       a__						(cls )					->  Any:


      """simple docstring"""



      _a											=						TOKEN
      HfFolder.save_token(A )



 @classmethod
 def       a__						(cls )					->  Union[str, Any]:


      """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       a__						(self )					->  str:


      """simple docstring"""



      _a											=						ViTImageProcessor.from_pretrained(A )
      image_processor.push_to_hub('''test-image-processor'''				,     use_auth_token=self._token )

      _a											=						ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor''' )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(A				,     getattr(A				,     A ) )

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

      _a											=						ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor''' )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(A				,     getattr(A				,     A ) )



 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						ViTImageProcessor.from_pretrained(A )
      image_processor.push_to_hub('''valid_org/test-image-processor'''				,     use_auth_token=self._token )

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

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

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



 def       a__						(self )					->  Union[str, Any]:


      """simple docstring"""



      CustomImageProcessor.register_for_auto_class()
      _a											=						CustomImageProcessor.from_pretrained(A )

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

      _a											=						AutoImageProcessor.from_pretrained(
          f'''{USER}/test-dynamic-image-processor'''				,     trust_remote_code=A )
      # 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''' )



