

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

import torch_xla.distributed.xla_multiprocessing as xmp





def 					lowercase_ (    )     -> Optional[Any]:





				'''simple docstring'''


				snake_case__      :Union[str, 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=lowercase__	,	default=1	,	help="Number of TPU cores to use (1 or 8)."      )

				# positional
				parser.add_argument(
				    "training_script"	,	type=lowercase__	,	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=lowercase__      )

				return parser.parse_args()





def 					lowercase_ (    )     -> List[str]:





				'''simple docstring'''


				snake_case__      :Dict         =   parse_args()

				# Import training_script as a module.
				snake_case__      :List[Any]         =   Path(args.training_script      )
				sys.path.append(str(script_fpath.parent.resolve()      )      )
				snake_case__      :List[str]         =   script_fpath.stem
				snake_case__      :Optional[Any]         =   importlib.import_module(lowercase__      )

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







from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
	if not (is_transformers_available() and is_torch_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
	from .multicontrolnet import MultiControlNetModel
	from .pipeline_controlnet import StableDiffusionControlNetPipeline
	from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
	from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
	from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline