code: '''simple docstring'''
  
  
  
  
  
  import warnings
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							a_    ):
      UpperCAmelCase_			:       Tuple						 =							['image_processor', 'tokenizer']
      UpperCAmelCase_			:       str						 =							'AutoImageProcessor'
      UpperCAmelCase_			:       Union[str, Any]						 =							'AutoTokenizer'
  
  
  
  
      def __init__(					self  :   str      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   str=None      ,      **lowerCAmelCase  :   Optional[int]   )	-> Union[str, Any]:
        a__     		=     None
        if "feature_extractor" in kwargs:
          warnings.warn(
              "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
              " instead."      ,      lowerCAmelCase      ,      )
          a__     		=     kwargs.pop("feature_extractor"   )
  
        a__     		=     image_processor if image_processor is not None else feature_extractor
        if image_processor is None:
          raise ValueError("You have to specify an image_processor."   )
        if tokenizer is None:
          raise ValueError("You have to specify a tokenizer."   )
  
        super().__init__(lowerCAmelCase      ,      lowerCAmelCase   )
        a__     		=     self.image_processor
  
  
  
  
      def __call__(					self  :   Union[str, Any]      ,      lowerCAmelCase  :   int=None      ,      lowerCAmelCase  :   int=None      ,      lowerCAmelCase  :   int=None      ,      **lowerCAmelCase  :   Union[str, Any]   )	-> Dict:
  
        if text is None and images is None:
          raise ValueError("You have to specify either text or images. Both cannot be none."   )
  
        if text is not None:
          a__     		=     self.tokenizer(lowerCAmelCase      ,      return_tensors=lowerCAmelCase      ,      **lowerCAmelCase   )
  
        if images is not None:
          a__     		=     self.image_processor(lowerCAmelCase      ,      return_tensors=lowerCAmelCase      ,      **lowerCAmelCase   )
  
        if text is not None and images is not None:
          a__     		=     image_features.pixel_values
          return encoding
        elif text is not None:
          return encoding
        else:
          return BatchEncoding(data=dict(**lowerCAmelCase   )      ,      tensor_type=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   str      ,      *lowerCAmelCase  :   str      ,      **lowerCAmelCase  :   Union[str, Any]   )	-> int:
        return self.tokenizer.batch_decode(*lowerCAmelCase      ,      **lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[int]      ,      *lowerCAmelCase  :   Tuple      ,      **lowerCAmelCase  :   int   )	-> Any:
        return self.tokenizer.decode(*lowerCAmelCase      ,      **lowerCAmelCase   )
  
  
  
  
      @property
      def 						__lowerCamelCase (					self  :   str   )	-> Dict:
        a__     		=     self.tokenizer.model_input_names
        a__     		=     self.image_processor.model_input_names
        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )
  
  
  
  
      @property
      def 						__lowerCamelCase (					self  :   Tuple   )	-> Union[str, Any]:
        warnings.warn(
            "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."      ,      lowerCAmelCase      ,      )
        return self.image_processor_class
  
  
  
  
      @property
      def 						__lowerCamelCase (					self  :   List[Any]   )	-> Dict:
        warnings.warn(
            "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."      ,      lowerCAmelCase      ,      )
        return self.image_processor
  
  
style_context: def 				__lowercase	(						lowerCamelCase__ ,				lowerCamelCase__					)				->Optional[int]:
  
    '''simple docstring'''
  
  
  
  
    sequence.append(lowerCamelCase__					)
  
    a__     		=     0
    while sequence[index] != target:
      index += 1
  
    sequence.pop()
  
    if index == len(lowerCamelCase__					):
      return None
  
    return index
  
  
  if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE   						=    input("""Enter numbers separated by comma:\n""").strip()
       _SCREAMING_SNAKE_CASE   						=    [int(item) for item in user_input.split(""",""")]
  
       _SCREAMING_SNAKE_CASE   						=    input("""Enter a single number to be found in the list:\n""")
       _SCREAMING_SNAKE_CASE   						=    int(target_input)
       _SCREAMING_SNAKE_CASE   						=    sentinel_linear_search(sequence, target)
       if result is not None:
            print(F"""{target} found at positions: {result}""")
       else:
            print("""Not found""")
  
  