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			,						_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			,						_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: 
  from __future__ import annotations
  
  
  
  def 		UpperCamelCase    (					_UpperCAmelCase     :      list[int]   , _UpperCAmelCase     :      int     )      -> int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  						_lowercase			,						_lowercase					:  Any    			=      0, len(_UpperCAmelCase     ) - 1
  						while start_ind <= end_ind:
  												if array[start_ind] == search_item:
  																		return start_ind
  												elif array[end_ind] == search_item:
  																		return end_ind
  												else:
  																		start_ind += 1
  																		end_ind -= 1
      # returns -1 if search_item is not found in array
  						return -1
  
  
  if __name__ == "__main__":
  							print(double_linear_search(list(range(100)), 40))
  
  
  
  
  