






# 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     snake_case   (UpperCAmelCase__=None    )			->							Any:
  if subparsers is not None:
    UpperCamelCase_:   Optional[Any]        =							subparsers.add_parser('env'    )
  else:
    UpperCamelCase_:   List[str]        =							argparse.ArgumentParser('Accelerate env command'    )

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

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

def     snake_case   (UpperCAmelCase__    )			->							Optional[int]:
  UpperCamelCase_:   Dict        =							torch.__version__
  UpperCamelCase_:   Optional[Any]        =							torch.cuda.is_available()
  UpperCamelCase_:   Optional[int]        =							is_xpu_available()
  UpperCamelCase_:   str        =							is_npu_available()

  UpperCamelCase_:   str        =							'Not found'
  # Get the default from the config file.
  if args.config_file is not None or os.path.isfile(UpperCAmelCase__    ):
    UpperCamelCase_:   int        =							load_config_from_file(args.config_file    ).to_dict()

  UpperCamelCase_:   List[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(UpperCAmelCase__    ),
      'PyTorch NPU available': str(UpperCAmelCase__    ),
      'System RAM': F'''{psutil.virtual_memory().total / 1_0_2_4 ** 3:.2f} GB''',
  }
  if pt_cuda_available:
    UpperCamelCase_:   List[Any]        =							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[Any]        =							(
      '\n'.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]    )
      if isinstance(UpperCAmelCase__      ,       UpperCAmelCase__    )
      else F'''\t{accelerate_config}'''
  )
  print(UpperCAmelCase__    )

  UpperCamelCase_:   str        =							accelerate_config

  return info

def     snake_case   ()			->							int:
  UpperCamelCase_:   Tuple        =							env_command_parser()
  UpperCamelCase_:   Optional[int]        =							parser.parse_args()
  env_command(UpperCAmelCase__    )
  return 0


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






'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def    a__							(							)						->						Tuple:





     """simple docstring"""

     import os as original_os
     from os import path as original_path
     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join

     _UpperCamelCase							       =			'''__test_patch_submodule_mock__'''
     with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
          # Every way to access os.path.join must be patched, and the rest must stay untouched

          # check os.path.join
          assert isinstance(_test_patching.os,   _PatchedModuleObj )
          assert isinstance(_test_patching.os.path,   _PatchedModuleObj )
          assert _test_patching.os.path.join is mock

          # check path.join
          assert isinstance(_test_patching.path,   _PatchedModuleObj )
          assert _test_patching.path.join is mock

          # check join
          assert _test_patching.join is mock

          # check that the other attributes are untouched
          assert _test_patching.os.rename is original_rename
          assert _test_patching.path.dirname is original_dirname
          assert _test_patching.os.path.dirname is original_dirname

          # Even renamed modules or objects must be patched

          # check renamed_os.path.join
          assert isinstance(_test_patching.renamed_os,   _PatchedModuleObj )
          assert isinstance(_test_patching.renamed_os.path,   _PatchedModuleObj )
          assert _test_patching.renamed_os.path.join is mock

          # check renamed_path.join
          assert isinstance(_test_patching.renamed_path,   _PatchedModuleObj )
          assert _test_patching.renamed_path.join is mock

          # check renamed_join
          assert _test_patching.renamed_join is mock

          # check that the other attributes are untouched
          assert _test_patching.renamed_os.rename is original_rename
          assert _test_patching.renamed_path.dirname is original_dirname
          assert _test_patching.renamed_os.path.dirname is original_dirname

     # check that everthing is back to normal when the patch is over

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join







def    a__							(							)						->						Tuple:





     """simple docstring"""

     assert _test_patching.open is open

     _UpperCamelCase							       =			'''__test_patch_submodule_builtin_mock__'''
     # _test_patching has "open" in its globals
     assert _test_patching.open is open
     with patch_submodule(_test_patching,   '''open''',   lowercase ):
          assert _test_patching.open is mock

     # check that everthing is back to normal when the patch is over

     assert _test_patching.open is open







def    a__							(							)						->						Optional[Any]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_missing_mock__'''
     with patch_submodule(_test_patching,   '''pandas.read_csv''',   lowercase ):
          pass







def    a__							(							)						->						Optional[int]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_missing_builtin_mock__'''
     # _test_patching doesn't have "len" in its globals
     assert getattr(_test_patching,   '''len''',   lowercase ) is None
     with patch_submodule(_test_patching,   '''len''',   lowercase ):
          assert _test_patching.len is mock
     assert _test_patching.len is len







def    a__							(							)						->						Optional[Any]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_start_and_stop_mock__'''
     _UpperCamelCase							       =			patch_submodule(_test_patching,   '''open''',   lowercase )
     assert _test_patching.open is open
     patch.start()
     assert _test_patching.open is mock
     patch.stop()
     assert _test_patching.open is open







def    a__							(							)						->						List[str]:





     """simple docstring"""

     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     _UpperCamelCase							       =			'''__test_patch_submodule_successive_join__'''
     _UpperCamelCase							       =			'''__test_patch_submodule_successive_dirname__'''
     _UpperCamelCase							       =			'''__test_patch_submodule_successive_rename__'''
     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename

     with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
          with patch_submodule(_test_patching,   '''os.rename''',   lowercase ):
               with patch_submodule(_test_patching,   '''os.path.dirname''',   lowercase ):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

    # try another order
     with patch_submodule(_test_patching,   '''os.rename''',   lowercase ):
          with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
               with patch_submodule(_test_patching,   '''os.path.dirname''',   lowercase ):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename







def    a__							(							)						->						str:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_doesnt_exist_mock__'''
     with patch_submodule(_test_patching,   '''__module_that_doesn_exist__.__attribute_that_doesn_exist__''',   lowercase ):
          pass
     with patch_submodule(_test_patching,   '''os.__attribute_that_doesn_exist__''',   lowercase ):
          pass



