



"""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__		:				Tuple          =	get_tests_dir("""fixtures""")







class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




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

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





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

        lowerCAmelCase_   :				Optional[int]								= AutoImageProcessor.from_pretrained(
            'hf-internal-testing/stable-diffusion-all-variants'    ,			subfolder='feature_extractor'       )

        self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )







@is_staging_test
class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]       ):
        lowerCAmelCase_   :				Optional[Any]								= TOKEN
        HfFolder.save_token(SCREAMING_SNAKE_CASE_       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      int       ):
        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      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]       ):
        lowerCAmelCase_   :				Union[str, Any]								= ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_       )
        image_processor.push_to_hub('test-image-processor'    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				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_       )       )

        # 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       )

        lowerCAmelCase_   :				Optional[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_       )       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Union[str, Any]       ):
        lowerCAmelCase_   :				List[str]								= ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_       )
        image_processor.push_to_hub('valid_org/test-image-processor'    ,			use_auth_token=self._token       )

        lowerCAmelCase_   :				Optional[int]								= 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       )

        lowerCAmelCase_   :				Optional[Any]								= 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      SCREAMING_SNAKE_CASE__ (      self				:      Tuple       ):
        CustomImageProcessor.register_for_auto_class()
        lowerCAmelCase_   :				Optional[int]								= 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'}    ,			)

        lowerCAmelCase_   :				int								= 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'       )










"""simple docstring"""







from ..utils import DummyObject, requires_backends







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      List[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Any    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      int    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[int]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      Dict    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      int    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      List[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      List[Any]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      str       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      List[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Dict    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      List[str]    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[Any]    ,			*SCREAMING_SNAKE_CASE_				:      str    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      List[str]    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Any    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      str    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Union[str, Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      Union[str, Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      int    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Union[str, Any]       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Any    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      str       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      List[Any]       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      List[Any]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Union[str, Any]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      str       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Optional[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Dict    ,			**SCREAMING_SNAKE_CASE_				:      Optional[int]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      str    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )





