



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


_lowerCamelCase   				=			get_tests_dir('fixtures')




class   UpperCamelCase_       (     unittest.TestCase    ):


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



									"""simple docstring"""



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

									# Download this model to make sure it's in the cache.
									SCREAMING_SNAKE_CASE__			=      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:
											SCREAMING_SNAKE_CASE__			=      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    :Dict		)   ->   List[str]:



									"""simple docstring"""



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


							def      _snake_case  (							self    :List[Any]		)   ->   Optional[int]:



									"""simple docstring"""



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

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

									self.assertIsNotNone(__A		)




@is_staging_test
class   UpperCamelCase_       (     unittest.TestCase    ):


							@classmethod
							def      _snake_case  (							cls    :int		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TOKEN
									HfFolder.save_token(__A		)


							@classmethod
							def      _snake_case  (							cls    :Optional[int]		)   ->   Optional[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      _snake_case  (							self    :Tuple		)   ->   List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      ViTImageProcessor.from_pretrained(__A		)
									image_processor.push_to_hub("""test-image-processor"""							,				use_auth_token=self._token		)

									SCREAMING_SNAKE_CASE__			=      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		)

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


							def      _snake_case  (							self    :int		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      ViTImageProcessor.from_pretrained(__A		)
									image_processor.push_to_hub("""valid_org/test-image-processor"""							,				use_auth_token=self._token		)

									SCREAMING_SNAKE_CASE__			=      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		)

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


							def      _snake_case  (							self    :Optional[Any]		)   ->   int:



									"""simple docstring"""



									CustomImageProcessor.register_for_auto_class()
									SCREAMING_SNAKE_CASE__			=      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"""}							,				)

									SCREAMING_SNAKE_CASE__			=      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"""		)






import inspect
import unittest




class   UpperCamelCase_       (     unittest.TestCase    ):


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



									"""simple docstring"""



									try:
											import diffusers  # noqa: F401
									except ImportError:
											assert False


							def      _snake_case  (							self    :Any		)   ->   Any:



									"""simple docstring"""



									import diffusers
									from diffusers.dependency_versions_table import deps

									SCREAMING_SNAKE_CASE__			=      inspect.getmembers(__A							,				inspect.isclass		)

									for cls_name, cls_module in all_classes:
											if "dummy_" in cls_module.__module__:
													for backend in cls_module._backends:
															if backend == "k_diffusion":
																	SCREAMING_SNAKE_CASE__			=      """k-diffusion"""
															elif backend == "invisible_watermark":
																	SCREAMING_SNAKE_CASE__			=      """invisible-watermark"""
															assert backend in deps, f'''{backend} is not in the deps table!'''