

'''simple docstring'''
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 							A__    (       A__  ):
  A__		 =				['image_processor', 'tokenizer']
  A__		 =				'FlavaImageProcessor'
  A__		 =				('BertTokenizer', 'BertTokenizerFast')





  def __init__(		self      :	Optional[Any]							,					_a      :	Tuple=None							,					_a      :	Optional[Any]=None							,					**_a      :	List[str] )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =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							,					)
            _SCREAMING_SNAKE_CASE							    =kwargs.pop('feature_extractor' )

       _SCREAMING_SNAKE_CASE							    =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 )
       _SCREAMING_SNAKE_CASE							    =self.image_processor





  def __call__(		self      :	List[str]							,					_a      :	Optional[ImageInput] = None							,					_a      :	Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None							,					_a      :	bool = True							,					_a      :	Union[bool, str, PaddingStrategy] = False							,					_a      :	Union[bool, str, TruncationStrategy] = False							,					_a      :	Optional[int] = None							,					_a      :	int = 0							,					_a      :	Optional[int] = None							,					_a      :	Optional[bool] = None							,					_a      :	Optional[bool] = None							,					_a      :	Optional[bool] = None							,					_a      :	Optional[bool] = None							,					_a      :	bool = False							,					_a      :	bool = False							,					_a      :	bool = False							,					_a      :	bool = False							,					_a      :	bool = True							,					_a      :	Optional[Union[str, TensorType]] = None							,					**_a      :	str							,					)	->    Tuple:





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

       if text is not None and images is not None:
            encoding.update(_a )
            return encoding
       elif text is not None:
            return encoding
       else:
            return BatchEncoding(data=dict(**_a )							,					tensor_type=_a )





  def 						A  (		self      :	Dict							,					*_a      :	Optional[Any]							,					**_a      :	Tuple )	->    List[Any]:





       '''simple docstring'''






       return self.tokenizer.batch_decode(*_a							,					**_a )





  def 						A  (		self      :	List[str]							,					*_a      :	Optional[Any]							,					**_a      :	List[Any] )	->    List[Any]:





       '''simple docstring'''






       return self.tokenizer.decode(*_a							,					**_a )





  @property
  def 						A  (		self      :	Any )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.tokenizer.model_input_names
       _SCREAMING_SNAKE_CASE							    =self.image_processor.model_input_names
       return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )





  @property
  def 						A  (		self      :	Optional[int] )	->    Dict:





       '''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 						A  (		self      :	Optional[Any] )	->    Dict:





       '''simple docstring'''






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



'''simple docstring'''
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def        _lowerCAmelCase					(						)      ->			Any:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =ArgumentParser(
         description=(
             'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
         )				)

     # Optional arguments for the launch helper
     parser.add_argument('--num_cores'							, type=_UpperCamelCase							, default=1							, help='Number of TPU cores to use (1 or 8).'				)

     # positional
     parser.add_argument(
         'training_script'							, type=_UpperCamelCase							, help=(
             'The full path to the single TPU training '
             'program/script to be launched in parallel, '
             'followed by all the arguments for the '
             'training script'
         )							, )

     # rest from the training program
     parser.add_argument('training_script_args'							, nargs=_UpperCamelCase				)

     return parser.parse_args()


def        _lowerCAmelCase					(						)      ->			Optional[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =parse_args()

     # Import training_script as a module.
     _SCREAMING_SNAKE_CASE							    =Path(args.training_script				)
     sys.path.append(str(script_fpath.parent.resolve()				)				)
     _SCREAMING_SNAKE_CASE							    =script_fpath.stem
     _SCREAMING_SNAKE_CASE							    =importlib.import_module(_UpperCamelCase				)

     # Patch sys.argv
     _SCREAMING_SNAKE_CASE							    =[args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores				)]

     xmp.spawn(mod._mp_fn							, args=()							, nprocs=args.num_cores				)


if __name__ == "__main__":
     main()
