





'''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      snake_case     (    unittest.TestCase       ):




 """simple docstring"""



 def        _lowerCamelCase					(       self       :							Any	):
        __UpperCamelCase       =  0






 @slow
 def        _lowerCamelCase					(       self       :							Dict	):
        for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
               self.assertIsNotNone(__A	)
               self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
               self.assertGreater(len(__A	)							,	0	)

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






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							Union[str, Any]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(RobertaTokenizer, RobertaTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	2_0	)






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoConfig.from_pretrained(__A	)
        self.assertIsInstance(__A							,	__A	)
        # Check that tokenizer_type ≠ model_type
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	config=__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.txt'							,	os.path.join(__A							,	'vocab.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='bert'							,	use_fast=__A	)
               self.assertIsInstance(__A							,	__A	)

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

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='gpt2'							,	use_fast=__A	)
               self.assertIsInstance(__A							,	__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.txt'							,	os.path.join(__A							,	'vocab.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='bert'	)
               self.assertIsInstance(__A							,	__A	)

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

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='gpt2'	)
               self.assertIsInstance(__A							,	__A	)






 def        _lowerCamelCase					(       self       :							int	):
        with pytest.raises(__A	):
               AutoTokenizer.from_pretrained('./'							,	tokenizer_type='xxx'	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
               __UpperCamelCase       =  tokenizer_class.from_pretrained('wietsedv/bert-base-dutch-cased'	)
               self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)

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

               self.assertEqual(tokenizer.model_max_length							,	5_1_2	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							List[str]	):
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
               with self.assertRaisesRegex(
                   __A							,	'julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'							,	):
                      __UpperCamelCase       =  tokenizer_class.from_pretrained('julien-c/herlolip-not-exists'	)






 def        _lowerCamelCase					(       self       :							List[Any]	):
        # 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
        __UpperCamelCase       =  TOKENIZER_MAPPING.values()
        __UpperCamelCase       =  []

        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(__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'							,	use_fast=__A	)							,	__A	)
        self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'	)							,	__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('distilbert-base-uncased'							,	do_lower_case=__A	)
        __UpperCamelCase       =  'Hello, world. How are you?'
        __UpperCamelCase       =  tokenizer.tokenize(__A	)
        self.assertEqual('[UNK]'							,	tokens[0]	)

        __UpperCamelCase       =  AutoTokenizer.from_pretrained('microsoft/mpnet-base'							,	do_lower_case=__A	)
        __UpperCamelCase       =  tokenizer.tokenize(__A	)
        self.assertEqual('[UNK]'							,	tokens[0]	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'	)
        self.assertEqual(type(__A	)							,	__A	)
        self.assertEqual(tokenizer.model_max_length							,	5_1_2	)
        self.assertEqual(tokenizer.vocab_size							,	3_0_0_0_0	)
        self.assertEqual(tokenizer.unk_token							,	'[UNK]'	)
        self.assertEqual(tokenizer.padding_side							,	'right'	)
        self.assertEqual(tokenizer.truncation_side							,	'right'	)






 def        _lowerCamelCase					(       self       :							int	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__A	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)

        self.assertIsInstance(__A							,	tokenizer.__class__	)
        self.assertEqual(tokenizera.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							int	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('ctrl'	)
        # There is no fast CTRL so this always gives us a slow tokenizer.
        self.assertIsInstance(__A							,	__A	)






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

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

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

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






 def        _lowerCamelCase					(       self       :							List[str]	):
        try:
               AutoConfig.register('custom'							,	__A	)

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

               __UpperCamelCase       =  CustomTokenizer.from_pretrained(__A	)
               with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(__A	)

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
                      self.assertIsInstance(__A							,	__A	)

        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        _lowerCamelCase					(       self       :							Optional[int]	):
        try:
               AutoConfig.register('custom'							,	__A	)

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

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

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

               # 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:
                      __UpperCamelCase       =  BertTokenizerFast.from_pretrained(__A	)
                      bert_tokenizer.save_pretrained(__A	)
                      __UpperCamelCase       =  CustomTokenizerFast.from_pretrained(__A	)

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

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
                      self.assertIsInstance(__A							,	__A	)

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	use_fast=__A	)
                      self.assertIsInstance(__A							,	__A	)

        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        _lowerCamelCase					(       self       :							List[Any]	):
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(__A	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'	)
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(__A	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)

        __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)
        self.assertTrue(tokenizer.special_attribute_present	)
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__A	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	trust_remote_code=__A	)
        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
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A							,	use_fast=__A	)
               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(__A	)
                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	trust_remote_code=__A							,	use_fast=__A	)
               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        _lowerCamelCase					(       self       :							Any	):

        class      snake_case     (    __lowerCamelCase       ):




         """simple docstring"""



         SCREAMING_SNAKE_CASE_	:					Any					=False






        class      snake_case     (    __lowerCamelCase       ):




         """simple docstring"""



         SCREAMING_SNAKE_CASE_	:					str					=NewTokenizer
         SCREAMING_SNAKE_CASE_	:					str					=False

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

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

               # If remote is enabled, we load from the Hub
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)
               self.assertTrue(tokenizer.special_attribute_present	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A							,	use_fast=__A	)
               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        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer_legacy'							,	trust_remote_code=__A	)
        self.assertTrue(tokenizer.special_attribute_present	)
        if is_tokenizers_available():
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)

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






 def        _lowerCamelCase					(       self       :							int	):
        with self.assertRaisesRegex(
            __A							,	'bert-base is not a local folder and is not a valid model identifier'	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('bert-base'	)






 def        _lowerCamelCase					(       self       :							str	):
        with self.assertRaisesRegex(
            __A							,	R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	revision='aaaaaa'	)






 def        _lowerCamelCase					(       self       :							Dict	):
        # Make sure we have cached the tokenizer.
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'	)
        with RequestCounter() as counter:
               __UpperCamelCase       =  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	)



# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


snake_case_			  = logging.get_logger(__name__)

snake_case_			  = {}
snake_case_			  = {}
snake_case_			  = {}

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    type	,     SCREAMING_SNAKE_CASE_		:    Optional[str]	,     SCREAMING_SNAKE_CASE_		:    Optional[List[str]] = None	,     ):



     '''simple docstring'''





     lowercase__    :   Union[str, Any]      =       aliases if aliases is not None else []
     if format_type in _FORMAT_TYPES:
          logger.warning(
              f"""Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"""			)
     lowercase__    :   Any      =       formatter_cls
     for alias in set(aliases + [format_type]			):
          if alias in _FORMAT_TYPES_ALIASES:
               logger.warning(
                   f"""Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"""			)
          lowercase__    :   int      =       format_type

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Exception	,     SCREAMING_SNAKE_CASE_		:    Optional[str]	,     SCREAMING_SNAKE_CASE_		:    Optional[List[str]] = None			):



     '''simple docstring'''





     lowercase__    :   Optional[Any]      =       aliases if aliases is not None else []
     for alias in set(aliases + [format_type]			):
          lowercase__    :   Any      =       unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=['''python'''])
_register_formatter(ArrowFormatter, '''arrow''', aliases=['''pa''', '''pyarrow'''])
_register_formatter(NumpyFormatter, '''numpy''', aliases=['''np'''])
_register_formatter(PandasFormatter, '''pandas''', aliases=['''pd'''])
_register_formatter(CustomFormatter, '''custom''')

if config.TORCH_AVAILABLE:
       from .torch_formatter import TorchFormatter

       _register_formatter(TorchFormatter, '''torch''', aliases=['''pt''', '''pytorch'''])
else:
       snake_case_			  = ValueError('''PyTorch needs to be installed to be able to return PyTorch tensors.''')
       _register_unavailable_formatter(_torch_error, '''torch''', aliases=['''pt''', '''pytorch'''])

if config.TF_AVAILABLE:
       from .tf_formatter import TFFormatter

       _register_formatter(TFFormatter, '''tensorflow''', aliases=['''tf'''])
else:
       snake_case_			  = ValueError('''Tensorflow needs to be installed to be able to return Tensorflow tensors.''')
       _register_unavailable_formatter(_tf_error, '''tensorflow''', aliases=['''tf'''])

if config.JAX_AVAILABLE:
       from .jax_formatter import JaxFormatter

       _register_formatter(JaxFormatter, '''jax''', aliases=[])
else:
       snake_case_			  = ValueError('''JAX needs to be installed to be able to return JAX arrays.''')
       _register_unavailable_formatter(_jax_error, '''jax''', aliases=[])

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Optional[str]			):



     '''simple docstring'''





     if format_type in _FORMAT_TYPES_ALIASES:
          return _FORMAT_TYPES_ALIASES[format_type]
     else:
          return format_type

def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    Optional[str]	,     **SCREAMING_SNAKE_CASE_		:    Any			):



     '''simple docstring'''





     lowercase__    :   Tuple      =       get_format_type_from_alias(SCREAMING_SNAKE_CASE_			)
     if format_type in _FORMAT_TYPES:
          return _FORMAT_TYPES[format_type](**SCREAMING_SNAKE_CASE_			)
     if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
          raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
     else:
          raise ValueError(
              f"""Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None			)}, but got '{format_type}'"""			)

