

"""simple docstring"""


from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


__A		     =    logging.get_logger(__name__)

__A		     =    {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

__A		     =    {
    "vocab_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json",
    },
    "merges_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "openai/clip-vit-base-patch32": (
            "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json"
        ),
    },
}

__A		     =    {
    "openai/clip-vit-base-patch32": 77,
}





class 					snake_case			(       __snake_case						):
				SCREAMING_SNAKE_CASE_     :   Dict        =						VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_     :   Optional[int]        =						PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_     :   Tuple        =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_     :   Union[str, Any]        =						["""input_ids""", """attention_mask"""]
				SCREAMING_SNAKE_CASE_     :   str        =						CLIPTokenizer

				def __init__(			self							:       Tuple  ,						UpperCamelCase__							:       Optional[int]=None  ,						UpperCamelCase__							:       List[str]=None  ,						UpperCamelCase__							:       str=None  ,						UpperCamelCase__							:       Dict="<|endoftext|>"  ,						UpperCamelCase__							:       int="<|startoftext|>"  ,						UpperCamelCase__							:       Optional[int]="<|endoftext|>"  ,						UpperCamelCase__							:       Union[str, Any]="<|endoftext|>"  ,						**UpperCamelCase__							:       str  ,						)->     str:



						'''simple docstring'''


						super().__init__(
						    UpperCamelCase__  ,						UpperCamelCase__  ,						tokenizer_file=UpperCamelCase__  ,						unk_token=UpperCamelCase__  ,						bos_token=UpperCamelCase__  ,						eos_token=UpperCamelCase__  ,						pad_token=UpperCamelCase__  ,						**UpperCamelCase__  ,						)

						if not isinstance(self.backend_tokenizer.pre_tokenizer  ,						pre_tokenizers.Sequence):
								raise ValueError(
								    "The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been"
								    " heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using"
								    " to be compatible with this version.The easiest way to do so is"
								    " `CLIPTokenizerFast.from_pretrained(\"path_to_local_folder_or_hub_repo, from_slow=True)`. If you want"
								    " to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of"
								    " transformers.")

						self._wrap_decode_method_backend_tokenizer()

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



						'''simple docstring'''


						__lowerCAmelCase: int					   =    self.backend_tokenizer.decode

						def new_decode_method(*UpperCamelCase__							:       Tuple  ,						**UpperCamelCase__							:       Optional[int]):
								__lowerCAmelCase: Optional[Any]					   =    orig_decode_method(*UpperCamelCase__  ,						**UpperCamelCase__)
								__lowerCAmelCase: Tuple					   =    text.replace(self.backend_tokenizer.model.end_of_word_suffix  ,						" ").strip()
								return text

						__lowerCAmelCase: List[Any]					   =    new_decode_method

				def 							lowercase_  (			self							:       Optional[Any]  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						__lowerCAmelCase: Dict					   =    [self.bos_token_id]
						__lowerCAmelCase: str					   =    [self.eos_token_id]

						if token_ids_a is None:
								return bos_token + token_ids_a + eos_token
						return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token

				def 							lowercase_  (			self							:       Optional[int]  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						__lowerCAmelCase: List[str]					   =    [self.bos_token_id]
						__lowerCAmelCase: Optional[int]					   =    [self.eos_token_id]

						if token_ids_a is None:
								return len(bos_token + token_ids_a + eos_token) * [0]
						return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token) * [0]




				def 							lowercase_  (			self							:       Union[str, Any]  ,						UpperCamelCase__							:       str  ,						UpperCamelCase__							:       Optional[str] = None)->     Tuple[str]:



						'''simple docstring'''


						__lowerCAmelCase: int					   =    self._tokenizer.model.save(UpperCamelCase__  ,						name=UpperCamelCase__)
						return tuple(UpperCamelCase__)





"""simple docstring"""


import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute






def 					a__					(					__SCREAMING_SNAKE_CASE = 1      ,				__SCREAMING_SNAKE_CASE = 1				)			->			qiskit.result.counts.Counts:
		if isinstance(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				) or isinstance(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				):
				raise TypeError("inputs must be integers."				)
		if (bit_a < 0) or (bit_a < 0):
				raise ValueError("inputs must be positive."				)
		if (math.floor(__SCREAMING_SNAKE_CASE				) != bit_a) or (math.floor(__SCREAMING_SNAKE_CASE				) != bit_a):
				raise ValueError("inputs must be exact integers."				)
		if (bit_a > 1) or (bit_a > 1):
				raise ValueError("inputs must be less or equal to 1."				)

		# build registers
		__lowerCAmelCase: str					   =    QuantumRegister(2      ,				"qr"				)
		__lowerCAmelCase: Optional[Any]					   =    ClassicalRegister(2      ,				"cr"				)

		__lowerCAmelCase: Dict					   =    QuantumCircuit(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)

		# entanglement the qubits
		quantum_circuit.h(1				)
		quantum_circuit.cx(1      ,				0				)

		# send the information
		__lowerCAmelCase: Dict					   =    str(__SCREAMING_SNAKE_CASE				) + str(__SCREAMING_SNAKE_CASE				)

		if c_information == "11":
				quantum_circuit.x(1				)
				quantum_circuit.z(1				)
		elif c_information == "10":
				quantum_circuit.z(1				)
		elif c_information == "01":
				quantum_circuit.x(1				)
		else:
				quantum_circuit.i(1				)

		# unentangled the circuit
		quantum_circuit.cx(1      ,				0				)
		quantum_circuit.h(1				)

		# measure the circuit
		quantum_circuit.measure(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)

		__lowerCAmelCase: List[str]					   =    Aer.get_backend("aer_simulator"				)
		__lowerCAmelCase: Dict					   =    execute(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE      ,				shots=1_0_0_0				)

		return job.result().get_counts(__SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
			print(F'''Counts for classical state send: {superdense_coding(1,1)}''')


