

"""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 platform

import numpy as np
import psutil
import torch

from accelerate import __version__ as version
from accelerate.commands.config import default_config_file, load_config_from_file

from ..utils import is_npu_available, is_xpu_available



def   lowercase_	(    _lowercase       :		str=None	):




					'''simple docstring'''






					if subparsers is not None:
										UpperCAmelCase			:   Any      =				subparsers.add_parser("env"	)
					else:
										UpperCAmelCase			:   int      =				argparse.ArgumentParser("Accelerate env command"	)

					parser.add_argument(
					    "--config_file"							,      default=_lowercase							,      help="The config file to use for the default values in the launching script."	)

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



def   lowercase_	(    _lowercase       :		Dict	):




					'''simple docstring'''






					UpperCAmelCase			:   List[str]      =				torch.__version__
					UpperCAmelCase			:   List[Any]      =				torch.cuda.is_available()
					UpperCAmelCase			:   List[Any]      =				is_xpu_available()
					UpperCAmelCase			:   int      =				is_npu_available()

					UpperCAmelCase			:   Optional[int]      =				"""Not found"""
					# Get the default from the config file.
					if args.config_file is not None or os.path.isfile(_lowercase	):
										UpperCAmelCase			:   List[str]      =				load_config_from_file(args.config_file	).to_dict()

					UpperCAmelCase			:   Optional[int]      =				{
					    """`Accelerate` version""": version,
					    """Platform""": platform.platform(),
					    """Python version""": platform.python_version(),
					    """Numpy version""": np.__version__,
					    """PyTorch version (GPU?)""": F"""{pt_version} ({pt_cuda_available})""",
					    """PyTorch XPU available""": str(_lowercase	),
					    """PyTorch NPU available""": str(_lowercase	),
					    """System RAM""": F"""{psutil.virtual_memory().total / 10_24 ** 3:.2f} GB""",
					}
					if pt_cuda_available:
										UpperCAmelCase			:   str      =				torch.cuda.get_device_name()

					print("\nCopy-and-paste the text below in your GitHub issue\n"	)
					print("\n".join([F"""- {prop}: {val}""" for prop, val in info.items()]	)	)

					print("- `Accelerate` default config:" if args.config_file is None else "- `Accelerate` config passed:"	)
					UpperCAmelCase			:   Optional[int]      =				(
					    """\n""".join([F"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]	)
					    if isinstance(_lowercase							,      _lowercase	)
					    else F"""\t{accelerate_config}"""
					)
					print(_lowercase	)

					UpperCAmelCase			:   Dict      =				accelerate_config

					return info



def   lowercase_	(    ):




					'''simple docstring'''






					UpperCAmelCase			:   Any      =				env_command_parser()
					UpperCAmelCase			:   Union[str, Any]      =				parser.parse_args()
					env_command(_lowercase	)
					return 0


if __name__ == "__main__":
	raise SystemExit(main())








"""simple docstring"""






def   lowercase_	(    _lowercase       :		str	):




					'''simple docstring'''






					if not all(x.isalpha() for x in string	):
										raise ValueError("String must only contain alphabetic characters."	)

					UpperCAmelCase			:   Optional[int]      =				sorted(string.lower()	)
					return len(_lowercase	) == len(set(_lowercase	)	)


if __name__ == "__main__":
	snake_case_   :   Tuple        =       input("""Enter a string """).strip()

	snake_case_   :   str        =       is_isogram(input_str)
	print(f'''{input_str} is {"an" if isogram else "not an"} isogram.''')


