





import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test





class 					A_					(   unittest.TestCase						):







       """simple docstring"""





       @parameterized.expand([(None,), ('foo.json',)]	)
       def  __UpperCAmelCase			(     self						:						Any    ,__A						:						Any	)    ->       Optional[Any]:
         _lowercase						    =			GenerationConfig(
             do_sample=__A    ,temperature=0.7    ,length_penalty=1.0    ,bad_words_ids=[[1, 2, 3], [4, 5]]    ,)
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(__A    ,config_name=__A	)
           _lowercase						    =			GenerationConfig.from_pretrained(__A    ,config_name=__A	)

         # Checks parameters that were specified
         self.assertEqual(loaded_config.do_sample    ,__A	)
         self.assertEqual(loaded_config.temperature    ,0.7	)
         self.assertEqual(loaded_config.length_penalty    ,1.0	)
         self.assertEqual(loaded_config.bad_words_ids    ,[[1, 2, 3], [4, 5]]	)

         # Checks parameters that were not specified (defaults)
         self.assertEqual(loaded_config.top_k    ,50	)
         self.assertEqual(loaded_config.max_length    ,20	)
         self.assertEqual(loaded_config.max_time    ,__A	)







       def  __UpperCAmelCase			(     self						:						int	)    ->       List[str]:
         _lowercase						    =			AutoConfig.from_pretrained('gpt2'	)
         _lowercase						    =			GenerationConfig.from_model_config(__A	)
         _lowercase						    =			GenerationConfig()

         # The generation config has loaded a few non-default parameters from the model config
         self.assertNotEqual(__A    ,__A	)

         # One of those parameters is eos_token_id -- check if it matches
         self.assertNotEqual(generation_config_from_model.eos_token_id    ,default_generation_config.eos_token_id	)
         self.assertEqual(generation_config_from_model.eos_token_id    ,model_config.eos_token_id	)







       def  __UpperCAmelCase			(     self						:						Optional[int]	)    ->       Any:
         _lowercase						    =			GenerationConfig()
         _lowercase						    =			{
             'max_new_tokens': 1024,
             'foo': 'bar',
         }
         _lowercase						    =			copy.deepcopy(__A	)
         _lowercase						    =			generation_config.update(**__A	)

         # update_kwargs was not modified (no side effects)
         self.assertEqual(__A    ,__A	)

         # update_kwargs was used to update the config on valid attributes
         self.assertEqual(generation_config.max_new_tokens    ,1024	)

         # `.update()` returns a dictionary of unused kwargs
         self.assertEqual(__A    ,{'foo': 'bar'}	)







       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       List[Any]:
         _lowercase						    =			GenerationConfig()
         _lowercase						    =			'bar'

         with tempfile.TemporaryDirectory('test-generation-config'	) as tmp_dir:
           generation_config.save_pretrained(__A	)

           _lowercase						    =			GenerationConfig.from_pretrained(__A	)
         # update_kwargs was used to update the config on valid attributes
         self.assertEqual(new_config.foo    ,'bar'	)

         _lowercase						    =			GenerationConfig.from_model_config(__A	)
         assert not hasattr(__A    ,'foo'	)  # no new kwargs should be initialized if from config







       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       Dict:
         _lowercase						    =			GenerationConfig()
         self.assertEqual(default_config.temperature    ,1.0	)
         self.assertEqual(default_config.do_sample    ,__A	)
         self.assertEqual(default_config.num_beams    ,1	)

         _lowercase						    =			GenerationConfig(
             do_sample=__A    ,temperature=0.7    ,length_penalty=1.0    ,bad_words_ids=[[1, 2, 3], [4, 5]]    ,)
         self.assertEqual(config.temperature    ,0.7	)
         self.assertEqual(config.do_sample    ,__A	)
         self.assertEqual(config.num_beams    ,1	)

         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(__A	)
           _lowercase						    =			GenerationConfig.from_pretrained(__A    ,temperature=1.0	)

         self.assertEqual(loaded_config.temperature    ,1.0	)
         self.assertEqual(loaded_config.do_sample    ,__A	)
         self.assertEqual(loaded_config.num_beams    ,1	)  # default value





