


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






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)


