





'''simple docstring'''






# DISCLAIMER: This file is strongly influenced by https://github.com/ermongroup/ddim

from dataclasses import dataclass
from typing import Optional, Tuple, Union

import flax
import jax
import jax.numpy as jnp

from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils_flax import (
    CommonSchedulerState,
    FlaxKarrasDiffusionSchedulers,
    FlaxSchedulerMixin,
    FlaxSchedulerOutput,
    add_noise_common,
    get_velocity_common,
)
@flax.struct.dataclass
class 					__snake_case  :






   '''simple docstring'''





   lowerCamelCase__    							=      42

   # setable values
   lowerCamelCase__    							=      42
   lowerCamelCase__    							=      42
   lowerCamelCase__    							=      None

   @classmethod
   def 		__UpperCamelCase						(							cls	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       ):
    return cls(common=__SCREAMING_SNAKE_CASE	,		init_noise_sigma=__SCREAMING_SNAKE_CASE	,		timesteps=__SCREAMING_SNAKE_CASE       )



@dataclass
class 					__snake_case  (					__SCREAMING_SNAKE_CASE							):






   '''simple docstring'''





   lowerCamelCase__    							=      42



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				__SCREAMING_SNAKE_CASE							):






   '''simple docstring'''





   lowerCamelCase__    							=      [e.name for e in FlaxKarrasDiffusionSchedulers]

   lowerCamelCase__    							=      42

   @property
   def 		__UpperCamelCase						(							self       ):
    return True

   @register_to_config
   def __init__(							self	,		__SCREAMING_SNAKE_CASE = 1_0_0_0	,		__SCREAMING_SNAKE_CASE = 0.0001	,		__SCREAMING_SNAKE_CASE = 0.02	,		__SCREAMING_SNAKE_CASE = "linear"	,		__SCREAMING_SNAKE_CASE = None	,		__SCREAMING_SNAKE_CASE = "fixed_small"	,		__SCREAMING_SNAKE_CASE = True	,		__SCREAMING_SNAKE_CASE = "epsilon"	,		__SCREAMING_SNAKE_CASE = jnp.floataa	,		):
    snake_case__     :					str    =  dtype

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE = None       ):
    if common is None:
     snake_case__     :					int    =  CommonSchedulerState.create(self       )

    # standard deviation of the initial noise distribution
    snake_case__     :					int    =  jnp.array(1.0	,		dtype=self.dtype       )

    snake_case__     :					int    =  jnp.arange(0	,		self.config.num_train_timesteps       ).round()[::-1]

    return DDPMSchedulerState.create(
        common=__SCREAMING_SNAKE_CASE	,		init_noise_sigma=__SCREAMING_SNAKE_CASE	,		timesteps=__SCREAMING_SNAKE_CASE	,		)

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE = None       ):
    return sample

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE = ()       ):
    snake_case__     :					Any    =  self.config.num_train_timesteps // num_inference_steps
    # creates integer timesteps by multiplying by ratio
    # rounding to avoid issues when num_inference_step is power of 3
    snake_case__     :					Union[str, Any]    =  (jnp.arange(0	,		__SCREAMING_SNAKE_CASE       ) * step_ratio).round()[::-1]

    return state.replace(
        num_inference_steps=__SCREAMING_SNAKE_CASE	,		timesteps=__SCREAMING_SNAKE_CASE	,		)

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE=None	,		__SCREAMING_SNAKE_CASE=None       ):
    snake_case__     :					Tuple    =  state.common.alphas_cumprod[t]
    snake_case__     :					Any    =  jnp.where(t > 0	,		state.common.alphas_cumprod[t - 1]	,		jnp.array(1.0	,		dtype=self.dtype       )       )

    # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf)
    # and sample from it to get previous sample
    # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample
    snake_case__     :					Tuple    =  (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * state.common.betas[t]

    if variance_type is None:
     snake_case__     :					Dict    =  self.config.variance_type

    # hacks - were probably added for training stability
    if variance_type == "fixed_small":
     snake_case__     :					Any    =  jnp.clip(__SCREAMING_SNAKE_CASE	,		a_min=1e-2_0       )
    # for rl-diffuser https://arxiv.org/abs/2205.09991
    elif variance_type == "fixed_small_log":
     snake_case__     :					Union[str, Any]    =  jnp.log(jnp.clip(__SCREAMING_SNAKE_CASE	,		a_min=1e-2_0       )       )
    elif variance_type == "fixed_large":
     snake_case__     :					Any    =  state.common.betas[t]
    elif variance_type == "fixed_large_log":
     # Glide max_log
     snake_case__     :					List[Any]    =  jnp.log(state.common.betas[t]       )
    elif variance_type == "learned":
     return predicted_variance
    elif variance_type == "learned_range":
     snake_case__     :					Optional[int]    =  variance
     snake_case__     :					Optional[int]    =  state.common.betas[t]
     snake_case__     :					Optional[Any]    =  (predicted_variance + 1) / 2
     snake_case__     :					Any    =  frac * max_log + (1 - frac) * min_log

    return variance

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE = None	,		__SCREAMING_SNAKE_CASE = True	,		):
    snake_case__     :					List[str]    =  timestep

    if key is None:
     snake_case__     :					str    =  jax.random.PRNGKey(0       )

    if model_output.shape[1] == sample.shape[1] * 2 and self.config.variance_type in ["learned", "learned_range"]:
     snake_case__  ,							snake_case__     :					Union[str, Any]    =  jnp.split(__SCREAMING_SNAKE_CASE	,		sample.shape[1]	,		axis=1       )
    else:
     snake_case__     :					List[Any]    =  None

    # 1. compute alphas, betas
    snake_case__     :					Optional[int]    =  state.common.alphas_cumprod[t]
    snake_case__     :					List[str]    =  jnp.where(t > 0	,		state.common.alphas_cumprod[t - 1]	,		jnp.array(1.0	,		dtype=self.dtype       )       )
    snake_case__     :					Any    =  1 - alpha_prod_t
    snake_case__     :					Optional[Any]    =  1 - alpha_prod_t_prev

    # 2. compute predicted original sample from predicted noise also called
    # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
    if self.config.prediction_type == "epsilon":
     snake_case__     :					List[Any]    =  (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
    elif self.config.prediction_type == "sample":
     snake_case__     :					str    =  model_output
    elif self.config.prediction_type == "v_prediction":
     snake_case__     :					str    =  (alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output
    else:
     raise ValueError(
         f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample` "
         """ for the FlaxDDPMScheduler."""       )

    # 3. Clip "predicted x_0"
    if self.config.clip_sample:
     snake_case__     :					Optional[Any]    =  jnp.clip(__SCREAMING_SNAKE_CASE	,		-1	,		1       )

    # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
    # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
    snake_case__     :					Optional[int]    =  (alpha_prod_t_prev ** 0.5 * state.common.betas[t]) / beta_prod_t
    snake_case__     :					Tuple    =  state.common.alphas[t] ** 0.5 * beta_prod_t_prev / beta_prod_t

    # 5. Compute predicted previous sample µ_t
    # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
    snake_case__     :					Dict    =  pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample

    # 6. Add noise
    def random_variance():
     snake_case__     :					Tuple    =  jax.random.split(__SCREAMING_SNAKE_CASE	,		num=1       )
     snake_case__     :					Dict    =  jax.random.normal(__SCREAMING_SNAKE_CASE	,		shape=model_output.shape	,		dtype=self.dtype       )
     return (self._get_variance(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		predicted_variance=__SCREAMING_SNAKE_CASE       ) ** 0.5) * noise

    snake_case__     :					Optional[int]    =  jnp.where(t > 0	,		random_variance()	,		jnp.zeros(model_output.shape	,		dtype=self.dtype       )       )

    snake_case__     :					Optional[Any]    =  pred_prev_sample + variance

    if not return_dict:
     return (pred_prev_sample, state)

    return FlaxDDPMSchedulerOutput(prev_sample=__SCREAMING_SNAKE_CASE	,		state=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		):
    return add_noise_common(state.common	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		):
    return get_velocity_common(state.common	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )


   def __len__(							self       ):
    return self.config.num_train_timesteps












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 ):

     '''simple docstring'''






     def   _SCREAMING_SNAKE_CASE     ( self      :    int ):






           """simple docstring"""




           UpperCamelCase					       =  0







     @slow
     def   _SCREAMING_SNAKE_CASE     ( self      :    Any ):






           """simple docstring"""




           for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
                 self.assertIsNotNone(_SCREAMING_SNAKE_CASE )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(BertTokenizer, BertTokenizerFast) )
                 self.assertGreater(len(_SCREAMING_SNAKE_CASE )   ,						0 )

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







     def   _SCREAMING_SNAKE_CASE     ( self      :    Union[str, Any] ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(BertTokenizer, BertTokenizerFast) )
           self.assertEqual(tokenizer.vocab_size   ,						12 )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(RobertaTokenizer, RobertaTokenizerFast) )
           self.assertEqual(tokenizer.vocab_size   ,						20 )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






           """simple docstring"""




           UpperCamelCase					       =  AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )
           # Check that tokenizer_type ≠ model_type
           UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						config=_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(BertTokenizer, BertTokenizerFast) )
           self.assertEqual(tokenizer.vocab_size   ,						12 )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Tuple ):






           """simple docstring"""




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

                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						tokenizer_type='bert'   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

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

                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						tokenizer_type='gpt2'   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    str ):






           """simple docstring"""




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

                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						tokenizer_type='bert' )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

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

                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						tokenizer_type='gpt2' )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )







     def   _SCREAMING_SNAKE_CASE     ( self      :    str ):






           """simple docstring"""




           with pytest.raises(_SCREAMING_SNAKE_CASE ):
                 AutoTokenizer.from_pretrained('./'   ,						tokenizer_type='xxx' )







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    Tuple ):






           """simple docstring"""




           for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                 UpperCamelCase					       =  tokenizer_class.from_pretrained('wietsedv/bert-base-dutch-cased' )
                 self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(BertTokenizer, BertTokenizerFast) )

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

                 self.assertEqual(tokenizer.model_max_length   ,						512 )







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """simple docstring"""




           for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                 with self.assertRaisesRegex(
                     _SCREAMING_SNAKE_CASE   ,						'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   _SCREAMING_SNAKE_CASE     ( self      :    int ):






           """simple docstring"""




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







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    List[Any] ):






           """simple docstring"""




           self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'   ,						use_fast=_SCREAMING_SNAKE_CASE )   ,						_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased' )   ,						_SCREAMING_SNAKE_CASE )







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






           """simple docstring"""




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

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







     @require_tokenizers
     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[Any] ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config' )
           self.assertEqual(type(_SCREAMING_SNAKE_CASE )   ,						_SCREAMING_SNAKE_CASE )
           self.assertEqual(tokenizer.model_max_length   ,						512 )
           self.assertEqual(tokenizer.vocab_size   ,						3_0000 )
           self.assertEqual(tokenizer.unk_token   ,						'[UNK]' )
           self.assertEqual(tokenizer.padding_side   ,						'right' )
           self.assertEqual(tokenizer.truncation_side   ,						'right' )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						(BertTokenizer, BertTokenizerFast) )
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE )
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )

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







     def   _SCREAMING_SNAKE_CASE     ( self      :    int ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained('ctrl' )
           # There is no fast CTRL so this always gives us a slow tokenizer.
           self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






           """simple docstring"""




           UpperCamelCase					       =  get_tokenizer_config('bert-base-cased' )
           UpperCamelCase					       =  config.pop('_commit_hash'   ,						_SCREAMING_SNAKE_CASE )
           # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
           self.assertEqual(_SCREAMING_SNAKE_CASE   ,						{'do_lower_case': False} )

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

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

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







     def   _SCREAMING_SNAKE_CASE     ( self      :    int ):






           """simple docstring"""




           try:
                 AutoConfig.register('custom'   ,						_SCREAMING_SNAKE_CASE )

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

                 UpperCamelCase					       =  CustomTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
                 with tempfile.TemporaryDirectory() as tmp_dir:
                       tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE )

                       UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
                       self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

           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   _SCREAMING_SNAKE_CASE     ( self      :    List[Any] ):






           """simple docstring"""




           try:
                 AutoConfig.register('custom'   ,						_SCREAMING_SNAKE_CASE )

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

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

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

                 # 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(_SCREAMING_SNAKE_CASE )
                       bert_tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE )
                       UpperCamelCase					       =  CustomTokenizerFast.from_pretrained(_SCREAMING_SNAKE_CASE )

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

                       UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE )
                       self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

                       UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                       self.assertIsInstance(_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE )

           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   _SCREAMING_SNAKE_CASE     ( self      :    int ):






           """simple docstring"""




           with self.assertRaises(_SCREAMING_SNAKE_CASE ):
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer' )
           # If remote code is disabled, we can't load this config.
           with self.assertRaises(_SCREAMING_SNAKE_CASE ):
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'   ,						trust_remote_code=_SCREAMING_SNAKE_CASE )

           UpperCamelCase					       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'   ,						trust_remote_code=_SCREAMING_SNAKE_CASE )
           self.assertTrue(tokenizer.special_attribute_present )
           # Test tokenizer can be reloaded.
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE )
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						trust_remote_code=_SCREAMING_SNAKE_CASE )
           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=_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 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(_SCREAMING_SNAKE_CASE )
                       UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						trust_remote_code=_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 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   _SCREAMING_SNAKE_CASE     ( self      :    Optional[int] ):






           """simple docstring"""




           class 					A__     (     __snake_case ):

                '''simple docstring'''






                snake_case__					=					False





           class 					A__     (     __snake_case ):

                '''simple docstring'''






                snake_case__					=					NewTokenizer
                snake_case__					=					False

           try:
                 AutoConfig.register('custom'   ,						_SCREAMING_SNAKE_CASE )
                 AutoTokenizer.register(_SCREAMING_SNAKE_CASE   ,						slow_tokenizer_class=_SCREAMING_SNAKE_CASE )
                 AutoTokenizer.register(_SCREAMING_SNAKE_CASE   ,						fast_tokenizer_class=_SCREAMING_SNAKE_CASE )
                 # 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=_SCREAMING_SNAKE_CASE )
                 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=_SCREAMING_SNAKE_CASE )
                 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=_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 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=_SCREAMING_SNAKE_CASE )
                 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=_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 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   _SCREAMING_SNAKE_CASE     ( self      :    Optional[Any] ):






           """simple docstring"""




           UpperCamelCase					       =  AutoTokenizer.from_pretrained(
               'hf-internal-testing/test_dynamic_tokenizer_legacy'   ,						trust_remote_code=_SCREAMING_SNAKE_CASE )
           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=_SCREAMING_SNAKE_CASE   ,						use_fast=_SCREAMING_SNAKE_CASE )
                 self.assertTrue(tokenizer.special_attribute_present )
                 self.assertEqual(tokenizer.__class__.__name__   ,						'NewTokenizer' )
           else:
                 self.assertEqual(tokenizer.__class__.__name__   ,						'NewTokenizer' )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Tuple ):






           """simple docstring"""




           with self.assertRaisesRegex(
               _SCREAMING_SNAKE_CASE   ,						'bert-base is not a local folder and is not a valid model identifier' ):
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained('bert-base' )







     def   _SCREAMING_SNAKE_CASE     ( self      :    Dict ):






           """simple docstring"""




           with self.assertRaisesRegex(
               _SCREAMING_SNAKE_CASE   ,						r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)' ):
                 UpperCamelCase					       =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE   ,						revision='aaaaaa' )







     def   _SCREAMING_SNAKE_CASE     ( self      :    str ):






           """simple docstring"""




           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 )



