





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCAmelCase			:List[Any]	 =     {'configuration_vilt': ['VILT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViltConfig']}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase			:Union[str, Any]	 =     ['ViltFeatureExtractor']
							__lowerCAmelCase			:List[Any]	 =     ['ViltImageProcessor']
							__lowerCAmelCase			:Dict	 =     ['ViltProcessor']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase			:List[str]	 =     [
							    'VILT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'ViltForImageAndTextRetrieval',
							    'ViltForImagesAndTextClassification',
							    'ViltForTokenClassification',
							    'ViltForMaskedLM',
							    'ViltForQuestionAnswering',
							    'ViltLayer',
							    'ViltModel',
							    'ViltPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_vilt import ViltFeatureExtractor
														from .image_processing_vilt import ViltImageProcessor
														from .processing_vilt import ViltProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_vilt import (
														    VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ViltForImageAndTextRetrieval,
														    ViltForImagesAndTextClassification,
														    ViltForMaskedLM,
														    ViltForQuestionAnswering,
														    ViltForTokenClassification,
														    ViltLayer,
														    ViltModel,
														    ViltPreTrainedModel,
														)


else:
							import sys

							__lowerCAmelCase			:Dict	 =     _LazyModule(__name__, globals()['__file__'], _import_structure)






import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp







def  A					(				):
					_snake_case							:       Optional[Any]												= 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  A					(				):
					_snake_case							:       Any												= parse_args()

					# Import training_script as a module.
					_snake_case							:       Any												= Path(args.training_script					)
					sys.path.append(str(script_fpath.parent.resolve()					)					)
					_snake_case							:       Tuple												= script_fpath.stem
					_snake_case							:       str												= importlib.import_module(UpperCAmelCase					)

					# Patch sys.argv
					_snake_case							:       str												= [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()