




'''simple docstring'''
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






@skip_mps
class 	SCREAMING_SNAKE_CASE(    __A       ,				__A       ,				__A       ,				unittest.TestCase					):
       snake_case_			:					List[str]   = StableDiffusionModelEditingPipeline
       snake_case_			:					List[Any]   = TEXT_TO_IMAGE_PARAMS
       snake_case_			:					List[str]   = TEXT_TO_IMAGE_BATCH_PARAMS
       snake_case_			:					Dict   = TEXT_TO_IMAGE_IMAGE_PARAMS
       snake_case_			:					Any   = TEXT_TO_IMAGE_IMAGE_PARAMS

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           torch.manual_seed(0					)
           __lowercase          =						UNetaDConditionModel(
               block_out_channels=(32, 64) ,		layers_per_block=2 ,		sample_size=32 ,		in_channels=4 ,		out_channels=4 ,		down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") ,		up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") ,		cross_attention_dim=32 ,		)
           __lowercase          =						DDIMScheduler()
           torch.manual_seed(0					)
           __lowercase          =						AutoencoderKL(
               block_out_channels=[32, 64] ,		in_channels=3 ,		out_channels=3 ,		down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] ,		up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] ,		latent_channels=4 ,		)
           torch.manual_seed(0					)
           __lowercase          =						CLIPTextConfig(
               bos_token_id=0 ,		eos_token_id=2 ,		hidden_size=32 ,		intermediate_size=37 ,		layer_norm_eps=1E-0_5 ,		num_attention_heads=4 ,		num_hidden_layers=5 ,		pad_token_id=1 ,		vocab_size=1000 ,		)
           __lowercase          =						CLIPTextModel(lowerCamelCase__					)
           __lowercase          =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

           __lowercase          =						{
               """unet""": unet,
               """scheduler""": scheduler,
               """vae""": vae,
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """safety_checker""": None,
               """feature_extractor""": None,
           }
           return components

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__=0					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						torch.manual_seed(lowerCamelCase__					)
           __lowercase          =						{
               """prompt""": """A field of roses""",
               """generator""": generator,
               # Setting height and width to None to prevent OOMs on CPU.
               """height""": None,
               """width""": None,
               """num_inference_steps""": 2,
               """guidance_scale""": 6.0,
               """output_type""": """numpy""",
           }
           return inputs

       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           __lowercase          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           __lowercase          =						self.get_dummy_components()
           __lowercase          =						StableDiffusionModelEditingPipeline(**lowerCamelCase__					)
           __lowercase          =						sd_pipe.to(lowerCamelCase__					)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						self.get_dummy_inputs(lowerCamelCase__					)
           __lowercase          =						sd_pipe(**lowerCamelCase__					).images
           __lowercase          =						image[0, -3:, -3:, -1]
           assert image.shape == (1, 64, 64, 3)

           __lowercase          =						np.array([0.47_55, 0.51_32, 0.49_76, 0.39_04, 0.35_54, 0.47_65, 0.51_39, 0.51_58, 0.48_89]					)

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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           __lowercase          =						self.get_dummy_components()
           __lowercase          =						StableDiffusionModelEditingPipeline(**lowerCamelCase__					)
           __lowercase          =						sd_pipe.to(lowerCamelCase__					)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						self.get_dummy_inputs(lowerCamelCase__					)
           __lowercase          =						"""french fries"""
           __lowercase          =						sd_pipe(**lowerCamelCase__ ,		negative_prompt=lowerCamelCase__					)
           __lowercase          =						output.images
           __lowercase          =						image[0, -3:, -3:, -1]

           assert image.shape == (1, 64, 64, 3)

           __lowercase          =						np.array([0.49_92, 0.51_01, 0.50_04, 0.39_49, 0.36_04, 0.47_35, 0.52_16, 0.52_04, 0.49_13]					)

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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           __lowercase          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           __lowercase          =						self.get_dummy_components()
           __lowercase          =						EulerAncestralDiscreteScheduler(
               beta_start=0.0_00_85 ,		beta_end=0.0_12 ,		beta_schedule="""scaled_linear"""					)
           __lowercase          =						StableDiffusionModelEditingPipeline(**lowerCamelCase__					)
           __lowercase          =						sd_pipe.to(lowerCamelCase__					)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						self.get_dummy_inputs(lowerCamelCase__					)
           __lowercase          =						sd_pipe(**lowerCamelCase__					).images
           __lowercase          =						image[0, -3:, -3:, -1]

           assert image.shape == (1, 64, 64, 3)

           __lowercase          =						np.array([0.47_47, 0.53_72, 0.47_79, 0.49_82, 0.55_43, 0.48_16, 0.52_38, 0.49_04, 0.50_27]					)

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

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

           """simple docstring"""



           __lowercase          =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           __lowercase          =						self.get_dummy_components()
           __lowercase          =						PNDMScheduler()
           __lowercase          =						StableDiffusionModelEditingPipeline(**lowerCamelCase__					)
           __lowercase          =						sd_pipe.to(lowerCamelCase__					)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase__					)

           __lowercase          =						self.get_dummy_inputs(lowerCamelCase__					)
           # the pipeline does not expect pndm so test if it raises error.
           with self.assertRaises(lowerCamelCase__					):
               __lowercase          =						sd_pipe(**lowerCamelCase__					).images

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           super().test_inference_batch_single_identical(expected_max_diff=5E-3					)




       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           super().test_attention_slicing_forward_pass(expected_max_diff=5E-3					)






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

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



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

       def    snake_case__      (   self ,		lowerCamelCase__=0					)   -> Dict:

           """simple docstring"""



           __lowercase          =						torch.manual_seed(lowerCamelCase__					)
           __lowercase          =						{
               """prompt""": """A field of roses""",
               """generator""": generator,
               """num_inference_steps""": 3,
               """guidance_scale""": 7.5,
               """output_type""": """numpy""",
           }
           return inputs

       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase          =						"""CompVis/stable-diffusion-v1-4"""
           __lowercase          =						StableDiffusionModelEditingPipeline.from_pretrained(lowerCamelCase__ ,		safety_checker=lowerCamelCase__					)
           pipe.to(lowerCamelCase__					)
           pipe.set_progress_bar_config(disable=lowerCamelCase__					)
           pipe.enable_attention_slicing()

           __lowercase          =						self.get_inputs()
           __lowercase          =						pipe(**lowerCamelCase__					).images
           __lowercase          =						image[0, -3:, -3:, -1].flatten()

           assert image.shape == (1, 512, 512, 3)

           __lowercase          =						np.array(
               [0.6_74_94_96, 0.6_38_64_53, 0.51_44_32_67, 0.66_09_49_05, 0.61_92_12_15, 0.5_49_13_32, 0.5_74_44_17, 0.58_07_51_06, 0.5_17_46_58]					)

           assert np.abs(expected_slice - image_slice					).max() < 1E-2

           # make sure image changes after editing
           pipe.edit_model("""A pack of roses""" ,		"""A pack of blue roses"""					)

           __lowercase          =						pipe(**lowerCamelCase__					).images
           __lowercase          =						image[0, -3:, -3:, -1].flatten()

           assert image.shape == (1, 512, 512, 3)

           assert np.abs(expected_slice - image_slice					).max() > 1E-1




       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



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

           __lowercase          =						"""CompVis/stable-diffusion-v1-4"""
           __lowercase          =						DDIMScheduler.from_pretrained(lowerCamelCase__ ,		subfolder="""scheduler"""					)
           __lowercase          =						StableDiffusionModelEditingPipeline.from_pretrained(
               lowerCamelCase__ ,		scheduler=lowerCamelCase__ ,		safety_checker=lowerCamelCase__					)
           __lowercase          =						pipe.to(lowerCamelCase__					)
           pipe.set_progress_bar_config(disable=lowerCamelCase__					)
           pipe.enable_attention_slicing(1					)
           pipe.enable_sequential_cpu_offload()

           __lowercase          =						self.get_inputs()
           __lowercase          =						pipe(**lowerCamelCase__					)

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










