





import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
					from test_module.custom_tokenization_fast import CustomTokenizerFast

class 							__SCREAMING_SNAKE_CASE       (  unittest.TestCase							):






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      0






							@slow
							def 					_lowerCamelCase		(    self	):
														for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
																					self.assertIsNotNone(__lowerCAmelCase	)
																					self.assertIsInstance(__lowerCAmelCase	,			(BertTokenizer, BertTokenizerFast)	)
																					self.assertGreater(len(__lowerCAmelCase	)	,			0	)

														for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
																					self.assertIsNotNone(__lowerCAmelCase	)
																					self.assertIsInstance(__lowerCAmelCase	,			(GPTaTokenizer, GPTaTokenizerFast)	)
																					self.assertGreater(len(__lowerCAmelCase	)	,			0	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
														self.assertIsInstance(__lowerCAmelCase	,			(BertTokenizer, BertTokenizerFast)	)
														self.assertEqual(tokenizer.vocab_size	,			12	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
														self.assertIsInstance(__lowerCAmelCase	,			(RobertaTokenizer, RobertaTokenizerFast)	)
														self.assertEqual(tokenizer.vocab_size	,			20	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoConfig.from_pretrained(__lowerCAmelCase	)
														self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)
														# Check that tokenizer_type ≠ model_type
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			config=__lowerCAmelCase	)
														self.assertIsInstance(__lowerCAmelCase	,			(BertTokenizer, BertTokenizerFast)	)
														self.assertEqual(tokenizer.vocab_size	,			12	)






							def 					_lowerCamelCase		(    self	):
														with tempfile.TemporaryDirectory() as tmp_dir:
																					shutil.copy("""./tests/fixtures/vocab.txt"""	,			os.path.join(__lowerCAmelCase	,			"""vocab.txt"""	)	)

																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			tokenizer_type="""bert"""	,			use_fast=__lowerCAmelCase	)
																					self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)

														with tempfile.TemporaryDirectory() as tmp_dir:
																					shutil.copy("""./tests/fixtures/vocab.json"""	,			os.path.join(__lowerCAmelCase	,			"""vocab.json"""	)	)
																					shutil.copy("""./tests/fixtures/merges.txt"""	,			os.path.join(__lowerCAmelCase	,			"""merges.txt"""	)	)

																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			tokenizer_type="""gpt2"""	,			use_fast=__lowerCAmelCase	)
																					self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														with tempfile.TemporaryDirectory() as tmp_dir:
																					shutil.copy("""./tests/fixtures/vocab.txt"""	,			os.path.join(__lowerCAmelCase	,			"""vocab.txt"""	)	)

																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			tokenizer_type="""bert"""	)
																					self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)

														with tempfile.TemporaryDirectory() as tmp_dir:
																					shutil.copy("""./tests/fixtures/vocab.json"""	,			os.path.join(__lowerCAmelCase	,			"""vocab.json"""	)	)
																					shutil.copy("""./tests/fixtures/merges.txt"""	,			os.path.join(__lowerCAmelCase	,			"""merges.txt"""	)	)

																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			tokenizer_type="""gpt2"""	)
																					self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														with pytest.raises(__lowerCAmelCase	):
																					AutoTokenizer.from_pretrained("""./"""	,			tokenizer_type="""xxx"""	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
																					UpperCamelCase__					  =      tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""	)
																					self.assertIsInstance(__lowerCAmelCase	,			(BertTokenizer, BertTokenizerFast)	)

																					if isinstance(__lowerCAmelCase	,			__lowerCAmelCase	):
																												self.assertEqual(tokenizer.basic_tokenizer.do_lower_case	,			__lowerCAmelCase	)
																					else:
																												self.assertEqual(tokenizer.do_lower_case	,			__lowerCAmelCase	)

																					self.assertEqual(tokenizer.model_max_length	,			512	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
																					with self.assertRaisesRegex(
																					    __lowerCAmelCase	,			"""julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""	,			):
																												UpperCamelCase__					  =      tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""	)






							def 					_lowerCamelCase		(    self	):
														# tests: https://github.com/huggingface/transformers/pull/13251
														# 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
														# 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
														UpperCamelCase__					  =      TOKENIZER_MAPPING.values()
														UpperCamelCase__					  =      []

														for slow_tok, fast_tok in tokenizers:
																					if slow_tok is not None:
																												tokenizer_names.append(slow_tok.__name__	)

																					if fast_tok is not None:
																												tokenizer_names.append(fast_tok.__name__	)

														for tokenizer_name in tokenizer_names:
																					# must find the right class
																					tokenizer_class_from_name(__lowerCAmelCase	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""	,			use_fast=__lowerCAmelCase	)	,			__lowerCAmelCase	)
														self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""	)	,			__lowerCAmelCase	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""distilbert-base-uncased"""	,			do_lower_case=__lowerCAmelCase	)
														UpperCamelCase__					  =      """Hello, world. How are you?"""
														UpperCamelCase__					  =      tokenizer.tokenize(__lowerCAmelCase	)
														self.assertEqual("""[UNK]"""	,			tokens[0]	)

														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""	,			do_lower_case=__lowerCAmelCase	)
														UpperCamelCase__					  =      tokenizer.tokenize(__lowerCAmelCase	)
														self.assertEqual("""[UNK]"""	,			tokens[0]	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""	)
														self.assertEqual(type(__lowerCAmelCase	)	,			__lowerCAmelCase	)
														self.assertEqual(tokenizer.model_max_length	,			512	)
														self.assertEqual(tokenizer.vocab_size	,			30000	)
														self.assertEqual(tokenizer.unk_token	,			"""[UNK]"""	)
														self.assertEqual(tokenizer.padding_side	,			"""right"""	)
														self.assertEqual(tokenizer.truncation_side	,			"""right"""	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
														self.assertIsInstance(__lowerCAmelCase	,			(BertTokenizer, BertTokenizerFast)	)
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tokenizer.save_pretrained(__lowerCAmelCase	)
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)

														self.assertIsInstance(__lowerCAmelCase	,			tokenizer.__class__	)
														self.assertEqual(tokenizera.vocab_size	,			12	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""ctrl"""	)
														# There is no fast CTRL so this always gives us a slow tokenizer.
														self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														# Check we can load the tokenizer config of an online model.
														UpperCamelCase__					  =      get_tokenizer_config("""bert-base-cased"""	)
														UpperCamelCase__					  =      config.pop("""_commit_hash"""	,			__lowerCAmelCase	)
														# If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
														self.assertEqual(__lowerCAmelCase	,			{"""do_lower_case""": False}	)

														# This model does not have a tokenizer_config so we get back an empty dict.
														UpperCamelCase__					  =      get_tokenizer_config(__lowerCAmelCase	)
														self.assertDictEqual(__lowerCAmelCase	,			{}	)

														# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tokenizer.save_pretrained(__lowerCAmelCase	)
																					UpperCamelCase__					  =      get_tokenizer_config(__lowerCAmelCase	)

														# Check the class of the tokenizer was properly saved (note that it always saves the slow class).
														self.assertEqual(config["""tokenizer_class"""]	,			"""BertTokenizer"""	)






							def 					_lowerCamelCase		(    self	):
														try:
																					AutoConfig.register("""custom"""	,			__lowerCAmelCase	)

																					AutoTokenizer.register(__lowerCAmelCase	,			slow_tokenizer_class=__lowerCAmelCase	)
																					# Trying to register something existing in the Transformers library will raise an error
																					with self.assertRaises(__lowerCAmelCase	):
																												AutoTokenizer.register(__lowerCAmelCase	,			slow_tokenizer_class=__lowerCAmelCase	)

																					UpperCamelCase__					  =      CustomTokenizer.from_pretrained(__lowerCAmelCase	)
																					with tempfile.TemporaryDirectory() as tmp_dir:
																												tokenizer.save_pretrained(__lowerCAmelCase	)

																												UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
																												self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in TOKENIZER_MAPPING._extra_content:
																												del TOKENIZER_MAPPING._extra_content[CustomConfig]






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														try:
																					AutoConfig.register("""custom"""	,			__lowerCAmelCase	)

																					# Can register in two steps
																					AutoTokenizer.register(__lowerCAmelCase	,			slow_tokenizer_class=__lowerCAmelCase	)
																					self.assertEqual(TOKENIZER_MAPPING[CustomConfig]	,			(CustomTokenizer, None)	)
																					AutoTokenizer.register(__lowerCAmelCase	,			fast_tokenizer_class=__lowerCAmelCase	)
																					self.assertEqual(TOKENIZER_MAPPING[CustomConfig]	,			(CustomTokenizer, CustomTokenizerFast)	)

																					del TOKENIZER_MAPPING._extra_content[CustomConfig]
																					# Can register in one step
																					AutoTokenizer.register(
																					    __lowerCAmelCase	,			slow_tokenizer_class=__lowerCAmelCase	,			fast_tokenizer_class=__lowerCAmelCase	)
																					self.assertEqual(TOKENIZER_MAPPING[CustomConfig]	,			(CustomTokenizer, CustomTokenizerFast)	)

																					# Trying to register something existing in the Transformers library will raise an error
																					with self.assertRaises(__lowerCAmelCase	):
																												AutoTokenizer.register(__lowerCAmelCase	,			fast_tokenizer_class=__lowerCAmelCase	)

																					# We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
																					# and that model does not have a tokenizer.json
																					with tempfile.TemporaryDirectory() as tmp_dir:
																												UpperCamelCase__					  =      BertTokenizerFast.from_pretrained(__lowerCAmelCase	)
																												bert_tokenizer.save_pretrained(__lowerCAmelCase	)
																												UpperCamelCase__					  =      CustomTokenizerFast.from_pretrained(__lowerCAmelCase	)

																					with tempfile.TemporaryDirectory() as tmp_dir:
																												tokenizer.save_pretrained(__lowerCAmelCase	)

																												UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	)
																												self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)

																												UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																												self.assertIsInstance(__lowerCAmelCase	,			__lowerCAmelCase	)

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in TOKENIZER_MAPPING._extra_content:
																												del TOKENIZER_MAPPING._extra_content[CustomConfig]






							def 					_lowerCamelCase		(    self	):
														# If remote code is not set, we will time out when asking whether to load the model.
														with self.assertRaises(__lowerCAmelCase	):
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""	)
														# If remote code is disabled, we can't load this config.
														with self.assertRaises(__lowerCAmelCase	):
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	)

														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	)
														self.assertTrue(tokenizer.special_attribute_present	)
														# Test tokenizer can be reloaded.
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tokenizer.save_pretrained(__lowerCAmelCase	)
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			trust_remote_code=__lowerCAmelCase	)
														self.assertTrue(reloaded_tokenizer.special_attribute_present	)

														if is_tokenizers_available():
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)
																					self.assertEqual(reloaded_tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)

																					# Test we can also load the slow version
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																					self.assertTrue(tokenizer.special_attribute_present	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					# Test tokenizer can be reloaded.
																					with tempfile.TemporaryDirectory() as tmp_dir:
																												tokenizer.save_pretrained(__lowerCAmelCase	)
																												UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			trust_remote_code=__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																					self.assertEqual(reloaded_tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					self.assertTrue(reloaded_tokenizer.special_attribute_present	)
														else:
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					self.assertEqual(reloaded_tokenizer.__class__.__name__	,			"""NewTokenizer"""	)






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):

														class 							__SCREAMING_SNAKE_CASE       (  _a							):
																					snake_case  :   List[str]      =							False






														class 							__SCREAMING_SNAKE_CASE       (  _a							):
																					snake_case  :   Dict      =							NewTokenizer
																					snake_case  :   List[Any]      =							False

														try:
																					AutoConfig.register("""custom"""	,			__lowerCAmelCase	)
																					AutoTokenizer.register(__lowerCAmelCase	,			slow_tokenizer_class=__lowerCAmelCase	)
																					AutoTokenizer.register(__lowerCAmelCase	,			fast_tokenizer_class=__lowerCAmelCase	)
																					# If remote code is not set, the default is to use local
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)
																					self.assertFalse(tokenizer.special_attribute_present	)
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""	,			use_fast=__lowerCAmelCase	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					self.assertFalse(tokenizer.special_attribute_present	)

																					# If remote code is disabled, we load the local one.
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)
																					self.assertFalse(tokenizer.special_attribute_present	)
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					self.assertFalse(tokenizer.special_attribute_present	)

																					# If remote is enabled, we load from the Hub
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)
																					self.assertTrue(tokenizer.special_attribute_present	)
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer"""	,			trust_remote_code=__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
																					self.assertTrue(tokenizer.special_attribute_present	)

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in TOKENIZER_MAPPING._extra_content:
																												del TOKENIZER_MAPPING._extra_content[CustomConfig]






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
														    """hf-internal-testing/test_dynamic_tokenizer_legacy"""	,			trust_remote_code=__lowerCAmelCase	)
														self.assertTrue(tokenizer.special_attribute_present	)
														if is_tokenizers_available():
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizerFast"""	)

																					# Test we can also load the slow version
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(
																					    """hf-internal-testing/test_dynamic_tokenizer_legacy"""	,			trust_remote_code=__lowerCAmelCase	,			use_fast=__lowerCAmelCase	)
																					self.assertTrue(tokenizer.special_attribute_present	)
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)
														else:
																					self.assertEqual(tokenizer.__class__.__name__	,			"""NewTokenizer"""	)






							def 					_lowerCamelCase		(    self	):
														with self.assertRaisesRegex(
														    __lowerCAmelCase	,			"""bert-base is not a local folder and is not a valid model identifier"""	):
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""bert-base"""	)






							def 					_lowerCamelCase		(    self	):
														with self.assertRaisesRegex(
														    __lowerCAmelCase	,			r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""	):
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained(__lowerCAmelCase	,			revision="""aaaaaa"""	)







							def 					_lowerCamelCase		(    self	):
														# Make sure we have cached the tokenizer.
														UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""	)
														with RequestCounter() as counter:
																					UpperCamelCase__					  =      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""	)
																					self.assertEqual(counter.get_request_count	,			0	)
																					self.assertEqual(counter.head_request_count	,			1	)
																					self.assertEqual(counter.other_request_count	,			0	)











from manim import *

class 							__SCREAMING_SNAKE_CASE       (  _a							):






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      Rectangle(height=0.5	,			width=0.5	)
														UpperCamelCase__					  =      Rectangle(height=0.25	,			width=0.25	)
														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(4	)]
														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.move_to([-1, -1, 0]	)
														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.add(__lowerCAmelCase	)

														UpperCamelCase__					  =      []
														UpperCamelCase__					  =      []
														UpperCamelCase__					  =      []

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

																					UpperCamelCase__					  =      Rectangle(height=0.46 / 4	,			width=0.46 / 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.02	,			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	)

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

														UpperCamelCase__					  =      Text("""Loaded Checkpoint"""	,			font_size=24	)
														UpperCamelCase__					  =      Group(__lowerCAmelCase	,			__lowerCAmelCase	).arrange(__lowerCAmelCase	,			buff=0.5	,			aligned_edge=__lowerCAmelCase	)
														checkpoint.move_to([3, 0.5, 0]	)

														self.add(__lowerCAmelCase	)

														UpperCamelCase__					  =      []
														UpperCamelCase__					  =      []

														for i, rect in enumerate(__lowerCAmelCase	):
																					UpperCamelCase__					  =      fill.copy().set_fill(__lowerCAmelCase	,			opacity=0.7	)
																					target.move_to(__lowerCAmelCase	)
																					ckpt_arr.append(__lowerCAmelCase	)

																					UpperCamelCase__					  =      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	)

														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]	)

														self.add(__lowerCAmelCase	,			__lowerCAmelCase	)

														UpperCamelCase__					  =      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	)

														UpperCamelCase__					  =      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]	)

														UpperCamelCase__					  =      [meta_mem.copy() for i in range(6	)]
														UpperCamelCase__					  =      [meta_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("""Disk"""	,			font_size=24	)
														UpperCamelCase__					  =      Group(__lowerCAmelCase	,			__lowerCAmelCase	).arrange(__lowerCAmelCase	,			buff=0.5	,			aligned_edge=__lowerCAmelCase	)
														disk.move_to([-4.0, -1.25, 0]	)
														self.play(Write(__lowerCAmelCase	,			run_time=3	)	,			Write(__lowerCAmelCase	,			run_time=1	)	,			Create(__lowerCAmelCase	,			run_time=1	)	)

														UpperCamelCase__					  =      []
														for i, rect in enumerate(__lowerCAmelCase	):
																					UpperCamelCase__					  =      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	)	)

														UpperCamelCase__					  =      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()




