





import random




def    __UpperCAmelCase(      lowercase_      ):
       _lowerCamelCase							:     int	=		num - 1
       _lowerCamelCase							:     Tuple	=		0

       while s % 2 == 0:
              _lowerCamelCase							:     Tuple	=		s // 2
              t += 1

       for _ in range(5      ):
              _lowerCamelCase							:     Any	=		random.randrange(2 ,    num - 1      )
              _lowerCamelCase							:     Optional[Any]	=		pow(lowercase_ ,    lowercase_ ,    lowercase_      )
              if v != 1:
                     _lowerCamelCase							:     str	=		0
                     while v != (num - 1):
                            if i == t - 1:
                                   return False
                            else:
                                   _lowerCamelCase							:     Dict	=		i + 1
                                   _lowerCamelCase							:     Optional[Any]	=		(v**2) % num
       return True




def    __UpperCAmelCase(      lowercase_      ):
       if num < 2:
              return False

       _lowerCamelCase							:     List[str]	=		[
           2,
           3,
           5,
           7,
           11,
           13,
           17,
           19,
           23,
           29,
           31,
           37,
           41,
           43,
           47,
           53,
           59,
           61,
           67,
           71,
           73,
           79,
           83,
           89,
           97,
           1_01,
           1_03,
           1_07,
           1_09,
           1_13,
           1_27,
           1_31,
           1_37,
           1_39,
           1_49,
           1_51,
           1_57,
           1_63,
           1_67,
           1_73,
           1_79,
           1_81,
           1_91,
           1_93,
           1_97,
           1_99,
           2_11,
           2_23,
           2_27,
           2_29,
           2_33,
           2_39,
           2_41,
           2_51,
           2_57,
           2_63,
           2_69,
           2_71,
           2_77,
           2_81,
           2_83,
           2_93,
           3_07,
           3_11,
           3_13,
           3_17,
           3_31,
           3_37,
           3_47,
           3_49,
           3_53,
           3_59,
           3_67,
           3_73,
           3_79,
           3_83,
           3_89,
           3_97,
           4_01,
           4_09,
           4_19,
           4_21,
           4_31,
           4_33,
           4_39,
           4_43,
           4_49,
           4_57,
           4_61,
           4_63,
           4_67,
           4_79,
           4_87,
           4_91,
           4_99,
           5_03,
           5_09,
           5_21,
           5_23,
           5_41,
           5_47,
           5_57,
           5_63,
           5_69,
           5_71,
           5_77,
           5_87,
           5_93,
           5_99,
           6_01,
           6_07,
           6_13,
           6_17,
           6_19,
           6_31,
           6_41,
           6_43,
           6_47,
           6_53,
           6_59,
           6_61,
           6_73,
           6_77,
           6_83,
           6_91,
           7_01,
           7_09,
           7_19,
           7_27,
           7_33,
           7_39,
           7_43,
           7_51,
           7_57,
           7_61,
           7_69,
           7_73,
           7_87,
           7_97,
           8_09,
           8_11,
           8_21,
           8_23,
           8_27,
           8_29,
           8_39,
           8_53,
           8_57,
           8_59,
           8_63,
           8_77,
           8_81,
           8_83,
           8_87,
           9_07,
           9_11,
           9_19,
           9_29,
           9_37,
           9_41,
           9_47,
           9_53,
           9_67,
           9_71,
           9_77,
           9_83,
           9_91,
           9_97,
       ]

       if num in low_primes:
              return True

       for prime in low_primes:
              if (num % prime) == 0:
                     return False

       return rabin_miller(lowercase_      )




def    __UpperCAmelCase(      lowercase_ = 10_24      ):
       while True:
              _lowerCamelCase							:     int	=		random.randrange(2 ** (keysize - 1) ,    2 ** (keysize)      )
              if is_prime_low_num(lowercase_      ):
                     return num


if __name__ == "__main__":
       _lowerCamelCase			       =      generate_large_prime()
       print(('Prime number:', num))
       print(('is_prime_low_num:', is_prime_low_num(num)))








import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand




def    __UpperCAmelCase(      lowercase_      ):
       return EnvironmentCommand()




def    __UpperCAmelCase(      lowercase_      ):
       return EnvironmentCommand(args.accelerate_config_file      )







