




import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402







class 						A(		unittest.TestCase     ):



 '''simple docstring'''


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

       """simple docstring"""






       lowerCamelCase_	  =					0

 def        a__				(       self      :						Dict						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					AutoImageProcessor.from_pretrained('openai/clip-vit-base-patch32'						)
       self.assertIsInstance(A_		,							A_						)

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

       """simple docstring"""






       with tempfile.TemporaryDirectory() as tmpdirname:
             lowerCamelCase_	  =					Path(A_						) / 'preprocessor_config.json'
             lowerCamelCase_	  =					Path(A_						) / 'config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}		,							open(A_		,							'w'						)		,							)
             json.dump({'model_type': 'clip'}		,							open(A_		,							'w'						)						)

             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						)
             self.assertIsInstance(A_		,							A_						)

 def        a__				(       self      :						str						)     ->			int:

       """simple docstring"""






       with tempfile.TemporaryDirectory() as tmpdirname:
             lowerCamelCase_	  =					Path(A_						) / 'preprocessor_config.json'
             lowerCamelCase_	  =					Path(A_						) / 'config.json'
             json.dump(
                 {'feature_extractor_type': 'CLIPFeatureExtractor', 'processor_class': 'CLIPProcessor'}		,							open(A_		,							'w'						)		,							)
             json.dump({'model_type': 'clip'}		,							open(A_		,							'w'						)						)

             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						)
             self.assertIsInstance(A_		,							A_						)

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

       """simple docstring"""






       with tempfile.TemporaryDirectory() as tmpdirname:
             lowerCamelCase_	  =					CLIPConfig()

             # Create a dummy config file with image_proceesor_type
             lowerCamelCase_	  =					Path(A_						) / 'preprocessor_config.json'
             lowerCamelCase_	  =					Path(A_						) / 'config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}		,							open(A_		,							'w'						)		,							)
             json.dump({'model_type': 'clip'}		,							open(A_		,							'w'						)						)

             # remove image_processor_type to make sure config.json alone is enough to load image processor locally
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						).to_dict()

             config_dict.pop('image_processor_type'						)
             lowerCamelCase_	  =					CLIPImageProcessor(**A_						)

             # save in new folder
             model_config.save_pretrained(A_						)
             config.save_pretrained(A_						)

             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						)

             # make sure private variable is not incorrectly saved
             lowerCamelCase_	  =					json.loads(config.to_json_string()						)
             self.assertTrue('_processor_class' not in dict_as_saved						)

       self.assertIsInstance(A_		,							A_						)

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

       """simple docstring"""






       with tempfile.TemporaryDirectory() as tmpdirname:
             lowerCamelCase_	  =					Path(A_						) / 'preprocessor_config.json'
             json.dump(
                 {'image_processor_type': 'CLIPImageProcessor', 'processor_class': 'CLIPProcessor'}		,							open(A_		,							'w'						)		,							)

             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						)
             self.assertIsInstance(A_		,							A_						)

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

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							'clip-base is not a local folder and is not a valid model identifier'						):
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained('clip-base'						)

 def        a__				(       self      :						Union[str, Any]						)     ->			int:

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'						):
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_		,							revision='aaaaaa'						)

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

       """simple docstring"""






       with self.assertRaisesRegex(
           A_		,							'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'		,							):
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained('hf-internal-testing/config-no-model'						)

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

       """simple docstring"""






       with self.assertRaises(A_						):
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained('hf-internal-testing/test_dynamic_image_processor'						)
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(A_						):
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'		,							trust_remote_code=A_						)

       lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(
           'hf-internal-testing/test_dynamic_image_processor'		,							trust_remote_code=A_						)
       self.assertEqual(image_processor.__class__.__name__		,							'NewImageProcessor'						)

       # Test image processor can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
             image_processor.save_pretrained(A_						)
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_		,							trust_remote_code=A_						)
       self.assertEqual(reloaded_image_processor.__class__.__name__		,							'NewImageProcessor'						)

 def        a__				(       self      :						Tuple						)     ->			Any:

       """simple docstring"""






       try:
             AutoConfig.register('custom'		,							A_						)
             AutoImageProcessor.register(A_		,							A_						)
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(A_						):
                   AutoImageProcessor.register(A_		,							A_						)

             with tempfile.TemporaryDirectory() as tmpdirname:
                   lowerCamelCase_	  =					Path(A_						) / 'preprocessor_config.json'
                   lowerCamelCase_	  =					Path(A_						) / 'config.json'
                   json.dump(
                       {'feature_extractor_type': 'CLIPFeatureExtractor', 'processor_class': 'CLIPProcessor'}		,							open(A_		,							'w'						)		,							)
                   json.dump({'model_type': 'clip'}		,							open(A_		,							'w'						)						)

                   lowerCamelCase_	  =					CustomImageProcessor.from_pretrained(A_						)

             # Now that the config is registered, it can be used as any other config with the auto-API
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(A_						)
                   lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(A_						)
                   self.assertIsInstance(A_		,							A_						)

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





 def        a__				(       self      :						int						)     ->			Tuple:

       """simple docstring"""






       class 						A(		UpperCamelCase     ):



        '''simple docstring'''


        UpperCamelCase		     =		True

       try:
             AutoConfig.register('custom'		,							A_						)
             AutoImageProcessor.register(A_		,							A_						)
             # If remote code is not set, the default is to use local
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained('hf-internal-testing/test_dynamic_image_processor'						)
             self.assertEqual(image_processor.__class__.__name__		,							'NewImageProcessor'						)
             self.assertTrue(image_processor.is_local						)

             # If remote code is disabled, we load the local one.
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'		,							trust_remote_code=A_						)
             self.assertEqual(image_processor.__class__.__name__		,							'NewImageProcessor'						)
             self.assertTrue(image_processor.is_local						)

             # If remote is enabled, we load from the Hub
             lowerCamelCase_	  =					AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/test_dynamic_image_processor'		,							trust_remote_code=A_						)
             self.assertEqual(image_processor.__class__.__name__		,							'NewImageProcessor'						)
             self.assertTrue(not hasattr(A_		,							'is_local'						)						)

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









