



'''simple docstring'''




# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


UpperCamelCase__ :			Optional[Any]												=				'''Run commands across TPU VMs for initial setup before running `accelerate launch`.'''


def        lowerCAmelCase_     (			_lowerCamelCase:     Optional[int]=None      ):
		if subparsers is not None:
				__SCREAMING_SNAKE_CASE :	int					 =	subparsers.add_parser("""tpu-config""" ,   description=_description      )
		else:
				__SCREAMING_SNAKE_CASE :	str					 =	argparse.ArgumentParser("""Accelerate tpu-config command""" ,   description=_description      )
		# Core arguments
		__SCREAMING_SNAKE_CASE :	Any					 =	parser.add_argument_group(
		    """Config Arguments""" ,   """Arguments that can be configured through `accelerate config`."""      )
		config_args.add_argument(
		    """--config_file""" ,   type=_lowerCamelCase ,   default=_lowerCamelCase ,   help="""Path to the config file to use for accelerate.""" ,   )
		config_args.add_argument(
		    """--tpu_name""" ,   default=_lowerCamelCase ,   help="""The name of the TPU to use. If not specified, will use the TPU specified in the config file.""" ,   )
		config_args.add_argument(
		    """--tpu_zone""" ,   default=_lowerCamelCase ,   help="""The zone of the TPU to use. If not specified, will use the zone specified in the config file.""" ,   )
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	parser.add_argument_group("""TPU Arguments""" ,   """Arguments for options ran inside the TPU."""      )
		pod_args.add_argument(
		    """--use_alpha""" ,   action="""store_true""" ,   help="""Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.""" ,   )
		pod_args.add_argument(
		    """--command_file""" ,   default=_lowerCamelCase ,   help="""The path to the file containing the commands to run on the pod on startup.""" ,   )
		pod_args.add_argument(
		    """--command""" ,   action="""append""" ,   nargs="""+""" ,   help="""A command to run on the pod. Can be passed multiple times.""" ,   )
		pod_args.add_argument(
		    """--install_accelerate""" ,   action="""store_true""" ,   help="""Whether to install accelerate on the pod. Defaults to False.""" ,   )
		pod_args.add_argument(
		    """--accelerate_version""" ,   default="""latest""" ,   help="""The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify 'dev' to install from GitHub.""" ,   )
		pod_args.add_argument(
		    """--debug""" ,   action="""store_true""" ,   help="""If set, will print the command that would be run instead of running it."""      )

		if subparsers is not None:
				parser.set_defaults(func=_lowerCamelCase      )
		return parser


def        lowerCAmelCase_     (			_lowerCamelCase:     int      ):
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	None

		# Get the default from the config file if it exists.
		if args.config_file is not None or os.path.isfile(_lowerCamelCase      ):
				__SCREAMING_SNAKE_CASE :	Tuple					 =	load_config_from_file(args.config_file      )
				if not args.command_file and defaults.command_file is not None and not args.command:
						__SCREAMING_SNAKE_CASE :	List[Any]					 =	defaults.command_file
				if not args.command and defaults.commands is not None:
						__SCREAMING_SNAKE_CASE :	Tuple					 =	defaults.commands
				if not args.tpu_name:
						__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	defaults.tpu_name
				if not args.tpu_zone:
						__SCREAMING_SNAKE_CASE :	str					 =	defaults.tpu_zone
		if args.accelerate_version == "dev":
				__SCREAMING_SNAKE_CASE :	Any					 =	"""git+https://github.com/huggingface/accelerate.git"""
		elif args.accelerate_version == "latest":
				__SCREAMING_SNAKE_CASE :	List[str]					 =	"""accelerate -U"""
		elif isinstance(parse(args.accelerate_version      ) ,   _lowerCamelCase      ):
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	F"accelerate=={args.accelerate_version}"

		if not args.command_file and not args.command:
				raise ValueError("""You must specify either a command file or a command to run on the pod."""      )

		if args.command_file:
				with open(args.command_file ,   """r"""      ) as f:
						__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	[f.read().splitlines()]

    # To turn list of lists into list of strings
		if isinstance(args.command[0] ,   _lowerCamelCase      ):
				__SCREAMING_SNAKE_CASE :	int					 =	[line for cmd in args.command for line in cmd]
		# Default to the shared folder and install accelerate
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	["""cd /usr/share"""]
		if args.install_accelerate:
				new_cmd += [F"pip install {args.accelerate_version}"]
		new_cmd += args.command
		__SCREAMING_SNAKE_CASE :	str					 =	"""; """.join(_lowerCamelCase      )

		# Then send it to gcloud
		# Eventually try to use google-api-core to do this instead of subprocess
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	["""gcloud"""]
		if args.use_alpha:
				cmd += ["alpha"]
		cmd += [
		    "compute",
		    "tpus",
		    "tpu-vm",
		    "ssh",
		    args.tpu_name,
		    "--zone",
		    args.tpu_zone,
		    "--command",
		    args.command,
		    "--worker",
		    "all",
		]
		if args.debug:
				print(F"Running {' '.join(_lowerCamelCase      )}"      )
				return
		subprocess.run(_lowerCamelCase      )
		print("""Successfully setup pod."""      )


def        lowerCAmelCase_     (			):
		__SCREAMING_SNAKE_CASE :	int					 =	tpu_command_parser()
		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	parser.parse_args()

		tpu_command_launcher(_lowerCamelCase      )




'''simple docstring'''




# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


UpperCamelCase__ :			Tuple												=				'''3'''

print('''Python version:''', sys.version)
print('''transformers version:''', transformers.__version__)

try:
						import torch

						print('''Torch version:''', torch.__version__)
						print('''Cuda available:''', torch.cuda.is_available())
						print('''Cuda version:''', torch.version.cuda)
						print('''CuDNN version:''', torch.backends.cudnn.version())
						print('''Number of GPUs available:''', torch.cuda.device_count())
						print('''NCCL version:''', torch.cuda.nccl.version())
except ImportError:
						print('''Torch version:''', None)

try:
						import deepspeed

						print('''DeepSpeed version:''', deepspeed.__version__)
except ImportError:
						print('''DeepSpeed version:''', None)

try:
						import tensorflow as tf

						print('''TensorFlow version:''', tf.__version__)
						print('''TF GPUs available:''', bool(tf.config.list_physical_devices('''GPU''')))
						print('''Number of TF GPUs available:''', len(tf.config.list_physical_devices('''GPU''')))
except ImportError:
						print('''TensorFlow version:''', None)