


import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
						from tokenizers import Tokenizer
						from tokenizers.models import WordPiece







class 					snake_case__(				unittest.TestCase				):







						'''simple docstring'''




						def     lowercase_			(					self ,    __lowercase				)       ->     Optional[int]:
										lowerCAmelCase_			:   str     					=					list(tokenizer_class.max_model_input_sizes.keys()				)
										for model_name in sa_models[:1]:
														lowerCAmelCase_			:   Any     					=					tokenizer_class.from_pretrained(__lowercase				)
														self.assertIsNotNone(__lowercase				)
														self.assertIsInstance(__lowercase ,    __lowercase				)
														self.assertIsInstance(__lowercase ,    __lowercase				)

														for special_tok in tokenizer.all_special_tokens:
																		self.assertIsInstance(__lowercase ,    __lowercase				)
																		lowerCAmelCase_			:   Union[str, Any]     					=					tokenizer.convert_tokens_to_ids(__lowercase				)
																		self.assertIsInstance(__lowercase ,    __lowercase				)




						def     lowercase_			(					self ,    __lowercase ,    __lowercase = None				)       ->     Union[str, Any]:
										lowerCAmelCase_			:   List[Any]     					=					pickle.dumps(__lowercase				)
										self.assertIsNotNone(__lowercase				)

										lowerCAmelCase_			:   List[Any]     					=					pickle.loads(__lowercase				)

										# Ensure is_fast is correctly restored
										self.assertEqual(be_restored.is_fast ,    be_original.is_fast				)

										# Ensure encodings are potentially correctly restored
										if be_original.is_fast:
														self.assertIsNotNone(be_restored.encodings				)
										else:
														self.assertIsNone(be_restored.encodings				)

										# Ensure the keys are the same
										for original_v, restored_v in zip(be_original.values() ,    be_restored.values()				):
														if equal_op:
																		self.assertTrue(equal_op(__lowercase ,    __lowercase				)				)
														else:
																		self.assertEqual(__lowercase ,    __lowercase				)




						@slow
						def     lowercase_			(					self				)       ->     Optional[int]:
										self.check_tokenizer_from_pretrained(__lowercase				)




						def     lowercase_			(					self				)       ->     str:
										self.assertEqual(TensorType('''tf'''				) ,    TensorType.TENSORFLOW				)
										self.assertEqual(TensorType('''pt'''				) ,    TensorType.PYTORCH				)
										self.assertEqual(TensorType('''np'''				) ,    TensorType.NUMPY				)




						@require_tokenizers
						def     lowercase_			(					self				)       ->     List[Any]:
										import numpy as np

										lowerCAmelCase_			:   Any     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)
										lowerCAmelCase_			:   str     					=					BertTokenizerFast.from_pretrained('''bert-base-cased'''				)

										# Python no tensor
										with self.subTest('''BatchEncoding (Python, return_tensors=None)'''				):
														self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''				)				)

										with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''				):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode''' ,    return_tensors=TensorType.NUMPY				) ,    np.array_equal				)

										with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''				):
														self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''				)				)

										with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''				):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode''' ,    return_tensors=TensorType.NUMPY				) ,    np.array_equal				)




						@require_tf
						@require_tokenizers
						def     lowercase_			(					self				)       ->     Optional[int]:
										import tensorflow as tf

										def tf_array_equals(__lowercase ,    __lowercase				):
														return tf.reduce_all(tf.equal(__lowercase ,    __lowercase				)				)

										lowerCAmelCase_			:   Dict     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)
										lowerCAmelCase_			:   int     					=					BertTokenizerFast.from_pretrained('''bert-base-cased'''				)

										with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''				):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode''' ,    return_tensors=TensorType.TENSORFLOW				) ,    __lowercase				)

										with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''				):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode''' ,    return_tensors=TensorType.TENSORFLOW				) ,    __lowercase				)




						@require_torch
						@require_tokenizers
						def     lowercase_			(					self				)       ->     Any:
										import torch

										lowerCAmelCase_			:   Union[str, Any]     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)
										lowerCAmelCase_			:   int     					=					BertTokenizerFast.from_pretrained('''bert-base-cased'''				)

										with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''				):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode''' ,    return_tensors=TensorType.PYTORCH				) ,    torch.equal				)

										with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''				):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode''' ,    return_tensors=TensorType.PYTORCH				) ,    torch.equal				)




						@require_tokenizers
						def     lowercase_			(					self				)       ->     Tuple:
										lowerCAmelCase_			:   Any     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)
										lowerCAmelCase_			:   Dict     					=					BertTokenizerFast.from_pretrained('''bert-base-cased'''				)

										with self.subTest('''Python Tokenizer'''				):
														self.assertFalse(tokenizer_p('''Small example to_encode'''				).is_fast				)

										with self.subTest('''Rust Tokenizer'''				):
														self.assertTrue(tokenizer_r('''Small example to_encode'''				).is_fast				)




						@require_tokenizers
						def     lowercase_			(					self				)       ->     Union[str, Any]:
										lowerCAmelCase_			:   List[str]     					=					BertTokenizerFast.from_pretrained('''bert-base-cased'''				)
										lowerCAmelCase_			:   List[str]     					=					tokenizer_r(['''Test''', '''\xad''', '''test'''] ,    is_split_into_words=__lowercase				)

										self.assertEqual(encoded.word_to_tokens(0				) ,    TokenSpan(start=1 ,    end=2				)				)
										self.assertEqual(encoded.word_to_tokens(1				) ,    __lowercase				)
										self.assertEqual(encoded.word_to_tokens(2				) ,    TokenSpan(start=2 ,    end=3				)				)




						def     lowercase_			(					self				)       ->     Union[str, Any]:
										lowerCAmelCase_			:   Tuple     					=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}				)
										lowerCAmelCase_			:   Optional[Any]     					=					batch.convert_to_tensors(tensor_type='''np'''				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (2, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (2,)				)
										# test converting the converted
										with CaptureStderr() as cs:
														lowerCAmelCase_			:   int     					=					batch.convert_to_tensors(tensor_type='''np'''				)
										self.assertFalse(len(cs.err				) ,    msg=f"""should have no warning, but got {cs.err}"""				)

										lowerCAmelCase_			:   Any     					=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}				)
										lowerCAmelCase_			:   Optional[Any]     					=					batch.convert_to_tensors(tensor_type='''np''' ,    prepend_batch_axis=__lowercase				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (1, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (1,)				)




						@require_torch
						def     lowercase_			(					self				)       ->     Any:
										lowerCAmelCase_			:   int     					=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}				)
										lowerCAmelCase_			:   Union[str, Any]     					=					batch.convert_to_tensors(tensor_type='''pt'''				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (2, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (2,)				)
										# test converting the converted
										with CaptureStderr() as cs:
														lowerCAmelCase_			:   int     					=					batch.convert_to_tensors(tensor_type='''pt'''				)
										self.assertFalse(len(cs.err				) ,    msg=f"""should have no warning, but got {cs.err}"""				)

										lowerCAmelCase_			:   Optional[Any]     					=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}				)
										lowerCAmelCase_			:   Optional[Any]     					=					batch.convert_to_tensors(tensor_type='''pt''' ,    prepend_batch_axis=__lowercase				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (1, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (1,)				)




						@require_tf
						def     lowercase_			(					self				)       ->     List[Any]:
										lowerCAmelCase_			:   Optional[int]     					=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}				)
										lowerCAmelCase_			:   Tuple     					=					batch.convert_to_tensors(tensor_type='''tf'''				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (2, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (2,)				)
										# test converting the converted
										with CaptureStderr() as cs:
														lowerCAmelCase_			:   str     					=					batch.convert_to_tensors(tensor_type='''tf'''				)
										self.assertFalse(len(cs.err				) ,    msg=f"""should have no warning, but got {cs.err}"""				)

										lowerCAmelCase_			:   str     					=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}				)
										lowerCAmelCase_			:   Union[str, Any]     					=					batch.convert_to_tensors(tensor_type='''tf''' ,    prepend_batch_axis=__lowercase				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (1, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (1,)				)




						@require_flax
						def     lowercase_			(					self				)       ->     Tuple:
										lowerCAmelCase_			:   Dict     					=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}				)
										lowerCAmelCase_			:   int     					=					batch.convert_to_tensors(tensor_type='''jax'''				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (2, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (2,)				)
										# test converting the converted
										with CaptureStderr() as cs:
														lowerCAmelCase_			:   str     					=					batch.convert_to_tensors(tensor_type='''jax'''				)
										self.assertFalse(len(cs.err				) ,    msg=f"""should have no warning, but got {cs.err}"""				)

										lowerCAmelCase_			:   Any     					=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}				)
										lowerCAmelCase_			:   int     					=					batch.convert_to_tensors(tensor_type='''jax''' ,    prepend_batch_axis=__lowercase				)
										self.assertEqual(tensor_batch['''inputs'''].shape ,    (1, 3)				)
										self.assertEqual(tensor_batch['''labels'''].shape ,    (1,)				)




						def     lowercase_			(					self				)       ->     List[Any]:
										lowerCAmelCase_			:   Optional[int]     					=					[{'''input_ids''': np.array([0, 1, 2]				)}, {'''input_ids''': np.array([0, 1, 2, 3]				)}]
										lowerCAmelCase_			:   int     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)

										lowerCAmelCase_			:   Optional[Any]     					=					tokenizer.pad(__lowercase ,    padding=__lowercase				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    np.ndarray				)				)
										self.assertEqual(batch['''input_ids'''].tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
										lowerCAmelCase_			:   List[str]     					=					tokenizer.pad(__lowercase ,    padding=__lowercase ,    return_tensors='''np'''				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    np.ndarray				)				)
										self.assertEqual(batch['''input_ids'''].tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




						@require_torch
						def     lowercase_			(					self				)       ->     str:
										import torch

										lowerCAmelCase_			:   Dict     					=					[{'''input_ids''': torch.tensor([0, 1, 2]				)}, {'''input_ids''': torch.tensor([0, 1, 2, 3]				)}]
										lowerCAmelCase_			:   List[str]     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)

										lowerCAmelCase_			:   Optional[Any]     					=					tokenizer.pad(__lowercase ,    padding=__lowercase				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    torch.Tensor				)				)
										self.assertEqual(batch['''input_ids'''].tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
										lowerCAmelCase_			:   Union[str, Any]     					=					tokenizer.pad(__lowercase ,    padding=__lowercase ,    return_tensors='''pt'''				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    torch.Tensor				)				)
										self.assertEqual(batch['''input_ids'''].tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




						@require_tf
						def     lowercase_			(					self				)       ->     Optional[Any]:
										import tensorflow as tf

										lowerCAmelCase_			:   List[Any]     					=					[{'''input_ids''': tf.constant([0, 1, 2]				)}, {'''input_ids''': tf.constant([0, 1, 2, 3]				)}]
										lowerCAmelCase_			:   int     					=					BertTokenizer.from_pretrained('''bert-base-cased'''				)

										lowerCAmelCase_			:   Any     					=					tokenizer.pad(__lowercase ,    padding=__lowercase				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    tf.Tensor				)				)
										self.assertEqual(batch['''input_ids'''].numpy().tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
										lowerCAmelCase_			:   int     					=					tokenizer.pad(__lowercase ,    padding=__lowercase ,    return_tensors='''tf'''				)
										self.assertTrue(isinstance(batch['''input_ids'''] ,    tf.Tensor				)				)
										self.assertEqual(batch['''input_ids'''].numpy().tolist() ,    [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




						@require_tokenizers
						def     lowercase_			(					self				)       ->     str:
										lowerCAmelCase_			:   str     					=					Tokenizer(WordPiece(unk_token='''[UNK]'''				)				)
										PreTrainedTokenizerFast(tokenizer_object=__lowercase				)




						@require_tokenizers
						def     lowercase_			(					self				)       ->     Union[str, Any]:
										lowerCAmelCase_			:   Dict     					=					Tokenizer(WordPiece(unk_token='''[UNK]'''				)				)
										with tempfile.TemporaryDirectory() as tmpdirname:
														bert_tokenizer.save(os.path.join(__lowercase ,    '''tokenizer.json'''				)				)
														PreTrainedTokenizerFast(tokenizer_file=os.path.join(__lowercase ,    '''tokenizer.json'''				)				)



import doctest

import projectq
from projectq.ops import H, Measure



def       lowerCAmelCase			(		lowerCAmelCase_			)->			int:
				lowerCAmelCase_			:   List[Any]     					=					quantum_engine.allocate_qubit()
				H | qubit
				Measure | qubit
				return int(lowerCAmelCase_			)


if __name__ == "__main__":
						doctest.testmod()

						# initialises a new quantum backend
						_UpperCAmelCase      :	str  =projectq.MainEngine()

						# Generate a list of 10 random numbers
						_UpperCAmelCase      :	Optional[int]  =[get_random_number(quantum_engine) for _ in range(10)]

						# Flushes the quantum engine from memory
						quantum_engine.flush()

						print("""Random numbers""", random_numbers_list)