"""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  _A(		lowerCAmelCase=None							):
							if subparsers is not None:
														A__       :     List[Any]								=			subparsers.add_parser("""env"""							)
							else:
														A__       :     int								=			argparse.ArgumentParser("""Accelerate env command"""							)

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

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

def  _A(		lowerCAmelCase							):
							A__       :     Any								=			torch.__version__
							A__       :     Union[str, Any]								=			torch.cuda.is_available()
							A__       :     List[str]								=			is_xpu_available()
							A__       :     Union[str, Any]								=			is_npu_available()

							A__       :     Optional[Any]								=			"""Not found"""
							# Get the default from the config file.
							if args.config_file is not None or os.path.isfile(lowerCAmelCase							):
														A__       :     Union[str, Any]								=			load_config_from_file(args.config_file							).to_dict()

							A__       :     str								=			{
							    """`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(lowerCAmelCase							),
							    """PyTorch NPU available""": str(lowerCAmelCase							),
							    """System RAM""": F'''{psutil.virtual_memory().total / 1024 ** 3:.2f} GB''',
							}
							if pt_cuda_available:
														A__       :     Tuple								=			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:"""							)
							A__       :     Optional[int]								=			(
							    """\n""".join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]							)
							    if isinstance(lowerCAmelCase			,  lowerCAmelCase							)
							    else F'''\t{accelerate_config}'''
							)
							print(lowerCAmelCase							)

							A__       :     str								=			accelerate_config

							return info

def  _A(		):
							A__       :     int								=			env_command_parser()
							A__       :     List[Any]								=			parser.parse_args()
							env_command(lowerCAmelCase							)
							return 0


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






"""simple docstring"""



import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin
class 						__UpperCAmelCase    (unittest.TestCase							,   __A     ):







			'''simple docstring'''





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			load_tool("""text-classification"""							)
										self.tool.setup()
										A__       :     Any								=			load_tool("""text-classification"""   ,      remote=snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     int								=			self.tool("""That's quite cool"""   ,      ["""positive""", """negative"""]							)
										self.assertEqual(snake_case_   ,      """positive"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			self.remote_tool("""That's quite cool"""   ,      ["""positive""", """negative"""]							)
										self.assertEqual(snake_case_   ,      """positive"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     str								=			self.tool(text="""That's quite cool"""   ,      labels=["""positive""", """negative"""]							)
										self.assertEqual(snake_case_   ,      """positive"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     int								=			self.remote_tool(text="""That's quite cool"""   ,      labels=["""positive""", """negative"""]							)
										self.assertEqual(snake_case_   ,      """positive"""							)





