


'''simple docstring'''






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 lowerCamelCase__      (						__lowerCamelCase	:							List[Any]=None							):







   '''simple docstring'''




   if subparsers is not None:
      _UpperCAmelCase       :       Optional[int]							   =subparsers.add_parser('env'							)
   else:
      _UpperCAmelCase       :       List[Any]							   =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 lowerCamelCase__      (						__lowerCamelCase	:							str							):







   '''simple docstring'''




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

   _UpperCAmelCase       :       Union[str, Any]							   ="Not found"
   # Get the default from the config file.
   if args.config_file is not None or os.path.isfile(_UpperCAmelCase							):
      _UpperCAmelCase       :       Union[str, Any]							   =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       :       int							   =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       :       Tuple							   =(
       "\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       :       Any							   =accelerate_config

   return info





def lowerCamelCase__      (						):







   '''simple docstring'''




   _UpperCAmelCase       :       Tuple							   =env_command_parser()
   _UpperCAmelCase       :       Dict							   =parser.parse_args()
   env_command(_UpperCAmelCase							)
   return 0


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









'''simple docstring'''






from __future__ import annotations





def lowerCamelCase__      (						__lowerCamelCase	:							list[int]							):







   '''simple docstring'''




   if not nums:
      return 0
   _UpperCAmelCase       :       Tuple							   =nums[0]
   _UpperCAmelCase       :       int							   =0
   for num in nums[1:]:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       Optional[int]							   =(
          max_excluding + num,
          max(__lowerCamelCase	,   __lowerCamelCase							),
      )
   return max(__lowerCamelCase	,   __lowerCamelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

