




import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


_lowerCamelCase			:	Dict							 =     get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
_lowerCamelCase			:	List[Any]							 =     get_tests_dir("""fixtures/vocab.json""")
_lowerCamelCase			:	int							 =     get_tests_dir("""fixtures""")


class        UpperCamelCase_					(				unittest.TestCase  ):

    '''simple docstring'''






    UpperCAmelCase__													=   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']


    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->Dict:





           '''simple docstring'''

           A__   				=					0


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





           '''simple docstring'''

           A__   				=					AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h''')
           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[Any])		->List[str]:





           '''simple docstring'''

           with tempfile.TemporaryDirectory() as tmpdirname:
                  A__   				=					WavaVecaConfig()
                  A__   				=					AutoProcessor.from_pretrained('''facebook/wav2vec2-base-960h''')

                  # save in new folder
                  model_config.save_pretrained(UpperCAmelCase__)
                  processor.save_pretrained(UpperCAmelCase__)

                  A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)

           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


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





           '''simple docstring'''

           with tempfile.TemporaryDirectory() as tmpdirname:
                  # copy relevant files
                  copyfile(UpperCAmelCase__      ,				os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__))
                  copyfile(UpperCAmelCase__      ,				os.path.join(UpperCAmelCase__      ,				'''vocab.json'''))

                  A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)

           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Tuple:





           '''simple docstring'''

           with tempfile.TemporaryDirectory() as tmpdirname:
                  A__   				=					WavaVecaFeatureExtractor()
                  A__   				=					AutoTokenizer.from_pretrained('''facebook/wav2vec2-base-960h''')

                  A__   				=					WavaVecaProcessor(UpperCAmelCase__      ,				UpperCAmelCase__)

                  # save in new folder
                  processor.save_pretrained(UpperCAmelCase__)

                  # drop `processor_class` in tokenizer
                  with open(os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__)      ,				'''r''') as f:
                         A__   				=					json.load(UpperCAmelCase__)
                         config_dict.pop('''processor_class''')

                  with open(os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__)      ,				'''w''') as f:
                         f.write(json.dumps(UpperCAmelCase__))

                  A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)

           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->Optional[int]:





           '''simple docstring'''

           with tempfile.TemporaryDirectory() as tmpdirname:
                  A__   				=					WavaVecaFeatureExtractor()
                  A__   				=					AutoTokenizer.from_pretrained('''facebook/wav2vec2-base-960h''')

                  A__   				=					WavaVecaProcessor(UpperCAmelCase__      ,				UpperCAmelCase__)

                  # save in new folder
                  processor.save_pretrained(UpperCAmelCase__)

                  # drop `processor_class` in feature extractor
                  with open(os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__)      ,				'''r''') as f:
                         A__   				=					json.load(UpperCAmelCase__)
                         config_dict.pop('''processor_class''')

                  with open(os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__)      ,				'''w''') as f:
                         f.write(json.dumps(UpperCAmelCase__))

                  A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)

           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


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





           '''simple docstring'''

           with tempfile.TemporaryDirectory() as tmpdirname:
                  A__   				=					WavaVecaConfig(processor_class='''Wav2Vec2Processor''')
                  model_config.save_pretrained(UpperCAmelCase__)
                  # copy relevant files
                  copyfile(UpperCAmelCase__      ,				os.path.join(UpperCAmelCase__      ,				'''vocab.json'''))
                  # create emtpy sample processor
                  with open(os.path.join(UpperCAmelCase__      ,				UpperCAmelCase__)      ,				'''w''') as f:
                         f.write('''{}''')

                  A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)

           self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->Any:





           '''simple docstring'''

           with self.assertRaises(UpperCAmelCase__):
                  A__   				=					AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor''')
           # If remote code is disabled, we can't load this config.
           with self.assertRaises(UpperCAmelCase__):
                  A__   				=					AutoProcessor.from_pretrained(
                      '''hf-internal-testing/test_dynamic_processor'''      ,				trust_remote_code=UpperCAmelCase__)

           A__   				=					AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor'''      ,				trust_remote_code=UpperCAmelCase__)
           self.assertTrue(processor.special_attribute_present)
           self.assertEqual(processor.__class__.__name__      ,				'''NewProcessor''')

           A__   				=					processor.feature_extractor
           self.assertTrue(feature_extractor.special_attribute_present)
           self.assertEqual(feature_extractor.__class__.__name__      ,				'''NewFeatureExtractor''')

           A__   				=					processor.tokenizer
           self.assertTrue(tokenizer.special_attribute_present)
           if is_tokenizers_available():
                  self.assertEqual(tokenizer.__class__.__name__      ,				'''NewTokenizerFast''')

                  # Test we can also load the slow version
                  A__   				=					AutoProcessor.from_pretrained(
                      '''hf-internal-testing/test_dynamic_processor'''      ,				trust_remote_code=UpperCAmelCase__      ,				use_fast=UpperCAmelCase__)
                  A__   				=					new_processor.tokenizer
                  self.assertTrue(new_tokenizer.special_attribute_present)
                  self.assertEqual(new_tokenizer.__class__.__name__      ,				'''NewTokenizer''')
           else:
                  self.assertEqual(tokenizer.__class__.__name__      ,				'''NewTokenizer''')


    def  SCREAMING_SNAKE_CASE							(    self   :			Any)		->Tuple:





           '''simple docstring'''

           try:
                  AutoConfig.register('''custom'''      ,				UpperCAmelCase__)
                  AutoFeatureExtractor.register(UpperCAmelCase__      ,				UpperCAmelCase__)
                  AutoTokenizer.register(UpperCAmelCase__      ,				slow_tokenizer_class=UpperCAmelCase__)
                  AutoProcessor.register(UpperCAmelCase__      ,				UpperCAmelCase__)
                  # Trying to register something existing in the Transformers library will raise an error
                  with self.assertRaises(UpperCAmelCase__):
                         AutoProcessor.register(UpperCAmelCase__      ,				UpperCAmelCase__)

                  # Now that the config is registered, it can be used as any other config with the auto-API
                  A__   				=					CustomFeatureExtractor.from_pretrained(UpperCAmelCase__)

                  with tempfile.TemporaryDirectory() as tmp_dir:
                         A__   				=					os.path.join(UpperCAmelCase__      ,				'''vocab.txt''')
                         with open(UpperCAmelCase__      ,				'''w'''      ,				encoding='''utf-8''') as vocab_writer:
                                vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]))
                         A__   				=					CustomTokenizer(UpperCAmelCase__)

                  A__   				=					CustomProcessor(UpperCAmelCase__      ,				UpperCAmelCase__)

                  with tempfile.TemporaryDirectory() as tmp_dir:
                         processor.save_pretrained(UpperCAmelCase__)
                         A__   				=					AutoProcessor.from_pretrained(UpperCAmelCase__)
                         self.assertIsInstance(UpperCAmelCase__      ,				UpperCAmelCase__)

           finally:
                  if "custom" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["custom"]
                  if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                         del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                  if CustomConfig in TOKENIZER_MAPPING._extra_content:
                         del TOKENIZER_MAPPING._extra_content[CustomConfig]
                  if CustomConfig in PROCESSOR_MAPPING._extra_content:
                         del PROCESSOR_MAPPING._extra_content[CustomConfig]


    def  SCREAMING_SNAKE_CASE							(    self   :			List[Any])		->Dict:





           '''simple docstring'''

           class        UpperCamelCase_					(				UpperCAmelCase__  ):

               '''simple docstring'''






               UpperCAmelCase__													=   False


           class        UpperCamelCase_					(				UpperCAmelCase__  ):

               '''simple docstring'''






               UpperCAmelCase__													=   False


           class        UpperCamelCase_					(				UpperCAmelCase__  ):

               '''simple docstring'''






               UpperCAmelCase__													=   '''AutoFeatureExtractor'''
               UpperCAmelCase__													=   '''AutoTokenizer'''
               UpperCAmelCase__													=   False

           try:
                  AutoConfig.register('''custom'''      ,				UpperCAmelCase__)
                  AutoFeatureExtractor.register(UpperCAmelCase__      ,				UpperCAmelCase__)
                  AutoTokenizer.register(UpperCAmelCase__      ,				slow_tokenizer_class=UpperCAmelCase__)
                  AutoProcessor.register(UpperCAmelCase__      ,				UpperCAmelCase__)
                  # If remote code is not set, the default is to use local classes.
                  A__   				=					AutoProcessor.from_pretrained('''hf-internal-testing/test_dynamic_processor''')
                  self.assertEqual(processor.__class__.__name__      ,				'''NewProcessor''')
                  self.assertFalse(processor.special_attribute_present)
                  self.assertFalse(processor.feature_extractor.special_attribute_present)
                  self.assertFalse(processor.tokenizer.special_attribute_present)

                  # If remote code is disabled, we load the local ones.
                  A__   				=					AutoProcessor.from_pretrained(
                      '''hf-internal-testing/test_dynamic_processor'''      ,				trust_remote_code=UpperCAmelCase__)
                  self.assertEqual(processor.__class__.__name__      ,				'''NewProcessor''')
                  self.assertFalse(processor.special_attribute_present)
                  self.assertFalse(processor.feature_extractor.special_attribute_present)
                  self.assertFalse(processor.tokenizer.special_attribute_present)

                  # If remote is enabled, we load from the Hub.
                  A__   				=					AutoProcessor.from_pretrained(
                      '''hf-internal-testing/test_dynamic_processor'''      ,				trust_remote_code=UpperCAmelCase__)
                  self.assertEqual(processor.__class__.__name__      ,				'''NewProcessor''')
                  self.assertTrue(processor.special_attribute_present)
                  self.assertTrue(processor.feature_extractor.special_attribute_present)
                  self.assertTrue(processor.tokenizer.special_attribute_present)

           finally:
                  if "custom" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["custom"]
                  if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
                         del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
                  if CustomConfig in TOKENIZER_MAPPING._extra_content:
                         del TOKENIZER_MAPPING._extra_content[CustomConfig]
                  if CustomConfig in PROCESSOR_MAPPING._extra_content:
                         del PROCESSOR_MAPPING._extra_content[CustomConfig]


    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->List[str]:





           '''simple docstring'''

           A__   				=					AutoProcessor.from_pretrained('''hf-internal-testing/tiny-random-bert''')
           self.assertEqual(processor.__class__.__name__      ,				'''BertTokenizerFast''')





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





           '''simple docstring'''

           A__   				=					AutoProcessor.from_pretrained('''hf-internal-testing/tiny-random-convnext''')
           self.assertEqual(processor.__class__.__name__      ,				'''ConvNextImageProcessor''')


@is_staging_test
class        UpperCamelCase_					(				unittest.TestCase  ):

    '''simple docstring'''






    UpperCAmelCase__													=   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']


    @classmethod
    def  SCREAMING_SNAKE_CASE							(    cls   :			Tuple)		->Any:





           '''simple docstring'''

           A__   				=					TOKEN
           HfFolder.save_token(UpperCAmelCase__)


    @classmethod
    def  SCREAMING_SNAKE_CASE							(    cls   :			List[Any])		->List[str]:





           '''simple docstring'''

           try:
                  delete_repo(token=cls._token      ,				repo_id='''test-processor''')
           except HTTPError:
                  pass

           try:
                  delete_repo(token=cls._token      ,				repo_id='''valid_org/test-processor-org''')
           except HTTPError:
                  pass

           try:
                  delete_repo(token=cls._token      ,				repo_id='''test-dynamic-processor''')
           except HTTPError:
                  pass


    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Tuple:





           '''simple docstring'''

           A__   				=					WavaVecaProcessor.from_pretrained(UpperCAmelCase__)
           with tempfile.TemporaryDirectory() as tmp_dir:
                  processor.save_pretrained(
                      os.path.join(UpperCAmelCase__      ,				'''test-processor''')      ,				push_to_hub=UpperCAmelCase__      ,				use_auth_token=self._token)

                  A__   				=					WavaVecaProcessor.from_pretrained(f"""{USER}/test-processor""")
                  for k, v in processor.feature_extractor.__dict__.items():
                         self.assertEqual(UpperCAmelCase__      ,				getattr(new_processor.feature_extractor      ,				UpperCAmelCase__))
                  self.assertDictEqual(new_processor.tokenizer.get_vocab()      ,				processor.tokenizer.get_vocab())


    def  SCREAMING_SNAKE_CASE							(    self   :			Tuple)		->List[str]:





           '''simple docstring'''

           A__   				=					WavaVecaProcessor.from_pretrained(UpperCAmelCase__)

           with tempfile.TemporaryDirectory() as tmp_dir:
                  processor.save_pretrained(
                      os.path.join(UpperCAmelCase__      ,				'''test-processor-org''')      ,				push_to_hub=UpperCAmelCase__      ,				use_auth_token=self._token      ,				organization='''valid_org'''      ,				)

                  A__   				=					WavaVecaProcessor.from_pretrained('''valid_org/test-processor-org''')
                  for k, v in processor.feature_extractor.__dict__.items():
                         self.assertEqual(UpperCAmelCase__      ,				getattr(new_processor.feature_extractor      ,				UpperCAmelCase__))
                  self.assertDictEqual(new_processor.tokenizer.get_vocab()      ,				processor.tokenizer.get_vocab())





    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[int])		->Union[str, Any]:





           '''simple docstring'''

           CustomFeatureExtractor.register_for_auto_class()
           CustomTokenizer.register_for_auto_class()
           CustomProcessor.register_for_auto_class()

           A__   				=					CustomFeatureExtractor.from_pretrained(UpperCAmelCase__)

           with tempfile.TemporaryDirectory() as tmp_dir:
                  A__   				=					os.path.join(UpperCAmelCase__      ,				'''vocab.txt''')
                  with open(UpperCAmelCase__      ,				'''w'''      ,				encoding='''utf-8''') as vocab_writer:
                         vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens]))
                  A__   				=					CustomTokenizer(UpperCAmelCase__)

           A__   				=					CustomProcessor(UpperCAmelCase__      ,				UpperCAmelCase__)

           with tempfile.TemporaryDirectory() as tmp_dir:
                  create_repo(f"""{USER}/test-dynamic-processor"""      ,				token=self._token)
                  A__   				=					Repository(UpperCAmelCase__      ,				clone_from=f"""{USER}/test-dynamic-processor"""      ,				token=self._token)
                  processor.save_pretrained(UpperCAmelCase__)

                  # This has added the proper auto_map field to the feature extractor config
                  self.assertDictEqual(
                      processor.feature_extractor.auto_map      ,				{
                          '''AutoFeatureExtractor''': '''custom_feature_extraction.CustomFeatureExtractor''',
                          '''AutoProcessor''': '''custom_processing.CustomProcessor''',
                      }      ,				)

                  # This has added the proper auto_map field to the tokenizer config
                  with open(os.path.join(UpperCAmelCase__      ,				'''tokenizer_config.json''')) as f:
                         A__   				=					json.load(UpperCAmelCase__)
                  self.assertDictEqual(
                      tokenizer_config['''auto_map''']      ,				{
                          '''AutoTokenizer''': ['''custom_tokenization.CustomTokenizer''', None],
                          '''AutoProcessor''': '''custom_processing.CustomProcessor''',
                      }      ,				)

                  # The code has been copied from fixtures
                  self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase__      ,				'''custom_feature_extraction.py''')))
                  self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase__      ,				'''custom_tokenization.py''')))
                  self.assertTrue(os.path.isfile(os.path.join(UpperCAmelCase__      ,				'''custom_processing.py''')))

                  repo.push_to_hub()

           A__   				=					AutoProcessor.from_pretrained(f"""{USER}/test-dynamic-processor"""      ,				trust_remote_code=UpperCAmelCase__)
           # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
           self.assertEqual(new_processor.__class__.__name__      ,				'''CustomProcessor''')








import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class        UpperCamelCase_					(				unittest.TestCase  ):

    '''simple docstring'''






    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->List[Any]:





           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()


    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			Union[str, Any])		->Dict:





           '''simple docstring'''

           A__   				=					1
           A__   				=					3
           A__   				=					(32, 32)

           A__   				=					floats_tensor((batch_size, num_channels) + sizes      ,				rng=random.Random(0)).to(UpperCAmelCase__)
           return image


    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			Any)		->str:





           '''simple docstring'''

           torch.manual_seed(0)
           A__   				=					UNetaDConditionModel(
               block_out_channels=(32, 32, 64)      ,				layers_per_block=2      ,				sample_size=32      ,				in_channels=7      ,				out_channels=4      ,				down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''', '''CrossAttnDownBlock2D''')      ,				up_block_types=('''CrossAttnUpBlock2D''', '''CrossAttnUpBlock2D''', '''UpBlock2D''')      ,				cross_attention_dim=32      ,				attention_head_dim=8      ,				use_linear_projection=UpperCAmelCase__      ,				only_cross_attention=(True, True, False)      ,				num_class_embeds=100      ,				)
           return model


    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Dict:





           '''simple docstring'''

           torch.manual_seed(0)
           A__   				=					AutoencoderKL(
               block_out_channels=[32, 32, 64]      ,				in_channels=3      ,				out_channels=3      ,				down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''', '''DownEncoderBlock2D''']      ,				up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''']      ,				latent_channels=4      ,				)
           return model


    @property
    def  SCREAMING_SNAKE_CASE							(    self   :			List[str])		->Dict:





           '''simple docstring'''

           torch.manual_seed(0)
           A__   				=					CLIPTextConfig(
               bos_token_id=0      ,				eos_token_id=2      ,				hidden_size=32      ,				intermediate_size=37      ,				layer_norm_eps=1e-05      ,				num_attention_heads=4      ,				num_hidden_layers=5      ,				pad_token_id=1      ,				vocab_size=1_000      ,				hidden_act='''gelu'''      ,				projection_dim=512      ,				)
           return CLIPTextModel(UpperCAmelCase__)


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





           '''simple docstring'''

           A__   				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
           A__   				=					self.dummy_cond_unet_upscale
           A__   				=					DDPMScheduler()
           A__   				=					DDIMScheduler(prediction_type='''v_prediction''')
           A__   				=					self.dummy_vae
           A__   				=					self.dummy_text_encoder
           A__   				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

           A__   				=					self.dummy_image.cpu().permute(0      ,				2      ,				3      ,				1)[0]
           A__   				=					Image.fromarray(np.uinta(UpperCAmelCase__)).convert('''RGB''').resize((64, 64))

           # make sure here that pndm scheduler skips prk
           A__   				=					StableDiffusionUpscalePipeline(
               unet=UpperCAmelCase__      ,				low_res_scheduler=UpperCAmelCase__      ,				scheduler=UpperCAmelCase__      ,				vae=UpperCAmelCase__      ,				text_encoder=UpperCAmelCase__      ,				tokenizer=UpperCAmelCase__      ,				max_noise_level=350      ,				)
           A__   				=					sd_pipe.to(UpperCAmelCase__)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__)

           A__   				=					'''A painting of a squirrel eating a burger'''
           A__   				=					torch.Generator(device=UpperCAmelCase__).manual_seed(0)
           A__   				=					sd_pipe(
               [prompt]      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				guidance_scale=6.0      ,				noise_level=20      ,				num_inference_steps=2      ,				output_type='''np'''      ,				)

           A__   				=					output.images

           A__   				=					torch.Generator(device=UpperCAmelCase__).manual_seed(0)
           A__   				=					sd_pipe(
               [prompt]      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				guidance_scale=6.0      ,				noise_level=20      ,				num_inference_steps=2      ,				output_type='''np'''      ,				return_dict=UpperCAmelCase__      ,				)[0]

           A__   				=					image[0, -3:, -3:, -1]
           A__   				=					image_from_tuple[0, -3:, -3:, -1]

           A__   				=					low_res_image.size[0] * 4
           assert image.shape == (1, expected_height_width, expected_height_width, 3)
           A__   				=					np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661])

           assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
           assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2


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





           '''simple docstring'''

           A__   				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
           A__   				=					self.dummy_cond_unet_upscale
           A__   				=					DDPMScheduler()
           A__   				=					DDIMScheduler(prediction_type='''v_prediction''')
           A__   				=					self.dummy_vae
           A__   				=					self.dummy_text_encoder
           A__   				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

           A__   				=					self.dummy_image.cpu().permute(0      ,				2      ,				3      ,				1)[0]
           A__   				=					Image.fromarray(np.uinta(UpperCAmelCase__)).convert('''RGB''').resize((64, 64))

           # make sure here that pndm scheduler skips prk
           A__   				=					StableDiffusionUpscalePipeline(
               unet=UpperCAmelCase__      ,				low_res_scheduler=UpperCAmelCase__      ,				scheduler=UpperCAmelCase__      ,				vae=UpperCAmelCase__      ,				text_encoder=UpperCAmelCase__      ,				tokenizer=UpperCAmelCase__      ,				max_noise_level=350      ,				)
           A__   				=					sd_pipe.to(UpperCAmelCase__)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__)

           A__   				=					'''A painting of a squirrel eating a burger'''
           A__   				=					sd_pipe(
               2 * [prompt]      ,				image=2 * [low_res_image]      ,				guidance_scale=6.0      ,				noise_level=20      ,				num_inference_steps=2      ,				output_type='''np'''      ,				)
           A__   				=					output.images
           assert image.shape[0] == 2

           A__   				=					torch.Generator(device=UpperCAmelCase__).manual_seed(0)
           A__   				=					sd_pipe(
               [prompt]      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				num_images_per_prompt=2      ,				guidance_scale=6.0      ,				noise_level=20      ,				num_inference_steps=2      ,				output_type='''np'''      ,				)
           A__   				=					output.images
           assert image.shape[0] == 2





    @unittest.skipIf(torch_device != '''cuda'''      ,				'''This test requires a GPU''')
    def  SCREAMING_SNAKE_CASE							(    self   :			Any)		->str:





           '''simple docstring'''

           A__   				=					self.dummy_cond_unet_upscale
           A__   				=					DDPMScheduler()
           A__   				=					DDIMScheduler(prediction_type='''v_prediction''')
           A__   				=					self.dummy_vae
           A__   				=					self.dummy_text_encoder
           A__   				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

           A__   				=					self.dummy_image.cpu().permute(0      ,				2      ,				3      ,				1)[0]
           A__   				=					Image.fromarray(np.uinta(UpperCAmelCase__)).convert('''RGB''').resize((64, 64))

           # put models in fp16, except vae as it overflows in fp16
           A__   				=					unet.half()
           A__   				=					text_encoder.half()

           # make sure here that pndm scheduler skips prk
           A__   				=					StableDiffusionUpscalePipeline(
               unet=UpperCAmelCase__      ,				low_res_scheduler=UpperCAmelCase__      ,				scheduler=UpperCAmelCase__      ,				vae=UpperCAmelCase__      ,				text_encoder=UpperCAmelCase__      ,				tokenizer=UpperCAmelCase__      ,				max_noise_level=350      ,				)
           A__   				=					sd_pipe.to(UpperCAmelCase__)
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__)

           A__   				=					'''A painting of a squirrel eating a burger'''
           A__   				=					torch.manual_seed(0)
           A__   				=					sd_pipe(
               [prompt]      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				num_inference_steps=2      ,				output_type='''np'''      ,				).images

           A__   				=					low_res_image.size[0] * 4
           assert image.shape == (1, expected_height_width, expected_height_width, 3)


