






# 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 typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_torch_available
from ...utils import OptionalDependencyNotAvailable


__snake_case						  =		{
    """configuration_gpt_neox_japanese""": ["""GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTNeoXJapaneseConfig"""],
    """tokenization_gpt_neox_japanese""": ["""GPTNeoXJapaneseTokenizer"""],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __snake_case						  =		[
           """GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """GPTNeoXJapaneseForCausalLM""",
           """GPTNeoXJapaneseLayer""",
           """GPTNeoXJapaneseModel""",
           """GPTNeoXJapanesePreTrainedModel""",
       ]


if TYPE_CHECKING:
       from .configuration_gpt_neox_japanese import GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXJapaneseConfig
       from .tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_gpt_neox_japanese import (
                  GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
                  GPTNeoXJapaneseForCausalLM,
                  GPTNeoXJapaneseLayer,
                  GPTNeoXJapaneseModel,
                  GPTNeoXJapanesePreTrainedModel,
              )


else:
       import sys

       __snake_case						  =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

