code: 
  
  
  
  """simple docstring"""
  
  
  
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       _UpperCamelCase		):
        __SCREAMING_SNAKE_CASE		:     Union[str, Any]				  =				['image_processor', 'tokenizer']
        __SCREAMING_SNAKE_CASE		:     Optional[int]				  =				'EfficientNetImageProcessor'
        __SCREAMING_SNAKE_CASE		:     List[Any]				  =				('BertTokenizer', 'BertTokenizerFast')
  
  
  
        def __init__(  self  :			Tuple  ,			A  :			str  ,			A  :			List[str]		):
             super().__init__(A  ,			A		)
  
  
  
        def __call__(  self  :			str  ,			A  :			List[str]=None  ,			A  :			str=None  ,			A  :			str="max_length"  ,			A  :			Optional[int]=6_4  ,			A  :			Dict=None  ,			**A  :			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:
                  _UpperCAmelCase    :			Optional[int]              =					self.tokenizer(
                      A  ,			padding=A  ,			max_length=A  ,			return_tensors=A  ,			**A		)
  
             if images is not None:
                  _UpperCAmelCase    :			Tuple              =					self.image_processor(A  ,			return_tensors=A  ,			**A		)
  
             if text is not None and images is not None:
                  _UpperCAmelCase    :			Any              =					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  :			str  ,			*A  :			Tuple  ,			**A  :			Optional[Any]		):
             return self.tokenizer.batch_decode(*A  ,			**A		)
  
  
  
        def 		snake_case_      (  self  :			Optional[int]  ,			*A  :			Optional[Any]  ,			**A  :			int		):
             return self.tokenizer.decode(*A  ,			**A		)
  
  
  
        @property
        def 		snake_case_      (  self  :			Tuple		):
             _UpperCAmelCase    :			Tuple              =					self.tokenizer.model_input_names
             _UpperCAmelCase    :			Tuple              =					self.image_processor.model_input_names
             return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import sys
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int		,						SCREAMING_SNAKE_CASE__			:		list[int]       )						->     int:
  
  
  
  
  
       '''simple docstring'''
  
       if not numbers:
            return 0
       if target == 0 and target in numbers:
            return 0
       if not isinstance(SCREAMING_SNAKE_CASE__		,						(list, tuple)       ) or not all(
           isinstance(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       ) for number in numbers       ):
            raise ValueError("numbers must be an iterable of integers"       )
  
       _UpperCAmelCase    :			List[Any]              =					0
       _UpperCAmelCase    :			str              =					sys.maxsize
  
       while right < len(SCREAMING_SNAKE_CASE__       ):
            curr_sum += numbers[right]
            while curr_sum >= target and left <= right:
                 _UpperCAmelCase    :			Any              =					min(SCREAMING_SNAKE_CASE__		,						right - left + 1       )
                 curr_sum -= numbers[left]
                 left += 1
            right += 1
  
       return 0 if min_len == sys.maxsize else min_len
  