

'''simple docstring'''







import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
      from test_module.custom_tokenization_fast import CustomTokenizerFast


class 					A__      (      unittest.TestCase			):



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





           '''simple docstring'''
           A_						=      0



    @slow
    def 					snake_case_			(					self       )						->      Optional[int]:





           '''simple docstring'''
           for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
                  self.assertIsNotNone(UpperCamelCase__       )
                  self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
                  self.assertGreater(len(UpperCamelCase__       )		,				0       )

           for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
                  self.assertIsNotNone(UpperCamelCase__       )
                  self.assertIsInstance(UpperCamelCase__		,				(GPTaTokenizer, GPTaTokenizerFast)       )
                  self.assertGreater(len(UpperCamelCase__       )		,				0       )



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





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
           self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
           self.assertEqual(tokenizer.vocab_size		,				12       )



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





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
           self.assertIsInstance(UpperCamelCase__		,				(RobertaTokenizer, RobertaTokenizerFast)       )
           self.assertEqual(tokenizer.vocab_size		,				20       )



    def 					snake_case_			(					self       )						->      Optional[Any]:





           '''simple docstring'''
           A_						=      AutoConfig.from_pretrained(UpperCamelCase__       )
           self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )
           # Check that tokenizer_type ≠ model_type
           A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				config=UpperCamelCase__       )
           self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
           self.assertEqual(tokenizer.vocab_size		,				12       )



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





           '''simple docstring'''
           with tempfile.TemporaryDirectory() as tmp_dir:
                  shutil.copy("""./tests/fixtures/vocab.txt"""		,				os.path.join(UpperCamelCase__		,				"""vocab.txt"""       )       )

                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""bert"""		,				use_fast=UpperCamelCase__       )
                  self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

           with tempfile.TemporaryDirectory() as tmp_dir:
                  shutil.copy("""./tests/fixtures/vocab.json"""		,				os.path.join(UpperCamelCase__		,				"""vocab.json"""       )       )
                  shutil.copy("""./tests/fixtures/merges.txt"""		,				os.path.join(UpperCamelCase__		,				"""merges.txt"""       )       )

                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""gpt2"""		,				use_fast=UpperCamelCase__       )
                  self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           with tempfile.TemporaryDirectory() as tmp_dir:
                  shutil.copy("""./tests/fixtures/vocab.txt"""		,				os.path.join(UpperCamelCase__		,				"""vocab.txt"""       )       )

                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""bert"""       )
                  self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

           with tempfile.TemporaryDirectory() as tmp_dir:
                  shutil.copy("""./tests/fixtures/vocab.json"""		,				os.path.join(UpperCamelCase__		,				"""vocab.json"""       )       )
                  shutil.copy("""./tests/fixtures/merges.txt"""		,				os.path.join(UpperCamelCase__		,				"""merges.txt"""       )       )

                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""gpt2"""       )
                  self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



    def 					snake_case_			(					self       )						->      Dict:





           '''simple docstring'''
           with pytest.raises(UpperCamelCase__       ):
                  AutoTokenizer.from_pretrained("""./"""		,				tokenizer_type="""xxx"""       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                  A_						=      tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""       )
                  self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )

                  if isinstance(UpperCamelCase__		,				UpperCamelCase__       ):
                         self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,				UpperCamelCase__       )
                  else:
                         self.assertEqual(tokenizer.do_lower_case		,				UpperCamelCase__       )

                  self.assertEqual(tokenizer.model_max_length		,				512       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                  with self.assertRaisesRegex(
                      UpperCamelCase__		,				"""julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""		,				):
                         A_						=      tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""       )



    def 					snake_case_			(					self       )						->      Optional[Any]:





           '''simple docstring'''
           # tests: https://github.com/huggingface/transformers/pull/13251
           # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
           # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
           A_						=      TOKENIZER_MAPPING.values()
           A_						=      []

           for slow_tok, fast_tok in tokenizers:
                  if slow_tok is not None:
                         tokenizer_names.append(slow_tok.__name__       )

                  if fast_tok is not None:
                         tokenizer_names.append(fast_tok.__name__       )

           for tokenizer_name in tokenizer_names:
                  # must find the right class
                  tokenizer_class_from_name(UpperCamelCase__       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""		,				use_fast=UpperCamelCase__       )		,				UpperCamelCase__       )
           self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""       )		,				UpperCamelCase__       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained("""distilbert-base-uncased"""		,				do_lower_case=UpperCamelCase__       )
           A_						=      """Hello, world. How are you?"""
           A_						=      tokenizer.tokenize(UpperCamelCase__       )
           self.assertEqual("""[UNK]"""		,				tokens[0]       )

           A_						=      AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""		,				do_lower_case=UpperCamelCase__       )
           A_						=      tokenizer.tokenize(UpperCamelCase__       )
           self.assertEqual("""[UNK]"""		,				tokens[0]       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""       )
           self.assertEqual(type(UpperCamelCase__       )		,				UpperCamelCase__       )
           self.assertEqual(tokenizer.model_max_length		,				512       )
           self.assertEqual(tokenizer.vocab_size		,				30000       )
           self.assertEqual(tokenizer.unk_token		,				"""[UNK]"""       )
           self.assertEqual(tokenizer.padding_side		,				"""right"""       )
           self.assertEqual(tokenizer.truncation_side		,				"""right"""       )



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





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
           self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
           with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(UpperCamelCase__       )
                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )

           self.assertIsInstance(UpperCamelCase__		,				tokenizer.__class__       )
           self.assertEqual(tokenizera.vocab_size		,				12       )



    def 					snake_case_			(					self       )						->      Dict:





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained("""ctrl"""       )
           # There is no fast CTRL so this always gives us a slow tokenizer.
           self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



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





           '''simple docstring'''
           # Check we can load the tokenizer config of an online model.
           A_						=      get_tokenizer_config("""bert-base-cased"""       )
           A_						=      config.pop("""_commit_hash"""		,				UpperCamelCase__       )
           # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
           self.assertEqual(UpperCamelCase__		,				{"""do_lower_case""": False}       )

           # This model does not have a tokenizer_config so we get back an empty dict.
           A_						=      get_tokenizer_config(UpperCamelCase__       )
           self.assertDictEqual(UpperCamelCase__		,				{}       )

           # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
           A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
           with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(UpperCamelCase__       )
                  A_						=      get_tokenizer_config(UpperCamelCase__       )

           # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
           self.assertEqual(config["""tokenizer_class"""]		,				"""BertTokenizer"""       )



    def 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           try:
                  AutoConfig.register("""custom"""		,				UpperCamelCase__       )

                  AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
                  # Trying to register something existing in the Transformers library will raise an error
                  with self.assertRaises(UpperCamelCase__       ):
                         AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )

                  A_						=      CustomTokenizer.from_pretrained(UpperCamelCase__       )
                  with tempfile.TemporaryDirectory() as tmp_dir:
                         tokenizer.save_pretrained(UpperCamelCase__       )

                         A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
                         self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

           finally:
                  if "custom" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["custom"]
                  if CustomConfig in TOKENIZER_MAPPING._extra_content:
                         del TOKENIZER_MAPPING._extra_content[CustomConfig]



    @require_tokenizers
    def 					snake_case_			(					self       )						->      Union[str, Any]:





           '''simple docstring'''
           try:
                  AutoConfig.register("""custom"""		,				UpperCamelCase__       )

                  # Can register in two steps
                  AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
                  self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, None)       )
                  AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
                  self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)       )

                  del TOKENIZER_MAPPING._extra_content[CustomConfig]
                  # Can register in one step
                  AutoTokenizer.register(
                      UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
                  self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)       )

                  # Trying to register something existing in the Transformers library will raise an error
                  with self.assertRaises(UpperCamelCase__       ):
                         AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )

                  # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
                  # and that model does not have a tokenizer.json
                  with tempfile.TemporaryDirectory() as tmp_dir:
                         A_						=      BertTokenizerFast.from_pretrained(UpperCamelCase__       )
                         bert_tokenizer.save_pretrained(UpperCamelCase__       )
                         A_						=      CustomTokenizerFast.from_pretrained(UpperCamelCase__       )

                  with tempfile.TemporaryDirectory() as tmp_dir:
                         tokenizer.save_pretrained(UpperCamelCase__       )

                         A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
                         self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

                         A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                         self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

           finally:
                  if "custom" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["custom"]
                  if CustomConfig in TOKENIZER_MAPPING._extra_content:
                         del TOKENIZER_MAPPING._extra_content[CustomConfig]



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





           '''simple docstring'''
           # If remote code is not set, we will time out when asking whether to load the model.
           with self.assertRaises(UpperCamelCase__       ):
                  A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""       )
           # If remote code is disabled, we can't load this config.
           with self.assertRaises(UpperCamelCase__       ):
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )

           A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
           self.assertTrue(tokenizer.special_attribute_present       )
           # Test tokenizer can be reloaded.
           with tempfile.TemporaryDirectory() as tmp_dir:
                  tokenizer.save_pretrained(UpperCamelCase__       )
                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				trust_remote_code=UpperCamelCase__       )
           self.assertTrue(reloaded_tokenizer.special_attribute_present       )

           if is_tokenizers_available():
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
                  self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )

                  # Test we can also load the slow version
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                  self.assertTrue(tokenizer.special_attribute_present       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  # Test tokenizer can be reloaded.
                  with tempfile.TemporaryDirectory() as tmp_dir:
                         tokenizer.save_pretrained(UpperCamelCase__       )
                         A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                  self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  self.assertTrue(reloaded_tokenizer.special_attribute_present       )
           else:
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizer"""       )



    @require_tokenizers
    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''


           class 					A__      (      _snake_case			):
               lowercase						=		False


           class 					A__      (      _snake_case			):
               lowercase						=		NewTokenizer
               lowercase						=		False

           try:
                  AutoConfig.register("""custom"""		,				UpperCamelCase__       )
                  AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
                  AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
                  # If remote code is not set, the default is to use local
                  A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
                  self.assertFalse(tokenizer.special_attribute_present       )
                  A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,				use_fast=UpperCamelCase__       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  self.assertFalse(tokenizer.special_attribute_present       )

                  # If remote code is disabled, we load the local one.
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
                  self.assertFalse(tokenizer.special_attribute_present       )
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  self.assertFalse(tokenizer.special_attribute_present       )

                  # If remote is enabled, we load from the Hub
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
                  self.assertTrue(tokenizer.special_attribute_present       )
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
                  self.assertTrue(tokenizer.special_attribute_present       )

           finally:
                  if "custom" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["custom"]
                  if CustomConfig in TOKENIZER_MAPPING._extra_content:
                         del TOKENIZER_MAPPING._extra_content[CustomConfig]



    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           A_						=      AutoTokenizer.from_pretrained(
               """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,				trust_remote_code=UpperCamelCase__       )
           self.assertTrue(tokenizer.special_attribute_present       )
           if is_tokenizers_available():
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )

                  # Test we can also load the slow version
                  A_						=      AutoTokenizer.from_pretrained(
                      """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
                  self.assertTrue(tokenizer.special_attribute_present       )
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
           else:
                  self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           with self.assertRaisesRegex(
               UpperCamelCase__		,				"""bert-base is not a local folder and is not a valid model identifier"""       ):
                  A_						=      AutoTokenizer.from_pretrained("""bert-base"""       )



    def 					snake_case_			(					self       )						->      Optional[Any]:





           '''simple docstring'''
           with self.assertRaisesRegex(
               UpperCamelCase__		,				R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""       ):
                  A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				revision="""aaaaaa"""       )







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





           '''simple docstring'''
           # Make sure we have cached the tokenizer.
           A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
           with RequestCounter() as counter:
                  A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
                  self.assertEqual(counter.get_request_count		,				0       )
                  self.assertEqual(counter.head_request_count		,				1       )
                  self.assertEqual(counter.other_request_count		,				0       )



'''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__    (      UpperCAmelCase__				)			->			Tuple:
       return EnvironmentCommand()
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       return EnvironmentCommand(args.accelerate_config_file				)







class 					A__      (      _snake_case			):



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      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		,				UpperCamelCase__		,				*UpperCamelCase__       )						->      None:





           '''simple docstring'''
           A_						=      accelerate_config_file



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      """not installed"""
           if is_safetensors_available():
                  import safetensors

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

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

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

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

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

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

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

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

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

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

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

           A_						=      {
               """`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 					snake_case_			(					UpperCamelCase__       )						->      List[str]:





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