code: 
  
  
  import warnings
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  
  
  
  class   __lowerCamelCase (_a	):
         _lowercase       							=    ["""image_processor""", """tokenizer"""]
         _lowercase       							=    """VideoMAEImageProcessor"""
         _lowercase       							=    ("""CLIPTokenizer""", """CLIPTokenizerFast""")
  
  
  
  
  
  
  
         def __init__( self:   Optional[Any],A_:   Any=None,A_:   Optional[int]=None,**A_:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = None
              if "feature_extractor" in kwargs:
                   warnings.warn(
                       'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                       ' instead.',A_,)
                   __UpperCamelCase   = kwargs.pop('feature_extractor'				)
  
              __UpperCamelCase   = image_processor if image_processor is not None else feature_extractor
              if image_processor is None:
                   raise ValueError('You need to specify an `image_processor`.'				)
              if tokenizer is None:
                   raise ValueError('You need to specify a `tokenizer`.'				)
  
              super().__init__(A_,A_				)
              __UpperCamelCase   = self.image_processor
  
  
  
  
  
  
  
         def __call__( self:   str,A_:   Any=None,A_:   Any=None,A_:   Union[str, Any]=None,**A_:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              if text is None and videos is None:
                   raise ValueError('You have to specify either text or videos. Both cannot be none.'				)
  
              if text is not None:
                   __UpperCamelCase   = self.tokenizer(A_,return_tensors=A_,**A_				)
  
              if videos is not None:
                   __UpperCamelCase   = self.image_processor(A_,return_tensors=A_,**A_				)
  
              if text is not None and videos is not None:
                   __UpperCamelCase   = image_features.pixel_values
                   return encoding
              elif text is not None:
                   return encoding
              else:
                   return BatchEncoding(data=dict(**A_				),tensor_type=A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict,*A_:   Union[str, Any],**A_:   Optional[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self.tokenizer.batch_decode(*A_,**A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict,*A_:   str,**A_:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self.tokenizer.decode(*A_,**A_				)
  
  
  
  
  
  
  
         @property
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return ["input_ids", "attention_mask", "position_ids", "pixel_values"]
  
  
  
  
  
  
  
         @property
         def 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              warnings.warn(
                  '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.',A_,)
              return self.image_processor_class
  
  
  
  
  
  
  
         @property
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              warnings.warn(
                  '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.',A_,)
              return self.image_processor
  
  
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   int | float:
  
  
       """simple docstring"""
  
  
       if len(_lowercase   ) == 0:
            raise ValueError('find_max() arg is an empty sequence'   )
       __UpperCamelCase   = nums[0]
       for x in nums:
            if x > max_num:
                 __UpperCamelCase   = x
       return max_num
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod(verbose=True)
  
  
  