'''simple docstring'''
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


A							:				Dict			     =	"""Here is a text containing a lot of information: '''{text}'''.

Can you answer this question about the text: '{question}'"""






class 	SCREAMING_SNAKE_CASE(    __A					):
       snake_case_			:					List[Any]   = """google/flan-t5-base"""
       snake_case_			:					int   = (
           """This is a tool that answers questions related to a text. It takes two arguments named `text`, which is the """
           """text where to find the answer, and `question`, which is the question, and returns the answer to the question."""
       )
       snake_case_			:					Optional[int]   = """text_qa"""
       snake_case_			:					List[Any]   = AutoTokenizer
       snake_case_			:					List[str]   = AutoModelForSeqaSeqLM

       snake_case_			:					int   = ["""text""", """text"""]
       snake_case_			:					Dict   = ["""text"""]

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> Optional[int]:

           """simple docstring"""



           __lowercase          =						QA_PROMPT.format(text=lowerCamelCase__ ,		question=lowerCamelCase__					)
           return self.pre_processor(lowerCamelCase__ ,		return_tensors="""pt"""					)

       def    snake_case__      (   self ,		lowerCamelCase__					)   -> int:

           """simple docstring"""



           __lowercase          =						self.model.generate(**lowerCamelCase__					)

           __lowercase    ,__lowercase          =						inputs["""input_ids"""].shape
           __lowercase          =						output_ids.shape[0]

           return output_ids.reshape(lowerCamelCase__ ,		out_b // in_b ,		*output_ids.shape[1:]					)[0][0]




       def    snake_case__      (   self ,		lowerCamelCase__					)   -> Tuple:

           """simple docstring"""



           return self.pre_processor.decode(lowerCamelCase__ ,		skip_special_tokens=lowerCamelCase__ ,		clean_up_tokenization_spaces=lowerCamelCase__					)




