





'''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    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      return EnvironmentCommand()




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      return EnvironmentCommand(args.accelerate_config_file	)





class lowerCamelCase						(a__					):







  @staticmethod
  def 				UpperCAmelCase_				(		lowercase__		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	Any					     =     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     ,     lowercase__     ,     *lowercase__		)		->						None:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     accelerate_config_file







  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Any					     =     '''not installed'''
        if is_safetensors_available():
              import safetensors

              _snake_case		:	Any					     =     safetensors.__version__
        elif importlib.util.find_spec('''safetensors'''		) is not None:
              import safetensors

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

        _snake_case		:	Tuple					     =     '''not installed'''
        _snake_case		:	List[Any]					     =     '''not found'''
        if is_accelerate_available():
              import accelerate
              from accelerate.commands.config import default_config_file, load_config_from_file

              _snake_case		:	Any					     =     accelerate.__version__
              # Get the default from the config file.
              if self._accelerate_config_file is not None or os.path.isfile(lowercase__		):
                    _snake_case		:	List[Any]					     =     load_config_from_file(self._accelerate_config_file		).to_dict()

              _snake_case		:	Optional[int]					     =     (
                  '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]		)
                  if isinstance(lowercase__     ,     lowercase__		)
                  else F'''\t{accelerate_config}'''
              )

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

              _snake_case		:	Tuple					     =     torch.__version__
              _snake_case		:	Any					     =     torch.cuda.is_available()

        _snake_case		:	Optional[int]					     =     '''not installed'''
        _snake_case		:	Tuple					     =     '''NA'''
        if is_tf_available():
              import tensorflow as tf

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

        _snake_case		:	Union[str, Any]					     =     '''not installed'''
        _snake_case		:	Tuple					     =     '''not installed'''
        _snake_case		:	Union[str, Any]					     =     '''not installed'''
        _snake_case		:	Optional[Any]					     =     '''NA'''
        if is_flax_available():
              import flax
              import jax
              import jaxlib

              _snake_case		:	Optional[Any]					     =     flax.__version__
              _snake_case		:	int					     =     jax.__version__
              _snake_case		:	Union[str, Any]					     =     jaxlib.__version__
              _snake_case		:	Tuple					     =     jax.lib.xla_bridge.get_backend().platform

        _snake_case		:	List[str]					     =     {
            '''`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 				UpperCAmelCase_				(		lowercase__		)		->						Optional[int]:






        """simple docstring"""





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









'''simple docstring'''

from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

UpperCAmelCase					:		Any		=							TypeVar('T')
UpperCAmelCase					:		str		=							TypeVar('U')





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self     ,     lowercase__     ,     lowercase__		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	str					     =     key
        _snake_case		:	Optional[int]					     =     val
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''Node: key: {self.key}, val: {self.val}, '''
            F'''has next: {bool(self.next		)}, has prev: {bool(self.prev		)}'''
        )





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case     ,							_snake_case		:	Union[str, Any]					     =     self.rear, self.head







  def __repr__(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     ['''DoubleLinkedList''']
        _snake_case		:	str					     =     self.head
        while node.next is not None:
              rep.append(str(lowercase__		)		)
              _snake_case		:	List[str]					     =     node.next
        rep.append(str(self.rear		)		)
        return ",\n    ".join(lowercase__		)







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						None:






        """simple docstring"""





        _snake_case		:	Tuple					     =     self.rear.prev

        # All nodes other than self.head are guaranteed to have non-None previous
        assert previous is not None

        _snake_case		:	Union[str, Any]					     =     node
        _snake_case		:	Optional[Any]					     =     previous
        _snake_case		:	int					     =     node
        _snake_case		:	Union[str, Any]					     =     self.rear







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						DoubleLinkedListNode[T, U] | None:






        """simple docstring"""





        if node.prev is None or node.next is None:
              return None

        _snake_case		:	Optional[int]					     =     node.next
        _snake_case		:	Any					     =     node.prev
        _snake_case		:	List[str]					     =     None
        _snake_case		:	Optional[int]					     =     None
        return node





class lowerCamelCase						(Generic[T, U]					):
  _lowercase  :	dict[Callable[[T], U], LRUCache[T, U]]       					=				{}







  def __init__(		self     ,     lowercase__		)		->						Union[str, Any]:






        """simple docstring"""





        _snake_case		:	DoubleLinkedList[T, U]					     =     DoubleLinkedList()
        _snake_case		:	Union[str, Any]					     =     capacity
        _snake_case		:	int					     =     0
        _snake_case		:	Dict					     =     0
        _snake_case		:	Union[str, Any]					     =     0
        _snake_case		:	dict[T, DoubleLinkedListNode[T, U]]					     =     {}







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''CacheInfo(hits={self.hits}, misses={self.miss}, '''
            F'''capacity={self.capacity}, current size={self.num_keys})'''
        )







  def __contains__(		self     ,     lowercase__		)		->						bool:






        """simple docstring"""





        return key in self.cache







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						U | None:






        """simple docstring"""





        if key in self.cache:
              self.hits += 1
              _snake_case		:	DoubleLinkedListNode[T, U]					     =     self.cache[key]
              _snake_case		:	Tuple					     =     self.list.remove(self.cache[key]		)
              assert node == value_node

              # node is guaranteed not None because it is in self.cache
              assert node is not None
              self.list.add(lowercase__		)
              return node.val
        self.miss += 1
        return None







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						None:






        """simple docstring"""





        if key not in self.cache:
              if self.num_keys >= self.capacity:
                    # delete first node (oldest) when over capacity
                    _snake_case		:	Dict					     =     self.list.head.next

                    # guaranteed to have a non-None first node when num_keys > 0
                    # explain to type checker via assertions
                    assert first_node is not None
                    assert first_node.key is not None
                    assert (
                        self.list.remove(lowercase__		) is not None
                    )  # node guaranteed to be in list assert node.key is not None

                    del self.cache[first_node.key]
                    self.num_keys -= 1
              _snake_case		:	Optional[int]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
              self.list.add(self.cache[key]		)
              self.num_keys += 1

        else:
              # bump node to the end of the list, update value
              _snake_case		:	Optional[Any]					     =     self.list.remove(self.cache[key]		)
              assert node is not None  # node guaranteed to be in list
              _snake_case		:	Optional[Any]					     =     value
              self.list.add(lowercase__		)







  @classmethod
  def 				UpperCAmelCase_				(		cls     ,     lowercase__ = 128		)		->						Callable[[Callable[[T], U]], Callable[..., U]]:






        """simple docstring"""





        def cache_decorator_inner(lowercase__		) -> Callable[..., U]:
              def cache_decorator_wrapper(*lowercase__		) -> U:
                    if func not in cls.decorator_function_to_instance_map:
                          _snake_case		:	Optional[Any]					     =     LRUCache(lowercase__		)

                    _snake_case		:	Union[str, Any]					     =     cls.decorator_function_to_instance_map[func].get(args[0]		)
                    if result is None:
                          _snake_case		:	Tuple					     =     func(*lowercase__		)
                          cls.decorator_function_to_instance_map[func].put(args[0]     ,     lowercase__		)
                    return result

              def cache_info() -> LRUCache[T, U]:
                    return cls.decorator_function_to_instance_map[func]

              setattr(lowercase__     ,     '''cache_info'''     ,     lowercase__		)  # noqa: B010

              return cache_decorator_wrapper

        return cache_decorator_inner


if __name__ == "__main__":
   import doctest

   doctest.testmod()


