'''simple docstring'''

import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


__a:			Tuple	       =       get_tests_dir("""fixtures/test_sentencepiece.model""")

if is_torch_available():
  from transformers.models.mbart.modeling_mbart import shift_tokens_right

__a:			List[str]	       =       25_00_04
__a:			List[str]	       =       25_00_20



@require_sentencepiece
@require_tokenizers
class       UpperCAmelCase  (						a__   ,						unittest.TestCase ):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE 		=   MBartaaTokenizer
       SCREAMING_SNAKE_CASE 		=   MBartaaTokenizerFast
       SCREAMING_SNAKE_CASE 		=   True
       SCREAMING_SNAKE_CASE 		=   True

       def _lowerCAmelCase(						self			)  ->  List[str]:
        super().setUp()

        # We have a SentencePiece fixture for testing
        lowercase__    :   Optional[int]						= MBartaaTokenizer(__lowerCAmelCase     ,       src_lang='''en_XX'''     ,       tgt_lang='''ro_RO'''     ,       keep_accents=__lowerCAmelCase			)
        tokenizer.save_pretrained(self.tmpdirname			)

       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   str						= '''<s>'''
        lowercase__    :   Dict						= 0

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCAmelCase			)     ,       __lowerCAmelCase			)
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCAmelCase			)     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  Dict:
        lowercase__    :   int						= list(self.get_tokenizer().get_vocab().keys()			)

        self.assertEqual(vocab_keys[0]     ,       '''<s>'''			)
        self.assertEqual(vocab_keys[1]     ,       '''<pad>'''			)
        self.assertEqual(vocab_keys[-1]     ,       '''<mask>'''			)
        self.assertEqual(len(__lowerCAmelCase			)     ,       1054			)

       def _lowerCAmelCase(						self			)  ->  str:
        self.assertEqual(self.get_tokenizer().vocab_size     ,       1054			)

       def _lowerCAmelCase(						self			)  ->  Dict:
        lowercase__    :   str						= MBartaaTokenizer(__lowerCAmelCase     ,       src_lang='''en_XX'''     ,       tgt_lang='''ro_RO'''     ,       keep_accents=__lowerCAmelCase			)

        lowercase__    :   Any						= tokenizer.tokenize('''This is a test'''			)
        self.assertListEqual(__lowerCAmelCase     ,       ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']			)

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(__lowerCAmelCase			)     ,       [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]     ,       )

        lowercase__    :   Tuple						= tokenizer.tokenize('''I was born in 92000, and this is falsé.'''			)
        self.assertListEqual(
            __lowerCAmelCase     ,       [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.''']     ,       )
        lowercase__    :   str						= tokenizer.convert_tokens_to_ids(__lowerCAmelCase			)
        self.assertListEqual(
            __lowerCAmelCase     ,       [
                value + tokenizer.fairseq_offset
                for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
            ]     ,       )

        lowercase__    :   Union[str, Any]						= tokenizer.convert_ids_to_tokens(__lowerCAmelCase			)
        self.assertListEqual(
            __lowerCAmelCase     ,       [SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.''']     ,       )

       @slow
       def _lowerCAmelCase(						self			)  ->  int:
        # fmt: off
        lowercase__    :   str						= {'''input_ids''': [[250004, 11062, 82772, 7, 15, 82772, 538, 51529, 237, 17198, 1290, 206, 9, 215175, 1314, 136, 17198, 1290, 206, 9, 56359, 42, 122009, 9, 16466, 16, 87344, 4537, 9, 4717, 78381, 6, 159958, 7, 15, 24480, 618, 4, 527, 22693, 5428, 4, 2777, 24480, 9874, 4, 43523, 594, 4, 803, 18392, 33189, 18, 4, 43523, 24447, 12399, 100, 24955, 83658, 9626, 144057, 15, 839, 22335, 16, 136, 24955, 83658, 83479, 15, 39102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 122009, 115774, 23, 805, 1328, 46876, 7, 136, 53894, 1940, 42227, 41159, 17721, 823, 425, 4, 27512, 98722, 206, 136, 5531, 4970, 919, 17336, 5, 2], [250004, 20080, 618, 83, 82775, 47, 479, 9, 1517, 73, 53894, 333, 80581, 110117, 18811, 5256, 1295, 51, 152526, 297, 7986, 390, 124416, 538, 35431, 214, 98, 15044, 25737, 136, 7108, 43701, 23, 756, 135355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250004, 581, 63773, 119455, 6, 147797, 88203, 7, 645, 70, 21, 3285, 10269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__lowerCAmelCase     ,       model_name='''facebook/mbart-large-50'''     ,       revision='''d3913889c59cd5c9e456b269c376325eabad57e2'''     ,       )


       def _lowerCAmelCase(						self			)  ->  Optional[int]:
        if not self.test_slow_tokenizer:
         # as we don't have a slow version, we can't compare the outputs between slow and fast versions
         return

        lowercase__    :   int						= (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {})
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
          lowercase__    :   Any						= self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase     ,       **__lowerCAmelCase			)
          lowercase__    :   Tuple						= self.tokenizer_class.from_pretrained(__lowerCAmelCase     ,       **__lowerCAmelCase			)

          lowercase__    :   Union[str, Any]						= tempfile.mkdtemp()

          lowercase__    :   List[str]						= tokenizer_r.save_pretrained(__lowerCAmelCase			)
          lowercase__    :   Any						= tokenizer_p.save_pretrained(__lowerCAmelCase			)

          # Checks it save with the same files + the tokenizer.json file for the fast one
          self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files			)			)
          lowercase__    :   str						= tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f			)
          self.assertSequenceEqual(__lowerCAmelCase     ,       __lowerCAmelCase			)

          # Checks everything loads correctly in the same way
          lowercase__    :   Optional[int]						= tokenizer_r.from_pretrained(__lowerCAmelCase			)
          lowercase__    :   List[str]						= tokenizer_p.from_pretrained(__lowerCAmelCase			)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(__lowerCAmelCase     ,       __lowerCAmelCase			)			)
           # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
           # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

          shutil.rmtree(__lowerCAmelCase			)

          # Save tokenizer rust, legacy_format=True
          lowercase__    :   List[Any]						= tempfile.mkdtemp()

          lowercase__    :   str						= tokenizer_r.save_pretrained(__lowerCAmelCase     ,       legacy_format=__lowerCAmelCase			)
          lowercase__    :   Optional[Any]						= tokenizer_p.save_pretrained(__lowerCAmelCase			)

          # Checks it save with the same files
          self.assertSequenceEqual(__lowerCAmelCase     ,       __lowerCAmelCase			)

          # Checks everything loads correctly in the same way
          lowercase__    :   Union[str, Any]						= tokenizer_r.from_pretrained(__lowerCAmelCase			)
          lowercase__    :   int						= tokenizer_p.from_pretrained(__lowerCAmelCase			)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(__lowerCAmelCase     ,       __lowerCAmelCase			)			)

          shutil.rmtree(__lowerCAmelCase			)

          # Save tokenizer rust, legacy_format=False
          lowercase__    :   Any						= tempfile.mkdtemp()

          lowercase__    :   List[Any]						= tokenizer_r.save_pretrained(__lowerCAmelCase     ,       legacy_format=__lowerCAmelCase			)
          lowercase__    :   Dict						= tokenizer_p.save_pretrained(__lowerCAmelCase			)

          # Checks it saved the tokenizer.json file
          self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files			)			)

          # Checks everything loads correctly in the same way
          lowercase__    :   Optional[Any]						= tokenizer_r.from_pretrained(__lowerCAmelCase			)
          lowercase__    :   Dict						= tokenizer_p.from_pretrained(__lowerCAmelCase			)

          # Check special tokens are set accordingly on Rust and Python
          for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(__lowerCAmelCase     ,       __lowerCAmelCase			)			)

          shutil.rmtree(__lowerCAmelCase			)



