'''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_     :   Dict 				=				get_tests_dir('fixtures')






class 		_lowerCamelCase		(   unittest.TestCase    ):
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     # A mock response for an HTTP head request to emulate server down
     SCREAMING_SNAKE_CASE__:   List[str]=      mock.Mock()
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      500
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      {}
     SCREAMING_SNAKE_CASE__:   Any=      HTTPError
     SCREAMING_SNAKE_CASE__:   int=      {}

     # Download this model to make sure it's in the cache.
     SCREAMING_SNAKE_CASE__:   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=_A   ) as mock_head:
      SCREAMING_SNAKE_CASE__:   int=      ViTImageProcessor.from_pretrained('''hf-internal-testing/tiny-random-vit'''   )
      # This check we did call the fake head request
      mock_head.assert_called()
    def 						UpperCamelCase_				(  self   )       ->					str:
     # This test is for deprecated behavior and can be removed in v5
     SCREAMING_SNAKE_CASE__:   Dict=      ViTImageProcessor.from_pretrained(
         '''https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'''   )



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

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

     self.assertIsNotNone(_A   )






@is_staging_test
class 		_lowerCamelCase		(   unittest.TestCase    ):
    @classmethod
    def 						UpperCamelCase_				(  cls   )       ->					Optional[int]:
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      TOKEN
     HfFolder.save_token(_A   )
    @classmethod
    def 						UpperCamelCase_				(  cls   )       ->					Optional[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 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__:   Dict=      ViTImageProcessor.from_pretrained(_A   )
     image_processor.push_to_hub('''test-image-processor''' , use_auth_token=self._token   )

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

     SCREAMING_SNAKE_CASE__:   int=      ViTImageProcessor.from_pretrained(f'{USER}/test-image-processor'   )
     for k, v in image_processor.__dict__.items():
      self.assertEqual(_A , getattr(_A , _A   )   )
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     SCREAMING_SNAKE_CASE__:   Tuple=      ViTImageProcessor.from_pretrained(_A   )
     image_processor.push_to_hub('''valid_org/test-image-processor''' , use_auth_token=self._token   )

     SCREAMING_SNAKE_CASE__:   str=      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__:   List[Any]=      ViTImageProcessor.from_pretrained('''valid_org/test-image-processor-org'''   )
     for k, v in image_processor.__dict__.items():
      self.assertEqual(_A , getattr(_A , _A   )   )



    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     CustomImageProcessor.register_for_auto_class()
     SCREAMING_SNAKE_CASE__:   Tuple=      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__:   Optional[int]=      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 unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible






class 		_lowerCamelCase		(   unittest.TestCase    ):
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   List[Any]=      [
         '''safety_checker/pytorch_model.bin''',
         '''safety_checker/model.safetensors''',
         '''vae/diffusion_pytorch_model.bin''',
         '''vae/diffusion_pytorch_model.safetensors''',
         '''text_encoder/pytorch_model.bin''',
         '''text_encoder/model.safetensors''',
         '''unet/diffusion_pytorch_model.bin''',
         '''unet/diffusion_pytorch_model.safetensors''',
     ]
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     SCREAMING_SNAKE_CASE__:   List[str]=      [
         '''unet/diffusion_pytorch_model.bin''',
         '''unet/diffusion_pytorch_model.safetensors''',
     ]
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      [
         '''safety_checker/pytorch_model.bin''',
         '''safety_checker/model.safetensors''',
         '''vae/diffusion_pytorch_model.bin''',
         '''vae/diffusion_pytorch_model.safetensors''',
         '''text_encoder/pytorch_model.bin''',
         '''text_encoder/model.safetensors''',
         '''unet/diffusion_pytorch_model.bin''',
         # Removed: 'unet/diffusion_pytorch_model.safetensors',
     ]
     self.assertFalse(is_safetensors_compatible(lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   str=      [
         '''text_encoder/pytorch_model.bin''',
         '''text_encoder/model.safetensors''',
     ]
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   List[str]=      [
         '''safety_checker/pytorch_model.bin''',
         '''safety_checker/model.safetensors''',
         '''vae/diffusion_pytorch_model.bin''',
         '''vae/diffusion_pytorch_model.safetensors''',
         '''text_encoder/pytorch_model.bin''',
         # Removed: 'text_encoder/model.safetensors',
         '''unet/diffusion_pytorch_model.bin''',
         '''unet/diffusion_pytorch_model.safetensors''',
     ]
     self.assertFalse(is_safetensors_compatible(lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      [
         '''safety_checker/pytorch_model.fp16.bin''',
         '''safety_checker/model.fp16.safetensors''',
         '''vae/diffusion_pytorch_model.fp16.bin''',
         '''vae/diffusion_pytorch_model.fp16.safetensors''',
         '''text_encoder/pytorch_model.fp16.bin''',
         '''text_encoder/model.fp16.safetensors''',
         '''unet/diffusion_pytorch_model.fp16.bin''',
         '''unet/diffusion_pytorch_model.fp16.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   Any=      '''fp16'''
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					Any:
     SCREAMING_SNAKE_CASE__:   List[str]=      [
         '''unet/diffusion_pytorch_model.fp16.bin''',
         '''unet/diffusion_pytorch_model.fp16.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   Dict=      '''fp16'''
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     # pass variant but use the non-variant filenames
     SCREAMING_SNAKE_CASE__:   List[str]=      [
         '''unet/diffusion_pytorch_model.bin''',
         '''unet/diffusion_pytorch_model.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      '''fp16'''
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   Dict=      [
         '''safety_checker/pytorch_model.fp16.bin''',
         '''safety_checker/model.fp16.safetensors''',
         '''vae/diffusion_pytorch_model.fp16.bin''',
         '''vae/diffusion_pytorch_model.fp16.safetensors''',
         '''text_encoder/pytorch_model.fp16.bin''',
         '''text_encoder/model.fp16.safetensors''',
         '''unet/diffusion_pytorch_model.fp16.bin''',
         # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
     ]
     SCREAMING_SNAKE_CASE__:   List[Any]=      '''fp16'''
     self.assertFalse(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     SCREAMING_SNAKE_CASE__:   int=      [
         '''text_encoder/pytorch_model.fp16.bin''',
         '''text_encoder/model.fp16.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   Any=      '''fp16'''
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     # pass variant but use the non-variant filenames
     SCREAMING_SNAKE_CASE__:   Optional[int]=      [
         '''text_encoder/pytorch_model.bin''',
         '''text_encoder/model.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   str=      '''fp16'''
     self.assertTrue(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )



    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__:   Tuple=      [
         '''safety_checker/pytorch_model.fp16.bin''',
         '''safety_checker/model.fp16.safetensors''',
         '''vae/diffusion_pytorch_model.fp16.bin''',
         '''vae/diffusion_pytorch_model.fp16.safetensors''',
         '''text_encoder/pytorch_model.fp16.bin''',
         # 'text_encoder/model.fp16.safetensors',
         '''unet/diffusion_pytorch_model.fp16.bin''',
         '''unet/diffusion_pytorch_model.fp16.safetensors''',
     ]
     SCREAMING_SNAKE_CASE__:   str=      '''fp16'''
     self.assertFalse(is_safetensors_compatible(lowerCAmelCase , variant=lowerCAmelCase   )   )