@slow
@require_torch_gpu
class        UpperCamelCase_					(				unittest.TestCase  ):

    '''simple docstring'''






    def  SCREAMING_SNAKE_CASE							(    self   :			Dict)		->str:





           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()


    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Any:





           '''simple docstring'''

           A__   				=					load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/sd2-upscale/low_res_cat.png''')
           A__   				=					load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
               '''/upsampled_cat.npy''')

           A__   				=					'''stabilityai/stable-diffusion-x4-upscaler'''
           A__   				=					StableDiffusionUpscalePipeline.from_pretrained(UpperCAmelCase__)
           pipe.to(UpperCAmelCase__)
           pipe.set_progress_bar_config(disable=UpperCAmelCase__)
           pipe.enable_attention_slicing()

           A__   				=					'''a cat sitting on a park bench'''

           A__   				=					torch.manual_seed(0)
           A__   				=					pipe(
               prompt=UpperCAmelCase__      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				output_type='''np'''      ,				)
           A__   				=					output.images[0]

           assert image.shape == (512, 512, 3)
           assert np.abs(expected_image - image).max() < 1e-3


    def  SCREAMING_SNAKE_CASE							(    self   :			int)		->str:





           '''simple docstring'''

           A__   				=					load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/sd2-upscale/low_res_cat.png''')
           A__   				=					load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
               '''/upsampled_cat_fp16.npy''')

           A__   				=					'''stabilityai/stable-diffusion-x4-upscaler'''
           A__   				=					StableDiffusionUpscalePipeline.from_pretrained(
               UpperCAmelCase__      ,				torch_dtype=torch.floataa      ,				)
           pipe.to(UpperCAmelCase__)
           pipe.set_progress_bar_config(disable=UpperCAmelCase__)
           pipe.enable_attention_slicing()

           A__   				=					'''a cat sitting on a park bench'''

           A__   				=					torch.manual_seed(0)
           A__   				=					pipe(
               prompt=UpperCAmelCase__      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				output_type='''np'''      ,				)
           A__   				=					output.images[0]

           assert image.shape == (512, 512, 3)
           assert np.abs(expected_image - image).max() < 5e-1





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





           '''simple docstring'''

           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           A__   				=					load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/sd2-upscale/low_res_cat.png''')

           A__   				=					'''stabilityai/stable-diffusion-x4-upscaler'''
           A__   				=					StableDiffusionUpscalePipeline.from_pretrained(
               UpperCAmelCase__      ,				torch_dtype=torch.floataa      ,				)
           pipe.to(UpperCAmelCase__)
           pipe.set_progress_bar_config(disable=UpperCAmelCase__)
           pipe.enable_attention_slicing(1)
           pipe.enable_sequential_cpu_offload()

           A__   				=					'''a cat sitting on a park bench'''

           A__   				=					torch.manual_seed(0)
           A__   				=					pipe(
               prompt=UpperCAmelCase__      ,				image=UpperCAmelCase__      ,				generator=UpperCAmelCase__      ,				num_inference_steps=5      ,				output_type='''np'''      ,				)

           A__   				=					torch.cuda.max_memory_allocated()
           # make sure that less than 2.9 GB is allocated
           assert mem_bytes < 2.9 * 10**9


