



'''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    _SCREAMING_SNAKE_CASE  (       UpperCamelCase=None			):



    """simple docstring"""





    if subparsers is not None:
        lowerCAmelCase__ :  Any							      =					subparsers.add_parser("""env"""			)
    else:
        lowerCAmelCase__ :  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    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





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

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

    lowerCAmelCase__ :  Optional[Any]							      =					{
        """`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 / 1024 ** 3:.2f} GB""",
    }
    if pt_cuda_available:
        lowerCAmelCase__ :  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:"""			)
    lowerCAmelCase__ :  Dict							      =					(
        """\n""".join([f"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]			)
        if isinstance(UpperCamelCase							,    UpperCamelCase			)
        else f"""\t{accelerate_config}"""
    )
    print(UpperCamelCase			)

    lowerCAmelCase__ :  str							      =					accelerate_config

    return info
def    _SCREAMING_SNAKE_CASE  (       ):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[Any]							      =					env_command_parser()
    lowerCAmelCase__ :  Optional[Any]							      =					parser.parse_args()
    env_command(UpperCamelCase			)
    return 0


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








import os

import pytest

from transformers.dynamic_module_utils import get_imports


_lowerCamelCase	:		Any							       =   """
import os
"""

_lowerCamelCase	:		Optional[int]							       =   """
def foo():
    import os
    return False
"""

_lowerCamelCase	:		List[Any]							       =   """
def foo():
    def bar():
        if True:
            import os
        return False
    return bar()
"""

_lowerCamelCase	:		List[Any]							       =   """
import os

try:
    import bar
except ImportError:
    raise ValueError()
"""

_lowerCamelCase	:		Union[str, Any]							       =   """
import os

def foo():
    try:
        import bar
    except ImportError:
        raise ValueError()
"""

_lowerCamelCase	:		List[Any]							       =   """
import os

try:
    import bar
except (ImportError, AttributeError):
    raise ValueError()
"""

_lowerCamelCase	:		List[Any]							       =   """
import os

try:
    import bar
except ImportError as e:
    raise ValueError()
"""

_lowerCamelCase	:		str							       =   """
import os

try:
    import bar
except:
    raise ValueError()
"""

_lowerCamelCase	:		Optional[Any]							       =   """
import os

try:
    import bar
    import baz
except ImportError:
    raise ValueError()
"""

_lowerCamelCase	:		Any							       =   """
import os

try:
    import bar
    import baz
except ImportError:
    x = 1
    raise ValueError()
"""

_lowerCamelCase	:		Dict							       =   [
    TOP_LEVEL_IMPORT,
    IMPORT_IN_FUNCTION,
    DEEPLY_NESTED_IMPORT,
    TOP_LEVEL_TRY_IMPORT,
    GENERIC_EXCEPT_IMPORT,
    MULTILINE_TRY_IMPORT,
    MULTILINE_BOTH_IMPORT,
    MULTIPLE_EXCEPTS_IMPORT,
    EXCEPT_AS_IMPORT,
    TRY_IMPORT_IN_FUNCTION,
]







@pytest.mark.parametrize('''case''' ,				lowercase_						)
def SCREAMING_SNAKE_CASE				(       lowercase_ ,				lowercase_						)   ->       int:



       """simple docstring"""

       A__       =    os.path.join(lowercase_ ,				'''test_file.py'''						)
       with open(lowercase_ ,				'''w'''						) as _tmp_file:
              _tmp_file.write(lowercase_						)

       A__       =    get_imports(lowercase_						)
       assert parsed_imports == ["os"]


