





'''simple docstring'''

from manim import *
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""





       def snake_case__						(							self       :		Dict					)   ->					Tuple:

            '''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(*lowerCAmelCase__					).arrange(lowerCAmelCase__	,			buff=0					)
            _UpperCamelCase       =	VGroup(*lowerCAmelCase__					).arrange(lowerCAmelCase__	,			buff=0					)
            _UpperCamelCase       =	VGroup(lowerCAmelCase__	,			lowerCAmelCase__					).arrange(lowerCAmelCase__	,			buff=0					)
            _UpperCamelCase       =	Text('''CPU'''	,			font_size=24					)
            _UpperCamelCase       =	Group(lowerCAmelCase__	,			lowerCAmelCase__					).arrange(lowerCAmelCase__	,			buff=0.5	,			aligned_edge=lowerCAmelCase__					)
            cpu.move_to([-2.5, -0.5, 0]					)
            self.add(lowerCAmelCase__					)

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

            self.add(lowerCAmelCase__					)

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

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

            self.play(
                Create(lowerCAmelCase__	,			run_time=1					)	,			Create(lowerCAmelCase__	,			run_time=1					)	,			Create(lowerCAmelCase__	,			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(lowerCAmelCase__	,			run_time=2.5					)	,			Write(lowerCAmelCase__					)	,			Write(lowerCAmelCase__					)					)

            self.add(lowerCAmelCase__					)

            _UpperCamelCase       =	[]
            _UpperCamelCase       =	[]
            _UpperCamelCase       =	[]
            for i, rect in enumerate(lowerCAmelCase__					):
                 _UpperCamelCase       =	Rectangle(height=0.46	,			width=0.46					).set_stroke(width=0.0					).set_fill(lowerCAmelCase__	,			opacity=0.7					)
                 cpu_target.move_to(lowerCAmelCase__					)
                 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=lowerCAmelCase__					)
                      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=lowerCAmelCase__	,			buff=0.0					)
                 else:
                      cpu_target.target.next_to(cpu_targs[i - 1].target	,			direction=lowerCAmelCase__	,			buff=0.0					)
                 cpu_targs.append(lowerCAmelCase__					)

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

            self.play(*lowerCAmelCase__					)
            self.play(*lowerCAmelCase__					)

            self.wait()










'''simple docstring'''

import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def snake_case__						(							self       :		Tuple					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.bin''',
                '''safety_checker/model.safetensors''',
                '''vae/diffusion_pytorch_model.bin''',
                '''vae/diffusion_pytorch_model.safetensors''',
                '''text_encoder/pytorch_model.bin''',
                '''text_encoder/model.safetensors''',
                '''unet/diffusion_pytorch_model.bin''',
                '''unet/diffusion_pytorch_model.safetensors''',
            ]
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__					)					)





       def snake_case__						(							self       :		int					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''unet/diffusion_pytorch_model.bin''',
                '''unet/diffusion_pytorch_model.safetensors''',
            ]
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.bin''',
                '''safety_checker/model.safetensors''',
                '''vae/diffusion_pytorch_model.bin''',
                '''vae/diffusion_pytorch_model.safetensors''',
                '''text_encoder/pytorch_model.bin''',
                '''text_encoder/model.safetensors''',
                '''unet/diffusion_pytorch_model.bin''',
                # Removed: 'unet/diffusion_pytorch_model.safetensors',
            ]
            self.assertFalse(is_safetensors_compatible(lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''text_encoder/pytorch_model.bin''',
                '''text_encoder/model.safetensors''',
            ]
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__					)					)





       def snake_case__						(							self       :		Dict					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.bin''',
                '''safety_checker/model.safetensors''',
                '''vae/diffusion_pytorch_model.bin''',
                '''vae/diffusion_pytorch_model.safetensors''',
                '''text_encoder/pytorch_model.bin''',
                # Removed: 'text_encoder/model.safetensors',
                '''unet/diffusion_pytorch_model.bin''',
                '''unet/diffusion_pytorch_model.safetensors''',
            ]
            self.assertFalse(is_safetensors_compatible(lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.fp16.bin''',
                '''safety_checker/model.fp16.safetensors''',
                '''vae/diffusion_pytorch_model.fp16.bin''',
                '''vae/diffusion_pytorch_model.fp16.safetensors''',
                '''text_encoder/pytorch_model.fp16.bin''',
                '''text_encoder/model.fp16.safetensors''',
                '''unet/diffusion_pytorch_model.fp16.bin''',
                '''unet/diffusion_pytorch_model.fp16.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)





       def snake_case__						(							self       :		Optional[Any]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''unet/diffusion_pytorch_model.fp16.bin''',
                '''unet/diffusion_pytorch_model.fp16.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''unet/diffusion_pytorch_model.bin''',
                '''unet/diffusion_pytorch_model.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.fp16.bin''',
                '''safety_checker/model.fp16.safetensors''',
                '''vae/diffusion_pytorch_model.fp16.bin''',
                '''vae/diffusion_pytorch_model.fp16.safetensors''',
                '''text_encoder/pytorch_model.fp16.bin''',
                '''text_encoder/model.fp16.safetensors''',
                '''unet/diffusion_pytorch_model.fp16.bin''',
                # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertFalse(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''text_encoder/pytorch_model.fp16.bin''',
                '''text_encoder/model.fp16.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)





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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''text_encoder/pytorch_model.bin''',
                '''text_encoder/model.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertTrue(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)







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

            '''simple docstring'''




            _UpperCamelCase       =	[
                '''safety_checker/pytorch_model.fp16.bin''',
                '''safety_checker/model.fp16.safetensors''',
                '''vae/diffusion_pytorch_model.fp16.bin''',
                '''vae/diffusion_pytorch_model.fp16.safetensors''',
                '''text_encoder/pytorch_model.fp16.bin''',
                # 'text_encoder/model.fp16.safetensors',
                '''unet/diffusion_pytorch_model.fp16.bin''',
                '''unet/diffusion_pytorch_model.fp16.safetensors''',
            ]
            _UpperCamelCase       =	'''fp16'''
            self.assertFalse(is_safetensors_compatible(lowerCAmelCase__	,			variant=lowerCAmelCase__					)					)



