


import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import AutoProcessor, BertTokenizer, CLIPImageProcessor, GitProcessor, PreTrainedTokenizerFast

@require_vision
class 						A__      (					unittest.TestCase			):







    """simple docstring"""

    def 	a_    ( self					):
         snake_case					=       tempfile.mkdtemp()

         snake_case					=       CLIPImageProcessor()
         snake_case					=       BertTokenizer.from_pretrained(
             '''hf-internal-testing/tiny-random-BertModel'''    ,      model_input_names=['''input_ids''', '''attention_mask''']					)

         snake_case					=       GitProcessor(a_    ,      a_					)

         processor.save_pretrained(self.tmpdirname					)
    def 	a_    ( self    ,      **__snake_case					):
         return AutoProcessor.from_pretrained(self.tmpdirname    ,      **a_					).tokenizer
    def 	a_    ( self    ,      **__snake_case					):
         return AutoProcessor.from_pretrained(self.tmpdirname    ,      **a_					).image_processor
    def 	a_    ( self					):
         shutil.rmtree(self.tmpdirname					)
    def 	a_    ( self					):
         snake_case					=       [np.random.randint(2_5_5    ,      size=(3, 3_0, 4_0_0)    ,      dtype=np.uinta					)]

         snake_case					=       [Image.fromarray(np.moveaxis(a_    ,      0    ,      -1					)					) for x in image_inputs]

         return image_inputs
    def 	a_    ( self					):
         snake_case					=       GitProcessor(tokenizer=self.get_tokenizer()    ,      image_processor=self.get_image_processor()					)
         processor.save_pretrained(self.tmpdirname					)

         snake_case					=       self.get_tokenizer(bos_token='''(BOS)'''    ,      eos_token='''(EOS)'''					)
         snake_case					=       self.get_image_processor(do_normalize=a_    ,      padding_value=1.0					)

         snake_case					=       GitProcessor.from_pretrained(
             self.tmpdirname    ,      bos_token='''(BOS)'''    ,      eos_token='''(EOS)'''    ,      do_normalize=a_    ,      padding_value=1.0					)

         self.assertEqual(processor.tokenizer.get_vocab()    ,      tokenizer_add_kwargs.get_vocab()					)
         self.assertIsInstance(processor.tokenizer    ,      a_					)

         self.assertEqual(processor.image_processor.to_json_string()    ,      image_processor_add_kwargs.to_json_string()					)
         self.assertIsInstance(processor.image_processor    ,      a_					)
    def 	a_    ( self					):
         snake_case					=       self.get_image_processor()
         snake_case					=       self.get_tokenizer()

         snake_case					=       GitProcessor(tokenizer=a_    ,      image_processor=a_					)

         snake_case					=       self.prepare_image_inputs()

         snake_case					=       image_processor(a_    ,      return_tensors='''np'''					)
         snake_case					=       processor(images=a_    ,      return_tensors='''np'''					)

         for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()    ,      input_processor[key].sum()    ,      delta=1E-2					)
    def 	a_    ( self					):
         snake_case					=       self.get_image_processor()
         snake_case					=       self.get_tokenizer()

         snake_case					=       GitProcessor(tokenizer=a_    ,      image_processor=a_					)

         snake_case					=       '''lower newer'''

         snake_case					=       processor(text=a_					)

         snake_case					=       tokenizer(a_    ,      return_token_type_ids=a_					)

         for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]    ,      encoded_processor[key]					)
    def 	a_    ( self					):
         snake_case					=       self.get_image_processor()
         snake_case					=       self.get_tokenizer()

         snake_case					=       GitProcessor(tokenizer=a_    ,      image_processor=a_					)

         snake_case					=       '''lower newer'''
         snake_case					=       self.prepare_image_inputs()

         snake_case					=       processor(text=a_    ,      images=a_					)

         self.assertListEqual(list(inputs.keys()					)    ,      ['''input_ids''', '''attention_mask''', '''pixel_values''']					)

         # test if it raises when no input is passed
         with pytest.raises(a_					):
              processor()
    def 	a_    ( self					):
         snake_case					=       self.get_image_processor()
         snake_case					=       self.get_tokenizer()

         snake_case					=       GitProcessor(tokenizer=a_    ,      image_processor=a_					)

         snake_case					=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         snake_case					=       processor.batch_decode(a_					)
         snake_case					=       tokenizer.batch_decode(a_					)

         self.assertListEqual(a_    ,      a_					)




    def 	a_    ( self					):
         snake_case					=       self.get_image_processor()
         snake_case					=       self.get_tokenizer()

         snake_case					=       GitProcessor(tokenizer=a_    ,      image_processor=a_					)

         snake_case					=       '''lower newer'''
         snake_case					=       self.prepare_image_inputs()

         snake_case					=       processor(text=a_    ,      images=a_					)

         # For now the processor supports only ['input_ids', 'attention_mask', 'pixel_values']
         self.assertListEqual(list(inputs.keys()					)    ,      ['''input_ids''', '''attention_mask''', '''pixel_values''']					)










