


"""simple docstring"""

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 lowerCAmelCase_      (				UpperCamelCase__	: List[Any] ):






 """simple docstring"""







 return EnvironmentCommand()


def lowerCAmelCase_      (				UpperCamelCase__	: str ):






 """simple docstring"""







 return EnvironmentCommand(args.accelerate_config_file )





class    lowerCamelCase__						(		_UpperCAmelCase    ):
      @staticmethod
      def SCREAMING_SNAKE_CASE_	(		A_	:	ArgumentParser							):






       '''simple docstring'''


       __lowercase									=	parser.add_parser("""env"""							)
       download_parser.set_defaults(func=__UpperCamelCase							)
       download_parser.add_argument(
           """--accelerate-config_file"""      ,       default=__UpperCamelCase      ,       help="""The accelerate config file to use for the default values in the launching script."""      ,       )
       download_parser.set_defaults(func=__UpperCamelCase							)
      def __init__(		self	:	Any      ,       A_	:	List[Any]      ,       *A_	:	Any							):






       '''simple docstring'''


       __lowercase									=	accelerate_config_file
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       __lowercase									=	"""not installed"""
       if is_safetensors_available():
        import safetensors

        __lowercase									=	safetensors.__version__
       elif importlib.util.find_spec("""safetensors"""							) is not None:
        import safetensors

        __lowercase									=	F'''{safetensors.__version__} but is ignored because of PyTorch version too old.'''

       __lowercase									=	"""not installed"""
       __lowercase									=	__lowercase									=	"""not found"""
       if is_accelerate_available():
        import accelerate
        from accelerate.commands.config import default_config_file, load_config_from_file

        __lowercase									=	accelerate.__version__
        # Get the default from the config file.
        if self._accelerate_config_file is not None or os.path.isfile(__UpperCamelCase							):
         __lowercase									=	load_config_from_file(self._accelerate_config_file							).to_dict()

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

       __lowercase									=	"""not installed"""
       __lowercase									=	"""NA"""
       if is_torch_available():
        import torch

        __lowercase									=	torch.__version__
        __lowercase									=	torch.cuda.is_available()

       __lowercase									=	"""not installed"""
       __lowercase									=	"""NA"""
       if is_tf_available():
        import tensorflow as tf

        __lowercase									=	tf.__version__
        try:
         # deprecated in v2.1
         __lowercase									=	tf.test.is_gpu_available()
        except AttributeError:
         # returns list of devices, convert to bool
         __lowercase									=	bool(tf.config.list_physical_devices("""GPU"""							)							)

       __lowercase									=	"""not installed"""
       __lowercase									=	"""not installed"""
       __lowercase									=	"""not installed"""
       __lowercase									=	"""NA"""
       if is_flax_available():
        import flax
        import jax
        import jaxlib

        __lowercase									=	flax.__version__
        __lowercase									=	jax.__version__
        __lowercase									=	jaxlib.__version__
        __lowercase									=	jax.lib.xla_bridge.get_backend().platform

       __lowercase									=	{
           """`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(__UpperCamelCase							)							)

       return info






      @staticmethod
      def SCREAMING_SNAKE_CASE_	(		A_	:	Union[str, Any]							):






       '''simple docstring'''


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




"""simple docstring"""

from typing import List

from .keymap import KEYMAP, get_character


def lowerCAmelCase_      (				UpperCamelCase__	: str ):






 """simple docstring"""







 def decorator(UpperCamelCase__	: Tuple ):
  __lowercase									=	getattr(UpperCamelCase__				,   """handle_key"""				,   [] )
  handle += [key]
  setattr(UpperCamelCase__				,   """handle_key"""				,   UpperCamelCase__ )
  return func

 return decorator


def lowerCAmelCase_      (				*UpperCamelCase__	: List[str] ):






 """simple docstring"""







 def decorator(UpperCamelCase__	: Tuple ):
  __lowercase									=	getattr(UpperCamelCase__				,   """handle_key"""				,   [] )
  handle += keys
  setattr(UpperCamelCase__				,   """handle_key"""				,   UpperCamelCase__ )
  return func

 return decorator





class    lowerCamelCase__						(		_a    ):
      def __new__(		cls	:	str      ,       A_	:	Optional[Any]      ,       A_	:	Union[str, Any]      ,       A_	:	int							):






       '''simple docstring'''


       __lowercase									=	super().__new__(cls      ,       A_      ,       A_      ,       A_							)
       if not hasattr(A_      ,       """key_handler"""							):
        setattr(A_      ,       """key_handler"""      ,       {}							)
       setattr(A_      ,       """handle_input"""      ,       KeyHandler.handle_input							)

       for value in attrs.values():
        __lowercase									=	getattr(A_      ,       """handle_key"""      ,       []							)
        for key in handled_keys:
         __lowercase									=	value
       return new_cls






      @staticmethod
      def SCREAMING_SNAKE_CASE_	(		cls	:	Dict							):






       '''simple docstring'''


       __lowercase									=	get_character()
       if char != KEYMAP["undefined"]:
        __lowercase									=	ord(A_							)
       __lowercase									=	cls.key_handler.get(A_							)
       if handler:
        __lowercase									=	char
        return handler(cls							)
       else:
        return None






def lowerCAmelCase_      (				cls	: int ):






 """simple docstring"""







 return KeyHandler(cls.__name__				,   cls.__bases__				,   cls.__dict__.copy() )