@require_torch
@require_sentencepiece
@require_tokenizers
class       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE 		=   "facebook/mbart-large-50-one-to-many-mmt"
       SCREAMING_SNAKE_CASE 		=   [
           " UN Chief Says There Is No Military Solution in Syria",
           " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
       ]
       SCREAMING_SNAKE_CASE 		=   [
           "Şeful ONU declară că nu există o soluţie militară în Siria",
           "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
           " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
           " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
       ]
       SCREAMING_SNAKE_CASE 		=   [EN_CODE, 8_2_7_4, 1_2_7_8_7_3, 2_5_9_1_6, 7, 8_6_2_2, 2_0_7_1, 4_3_8, 6_7_4_8_5, 5_3, 1_8_7_8_9_5, 2_3, 5_1_7_1_2, 2]

       @classmethod
       def _lowerCAmelCase(						cls			)  ->  int:
        lowercase__    :   MBartaaTokenizer						= MBartaaTokenizer.from_pretrained(
            cls.checkpoint_name     ,       src_lang='''en_XX'''     ,       tgt_lang='''ro_RO'''			)
        lowercase__    :   Union[str, Any]						= 1
        return cls

       def _lowerCAmelCase(						self			)  ->  Dict:
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR''']     ,       250001			)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN''']     ,       250004			)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO''']     ,       250020			)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN''']     ,       250038			)

       def _lowerCAmelCase(						self			)  ->  Optional[int]:
        lowercase__    :   Union[str, Any]						= self.tokenizer.batch_encode_plus(self.src_text			).input_ids[0]
        self.assertListEqual(self.expected_src_tokens     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  str:
        self.assertIn(__lowerCAmelCase     ,       self.tokenizer.all_special_ids			)
        lowercase__    :   Any						= [RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2]
        lowercase__    :   int						= self.tokenizer.decode(__lowerCAmelCase     ,       skip_special_tokens=__lowerCAmelCase			)
        lowercase__    :   Tuple						= self.tokenizer.decode(generated_ids[1:]     ,       skip_special_tokens=__lowerCAmelCase			)
        self.assertEqual(__lowerCAmelCase     ,       __lowerCAmelCase			)
        self.assertNotIn(self.tokenizer.eos_token     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   Optional[Any]						= ['''this is gunna be a long sentence ''' * 20]
        assert isinstance(src_text[0]     ,       __lowerCAmelCase			)
        lowercase__    :   Optional[Any]						= 10
        lowercase__    :   List[str]						= self.tokenizer(__lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       truncation=__lowerCAmelCase			).input_ids[0]
        self.assertEqual(ids[0]     ,       __lowerCAmelCase			)
        self.assertEqual(ids[-1]     ,       2			)
        self.assertEqual(len(__lowerCAmelCase			)     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  Dict:
        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']			)     ,       [250053, 250001]			)

       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Tuple						= tempfile.mkdtemp()
        lowercase__    :   Dict						= self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(__lowerCAmelCase			)
        lowercase__    :   Union[str, Any]						= MBartaaTokenizer.from_pretrained(__lowerCAmelCase			)
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids     ,       __lowerCAmelCase			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   Optional[Any]						= self.tokenizer(self.src_text     ,       text_target=self.tgt_text     ,       padding=__lowerCAmelCase     ,       return_tensors='''pt'''			)
        lowercase__    :   Union[str, Any]						= shift_tokens_right(batch['''labels''']     ,       self.tokenizer.pad_token_id			)

        # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
        assert batch.input_ids[1][0] == EN_CODE
        assert batch.input_ids[1][-1] == 2
        assert batch.labels[1][0] == RO_CODE
        assert batch.labels[1][-1] == 2
        assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]

       @require_torch
       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   Tuple						= self.tokenizer(
            self.src_text     ,       text_target=self.tgt_text     ,       padding=__lowerCAmelCase     ,       truncation=__lowerCAmelCase     ,       max_length=len(self.expected_src_tokens			)     ,       return_tensors='''pt'''     ,       )
        lowercase__    :   Optional[int]						= shift_tokens_right(batch['''labels''']     ,       self.tokenizer.pad_token_id			)

        self.assertIsInstance(__lowerCAmelCase     ,       __lowerCAmelCase			)

        self.assertEqual((2, 14)     ,       batch.input_ids.shape			)
        self.assertEqual((2, 14)     ,       batch.attention_mask.shape			)
        lowercase__    :   List[str]						= batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens     ,       __lowerCAmelCase			)
        self.assertEqual(2     ,       batch.decoder_input_ids[0, 0]			)  # decoder_start_token_id
        # Test that special tokens are reset
        self.assertEqual(self.tokenizer.prefix_tokens     ,       [EN_CODE]			)
        self.assertEqual(self.tokenizer.suffix_tokens     ,       [self.tokenizer.eos_token_id]			)

       def _lowerCAmelCase(						self			)  ->  List[str]:
        lowercase__    :   Dict						= self.tokenizer(self.src_text     ,       padding=__lowerCAmelCase     ,       truncation=__lowerCAmelCase     ,       max_length=3     ,       return_tensors='''pt'''			)
        lowercase__    :   List[str]						= self.tokenizer(
            text_target=self.tgt_text     ,       padding=__lowerCAmelCase     ,       truncation=__lowerCAmelCase     ,       max_length=10     ,       return_tensors='''pt'''			)
        lowercase__    :   str						= targets['''input_ids''']
        lowercase__    :   str						= shift_tokens_right(__lowerCAmelCase     ,       self.tokenizer.pad_token_id			)

        self.assertEqual(batch.input_ids.shape[1]     ,       3			)
        self.assertEqual(batch.decoder_input_ids.shape[1]     ,       10			)


       @require_torch
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   Tuple						= self.tokenizer._build_translation_inputs(
            '''A test'''     ,       return_tensors='''pt'''     ,       src_lang='''en_XX'''     ,       tgt_lang='''ar_AR'''			)

        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       {
                # en_XX, A, test, EOS
                '''input_ids''': [[250004, 62, 3034, 2]],
                '''attention_mask''': [[1, 1, 1, 1]],
                # ar_AR
                '''forced_bos_token_id''': 250001,
            }     ,       )