from manim import *

class 						A__      (					snake_case__			):







    """simple docstring"""

    def 	a_    ( self					):
         snake_case					=       Rectangle(height=0.5    ,      width=0.5					)
         snake_case					=       Rectangle(height=0.46    ,      width=0.46					).set_stroke(width=0					)
         snake_case					=       Rectangle(height=0.25    ,      width=0.25					)

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

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

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

         snake_case					=       Text('''Model'''    ,      font_size=2_4					)
         snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
         model.move_to([3, -1.0, 0]					)
         self.add(__snake_case					)

         snake_case					=       []
         snake_case					=       []

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

              snake_case					=       Rectangle(height=0.46 / 4    ,      width=0.46 / 3					).set_stroke(width=0.0					).set_fill(__snake_case    ,      opacity=0.7					)

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

         self.add(*__snake_case    ,      *__snake_case					)

         snake_case					=       [meta_mem.copy() for i in range(6					)]
         snake_case					=       [meta_mem.copy() for i in range(6					)]
         snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
         snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
         snake_case					=       VGroup(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0					)
         snake_case					=       Text('''Disk'''    ,      font_size=2_4					)
         snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
         disk.move_to([-4.0, -1.25, 0]					)
         self.add(__snake_case    ,      __snake_case					)

         snake_case					=       []

         for i in range(6					):
              snake_case					=       fill.copy().set_fill(__snake_case    ,      opacity=0.8					)
              target.move_to(disk_left_col_base[i]					).scale(0.5					)
              cpu_disk_arr.append(__snake_case					)

         self.add(*__snake_case					)

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

         snake_case					=       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(__snake_case    ,      __snake_case					)

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

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

         snake_case					=       MarkupText(F'''The offloaded weights are all sent to the CPU.'''    ,      font_size=2_4					)
         step_a.move_to([2, 2, 0]					)

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

         for i in range(6					):
              snake_case					=       cpu_disk_arr[i]
              snake_case					=       rect.copy().set_fill(__snake_case    ,      opacity=0.8					).scale(2.0					)
              cpa.generate_target()
              cpa.target.move_to(model_base[i]					)

              if i == 0:
                   rect.set_fill(__snake_case    ,      opacity=0.8					)
                   rect.generate_target()
                   rect.target.move_to(cpu_left_col_base[0]					).scale(2.0					)

                   self.remove(
                       *__snake_case    ,      *__snake_case    ,      )

              else:
                   rect.generate_target()
                   rect.target.move_to(cpu_left_col_base[i]					).scale(2.0					)
              self.play(MoveToTarget(__snake_case					)    ,      MoveToTarget(__snake_case					)    ,      model_base[i].animate.set_stroke(__snake_case					)					)
         self.play(FadeOut(__snake_case					)					)

         snake_case					=       MarkupText(
             F'''Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.'''    ,      font_size=2_4    ,      )
         step_a.move_to([2, 2, 0]					)

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

         snake_case					=       []
         snake_case					=       []
         for i in range(6					):
              snake_case					=       Arrow(start=__snake_case    ,      end=__snake_case    ,      color=__snake_case    ,      buff=0.5					)
              a.next_to(model_base[i].get_left()    ,      __snake_case    ,      buff=0.2					)
              arrows.append(__snake_case					)
              animations.append(Write(__snake_case					)					)
         self.play(*__snake_case					)
         self.wait()




