




"""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            =							get_tests_dir('fixtures')






class 					SCREAMING_SNAKE_CASE__    (    unittest.TestCase    ):


						def      __lowercase       (							self :	Optional[int]    ):
										# A mock response for an HTTP head request to emulate server down
										lowerCAmelCase              = mock.Mock()
										lowerCAmelCase              = 500
										lowerCAmelCase              = {}
										lowerCAmelCase              = HTTPError
										lowerCAmelCase              = {}

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


						def      __lowercase       (							self :	Optional[int]    ):
										# This test is for deprecated behavior and can be removed in v5
										lowerCAmelCase              = ViTImageProcessor.from_pretrained(
										    """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""    )




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

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

										self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )






@is_staging_test
class 					SCREAMING_SNAKE_CASE__    (    unittest.TestCase    ):


						@classmethod
						def      __lowercase       (							cls :	Optional[int]    ):
										lowerCAmelCase              = TOKEN
										HfFolder.save_token(SCREAMING_SNAKE_CASE_    )


						@classmethod
						def      __lowercase       (							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      __lowercase       (							self :	Optional[int]    ):
										lowerCAmelCase              = ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_    )
										image_processor.push_to_hub("""test-image-processor"""  ,  use_auth_token=self._token    )

										lowerCAmelCase              = 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              = 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      __lowercase       (							self :	Union[str, Any]    ):
										lowerCAmelCase              = ViTImageProcessor.from_pretrained(SCREAMING_SNAKE_CASE_    )
										image_processor.push_to_hub("""valid_org/test-image-processor"""  ,  use_auth_token=self._token    )

										lowerCAmelCase              = 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              = 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      __lowercase       (							self :	Tuple    ):
										CustomImageProcessor.register_for_auto_class()
										lowerCAmelCase              = 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              = 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']       )