'''simple docstring'''

from manim import *



class       UpperCAmelCase  (						a__ ):





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						= Rectangle(height=0.5     ,       width=0.5			)
        lowercase__    :   Optional[int]						= Rectangle(height=0.2_5     ,       width=0.2_5			)
        lowercase__    :   Tuple						= Rectangle(height=0.4_6     ,       width=0.4_6			).set_stroke(width=0			)

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

        lowercase__    :   Any						= [mem.copy() for i in range(4			)]
        lowercase__    :   int						= VGroup(*__lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0			)
        lowercase__    :   Optional[int]						= Text('''GPU'''     ,       font_size=24			)
        lowercase__    :   Tuple						= Group(__lowerCAmelCase     ,       __lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0.5     ,       aligned_edge=__lowerCAmelCase			)
        gpu.move_to([-1, -1, 0]			)
        self.add(__lowerCAmelCase			)

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

        lowercase__    :   Any						= Text('''Model'''     ,       font_size=24			)
        lowercase__    :   Optional[Any]						= Group(__lowerCAmelCase     ,       __lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0.5     ,       aligned_edge=__lowerCAmelCase			)
        model.move_to([3, -1.0, 0]			)
        self.add(__lowerCAmelCase			)

        lowercase__    :   int						= []
        lowercase__    :   int						= []
        lowercase__    :   Any						= []

        for i, rect in enumerate(__lowerCAmelCase			):
         rect.set_stroke(__lowerCAmelCase			)

         lowercase__    :   Optional[int]						= Rectangle(height=0.4_6 / 4     ,       width=0.4_6 / 3			).set_stroke(width=0.0			).set_fill(__lowerCAmelCase     ,       opacity=0.7			)

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

        self.add(*__lowerCAmelCase     ,       *__lowerCAmelCase     ,       *__lowerCAmelCase			)

        lowercase__    :   Optional[int]						= [mem.copy() for i in range(6			)]
        lowercase__    :   List[Any]						= VGroup(*__lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0			)

        lowercase__    :   Optional[Any]						= Text('''Loaded Checkpoint'''     ,       font_size=24			)
        lowercase__    :   Dict						= Group(__lowerCAmelCase     ,       __lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0.5     ,       aligned_edge=__lowerCAmelCase			)
        checkpoint.move_to([3, 0.5, 0]			)

        self.add(__lowerCAmelCase			)

        lowercase__    :   str						= []
        lowercase__    :   List[str]						= []

        for i, rect in enumerate(__lowerCAmelCase			):
         lowercase__    :   List[str]						= fill.copy().set_fill(__lowerCAmelCase     ,       opacity=0.7			)
         target.move_to(__lowerCAmelCase			)
         ckpt_arr.append(__lowerCAmelCase			)

         lowercase__    :   Any						= target.copy()
         if i < 5:
          cpu_target.move_to(cpu_left_col_base[i + 1]			)
         else:
          cpu_target.move_to(cpu_right_col_base[i - 5]			)
         ckpt_cpu_arr.append(__lowerCAmelCase			)
        self.add(*__lowerCAmelCase     ,       *__lowerCAmelCase			)

        lowercase__    :   Optional[int]						= Square(side_length=2.2			)
        key.move_to([-5, 2, 0]			)

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

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

        self.add(__lowerCAmelCase     ,       __lowerCAmelCase			)

        lowercase__    :   str						= MarkupText(
            F"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""     ,       font_size=18     ,       )

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

        lowercase__    :   Union[str, Any]						= MarkupText(
            F"""Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device."""     ,       font_size=24     ,       )
        step_a.move_to([2, 2, 0]			)

        lowercase__    :   Tuple						= [meta_mem.copy() for i in range(6			)]
        lowercase__    :   Any						= [meta_mem.copy() for i in range(6			)]
        lowercase__    :   str						= VGroup(*__lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0			)
        lowercase__    :   Any						= VGroup(*__lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0			)
        lowercase__    :   Union[str, Any]						= VGroup(__lowerCAmelCase     ,       __lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0			)
        lowercase__    :   Union[str, Any]						= Text('''Disk'''     ,       font_size=24			)
        lowercase__    :   Tuple						= Group(__lowerCAmelCase     ,       __lowerCAmelCase			).arrange(__lowerCAmelCase     ,       buff=0.5     ,       aligned_edge=__lowerCAmelCase			)
        disk.move_to([-4.0, -1.2_5, 0]			)
        self.play(Write(__lowerCAmelCase     ,       run_time=3			)     ,       Write(__lowerCAmelCase     ,       run_time=1			)     ,       Create(__lowerCAmelCase     ,       run_time=1			)			)

        lowercase__    :   Tuple						= []
        for i, rect in enumerate(__lowerCAmelCase			):
         lowercase__    :   Dict						= rect.copy()
         target.generate_target()
         target.target.move_to(disk_left_col_base[i]			).scale(0.5			)
         animations.append(MoveToTarget(__lowerCAmelCase     ,       run_time=1.5			)			)
        self.play(*__lowerCAmelCase			)

        self.play(FadeOut(__lowerCAmelCase			)			)

        lowercase__    :   Dict						= MarkupText(F"""Then, the checkpoint is removed from memory\nthrough garbage collection."""     ,       font_size=24			)
        step_a.move_to([2, 2, 0]			)

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

        self.play(
            FadeOut(__lowerCAmelCase     ,       __lowerCAmelCase     ,       *__lowerCAmelCase     ,       *__lowerCAmelCase			)     ,       )

        self.wait()

