
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  :					Union[str, Any]						    =							get_tests_dir("""fixtures""")

class __snake_case		(      unittest.TestCase     ):
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      mock.Mock()
           lowercase							:     int       	=      500
           lowercase							:     Tuple       	=      {}
           lowercase							:     str       	=      HTTPError
           lowercase							:     Union[str, Any]       	=      {}

           # Download this model to make sure it's in the cache.
           lowercase							:     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=__a      ) as mock_head:
                  lowercase							:     Optional[int]       	=      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      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      ViTImageProcessor.from_pretrained(
               """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







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

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

           self.assertIsNotNone(__a      )






@is_staging_test
class __snake_case		(      unittest.TestCase     ):
    @classmethod
    def       _SCREAMING_SNAKE_CASE       (  cls      ):



           '''simple docstring'''







           lowercase							:     Union[str, Any]       	=      TOKEN
           HfFolder.save_token(__a      )
    @classmethod
    def       _SCREAMING_SNAKE_CASE       (  cls      ):



           '''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       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[int]       	=      ViTImageProcessor.from_pretrained(__a      )
           image_processor.push_to_hub("""test-image-processor"""		,use_auth_token=self._token      )

           lowercase							:     str       	=      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      )

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



           '''simple docstring'''







           lowercase							:     Any       	=      ViTImageProcessor.from_pretrained(__a      )
           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(__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      )

           lowercase							:     Optional[int]       	=      ViTImageProcessor.from_pretrained("""valid_org/test-image-processor-org"""      )
           for k, v in image_processor.__dict__.items():
                  self.assertEqual(__a		,getattr(__a		,__a      )      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           CustomImageProcessor.register_for_auto_class()
           lowercase							:     List[str]       	=      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"""}		,)

           lowercase							:     Tuple       	=      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"""      )





def 				A				(					_lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							if density <= 0:
														raise ValueError("Impossible fluid density"  )
							if bulk_modulus <= 0:
														raise ValueError("Impossible bulk modulus"  )

							return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
						import doctest

						doctest.testmod()
