
"""simple docstring"""





from manim import *






class     _UpperCAmelCase(    lowerCamelCase	):



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  Rectangle(height=0.5				,		width=0.5)
							_UpperCamelCase							 =  Rectangle(height=0.46				,		width=0.46).set_stroke(width=0)

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

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

							self.add(__a)

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

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

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

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

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

							_UpperCamelCase							 =  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(__a				,		run_time=2.5)				,		Write(__a)				,		Write(__a))

							self.add(__a)

							_UpperCamelCase							 =  []
							_UpperCamelCase							 =  []
							_UpperCamelCase							 =  []
							for i, rect in enumerate(__a):
												_UpperCamelCase							 =  Rectangle(height=0.46				,		width=0.46).set_stroke(width=0.0).set_fill(__a				,		opacity=0.7)
												cpu_target.move_to(__a)
												cpu_target.generate_target()
												_UpperCamelCase							 =  0.46 / 4
												_UpperCamelCase							 =  0.46 / 3

												if i == 0:
																	cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)				,		buff=0.02				,		direction=__a)
																	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=__a				,		buff=0.0)
												else:
																	cpu_target.target.next_to(cpu_targs[i - 1].target				,		direction=__a				,		buff=0.0)
												cpu_targs.append(__a)

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

							self.play(*__a)
							self.play(*__a)

							self.wait()











"""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 							_UpperCAmelCase							( a		,a		,unittest.TestCase      ):





     '''simple docstring'''



     a__									=IFImgaImgSuperResolutionPipeline
     a__									=TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
     a__									=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}      )
     a__									=PipelineTesterMixin.required_optional_params - {'''latents'''}





     def  __lowerCAmelCase	(					self		)							->					List[str]:
         return self._get_superresolution_dummy_components()





     def  __lowerCAmelCase	(					self       ,	A       ,	A=0		)							->					Union[str, Any]:
         if str(A		).startswith('''mps'''		):
             _UpperCAmelCase							:  Any											=    torch.manual_seed(A		)
         else:
             _UpperCAmelCase							:  int											=    torch.Generator(device=A		).manual_seed(A		)

         _UpperCAmelCase							:  str											=    floats_tensor((1, 3, 3_2, 3_2)       ,	rng=random.Random(A		)		).to(A		)
         _UpperCAmelCase							:  Dict											=    floats_tensor((1, 3, 1_6, 1_6)       ,	rng=random.Random(A		)		).to(A		)

         _UpperCAmelCase							:  List[Any]											=    {
             '''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  __lowerCAmelCase	(					self		)							->					List[Any]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)





     def  __lowerCAmelCase	(					self		)							->					List[str]:
         self._test_save_load_optional_components()





     @unittest.skipIf(torch_device != '''cuda'''       ,	reason='''float16 requires CUDA'''		)
     def  __lowerCAmelCase	(					self		)							->					Optional[Any]:
         # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
         super().test_save_load_floataa(expected_max_diff=1E-1		)





     def  __lowerCAmelCase	(					self		)							->					int:
         self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)





     def  __lowerCAmelCase	(					self		)							->					Union[str, Any]:
         self._test_save_load_local()





     def  __lowerCAmelCase	(					self		)							->					Union[str, Any]:
         self._test_inference_batch_single_identical(
             expected_max_diff=1E-2       ,	)


