
"""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 			_UpperCamelCase						(    _A=None   )     ->	Optional[int]:





    """simple docstring"""

    if subparsers is not None:
        _UpperCAmelCase        = subparsers.add_parser("""env"""   )
    else:
        _UpperCAmelCase        = argparse.ArgumentParser("""Accelerate env command"""   )

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

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


def 			_UpperCamelCase						(    _A   )     ->	Optional[Any]:





    """simple docstring"""

    _UpperCAmelCase        = torch.__version__
    _UpperCAmelCase        = torch.cuda.is_available()
    _UpperCAmelCase        = is_xpu_available()
    _UpperCAmelCase        = is_npu_available()

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

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

    _UpperCAmelCase        = accelerate_config

    return info


def 			_UpperCamelCase						(    )     ->	int:





    """simple docstring"""

    _UpperCAmelCase        = env_command_parser()
    _UpperCAmelCase        = parser.parse_args()
    env_command(_A   )
    return 0


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

"""simple docstring"""



import math
import unittest


def 			_UpperCamelCase						(    _A   )     ->	bool:





    """simple docstring"""

    assert isinstance(_A       ,   _A   ) and (
        number >= 0
    ), "'number' must been an int and positive"

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5       ,   int(math.sqrt(_A   ) + 1   )       ,   6   ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True




class 		a_    (			unittest.TestCase						):







    def   _snake_case       (      self      :							int  )		->Optional[int]:






        '''simple docstring'''






        self.assertTrue(is_prime(2  )  )
        self.assertTrue(is_prime(3  )  )
        self.assertTrue(is_prime(5  )  )
        self.assertTrue(is_prime(7  )  )
        self.assertTrue(is_prime(11  )  )
        self.assertTrue(is_prime(13  )  )
        self.assertTrue(is_prime(17  )  )
        self.assertTrue(is_prime(19  )  )
        self.assertTrue(is_prime(23  )  )
        self.assertTrue(is_prime(29  )  )







    def   _snake_case       (      self      :							Union[str, Any]  )		->Optional[Any]:






        '''simple docstring'''






        with self.assertRaises(__UpperCamelCase  ):
            is_prime(-19  )
        self.assertFalse(
            is_prime(0  )  ,       """Zero doesn't have any positive factors, primes must have exactly two."""  ,       )
        self.assertFalse(
            is_prime(1  )  ,       """One only has 1 positive factor, primes must have exactly two."""  ,       )
        self.assertFalse(is_prime(2 * 2  )  )
        self.assertFalse(is_prime(2 * 3  )  )
        self.assertFalse(is_prime(3 * 3  )  )
        self.assertFalse(is_prime(3 * 5  )  )
        self.assertFalse(is_prime(3 * 5 * 7  )  )


if __name__ == "__main__":
 unittest.main()