




# 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


__A								=       "Run commands across TPU VMs for initial setup before running `accelerate launch`."







def      lowerCamelCase_						(			UpperCamelCase__							: Tuple=None )	->			str:





				"""simple docstring"""


				if subparsers is not None:
								__lowerCamelCase									=       subparsers.add_parser('tpu-config'					,	description=_description )
				else:
								__lowerCamelCase									=       argparse.ArgumentParser('Accelerate tpu-config command'					,	description=_description )
				# Core arguments
				__lowerCamelCase									=       parser.add_argument_group(
				    'Config Arguments'					,	'Arguments that can be configured through `accelerate config`.' )
				config_args.add_argument(
				    '--config_file'					,	type=UpperCamelCase__					,	default=UpperCamelCase__					,	help='Path to the config file to use for accelerate.'					,	)
				config_args.add_argument(
				    '--tpu_name'					,	default=UpperCamelCase__					,	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=UpperCamelCase__					,	help='The zone of the TPU to use. If not specified, will use the zone specified in the config file.'					,	)
				__lowerCamelCase									=       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=UpperCamelCase__					,	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=UpperCamelCase__ )
				return parser







def      lowerCamelCase_						(			UpperCamelCase__							: Any )	->			List[str]:





				"""simple docstring"""


				__lowerCamelCase									=       None

				# Get the default from the config file if it exists.
				if args.config_file is not None or os.path.isfile(UpperCamelCase__ ):
								__lowerCamelCase									=       load_config_from_file(args.config_file )
								if not args.command_file and defaults.command_file is not None and not args.command:
												__lowerCamelCase									=       defaults.command_file
								if not args.command and defaults.commands is not None:
												__lowerCamelCase									=       defaults.commands
								if not args.tpu_name:
												__lowerCamelCase									=       defaults.tpu_name
								if not args.tpu_zone:
												__lowerCamelCase									=       defaults.tpu_zone
				if args.accelerate_version == "dev":
								__lowerCamelCase									=       'git+https://github.com/huggingface/accelerate.git'
				elif args.accelerate_version == "latest":
								__lowerCamelCase									=       'accelerate -U'
				elif isinstance(parse(args.accelerate_version )					,	UpperCamelCase__ ):
								__lowerCamelCase									=       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:
												__lowerCamelCase									=       [f.read().splitlines()]

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

				# Then send it to gcloud
				# Eventually try to use google-api-core to do this instead of subprocess
				__lowerCamelCase									=       ['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(UpperCamelCase__ )}""" )
								return
				subprocess.run(UpperCamelCase__ )
				print('Successfully setup pod.' )







def      lowerCamelCase_						(			)	->			int:





				"""simple docstring"""


				__lowerCamelCase									=       tpu_command_parser()
				__lowerCamelCase									=       parser.parse_args()

				tpu_command_launcher(UpperCamelCase__ )








from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase







def      lowerCamelCase_						(			UpperCamelCase__							: str )	->			None:





				"""simple docstring"""


				__lowerCamelCase			,		__lowerCamelCase									=       analyze_text(UpperCamelCase__ )
				__lowerCamelCase									=       list(' ' + ascii_lowercase )
				# what is our total sum of probabilities.
				__lowerCamelCase									=       sum(single_char_strings.values() )

				# one length string
				__lowerCamelCase									=       0
				# for each alpha we go in our dict and if it is in it we calculate entropy
				for ch in my_alphas:
								if ch in single_char_strings:
												__lowerCamelCase									=       single_char_strings[ch]
												__lowerCamelCase									=       my_str / all_sum
												my_fir_sum += prob * math.loga(UpperCamelCase__ )  # entropy formula.

    # print entropy
				print(F"""{round(-1 * my_fir_sum ):.1f}""" )

				# two len string
				__lowerCamelCase									=       sum(two_char_strings.values() )
				__lowerCamelCase									=       0
				# for each alpha (two in size) calculate entropy.
				for cha in my_alphas:
								for cha in my_alphas:
												__lowerCamelCase									=       cha + cha
												if sequence in two_char_strings:
																__lowerCamelCase									=       two_char_strings[sequence]
																__lowerCamelCase									=       int(UpperCamelCase__ ) / all_sum
																my_sec_sum += prob * math.loga(UpperCamelCase__ )

    # print second entropy
				print(F"""{round(-1 * my_sec_sum ):.1f}""" )

				# print the difference between them
				print(F"""{round((-1 * my_sec_sum) - (-1 * my_fir_sum) ):.1f}""" )







def      lowerCamelCase_						(			UpperCamelCase__							: str )	->			tuple[dict, dict]:





				"""simple docstring"""


				__lowerCamelCase									=       Counter()  # type: ignore
				__lowerCamelCase									=       Counter()  # type: ignore
				single_char_strings[text[-1]] += 1

				# first case when we have space at start.
				two_char_strings[" " + text[0]] += 1
				for i in range(0					,	len(UpperCamelCase__ ) - 1 ):
								single_char_strings[text[i]] += 1
								two_char_strings[text[i : i + 2]] += 1
				return single_char_strings, two_char_strings







def      lowerCamelCase_						(			)	->			Dict:





				"""simple docstring"""


				import doctest

				doctest.testmod()
				# text = (
				#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
				#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
				#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
				#     "beloved evident through no service elderly is. Blind there if every no so "
				#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
				#     "of message cottage windows do besides against uncivil.  Delightful "
				#     "unreserved impossible few estimating men favourable see entreaties. She "
				#     "propriety immediate was improving. He or entrance humoured likewise "
				#     "moderate. Much nor game son say feel. Fat make met can must form into "
				#     "gate. Me we offending prevailed discovery. "
				# )

				# calculate_prob(text)


if __name__ == "__main__":
					main()


