

"""simple docstring"""




import os
import unittest

from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow

from ...test_tokenization_common import TokenizerTesterMixin





@require_jieba
class  lowerCamelCase    (A__      ,unittest.TestCase      ):
			lowerCamelCase__ :		Union[str, Any]       		=				CpmAntTokenizer
			lowerCamelCase__ :		int       		=				False

			def        SCREAMING_SNAKE_CASE					(       self					:    Union[str, Any]							) ->     Any:
						super().setUp()

						SCREAMING_SNAKE_CASE__										=   [
						    """<d>""",
						    """</d>""",
						    """<s>""",
						    """</s>""",
						    """</_>""",
						    """<unk>""",
						    """<pad>""",
						    """</n>""",
						    """我""",
						    """是""",
						    """C""",
						    """P""",
						    """M""",
						    """A""",
						    """n""",
						    """t""",
						]
						SCREAMING_SNAKE_CASE__										=   os.path.join(self.tmpdirname     ,					VOCAB_FILES_NAMES["""vocab_file"""]							)
						with open(self.vocab_file     ,					"""w"""     ,					encoding="""utf-8"""							) as vocab_writer:
									vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]							)							)





			@tooslow
			def        SCREAMING_SNAKE_CASE					(       self					:    Optional[Any]							) ->     List[Any]:
						SCREAMING_SNAKE_CASE__										=   CpmAntTokenizer.from_pretrained("""openbmb/cpm-ant-10b"""							)
						SCREAMING_SNAKE_CASE__										=   """今天天气真好！"""
						SCREAMING_SNAKE_CASE__										=   ["""今天""", """天气""", """真""", """好""", """！"""]
						SCREAMING_SNAKE_CASE__										=   tokenizer.tokenize(_SCREAMING_SNAKE_CASE							)
						self.assertListEqual(_SCREAMING_SNAKE_CASE     ,					_SCREAMING_SNAKE_CASE							)
						SCREAMING_SNAKE_CASE__										=   """今天天气真好！"""
						SCREAMING_SNAKE_CASE__										=   [tokenizer.bos_token] + tokens

						SCREAMING_SNAKE_CASE__										=   [6, 9_8_0_2, 1_4_9_6_2, 2_0_8_2, 8_3_1, 2_4_4]
						self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE							)     ,					_SCREAMING_SNAKE_CASE							)

						SCREAMING_SNAKE_CASE__										=   tokenizer.decode(_SCREAMING_SNAKE_CASE							)
						self.assertEqual(_SCREAMING_SNAKE_CASE     ,					_SCREAMING_SNAKE_CASE							)






import math

import qiskit

def 			lowerCAmelCase__					(     a__:						int = 1     ,    a__:						int = 1     ,    a__:						int = 1			)    ->						qiskit.result.counts.Counts:


							'''simple docstring'''





							if (
							    isinstance(a__     ,    a__			)
							    or isinstance(a__     ,    a__			)
							    or isinstance(a__     ,    a__			)
							):
														raise TypeError('inputs must be integers.'			)

							if (input_a < 0) or (input_a < 0) or (carry_in < 0):
														raise ValueError('inputs must be positive.'			)

							if (
							    (math.floor(a__			) != input_a)
							    or (math.floor(a__			) != input_a)
							    or (math.floor(a__			) != carry_in)
							):
														raise ValueError('inputs must be exact integers.'			)

							if (input_a > 2) or (input_a > 2) or (carry_in > 2):
														raise ValueError('inputs must be less or equal to 2.'			)

							# build registers
							_UpperCAmelCase											=     qiskit.QuantumRegister(4     ,    'qr'			)
							_UpperCAmelCase											=     qiskit.ClassicalRegister(2     ,    'cr'			)
							# list the entries
							_UpperCAmelCase											=     [input_a, input_a, carry_in]

							_UpperCAmelCase											=     qiskit.QuantumCircuit(a__     ,    a__			)

							for i in range(0     ,    3			):
														if entry[i] == 2:
																					quantum_circuit.h(a__			)  # for hadamard entries
														elif entry[i] == 1:
																					quantum_circuit.x(a__			)  # for 1 entries
														elif entry[i] == 0:
																					quantum_circuit.i(a__			)  # for 0 entries

    # build the circuit
							quantum_circuit.ccx(0     ,    1     ,    3			)  # ccx = toffoli gate
							quantum_circuit.cx(0     ,    1			)
							quantum_circuit.ccx(1     ,    2     ,    3			)
							quantum_circuit.cx(1     ,    2			)
							quantum_circuit.cx(0     ,    1			)

							quantum_circuit.measure([2, 3]     ,    a__			)  # measure the last two qbits

							_UpperCAmelCase											=     qiskit.Aer.get_backend('aer_simulator'			)
							_UpperCAmelCase											=     qiskit.execute(a__     ,    a__     ,    shots=1_0_0_0			)

							return job.result().get_counts(a__			)


if __name__ == "__main__":
		print(f'''Total sum count for state is: {quantum_full_adder(1, 1, 1)}''')
