




import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType

class 		__lowerCAmelCase	(	__magic_name__ ):
							UpperCamelCase__					     =  ['''image_processor''', '''tokenizer''']
							UpperCamelCase__					     =  '''FlavaImageProcessor'''
							UpperCamelCase__					     =  ('''BertTokenizer''', '''BertTokenizerFast''')
							def __init__(						self						:List[str]		,      __magic_name__						:Tuple=None		,      __magic_name__						:Dict=None		,      **__magic_name__						:List[Any]				):







								'''simple docstring'''







								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."""		,      __magic_name__		,      )
									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 need to specify an `image_processor`."""				)
								if tokenizer is None:
									raise ValueError("""You need to specify a `tokenizer`."""				)

								super().__init__(__magic_name__		,      __magic_name__				)
								a										=							self.image_processor
							def __call__(						self						:Union[str, Any]		,      __magic_name__						:Optional[ImageInput] = None		,      __magic_name__						:Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None		,      __magic_name__						:bool = True		,      __magic_name__						:Union[bool, str, PaddingStrategy] = False		,      __magic_name__						:Union[bool, str, TruncationStrategy] = False		,      __magic_name__						:Optional[int] = None		,      __magic_name__						:int = 0		,      __magic_name__						:Optional[int] = None		,      __magic_name__						:Optional[bool] = None		,      __magic_name__						:Optional[bool] = None		,      __magic_name__						:Optional[bool] = None		,      __magic_name__						:Optional[bool] = None		,      __magic_name__						:bool = False		,      __magic_name__						:bool = False		,      __magic_name__						:bool = False		,      __magic_name__						:bool = False		,      __magic_name__						:bool = True		,      __magic_name__						:Optional[Union[str, TensorType]] = None		,      **__magic_name__						:int		,      ):







								'''simple docstring'''







								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(
									    text=__magic_name__		,      add_special_tokens=__magic_name__		,      padding=__magic_name__		,      truncation=__magic_name__		,      max_length=__magic_name__		,      stride=__magic_name__		,      pad_to_multiple_of=__magic_name__		,      return_token_type_ids=__magic_name__		,      return_attention_mask=__magic_name__		,      return_overflowing_tokens=__magic_name__		,      return_special_tokens_mask=__magic_name__		,      return_offsets_mapping=__magic_name__		,      return_length=__magic_name__		,      verbose=__magic_name__		,      return_tensors=__magic_name__		,      **__magic_name__		,      )
								if images is not None:
									a										=							self.image_processor(
									    __magic_name__		,      return_image_mask=__magic_name__		,      return_codebook_pixels=__magic_name__		,      return_tensors=__magic_name__		,      **__magic_name__		,      )

								if text is not None and images is not None:
									encoding.update(__magic_name__				)
									return encoding
								elif text is not None:
									return encoding
								else:
									return BatchEncoding(data=dict(**__magic_name__				)		,      tensor_type=__magic_name__				)
							def       lowerCamelCase__							(						self						:List[str]		,      *__magic_name__						:str		,      **__magic_name__						:str				):







								'''simple docstring'''







								return self.tokenizer.batch_decode(*__magic_name__		,      **__magic_name__				)
							def       lowerCamelCase__							(						self						:Union[str, Any]		,      *__magic_name__						:Tuple		,      **__magic_name__						:Union[str, Any]				):







								'''simple docstring'''







								return self.tokenizer.decode(*__magic_name__		,      **__magic_name__				)
							@property
							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







								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						:int				):







								'''simple docstring'''







								warnings.warn(
								    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""		,      __magic_name__		,      )
								return self.image_processor_class





							@property
							def       lowerCamelCase__							(						self						:List[Any]				):







								'''simple docstring'''







								warnings.warn(
								    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""		,      __magic_name__		,      )
								return self.image_processor







from __future__ import annotations





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       float:
	a										=							sorted(numsa + numsa    )
	a				, a										=							divmod(len(__lowerCamelCase    )							,			2    )
	if mod == 1:
		return all_numbers[div]
	else:
		return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		__UpperCamelCase					:       Tuple    					=      [float(x) for x in input("Enter the elements of first array: ").split()]
		__UpperCamelCase					:       List[Any]    					=      [float(x) for x in input("Enter the elements of second array: ").split()]
		print(F'The median of two arrays is: {median_of_two_arrays(array_a, array_a)}')

