
"""simple docstring"""



import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin





@skip_mps
class 					lowerCAmelCase			(				UpperCAmelCase__     ,						UpperCAmelCase__     ,						unittest.TestCase					):
     """simple docstring"""







     __lowercase						:Tuple          =    IFPipeline
     __lowercase						:Optional[int]          =    TEXT_TO_IMAGE_PARAMS - {"width", "height", "latents"}
     __lowercase						:Optional[int]          =    TEXT_TO_IMAGE_BATCH_PARAMS
     __lowercase						:List[str]          =    PipelineTesterMixin.required_optional_params - {"latents"}




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







            '''simple docstring'''





            return self._get_dummy_components()




     def    _lowerCAmelCase		(      self ,		UpperCamelCase__ ,		UpperCamelCase__=0							)					->  List[Any]:







            '''simple docstring'''





            if str(_a							).startswith('''mps'''							):
                   lowerCamelCase_       							=		torch.manual_seed(_a							)
            else:
                   lowerCamelCase_       							=		torch.Generator(device=_a							).manual_seed(_a							)

            lowerCamelCase_       							=		{
                '''prompt''': '''A painting of a squirrel eating a burger''',
                '''generator''': generator,
                '''num_inference_steps''': 2,
                '''output_type''': '''numpy''',
            }

            return inputs




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







            '''simple docstring'''





            self._test_save_load_optional_components()




     @unittest.skipIf(torch_device != '''cuda''' ,		reason='''float16 requires CUDA'''							)
     def    _lowerCAmelCase		(      self							)					->  Dict:







            '''simple docstring'''





            super().test_save_load_floataa(expected_max_diff=1e-1							)




     def    _lowerCAmelCase		(      self							)					->  Any:







            '''simple docstring'''





            self._test_attention_slicing_forward_pass(expected_max_diff=1e-2							)




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







            '''simple docstring'''





            self._test_save_load_local()




     def    _lowerCAmelCase		(      self							)					->  Optional[Any]:







            '''simple docstring'''





            self._test_inference_batch_single_identical(
                expected_max_diff=1e-2 ,		)




     @unittest.skipIf(
         torch_device != '''cuda''' or not is_xformers_available() ,		reason='''XFormers attention is only available with CUDA and `xformers` installed''' ,		)
     def    _lowerCAmelCase		(      self							)					->  Optional[int]:







            '''simple docstring'''





            self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3							)





