code: 
  
  
  
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin
  
  
  if is_torch_available():
    import torch
  
  if is_vision_available():
    from PIL import Image
  
    from transformers import TvltImageProcessor
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      List[Any]		, _lowerCamelCase      :      str=10		, _lowerCamelCase      :      Optional[Any]=10		, _lowerCamelCase      :      List[Any]=False		, _lowerCamelCase      :      Tuple=False ):
      A__       =    []
      for i in range(image_processor_tester.num_frames ):
          video.append(np.random.randint(2_55		, 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
          A__       =    [Image.fromarray(np.moveaxis(_lowerCamelCase		, 0		, -1 ) ) for frame in video]
  
      if torchify:
          A__       =    [torch.from_numpy(_lowerCamelCase ) for frame in video]
  
      return video
  
  
  
  
  
  def 		UpperCamelCase       (							_lowerCamelCase      :      int		, _lowerCamelCase      :      str=False		, _lowerCamelCase      :      List[Any]=False		, _lowerCamelCase      :      Optional[int]=False ):
      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
      A__       =    []
      for i in range(image_processor_tester.batch_size ):
          if equal_resolution:
              A__       =    A__       =    image_processor_tester.max_resolution
          else:
              A__,			A__       =    np.random.choice(
                  np.arange(image_processor_tester.min_resolution		, image_processor_tester.max_resolution )		, 2 )
              A__       =    prepare_video(
                  image_processor_tester=_lowerCamelCase		, width=_lowerCamelCase		, height=_lowerCamelCase		, numpify=_lowerCamelCase		, torchify=_lowerCamelCase		, )
          video_inputs.append(_lowerCamelCase )
  
      return video_inputs
  
  
  
  
  
  
  class      UpperCAmelCase			( unittest.TestCase       ):
   def __init__(       self   :Tuple		, lowercase_   :Dict		, lowercase_   :Tuple=7		, lowercase_   :Optional[Any]=3		, lowercase_   :Optional[Any]=4		, lowercase_   :Any=18		, lowercase_   :Optional[Any]=30		, lowercase_   :Tuple=4_00		, lowercase_   :Tuple=True		, lowercase_   :str=None		, lowercase_   :Dict=True		, lowercase_   :int=[0.5, 0.5, 0.5]		, lowercase_   :Any=[0.5, 0.5, 0.5]		, lowercase_   :int=True		, lowercase_   :Dict=None		, )->							List[Any]:
       A__       =    size if size is not None else {"shortest_edge": 18}
       A__       =    crop_size if crop_size is not None else {"height": 18, "width": 18}
  
       A__       =    parent
       A__       =    batch_size
       A__       =    num_channels
       A__       =    num_frames
       A__       =    image_size
       A__       =    min_resolution
       A__       =    max_resolution
       A__       =    do_resize
       A__       =    size
       A__       =    do_normalize
       A__       =    image_mean
       A__       =    image_std
       A__       =    do_center_crop
       A__       =    crop_size
  
  
  
   def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							Dict:
       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
       }
  
  
  
  
  
  
  @require_torch
  @require_vision
  class      UpperCAmelCase			( UpperCamelCase__    , unittest.TestCase       ):
   __lowercase     	=       TvltImageProcessor if is_vision_available() else None
   def   UpperCAmelCase_							(       self   :Tuple							)->							Tuple:
       A__       =    TvltImageProcessorTester(self							)
   @property
   def   UpperCAmelCase_							(       self   :Optional[Any]							)->							Any:
       return self.image_processor_tester.prepare_image_processor_dict()
   def   UpperCAmelCase_							(       self   :Any							)->							Tuple:
       A__       =    self.image_processing_class(**self.image_processor_dict							)
       self.assertTrue(hasattr(lowercase_		, "image_mean"							)							)
       self.assertTrue(hasattr(lowercase_		, "image_std"							)							)
       self.assertTrue(hasattr(lowercase_		, "do_normalize"							)							)
       self.assertTrue(hasattr(lowercase_		, "do_resize"							)							)
       self.assertTrue(hasattr(lowercase_		, "do_center_crop"							)							)
       self.assertTrue(hasattr(lowercase_		, "size"							)							)
   def   UpperCAmelCase_							(       self   :Tuple							)->							Tuple:
       # Initialize image_processor
       A__       =    self.image_processing_class(**self.image_processor_dict							)
       # create random PIL videos
       A__       =    prepare_video_inputs(self.image_processor_tester		, equal_resolution=lowercase_							)
       for video in video_inputs:
           self.assertIsInstance(lowercase_		, lowercase_							)
           self.assertIsInstance(video[0]		, Image.Image							)
  
       # Test not batched input
       A__       =    image_processor(video_inputs[0]		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
  
       # Test batched
       A__       =    image_processor(lowercase_		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
   def   UpperCAmelCase_							(       self   :Any							)->							Optional[Any]:
       # Initialize image_processor
       A__       =    self.image_processing_class(**self.image_processor_dict							)
       # create random numpy tensors
       A__       =    prepare_video_inputs(self.image_processor_tester		, equal_resolution=lowercase_		, numpify=lowercase_							)
       for video in video_inputs:
           self.assertIsInstance(lowercase_		, lowercase_							)
           self.assertIsInstance(video[0]		, np.ndarray							)
  
       # Test not batched input
       A__       =    image_processor(video_inputs[0]		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
  
       # Test batched
       A__       =    image_processor(lowercase_		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
  
  
  
   def   UpperCAmelCase_							(       self   :Union[str, Any]							)->							Union[str, Any]:
       # Initialize image_processor
       A__       =    self.image_processing_class(**self.image_processor_dict							)
       # create random PyTorch tensors
       A__       =    prepare_video_inputs(self.image_processor_tester		, equal_resolution=lowercase_		, torchify=lowercase_							)
       for video in video_inputs:
           self.assertIsInstance(lowercase_		, lowercase_							)
           self.assertIsInstance(video[0]		, torch.Tensor							)
  
       # Test not batched input
       A__       =    image_processor(video_inputs[0]		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
  
       # Test batched
       A__       =    image_processor(lowercase_		, return_tensors="pt"							).pixel_values
       self.assertEqual(
           encoded_videos.shape		, (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )		, )
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import torch
  
  from transformers import AutoTokenizer
  
  
  
  
  
  
  class      UpperCAmelCase			( UpperCamelCase__       ):
   def __init__(       self   :Any		, lowercase_   :Dict							)->							Any:
       A__       =    AutoTokenizer.from_pretrained(lowercase_							)
   def   UpperCAmelCase_							(       self   :Tuple		, lowercase_   :int							)->							Optional[int]:
  
       if isinstance(lowercase_		, lowercase_							) and all(isinstance(_x		, lowercase_							) for _x in x							):
           A__       =    None
           for l in x:
               A__       =    self.tokenizer(
                   lowercase_		, padding="max_length"		, max_length=3_84		, truncation=lowercase_		, return_tensors="pt"		, )
               A__       =    torch.tensor([len(lowercase_							)]							)
               if d is not None:
                   for k in d.keys():
                       A__       =    torch.cat((d[k], t[k])		, 0							)
               else:
                   A__       =    t
  
           A__       =    torch.tensor(self.tokenizer.convert_tokens_to_ids("[E]"							)							)
           A__       =    torch.tensor(self.tokenizer.convert_tokens_to_ids("[/E]"							)							)
  
       elif isinstance(lowercase_		, lowercase_							) and all(isinstance(_x		, lowercase_							) for _x in x							):
           A__       =    self.tokenizer(
               lowercase_		, padding="max_length"		, max_length=3_84		, truncation=lowercase_		, return_tensors="pt"		, )
  
       else:
           raise Exception(
               "Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of"
               " strings` for supports are supported."							)
  
       return d
  
  
  
   def   UpperCAmelCase_							(       self   :Union[str, Any]		, lowercase_   :List[str]		, lowercase_   :str		, lowercase_   :str		, lowercase_   :List[Any]		, lowercase_   :Dict=0.7_0							)->							int:
       A__       =    []
       for idx in range(len(W_query["input_ids"]							)							):
           A__       =    A__       =    range(p_start.shape[1]							)
  
           A__       =    []
           for start_id in start_indexes:
               for end_id in end_indexes:
                   if start_id < end_id:
                       output.append(
                           (
                               start_id,
                               end_id,
                               p_start[idx][start_id].item(),
                               p_end[idx][end_id].item(),
                           )							)
  
           output.sort(key=lambda lowercase_							: (tup[2] * tup[3])		, reverse=lowercase_							)
           A__       =    []
           for k in range(len(lowercase_							)							):
               if output[k][2] * output[k][3] >= thresh:
                   A__,			A__       =    output[k][0], output[k][1]
                   A__       =    self.tokenizer.decode(W_query["input_ids"][idx][c_start_pos:c_end_pos]							)
                   temp.append((decoded, output[k][2] * output[k][3])							)
  
           final_outputs.append(lowercase_							)
  
       return final_outputs
  
  
  
  