@is_staging_test
class 					A_					(   unittest.TestCase						):







       """simple docstring"""





       @classmethod
       def  __UpperCAmelCase			(     cls						:						Optional[Any]	)    ->       Optional[int]:
         _lowercase						    =			TOKEN
         HfFolder.save_token(__A	)







       @classmethod
       def  __UpperCAmelCase			(     cls						:						List[str]	)    ->       Union[str, Any]:
         try:
           delete_repo(token=cls._token    ,repo_id='test-generation-config'	)
         except HTTPError:
           pass

         try:
           delete_repo(token=cls._token    ,repo_id='valid_org/test-generation-config-org'	)
         except HTTPError:
           pass







       def  __UpperCAmelCase			(     self						:						Tuple	)    ->       List[Any]:
         _lowercase						    =			GenerationConfig(
             do_sample=__A    ,temperature=0.7    ,length_penalty=1.0    ,)
         config.push_to_hub('test-generation-config'    ,use_auth_token=self._token	)

         _lowercase						    =			GenerationConfig.from_pretrained(F"""{USER}/test-generation-config"""	)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(__A    ,getattr(__A    ,__A	)	)

        # Reset repo
         delete_repo(token=self._token    ,repo_id='test-generation-config'	)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(
               __A    ,repo_id='test-generation-config'    ,push_to_hub=__A    ,use_auth_token=self._token	)

         _lowercase						    =			GenerationConfig.from_pretrained(F"""{USER}/test-generation-config"""	)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(__A    ,getattr(__A    ,__A	)	)







       def  __UpperCAmelCase			(     self						:						Optional[int]	)    ->       Tuple:
         _lowercase						    =			GenerationConfig(
             do_sample=__A    ,temperature=0.7    ,length_penalty=1.0    ,)
         config.push_to_hub('valid_org/test-generation-config-org'    ,use_auth_token=self._token	)

         _lowercase						    =			GenerationConfig.from_pretrained('valid_org/test-generation-config-org'	)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(__A    ,getattr(__A    ,__A	)	)

        # Reset repo
         delete_repo(token=self._token    ,repo_id='valid_org/test-generation-config-org'	)

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(
               __A    ,repo_id='valid_org/test-generation-config-org'    ,push_to_hub=__A    ,use_auth_token=self._token	)

         _lowercase						    =			GenerationConfig.from_pretrained('valid_org/test-generation-config-org'	)
         for k, v in config.to_dict().items():
           if k != "transformers_version":
             self.assertEqual(__A    ,getattr(__A    ,__A	)	)



'''simple docstring'''
from manim import *




class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE):


				'''simple docstring'''


				def 	a__		(     self							)    ->  List[str]:
					lowercase						:		List[Any]   					=		Rectangle(height=0.5							,      width=0.5							)
					lowercase						:		str   					=		Rectangle(height=0.25							,      width=0.25							)
					lowercase						:		Union[str, Any]   					=		Rectangle(height=0.46							,      width=0.46							).set_stroke(width=0							)

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

					lowercase						:		List[Any]   					=		[mem.copy() for i in range(4							)]
					lowercase						:		Union[str, Any]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Dict   					=		Text("GPU"							,      font_size=2_4							)
					lowercase						:		Tuple   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					gpu.move_to([-1, -1, 0]							)
					self.add(a_							)

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

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

					lowercase						:		Dict   					=		[]
					lowercase						:		Tuple   					=		[]
					lowercase						:		List[Any]   					=		[]

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

						lowercase						:		Tuple   					=		Rectangle(height=0.46 / 4							,      width=0.46 / 3							).set_stroke(width=0.0							).set_fill(a_							,      opacity=0.7							)

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

					self.add(*a_							,      *a_							,      *a_							)

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

					lowercase						:		List[str]   					=		Text("Loaded Checkpoint"							,      font_size=2_4							)
					lowercase						:		Optional[Any]   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					checkpoint.move_to([3, 0.5, 0]							)

					self.add(a_							)

					lowercase						:		Any   					=		[]
					lowercase						:		int   					=		[]

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

						lowercase						:		Optional[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(a_							)
					self.add(*a_							,      *a_							)

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

					lowercase						:		str   					=		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(a_							,      a_							)

					lowercase						:		Any   					=		MarkupText(
					    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''							,      font_size=1_8							,      )

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

					lowercase						:		List[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=2_4							,      )
					step_a.move_to([2, 2, 0]							)

					lowercase						:		Any   					=		[meta_mem.copy() for i in range(6							)]
					lowercase						:		Dict   					=		[meta_mem.copy() for i in range(6							)]
					lowercase						:		Union[str, Any]   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Dict   					=		VGroup(*a_							).arrange(a_							,      buff=0							)
					lowercase						:		Any   					=		VGroup(a_							,      a_							).arrange(a_							,      buff=0							)
					lowercase						:		Optional[Any]   					=		Text("Disk"							,      font_size=2_4							)
					lowercase						:		List[str]   					=		Group(a_							,      a_							).arrange(a_							,      buff=0.5							,      aligned_edge=a_							)
					disk.move_to([-4.0, -1.25, 0]							)
					self.play(Write(a_							,      run_time=3							)							,      Write(a_							,      run_time=1							)							,      Create(a_							,      run_time=1							)							)

					lowercase						:		Optional[Any]   					=		[]
					for i, rect in enumerate(a_							):
						lowercase						:		int   					=		rect.copy()
						target.generate_target()
						target.target.move_to(disk_left_col_base[i]							).scale(0.5							)
						animations.append(MoveToTarget(a_							,      run_time=1.5							)							)
					self.play(*a_							)

					self.play(FadeOut(a_							)							)

					lowercase						:		List[Any]   					=		MarkupText(F'''Then, the checkpoint is removed from memory\nthrough garbage collection.'''							,      font_size=2_4							)
					step_a.move_to([2, 2, 0]							)

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

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

					self.wait()


