code: 
  import json
  import os
  import tempfile
  
  from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  
  if is_torch_available():
         import numpy as np
         import torch
  
  if is_vision_available():
         from PIL import Image
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      Dict   , _UpperCAmelCase     :      Tuple=False   , _UpperCAmelCase     :      List[Any]=False   , _UpperCAmelCase     :      List[Any]=False     )      -> int:
  
  
  
  
  
  
        '''simple docstring'''
  
        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
        _lowercase					:  Optional[int]    			=      []
        for i in range(image_processor_tester.batch_size     ):
              if equal_resolution:
                    _lowercase					:  Tuple    			=      image_processor_tester.max_resolution
              else:
                    # To avoid getting image width/height 0
                    _lowercase					:  int    			=      image_processor_tester.min_resolution
                    if getattr(_UpperCAmelCase   , "size_divisor"   , _UpperCAmelCase     ):
                          # If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
                          _lowercase					:  Any    			=      max(image_processor_tester.size_divisor   , _UpperCAmelCase     )
                    _lowercase					:  Union[str, Any]    			=      np.random.choice(np.arange(_UpperCAmelCase   , image_processor_tester.max_resolution     )   , 2     )
              image_inputs.append(
                  np.random.randint(255   , size=(image_processor_tester.num_channels, width, height)   , dtype=np.uinta     )     )
  
        if not numpify and not torchify:
              # PIL expects the channel dimension as last dimension
              _lowercase					:  Optional[Any]    			=      [Image.fromarray(np.moveaxis(_UpperCAmelCase   , 0   , -1     )     ) for image in image_inputs]
  
        if torchify:
              _lowercase					:  Any    			=      [torch.from_numpy(_UpperCAmelCase     ) for image in image_inputs]
  
        return image_inputs
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      Optional[int]   , _UpperCAmelCase     :      str=10   , _UpperCAmelCase     :      List[Any]=10   , _UpperCAmelCase     :      Any=False   , _UpperCAmelCase     :      List[Any]=False     )      -> Dict:
  
  
  
  
  
  
        '''simple docstring'''
  
        _lowercase					:  List[Any]    			=      []
        for i in range(image_processor_tester.num_frames     ):
              video.append(np.random.randint(255   , size=(image_processor_tester.num_channels, width, height)   , dtype=np.uinta     )     )
  
        if not numpify and not torchify:
              # PIL expects the channel dimension as last dimension
              _lowercase					:  List[str]    			=      [Image.fromarray(np.moveaxis(_UpperCAmelCase   , 0   , -1     )     ) for frame in video]
  
        if torchify:
              _lowercase					:  Dict    			=      [torch.from_numpy(_UpperCAmelCase     ) for frame in video]
  
        return video
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      int   , _UpperCAmelCase     :      List[Any]=False   , _UpperCAmelCase     :      int=False   , _UpperCAmelCase     :      Optional[int]=False     )      -> Any:
  
  
  
  
  
  
        '''simple docstring'''
  
        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
        _lowercase					:  str    			=      []
        for i in range(image_processor_tester.batch_size     ):
              if equal_resolution:
                    _lowercase					:  List[str]    			=      image_processor_tester.max_resolution
              else:
                    _lowercase					:  Tuple    			=      np.random.choice(
                        np.arange(image_processor_tester.min_resolution   , image_processor_tester.max_resolution     )   , 2     )
                    _lowercase					:  List[Any]    			=      prepare_video(
                        image_processor_tester=_UpperCAmelCase   , width=_UpperCAmelCase   , height=_UpperCAmelCase   , numpify=_UpperCAmelCase   , torchify=_UpperCAmelCase   , )
              video_inputs.append(_UpperCAmelCase     )
  
        return video_inputs
  
  
  
  
  class      __lowercase	:
   _A   			=      None
  
  
  
  
  
  
   def 			_a(self							:   Tuple						)   -> Dict:
         _lowercase					:  Union[str, Any]    			=      self.image_processing_class(**self.image_processor_dict						)
         _lowercase					:  Optional[int]    			=      json.loads(image_processor.to_json_string()						)
         for key, value in self.image_processor_dict.items():
               self.assertEqual(obj[key]			,  snake_case						)
  
  
  
  
  
  
   def 			_a(self							:   int						)   -> str:
         _lowercase					:  Any    			=      self.image_processing_class(**self.image_processor_dict						)
  
         with tempfile.TemporaryDirectory() as tmpdirname:
               _lowercase					:  int    			=      os.path.join(snake_case			,  "image_processor.json"						)
               image_processor_first.to_json_file(snake_case						)
               _lowercase					:  Dict    			=      self.image_processing_class.from_json_file(snake_case						)
  
         self.assertEqual(image_processor_second.to_dict()			,  image_processor_first.to_dict()						)
  
  
  
  
  
  
   def 			_a(self							:   List[Any]						)   -> Optional[Any]:
         _lowercase					:  str    			=      self.image_processing_class(**self.image_processor_dict						)
  
         with tempfile.TemporaryDirectory() as tmpdirname:
               _lowercase					:  Tuple    			=      image_processor_first.save_pretrained(snake_case						)[0]
               check_json_file_has_correct_format(snake_case						)
               _lowercase					:  Dict    			=      self.image_processing_class.from_pretrained(snake_case						)
  
         self.assertEqual(image_processor_second.to_dict()			,  image_processor_first.to_dict()						)
  
  
  
  
  
  
   def 			_a(self							:   List[str]						)   -> Any:
         _lowercase					:  List[Any]    			=      self.image_processing_class()
         self.assertIsNotNone(snake_case						)
  
  
  
  
  
  
   @require_torch
   @require_vision
   def 			_a(self							:   Optional[Any]						)   -> Optional[int]:
         if self.test_cast_dtype is not None:
               # Initialize image_processor
               _lowercase					:  Optional[Any]    			=      self.image_processing_class(**self.image_processor_dict						)
  
               # create random PyTorch tensors
               _lowercase					:  Optional[int]    			=      prepare_image_inputs(self.image_processor_tester			,  equal_resolution=snake_case			,  torchify=snake_case						)
  
               _lowercase					:  List[str]    			=      image_processor(snake_case			,  return_tensors="pt"						)
               # for layoutLM compatiblity
               self.assertEqual(encoding.pixel_values.device			,  torch.device("cpu"						)						)
               self.assertEqual(encoding.pixel_values.dtype			,  torch.floataa						)
  
               _lowercase					:  Union[str, Any]    			=      image_processor(snake_case			,  return_tensors="pt"						).to(torch.floataa						)
               self.assertEqual(encoding.pixel_values.device			,  torch.device("cpu"						)						)
               self.assertEqual(encoding.pixel_values.dtype			,  torch.floataa						)
  
               _lowercase					:  Any    			=      image_processor(snake_case			,  return_tensors="pt"						).to("cpu"			,  torch.bfloataa						)
               self.assertEqual(encoding.pixel_values.device			,  torch.device("cpu"						)						)
               self.assertEqual(encoding.pixel_values.dtype			,  torch.bfloataa						)
  
               with self.assertRaises(snake_case						):
                     _lowercase					:  str    			=      image_processor(snake_case			,  return_tensors="pt"						).to(torch.bfloataa			,  "cpu"						)
  
               # Try with text + image feature
               _lowercase					:  Optional[int]    			=      image_processor(snake_case			,  return_tensors="pt"						)
               encoding.update({"input_ids": torch.LongTensor([[1, 2, 3], [4, 5, 6]]						)}						)
               _lowercase					:  List[Any]    			=      encoding.to(torch.floataa						)
  
               self.assertEqual(encoding.pixel_values.device			,  torch.device("cpu"						)						)
               self.assertEqual(encoding.pixel_values.dtype			,  torch.floataa						)
               self.assertEqual(encoding.input_ids.dtype			,  torch.long						)
  
  
  
  
  
