


"""simple docstring"""
# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
 import jax
 import jaxlib

UpperCAmelCase				=						get_logger()

UpperCAmelCase				=						None




class 	lowercase__				(					TensorFormatter[Mapping, '''jax.Array''', Mapping]				):





   def __init__(							self      ,   SCREAMING_SNAKE_CASE=None      ,   SCREAMING_SNAKE_CASE=None      ,   **SCREAMING_SNAKE_CASE)  ->  int:
      super().__init__(features=SCREAMING_SNAKE_CASE)
      import jax
      from jaxlib.xla_client import Device

      if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE):
         raise ValueError(
             F'Expected {device} to be a `str` not {type(SCREAMING_SNAKE_CASE)}, as `jaxlib.xla_extension.Device` '
             """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """
             """the device with `str()` to get its string identifier that will be internally mapped """
             """to the actual `jaxlib.xla_extension.Device`.""")
      _lowerCamelCase	:					str   =		device if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE) else str(jax.devices()[0])
      # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
      # with `pickle` nor with `dill`, so we need to use a global variable instead
      global DEVICE_MAPPING
      if DEVICE_MAPPING is None:
         _lowerCamelCase	:					Optional[int]   =		self._map_devices_to_str()
      if self.device not in list(DEVICE_MAPPING.keys()):
         logger.warning(
             F'Device with string identifier {self.device} not listed among the available '
             F'devices: {list(DEVICE_MAPPING.keys())}, so falling back to the default '
             F'device: {str(jax.devices()[0])}.')
         _lowerCamelCase	:					str   =		str(jax.devices()[0])
      _lowerCamelCase	:					Tuple   =		jnp_array_kwargs





   @staticmethod
   def 		UpperCamelCase_  (							)  ->  Dict[str, "jaxlib.xla_extension.Device"]:
      import jax

      return {str(SCREAMING_SNAKE_CASE): device for device in jax.devices()}





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  List[Any]:
      import jax
      import jax.numpy as jnp

      if isinstance(SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE) and column:
         if all(
             isinstance(SCREAMING_SNAKE_CASE      ,   jax.Array) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column):
            return jnp.stack(SCREAMING_SNAKE_CASE      ,   axis=0)
      return column





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Optional[Any]:
      import jax
      import jax.numpy as jnp

      if isinstance(SCREAMING_SNAKE_CASE      ,   (str, bytes, type(SCREAMING_SNAKE_CASE))):
         return value
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (np.character, np.ndarray)) and np.issubdtype(value.dtype      ,   np.character):
         return value.tolist()

      _lowerCamelCase	:					List[str]   =		{}

      if isinstance(SCREAMING_SNAKE_CASE      ,   (np.number, np.ndarray)) and np.issubdtype(value.dtype      ,   np.integer):
         # the default int precision depends on the jax config
         # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
         if jax.config.jax_enable_xaa:
            _lowerCamelCase	:					int   =		{"""dtype""": jnp.intaa}
         else:
            _lowerCamelCase	:					Dict   =		{"""dtype""": jnp.intaa}
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (np.number, np.ndarray)) and np.issubdtype(value.dtype      ,   np.floating):
         _lowerCamelCase	:					Any   =		{"""dtype""": jnp.floataa}
      elif config.PIL_AVAILABLE and "PIL" in sys.modules:
         import PIL.Image

         if isinstance(SCREAMING_SNAKE_CASE      ,   PIL.Image.Image):
            _lowerCamelCase	:					List[Any]   =		np.asarray(SCREAMING_SNAKE_CASE)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
      global DEVICE_MAPPING
      if DEVICE_MAPPING is None:
         _lowerCamelCase	:					List[Any]   =		self._map_devices_to_str()

      with jax.default_device(DEVICE_MAPPING[self.device]):
         # calling jnp.array on a np.ndarray does copy the data
         # see https://github.com/google/jax/issues/4486
         return jnp.array(SCREAMING_SNAKE_CASE      ,   **{**default_dtype, **self.jnp_array_kwargs})





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Any:
      import jax

      # support for torch, tf, jax etc.
      if config.TORCH_AVAILABLE and "torch" in sys.modules:
         import torch

         if isinstance(SCREAMING_SNAKE_CASE      ,   torch.Tensor):
            return self._tensorize(data_struct.detach().cpu().numpy()[()])
      if hasattr(SCREAMING_SNAKE_CASE      ,   """__array__""") and not isinstance(SCREAMING_SNAKE_CASE      ,   jax.Array):
         _lowerCamelCase	:					str   =		data_struct.__array__()
      # support for nested types like struct of list of struct
      if isinstance(SCREAMING_SNAKE_CASE      ,   np.ndarray):
         if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
            return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE) for substruct in data_struct])
      elif isinstance(SCREAMING_SNAKE_CASE      ,   (list, tuple)):
         return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE) for substruct in data_struct])
      return self._tensorize(SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  int:
      return map_nested(self._recursive_tensorize      ,   SCREAMING_SNAKE_CASE      ,   map_list=SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Mapping:
      _lowerCamelCase	:					List[str]   =		self.numpy_arrow_extractor().extract_row(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		self.python_features_decoder.decode_row(SCREAMING_SNAKE_CASE)
      return self.recursive_tensorize(SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  "jax.Array":
      _lowerCamelCase	:					str   =		self.numpy_arrow_extractor().extract_column(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					int   =		self.python_features_decoder.decode_column(SCREAMING_SNAKE_CASE      ,   pa_table.column_names[0])
      _lowerCamelCase	:					List[str]   =		self.recursive_tensorize(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Any   =		self._consolidate(SCREAMING_SNAKE_CASE)
      return column





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Mapping:
      _lowerCamelCase	:					Optional[int]   =		self.numpy_arrow_extractor().extract_batch(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Union[str, Any]   =		self.python_features_decoder.decode_batch(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Dict   =		self.recursive_tensorize(SCREAMING_SNAKE_CASE)
      for column_name in batch:
         _lowerCamelCase	:					int   =		self._consolidate(batch[column_name])
      return batch




'''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 					__UpperCamelCase				(						lowercase__    :	Union[str, Any]			):






     '''simple docstring'''





     return EnvironmentCommand()

def 					__UpperCamelCase				(						lowercase__    :	Any			):






     '''simple docstring'''





     return EnvironmentCommand(args.accelerate_config_file			)







class 	lowerCAmelCase  (   A ):







       @staticmethod
       def       snake_case (				__lowercase      :			ArgumentParser   ):







            """simple docstring"""







            __lowercase      		=parser.add_parser('env'   )
            download_parser.set_defaults(func=__lowercase   )
            download_parser.add_argument(
                '--accelerate-config_file'    ,   default=__lowercase    ,   help='The accelerate config file to use for the default values in the launching script.'    ,   )
            download_parser.set_defaults(func=__lowercase   )







       def __init__(				self      :			int    ,   __lowercase      :			Any    ,   *__lowercase      :			str   ):







            """simple docstring"""







            __lowercase      		=accelerate_config_file







       def       snake_case (				self      :			Optional[int]   ):







            """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(__lowercase   ):
                      __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(__lowercase    ,   __lowercase   )
                     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(__lowercase   )   )

            return info







       @staticmethod
       def       snake_case (				__lowercase      :			Optional[Any]   ):







            """simple docstring"""







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


