


'''simple docstring'''

import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class       a__				( _SCREAMING_SNAKE_CASE							,						_SCREAMING_SNAKE_CASE							,						unittest.TestCase      ):







				"""simple docstring"""



				__UpperCamelCase    :		Optional[int]	=	IFImgaImgSuperResolutionPipeline
				__UpperCamelCase    :		Union[str, Any]	=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
				__UpperCamelCase    :		List[str]	=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}      )
				__UpperCamelCase    :		Any	=	PipelineTesterMixin.required_optional_params - {"latents"}




				def 					_snake_case  (self		):
										return self._get_superresolution_dummy_components()




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase=0		):
										if str(A_		).startswith('''mps'''		):
																__lowerCAmelCase							       =				torch.manual_seed(A_		)
										else:
																__lowerCAmelCase							       =				torch.Generator(device=A_		).manual_seed(A_		)

										__lowerCAmelCase							       =				floats_tensor((1, 3, 32, 32)       ,			rng=random.Random(A_		)		).to(A_		)
										__lowerCAmelCase							       =				floats_tensor((1, 3, 16, 16)       ,			rng=random.Random(A_		)		).to(A_		)

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

										return inputs




				@unittest.skipIf(
				    torch_device != '''cuda''' or not is_xformers_available()       ,			reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,			)
				def 					_snake_case  (self		):
										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3		)




				def 					_snake_case  (self		):
										self._test_save_load_optional_components()




				@unittest.skipIf(torch_device != '''cuda'''       ,			reason='''float16 requires CUDA'''		)
				def 					_snake_case  (self		):
										super().test_save_load_floataa(expected_max_diff=1e-1		)




				def 					_snake_case  (self		):
										self._test_attention_slicing_forward_pass(expected_max_diff=1e-2		)




				def 					_snake_case  (self		):
										self._test_save_load_local()




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





'''simple docstring'''

from manim import *


class       a__				( __A      ):







				"""simple docstring"""



				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				Rectangle(height=0.5       ,			width=0.5		)
										__lowerCAmelCase							       =				Rectangle(height=0.4_6       ,			width=0.4_6		).set_stroke(width=0		)

										__lowerCAmelCase							       =				[mem.copy() for i in range(6		)]
										__lowerCAmelCase							       =				[mem.copy() for i in range(6		)]
										__lowerCAmelCase							       =				VGroup(*__lowercase		).arrange(__lowercase       ,			buff=0		)
										__lowerCAmelCase							       =				VGroup(*__lowercase		).arrange(__lowercase       ,			buff=0		)
										__lowerCAmelCase							       =				VGroup(__lowercase       ,			__lowercase		).arrange(__lowercase       ,			buff=0		)
										__lowerCAmelCase							       =				Text('''CPU'''       ,			font_size=24		)
										__lowerCAmelCase							       =				Group(__lowercase       ,			__lowercase		).arrange(__lowercase       ,			buff=0.5       ,			aligned_edge=__lowercase		)
										cpu.move_to([-2.5, -0.5, 0]		)
										self.add(__lowercase		)

										__lowerCAmelCase							       =				[mem.copy() for i in range(1		)]
										__lowerCAmelCase							       =				VGroup(*__lowercase		).arrange(__lowercase       ,			buff=0		)
										__lowerCAmelCase							       =				Text('''GPU'''       ,			font_size=24		)
										__lowerCAmelCase							       =				Group(__lowercase       ,			__lowercase		).arrange(__lowercase       ,			buff=0.5       ,			aligned_edge=__lowercase		)
										gpu.align_to(__lowercase       ,			__lowercase		)
										gpu.set_x(gpu.get_x() - 1		)

										self.add(__lowercase		)

										__lowerCAmelCase							       =				[mem.copy() for i in range(6		)]
										__lowerCAmelCase							       =				VGroup(*__lowercase		).arrange(__lowercase       ,			buff=0		)

										__lowerCAmelCase							       =				Text('''Model'''       ,			font_size=24		)
										__lowerCAmelCase							       =				Group(__lowercase       ,			__lowercase		).arrange(__lowercase       ,			buff=0.5       ,			aligned_edge=__lowercase		)
										model.move_to([3, -1.0, 0]		)

										self.play(
										    Create(__lowercase       ,			run_time=1		)       ,			Create(__lowercase       ,			run_time=1		)       ,			Create(__lowercase       ,			run_time=1		)       ,			)

										__lowerCAmelCase							       =				MarkupText(
										    F"""First, an empty model skeleton is loaded\ninto <span fgcolor='{YELLOW}'>memory</span> without using much RAM."""       ,			font_size=24       ,			)

										__lowerCAmelCase							       =				Square(side_length=2.2		)
										key.move_to([-5, 2, 0]		)

										__lowerCAmelCase							       =				MarkupText(
										    F"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""       ,			font_size=18       ,			)

										key_text.move_to([-5, 2.4, 0]		)

										step_a.move_to([2, 2, 0]		)
										self.play(Write(__lowercase       ,			run_time=2.5		)       ,			Write(__lowercase		)       ,			Write(__lowercase		)		)

										self.add(__lowercase		)

										__lowerCAmelCase							       =				[]
										__lowerCAmelCase							       =				[]
										__lowerCAmelCase							       =				[]
										for i, rect in enumerate(__lowercase		):
																__lowerCAmelCase							       =				Rectangle(height=0.4_6       ,			width=0.4_6		).set_stroke(width=0.0		).set_fill(__lowercase       ,			opacity=0.7		)
																cpu_target.move_to(__lowercase		)
																cpu_target.generate_target()
																__lowerCAmelCase							       =				0.4_6 / 4
																__lowerCAmelCase							       =				0.4_6 / 3

																if i == 0:
																						cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT		)       ,			buff=0.0_2       ,			direction=__lowercase		)
																						cpu_target.target.set_x(cpu_target.target.get_x() + 0.1		)
																elif i == 3:
																						cpu_target.target.next_to(cpu_targs[0].target       ,			direction=__lowercase       ,			buff=0.0		)
																else:
																						cpu_target.target.next_to(cpu_targs[i - 1].target       ,			direction=__lowercase       ,			buff=0.0		)
																cpu_targs.append(__lowercase		)

																first_animations.append(rect.animate(run_time=0.5		).set_stroke(__lowercase		)		)
																second_animations.append(MoveToTarget(__lowercase       ,			run_time=1.5		)		)

										self.play(*__lowercase		)
										self.play(*__lowercase		)

										self.wait()