style_context: 
  import os
  import unittest
  
  from transformers.models.bertweet.tokenization_bertweet import VOCAB_FILES_NAMES, BertweetTokenizer
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  class      __lowercase	(	__snake_case      ,   unittest.TestCase					):
  	_A   			=      BertweetTokenizer
  	_A   			=      False
  
  
  
  
  
  
  	def 			_a(self							:   Tuple						)   -> Any:
  							super().setUp()
  
  							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
  							_lowercase					:  Tuple    			=      ["I", "m", "V@@", "R@@", "r", "e@@"]
  							_lowercase					:  Tuple    			=      dict(zip(snake_case			,  range(len(snake_case						)						)						)						)
  							_lowercase					:  Tuple    			=      ["#version: 0.2", "a m</w>"]
  							_lowercase					:  Optional[Any]    			=      {"unk_token": "<unk>"}
  
  							_lowercase					:  int    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["vocab_file"]						)
  							_lowercase					:  Optional[int]    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["merges_file"]						)
  							with open(self.vocab_file			,  "w"			,  encoding="utf-8"						) as fp:
  													for token in vocab_tokens:
  																			fp.write(F"""{token} {vocab_tokens[token]}\n"""						)
  							with open(self.merges_file			,  "w"			,  encoding="utf-8"						) as fp:
  													fp.write("\n".join(snake_case						)						)
  
  
  
  
  
  
  	def 			_a(self							:   List[Any]			,  **snake_case							:   Tuple						)   -> Union[str, Any]:
  							kwargs.update(self.special_tokens_map						)
  							return BertweetTokenizer.from_pretrained(self.tmpdirname			,  **snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   Any			,  snake_case							:   Any						)   -> List[Any]:
  							_lowercase					:  Tuple    			=      "I am VinAI Research"
  							_lowercase					:  Optional[int]    			=      "I <unk> m V<unk> <unk> <unk> I Re<unk> e<unk> <unk> <unk> <unk>"
  							return input_text, output_text
  
  
  
  
  
  
  	def 			_a(self							:   str						)   -> Optional[int]:
  							_lowercase					:  str    			=      BertweetTokenizer(self.vocab_file			,  self.merges_file			,  **self.special_tokens_map						)
  							_lowercase					:  Optional[Any]    			=      "I am VinAI Research"
  							_lowercase					:  str    			=      "I a@@ m V@@ i@@ n@@ A@@ I R@@ e@@ s@@ e@@ a@@ r@@ c@@ h".split()
  							_lowercase					:  Tuple    			=      tokenizer.tokenize(snake_case						)
  							self.assertListEqual(snake_case			,  snake_case						)
  
  							_lowercase					:  str    			=      tokens + [tokenizer.unk_token]
  
  							_lowercase					:  str    			=      [4, 3, 5, 6, 3, 3, 3, 4, 7, 9, 3, 9, 3, 3, 3, 3, 3]
  							self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case						)			,  snake_case						)
  
  
  
  
  