




"""simple docstring"""



import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


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

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
      from test_module.custom_tokenization_fast import CustomTokenizerFast




class 	UpperCAmelCase_  (						unittest.TestCase							):




    def 							__magic_name__							(    self						:       Optional[Any]      )      ->							Optional[int]:




     '''simple docstring'''

     A__       =				mock.Mock()
     A__       =				500
     A__       =				{}
     A__       =				HTTPError
     A__       =				{}

     # Download this model to make sure it's in the cache.
     A__       =				BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"      )

     # Under the mock environment we get a 500 error when trying to reach the tokenizer.
     with mock.patch("requests.Session.request"	, return_value=SCREAMING_SNAKE_CASE__      ) as mock_head:
      A__       =				BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"      )
      # This check we did call the fake head request
      mock_head.assert_called()




    @require_tokenizers
    def 							__magic_name__							(    self						:       int      )      ->							List[Any]:




     '''simple docstring'''

     A__       =				mock.Mock()
     A__       =				500
     A__       =				{}
     A__       =				HTTPError
     A__       =				{}

     # Download this model to make sure it's in the cache.
     A__       =				GPTaTokenizerFast.from_pretrained("gpt2"      )

     # Under the mock environment we get a 500 error when trying to reach the tokenizer.
     with mock.patch("requests.Session.request"	, return_value=SCREAMING_SNAKE_CASE__      ) as mock_head:
      A__       =				GPTaTokenizerFast.from_pretrained("gpt2"      )
      # This check we did call the fake head request
      mock_head.assert_called()




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




     '''simple docstring'''

     try:
      A__       =				tempfile.mktemp()
      with open(SCREAMING_SNAKE_CASE__	, "wb"      ) as f:
       http_get("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"	, SCREAMING_SNAKE_CASE__      )

      A__       =				AlbertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE__      )
     finally:
      os.remove(SCREAMING_SNAKE_CASE__      )

     # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
     # the current folder and have the right name.
     if os.path.isfile("tokenizer.json"      ):
      # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
      return
     try:
      with open("tokenizer.json"	, "wb"      ) as f:
       http_get("https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json"	, SCREAMING_SNAKE_CASE__      )
      A__       =				AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"      )
      # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
      self.assertEqual(tokenizer.vocab_size	, 1_000      )
      # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

     finally:
      os.remove("tokenizer.json"      )




    def 							__magic_name__							(    self						:       List[str]      )      ->							Optional[Any]:




     '''simple docstring'''

     A__       =				AlbertTokenizer.from_pretrained("https://huggingface.co/albert-base-v1/resolve/main/spiece.model"      )






