

'''simple docstring'''





from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available
@dataclass
class        A  (	__UpperCAmelCase ):
						__UpperCAmelCase				:	Union[List[PIL.Image.Image], np.ndarray]
						__UpperCAmelCase				:	Optional[List[bool]]


if is_transformers_available() and is_torch_available():
							from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline









"""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


__snake_case    					=					get_tests_dir('fixtures')

class 				_SCREAMING_SNAKE_CASE				(							unittest.TestCase  ):
   """simple docstring"""



   def 					UpperCAmelCase__(						self						)      ->							str:
    # A mock response for an HTTP head request to emulate server down
    lowercase__       :       List[str]				=						mock.Mock()
    lowercase__       :       Dict				=						500
    lowercase__       :       Any				=						{}
    lowercase__       :       int				=						HTTPError
    lowercase__       :       Optional[int]				=						{}

    # Download this model to make sure it's in the cache.
    lowercase__       :       Dict				=						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=lowerCamelCase__						) as mock_head:
     lowercase__       :       Dict				=						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						)      ->							Dict:
    # This test is for deprecated behavior and can be removed in v5
    lowercase__       :       Dict				=						ViTImageProcessor.from_pretrained(
        """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""						)







   def 					UpperCAmelCase__(						self						)      ->							Tuple:
    with self.assertRaises(lowerCamelCase__						):
     # config is in subfolder, the following should not work without specifying the subfolder
     lowercase__       :       List[str]				=						AutoImageProcessor.from_pretrained("""hf-internal-testing/stable-diffusion-all-variants"""						)

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

    self.assertIsNotNone(lowerCamelCase__						)

@is_staging_test
class 				_SCREAMING_SNAKE_CASE				(							unittest.TestCase  ):
   """simple docstring"""



   @classmethod
   def 					UpperCAmelCase__(						cls						)      ->							int:
    lowercase__       :       str				=						TOKEN
    HfFolder.save_token(lowerCamelCase__						)


   @classmethod
   def 					UpperCAmelCase__(						cls						)      ->							List[str]:
    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						)      ->							int:
    lowercase__       :       List[str]				=						ViTImageProcessor.from_pretrained(lowerCamelCase__						)
    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(lowerCamelCase__ ,     getattr(lowerCamelCase__ ,     lowerCamelCase__						)						)

    # 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(
         lowerCamelCase__ ,     repo_id="""test-image-processor""" ,     push_to_hub=lowerCamelCase__ ,     use_auth_token=self._token						)

    lowercase__       :       Union[str, Any]				=						ViTImageProcessor.from_pretrained(F'''{USER}/test-image-processor'''						)
    for k, v in image_processor.__dict__.items():
     self.assertEqual(lowerCamelCase__ ,     getattr(lowerCamelCase__ ,     lowerCamelCase__						)						)


   def 					UpperCAmelCase__(						self						)      ->							Optional[int]:
    lowercase__       :       Tuple				=						ViTImageProcessor.from_pretrained(lowerCamelCase__						)
    image_processor.push_to_hub("""valid_org/test-image-processor""" ,     use_auth_token=self._token						)

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

    # 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(
         lowerCamelCase__ ,     repo_id="""valid_org/test-image-processor-org""" ,     push_to_hub=lowerCamelCase__ ,     use_auth_token=self._token						)

    lowercase__       :       List[Any]				=						ViTImageProcessor.from_pretrained("""valid_org/test-image-processor-org"""						)
    for k, v in image_processor.__dict__.items():
     self.assertEqual(lowerCamelCase__ ,     getattr(lowerCamelCase__ ,     lowerCamelCase__						)						)







   def 					UpperCAmelCase__(						self						)      ->							Dict:
    CustomImageProcessor.register_for_auto_class()
    lowercase__       :       List[str]				=						CustomImageProcessor.from_pretrained(lowerCamelCase__						)

    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__       :       Dict				=						AutoImageProcessor.from_pretrained(
        F'''{USER}/test-dynamic-image-processor''' ,     trust_remote_code=lowerCamelCase__						)
    # 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"""						)