@slow
@require_torch_gpu
class 					lowerCAmelCase			(				unittest.TestCase					):
     """simple docstring"""







     def    _lowerCAmelCase		(      self							)					->  Dict:







            '''simple docstring'''





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




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







            '''simple docstring'''





            lowerCamelCase_       							=		IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0''' ,		variant='''fp16''' ,		torch_dtype=torch.floataa							)

            lowerCamelCase_       							=		IFSuperResolutionPipeline.from_pretrained(
                '''DeepFloyd/IF-II-L-v1.0''' ,		variant='''fp16''' ,		torch_dtype=torch.floataa ,		text_encoder=_a ,		tokenizer=_a							)

            # pre compute text embeddings and remove T5 to save memory

            pipe_a.text_encoder.to('''cuda'''							)

            lowerCamelCase_							,							lowerCamelCase_       							=		pipe_a.encode_prompt('''anime turtle''' ,		device='''cuda'''							)

            del pipe_a.tokenizer
            del pipe_a.text_encoder
            gc.collect()

            lowerCamelCase_       							=		None
            lowerCamelCase_       							=		None

            pipe_a.enable_model_cpu_offload()
            pipe_a.enable_model_cpu_offload()

            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)
            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)

            self._test_if(_a ,		_a ,		_a ,		_a							)

            pipe_a.remove_all_hooks()
            pipe_a.remove_all_hooks()

            # img2img

            lowerCamelCase_       							=		IFImgaImgPipeline(**pipe_a.components							)
            lowerCamelCase_       							=		IFImgaImgSuperResolutionPipeline(**pipe_a.components							)

            pipe_a.enable_model_cpu_offload()
            pipe_a.enable_model_cpu_offload()

            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)
            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)

            self._test_if_imgaimg(_a ,		_a ,		_a ,		_a							)

            pipe_a.remove_all_hooks()
            pipe_a.remove_all_hooks()

            # inpainting

            lowerCamelCase_       							=		IFInpaintingPipeline(**pipe_a.components							)
            lowerCamelCase_       							=		IFInpaintingSuperResolutionPipeline(**pipe_a.components							)

            pipe_a.enable_model_cpu_offload()
            pipe_a.enable_model_cpu_offload()

            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)
            pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()							)

            self._test_if_inpainting(_a ,		_a ,		_a ,		_a							)




     def    _lowerCAmelCase		(      self ,		UpperCamelCase__ ,		UpperCamelCase__ ,		UpperCamelCase__ ,		UpperCamelCase__							)					->  List[Any]:







            '''simple docstring'''





            _start_torch_memory_measurement()

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)
            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		num_inference_steps=2 ,		generator=_a ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

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

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 13 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)

            # pipeline 2

            _start_torch_memory_measurement()

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)

            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(0							)							).to(_a							)

            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		image=_a ,		generator=_a ,		num_inference_steps=2 ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

            assert image.shape == (256, 256, 3)

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 4 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)




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







            '''simple docstring'''





            _start_torch_memory_measurement()

            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(0							)							).to(_a							)

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)

            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		image=_a ,		num_inference_steps=2 ,		generator=_a ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

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

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 10 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)

            # pipeline 2

            _start_torch_memory_measurement()

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)

            lowerCamelCase_       							=		floats_tensor((1, 3, 256, 256) ,		rng=random.Random(0							)							).to(_a							)
            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(0							)							).to(_a							)

            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		image=_a ,		original_image=_a ,		generator=_a ,		num_inference_steps=2 ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

            assert image.shape == (256, 256, 3)

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 4 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)




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







            '''simple docstring'''





            _start_torch_memory_measurement()

            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(0							)							).to(_a							)
            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(1							)							).to(_a							)

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)
            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		image=_a ,		mask_image=_a ,		num_inference_steps=2 ,		generator=_a ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

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

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 10 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)

            # pipeline 2

            _start_torch_memory_measurement()

            lowerCamelCase_       							=		torch.Generator(device='''cpu'''							).manual_seed(0							)

            lowerCamelCase_       							=		floats_tensor((1, 3, 64, 64) ,		rng=random.Random(0							)							).to(_a							)
            lowerCamelCase_       							=		floats_tensor((1, 3, 256, 256) ,		rng=random.Random(0							)							).to(_a							)
            lowerCamelCase_       							=		floats_tensor((1, 3, 256, 256) ,		rng=random.Random(1							)							).to(_a							)

            lowerCamelCase_       							=		pipe_a(
                prompt_embeds=_a ,		negative_prompt_embeds=_a ,		image=_a ,		mask_image=_a ,		original_image=_a ,		generator=_a ,		num_inference_steps=2 ,		output_type='''np''' ,		)

            lowerCamelCase_       							=		output.images[0]

            assert image.shape == (256, 256, 3)

            lowerCamelCase_       							=		torch.cuda.max_memory_allocated()
            assert mem_bytes < 4 * 10**9

            lowerCamelCase_       							=		load_numpy(
                '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'''							)
            assert_mean_pixel_difference(_a ,		_a							)



def lowerCamelCase_				(     ):
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()





"""simple docstring"""




from collections.abc import Sequence



def        a__					(							snake_case__			,					snake_case__ = False							)		->   float:
			if not arr:
						return 0

			lowerCamelCase      =   0 if allow_empty_subarrays else float("""-inf"""							)
			lowerCamelCase      =   0.0
			for num in arr:
						lowerCamelCase      =   max(0 if allow_empty_subarrays else num			,					curr_sum + num							)
						lowerCamelCase      =   max(snake_case__			,					snake_case__							)

			return max_sum


if __name__ == "__main__":
					from doctest import testmod

					testmod()

					lowerCAmelCase				:     Union[str, Any]					=				[-2, 1, -3, 4, -1, 2, 1, -5, 4]
					print(F"""{max_subarray_sum(nums) = }""")