@is_staging_test
class 	UpperCAmelCase_  (						unittest.TestCase							):
    lowercase__											=      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']




    @classmethod
    def 							__magic_name__							(    cls						:       List[str]      )      ->							List[str]:




     '''simple docstring'''

     A__       =				TOKEN
     HfFolder.save_token(SCREAMING_SNAKE_CASE__      )




    @classmethod
    def 							__magic_name__							(    cls						:       Any      )      ->							List[str]:




     '''simple docstring'''

     try:
      delete_repo(token=cls._token	, repo_id="test-tokenizer"      )
     except HTTPError:
      pass

     try:
      delete_repo(token=cls._token	, repo_id="valid_org/test-tokenizer-org"      )
     except HTTPError:
      pass

     try:
      delete_repo(token=cls._token	, repo_id="test-dynamic-tokenizer"      )
     except HTTPError:
      pass




    def 							__magic_name__							(    self						:       Tuple      )      ->							List[str]:




     '''simple docstring'''

     with tempfile.TemporaryDirectory() as tmp_dir:
      A__       =				os.path.join(SCREAMING_SNAKE_CASE__	, "vocab.txt"      )
      with open(SCREAMING_SNAKE_CASE__	, "w"	, encoding="utf-8"      ) as vocab_writer:
       vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]      )      )
      A__       =				BertTokenizer(SCREAMING_SNAKE_CASE__      )

     tokenizer.push_to_hub("test-tokenizer"	, use_auth_token=self._token      )
     A__       =				BertTokenizer.from_pretrained(F"""{USER}/test-tokenizer"""      )
     self.assertDictEqual(new_tokenizer.vocab	, tokenizer.vocab      )

     # Reset repo
     delete_repo(token=self._token	, repo_id="test-tokenizer"      )

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__	, repo_id="test-tokenizer"	, push_to_hub=SCREAMING_SNAKE_CASE__	, use_auth_token=self._token      )

     A__       =				BertTokenizer.from_pretrained(F"""{USER}/test-tokenizer"""      )
     self.assertDictEqual(new_tokenizer.vocab	, tokenizer.vocab      )




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




     '''simple docstring'''

     with tempfile.TemporaryDirectory() as tmp_dir:
      A__       =				os.path.join(SCREAMING_SNAKE_CASE__	, "vocab.txt"      )
      with open(SCREAMING_SNAKE_CASE__	, "w"	, encoding="utf-8"      ) as vocab_writer:
       vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]      )      )
      A__       =				BertTokenizer(SCREAMING_SNAKE_CASE__      )

     tokenizer.push_to_hub("valid_org/test-tokenizer-org"	, use_auth_token=self._token      )
     A__       =				BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"      )
     self.assertDictEqual(new_tokenizer.vocab	, tokenizer.vocab      )

     # Reset repo
     delete_repo(token=self._token	, repo_id="valid_org/test-tokenizer-org"      )

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      tokenizer.save_pretrained(
          SCREAMING_SNAKE_CASE__	, repo_id="valid_org/test-tokenizer-org"	, push_to_hub=SCREAMING_SNAKE_CASE__	, use_auth_token=self._token      )

     A__       =				BertTokenizer.from_pretrained("valid_org/test-tokenizer-org"      )
     self.assertDictEqual(new_tokenizer.vocab	, tokenizer.vocab      )




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




     '''simple docstring'''

     CustomTokenizer.register_for_auto_class()
     with tempfile.TemporaryDirectory() as tmp_dir:
      A__       =				os.path.join(SCREAMING_SNAKE_CASE__	, "vocab.txt"      )
      with open(SCREAMING_SNAKE_CASE__	, "w"	, encoding="utf-8"      ) as vocab_writer:
       vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]      )      )
      A__       =				CustomTokenizer(SCREAMING_SNAKE_CASE__      )

     # No fast custom tokenizer
     tokenizer.push_to_hub("test-dynamic-tokenizer"	, use_auth_token=self._token      )

     A__       =				AutoTokenizer.from_pretrained(F"""{USER}/test-dynamic-tokenizer"""	, trust_remote_code=SCREAMING_SNAKE_CASE__      )
     # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
     self.assertEqual(tokenizer.__class__.__name__	, "CustomTokenizer"      )

     # Fast and slow custom tokenizer
     CustomTokenizerFast.register_for_auto_class()
     with tempfile.TemporaryDirectory() as tmp_dir:
      A__       =				os.path.join(SCREAMING_SNAKE_CASE__	, "vocab.txt"      )
      with open(SCREAMING_SNAKE_CASE__	, "w"	, encoding="utf-8"      ) as vocab_writer:
       vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]      )      )

      A__       =				BertTokenizerFast.from_pretrained(SCREAMING_SNAKE_CASE__      )
      bert_tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__      )
      A__       =				CustomTokenizerFast.from_pretrained(SCREAMING_SNAKE_CASE__      )

     tokenizer.push_to_hub("test-dynamic-tokenizer"	, use_auth_token=self._token      )

     A__       =				AutoTokenizer.from_pretrained(F"""{USER}/test-dynamic-tokenizer"""	, trust_remote_code=SCREAMING_SNAKE_CASE__      )
     # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
     self.assertEqual(tokenizer.__class__.__name__	, "CustomTokenizerFast"      )
     A__       =				AutoTokenizer.from_pretrained(
         F"""{USER}/test-dynamic-tokenizer"""	, use_fast=SCREAMING_SNAKE_CASE__	, trust_remote_code=SCREAMING_SNAKE_CASE__      )
     # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
     self.assertEqual(tokenizer.__class__.__name__	, "CustomTokenizer"      )