from manim import *







class 						A(		UpperCamelCase     ):



 '''simple docstring'''


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

       """simple docstring"""






       lowerCamelCase_	  =					Rectangle(height=0.5		,							width=0.5						)
       lowerCamelCase_	  =					Rectangle(height=0.46		,							width=0.46						).set_stroke(width=0						)

       lowerCamelCase_	  =					Rectangle(height=0.25		,							width=0.25						)

       lowerCamelCase_	  =					[mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					[mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(A_		,							A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('CPU'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       cpu.move_to([-2.5, -0.5, 0]						)
       self.add(A_						)

       lowerCamelCase_	  =					[mem.copy() for i in range(4						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('GPU'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       gpu.move_to([-1, -1, 0]						)
       self.add(A_						)

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

       lowerCamelCase_	  =					Text('Model'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       model.move_to([3, -1.0, 0]						)
       self.add(A_						)

       lowerCamelCase_	  =					[]
       lowerCamelCase_	  =					[]

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

             lowerCamelCase_	  =					Rectangle(height=0.46		,							width=0.46						).set_stroke(width=0.0						).set_fill(A_		,							opacity=0.8						)
             cpu_target.move_to(cpu_left_col_base[i]						)
             model_cpu_arr.append(A_						)

       self.add(*A_		,							*A_						)

       lowerCamelCase_	  =					[meta_mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					[meta_mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(A_		,							A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('Disk'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       disk.move_to([-4, -1.25, 0]						)
       self.add(A_		,							A_						)

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

       lowerCamelCase_	  =					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(A_		,							A_						)

       lowerCamelCase_	  =					MarkupText(
           f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""		,							font_size=18		,							)

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

       lowerCamelCase_	  =					MarkupText(
           f"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""		,							font_size=24		,							)
       step_a.move_to([2, 2, 0]						)

       self.play(Write(A_						)						)

       lowerCamelCase_	  =					Square(0.3						)
       input.set_fill(A_		,							opacity=1.0						)
       input.set_stroke(width=0.0						)
       input.next_to(model_base[0]		,							A_		,							buff=0.5						)

       self.play(Write(A_						)						)

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

       self.play(FadeOut(A_						)						)

       lowerCamelCase_	  =					Arrow(start=A_		,							end=A_		,							color=A_		,							buff=0.5						)
       a.next_to(model_arr[0].get_left()		,							A_		,							buff=0.2						)

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

       lowerCamelCase_	  =					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=24		,							)
       step_a.move_to([2, 2, 0]						)

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

       lowerCamelCase_	  =					{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

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

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

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

             lowerCamelCase_	  =					AnimationGroup(
                 FadeOut(A_		,							run_time=0.5						)		,							MoveToTarget(A_		,							run_time=0.5						)		,							FadeIn(A_		,							run_time=0.5						)		,							lag_ratio=0.2						)

             self.play(A_						)

             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:
                         lowerCamelCase_	  =					0.7

                   self.play(
                       Circumscribe(model_arr[i]		,							**A_						)		,							Circumscribe(cpu_left_col_base[i]		,							**A_						)		,							Circumscribe(cpu_left_col_base[i + 1]		,							color=A_		,							**A_						)		,							Circumscribe(gpu_rect[0]		,							color=A_		,							**A_						)		,							Circumscribe(model_arr[i + 1]		,							color=A_		,							**A_						)		,							)
                   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=A_		,							**A_						)		,							Circumscribe(cpu_left_col_base[-1]		,							color=A_		,							**A_						)		,							Circumscribe(gpu_rect[0]		,							color=A_		,							**A_						)		,							)

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

             lowerCamelCase_	  =					a_c
             lowerCamelCase_	  =					a_c.copy()

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

       lowerCamelCase_	  =					MarkupText(f"""Inference on a model too large for GPU memory\nis successfully completed."""		,							font_size=24						)
       step_a.move_to([2, 2, 0]						)

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

       self.wait()



