


from manim import *
class 				SCREAMING_SNAKE_CASE__						(       __lowerCamelCase    ):
      def  SCREAMING_SNAKE_CASE							( self       : Union[str, Any]  )	->    Tuple:
             a_      :	Tuple							=						Rectangle(height=0.5  ,							width=0.5  )
             a_      :	Dict							=						Rectangle(height=0.46  ,							width=0.46  ).set_stroke(width=0  )

             a_      :	List[Any]							=						Rectangle(height=0.25  ,							width=0.25  )

             a_      :	List[Any]							=						[mem.copy() for i in range(6  )]
             a_      :	Optional[int]							=						[mem.copy() for i in range(6  )]
             a_      :	int							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	Tuple							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	str							=						VGroup(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	List[Any]							=						Text('CPU'  ,							font_size=2_4  )
             a_      :	Optional[int]							=						Group(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0.5  ,							aligned_edge=UpperCamelCase_  )
             cpu.move_to([-2.5, -0.5, 0]  )
             self.add(UpperCamelCase_  )

             a_      :	Optional[int]							=						[mem.copy() for i in range(4  )]
             a_      :	List[str]							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	List[str]							=						Text('GPU'  ,							font_size=2_4  )
             a_      :	int							=						Group(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0.5  ,							aligned_edge=UpperCamelCase_  )
             gpu.move_to([-1, -1, 0]  )
             self.add(UpperCamelCase_  )

             a_      :	Tuple							=						[mem.copy() for i in range(6  )]
             a_      :	Tuple							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )

             a_      :	int							=						Text('Model'  ,							font_size=2_4  )
             a_      :	List[Any]							=						Group(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0.5  ,							aligned_edge=UpperCamelCase_  )
             model.move_to([3, -1.0, 0]  )
             self.add(UpperCamelCase_  )

             a_      :	List[str]							=						[]
             a_      :	Optional[int]							=						[]

             for i, rect in enumerate(UpperCamelCase_  ):
                    a_      :	Any							=						fill.copy().set_fill(UpperCamelCase_  ,							opacity=0.8  )
                    target.move_to(UpperCamelCase_  )
                    model_arr.append(UpperCamelCase_  )

                    a_      :	Tuple							=						Rectangle(height=0.46  ,							width=0.46  ).set_stroke(width=0.0  ).set_fill(UpperCamelCase_  ,							opacity=0.8  )
                    cpu_target.move_to(cpu_left_col_base[i]  )
                    model_cpu_arr.append(UpperCamelCase_  )

             self.add(*UpperCamelCase_  ,							*UpperCamelCase_  )

             a_      :	Optional[Any]							=						[meta_mem.copy() for i in range(6  )]
             a_      :	int							=						[meta_mem.copy() for i in range(6  )]
             a_      :	Optional[int]							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	Union[str, Any]							=						VGroup(*UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	List[str]							=						VGroup(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0  )
             a_      :	List[Any]							=						Text('Disk'  ,							font_size=2_4  )
             a_      :	Dict							=						Group(UpperCamelCase_  ,							UpperCamelCase_  ).arrange(UpperCamelCase_  ,							buff=0.5  ,							aligned_edge=UpperCamelCase_  )
             disk.move_to([-4, -1.25, 0]  )
             self.add(UpperCamelCase_  ,							UpperCamelCase_  )

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

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

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

             self.add(UpperCamelCase_  ,							UpperCamelCase_  )

             a_      :	Union[str, Any]							=						MarkupText(
                 F"""<span fgcolor=\'{BLUE}\'>●</span> Checkpoint"""  ,							font_size=1_8  ,							)

             blue_text.next_to(UpperCamelCase_  ,							DOWN * 2.4  ,							aligned_edge=key_text.get_left()  )
             self.add(UpperCamelCase_  )

             a_      :	Optional[int]							=						MarkupText(
                 F"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""  ,							font_size=2_4  ,							)
             step_a.move_to([2, 2, 0]  )

             self.play(Write(UpperCamelCase_  )  )

             a_      :	Tuple							=						Square(0.3  )
             input.set_fill(UpperCamelCase_  ,							opacity=1.0  )
             input.set_stroke(width=0.0  )
             input.next_to(model_base[0]  ,							UpperCamelCase_  ,							buff=0.5  )

             self.play(Write(UpperCamelCase_  )  )

             input.generate_target()
             input.target.next_to(model_arr[0]  ,							direction=UpperCamelCase_  ,							buff=0.02  )
             self.play(MoveToTarget(UpperCamelCase_  )  )

             self.play(FadeOut(UpperCamelCase_  )  )

             a_      :	Optional[int]							=						Arrow(start=UpperCamelCase_  ,							end=UpperCamelCase_  ,							color=UpperCamelCase_  ,							buff=0.5  )
             a.next_to(model_arr[0].get_left()  ,							UpperCamelCase_  ,							buff=0.2  )

             model_cpu_arr[0].generate_target()
             model_cpu_arr[0].target.move_to(gpu_rect[0]  )

             a_      :	str							=						MarkupText(
                 F"""As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."""  ,							font_size=2_4  ,							)
             step_a.move_to([2, 2, 0]  )

             self.play(Write(UpperCamelCase_  ,							run_time=3  )  )

             a_      :	Optional[int]							=						{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

             self.play(
                 Write(UpperCamelCase_  )  ,							Circumscribe(model_arr[0]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(model_cpu_arr[0]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(gpu_rect[0]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							)
             self.play(MoveToTarget(model_cpu_arr[0]  )  )

             a_      :	Tuple							=						a.copy()
             for i in range(6  ):
                    a_c.next_to(model_arr[i].get_right() + 0.02  ,							UpperCamelCase_  ,							buff=0.2  )

                    input.generate_target()
                    input.target.move_to(model_arr[i].get_right() + 0.02  )

                    a_      :	Tuple							=						AnimationGroup(
                        FadeOut(UpperCamelCase_  ,							run_time=0.5  )  ,							MoveToTarget(UpperCamelCase_  ,							run_time=0.5  )  ,							FadeIn(UpperCamelCase_  ,							run_time=0.5  )  ,							lag_ratio=0.2  )

                    self.play(UpperCamelCase_  )

                    model_cpu_arr[i].generate_target()
                    model_cpu_arr[i].target.move_to(cpu_left_col_base[i]  )

                    if i < 5:
                           model_cpu_arr[i + 1].generate_target()
                           model_cpu_arr[i + 1].target.move_to(gpu_rect[0]  )
                           if i >= 1:
                                  a_      :	List[Any]							=						0.7

                           self.play(
                               Circumscribe(model_arr[i]  ,							**UpperCamelCase_  )  ,							Circumscribe(cpu_left_col_base[i]  ,							**UpperCamelCase_  )  ,							Circumscribe(cpu_left_col_base[i + 1]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(gpu_rect[0]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(model_arr[i + 1]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							)
                           if i < 1:
                                  self.play(
                                      MoveToTarget(model_cpu_arr[i]  )  ,							MoveToTarget(model_cpu_arr[i + 1]  )  ,							)
                           else:
                                  self.play(
                                      MoveToTarget(model_cpu_arr[i]  ,							run_time=0.7  )  ,							MoveToTarget(model_cpu_arr[i + 1]  ,							run_time=0.7  )  ,							)
                    else:
                           model_cpu_arr[i].generate_target()
                           model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]  )
                           input.generate_target()
                           input.target.next_to(model_arr[-1].get_right()  ,							RIGHT + 0.02  ,							buff=0.2  )

                           self.play(
                               Circumscribe(model_arr[-1]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(cpu_left_col_base[-1]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							Circumscribe(gpu_rect[0]  ,							color=UpperCamelCase_  ,							**UpperCamelCase_  )  ,							)

                           self.play(MoveToTarget(model_cpu_arr[i]  )  )

                    a_      :	Dict							=						a_c
                    a_      :	Dict							=						a_c.copy()

             input.generate_target()
             input.target.next_to(model_base[-1]  ,							RIGHT + 0.02  ,							buff=0.5  )
             self.play(
                 FadeOut(UpperCamelCase_  )  ,							FadeOut(UpperCamelCase_  ,							run_time=0.5  )  ,							)

             a_      :	List[Any]							=						MarkupText(F"""Inference on a model too large for GPU memory\nis successfully completed."""  ,							font_size=2_4  )
             step_a.move_to([2, 2, 0]  )

             self.play(Write(UpperCamelCase_  ,							run_time=3  )  ,							MoveToTarget(UpperCamelCase_  )  )

             self.wait()






import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property
@unittest.skipUnless(os.path.exists(lowercase__    )		,					'''Tatoeba directory does not exist.'''    )
class 				SCREAMING_SNAKE_CASE__						(       unittest.TestCase    ):
      @cached_property
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    List[Any]:
             a_      :	Optional[Any]							=						tempfile.mkdtemp()
             return TatoebaConverter(save_dir=SCREAMING_SNAKE_CASE__  )
      @slow
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    Optional[Any]:
             self.resolver.convert_models(['heb-eng']  )

      @slow
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    Any:
             a_							,	a_      :	Dict							=						self.resolver.write_model_card('opus-mt-he-en'  ,							dry_run=SCREAMING_SNAKE_CASE__  )
             assert mmeta["long_pair"] == "heb-eng"