class 	UpperCAmelCase_  (						unittest.TestCase							):




    def 							__magic_name__							(    self						:       Any      )      ->							Any:




     '''simple docstring'''

     A__       =				Trie()
     trie.add("Hello 友達"      )
     self.assertEqual(trie.data	, {"H": {"e": {"l": {"l": {"o": {" ": {"友": {"達": {"": 1}}}}}}}}}      )
     trie.add("Hello"      )
     trie.data
     self.assertEqual(trie.data	, {"H": {"e": {"l": {"l": {"o": {"": 1, " ": {"友": {"達": {"": 1}}}}}}}}}      )




    def 							__magic_name__							(    self						:       Optional[Any]      )      ->							Dict:




     '''simple docstring'''

     A__       =				Trie()
     self.assertEqual(trie.split("[CLS] This is a extra_id_100"      )	, ["[CLS] This is a extra_id_100"]      )
     trie.add("[CLS]"      )
     trie.add("extra_id_1"      )
     trie.add("extra_id_100"      )
     self.assertEqual(trie.split("[CLS] This is a extra_id_100"      )	, ["[CLS]", " This is a ", "extra_id_100"]      )




    def 							__magic_name__							(    self						:       Optional[Any]      )      ->							Optional[int]:




     '''simple docstring'''

     A__       =				Trie()
     trie.add("A"      )
     self.assertEqual(trie.split("ABC"      )	, ["A", "BC"]      )
     self.assertEqual(trie.split("BCA"      )	, ["BC", "A"]      )




    def 							__magic_name__							(    self						:       str      )      ->							Tuple:




     '''simple docstring'''

     A__       =				Trie()
     trie.add("TOKEN]"      )
     trie.add("[SPECIAL_TOKEN]"      )
     self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"      )	, ["This is something ", "[SPECIAL_TOKEN]"]      )




    def 							__magic_name__							(    self						:       List[str]      )      ->							Tuple:




     '''simple docstring'''

     A__       =				Trie()
     trie.add("A"      )
     trie.add("P"      )
     trie.add("[SPECIAL_TOKEN]"      )
     self.assertEqual(trie.split("This is something [SPECIAL_TOKEN]"      )	, ["This is something ", "[SPECIAL_TOKEN]"]      )




    def 							__magic_name__							(    self						:       Optional[int]      )      ->							Dict:




     '''simple docstring'''

     A__       =				Trie()
     trie.add("AB"      )
     trie.add("B"      )
     trie.add("C"      )
     self.assertEqual(trie.split("ABC"      )	, ["AB", "C"]      )




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




     '''simple docstring'''

     A__       =				Trie()
     trie.add("ABC"      )
     trie.add("B"      )
     trie.add("CD"      )
     self.assertEqual(trie.split("ABCD"      )	, ["ABC", "D"]      )




    def 							__magic_name__							(    self						:       int      )      ->							Dict:




     '''simple docstring'''

     A__       =				Trie()
     A__       =				trie.cut_text("ABC"	, [0, 0, 2, 1, 2, 3]      )
     self.assertEqual(SCREAMING_SNAKE_CASE__	, ["AB", "C"]      )












"""simple docstring"""
import qiskit



def      __lowerCamelCase   (							a_     :		int ,   a_     :		int							)			->      qiskit.result.counts.Counts:
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.Aer.get_backend('''aer_simulator'''							)

      # Create a Quantum Circuit acting on the q register
      __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  qiskit.QuantumCircuit(a_ ,   a_							)

      # Apply X (NOT) Gate to Qubits 0 & 1
      circuit.x(0							)
      circuit.x(1							)

      # Map the quantum measurement to the classical bits
      circuit.measure([0, 1] ,   [0, 1]							)

      # Execute the circuit on the qasm simulator
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.execute(a_ ,   a_ ,   shots=10_00							)

      # Return the histogram data of the results of the experiment.
      return job.result().get_counts(a_							)


if __name__ == "__main__":
  lowerCamelCase_								=		single_qubit_measure(2, 2)
  print(f'Total count for various states are: {counts}')