

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

   '''simple docstring'''




   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =0



   @slow
   def  _UpperCAmelCase (				self       )							->    Union[str, Any]:






     """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(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():
       a__  =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  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )
     self.assertIsInstance(SCREAMING_SNAKE_CASE__,    (BertTokenizer, BertTokenizerFast)       )
     self.assertEqual(tokenizer.vocab_size,    12       )



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






     """simple docstring"""






     a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )
     self.assertIsInstance(SCREAMING_SNAKE_CASE__,    (RobertaTokenizer, RobertaTokenizerFast)       )
     self.assertEqual(tokenizer.vocab_size,    20       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






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



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






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

       a__  =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'''       )       )

       a__  =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  _UpperCAmelCase (				self       )							->    Optional[Any]:






     """simple docstring"""






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

       a__  =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'''       )       )

       a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__,    tokenizer_type='''gpt2'''       )
       self.assertIsInstance(SCREAMING_SNAKE_CASE__,    SCREAMING_SNAKE_CASE__       )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






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



   @require_tokenizers
   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
       a__  =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  _UpperCAmelCase (				self       )							->    List[str]:






     """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''',    ):
         a__  =tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''       )



   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






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



   @require_tokenizers
   def  _UpperCAmelCase (				self       )							->    str:






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






     """simple docstring"""






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

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



   @require_tokenizers
   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =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,    30000       )
     self.assertEqual(tokenizer.unk_token,    '''[UNK]'''       )
     self.assertEqual(tokenizer.padding_side,    '''right'''       )
     self.assertEqual(tokenizer.truncation_side,    '''right'''       )



   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     a__  =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__       )
       a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )

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



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =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  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =get_tokenizer_config('''bert-base-cased'''       )
     a__  =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.
     a__  =get_tokenizer_config(SCREAMING_SNAKE_CASE__       )
     self.assertDictEqual(SCREAMING_SNAKE_CASE__,    {}       )

     # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
     a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )
     with tempfile.TemporaryDirectory() as tmp_dir:
       tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__       )
       a__  =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  _UpperCAmelCase (				self       )							->    Dict:






     """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__       )

       a__  =CustomTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )
       with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__       )

         a__  =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  _UpperCAmelCase (				self       )							->    Optional[int]:






     """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:
         a__  =BertTokenizerFast.from_pretrained(SCREAMING_SNAKE_CASE__       )
         bert_tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__       )
         a__  =CustomTokenizerFast.from_pretrained(SCREAMING_SNAKE_CASE__       )

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

         a__  =AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__       )
         self.assertIsInstance(SCREAMING_SNAKE_CASE__,    SCREAMING_SNAKE_CASE__       )

         a__  =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  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     with self.assertRaises(SCREAMING_SNAKE_CASE__       ):
       a__  =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__       ):
       a__  =AutoTokenizer.from_pretrained(
           '''hf-internal-testing/test_dynamic_tokenizer''',    trust_remote_code=SCREAMING_SNAKE_CASE__       )

     a__  =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__       )
       a__  =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
       a__  =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__       )
         a__  =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  _UpperCAmelCase (				self       )							->    List[Any]:






     """simple docstring"""






     class 						__magic_name__			(							UpperCAmelCase__							):

        '''simple docstring'''




        lowerCamelCase__ :	int    =   False







     class 						__magic_name__			(							UpperCAmelCase__							):

        '''simple docstring'''




        lowerCamelCase__ :	List[Any]    =   NewTokenizer
        lowerCamelCase__ :	int    =   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
       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=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.
       a__  =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       )
       a__  =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
       a__  =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       )
       a__  =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  _UpperCAmelCase (				self       )							->    List[str]:






     """simple docstring"""






     a__  =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
       a__  =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  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






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



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






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



   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     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 numpy as np
import qiskit







def      UpperCamelCase_						(					snake_case_       :       int = 8						,		snake_case_       :       int | None = None      )					->     str:






 '''simple docstring'''

 __lowerCAmelCase											=						np.random.default_rng(seed=snake_case_      )

 # Roughly 25% of the qubits will contribute to the key.
 # So we take more than we need.
 __lowerCAmelCase											=						6 * key_len
 # Measurement basis for Alice's qubits.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )
 # The set of states Alice will prepare.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )
 # Measurement basis for Bob's qubits.
 __lowerCAmelCase											=						rng.integers(2						,		size=snake_case_      )

 # Quantum Circuit to simulate BB84
 __lowerCAmelCase											=						qiskit.QuantumCircuit(snake_case_						,		name="""BB84"""      )

 # Alice prepares her qubits according to rules above.
 for index, _ in enumerate(snake_case_      ):
  if alice_state[index] == 1:
   bbaa_circ.x(snake_case_      )
  if alice_basis[index] == 1:
   bbaa_circ.h(snake_case_      )
 bbaa_circ.barrier()

 # Bob measures the received qubits according to rules above.
 for index, _ in enumerate(snake_case_      ):
  if bob_basis[index] == 1:
   bbaa_circ.h(snake_case_      )

 bbaa_circ.barrier()
 bbaa_circ.measure_all()

 # Simulate the quantum circuit.
 __lowerCAmelCase											=						qiskit.Aer.get_backend("""aer_simulator"""      )
 # We only need to run one shot because the key is unique.
 # Multiple shots will produce the same key.
 __lowerCAmelCase											=						qiskit.execute(snake_case_						,		snake_case_						,		shots=1						,		seed_simulator=snake_case_      )
 # Returns the result of measurement.
 __lowerCAmelCase											=						job.result().get_counts(snake_case_      ).most_frequent()

 # Extracting the generated key from the simulation results.
 # Only keep measurement results where Alice and Bob chose the same basis.
 __lowerCAmelCase											=						"""""".join(
     [
         result_bit
         for alice_basis_bit, bob_basis_bit, result_bit in zip(
             snake_case_						,		snake_case_						,		snake_case_      )
         if alice_basis_bit == bob_basis_bit
     ]      )

 # Get final key. Pad with 0 if too short, otherwise truncate.
 __lowerCAmelCase											=						gen_key[:key_len] if len(snake_case_      ) >= key_len else gen_key.ljust(snake_case_						,		"""0"""      )
 return key


if __name__ == "__main__":
 print(f'The generated key is : {bbaa(8, seed=0)}')
 from doctest import testmod

 testmod()






