code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import importlib.metadata
  import sys
  
  from transformers.testing_utils import TestCasePlus
  from transformers.utils.versions import require_version, require_version_core
  
  
  A_			  =    importlib.metadata.version("numpy")
  A_			  =    ".".join([str(x) for x in sys.version_info[:3]])
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def 					UpperCamelCase__   (      self:		Any					):
       # lt + different version strings
       require_version_core("numpy<1000.4.5"					)
       require_version_core("numpy<1000.4"					)
       require_version_core("numpy<1000"					)
  
       # le
       require_version_core("numpy<=1000.4.5"					)
       require_version_core(f"""numpy<={numpy_ver}"""					)
  
       # eq
       require_version_core(f"""numpy=={numpy_ver}"""					)
  
       # ne
       require_version_core("numpy!=1000.4.5"					)
  
       # ge
       require_version_core("numpy>=1.0"					)
       require_version_core("numpy>=1.0.0"					)
       require_version_core(f"""numpy>={numpy_ver}"""					)
  
       # gt
       require_version_core("numpy>1.0.0"					)
  
       # mix
       require_version_core("numpy>1.0.0,<1000"					)
  
       # requirement w/o version
       require_version_core("numpy"					)
  
       # unmet requirements due to version conflict
       for req in ["numpy==1.0.0", "numpy>=1000.0.0", f"""numpy<{numpy_ver}"""]:
          try:
             require_version_core(UpperCamelCase_					)
          except ImportError as e:
             self.assertIn(f"""{req} is required"""				,			str(UpperCamelCase_					)					)
             self.assertIn("but found"				,			str(UpperCamelCase_					)					)
  
          # unmet requirements due to missing module
       for req in ["numpipypie>1", "numpipypie2"]:
          try:
             require_version_core(UpperCamelCase_					)
          except importlib.metadata.PackageNotFoundError as e:
             self.assertIn(f"""The '{req}' distribution was not found and is required by this application"""				,			str(UpperCamelCase_					)					)
             self.assertIn("Try: pip install transformers -U"				,			str(UpperCamelCase_					)					)
  
          # bogus requirements formats:
          # 1. whole thing
       for req in ["numpy??1.0.0", "numpy1.0.0"]:
          try:
             require_version_core(UpperCamelCase_					)
          except ValueError as e:
             self.assertIn("requirement needs to be in the pip package format"				,			str(UpperCamelCase_					)					)
          # 2. only operators
       for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
          try:
             require_version_core(UpperCamelCase_					)
          except ValueError as e:
             self.assertIn("need one of "				,			str(UpperCamelCase_					)					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		int					):
       # matching requirement
       require_version("python>=3.6.0"					)
  
       # not matching requirements
       for req in ["python>9.9.9", "python<3.0.0"]:
          try:
             require_version_core(UpperCamelCase_					)
          except ImportError as e:
             self.assertIn(f"""{req} is required"""				,			str(UpperCamelCase_					)					)
             self.assertIn(f"""but found python=={python_ver}"""				,			str(UpperCamelCase_					)					)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import warnings
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    Optional[Any]     	=			["image_processor", "tokenizer"]
    __lowerCamelCase       :    List[str]     	=			"VideoMAEImageProcessor"
    __lowerCamelCase       :    Dict     	=			("CLIPTokenizer", "CLIPTokenizerFast")
    def __init__(      self:		str				,			UpperCamelCase_:		Dict=None				,			UpperCamelCase_:		str=None				,			**UpperCamelCase_:		str					):
       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."				,			UpperCamelCase_				,			)
          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__(UpperCamelCase_				,			UpperCamelCase_					)
       UpperCamelCase_     =self.image_processor
    def __call__(      self:		Tuple				,			UpperCamelCase_:		str=None				,			UpperCamelCase_:		str=None				,			UpperCamelCase_:		Optional[Any]=None				,			**UpperCamelCase_:		int					):
  
       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(UpperCamelCase_				,			return_tensors=UpperCamelCase_				,			**UpperCamelCase_					)
  
       if videos is not None:
          UpperCamelCase_     =self.image_processor(UpperCamelCase_				,			return_tensors=UpperCamelCase_				,			**UpperCamelCase_					)
  
       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(**UpperCamelCase_					)				,			tensor_type=UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Any				,			*UpperCamelCase_:		List[str]				,			**UpperCamelCase_:		Optional[int]					):
       return self.tokenizer.batch_decode(*UpperCamelCase_				,			**UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Optional[Any]				,			*UpperCamelCase_:		List[str]				,			**UpperCamelCase_:		Tuple					):
       return self.tokenizer.decode(*UpperCamelCase_				,			**UpperCamelCase_					)
    @property
    def 					UpperCamelCase__   (      self:		List[Any]					):
       return ["input_ids", "attention_mask", "position_ids", "pixel_values"]
    @property
    def 					UpperCamelCase__   (      self:		str					):
       warnings.warn(
           "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."				,			UpperCamelCase_				,			)
       return self.image_processor_class
  
  
  
  
  
    @property
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       warnings.warn(
           "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."				,			UpperCamelCase_				,			)
       return self.image_processor
  