


import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor





@require_tokenizers
@require_vision
class  lowerCAmelCase__(    unittest.TestCase						):






    '''simple docstring'''





    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   tempfile.mkdtemp()

       # fmt: off
       UpperCAmelCase_							:      List[str]						=   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
       # fmt: on
       UpperCAmelCase_							:      List[str]						=   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]	)	)

       UpperCAmelCase_							:      str						=   {
           '''do_resize''': True,
           '''size''': {'''height''': 18, '''width''': 18},
           '''do_normalize''': True,
           '''image_mean''': [0.5, 0.5, 0.5],
           '''image_std''': [0.5, 0.5, 0.5],
       }
       UpperCAmelCase_							:      str						=   os.path.join(self.tmpdirname       ,   __A	)
       with open(self.image_processor_file       ,   '''w'''       ,   encoding='''utf-8'''	) as fp:
          json.dump(__A       ,   __A	)





    def 					_lowerCamelCase (	self				:   List[Any]       ,   **__snake_case				:   Any	):





       '''simple docstring'''
       return BertTokenizer.from_pretrained(self.tmpdirname       ,   **__A	)





    def 					_lowerCamelCase (	self				:   int       ,   **__snake_case				:   List[str]	):





       '''simple docstring'''
       return ViTImageProcessor.from_pretrained(self.tmpdirname       ,   **__A	)





    def 					_lowerCamelCase (	self				:   Union[str, Any]	):





       '''simple docstring'''
       shutil.rmtree(self.tmpdirname	)





    def 					_lowerCamelCase (	self				:   Optional[int]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   [np.random.randint(255       ,   size=(3, 30, 400)       ,   dtype=np.uinta	)]

       UpperCAmelCase_							:      Optional[int]						=   [Image.fromarray(np.moveaxis(__A       ,   0       ,   -1	)	) for x in image_inputs]

       return image_inputs





    def 					_lowerCamelCase (	self				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   self.get_tokenizer()
       UpperCAmelCase_							:      Dict						=   self.get_image_processor()

       UpperCAmelCase_							:      List[str]						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       processor.save_pretrained(self.tmpdirname	)
       UpperCAmelCase_							:      Dict						=   VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname	)

       self.assertEqual(processor.tokenizer.get_vocab()       ,   tokenizer.get_vocab()	)
       self.assertIsInstance(processor.tokenizer       ,   (BertTokenizer, BertTokenizerFast)	)

       self.assertEqual(processor.image_processor.to_json_string()       ,   image_processor.to_json_string()	)
       self.assertIsInstance(processor.image_processor       ,   __A	)





    def 					_lowerCamelCase (	self				:   Union[str, Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   VisionTextDualEncoderProcessor(
           tokenizer=self.get_tokenizer()       ,   image_processor=self.get_image_processor()	)
       processor.save_pretrained(self.tmpdirname	)

       UpperCAmelCase_							:      Tuple						=   self.get_tokenizer(bos_token='''(BOS)'''       ,   eos_token='''(EOS)'''	)
       UpperCAmelCase_							:      int						=   self.get_image_processor(do_normalize=__A       ,   padding_value=1.0	)

       UpperCAmelCase_							:      Tuple						=   VisionTextDualEncoderProcessor.from_pretrained(
           self.tmpdirname       ,   bos_token='''(BOS)'''       ,   eos_token='''(EOS)'''       ,   do_normalize=__A       ,   padding_value=1.0	)

       self.assertEqual(processor.tokenizer.get_vocab()       ,   tokenizer_add_kwargs.get_vocab()	)
       self.assertIsInstance(processor.tokenizer       ,   (BertTokenizer, BertTokenizerFast)	)

       self.assertEqual(processor.image_processor.to_json_string()       ,   image_processor_add_kwargs.to_json_string()	)
       self.assertIsInstance(processor.image_processor       ,   __A	)





    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   self.get_image_processor()
       UpperCAmelCase_							:      Tuple						=   self.get_tokenizer()

       UpperCAmelCase_							:      Optional[Any]						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       UpperCAmelCase_							:      int						=   self.prepare_image_inputs()

       UpperCAmelCase_							:      Union[str, Any]						=   image_processor(__A       ,   return_tensors='''np'''	)
       UpperCAmelCase_							:      List[str]						=   processor(images=__A       ,   return_tensors='''np'''	)

       for key in input_feat_extract.keys():
          self.assertAlmostEqual(input_feat_extract[key].sum()       ,   input_processor[key].sum()       ,   delta=1E-2	)





    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[Any]						=   self.get_image_processor()
       UpperCAmelCase_							:      Dict						=   self.get_tokenizer()

       UpperCAmelCase_							:      Optional[Any]						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       UpperCAmelCase_							:      Any						=   '''lower newer'''

       UpperCAmelCase_							:      Optional[int]						=   processor(text=__A	)

       UpperCAmelCase_							:      Optional[Any]						=   tokenizer(__A	)

       for key in encoded_tok.keys():
          self.assertListEqual(encoded_tok[key]       ,   encoded_processor[key]	)





    def 					_lowerCamelCase (	self				:   Optional[int]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   self.get_image_processor()
       UpperCAmelCase_							:      int						=   self.get_tokenizer()

       UpperCAmelCase_							:      Optional[int]						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       UpperCAmelCase_							:      Dict						=   '''lower newer'''
       UpperCAmelCase_							:      Any						=   self.prepare_image_inputs()

       UpperCAmelCase_							:      Any						=   processor(text=__A       ,   images=__A	)

       self.assertListEqual(list(inputs.keys()	)       ,   ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']	)

       # test if it raises when no input is passed
       with self.assertRaises(__A	):
          processor()





    def 					_lowerCamelCase (	self				:   Union[str, Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   self.get_image_processor()
       UpperCAmelCase_							:      Any						=   self.get_tokenizer()

       UpperCAmelCase_							:      Dict						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       UpperCAmelCase_							:      Optional[int]						=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       UpperCAmelCase_							:      str						=   processor.batch_decode(__A	)
       UpperCAmelCase_							:      Tuple						=   tokenizer.batch_decode(__A	)

       self.assertListEqual(__A       ,   __A	)





    def 					_lowerCamelCase (	self				:   Optional[int]	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   self.get_image_processor()
       UpperCAmelCase_							:      int						=   self.get_tokenizer()

       UpperCAmelCase_							:      Dict						=   VisionTextDualEncoderProcessor(tokenizer=__A       ,   image_processor=__A	)

       UpperCAmelCase_							:      int						=   '''lower newer'''
       UpperCAmelCase_							:      Dict						=   self.prepare_image_inputs()

       UpperCAmelCase_							:      Optional[Any]						=   processor(text=__A       ,   images=__A	)

       self.assertListEqual(list(inputs.keys()	)       ,   processor.model_input_names	)



import math

import qiskit
def      snake_case_						( __lowercase = 1			,       __lowercase = 1			,       __lowercase = 1       ):
   if (
       isinstance(__lowercase			,       __lowercase       )
       or isinstance(__lowercase			,       __lowercase       )
       or isinstance(__lowercase			,       __lowercase       )
   ):
      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(__lowercase       ) != input_a)
       or (math.floor(__lowercase       ) != input_a)
       or (math.floor(__lowercase       ) != 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_							:      Any						=   qiskit.QuantumRegister(4			,       '''qr'''       )
   UpperCAmelCase_							:      List[str]						=   qiskit.ClassicalRegister(2			,       '''cr'''       )
   # list the entries
   UpperCAmelCase_							:      Any						=   [input_a, input_a, carry_in]

   UpperCAmelCase_							:      Dict						=   qiskit.QuantumCircuit(__lowercase			,       __lowercase       )

   for i in range(0			,       3       ):
      if entry[i] == 2:
         quantum_circuit.h(__lowercase       )  # for hadamard entries
      elif entry[i] == 1:
         quantum_circuit.x(__lowercase       )  # for 1 entries
      elif entry[i] == 0:
         quantum_circuit.i(__lowercase       )  # 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]			,       __lowercase       )  # measure the last two qbits

   UpperCAmelCase_							:      Optional[int]						=   qiskit.Aer.get_backend('''aer_simulator'''       )
   UpperCAmelCase_							:      List[str]						=   qiskit.execute(__lowercase			,       __lowercase			,       shots=1_0_0_0       )

   return job.result().get_counts(__lowercase       )


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