class 			__A       (      lowerCamelCase__  ):




      """simple docstring"""







      @staticmethod
      def 				__snake_case			(		a__):



             """simple docstring"""





             _lowerCamelCase							:     List[Any]	=		parser.add_parser('''env''')
             download_parser.set_defaults(func=a__)
             download_parser.add_argument(
                 '''--accelerate-config_file'''      ,							default=a__      ,							help='''The accelerate config file to use for the default values in the launching script.'''      ,							)
             download_parser.set_defaults(func=a__)


      def __init__(		self      ,							a__      ,							*a__):



             """simple docstring"""





             _lowerCamelCase							:     str	=		accelerate_config_file


      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Union[str, Any]	=		'''not installed'''
             if is_safetensors_available():
                    import safetensors

                    _lowerCamelCase							:     Optional[Any]	=		safetensors.__version__
             elif importlib.util.find_spec('''safetensors''') is not None:
                    import safetensors

                    _lowerCamelCase							:     Optional[int]	=		F"""{safetensors.__version__} but is ignored because of PyTorch version too old."""

             _lowerCamelCase							:     Union[str, Any]	=		'''not installed'''
             _lowerCamelCase							:     Any	=		'''not found'''
             if is_accelerate_available():
                    import accelerate
                    from accelerate.commands.config import default_config_file, load_config_from_file

                    _lowerCamelCase							:     Optional[int]	=		accelerate.__version__
                    # Get the default from the config file.
                    if self._accelerate_config_file is not None or os.path.isfile(a__):
                           _lowerCamelCase							:     Optional[int]	=		load_config_from_file(self._accelerate_config_file).to_dict()

                    _lowerCamelCase							:     str	=		(
                        '''\n'''.join([F"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()])
                        if isinstance(a__      ,							a__)
                        else F"""\t{accelerate_config}"""
                    )

             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     Tuple	=		'''NA'''
             if is_torch_available():
                    import torch

                    _lowerCamelCase							:     int	=		torch.__version__
                    _lowerCamelCase							:     List[str]	=		torch.cuda.is_available()

             _lowerCamelCase							:     str	=		'''not installed'''
             _lowerCamelCase							:     Union[str, Any]	=		'''NA'''
             if is_tf_available():
                    import tensorflow as tf

                    _lowerCamelCase							:     List[str]	=		tf.__version__
                    try:
                           # deprecated in v2.1
                           _lowerCamelCase							:     Optional[int]	=		tf.test.is_gpu_available()
                    except AttributeError:
                           # returns list of devices, convert to bool
                           _lowerCamelCase							:     Optional[int]	=		bool(tf.config.list_physical_devices('''GPU'''))

             _lowerCamelCase							:     str	=		'''not installed'''
             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     Optional[int]	=		'''NA'''
             if is_flax_available():
                    import flax
                    import jax
                    import jaxlib

                    _lowerCamelCase							:     Any	=		flax.__version__
                    _lowerCamelCase							:     str	=		jax.__version__
                    _lowerCamelCase							:     Any	=		jaxlib.__version__
                    _lowerCamelCase							:     int	=		jax.lib.xla_bridge.get_backend().platform

             _lowerCamelCase							:     int	=		{
                 '''`transformers` version''': version,
                 '''Platform''': platform.platform(),
                 '''Python version''': platform.python_version(),
                 '''Huggingface_hub version''': huggingface_hub.__version__,
                 '''Safetensors version''': F"""{safetensors_version}""",
                 '''Accelerate version''': F"""{accelerate_version}""",
                 '''Accelerate config''': F"""{accelerate_config_str}""",
                 '''PyTorch version (GPU?)''': F"""{pt_version} ({pt_cuda_available})""",
                 '''Tensorflow version (GPU?)''': F"""{tf_version} ({tf_cuda_available})""",
                 '''Flax version (CPU?/GPU?/TPU?)''': F"""{flax_version} ({jax_backend})""",
                 '''Jax version''': F"""{jax_version}""",
                 '''JaxLib version''': F"""{jaxlib_version}""",
                 '''Using GPU in script?''': '''<fill in>''',
                 '''Using distributed or parallel set-up in script?''': '''<fill in>''',
             }

             print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''')
             print(self.format_dict(a__))

             return info



      @staticmethod
      def 				__snake_case			(		a__):



             """simple docstring"""





             return "\n".join([F"""- {prop}: {val}""" for prop, val in d.items()]) + "\n"

